@atproto/lex-json 0.0.15 → 0.1.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @atproto/lex-json
 
+## 0.1.0-next.0
+
+### Minor Changes
+
+- [#4929](https://github.com/bluesky-social/atproto/pull/4929) [`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Drop support for Node.js 18 and 20. Node.js 22 is now the minimum supported version. Docker images now use Node.js 24.
+
+- [#4943](https://github.com/bluesky-social/atproto/pull/4943) [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Convert to pure ESM. All packages now ship `"type": "module"` with ES module output and Node16 module resolution.
+
+  Node.js 22's `require()` compatibility layer can still load these packages in CommonJS code.
+
+- [#4930](https://github.com/bluesky-social/atproto/pull/4930) [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9) Thanks [@devinivy](https://github.com/devinivy)! - Build with TypeScript 6.0. Emitted `.d.ts` files now use TypeScript 6's stricter `Uint8Array<ArrayBuffer>` typing in places where Web/Node APIs require buffer-backed (not shared-memory) byte arrays. Consumers compiling against these types on older TypeScript should see no runtime impact, but may need to widen or cast in spots that previously relied on `Uint8Array` defaulting to `<ArrayBufferLike>`.
+
+  Internal: tsconfig `moduleResolution: "node"` is silenced via `ignoreDeprecations: "6.0"` for now; the proper migration to `node16`/`bundler` resolution is deferred.
+
+### Patch Changes
+
+- Updated dependencies [[`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b), [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028), [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9)]:
+  - @atproto/lex-data@0.1.0-next.0
+
+## 0.0.16
+
+### Patch Changes
+
+- [#4836](https://github.com/bluesky-social/atproto/pull/4836) [`952354c`](https://github.com/bluesky-social/atproto/commit/952354c1dd458251f8b643d02f4b227d40c5df17) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Improve performances of `lexParseJsonBytes` function
+
 ## 0.0.15
 
 ### Patch Changes

package/dist/blob.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTypedBlobRef = parseTypedBlobRef;
-const lex_data_1 = require("@atproto/lex-data");
-const link_js_1 = require("./link.js");
+import { isTypedBlobRef, } from '@atproto/lex-data';
+import { parseLexLink } from './link.js';
 /**
  * Parses a blob reference from a JSON object.
  *
@@ -37,7 +34,7 @@ const link_js_1 = require("./link.js");
  * // result is undefined
  * ```
  */
-function parseTypedBlobRef(input, options) {
+export function parseTypedBlobRef(input, options) {
     if (input.$type !== 'blob')
         return undefined;
     const ref = input?.ref;
@@ -48,14 +45,14 @@ function parseTypedBlobRef(input, options) {
     // jsonToLex), the `ref` property may either be a LexMap with a $link
     // property, or it may already be a CID instance.
     if ('$link' in ref) {
-        const cid = (0, link_js_1.parseLexLink)(ref);
+        const cid = parseLexLink(ref);
         if (!cid)
             return undefined;
         const blob = { ...input, ref: cid };
-        if ((0, lex_data_1.isTypedBlobRef)(blob, options))
+        if (isTypedBlobRef(blob, options))
             return blob;
     }
-    if ((0, lex_data_1.isTypedBlobRef)(input)) {
+    if (isTypedBlobRef(input)) {
         return input;
     }
     return undefined;

package/dist/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":";;AA0CA,8CA2BC;AArED,gDAK0B;AAC1B,uCAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,iBAAiB,CAC/B,KAAa,EACb,OAA6B;IAE7B,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,SAAS,CAAA;IAE5C,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAA;IACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IAErD,8EAA8E;IAC9E,oEAAoE;IACpE,qEAAqE;IACrE,iDAAiD;IAEjD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAE1B,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;QACnC,IAAI,IAAA,yBAAc,EAAC,IAAI,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;IAChD,CAAC;IAED,IAAI,IAAA,yBAAc,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC","sourcesContent":["import {\n  BlobRefCheckOptions,\n  LexMap,\n  TypedBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { parseLexLink } from './link.js'\n\n/**\n * Parses a blob reference from a JSON object.\n *\n * In the AT Protocol, blobs are referenced using a specific object structure\n * with `$type: 'blob'`, a `ref` property containing a CID link, and metadata\n * like `mimeType` and `size`. This function validates and parses such objects\n * into `BlobRef` instances.\n *\n * The function handles both cases where the `ref` property is:\n * - A `{$link: string}` object (when parsing from JSON)\n * - Already a `Cid` instance (when the parent object has been partially converted)\n *\n * @param input - A Lex map potentially representing a blob reference\n * @param options - Optional blob reference validation options\n * @returns The parsed `BlobRef` if the input is a valid blob reference,\n *          or `undefined` if the input is not a valid blob representation\n *\n * @example\n * ```typescript\n * // Parse a blob reference from JSON\n * const blobRef = parseTypedBlobRef({\n *   $type: 'blob',\n *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },\n *   mimeType: 'image/png',\n *   size: 12345\n * })\n *\n * // blobRef.ref is a Cid instance\n *\n * // Returns undefined for non-blob objects\n * const result = parseTypedBlobRef({ foo: 'bar' })\n * // result is undefined\n * ```\n */\nexport function parseTypedBlobRef(\n  input: LexMap,\n  options?: BlobRefCheckOptions,\n): TypedBlobRef | undefined {\n  if (input.$type !== 'blob') return undefined\n\n  const ref = input?.ref\n  if (!ref || typeof ref !== 'object') return undefined\n\n  // @NOTE Because json to lex conversion can be performed both in a depth-first\n  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via\n  // jsonToLex), the `ref` property may either be a LexMap with a $link\n  // property, or it may already be a CID instance.\n\n  if ('$link' in ref) {\n    const cid = parseLexLink(ref)\n    if (!cid) return undefined\n\n    const blob = { ...input, ref: cid }\n    if (isTypedBlobRef(blob, options)) return blob\n  }\n\n  if (isTypedBlobRef(input)) {\n    return input\n  }\n\n  return undefined\n}\n"]}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,cAAc,GACf,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAa,EACb,OAA6B;IAE7B,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,SAAS,CAAA;IAE5C,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAA;IACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IAErD,8EAA8E;IAC9E,oEAAoE;IACpE,qEAAqE;IACrE,iDAAiD;IAEjD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAE1B,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;QACnC,IAAI,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;IAChD,CAAC;IAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC","sourcesContent":["import {\n  BlobRefCheckOptions,\n  LexMap,\n  TypedBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { parseLexLink } from './link.js'\n\n/**\n * Parses a blob reference from a JSON object.\n *\n * In the AT Protocol, blobs are referenced using a specific object structure\n * with `$type: 'blob'`, a `ref` property containing a CID link, and metadata\n * like `mimeType` and `size`. This function validates and parses such objects\n * into `BlobRef` instances.\n *\n * The function handles both cases where the `ref` property is:\n * - A `{$link: string}` object (when parsing from JSON)\n * - Already a `Cid` instance (when the parent object has been partially converted)\n *\n * @param input - A Lex map potentially representing a blob reference\n * @param options - Optional blob reference validation options\n * @returns The parsed `BlobRef` if the input is a valid blob reference,\n *          or `undefined` if the input is not a valid blob representation\n *\n * @example\n * ```typescript\n * // Parse a blob reference from JSON\n * const blobRef = parseTypedBlobRef({\n *   $type: 'blob',\n *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },\n *   mimeType: 'image/png',\n *   size: 12345\n * })\n *\n * // blobRef.ref is a Cid instance\n *\n * // Returns undefined for non-blob objects\n * const result = parseTypedBlobRef({ foo: 'bar' })\n * // result is undefined\n * ```\n */\nexport function parseTypedBlobRef(\n  input: LexMap,\n  options?: BlobRefCheckOptions,\n): TypedBlobRef | undefined {\n  if (input.$type !== 'blob') return undefined\n\n  const ref = input?.ref\n  if (!ref || typeof ref !== 'object') return undefined\n\n  // @NOTE Because json to lex conversion can be performed both in a depth-first\n  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via\n  // jsonToLex), the `ref` property may either be a LexMap with a $link\n  // property, or it may already be a CID instance.\n\n  if ('$link' in ref) {\n    const cid = parseLexLink(ref)\n    if (!cid) return undefined\n\n    const blob = { ...input, ref: cid }\n    if (isTypedBlobRef(blob, options)) return blob\n  }\n\n  if (isTypedBlobRef(input)) {\n    return input\n  }\n\n  return undefined\n}\n"]}

package/dist/bytes.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLexBytes = parseLexBytes;
-exports.encodeLexBytes = encodeLexBytes;
-const lex_data_1 = require("@atproto/lex-data");
+import { fromBase64, toBase64 } from '@atproto/lex-data';
 /**
  * Parses a `{$bytes: string}` JSON object into a `Uint8Array`.
  *
@@ -29,7 +25,7 @@ const lex_data_1 = require("@atproto/lex-data");
  * // invalid is undefined
  * ```
  */
-function parseLexBytes(input) {
+export function parseLexBytes(input) {
     if (!input || !('$bytes' in input)) {
         return undefined;
     }
@@ -42,7 +38,7 @@ function parseLexBytes(input) {
         return undefined;
     }
     try {
-        return (0, lex_data_1.fromBase64)(input.$bytes);
+        return fromBase64(input.$bytes);
     }
     catch {
         return undefined;
@@ -65,7 +61,7 @@ function parseLexBytes(input) {
  * // encoded is { $bytes: 'SGVsbG8sIHdvcmxkIQ==' }
  * ```
  */
-function encodeLexBytes(bytes) {
-    return { $bytes: (0, lex_data_1.toBase64)(bytes) };
+export function encodeLexBytes(bytes) {
+    return { $bytes: toBase64(bytes) };
 }
 //# sourceMappingURL=bytes.js.map

package/dist/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":";;AA6BA,sCAsBC;AAmBD,wCAEC;AAxED,gDAAwD;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,aAAa,CAC3B,KAA+B;IAE/B,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC;IAED,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QACrC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,IAAI,CAAC;QACH,OAAO,IAAA,qBAAU,EAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,cAAc,CAAC,KAAiB;IAC9C,OAAO,EAAE,MAAM,EAAE,IAAA,mBAAQ,EAAC,KAAK,CAAC,EAAE,CAAA;AACpC,CAAC","sourcesContent":["import { fromBase64, toBase64 } from '@atproto/lex-data'\nimport { JsonValue } from './json.js'\n\n/**\n * Parses a `{$bytes: string}` JSON object into a `Uint8Array`.\n *\n * In the AT Protocol data model, binary data is represented in JSON as an object\n * with a single `$bytes` property containing a base64-encoded string. This function\n * decodes that representation back into raw bytes.\n *\n * @param input - An object potentially containing a `$bytes` property\n * @returns The decoded `Uint8Array` if the input is a valid `$bytes` object,\n *          or `undefined` if the input is not a valid `$bytes` representation\n *\n * @example\n * ```typescript\n * // Parse a $bytes object to Uint8Array\n * const bytes = parseLexBytes({ $bytes: 'SGVsbG8sIHdvcmxkIQ==' })\n * // bytes is Uint8Array containing \"Hello, world!\"\n *\n * // Returns undefined for non-$bytes objects\n * const result = parseLexBytes({ foo: 'bar' })\n * // result is undefined\n *\n * // Returns undefined for objects with extra properties\n * const invalid = parseLexBytes({ $bytes: 'SGVsbG8=', extra: true })\n * // invalid is undefined\n * ```\n */\nexport function parseLexBytes(\n  input?: Record<string, unknown>,\n): Uint8Array | undefined {\n  if (!input || !('$bytes' in input)) {\n    return undefined\n  }\n\n  for (const key in input) {\n    if (key !== '$bytes') {\n      return undefined\n    }\n  }\n\n  if (typeof input.$bytes !== 'string') {\n    return undefined\n  }\n\n  try {\n    return fromBase64(input.$bytes)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Encodes a `Uint8Array` into a `{$bytes: string}` JSON representation.\n *\n * In the AT Protocol data model, binary data is represented in JSON as an object\n * with a single `$bytes` property containing a base64-encoded string. This function\n * performs that encoding.\n *\n * @param bytes - The binary data to encode\n * @returns An object with a `$bytes` property containing the base64-encoded data\n *\n * @example\n * ```typescript\n * const bytes = new TextEncoder().encode('Hello, world!')\n * const encoded = encodeLexBytes(bytes)\n * // encoded is { $bytes: 'SGVsbG8sIHdvcmxkIQ==' }\n * ```\n */\nexport function encodeLexBytes(bytes: Uint8Array): JsonValue {\n  return { $bytes: toBase64(bytes) }\n}\n"]}
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,aAAa,CAC3B,KAA+B;IAE/B,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC;IAED,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QACrC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,IAAI,CAAC;QACH,OAAO,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,cAAc,CAAC,KAAiB;IAC9C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAA;AACpC,CAAC","sourcesContent":["import { fromBase64, toBase64 } from '@atproto/lex-data'\nimport { JsonValue } from './json.js'\n\n/**\n * Parses a `{$bytes: string}` JSON object into a `Uint8Array`.\n *\n * In the AT Protocol data model, binary data is represented in JSON as an object\n * with a single `$bytes` property containing a base64-encoded string. This function\n * decodes that representation back into raw bytes.\n *\n * @param input - An object potentially containing a `$bytes` property\n * @returns The decoded `Uint8Array` if the input is a valid `$bytes` object,\n *          or `undefined` if the input is not a valid `$bytes` representation\n *\n * @example\n * ```typescript\n * // Parse a $bytes object to Uint8Array\n * const bytes = parseLexBytes({ $bytes: 'SGVsbG8sIHdvcmxkIQ==' })\n * // bytes is Uint8Array containing \"Hello, world!\"\n *\n * // Returns undefined for non-$bytes objects\n * const result = parseLexBytes({ foo: 'bar' })\n * // result is undefined\n *\n * // Returns undefined for objects with extra properties\n * const invalid = parseLexBytes({ $bytes: 'SGVsbG8=', extra: true })\n * // invalid is undefined\n * ```\n */\nexport function parseLexBytes(\n  input?: Record<string, unknown>,\n): Uint8Array | undefined {\n  if (!input || !('$bytes' in input)) {\n    return undefined\n  }\n\n  for (const key in input) {\n    if (key !== '$bytes') {\n      return undefined\n    }\n  }\n\n  if (typeof input.$bytes !== 'string') {\n    return undefined\n  }\n\n  try {\n    return fromBase64(input.$bytes)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Encodes a `Uint8Array` into a `{$bytes: string}` JSON representation.\n *\n * In the AT Protocol data model, binary data is represented in JSON as an object\n * with a single `$bytes` property containing a base64-encoded string. This function\n * performs that encoding.\n *\n * @param bytes - The binary data to encode\n * @returns An object with a `$bytes` property containing the base64-encoded data\n *\n * @example\n * ```typescript\n * const bytes = new TextEncoder().encode('Hello, world!')\n * const encoded = encodeLexBytes(bytes)\n * // encoded is { $bytes: 'SGVsbG8sIHdvcmxkIQ==' }\n * ```\n */\nexport function encodeLexBytes(bytes: Uint8Array): JsonValue {\n  return { $bytes: toBase64(bytes) }\n}\n"]}

package/dist/index.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./bytes.js"), exports);
-tslib_1.__exportStar(require("./json.js"), exports);
-tslib_1.__exportStar(require("./lex-json.js"), exports);
-tslib_1.__exportStar(require("./link.js"), exports);
+export * from './bytes.js';
+export * from './json.js';
+export * from './lex-json.js';
+export * from './link.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAA0B;AAC1B,oDAAyB;AACzB,wDAA6B;AAC7B,oDAAyB","sourcesContent":["export * from './bytes.js'\nexport * from './json.js'\nexport * from './lex-json.js'\nexport * from './link.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA","sourcesContent":["export * from './bytes.js'\nexport * from './json.js'\nexport * from './lex-json.js'\nexport * from './link.js'\n"]}

package/dist/json-bytes-decoder.d.ts

@@ -0,0 +1,24 @@
+import { LexValue } from '@atproto/lex-data';
+export declare const BASE64_NATIVE_THRESHOLD = 256;
+export declare class JsonBytesDecoder {
+    private readonly data;
+    private readonly strict;
+    private pos;
+    constructor(data: Uint8Array, strict?: boolean);
+    decode(): LexValue;
+    private parseValue;
+    private parseObject;
+    private parseArray;
+    private parseString;
+    private parseEscapeSequence;
+    private parseUnicodeEscape;
+    private hexValue;
+    private base64Value;
+    private decodeUnescapedString;
+    private parseNumber;
+    private parseTrue;
+    private parseFalse;
+    private parseNull;
+    private skipWhitespace;
+}
+//# sourceMappingURL=json-bytes-decoder.d.ts.map

package/dist/json-bytes-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-bytes-decoder.d.ts","sourceRoot":"","sources":["../src/json-bytes-decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwB,MAAM,mBAAmB,CAAA;AAkElE,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,GAAG,CAAI;gBAGI,IAAI,EAAE,UAAU,EAChB,MAAM,UAAO;IAGhC,MAAM,IAAI,QAAQ;IAYlB,OAAO,CAAC,UAAU;IAuBlB,OAAO,CAAC,WAAW;IA4LnB,OAAO,CAAC,UAAU;IA+BlB,OAAO,CAAC,WAAW;IA+DnB,OAAO,CAAC,mBAAmB;IA2B3B,OAAO,CAAC,kBAAkB;IAwC1B,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,qBAAqB;IAkC7B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,cAAc;CAkBvB"}