@zowe/cli 8.36.1 → 8.37.1

package/node_modules/htmlparser2/src/WebWritableStream.ts

@@ -0,0 +1,47 @@
+import { type Handler, Parser, type ParserOptions } from "./Parser.js";
+
+/**
+ * WebWritableStream makes the `Parser` interface available as a Web Streams API WritableStream.
+ *
+ * This is useful for piping `fetch()` response bodies directly into the parser.
+ * @see Parser
+ * @example
+ * ```typescript
+ * import { WebWritableStream } from "htmlparser2/WebWritableStream";
+ *
+ * const stream = new WebWritableStream({
+ *     onopentag(name, attribs) {
+ *         console.log("Opened:", name);
+ *     },
+ * });
+ *
+ * const response = await fetch("https://example.com");
+ * await response.body.pipeTo(stream);
+ * ```
+ */
+// eslint-disable-next-line n/no-unsupported-features/node-builtins -- Web Streams API; requires a runtime with WritableStream (browsers, Deno, Node ≥18.0)
+export class WebWritableStream extends WritableStream<string | Uint8Array> {
+    constructor(cbs: Partial<Handler>, options?: ParserOptions) {
+        const parser = new Parser(cbs, options);
+        const decoder = new TextDecoder();
+        const streamOption: TextDecodeOptions = { stream: true };
+
+        super({
+            write(chunk) {
+                parser.write(
+                    typeof chunk === "string"
+                        ? chunk
+                        : decoder.decode(chunk, streamOption),
+                );
+            },
+            close() {
+                // Flush any remaining bytes in the decoder
+                const remaining = decoder.decode();
+                if (remaining) {
+                    parser.write(remaining);
+                }
+                parser.end();
+            },
+        });
+    }
+}

package/node_modules/htmlparser2/src/WritableStream.ts

