@btoon/js 0.0.0-stage → 0.1.1

package/dist/cjs/node.d.ts

@@ -0,0 +1,64 @@
+/**
+ * BTOON for JavaScript and TypeScript — Node.js entry point (also used by Bun). Same API
+ * as the portable entry; synchronous compression and signing use `node:zlib` (zlib,
+ * Brotli, and Zstandard where Node.js has it) and `node:crypto`.
+ *
+ * @packageDocumentation
+ */
+import { type BinaryInput } from './core.js';
+import type { DecodeOptions, EncodeOptions } from './options.js';
+export { SPEC_VERSION, VERSION } from './constants.js';
+export type { BinaryInput } from './core.js';
+export { BtoonError, type BtoonErrorCode } from './errors.js';
+export type { Codec, CodecRegistry, CompressionAlgorithm, DecodeOptions, EncodeOptions } from './options.js';
+export { Ext, Timestamp } from './values.js';
+/**
+ * Encodes a value as canonical BTOON (SPEC §4): identical values produce identical bytes
+ * in every conforming implementation.
+ *
+ * Accepted values: `null`/`undefined` (nil), booleans, numbers (safe integers as integers,
+ * everything else — including `-0`, `NaN` and integral values beyond ±2^53 — as float64),
+ * `bigint`, strings (must not contain lone surrogates), `Uint8Array`/`ArrayBuffer`/other
+ * typed arrays and `DataView` (binary), `Float32Array`/`Float64Array` (float vectors),
+ * arrays, plain objects and `Map`s with string keys (maps, keys sorted by UTF-8 bytes),
+ * `Date` and {@link Timestamp} (timestamps), and {@link Ext}. Any other object is encoded
+ * the way `JSON.stringify` sees it: the result of its `toJSON()` method if it has one
+ * (called once), otherwise a map of its own enumerable string-keyed properties; `Number`,
+ * `String`, `Boolean` and `BigInt` wrapper objects are unwrapped. Functions and symbols are
+ * rejected. Arrays of uniform objects use the tabular encoding when it is smaller.
+ *
+ * With `compress` or `hmacKey`, the document is wrapped in a compression and/or signed
+ * envelope, layered as sign(compress(document)).
+ *
+ * @throws {BtoonError} `invalid_argument` for functions, symbols or invalid options, `max_depth`
+ *   for values nested deeper than `maxDepth` (including cycles), `invalid_utf8` for strings
+ *   with lone surrogates, `unsupported_compression` if the algorithm has no synchronous
+ *   implementation here (see `encodeAsync` and `options.codecs`).
+ */
+export declare function encode(value: unknown, options?: EncodeOptions): Uint8Array<ArrayBuffer>;
+/**
+ * Decodes one BTOON document, enforcing SPEC §7: bounds-checked reads, a nesting limit,
+ * no allocation beyond what the input justifies, strict UTF-8, unique map keys and no
+ * trailing bytes. Compression envelopes are decompressed (with the output capped at the
+ * declared size and `maxDecompressedSize`); with `hmacKey` the signature is verified before
+ * anything is parsed.
+ *
+ * Maps decode to plain objects. A `"__proto__"` key becomes an own property (as with
+ * `JSON.parse`); it never changes an object's prototype.
+ *
+ * @throws {BtoonError} with the SPEC §7 error code describing the problem.
+ */
+export declare function decode(data: BinaryInput, options?: DecodeOptions): unknown;
+/**
+ * Like {@link encode}, but compresses with `CompressionStream` (when the runtime supports
+ * the algorithm) and signs with WebCrypto, falling back to the synchronous implementations.
+ * Rejects with a {@link BtoonError}.
+ */
+export declare function encodeAsync(value: unknown, options?: EncodeOptions): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
+ * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
+ * to the synchronous implementations. The input is copied first, so the caller may reuse
+ * its buffer immediately. Rejects with a {@link BtoonError}.
+ */
+export declare function decodeAsync(data: BinaryInput, options?: DecodeOptions): Promise<unknown>;

