/*
          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