@zowe/cli 8.36.1 → 8.37.0

package/node_modules/{domutils/lib/helpers.js → sanitize-html/node_modules/domutils/src/helpers.ts}

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentPosition = void 0;
-exports.removeSubsets = removeSubsets;
-exports.compareDocumentPosition = compareDocumentPosition;
-exports.uniqueSort = uniqueSort;
-var domhandler_1 = require("domhandler");
+import { type AnyNode, hasChildren, type ParentNode } from "domhandler";
+
 /**
  * Given an array of nodes, remove any member that is contained by another
  * member.
@@ -13,44 +8,48 @@ var domhandler_1 = require("domhandler");
  * @param nodes Nodes to filter.
  * @returns Remaining nodes that aren't contained by other nodes.
  */
-function removeSubsets(nodes) {
-    var idx = nodes.length;
+export function removeSubsets(nodes: AnyNode[]): AnyNode[] {
+    let index = nodes.length;
+
     /*
      * Check if each node (or one of its ancestors) is already contained in the
      * array.
      */
-    while (--idx >= 0) {
-        var node = nodes[idx];
+    while (--index >= 0) {
+        const node = nodes[index];
+
         /*
          * Remove the node if it is not unique.
          * We are going through the array from the end, so we only
          * have to check nodes that preceed the node under consideration in the array.
          */
-        if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
-            nodes.splice(idx, 1);
+        if (index > 0 && nodes.lastIndexOf(node, index - 1) >= 0) {
+            nodes.splice(index, 1);
             continue;
         }
-        for (var ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
             if (nodes.includes(ancestor)) {
-                nodes.splice(idx, 1);
+                nodes.splice(index, 1);
                 break;
             }
         }
     }
+
     return nodes;
 }
 /**
  * @category Helpers
  * @see {@link http://dom.spec.whatwg.org/#dom-node-comparedocumentposition}
  */
-var DocumentPosition;
-(function (DocumentPosition) {
-    DocumentPosition[DocumentPosition["DISCONNECTED"] = 1] = "DISCONNECTED";
-    DocumentPosition[DocumentPosition["PRECEDING"] = 2] = "PRECEDING";
-    DocumentPosition[DocumentPosition["FOLLOWING"] = 4] = "FOLLOWING";
-    DocumentPosition[DocumentPosition["CONTAINS"] = 8] = "CONTAINS";
-    DocumentPosition[DocumentPosition["CONTAINED_BY"] = 16] = "CONTAINED_BY";
-})(DocumentPosition || (exports.DocumentPosition = DocumentPosition = {}));
+export const enum DocumentPosition {
+    DISCONNECTED = 1,
+    PRECEDING = 2,
+    FOLLOWING = 4,
+    CONTAINS = 8,
+    CONTAINED_BY = 16,
+}
+
 /**
  * Compare the position of one node against another node in any other document,
  * returning a bitmask with the values from {@link DocumentPosition}.
@@ -77,34 +76,43 @@ var DocumentPosition;
  * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
  * a description of these values.
  */
-function compareDocumentPosition(nodeA, nodeB) {
-    var aParents = [];
-    var bParents = [];
+export function compareDocumentPosition(
+    nodeA: AnyNode,
+    nodeB: AnyNode,
+): number {
+    const aParents: ParentNode[] = [];
+    const bParents: ParentNode[] = [];
+
     if (nodeA === nodeB) {
         return 0;
     }
-    var current = (0, domhandler_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
+
+    let current = hasChildren(nodeA) ? nodeA : nodeA.parent;
     while (current) {
         aParents.unshift(current);
         current = current.parent;
     }
-    current = (0, domhandler_1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
+    current = hasChildren(nodeB) ? nodeB : nodeB.parent;
     while (current) {
         bParents.unshift(current);
         current = current.parent;
     }
-    var maxIdx = Math.min(aParents.length, bParents.length);
-    var idx = 0;
-    while (idx < maxIdx && aParents[idx] === bParents[idx]) {
-        idx++;
+
+    const maxIndex = Math.min(aParents.length, bParents.length);
+    let index = 0;
+    while (index < maxIndex && aParents[index] === bParents[index]) {
+        index++;
     }
-    if (idx === 0) {
+
+    if (index === 0) {
         return DocumentPosition.DISCONNECTED;
     }
-    var sharedParent = aParents[idx - 1];
-    var siblings = sharedParent.children;
-    var aSibling = aParents[idx];
-    var bSibling = bParents[idx];
+
+    const sharedParent = aParents[index - 1];
+    const siblings: AnyNode[] = sharedParent.children;
+    const aSibling = aParents[index];
+    const bSibling = bParents[index];
+
     if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
         if (sharedParent === nodeB) {
             return DocumentPosition.FOLLOWING | DocumentPosition.CONTAINED_BY;
@@ -116,6 +124,7 @@ function compareDocumentPosition(nodeA, nodeB) {
     }
     return DocumentPosition.PRECEDING;
 }
+
 /**
  * Sort an array of nodes based on their relative position in the document,
  * removing any duplicate nodes. If the array contains nodes that do not belong
@@ -125,18 +134,21 @@ function compareDocumentPosition(nodeA, nodeB) {
  * @param nodes Array of DOM nodes.
  * @returns Collection of unique nodes, sorted in document order.
  */
-function uniqueSort(nodes) {
-    nodes = nodes.filter(function (node, i, arr) { return !arr.includes(node, i + 1); });
-    nodes.sort(function (a, b) {
-        var relative = compareDocumentPosition(a, b);
+export function uniqueSort<T extends AnyNode>(nodes: T[]): T[] {
+    nodes = nodes.filter(
+        (node, index, array) => !array.includes(node, index + 1),
+    );
+
+    nodes.sort((a, b) => {
+        const relative = compareDocumentPosition(a, b);
         if (relative & DocumentPosition.PRECEDING) {
             return -1;
         }
-        else if (relative & DocumentPosition.FOLLOWING) {
+        if (relative & DocumentPosition.FOLLOWING) {
             return 1;
         }
         return 0;
     });
+
     return nodes;
 }
-//# sourceMappingURL=helpers.js.map

package/node_modules/{domutils/lib/index.d.ts → sanitize-html/node_modules/domutils/src/index.ts}

@@ -1,10 +1,7 @@
-export * from "./stringify.js";
-export * from "./traversal.js";
+export * from "./feeds.js";
+export * from "./helpers.js";
+export * from "./legacy.js";
 export * from "./manipulation.js";
 export * from "./querying.js";
-export * from "./legacy.js";
-export * from "./helpers.js";
-export * from "./feeds.js";
-/** @deprecated Use these methods from `domhandler` directly. */
-export { isTag, isCDATA, isText, isComment, isDocument, hasChildren, } from "domhandler";
-//# sourceMappingURL=index.d.ts.map
+export * from "./stringify.js";
+export * from "./traversal.js";

package/node_modules/sanitize-html/node_modules/domutils/src/legacy.ts

@@ -0,0 +1,224 @@
+import type { ElementType } from "domelementtype";
+import { type AnyNode, type Element, isTag, isText } from "domhandler";
+import { filter, findOne } from "./querying.js";
+
+type TestType = (element: AnyNode) => boolean;
+
+/**
+ * An object with keys to check elements against. If a key is `tag_name`,
+ * `tag_type` or `tag_contains`, it will check the value against that specific
+ * value. Otherwise, it will check an attribute with the key's name.
+ *
+ * @category Legacy Query Functions
+ */
+// eslint-disable-next-line unicorn/prevent-abbreviations -- Keep the exported API name for backwards compatibility.
+export interface TestElementOpts {
+    tag_name?: string | ((name: string) => boolean);
+    tag_type?: string | ((name: string) => boolean);
+    tag_contains?: string | ((data?: string) => boolean);
+    [attributeName: string]:
+        | undefined
+        | string
+        | ((attributeValue: string) => boolean);
+}
+
+/**
+ * A map of functions to check nodes against.
+ */
+const Checks: Record<
+    string,
+    (value: string | undefined | ((inputString: string) => boolean)) => TestType
+> = {
+    tag_name(name) {
+        if (typeof name === "function") {
+            return (element: AnyNode) => isTag(element) && name(element.name);
+        }
+        if (name === "*") {
+            return isTag;
+        }
+        return (element: AnyNode) => isTag(element) && element.name === name;
+    },
+    tag_type(type) {
+        if (typeof type === "function") {
+            return (element: AnyNode) => type(element.type);
+        }
+        return (element: AnyNode) => element.type === type;
+    },
+    tag_contains(data) {
+        if (typeof data === "function") {
+            return (element: AnyNode) => isText(element) && data(element.data);
+        }
+        return (element: AnyNode) => isText(element) && element.data === data;
+    },
+};
+
+/**
+ * Returns a function to check whether a node has an attribute with a particular
+ * value.
+ *
+ * @param attrib Attribute to check.
+ * @param value Attribute value to look for.
+ * @returns A function to check whether the a node has an attribute with a
+ *   particular value.
+ */
+function getAttribCheck(
+    attrib: string,
+    value: undefined | string | ((value: string) => boolean),
+): TestType {
+    if (typeof value === "function") {
+        return (element: AnyNode) =>
+            isTag(element) && value(element.attribs[attrib]);
+    }
+    return (element: AnyNode) =>
+        isTag(element) && element.attribs[attrib] === value;
+}
+
+/**
+ * Returns a function that returns `true` if either of the input functions
+ * returns `true` for a node.
+ *
+ * @param a First function to combine.
+ * @param b Second function to combine.
+ * @returns A function taking a node and returning `true` if either of the input
+ *   functions returns `true` for the node.
+ */
+function combineFuncs(a: TestType, b: TestType): TestType {
+    return (element: AnyNode) => a(element) || b(element);
+}
+
+/**
+ * Returns a function that executes all checks in `options` and returns `true`
+ * if any of them match a node.
+ *
+ * @param options An object describing nodes to look for.
+ * @returns A function that executes all checks in `options` and returns `true`
+ *   if any of them match a node.
+ */
+function compileTest(options: TestElementOpts): TestType | null {
+    const funcs = Object.keys(options).map((key) => {
+        const value = options[key];
+        return Object.hasOwn(Checks, key)
+            ? Checks[key](value)
+            : getAttribCheck(key, value);
+    });
+
+    return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
+}
+
+/**
+ * Checks whether a node matches the description in `options`.
+ *
+ * @category Legacy Query Functions
+ * @param options An object describing nodes to look for.
+ * @param node The element to test.
+ * @returns Whether the element matches the description in `options`.
+ */
+export function testElement(options: TestElementOpts, node: AnyNode): boolean {
+    const test = compileTest(options);
+    return test ? test(node) : true;
+}
+
+/**
+ * Returns all nodes that match `options`.
+ *
+ * @category Legacy Query Functions
+ * @param options An object describing nodes to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes that match `options`.
+ */
+export function getElements(
+    options: TestElementOpts,
+    nodes: AnyNode | AnyNode[],
+    recurse: boolean,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
+    const test = compileTest(options);
+    return test ? filter(test, nodes, recurse, limit) : [];
+}
+
+/**
+ * Returns the node with the supplied ID.
+ *
+ * @category Legacy Query Functions
+ * @param id The unique ID attribute value to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @returns The node with the supplied ID.
+ */
+export function getElementById(
+    id: string | ((id: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+): Element | null {
+    if (!Array.isArray(nodes)) nodes = [nodes];
+    return findOne(getAttribCheck("id", id), nodes, recurse);
+}
+
+/**
+ * Returns all nodes with the supplied `tagName`.
+ *
+ * @category Legacy Query Functions
+ * @param tagName Tag name to search for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `tagName`.
+ */
+export function getElementsByTagName(
+    tagName: string | ((name: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): Element[] {
+    return filter(
+        Checks["tag_name"](tagName),
+        nodes,
+        recurse,
+        limit,
+    ) as Element[];
+}
+
+/**
+ * Returns all nodes with the supplied `className`.
+ *
+ * @category Legacy Query Functions
+ * @param className Class name to search for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `className`.
+ */
+export function getElementsByClassName(
+    className: string | ((name: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): Element[] {
+    return filter(
+        getAttribCheck("class", className),
+        nodes,
+        recurse,
+        limit,
+    ) as Element[];
+}
+
+/**
+ * Returns all nodes with the supplied `type`.
+ *
+ * @category Legacy Query Functions
+ * @param type Element type to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `type`.
+ */
+export function getElementsByTagType(
+    type: ElementType | ((type: ElementType) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
+    return filter(Checks["tag_type"](type as string), nodes, recurse, limit);
+}

package/node_modules/sanitize-html/node_modules/domutils/src/manipulation.ts

@@ -0,0 +1,156 @@
+import type { ChildNode, ParentNode } from "domhandler";
+
+/**
+ * Remove an element from the dom
+ *
+ * @category Manipulation
+ * @param element The element to be removed.
+ */
+export function removeElement(element: ChildNode): void {
+    if (element.prev) element.prev.next = element.next;
+    if (element.next) element.next.prev = element.prev;
+
+    if (element.parent) {
+        const childs = element.parent.children;
+        const childsIndex = childs.lastIndexOf(element);
+        if (childsIndex !== -1) {
+            childs.splice(childsIndex, 1);
+        }
+    }
+    element.next = null;
+    element.prev = null;
+    element.parent = null;
+}
+
+/**
+ * Replace an element in the dom
+ *
+ * @category Manipulation
+ * @param element The element to be replaced.
+ * @param replacement The element to be added
+ */
+export function replaceElement(
+    element: ChildNode,
+    replacement: ChildNode,
+): void {
+    replacement.prev = element.prev;
+    if (replacement.prev) {
+        replacement.prev.next = replacement;
+    }
+
+    replacement.next = element.next;
+    if (replacement.next) {
+        replacement.next.prev = replacement;
+    }
+
+    replacement.parent = element.parent;
+    if (replacement.parent) {
+        const { children } = replacement.parent;
+        const elementIndex = children.lastIndexOf(element);
+        if (elementIndex === -1) {
+            return;
+        }
+
+        children[elementIndex] = replacement;
+        element.parent = null;
+    }
+}
+
+/**
+ * Append a child to an element.
+ *
+ * @category Manipulation
+ * @param parent The element to append to.
+ * @param child The element to be added as a child.
+ */
+export function appendChild(parent: ParentNode, child: ChildNode): void {
+    removeElement(child);
+
+    child.next = null;
+    child.parent = parent;
+
+    if (parent.children.push(child) > 1) {
+        const sibling = parent.children[parent.children.length - 2];
+        sibling.next = child;
+        child.prev = sibling;
+    } else {
+        child.prev = null;
+    }
+}
+
+/**
+ * Append an element after another.
+ *
+ * @category Manipulation
+ * @param element The element to append after.
+ * @param next The element be added.
+ */
+export function append(element: ChildNode, next: ChildNode): void {
+    removeElement(next);
+
+    const { parent } = element;
+    const currentNext = element.next;
+
+    next.next = currentNext;
+    next.prev = element;
+    element.next = next;
+    next.parent = parent;
+
+    if (currentNext) {
+        currentNext.prev = next;
+        if (parent) {
+            const childs = parent.children;
+            childs.splice(childs.lastIndexOf(currentNext), 0, next);
+        }
+    } else if (parent) {
+        parent.children.push(next);
+    }
+}
+
+/**
+ * Prepend a child to an element.
+ *
+ * @category Manipulation
+ * @param parent The element to prepend before.
+ * @param child The element to be added as a child.
+ */
+export function prependChild(parent: ParentNode, child: ChildNode): void {
+    removeElement(child);
+
+    child.parent = parent;
+    child.prev = null;
+
+    if (parent.children.unshift(child) === 1) {
+        child.next = null;
+    } else {
+        const sibling = parent.children[1];
+        sibling.prev = child;
+        child.next = sibling;
+    }
+}
+
+/**
+ * Prepend an element before another.
+ *
+ * @category Manipulation
+ * @param element The element to prepend before.
+ * @param previous The element to be added.
+ */
+export function prepend(element: ChildNode, previous: ChildNode): void {
+    removeElement(previous);
+
+    const { parent } = element;
+    if (parent) {
+        const childs = parent.children;
+        childs.splice(childs.indexOf(element), 0, previous);
+    }
+
+    if (element.prev) {
+        element.prev.next = previous;
+    }
+
+    previous.parent = parent;
+    previous.prev = element.prev;
+    previous.next = element;
+    element.prev = previous;
+}