package/dist/cjs/node.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = exports.Ext = exports.BtoonError = exports.VERSION = exports.SPEC_VERSION = void 0;
+exports.encode = encode;
+exports.decode = decode;
+exports.encodeAsync = encodeAsync;
+exports.decodeAsync = decodeAsync;
+/**
+ * BTOON for JavaScript and TypeScript — Node.js entry point (also used by Bun). Same API
+ * as the portable entry; synchronous compression and signing use `node:zlib` (zlib,
+ * Brotli, and Zstandard where Node.js has it) and `node:crypto`.
+ *
+ * @packageDocumentation
+ */
+const core_js_1 = require("./core.js");
+const platform_node_js_1 = require("./platform-node.js");
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "SPEC_VERSION", { enumerable: true, get: function () { return constants_js_1.SPEC_VERSION; } });
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return constants_js_1.VERSION; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "BtoonError", { enumerable: true, get: function () { return errors_js_1.BtoonError; } });
+var values_js_1 = require("./values.js");
+Object.defineProperty(exports, "Ext", { enumerable: true, get: function () { return values_js_1.Ext; } });
+Object.defineProperty(exports, "Timestamp", { enumerable: true, get: function () { return values_js_1.Timestamp; } });
+/**
+ * Encodes a value as canonical BTOON (SPEC §4): identical values produce identical bytes
+ * in every conforming implementation.
+ *
+ * Accepted values: `null`/`undefined` (nil), booleans, numbers (safe integers as integers,
+ * everything else — including `-0`, `NaN` and integral values beyond ±2^53 — as float64),
+ * `bigint`, strings (must not contain lone surrogates), `Uint8Array`/`ArrayBuffer`/other
+ * typed arrays and `DataView` (binary), `Float32Array`/`Float64Array` (float vectors),
+ * arrays, plain objects and `Map`s with string keys (maps, keys sorted by UTF-8 bytes),
+ * `Date` and {@link Timestamp} (timestamps), and {@link Ext}. Any other object is encoded
+ * the way `JSON.stringify` sees it: the result of its `toJSON()` method if it has one
+ * (called once), otherwise a map of its own enumerable string-keyed properties; `Number`,
+ * `String`, `Boolean` and `BigInt` wrapper objects are unwrapped. Functions and symbols are
+ * rejected. Arrays of uniform objects use the tabular encoding when it is smaller.
+ *
+ * With `compress` or `hmacKey`, the document is wrapped in a compression and/or signed
+ * envelope, layered as sign(compress(document)).
+ *
+ * @throws {BtoonError} `invalid_argument` for functions, symbols or invalid options, `max_depth`
+ *   for values nested deeper than `maxDepth` (including cycles), `invalid_utf8` for strings
+ *   with lone surrogates, `unsupported_compression` if the algorithm has no synchronous
+ *   implementation here (see `encodeAsync` and `options.codecs`).
+ */
+function encode(value, options) {
+    return (0, core_js_1.encodeWith)(value, options, platform_node_js_1.nodePlatform);
+}
+/**
+ * Decodes one BTOON document, enforcing SPEC §7: bounds-checked reads, a nesting limit,
+ * no allocation beyond what the input justifies, strict UTF-8, unique map keys and no
+ * trailing bytes. Compression envelopes are decompressed (with the output capped at the
+ * declared size and `maxDecompressedSize`); with `hmacKey` the signature is verified before
+ * anything is parsed.
+ *
+ * Maps decode to plain objects. A `"__proto__"` key becomes an own property (as with
+ * `JSON.parse`); it never changes an object's prototype.
+ *
+ * @throws {BtoonError} with the SPEC §7 error code describing the problem.
+ */
+function decode(data, options) {
+    return (0, core_js_1.decodeWith)(data, options, platform_node_js_1.nodePlatform);
+}
+/**
+ * Like {@link encode}, but compresses with `CompressionStream` (when the runtime supports
+ * the algorithm) and signs with WebCrypto, falling back to the synchronous implementations.
+ * Rejects with a {@link BtoonError}.
+ */
+function encodeAsync(value, options) {
+    return (0, core_js_1.encodeAsyncWith)(value, options, platform_node_js_1.nodePlatform);
+}
+/**
+ * Like {@link decode}, but decompresses with `DecompressionStream` (when the runtime
+ * supports the algorithm) and verifies signatures with `crypto.subtle.verify`, falling back
+ * to the synchronous implementations. The input is copied first, so the caller may reuse
+ * its buffer immediately. Rejects with a {@link BtoonError}.
+ */
+function decodeAsync(data, options) {
+    return (0, core_js_1.decodeAsyncWith)(data, options, platform_node_js_1.nodePlatform);
+}

