@zowe/cli 8.36.1 → 8.37.0

package/node_modules/sanitize-html/node_modules/dom-serializer/src/foreign-names.ts

@@ -0,0 +1,19 @@
+/**
+ * Mixed-case SVG and MathML element names recognized in foreign content.
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+export const elementNames = new Map<string, string>(
+  "altGlyph altGlyphDef altGlyphItem animateColor animateMotion animateTransform clipPath feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence foreignObject glyphRef linearGradient radialGradient textPath"
+    .split(" ")
+    .map((name) => [name.toLowerCase(), name]),
+);
+
+/**
+ * Mixed-case SVG and MathML attribute names recognized in foreign content.
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+export const attributeNames = new Map<string, string>(
+  "definitionURL attributeName attributeType baseFrequency baseProfile calcMode clipPathUnits diffuseConstant edgeMode filterUnits glyphRef gradientTransform gradientUnits kernelMatrix kernelUnitLength keyPoints keySplines keyTimes lengthAdjust limitingConeAngle markerHeight markerUnits markerWidth maskContentUnits maskUnits numOctaves pathLength patternContentUnits patternTransform patternUnits pointsAtX pointsAtY pointsAtZ preserveAlpha preserveAspectRatio primitiveUnits refX refY repeatCount repeatDur requiredExtensions requiredFeatures specularConstant specularExponent spreadMethod startOffset stdDeviation stitchTiles surfaceScale systemLanguage tableValues targetX targetY textLength viewBox viewTarget xChannelSelector yChannelSelector zoomAndPan"
+    .split(" ")
+    .map((name) => [name.toLowerCase(), name]),
+);

package/node_modules/sanitize-html/node_modules/dom-serializer/src/index.ts

@@ -0,0 +1,315 @@
+import * as ElementType from "domelementtype";
+import type {
+  AnyNode,
+  CDATA,
+  Comment,
+  Element,
+  ProcessingInstruction,
+  Text,
+} from "domhandler";
+import { encodeXML, escapeAttribute, escapeText } from "entities";
+import { attributeNames, elementNames } from "./foreign-names.js";
+
+/**
+ * Options for DOM serialization.
+ */
+export interface DomSerializerOptions {
+  /**
+   * Print an empty attribute's value.
+   * @default xmlMode
+   * @example With <code>emptyAttrs: false</code>: <code>&lt;input checked&gt;</code>
+   * @example With <code>emptyAttrs: true</code>: <code>&lt;input checked=""&gt;</code>
+   */
+  emptyAttrs?: boolean;
+  /**
+   * Print self-closing tags for tags without contents. If `xmlMode` is set,
+   * this will apply to all tags. Otherwise, only tags that are defined as
+   * self-closing in the HTML specification will be printed as such.
+   * @default xmlMode
+   * @example With <code>selfClosingTags: false</code>: <code>&lt;foo&gt;&lt;/foo&gt;&lt;br&gt;&lt;/br&gt;</code>
+   * @example With <code>xmlMode: true</code> and <code>selfClosingTags: true</code>: <code>&lt;foo/&gt;&lt;br/&gt;</code>
+   * @example With <code>xmlMode: false</code> and <code>selfClosingTags: true</code>: <code>&lt;foo&gt;&lt;/foo&gt;&lt;br /&gt;</code>
+   */
+  selfClosingTags?: boolean;
+  /**
+   * Treat the input as an XML document; enables the `emptyAttrs` and
+   * `selfClosingTags` options.
+   *
+   * If the value is `"foreign"`, it will try to correct mixed-case attribute
+   * names.
+   * @default false
+   */
+  xmlMode?: boolean | "foreign";
+  /**
+   * Encode characters reserved in HTML or XML in text and attribute values.
+   *
+   * If `xmlMode` is set or the value is not `'utf8'`, characters outside the
+   * ASCII range will also be encoded as numeric entities.
+   *
+   * **Security:** Setting this to `false` disables encoding of `<`, `>`, `&`,
+   * and (in attribute values) `'` — only `"` in attribute values is escaped.
+   * This is safe for the round-trip case (DOM was parsed with
+   * `decodeEntities: false`, so any markup characters in text or attribute
+   * values exist only as entity references), and unsafe otherwise. If text
+   * or attribute values in the DOM contain raw `<`, `>`, or `&`, those
+   * characters will appear literally in the output.
+   * @default `decodeEntities`
+   */
+  encodeEntities?: boolean | "utf8";
+  /**
+   * Default for `encodeEntities`. Named to match the parser option of the
+   * same name so a single options object can be threaded through parse and
+   * serialize for a faithful round-trip — for example, cheerio parses with
+   * `decodeEntities: false` to preserve entity references and passes the
+   * same option here so they are not re-encoded.
+   *
+   * Despite the name, on the serializer this option controls *encoding*.
+   * Setting it to `false` carries the same caveat as `encodeEntities: false`
+   * — see that option.
+   * @default true
+   */
+  decodeEntities?: boolean;
+}
+
+// ── Constants ────────────────────────────────────────────────────────
+
+/** Elements whose text content is never entity-encoded. */
+const unencodedElements = new Set(
+  "style script xmp iframe noembed noframes plaintext noscript".split(" "),
+);
+
+/** HTML void elements — they cannot have children. */
+const voidElements = new Set(
+  "area base basefont br col command embed frame hr img input isindex keygen link meta param source track wbr".split(
+    " ",
+  ),
+);
+
+/** Elements that switch the parser into foreign (XML-like) mode. */
+const foreignElements = new Set(["svg", "math"]);
+
+/**
+ * Foreign-mode integration points: children of these elements are parsed
+ * as HTML again, not as foreign content.
+ */
+const foreignModeIntegrationPoints = new Set(
+  "mi mo mn ms mtext annotation-xml foreignObject desc title".split(" "),
+);
+
+// ── Public API ───────────────────────────────────────────────────────
+
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed
+ * node(s).
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+export function render(
+  node: AnyNode | ArrayLike<AnyNode>,
+  options: DomSerializerOptions = {},
+): string {
+  const nodes = "length" in node ? node : [node];
+
+  /*
+   * `xmlMode` is threaded as a separate argument through the internal
+   * functions so that foreign-mode transitions (svg/mathml ↔ html) can
+   * adjust it without copying the options object on every element.
+   */
+  const xmlMode = options.xmlMode ?? false;
+
+  let output = "";
+  // eslint-disable-next-line unicorn/no-for-loop
+  for (let index = 0; index < nodes.length; index++) {
+    output += renderNode(nodes[index], options, xmlMode);
+  }
+
+  return output;
+}
+
+export default render;
+
+// ── Internal rendering ───────────────────────────────────────────────
+
+/**
+ * Render an array of child nodes (skips the single-node wrapping in `render`).
+ * @param children The child nodes to render.
+ * @param options The serialization options.
+ * @param xmlMode The XML mode to use.
+ */
+function renderChildren(
+  children: ArrayLike<AnyNode>,
+  options: DomSerializerOptions,
+  xmlMode: boolean | "foreign",
+): string {
+  let output = "";
+  // eslint-disable-next-line unicorn/no-for-loop
+  for (let index = 0; index < children.length; index++) {
+    output += renderNode(children[index], options, xmlMode);
+  }
+  return output;
+}
+
+function renderNode(
+  node: AnyNode,
+  options: DomSerializerOptions,
+  xmlMode: boolean | "foreign",
+): string {
+  switch (node.type) {
+    case ElementType.Root: {
+      return renderChildren(node.children, options, xmlMode);
+    }
+
+    case ElementType.Directive: {
+      return `<${(node as ProcessingInstruction).data}>`;
+    }
+
+    case ElementType.Comment: {
+      return `<!--${(node as Comment).data}-->`;
+    }
+
+    case ElementType.CDATA: {
+      return `<![CDATA[${((node as CDATA).children[0] as Text).data}]]>`;
+    }
+
+    case ElementType.Script:
+    case ElementType.Style:
+    case ElementType.Tag: {
+      return renderTag(node as Element, options, xmlMode);
+    }
+
+    case ElementType.Text: {
+      const element = node as Text;
+      const data = element.data || "";
+
+      /*
+       * Skip encoding when entities weren't decoded on input, or when
+       * inside a raw-text element (script, style, etc.) in HTML mode.
+       */
+      if (
+        (options.encodeEntities ?? options.decodeEntities) !== false &&
+        !(
+          !xmlMode &&
+          element.parent &&
+          unencodedElements.has((element.parent as Element).name)
+        )
+      ) {
+        // `xmlMode: "foreign"` is truthy
+        return xmlMode || options.encodeEntities !== "utf8"
+          ? encodeXML(data)
+          : escapeText(data);
+      }
+
+      return data;
+    }
+  }
+}
+
+function renderTag(
+  element: Element,
+  options: DomSerializerOptions,
+  xmlMode: boolean | "foreign",
+) {
+  if (xmlMode === "foreign") {
+    // Correct lowercase element names back to their canonical mixed-case form
+    element.name = elementNames.get(element.name) ?? element.name;
+
+    // Integration points exit foreign mode: their children are HTML
+    if (
+      element.parent &&
+      foreignModeIntegrationPoints.has((element.parent as Element).name)
+    ) {
+      xmlMode = false;
+    }
+  }
+
+  if (!xmlMode && foreignElements.has(element.name)) {
+    xmlMode = "foreign";
+  }
+
+  const { name, children } = element;
+
+  // Cache the void-element check — used for both self-closing and closing-tag logic
+  const isVoid = !xmlMode && voidElements.has(name);
+
+  let tag = `<${name}${formatAttributes(element.attribs, options, xmlMode)}`;
+
+  if (
+    children.length === 0 &&
+    (xmlMode
+      ? options.selfClosingTags !== false
+      : options.selfClosingTags && isVoid)
+  ) {
+    // XML: `<br/>`, HTML: `<br />`
+    tag += xmlMode ? "/>" : " />";
+  } else {
+    tag += ">";
+
+    if (children.length > 0) {
+      tag += renderChildren(children, options, xmlMode);
+    }
+
+    if (!isVoid) {
+      tag += `</${name}>`;
+    }
+  }
+
+  return tag;
+}
+
+// ── Attribute formatting ─────────────────────────────────────────────
+
+function replaceQuotes(value: string): string {
+  return value.replaceAll('"', "&quot;");
+}
+
+/**
+ * Serialize an element's attribute map to a string.
+ *
+ * Returns a string with a leading space before each attribute, or an
+ * empty string if there are no attributes. This convention lets the
+ * caller unconditionally concatenate the result onto the tag name.
+ * @param attributes
+ * @param options
+ * @param xmlMode
+ */
+function formatAttributes(
+  attributes: Record<string, unknown> | undefined,
+  options: DomSerializerOptions,
+  xmlMode: boolean | "foreign",
+) {
+  if (!attributes) return "";
+
+  /*
+   * Pick the right encoder:
+   *  - Encoding disabled → only escape double-quotes (for valid attributes)
+   *  - XML / non-utf8    → full numeric entity encoding (encodeXML)
+   *  - HTML + utf8       → minimal escaping (escapeAttribute)
+   */
+  const encode =
+    (options.encodeEntities ?? options.decodeEntities) === false
+      ? replaceQuotes
+      : xmlMode || options.encodeEntities !== "utf8"
+        ? encodeXML
+        : escapeAttribute;
+
+  const isForeign = xmlMode === "foreign";
+  const showEmpty = !!(options.emptyAttrs ?? xmlMode);
+
+  let result = "";
+
+  for (const key in attributes) {
+    if (!Object.hasOwn(attributes, key)) continue;
+
+    const value = attributes[key];
+    const k = isForeign ? (attributeNames.get(key) ?? key) : key;
+
+    result +=
+      !showEmpty && (value == null || value === "")
+        ? ` ${k}`
+        : ` ${k}="${encode(value == null ? "" : String(value))}"`;
+  }
+
+  return result;
+}

