language-operator 0.1.81 → 0.1.82

data/.claude/hooks/node_modules/@types/node/string_decoder.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The `node:string_decoder` module provides an API for decoding `Buffer` objects
+ * into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
+ * characters. It can be accessed using:
+ *
+ * ```js
+ * import { StringDecoder } from 'node:string_decoder';
+ * ```
+ *
+ * The following example shows the basic use of the `StringDecoder` class.
+ *
+ * ```js
+ * import { StringDecoder } from 'node:string_decoder';
+ * const decoder = new StringDecoder('utf8');
+ *
+ * const cent = Buffer.from([0xC2, 0xA2]);
+ * console.log(decoder.write(cent)); // Prints: ¢
+ *
+ * const euro = Buffer.from([0xE2, 0x82, 0xAC]);
+ * console.log(decoder.write(euro)); // Prints: €
+ * ```
+ *
+ * When a `Buffer` instance is written to the `StringDecoder` instance, an
+ * internal buffer is used to ensure that the decoded string does not contain
+ * any incomplete multibyte characters. These are held in the buffer until the
+ * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
+ *
+ * In the following example, the three UTF-8 encoded bytes of the European Euro
+ * symbol (`€`) are written over three separate operations:
+ *
+ * ```js
+ * import { StringDecoder } from 'node:string_decoder';
+ * const decoder = new StringDecoder('utf8');
+ *
+ * decoder.write(Buffer.from([0xE2]));
+ * decoder.write(Buffer.from([0x82]));
+ * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/string_decoder.js)
+ */
+declare module "node:string_decoder" {
+    class StringDecoder {
+        constructor(encoding?: BufferEncoding);
+        /**
+         * Returns a decoded string, ensuring that any incomplete multibyte characters at
+         * the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
+         * returned string and stored in an internal buffer for the next call to `stringDecoder.write()` or `stringDecoder.end()`.
+         * @since v0.1.99
+         * @param buffer The bytes to decode.
+         */
+        write(buffer: string | NodeJS.ArrayBufferView): string;
+        /**
+         * Returns any remaining input stored in the internal buffer as a string. Bytes
+         * representing incomplete UTF-8 and UTF-16 characters will be replaced with
+         * substitution characters appropriate for the character encoding.
+         *
+         * If the `buffer` argument is provided, one final call to `stringDecoder.write()` is performed before returning the remaining input.
+         * After `end()` is called, the `stringDecoder` object can be reused for new input.
+         * @since v0.9.3
+         * @param buffer The bytes to decode.
+         */
+        end(buffer?: string | NodeJS.ArrayBufferView): string;
+    }
+}
+declare module "string_decoder" {
+    export * from "node:string_decoder";
+}

data/.claude/hooks/node_modules/@types/node/test/reporters.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The `node:test` module supports passing `--test-reporter`
+ * flags for the test runner to use a specific reporter.
+ *
+ * The following built-reporters are supported:
+ *
+ * * `spec`
+ *   The `spec` reporter outputs the test results in a human-readable format. This
+ *   is the default reporter.
+ *
+ * * `tap`
+ *   The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
+ *
+ * * `dot`
+ *   The `dot` reporter outputs the test results in a compact format,
+ *   where each passing test is represented by a `.`,
+ *   and each failing test is represented by a `X`.
+ *
+ * * `junit`
+ *   The junit reporter outputs test results in a jUnit XML format
+ *
+ * * `lcov`
+ *   The `lcov` reporter outputs test coverage when used with the
+ *   `--experimental-test-coverage` flag.
+ *
+ * The exact output of these reporters is subject to change between versions of
+ * Node.js, and should not be relied on programmatically. If programmatic access
+ * to the test runner's output is required, use the events emitted by the
+ * `TestsStream`.
+ *
+ * The reporters are available via the `node:test/reporters` module:
+ *
+ * ```js
+ * import { tap, spec, dot, junit, lcov } from 'node:test/reporters';
+ * ```
+ * @since v19.9.0, v18.17.0
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/test/reporters.js)
+ */
+declare module "node:test/reporters" {
+    import { Transform, TransformOptions } from "node:stream";
+    import { EventData } from "node:test";
+    type TestEvent =
+        | { type: "test:coverage"; data: EventData.TestCoverage }
+        | { type: "test:complete"; data: EventData.TestComplete }
+        | { type: "test:dequeue"; data: EventData.TestDequeue }
+        | { type: "test:diagnostic"; data: EventData.TestDiagnostic }
+        | { type: "test:enqueue"; data: EventData.TestEnqueue }
+        | { type: "test:fail"; data: EventData.TestFail }
+        | { type: "test:pass"; data: EventData.TestPass }
+        | { type: "test:plan"; data: EventData.TestPlan }
+        | { type: "test:start"; data: EventData.TestStart }
+        | { type: "test:stderr"; data: EventData.TestStderr }
+        | { type: "test:stdout"; data: EventData.TestStdout }
+        | { type: "test:summary"; data: EventData.TestSummary }
+        | { type: "test:watch:drained"; data: undefined }
+        | { type: "test:watch:restarted"; data: undefined };
+    interface ReporterConstructorWrapper<T extends new(...args: any[]) => Transform> {
+        new(...args: ConstructorParameters<T>): InstanceType<T>;
+        (...args: ConstructorParameters<T>): InstanceType<T>;
+    }
+    /**
+     * The `dot` reporter outputs the test results in a compact format,
+     * where each passing test is represented by a `.`,
+     * and each failing test is represented by a `X`.
+     * @since v20.0.0
+     */
+    function dot(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    /**
+     * The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
+     * @since v20.0.0
+     */
+    function tap(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    class SpecReporter extends Transform {
+        constructor();
+    }
+    /**
+     * The `spec` reporter outputs the test results in a human-readable format.
+     * @since v20.0.0
+     */
+    const spec: ReporterConstructorWrapper<typeof SpecReporter>;
+    /**
+     * The `junit` reporter outputs test results in a jUnit XML format.
+     * @since v21.0.0
+     */
+    function junit(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    class LcovReporter extends Transform {
+        constructor(options?: Omit<TransformOptions, "writableObjectMode">);
+    }
+    /**
+     * The `lcov` reporter outputs test coverage when used with the
+     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--experimental-test-coverage) flag.
+     * @since v22.0.0
+     */
+    const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
+    export { dot, junit, lcov, spec, tap, TestEvent };
+}