package/dist/cjs/options.d.ts

@@ -0,0 +1,95 @@
+/** Compression algorithms of the envelope (SPEC §6). Only `zlib` is mandatory. */
+export type CompressionAlgorithm = 'zlib' | 'lz4' | 'zstd' | 'brotli' | 'snappy';
+/**
+ * A user-supplied compression codec (see {@link CodecRegistry}). Either function may be
+ * synchronous or return a Promise; synchronous `encode`/`decode` accept only synchronous
+ * results.
+ */
+export interface Codec {
+    /**
+     * Compress a whole document. The output must be the payload format SPEC §6 requires for
+     * the algorithm: an RFC 1950 zlib stream, an LZ4 *block* (no frame), a Zstandard frame,
+     * a Brotli stream, or raw Snappy.
+     */
+    compress?(data: Uint8Array): Uint8Array | Promise<Uint8Array>;
+    /**
+     * Decompress a payload. `uncompressedSize` is the size declared by the envelope, already
+     * checked against `maxDecompressedSize`; implementations must not produce more than that
+     * (LZ4 block decoders need it as the output size). The result must be exactly that long.
+     */
+    decompress?(data: Uint8Array, uncompressedSize: number): Uint8Array | Promise<Uint8Array>;
+}
+/**
+ * Compression codecs supplied by the caller, keyed by algorithm. A codec here takes
+ * precedence over the built-in implementations, so this is how to add LZ4 or Snappy, or
+ * synchronous zlib compression in browsers (for example with `fflate`).
+ */
+export type CodecRegistry = {
+    readonly [A in CompressionAlgorithm]?: Codec;
+};
+/** Options of `encode` / `encodeAsync`. */
+export interface EncodeOptions {
+    /** Wrap the document in a compression envelope (SPEC §6). Default `false`. */
+    compress?: boolean;
+    /** Algorithm used when `compress` is true. Default `'zlib'`. Has no effect unless `compress` is true. */
+    compression?: CompressionAlgorithm;
+    /** Use the tabular (columnar) encoding where SPEC §5.6.2's size rule says so. Default `true`. */
+    autoTabular?: boolean;
+    /** Maximum container nesting; deeper or cyclic values throw `max_depth`. Default `128`. */
+    maxDepth?: number;
+    /** Sign the output with HMAC-SHA256 (SPEC §8). A string is used as its UTF-8 bytes. Must not be empty. */
+    hmacKey?: Uint8Array | string;
+    /** Caller-supplied compression codecs. */
+    codecs?: CodecRegistry;
+}
+/** Options of `decode` / `decodeAsync`. */
+export interface DecodeOptions {
+    /**
+     * SPEC §7 strict mode. Default `true`. Non-strict mode allows trailing bytes and
+     * duplicate keys (last wins) and replaces invalid UTF-8 with U+FFFD; bounds, depth and
+     * allocation checks are never relaxed.
+     */
+    strict?: boolean;
+    /** Maximum container nesting; deeper input throws `max_depth`. Default `128`. */
+    maxDepth?: number;
+    /** Largest accepted `uncompressed_size` of a compression envelope, in bytes. Default 256 MiB. */
+    maxDecompressedSize?: number;
+    /** Accept compression envelopes. Default `true`; when `false` they throw `invalid_envelope`. */
+    autoDecompress?: boolean;
+    /** Require a signed envelope and verify it (SPEC §8) before parsing. Must not be empty. */
+    hmacKey?: Uint8Array | string;
+    /**
+     * How timestamp (-1), date (-2) and datetime (-3) values decode. `'date'` (default):
+     * `Date` (millisecond precision, offset dropped; instants outside the range of `Date`
+     * become `Timestamp`). `'object'`: always {@link Timestamp}, with full precision.
+     */
+    timestamps?: 'date' | 'object';
+    /**
+     * `'auto'` (default): integers decode to `number` when they are safe integers and to
+     * `bigint` otherwise. `'always'`: integers written with a 64-bit marker (uint64/int64)
+     * or as a bigint extension always decode to `bigint`.
+     */
+    bigint?: 'auto' | 'always';
+    /** Caller-supplied compression codecs. */
+    codecs?: CodecRegistry;
+}
+export interface EncodeConfig {
+    compress: boolean;
+    algorithm: CompressionAlgorithm;
+    autoTabular: boolean;
+    maxDepth: number;
+    hmacKey: Uint8Array | undefined;
+    codecs: CodecRegistry | undefined;
+}
+export interface DecodeConfig {
+    strict: boolean;
+    maxDepth: number;
+    maxDecompressedSize: number;
+    autoDecompress: boolean;
+    hmacKey: Uint8Array | undefined;
+    timestampObjects: boolean;
+    bigintAlways: boolean;
+    codecs: CodecRegistry | undefined;
+}
+export declare function encodeConfig(options: EncodeOptions | undefined): EncodeConfig;
+export declare function decodeConfig(options: DecodeOptions | undefined): DecodeConfig;

