DOMPurify
DOMPurify 3.2.1
DOMPurify ist ein superschneller, überaus toleranter XSS-Sanitizer nur für DOM für HTML, MathML und SVG.
Es ist außerdem sehr einfach zu bedienen und zu starten. DOMPurify wurde im Februar 2014 gestartet und hat mittlerweile die Version v3.2.1 erreicht.
DOMPurify ist in JavaScript geschrieben und funktioniert in allen modernen Browsern (Safari (10+), Opera (15+), Edge, Firefox und Chrome – sowie fast allem anderen, das Blink, Gecko oder WebKit verwendet. Bei MSIE oder anderen älteren Browsern funktioniert es nicht. Es bringt einfach nichts.
Beachten Sie, dass DOMPurify v2.5.7 die neueste Version ist, die MSIE unterstützt. Für wichtige Sicherheitsupdates, die mit MSIE kompatibel sind, verwenden Sie bitte den 2.x-Zweig.
Unsere automatisierten Tests decken derzeit 24 verschiedene Browser ab, weitere werden folgen. Wir behandeln auch Node.js v16.x, v17.x, v18.x und v19.x, wobei DOMPurify auf jsdom ausgeführt wird. Es ist bekannt, dass ältere Node-Versionen auch funktionieren, aber hey... keine Garantie.
DOMPurify wurde von Sicherheitsleuten geschrieben, die über umfassende Erfahrung in Webangriffen und XSS verfügen. Keine Angst. Weitere Informationen finden Sie auch in unserem Sicherheitsziel- und Bedrohungsmodell. Bitte lesen Sie es. Wirklich.
DOMPurify bereinigt HTML und verhindert XSS-Angriffe. Sie können DOMPurify mit einer Zeichenfolge voller schmutzigem HTML füttern und es wird eine Zeichenfolge (sofern nicht anders konfiguriert) mit sauberem HTML zurückgegeben. DOMPurify entfernt alles, was gefährliches HTML enthält, und verhindert so XSS-Angriffe und andere Übel. Es geht auch verdammt schnell. Wir nutzen die vom Browser bereitgestellten Technologien und verwandeln sie in einen XSS-Filter. Je schneller Ihr Browser ist, desto schneller wird DOMPurify sein.
Es ist einfach. Integrieren Sie einfach DOMPurify in Ihre Website.
<script type="text/javascript" src="src/purify.js"></script>
<script type="text/javascript" src="dist/purify.min.js"></script>
Anschließend können Sie Zeichenfolgen bereinigen, indem Sie den folgenden Code ausführen:
const clean = DOMPurify.sanitize(dirty);
Oder vielleicht das, wenn Sie gerne mit Angular oder Ähnlichem arbeiten:
import DOMPurify from 'dompurify';const clean = DOMPurify.sanitize('<b>hello there</b>'); Der resultierende HTML-Code kann mit innerHTML in ein DOM-Element oder mit document.write() in das DOM geschrieben werden. Das liegt ganz bei Ihnen. Beachten Sie, dass wir standardmäßig HTML, SVG und MathML zulassen. Wenn Sie nur HTML benötigen, was ein sehr häufiger Anwendungsfall sein könnte, können Sie dies auch einfach einrichten:
const clean = DOMPurify.sanitize(dirty, { USE_PROFILES: { html: true } });Bitte beachten Sie: Wenn Sie HTML zunächst bereinigen und es anschließend ändern, kann es leicht passieren , dass die Auswirkungen der Bereinigung zunichte gemacht werden . Wenn Sie das bereinigte Markup nach der Bereinigung an eine andere Bibliothek weiterleiten, stellen Sie bitte sicher, dass die Bibliothek nicht selbst mit dem HTML herumspielt.
Nachdem Sie Ihr Markup bereinigt haben, können Sie sich auch die Eigenschaft DOMPurify.removed ansehen und herausfinden, welche Elemente und Attribute verworfen wurden. Bitte verwenden Sie diese Eigenschaft nicht für sicherheitskritische Entscheidungen. Dies ist nur ein kleiner Helfer für neugierige Köpfe.
DOMPurify funktioniert technisch gesehen auch serverseitig mit Node.js. Unser Support ist bestrebt, den Release-Zyklus von Node.js einzuhalten.
Für die Ausführung von DOMPurify auf dem Server muss ein DOM vorhanden sein, was wahrscheinlich keine Überraschung ist. Normalerweise ist jsdom das Tool der Wahl und wir empfehlen dringend, die neueste Version von jsdom zu verwenden.
Warum? Denn ältere Versionen von jsdom sind bekanntermaßen fehlerhaft und führen zu XSS, selbst wenn DOMPurify alles zu 100 % korrekt macht. Es gibt bekannte Angriffsvektoren , z. B. in jsdom v19.0.0 , die in jsdom v20.0.0 behoben wurden – und wir empfehlen daher dringend, jsdom auf dem neuesten Stand zu halten.
Bitte beachten Sie auch, dass es Tools wie Happy-Dom gibt, diese jedoch derzeit nicht als sicher gelten . Die Kombination von DOMPurify mit Happy-Dom wird derzeit nicht empfohlen und wird wahrscheinlich zu XSS führen.
Ansonsten können Sie DOMPurify problemlos auf dem Server verwenden. Wahrscheinlich. Dies hängt wirklich von jsdom oder dem DOM ab, das Sie serverseitig verwenden. Wenn Sie damit leben können, gehen Sie folgendermaßen vor:
npm install dompurify npm installiert jsdom
Für jsdom (bitte verwenden Sie eine aktuelle Version) sollte dies den Zweck erfüllen:
const createDOMPurify = require('dompurify');const { JSDOM } = require('jsdom');const window = new JSDOM('').window;const DOMPurify = createDOMPurify(window);const clean = DOMPurify.sanitize(' <b>Hallo</b>');Oder sogar das, wenn Sie lieber mit Importen arbeiten:
import { JSDOM } from 'jsdom';import DOMPurify from 'dompurify';const window = new JSDOM('').window;const purify = DOMPurify(window);const clean = purify.sanitize('<b>Hallo da< /b>');Wenn Sie Probleme damit haben, dass es in Ihrem speziellen Setup funktioniert, sollten Sie einen Blick auf das erstaunliche isomorphic-dompurify-Projekt werfen, das viele Probleme löst, auf die Menschen stoßen könnten.
npm install isomorphic-dompurify
import DOMPurify from 'isomorphic-dompurify';const clean = DOMPurify.sanitize('<s>hello</s>');Natürlich gibt es eine Demo! Spielen Sie mit DOMPurify
Bitte kontaktieren Sie uns zunächst umgehend per E-Mail, damit wir an einer Lösung arbeiten können. PGP-Schlüssel
Außerdem qualifizieren Sie sich wahrscheinlich für ein Bug-Bounty! Die guten Leute bei Fastmail nutzen DOMPurify für ihre Dienste und haben unsere Bibliothek zu ihrem Bug-Bounty-Bereich hinzugefügt. Wenn Sie also eine Möglichkeit finden, DOMPurify zu umgehen oder zu schwächen, werfen Sie bitte auch einen Blick auf deren Website und die Bug-Bounty-Informationen.
Wie sieht ein bereinigtes Markup aus? Nun, die Demo zeigt es mit einer Menge unangenehmer Elemente. Aber lassen Sie uns auch einige kleinere Beispiele zeigen!
DOMPurify.sanitize('<img src=x onerror=alert(1)//>'); // wird zu <img src="x">DOMPurify.sanitize('<svg><g/onload=alert(2)//<p>'); // wird zu <svg><g></g></svg>DOMPurify.sanitize('<p>abc<iframe//src=jAva	script:alert(3)>def</p>'); // wird zu <p>abc</p>DOMPurify.sanitize('<math><mi//xlink:href="data:x,<script>alert(4)</script>">'); // wird zu <math><mi></mi></math>DOMPurify.sanitize('<TABLE><tr><td>HELLO</tr></TABL>'); // wird zu <table><tbody><tr><td>HELLO</td></tr></tbody></table>DOMPurify.sanitize('<UL><li><A HREF=//google .com>click</UL>'); // wird zu <ul><li><a href="//google.com">click</a></li></ul> DOMPurify unterstützt derzeit HTML5, SVG und MathML. DOMPurify erlaubt standardmäßig benutzerdefinierte CSS- und HTML-Datenattribute. DOMPurify unterstützt auch das Shadow DOM – und bereinigt DOM-Vorlagen rekursiv. Mit DOMPurify können Sie auch HTML für die Verwendung mit den APIs jQuery $() und elm.html() ohne bekannte Probleme bereinigen.
DOMPurify macht überhaupt nichts. Es gibt einfach genau die Zeichenfolge zurück, die Sie eingegeben haben. DOMPurify stellt eine Eigenschaft namens isSupported zur Verfügung, die Ihnen sagt, ob es seine Aufgabe erfüllen kann, sodass Sie Ihren eigenen Backup-Plan erstellen können.
In Version 1.0.9 wurde DOMPurify Unterstützung für die Trusted Types API hinzugefügt. In Version 2.0.0 wurde ein Konfigurationsflag hinzugefügt, um das diesbezügliche Verhalten von DOMPurify zu steuern.
Wenn DOMPurify.sanitize in einer Umgebung verwendet wird, in der die Trusted Types API verfügbar ist und RETURN_TRUSTED_TYPE auf true gesetzt ist, versucht es, einen TrustedHTML Wert anstelle einer Zeichenfolge zurückzugeben (das Verhalten für die Konfigurationsoptionen RETURN_DOM und RETURN_DOM_FRAGMENT ändert sich nicht).
Beachten Sie, dass zum Erstellen einer Richtlinie in trustedTypes mithilfe von DOMPurify RETURN_TRUSTED_TYPE: false erforderlich ist, da createHTML eine normale Zeichenfolge und nicht TrustedHTML erwartet. Das folgende Beispiel zeigt dies.
window.trustedTypes!.createPolicy('default', {
createHTML: (to_escape) =>DOMPurify.sanitize(to_escape, { RETURN_TRUSTED_TYPE: false }),}); Ja. Die enthaltenen Standardkonfigurationswerte sind bereits ziemlich gut – Sie können sie aber natürlich überschreiben. Schauen Sie sich den Ordner /demos an, um eine Reihe von Beispielen zu sehen, wie Sie DOMPurify anpassen können.
// {{ ... }}, ${ ... } und <% ... %> entfernen, um die Ausgabe für Vorlagensysteme sicher zu machen// Bitte seien Sie vorsichtig, dieser Modus wird nicht für den Produktionsgebrauch empfohlen.// erlaubt Das Parsen von Vorlagen in benutzergesteuertem HTML wird überhaupt nicht empfohlen.// Verwenden Sie diesen Modus nur, wenn es wirklich keine Alternative gibt.const clean = DOMPurify.sanitize(dirty, {SAFE_FOR_TEMPLATES: true});// Ändern Sie beispielsweise die Art und Weise, wie Kommentare riskant sind HTML-Zeichen sind behandelt.// Seien Sie sehr vorsichtig, diese Einstellung sollte nur auf „false“ gesetzt werden, wenn Sie wirklich nur // HTML und nichts anderes verarbeiten, kein SVG, MathML oder ähnliches. // Andernfalls führt der Wechsel von „true“ zu „false“ auf diese oder eine andere Weise zu XSS.const clean = DOMPurify.sanitize(dirty, {SAFE_FOR_XML: false}); // Nur <b>-Elemente zulassen, sehr strengconst clean = DOMPurify.sanitize(dirty, {ALLOWED_TAGS: ['b']});// Nur <b> und <q> mit Stilattributen zulassenconst clean = DOMPurify.sanitize( dirty, {ALLOWED_TAGS: ['b', 'q'], ALLOWED_ATTR: ['style']});// alle sicheren HTML-Elemente zulassen, aber weder SVG noch MathML// beachten Sie, dass die USE_PROFILES-Einstellung die ALLOWED_TAGS-Einstellung überschreibt// also nicht zusammen verwenden const clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {html: true}});// alle sicheren SVG-Elemente und SVG zulassen Filter, kein HTML oder MathMLconst clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {svg: true, svgFilters: true}});// alle sicheren MathML-Elemente und SVG zulassen, aber keine SVG-Filterconst clean = DOMPurify.sanitize(dirty, {USE_PROFILES: {mathMl: true, svg: true}});// den Standard-Namespace von HTML ändern zu etwas anderemconst clean = DOMPurify.sanitize(dirty, {NAMESPACE: 'http://www.w3.org/2000/svg'});// alles sichere HTML belassen so wie es ist und fügen Sie <style>-Elemente zu block-listconst clean = DOMPurify.sanitize(dirty, {FORBID_TAGS: ['style']});// hinzu, lassen Sie alles sichere HTML unverändert und fügen Sie Stilattribute zu block-listconst clean hinzu = DOMPurify.sanitize(dirty, {FORBID_ATTR: ['style']});// Erweitern Sie das vorhandene Array zulässiger Tags und fügen Sie <my-tag> zuallow-listconst clean hinzu = DOMPurify.sanitize(dirty, {ADD_TAGS: ['my-tag']});// Erweitern Sie das vorhandene Array zulässiger Attribute und fügen Sie my-attr zur Allow-Listconst hinzu. clean = DOMPurify.sanitize(dirty, {ADD_ATTR: [ 'my-attr']});// ARIA-Attribute verbieten, anderes sicheres HTML unverändert lassen (Standard ist true)const clean = DOMPurify.sanitize(dirty, {ALLOW_ARIA_ATTR: false});// HTML5-Datenattribute verbieten, anderes sicheres HTML unverändert lassen (Standard ist true)const clean = DOMPurify.sanitize(dirty, {ALLOW_DATA_ATTR: false}); // DOMPurify ermöglicht die Definition von Regeln für benutzerdefinierte Elemente. Wenn Sie das Literal CUSTOM_ELEMENT_HANDLING// verwenden, können Sie genau definieren, welche Elemente Sie zulassen möchten (standardmäßig sind keine erlaubt).//// Das Gleiche gilt für ihre Attribute. Standardmäßig wird die integrierte oder konfigurierte „allow.list“ verwendet.//// Sie können ein RegExp-Literal verwenden, um anzugeben, was erlaubt ist, oder ein Prädikat. Beispiele für beide sind unten zu sehen.// Die Standardwerte sind sehr restriktiv um versehentliche XSS-Umgehungen zu verhindern. Gehen Sie mit großer Sorgfalt vor!const clean = DOMPurify.sanitize('<foo-bar baz="foobar" verboten="true"></foo-bar><div is="foo-baz"></div>', {CUSTOM_ELEMENT_HANDLING: {tagNameCheck: null, // keine benutzerdefinierten Elemente sind zulässigattributeNameCheck: null, // Standard-/Standardattribut-Zulassungsliste wird verwendetallowCustomizedBuiltInElements: false, // keine angepassten Integrierte Funktionen erlaubt},}); // <div is=""></div>const clean = DOMPurify.sanitize('<foo-bar baz="foobar" verboten="true"></foo-bar><div is="foo-baz "></div>',{CUSTOM_ELEMENT_HANDLING: {tagNameCheck: /^foo-/, // alle Tags zulassen, die mit „foo-" beginnenattributeNameCheck: /baz/, // alle Attribute zulassen, die enthalten "baz"allowCustomizedBuiltInElements: true, // benutzerdefinierte integrierte Elemente sind zulässig},}); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div>const clean = DOMPurify.sanitize('<foo-bar baz="foobar" verboten ="true"></foo-bar><div is="foo-baz"></div>',{CUSTOM_ELEMENT_HANDLING: {tagNameCheck: (tagName) => tagName.match(/^foo-/), // alle Tags zulassen, die mit „foo-“ beginnen attributeNameCheck: (attr) => attr.match(/baz/), // alle zulassen, die „baz“ enthaltenallowCustomizedBuiltInElements: true, // benutzerdefinierte integrierte Funktionen zulassen},}); // <foo-bar baz="foobar"></foo-bar><div is="foo-baz"></div> // Erweitern Sie das vorhandene Array von Elementen, die Daten-URIs verwenden können. const clean = DOMPurify.sanitize(dirty, {ADD_DATA_URI_TAGS: ['a', 'area']});// Erweitern Sie das vorhandene Array von Elementen, die für URI-sicher sind. Like-Werte (Vorsicht, XSS-Risiko)const clean = DOMPurify.sanitize(dirty, {ADD_URI_SAFE_ATTR: ['mein-attr']}); // Externe Protokollhandler in URL-Attributen zulassen (Standard ist falsch, Vorsicht, XSS-Risiko)// Standardmäßig sind nur http, https, ftp, ftps, tel, mailto, callto, sms, cid und xmpp erlaubt.const clean = DOMPurify.sanitize(dirty, {ALLOW_UNKNOWN_PROTOCOLS: true});// bestimmte Protokollhandler in URL-Attributen über Regex zulassen (Standard ist false, seien Sie vorsichtig, XSS-Risiko)// Standardmäßig sind nur http, https, ftp, ftps, tel, mailto, callto, sms, cid und xmpp erlaubt.// Standard-RegExp: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^az]|[a-z+.-]+(?:[^ a-z+.-:]|$))/i;const clean = DOMPurify.sanitize(dirty, {ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|xxx):|[^az]|[a-z+.-]+(?: [^a-z+.-:]|$))/i}); // ein DOM HTMLBodyElement anstelle eines HTML-Strings zurückgeben (Standard ist false)const clean = DOMPurify.sanitize(dirty, {RETURN_DOM: true});// ein DOM DocumentFragment anstelle eines HTML-Strings zurückgeben (Standard ist false)const clean = DOMPurify.sanitize(dirty, {RETURN_DOM_FRAGMENT: true});// Verwenden Sie das RETURN_TRUSTED_TYPE-Flag zum Umdrehen zur Unterstützung vertrauenswürdiger Typen, falls verfügbarconst clean = DOMPurify.sanitize(dirty, {RETURN_TRUSTED_TYPE: true}); // gibt wenn möglich ein TrustedHTML-Objekt anstelle einer Zeichenfolge zurück// verwendet eine bereitgestellte Richtlinie für vertrauenswürdige Typenconst clean = DOMPurify.sanitize(dirty, {// Die bereitgestellte Richtlinie muss createHTML und createScriptURLTRUSTED_TYPES_POLICY definieren: TrustedTypes.createPolicy({createHTML(s) { return s},createScriptURL(s) { return s},}}); // gesamtes Dokument einschließlich <html>-Tags zurückgeben (Standard ist false)const clean = DOMPurify.sanitize(dirty, {WHOLE_DOCUMENT: true});// DOM-Clobbering-Schutz bei der Ausgabe deaktivieren (Standard ist true, mit Vorsicht behandeln, kleineres XSS Risiken hier)const clean = DOMPurify.sanitize(dirty, {SANITIZE_DOM: false});// strengen DOM-Clobbering-Schutz durch Namespace-Isolation erzwingen (Standard ist false)// Wenn diese Option aktiviert ist, wird der Namespace benannter Eigenschaften (z. B. „id“- und „name“-Attribute)// von JS-Variablen isoliert, indem ihnen die Zeichenfolge „user-content-“const clean = DOMPurify vorangestellt wird. sanitize(dirty, {SANITIZE_NAMED_PROPS: true});// den Inhalt eines Elements behalten, wenn das Element entfernt wird (Standard ist true)const clean = DOMPurify.sanitize(dirty, {KEEP_CONTENT: false});// Elemente wie Stil, Skript oder andere an document.body kleben und unintuitives Browserverhalten in mehreren Randfällen verhindern (Standard ist false)const clean = DOMPurify.sanitize(dirty , {FORCE_BODY: true});// alle <a>-Elemente unter <p>-Elementen entfernen, die entfernt werdenconst clean = DOMPurify.sanitize(dirty, {FORBID_CONTENTS: ['a'], FORBID_TAGS: ['p']});// den Parsertyp ändern, sodass bereinigte Daten als XML und nicht als HTML behandelt werden, was die Standardeinstellung istconst clean = DOMPurify .sanitize(dirty, {PARSER_MEDIA_TYPE: 'application/xhtml+xml'}); // Verwenden Sie den IN_PLACE-Modus, um einen Knoten „an Ort und Stelle“ zu bereinigen, was je nach Verwendung von DOMPurifyconst viel schneller geht dirty = document.createElement('a');dirty.setAttribute('href', 'javascript:alert(1 )');const clean = DOMPurify.sanitize(dirty, {IN_PLACE: true}); // Weitere Informationen finden Sie unter https://github.com/cure53/DOMPurify/issues/288Hier finden Sie noch weitere Beispiele, die zeigen, wie Sie DOMPurify entsprechend Ihren Anforderungen ausführen, anpassen und konfigurieren können.
Anstatt immer wieder dieselbe Konfiguration an DOMPurify.sanitize zu übergeben, können Sie die Methode DOMPurify.setConfig verwenden. Ihre Konfiguration bleibt bis zu Ihrem nächsten Aufruf von DOMPurify.setConfig bestehen oder bis Sie DOMPurify.clearConfig aufrufen, um sie zurückzusetzen. Denken Sie daran, dass es nur eine aktive Konfiguration gibt. Das heißt, sobald sie festgelegt ist, werden alle zusätzlichen Konfigurationsparameter, die an DOMPurify.sanitize übergeben werden, ignoriert.
Mit DOMPurify können Sie seine Funktionalität erweitern, indem Sie eine oder mehrere Funktionen mit der DOMPurify.addHook -Methode an einen der folgenden Hooks anhängen:
beforeSanitizeElements
uponSanitizeElement (Kein „s“ – wird für jedes Element aufgerufen)
afterSanitizeElements
beforeSanitizeAttributes
uponSanitizeAttribute
afterSanitizeAttributes
beforeSanitizeShadowDOM
uponSanitizeShadowNode
afterSanitizeShadowDOM
Es übergibt den aktuell verarbeiteten DOM-Knoten, bei Bedarf ein Literal mit verifizierten Knoten- und Attributdaten und der DOMPurify-Konfiguration an den Rückruf. Schauen Sie sich die MentalJS-Hook-Demo an, um zu sehen, wie die API gut genutzt werden kann.
Beispiel :
DOMPurify.addHook(
'uponSanitizeAttribute',
Funktion (currentNode, HookEvent, config) {// Etwas mit dem aktuellen Knoten machen// Sie können HookEvent auch für den aktuellen Knoten mutieren (dh HookEvent.forceKeepAttr = true setzen)// Für andere Hook-Typen als „uponSanitizeAttribute“ ist HookEvent gleich null
});| Option | Seit | Notiz |
|---|---|---|
| SAFE_FOR_JQUERY | 2.1.0 | Kein Austausch erforderlich. |
Wir verwenden derzeit Github Actions in Kombination mit BrowserStack. Dies gibt uns die Möglichkeit, bei jedem einzelnen Commit zu bestätigen, dass in allen unterstützten Browsern alles nach Plan läuft. Schauen Sie sich die Build-Protokolle hier an: https://github.com/cure53/DOMPurify/actions
Sie können weitere lokale Tests ausführen, indem Sie npm test ausführen. Die Tests funktionieren gut mit Node.js v0.6.2 und [email protected].
Alle relevanten Commits werden zur zusätzlichen Sicherheit mit dem Schlüssel 0x24BB6BF4 signiert (seit 8. April 2016).
npm i ) Wir unterstützen npm offiziell. Der GitHub Actions-Workflow ist so konfiguriert, dass Abhängigkeiten mithilfe von npm installiert werden. Bei Verwendung einer veralteten Version von npm können wir die Versionen der installierten Abhängigkeiten nicht vollständig sicherstellen, was zu unerwarteten Problemen führen kann.
Für die Integration in unsere Tooling-Infrastruktur verlassen wir uns auf npm-Run-Scripts. Wir verwenden ESLint als Pre-Commit-Hook, um die Codekonsistenz sicherzustellen. Um die Formatierung zu vereinfachen, verwenden wir außerdem prettier, während die Erstellung der /dist -Assets durch rollup erfolgt.
Dies sind unsere NPM-Skripte:
npm run dev um mit dem Erstellen zu beginnen, während Sie die Quellen auf Änderungen überwachen
npm run test um unsere Testsuite über jsdom und karma auszuführen
test:jsdom um Tests nur über jsdom auszuführen
test:karma um Tests nur über Karma durchzuführen
npm run lint um die Quellen mit ESLint zu linten (über xo)
npm run format , um unsere Quellen mit Prettier zu formatieren, um die Weitergabe von ESLint zu erleichtern
npm run build um unsere Distributionsressourcen minimiert und nicht minimiert als UMD-Modul zu erstellen
npm run build:umd um nur ein nicht minimiertes UMD-Modul zu erstellen
npm run build:umd:min , um nur ein minimiertes UMD-Modul zu erstellen
Hinweis: Alle Ausführungsskripte werden über npm run <script> ausgelöst.
Es gibt weitere npm-Skripte, diese dienen jedoch hauptsächlich der Integration mit CI oder sind als „privat“ gedacht, um beispielsweise Build-Distributionsdateien bei jedem Commit zu ändern.
Wir ma
