@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

package/node_modules/@types/node/module.d.ts

@@ -1,4 +1,7 @@
-declare module "node:module" {
+/**
+ * @since v0.3.7
+ */
+declare module "module" {
     import { URL } from "node:url";
     class Module {
         constructor(id: string, parent?: Module);
@@ -27,7 +30,7 @@ declare module "node:module" {
             /**
              * The following constants are returned as the `status` field in the object returned by
              * {@link enableCompileCache} to indicate the result of the attempt to enable the
-             * [module compile cache](https://nodejs.org/docs/latest-v26.x/api/module.html#module-compile-cache).
+             * [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache).
              * @since v22.8.0
              */
             namespace compileCacheStatus {
@@ -59,24 +62,6 @@ declare module "node:module" {
                 const DISABLED: number;
             }
         }
-        interface EnableCompileCacheOptions {
-            /**
-             * Optional. Directory to store the compile cache. If not specified,
-             * the directory specified by the `NODE_COMPILE_CACHE=dir` environment variable
-             * will be used if it's set, or `path.join(os.tmpdir(), 'node-compile-cache')`
-             * otherwise.
-             * @since v25.0.0
-             */
-            directory?: string | undefined;
-            /**
-             * Optional. If `true`, enables portable compile cache so that
-             * the cache can be reused even if the project directory is moved. This is a best-effort
-             * feature. If not specified, it will depend on whether the environment variable
-             * `NODE_COMPILE_CACHE_PORTABLE=1` is set.
-             * @since v25.0.0
-             */
-            portable?: boolean | undefined;
-        }
         interface EnableCompileCacheResult {
             /**
              * One of the {@link constants.compileCacheStatus}
@@ -96,21 +81,25 @@ declare module "node:module" {
             directory?: string;
         }
         /**
-         * Enable [module compile cache](https://nodejs.org/docs/latest-v26.x/api/module.html#module-compile-cache)
+         * Enable [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
          * in the current Node.js instance.
          *
-         * For general use cases, it's recommended to call `module.enableCompileCache()` without
-         * specifying the `options.directory`, so that the directory can be overridden by the
-         * `NODE_COMPILE_CACHE` environment variable when necessary.
+         * If `cacheDir` is not specified, Node.js will either use the directory specified by the
+         * `NODE_COMPILE_CACHE=dir` environment variable if it's set, or use
+         * `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. For general use cases, it's
+         * recommended to call `module.enableCompileCache()` without specifying the `cacheDir`,
+         * so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
+         * variable when necessary.
          *
-         * Since compile cache is supposed to be a optimization that is not mission critical, this
-         * method is designed to not throw any exception when the compile cache cannot be enabled.
-         * Instead, it will return an object containing an error message in the `message` field to
-         * aid debugging. If compile cache is enabled successfully, the `directory` field in the
-         * returned object contains the path to the directory where the compile cache is stored. The
-         * `status` field in the returned object would be one of the `module.constants.compileCacheStatus`
+         * Since compile cache is supposed to be a quiet optimization that is not required for the
+         * application to be functional, this method is designed to not throw any exception when the
+         * compile cache cannot be enabled. Instead, it will return an object containing an error
+         * message in the `message` field to aid debugging.
+         * If compile cache is enabled successfully, the `directory` field in the returned object
+         * contains the path to the directory where the compile cache is stored. The `status`
+         * field in the returned object would be one of the `module.constants.compileCacheStatus`
          * values to indicate the result of the attempt to enable the
-         * [module compile cache](https://nodejs.org/docs/latest-v26.x/api/module.html#module-compile-cache).
+         * [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache).
          *
          * This method only affects the current Node.js instance. To enable it in child worker threads,
          * either call this method in child worker threads too, or set the
@@ -118,11 +107,12 @@ declare module "node:module" {
          * be inherited into the child workers. The directory can be obtained either from the
          * `directory` field returned by this method, or with {@link getCompileCacheDir}.
          * @since v22.8.0
-         * @param options Optional. If a string is passed, it is considered to be `options.directory`.
+         * @param cacheDir Optional path to specify the directory where the compile cache
+         * will be stored/retrieved.
          */
-        function enableCompileCache(options?: string | EnableCompileCacheOptions): EnableCompileCacheResult;
+        function enableCompileCache(cacheDir?: string): EnableCompileCacheResult;
         /**
-         * Flush the [module compile cache](https://nodejs.org/docs/latest-v26.x/api/module.html#module-compile-cache)
+         * Flush the [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
          * accumulated from modules already loaded
          * in the current Node.js instance to disk. This returns after all the flushing
          * file system operations come to an end, no matter they succeed or not. If there
@@ -133,7 +123,7 @@ declare module "node:module" {
         function flushCompileCache(): void;
         /**
          * @since v22.8.0
-         * @return Path to the [module compile cache](https://nodejs.org/docs/latest-v26.x/api/module.html#module-compile-cache)
+         * @return Path to the [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
          * directory if it is enabled, or `undefined` otherwise.
          */
         function getCompileCacheDir(): string | undefined;
@@ -204,7 +194,7 @@ declare module "node:module" {
              */
             data?: Data | undefined;
             /**
-             * [Transferable objects](https://nodejs.org/docs/latest-v26.x/api/worker_threads.html#portpostmessagevalue-transferlist)
+             * [Transferable objects](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html#portpostmessagevalue-transferlist)
              * to be passed into the `initialize` hook.
              */
             transferList?: any[] | undefined;
@@ -213,12 +203,11 @@ declare module "node:module" {
         /**
          * Register a module that exports hooks that customize Node.js module
          * resolution and loading behavior. See
-         * [Customization hooks](https://nodejs.org/docs/latest-v26.x/api/module.html#customization-hooks).
+         * [Customization hooks](https://nodejs.org/docs/latest-v22.x/api/module.html#customization-hooks).
          *
          * This feature requires `--allow-worker` if used with the
-         * [Permission Model](https://nodejs.org/docs/latest-v26.x/api/permissions.html#permission-model).
+         * [Permission Model](https://nodejs.org/docs/latest-v22.x/api/permissions.html#permission-model).
          * @since v20.6.0, v18.19.0
-         * @deprecated Use `module.registerHooks()` instead.
          * @param specifier Customization hooks to be registered; this should be
          * the same string that would be passed to `import()`, except that if it is
          * relative, it is resolved relative to `parentURL`.
@@ -233,12 +222,12 @@ declare module "node:module" {
         function register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
         interface RegisterHooksOptions {
             /**
-             * See [load hook](https://nodejs.org/docs/latest-v26.x/api/module.html#loadurl-context-nextload).
+             * See [load hook](https://nodejs.org/docs/latest-v22.x/api/module.html#loadurl-context-nextload).
              * @default undefined
              */
             load?: LoadHookSync | undefined;
             /**
-             * See [resolve hook](https://nodejs.org/docs/latest-v26.x/api/module.html#resolvespecifier-context-nextresolve).
+             * See [resolve hook](https://nodejs.org/docs/latest-v22.x/api/module.html#resolvespecifier-context-nextresolve).
              * @default undefined
              */
             resolve?: ResolveHookSync | undefined;
@@ -250,7 +239,7 @@ declare module "node:module" {
             deregister(): void;
         }
         /**
-         * Register [hooks](https://nodejs.org/docs/latest-v26.x/api/module.html#customization-hooks)
+         * Register [hooks](https://nodejs.org/docs/latest-v22.x/api/module.html#customization-hooks)
          * that customize Node.js module resolution and loading behavior.
          * @since v22.15.0
          * @experimental
@@ -260,9 +249,16 @@ declare module "node:module" {
             /**
              * Possible values are:
              * * `'strip'` Only strip type annotations without performing the transformation of TypeScript features.
+             * * `'transform'` Strip type annotations and transform TypeScript features to JavaScript.
              * @default 'strip'
              */
-            mode?: "strip" | undefined;
+            mode?: "strip" | "transform" | undefined;
+            /**
+             * Only when `mode` is `'transform'`, if `true`, a source map
+             * will be generated for the transformed code.
+             * @default false
+             */
+            sourceMap?: boolean | undefined;
             /**
              * Specifies the source url used in the source map.
              */
@@ -272,9 +268,13 @@ declare module "node:module" {
          * `module.stripTypeScriptTypes()` removes type annotations from TypeScript code. It
          * can be used to strip type annotations from TypeScript code before running it
          * with `vm.runInContext()` or `vm.compileFunction()`.
-         *
          * By default, it will throw an error if the code contains TypeScript features
-         * that require transformation, such as `enum`s. See [type-stripping](https://nodejs.org/docs/latest-v26.x/api/typescript.md#type-stripping) for more information.
+         * that require transformation such as `Enums`,
+         * see [type-stripping](https://nodejs.org/docs/latest-v22.x/api/typescript.md#type-stripping) for more information.
+         * When mode is `'transform'`, it also transforms TypeScript features to JavaScript,
+         * see [transform TypeScript features](https://nodejs.org/docs/latest-v22.x/api/typescript.md#typescript-features) for more information.
+         * When mode is `'strip'`, source maps are not generated, because locations are preserved.
+         * If `sourceMap` is provided, when mode is `'strip'`, an error will be thrown.
          *
          * _WARNING_: The output of this function should not be considered stable across Node.js versions,
          * due to changes in the TypeScript parser.
@@ -296,6 +296,24 @@ declare module "node:module" {
          * console.log(strippedCode);
          * // Prints: const a         = 1\n\n//# sourceURL=source.ts;
          * ```
+         *
+         * When `mode` is `'transform'`, the code is transformed to JavaScript:
+         *
+         * ```js
+         * import { stripTypeScriptTypes } from 'node:module';
+         * const code = `
+         *   namespace MathUtil {
+         *     export const add = (a: number, b: number) => a + b;
+         *   }`;
+         * const strippedCode = stripTypeScriptTypes(code, { mode: 'transform', sourceMap: true });
+         * console.log(strippedCode);
+         * // Prints:
+         * // var MathUtil;
+         * // (function(MathUtil) {
+         * //     MathUtil.add = (a, b)=>a + b;
+         * // })(MathUtil || (MathUtil = {}));
+         * // # sourceMappingURL=data:application/json;base64, ...
+         * ```
          * @since v22.13.0
          * @param code The code to strip type annotations from.
          * @returns The code with type annotations stripped.
@@ -341,9 +359,7 @@ declare module "node:module" {
         interface ImportAttributes extends NodeJS.Dict<string> {
             type?: string | undefined;
         }
-        type ImportPhase = "source" | "evaluation";
         type ModuleFormat =
-            | "addon"
             | "builtin"
             | "commonjs"
             | "commonjs-typescript"
@@ -352,18 +368,59 @@ declare module "node:module" {
             | "module-typescript"
             | "wasm";
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
+        /**
+         * The `initialize` hook provides a way to define a custom function that runs in
+         * the hooks thread when the hooks module is initialized. Initialization happens
+         * when the hooks module is registered via {@link register}.
+         *
+         * This hook can receive data from a {@link register} invocation, including
+         * ports and other transferable objects. The return value of `initialize` can be a
+         * `Promise`, in which case it will be awaited before the main application thread
+         * execution resumes.
+         */
         type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
         interface ResolveHookContext {
+            /**
+             * Export conditions of the relevant `package.json`
+             */
             conditions: string[];
+            /**
+             *  An object whose key-value pairs represent the assertions for the module to import
+             */
             importAttributes: ImportAttributes;
+            /**
+             * The module importing this one, or undefined if this is the Node.js entry point
+             */
             parentURL: string | undefined;
         }
         interface ResolveFnOutput {
+            /**
+             * A hint to the load hook (it might be ignored); can be an intermediary value.
+             */
             format?: string | null | undefined;
+            /**
+             * The import attributes to use when caching the module (optional; if excluded the input will be used)
+             */
             importAttributes?: ImportAttributes | undefined;
+            /**
+             * A signal that this hook intends to terminate the chain of `resolve` hooks.
+             * @default false
+             */
             shortCircuit?: boolean | undefined;
+            /**
+             * The absolute URL to which this input resolves
+             */
             url: string;
         }
+        /**
+         * The `resolve` hook chain is responsible for telling Node.js where to find and
+         * how to cache a given `import` statement or expression, or `require` call. It can
+         * optionally return a format (such as `'module'`) as a hint to the `load` hook. If
+         * a format is specified, the `load` hook is ultimately responsible for providing
+         * the final `format` value (and it is free to ignore the hint provided by
+         * `resolve`); if `resolve` provides a `format`, a custom `load` hook is required
+         * even if only to pass the value to the Node.js default `load` hook.
+         */
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
@@ -381,15 +438,36 @@ declare module "node:module" {
             ) => ResolveFnOutput,
         ) => ResolveFnOutput;
         interface LoadHookContext {
+            /**
+             * Export conditions of the relevant `package.json`
+             */
             conditions: string[];
+            /**
+             * The format optionally supplied by the `resolve` hook chain (can be an intermediary value).
+             */
             format: string | null | undefined;
+            /**
+             *  An object whose key-value pairs represent the assertions for the module to import
+             */
             importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
             format: string | null | undefined;
+            /**
+             * A signal that this hook intends to terminate the chain of `resolve` hooks.
+             * @default false
+             */
             shortCircuit?: boolean | undefined;
+            /**
+             * The source for Node.js to evaluate
+             */
             source?: ModuleSource | undefined;
         }
+        /**
+         * The `load` hook provides a way to define a custom method of determining how a
+         * URL should be interpreted, retrieved, and parsed. It is also in charge of
+         * validating the import attributes.
+         */
         type LoadHook = (
             url: string,
             context: LoadHookContext,
@@ -423,7 +501,7 @@ declare module "node:module" {
         /**
          * This method returns whether the [Source Map v3](https://tc39.es/ecma426/) support for stack
          * traces is enabled.
-         * @since v23.7.0, v22.14.0
+         * @since v22.14.0
          */
         function getSourceMapsSupport(): SourceMapsSupport;
         /**
@@ -457,7 +535,7 @@ declare module "node:module" {
          * enabled will be parsed and loaded. Preferably, use the commandline options
          * `--enable-source-maps` to avoid losing track of source maps of modules loaded
          * before this API call.
-         * @since v23.7.0, v22.14.0
+         * @since v22.14.0
          */
         function setSourceMapsSupport(enabled: boolean, options?: SetSourceMapsSupportOptions): void;
         interface SourceMapConstructorOptions {
@@ -543,6 +621,94 @@ declare module "node:module" {
         function wrap(script: string): string;
     }
     global {
+        interface ImportMeta {
+            /**
+             * The directory name of the current module.
+             *
+             * This is the same as the `path.dirname()` of the `import.meta.filename`.
+             *
+             * > **Caveat**: only present on `file:` modules.
+             * @since v21.2.0, v20.11.0
+             */
+            dirname: string;
+            /**
+             * The full absolute path and filename of the current module, with
+             * symlinks resolved.
+             *
+             * This is the same as the `url.fileURLToPath()` of the `import.meta.url`.
+             *
+             * > **Caveat** only local modules support this property. Modules not using the
+             * > `file:` protocol will not provide it.
+             * @since v21.2.0, v20.11.0
+             */
+            filename: string;
+            /**
+             * The absolute `file:` URL of the module.
+             *
+             * This is defined exactly the same as it is in browsers providing the URL of the
+             * current module file.
+             *
+             * This enables useful patterns such as relative file loading:
+             *
+             * ```js
+             * import { readFileSync } from 'node:fs';
+             * const buffer = readFileSync(new URL('./data.proto', import.meta.url));
+             * ```
+             */
+            url: string;
+            /**
+             * `import.meta.resolve` is a module-relative resolution function scoped to
+             * each module, returning the URL string.
+             *
+             * ```js
+             * const dependencyAsset = import.meta.resolve('component-lib/asset.css');
+             * // file:///app/node_modules/component-lib/asset.css
+             * import.meta.resolve('./dep.js');
+             * // file:///app/dep.js
+             * ```
+             *
+             * All features of the Node.js module resolution are supported. Dependency
+             * resolutions are subject to the permitted exports resolutions within the package.
+             *
+             * **Caveats**:
+             *
+             * * This can result in synchronous file-system operations, which
+             *   can impact performance similarly to `require.resolve`.
+             * * This feature is not available within custom loaders (it would
+             *   create a deadlock).
+             * @since v13.9.0, v12.16.0
+             * @param specifier The module specifier to resolve relative to the
+             * current module.
+             * @param parent An optional absolute parent module URL to resolve from.
+             * **Default:** `import.meta.url`
+             * @returns The absolute URL string that the specifier would resolve to.
+             */
+            resolve(specifier: string, parent?: string | URL): string;
+            /**
+             * `true` when the current module is the entry point of the current process; `false` otherwise.
+             *
+             * Equivalent to `require.main === module` in CommonJS.
+             *
+             * Analogous to Python's `__name__ == "__main__"`.
+             *
+             * ```js
+             * export function foo() {
+             *   return 'Hello, world';
+             * }
+             *
+             * function main() {
+             *   const message = foo();
+             *   console.log(message);
+             * }
+             *
+             * if (import.meta.main) main();
+             * // `foo` can be imported from another module without possible side-effects from `main`
+             * ```
+             * @since v22.18.0
+             * @experimental
+             */
+            main: boolean;
+        }
         namespace NodeJS {
             interface Module {
                 /**
@@ -616,7 +782,7 @@ declare module "node:module" {
                  * Modules are cached in this object when they are required. By deleting a key
                  * value from this object, the next `require` will reload the module.
                  * This does not apply to
-                 * [native addons](https://nodejs.org/docs/latest-v26.x/api/addons.html),
+                 * [native addons](https://nodejs.org/docs/latest-v22.x/api/addons.html),
                  * for which reloading will result in an error.
                  * @since v0.3.0
                  */
@@ -650,7 +816,7 @@ declare module "node:module" {
                  * Paths to resolve module location from. If present, these
                  * paths are used instead of the default resolution paths, with the exception
                  * of
-                 * [GLOBAL\_FOLDERS](https://nodejs.org/docs/latest-v26.x/api/modules.html#loading-from-the-global-folders)
+                 * [GLOBAL\_FOLDERS](https://nodejs.org/docs/latest-v22.x/api/modules.html#loading-from-the-global-folders)
                  * like `$HOME/.node_modules`, which are
                  * always included. Each of these paths is used as a starting point for
                  * the module resolution algorithm, meaning that the `node_modules` hierarchy
@@ -710,7 +876,6 @@ declare module "node:module" {
          */
         var require: NodeJS.Require;
         // Global-scope aliases for backwards compatibility with @types/node <13.0.x
-        // TODO: consider removing in a future major version update
         /** @deprecated Use `NodeJS.Module` instead. */
         interface NodeModule extends NodeJS.Module {}
         /** @deprecated Use `NodeJS.Require` instead. */
@@ -720,7 +885,7 @@ declare module "node:module" {
     }
     export = Module;
 }
-declare module "module" {
-    import module = require("node:module");
+declare module "node:module" {
+    import module = require("module");
     export = module;
 }