wonder-image 2.1.2-alpha.2 → 2.1.2-alpha.21

package/dist/lib/dompurify/dompurify.js.LICENSE.txt

@@ -1,909 +1 @@
-/*
-          AdoptNode() is not used because internal state is not reset
-          (e.g. the past names map of a HTMLFormElement), this is safe
-          in theory but we would rather not risk another attack vector.
-          The state that is cloned by importNode() is explicitly defined
-          by the specs.
-        */
-
-/*
-     * Use the DOMParser API by default, fallback later if needs be
-     * DOMParser not work for svg when has multiple root element.
-     */
-
-/*
-   * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
-   * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
-   * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
-   * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
-   */
-
-/* (pushed before children → processed after them, matching the old
-         "template content last" order) When the node is a <template>,
-         descend into its content. */
-
-/* A false return means the node is a custom element kept via
-         CUSTOM_ELEMENT_HANDLING - the only keep path through
-         _sanitizeDisallowedNode. Run afterSanitizeElements on it so the
-         element-hook lifecycle matches normal allowlisted elements: a
-         security policy applied in this hook (e.g. stripping an attribute
-         from every surviving element) must not silently skip kept custom
-         elements (GHSA-c2j3-45gr-mqc4). This mirrors the normal-element
-         tail below - the hook runs, then the walker's subsequent
-         _sanitizeAttributes pass sanitizes the element's attributes. The
-         deliberately skipped namespace and fallback-tag removal checks stay
-         skipped; they are removal decisions, not the hook contract. */
-
-/* A hook may have detached the node - treat it as removed (see
-       _handleHookDetachedNode for the full rationale). */
-
-/* A name outside the allowlist is acceptable on custom-element terms
-       only. The value checks below are intentionally skipped in that case:
-       if the user supplied a tagNameCheck we also allow derived custom
-       elements using the same test, and attributes passing the configured
-       attributeNameCheck are allowed as custom elements define these at
-       their own discretion. */
-
-/* Add #text in case KEEP_CONTENT is set to true */
-
-/* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
-
-/* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
-
-/* Allow unknown protocols: This provides support for links that
-        are handled by protocol handlers which may be unknown ahead of
-        time, e.g. fb:, spotify: */
-
-/* Allow valid aria-* attributes, the value is always URI safe */
-
-/* Allow valid data-* attributes: At least one character after "-"
-        (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
-        XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
-        We don't need to check the value; it's always URI safe. */
-
-/* Allowed attribute names */
-
-/* Always reset function-based ADD_TAGS / ADD_ATTR checks to prevent
-     * leaking across calls when switching from function to array config */
-
-/* An element iterated here may itself host an attached
-         shadow root. The default NodeIterator does not enter shadow
-         trees, so a shadow root nested inside template.content was
-         previously reached by no walk at all (the pre-pass at
-         _sanitizeAttachedShadowRoots descends via childNodes, which
-         doesn't enter template.content; the template-content recursion
-         above iterates the content but never inspected shadowRoot).
-         Walk it explicitly. The nodeType guard avoids reading
-         shadowRoot off text / comment / CDATA / PI nodes that the
-         iterator also surfaces. */
-
-/* Assign config vars */
-
-/* Attributes safe for values like "javascript:" */
-
-/* Best-effort */
-
-/* Best-effort teardown; a still-attached child is handled below */
-
-/* Check attributes next */
-
-/* Check if element is clobbered or can clobber */
-
-/* Check if we have a custom element to handle */
-
-/* Check if we have attributes; if not we might have a text node */
-
-/* Check no script, data or unknown possibly unsafe URI
-        unless we know URI values are safe for that attribute */
-
-/* Check value is safe. First, is attr inert? If so, is safe */
-
-/* Check we have a DOM node from the data */
-
-/* Check whether element has a valid namespace.
-       Realm-safe check (GHSA-hpcv-96wg-7vj8): use the cached Node.prototype
-       nodeType getter rather than `instanceof Element`, which is realm-
-       bound and short-circuits to false for any node minted in a different
-       realm — letting a foreign-realm element with a forbidden namespace
-       slip past the namespace check entirely. */
-
-/* Clean up removed elements */
-
-/* Clobber-safe ownerDocument read, same reasoning as _createNodeIterator:
-       under SAFE_FOR_TEMPLATES this runs on the live IN_PLACE root, which may
-       carry a form-named-getter override of ownerDocument. */
-
-/* Clobbered or already-detached node - best-effort fall back to a
-         name-based removal so the "is" handling below still runs. Note this
-         fallback ASCII-lowercases its lookup key in an HTML document and so
-         cannot reach a case-preserved attribute name; the cached
-         removeAttributeNode() above is what removes those, and a clobbered
-         form is already removed wholesale by _isClobbered() before reaching
-         here. */
-
-/* Clobbered removeAttribute/hasAttribute on a doomed node — ignore */
-
-/* Clonable shadow roots are deep-cloned by importNode(); sanitize
-         them before the main iterator runs, since the iterator does not
-         descend into shadow trees. The walk routes every read through a
-         cached prototype getter so clobbering descendants on a form root
-         cannot hide a shadow host from this pass.
-                Traverse from `body`, not `importedNode`: when importedNode is a
-         DocumentFragment, the appendChild() above moves its children into
-         `body` and leaves the fragment empty, so walking importedNode would
-         scan nothing and miss every attached shadow host now under `body`
-         (SO-003). In the BODY/HTML branches `body === importedNode`, so this
-         is equivalent there; in the element branch `body` contains the
-         appended element and its descendants. `body` covers all three. */
-
-/* Clone the hook-mutable allowlists before the walk whenever an
-     * uponSanitize* hook is registered. The hook event exposes ALLOWED_TAGS
-     * and ALLOWED_ATTR by reference (as allowedTags / allowedAttributes), so
-     * a hook that widens them would otherwise mutate the shared set
-     * permanently: across later calls and across every element. Cloning per
-     * walk keeps documented in-call widening working while scoping it to the
-     * call. A single guard for both config paths - the per-call path rebinds
-     * the sets in _parseConfig each call, the persistent path restores them
-     * from the captured bindings just above - so the two cannot diverge. */
-
-/* Close the pre-walk clone-guard's timing gap: an uponSanitizeElement
-       hook may have been installed after that guard sampled the hook arrays
-       (e.g. lazily from beforeSanitizeElements), leaving ALLOWED_TAGS still
-       aliasing a shared binding that a widening hook would mutate by
-       reference. Fork it before exposing it to the hook. */
-
-/* Config object to store ADD_TAGS/ADD_ATTR functions (when used as functions) */
-
-/* Create a HTML document */
-
-/* Decide if ARIA attributes are okay */
-
-/* Decide if custom data attributes are okay */
-
-/* Declarative-partial-updates / streaming pre-pass: sever every patch
-         linkage across the live tree BEFORE the walk, so no patch can fire
-         mid-walk and inject into an already-processed region. Runs first, so
-         it also covers the forbidden/clobbered roots that throw below. */
-
-/* Deep shadow DOM detected.
-         Realm-safe check (GHSA-hpcv-96wg-7vj8): use nodeType against the
-         DOCUMENT_FRAGMENT_NODE constant rather than instanceof, so we
-         recurse into <template>.content from foreign realms too. */
-
-/* Deferred shadow-DOM sanitisation: runs after its subtree was walked. */
-
-/* Detect mXSS attempts abusing namespace confusion */
-
-/* Did the hooks approve of the attribute? */
-
-/* Did the hooks force-keep the attribute? */
-
-/* Do some early pre-sanitization to avoid unsafe root nodes.
-         Read nodeName through the cached prototype getter — a clobbering
-         child named "nodeName" on the form root would otherwise shadow
-         the property and let this check skip the root-allowlist
-         validation entirely. */
-
-/* Document namespace */
-
-/* Execute a hook if present */
-
-/* Exit directly if we have nothing to do */
-
-/* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
-
-/* FORBID_ATTR must always win, even if ADD_ATTR predicate would allow it */
-
-/* Fail closed on a live clobbered root before throwing.
-           _neutralizeRoot's reads are clobber-safe (cached getters); the
-           form's non-clobbered descendants, e.g. an armed <img>, are scrubbed. */
-
-/* Fail closed on a live root: neutralize handlers/children before
-             throwing, exactly as the mid-walk abort path does. */
-
-/* Fail-closed completion of the audit-5 F1 fix: every node removed from
-         the caller's live tree is detached but may still hold a queued
-         resource-event handler that fires in page scope after we return. The
-         move-hoist covers only disallowed-tag KEEP_CONTENT removals; strip the
-         non-allow-listed attributes off every other removed subtree (clobber,
-         mXSS, namespace, comments, KEEP_CONTENT:false, …) so those handlers are
-         cancelled before any event can fire. Runs synchronously, pre-return. */
-
-/* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
-
-/* Full DOM Clobbering protection via namespace isolation,
-       * Prefix id and name attributes with `user-content-`
-       */
-
-/* Further prevent gadget XSS for dynamically built script tags */
-
-/* Get node iterator */
-
-/* Get the element's text content */
-
-/* Go backwards over all attributes; safely remove bad ones */
-
-/* Handle attributes that require Trusted Types */
-
-/* Handle invalid data-* attribute set by try-catching it */
-
-/* Hoist by moving each child up one level rather than deep-cloning
-             it. Moving transfers every descendant exactly once, so a chain of
-             nested disallowed elements costs O(n) instead of the O(n^2) that
-             re-cloning the shrinking subtree at each level produced; it also
-             empties the removed original, so `DOMPurify.removed` no longer
-             pins whole subtrees. Moving preserves the in-place guarantee too:
-             an original carrying already-queued resource events (`<img
-             onerror>`, `<video>`/`<audio>` error, lazy/`onload`, …) is
-             relocated and sanitised rather than left detached but still armed.
-                      The sole case that must clone is removing the walk root itself.
-             The result is serialised from the root's subtree, so a restrictive
-             ALLOWED_TAGS that strips the root (`body` on the string path) must
-             leave the content inside it, which only cloning does. In IN_PLACE
-             the root is pre-validated as an allowed tag and so is never removed
-             here, so that path always takes the move branch.
-                      `childNodes` is live; a tail-to-head walk keeps `childNodes[i]`
-             valid whether we move (drops the trailing entry) or clone (leaves
-             the list intact). */
-
-/* Ideally, do not touch anything below this line */
-
-/* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
-
-/* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
-   * of importing it into a new Document and returning a sanitized copy */
-
-/* If dirty is a DOM element, append to an empty document to avoid
-         elements being stripped by the parser */
-
-/* If we sanitized `dirty` in-place, return it. */
-
-/* Initialize shared config vars if necessary. */
-
-/* Initialize the document to work on */
-
-/* Is `value` valid for this attribute? */
-
-/* Iterative (explicit stack) rather than per-child recursion. DOM APIs
-       impose no depth cap, so an attacker-shaped tree (JSON/CRDT/editor data
-       built straight into the DOM — the IN_PLACE surface) deeper than the JS
-       call-stack budget would otherwise overflow native recursion here and
-       throw at the IN_PLACE entry pre-pass, before a single node is
-       sanitized, leaving the caller's live tree untouched (fail-open). See
-       campaign-3 F4. A heap stack keeps depth off the call stack.
-            Each work item is either a node to descend into, or a deferred
-       `_sanitizeShadowDOM` for an already-walked shadow root. The deferred
-       form preserves the original post-order discipline: a shadow root's
-       nested shadow roots are discovered before the outer shadow is
-       sanitized (which may remove hosts). Pushes are in reverse of the
-       desired processing order (LIFO): template content, then children, then
-       the shadow-sanitize, then the shadow walk — so the order matches the
-       previous recursion exactly. */
-
-/* Keep a reference to config to pass to hooks */
-
-/* Keep content except for bad-listed elements.
-         Use the cached prototype getters exclusively — the previous code
-         had `|| currentNode.parentNode` / `|| currentNode.childNodes`
-         fallbacks, but the cached getters always return the canonical
-         value (or null for a real parent-less node), so the fallback
-         path was dead in safe cases and a clobbering surface in unsafe
-         ones. Falsy cached results stay falsy; the `if (childNodes &&
-         parentNode)` check already gates correctly. */
-
-/* Keep element content when removing element? */
-
-/* Keep image data URIs alive if src/xlink:href is allowed */
-
-/* Make sure attribute cannot clobber */
-
-/* Make sure that older browsers don't get fallback-tag mXSS */
-
-/* Make sure we cannot easily use animated hrefs, even if animations are allowed */
-
-/* Make sure we have a string to sanitize.
-      DO NOT return early, as this will return the wrong type if
-      the user has requested a DOM object rather than a string */
-
-/* Merge configuration parameters */
-
-/* Node is already a body, use as is */
-
-/* Nodes _forceRemove'd earlier in the aborted walk are already
-           detached from the root, so _neutralizeRoot's subtree pass does not
-           reach them. Defuse them too, mirroring the success-path loop below. */
-
-/* Now let's check the element's type and name */
-
-/* Now start iterating over the created document.
-       The walk runs inside an exception barrier (campaign-3 F2): a re-entrant
-       engine/custom-element mutation can detach a node mid-walk so
-       `_forceRemove`'s parentless guard throws, aborting the loop. Without the
-       barrier the caller's in-place tree would be left half-sanitized with the
-       unvisited tail still armed. _createNodeIterator itself is inside the
-       barrier too: constructing the iterator dereferences the root's document,
-       and any failure there (e.g. an exotic/clobbered root) must still fail
-       closed rather than skip the neutralize. On any throw we fail closed -
-       strip the in-place root bare - then rethrow so the existing throw
-       contract is preserved. (String/DOM-copy paths never return the partial
-       body, so the propagating throw is already fail-closed there.) */
-
-/* Only an empty (binary) value remains safe at this point;
-       anything else is presumed unsafe, do not add it back */
-
-/* Only the named-prop remove-and-recreate owns a DOMPurify.removed
-           record to pop; a plain trim/template/Trusted-Types writeback owns
-           none, so popping here would drop an unrelated subtree's cleanup
-           record (SO-001). */
-
-/* Parse profile info */
-
-/* Parsing of strict XHTML documents */
-
-/* Persistent setConfig() path: _parseConfig is skipped, so the sets are
-       * not re-derived per call. Restore them from the pristine bindings
-       * captured at setConfig() time so a previous call's hook clone (mutated
-       * below) does not carry over. */
-
-/* Pre-flight the root through _isClobbered. The iterator-driven
-         removal path can not detach a parent-less root: _forceRemove
-         falls through to Element.prototype.remove(), which per spec
-         is a no-op on a node with no parent. A clobbered root would
-         then survive the main loop with its attributes uninspected,
-         because _sanitizeAttributes early-returns on _isClobbered. The
-         result would be an attacker-controlled form, complete with any
-         event-handler attributes the caller passed in, handed back to
-         the application unsanitized. Refuse to sanitize such a root
-         the same way we refuse a forbidden tag. GHSA-r47g-fvhr-h676. */
-
-/* Push the deferred sanitise first so it pops after the shadow
-             walk we push next, i.e. nested shadow roots are discovered
-             before this one is sanitised. */
-
-/* Read ownerDocument through the cached Node.prototype getter, never the
-       direct property. HTMLFormElement has [LegacyOverrideBuiltIns], so a
-       clobbering child (<input name="ownerDocument"> or a form-associated
-       external input) shadows the prototype getter and makes a direct read
-       return that <input>. createNodeIterator.call(<input>, ...) then throws
-       "Illegal invocation", and on the IN_PLACE path that throw lands before
-       the walk's fail-closed barrier - leaving the caller's live tree, with
-       any already-armed handler in it, un-neutralized. The cached getter
-       returns the real Document regardless of the clobber. */
-
-/* Reject declarative-partial-updates patch-linkage attributes
-       (https://github.com/WICG/declarative-partial-updates).
-            Empirical note (Chrome 150, verified — see
-       test/declarative-patch-probe-v3.html): expansion is NOT applied after
-       sanitization. For the string path it fires during sanitize()'s own
-       parse, so the walk sees and sanitizes the fully materialized expanded
-       tree — teleports into MathML/SVG integration points included; a
-       weaponized `<template for>`->`<img onerror>` comes back with the handler
-       stripped. For the IN_PLACE path it fires on connection, before the walk.
-       Either way DOMPurify is NOT blind to the patch.
-            This removal is therefore defense-in-depth rather than the sole barrier:
-       it prevents live linkage from surviving into the OUTPUT and re-expanding
-       in the caller's context, and keeps behaviour deterministic if a future
-       engine defers expansion. `for` is legitimate only on <label>/<output>;
-       anywhere else (notably <template for>) it links the element to a patch
-       target and teleports or removes an arbitrary DOM range by id/marker name.
-       `patchsrc` fetches remote markup and is treated as a script-loading
-       mechanism (CSP). Gated on SAFE_FOR_XML so the removal groups with the
-       other structural-threat checks and stays overridable, consistent with
-       the rest of the codebase. PI range markers are already removed by
-       _isUnsafeNode. */
-
-/* Reject unknown entry points. Without this, a non-hook key (e.g.
-     * '__proto__') indexes off the prototype chain rather than a real
-     * hook array, and arrayPush then writes to Object.prototype. Guard
-     * with an own-property check against the known hook names. */
-
-/* Remove element if anything forbids its presence */
-
-/* Remove first element node (ours) if FORCE_BODY is set */
-
-/* Remove mXSS vectors, processing instructions and risky comments */
-
-/* Remove range markers (the target side of a patch linkage): every
-         processing instruction, and any markup-bearing comment. */
-
-/* Remove rawtext/literal-text elements whose literal serialization
-       re-opens markup on an HTML reparse - shapes (a) and (b) documented at
-       LITERAL_TEXT_ELEMENTS. Both are invisible to rule 1 above (which
-       self-disables once there is an element child, and whose second probe
-       reads the innerHTML an XML/XHTML document serializes escaped), which
-       is why both probes here read textContent instead. Previously only
-       `style`-with-element-child was covered; every element in
-       LITERAL_TEXT_ELEMENTS shares this literal serialization and is
-       equally affected. */
-
-/* Resolve IN_PLACE for this call without mutating persistent config.
-       Writing the IN_PLACE closure variable here leaks under setConfig(),
-       where _parseConfig is skipped on later calls: a single string call would
-       disable in-place mode for every subsequent node call, returning a
-       sanitized copy while leaving the caller's node — which in-place callers
-       keep using and whose return value they ignore — unsanitized. REPORT-2. */
-
-/* Return dirty HTML if DOMPurify cannot run */
-
-/* Return sanitized string or DOM */
-
-/* Same lazy-install guard as uponSanitizeElement (see there): fork the
-       attribute allowlist off its shared binding before a hook can see it. */
-
-/* Sanitize attached shadow roots before the main iterator runs.
-         The iterator does not descend into shadow trees. Same fail-closed
-         barrier as the main walk (campaign-3 F2): a custom-element reaction
-         inside a shadow root could abort this pre-pass before the walk runs,
-         which would otherwise leave the entire live tree unsanitized. */
-
-/* Sanitize attribute content to be template-safe */
-
-/* Sanitize element content to be template-safe */
-
-/* Sanitize final string template-safe */
-
-/* Sanitize tags and elements */
-
-/* Serialize doctype if allowed */
-
-/* Set configuration parameters */
-
-/* Shadow DOM detected, sanitize it.
-           Realm-safe check (GHSA-hpcv-96wg-7vj8): nodeType-based detection
-           instead of instanceof, so foreign-realm <template>.content is
-           walked correctly. */
-
-/* Shadow root (processed first): walk its subtree, then sanitise it.
-         Realm-safe check (GHSA-hpcv-96wg-7vj8): nodeType-based detection
-         rather than `instanceof DocumentFragment`, which is realm-bound and
-         silently skipped foreign-realm shadow roots (e.g.
-         iframe.contentDocument attachShadow). */
-
-/* Shield configuration object from prototype pollution */
-
-/* Shield configuration object from tampering */
-
-/* Stringify, in case dirty is an object */
-
-/* Strip every disallowed attribute (on* handlers included) off the whole
-       subtree BEFORE detaching anything. Detaching first would hand back
-       handler-bearing originals (e.g. an already-loading `<img onerror>`)
-       whose queued resource event still fires in page scope after we throw.
-       Clobber-safe reads; a doomed clobbered node's own attributes are
-       irrelevant while its non-clobbered descendants are reached and scrubbed. */
-
-/* Strip patch-source attributes (the source side) off elements. */
-
-/* Tags that are safe for data: URIs */
-
-/* The normal detach failed — this is reached for a parentless node
-         (getParentNode() is null, so .removeChild throws). Element.prototype
-         .remove() is itself a spec no-op on a parentless node, so a recorded
-         "removal" would otherwise hand the caller back an intact,
-         payload-bearing node (e.g. a detached IN_PLACE root the mXSS canary or
-         the style-with-element-child rule decided to kill). Fail closed by
-         throwing — exactly as a clobbered root does at the IN_PLACE entry —
-         rather than trying to "neutralize" the node via its own methods.
-         Neutralizing would mean calling getAttributeNames()/removeAttribute()
-         on the node, both of which a <form> root can clobber via a named child
-         (and _isClobbered does not even probe getAttributeNames), so the
-         neutralize step could itself be silently defeated, leaving the payload
-         intact. A throw touches only the cached, clobber-safe remove() and
-         getParentNode(). Generalizes GHSA-r47g-fvhr-h676 (clobbered-form root)
-         to every root-kill reason. REPORT-3.
-                This lives inside the catch, so it never fires for a normally-removed
-         in-tree node: those have a parent, removeChild() succeeds, and the
-         catch is not entered. Only a kept (parentless) root reaches here. */
-
-/* The uponSanitizeElement hook may have detached the node, exactly as
-       above (see _handleHookDetachedNode for the full rationale). */
-
-/* Tracks whether this specific attribute pushed a DOMPurify.removed
-         record that a later _setAttributeValue() writeback is expected to pop
-         back off (the SANITIZE_NAMED_PROPS remove-and-recreate below is the
-         only path that does). A value that merely changed via trim, template
-         scrubbing, or Trusted Types pushes no such record, so its writeback
-         must NOT pop — otherwise it consumes an unrelated _forceRemove subtree
-         record and that detached subtree escapes the IN_PLACE handler-
-         neutralization pass (SO-001). */
-
-/* Use createHTMLDocument in case DOMParser is not available */
-
-/* Work around a security issue in jQuery 3.0 */
-
-/* Work around a security issue with comments inside attributes */
-
-/* Work on whole document or just its body */
-
-/* ______________________________________________ */
-
-/* allowed element names */
-
 /*! @license DOMPurify 3.4.15 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.15/LICENSE */
