@zowe/cli 8.36.1 → 8.37.1

package/node_modules/domutils/{lib/querying.js → src/querying.ts}

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filter = filter;
-exports.find = find;
-exports.findOneChild = findOneChild;
-exports.findOne = findOne;
-exports.existsOne = existsOne;
-exports.findAll = findAll;
-var domhandler_1 = require("domhandler");
+import {
+    type AnyNode,
+    type Element,
+    hasChildren,
+    isTag,
+    type ParentNode,
+} from "domhandler";
+
 /**
  * Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one.
  *
@@ -17,11 +16,15 @@ var domhandler_1 = require("domhandler");
  * @param limit Maximum number of nodes to return.
  * @returns All nodes passing `test`.
  */
-function filter(test, node, recurse, limit) {
-    if (recurse === void 0) { recurse = true; }
-    if (limit === void 0) { limit = Infinity; }
+export function filter(
+    test: (element: AnyNode) => boolean,
+    node: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
     return find(test, Array.isArray(node) ? node : [node], recurse, limit);
 }
+
 /**
  * Search an array of nodes and their children for nodes passing a test function.
  *
@@ -32,12 +35,18 @@ function filter(test, node, recurse, limit) {
  * @param limit Maximum number of nodes to return.
  * @returns All nodes passing `test`.
  */
-function find(test, nodes, recurse, limit) {
-    var result = [];
+export function find(
+    test: (element: AnyNode) => boolean,
+    nodes: AnyNode[] | ParentNode,
+    recurse: boolean,
+    limit: number,
+): AnyNode[] {
+    const result: AnyNode[] = [];
     /** Stack of the arrays we are looking at. */
-    var nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
+    const nodeStack: AnyNode[][] = [Array.isArray(nodes) ? nodes : [nodes]];
     /** Stack of the indices within the arrays. */
-    var indexStack = [0];
+    const indexStack = [0];
+
     for (;;) {
         // First, check if the current array has any more elements to look at.
         if (indexStack[0] >= nodeStack[0].length) {
@@ -45,40 +54,33 @@ function find(test, nodes, recurse, limit) {
             if (indexStack.length === 1) {
                 return result;
             }
+
             // Otherwise, remove the current array from the stack.
             nodeStack.shift();
             indexStack.shift();
+
             // Loop back to the start to continue with the next array.
             continue;
         }
-        var elem = nodeStack[0][indexStack[0]++];
-        if (test(elem)) {
-            result.push(elem);
-            if (--limit <= 0)
-                return result;
+
+        const element = nodeStack[0][indexStack[0]++];
+
+        if (test(element)) {
+            result.push(element);
+            if (--limit <= 0) return result;
         }
-        if (recurse && (0, domhandler_1.hasChildren)(elem) && elem.children.length > 0) {
+
+        if (recurse && hasChildren(element) && element.children.length > 0) {
             /*
              * Add the children to the stack. We are depth-first, so this is
              * the next array we look at.
              */
             indexStack.unshift(0);
-            nodeStack.unshift(elem.children);
+            nodeStack.unshift(element.children);
         }
     }
 }
-/**
- * Finds the first element inside of an array that matches a test function. This is an alias for `Array.prototype.find`.
- *
- * @category Querying
- * @param test Function to test nodes on.
- * @param nodes Array of nodes to search.
- * @returns The first node in the array that passes `test`.
- * @deprecated Use `Array.prototype.find` directly.
- */
-function findOneChild(test, nodes) {
-    return nodes.find(test);
-}
+
 /**
  * Finds one element in a tree that passes a test.
  *
@@ -88,22 +90,25 @@ function findOneChild(test, nodes) {
  * @param recurse Also consider child nodes.
  * @returns The first node that passes `test`.
  */
-function findOne(test, nodes, recurse) {
-    if (recurse === void 0) { recurse = true; }
-    var searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
-    for (var i = 0; i < searchedNodes.length; i++) {
-        var node = searchedNodes[i];
-        if ((0, domhandler_1.isTag)(node) && test(node)) {
+export function findOne(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+    recurse = true,
+): Element | null {
+    const searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
+    for (const node of searchedNodes) {
+        if (isTag(node) && test(node)) {
             return node;
         }
-        if (recurse && (0, domhandler_1.hasChildren)(node) && node.children.length > 0) {
-            var found = findOne(test, node.children, true);
-            if (found)
-                return found;
+        if (recurse && hasChildren(node) && node.children.length > 0) {
+            const found = findOne(test, node.children, true);
+            if (found) return found;
         }
     }
+
     return null;
 }
+
 /**
  * Checks if a tree of nodes contains at least one node passing a test.
  *
@@ -112,12 +117,17 @@ function findOne(test, nodes, recurse) {
  * @param nodes Array of nodes to search.
  * @returns Whether a tree of nodes contains at least one node passing the test.
  */
-function existsOne(test, nodes) {
-    return (Array.isArray(nodes) ? nodes : [nodes]).some(function (node) {
-        return ((0, domhandler_1.isTag)(node) && test(node)) ||
-            ((0, domhandler_1.hasChildren)(node) && existsOne(test, node.children));
-    });
+export function existsOne(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+): boolean {
+    return (Array.isArray(nodes) ? nodes : [nodes]).some(
+        (node) =>
+            (isTag(node) && test(node)) ||
+            (hasChildren(node) && existsOne(test, node.children)),
+    );
 }
+
 /**
  * Search an array of nodes and their children for elements passing a test function.
  *
@@ -128,28 +138,35 @@ function existsOne(test, nodes) {
  * @param nodes Array of nodes to search.
  * @returns All nodes passing `test`.
  */
-function findAll(test, nodes) {
-    var result = [];
-    var nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
-    var indexStack = [0];
+export function findAll(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+): Element[] {
+    const result = [];
+    const nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
+    const indexStack = [0];
+
     for (;;) {
         if (indexStack[0] >= nodeStack[0].length) {
             if (nodeStack.length === 1) {
                 return result;
             }
+
             // Otherwise, remove the current array from the stack.
             nodeStack.shift();
             indexStack.shift();
+
             // Loop back to the start to continue with the next array.
             continue;
         }
-        var elem = nodeStack[0][indexStack[0]++];
-        if ((0, domhandler_1.isTag)(elem) && test(elem))
-            result.push(elem);
-        if ((0, domhandler_1.hasChildren)(elem) && elem.children.length > 0) {
+
+        const element = nodeStack[0][indexStack[0]++];
+
+        if (isTag(element) && test(element)) result.push(element);
+
+        if (hasChildren(element) && element.children.length > 0) {
             indexStack.unshift(0);
-            nodeStack.unshift(elem.children);
+            nodeStack.unshift(element.children);
         }
     }
 }
-//# sourceMappingURL=querying.js.map

package/node_modules/domutils/src/stringify.ts

@@ -0,0 +1,90 @@
+import renderHTML, { type DomSerializerOptions } from "dom-serializer";
+import { ElementType } from "domelementtype";
+import {
+    type AnyNode,
+    hasChildren,
+    isCDATA,
+    isComment,
+    isTag,
+    isText,
+} from "domhandler";
+
+/**
+ * @category Stringify
+ * @deprecated Use the `dom-serializer` module directly.
+ * @param node Node to get the outer HTML of.
+ * @param options Options for serialization.
+ * @returns `node`'s outer HTML.
+ */
+export function getOuterHTML(
+    node: AnyNode | ArrayLike<AnyNode>,
+    options?: DomSerializerOptions,
+): string {
+    return renderHTML(node, options);
+}
+
+/**
+ * @category Stringify
+ * @deprecated Use the `dom-serializer` module directly.
+ * @param node Node to get the inner HTML of.
+ * @param options Options for serialization.
+ * @returns `node`'s inner HTML.
+ */
+export function getInnerHTML(
+    node: AnyNode,
+    options?: DomSerializerOptions,
+): string {
+    return hasChildren(node)
+        ? node.children.map((node) => getOuterHTML(node, options)).join("")
+        : "";
+}
+
+/**
+ * Get a node's inner text. Same as `textContent`, but inserts newlines for `<br>` tags. Ignores comments.
+ *
+ * @category Stringify
+ * @deprecated Use `textContent` instead.
+ * @param node Node to get the inner text of.
+ * @returns `node`'s inner text.
+ */
+export function getText(node: AnyNode | AnyNode[]): string {
+    if (Array.isArray(node)) return node.map(getText).join("");
+    if (isTag(node)) return node.name === "br" ? "\n" : getText(node.children);
+    if (isCDATA(node)) return getText(node.children);
+    if (isText(node)) return node.data;
+    return "";
+}
+
+/**
+ * Get a node's text content. Ignores comments.
+ *
+ * @category Stringify
+ * @param node Node to get the text content of.
+ * @returns `node`'s text content.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent}
+ */
+export function textContent(node: AnyNode | AnyNode[]): string {
+    if (Array.isArray(node)) return node.map(textContent).join("");
+    if (hasChildren(node) && !isComment(node)) {
+        return textContent(node.children);
+    }
+    if (isText(node)) return node.data;
+    return "";
+}
+
+/**
+ * Get a node's inner text, ignoring `<script>` and `<style>` tags. Ignores comments.
+ *
+ * @category Stringify
+ * @param node Node to get the inner text of.
+ * @returns `node`'s inner text.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/innerText}
+ */
+export function innerText(node: AnyNode | AnyNode[]): string {
+    if (Array.isArray(node)) return node.map(innerText).join("");
+    if (hasChildren(node) && (node.type === ElementType.Tag || isCDATA(node))) {
+        return innerText(node.children);
+    }
+    if (isText(node)) return node.data;
+    return "";
+}

package/node_modules/domutils/src/traversal.ts

@@ -0,0 +1,132 @@
+import {
+    type AnyNode,
+    type ChildNode,
+    type Element,
+    hasChildren,
+    isTag,
+    type ParentNode,
+} from "domhandler";
+
+/**
+ * Get a node's children.
+ *
+ * @category Traversal
+ * @param element Node to get the children of.
+ * @returns `element`'s children, or an empty array.
+ */
+export function getChildren(element: AnyNode): ChildNode[] {
+    return hasChildren(element) ? element.children : [];
+}
+
+/**
+ * Get a node's parent.
+ *
+ * @category Traversal
+ * @param element Node to get the parent of.
+ * @returns `element`'s parent node, or `null` if `element` is a root node.
+ */
+export function getParent(element: AnyNode): ParentNode | null;
+export function getParent(element: AnyNode): ParentNode | null {
+    return element.parent || null;
+}
+
+/**
+ * Gets an elements siblings, including the element itself.
+ *
+ * Attempts to get the children through the element's parent first. If we don't
+ * have a parent (the element is a root node), we walk the element's `prev` &
+ * `next` to get all remaining nodes.
+ *
+ * @category Traversal
+ * @param element Element to get the siblings of.
+ * @returns `element`'s siblings, including `element`.
+ */
+export function getSiblings(element: AnyNode): AnyNode[] {
+    const parent = getParent(element);
+    if (parent != null) return getChildren(parent);
+
+    const siblings = [element];
+    let { prev, next } = element;
+    while (prev != null) {
+        siblings.unshift(prev);
+        ({ prev } = prev);
+    }
+    while (next != null) {
+        siblings.push(next);
+        ({ next } = next);
+    }
+    return siblings;
+}
+
+/**
+ * Gets an attribute from an element.
+ *
+ * @category Traversal
+ * @param element Element to check.
+ * @param name Attribute name to retrieve.
+ * @returns The element's attribute value, or `undefined`.
+ */
+export function getAttributeValue(
+    element: Element,
+    name: string,
+): string | undefined {
+    const { attribs } = element as {
+        attribs?: Record<string, string | undefined>;
+    };
+    return attribs?.[name];
+}
+
+/**
+ * Checks whether an element has an attribute.
+ *
+ * @category Traversal
+ * @param element Element to check.
+ * @param name Attribute name to look for.
+ * @returns Returns whether `element` has the attribute `name`.
+ */
+export function hasAttrib(element: Element, name: string): boolean {
+    const { attribs } = element as { attribs?: Record<string, string | null> };
+    return (
+        attribs != null && Object.hasOwn(attribs, name) && attribs[name] != null
+    );
+}
+
+/**
+ * Get the tag name of an element.
+ *
+ * @category Traversal
+ * @param element The element to get the name for.
+ * @returns The tag name of `element`.
+ */
+export function getName(element: Element): string {
+    return element.name;
+}
+
+/**
+ * Returns the next element sibling of a node.
+ *
+ * @category Traversal
+ * @param element The element to get the next sibling of.
+ * @returns `element`'s next sibling that is a tag, or `null` if there is no next
+ * sibling.
+ */
+export function nextElementSibling(element: AnyNode): Element | null {
+    let { next } = element;
+    while (next !== null && !isTag(next)) ({ next } = next);
+    return next;
+}
+
+/**
+ * Returns the previous element sibling of a node.
+ *
+ * @category Traversal
+ * @param element The element to get the previous sibling of.
+ * @returns `element`'s previous sibling that is a tag, or `null` if there is no
+ * previous sibling.
+ */
+// eslint-disable-next-line unicorn/prevent-abbreviations -- Keep public API name for backwards compatibility.
+export function prevElementSibling(element: AnyNode): Element | null {
+    let { prev } = element;
+    while (prev !== null && !isTag(prev)) ({ prev } = prev);
+    return prev;
+}

package/node_modules/htmlparser2/README.md

@@ -83,8 +83,37 @@ JS! Hooray!
 That's it?!
 ```
 
-This example only shows three of the possible events.
-Read more about the parser, its events and options in the [wiki](https://github.com/fb55/htmlparser2/wiki/Parser-options).
+### Parser events
+
+All callbacks are optional. The handler object you pass to `Parser` may implement any subset of these:
+
+| Event                                        | Description                                                                                                                                      |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `onopentag(name, attribs, isImplied)`        | Opening tag. `attribs` is an object mapping attribute names to values. `isImplied` is `true` when the tag was opened implicitly (HTML mode only). |
+| `onopentagname(name)`                        | Emitted for the tag name as soon as it is available (before attributes are parsed).                                                              |
+| `onattribute(name, value, quote)`            | Attribute. `quote` is `"` / `'` / `null` (unquoted) / `undefined` (no value, e.g. `disabled`).                                                  |
+| `onclosetag(name, isImplied)`                | Closing tag. `isImplied` is `true` when the tag was closed implicitly (HTML mode only).                                                          |
+| `ontext(data)`                               | Text content. May fire multiple times for a single text node.                                                                                    |
+| `oncomment(data)`                            | Comment (content between `<!--` and `-->`).                                                                                                      |
+| `oncdatastart()`                             | Opening of a CDATA section (`<![CDATA[`).                                                                                                        |
+| `oncdataend()`                               | End of a CDATA section (`]]>`).                                                                                                                  |
+| `onprocessinginstruction(name, data)`        | Processing instruction (e.g. `<?xml ...?>`).                                                                                                     |
+| `oncommentend()`                             | Fires after a comment has ended.                                                                                                                 |
+| `onparserinit(parser)`                       | Fires when the parser is initialized or reset.                                                                                                   |
+| `onreset()`                                  | Fires when `parser.reset()` is called.                                                                                                           |
+| `onend()`                                    | Fires when parsing is complete.                                                                                                                  |
+| `onerror(error)`                             | Fires on error.                                                                                                                                  |
+
+### Parser options
+
+| Option                   | Type      | Default    | Description                                                                                                                                              |
+| ------------------------ | --------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `xmlMode`                | `boolean` | `false`    | Treat the document as XML. This affects entity decoding, self-closing tags, CDATA handling, and more. Set this to `true` for XML, RSS, Atom and RDF feeds. |
+| `decodeEntities`         | `boolean` | `true`     | Decode HTML entities (e.g. `&amp;` -> `&`).                                                                                                              |
+| `lowerCaseTags`          | `boolean` | `!xmlMode` | Lowercase tag names.                                                                                                                                     |
+| `lowerCaseAttributeNames`| `boolean` | `!xmlMode` | Lowercase attribute names.                                                                                                                               |
+| `recognizeSelfClosing`   | `boolean` | `xmlMode`  | Recognize self-closing tags (e.g. `<br/>`). Always enabled in `xmlMode`.                                                                                 |
+| `recognizeCDATA`         | `boolean` | `xmlMode`  | Recognize CDATA sections as text. Always enabled in `xmlMode`.                                                                                           |
 
 ### Usage with streams
 
@@ -106,25 +135,100 @@ htmlStream.pipe(parserStream).on("finish", () => console.log("done"));
 
 ## Getting a DOM
 
-The `DomHandler` produces a DOM (document object model) that can be manipulated using the [`DomUtils`](https://github.com/fb55/DomUtils) helper.
+The `parseDocument` helper parses a string and returns a DOM tree (a [`Document`](https://github.com/fb55/domhandler) node).
 
 ```js
 import * as htmlparser2 from "htmlparser2";
 
-const dom = htmlparser2.parseDocument(htmlString);
+const dom = htmlparser2.parseDocument(
+    `<ul id="fruits">
+        <li class="apple">Apple</li>
+        <li class="orange">Orange</li>
+    </ul>`,
+);
+```
+
+`parseDocument` accepts an optional second argument with both parser and [DOM handler options](https://github.com/fb55/domhandler):
+
+```js
+const dom = htmlparser2.parseDocument(data, {
+    // Parser options
+    xmlMode: true,
+
+    // domhandler options
+    withStartIndices: true, // Add `startIndex` to each node
+    withEndIndices: true,   // Add `endIndex` to each node
+});
+```
+
+### Searching the DOM
+
+The [`DomUtils`](https://github.com/fb55/domutils) module (re-exported on the main `htmlparser2` export) provides helpers for finding nodes:
+
+```js
+import * as htmlparser2 from "htmlparser2";
+
+const dom = htmlparser2.parseDocument(`<div><p id="greeting">Hello</p></div>`);
+
+// Find elements by ID, tag name, or class
+const greeting = htmlparser2.DomUtils.getElementById("greeting", dom);
+const paragraphs = htmlparser2.DomUtils.getElementsByTagName("p", dom);
+
+// Find elements with custom test functions
+const all = htmlparser2.DomUtils.findAll(
+    (el) => el.attribs?.class === "active",
+    dom,
+);
+
+// Get text content
+htmlparser2.DomUtils.textContent(greeting); // "Hello"
+```
+
+For CSS selector queries, use [`css-select`](https://github.com/fb55/css-select):
+
+```js
+import { selectAll, selectOne } from "css-select";
+
+const results = selectAll("ul#fruits > li", dom);
+const first = selectOne("li.apple", dom);
+```
+
+Or, if you'd prefer a jQuery-like API, use [`cheerio`](https://github.com/cheeriojs/cheerio).
+
+### Modifying and serializing the DOM
+
+Use `DomUtils` to modify the tree, and [`dom-serializer`](https://github.com/cheeriojs/dom-serializer) (also available as `DomUtils.getOuterHTML`) to serialize it back to HTML:
+
+```js
+import * as htmlparser2 from "htmlparser2";
+
+const dom = htmlparser2.parseDocument(
+    `<ul><li>Apple</li><li>Orange</li></ul>`,
+);
+
+// Remove the first <li>
+const items = htmlparser2.DomUtils.getElementsByTagName("li", dom);
+htmlparser2.DomUtils.removeElement(items[0]);
+
+// Serialize back to HTML
+const html = htmlparser2.DomUtils.getOuterHTML(dom);
+// "<ul><li>Orange</li></ul>"
 ```
 
-The `DomHandler`, while still bundled with this module, was moved to its [own module](https://github.com/fb55/domhandler).
-Have a look at that for further information.
+Other manipulation helpers include `appendChild`, `prependChild`, `append`, `prepend`, and `replaceElement` -- see the [`domutils` docs](https://github.com/fb55/domutils) for the full API.
 
-## Parsing Feeds
+## Parsing feeds
 
 `htmlparser2` makes it easy to parse RSS, RDF and Atom feeds, by providing a `parseFeed` method:
 
 ```javascript
-const feed = htmlparser2.parseFeed(content, options);
+const feed = htmlparser2.parseFeed(content);
 ```
 
+This returns an object with `type`, `title`, `link`, `description`, `updated`, `author`, and `items` (an array of feed entries), or `null` if the document isn't a recognized feed format.
+
+The `xmlMode` option is enabled by default for `parseFeed`. If you pass custom options, make sure to include `xmlMode: true`.
+
 ## Performance
 
 After having some artificial benchmarks for some time, **@AndreasMadsen** published his [`htmlparser-benchmark`](https://github.com/AndreasMadsen/htmlparser-benchmark), which benchmarks HTML parses based on real-world websites.
@@ -147,25 +251,7 @@ saxes              : 45.7921 ms/file ± 128.691
 html5              : 120.844 ms/file ± 153.944
 ```
 
-## How does this module differ from [node-htmlparser](https://github.com/tautologistics/node-htmlparser)?
-
-In 2011, this module started as a fork of the `htmlparser` module.
-`htmlparser2` was rewritten multiple times and, while it maintains an API that's mostly compatible with `htmlparser`, the projects don't share any code anymore.
-
-The parser now provides a callback interface inspired by [sax.js](https://github.com/isaacs/sax-js) (originally targeted at [readabilitySAX](https://github.com/fb55/readabilitysax)).
-As a result, old handlers won't work anymore.
-
-The `DefaultHandler` was renamed to clarify its purpose (to `DomHandler`). The old name is still available when requiring `htmlparser2` and your code should work as expected.
-
-The `RssHandler` was replaced with a `getFeed` function that takes a `DomHandler` DOM and returns a feed object. There is a `parseFeed` helper function that can be used to parse a feed from a string.
-
 ## Security contact information
 
 To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security).
 Tidelift will coordinate the fix and disclosure.
-
-## `htmlparser2` for enterprise
-
-Available as part of the Tidelift Subscription.
-
-The maintainers of `htmlparser2` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-htmlparser2?utm_source=npm-htmlparser2&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)