package/node_modules/{domelementtype/lib → sanitize-html/node_modules/domelementtype/dist}/index.d.ts

@@ -21,28 +21,28 @@ export declare enum ElementType {
 }
 /**
  * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
+ * @param element Element to test
+ * @param element.type Node type discriminator to check.
  */
-export declare function isTag(elem: {
+export declare function isTag(element: {
     type: ElementType;
 }): boolean;
 /** Type for the root element of a document */
-export declare const Root = ElementType.Root;
+export declare const Root: ElementType.Root;
 /** Type for Text */
-export declare const Text = ElementType.Text;
+export declare const Text: ElementType.Text;
 /** Type for <? ... ?> */
-export declare const Directive = ElementType.Directive;
+export declare const Directive: ElementType.Directive;
 /** Type for <!-- ... --> */
-export declare const Comment = ElementType.Comment;
+export declare const Comment: ElementType.Comment;
 /** Type for <script> tags */
-export declare const Script = ElementType.Script;
+export declare const Script: ElementType.Script;
 /** Type for <style> tags */
-export declare const Style = ElementType.Style;
+export declare const Style: ElementType.Style;
 /** Type for Any tag */
-export declare const Tag = ElementType.Tag;
+export declare const Tag: ElementType.Tag;
 /** Type for <![CDATA[ ... ]]> */
-export declare const CDATA = ElementType.CDATA;
+export declare const CDATA: ElementType.CDATA;
 /** Type for <!doctype ...> */
-export declare const Doctype = ElementType.Doctype;
+export declare const Doctype: ElementType.Doctype;
 //# sourceMappingURL=index.d.ts.map

package/node_modules/sanitize-html/node_modules/domelementtype/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,oBAAY,WAAW;IACnB,8CAA8C;IAC9C,IAAI,SAAS;IACb,oBAAoB;IACpB,IAAI,SAAS;IACb,yBAAyB;IACzB,SAAS,cAAc;IACvB,4BAA4B;IAC5B,OAAO,YAAY;IACnB,6BAA6B;IAC7B,MAAM,WAAW;IACjB,4BAA4B;IAC5B,KAAK,UAAU;IACf,uBAAuB;IACvB,GAAG,QAAQ;IACX,iCAAiC;IACjC,KAAK,UAAU;IACf,8BAA8B;IAC9B,OAAO,YAAY;CACtB;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAM7D;AAGD,8CAA8C;AAE9C,eAAO,MAAM,IAAI,EAAE,WAAW,CAAC,IAAuB,CAAC;AACvD,oBAAoB;AAEpB,eAAO,MAAM,IAAI,EAAE,WAAW,CAAC,IAAuB,CAAC;AACvD,yBAAyB;AAEzB,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,SAAiC,CAAC;AACtE,4BAA4B;AAE5B,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,OAA6B,CAAC;AAChE,6BAA6B;AAE7B,eAAO,MAAM,MAAM,EAAE,WAAW,CAAC,MAA2B,CAAC;AAC7D,4BAA4B;AAE5B,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,KAAyB,CAAC;AAC1D,uBAAuB;AAEvB,eAAO,MAAM,GAAG,EAAE,WAAW,CAAC,GAAqB,CAAC;AACpD,iCAAiC;AAEjC,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,KAAyB,CAAC;AAC1D,8BAA8B;AAE9B,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,OAA6B,CAAC"}

package/node_modules/{domelementtype/lib/esm → sanitize-html/node_modules/domelementtype/dist}/index.js

@@ -22,30 +22,39 @@ export var ElementType;
 })(ElementType || (ElementType = {}));
 /**
  * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
+ * @param element Element to test
+ * @param element.type Node type discriminator to check.
  */