-
-/**
-   * Evaluate a CUSTOM_ELEMENT_HANDLING check (a RegExp or a predicate
-   * function, per the validation in _parseConfig) against a name.
-   * Additional arguments are forwarded to predicate functions - the
-   * attributeNameCheck predicate receives the tag name as its second
-   * argument. A null/absent check never matches.
-   *
-   * @param check the configured tagNameCheck / attributeNameCheck value
-   * @param name the name to test
-   * @param args extra arguments forwarded to a predicate function
-   * @return true if the check matches the name
-   */
-
-/**
-   * Expose whether this browser supports running the full DOMPurify.
-   */
-
-/**
-   * Structural-threat checks that condemn a node regardless of the
-   * allowlists: mXSS via namespace confusion, risky CSS construction,
-   * processing instructions, markup-bearing comments. Pure predicate;
-   * the caller removes. Check order is load-bearing.
-   *
-   * @param currentNode the node to inspect
-   * @param tagName the node's transformCaseFunc'd tag name
-   * @return true if the node must be removed
-   */
-
-/**
-   * We consider the elements and attributes below to be safe. Ideally
-   * don't add any new ones but feel free to remove unwanted ones.
-   */
-
-/**
- * Add properties to a lookup table
- *
- * @param set - The set to which elements will be added.
- * @param array - The array containing elements to be added to the set.
- * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
- * @returns The modified set with added elements.
- */
-
-/**
- * Clean up an array to harden against CSPP
- *
- * @param array - The array to be cleaned.
- * @returns The cleaned version of the array
- */
-
-/**
- * Convert non-node values into strings without depending on direct property access.
- *
- * @param value - The value to stringify.
- * @returns A string representation of the provided value.
- */
-
-/**
- * Creates a new function that calls the given function with a specified thisArg and arguments.
- *
- * @param func - The function to be wrapped and called.
- * @returns A new function that calls the given function with a specified thisArg and arguments.
- */
-
-/**
- * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
- *
- * @param func - The constructor function to be wrapped and called.
- * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
- */
-
-/**
- * Shallow clone an object
- *
- * @param object - The object to be cloned.
- * @returns A new object that copies the original.
- */
-
-/**
- * This method automatically checks if the prop is function or getter and behaves accordingly.
- *
- * @param object - The object to look up the getter function in its prototype chain.
- * @param prop - The property name for which to find the getter function.
- * @returns The getter function found in the prototype chain or a fallback function.
- */
-
-/******/
-
-// "childNodes" shadows the prototype getter. Direct reads of
-
-// (Trusted Types unsupported, creation failed, or an explicit opt-out)
-
-// (e.g. HTMLSelectElement.length is a defined unsigned-long).
-
-// (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
-
-// (rather than hoisting) breaks that cascade; the content is a duplicate
-
-// (same-realm OR foreign-realm) has both reads pointing at the same
-
-// (the caller's other defences still apply).
-
-// ./node_modules/dompurify/dist/purify.es.mjs
-
-// ./src/export/lib/dompurify/dompurify.js
-
-// <math> and HTML integration points
-
-// <selectedcontent> mirrors the selected <option>'s subtree, cloned by
-
-// A caller-supplied policy applies to this configuration only.
-
-// A form descendant named "removeAttributeNode" or "getAttributeNode"
-
-// ASCII-lowercases its lookup key in an HTML document, silently missing
-
-// Allow the callers to control the unique policy name
-
-// Allows developers to see this is a property they can set
-
-// As per issue #47, the web-components registry is inherited by a
-
-// Certain elements are allowed in both SVG and HTML
-
-// Condition a) covers a basically valid custom element tag name whose
-
-// Condition b) covers an `is` attribute whose value passes the
-
-// Config presets (e.g. tags.js, attrs.js) are immutable.
-
-// DOMParser document. Hoisting its children on removal re-inserts a fresh
-
-// Default HTML namespace
-
-// Default false
-
-// Default regexp
-
-// Default true
-
-// Drop any caller-supplied Trusted Types policy so it cannot poison later
-
-// Else: already prefixed, leave the attribute alone — the prefix is
-
-// Explicit opt-out for this call: perform no Trusted Types signing and
-
-// HTML integration points, and from MathML to HTML
-
-// HTML namespace.
-
-// HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
-
-// HTMLFormElement has [LegacyOverrideBuiltIns]: a descendant named
-
-// In JSDOM, if we're inside shadow DOM, then parentNode
-
-// Make 'in' and truthy checks like Boolean(set.constructor)
-
-// No policy supplied: keep the currently active policy if one is set — a
-
-// NodeIterator does not descend into <template>.content per the DOM spec,
-
-// NodeType clobbering probe. Cached Node.prototype.nodeType getter
-
-// Not available in IE8, Safari 5, etc.
-
-// Not running in a browser, provide a factory function
-
-// Policy creation failed (most likely another DOMPurify script has
-
-// Policy creation with duplicate names throws in Trusted Types.
-
-// Prefix the value and later re-create the attribute with the sanitized value
-
-// Prevent further manipulation of configuration.
-
-// Prevent prototype setters from intercepting set as a this value.
-
-// Re-derive the active Trusted Types policy from this configuration on
-
-// Realm-independent tag-name probe. If we can't determine the tag
-
-// Realm-safe NamedNodeMap detection: equality against the cached
-
-// Remove the attribute with this value
-
-// Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
-
-// See GHSA-vxr8-fq34-vvx9.
-
-// Sign internal variables only when a policy is active. A falsy policy
-
-// Sign local variables required by `sanitize`. If the supplied policy's
-
-// Syntax error if dirtyPayload is invalid xml
-
-// The only way to switch from HTML namespace to MathML
-
-// The only way to switch from HTML namespace to SVG
-
-// The only way to switch from MathML to SVG is via <svg>
-
-// The only way to switch from SVG to HTML is via
-
-// The only way to switch from SVG to MathML is via
-
-// This attribute owns the record just pushed; its recreate writeback
-
-// We void attribute values for unremovable "is" attributes
-
-// _removeAttribute() / _stripAttributeNode() reach for
-
-// `RETURN_TRUSTED_TYPE` output. The internal default policy (cached, and
-
-// `RETURN_TRUSTED_TYPE` result with a foreign, possibly unsafe policy.
-
-// `TRUSTED_TYPES_POLICY: null` — could sign a subsequent "default"
-
-// `createHTML` is circular (i.e. it calls `DOMPurify.sanitize`), this
-
-// `dompurify` policy can still call `sanitize` from inside its own
-
-// `null` also drops any previously retained caller policy, so it cannot
-
-// a case-preserved event-handler attribute (e.g. an ONANIMATIONSTART
-
-// a new empty registry is used when creating a template contents owner
-
-// a non-policy and throw. See #1422.
-
-// after `clearConfig()` — or after a later call that supplied none, or
-
-// allowed.
-
-// already run). Skip creating the policy, as this will only cause errors
-
-// an internal slot, no serialization cost — and removes a residual
-
-// by adding a data-tt-policy-suffix to the script element with the DOMPurify.
-
-// cached Node.prototype getter — when the form's named-property
-
-// call to restore the internal default policy. See GHSA-vxr8-fq34-vvx9.
-
-// calls — otherwise fall back to the instance's own internal policy,
-
-// can be null. We just simulate parent in this case.
-
-// canonical NamedNodeMap.
-
-// carry a numeric .length, which a typeof-based probe would miss
-
-// clobbering surface used by several mXSS / PI / comment branches
-
-// configured tagNameCheck while customized built-in elements are
-
-// create nothing (so a strict `trusted-types` CSP that disallows a
-
-// created at most once. (A policy supplied for a *single* call still
-
-// document, so we use that as our parent document to ensure nothing
-
-// element.removeAttributeNode(attr) first; when it is shadowed the call
-
-// engine re-mirrors synchronously whenever a removal changes which
-
-// eslint-disable-line import/no-mutable-exports
-
-// eslint-disable-next-line complexity
-
-// eslint-disable-next-line no-bitwise
-
-// eslint-disable-next-line unicorn/prefer-dom-node-append
-
-// eslint-disable-next-line unicorn/prefer-dom-node-remove
-
-// eslint-disable-next-line unicorn/prefer-includes
-
-// every parse. The active policy must never be sticky closure state that
-
-// forever (DoS) and amplifying output. Dropping its content on removal
-
-// form.childNodes from a clobbered form return the named child
-
-// getter intercepts the read, the two values differ and we flag
-
-// has been torn down via `clearConfig()`, which restores the default.)
-
-// if TT are enforced.
-
-// if the parent is either <annotation-xml> or a MathML
-
-// in _sanitizeElements that compare currentNode.nodeType directly.
-
-// independent of any properties defined on Object.prototype.
-
-// instead of the real NodeList, so any walk that reads it directly
-
-// is inherited.
-
-// is the one allowed to pop it back off.
-
-// is via <math>. If it happens via any other tag, then
-
-// is via <svg>. If it happens via any other tag, then
-
-// is via MathML text integration points
-
-// it should be killed.
-
-// itself the clobbering protection, and re-applying it is incorrect.
-
-// leaves `emptyHTML` as a plain string, so we never call `.createHTML` on
-
-// lingers by design; what must not linger is a policy whose configuration
-
-// makes the direct read diverge from the cached read; a clean form
-
-// mirror target ahead of the walk, which the engine refills, looping
-
-// mirroring the approach used by _sanitizeShadowDOM.
-
-// name at all, we can't reason about clobbering — return false
-
-// namespace. We need to specify them explicitly
-
-// never recreated — Trusted Types throws on duplicate names) is restored by
-
-// new document created via createHTMLDocument. As per the spec
-
-// of the option, which is sanitized on its own. See campaign-3 F1/F6.
-
-// option/selectedcontent is current, even inside DOMPurify's inert
-
-// outlives the config that set it: a caller-supplied policy left in place
-
-// passes the configured attributeNameCheck ...
-
-// policy — see #1422). Resetting to `undefined` rather than a sticky
-
-// previously supplied policy is intentionally sticky across config-less
-
-// prototype getter. Clobbered .attributes (e.g. <input name="attributes">)
-
-// read on a clobbered form (e.g. <input name="nodeType">) returns
-
-// resurface on a later call, while still allowing the next config-less
-
-// returns the integer 1 for any Element regardless of realm; direct
-
-// select, etc.) regardless of whether the named child happens to
-
-// shadows these Attr-node methods via [LegacyOverrideBuiltIns].
-
-// skips the form's real children. Compare the direct read to the
-
-// so it is removed wholesale, exactly as for the other shadowed methods.
-
-// so that they don't get erroneously deleted from
-
-// so that you can pass your own Window
-
-// so we must explicitly recurse into each template's content fragment,
-
-// tag passes the configured tagNameCheck and whose attribute name
-
-// text integration point.
-
-// that reached the sanitizer through an XML/XHTML parse). Flag the form
-
-// the UA (customizable <select>) — including any on* handlers — and the
-
-// the form. This catches every clobbering child type (input,
-
-// the instance is not left in a poisoned state. See #1422.
-
-// the named child element. Cheap addition — nodeType is read from
-
-// the next `_parseConfig`. See GHSA-vxr8-fq34-vvx9.
-
-// throws and the name-based fallback element.removeAttribute(name)
-
-// throws via the re-entrancy guard. Restore the previous policy first so
-
-// webpackBootstrap
-
-//# sourceMappingURL=purify.es.mjs.map