@zowe/cli 8.36.1 → 8.37.0

package/node_modules/sanitize-html/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 → sanitize-html/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 → sanitize-html/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/sanitize-html/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanitize-html",
-  "version": "2.17.5",
+  "version": "2.17.7",
   "description": "Clean up user-submitted HTML, preserving allowlisted elements and allowlisted attributes on a per-element basis",
   "sideEffects": false,
   "main": "index.js",
@@ -21,10 +21,13 @@
   ],
   "author": "Apostrophe Technologies, Inc.",
   "license": "MIT",
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "dependencies": {
     "deepmerge": "^4.2.2",
     "escape-string-regexp": "^4.0.0",
-    "htmlparser2": "^10.1.0",
+    "htmlparser2": "^12.0.0",
     "is-plain-object": "^5.0.0",
     "parse-srcset": "^1.0.2",
     "postcss": "^8.3.11",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zowe/cli",
-  "version": "8.36.1",
+  "version": "8.37.0",
   "zoweVersion": "v3.6.0",
   "description": "Zowe CLI is a command line interface (CLI) that provides a simple and streamlined way to interact with IBM z/OS.",
   "author": "Zowe",
@@ -42,7 +42,7 @@
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "scripts": {
-    "postinstall": "node ./scripts/validatePlugins && node ./scripts/printSuccessMessage",
+    "postinstall": "node ./scripts/validatePlugins && node ./scripts/printSuccessMessage && node ./scripts/validateSecretsPrebuild",
     "build": "tsc --pretty",
     "watch": "tsc --pretty --watch",
     "clean": "rimraf lib",
@@ -55,17 +55,17 @@
     "prepublishOnly": "bash ../../scripts/bundleDaemon.sh"
   },
   "dependencies": {
-    "@zowe/core-for-zowe-sdk": "8.36.1",
-    "@zowe/imperative": "8.36.1",
-    "@zowe/provisioning-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-console-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-files-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-jobs-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-logs-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-tso-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-uss-for-zowe-sdk": "8.36.1",
-    "@zowe/zos-workflows-for-zowe-sdk": "8.36.1",
-    "@zowe/zosmf-for-zowe-sdk": "8.36.1",
+    "@zowe/core-for-zowe-sdk": "8.37.0",
+    "@zowe/imperative": "8.37.0",
+    "@zowe/provisioning-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-console-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-files-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-jobs-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-logs-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-tso-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-uss-for-zowe-sdk": "8.37.0",
+    "@zowe/zos-workflows-for-zowe-sdk": "8.37.0",
+    "@zowe/zosmf-for-zowe-sdk": "8.37.0",
     "find-process": "^1.4.7",
     "lodash": "^4.17.23",
     "minimatch": "^10.2.3",
@@ -74,13 +74,13 @@
   "devDependencies": {
     "@types/diff": "^5.0.9",
     "@types/lodash": "^4.17.6",
-    "@zowe/cli-test-utils": "8.36.1",
+    "@zowe/cli-test-utils": "8.37.0",
     "comment-json": "^4.2.3",
     "strip-ansi": "^6.0.1",
     "which": "^4.0.0"
   },
   "optionalDependencies": {
-    "@zowe/secrets-for-zowe-sdk": "8.36.1"
+    "@zowe/secrets-for-zowe-sdk": "8.37.0"
   },
   "engines": {
     "node": ">=20.9.0"

package/scripts/validateSecretsPrebuild.js

@@ -0,0 +1,231 @@
+/*
+* This program and the accompanying materials are made available under the terms of the
+* Eclipse Public License v2.0 which accompanies this distribution, and is available at
+* https://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Copyright Contributors to the Zowe Project.
+*
+*/
+
+/* Verify that the Secrets SDK has a keyring prebuild this platform can load.
+ *
+ * @zowe/secrets-for-zowe-sdk is an optional dependency of the CLI, so npm
+ * quietly omits it whenever its install script fails - for example, when no
+ * prebuild ships for the platform and no Rust toolchain is available to build
+ * one. The CLI still installs and reports success in that state, but secure
+ * credential storage is unavailable and the only symptom the user ever sees is
+ * a "Failed to load Keytar module" error the first time a command reads a
+ * credential. This script turns that into an actionable warning at install
+ * time, while the user is still looking at the terminal.
+ *
+ * This script is run in our package.json:scripts:postinstall as:
+ *    node ./scripts/validateSecretsPrebuild.js
+ * It runs last in the chain so that any warning is the final thing printed,
+ * rather than scrolling past above the "successfully installed" message.
+ *
+ * A missing prebuild is a warning, not an error: nothing here is allowed to
+ * exit non-zero, because doing so would fail the whole `npm install`.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const SECRETS_PKG = "@zowe/secrets-for-zowe-sdk";
+const DOC_LINK = "https://github.com/zowe/zowe-cli/blob/master/packages/secrets/README.md#troubleshooting";
+
+/* The platform target that the keyring loader builds its binary file name from.
+ * Kept deliberately identical to getTargetName() in the Secrets SDK's
+ * src/keyring/index.js, so that the file name we report as missing is the exact
+ * file name the loader looked for.
+ */
+function getTargetName() {
+    switch (process.platform) {
+        case "win32":
+            return `win32-${process.arch}-msvc`;
+        case "linux": {
+            const isMusl = process.report.getReport().header.glibcVersionRuntime == null;
+            const abi = isMusl ? "musl" : "gnu";
+            return process.arch === "arm" ? `linux-arm-${abi}eabihf` : `linux-${process.arch}-${abi}`;
+        }
+        default:
+            return `${process.platform}-${process.arch}`;
+    }
+}
+
+function resolveQuietly(request) {
+    try {
+        return require.resolve(request, { paths: [__dirname, process.cwd()] });
+    } catch (_err) {
+        return undefined;
+    }
+}
+
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf-8"));
+    } catch (_err) {
+        return {};
+    }
+}
+
+/* Look for the prebuild in both places the keyring loader accepts: its own
+ * directory, where a local `npm run rebuild` writes the binary, and the
+ * package's prebuilds folder, where the published binaries live.
+ */
+function findPrebuild(pkgDir, target) {
+    const binaryName = `keyring.${target}.node`;
+    return [path.join(pkgDir, "src", "keyring"), path.join(pkgDir, "prebuilds")]
+        .map((dir) => path.join(dir, binaryName))
+        .find((file) => fs.existsSync(file));
+}
+
+/* Returns a description of what is wrong, or undefined when the Secrets SDK is
+ * usable. We only load the module - we never call into it, since reading the
+ * credential vault during an install could prompt the user for keychain access.
+ */
+function diagnose(target) {
+    const pkgJsonFile = resolveQuietly(`${SECRETS_PKG}/package.json`);
+
+    if (pkgJsonFile == null) {
+        return {
+            kind: "notInstalled",
+            problem: `${SECRETS_PKG} is not installed.`,
+            cause: "npm omits this optional dependency when its install script fails, which " +
+                "usually means no prebuild shipped for this platform and no Rust toolchain " +
+                "was available to build one."
+        };
+    }
+
+    const pkgDir = path.dirname(pkgJsonFile);
+    const version = readJson(pkgJsonFile).version;
+
+    if (findPrebuild(pkgDir, target) == null) {
+        return {
+            kind: "noPrebuild",
+            problem: `${SECRETS_PKG}@${version} contains no keyring prebuild for ${target}.`,
+            cause: `The keyring loader expects keyring.${target}.node, which is not present ` +
+                "in this installation, so the module has to be built from source here."
+        };
+    }
+
+    try {
+        const { keyring } = require(pkgDir);
+        if (typeof keyring.getPassword !== "function") {
+            return {
+                kind: "noPrebuild",
+                problem: `The keyring prebuild for ${target} loaded but is missing expected functions.`,
+                cause: `${SECRETS_PKG}@${version} looks like a partial or corrupted installation.`
+            };
+        }
+        return undefined;
+    } catch (err) {
+        return {
+            kind: "unloadable",
+            problem: `The keyring prebuild for ${target} is present but could not be loaded.`,
+            cause: `The operating system rejected the native module: ${err.message}`
+        };
+    }
+}
+
+/* The repair steps the user should follow, tailored to what we found. We do not
+ * attempt the repair ourselves: rebuilding a native module needs prerequisites
+ * we cannot install, and re-entering npm from inside a lifecycle script is not
+ * safe.
+ */
+function repairSteps(problem) {
+    const isGlobal = process.env.npm_config_global === "true";
+    const cliVersion = readJson(path.join(process.cwd(), "package.json")).version;
+    const reinstall = isGlobal
+        ? `npm install -g @zowe/cli@${cliVersion} --foreground-scripts`
+        : "npm install --foreground-scripts";
+
+    switch (problem.kind) {
+        case "notInstalled":
+            // We cannot tell why npm skipped the package, so the first step is to
+            // make it say so out loud rather than to guess at a prerequisite.
+            return `To repair:
+
+1. Re-run the Zowe CLI install with --foreground-scripts. That prints the
+   install script output that npm hid the first time:
+
+     ${reinstall}
+
+2. Install whatever that output reports as missing, then repeat Step 1.
+   - A failed Rust/cargo command means the module had to be built from
+     source: install the toolchain from https://rustup.rs
+   - A missing shared library on Linux (e.g. libsecret-1.so.0) means the
+     libsecret runtime is absent: install it with "apt install libsecret-1-0"
+     or "yum install libsecret"`;
+
+        case "noPrebuild":
+            return `To repair:
+
+1. Install the Rust toolchain from https://rustup.rs so the keyring module
+   can be built for this platform.
+
+2. Rebuild the Secrets SDK in place, without reinstalling the CLI:
+
+     npm rebuild ${SECRETS_PKG}
+
+   If that is not an option, reinstall the CLI instead:
+
+     ${reinstall}`;
+
+        default:
+            // The binary is fine; the OS could not satisfy its dependencies. A
+            // rebuild produces the same binary, so do not suggest one.
+            return `To repair:
+
+1. Install the credential storage prerequisites for your platform. On Linux
+   this is the libsecret runtime: "apt install libsecret-1-0" or
+   "yum install libsecret".
+
+2. Re-run the failed Zowe CLI command. No reinstall is needed once the
+   prerequisites are in place.`;
+    }
+}
+
+function printWarning(problem, target) {
+    console.log(`
+Warning: Zowe CLI cannot use secure credential storage
+
+${problem.problem}
+${problem.cause}
+
+Zowe CLI is installed and will run, but it cannot store or read credentials
+securely until this is resolved. Commands that need a stored credential fail
+with "Failed to load Keytar module".
+
+${repairSteps(problem)}
+
+Detected platform: ${target} (node ${process.version})
+Full troubleshooting steps:
+  ${DOC_LINK}
+`);
+}
+
+function validateSecretsPrebuild() {
+    /* Only check an end-user install. A source checkout that has not been built
+     * yet has no lib/main.js and no compiled Secrets SDK either, so checking
+     * there would warn every contributor who runs `npm install` before
+     * `npm run build`. This is the same guard validatePlugins.js uses.
+     */
+    if (!fs.existsSync(path.join(process.cwd(), "lib", "main.js"))) {
+        return;
+    }
+
+    const target = getTargetName();
+    const problem = diagnose(target);
+    if (problem != null) {
+        printWarning(problem, target);
+    }
+}
+
+try {
+    validateSecretsPrebuild();
+} catch (err) {
+    // A diagnostic must never break an install, so swallow anything unexpected.
+    console.log(`Could not verify secure credential storage for Zowe CLI: ${err.message}`);
+}

package/node_modules/dom-serializer/LICENSE

@@ -1,11 +0,0 @@
-License
-
-(The MIT License)
-
-Copyright (c) 2014 The cheeriojs contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/dom-serializer/lib/esm/foreignNames.d.ts

@@ -1,3 +0,0 @@
-export declare const elementNames: Map<string, string>;
-export declare const attributeNames: Map<string, string>;
-//# sourceMappingURL=foreignNames.d.ts.map

package/node_modules/dom-serializer/lib/esm/foreignNames.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"foreignNames.d.ts","sourceRoot":"","sources":["../../src/foreignNames.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,qBAwCxB,CAAC;AACF,eAAO,MAAM,cAAc,qBA8D1B,CAAC"}

package/node_modules/dom-serializer/lib/esm/foreignNames.js

@@ -1,100 +0,0 @@
-export const elementNames = new Map([
-    "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",
-].map((val) => [val.toLowerCase(), val]));
-export const attributeNames = new Map([
-    "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",
-].map((val) => [val.toLowerCase(), val]));

package/node_modules/dom-serializer/lib/esm/index.d.ts

@@ -1,52 +0,0 @@
-import type { AnyNode } from "domhandler";
-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.
-     *
-     * @default xmlMode
-     * @example With <code>selfClosingTags: false</code>: <code>&lt;foo&gt;&lt;/foo&gt;</code>
-     * @example With <code>selfClosingTags: true</code>: <code>&lt;foo /&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 that are either reserved in HTML or XML.
-     *
-     * If `xmlMode` is `true` or the value not `'utf8'`, characters outside of the utf8 range will be encoded as well.
-     *
-     * @default `decodeEntities`
-     */
-    encodeEntities?: boolean | "utf8";
-    /**
-     * Option inherited from parsing; will be used as the default value for `encodeEntities`.
-     *
-     * @default true
-     */
-    decodeEntities?: boolean;
-}
-/**
- * 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 declare function render(node: AnyNode | ArrayLike<AnyNode>, options?: DomSerializerOptions): string;
-export default render;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/dom-serializer/lib/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,OAAO,EAMR,MAAM,YAAY,CAAC;AAWpB,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA4ED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CACpB,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,EAClC,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAUR;AAED,eAAe,MAAM,CAAC"}