@shawnstack/quickforge 1.2.10 → 1.3.1

package/node_modules/@types/node/stream/iter.d.ts

@@ -0,0 +1,298 @@
+declare module "node:stream/iter" {
+    // Symbols and custom typedefs
+    const broadcastProtocol: unique symbol;
+    const drainableProtocol: unique symbol;
+    const shareProtocol: unique symbol;
+    const shareSyncProtocol: unique symbol;
+    const toAsyncStreamable: unique symbol;
+    const toStreamable: unique symbol;
+    type Source =
+        | string
+        | ArrayBufferLike
+        | ArrayBufferView
+        | Iterable<SyncSource>
+        | AsyncIterable<Source>
+        | Streamable
+        | AsyncStreamable;
+    type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable;
+    type Transform = StatelessTransformFn | StatefulTransform;
+    type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform;
+    type TransformResult =
+        | string
+        | ArrayBufferLike
+        | ArrayBufferView
+        | Iterable<SyncTransformResult>
+        | AsyncIterable<TransformResult>;
+    type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>;
+    interface AsyncStreamable {
+        [toAsyncStreamable](): Source;
+    }
+    interface Broadcastable {
+        [broadcastProtocol](options: BroadcastOptions): Broadcast;
+    }
+    interface Drainable {
+        [drainableProtocol](): Promise<boolean> | null;
+    }
+    interface Shareable {
+        [shareProtocol](options: ShareOptions): Share;
+    }
+    interface Streamable {
+        [toStreamable](): SyncSource;
+    }
+    interface SyncShareable {
+        [shareSyncProtocol](options: ShareSyncOptions): SyncShare;
+    }
+    // IDL dictionaries, enums, typedefs
+    type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest";
+    type ByteReadableStream = AsyncIterable<Uint8Array[]>;
+    type SyncByteReadableStream = Iterable<Uint8Array[]>;
+    interface WriteOptions {
+        signal?: AbortSignal;
+    }
+    interface PushStreamOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface PullOptions {
+        signal?: AbortSignal;
+    }
+    interface PipeToOptions {
+        signal?: AbortSignal;
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface PipeToSyncOptions {
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface ConsumeOptions {
+        signal?: AbortSignal;
+        limit?: number;
+    }
+    interface ConsumeSyncOptions {
+        limit?: number;
+    }
+    interface TextConsumeOptions extends ConsumeOptions {
+        encoding?: string;
+    }
+    interface TextConsumeSyncOptions extends ConsumeSyncOptions {
+        encoding?: string;
+    }
+    interface MergeOptions {
+        signal?: AbortSignal;
+    }
+    interface BroadcastOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareSyncOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexDirectionOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        a?: DuplexDirectionOptions;
+        b?: DuplexDirectionOptions;
+        signal?: AbortSignal;
+    }
+    interface TransformCallbackOptions {
+        signal: AbortSignal;
+    }
+    interface StatelessTransformFn {
+        (chunks: Uint8Array[] | null, options: TransformCallbackOptions): TransformResult | null;
+    }
+    interface SyncStatelessTransformFn {
+        (chunks: Uint8Array[] | null): SyncTransformResult | null;
+    }
+    interface StatefulTransform {
+        transform(
+            source: AsyncIterable<Uint8Array[] | null>,
+            options: TransformCallbackOptions,
+        ): AsyncIterable<TransformResult>;
+    }
+    interface SyncStatefulTransform {
+        transform(source: Iterable<Uint8Array[] | null>): Iterable<SyncTransformResult>;
+    }
+    // IDL interfaces
+    interface PushWriter extends Writer, Drainable {}
+    interface PushStreamResult {
+        writer: PushWriter;
+        readable: ByteReadableStream;
+    }
+    interface BroadcastWriter extends Writer, Drainable {}
+    interface BroadcastResult {
+        writer: BroadcastWriter;
+        broadcast: Broadcast;
+    }
+    interface Writer extends Disposable, AsyncDisposable {
+        readonly desiredSize: number | null;
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+        writev(chunks: Array<Uint8Array | string>, options?: WriteOptions): Promise<void>;
+        writeSync(chunk: Uint8Array | string): boolean;
+        writevSync(chunks: Array<Uint8Array | string>): boolean;
+        end(options?: WriteOptions): Promise<number>;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialWriter extends Partial<Writer> {
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+    }
+    interface SyncWriter extends Disposable {
+        readonly desiredSize: number | null;
+        writeSync(chunk: Uint8Array | string): number;
+        writevSync(chunks: Array<Uint8Array | string>): number;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialSyncWriter extends Partial<SyncWriter> {
+        writeSync(chunk: Uint8Array | string): number;
+    }
+    interface Broadcast extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        push(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface Share extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface SyncShare extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any): SyncByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface DuplexChannel extends AsyncDisposable {
+        readonly writer: Writer;
+        readonly readable: ByteReadableStream;
+        close(): Promise<void>;
+    }
+    // Push stream creation
+    function push(...transforms: Transform[]): PushStreamResult;
+    function push(...args: [...transforms: Transform[], options: PushStreamOptions]): PushStreamResult;
+    // Stream factories
+    function from(input: Source): ByteReadableStream;
+    function fromSync(input: SyncSource): SyncByteReadableStream;
+    // Pull pipelines
+    function pull(source: Source, ...transforms: Transform[]): ByteReadableStream;
+    function pull(
+        source: Source,
+        ...args: [...transforms: Transform[], options: PullOptions]
+    ): ByteReadableStream;
+    function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream;
+    // Pipe operations
+    function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise<number>;
+    function pipeTo(source: Source, ...args: [...transforms: Transform[], writer: PartialWriter]): Promise<number>;
+    function pipeTo(
+        source: Source,
+        ...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions]
+    ): Promise<number>;
+    function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number;
+    function pipeToSync(
+        source: SyncSource,
+        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter]
+    ): number;
+    function pipeToSync(
+        source: SyncSource,
+        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions]
+    ): number;
+    // Consumers
+    function bytes(source: Source, options?: ConsumeOptions): Promise<Uint8Array>;
+    function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array;
+    function text(source: Source, options?: TextConsumeOptions): Promise<string>;
+    function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string;
+    function arrayBuffer(source: Source, options?: ConsumeOptions): Promise<ArrayBuffer>;
+    function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer;
+    function array(source: Source, options?: ConsumeOptions): Promise<Uint8Array[]>;
+    function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[];
+    // Utilities
+    function tap(callback: StatelessTransformFn): StatelessTransformFn;
+    function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn;
+    function merge(...sources: Source[]): ByteReadableStream;
+    function merge(...args: [...sources: Source[], options: MergeOptions]): ByteReadableStream;
+    function ondrain(drainable: any): Promise<boolean> | null;
+    // Multi-consumer
+    function broadcast(options?: BroadcastOptions): BroadcastResult;
+    function share(source: Source, options?: ShareOptions): Share;
+    function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare;
+    // Duplex
+    function duplex(options?: DuplexOptions): [DuplexChannel, DuplexChannel];
+    // Node.js-specific extensions
+    namespace Broadcast {
+        /**
+         * Create a `Broadcast` from an existing source. The source is consumed
+         * automatically and pushed to all subscribers.
+         * @since v25.9.0
+         * @param options Same as `broadcast()`.
+         */
+        function from(
+            input: ByteReadableStream | SyncByteReadableStream | Broadcastable,
+            options?: BroadcastOptions,
+        ): BroadcastResult;
+    }
+    namespace Share {
+        /**
+         * Create a `Share` from an existing source.
+         * @since v25.9.0
+         * @param options Same as `share()`.
+         */
+        function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share;
+    }
+    namespace SyncShare {
+        /**
+         * @since v25.9.0
+         */
+        function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
+    }
+    namespace Stream {
+        export {
+            array,
+            arrayBuffer,
+            arrayBufferSync,
+            arraySync,
+            broadcast,
+            broadcastProtocol,
+            bytes,
+            bytesSync,
+            drainableProtocol,
+            duplex,
+            from,
+            fromSync,
+            merge,
+            ondrain,
+            pipeTo,
+            pipeToSync,
+            pull,
+            pullSync,
+            push,
+            share,
+            shareProtocol,
+            shareSync,
+            shareSyncProtocol,
+            tap,
+            tapSync,
+            text,
+            textSync,
+            toAsyncStreamable,
+            toStreamable,
+        };
+    }
+}
+declare module "stream/iter" {
+    export * from "node:stream/iter";
+}

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

