cloudstructs 0.12.10 → 0.12.11

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js

@@ -35,7 +35,7 @@ export default class XMLParser {
         orderedObjParser.addExternalEntities(this.externalEntities);
         const orderedResult = orderedObjParser.parseXml(xmlData);
         if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;
-        else return prettify(orderedResult, this.options);
+        else return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
     }
 
     /**
@@ -68,4 +68,4 @@ export default class XMLParser {
     static getMetaDataSymbol() {
         return XmlNode.getMetaDataSymbol();
     }
-}
+}

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/xmlparser/node2json.js

@@ -1,35 +1,65 @@
 'use strict';
 
 import XmlNode from './xmlNode.js';
+import { Matcher } from 'path-expression-matcher';
 
 const METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
 
+/**
+ * Helper function to strip attribute prefix from attribute map
+ * @param {object} attrs - Attributes with prefix (e.g., {"@_class": "code"})
+ * @param {string} prefix - Attribute prefix to remove (e.g., "@_")
+ * @returns {object} Attributes without prefix (e.g., {"class": "code"})
+ */
+function stripAttributePrefix(attrs, prefix) {
+  if (!attrs || typeof attrs !== 'object') return {};
+  if (!prefix) return attrs;
+
+  const rawAttrs = {};
+  for (const key in attrs) {
+    if (key.startsWith(prefix)) {
+      const rawName = key.substring(prefix.length);
+      rawAttrs[rawName] = attrs[key];
+    } else {
+      // Attribute without prefix (shouldn't normally happen, but be safe)
+      rawAttrs[key] = attrs[key];
+    }
+  }
+  return rawAttrs;
+}
+
 /**
  * 
  * @param {array} node 
  * @param {any} options 
+ * @param {Matcher} matcher - Path matcher instance
  * @returns 
  */
