@volter/tabnode 0.5.48 → 0.5.50

package/dist/node-body.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The init with an async-iterable body read as a stream, or the init itself.
+ * The body is read once; the replacement is built member by member (an init
+ * may carry its members on getters of its prototype, as a `Request` passed as
+ * an init does), with the init's own other members as they are.
+ */
+export declare function withNodeRequestBody<T extends RequestInit | undefined>(init: T): T;
+/** A response body as undici takes it: an async iterable read as a stream, anything else as given. */
+export declare function nodeResponseBody(body: unknown): unknown;

package/dist/shims/crypto-cipher.d.ts

@@ -0,0 +1,203 @@
+import { GHASH } from '@noble/ciphers/_polyval.js';
+type Mode = 'gcm' | 'cbc' | 'ctr' | 'ecb';
+type Bytes = Uint8Array;
+export interface CipherDeps {
+    /** The guest's Buffer.from over bytes. */
+    toBuffer(bytes: Bytes): Uint8Array;
+    /** Bytes of a string (in its encoding) or a view, as the rest of crypto reads them. */
+    bytesOf(value: unknown, encoding?: string): Bytes;
+    /** A secret KeyObject's bytes, or undefined when the value is not a KeyObject. */
+    secretKeyBytes(value: unknown): Bytes | undefined;
+    /** Bytes in an output encoding, as `digest` answers them. */
+    encode(bytes: Bytes, encoding?: string): unknown;
+    error(code: string, message: string): Error;
+}
+/** The ciphers `createCipheriv` accepts, as `getCiphers` lists them. */
+export declare function cipherNames(): string[];
+export declare function createCipherClasses(deps: CipherDeps): {
+    Cipheriv: {
+        new (algorithm: unknown, key: unknown, iv: unknown, options?: {
+            authTagLength?: number;
+        }): {
+            getAuthTag(): Uint8Array;
+            readonly "__#private@#decrypt": boolean;
+            readonly "__#private@#mode": Mode;
+            readonly "__#private@#xk": Uint32Array;
+            readonly "__#private@#xkDec": Uint32Array | undefined;
+            "__#private@#padding": boolean;
+            "__#private@#finished": boolean;
+            "__#private@#started": boolean;
+            /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+            "__#private@#pending": Bytes;
+            /** CBC's chaining block. */
+            "__#private@#chain": Bytes | undefined;
+            /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+            "__#private@#counter": Bytes | undefined;
+            "__#private@#keystream": Bytes;
+            /** GCM. */
+            "__#private@#ghash": GHASH | undefined;
+            "__#private@#tagMask": Bytes | undefined;
+            "__#private@#ghashPending": Bytes;
+            "__#private@#aadLength": number;
+            "__#private@#dataLength": number;
+            "__#private@#authTagLength": number | undefined;
+            "__#private@#authTag": Bytes | undefined;
+            setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+            setAAD(buffer: unknown, _options?: {
+                plaintextLength?: number;
+            }): /*elided*/ any;
+            "__#private@#getTag"(): Bytes;
+            "__#private@#setTag"(tag: unknown, encoding?: string): void;
+            update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+            final(outputEncoding?: string): unknown;
+            "__#private@#process"(input: Bytes): Bytes;
+            /** XOR with the counter's keystream, carrying a partial block across calls. */
+            "__#private@#stream"(input: Bytes): Bytes;
+            /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+            "__#private@#absorb"(ciphertext: Bytes): void;
+            /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+            "__#private@#blocks"(input: Bytes): Bytes;
+            "__#private@#block"(block: Bytes): Bytes;
+            "__#private@#finish"(): Bytes;
+            "__#private@#finishGcm"(): Bytes;
+        };
+    };
+    Decipheriv: {
+        new (algorithm: unknown, key: unknown, iv: unknown, options?: {
+            authTagLength?: number;
+        }): {
+            setAuthTag(tag: unknown, encoding?: string): /*elided*/ any;
+            readonly "__#private@#decrypt": boolean;
+            readonly "__#private@#mode": Mode;
+            readonly "__#private@#xk": Uint32Array;
+            readonly "__#private@#xkDec": Uint32Array | undefined;
+            "__#private@#padding": boolean;
+            "__#private@#finished": boolean;
+            "__#private@#started": boolean;
+            /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+            "__#private@#pending": Bytes;
+            /** CBC's chaining block. */
+            "__#private@#chain": Bytes | undefined;
+            /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+            "__#private@#counter": Bytes | undefined;
+            "__#private@#keystream": Bytes;
+            /** GCM. */
+            "__#private@#ghash": GHASH | undefined;
+            "__#private@#tagMask": Bytes | undefined;
+            "__#private@#ghashPending": Bytes;
+            "__#private@#aadLength": number;
+            "__#private@#dataLength": number;
+            "__#private@#authTagLength": number | undefined;
+            "__#private@#authTag": Bytes | undefined;
+            setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+            setAAD(buffer: unknown, _options?: {
+                plaintextLength?: number;
+            }): /*elided*/ any;
+            "__#private@#getTag"(): Bytes;
+            "__#private@#setTag"(tag: unknown, encoding?: string): void;
+            update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+            final(outputEncoding?: string): unknown;
+            "__#private@#process"(input: Bytes): Bytes;
+            /** XOR with the counter's keystream, carrying a partial block across calls. */
+            "__#private@#stream"(input: Bytes): Bytes;
+            /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+            "__#private@#absorb"(ciphertext: Bytes): void;
+            /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+            "__#private@#blocks"(input: Bytes): Bytes;
+            "__#private@#block"(block: Bytes): Bytes;
+            "__#private@#finish"(): Bytes;
+            "__#private@#finishGcm"(): Bytes;
+        };
+    };
+    createCipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: {
+        authTagLength?: number;
+    }) => {
+        getAuthTag(): Uint8Array;
+        readonly "__#private@#decrypt": boolean;
+        readonly "__#private@#mode": Mode;
+        readonly "__#private@#xk": Uint32Array;
+        readonly "__#private@#xkDec": Uint32Array | undefined;
+        "__#private@#padding": boolean;
+        "__#private@#finished": boolean;
+        "__#private@#started": boolean;
+        /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+        "__#private@#pending": Bytes;
+        /** CBC's chaining block. */
+        "__#private@#chain": Bytes | undefined;
+        /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+        "__#private@#counter": Bytes | undefined;
+        "__#private@#keystream": Bytes;
+        /** GCM. */
+        "__#private@#ghash": GHASH | undefined;
+        "__#private@#tagMask": Bytes | undefined;
+        "__#private@#ghashPending": Bytes;
+        "__#private@#aadLength": number;
+        "__#private@#dataLength": number;
+        "__#private@#authTagLength": number | undefined;
+        "__#private@#authTag": Bytes | undefined;
+        setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+        setAAD(buffer: unknown, _options?: {
+            plaintextLength?: number;
+        }): /*elided*/ any;
+        "__#private@#getTag"(): Bytes;
+        "__#private@#setTag"(tag: unknown, encoding?: string): void;
+        update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+        final(outputEncoding?: string): unknown;
+        "__#private@#process"(input: Bytes): Bytes;
+        /** XOR with the counter's keystream, carrying a partial block across calls. */
+        "__#private@#stream"(input: Bytes): Bytes;
+        /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+        "__#private@#absorb"(ciphertext: Bytes): void;
+        /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+        "__#private@#blocks"(input: Bytes): Bytes;
+        "__#private@#block"(block: Bytes): Bytes;
+        "__#private@#finish"(): Bytes;
+        "__#private@#finishGcm"(): Bytes;
+    };
+    createDecipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: {
+        authTagLength?: number;
+    }) => {
+        setAuthTag(tag: unknown, encoding?: string): /*elided*/ any;
+        readonly "__#private@#decrypt": boolean;
+        readonly "__#private@#mode": Mode;
+        readonly "__#private@#xk": Uint32Array;
+        readonly "__#private@#xkDec": Uint32Array | undefined;
+        "__#private@#padding": boolean;
+        "__#private@#finished": boolean;
+        "__#private@#started": boolean;
+        /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+        "__#private@#pending": Bytes;
+        /** CBC's chaining block. */
+        "__#private@#chain": Bytes | undefined;
+        /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+        "__#private@#counter": Bytes | undefined;
+        "__#private@#keystream": Bytes;
+        /** GCM. */
+        "__#private@#ghash": GHASH | undefined;
+        "__#private@#tagMask": Bytes | undefined;
+        "__#private@#ghashPending": Bytes;
+        "__#private@#aadLength": number;
+        "__#private@#dataLength": number;
+        "__#private@#authTagLength": number | undefined;
+        "__#private@#authTag": Bytes | undefined;
+        setAutoPadding(autoPadding?: boolean): /*elided*/ any;
+        setAAD(buffer: unknown, _options?: {
+            plaintextLength?: number;
+        }): /*elided*/ any;
+        "__#private@#getTag"(): Bytes;
+        "__#private@#setTag"(tag: unknown, encoding?: string): void;
+        update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown;
+        final(outputEncoding?: string): unknown;
+        "__#private@#process"(input: Bytes): Bytes;
+        /** XOR with the counter's keystream, carrying a partial block across calls. */
+        "__#private@#stream"(input: Bytes): Bytes;
+        /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+        "__#private@#absorb"(ciphertext: Bytes): void;
+        /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+        "__#private@#blocks"(input: Bytes): Bytes;
+        "__#private@#block"(block: Bytes): Bytes;
+        "__#private@#finish"(): Bytes;
+        "__#private@#finishGcm"(): Bytes;
+    };
+};
+export {};