@@ -1,5 +1,5 @@
 declare module "node:test" {
-    import { AssertMethodNames } from "node:assert";
+    import { AssertMethodNames, AssertPredicate } from "node:assert";
     import { Readable, ReadableEventMap } from "node:stream";
     import { TestEvent } from "node:test/reporters";
     import { URL } from "node:url";
@@ -111,7 +111,12 @@ declare module "node:test" {
             function only(name?: string, fn?: SuiteFn): Promise<void>;
             function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
             function only(fn?: SuiteFn): Promise<void>;
-            // added in v25.5.0, undocumented
+            /**
+             * This flips the pass/fail reporting for a specific test or suite: a flagged test
+             * case must throw in order to pass, and a flagged test case that does not throw
+             * fails.
+             * @since v25.5.0
+             */
             function expectFailure(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
             function expectFailure(name?: string, fn?: SuiteFn): Promise<void>;
             function expectFailure(options?: TestOptions, fn?: SuiteFn): Promise<void>;
@@ -992,6 +997,34 @@ declare module "node:test" {
              * @since v21.7.0, v20.12.0
              */
             readonly attempt: number;
+            /**
+             * The unique identifier of the worker running the current test file. This value is
+             * derived from the `NODE_TEST_WORKER_ID` environment variable. When running tests
+             * with `--test-isolation=process` (the default), each test file runs in a separate
+             * child process and is assigned a worker ID from 1 to N, where N is the number of
+             * concurrent workers. When running with `--test-isolation=none`, all tests run in
+             * the same process and the worker ID is always 1. This value is `undefined` when
+             * not running in a test context.
+             *
+             * This property is useful for splitting resources (like database connections or
+             * server ports) across concurrent test files:
+             *
+             * ```js
+             * import { test } from 'node:test';
+             * import { process } from 'node:process';
+             *
+             * test('database operations', async (t) => {
+             *   // Worker ID is available via context
+             *   console.log(`Running in worker ${t.workerId}`);
+             *
+             *   // Or via environment variable (available at import time)
+             *   const workerId = process.env.NODE_TEST_WORKER_ID;
+             *   // Use workerId to allocate separate resources per worker
+             * });
+             * ```
+             * @since v25.8.0
+             */
+            readonly workerId: number | undefined;
             /**
              * This function is used to set the number of assertions and subtests that are expected to run
              * within the test. If the number of assertions and subtests that run does not match the
@@ -1272,6 +1305,17 @@ declare module "node:test" {
              * @default false
              */
             concurrency?: number | boolean | undefined;
+            /**
+             * If truthy, the test is expected to fail. If a non-empty string is provided, that string is displayed
+             * in the test results as the reason why the test is expected to fail. If a
+             * `RegExp`, `Function`, `Object`, or `Error` is provided directly (without wrapping in `{ match: … }`), the test passes
+             * only if the thrown error matches, following the behavior of
+             * `assert.throws`. To provide both a reason and validation, pass an object
+             * with `label` (string) and `match` (RegExp, Function, Object, or Error).
+             * @since v25.5.0
+             * @default false
+             */
+            expectFailure?: boolean | string | AssertPredicate | undefined;
             /**
              * If truthy, and the test context is configured to run `only` tests, then this test will be
              * run. Otherwise, the test is skipped.
@@ -1310,8 +1354,6 @@ declare module "node:test" {
              * @since v22.2.0
              */
             plan?: number | undefined;
-            // added in v25.5.0, undocumented
-            expectFailure?: boolean | undefined;
         }
         /**
          * This function creates a hook that runs before executing a suite.
@@ -1437,19 +1479,40 @@ declare module "node:test" {
              */
             cache?: boolean | undefined;
             /**
-             * The value to use as the mocked module's default export.
-             *
-             * If this value is not provided, ESM mocks do not include a default export.
-             * If the mock is a CommonJS or builtin module, this setting is used as the value of `module.exports`.
-             * If this value is not provided, CJS and builtin mocks use an empty object as the value of `module.exports`.
+             * Optional mocked exports. The `default` property, if
+             * provided, is used as the mocked module's default export. All other own
+             * enumerable properties are used as named exports.
+             * **This option cannot be used with `defaultExport` or `namedExports`.**
+             * * If the mock is a CommonJS or builtin module, `exports.default` is used as
+             *   the value of `module.exports`.
+             * * If `exports.default` is not provided for a CommonJS or builtin mock,
+             *   `module.exports` defaults to an empty object.
+             * * If named exports are provided with a non-object default export, the mock
+             *   throws an exception when used as a CommonJS or builtin module.
+             */
+            exports?: object | undefined;
+            /**
+             * An optional value used as the mocked module's default
+             * export. If this value is not provided, ESM mocks do not include a default
+             * export. If the mock is a CommonJS or builtin module, this setting is used as
+             * the value of `module.exports`. If this value is not provided, CJS and builtin
+             * mocks use an empty object as the value of `module.exports`.
+             * **This option cannot be used with `options.exports`.**
+             * This option is deprecated and will be removed in a later version.
+             * Prefer `options.exports.default`.
+             * @deprecated
              */
             defaultExport?: any;
             /**
-             * An object whose keys and values are used to create the named exports of the mock module.
-             *
-             * If the mock is a CommonJS or builtin module, these values are copied onto `module.exports`.
-             * Therefore, if a mock is created with both named exports and a non-object default export,
-             * the mock will throw an exception when used as a CJS or builtin module.
+             * An optional object whose keys and values are used to
+             * create the named exports of the mock module. If the mock is a CommonJS or
+             * builtin module, these values are copied onto `module.exports`. Therefore, if a
+             * mock is created with both named exports and a non-object default export, the
+             * mock will throw an exception when used as a CJS or builtin module.
+             * **This option cannot be used with `options.exports`.**
+             * This option is deprecated and will be removed in a later version.
+             * Prefer `options.exports`.
+             * @deprecated
              */
             namedExports?: object | undefined;
         }
@@ -1624,14 +1687,19 @@ declare module "node:test" {
              * [`--experimental-test-module-mocks`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--experimental-test-module-mocks)
              * command-line flag.
              *
+             * **Note**: [module customization hooks](https://nodejs.org/docs/latest-v25.x/api/module.html#customization-hooks) registered via the **synchronous** API effect resolution of
+             * the `specifier` provided to `mock.module`. Customization hooks registered via the **asynchronous**
+             * API are currently ignored (because the test runner's loader is synchronous, and node does not
+             * support multi-chain / cross-chain loading).
+             *
              * The following example demonstrates how a mock is created for a module.
              *
              * ```js
              * test('mocks a builtin module in both module systems', async (t) => {
-             *   // Create a mock of 'node:readline' with a named export named 'fn', which
+             *   // Create a mock of 'node:readline' with a named export named 'foo', which
              *   // does not exist in the original 'node:readline' module.
              *   const mock = t.mock.module('node:readline', {
-             *     namedExports: { fn() { return 42; } },
+             *     exports: { foo: () => 42 },
              *   });
              *
              *   let esmImpl = await import('node:readline');

package/node_modules/@types/node/ts5.6/index.d.ts

@@ -97,6 +97,7 @@
 /// <reference path="../sqlite.d.ts" />
 /// <reference path="../stream.d.ts" />
 /// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/iter.d.ts" />
 /// <reference path="../stream/promises.d.ts" />
 /// <reference path="../stream/web.d.ts" />
 /// <reference path="../string_decoder.d.ts" />
@@ -115,3 +116,4 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
+/// <reference path="../zlib/iter.d.ts" />

package/node_modules/@types/node/ts5.7/index.d.ts

@@ -97,6 +97,7 @@
 /// <reference path="../sqlite.d.ts" />
 /// <reference path="../stream.d.ts" />
 /// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/iter.d.ts" />
 /// <reference path="../stream/promises.d.ts" />
 /// <reference path="../stream/web.d.ts" />
 /// <reference path="../string_decoder.d.ts" />
@@ -115,3 +116,4 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
+/// <reference path="../zlib/iter.d.ts" />

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

@@ -235,7 +235,7 @@ declare module "node:url" {
     /**
      * `url.format(urlString)` is shorthand for `url.format(url.parse(urlString))`.
      *
-     * Because it invokes the deprecated `url.parse()`, passing a string argument
+     * Because it invokes the deprecated `url.parse()` internally, passing a string argument
      * to `url.format()` is itself deprecated.
      *
      * Canonicalizing a URL string can be performed using the WHATWG URL API, by
@@ -265,6 +265,8 @@ declare module "node:url" {
      * url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'
      * ```
      *
+     * Because it invokes the deprecated `url.parse()` internally, `url.resolve()` is itself deprecated.
+     *
      * To achieve the same result using the WHATWG URL API:
      *
      * ```js
@@ -283,7 +285,7 @@ declare module "node:url" {
      * resolve('http://example.com/one', '/two'); // 'http://example.com/two'
      * ```
      * @since v0.1.25
-     * @legacy Use the WHATWG URL API instead.
+     * @deprecated Use the WHATWG URL API instead.
      * @param from The base URL to use if `to` is a relative URL.
      * @param to The target URL to resolve.
      */

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

@@ -232,11 +232,12 @@ declare module "node:vm" {
          *
          * 1. Creates a new context.
          * 2. If `contextObject` is an object, contextifies it with the new context.
-         *    If  `contextObject` is undefined, creates a new object and contextifies it.
+         *    If `contextObject` is undefined, creates a new object and contextifies it.
          *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
-         * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
-         *    does not have access to the scope in which this method is called.
-         * 4. Returns the result.
+         * 3. Compiles the code as a `vm.Script`
+         * 4. Runs the compiled code within the created context. The code does not have access to the scope in
+         *    which this method is called.
+         * 5. Returns the result.
          *
          * The following example compiles code that sets a global variable, then executes
          * the code multiple times in different contexts. The globals are set on and

package/node_modules/@types/node/zlib/iter.d.ts

@@ -0,0 +1,131 @@
+declare module "node:zlib/iter" {
+    import { StatefulTransform, SyncStatefulTransform } from "node:stream/iter";
+    interface BrotliOptions {
+        chunkSize?: number | undefined;
+        params?: { [key: number]: number | boolean } | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZlibOptions {
+        chunkSize?: number | undefined;
+        windowBits?: number | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZlibCompressionOptions extends ZlibOptions {
+        level?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: number | undefined;
+    }
+    interface ZstdOptions {
+        chunkSize?: number | undefined;
+        params?: { [key: number]: number | boolean } | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZstdCompressionOptions extends ZstdOptions {
+        pledgedSrcSize?: number | undefined;
+    }
+    /**
+     * Create a Brotli compression transform. Output is compatible with
+     * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressBrotli(options?: BrotliOptions): StatefulTransform;
+    /**
+     * Create a Brotli compression transform. Output is compatible with
+     * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressBrotliSync(options?: BrotliOptions): SyncStatefulTransform;
+    /**
+     * Create a deflate compression transform. Output is compatible with
+     * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressDeflate(options?: ZlibCompressionOptions): StatefulTransform;
+    /**
+     * Create a deflate compression transform. Output is compatible with
+     * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressDeflateSync(options?: ZlibCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a gzip compression transform. Output is compatible with `zlib.gunzip()`
+     * and `decompressGzip()`/`decompressGzipSync()`.
+     * @returns A stateful transform.
+     */
+    function compressGzip(options?: ZlibCompressionOptions): StatefulTransform;
+    /**
+     * Create a gzip compression transform. Output is compatible with `zlib.gunzip()`
+     * and `decompressGzip()`/`decompressGzipSync()`.
+     * @returns A stateful transform.
+     */
+    function compressGzipSync(options?: ZlibCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a Zstandard compression transform. Output is compatible with
+     * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressZstd(options?: ZstdCompressionOptions): StatefulTransform;
+    /**
+     * Create a Zstandard compression transform. Output is compatible with
+     * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressZstdSync(options?: ZstdCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a Brotli decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressBrotli(options?: BrotliOptions): StatefulTransform;
+    /**
+     * Create a Brotli decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressBrotliSync(options?: BrotliOptions): SyncStatefulTransform;
+    /**
+     * Create a deflate decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressDeflate(options?: ZlibOptions): StatefulTransform;
+    /**
+     * Create a deflate decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressDeflateSync(options?: ZlibOptions): SyncStatefulTransform;
+    /**
+     * Create a gzip decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressGzip(options?: ZlibOptions): StatefulTransform;
+    /**
+     * Create a gzip decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressGzipSync(options?: ZlibOptions): SyncStatefulTransform;
+    /**
+     * Create a Zstandard decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressZstd(options?: ZstdOptions): StatefulTransform;
+    /**
+     * Create a Zstandard decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressZstdSync(options?: ZstdOptions): SyncStatefulTransform;
+}
+declare module "zlib/iter" {
+    export * from "node:zlib/iter";
+}

package/node_modules/@vscode/ripgrep/LICENSE

@@ -0,0 +1,13 @@
+vscode-ripgrep
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+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.