boom-format 0.9.0

package/dist/cli.global.js

@@ -0,0 +1,4249 @@
+#!/usr/bin/env node
+"use strict";
+var Boom = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // src/cli.ts
+  var fs = __toESM(__require("fs"), 1);
+  var path = __toESM(__require("path"), 1);
+
+  // src/errors.ts
+  var BoomError = class _BoomError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BoomError";
+      Object.setPrototypeOf(this, _BoomError.prototype);
+    }
+  };
+
+  // src/core.ts
+  var VERSION = 1;
+  var BOOM_DICTIONARY_V1 = Object.freeze([
+    // 0-31: Most common keys (highest frequency - 1 byte encoding)
+    "id",
+    "name",
+    "type",
+    "content",
+    "data",
+    "value",
+    "text",
+    "message",
+    "status",
+    "error",
+    "result",
+    "code",
+    "key",
+    "index",
+    "role",
+    "model",
+    "user",
+    "items",
+    "count",
+    "total",
+    "page",
+    "size",
+    "url",
+    "path",
+    "title",
+    "body",
+    "query",
+    "token",
+    "version",
+    "created",
+    "updated",
+    "source",
+    // 32-63: API response fields
+    "success",
+    "response",
+    "request",
+    "payload",
+    "params",
+    "headers",
+    "method",
+    "endpoint",
+    "description",
+    "label",
+    "meta",
+    "info",
+    "details",
+    "options",
+    "config",
+    "settings",
+    "enabled",
+    "disabled",
+    "active",
+    "visible",
+    "required",
+    "optional",
+    "default",
+    "custom",
+    "input",
+    "output",
+    "format",
+    "encoding",
+    "language",
+    "locale",
+    "timezone",
+    "currency",
+    // 64-95: AI/LLM streaming fields (OpenAI, Anthropic, Cohere, etc.)
+    "choices",
+    "delta",
+    "finish_reason",
+    "usage",
+    "prompt_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "messages",
+    "assistant",
+    "system",
+    "function",
+    "tool",
+    "tools",
+    "tool_calls",
+    "tool_call",
+    "arguments",
+    "stream",
+    "chunk",
+    "object",
+    "chat",
+    "completion",
+    "completions",
+    "embedding",
+    "embeddings",
+    "logprobs",
+    "top_logprobs",
+    "stop",
+    "stop_reason",
+    "stop_sequence",
+    "max_tokens",
+    "temperature",
+    "top_p",
+    // 96-127: Status and state values (1 byte encoding)
+    "pending",
+    "completed",
+    "failed",
+    "cancelled",
+    "processing",
+    "queued",
+    "running",
+    "stopped",
+    "ok",
+    "done",
+    "ready",
+    "loading",
+    "waiting",
+    "blocked",
+    "paused",
+    "resumed",
+    "open",
+    "closed",
+    "connected",
+    "disconnected",
+    "online",
+    "offline",
+    "available",
+    "unavailable",
+    "valid",
+    "invalid",
+    "verified",
+    "unverified",
+    "approved",
+    "rejected",
+    "expired",
+    "revoked",
+    // 128-159: HTTP and headers
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "HEAD",
+    "OPTIONS",
+    "CONNECT",
+    "content-type",
+    "authorization",
+    "accept",
+    "accept-encoding",
+    "cache-control",
+    "user-agent",
+    "origin",
+    "referer",
+    "application/json",
+    "application/octet-stream",
+    "text/plain",
+    "text/html",
+    "multipart/form-data",
+    "Bearer",
+    "Basic",
+    "gzip",
+    "x-request-id",
+    "x-correlation-id",
+    "x-api-key",
+    "x-auth-token",
+    "etag",
+    "last-modified",
+    "if-none-match",
+    "if-modified-since",
+    // 160-191: Timestamps and dates
+    "created_at",
+    "updated_at",
+    "deleted_at",
+    "expires_at",
+    "started_at",
+    "ended_at",
+    "published_at",
+    "modified_at",
+    "createdAt",
+    "updatedAt",
+    "deletedAt",
+    "expiresAt",
+    "startedAt",
+    "endedAt",
+    "publishedAt",
+    "modifiedAt",
+    "start_date",
+    "end_date",
+    "due_date",
+    "birth_date",
+    "timestamp",
+    "datetime",
+    "date",
+    "time",
+    "year",
+    "month",
+    "day",
+    "hour",
+    "minute",
+    "second",
+    "millisecond",
+    "duration",
+    // 192-223: User/auth fields
+    "username",
+    "password",
+    "email",
+    "phone",
+    "address",
+    "avatar",
+    "profile",
+    "session",
+    "firstName",
+    "lastName",
+    "fullName",
+    "displayName",
+    "first_name",
+    "last_name",
+    "full_name",
+    "display_name",
+    "roles",
+    "permissions",
+    "groups",
+    "teams",
+    "organization",
+    "company",
+    "department",
+    "position",
+    "access_token",
+    "refresh_token",
+    "id_token",
+    "api_key",
+    "client_id",
+    "client_secret",
+    "scope",
+    "grant_type",
+    // 224-255: Data types and formats
+    "string",
+    "number",
+    "boolean",
+    "integer",
+    "float",
+    "double",
+    "decimal",
+    "bigint",
+    "array",
+    "object",
+    "null",
+    "undefined",
+    "binary",
+    "base64",
+    "hex",
+    "uuid",
+    "json",
+    "xml",
+    "html",
+    "csv",
+    "yaml",
+    "markdown",
+    "plain",
+    "rich",
+    "utf8",
+    "utf-8",
+    "ascii",
+    "latin1",
+    "iso-8859-1",
+    "unicode",
+    "emoji",
+    "symbol",
+    // 256-287: Error handling
+    "errors",
+    "warnings",
+    "exception",
+    "stack",
+    "trace",
+    "cause",
+    "reason",
+    "context",
+    "error_code",
+    "error_message",
+    "error_type",
+    "error_details",
+    "errorCode",
+    "errorMessage",
+    "errorType",
+    "errorDetails",
+    "not_found",
+    "unauthorized",
+    "forbidden",
+    "bad_request",
+    "server_error",
+    "timeout",
+    "conflict",
+    "rate_limit",
+    "notFound",
+    "badRequest",
+    "serverError",
+    "rateLimit",
+    "validation_error",
+    "parse_error",
+    "network_error",
+    "unknown_error",
+    // 288-319: Collections and pagination
+    "list",
+    "items",
+    "records",
+    "entries",
+    "rows",
+    "columns",
+    "fields",
+    "values",
+    "limit",
+    "offset",
+    "cursor",
+    "next_cursor",
+    "prev_cursor",
+    "has_more",
+    "total_count",
+    "page_count",
+    "first",
+    "last",
+    "next",
+    "previous",
+    "current",
+    "per_page",
+    "page_size",
+    "page_number",
+    "sort",
+    "order",
+    "filter",
+    "search",
+    "asc",
+    "desc",
+    "ascending",
+    "descending",
+    // 320-351: Additional common fields
+    "category",
+    "categories",
+    "tag",
+    "tags",
+    "parent",
+    "children",
+    "ancestors",
+    "descendants",
+    "price",
+    "amount",
+    "quantity",
+    "unit",
+    "discount",
+    "tax",
+    "subtotal",
+    "grand_total",
+    "image",
+    "images",
+    "file",
+    "files",
+    "document",
+    "documents",
+    "attachment",
+    "attachments",
+    "link",
+    "links",
+    "href",
+    "ref",
+    "reference",
+    "references",
+    "relation",
+    "relations",
+    // 352-383: Events and actions
+    "event",
+    "events",
+    "action",
+    "actions",
+    "trigger",
+    "handler",
+    "callback",
+    "listener",
+    "click",
+    "submit",
+    "change",
+    "load",
+    "error",
+    "success",
+    "start",
+    "end",
+    "create",
+    "read",
+    "update",
+    "delete",
+    "insert",
+    "remove",
+    "add",
+    "set",
+    "get",
+    "put",
+    "post",
+    "patch",
+    "fetch",
+    "send",
+    "receive",
+    "process",
+    // 384-415: Metrics and analytics
+    "metric",
+    "metrics",
+    "stat",
+    "stats",
+    "analytics",
+    "tracking",
+    "telemetry",
+    "logging",
+    "latency",
+    "throughput",
+    "bandwidth",
+    "cpu",
+    "memory",
+    "disk",
+    "network",
+    "io",
+    "requests",
+    "responses",
+    "errors",
+    "successes",
+    "failures",
+    "retries",
+    "timeouts",
+    "rate",
+    "min",
+    "max",
+    "avg",
+    "sum",
+    "p50",
+    "p90",
+    "p95",
+    "p99"
+  ]);
+  var DICTIONARY_LOOKUP = new Map(
+    BOOM_DICTIONARY_V1.map((str, idx) => [str, idx])
+  );
+  var DEFAULT_OPTIONS = {
+    maxDepth: 64,
+    maxStringLength: 16 * 1024 * 1024,
+    maxArrayLength: 1e6,
+    enableInterning: true,
+    skipHeader: false,
+    forCompression: false,
+    useBuiltInDictionary: true,
+    sharedDictionary: void 0,
+    strictBinaryMode: false
+  };
+  function mergeOptions(defaults, options) {
+    return { ...defaults, ...options };
+  }
+  function zigzagDecode(value) {
+    return value >>> 1 ^ -(value & 1);
+  }
+  var ByteWriter = class {
+    buffer;
+    view;
+    pos = 0;
+    capacity;
+    constructor(initialCapacity = 8192) {
+      this.capacity = initialCapacity;
+      this.buffer = new Uint8Array(initialCapacity);
+      this.view = new DataView(this.buffer.buffer);
+    }
+    // Inline grow - only called when needed
+    grow(needed) {
+      let newCapacity = this.capacity << 1;
+      const required = this.pos + needed;
+      while (newCapacity < required) newCapacity <<= 1;
+      const newBuffer = new Uint8Array(newCapacity);
+      newBuffer.set(this.buffer.subarray(0, this.pos));
+      this.buffer = newBuffer;
+      this.view = new DataView(this.buffer.buffer);
+      this.capacity = newCapacity;
+    }
+    write(data) {
+      const len = data.length;
+      if (this.pos + len > this.capacity) this.grow(len);
+      this.buffer.set(data, this.pos);
+      this.pos += len;
+    }
+    writeByte(value) {
+      if (this.pos >= this.capacity) this.grow(1);
+      this.buffer[this.pos++] = value;
+    }
+    writeInt8(value) {
+      if (this.pos >= this.capacity) this.grow(1);
+      this.buffer[this.pos++] = value & 255;
+    }
+    writeInt16LE(value) {
+      if (this.pos + 2 > this.capacity) this.grow(2);
+      const buf = this.buffer;
+      const p = this.pos;
+      buf[p] = value & 255;
+      buf[p + 1] = value >> 8 & 255;
+      this.pos = p + 2;
+    }
+    writeInt32LE(value) {
+      if (this.pos + 4 > this.capacity) this.grow(4);
+      const buf = this.buffer;
+      const p = this.pos;
+      buf[p] = value & 255;
+      buf[p + 1] = value >> 8 & 255;
+      buf[p + 2] = value >> 16 & 255;
+      buf[p + 3] = value >> 24 & 255;
+      this.pos = p + 4;
+    }
+    writeBigInt64LE(value) {
+      if (this.pos + 8 > this.capacity) this.grow(8);
+      this.view.setBigInt64(this.pos, value, true);
+      this.pos += 8;
+    }
+    writeBigUInt64LE(value) {
+      if (this.pos + 8 > this.capacity) this.grow(8);
+      this.view.setBigUint64(this.pos, value, true);
+      this.pos += 8;
+    }
+    writeFloat32LE(value) {
+      if (this.pos + 4 > this.capacity) this.grow(4);
+      this.view.setFloat32(this.pos, value, true);
+      this.pos += 4;
+    }
+    writeFloat64LE(value) {
+      if (this.pos + 8 > this.capacity) this.grow(8);
+      this.view.setFloat64(this.pos, value, true);
+      this.pos += 8;
+    }
+    // Inline varint - critical hot path
+    writeVarint(value) {
+      if (this.pos + 5 > this.capacity) this.grow(5);
+      const buf = this.buffer;
+      let p = this.pos;
+      let v = value >>> 0;
+      while (v > 127) {
+        buf[p++] = v & 127 | 128;
+        v >>>= 7;
+      }
+      buf[p++] = v;
+      this.pos = p;
+    }
+    // Fast path for small varints (most common case)
+    writeVarintSmall(value) {
+      if (this.pos + 2 > this.capacity) this.grow(2);
+      const buf = this.buffer;
+      if (value < 128) {
+        buf[this.pos++] = value;
+      } else if (value < 16384) {
+        buf[this.pos++] = value & 127 | 128;
+        buf[this.pos++] = value >>> 7;
+      } else {
+        this.writeVarint(value);
+      }
+    }
+    toUint8Array() {
+      return this.buffer.subarray(0, this.pos);
+    }
+  };
+  var ByteReader = class {
+    view;
+    offset = 0;
+    buf;
+    len;
+    constructor(buffer) {
+      this.buf = buffer;
+      this.len = buffer.length;
+      this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    get remaining() {
+      return this.len - this.offset;
+    }
+    readByte() {
+      return this.buf[this.offset++];
+    }
+    readBytes(count) {
+      const start = this.offset;
+      this.offset += count;
+      return this.buf.subarray(start, this.offset);
+    }
+    readInt8() {
+      const v = this.buf[this.offset++];
+      return v > 127 ? v - 256 : v;
+    }
+    readInt16LE() {
+      const buf = this.buf;
+      const p = this.offset;
+      this.offset = p + 2;
+      const v = buf[p] | buf[p + 1] << 8;
+      return v > 32767 ? v - 65536 : v;
+    }
+    readInt32LE() {
+      const buf = this.buf;
+      const p = this.offset;
+      this.offset = p + 4;
+      return buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24;
+    }
+    readBigInt64LE() {
+      const value = this.view.getBigInt64(this.offset, true);
+      this.offset += 8;
+      return value;
+    }
+    readUInt8() {
+      return this.buf[this.offset++];
+    }
+    readUInt16LE() {
+      const buf = this.buf;
+      const p = this.offset;
+      this.offset = p + 2;
+      return buf[p] | buf[p + 1] << 8;
+    }
+    readUInt32LE() {
+      const buf = this.buf;
+      const p = this.offset;
+      this.offset = p + 4;
+      return (buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24) >>> 0;
+    }
+    readBigUInt64LE() {
+      const value = this.view.getBigUint64(this.offset, true);
+      this.offset += 8;
+      return value;
+    }
+    readFloat32LE() {
+      const value = this.view.getFloat32(this.offset, true);
+      this.offset += 4;
+      return value;
+    }
+    readFloat64LE() {
+      const value = this.view.getFloat64(this.offset, true);
+      this.offset += 8;
+      return value;
+    }
+    // Inline varint for maximum speed
+    readVarint() {
+      const buf = this.buf;
+      let p = this.offset;
+      let b = buf[p++];
+      if (b < 128) {
+        this.offset = p;
+        return b;
+      }
+      let result = b & 127;
+      b = buf[p++];
+      if (b < 128) {
+        this.offset = p;
+        return result | b << 7;
+      }
+      result |= (b & 127) << 7;
+      b = buf[p++];
+      if (b < 128) {
+        this.offset = p;
+        return result | b << 14;
+      }
+      result |= (b & 127) << 14;
+      b = buf[p++];
+      if (b < 128) {
+        this.offset = p;
+        return result | b << 21;
+      }
+      result |= (b & 127) << 21;
+      b = buf[p++];
+      this.offset = p;
+      return (result | b << 28) >>> 0;
+    }
+  };
+  var textEncoder = new TextEncoder();
+  var SMALL_BUF_SIZE = 4096;
+  var LARGE_BUF_SIZE = 65536;
+  var sharedSmallBuf = new Uint8Array(SMALL_BUF_SIZE);
+  var sharedSmallView = new DataView(sharedSmallBuf.buffer);
+  var sharedLargeBuf = new Uint8Array(LARGE_BUF_SIZE);
+  var sharedLargeView = new DataView(sharedLargeBuf.buffer);
+  var sharedDecodeView = null;
+  var sharedDecodeBuf = null;
+  function getDecodeView(buf) {
+    if (sharedDecodeBuf !== buf) {
+      sharedDecodeBuf = buf;
+      sharedDecodeView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return sharedDecodeView;
+  }
+  function isAscii(s) {
+    for (let i = 0; i < s.length; i++) {
+      if (s.charCodeAt(i) > 127) return false;
+    }
+    return true;
+  }
+  function ultraFastEncodeTiny(obj) {
+    const buf = sharedSmallBuf;
+    buf[0] = 66;
+    buf[1] = 79;
+    buf[2] = 79;
+    buf[3] = 77;
+    buf[4] = 1;
+    buf[5] = 0;
+    buf[6] = 80;
+    let pos = 8;
+    let count = 0;
+    for (const k in obj) {
+      count++;
+      if (count > 6) return null;
+      const klen = k.length;
+      if (klen > 20) return null;
+      buf[pos++] = 48;
+      buf[pos++] = klen;
+      for (let i = 0; i < klen; i++) {
+        const c = k.charCodeAt(i);
+        if (c > 127) return null;
+        buf[pos++] = c;
+      }
+      const v = obj[k];
+      if (v === null) {
+        buf[pos++] = 0;
+      } else if (v === true) {
+        buf[pos++] = 2;
+      } else if (v === false) {
+        buf[pos++] = 1;
+      } else {
+        const t = typeof v;
+        if (t === "number") {
+          const n = v;
+          if ((n | 0) === n) {
+            if (n >= -128 && n <= 127) {
+              buf[pos++] = 16;
+              buf[pos++] = n & 255;
+            } else if (n >= -32768 && n <= 32767) {
+              buf[pos++] = 17;
+              buf[pos++] = n & 255;
+              buf[pos++] = n >> 8 & 255;
+            } else {
+              buf[pos++] = 18;
+              buf[pos++] = n & 255;
+              buf[pos++] = n >> 8 & 255;
+              buf[pos++] = n >> 16 & 255;
+              buf[pos++] = n >> 24 & 255;
+            }
+          } else {
+            buf[pos++] = 33;
+            sharedSmallView.setFloat64(pos, n, true);
+            pos += 8;
+          }
+        } else if (t === "string") {
+          const s = v;
+          const slen = s.length;
+          if (slen > 100) return null;
+          buf[pos++] = 48;
+          buf[pos++] = slen;
+          for (let i = 0; i < slen; i++) {
+            const c = s.charCodeAt(i);
+            if (c > 127) return null;
+            buf[pos++] = c;
+          }
+        } else {
+          return null;
+        }
+      }
+    }
+    buf[7] = count;
+    return buf.slice(0, pos);
+  }
+  function writeAsciiInline(buf, pos, s) {
+    const len = s.length;
+    switch (len) {
+      case 1:
+        buf[pos] = s.charCodeAt(0);
+        return;
+      case 2:
+        buf[pos] = s.charCodeAt(0);
+        buf[pos + 1] = s.charCodeAt(1);
+        return;
+      case 3:
+        buf[pos] = s.charCodeAt(0);
+        buf[pos + 1] = s.charCodeAt(1);
+        buf[pos + 2] = s.charCodeAt(2);
+        return;
+      case 4:
+        buf[pos] = s.charCodeAt(0);
+        buf[pos + 1] = s.charCodeAt(1);
+        buf[pos + 2] = s.charCodeAt(2);
+        buf[pos + 3] = s.charCodeAt(3);
+        return;
+      default:
+        for (let i = 0; i < len; i++) buf[pos + i] = s.charCodeAt(i);
+    }
+  }
+  function tryFastEncodeSmallInline(obj, keyCount) {
+    for (const k in obj) {
+      if (k.length > 127 || !isAscii(k)) return null;
+      const v = obj[k];
+      if (v === null || v === true || v === false) continue;
+      const t = typeof v;
+      if (t === "number" || t === "boolean") continue;
+      if (t === "string") {
+        const s = v;
+        if (s.length > 127 || !isAscii(s)) return null;
+        continue;
+      }
+      if (t === "object") {
+        if (Array.isArray(v) || v instanceof Uint8Array) return null;
+        const nested = v;
+        let ncount = 0;
+        for (const nk in nested) {
+          ncount++;
+          if (ncount > 10) return null;
+          if (nk.length > 127 || !isAscii(nk)) return null;
+          const nv = nested[nk];
+          if (nv === null || nv === true || nv === false) continue;
+          const nt = typeof nv;
+          if (nt === "number" || nt === "boolean") continue;
+          if (nt === "string") {
+            const ns = nv;
+            if (ns.length > 127 || !isAscii(ns)) return null;
+            continue;
+          }
+          return null;
+        }
+      } else {
+        return null;
+      }
+    }
+    const buf = sharedSmallBuf;
+    const view = sharedSmallView;
+    buf[0] = 66;
+    buf[1] = 79;
+    buf[2] = 79;
+    buf[3] = 77;
+    buf[4] = 1;
+    buf[5] = 0;
+    buf[6] = 80;
+    buf[7] = keyCount;
+    let pos = 8;
+    for (const k in obj) {
+      const kl = k.length;
+      buf[pos++] = 48;
+      buf[pos++] = kl;
+      writeAsciiInline(buf, pos, k);
+      pos += kl;
+      const v = obj[k];
+      if (v === null) {
+        buf[pos++] = 0;
+      } else if (v === true) {
+        buf[pos++] = 2;
+      } else if (v === false) {
+        buf[pos++] = 1;
+      } else {
+        const t = typeof v;
+        if (t === "string") {
+          const s = v;
+          const sl = s.length;
+          buf[pos++] = 48;
+          buf[pos++] = sl;
+          writeAsciiInline(buf, pos, s);
+          pos += sl;
+        } else if (t === "number") {
+          const n = v;
+          if ((n | 0) === n && n >= -128 && n <= 127) {
+            buf[pos++] = 16;
+            buf[pos++] = n & 255;
+          } else if ((n | 0) === n) {
+            buf[pos++] = 18;
+            buf[pos++] = n & 255;
+            buf[pos++] = n >> 8 & 255;
+            buf[pos++] = n >> 16 & 255;
+            buf[pos++] = n >> 24 & 255;
+          } else {
+            buf[pos++] = 33;
+            view.setFloat64(pos, n, true);
+            pos += 8;
+          }
+        } else {
+          const nested = v;
+          let nkCount = 0;
+          for (const _ in nested) nkCount++;
+          buf[pos++] = 80;
+          buf[pos++] = nkCount;
+          for (const nk in nested) {
+            const nkl = nk.length;
+            buf[pos++] = 48;
+            buf[pos++] = nkl;
+            writeAsciiInline(buf, pos, nk);
+            pos += nkl;
+            const nv = nested[nk];
+            if (nv === null) {
+              buf[pos++] = 0;
+            } else if (nv === true) {
+              buf[pos++] = 2;
+            } else if (nv === false) {
+              buf[pos++] = 1;
+            } else {
+              const nt = typeof nv;
+              if (nt === "string") {
+                const ns = nv;
+                const nsl = ns.length;
+                buf[pos++] = 48;
+                buf[pos++] = nsl;
+                writeAsciiInline(buf, pos, ns);
+                pos += nsl;
+              } else {
+                const nn = nv;
+                if ((nn | 0) === nn && nn >= -128 && nn <= 127) {
+                  buf[pos++] = 16;
+                  buf[pos++] = nn & 255;
+                } else if ((nn | 0) === nn) {
+                  buf[pos++] = 18;
+                  buf[pos++] = nn & 255;
+                  buf[pos++] = nn >> 8 & 255;
+                  buf[pos++] = nn >> 16 & 255;
+                  buf[pos++] = nn >> 24 & 255;
+                } else {
+                  buf[pos++] = 33;
+                  view.setFloat64(pos, nn, true);
+                  pos += 8;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return buf.slice(0, pos);
+  }
+  function tryFastEncodeArrayOfObjects(arr) {
+    const len = arr.length;
+    if (len === 0) return null;
+    const first = arr[0];
+    if (typeof first !== "object" || first === null || Array.isArray(first)) return null;
+    if (len >= 2) {
+      const firstKeys = Object.keys(first).sort().join(",");
+      const second = arr[1];
+      if (typeof second === "object" && second !== null && !Array.isArray(second)) {
+        const secondKeys = Object.keys(second).sort().join(",");
+        if (firstKeys === secondKeys) {
+          return null;
+        }
+      }
+    }
+    let buf = len > 50 ? sharedLargeBuf : sharedSmallBuf;
+    let view = len > 50 ? sharedLargeView : sharedSmallView;
+    let capacity = buf.length;
+    const stringTable = /* @__PURE__ */ Object.create(null);
+    let stringCount = 0;
+    buf[0] = 66;
+    buf[1] = 79;
+    buf[2] = 79;
+    buf[3] = 77;
+    buf[4] = 1;
+    buf[5] = 0;
+    buf[6] = 64;
+    let pos = 7;
+    if (len < 128) {
+      buf[pos++] = len;
+    } else {
+      let v = len;
+      while (v > 127) {
+        buf[pos++] = v & 127 | 128;
+        v >>>= 7;
+      }
+      buf[pos++] = v;
+    }
+    function grow(need) {
+      const required = pos + need;
+      while (capacity < required) capacity <<= 1;
+      const newBuf = new Uint8Array(capacity);
+      newBuf.set(buf.subarray(0, pos));
+      buf = newBuf;
+      view = new DataView(buf.buffer);
+    }
+    for (let i = 0; i < len; i++) {
+      const item = arr[i];
+      if (typeof item !== "object" || item === null || Array.isArray(item)) return null;
+      const obj = item;
+      let keyCount = 0;
+      for (const _ in obj) keyCount++;
+      if (pos + 2 > capacity) grow(256);
+      buf[pos++] = 80;
+      buf[pos++] = keyCount;
+      for (const k in obj) {
+        const keyRef = stringTable[k];
+        if (keyRef !== void 0) {
+          if (pos + 2 > capacity) grow(64);
+          buf[pos++] = 96;
+          buf[pos++] = keyRef;
+        } else {
+          const kl = k.length;
+          if (kl > 127) return null;
+          stringTable[k] = stringCount++;
+          if (pos + 2 + kl > capacity) grow(64 + kl);
+          buf[pos++] = 48;
+          buf[pos++] = kl;
+          for (let j = 0; j < kl; j++) {
+            const c = k.charCodeAt(j);
+            if (c > 127) return null;
+            buf[pos++] = c;
+          }
+        }
+        const v = obj[k];
+        if (v === null) {
+          buf[pos++] = 0;
+        } else if (v === true) {
+          buf[pos++] = 2;
+        } else if (v === false) {
+          buf[pos++] = 1;
+        } else {
+          const t = typeof v;
+          if (t === "string") {
+            const s = v;
+            const sl = s.length;
+            const valRef = stringTable[s];
+            if (valRef !== void 0) {
+              if (pos + 2 > capacity) grow(64);
+              buf[pos++] = 96;
+              buf[pos++] = valRef;
+              continue;
+            }
+            stringTable[s] = stringCount++;
+            if (pos + 2 + sl > capacity) grow(64 + sl);
+            buf[pos++] = 48;
+            if (sl < 128) {
+              buf[pos++] = sl;
+            } else {
+              let lv = sl;
+              while (lv > 127) {
+                buf[pos++] = lv & 127 | 128;
+                lv >>>= 7;
+              }
+              buf[pos++] = lv;
+            }
+            for (let j = 0; j < sl; j++) {
+              const c = s.charCodeAt(j);
+              if (c > 127) return null;
+              buf[pos++] = c;
+            }
+          } else if (t === "number") {
+            const n = v;
+            if ((n | 0) === n) {
+              if (n >= -128 && n <= 127) {
+                if (pos + 2 > capacity) grow(16);
+                buf[pos++] = 16;
+                buf[pos++] = n & 255;
+              } else if (n >= -32768 && n <= 32767) {
+                if (pos + 3 > capacity) grow(16);
+                buf[pos++] = 17;
+                buf[pos++] = n & 255;
+                buf[pos++] = n >> 8 & 255;
+              } else {
+                if (pos + 5 > capacity) grow(16);
+                buf[pos++] = 18;
+                buf[pos++] = n & 255;
+                buf[pos++] = n >> 8 & 255;
+                buf[pos++] = n >> 16 & 255;
+                buf[pos++] = n >> 24 & 255;
+              }
+            } else {
+              if (pos + 9 > capacity) grow(16);
+              buf[pos++] = 33;
+              view.setFloat64(pos, n, true);
+              pos += 8;
+            }
+          } else if (t === "object") {
+            return null;
+          }
+        }
+      }
+    }
+    return buf.subarray(0, pos);
+  }
+  function tryFastEncodeArray(arr) {
+    const len = arr.length;
+    if (len > 127) return null;
+    const buf = sharedSmallBuf;
+    const view = sharedSmallView;
+    buf[0] = 66;
+    buf[1] = 79;
+    buf[2] = 79;
+    buf[3] = 77;
+    buf[4] = 1;
+    buf[5] = 0;
+    if (len >= 4) {
+      const first = arr[0];
+      const firstType = typeof first;
+      if (firstType === "boolean") {
+        let allBool = true;
+        for (let i = 1; i < len && allBool; i++) {
+          if (typeof arr[i] !== "boolean") allBool = false;
+        }
+        if (allBool) {
+          const byteCount = Math.ceil(len / 8);
+          buf[6] = 133 /* PACKED_BOOL */;
+          buf[7] = len;
+          let pos2 = 8;
+          for (let byteIdx = 0; byteIdx < byteCount; byteIdx++) {
+            let byte = 0;
+            const baseIdx = byteIdx * 8;
+            for (let bit = 0; bit < 8 && baseIdx + bit < len; bit++) {
+              if (arr[baseIdx + bit]) byte |= 1 << bit;
+            }
+            buf[pos2++] = byte;
+          }
+          return buf.slice(0, pos2);
+        }
+      }
+      if (firstType === "number") {
+        let minVal = first;
+        let maxVal = first;
+        let allInt = Number.isInteger(first);
+        let allNum = true;
+        for (let i = 1; i < len && allNum; i++) {
+          const n = arr[i];
+          if (typeof n !== "number") {
+            allNum = false;
+            break;
+          }
+          const num = n;
+          if (num < minVal) minVal = num;
+          if (num > maxVal) maxVal = num;
+          if (allInt && !Number.isInteger(num)) allInt = false;
+        }
+        if (allNum) {
+          if (allInt && minVal >= -128 && maxVal <= 127) {
+            buf[6] = 128 /* PACKED_INT8 */;
+            buf[7] = len;
+            let pos2 = 8;
+            for (let i = 0; i < len; i++) buf[pos2++] = arr[i] & 255;
+            return buf.slice(0, pos2);
+          } else if (allInt && minVal >= -32768 && maxVal <= 32767) {
+            buf[6] = 129 /* PACKED_INT16 */;
+            buf[7] = len;
+            let pos2 = 8;
+            for (let i = 0; i < len; i++) {
+              const n = arr[i];
+              buf[pos2++] = n & 255;
+              buf[pos2++] = n >> 8 & 255;
+            }
+            return buf.slice(0, pos2);
+          } else if (allInt && minVal >= -2147483648 && maxVal <= 2147483647) {
+            buf[6] = 130 /* PACKED_INT32 */;
+            buf[7] = len;
+            let pos2 = 8;
+            for (let i = 0; i < len; i++) {
+              const n = arr[i];
+              buf[pos2++] = n & 255;
+              buf[pos2++] = n >> 8 & 255;
+              buf[pos2++] = n >> 16 & 255;
+              buf[pos2++] = n >> 24 & 255;
+            }
+            return buf.slice(0, pos2);
+          } else {
+            buf[6] = 132 /* PACKED_FLOAT64 */;
+            buf[7] = len;
+            let pos2 = 8;
+            for (let i = 0; i < len; i++) {
+              view.setFloat64(pos2, arr[i], true);
+              pos2 += 8;
+            }
+            return buf.slice(0, pos2);
+          }
+        }
+      }
+    }
+    buf[6] = 64;
+    buf[7] = len;
+    let pos = 8;
+    for (let i = 0; i < len; i++) {
+      const v = arr[i];
+      const t = typeof v;
+      if (t === "number") {
+        const n = v;
+        if ((n | 0) === n && n >= -128 && n <= 127) {
+          buf[pos++] = 16;
+          buf[pos++] = n & 255;
+        } else if ((n | 0) === n) {
+          buf[pos++] = 18;
+          buf[pos++] = n & 255;
+          buf[pos++] = n >> 8 & 255;
+          buf[pos++] = n >> 16 & 255;
+          buf[pos++] = n >> 24 & 255;
+        } else {
+          buf[pos++] = 33;
+          view.setFloat64(pos, n, true);
+          pos += 8;
+        }
+      } else if (t === "string") {
+        const s = v;
+        const sl = s.length;
+        if (sl > 127 || !isAscii(s)) return null;
+        buf[pos++] = 48;
+        buf[pos++] = sl;
+        writeAsciiInline(buf, pos, s);
+        pos += sl;
+      } else if (t === "boolean") {
+        buf[pos++] = v ? 2 : 1;
+      } else if (v === null) {
+        buf[pos++] = 0;
+      } else {
+        return null;
+      }
+    }
+    return buf.slice(0, pos);
+  }
+  function fastEncode(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Uint8Array)) {
+      const obj = value;
+      const ultraResult = ultraFastEncodeTiny(obj);
+      if (ultraResult) return ultraResult;
+      let keyCount = 0;
+      for (const _ in obj) keyCount++;
+      if (keyCount <= 6) {
+        const result = tryFastEncodeSmallInline(obj, keyCount);
+        if (result) return result;
+      }
+    }
+    if (Array.isArray(value) && value.length > 0) {
+      if (typeof value[0] === "object" && value[0] !== null && !Array.isArray(value[0])) {
+        const result = tryFastEncodeArrayOfObjects(value);
+        if (result) return result;
+      }
+      if (value.length <= 127) {
+        const result = tryFastEncodeArray(value);
+        if (result) return result;
+      }
+    }
+    let buf = sharedLargeBuf;
+    let view = sharedLargeView;
+    let capacity = buf.length;
+    let pos = 0;
+    let depth = 0;
+    const maxDepth = 64;
+    const stringTable = /* @__PURE__ */ Object.create(null);
+    let stringCount = 0;
+    function grow(need) {
+      const required = pos + need;
+      while (capacity < required) capacity <<= 1;
+      const newBuf = new Uint8Array(capacity);
+      newBuf.set(buf.subarray(0, pos));
+      buf = newBuf;
+      view = new DataView(buf.buffer);
+    }
+    function writeValue(v) {
+      if (v === null) {
+        if (pos >= capacity) grow(1);
+        buf[pos++] = 0 /* NULL */;
+        return;
+      }
+      switch (typeof v) {
+        case "string": {
+          const dictIdx = DICTIONARY_LOOKUP.get(v);
+          if (dictIdx !== void 0) {
+            if (pos + 4 > capacity) grow(4);
+            buf[pos++] = 97 /* DICT_REF */;
+            if (dictIdx < 128) buf[pos++] = dictIdx;
+            else {
+              let val = dictIdx >>> 0;
+              while (val > 127) {
+                buf[pos++] = val & 127 | 128;
+                val >>>= 7;
+              }
+              buf[pos++] = val;
+            }
+            return;
+          }
+          const ref = stringTable[v];
+          if (ref !== void 0) {
+            if (pos + 6 > capacity) grow(6);
+            buf[pos++] = 96 /* REF */;
+            if (ref < 128) buf[pos++] = ref;
+            else {
+              let val = ref >>> 0;
+              while (val > 127) {
+                buf[pos++] = val & 127 | 128;
+                val >>>= 7;
+              }
+              buf[pos++] = val;
+            }
+            return;
+          }
+          stringTable[v] = stringCount++;
+          const len = v.length;
+          if (len <= 8 && isAscii(v)) {
+            if (pos + 10 > capacity) grow(10);
+            buf[pos++] = 48;
+            buf[pos++] = len;
+            switch (len) {
+              case 1:
+                buf[pos++] = v.charCodeAt(0);
+                break;
+              case 2:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                break;
+              case 3:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                break;
+              case 4:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                buf[pos++] = v.charCodeAt(3);
+                break;
+              case 5:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                buf[pos++] = v.charCodeAt(3);
+                buf[pos++] = v.charCodeAt(4);
+                break;
+              case 6:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                buf[pos++] = v.charCodeAt(3);
+                buf[pos++] = v.charCodeAt(4);
+                buf[pos++] = v.charCodeAt(5);
+                break;
+              case 7:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                buf[pos++] = v.charCodeAt(3);
+                buf[pos++] = v.charCodeAt(4);
+                buf[pos++] = v.charCodeAt(5);
+                buf[pos++] = v.charCodeAt(6);
+                break;
+              case 8:
+                buf[pos++] = v.charCodeAt(0);
+                buf[pos++] = v.charCodeAt(1);
+                buf[pos++] = v.charCodeAt(2);
+                buf[pos++] = v.charCodeAt(3);
+                buf[pos++] = v.charCodeAt(4);
+                buf[pos++] = v.charCodeAt(5);
+                buf[pos++] = v.charCodeAt(6);
+                buf[pos++] = v.charCodeAt(7);
+                break;
+            }
+            return;
+          }
+          const bytes = textEncoder.encode(v);
+          const blen = bytes.length;
+          if (pos + 6 + blen > capacity) grow(6 + blen);
+          buf[pos++] = 48 /* STRING */;
+          if (blen < 128) buf[pos++] = blen;
+          else {
+            let val = blen >>> 0;
+            while (val > 127) {
+              buf[pos++] = val & 127 | 128;
+              val >>>= 7;
+            }
+            buf[pos++] = val;
+          }
+          buf.set(bytes, pos);
+          pos += blen;
+          return;
+        }
+        case "number": {
+          const n = v;
+          if ((n | 0) === n) {
+            if (n >= -128 && n <= 127) {
+              if (pos + 2 > capacity) grow(2);
+              buf[pos++] = 16 /* INT8 */;
+              buf[pos++] = n & 255;
+            } else if (n >= -32768 && n <= 32767) {
+              if (pos + 3 > capacity) grow(3);
+              buf[pos++] = 17 /* INT16 */;
+              buf[pos++] = n & 255;
+              buf[pos++] = n >> 8 & 255;
+            } else {
+              if (pos + 5 > capacity) grow(5);
+              buf[pos++] = 18 /* INT32 */;
+              buf[pos++] = n & 255;
+              buf[pos++] = n >> 8 & 255;
+              buf[pos++] = n >> 16 & 255;
+              buf[pos++] = n >> 24 & 255;
+            }
+          } else {
+            if (pos + 9 > capacity) grow(9);
+            buf[pos++] = 33 /* FLOAT64 */;
+            view.setFloat64(pos, n, true);
+            pos += 8;
+          }
+          return;
+        }
+        case "boolean":
+          if (pos >= capacity) grow(1);
+          buf[pos++] = v ? 2 /* TRUE */ : 1 /* FALSE */;
+          return;
+        case "object": {
+          if (Array.isArray(v)) {
+            depth++;
+            if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+            const len = v.length;
+            if (len >= 4) {
+              const first = v[0];
+              const firstType = typeof first;
+              if (firstType === "boolean") {
+                let allBool = true;
+                for (let i = 1; i < len && allBool; i++) {
+                  if (typeof v[i] !== "boolean") allBool = false;
+                }
+                if (allBool) {
+                  const byteCount = Math.ceil(len / 8);
+                  if (pos + 3 + byteCount > capacity) grow(3 + byteCount);
+                  buf[pos++] = 133 /* PACKED_BOOL */;
+                  if (len < 128) buf[pos++] = len;
+                  else {
+                    let c = len >>> 0;
+                    while (c > 127) {
+                      buf[pos++] = c & 127 | 128;
+                      c >>>= 7;
+                    }
+                    buf[pos++] = c;
+                  }
+                  for (let byteIdx = 0; byteIdx < byteCount; byteIdx++) {
+                    let byte = 0;
+                    const baseIdx = byteIdx * 8;
+                    for (let bit = 0; bit < 8 && baseIdx + bit < len; bit++) {
+                      if (v[baseIdx + bit]) byte |= 1 << bit;
+                    }
+                    buf[pos++] = byte;
+                  }
+                  depth--;
+                  return;
+                }
+              }
+              if (firstType === "number") {
+                let minVal = first;
+                let maxVal = first;
+                let allInt = Number.isInteger(first);
+                let allNum = true;
+                for (let i = 1; i < len && allNum; i++) {
+                  const n = v[i];
+                  if (typeof n !== "number") {
+                    allNum = false;
+                    break;
+                  }
+                  const num = n;
+                  if (num < minVal) minVal = num;
+                  if (num > maxVal) maxVal = num;
+                  if (allInt && !Number.isInteger(num)) allInt = false;
+                }
+                if (allNum) {
+                  if (allInt && minVal >= -128 && maxVal <= 127) {
+                    if (pos + 3 + len > capacity) grow(3 + len);
+                    buf[pos++] = 128 /* PACKED_INT8 */;
+                    if (len < 128) buf[pos++] = len;
+                    else {
+                      let c = len >>> 0;
+                      while (c > 127) {
+                        buf[pos++] = c & 127 | 128;
+                        c >>>= 7;
+                      }
+                      buf[pos++] = c;
+                    }
+                    for (let i = 0; i < len; i++) buf[pos++] = v[i] & 255;
+                    depth--;
+                    return;
+                  } else if (allInt && minVal >= -32768 && maxVal <= 32767) {
+                    if (pos + 3 + len * 2 > capacity) grow(3 + len * 2);
+                    buf[pos++] = 129 /* PACKED_INT16 */;
+                    if (len < 128) buf[pos++] = len;
+                    else {
+                      let c = len >>> 0;
+                      while (c > 127) {
+                        buf[pos++] = c & 127 | 128;
+                        c >>>= 7;
+                      }
+                      buf[pos++] = c;
+                    }
+                    for (let i = 0; i < len; i++) {
+                      const n = v[i];
+                      buf[pos++] = n & 255;
+                      buf[pos++] = n >> 8 & 255;
+                    }
+                    depth--;
+                    return;
+                  } else if (allInt && minVal >= -2147483648 && maxVal <= 2147483647) {
+                    if (pos + 3 + len * 4 > capacity) grow(3 + len * 4);
+                    buf[pos++] = 130 /* PACKED_INT32 */;
+                    if (len < 128) buf[pos++] = len;
+                    else {
+                      let c = len >>> 0;
+                      while (c > 127) {
+                        buf[pos++] = c & 127 | 128;
+                        c >>>= 7;
+                      }
+                      buf[pos++] = c;
+                    }
+                    for (let i = 0; i < len; i++) {
+                      const n = v[i];
+                      buf[pos++] = n & 255;
+                      buf[pos++] = n >> 8 & 255;
+                      buf[pos++] = n >> 16 & 255;
+                      buf[pos++] = n >> 24 & 255;
+                    }
+                    depth--;
+                    return;
+                  } else {
+                    if (pos + 3 + len * 8 > capacity) grow(3 + len * 8);
+                    buf[pos++] = 132 /* PACKED_FLOAT64 */;
+                    if (len < 128) buf[pos++] = len;
+                    else {
+                      let c = len >>> 0;
+                      while (c > 127) {
+                        buf[pos++] = c & 127 | 128;
+                        c >>>= 7;
+                      }
+                      buf[pos++] = c;
+                    }
+                    for (let i = 0; i < len; i++) {
+                      view.setFloat64(pos, v[i], true);
+                      pos += 8;
+                    }
+                    depth--;
+                    return;
+                  }
+                }
+              }
+            }
+            if (pos + 6 > capacity) grow(6);
+            buf[pos++] = 64 /* ARRAY */;
+            if (len < 128) buf[pos++] = len;
+            else {
+              let val = len >>> 0;
+              while (val > 127) {
+                buf[pos++] = val & 127 | 128;
+                val >>>= 7;
+              }
+              buf[pos++] = val;
+            }
+            if (len > 0 && typeof v[0] === "object" && v[0] !== null && !Array.isArray(v[0]) && !(v[0] instanceof Uint8Array)) {
+              const first = v[0];
+              const objKeys = Object.keys(first);
+              const klen = objKeys.length;
+              let allFlat = klen <= 8;
+              if (allFlat) {
+                for (let ki = 0; ki < klen; ki++) {
+                  const fv = first[objKeys[ki]];
+                  const ft = typeof fv;
+                  if (ft === "object" && fv !== null) {
+                    allFlat = false;
+                    break;
+                  }
+                }
+              }
+              if (allFlat) {
+                const estimatedSize = len * (2 + klen * 24) + 512;
+                if (pos + estimatedSize > capacity) grow(estimatedSize);
+                const keyRefs = new Array(klen);
+                let keysRegistered = false;
+                for (let i = 0; i < len; i++) {
+                  const elem = v[i];
+                  if (typeof elem !== "object" || elem === null || Array.isArray(elem)) {
+                    writeValue(elem);
+                    continue;
+                  }
+                  const obj = elem;
+                  if (pos + 6 > capacity) grow(6);
+                  buf[pos++] = 80 /* OBJECT */;
+                  buf[pos++] = klen;
+                  for (let ki = 0; ki < klen; ki++) {
+                    const key = objKeys[ki];
+                    if (keysRegistered) {
+                      if (pos + 2 > capacity) grow(2);
+                      buf[pos++] = 96;
+                      buf[pos++] = keyRefs[ki];
+                    } else {
+                      const existing = stringTable[key];
+                      if (existing !== void 0) {
+                        keyRefs[ki] = existing;
+                        if (pos + 2 > capacity) grow(2);
+                        buf[pos++] = 96;
+                        buf[pos++] = existing;
+                      } else {
+                        keyRefs[ki] = stringCount;
+                        stringTable[key] = stringCount++;
+                        const keyLen = key.length;
+                        if (pos + 2 + keyLen > capacity) grow(2 + keyLen);
+                        buf[pos++] = 48;
+                        buf[pos++] = keyLen;
+                        writeAsciiInline(buf, pos, key);
+                        pos += keyLen;
+                      }
+                    }
+                    const val = obj[key];
+                    const vt = typeof val;
+                    if (vt === "string") {
+                      const s = val;
+                      const sl = s.length;
+                      const sref = stringTable[s];
+                      if (sref !== void 0) {
+                        if (pos + 6 > capacity) grow(6);
+                        buf[pos++] = 96;
+                        if (sref < 128) buf[pos++] = sref;
+                        else {
+                          let rv = sref >>> 0;
+                          while (rv > 127) {
+                            buf[pos++] = rv & 127 | 128;
+                            rv >>>= 7;
+                          }
+                          buf[pos++] = rv;
+                        }
+                      } else {
+                        stringTable[s] = stringCount++;
+                        if (pos + 2 + sl > capacity) grow(2 + sl);
+                        buf[pos++] = 48;
+                        buf[pos++] = sl;
+                        writeAsciiInline(buf, pos, s);
+                        pos += sl;
+                      }
+                    } else if (vt === "number") {
+                      const n = val;
+                      if ((n | 0) === n && n >= -128 && n <= 127) {
+                        if (pos + 2 > capacity) grow(2);
+                        buf[pos++] = 16;
+                        buf[pos++] = n & 255;
+                      } else if ((n | 0) === n) {
+                        if (pos + 5 > capacity) grow(5);
+                        buf[pos++] = 18;
+                        buf[pos++] = n & 255;
+                        buf[pos++] = n >> 8 & 255;
+                        buf[pos++] = n >> 16 & 255;
+                        buf[pos++] = n >> 24 & 255;
+                      } else {
+                        if (pos + 9 > capacity) grow(9);
+                        buf[pos++] = 33;
+                        view.setFloat64(pos, n, true);
+                        pos += 8;
+                      }
+                    } else if (vt === "boolean") {
+                      if (pos >= capacity) grow(1);
+                      buf[pos++] = val ? 2 : 1;
+                    } else if (val === null) {
+                      if (pos >= capacity) grow(1);
+                      buf[pos++] = 0;
+                    } else {
+                      writeValue(val);
+                    }
+                  }
+                  keysRegistered = true;
+                }
+                depth--;
+                return;
+              }
+            }
+            for (let i = 0; i < len; i++) writeValue(v[i]);
+            depth--;
+          } else if (v instanceof Uint8Array) {
+            const len = v.length;
+            if (pos + 6 + len > capacity) grow(6 + len);
+            buf[pos++] = 49 /* BINARY */;
+            if (len < 128) buf[pos++] = len;
+            else {
+              let val = len >>> 0;
+              while (val > 127) {
+                buf[pos++] = val & 127 | 128;
+                val >>>= 7;
+              }
+              buf[pos++] = val;
+            }
+            buf.set(v, pos);
+            pos += len;
+          } else {
+            depth++;
+            if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+            const keys = Object.keys(v);
+            const klen = keys.length;
+            if (pos + 6 > capacity) grow(6);
+            buf[pos++] = 80 /* OBJECT */;
+            if (klen < 128) buf[pos++] = klen;
+            else {
+              let val = klen >>> 0;
+              while (val > 127) {
+                buf[pos++] = val & 127 | 128;
+                val >>>= 7;
+              }
+              buf[pos++] = val;
+            }
+            for (let i = 0; i < klen; i++) {
+              const key = keys[i];
+              const ref = stringTable[key];
+              if (ref !== void 0) {
+                if (pos + 2 > capacity) grow(2);
+                buf[pos++] = 96;
+                buf[pos++] = ref;
+              } else {
+                stringTable[key] = stringCount++;
+                const keyBytes = textEncoder.encode(key);
+                const kl = keyBytes.length;
+                if (pos + 2 + kl > capacity) grow(2 + kl);
+                buf[pos++] = 48;
+                buf[pos++] = kl;
+                buf.set(keyBytes, pos);
+                pos += kl;
+              }
+              writeValue(v[key]);
+            }
+            depth--;
+          }
+          return;
+        }
+        case "bigint": {
+          if (pos + 9 > capacity) grow(9);
+          buf[pos++] = v >= 0n ? 23 /* UINT64 */ : 19 /* INT64 */;
+          view.setBigInt64(pos, v, true);
+          pos += 8;
+          return;
+        }
+        default:
+          if (pos >= capacity) grow(1);
+          buf[pos++] = 0 /* NULL */;
+      }
+    }
+    buf[pos++] = 66;
+    buf[pos++] = 79;
+    buf[pos++] = 79;
+    buf[pos++] = 77;
+    buf[pos++] = VERSION;
+    buf[pos++] = 0;
+    writeValue(value);
+    return buf.slice(0, pos);
+  }
+  var textDecoder = new TextDecoder();
+  var NEED_FULL_DECODE = /* @__PURE__ */ Symbol("NEED_FULL_DECODE");
+  function tryDecodeTinyObject(buf) {
+    let pos = 6;
+    const type = buf[pos++];
+    if (type !== 80) return NEED_FULL_DECODE;
+    const count = buf[pos++];
+    if (count > 8) return NEED_FULL_DECODE;
+    const obj = {};
+    for (let i = 0; i < count; i++) {
+      if (buf[pos++] !== 48) return NEED_FULL_DECODE;
+      const klen = buf[pos++];
+      if (klen > 16) return NEED_FULL_DECODE;
+      let key;
+      switch (klen) {
+        case 1:
+          key = String.fromCharCode(buf[pos]);
+          break;
+        case 2:
+          key = String.fromCharCode(buf[pos], buf[pos + 1]);
+          break;
+        case 3:
+          key = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2]);
+          break;
+        case 4:
+          key = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3]);
+          break;
+        case 5:
+          key = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4]);
+          break;
+        case 6:
+          key = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5]);
+          break;
+        default:
+          key = ultraDecodeStr(buf, pos, klen);
+      }
+      pos += klen;
+      const vtype = buf[pos++];
+      if (vtype === 48) {
+        const vlen = buf[pos++];
+        switch (vlen) {
+          case 1:
+            obj[key] = String.fromCharCode(buf[pos]);
+            break;
+          case 2:
+            obj[key] = String.fromCharCode(buf[pos], buf[pos + 1]);
+            break;
+          case 3:
+            obj[key] = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2]);
+            break;
+          case 4:
+            obj[key] = String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3]);
+            break;
+          default:
+            obj[key] = ultraDecodeStr(buf, pos, vlen);
+        }
+        pos += vlen;
+      } else if (vtype === 16) {
+        const v = buf[pos++];
+        obj[key] = v > 127 ? v - 256 : v;
+      } else if (vtype === 2) {
+        obj[key] = true;
+      } else if (vtype === 1) {
+        obj[key] = false;
+      } else if (vtype === 0) {
+        obj[key] = null;
+      } else if (vtype === 17) {
+        const v = buf[pos] | buf[pos + 1] << 8;
+        obj[key] = v > 32767 ? v - 65536 : v;
+        pos += 2;
+      } else if (vtype === 18) {
+        obj[key] = buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24;
+        pos += 4;
+      } else if (vtype === 33) {
+        obj[key] = getDecodeView(buf).getFloat64(pos, true);
+        pos += 8;
+      } else {
+        return NEED_FULL_DECODE;
+      }
+    }
+    return obj;
+  }
+  function isAsciiBytes(buf, pos, len) {
+    for (let i = 0; i < len; i++) {
+      if (buf[pos + i] > 127) return false;
+    }
+    return true;
+  }
+  function ultraDecodeStr(buf, pos, len) {
+    switch (len) {
+      case 1:
+        return String.fromCharCode(buf[pos]);
+      case 2:
+        return String.fromCharCode(buf[pos], buf[pos + 1]);
+      case 3:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2]);
+      case 4:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3]);
+      case 5:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4]);
+      case 6:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5]);
+      case 7:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5], buf[pos + 6]);
+      case 8:
+        return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5], buf[pos + 6], buf[pos + 7]);
+    }
+    for (let i = 0; i < len; i++) {
+      if (buf[pos + i] > 127) {
+        return textDecoder.decode(buf.subarray(pos, pos + len));
+      }
+    }
+    let s = "";
+    for (let i = 0; i < len; i++) s += String.fromCharCode(buf[pos + i]);
+    return s;
+  }
+  function decodeStr(buf, pos, len) {
+    if (len <= 8) {
+      if (isAsciiBytes(buf, pos, len)) {
+        switch (len) {
+          case 1:
+            return String.fromCharCode(buf[pos]);
+          case 2:
+            return String.fromCharCode(buf[pos], buf[pos + 1]);
+          case 3:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2]);
+          case 4:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3]);
+          case 5:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4]);
+          case 6:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5]);
+          case 7:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5], buf[pos + 6]);
+          case 8:
+            return String.fromCharCode(buf[pos], buf[pos + 1], buf[pos + 2], buf[pos + 3], buf[pos + 4], buf[pos + 5], buf[pos + 6], buf[pos + 7]);
+        }
+      }
+      return textDecoder.decode(buf.subarray(pos, pos + len));
+    }
+    if (len <= 32 && isAsciiBytes(buf, pos, len)) {
+      let s = "";
+      let i = 0;
+      for (; i + 8 <= len; i += 8) {
+        s += String.fromCharCode(
+          buf[pos + i],
+          buf[pos + i + 1],
+          buf[pos + i + 2],
+          buf[pos + i + 3],
+          buf[pos + i + 4],
+          buf[pos + i + 5],
+          buf[pos + i + 6],
+          buf[pos + i + 7]
+        );
+      }
+      for (; i < len; i++) {
+        s += String.fromCharCode(buf[pos + i]);
+      }
+      return s;
+    }
+    return textDecoder.decode(buf.subarray(pos, pos + len));
+  }
+  function fastDecodeSmall(buffer) {
+    const buf = buffer;
+    let pos = 6;
+    const type = buf[pos++];
+    if (type === 80) {
+      const count = buf[pos++];
+      const obj = {};
+      for (let i = 0; i < count; i++) {
+        pos++;
+        const klen = buf[pos++];
+        const key = decodeStr(buf, pos, klen);
+        pos += klen;
+        const vtype = buf[pos++];
+        if (vtype === 48) {
+          const vlen = buf[pos++];
+          obj[key] = decodeStr(buf, pos, vlen);
+          pos += vlen;
+        } else if (vtype === 16) {
+          const v = buf[pos++];
+          obj[key] = v > 127 ? v - 256 : v;
+        } else if (vtype === 17) {
+          const v = buf[pos] | buf[pos + 1] << 8;
+          obj[key] = v > 32767 ? v - 65536 : v;
+          pos += 2;
+        } else if (vtype === 18) {
+          obj[key] = buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24;
+          pos += 4;
+        } else if (vtype === 33) {
+          obj[key] = getDecodeView(buf).getFloat64(pos, true);
+          pos += 8;
+        } else if (vtype === 2) {
+          obj[key] = true;
+        } else if (vtype === 1) {
+          obj[key] = false;
+        } else if (vtype === 23) {
+          obj[key] = getDecodeView(buf).getBigUint64(pos, true);
+          pos += 8;
+        } else if (vtype === 19 || vtype === 25) {
+          obj[key] = getDecodeView(buf).getBigInt64(pos, true);
+          pos += 8;
+        } else if (vtype === 80) {
+          const ncount = buf[pos++];
+          const nobj = {};
+          for (let ni = 0; ni < ncount; ni++) {
+            pos++;
+            const nklen = buf[pos++];
+            const nkey = decodeStr(buf, pos, nklen);
+            pos += nklen;
+            const nvtype = buf[pos++];
+            if (nvtype === 48) {
+              const nvlen = buf[pos++];
+              nobj[nkey] = decodeStr(buf, pos, nvlen);
+              pos += nvlen;
+            } else if (nvtype === 16) {
+              const v = buf[pos++];
+              nobj[nkey] = v > 127 ? v - 256 : v;
+            } else if (nvtype === 17) {
+              const v = buf[pos] | buf[pos + 1] << 8;
+              nobj[nkey] = v > 32767 ? v - 65536 : v;
+              pos += 2;
+            } else if (nvtype === 18) {
+              nobj[nkey] = buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24;
+              pos += 4;
+            } else if (nvtype === 33) {
+              nobj[nkey] = getDecodeView(buf).getFloat64(pos, true);
+              pos += 8;
+            } else if (nvtype === 23) {
+              nobj[nkey] = getDecodeView(buf).getBigUint64(pos, true);
+              pos += 8;
+            } else if (nvtype === 19 || nvtype === 25) {
+              nobj[nkey] = getDecodeView(buf).getBigInt64(pos, true);
+              pos += 8;
+            } else if (nvtype === 2) {
+              nobj[nkey] = true;
+            } else if (nvtype === 1) {
+              nobj[nkey] = false;
+            } else if (nvtype === 0) {
+              nobj[nkey] = null;
+            } else {
+              return NEED_FULL_DECODE;
+            }
+          }
+          obj[key] = nobj;
+        } else if (vtype === 0) {
+          obj[key] = null;
+        } else {
+          return NEED_FULL_DECODE;
+        }
+      }
+      return obj;
+    }
+    if (type === 64) {
+      const count = buf[pos++];
+      const arr = new Array(count);
+      for (let i = 0; i < count; i++) {
+        const vtype = buf[pos++];
+        if (vtype === 16) {
+          const v = buf[pos++];
+          arr[i] = v > 127 ? v - 256 : v;
+        } else if (vtype === 48) {
+          const len = buf[pos++];
+          arr[i] = decodeStr(buf, pos, len);
+          pos += len;
+        } else if (vtype === 17) {
+          const v = buf[pos] | buf[pos + 1] << 8;
+          arr[i] = v > 32767 ? v - 65536 : v;
+          pos += 2;
+        } else if (vtype === 18) {
+          arr[i] = buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24;
+          pos += 4;
+        } else if (vtype === 33) {
+          arr[i] = getDecodeView(buf).getFloat64(pos, true);
+          pos += 8;
+        } else if (vtype === 64) {
+          return NEED_FULL_DECODE;
+        } else if (vtype === 80) {
+          return NEED_FULL_DECODE;
+        } else if (vtype === 2) {
+          arr[i] = true;
+        } else if (vtype === 1) {
+          arr[i] = false;
+        } else if (vtype === 0) {
+          arr[i] = null;
+        } else {
+          return NEED_FULL_DECODE;
+        }
+      }
+      return arr;
+    }
+    if (type === 48) {
+      const len = buf[pos++];
+      return decodeStr(buf, pos, len);
+    }
+    if (type === 16) {
+      const v = buf[pos];
+      return v > 127 ? v - 256 : v;
+    }
+    if (type === 2) return true;
+    if (type === 1) return false;
+    return null;
+  }
+  function fastDecodeArrayOfObjects(buffer, startPos, count) {
+    const buf = buffer;
+    let pos = startPos;
+    const arr = new Array(count);
+    const view = getDecodeView(buf);
+    const stringTable = [];
+    for (let i = 0; i < count; i++) {
+      const objMarker = buf[pos++];
+      if (objMarker !== 80) return NEED_FULL_DECODE;
+      const keyCount = buf[pos++];
+      const obj = {};
+      for (let j = 0; j < keyCount; j++) {
+        const keyType = buf[pos++];
+        let key;
+        if (keyType === 48) {
+          const klen = buf[pos++];
+          key = decodeStr(buf, pos, klen);
+          pos += klen;
+          stringTable.push(key);
+        } else if (keyType === 96) {
+          const ref = buf[pos++];
+          key = stringTable[ref];
+          if (!key) return NEED_FULL_DECODE;
+        } else if (keyType === 97) {
+          const ref = buf[pos++];
+          key = BOOM_DICTIONARY_V1[ref];
+        } else {
+          return NEED_FULL_DECODE;
+        }
+        const vtype = buf[pos++];
+        if (vtype === 48) {
+          const vlen = buf[pos++];
+          const val = decodeStr(buf, pos, vlen);
+          pos += vlen;
+          stringTable.push(val);
+          obj[key] = val;
+        } else if (vtype === 96) {
+          const ref = buf[pos++];
+          obj[key] = stringTable[ref];
+        } else if (vtype === 97) {
+          const ref = buf[pos++];
+          obj[key] = BOOM_DICTIONARY_V1[ref];
+        } else if (vtype === 16) {
+          const v = buf[pos++];
+          obj[key] = v > 127 ? v - 256 : v;
+        } else if (vtype === 17) {
+          const v = buf[pos] | buf[pos + 1] << 8;
+          obj[key] = v > 32767 ? v - 65536 : v;
+          pos += 2;
+        } else if (vtype === 18) {
+          obj[key] = buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24;
+          pos += 4;
+        } else if (vtype === 33) {
+          obj[key] = view.getFloat64(pos, true);
+          pos += 8;
+        } else if (vtype === 2) {
+          obj[key] = true;
+        } else if (vtype === 1) {
+          obj[key] = false;
+        } else if (vtype === 0) {
+          obj[key] = null;
+        } else {
+          return NEED_FULL_DECODE;
+        }
+      }
+      arr[i] = obj;
+    }
+    return arr;
+  }
+  function fastDecode(buffer) {
+    if (buffer.length < 6 || buffer[0] !== 66 || buffer[1] !== 79 || buffer[2] !== 79 || buffer[3] !== 77) {
+      if (buffer.length < 6) throw new BoomError("Buffer too short for BOOM header");
+      throw new BoomError("Invalid BOOM magic bytes");
+    }
+    if (buffer[4] !== VERSION) {
+      throw new BoomError(`Unsupported BOOM version: ${buffer[4]}`);
+    }
+    const len = buffer.length;
+    if (len < 64) {
+      const result = tryDecodeTinyObject(buffer);
+      if (result !== NEED_FULL_DECODE) return result;
+    }
+    const type = buffer[6];
+    if (type === 64) {
+      let pos2 = 7;
+      let b = buffer[pos2++];
+      let count = b & 127;
+      if (b >= 128) {
+        b = buffer[pos2++];
+        count |= (b & 127) << 7;
+        if (b >= 128) {
+          b = buffer[pos2++];
+          count |= (b & 127) << 14;
+        }
+      }
+      if (count > 0) {
+        const firstType = buffer[pos2];
+        if (firstType === 80) {
+          const result = fastDecodeArrayOfObjects(buffer, pos2, count);
+          if (result !== NEED_FULL_DECODE) return result;
+        }
+      }
+    }
+    if (type === 80) {
+      const keyCount = buffer[7];
+      if (keyCount <= 10 && len < 512) {
+        let isFlat = true;
+        let pos2 = 8;
+        for (let k = 0; k < keyCount && pos2 < len && isFlat; k++) {
+          if (buffer[pos2] !== 48) {
+            isFlat = false;
+            break;
+          }
+          pos2++;
+          const klen = buffer[pos2++];
+          pos2 += klen;
+          const vtype = buffer[pos2++];
+          if (vtype === 64) {
+            isFlat = false;
+            break;
+          }
+          if (vtype === 48) {
+            const vlen = buffer[pos2++];
+            pos2 += vlen;
+          } else if (vtype === 80) {
+            const ncount = buffer[pos2++];
+            for (let nk = 0; nk < ncount && pos2 < len; nk++) {
+              if (buffer[pos2] !== 48) {
+                isFlat = false;
+                break;
+              }
+              pos2++;
+              const nklen = buffer[pos2++];
+              pos2 += nklen;
+              const nvtype = buffer[pos2++];
+              if (nvtype === 80 || nvtype === 64) {
+                isFlat = false;
+                break;
+              }
+              if (nvtype === 48) {
+                const nvlen = buffer[pos2++];
+                pos2 += nvlen;
+              } else if (nvtype === 16) pos2 += 1;
+              else if (nvtype === 18) pos2 += 4;
+              else if (nvtype === 33) pos2 += 8;
+            }
+          } else if (vtype === 16) pos2 += 1;
+          else if (vtype === 17) pos2 += 2;
+          else if (vtype === 18) pos2 += 4;
+          else if (vtype === 33 || vtype === 19 || vtype === 23 || vtype === 25) pos2 += 8;
+          else if (vtype === 96) pos2 += 1;
+        }
+        if (isFlat) {
+          const result = fastDecodeSmall(buffer);
+          if (result !== NEED_FULL_DECODE) return result;
+        }
+      }
+    }
+    const buf = buffer;
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    let pos = 6;
+    const stringTable = [];
+    let depth = 0;
+    const maxDepth = 64;
+    function readVarint() {
+      let b = buf[pos++];
+      if (b < 128) return b;
+      let result = b & 127;
+      b = buf[pos++];
+      if (b < 128) return result | b << 7;
+      result |= (b & 127) << 7;
+      b = buf[pos++];
+      if (b < 128) return result | b << 14;
+      result |= (b & 127) << 14;
+      b = buf[pos++];
+      if (b < 128) return result | b << 21;
+      result |= (b & 127) << 21;
+      b = buf[pos++];
+      return (result | b << 28) >>> 0;
+    }
+    function readString() {
+      const length = readVarint();
+      const start = pos;
+      pos += length;
+      if (length <= 8) {
+        const str2 = decodeStr(buf, start, length);
+        stringTable.push(str2);
+        return str2;
+      }
+      if (length < 128) {
+        let isAscii2 = true;
+        for (let i = start; i < pos; i++) {
+          if (buf[i] > 127) {
+            isAscii2 = false;
+            break;
+          }
+        }
+        if (isAscii2) {
+          const str2 = String.fromCharCode.apply(null, buf.subarray(start, pos));
+          stringTable.push(str2);
+          return str2;
+        }
+      }
+      const str = textDecoder.decode(buf.subarray(start, pos));
+      stringTable.push(str);
+      return str;
+    }
+    function readValue() {
+      const type2 = buf[pos++];
+      switch (type2) {
+        case 48 /* STRING */:
+          return readString();
+        case 16 /* INT8 */: {
+          const v = buf[pos++];
+          return v > 127 ? v - 256 : v;
+        }
+        case 18 /* INT32 */: {
+          const p = pos;
+          pos += 4;
+          return buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24;
+        }
+        case 17 /* INT16 */: {
+          const p = pos;
+          pos += 2;
+          const v = buf[p] | buf[p + 1] << 8;
+          return v > 32767 ? v - 65536 : v;
+        }
+        case 80 /* OBJECT */: {
+          depth++;
+          if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+          const count = readVarint();
+          const obj = {};
+          for (let i = 0; i < count; i++) {
+            const keyType = buf[pos++];
+            const key = keyType === 48 /* STRING */ ? readString() : keyType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()];
+            obj[key] = readValue();
+          }
+          depth--;
+          return obj;
+        }
+        case 64 /* ARRAY */: {
+          depth++;
+          if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+          const count = readVarint();
+          const arr = new Array(count);
+          for (let i = 0; i < count; i++) arr[i] = readValue();
+          depth--;
+          return arr;
+        }
+        case 96 /* REF */:
+          return stringTable[readVarint()];
+        case 97 /* DICT_REF */:
+          return BOOM_DICTIONARY_V1[readVarint()];
+        case 0 /* NULL */:
+          return null;
+        case 2 /* TRUE */:
+          return true;
+        case 1 /* FALSE */:
+          return false;
+        case 33 /* FLOAT64 */: {
+          const v = view.getFloat64(pos, true);
+          pos += 8;
+          return v;
+        }
+        case 32 /* FLOAT32 */: {
+          const v = view.getFloat32(pos, true);
+          pos += 4;
+          return v;
+        }
+        case 49 /* BINARY */: {
+          const len2 = readVarint();
+          const start = pos;
+          pos += len2;
+          return new Uint8Array(buf.subarray(start, pos));
+        }
+        case 23 /* UINT64 */: {
+          const v = view.getBigUint64(pos, true);
+          pos += 8;
+          return v;
+        }
+        case 19 /* INT64 */: {
+          const v = view.getBigInt64(pos, true);
+          pos += 8;
+          return v;
+        }
+        case 112 /* TABLE */: {
+          depth++;
+          if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+          const rowCount = readVarint();
+          const colCount = readVarint();
+          const keys = [];
+          for (let i = 0; i < colCount; i++) {
+            const keyType = buf[pos++];
+            keys.push(keyType === 48 /* STRING */ ? readString() : keyType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()]);
+          }
+          const colSchemas = [];
+          for (let i = 0; i < colCount; i++) {
+            const colType = buf[pos++];
+            const schema = { type: colType };
+            if (colType === 114 /* NESTED_OBJECT */) {
+              const nestedColCount = readVarint();
+              schema.nestedKeys = [];
+              schema.nestedTypes = [];
+              for (let j = 0; j < nestedColCount; j++) {
+                const nestedKeyType = buf[pos++];
+                schema.nestedKeys.push(nestedKeyType === 48 /* STRING */ ? readString() : nestedKeyType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()]);
+              }
+              for (let j = 0; j < nestedColCount; j++) {
+                schema.nestedTypes.push(buf[pos++]);
+              }
+            }
+            colSchemas.push(schema);
+          }
+          const rows = [];
+          for (let r = 0; r < rowCount; r++) {
+            const row = {};
+            for (let c = 0; c < colCount; c++) {
+              const key = keys[c];
+              const schema = colSchemas[c];
+              switch (schema.type) {
+                case 133 /* PACKED_BOOL */:
+                  row[key] = buf[pos++] !== 0;
+                  break;
+                case 128 /* PACKED_INT8 */: {
+                  const v = buf[pos++];
+                  row[key] = v > 127 ? v - 256 : v;
+                  break;
+                }
+                case 129 /* PACKED_INT16 */: {
+                  const p = pos;
+                  pos += 2;
+                  const v = buf[p] | buf[p + 1] << 8;
+                  row[key] = v > 32767 ? v - 65536 : v;
+                  break;
+                }
+                case 130 /* PACKED_INT32 */: {
+                  const p = pos;
+                  pos += 4;
+                  row[key] = buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24;
+                  break;
+                }
+                case 132 /* PACKED_FLOAT64 */:
+                  row[key] = view.getFloat64(pos, true);
+                  pos += 8;
+                  break;
+                case 48 /* STRING */: {
+                  const strType = buf[pos++];
+                  row[key] = strType === 48 /* STRING */ ? readString() : strType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()];
+                  break;
+                }
+                case 113 /* NESTED_TABLE */: {
+                  const itemCount = readVarint();
+                  const nestedArr = [];
+                  for (let j = 0; j < itemCount; j++) nestedArr.push(readValue());
+                  row[key] = nestedArr;
+                  break;
+                }
+                case 114 /* NESTED_OBJECT */: {
+                  const nestedObj = {};
+                  for (let j = 0; j < schema.nestedKeys.length; j++) {
+                    const nestedKey = schema.nestedKeys[j];
+                    const nestedType = schema.nestedTypes[j];
+                    switch (nestedType) {
+                      case 133 /* PACKED_BOOL */:
+                        nestedObj[nestedKey] = buf[pos++] !== 0;
+                        break;
+                      case 128 /* PACKED_INT8 */: {
+                        const v = buf[pos++];
+                        nestedObj[nestedKey] = v > 127 ? v - 256 : v;
+                        break;
+                      }
+                      case 129 /* PACKED_INT16 */: {
+                        const p = pos;
+                        pos += 2;
+                        const v = buf[p] | buf[p + 1] << 8;
+                        nestedObj[nestedKey] = v > 32767 ? v - 65536 : v;
+                        break;
+                      }
+                      case 130 /* PACKED_INT32 */: {
+                        const p = pos;
+                        pos += 4;
+                        nestedObj[nestedKey] = buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24;
+                        break;
+                      }
+                      case 132 /* PACKED_FLOAT64 */:
+                        nestedObj[nestedKey] = view.getFloat64(pos, true);
+                        pos += 8;
+                        break;
+                      case 48 /* STRING */: {
+                        const strType = buf[pos++];
+                        nestedObj[nestedKey] = strType === 48 /* STRING */ ? readString() : strType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()];
+                        break;
+                      }
+                      default:
+                        nestedObj[nestedKey] = readValue();
+                    }
+                  }
+                  row[key] = nestedObj;
+                  break;
+                }
+                default:
+                  row[key] = readValue();
+              }
+            }
+            rows.push(row);
+          }
+          depth--;
+          return rows;
+        }
+        case 115 /* COLUMNAR */: {
+          depth++;
+          if (depth > maxDepth) throw new BoomError(`Maximum nesting depth of ${maxDepth} exceeded`);
+          const rowCount = readVarint();
+          const colCount = readVarint();
+          const keys = [];
+          for (let i = 0; i < colCount; i++) {
+            const len2 = readVarint();
+            const start = pos;
+            pos += len2;
+            keys.push(textDecoder.decode(buf.subarray(start, pos)));
+          }
+          const colTypes = [];
+          for (let i = 0; i < colCount; i++) colTypes.push(buf[pos++]);
+          const rows = [];
+          for (let r = 0; r < rowCount; r++) rows.push({});
+          for (let c = 0; c < colCount; c++) {
+            const key = keys[c];
+            const colType = colTypes[c];
+            switch (colType) {
+              case 116 /* RLE_CONST */: {
+                const constValue = readValue();
+                for (let r = 0; r < rowCount; r++) rows[r][key] = constValue;
+                break;
+              }
+              case 133 /* PACKED_BOOL */: {
+                for (let i = 0; i < rowCount; i += 8) {
+                  const byte = buf[pos++];
+                  for (let j = 0; j < 8 && i + j < rowCount; j++) {
+                    rows[i + j][key] = (byte & 1 << j) !== 0;
+                  }
+                }
+                break;
+              }
+              case 128 /* PACKED_INT8 */:
+                for (let r = 0; r < rowCount; r++) {
+                  const v = buf[pos++];
+                  rows[r][key] = v > 127 ? v - 256 : v;
+                }
+                break;
+              case 129 /* PACKED_INT16 */:
+                for (let r = 0; r < rowCount; r++) {
+                  const p = pos;
+                  pos += 2;
+                  const v = buf[p] | buf[p + 1] << 8;
+                  rows[r][key] = v > 32767 ? v - 65536 : v;
+                }
+                break;
+              case 130 /* PACKED_INT32 */:
+                for (let r = 0; r < rowCount; r++) {
+                  const p = pos;
+                  pos += 4;
+                  rows[r][key] = buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24;
+                }
+                break;
+              case 132 /* PACKED_FLOAT64 */:
+                for (let r = 0; r < rowCount; r++) {
+                  rows[r][key] = view.getFloat64(pos, true);
+                  pos += 8;
+                }
+                break;
+              case 48 /* STRING */:
+                for (let r = 0; r < rowCount; r++) {
+                  const strType = buf[pos++];
+                  rows[r][key] = strType === 48 /* STRING */ ? readString() : strType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[readVarint()] : stringTable[readVarint()];
+                }
+                break;
+              default:
+                for (let r = 0; r < rowCount; r++) rows[r][key] = readValue();
+            }
+          }
+          depth--;
+          return rows;
+        }
+        case 133 /* PACKED_BOOL */: {
+          const count = readVarint();
+          const result = [];
+          const byteCount = Math.ceil(count / 8);
+          for (let i = 0; i < byteCount; i++) {
+            const byte = buf[pos++];
+            for (let j = 0; j < 8 && result.length < count; j++) {
+              result.push((byte & 1 << j) !== 0);
+            }
+          }
+          return result;
+        }
+        case 128 /* PACKED_INT8 */: {
+          const count = readVarint();
+          const result = [];
+          for (let i = 0; i < count; i++) {
+            const v = buf[pos++];
+            result.push(v > 127 ? v - 256 : v);
+          }
+          return result;
+        }
+        case 129 /* PACKED_INT16 */: {
+          const count = readVarint();
+          const result = [];
+          for (let i = 0; i < count; i++) {
+            const p = pos;
+            pos += 2;
+            const v = buf[p] | buf[p + 1] << 8;
+            result.push(v > 32767 ? v - 65536 : v);
+          }
+          return result;
+        }
+        case 130 /* PACKED_INT32 */: {
+          const count = readVarint();
+          const result = [];
+          for (let i = 0; i < count; i++) {
+            const p = pos;
+            pos += 4;
+            result.push(buf[p] | buf[p + 1] << 8 | buf[p + 2] << 16 | buf[p + 3] << 24);
+          }
+          return result;
+        }
+        case 131 /* PACKED_FLOAT32 */: {
+          const count = readVarint();
+          const result = [];
+          for (let i = 0; i < count; i++) {
+            result.push(view.getFloat32(pos, true));
+            pos += 4;
+          }
+          return result;
+        }
+        case 132 /* PACKED_FLOAT64 */: {
+          const count = readVarint();
+          const result = [];
+          for (let i = 0; i < count; i++) {
+            result.push(view.getFloat64(pos, true));
+            pos += 8;
+          }
+          return result;
+        }
+        default:
+          throw new BoomError(`Unknown type: 0x${type2.toString(16)}`);
+      }
+    }
+    return readValue();
+  }
+  var BoomBinaryEncoder = class _BoomBinaryEncoder {
+    writer = new ByteWriter();
+    stringTable = /* @__PURE__ */ new Map();
+    stringCount = 0;
+    options;
+    depth = 0;
+    enableInterning;
+    constructor(options = {}) {
+      this.options = mergeOptions(DEFAULT_OPTIONS, options);
+      this.enableInterning = this.options.enableInterning;
+    }
+    encode(value) {
+      if (this.enableInterning && this.options.maxDepth === 64) {
+        if (Array.isArray(value) && value.length >= 2 && this.isUniformObjectArray(value)) {
+        } else {
+          return fastEncode(value);
+        }
+      }
+      this.writer = new ByteWriter();
+      this.stringTable = /* @__PURE__ */ new Map();
+      this.stringCount = 0;
+      this.depth = 0;
+      const w = this.writer;
+      if (w.pos + 6 > w.buffer.length) w["grow"](6);
+      const buf = w.buffer;
+      buf[w.pos++] = 66;
+      buf[w.pos++] = 79;
+      buf[w.pos++] = 79;
+      buf[w.pos++] = 77;
+      buf[w.pos++] = VERSION;
+      buf[w.pos++] = 0;
+      this.encodeValue(value);
+      return this.writer.toUint8Array();
+    }
+    encodeValue(value) {
+      if (value === null) {
+        this.writer.writeByte(0 /* NULL */);
+        return;
+      }
+      const ctor = value.constructor;
+      if (ctor === String) {
+        this.encodeString(value);
+        return;
+      }
+      if (ctor === Number) {
+        this.encodeNumber(value);
+        return;
+      }
+      if (ctor === Array) {
+        this.encodeArray(value);
+        return;
+      }
+      if (ctor === Object) {
+        this.encodeObject(value);
+        return;
+      }
+      if (ctor === Boolean) {
+        this.writer.writeByte(value ? 2 /* TRUE */ : 1 /* FALSE */);
+        return;
+      }
+      if (value instanceof Uint8Array) {
+        this.encodeBinary(value);
+        return;
+      }
+      if (typeof value === "bigint") {
+        this.encodeBigInt(value);
+        return;
+      }
+      if (value === void 0) {
+        this.writer.writeByte(0 /* NULL */);
+        return;
+      }
+      throw new BoomError(`Unsupported type: ${typeof value}`);
+    }
+    encodeNumber(value) {
+      const w = this.writer;
+      if ((value | 0) === value) {
+        if (value >= -128 && value <= 127) {
+          if (w.pos + 2 > w.buffer.length) w["grow"](2);
+          w.buffer[w.pos++] = 16 /* INT8 */;
+          w.buffer[w.pos++] = value & 255;
+        } else if (value >= -32768 && value <= 32767) {
+          if (w.pos + 3 > w.buffer.length) w["grow"](3);
+          const buf = w.buffer;
+          buf[w.pos++] = 17 /* INT16 */;
+          buf[w.pos++] = value & 255;
+          buf[w.pos++] = value >> 8 & 255;
+        } else {
+          if (w.pos + 5 > w.buffer.length) w["grow"](5);
+          const buf = w.buffer;
+          buf[w.pos++] = 18 /* INT32 */;
+          buf[w.pos++] = value & 255;
+          buf[w.pos++] = value >> 8 & 255;
+          buf[w.pos++] = value >> 16 & 255;
+          buf[w.pos++] = value >> 24 & 255;
+        }
+      } else {
+        w.writeByte(33 /* FLOAT64 */);
+        w.writeFloat64LE(value);
+      }
+    }
+    encodeBigInt(value) {
+      if (value >= 0n && value <= 0xFFFFFFFFFFFFFFFFn) {
+        this.writer.writeByte(23 /* UINT64 */);
+        this.writer.writeBigUInt64LE(value);
+      } else if (value >= -0x8000000000000000n && value <= 0x7FFFFFFFFFFFFFFFn) {
+        this.writer.writeByte(19 /* INT64 */);
+        this.writer.writeBigInt64LE(value);
+      } else {
+        throw new BoomError("BigInt out of range for int64/uint64");
+      }
+    }
+    // Reuse TextEncoder for performance
+    static textEncoder = new TextEncoder();
+    encodeString(value) {
+      const dictIdx = DICTIONARY_LOOKUP.get(value);
+      if (dictIdx !== void 0) {
+        const w = this.writer;
+        if (w.pos + 4 > w.buffer.length) w["grow"](4);
+        w.buffer[w.pos++] = 97 /* DICT_REF */;
+        if (dictIdx < 128) {
+          w.buffer[w.pos++] = dictIdx;
+        } else {
+          w.writeVarint(dictIdx);
+        }
+        return;
+      }
+      if (this.enableInterning) {
+        const existingIndex = this.stringTable.get(value);
+        if (existingIndex !== void 0) {
+          const w = this.writer;
+          if (w.pos + 6 > w.buffer.length) w["grow"](6);
+          w.buffer[w.pos++] = 96 /* REF */;
+          if (existingIndex < 128) {
+            w.buffer[w.pos++] = existingIndex;
+          } else {
+            w.writeVarint(existingIndex);
+          }
+          return;
+        }
+        this.stringTable.set(value, this.stringCount++);
+      }
+      const len = value.length;
+      if (len < 64) {
+        let isAscii2 = true;
+        for (let i = 0; i < len; i++) {
+          if (value.charCodeAt(i) > 127) {
+            isAscii2 = false;
+            break;
+          }
+        }
+        if (isAscii2) {
+          const w = this.writer;
+          const needed = 2 + len;
+          if (w.pos + needed > w.buffer.length) w["grow"](needed);
+          const buf = w.buffer;
+          buf[w.pos++] = 48 /* STRING */;
+          buf[w.pos++] = len;
+          for (let i = 0; i < len; i++) {
+            buf[w.pos++] = value.charCodeAt(i);
+          }
+          return;
+        }
+      }
+      const bytes = _BoomBinaryEncoder.textEncoder.encode(value);
+      this.writer.writeByte(48 /* STRING */);
+      this.writer.writeVarint(bytes.length);
+      this.writer.write(bytes);
+    }
+    encodeBinary(value) {
+      this.writer.writeByte(49 /* BINARY */);
+      this.writer.writeVarint(value.length);
+      this.writer.write(value);
+    }
+    encodeArray(value) {
+      if (value.length > this.options.maxArrayLength) {
+        throw new BoomError(`Array exceeds maximum length of ${this.options.maxArrayLength}`);
+      }
+      this.depth++;
+      if (this.depth > this.options.maxDepth) {
+        throw new BoomError(`Maximum nesting depth of ${this.options.maxDepth} exceeded`);
+      }
+      if (value.length >= 2 && this.isUniformObjectArray(value)) {
+        this.encodeColumnar(value);
+        this.depth--;
+        return;
+      }
+      if (value.length >= 4) {
+        const packedResult = this.tryPackedArray(value);
+        if (packedResult) {
+          this.writer.write(packedResult);
+          this.depth--;
+          return;
+        }
+      }
+      this.writer.writeByte(64 /* ARRAY */);
+      this.writer.writeVarint(value.length);
+      for (const item of value) {
+        this.encodeValue(item);
+      }
+      this.depth--;
+    }
+    isUniformObjectArray(arr) {
+      if (arr.length < 2) return false;
+      const first = arr[0];
+      if (typeof first !== "object" || first === null || Array.isArray(first) || first instanceof Uint8Array) {
+        return false;
+      }
+      const keys = Object.keys(first);
+      const keyCount = keys.length;
+      if (keyCount === 0) return false;
+      const keySet = new Set(keys);
+      for (let i = 1; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item !== "object" || item === null || Array.isArray(item) || item instanceof Uint8Array) {
+          return false;
+        }
+        const itemKeys = Object.keys(item);
+        if (itemKeys.length !== keyCount) return false;
+        for (let j = 0; j < keyCount; j++) {
+          if (!keySet.has(itemKeys[j])) return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * Column-major table encoding for optimal compression.
+     * Instead of encoding row-by-row: row1[col1,col2], row2[col1,col2]...
+     * We encode column-by-column: col1[row1,row2...], col2[row1,row2...]...
+     *
+     * This dramatically improves compression because:
+     * 1. All integers are grouped together (compressors see patterns)
+     * 2. All strings are grouped together (repeated patterns found)
+     * 3. All booleans can be bit-packed efficiently
+     * 4. Type markers are at the start, not scattered throughout
+     */
+    encodeColumnar(rows) {
+      const keys = Object.keys(rows[0]);
+      this.writer.writeByte(115 /* COLUMNAR */);
+      this.writer.writeVarint(rows.length);
+      this.writer.writeVarint(keys.length);
+      const textEncoder2 = _BoomBinaryEncoder.textEncoder;
+      for (const key of keys) {
+        const bytes = textEncoder2.encode(key);
+        this.writer.writeVarint(bytes.length);
+        this.writer.write(bytes);
+      }
+      const columnInfos = keys.map((key) => {
+        let allInt8 = true, allInt16 = true, allInt32 = true;
+        let allFloat = true, allBool = true, allString = true;
+        const firstVal = rows[0][key];
+        let isConstant = true;
+        for (const row of rows) {
+          const val = row[key];
+          if (isConstant && val !== firstVal) {
+            if (typeof val !== typeof firstVal || JSON.stringify(val) !== JSON.stringify(firstVal)) {
+              isConstant = false;
+            }
+          }
+          if (typeof val !== "boolean") allBool = false;
+          if (typeof val !== "string") allString = false;
+          if (typeof val !== "number") {
+            allInt8 = allInt16 = allInt32 = allFloat = false;
+          } else if (!Number.isInteger(val)) {
+            allInt8 = allInt16 = allInt32 = false;
+          } else {
+            if (val < -128 || val > 127) allInt8 = false;
+            if (val < -32768 || val > 32767) allInt16 = false;
+            if (val < -2147483648 || val > 2147483647) allInt32 = false;
+          }
+        }
+        const baseType = allBool ? "bool" : allInt8 ? "int8" : allInt16 ? "int16" : allInt32 ? "int32" : allFloat ? "float" : allString ? "string" : "mixed";
+        return {
+          type: baseType,
+          isConstant: isConstant && rows.length > 1,
+          // Only use RLE if more than 1 row
+          constantValue: isConstant ? firstVal : void 0
+        };
+      });
+      for (const colInfo of columnInfos) {
+        if (colInfo.isConstant) {
+          this.writer.writeByte(116 /* RLE_CONST */);
+        } else {
+          const typeMarker = colInfo.type === "bool" ? 133 /* PACKED_BOOL */ : colInfo.type === "int8" ? 128 /* PACKED_INT8 */ : colInfo.type === "int16" ? 129 /* PACKED_INT16 */ : colInfo.type === "int32" ? 130 /* PACKED_INT32 */ : colInfo.type === "float" ? 132 /* PACKED_FLOAT64 */ : colInfo.type === "string" ? 48 /* STRING */ : 64 /* ARRAY */;
+          this.writer.writeByte(typeMarker);
+        }
+      }
+      for (let colIdx = 0; colIdx < keys.length; colIdx++) {
+        const key = keys[colIdx];
+        const colInfo = columnInfos[colIdx];
+        if (colInfo.isConstant) {
+          this.encodeValue(colInfo.constantValue);
+          continue;
+        }
+        switch (colInfo.type) {
+          case "bool":
+            for (let i = 0; i < rows.length; i += 8) {
+              let byte = 0;
+              for (let j = 0; j < 8 && i + j < rows.length; j++) {
+                if (rows[i + j][key]) byte |= 1 << j;
+              }
+              this.writer.writeByte(byte);
+            }
+            break;
+          case "int8":
+            for (const row of rows) {
+              this.writer.writeInt8(row[key]);
+            }
+            break;
+          case "int16":
+            for (const row of rows) {
+              this.writer.writeInt16LE(row[key]);
+            }
+            break;
+          case "int32":
+            for (const row of rows) {
+              this.writer.writeInt32LE(row[key]);
+            }
+            break;
+          case "float":
+            for (const row of rows) {
+              this.writer.writeFloat64LE(row[key]);
+            }
+            break;
+          case "string":
+            for (const row of rows) {
+              this.encodeString(row[key]);
+            }
+            break;
+          default:
+            for (const row of rows) {
+              this.encodeValue(row[key]);
+            }
+        }
+      }
+    }
+    tryPackedArray(arr) {
+      let allInt8 = true, allInt16 = true, allInt32 = true;
+      let allFloat32 = true, allBool = true;
+      for (const item of arr) {
+        if (typeof item === "boolean") {
+          allInt8 = allInt16 = allInt32 = allFloat32 = false;
+        } else if (typeof item === "number") {
+          allBool = false;
+          if (!Number.isInteger(item)) {
+            allInt8 = allInt16 = allInt32 = false;
+            const f32 = new Float32Array([item])[0];
+            if (f32 !== item) allFloat32 = false;
+          } else {
+            allFloat32 = false;
+            if (item < -128 || item > 127) allInt8 = false;
+            if (item < -32768 || item > 32767) allInt16 = false;
+            if (item < -2147483648 || item > 2147483647) allInt32 = false;
+          }
+        } else {
+          return null;
+        }
+      }
+      const writer = new ByteWriter();
+      if (allBool) {
+        writer.writeByte(133 /* PACKED_BOOL */);
+        writer.writeVarint(arr.length);
+        for (let i = 0; i < arr.length; i += 8) {
+          let byte = 0;
+          for (let j = 0; j < 8 && i + j < arr.length; j++) {
+            if (arr[i + j]) byte |= 1 << j;
+          }
+          writer.writeByte(byte);
+        }
+        return writer.toUint8Array();
+      }
+      if (allInt8) {
+        writer.writeByte(128 /* PACKED_INT8 */);
+        writer.writeVarint(arr.length);
+        for (const item of arr) {
+          writer.writeInt8(item);
+        }
+        return writer.toUint8Array();
+      }
+      if (allInt16) {
+        writer.writeByte(129 /* PACKED_INT16 */);
+        writer.writeVarint(arr.length);
+        for (const item of arr) {
+          writer.writeInt16LE(item);
+        }
+        return writer.toUint8Array();
+      }
+      if (allInt32) {
+        writer.writeByte(130 /* PACKED_INT32 */);
+        writer.writeVarint(arr.length);
+        for (const item of arr) {
+          writer.writeInt32LE(item);
+        }
+        return writer.toUint8Array();
+      }
+      if (allFloat32) {
+        writer.writeByte(131 /* PACKED_FLOAT32 */);
+        writer.writeVarint(arr.length);
+        for (const item of arr) {
+          writer.writeFloat32LE(item);
+        }
+        return writer.toUint8Array();
+      }
+      return null;
+    }
+    encodeObject(value) {
+      const keys = Object.keys(value);
+      if (keys.length > this.options.maxArrayLength) {
+        throw new BoomError(`Object exceeds maximum key count of ${this.options.maxArrayLength}`);
+      }
+      this.depth++;
+      if (this.depth > this.options.maxDepth) {
+        throw new BoomError(`Maximum nesting depth of ${this.options.maxDepth} exceeded`);
+      }
+      this.writer.writeByte(80 /* OBJECT */);
+      this.writer.writeVarint(keys.length);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        this.encodeString(key);
+        this.encodeValue(value[key]);
+      }
+      this.depth--;
+    }
+  };
+  var BoomBinaryDecoder = class _BoomBinaryDecoder {
+    reader;
+    stringTable = [];
+    options;
+    depth = 0;
+    enableInterning;
+    // Reuse TextDecoder for performance
+    static textDecoder = new TextDecoder();
+    constructor(options = {}) {
+      this.options = mergeOptions(DEFAULT_OPTIONS, options);
+      this.enableInterning = this.options.enableInterning;
+    }
+    decode(buffer) {
+      if (this.enableInterning && this.options.maxDepth === 64) {
+        return fastDecode(buffer);
+      }
+      if (buffer.length < 6 || buffer[0] !== 66 || buffer[1] !== 79 || buffer[2] !== 79 || buffer[3] !== 77) {
+        throw new BoomError("Invalid BOOM header");
+      }
+      if (buffer[4] !== VERSION) {
+        throw new BoomError(`Unsupported BOOM version: ${buffer[4]}`);
+      }
+      this.reader = new ByteReader(buffer);
+      this.reader.offset = 6;
+      this.stringTable = [];
+      this.depth = 0;
+      return this.decodeValue();
+    }
+    decodeValue() {
+      const r = this.reader;
+      const type = r.readByte();
+      if (type === 48 /* STRING */) return this.decodeString();
+      if (type === 16 /* INT8 */) return r.readInt8();
+      if (type === 18 /* INT32 */) return r.readInt32LE();
+      if (type === 80 /* OBJECT */) return this.decodeObject();
+      if (type === 64 /* ARRAY */) return this.decodeArray();
+      if (type === 96 /* REF */) return this.stringTable[r.readVarint()];
+      if (type === 0 /* NULL */) return null;
+      if (type === 2 /* TRUE */) return true;
+      if (type === 1 /* FALSE */) return false;
+      if (type === 17 /* INT16 */) return r.readInt16LE();
+      if (type === 33 /* FLOAT64 */) return r.readFloat64LE();
+      switch (type) {
+        case 19 /* INT64 */:
+          return r.readBigInt64LE();
+        case 20 /* UINT8 */:
+          return r.readUInt8();
+        case 21 /* UINT16 */:
+          return r.readUInt16LE();
+        case 22 /* UINT32 */:
+          return r.readUInt32LE();
+        case 23 /* UINT64 */:
+          return r.readBigUInt64LE();
+        case 24 /* VARINT */:
+          return r.readVarint();
+        case 25 /* SVARINT */:
+          return zigzagDecode(r.readVarint());
+        case 32 /* FLOAT32 */:
+          return r.readFloat32LE();
+        case 49 /* BINARY */:
+          return this.decodeBinary();
+        case 112 /* TABLE */:
+          return this.decodeTable();
+        case 115 /* COLUMNAR */:
+          return this.decodeColumnar();
+        case 133 /* PACKED_BOOL */:
+          return this.decodePackedBool();
+        case 128 /* PACKED_INT8 */:
+          return this.decodePackedInt8();
+        case 129 /* PACKED_INT16 */:
+          return this.decodePackedInt16();
+        case 130 /* PACKED_INT32 */:
+          return this.decodePackedInt32();
+        case 131 /* PACKED_FLOAT32 */:
+          return this.decodePackedFloat32();
+        case 132 /* PACKED_FLOAT64 */:
+          return this.decodePackedFloat64();
+        default:
+          throw new BoomError(`Unknown type marker: 0x${type.toString(16)}`);
+      }
+    }
+    decodeString() {
+      const r = this.reader;
+      const length = r.readVarint();
+      if (length < 64) {
+        const bytes2 = r.readBytes(length);
+        let isAscii2 = true;
+        for (let i = 0; i < length; i++) {
+          if (bytes2[i] > 127) {
+            isAscii2 = false;
+            break;
+          }
+        }
+        if (isAscii2) {
+          let str3 = "";
+          for (let i = 0; i < length; i++) {
+            str3 += String.fromCharCode(bytes2[i]);
+          }
+          if (this.enableInterning) this.stringTable.push(str3);
+          return str3;
+        }
+        const str2 = _BoomBinaryDecoder.textDecoder.decode(bytes2);
+        if (this.enableInterning) this.stringTable.push(str2);
+        return str2;
+      }
+      const bytes = r.readBytes(length);
+      const str = _BoomBinaryDecoder.textDecoder.decode(bytes);
+      if (this.enableInterning) this.stringTable.push(str);
+      return str;
+    }
+    decodeBinary() {
+      const length = this.reader.readVarint();
+      return new Uint8Array(this.reader.readBytes(length));
+    }
+    decodeArray() {
+      const r = this.reader;
+      const count = r.readVarint();
+      this.depth++;
+      const arr = new Array(count);
+      for (let i = 0; i < count; i++) {
+        arr[i] = this.decodeValue();
+      }
+      this.depth--;
+      return arr;
+    }
+    decodeObject() {
+      const r = this.reader;
+      const count = r.readVarint();
+      const stringTable = this.stringTable;
+      this.depth++;
+      const obj = {};
+      for (let i = 0; i < count; i++) {
+        const keyType = r.readByte();
+        const key = keyType === 48 /* STRING */ ? this.decodeString() : keyType === 96 /* REF */ ? stringTable[r.readVarint()] : keyType === 97 /* DICT_REF */ ? BOOM_DICTIONARY_V1[r.readVarint()] : (() => {
+          throw new BoomError(`Invalid key type: 0x${keyType.toString(16)}`);
+        })();
+        obj[key] = this.decodeValue();
+      }
+      this.depth--;
+      return obj;
+    }
+    decodeRef() {
+      return this.stringTable[this.reader.readVarint()];
+    }
+    decodeTable() {
+      const rowCount = this.reader.readVarint();
+      const colCount = this.reader.readVarint();
+      const keys = [];
+      for (let i = 0; i < colCount; i++) {
+        const keyType = this.reader.readByte();
+        if (keyType === 48 /* STRING */) {
+          keys.push(this.decodeString());
+        } else if (keyType === 96 /* REF */) {
+          keys.push(this.decodeRef());
+        } else if (keyType === 97 /* DICT_REF */) {
+          keys.push(BOOM_DICTIONARY_V1[this.reader.readVarint()]);
+        } else {
+          throw new BoomError(`Invalid table column name type: 0x${keyType.toString(16)}`);
+        }
+      }
+      const colSchemas = [];
+      for (let i = 0; i < colCount; i++) {
+        const colType = this.reader.readByte();
+        const schema = { type: colType };
+        if (colType === 114 /* NESTED_OBJECT */) {
+          const nestedColCount = this.reader.readVarint();
+          schema.nestedKeys = [];
+          schema.nestedTypes = [];
+          for (let j = 0; j < nestedColCount; j++) {
+            const nestedKeyType = this.reader.readByte();
+            if (nestedKeyType === 48 /* STRING */) {
+              schema.nestedKeys.push(this.decodeString());
+            } else if (nestedKeyType === 96 /* REF */) {
+              schema.nestedKeys.push(this.decodeRef());
+            } else if (nestedKeyType === 97 /* DICT_REF */) {
+              schema.nestedKeys.push(BOOM_DICTIONARY_V1[this.reader.readVarint()]);
+            } else {
+              throw new BoomError(`Invalid nested key type: 0x${nestedKeyType.toString(16)}`);
+            }
+          }
+          for (let j = 0; j < nestedColCount; j++) {
+            schema.nestedTypes.push(this.reader.readByte());
+          }
+        }
+        colSchemas.push(schema);
+      }
+      const rows = [];
+      for (let r = 0; r < rowCount; r++) {
+        const row = {};
+        for (let c = 0; c < colCount; c++) {
+          const key = keys[c];
+          const schema = colSchemas[c];
+          switch (schema.type) {
+            case 133 /* PACKED_BOOL */:
+              row[key] = this.reader.readByte() !== 0;
+              break;
+            case 128 /* PACKED_INT8 */:
+              row[key] = this.reader.readInt8();
+              break;
+            case 129 /* PACKED_INT16 */:
+              row[key] = this.reader.readInt16LE();
+              break;
+            case 130 /* PACKED_INT32 */:
+              row[key] = this.reader.readInt32LE();
+              break;
+            case 132 /* PACKED_FLOAT64 */:
+              row[key] = this.reader.readFloat64LE();
+              break;
+            case 48 /* STRING */: {
+              const strType = this.reader.readByte();
+              if (strType === 48 /* STRING */) {
+                row[key] = this.decodeString();
+              } else if (strType === 96 /* REF */) {
+                row[key] = this.decodeRef();
+              } else if (strType === 97 /* DICT_REF */) {
+                row[key] = BOOM_DICTIONARY_V1[this.reader.readVarint()];
+              } else {
+                throw new BoomError(`Invalid string type in table: 0x${strType.toString(16)}`);
+              }
+              break;
+            }
+            case 114 /* NESTED_OBJECT */: {
+              const nestedObj = {};
+              for (let j = 0; j < schema.nestedKeys.length; j++) {
+                const nestedKey = schema.nestedKeys[j];
+                const nestedType = schema.nestedTypes[j];
+                switch (nestedType) {
+                  case 133 /* PACKED_BOOL */:
+                    nestedObj[nestedKey] = this.reader.readByte() !== 0;
+                    break;
+                  case 128 /* PACKED_INT8 */:
+                    nestedObj[nestedKey] = this.reader.readInt8();
+                    break;
+                  case 129 /* PACKED_INT16 */:
+                    nestedObj[nestedKey] = this.reader.readInt16LE();
+                    break;
+                  case 130 /* PACKED_INT32 */:
+                    nestedObj[nestedKey] = this.reader.readInt32LE();
+                    break;
+                  case 132 /* PACKED_FLOAT64 */:
+                    nestedObj[nestedKey] = this.reader.readFloat64LE();
+                    break;
+                  case 48 /* STRING */: {
+                    const strType = this.reader.readByte();
+                    if (strType === 48 /* STRING */) {
+                      nestedObj[nestedKey] = this.decodeString();
+                    } else if (strType === 96 /* REF */) {
+                      nestedObj[nestedKey] = this.decodeRef();
+                    } else if (strType === 97 /* DICT_REF */) {
+                      nestedObj[nestedKey] = BOOM_DICTIONARY_V1[this.reader.readVarint()];
+                    } else {
+                      throw new BoomError(`Invalid nested string type: 0x${strType.toString(16)}`);
+                    }
+                    break;
+                  }
+                  default:
+                    nestedObj[nestedKey] = this.decodeValue();
+                }
+              }
+              row[key] = nestedObj;
+              break;
+            }
+            case 113 /* NESTED_TABLE */: {
+              const itemCount = this.reader.readVarint();
+              const nestedArr = [];
+              for (let j = 0; j < itemCount; j++) {
+                nestedArr.push(this.decodeValue());
+              }
+              row[key] = nestedArr;
+              break;
+            }
+            default:
+              row[key] = this.decodeValue();
+          }
+        }
+        rows.push(row);
+      }
+      return rows;
+    }
+    /**
+     * Decode column-major table format.
+     * Data is stored column-by-column for better compression.
+     */
+    decodeColumnar() {
+      const rowCount = this.reader.readVarint();
+      const colCount = this.reader.readVarint();
+      const keys = [];
+      for (let i = 0; i < colCount; i++) {
+        const len = this.reader.readVarint();
+        const bytes = this.reader.readBytes(len);
+        keys.push(_BoomBinaryDecoder.textDecoder.decode(bytes));
+      }
+      const colTypes = [];
+      for (let i = 0; i < colCount; i++) {
+        colTypes.push(this.reader.readByte());
+      }
+      const rows = [];
+      for (let r = 0; r < rowCount; r++) {
+        rows.push({});
+      }
+      for (let c = 0; c < colCount; c++) {
+        const key = keys[c];
+        const colType = colTypes[c];
+        switch (colType) {
+          case 116 /* RLE_CONST */: {
+            const constValue = this.decodeValue();
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = constValue;
+            }
+            break;
+          }
+          case 133 /* PACKED_BOOL */: {
+            for (let i = 0; i < rowCount; i += 8) {
+              const byte = this.reader.readByte();
+              for (let j = 0; j < 8 && i + j < rowCount; j++) {
+                rows[i + j][key] = (byte & 1 << j) !== 0;
+              }
+            }
+            break;
+          }
+          case 128 /* PACKED_INT8 */:
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = this.reader.readInt8();
+            }
+            break;
+          case 129 /* PACKED_INT16 */:
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = this.reader.readInt16LE();
+            }
+            break;
+          case 130 /* PACKED_INT32 */:
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = this.reader.readInt32LE();
+            }
+            break;
+          case 132 /* PACKED_FLOAT64 */:
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = this.reader.readFloat64LE();
+            }
+            break;
+          case 48 /* STRING */:
+            for (let r = 0; r < rowCount; r++) {
+              const strType = this.reader.readByte();
+              if (strType === 48 /* STRING */) {
+                rows[r][key] = this.decodeString();
+              } else if (strType === 96 /* REF */) {
+                rows[r][key] = this.decodeRef();
+              } else if (strType === 97 /* DICT_REF */) {
+                rows[r][key] = BOOM_DICTIONARY_V1[this.reader.readVarint()];
+              } else {
+                throw new BoomError(`Invalid string type in columnar: 0x${strType.toString(16)}`);
+              }
+            }
+            break;
+          default:
+            for (let r = 0; r < rowCount; r++) {
+              rows[r][key] = this.decodeValue();
+            }
+        }
+      }
+      return rows;
+    }
+    decodePackedBool() {
+      const count = this.reader.readVarint();
+      const result = [];
+      const byteCount = Math.ceil(count / 8);
+      for (let i = 0; i < byteCount; i++) {
+        const byte = this.reader.readByte();
+        for (let j = 0; j < 8 && result.length < count; j++) {
+          result.push((byte & 1 << j) !== 0);
+        }
+      }
+      return result;
+    }
+    decodePackedInt8() {
+      const count = this.reader.readVarint();
+      const result = [];
+      for (let i = 0; i < count; i++) {
+        result.push(this.reader.readInt8());
+      }
+      return result;
+    }
+    decodePackedInt16() {
+      const count = this.reader.readVarint();
+      const result = [];
+      for (let i = 0; i < count; i++) {
+        result.push(this.reader.readInt16LE());
+      }
+      return result;
+    }
+    decodePackedInt32() {
+      const count = this.reader.readVarint();
+      const result = [];
+      for (let i = 0; i < count; i++) {
+        result.push(this.reader.readInt32LE());
+      }
+      return result;
+    }
+    decodePackedFloat32() {
+      const count = this.reader.readVarint();
+      const result = [];
+      for (let i = 0; i < count; i++) {
+        result.push(this.reader.readFloat32LE());
+      }
+      return result;
+    }
+    decodePackedFloat64() {
+      const count = this.reader.readVarint();
+      const result = [];
+      for (let i = 0; i < count; i++) {
+        result.push(this.reader.readFloat64LE());
+      }
+      return result;
+    }
+  };
+  var BoomTextEncoder = class {
+    indent = 0;
+    options;
+    constructor(options = {}) {
+      this.options = {
+        ...DEFAULT_OPTIONS,
+        compact: false,
+        indentString: "  ",
+        ...options
+      };
+    }
+    encode(value) {
+      this.indent = 0;
+      return this.encodeValue(value);
+    }
+    get newline() {
+      return this.options.compact ? " " : "\n";
+    }
+    get currentIndent() {
+      return this.options.compact ? "" : this.options.indentString.repeat(this.indent);
+    }
+    encodeValue(value) {
+      if (value === null || value === void 0) {
+        return "null";
+      }
+      if (typeof value === "boolean") {
+        return value ? "true" : "false";
+      }
+      if (typeof value === "number") {
+        if (Number.isNaN(value)) return "null";
+        if (!Number.isFinite(value)) return "null";
+        return Object.is(value, -0) ? "-0" : String(value);
+      }
+      if (typeof value === "bigint") {
+        return `${value}n`;
+      }
+      if (typeof value === "string") {
+        return this.encodeString(value);
+      }
+      if (value instanceof Uint8Array) {
+        return this.encodeBinary(value);
+      }
+      if (Array.isArray(value)) {
+        return this.encodeArray(value);
+      }
+      if (typeof value === "object") {
+        return this.encodeObject(value);
+      }
+      return "null";
+    }
+    encodeString(value) {
+      const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+      return `"${escaped}"`;
+    }
+    encodeBinary(value) {
+      const base64 = this.uint8ArrayToBase64(value);
+      return `<binary:${base64}>`;
+    }
+    uint8ArrayToBase64(bytes) {
+      if (typeof btoa === "function") {
+        return btoa(String.fromCharCode(...bytes));
+      }
+      return Buffer.from(bytes).toString("base64");
+    }
+    encodeArray(value) {
+      if (value.length === 0) {
+        return "[]";
+      }
+      const allPrimitive = value.every(
+        (item) => item === null || typeof item === "boolean" || typeof item === "number" || typeof item === "string" || typeof item === "bigint"
+      );
+      if (allPrimitive && value.length <= 5 && this.options.compact) {
+        const items2 = value.map((item) => this.encodeValue(item)).join(" ");
+        return `[${items2}]`;
+      }
+      this.indent++;
+      const items = value.map((item) => `${this.currentIndent}${this.encodeValue(item)}`);
+      this.indent--;
+      return `[${this.newline}${items.join(this.newline)}${this.newline}${this.currentIndent}]`;
+    }
+    encodeObject(value) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        return "{}";
+      }
+      this.indent++;
+      const pairs = entries.map(([key, val]) => {
+        const encodedKey = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? key : this.encodeString(key);
+        return `${this.currentIndent}${encodedKey}: ${this.encodeValue(val)}`;
+      });
+      this.indent--;
+      return `{${this.newline}${pairs.join(this.newline)}${this.newline}${this.currentIndent}}`;
+    }
+  };
+  var BoomTextDecoder = class {
+    input = "";
+    pos = 0;
+    options;
+    depth = 0;
+    constructor(options = {}) {
+      this.options = mergeOptions(DEFAULT_OPTIONS, options);
+    }
+    decode(input) {
+      this.input = input;
+      this.pos = 0;
+      this.depth = 0;
+      this.skipWhitespaceAndComments();
+      const value = this.parseValue();
+      this.skipWhitespaceAndComments();
+      if (this.pos < this.input.length) {
+        throw new BoomError(`Unexpected character at position ${this.pos}: ${this.input[this.pos]}`);
+      }
+      return value;
+    }
+    get current() {
+      return this.pos < this.input.length ? this.input[this.pos] : "";
+    }
+    // @ts-expect-error - peek is reserved for future use
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    peek(offset = 0) {
+      const idx = this.pos + offset;
+      return idx < this.input.length ? this.input[idx] : "";
+    }
+    advance() {
+      if (this.pos >= this.input.length) return "";
+      const ch = this.input[this.pos];
+      this.pos++;
+      return ch;
+    }
+    skipWhitespaceAndComments() {
+      while (this.pos < this.input.length) {
+        const ch = this.current;
+        if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+          this.pos++;
+        } else if (ch === "#") {
+          while (this.pos < this.input.length && this.current !== "\n") {
+            this.pos++;
+          }
+        } else {
+          break;
+        }
+      }
+    }
+    parseValue() {
+      this.skipWhitespaceAndComments();
+      const ch = this.current;
+      if (ch === '"') {
+        return this.parseString();
+      }
+      if (ch === "[") {
+        return this.parseArray();
+      }
+      if (ch === "{") {
+        return this.parseObject();
+      }
+      if (ch === "<") {
+        return this.parseBinary();
+      }
+      if (ch === "-" || ch === "+" || ch >= "0" && ch <= "9") {
+        return this.parseNumber();
+      }
+      if (this.matchKeyword("null")) {
+        return null;
+      }
+      if (this.matchKeyword("true")) {
+        return true;
+      }
+      if (this.matchKeyword("false")) {
+        return false;
+      }
+      throw new BoomError(`Unexpected character at position ${this.pos}: ${ch}`);
+    }
+    matchKeyword(keyword) {
+      if (this.input.slice(this.pos, this.pos + keyword.length) === keyword) {
+        const nextChar = this.input[this.pos + keyword.length] ?? "";
+        if (!/[a-zA-Z0-9_]/.test(nextChar)) {
+          this.pos += keyword.length;
+          return true;
+        }
+      }
+      return false;
+    }
+    parseString() {
+      this.advance();
+      let result = "";
+      while (this.pos < this.input.length) {
+        const ch = this.advance();
+        if (ch === '"') {
+          return result;
+        }
+        if (ch === "\\") {
+          const escaped = this.advance();
+          switch (escaped) {
+            case "n":
+              result += "\n";
+              break;
+            case "r":
+              result += "\r";
+              break;
+            case "t":
+              result += "	";
+              break;
+            case '"':
+              result += '"';
+              break;
+            case "\\":
+              result += "\\";
+              break;
+            case "u": {
+              const hex = this.input.slice(this.pos, this.pos + 4);
+              if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+                throw new BoomError(`Invalid unicode escape at position ${this.pos}`);
+              }
+              result += String.fromCharCode(parseInt(hex, 16));
+              this.pos += 4;
+              break;
+            }
+            default:
+              result += escaped;
+          }
+        } else {
+          result += ch;
+        }
+      }
+      throw new BoomError("Unterminated string");
+    }
+    parseNumber() {
+      const start = this.pos;
+      const firstChar = this.current;
+      if (firstChar === "-" || firstChar === "+") {
+        this.pos++;
+      }
+      while (this.current >= "0" && this.current <= "9") {
+        this.pos++;
+      }
+      let isFloat = false;
+      if (this.current === ".") {
+        isFloat = true;
+        this.pos++;
+        while (this.current >= "0" && this.current <= "9") {
+          this.pos++;
+        }
+      }
+      const expChar = this.current;
+      if (expChar === "e" || expChar === "E") {
+        isFloat = true;
+        this.pos++;
+        const signChar = this.current;
+        if (signChar === "-" || signChar === "+") {
+          this.pos++;
+        }
+        while (this.current >= "0" && this.current <= "9") {
+          this.pos++;
+        }
+      }
+      if (this.current === "n") {
+        this.pos++;
+        const numStr2 = this.input.slice(start, this.pos - 1);
+        return BigInt(numStr2);
+      }
+      const numStr = this.input.slice(start, this.pos);
+      return isFloat ? parseFloat(numStr) : parseInt(numStr, 10);
+    }
+    parseArray() {
+      this.advance();
+      this.depth++;
+      if (this.depth > this.options.maxDepth) {
+        throw new BoomError(`Maximum nesting depth of ${this.options.maxDepth} exceeded`);
+      }
+      const arr = [];
+      this.skipWhitespaceAndComments();
+      if (this.current === "]") {
+        this.advance();
+        this.depth--;
+        return arr;
+      }
+      while (true) {
+        this.skipWhitespaceAndComments();
+        arr.push(this.parseValue());
+        this.skipWhitespaceAndComments();
+        if (this.current === "]") {
+          this.advance();
+          break;
+        }
+        if (this.current === ",") {
+          this.advance();
+        }
+      }
+      this.depth--;
+      return arr;
+    }
+    parseObject() {
+      this.advance();
+      this.depth++;
+      if (this.depth > this.options.maxDepth) {
+        throw new BoomError(`Maximum nesting depth of ${this.options.maxDepth} exceeded`);
+      }
+      const obj = {};
+      this.skipWhitespaceAndComments();
+      if (this.current === "}") {
+        this.advance();
+        this.depth--;
+        return obj;
+      }
+      while (true) {
+        this.skipWhitespaceAndComments();
+        let key;
+        const keyStart = this.current;
+        if (keyStart === '"') {
+          key = this.parseString();
+        } else {
+          const start = this.pos;
+          while (/[a-zA-Z0-9_]/.test(this.current)) {
+            this.pos++;
+          }
+          key = this.input.slice(start, this.pos);
+          if (!key) {
+            throw new BoomError(`Expected key at position ${this.pos}`);
+          }
+        }
+        this.skipWhitespaceAndComments();
+        const colonChar = this.current;
+        if (colonChar !== ":") {
+          throw new BoomError(`Expected ':' after key at position ${this.pos}`);
+        }
+        this.advance();
+        this.skipWhitespaceAndComments();
+        obj[key] = this.parseValue();
+        this.skipWhitespaceAndComments();
+        const endChar = this.current;
+        if (endChar === "}") {
+          this.advance();
+          break;
+        }
+        if (endChar === ",") {
+          this.advance();
+        }
+      }
+      this.depth--;
+      return obj;
+    }
+    parseBinary() {
+      if (!this.input.slice(this.pos).startsWith("<binary:")) {
+        throw new BoomError(`Expected binary literal at position ${this.pos}`);
+      }
+      this.pos += 8;
+      const endPos = this.input.indexOf(">", this.pos);
+      if (endPos === -1) {
+        throw new BoomError("Unterminated binary literal");
+      }
+      const base64 = this.input.slice(this.pos, endPos);
+      this.pos = endPos + 1;
+      return this.base64ToUint8Array(base64);
+    }
+    base64ToUint8Array(base64) {
+      if (typeof atob === "function") {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+      }
+      return new Uint8Array(Buffer.from(base64, "base64"));
+    }
+  };
+  function isUniformObjectArray(arr) {
+    if (arr.length < 2) return false;
+    const first = arr[0];
+    if (typeof first !== "object" || first === null || Array.isArray(first)) return false;
+    const firstKeys = Object.keys(first).sort().join(",");
+    for (let i = 1; i < Math.min(arr.length, 3); i++) {
+      const item = arr[i];
+      if (typeof item !== "object" || item === null || Array.isArray(item)) return false;
+      const itemKeys = Object.keys(item).sort().join(",");
+      if (itemKeys !== firstKeys) return false;
+    }
+    return true;
+  }
+  function encode(value, options) {
+    if (options?.forCompression) {
+      options = { ...options, enableInterning: false, skipHeader: true };
+    }
+    if (!options || options.enableInterning !== false && !options.skipHeader && (!options.maxDepth || options.maxDepth === 64)) {
+      if (Array.isArray(value) && isUniformObjectArray(value)) {
+        return new BoomBinaryEncoder(options || {}).encode(value);
+      }
+      return fastEncode(value);
+    }
+    const result = new BoomBinaryEncoder(options).encode(value);
+    if (options.skipHeader) {
+      return result.slice(6);
+    }
+    return result;
+  }
+  function decode(buffer, options) {
+    if (options?.strictBinaryMode) {
+      if (buffer.length < 6 || buffer[0] !== 66 || buffer[1] !== 79 || buffer[2] !== 79 || buffer[3] !== 77) {
+        throw new BoomError(
+          'Strict binary mode: input must be BOOM binary format (starts with "BOOM" magic bytes). JSON and BOOM text formats are not allowed in production mode.'
+        );
+      }
+    }
+    let actualBuffer = buffer;
+    if (options?.skipHeader || options?.forCompression) {
+      const withHeader = new Uint8Array(buffer.length + 6);
+      withHeader[0] = 66;
+      withHeader[1] = 79;
+      withHeader[2] = 79;
+      withHeader[3] = 77;
+      withHeader[4] = 1;
+      withHeader[5] = 0;
+      withHeader.set(buffer, 6);
+      actualBuffer = withHeader;
+    }
+    if (!options || (!options.maxDepth || options.maxDepth === 64)) {
+      return fastDecode(actualBuffer);
+    }
+    return new BoomBinaryDecoder(options).decode(actualBuffer);
+  }
+  function stringify(value, options) {
+    return new BoomTextEncoder(options).encode(value);
+  }
+  function parseText(input, options) {
+    return new BoomTextDecoder(options).decode(input);
+  }
+  var DEFAULT_THRESHOLDS = {
+    /** Below this, use JSON (default: 1KB) */
+    minSize: 1024,
+    /** Above this, prefer BOOM (default: 10KB) */
+    preferSize: 10240,
+    /** Above this, always use BOOM (default: 100KB) */
+    forceSize: 102400
+  };
+  var globalThresholdConfig = {
+    minSize: DEFAULT_THRESHOLDS.minSize,
+    preferSize: DEFAULT_THRESHOLDS.preferSize,
+    forceSize: DEFAULT_THRESHOLDS.forceSize,
+    autoDetect: true,
+    respectClientHint: true
+  };
+
+  // src/http/fetch.ts
+  var encodeFn;
+  var decodeFn;
+  var stringifyFn;
+  var parseTextFn;
+  function setCodecs(encode2, decode2, stringify2, parseText2) {
+    encodeFn = encode2;
+    decodeFn = decode2;
+    stringifyFn = stringify2;
+    parseTextFn = parseText2;
+  }
+
+  // src/browser.ts
+  var parseTextFn2 = null;
+  function setParseText(fn) {
+    parseTextFn2 = fn;
+  }
+
+  // src/constants.ts
+  var MAGIC = new Uint8Array([66, 79, 79, 77]);
+  var DEFAULT_OPTIONS2 = {
+    maxDepth: 64,
+    maxStringLength: 16 * 1024 * 1024,
+    maxArrayLength: 1e6,
+    enableInterning: true,
+    skipHeader: false,
+    forCompression: false
+  };
+
+  // src/index.ts
+  setParseText(parseText);
+  setCodecs(encode, decode, stringify, parseText);
+
+  // src/cli.ts
+  var VERSION3 = "1.0.0";
+  var BOOM_MAGIC = [66, 79, 79, 77];
+  function printHelp() {
+    console.log(`
+BOOM CLI v${VERSION3} - Binary Object Optimised Markup
+
+Usage:
+  boom encode <input.json> [output]        Encode JSON to BOOM format
+  boom decode <input.boom> [output.json]   Decode BOOM to JSON
+  boom info <input.boom>                   Show info about a BOOM file
+  boom <input.json>                        Shorthand for encode
+
+Output Formats:
+  --binary, -b   Output BOOM binary format (default)
+  --text, -t     Output BOOM text format (.boom.txt)
+  --json, -j     Output JSON format (for decode)
+
+Options:
+  --help, -h     Show this help message
+  --version, -v  Show version
+  --pretty, -p   Pretty-print output (JSON and text)
+  --dict, -d     Use shared dictionary (default: true)
+  --no-dict      Disable shared dictionary
+
+Examples:
+  boom encode data.json                    # Output: data.boom (binary)
+  boom encode data.json --text             # Output: data.boom.txt (text)
+  boom encode data.json output.boom        # Custom output file
+  boom decode data.boom                    # Output: data.json
+  boom decode data.boom --pretty           # Pretty-printed JSON
+  boom decode data.boom.txt                # Decode BOOM text
+  boom info data.boom                      # Show file info
+  cat data.json | boom encode - > out.boom # Stdin/stdout
+  cat data.boom | boom decode -            # Decode from stdin
+
+File Extensions:
+  .boom          BOOM binary format
+  .boom.txt      BOOM text format (human-readable)
+  .json          JSON format
+`);
+  }
+  function printVersion() {
+    console.log(`boom v${VERSION3}`);
+  }
+  function parseArgs(args) {
+    const options = {
+      command: "help",
+      input: null,
+      output: null,
+      pretty: false,
+      useDict: true,
+      format: "binary"
+    };
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === void 0) continue;
+      if (arg === "--help" || arg === "-h") {
+        options.command = "help";
+        return options;
+      }
+      if (arg === "--version" || arg === "-v") {
+        options.command = "version";
+        return options;
+      }
+      if (arg === "--pretty" || arg === "-p") {
+        options.pretty = true;
+        continue;
+      }
+      if (arg === "--dict" || arg === "-d") {
+        options.useDict = true;
+        continue;
+      }
+      if (arg === "--no-dict") {
+        options.useDict = false;
+        continue;
+      }
+      if (arg === "--binary" || arg === "-b") {
+        options.format = "binary";
+        continue;
+      }
+      if (arg === "--text" || arg === "-t") {
+        options.format = "text";
+        continue;
+      }
+      if (arg === "--json" || arg === "-j") {
+        options.format = "json";
+        continue;
+      }
+      if (arg === "-") {
+        positional.push(arg);
+      } else if (arg.startsWith("-")) {
+        console.error(`Unknown option: ${arg}`);
+        process.exit(1);
+      } else {
+        positional.push(arg);
+      }
+    }
+    if (positional.length === 0) {
+      options.command = "help";
+      return options;
+    }
+    const cmd = positional[0];
+    if (!cmd) {
+      options.command = "help";
+      return options;
+    }
+    const cmdLower = cmd.toLowerCase();
+    if (cmdLower === "encode") {
+      options.command = "encode";
+      options.input = positional[1] ?? null;
+      options.output = positional[2] ?? null;
+    } else if (cmdLower === "decode") {
+      options.command = "decode";
+      options.input = positional[1] ?? null;
+      options.output = positional[2] ?? null;
+    } else if (cmdLower === "info") {
+      options.command = "info";
+      options.input = positional[1] ?? null;
+    } else if (cmdLower === "help") {
+      options.command = "help";
+    } else if (cmdLower === "version") {
+      options.command = "version";
+    } else {
+      const inputFile = positional[0];
+      if (inputFile) {
+        options.input = inputFile;
+        options.output = positional[1] ?? null;
+        if (inputFile.endsWith(".boom") || inputFile.endsWith(".boom.txt")) {
+          options.command = "decode";
+        } else {
+          options.command = "encode";
+        }
+      }
+    }
+    return options;
+  }
+  function readInput(inputPath) {
+    if (inputPath === "-") {
+      return fs.readFileSync(0);
+    }
+    return fs.readFileSync(inputPath);
+  }
+  function getOutputPath(inputPath, command, format) {
+    if (inputPath === "-") {
+      return "-";
+    }
+    let base;
+    const dir = path.dirname(inputPath);
+    if (inputPath.endsWith(".boom.txt")) {
+      base = path.basename(inputPath, ".boom.txt");
+    } else {
+      const ext = path.extname(inputPath);
+      base = path.basename(inputPath, ext);
+    }
+    if (command === "encode") {
+      if (format === "text") {
+        return path.join(dir, base + ".boom.txt");
+      }
+      return path.join(dir, base + ".boom");
+    } else {
+      return path.join(dir, base + ".json");
+    }
+  }
+  function writeOutput(outputPath, data) {
+    if (outputPath === "-") {
+      if (typeof data === "string") {
+        process.stdout.write(data);
+      } else {
+        process.stdout.write(data);
+      }
+    } else {
+      fs.writeFileSync(outputPath, data);
+    }
+  }
+  function formatBytes(bytes) {
+    if (bytes < 1024) return bytes + " B";
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + " KB";
+    return (bytes / (1024 * 1024)).toFixed(2) + " MB";
+  }
+  async function runEncode(options) {
+    if (!options.input) {
+      console.error("Error: No input file specified");
+      process.exit(1);
+    }
+    const inputData = readInput(options.input);
+    const jsonData = JSON.parse(inputData.toString("utf-8"));
+    const outputPath = options.output || getOutputPath(options.input, "encode", options.format);
+    if (options.format === "text") {
+      const textData = stringify(jsonData, { compact: !options.pretty });
+      writeOutput(outputPath, textData + "\n");
+      if (outputPath !== "-") {
+        const savings = ((1 - textData.length / inputData.length) * 100).toFixed(1);
+        console.log(`Encoded: ${options.input} -> ${outputPath}`);
+        console.log(`  JSON:      ${formatBytes(inputData.length)}`);
+        console.log(`  BOOM text: ${formatBytes(textData.length)} (${savings}% smaller)`);
+      }
+    } else {
+      const boomData = encode(jsonData, { enableInterning: options.useDict });
+      writeOutput(outputPath, Buffer.from(boomData));
+      if (outputPath !== "-") {
+        const savings = ((1 - boomData.length / inputData.length) * 100).toFixed(1);
+        console.log(`Encoded: ${options.input} -> ${outputPath}`);
+        console.log(`  JSON:        ${formatBytes(inputData.length)}`);
+        console.log(`  BOOM binary: ${formatBytes(boomData.length)} (${savings}% smaller)`);
+      }
+    }
+  }
+  async function runDecode(options) {
+    if (!options.input) {
+      console.error("Error: No input file specified");
+      process.exit(1);
+    }
+    const inputData = readInput(options.input);
+    const isTextFormat = options.input.endsWith(".boom.txt") || options.input.endsWith(".txt") || !isBinaryFormat(inputData);
+    let jsonData;
+    let inputFormat;
+    if (isTextFormat) {
+      const textContent = inputData.toString("utf-8");
+      jsonData = parseText(textContent);
+      inputFormat = "BOOM text";
+    } else {
+      const boomArray = new Uint8Array(inputData);
+      if (boomArray.length < 6 || boomArray[0] !== BOOM_MAGIC[0] || boomArray[1] !== BOOM_MAGIC[1] || boomArray[2] !== BOOM_MAGIC[2] || boomArray[3] !== BOOM_MAGIC[3]) {
+        console.error("Error: Not a valid BOOM file (invalid magic header)");
+        process.exit(1);
+      }
+      jsonData = decode(boomArray);
+      inputFormat = "BOOM binary";
+    }
+    const jsonString = options.pretty ? JSON.stringify(jsonData, null, 2) : JSON.stringify(jsonData);
+    const outputPath = options.output || getOutputPath(options.input, "decode", options.format);
+    writeOutput(outputPath, jsonString + "\n");
+    if (outputPath !== "-") {
+      console.log(`Decoded: ${options.input} -> ${outputPath}`);
+      console.log(`  ${inputFormat}: ${formatBytes(inputData.length)}`);
+      console.log(`  JSON:        ${formatBytes(jsonString.length)}`);
+    }
+  }
+  function isBinaryFormat(data) {
+    return data.length >= 4 && data[0] === BOOM_MAGIC[0] && data[1] === BOOM_MAGIC[1] && data[2] === BOOM_MAGIC[2] && data[3] === BOOM_MAGIC[3];
+  }
+  async function runInfo(options) {
+    if (!options.input) {
+      console.error("Error: No input file specified");
+      process.exit(1);
+    }
+    const inputData = readInput(options.input);
+    const boomArray = new Uint8Array(inputData);
+    if (boomArray.length < 6 || boomArray[0] !== BOOM_MAGIC[0] || boomArray[1] !== BOOM_MAGIC[1] || boomArray[2] !== BOOM_MAGIC[2] || boomArray[3] !== BOOM_MAGIC[3]) {
+      console.error("Error: Not a valid BOOM file (invalid magic header)");
+      process.exit(1);
+    }
+    const version = boomArray[4];
+    const flags = boomArray[5];
+    const usesDict = flags !== void 0 ? (flags & 1) !== 0 : false;
+    const jsonData = decode(boomArray);
+    const jsonString = JSON.stringify(jsonData);
+    const prettyJson = JSON.stringify(jsonData, null, 2);
+    const savings = ((1 - boomArray.length / jsonString.length) * 100).toFixed(1);
+    console.log(`BOOM File Info: ${options.input}`);
+    console.log(`${"\u2500".repeat(50)}`);
+    console.log(`  Format version:    ${version}`);
+    console.log(`  Uses dictionary:   ${usesDict ? "yes" : "no"}`);
+    console.log(`  BOOM size:         ${formatBytes(boomArray.length)}`);
+    console.log(`  JSON size:         ${formatBytes(jsonString.length)}`);
+    console.log(`  Size reduction:    ${savings}%`);
+    console.log(`${"\u2500".repeat(50)}`);
+    console.log(`Preview (first 500 chars):`);
+    console.log(prettyJson.slice(0, 500) + (prettyJson.length > 500 ? "..." : ""));
+  }
+  async function main() {
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+    try {
+      switch (options.command) {
+        case "help":
+          printHelp();
+          break;
+        case "version":
+          printVersion();
+          break;
+        case "encode":
+          await runEncode(options);
+          break;
+        case "decode":
+          await runDecode(options);
+          break;
+        case "info":
+          await runInfo(options);
+          break;
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error: ${error.message}`);
+      } else {
+        console.error("An unknown error occurred");
+      }
+      process.exit(1);
+    }
+  }
+  main();
+})();
+/**
+ * BOOM - Binary Object Optimised Markup
+ * A compact binary serialisation format with readable debug mode
+ *
+ * @module boom-format
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * BOOM - Binary Object Optimised Markup
+ * A compact binary serialization format with readable debug mode
+ *
+ * @module boom-format
+ * @version 1.0.0
+ * @license MIT
+ */