-export function isTag(elem) {
-    return (elem.type === ElementType.Tag ||
-        elem.type === ElementType.Script ||
-        elem.type === ElementType.Style);
+export function isTag(element) {
+    return (element.type === ElementType.Tag ||
+        element.type === ElementType.Script ||
+        element.type === ElementType.Style);
 }
 // Exports for backwards compatibility
 /** Type for the root element of a document */
+// eslint-disable-next-line prefer-destructuring
 export const Root = ElementType.Root;
 /** Type for Text */
+// eslint-disable-next-line prefer-destructuring
 export const Text = ElementType.Text;
 /** Type for <? ... ?> */
+// eslint-disable-next-line prefer-destructuring
 export const Directive = ElementType.Directive;
 /** Type for <!-- ... --> */
+// eslint-disable-next-line prefer-destructuring
 export const Comment = ElementType.Comment;
 /** Type for <script> tags */
+// eslint-disable-next-line prefer-destructuring
 export const Script = ElementType.Script;
 /** Type for <style> tags */
+// eslint-disable-next-line prefer-destructuring
 export const Style = ElementType.Style;
 /** Type for Any tag */
+// eslint-disable-next-line prefer-destructuring
 export const Tag = ElementType.Tag;
 /** Type for <![CDATA[ ... ]]> */
+// eslint-disable-next-line prefer-destructuring
 export const CDATA = ElementType.CDATA;
 /** Type for <!doctype ...> */
+// eslint-disable-next-line prefer-destructuring
 export const Doctype = ElementType.Doctype;

package/node_modules/sanitize-html/node_modules/domelementtype/package.json

@@ -0,0 +1,59 @@
+{
+    "type": "module",
+    "name": "domelementtype",
+    "version": "3.0.0",
+    "description": "all the types of nodes in htmlparser2's dom",
+    "author": "Felix Boehm <me@feedic.com>",
+    "license": "BSD-2-Clause",
+    "funding": [
+        {
+            "type": "github",
+            "url": "https://github.com/sponsors/fb55"
+        }
+    ],
+    "sideEffects": false,
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist/**/*"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/fb55/domelementtype.git"
+    },
+    "keywords": [
+        "dom",
+        "element",
+        "types",
+        "htmlparser2"
+    ],
+    "engines": {
+        "node": ">=20.19.0"
+    },
+    "scripts": {
+        "build": "tsc",
+        "format": "npm run format:es && npm run format:biome",
+        "format:biome": "biome check --write .",
+        "format:es": "npm run lint:es -- --fix",
+        "lint": "npm run lint:es && npm run lint:biome",
+        "lint:biome": "biome check .",
+        "lint:es": "eslint .",
+        "prepare": "npm run build",
+        "test": "npm run lint"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^2.4.4",
+        "@eslint/compat": "^2.0.2",
+        "@feedic/eslint-config": "^0.2.3",
+        "eslint": "^10.0.1",
+        "eslint-config-biome": "^2.1.3",
+        "typescript": "^5.7.2",
+        "typescript-eslint": "^8.56.0"
+    }
+}