package/dist/cjs/options.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeConfig = encodeConfig;
+exports.decodeConfig = decodeConfig;
+const constants_js_1 = require("./constants.js");
+const errors_js_1 = require("./errors.js");
+const utf8_js_1 = require("./utf8.js");
+const values_js_1 = require("./values.js");
+const DEFAULT_ENCODE = Object.freeze({
+    compress: false,
+    algorithm: 'zlib',
+    autoTabular: true,
+    maxDepth: constants_js_1.DEFAULT_MAX_DEPTH,
+    hmacKey: undefined,
+    codecs: undefined,
+});
+const DEFAULT_DECODE = Object.freeze({
+    strict: true,
+    maxDepth: constants_js_1.DEFAULT_MAX_DEPTH,
+    maxDecompressedSize: constants_js_1.DEFAULT_MAX_DECOMPRESSED_SIZE,
+    autoDecompress: true,
+    hmacKey: undefined,
+    timestampObjects: false,
+    bigintAlways: false,
+    codecs: undefined,
+});
+function optionsObject(options, what) {
+    if (options === undefined || options === null)
+        return undefined;
+    if (typeof options !== 'object')
+        throw (0, errors_js_1.fail)('invalid_argument', `${what} options must be an object`);
+    return options;
+}
+function bool(o, name, dflt) {
+    const v = o[name];
+    if (v === undefined)
+        return dflt;
+    if (typeof v !== 'boolean')
+        throw (0, errors_js_1.fail)('invalid_argument', `option ${name} must be a boolean`);
+    return v;
+}
+function count(o, name, dflt) {
+    const v = o[name];
+    if (v === undefined)
+        return dflt;
+    if (typeof v !== 'number' || !Number.isSafeInteger(v) || v < 0) {
+        throw (0, errors_js_1.fail)('invalid_argument', `option ${name} must be a non-negative integer`);
+    }
+    return v;
+}
+function oneOf(o, name, allowed, dflt) {
+    const v = o[name];
+    if (v === undefined)
+        return dflt;
+    if (typeof v !== 'string' || !allowed.includes(v)) {
+        throw (0, errors_js_1.fail)('invalid_argument', `option ${name} must be one of ${allowed.map((a) => `'${a}'`).join(', ')}`);
+    }
+    return v;
+}
+function hmacKey(o) {
+    const v = o.hmacKey;
+    if (v === undefined)
+        return undefined;
+    let key;
+    if (typeof v === 'string') {
+        if (!(0, utf8_js_1.isWellFormed)(v))
+            throw (0, errors_js_1.fail)('invalid_argument', 'hmacKey string contains a lone surrogate');
+        key = new TextEncoder().encode(v);
+    }
+    else if ((0, values_js_1.isUint8Array)(v)) {
+        key = Uint8Array.prototype.slice.call(v); // private copy: immune to later mutation
+    }
+    else {
+        throw (0, errors_js_1.fail)('invalid_argument', 'option hmacKey must be a Uint8Array or a string');
+    }
+    if (key.length === 0)
+        throw (0, errors_js_1.fail)('invalid_argument', 'option hmacKey must not be empty');
+    return key;
+}
+function codecs(o) {
+    const v = o.codecs;
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== 'object' || v === null)
+        throw (0, errors_js_1.fail)('invalid_argument', 'option codecs must be an object');
+    for (const name of constants_js_1.ALGORITHM_NAMES) {
+        const c = v[name];
+        if (c === undefined)
+            continue;
+        if (typeof c !== 'object' || c === null)
+            throw (0, errors_js_1.fail)('invalid_argument', `codecs.${name} must be an object`);
+        for (const fn of ['compress', 'decompress']) {
+            const f = c[fn];
+            if (f !== undefined && typeof f !== 'function') {
+                throw (0, errors_js_1.fail)('invalid_argument', `codecs.${name}.${fn} must be a function`);
+            }
+        }
+    }
+    return v;
+}
+function encodeConfig(options) {
+    const o = optionsObject(options, 'encode');
+    if (o === undefined)
+        return DEFAULT_ENCODE;
+    return {
+        compress: bool(o, 'compress', false),
+        algorithm: oneOf(o, 'compression', constants_js_1.ALGORITHM_NAMES, 'zlib'),
+        autoTabular: bool(o, 'autoTabular', true),
+        maxDepth: count(o, 'maxDepth', constants_js_1.DEFAULT_MAX_DEPTH),
+        hmacKey: hmacKey(o),
+        codecs: codecs(o),
+    };
+}
+function decodeConfig(options) {
+    const o = optionsObject(options, 'decode');
+    if (o === undefined)
+        return DEFAULT_DECODE;
+    return {
+        strict: bool(o, 'strict', true),
+        maxDepth: count(o, 'maxDepth', constants_js_1.DEFAULT_MAX_DEPTH),
+        maxDecompressedSize: count(o, 'maxDecompressedSize', constants_js_1.DEFAULT_MAX_DECOMPRESSED_SIZE),
+        autoDecompress: bool(o, 'autoDecompress', true),
+        hmacKey: hmacKey(o),
+        timestampObjects: oneOf(o, 'timestamps', ['date', 'object'], 'date') === 'object',
+        bigintAlways: oneOf(o, 'bigint', ['auto', 'always'], 'auto') === 'always',
+        codecs: codecs(o),
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/platform-node.d.ts

@@ -0,0 +1,3 @@
+import type { Platform } from './core.js';
+/** Node.js (and Bun): node:zlib for zlib, Brotli and Zstandard; node:crypto for HMAC. */
+export declare const nodePlatform: Platform;

package/dist/cjs/platform-node.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodePlatform = void 0;
+const node_crypto_1 = require("node:crypto");
+const zlib = __importStar(require("node:zlib"));
+const errors_js_1 = require("./errors.js");
+const inflate_js_1 = require("./inflate.js");
+function nodeFn(name) {
+    const f = zlib[name];
+    return typeof f === 'function' ? f : undefined;
+}
+function plain(b) {
+    return new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+}
+/**
+ * Wraps a node:zlib `*Sync` decompressor: output is capped at the declared size
+ * (`maxOutputLength`), and input left over after the end of the stream is rejected.
+ */
+function decompressor(alg, fn, extra) {
+    if (fn === undefined)
+        return undefined;
+    return (data, size) => {
+        let r;
+        try {
+            r = fn(data, { ...extra?.(size), info: true, maxOutputLength: Math.max(1, size) });
+        }
+        catch (e) {
+            if (e.code === 'ERR_BUFFER_TOO_LARGE') {
+                throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload decompresses to more than the declared size`, e);
+            }
+            throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload is corrupt: ${e.message}`, e);
+        }
+        let out;
+        let consumed;
+        if (r instanceof Uint8Array) {
+            out = r;
+        }
+        else {
+            const info = r;
+            out = info.buffer;
+            consumed = info.engine?.bytesWritten;
+        }
+        if (typeof consumed === 'number') {
+            if (consumed !== data.length)
+                throw (0, errors_js_1.fail)('invalid_envelope', `${alg} payload has trailing bytes`);
+        }
+        else if (alg === 'zlib') {
+            // A runtime that doesn't report consumed input: the stream must end in its Adler-32.
+            const n = data.length;
+            const trailer = n >= 4 ? ((data[n - 4] << 24) | (data[n - 3] << 16) | (data[n - 2] << 8) | data[n - 1]) >>> 0 : -1;
+            if (trailer !== (0, inflate_js_1.adler32)(out))
+                throw (0, errors_js_1.fail)('invalid_envelope', 'zlib payload has trailing bytes');
+        }
+        return plain(out);
+    };
+}
+function compressor(fn, options) {
+    if (fn === undefined)
+        return undefined;
+    return (data) => plain(fn(data, options));
+}
+const decompress = {};
+const compress = {};
+decompress.zlib = decompressor('zlib', nodeFn('inflateSync'));
+compress.zlib = compressor(nodeFn('deflateSync'), { level: 6 });
+const brotliQuality = zlib.constants?.BROTLI_PARAM_QUALITY;
+if (brotliQuality !== undefined) {
+    decompress.brotli = decompressor('brotli', nodeFn('brotliDecompressSync'));
+    compress.brotli = compressor(nodeFn('brotliCompressSync'), { params: { [brotliQuality]: 6 } });
+}
+// node:zlib has Zstandard from Node.js 22.15 / 23.8. SPEC §6: bound the decoder's memory
+// by rejecting frames whose window exceeds max(8 MiB, min(uncompressed_size, 128 MiB)).
+const zstdWindowLogMax = zlib.constants?.ZSTD_d_windowLogMax;
+decompress.zstd = decompressor('zstd', nodeFn('zstdDecompressSync'), (size) => zstdWindowLogMax === undefined
+    ? {}
+    : { params: { [zstdWindowLogMax]: Math.ceil(Math.log2(Math.max(8 << 20, Math.min(size, 128 << 20)))) } });
+compress.zstd = compressor(nodeFn('zstdCompressSync'), {});
+for (const alg of Object.keys(decompress)) {
+    if (decompress[alg] === undefined)
+        delete decompress[alg];
+}
+for (const alg of Object.keys(compress)) {
+    if (compress[alg] === undefined)
+        delete compress[alg];
+}
+/** Node.js (and Bun): node:zlib for zlib, Brotli and Zstandard; node:crypto for HMAC. */
+exports.nodePlatform = {
+    decompress,
+    compress,
+    hmac(key, parts) {
+        const h = (0, node_crypto_1.createHmac)('sha256', key);
+        for (const p of parts)
+            h.update(p);
+        return plain(h.digest());
+    },
+    equal(a, b) {
+        return a.length === b.length && (0, node_crypto_1.timingSafeEqual)(a, b);
+    },
+};

package/dist/cjs/platform-portable.d.ts

@@ -0,0 +1,7 @@
+import type { Platform } from './core.js';
+/**
+ * Environments without Node.js built-ins (browsers, Deno, workers): synchronous zlib
+ * decompression and HMAC-SHA256 in pure JavaScript. Synchronous compression needs a
+ * caller-supplied codec; encodeAsync uses CompressionStream instead.
+ */
+export declare const portablePlatform: Platform;

package/dist/cjs/platform-portable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portablePlatform = void 0;
+const inflate_js_1 = require("./inflate.js");
+const sha256_js_1 = require("./sha256.js");
+/**
+ * Environments without Node.js built-ins (browsers, Deno, workers): synchronous zlib
+ * decompression and HMAC-SHA256 in pure JavaScript. Synchronous compression needs a
+ * caller-supplied codec; encodeAsync uses CompressionStream instead.
+ */
+exports.portablePlatform = {
+    decompress: { zlib: inflate_js_1.inflateZlib },
+    compress: {},
+    hmac: sha256_js_1.hmacSha256,
+    equal: sha256_js_1.timingSafeEqual,
+};

package/dist/cjs/sha256.d.ts

@@ -0,0 +1,5 @@
+export declare function sha256(data: Uint8Array): Uint8Array;
+/** HMAC-SHA256 over the concatenation of `parts` (no copy of the parts is made). */
+export declare function hmacSha256(key: Uint8Array, parts: readonly Uint8Array[]): Uint8Array;
+/** Compares two byte strings in time that depends only on their length. */
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;