cdk-ecr-deployment 2.5.5 → 2.5.21

package/node_modules/@types/cacheable-request/node_modules/@types/node/util.d.ts

@@ -1,33 +1,49 @@
 /**
- * The `util` module supports the needs of Node.js internal APIs. Many of the
+ * The `node:util` module supports the needs of Node.js internal APIs. Many of the
  * utilities are useful for application and module developers as well. To access
  * it:
  *
  * ```js
- * const util = require('util');
+ * const util = require('node:util');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/util.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/util.js)
  */
 declare module 'util' {
     import * as types from 'node:util/types';
     export interface InspectOptions {
         /**
-         * If set to `true`, getters are going to be
-         * inspected as well. If set to `'get'` only getters without setter are going
-         * to be inspected. If set to `'set'` only getters having a corresponding
-         * setter are going to be inspected. This might cause side effects depending on
-         * the getter function.
-         * @default `false`
+         * If `true`, object's non-enumerable symbols and properties are included in the formatted result.
+         * `WeakMap` and `WeakSet` entries are also included as well as user defined prototype properties (excluding method properties).
+         * @default false
          */
-        getters?: 'get' | 'set' | boolean | undefined;
         showHidden?: boolean | undefined;
         /**
+         * Specifies the number of times to recurse while formatting object.
+         * This is useful for inspecting large objects.
+         * To recurse up to the maximum call stack size pass `Infinity` or `null`.
          * @default 2
          */
         depth?: number | null | undefined;
+        /**
+         * If `true`, the output is styled with ANSI color codes. Colors are customizable.
+         */
         colors?: boolean | undefined;
+        /**
+         * If `false`, `[util.inspect.custom](depth, opts, inspect)` functions are not invoked.
+         * @default true
+         */
         customInspect?: boolean | undefined;
+        /**
+         * If `true`, `Proxy` inspection includes the target and handler objects.
+         * @default false
+         */
         showProxy?: boolean | undefined;
+        /**
+         * Specifies the maximum number of `Array`, `TypedArray`, `WeakMap`, and `WeakSet` elements
+         * to include when formatting. Set to `null` or `Infinity` to show all elements.
+         * Set to `0` or negative to show no elements.
+         * @default 100
+         */
         maxArrayLength?: number | null | undefined;
         /**
          * Specifies the maximum number of characters to
@@ -36,6 +52,12 @@ declare module 'util' {
          * @default 10000
          */
         maxStringLength?: number | null | undefined;
+        /**
+         * The length at which input values are split across multiple lines.
+         * Set to `Infinity` to format the input as a single line
+         * (in combination with `compact` set to `true` or any number >= `1`).
+         * @default 80
+         */
         breakLength?: number | undefined;
         /**
          * Setting this to `false` causes each object key
@@ -45,13 +67,33 @@ declare module 'util' {
          * `breakLength`. Short array elements are also grouped together. Note that no
          * text will be reduced below 16 characters, no matter the `breakLength` size.
          * For more information, see the example below.
-         * @default `true`
+         * @default true
          */
         compact?: boolean | number | undefined;
+        /**
+         * If set to `true` or a function, all properties of an object, and `Set` and `Map`
+         * entries are sorted in the resulting string.
+         * If set to `true` the default sort is used.
+         * If set to a function, it is used as a compare function.
+         */
         sorted?: boolean | ((a: string, b: string) => number) | undefined;
+        /**
+         * If set to `true`, getters are going to be
+         * inspected as well. If set to `'get'` only getters without setter are going
+         * to be inspected. If set to `'set'` only getters having a corresponding
+         * setter are going to be inspected. This might cause side effects depending on
+         * the getter function.
+         * @default false
+         */
+        getters?: 'get' | 'set' | boolean | undefined;
+        /**
+         * If set to `true`, an underscore is used to separate every three digits in all bigints and numbers.
+         * @default false
+         */
+        numericSeparator?: boolean | undefined;
     }
     export type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
-    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => string;
+    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => any; // TODO: , inspect: inspect
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
@@ -147,7 +189,7 @@ declare module 'util' {
      * timestamp.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.log('Timestamped message.');
      * ```
@@ -162,6 +204,52 @@ declare module 'util' {
      * @since v16.8.0, v14.18.0
      */
     export function toUSVString(string: string): string;
+    /**
+     * Creates and returns an `AbortController` instance whose `AbortSignal` is marked
+     * as transferable and can be used with `structuredClone()` or `postMessage()`.
+     * @since v18.11.0
+     * @experimental
+     * @returns A transferable AbortController
+     */
+    export function transferableAbortController(): AbortController;
+    /**
+     * Marks the given `AbortSignal` as transferable so that it can be used with`structuredClone()` and `postMessage()`.
+     *
+     * ```js
+     * const signal = transferableAbortSignal(AbortSignal.timeout(100));
+     * const channel = new MessageChannel();
+     * channel.port2.postMessage(signal, [signal]);
+     * ```
+     * @since v18.11.0
+     * @experimental
+     * @param signal The AbortSignal
+     * @returns The same AbortSignal
+     */
+    export function transferableAbortSignal(signal: AbortSignal): AbortSignal;
+    /**
+     * Listens to abort event on the provided `signal` and
+     * returns a promise that is fulfilled when the `signal` is
+     * aborted. If the passed `resource` is garbage collected before the `signal` is
+     * aborted, the returned promise shall remain pending indefinitely.
+     *
+     * ```js
+     * import { aborted } from 'node:util';
+     *
+     * const dependent = obtainSomethingAbortable();
+     *
+     * aborted(dependent.signal, dependent).then(() => {
+     *   // Do something when dependent is aborted.
+     * });
+     *
+     * dependent.on('event', () => {
+     *   dependent.abort();
+     * });
+     * ```
+     * @since v19.7.0
+     * @experimental
+     * @param resource Any non-null entity, reference to which is held weakly.
+     */
+    export function aborted(signal: AbortSignal, resource: any): Promise<void>;
     /**
      * The `util.inspect()` method returns a string representation of `object` that is
      * intended for debugging. The output of `util.inspect` may change at any time
@@ -188,7 +276,7 @@ declare module 'util' {
      * Circular references point to their anchor by using a reference index:
      *
      * ```js
-     * const { inspect } = require('util');
+     * const { inspect } = require('node:util');
      *
      * const obj = {};
      * obj.a = [obj];
@@ -206,7 +294,7 @@ declare module 'util' {
      * The following example inspects all properties of the `util` object:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * console.log(util.inspect(util, { showHidden: true, depth: null }));
      * ```
@@ -214,7 +302,7 @@ declare module 'util' {
      * The following example highlights the effect of the `compact` option:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const o = {
      *   a: [1, 2, [[
@@ -222,7 +310,7 @@ declare module 'util' {
      *       'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
      *     'test',
      *     'foo']], 4],
-     *   b: new Map([['za', 1], ['zb', 'test']])
+     *   b: new Map([['za', 1], ['zb', 'test']]),
      * };
      * console.log(util.inspect(o, { compact: true, depth: 5, breakLength: 80 }));
      *
@@ -271,7 +359,7 @@ declare module 'util' {
      * with no remaining strong references may be garbage collected at any time.
      *
      * ```js
-     * const { inspect } = require('util');
+     * const { inspect } = require('node:util');
      *
      * const obj = { a: 1 };
      * const obj2 = { b: 2 };
@@ -285,13 +373,13 @@ declare module 'util' {
      * impact the result of `util.inspect()`.
      *
      * ```js
-     * const { inspect } = require('util');
-     * const assert = require('assert');
+     * const { inspect } = require('node:util');
+     * const assert = require('node:assert');
      *
      * const o1 = {
      *   b: [2, 3, 1],
      *   a: '`a` comes before `b`',
-     *   c: new Set([2, 3, 1])
+     *   c: new Set([2, 3, 1]),
      * };
      * console.log(inspect(o1, { sorted: true }));
      * // { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
@@ -301,16 +389,31 @@ declare module 'util' {
      * const o2 = {
      *   c: new Set([2, 1, 3]),
      *   a: '`a` comes before `b`',
-     *   b: [2, 3, 1]
+     *   b: [2, 3, 1],
      * };
      * assert.strict.equal(
      *   inspect(o1, { sorted: true }),
-     *   inspect(o2, { sorted: true })
+     *   inspect(o2, { sorted: true }),
      * );
      * ```
      *
+     * The `numericSeparator` option adds an underscore every three digits to all
+     * numbers.
+     *
+     * ```js
+     * const { inspect } = require('node:util');
+     *
+     * const thousand = 1_000;
+     * const million = 1_000_000;
+     * const bigNumber = 123_456_789n;
+     * const bigDecimal = 1_234.123_45;
+     *
+     * console.log(thousand, million, bigNumber, bigDecimal);
+     * // 1_000 1_000_000 123_456_789n 1_234.123_45
+     * ```
+     *
      * `util.inspect()` is a synchronous method intended for debugging. Its maximum
-     * output length is approximately 128 MB. Inputs that result in longer output will
+     * output length is approximately 128 MiB. Inputs that result in longer output will
      * be truncated.
      * @since v0.3.0
      * @param object Any JavaScript primitive or `Object`.
@@ -339,7 +442,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is an `Array`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isArray([]);
      * // Returns: true
@@ -356,7 +459,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `RegExp`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isRegExp(/some regexp/);
      * // Returns: true
@@ -373,7 +476,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Date`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isDate(new Date());
      * // Returns: true
@@ -390,7 +493,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is an `Error`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isError(new Error());
      * // Returns: true
@@ -404,7 +507,7 @@ declare module 'util' {
      * possible to obtain an incorrect result when the `object` argument manipulates`@@toStringTag`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const obj = { name: 'Error', message: 'an error occurred' };
      *
      * util.isError(obj);
@@ -429,8 +532,8 @@ declare module 'util' {
      * through the `constructor.super_` property.
      *
      * ```js
-     * const util = require('util');
-     * const EventEmitter = require('events');
+     * const util = require('node:util');
+     * const EventEmitter = require('node:events');
      *
      * function MyStream() {
      *   EventEmitter.call(this);
@@ -456,7 +559,7 @@ declare module 'util' {
      * ES6 example using `class` and `extends`:
      *
      * ```js
-     * const EventEmitter = require('events');
+     * const EventEmitter = require('node:events');
      *
      * class MyStream extends EventEmitter {
      *   write(data) {
@@ -472,7 +575,7 @@ declare module 'util' {
      * stream.write('With ES6');
      * ```
      * @since v0.3.0
-     * @deprecated Legacy: Use ES2015 class syntax and `extends` keyword instead.
+     * @legacy Use ES2015 class syntax and `extends` keyword instead.
      */
     export function inherits(constructor: unknown, superConstructor: unknown): void;
     export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
@@ -485,7 +588,7 @@ declare module 'util' {
      * environment variable, then the returned function operates similar to `console.error()`. If not, then the returned function is a no-op.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const debuglog = util.debuglog('foo');
      *
      * debuglog('hello from foo [%d]', 123);
@@ -504,7 +607,7 @@ declare module 'util' {
      * The `section` supports wildcard also:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * const debuglog = util.debuglog('foo-bar');
      *
      * debuglog('hi there, it\'s foo-bar [%d]', 2333);
@@ -524,7 +627,7 @@ declare module 'util' {
      * unnecessary wrapping.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      * let debuglog = util.debuglog('internals', (debug) => {
      *   // Replace with a logging function that optimizes out
      *   // testing if the section is enabled
@@ -542,7 +645,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isBoolean(1);
      * // Returns: false
@@ -559,7 +662,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Buffer`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isBuffer({ length: 0 });
      * // Returns: false
@@ -576,7 +679,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Function`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * function Foo() {}
      * const Bar = () => {};
@@ -596,7 +699,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is strictly `null`. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNull(0);
      * // Returns: false
@@ -614,7 +717,7 @@ declare module 'util' {
      * returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNullOrUndefined(0);
      * // Returns: false
@@ -631,7 +734,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isNumber(false);
      * // Returns: false
@@ -651,7 +754,7 @@ declare module 'util' {
      * Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isObject(5);
      * // Returns: false
@@ -663,14 +766,14 @@ declare module 'util' {
      * // Returns: false
      * ```
      * @since v0.11.5
-     * @deprecated Since v4.0.0 - Deprecated: Use `value !== null && typeof value === 'object'` instead.
+     * @deprecated Since v4.0.0 - Use `value !== null && typeof value === 'object'` instead.
      */
     export function isObject(object: unknown): boolean;
     /**
      * Returns `true` if the given `object` is a primitive type. Otherwise, returns`false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isPrimitive(5);
      * // Returns: true
@@ -699,7 +802,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `string`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isString('');
      * // Returns: true
@@ -718,7 +821,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is a `Symbol`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * util.isSymbol(5);
      * // Returns: false
@@ -735,7 +838,7 @@ declare module 'util' {
      * Returns `true` if the given `object` is `undefined`. Otherwise, returns `false`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const foo = undefined;
      * util.isUndefined(5);
@@ -754,7 +857,7 @@ declare module 'util' {
      * such a way that it is marked as deprecated.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * exports.obsoleteFunction = util.deprecate(() => {
      *   // Do something here.
@@ -770,7 +873,7 @@ declare module 'util' {
      * the warning will be emitted only once for that `code`.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
      * const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
@@ -824,7 +927,7 @@ declare module 'util' {
      * first argument will be the rejection reason (or `null` if the `Promise`resolved), and the second argument will be the resolved value.
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * async function fn() {
      *   return 'hello world';
@@ -859,11 +962,11 @@ declare module 'util' {
      * callbackFunction((err, ret) => {
      *   // When the Promise was rejected with `null` it is wrapped with an Error and
      *   // the original value is stored in `reason`.
-     *   err &#x26;&#x26; err.hasOwnProperty('reason') &#x26;&#x26; err.reason === null;  // true
+     *   err &#x26;&#x26; Object.hasOwn(err, 'reason') &#x26;&#x26; err.reason === null;  // true
      * });
      * ```
      * @since v8.2.0
-     * @param original An `async` function
+     * @param fn An `async` function
      * @return a callback style function
      */
     export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
@@ -907,8 +1010,8 @@ declare module 'util' {
      * that returns promises.
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * const util = require('node:util');
+     * const fs = require('node:fs');
      *
      * const stat = util.promisify(fs.stat);
      * stat('.').then((stats) => {
@@ -921,8 +1024,8 @@ declare module 'util' {
      * Or, equivalently using `async function`s:
      *
      * ```js
-     * const util = require('util');
-     * const fs = require('fs');
+     * const util = require('node:util');
+     * const fs = require('node:fs');
      *
      * const stat = util.promisify(fs.stat);
      *
@@ -943,7 +1046,7 @@ declare module 'util' {
      * work as expected unless handled specially:
      *
      * ```js
-     * const util = require('util');
+     * const util = require('node:util');
      *
      * class Foo {
      *   constructor() {
@@ -998,13 +1101,9 @@ declare module 'util' {
      * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextDecoder` API.
      *
      * ```js
-     * const decoder = new TextDecoder('shift_jis');
-     * let string = '';
-     * let buffer;
-     * while (buffer = getNextChunkSomehow()) {
-     *   string += decoder.decode(buffer, { stream: true });
-     * }
-     * string += decoder.decode(); // end-of-stream
+     * const decoder = new TextDecoder();
+     * const u8arr = new Uint8Array([72, 101, 108, 108, 111]);
+     * console.log(decoder.decode(u8arr)); // Hello
      * ```
      * @since v8.3.0
      */
@@ -1036,7 +1135,7 @@ declare module 'util' {
          * internally and emitted after the next call to `textDecoder.decode()`.
          *
          * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a`TypeError` being thrown.
-         * @param input An `ArrayBuffer`, `DataView` or `TypedArray` instance containing the encoded data.
+         * @param input An `ArrayBuffer`, `DataView`, or `TypedArray` instance containing the encoded data.
          */
         decode(
             input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
@@ -1056,6 +1155,8 @@ declare module 'util' {
         written: number;
     }
     export { types };
+
+    //// TextEncoder/Decoder
     /**
      * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextEncoder` API. All
      * instances of `TextEncoder` only support UTF-8 encoding.
@@ -1094,6 +1195,335 @@ declare module 'util' {
          */
         encodeInto(src: string, dest: Uint8Array): EncodeIntoResult;
     }
+    import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'util';
+    global {
+        /**
+         * `TextDecoder` class is a global reference for `require('util').TextDecoder`
+         * https://nodejs.org/api/globals.html#textdecoder
+         * @since v11.0.0
+         */
+        var TextDecoder: typeof globalThis extends {
+            onmessage: any;
+            TextDecoder: infer TextDecoder;
+        }
+            ? TextDecoder
+            : typeof _TextDecoder;
+        /**
+         * `TextEncoder` class is a global reference for `require('util').TextEncoder`
+         * https://nodejs.org/api/globals.html#textencoder
+         * @since v11.0.0
+         */
+        var TextEncoder: typeof globalThis extends {
+            onmessage: any;
+            TextEncoder: infer TextEncoder;
+        }
+            ? TextEncoder
+            : typeof _TextEncoder;
+    }
+
+    //// parseArgs
+    /**
+     * Provides a higher level API for command-line argument parsing than interacting
+     * with `process.argv` directly. Takes a specification for the expected arguments
+     * and returns a structured object with the parsed options and positionals.
+     *
+     * ```js
+     * import { parseArgs } from 'node:util';
+     * const args = ['-f', '--bar', 'b'];
+     * const options = {
+     *   foo: {
+     *     type: 'boolean',
+     *     short: 'f',
+     *   },
+     *   bar: {
+     *     type: 'string',
+     *   },
+     * };
+     * const {
+     *   values,
+     *   positionals,
+     * } = parseArgs({ args, options });
+     * console.log(values, positionals);
+     * // Prints: [Object: null prototype] { foo: true, bar: 'b' } []
+     * ```
+     * @since v18.3.0, v16.17.0
+     * @param config Used to provide arguments for parsing and to configure the parser. `config` supports the following properties:
+     * @return The parsed command line arguments:
+     */
+    export function parseArgs<T extends ParseArgsConfig>(config?: T): ParsedResults<T>;
+    interface ParseArgsOptionConfig {
+        /**
+         * Type of argument.
+         */
+        type: 'string' | 'boolean';
+        /**
+         * Whether this option can be provided multiple times.
+         * If `true`, all values will be collected in an array.
+         * If `false`, values for the option are last-wins.
+         * @default false.
+         */
+        multiple?: boolean | undefined;
+        /**
+         * A single character alias for the option.
+         */
+        short?: string | undefined;
+        /**
+         * The default option value when it is not set by args.
+         * It must be of the same type as the the `type` property.
+         * When `multiple` is `true`, it must be an array.
+         * @since v18.11.0
+         */
+        default?: string | boolean | string[] | boolean[] | undefined;
+    }
+    interface ParseArgsOptionsConfig {
+        [longOption: string]: ParseArgsOptionConfig;
+    }
+    export interface ParseArgsConfig {
+        /**
+         * Array of argument strings.
+         */
+        args?: string[] | undefined;
+        /**
+         * Used to describe arguments known to the parser.
+         */
+        options?: ParseArgsOptionsConfig | undefined;
+        /**
+         * Should an error be thrown when unknown arguments are encountered,
+         * or when arguments are passed that do not match the `type` configured in `options`.
+         * @default true
+         */
+        strict?: boolean | undefined;
+        /**
+         * Whether this command accepts positional arguments.
+         */
+        allowPositionals?: boolean | undefined;
+        /**
+         * Return the parsed tokens. This is useful for extending the built-in behavior,
+         * from adding additional checks through to reprocessing the tokens in different ways.
+         * @default false
+         */
+        tokens?: boolean | undefined;
+    }
+    /*
+    IfDefaultsTrue and IfDefaultsFalse are helpers to handle default values for missing boolean properties.
+    TypeScript does not have exact types for objects: https://github.com/microsoft/TypeScript/issues/12936
+    This means it is impossible to distinguish between "field X is definitely not present" and "field X may or may not be present".
+    But we expect users to generally provide their config inline or `as const`, which means TS will always know whether a given field is present.
+    So this helper treats "not definitely present" (i.e., not `extends boolean`) as being "definitely not present", i.e. it should have its default value.
+    This is technically incorrect but is a much nicer UX for the common case.
+    The IfDefaultsTrue version is for things which default to true; the IfDefaultsFalse version is for things which default to false.
+    */
+    type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true
+        ? IfTrue
+        : T extends false
+        ? IfFalse
+        : IfTrue;
+
+    // we put the `extends false` condition first here because `undefined` compares like `any` when `strictNullChecks: false`
+    type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false
+        ? IfFalse
+        : T extends true
+        ? IfTrue
+        : IfFalse;
+
+    type ExtractOptionValue<T extends ParseArgsConfig, O extends ParseArgsOptionConfig> = IfDefaultsTrue<
+        T['strict'],
+        O['type'] extends 'string' ? string : O['type'] extends 'boolean' ? boolean : string | boolean,
+        string | boolean
+    >;
+
+    type ParsedValues<T extends ParseArgsConfig> =
+        & IfDefaultsTrue<T['strict'], unknown, { [longOption: string]: undefined | string | boolean }>
+        & (T['options'] extends ParseArgsOptionsConfig
+            ? {
+                -readonly [LongOption in keyof T['options']]: IfDefaultsFalse<
+                    T['options'][LongOption]['multiple'],
+                    undefined | Array<ExtractOptionValue<T, T['options'][LongOption]>>,
+                    undefined | ExtractOptionValue<T, T['options'][LongOption]>
+                >;
+            }
+            : {});
+
+    type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<
+        T['strict'],
+        IfDefaultsFalse<T['allowPositionals'], string[], []>,
+        IfDefaultsTrue<T['allowPositionals'], string[], []>
+    >;
+
+    type PreciseTokenForOptions<
+        K extends string,
+        O extends ParseArgsOptionConfig,
+    > = O['type'] extends 'string'
+        ? {
+              kind: 'option';
+              index: number;
+              name: K;
+              rawName: string;
+              value: string;
+              inlineValue: boolean;
+          }
+        : O['type'] extends 'boolean'
+        ? {
+              kind: 'option';
+              index: number;
+              name: K;
+              rawName: string;
+              value: undefined;
+              inlineValue: undefined;
+          }
+        : OptionToken & { name: K };
+
+    type TokenForOptions<
+        T extends ParseArgsConfig,
+        K extends keyof T['options'] = keyof T['options'],
+    > = K extends unknown
+        ? T['options'] extends ParseArgsOptionsConfig
+            ? PreciseTokenForOptions<K & string, T['options'][K]>
+            : OptionToken
+        : never;
+
+    type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<T['strict'], TokenForOptions<T>, OptionToken>;
+
+    type ParsedPositionalToken<T extends ParseArgsConfig> = IfDefaultsTrue<
+        T['strict'],
+        IfDefaultsFalse<T['allowPositionals'], { kind: 'positional'; index: number; value: string }, never>,
+        IfDefaultsTrue<T['allowPositionals'], { kind: 'positional'; index: number; value: string }, never>
+    >;
+
+    type ParsedTokens<T extends ParseArgsConfig> = Array<
+        ParsedOptionToken<T> | ParsedPositionalToken<T> | { kind: 'option-terminator'; index: number }
+    >;
+
+    type PreciseParsedResults<T extends ParseArgsConfig> = IfDefaultsFalse<
+        T['tokens'],
+        {
+            values: ParsedValues<T>;
+            positionals: ParsedPositionals<T>;
+            tokens: ParsedTokens<T>;
+        },
+        {
+            values: ParsedValues<T>;
+            positionals: ParsedPositionals<T>;
+        }
+    >;
+
+    type OptionToken =
+        | { kind: 'option'; index: number; name: string; rawName: string; value: string; inlineValue: boolean }
+        | {
+              kind: 'option';
+              index: number;
+              name: string;
+              rawName: string;
+              value: undefined;
+              inlineValue: undefined;
+          };
+
+    type Token =
+        | OptionToken
+        | { kind: 'positional'; index: number; value: string }
+        | { kind: 'option-terminator'; index: number };
+
+    // If ParseArgsConfig extends T, then the user passed config constructed elsewhere.
+    // So we can't rely on the `"not definitely present" implies "definitely not present"` assumption mentioned above.
+    type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T
+        ? {
+              values: {
+                  [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+              };
+              positionals: string[];
+              tokens?: Token[];
+          }
+        : PreciseParsedResults<T>;
+
+    /**
+     * An implementation of [the MIMEType class](https://bmeck.github.io/node-proposal-mime-api/).
+     *
+     * In accordance with browser conventions, all properties of `MIMEType` objects
+     * are implemented as getters and setters on the class prototype, rather than as
+     * data properties on the object itself.
+     *
+     * A MIME string is a structured string containing multiple meaningful
+     * components. When parsed, a `MIMEType` object is returned containing
+     * properties for each of these components.
+     * @since v19.1.0, v18.13.0
+     * @experimental
+     */
+    export class MIMEType {
+        /**
+         * Creates a new MIMEType object by parsing the input.
+         *
+         * A `TypeError` will be thrown if the `input` is not a valid MIME.
+         * Note that an effort will be made to coerce the given values into strings.
+         * @param input The input MIME to parse.
+         */
+        constructor(input: string | { toString: () => string });
+
+        /**
+         * Gets and sets the type portion of the MIME.
+         */
+        type: string;
+        /**
+         * Gets and sets the subtype portion of the MIME.
+         */
+        subtype: string;
+        /**
+         * Gets the essence of the MIME.
+         *
+         * Use `mime.type` or `mime.subtype` to alter the MIME.
+         */
+        readonly essence: string;
+        /**
+         * Gets the `MIMEParams` object representing the parameters of the MIME.
+         */
+        readonly params: MIMEParams;
+        /**
+         * Returns the serialized MIME.
+         *
+         * Because of the need for standard compliance, this method
+         * does not allow users to customize the serialization process of the MIME.
+         */
+        toString(): string;
+    }
+    /**
+     * @since v18.13.0
+     */
+    export class MIMEParams {
+        /**
+         * Remove all name-value pairs whose name is `name`.
+         */
+        delete(name: string): void;
+        /**
+         * Returns an iterator over each of the name-value pairs in the parameters.
+         */
+        entries(): IterableIterator<[name: string, value: string]>;
+        /**
+         * Returns the value of the first name-value pair whose name is `name`.
+         * If there are no such pairs, `null` is returned.
+         */
+        get(name: string): string | null;
+        /**
+         * Returns `true` if there is at least one name-value pair whose name is `name`.
+         */
+        has(name: string): boolean;
+        /**
+         * Returns an iterator over the names of each name-value pair.
+         */
+        keys(): IterableIterator<string>;
+        /**
+         * Sets the value in the `MIMEParams` object associated with `name` to `value`.
+         * If there are any pre-existing name-value pairs whose names are `name`,
+         * set the first such pair's value to `value`.
+         */
+        set(name: string, value: string): void;
+        /**
+         * Returns an iterator over the values of each name-value pair.
+         */
+        values(): IterableIterator<string>;
+        /**
+         * Returns an iterator over each of the name-value pairs in the parameters.
+         */
+        [Symbol.iterator]: typeof MIMEParams.prototype.entries;
+    }
 }
 declare module 'util/types' {
     export * from 'util/types';
@@ -1391,12 +1821,40 @@ declare module 'util/types' {
      */
     function isModuleNamespaceObject(value: unknown): boolean;
     /**
-     * Returns `true` if the value is an instance of a built-in `Error` type.
+     * Returns `true` if the value was returned by the constructor of a [built-in `Error` type](https://tc39.es/ecma262/#sec-error-objects).
+     *
+     * ```js
+     * console.log(util.types.isNativeError(new Error()));  // true
+     * console.log(util.types.isNativeError(new TypeError()));  // true
+     * console.log(util.types.isNativeError(new RangeError()));  // true
+     * ```
+     *
+     * Subclasses of the native error types are also native errors:
+     *
+     * ```js
+     * class MyError extends Error {}
+     * console.log(util.types.isNativeError(new MyError()));  // true
+     * ```
+     *
+     * A value being `instanceof` a native error class is not equivalent to `isNativeError()`returning `true` for that value. `isNativeError()` returns `true` for errors
+     * which come from a different [realm](https://tc39.es/ecma262/#realm) while `instanceof Error` returns `false`for these errors:
+     *
+     * ```js
+     * const vm = require('node:vm');
+     * const context = vm.createContext({});
+     * const myError = vm.runInContext('new Error()', context);
+     * console.log(util.types.isNativeError(myError)); // true
+     * console.log(myError instanceof Error); // false
+     * ```
+     *
+     * Conversely, `isNativeError()` returns `false` for all objects which were not
+     * returned by the constructor of a native error. That includes values
+     * which are `instanceof` native errors:
      *
      * ```js
-     * util.types.isNativeError(new Error());  // Returns true
-     * util.types.isNativeError(new TypeError());  // Returns true
-     * util.types.isNativeError(new RangeError());  // Returns true
+     * const myError = { __proto__: Error.prototype };
+     * console.log(util.types.isNativeError(myError)); // false
+     * console.log(myError instanceof Error); // true
      * ```
      * @since v10.0.0
      */