@@ -1,10 +1,10 @@
-import { Parser, type Handler, type ParserOptions } from "./Parser.js";
 /*
  * NOTE: If either of these two imports produces a type error,
  * please update your @types/node dependency!
  */
 import { Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
+import { type Handler, Parser, type ParserOptions } from "./Parser.js";
 
 // Following the example in https://nodejs.org/api/stream.html#stream_decoding_buffers_in_a_writable_stream
 function isBuffer(_chunk: string | Buffer, encoding: string): _chunk is Buffer {
@@ -13,7 +13,6 @@ function isBuffer(_chunk: string | Buffer, encoding: string): _chunk is Buffer {
 
 /**
  * WritableStream makes the `Parser` interface available as a NodeJS stream.
- *
  * @see Parser
  */
 export class WritableStream extends Writable {

package/node_modules/htmlparser2/src/index.ts

@@ -1,13 +1,13 @@
 import { Parser, type ParserOptions } from "./Parser.js";
+
 export type { Handler, ParserOptions } from "./Parser.js";
 export { Parser } from "./Parser.js";
 
 import {
+    type Document,
     DomHandler,
     type DomHandlerOptions,
-    type ChildNode,
     type Element,
-    type Document,
 } from "domhandler";
 
 export {
@@ -17,13 +17,15 @@ export {
     type DomHandlerOptions,
 } from "domhandler";
 
+/**
+ * Combined parser and handler options.
+ */
 export type Options = ParserOptions & DomHandlerOptions;
 
 // Helper methods
 
 /**
  * Parses the data, returns the resulting document.
- *
  * @param data The data that should be parsed.
  * @param options Optional options for the parser and DOM handler.
  */
@@ -32,22 +34,9 @@ export function parseDocument(data: string, options?: Options): Document {
     new Parser(handler, options).end(data);
     return handler.root;
 }
-/**
- * Parses data, returns an array of the root nodes.
- *
- * Note that the root nodes still have a `Document` node as their parent.
- * Use `parseDocument` to get the `Document` node instead.
- *
- * @param data The data that should be parsed.
- * @param options Optional options for the parser and DOM handler.
- * @deprecated Use `parseDocument` instead.
- */
-export function parseDOM(data: string, options?: Options): ChildNode[] {
-    return parseDocument(data, options).children;
-}
+
 /**
  * Creates a parser instance, with an attached DOM handler.
- *
  * @param callback A callback that will be called once parsing has been completed, with the resulting document.
  * @param options Optional options for the parser and DOM handler.
  * @param elementCallback An optional callback that will be called every time a tag has been completed inside of the DOM.
@@ -64,44 +53,26 @@ export function createDocumentStream(
     );
     return new Parser(handler, options);
 }
-/**
- * Creates a parser instance, with an attached DOM handler.
- *
- * @param callback A callback that will be called once parsing has been completed, with an array of root nodes.
- * @param options Optional options for the parser and DOM handler.
- * @param elementCallback An optional callback that will be called every time a tag has been completed inside of the DOM.
- * @deprecated Use `createDocumentStream` instead.
- */
-export function createDomStream(
-    callback: (error: Error | null, dom: ChildNode[]) => void,
-    options?: Options,
-    elementCallback?: (element: Element) => void,
-): Parser {
-    const handler = new DomHandler(callback, options, elementCallback);
-    return new Parser(handler, options);
-}
-
-export {
-    default as Tokenizer,
-    type Callbacks as TokenizerCallbacks,
-    QuoteType,
-} from "./Tokenizer.js";
 
 /*
  * All of the following exports exist for backwards-compatibility.
  * They should probably be removed eventually.
  */
 export * as ElementType from "domelementtype";
+export {
+    type Callbacks as TokenizerCallbacks,
+    default as Tokenizer,
+    QuoteType,
+} from "./Tokenizer.js";
 
-import { getFeed, type Feed } from "domutils";
+import { type Feed, getFeed } from "domutils";
 
-export { getFeed, type Feed } from "domutils";
+export { type Feed, getFeed } from "domutils";
 
 const parseFeedDefaultOptions = { xmlMode: true };
 
 /**
  * Parse a feed.
- *
  * @param feed The feed that should be parsed, as a string.
  * @param options Optionally, options for parsing. When using this, you should set `xmlMode` to `true`.
  */
@@ -109,7 +80,7 @@ export function parseFeed(
     feed: string,
     options: Options = parseFeedDefaultOptions,
 ): Feed | null {
-    return getFeed(parseDOM(feed, options));
+    return getFeed(parseDocument(feed, options).children);
 }
 
 export * as DomUtils from "domutils";

package/node_modules/isexe/LICENSE

@@ -1,6 +1,6 @@
 The ISC License
 
-Copyright (c) Isaac Z. Schlueter and Contributors
+Copyright (c) 2016-2022 Isaac Z. Schlueter and Contributors
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/node_modules/isexe/README.md

@@ -7,45 +7,68 @@ Windows.
 
 ## USAGE
 
-```javascript
-var isexe = require('isexe')
-isexe('some-file-name', function (err, isExe) {
-  if (err) {
-    console.error('probably file does not exist or something', err)
-  } else if (isExe) {
+```js
+import { isexe, sync } from 'isexe'
+// or require() works too
+// const { isexe } = require('isexe')
+isexe('some-file-name').then(isExe => {
+  if (isExe) {
     console.error('this thing can be run')
   } else {
     console.error('cannot be run')
   }
+}, (err) => {
+  console.error('probably file doesnt exist or something')
 })
 
 // same thing but synchronous, throws errors
-var isExe = isexe.sync('some-file-name')
+isExe = sync('some-file-name')
 
 // treat errors as just "not executable"
-isexe('maybe-missing-file', { ignoreErrors: true }, callback)
-var isExe = isexe.sync('maybe-missing-file', { ignoreErrors: true })
+const isExe = await isexe('maybe-missing-file', { ignoreErrors: true })
+const isExe = sync('maybe-missing-file', { ignoreErrors: true })
 ```
 
 ## API
 
-### `isexe(path, [options], [callback])`
+### `isexe(path, [options]) => Promise<boolean>`
 
-Check if the path is executable.  If no callback provided, and a
-global `Promise` object is available, then a Promise will be returned.
+Check if the path is executable.
 
 Will raise whatever errors may be raised by `fs.stat`, unless
 `options.ignoreErrors` is set to true.
 
-### `isexe.sync(path, [options])`
+### `sync(path, [options]) => boolean`
 
 Same as `isexe` but returns the value and throws any errors raised.
 
+## Platform Specific Implementations
+
+If for some reason you want to use the implementation for a
+specific platform, you can do that.
+
+```js
+import { win32, posix } from 'isexe'
+win32.isexe(...)
+win32.sync(...)
+// etc
+
+// or:
+import { isexe, sync } from 'isexe/posix'
+```
+
+The default exported implementation will be chosen based on
+`process.platform`.
+
 ### Options
 
-* `ignoreErrors` Treat all errors as "no, this is not executable", but
-  don't raise them.
-* `uid` Number to use as the user id
-* `gid` Number to use as the group id
+```ts
+import type IsexeOptions from 'isexe'
+```
+
+* `ignoreErrors` Treat all errors as "no, this is not
+  executable", but don't raise them.
+* `uid` Number to use as the user id on posix
+* `gid` Number to use as the group id on posix
 * `pathExt` List of path extensions to use instead of `PATHEXT`
   environment variable on Windows.

package/node_modules/isexe/package.json

@@ -1,31 +1,96 @@
 {
   "name": "isexe",
-  "version": "2.0.0",
+  "version": "3.1.1",
   "description": "Minimal module to check if a file is executable.",
-  "main": "index.js",
-  "directories": {
-    "test": "test"
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/mjs/index.js",
+  "types": "./dist/cjs/index.js",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/mjs/index.d.ts",
+        "default": "./dist/mjs/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./posix": {
+      "import": {
+        "types": "./dist/mjs/posix.d.ts",
+        "default": "./dist/mjs/posix.js"
+      },
+      "require": {
+        "types": "./dist/cjs/posix.d.ts",
+        "default": "./dist/cjs/posix.js"
+      }
+    },
+    "./win32": {
+      "import": {
+        "types": "./dist/mjs/win32.d.ts",
+        "default": "./dist/mjs/win32.js"
+      },
+      "require": {
+        "types": "./dist/cjs/win32.d.ts",
+        "default": "./dist/cjs/win32.js"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "devDependencies": {
+    "@types/node": "^20.4.5",
+    "@types/tap": "^15.0.8",
+    "c8": "^8.0.1",
     "mkdirp": "^0.5.1",
+    "prettier": "^2.8.8",
     "rimraf": "^2.5.0",
-    "tap": "^10.3.0"
+    "sync-content": "^1.0.2",
+    "tap": "^16.3.8",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.24.8",
+    "typescript": "^5.1.6"
   },
   "scripts": {
-    "test": "tap test/*.js --100",
     "preversion": "npm test",
     "postversion": "npm publish",
-    "postpublish": "git push origin --all; git push origin --tags"
+    "prepublishOnly": "git push origin --follow-tags",
+    "prepare": "tsc -p tsconfig/cjs.json && tsc -p tsconfig/esm.json && bash ./scripts/fixup.sh",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "test": "c8 tap",
+    "snap": "c8 tap",
+    "format": "prettier --write . --loglevel warn --ignore-path ../../.prettierignore --cache",
+    "typedoc": "typedoc --tsconfig tsconfig/esm.json ./src/*.ts"
   },
   "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
   "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/isaacs/isexe.git"
+  "tap": {
+    "coverage": false,
+    "node-arg": [
+      "--enable-source-maps",
+      "--no-warnings",
+      "--loader",
+      "ts-node/esm"
+    ],
+    "ts": false
   },
-  "keywords": [],
-  "bugs": {
-    "url": "https://github.com/isaacs/isexe/issues"
+  "prettier": {
+    "semi": false,
+    "printWidth": 75,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
   },
-  "homepage": "https://github.com/isaacs/isexe#readme"
+  "repository": "https://github.com/isaacs/isexe",
+  "engines": {
+    "node": ">=16"
+  }
 }

package/node_modules/js-yaml/dist/js-yaml.js

@@ -1262,16 +1262,21 @@
                 state.result += _result;
             }
         }
+        function chargeMergeWork(state) {
+            state.totalMergeKeys++;
+            if (state.maxTotalMergeKeys !== -1 && state.totalMergeKeys > state.maxTotalMergeKeys) {
+                throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+            }
+        }
         function mergeMappings(state, destination, source, overridableKeys) {
             if (!common2.isObject(source)) {
                 throwError(state, "cannot merge mappings; the provided source object is unacceptable");
             }
+            chargeMergeWork(state);
             var sourceKeys = Object.keys(source);
             for (var index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
                 var key = sourceKeys[index];
-                if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) {
-                    throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
-                }
+                chargeMergeWork(state);
                 if (!_hasOwnProperty.call(destination, key)) {
                     setProperty(destination, key, source[key]);
                     overridableKeys[key] = true;
@@ -1299,6 +1304,9 @@
             }
             if (keyTag === "tag:yaml.org,2002:merge") {
                 if (Array.isArray(valueNode)) {
+                    if (valueNode.length > 100) {
+                        throwError(state, "abnormal merge sequence size");
+                    }
                     for (var _index = 0, _quantity = valueNode.length; _index < _quantity; _index += 1) {
                         mergeMappings(state, _result, valueNode[_index], overridableKeys);
                     }