-export default function prettify(node, options) {
-  return compress(node, options);
+export default function prettify(node, options, matcher, readonlyMatcher) {
+  return compress(node, options, matcher, readonlyMatcher);
 }
 
 /**
- * 
  * @param {array} arr 
  * @param {object} options 
- * @param {string} jPath 
+ * @param {Matcher} matcher - Path matcher instance
  * @returns object
  */
-function compress(arr, options, jPath) {
+function compress(arr, options, matcher, readonlyMatcher) {
   let text;
   const compressedObj = {}; //This is intended to be a plain object
   for (let i = 0; i < arr.length; i++) {
     const tagObj = arr[i];
     const property = propName(tagObj);
-    let newJpath = "";
-    if (jPath === undefined) newJpath = property;
-    else newJpath = jPath + "." + property;
+
+    // Push current property to matcher WITH RAW ATTRIBUTES (no prefix)
+    if (property !== undefined && property !== options.textNodeName) {
+      const rawAttrs = stripAttributePrefix(
+        tagObj[":@"] || {},
+        options.attributeNamePrefix
+      );
+      matcher.push(property, rawAttrs);
+    }
 
     if (property === options.textNodeName) {
       if (text === undefined) text = tagObj[property];
@@ -38,11 +68,11 @@ function compress(arr, options, jPath) {
       continue;
     } else if (tagObj[property]) {
 
-      let val = compress(tagObj[property], options, newJpath);
+      let val = compress(tagObj[property], options, matcher, readonlyMatcher);
       const isLeaf = isLeafTag(val, options);
 
       if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], newJpath, options);
+        assignAttributes(val, tagObj[":@"], readonlyMatcher, options);
       } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
         val = val[options.textNodeName];
       } else if (Object.keys(val).length === 0) {
@@ -63,12 +93,20 @@ function compress(arr, options, jPath) {
       } else {
         //TODO: if a node is not an array, then check if it should be an array
         //also determine if it is a leaf node
-        if (options.isArray(property, newJpath, isLeaf)) {
+
+        // Pass jPath string or readonlyMatcher based on options.jPath setting
+        const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;
+        if (options.isArray(property, jPathOrMatcher, isLeaf)) {
           compressedObj[property] = [val];
         } else {
           compressedObj[property] = val;
         }
       }
+
+      // Pop property from matcher after processing
+      if (property !== undefined && property !== options.textNodeName) {
+        matcher.pop();
+      }
     }
 
   }
@@ -89,13 +127,25 @@ function propName(obj) {
   }
 }
 
-function assignAttributes(obj, attrMap, jpath, options) {
+function assignAttributes(obj, attrMap, readonlyMatcher, options) {
   if (attrMap) {
     const keys = Object.keys(attrMap);
     const len = keys.length; //don't make it inline
     for (let i = 0; i < len; i++) {
-      const atrrName = keys[i];
-      if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+      const atrrName = keys[i];  // This is the PREFIXED name (e.g., "@_class")
+
+      // Strip prefix for matcher path (for isArray callback)
+      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix)
+        ? atrrName.substring(options.attributeNamePrefix.length)
+        : atrrName;
+
+      // For attributes, we need to create a temporary path
+      // Pass jPath string or matcher based on options.jPath setting
+      const jPathOrMatcher = options.jPath
+        ? readonlyMatcher.toString() + "." + rawAttrName
+        : readonlyMatcher;
+
+      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {
         obj[atrrName] = [attrMap[atrrName]];
       } else {
         obj[atrrName] = attrMap[atrrName];
@@ -120,4 +170,4 @@ function isLeafTag(obj, options) {
   }
 
   return false;
-}
+}

package/node_modules/@aws-sdk/xml-builder/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@aws-sdk/xml-builder",
-  "version": "3.972.11",
+  "version": "3.972.17",
   "description": "XML utilities for the AWS SDK",
   "dependencies": {
-    "@smithy/types": "^4.13.1",
-    "fast-xml-parser": "5.4.1",
+    "@smithy/types": "^4.14.0",
+    "fast-xml-parser": "5.5.8",
     "tslib": "^2.6.2"
   },
   "scripts": {

package/node_modules/@slack/logger/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 12 Mar 2026 15:47:58 GMT
+ * Last updated: Fri, 10 Apr 2026 03:39:58 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@slack/logger/node_modules/@types/node/assert/strict.d.ts

@@ -1,49 +1,3 @@
-/**
- * In strict assertion mode, non-strict methods behave like their corresponding
- * strict methods. For example, `assert.deepEqual()` will behave like
- * `assert.deepStrictEqual()`.
- *
- * In strict assertion mode, error messages for objects display a diff. In legacy
- * assertion mode, error messages for objects display the objects, often truncated.
- *
- * To use strict assertion mode:
- *
- * ```js
- * import { strict as assert } from 'node:assert';
- * ```
- *
- * ```js
- * import assert from 'node:assert/strict';
- * ```
- *
- * Example error diff:
- *
- * ```js
- * import { strict as assert } from 'node:assert';
- *
- * assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
- * // AssertionError: Expected inputs to be strictly deep-equal:
- * // + actual - expected ... Lines skipped
- * //
- * //   [
- * //     [
- * // ...
- * //       2,
- * // +     3
- * // -     '3'
- * //     ],
- * // ...
- * //     5
- * //   ]
- * ```
- *
- * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS`
- * environment variables. This will also deactivate the colors in the REPL. For
- * more on color support in terminal environments, read the tty
- * [`getColorDepth()`](https://nodejs.org/docs/latest-v25.x/api/tty.html#writestreamgetcolordepthenv) documentation.
- * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert/strict.js)
- */
 declare module "node:assert/strict" {
     import {
         Assert,

package/node_modules/@slack/logger/node_modules/@types/node/assert.d.ts

@@ -1,8 +1,3 @@
-/**
- * The `node:assert` module provides a set of assertion functions for verifying
- * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert.js)
- */
 declare module "node:assert" {
     import strict = require("node:assert/strict");
     /**

package/node_modules/@slack/logger/node_modules/@types/node/async_hooks.d.ts

@@ -1,19 +1,3 @@
-/**
- * We strongly discourage the use of the `async_hooks` API.
- * Other APIs that can cover most of its use cases include:
- *
- * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v25.x/api/async_context.html#class-asynclocalstorage) tracks async context
- * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v25.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
- *
- * The `node:async_hooks` module provides an API to track asynchronous resources.
- * It can be accessed using:
- *
- * ```js
- * import async_hooks from 'node:async_hooks';
- * ```
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/async_hooks.js)
- */
 declare module "node:async_hooks" {
     /**
      * ```js
@@ -123,37 +107,31 @@ declare module "node:async_hooks" {
     function triggerAsyncId(): number;
     interface HookCallbacks {
         /**
-         * Called when a class is constructed that has the possibility to emit an asynchronous event.
-         * @param asyncId A unique ID for the async resource
-         * @param type The type of the async resource
-         * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
-         * @param resource Reference to the resource representing the async operation, needs to be released during destroy
+         * The [`init` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#initasyncid-type-triggerasyncid-resource).
          */
         init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
         /**
-         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
-         * The before callback is called just before said callback is executed.
-         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         * The [`before` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#beforeasyncid).
          */
         before?(asyncId: number): void;
         /**
-         * Called immediately after the callback specified in `before` is completed.
-         *
-         * If an uncaught exception occurs during execution of the callback, then `after` will run after the `'uncaughtException'` event is emitted or a `domain`'s handler runs.
-         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         * The [`after` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#afterasyncid).
          */
         after?(asyncId: number): void;
         /**
-         * Called when a promise has resolve() called. This may not be in the same execution id
-         * as the promise itself.
-         * @param asyncId the unique id for the promise that was resolve()d.
+         * The [`promiseResolve` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promiseresolveasyncid).
          */
         promiseResolve?(asyncId: number): void;
         /**
-         * Called after the resource corresponding to asyncId is destroyed
-         * @param asyncId a unique ID for the async resource
+         * The [`destroy` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#destroyasyncid).
          */
         destroy?(asyncId: number): void;
+        /**
+         * Whether the hook should track `Promise`s. Cannot be `false` if
+         * `promiseResolve` is set.
+         * @default true
+         */
+        trackPromises?: boolean | undefined;
     }
     interface AsyncHook {
         /**
@@ -174,7 +152,8 @@ declare module "node:async_hooks" {
      *
      * All callbacks are optional. For example, if only resource cleanup needs to
      * be tracked, then only the `destroy` callback needs to be passed. The
-     * specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
+     * specifics of all functions that can be passed to `callbacks` is in the
+     * [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) section.
      *
      * ```js
      * import { createHook } from 'node:async_hooks';
@@ -202,12 +181,13 @@ declare module "node:async_hooks" {
      * ```
      *
      * Because promises are asynchronous resources whose lifecycle is tracked
-     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
+     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and
+     * `destroy()` callbacks _must not_ be async functions that return promises.
      * @since v8.1.0
-     * @param callbacks The `Hook Callbacks` to register
-     * @return Instance used for disabling and enabling hooks
+     * @param options The [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) to register
+     * @returns Instance used for disabling and enabling hooks
      */
-    function createHook(callbacks: HookCallbacks): AsyncHook;
+    function createHook(options: HookCallbacks): AsyncHook;
     interface AsyncResourceOptions {
         /**
          * The ID of the execution context that created this async event.

package/node_modules/@slack/logger/node_modules/@types/node/buffer.buffer.d.ts

@@ -174,7 +174,7 @@ declare module "node:buffer" {
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
              *
-             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
+             * If `totalLength` is provided, it must be an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
              * truncated to `totalLength`. If the combined length of the `Buffer`s in `list` is
              * less than `totalLength`, the remaining space is filled with zeros.

package/node_modules/@slack/logger/node_modules/@types/node/buffer.d.ts

@@ -1,48 +1,3 @@
-/**
- * `Buffer` objects are used to represent a fixed-length sequence of bytes. Many
- * Node.js APIs support `Buffer`s.
- *
- * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and
- * extends it with methods that cover additional use cases. Node.js APIs accept
- * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well.
- *
- * While the `Buffer` class is available within the global scope, it is still
- * recommended to explicitly reference it via an import or require statement.
- *
- * ```js
- * import { Buffer } from 'node:buffer';
- *
- * // Creates a zero-filled Buffer of length 10.
- * const buf1 = Buffer.alloc(10);
- *
- * // Creates a Buffer of length 10,
- * // filled with bytes which all have the value `1`.
- * const buf2 = Buffer.alloc(10, 1);
- *
- * // Creates an uninitialized buffer of length 10.
- * // This is faster than calling Buffer.alloc() but the returned
- * // Buffer instance might contain old data that needs to be
- * // overwritten using fill(), write(), or other functions that fill the Buffer's
- * // contents.
- * const buf3 = Buffer.allocUnsafe(10);
- *
- * // Creates a Buffer containing the bytes [1, 2, 3].
- * const buf4 = Buffer.from([1, 2, 3]);
- *
- * // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
- * // are all truncated using `(value & 255)` to fit into the range 0–255.
- * const buf5 = Buffer.from([257, 257.5, -255, '1']);
- *
- * // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
- * // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
- * // [116, 195, 169, 115, 116] (in decimal notation)
- * const buf6 = Buffer.from('tést');
- *
- * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
- * const buf7 = Buffer.from('tést', 'latin1');
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/buffer.js)
- */
 declare module "node:buffer" {
     import { ReadableStream } from "node:stream/web";
     /**

package/node_modules/@slack/logger/node_modules/@types/node/child_process.d.ts

@@ -1,70 +1,3 @@
-/**
- * The `node:child_process` module provides the ability to spawn subprocesses in
- * a manner that is similar, but not identical, to [`popen(3)`](http://man7.org/linux/man-pages/man3/popen.3.html). This capability
- * is primarily provided by the {@link spawn} function:
- *
- * ```js
- * import { spawn } from 'node:child_process';
- * import { once } from 'node:events';
- * const ls = spawn('ls', ['-lh', '/usr']);
- *
- * ls.stdout.on('data', (data) => {
- *   console.log(`stdout: ${data}`);
- * });
- *
- * ls.stderr.on('data', (data) => {
- *   console.error(`stderr: ${data}`);
- * });
- *
- * const [code] = await once(ls, 'close');
- * console.log(`child process exited with code ${code}`);
- * ```
- *
- * By default, pipes for `stdin`, `stdout`, and `stderr` are established between
- * the parent Node.js process and the spawned subprocess. These pipes have
- * limited (and platform-specific) capacity. If the subprocess writes to
- * stdout in excess of that limit without the output being captured, the
- * subprocess blocks, waiting for the pipe buffer to accept more data. This is
- * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }` option if the output will not be consumed.
- *
- * The command lookup is performed using the `options.env.PATH` environment
- * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is
- * used. If `options.env` is set without `PATH`, lookup on Unix is performed
- * on a default search path search of `/usr/bin:/bin` (see your operating system's
- * manual for execvpe/execvp), on Windows the current processes environment
- * variable `PATH` is used.
- *
- * On Windows, environment variables are case-insensitive. Node.js
- * lexicographically sorts the `env` keys and uses the first one that
- * case-insensitively matches. Only first (in lexicographic order) entry will be
- * passed to the subprocess. This might lead to issues on Windows when passing
- * objects to the `env` option that have multiple variants of the same key, such as `PATH` and `Path`.
- *
- * The {@link spawn} method spawns the child process asynchronously,
- * without blocking the Node.js event loop. The {@link spawnSync} function provides equivalent functionality in a synchronous manner that blocks
- * the event loop until the spawned process either exits or is terminated.
- *
- * For convenience, the `node:child_process` module provides a handful of
- * synchronous and asynchronous alternatives to {@link spawn} and {@link spawnSync}. Each of these alternatives are implemented on
- * top of {@link spawn} or {@link spawnSync}.
- *
- * * {@link exec}: spawns a shell and runs a command within that
- * shell, passing the `stdout` and `stderr` to a callback function when
- * complete.
- * * {@link execFile}: similar to {@link exec} except
- * that it spawns the command directly without first spawning a shell by
- * default.
- * * {@link fork}: spawns a new Node.js process and invokes a
- * specified module with an IPC communication channel established that allows
- * sending messages between parent and child.
- * * {@link execSync}: a synchronous version of {@link exec} that will block the Node.js event loop.
- * * {@link execFileSync}: a synchronous version of {@link execFile} that will block the Node.js event loop.
- *
- * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
- * the synchronous methods can have significant impact on performance due to
- * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/child_process.js)
- */
 declare module "node:child_process" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dgram from "node:dgram";

package/node_modules/@slack/logger/node_modules/@types/node/cluster.d.ts

@@ -1,57 +1,3 @@
-/**
- * Clusters of Node.js processes can be used to run multiple instances of Node.js
- * that can distribute workloads among their application threads. When process isolation
- * is not needed, use the [`worker_threads`](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html)
- * module instead, which allows running multiple application threads within a single Node.js instance.
- *
- * The cluster module allows easy creation of child processes that all share
- * server ports.
- *
- * ```js
- * import cluster from 'node:cluster';
- * import http from 'node:http';
- * import { availableParallelism } from 'node:os';
- * import process from 'node:process';
- *
- * const numCPUs = availableParallelism();
- *
- * if (cluster.isPrimary) {
- *   console.log(`Primary ${process.pid} is running`);
- *
- *   // Fork workers.
- *   for (let i = 0; i < numCPUs; i++) {
- *     cluster.fork();
- *   }
- *
- *   cluster.on('exit', (worker, code, signal) => {
- *     console.log(`worker ${worker.process.pid} died`);
- *   });
- * } else {
- *   // Workers can share any TCP connection
- *   // In this case it is an HTTP server
- *   http.createServer((req, res) => {
- *     res.writeHead(200);
- *     res.end('hello world\n');
- *   }).listen(8000);
- *
- *   console.log(`Worker ${process.pid} started`);
- * }
- * ```
- *
- * Running Node.js will now share port 8000 between the workers:
- *
- * ```console
- * $ node server.js
- * Primary 3596 is running
- * Worker 4324 started
- * Worker 4520 started
- * Worker 6056 started
- * Worker 5644 started
- * ```
- *
- * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/cluster.js)
- */
 declare module "node:cluster" {
     import * as child_process from "node:child_process";
     import { EventEmitter, InternalEventEmitter } from "node:events";

package/node_modules/@slack/logger/node_modules/@types/node/console.d.ts

@@ -1,61 +1,3 @@
-/**
- * The `node:console` module provides a simple debugging console that is similar to
- * the JavaScript console mechanism provided by web browsers.
- *
- * The module exports two specific components:
- *
- * * A `Console` class with methods such as `console.log()`, `console.error()`, and `console.warn()` that can be used to write to any Node.js stream.
- * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdout) and
- * [`process.stderr`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
- *
- * _**Warning**_: The global console object's methods are neither consistently
- * synchronous like the browser APIs they resemble, nor are they consistently
- * asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v25.x/api/process.html#a-note-on-process-io) for
- * more information.
- *
- * Example using the global `console`:
- *
- * ```js
- * console.log('hello world');
- * // Prints: hello world, to stdout
- * console.log('hello %s', 'world');
- * // Prints: hello world, to stdout
- * console.error(new Error('Whoops, something bad happened'));
- * // Prints error message and stack trace to stderr:
- * //   Error: Whoops, something bad happened
- * //     at [eval]:5:15
- * //     at Script.runInThisContext (node:vm:132:18)
- * //     at Object.runInThisContext (node:vm:309:38)
- * //     at node:internal/process/execution:77:19
- * //     at [eval]-wrapper:6:22
- * //     at evalScript (node:internal/process/execution:76:60)
- * //     at node:internal/main/eval_string:23:3
- *
- * const name = 'Will Robinson';
- * console.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to stderr
- * ```
- *
- * Example using the `Console` class:
- *
- * ```js
- * const out = getStreamSomehow();
- * const err = getStreamSomehow();
- * const myConsole = new console.Console(out, err);
- *
- * myConsole.log('hello world');
- * // Prints: hello world, to out
- * myConsole.log('hello %s', 'world');
- * // Prints: hello world, to out
- * myConsole.error(new Error('Whoops, something bad happened'));
- * // Prints: [Error: Whoops, something bad happened], to err
- *
- * const name = 'Will Robinson';
- * myConsole.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to err
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/console.js)
- */
 declare module "node:console" {
     import { InspectOptions } from "node:util";
     namespace console {

package/node_modules/@slack/logger/node_modules/@types/node/constants.d.ts

@@ -1,9 +1,3 @@
-/**
- * @deprecated The `node:constants` module is deprecated. When requiring access to constants
- * relevant to specific Node.js builtin modules, developers should instead refer
- * to the `constants` property exposed by the relevant module. For instance,
- * `require('node:fs').constants` and `require('node:os').constants`.
- */
 declare module "node:constants" {
     const constants:
         & typeof import("node:os").constants.dlopen

package/node_modules/@slack/logger/node_modules/@types/node/crypto.d.ts

@@ -1,21 +1,3 @@
-/**
- * The `node:crypto` module provides cryptographic functionality that includes a
- * set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
- * functions.
- *
- * ```js
- * const { createHmac } = await import('node:crypto');
- *
- * const secret = 'abcdefg';
- * const hash = createHmac('sha256', secret)
- *                .update('I love cupcakes')
- *                .digest('hex');
- * console.log(hash);
- * // Prints:
- * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/crypto.js)
- */
 declare module "node:crypto" {
     import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";

package/node_modules/@slack/logger/node_modules/@types/node/dgram.d.ts

@@ -1,30 +1,3 @@
-/**
- * The `node:dgram` module provides an implementation of UDP datagram sockets.
- *
- * ```js
- * import dgram from 'node:dgram';
- *
- * const server = dgram.createSocket('udp4');
- *
- * server.on('error', (err) => {
- *   console.error(`server error:\n${err.stack}`);
- *   server.close();
- * });
- *
- * server.on('message', (msg, rinfo) => {
- *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
- * });
- *
- * server.on('listening', () => {
- *   const address = server.address();
- *   console.log(`server listening ${address.address}:${address.port}`);
- * });
- *
- * server.bind(41234);
- * // Prints: server listening 0.0.0.0:41234
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/dgram.js)
- */
 declare module "node:dgram" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";