package/node_modules/{domhandler/lib → sanitize-html/node_modules/domhandler/dist}/index.d.ts

@@ -1,11 +1,13 @@
-import { ChildNode, Element, DataNode, Document, ParentNode } from "./node.js";
+import { type ChildNode, type DataNode, Document, Element, type ParentNode } from "./node.js";
 export * from "./node.js";
+/**
+ * Configuration options for `DomHandler`.
+ */
 export interface DomHandlerOptions {
     /**
      * Add a `startIndex` property to nodes.
      * When the parser is used in a non-streaming fashion, `startIndex` is an integer
      * indicating the position of the start of the node in the document.
-     *
      * @default false
      */
     withStartIndices?: boolean;
@@ -13,13 +15,11 @@ export interface DomHandlerOptions {
      * Add an `endIndex` property to nodes.
      * When the parser is used in a non-streaming fashion, `endIndex` is an integer
      * indicating the position of the end of the node in the document.
-     *
      * @default false
      */
     withEndIndices?: boolean;
     /**
      * Treat the markup as XML.
-     *
      * @default false
      */
     xmlMode?: boolean;
@@ -28,8 +28,11 @@ interface ParserInterface {
     startIndex: number | null;
     endIndex: number | null;
 }
-declare type Callback = (error: Error | null, dom: ChildNode[]) => void;
-declare type ElementCallback = (element: Element) => void;
+type Callback = (error: Error | null, dom: ChildNode[]) => void;
+type ElementCallback = (element: Element) => void;
+/**
+ * Event-based handler that builds a DOM tree from parser callbacks.
+ */
 export declare class DomHandler {
     /** The elements of the DOM */
     dom: ChildNode[];

package/node_modules/sanitize-html/node_modules/domhandler/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,SAAS,EAEd,KAAK,QAAQ,EACb,QAAQ,EACR,OAAO,EACP,KAAK,UAAU,EAGlB,MAAM,WAAW,CAAC;AAEnB,cAAc,WAAW,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AASD,UAAU,eAAe;IACrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;AAChE,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAElD;;GAEG;AACH,qBAAa,UAAU;IACnB,8BAA8B;IAC9B,GAAG,EAAE,SAAS,EAAE,CAAM;IAEtB,mCAAmC;IACnC,IAAI,EAAE,QAAQ,CAA0B;IAExC,yCAAyC;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAE3C,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C,yCAAyC;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IAEnD,oDAAoD;IACpD,OAAO,CAAC,IAAI,CAAS;IAErB,0BAA0B;IAC1B,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAe;IAE/C,kDAAkD;IAClD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAQ;IAE3C,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAAgC;IAE9C;;;;OAIG;gBAEC,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI,EAClC,SAAS,CAAC,EAAE,eAAe;IAiB/B,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAK3C,OAAO,IAAI,IAAI;IAUf,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAI3B,UAAU,IAAI,IAAI;IAYlB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI;IAOjE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAe1B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAW7B,YAAY,IAAI,IAAI;IAIpB,YAAY,IAAI,IAAI;IAUpB,UAAU,IAAI,IAAI;IAIlB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKzD,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI;IAQnD,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;CAwB3C;AAED,eAAe,UAAU,CAAC"}

package/node_modules/{domhandler/lib/esm → sanitize-html/node_modules/domhandler/dist}/index.js

@@ -1,43 +1,52 @@
 import { ElementType } from "domelementtype";
-import { Element, Text, Comment, CDATA, Document, ProcessingInstruction, } from "./node.js";
+import { CDATA, Comment, Document, Element, ProcessingInstruction, Text, } from "./node.js";
 export * from "./node.js";
 // Default options
-const defaultOpts = {
+const defaultOptions = {
     withStartIndices: false,
     withEndIndices: false,
     xmlMode: false,
 };
+/**
+ * Event-based handler that builds a DOM tree from parser callbacks.
+ */
 export class DomHandler {
+    /** The elements of the DOM */
+    dom = [];
+    /** The root element for the DOM */
+    root = new Document(this.dom);
+    /** Called once parsing has completed. */
+    callback;
+    /** Settings for the handler. */
+    options;
+    /** Callback whenever a tag is closed. */
+    elementCB;
+    /** Indicated whether parsing has been completed. */
+    done = false;
+    /** Stack of open tags. */
+    tagStack = [this.root];
+    /** A data node that is still being written to. */
+    lastNode = null;
+    /** Reference to the parser instance. Used for location information. */
+    parser = null;
     /**
      * @param callback Called once parsing has completed.
      * @param options Settings for the handler.
      * @param elementCB Callback whenever a tag is closed.
      */
     constructor(callback, options, elementCB) {
-        /** The elements of the DOM */
-        this.dom = [];
-        /** The root element for the DOM */
-        this.root = new Document(this.dom);
-        /** Indicated whether parsing has been completed. */
-        this.done = false;
-        /** Stack of open tags. */
-        this.tagStack = [this.root];
-        /** A data node that is still being written to. */
-        this.lastNode = null;
-        /** Reference to the parser instance. Used for location information. */
-        this.parser = null;
         // Make it possible to skip arguments, for backwards-compatibility
         if (typeof options === "function") {
             elementCB = options;
-            options = defaultOpts;
+            options = defaultOptions;
         }
         if (typeof callback === "object") {
             options = callback;
             callback = undefined;
         }
-        this.callback = callback !== null && callback !== void 0 ? callback : null;
-        this.options = options !== null && options !== void 0 ? options : defaultOpts;
-        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
+        this.callback = callback ?? null;
+        this.options = options ?? defaultOptions;
+        this.elementCB = elementCB ?? null;
     }
     onparserinit(parser) {
         this.parser = parser;
@@ -64,12 +73,12 @@ export class DomHandler {
     }
     onclosetag() {
         this.lastNode = null;
-        const elem = this.tagStack.pop();
-        if (this.options.withEndIndices) {
-            elem.endIndex = this.parser.endIndex;
+        const element = this.tagStack.pop();
+        if (this.options.withEndIndices && this.parser) {
+            element.endIndex = this.parser.endIndex;
         }
         if (this.elementCB)
-            this.elementCB(elem);
+            this.elementCB(element);
     }
     onopentag(name, attribs) {
         const type = this.options.xmlMode ? ElementType.Tag : undefined;
@@ -81,7 +90,7 @@ export class DomHandler {
         const { lastNode } = this;
         if (lastNode && lastNode.type === ElementType.Text) {
             lastNode.data += data;
-            if (this.options.withEndIndices) {
+            if (this.options.withEndIndices && this.parser) {
                 lastNode.endIndex = this.parser.endIndex;
             }
         }
@@ -128,10 +137,10 @@ export class DomHandler {
     addNode(node) {
         const parent = this.tagStack[this.tagStack.length - 1];
         const previousSibling = parent.children[parent.children.length - 1];
-        if (this.options.withStartIndices) {
+        if (this.options.withStartIndices && this.parser) {
             node.startIndex = this.parser.startIndex;
         }
-        if (this.options.withEndIndices) {
+        if (this.options.withEndIndices && this.parser) {
             node.endIndex = this.parser.endIndex;
         }
         parent.children.push(node);