@atproto/lex-data 0.0.5 → 0.0.7

package/dist/uint8array-from-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array-from-base64.js","sourceRoot":"","sources":["../src/uint8array-from-base64.ts"],"names":[],"mappings":"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","sourcesContent":["import { fromString } from 'uint8arrays/from-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\n\nconst Buffer = NodeJSBuffer\n\ndeclare global {\n  interface Uint8ArrayConstructor {\n    /**\n     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64 Uint8Array.fromBase64()}\n     */\n    fromBase64?: (\n      b64: string,\n      options?: {\n        /** @default 'base64' */\n        alphabet?: 'base64' | 'base64url'\n        lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial'\n      },\n    ) => Uint8Array\n  }\n}\n\nexport const fromBase64Native =\n  typeof Uint8Array.fromBase64 === 'function'\n    ? function fromBase64Native(\n        b64: string,\n        alphabet: Base64Alphabet = 'base64',\n      ): Uint8Array {\n        return Uint8Array.fromBase64!(b64, {\n          alphabet,\n          lastChunkHandling: 'loose',\n        })\n      }\n    : null\n\nexport const fromBase64Node = Buffer\n  ? function fromBase64Node(\n      b64: string,\n      alphabet: Base64Alphabet = 'base64',\n    ): Uint8Array {\n      const bytes = Buffer.from(b64, alphabet)\n      verifyBase64ForBytes(b64, bytes)\n      // Convert to Uint8Array because even though Buffer is a sub class of\n      // Uint8Array, it serializes differently to Uint8Array (e.g. in JSON) and\n      // results in unexpected behavior downstream (e.g. in tests)\n      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function fromBase64Ponyfill(\n  b64: string,\n  alphabet: Base64Alphabet = 'base64',\n): Uint8Array {\n  const bytes = fromString(b64, b64.endsWith('=') ? `${alphabet}pad` : alphabet)\n  verifyBase64ForBytes(b64, bytes)\n  return bytes\n}\n\n// @NOTE NodeJS will silently stop decoding at the first invalid character,\n// while \"uint8arrays/from-string\" will not validate that the padding is\n// correct. The following function performs basic validation to ensure that the\n// input was a valid base64 string. The availability of the \"bytes\" allows\n// to perform checks with O[1] complexity.\nfunction verifyBase64ForBytes(b64: string, bytes: Uint8Array): void {\n  const paddingCount = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0\n  const trimmedLength = b64.length - paddingCount\n  const expectedByteLength = Math.floor((trimmedLength * 3) / 4)\n  if (bytes.length !== expectedByteLength) {\n    throw new Error('Invalid base64 string')\n  }\n\n  const expectedB64Length = (bytes.length / 3) * 4\n  const expectedPaddingCount =\n    expectedB64Length % 4 === 0 ? 0 : 4 - (expectedB64Length % 4)\n  const expectedFullB64Length = expectedB64Length + expectedPaddingCount\n  if (b64.length > expectedFullB64Length) {\n    throw new Error('Invalid base64 string')\n  }\n\n  // The previous might still allow false positive if only the last few\n  // chars are invalid.\n  for (\n    let i = Math.ceil(expectedB64Length);\n    i < b64.length - paddingCount;\n    i++\n  ) {\n    const code = b64.charCodeAt(i)\n    if (\n      !(code >= 65 && code <= 90) && // A-Z\n      !(code >= 97 && code <= 122) && // a-z\n      !(code >= 48 && code <= 57) && // 0-9\n      code !== 43 && // +\n      code !== 47 // /\n    ) {\n      throw new Error('Invalid base64 string')\n    }\n  }\n}\n"]}
+{"version":3,"file":"uint8array-from-base64.js","sourceRoot":"","sources":["../src/uint8array-from-base64.ts"],"names":[],"mappings":"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","sourcesContent":["import { fromString } from 'uint8arrays/from-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\n\nconst Buffer = NodeJSBuffer\n\ndeclare global {\n  interface Uint8ArrayConstructor {\n    /**\n     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64 Uint8Array.fromBase64()}\n     */\n    fromBase64?: (\n      b64: string,\n      options?: {\n        /** @default 'base64' */\n        alphabet?: 'base64' | 'base64url'\n        lastChunkHandling?: 'loose' | 'strict' | 'stop-before-partial'\n      },\n    ) => Uint8Array\n  }\n}\n\nexport const fromBase64Native =\n  typeof Uint8Array.fromBase64 === 'function'\n    ? function fromBase64Native(\n        b64: string,\n        alphabet: Base64Alphabet = 'base64',\n      ): Uint8Array {\n        return Uint8Array.fromBase64!(b64, {\n          alphabet,\n          lastChunkHandling: 'loose',\n        })\n      }\n    : /* v8 ignore next -- @preserve */ null\n\nexport const fromBase64Node = Buffer\n  ? function fromBase64Node(\n      b64: string,\n      alphabet: Base64Alphabet = 'base64',\n    ): Uint8Array {\n      const bytes = Buffer.from(b64, alphabet)\n      verifyBase64ForBytes(b64, bytes)\n      // Convert to Uint8Array because even though Buffer is a sub class of\n      // Uint8Array, it serializes differently to Uint8Array (e.g. in JSON) and\n      // results in unexpected behavior downstream (e.g. in tests)\n      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function fromBase64Ponyfill(\n  b64: string,\n  alphabet: Base64Alphabet = 'base64',\n): Uint8Array {\n  const bytes = fromString(b64, b64.endsWith('=') ? `${alphabet}pad` : alphabet)\n  verifyBase64ForBytes(b64, bytes)\n  return bytes\n}\n\n// @NOTE NodeJS will silently stop decoding at the first invalid character,\n// while \"uint8arrays/from-string\" will not validate that the padding is\n// correct. The following function performs basic validation to ensure that the\n// input was a valid base64 string. The availability of the \"bytes\" allows\n// to perform checks with O[1] complexity.\nfunction verifyBase64ForBytes(b64: string, bytes: Uint8Array): void {\n  const paddingCount = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0\n  const trimmedLength = b64.length - paddingCount\n  const expectedByteLength = Math.floor((trimmedLength * 3) / 4)\n  if (bytes.length !== expectedByteLength) {\n    throw new Error('Invalid base64 string')\n  }\n\n  const expectedB64Length = (bytes.length / 3) * 4\n  const expectedPaddingCount =\n    expectedB64Length % 4 === 0 ? 0 : 4 - (expectedB64Length % 4)\n  const expectedFullB64Length = expectedB64Length + expectedPaddingCount\n  if (b64.length > expectedFullB64Length) {\n    throw new Error('Invalid base64 string')\n  }\n\n  // The previous might still allow false positive if only the last few\n  // chars are invalid.\n  for (\n    let i = Math.ceil(expectedB64Length);\n    i < b64.length - paddingCount;\n    i++\n  ) {\n    const code = b64.charCodeAt(i)\n    if (\n      !(code >= 65 && code <= 90) && // A-Z\n      !(code >= 97 && code <= 122) && // a-z\n      !(code >= 48 && code <= 57) && // 0-9\n      code !== 43 && // +\n      code !== 47 // /\n    ) {\n      throw new Error('Invalid base64 string')\n    }\n  }\n}\n"]}

package/dist/uint8array-to-base64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array-to-base64.d.ts","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAIvD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;WAEG;QACH,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE;YACpB,wBAAwB;YACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAA;YACjC,WAAW,CAAC,EAAE,OAAO,CAAA;SACtB,KAAK,MAAM,CAAA;KACb;CACF;AAED,eAAO,MAAM,cAAc,WAGZ,UAAU,aACP,cAAc,KACvB,MAAM,QAGL,CAAA;AAEV,eAAO,MAAM,YAAY,WAEZ,UAAU,aACP,cAAc,KACvB,MAAM,QAcL,CAAA;AAER,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,QAAQ,GAAE,cAAyB,GAClC,MAAM,CAER"}
+{"version":3,"file":"uint8array-to-base64.d.ts","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAIvD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;WAEG;QACH,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE;YACpB,wBAAwB;YACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAA;YACjC,WAAW,CAAC,EAAE,OAAO,CAAA;SACtB,KAAK,MAAM,CAAA;KACb;CACF;AAED,eAAO,MAAM,cAAc,WAGZ,UAAU,aACP,cAAc,KACvB,MAAM,QAG6B,CAAA;AAE5C,eAAO,MAAM,YAAY,WAEZ,UAAU,aACP,cAAc,KACvB,MAAM,QAc6B,CAAA;AAE1C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,QAAQ,GAAE,cAAyB,GAClC,MAAM,CAER"}

package/dist/uint8array-to-base64.js

@@ -9,7 +9,7 @@ exports.toBase64Native = typeof Uint8Array.prototype.toBase64 === 'function'
     ? function toBase64Native(bytes, alphabet = 'base64') {
         return bytes.toBase64({ alphabet, omitPadding: true });
     }
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 exports.toBase64Node = Buffer
     ? function toBase64Node(bytes, alphabet = 'base64') {
         const buffer = bytes instanceof Buffer ? bytes : Buffer.from(bytes);
@@ -24,7 +24,7 @@ exports.toBase64Node = Buffer
                 : b64.slice(0, -1) // '='
             : b64;
     }
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 function toBase64Ponyfill(bytes, alphabet = 'base64') {
     return (0, to_string_1.toString)(bytes, alphabet);
 }

package/dist/uint8array-to-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array-to-base64.js","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":";;;AAiDA,4CAKC;AAtDD,qDAAgD;AAChD,6DAAqD;AAGrD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAed,QAAA,cAAc,GACzB,OAAO,UAAU,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU;IACjD,CAAC,CAAC,SAAS,cAAc,CACrB,KAAiB,EACjB,WAA2B,QAAQ;QAEnC,OAAO,KAAK,CAAC,QAAS,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAA;IACzD,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAEG,QAAA,YAAY,GAAG,MAAM;IAChC,CAAC,CAAC,SAAS,YAAY,CACnB,KAAiB,EACjB,WAA2B,QAAQ;QAEnC,MAAM,MAAM,GAAG,KAAK,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACnE,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAErC,uDAAuD;QACvD,0EAA0E;QAC1E,sEAAsE;QACtE,6DAA6D;QAC7D,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI;YACtD,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI;gBACjD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO;gBAC1B,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM;YAC3B,CAAC,CAAC,GAAG,CAAA;IACT,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAER,SAAgB,gBAAgB,CAC9B,KAAiB,EACjB,WAA2B,QAAQ;IAEnC,OAAO,IAAA,oBAAQ,EAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AAClC,CAAC","sourcesContent":["import { toString } from 'uint8arrays/to-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\n\nconst Buffer = NodeJSBuffer\n\ndeclare global {\n  interface Uint8Array {\n    /**\n     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64 Uint8Array.prototype.toBase64()}\n     */\n    toBase64?: (options?: {\n      /** @default 'base64' */\n      alphabet?: 'base64' | 'base64url'\n      omitPadding?: boolean\n    }) => string\n  }\n}\n\nexport const toBase64Native =\n  typeof Uint8Array.prototype.toBase64 === 'function'\n    ? function toBase64Native(\n        bytes: Uint8Array,\n        alphabet: Base64Alphabet = 'base64',\n      ): string {\n        return bytes.toBase64!({ alphabet, omitPadding: true })\n      }\n    : null\n\nexport const toBase64Node = Buffer\n  ? function toBase64Node(\n      bytes: Uint8Array,\n      alphabet: Base64Alphabet = 'base64',\n    ): string {\n      const buffer = bytes instanceof Buffer ? bytes : Buffer.from(bytes)\n      const b64 = buffer.toString(alphabet)\n\n      // @NOTE We strip padding for strict compatibility with\n      // uint8arrays.toString behavior. Tests failing because of the presence of\n      // padding are not really synonymous with an actual error and we might\n      // (should?) actually want to keep the padding at some point.\n      return b64.charCodeAt(b64.length - 1) === /* '=' */ 0x3d\n        ? b64.charCodeAt(b64.length - 2) === /* '=' */ 0x3d\n          ? b64.slice(0, -2) // '=='\n          : b64.slice(0, -1) // '='\n        : b64\n    }\n  : null\n\nexport function toBase64Ponyfill(\n  bytes: Uint8Array,\n  alphabet: Base64Alphabet = 'base64',\n): string {\n  return toString(bytes, alphabet)\n}\n"]}
+{"version":3,"file":"uint8array-to-base64.js","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":";;;AAiDA,4CAKC;AAtDD,qDAAgD;AAChD,6DAAqD;AAGrD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAed,QAAA,cAAc,GACzB,OAAO,UAAU,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU;IACjD,CAAC,CAAC,SAAS,cAAc,CACrB,KAAiB,EACjB,WAA2B,QAAQ;QAEnC,OAAO,KAAK,CAAC,QAAS,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAA;IACzD,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE/B,QAAA,YAAY,GAAG,MAAM;IAChC,CAAC,CAAC,SAAS,YAAY,CACnB,KAAiB,EACjB,WAA2B,QAAQ;QAEnC,MAAM,MAAM,GAAG,KAAK,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACnE,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAErC,uDAAuD;QACvD,0EAA0E;QAC1E,sEAAsE;QACtE,6DAA6D;QAC7D,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI;YACtD,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI;gBACjD,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO;gBAC1B,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM;YAC3B,CAAC,CAAC,GAAG,CAAA;IACT,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,SAAgB,gBAAgB,CAC9B,KAAiB,EACjB,WAA2B,QAAQ;IAEnC,OAAO,IAAA,oBAAQ,EAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AAClC,CAAC","sourcesContent":["import { toString } from 'uint8arrays/to-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\n\nconst Buffer = NodeJSBuffer\n\ndeclare global {\n  interface Uint8Array {\n    /**\n     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64 Uint8Array.prototype.toBase64()}\n     */\n    toBase64?: (options?: {\n      /** @default 'base64' */\n      alphabet?: 'base64' | 'base64url'\n      omitPadding?: boolean\n    }) => string\n  }\n}\n\nexport const toBase64Native =\n  typeof Uint8Array.prototype.toBase64 === 'function'\n    ? function toBase64Native(\n        bytes: Uint8Array,\n        alphabet: Base64Alphabet = 'base64',\n      ): string {\n        return bytes.toBase64!({ alphabet, omitPadding: true })\n      }\n    : /* v8 ignore next -- @preserve */ null\n\nexport const toBase64Node = Buffer\n  ? function toBase64Node(\n      bytes: Uint8Array,\n      alphabet: Base64Alphabet = 'base64',\n    ): string {\n      const buffer = bytes instanceof Buffer ? bytes : Buffer.from(bytes)\n      const b64 = buffer.toString(alphabet)\n\n      // @NOTE We strip padding for strict compatibility with\n      // uint8arrays.toString behavior. Tests failing because of the presence of\n      // padding are not really synonymous with an actual error and we might\n      // (should?) actually want to keep the padding at some point.\n      return b64.charCodeAt(b64.length - 1) === /* '=' */ 0x3d\n        ? b64.charCodeAt(b64.length - 2) === /* '=' */ 0x3d\n          ? b64.slice(0, -2) // '=='\n          : b64.slice(0, -1) // '='\n        : b64\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function toBase64Ponyfill(\n  bytes: Uint8Array,\n  alphabet: Base64Alphabet = 'base64',\n): string {\n  return toString(bytes, alphabet)\n}\n"]}

package/dist/utf8-from-base64.d.ts

@@ -0,0 +1,4 @@
+import { Base64Alphabet } from './uint8array-base64.js';
+export declare const utf8FromBase64Node: ((b64: string, alphabet?: Base64Alphabet) => string) | null;
+export declare function utf8FromBase64Ponyfill(b64: string, alphabet?: Base64Alphabet): string;
+//# sourceMappingURL=utf8-from-base64.d.ts.map

package/dist/utf8-from-base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8-from-base64.d.ts","sourceRoot":"","sources":["../src/utf8-from-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAIvD,eAAO,MAAM,kBAAkB,SAEpB,MAAM,aACD,cAAc,KACvB,MAAM,QAG6B,CAAA;AAG1C,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,CAGR"}

package/dist/utf8-from-base64.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8FromBase64Node = void 0;
+exports.utf8FromBase64Ponyfill = utf8FromBase64Ponyfill;
+const from_string_1 = require("uint8arrays/from-string");
+const nodejs_buffer_js_1 = require("./lib/nodejs-buffer.js");
+const Buffer = nodejs_buffer_js_1.NodeJSBuffer;
+exports.utf8FromBase64Node = Buffer
+    ? function utf8FromBase64Node(b64, alphabet = 'base64') {
+        return Buffer.from(b64, alphabet).toString('utf8');
+    }
+    : /* v8 ignore next -- @preserve */ null;
+const textDecoder = /*#__PURE__*/ new TextDecoder();
+function utf8FromBase64Ponyfill(b64, alphabet) {
+    const bytes = (0, from_string_1.fromString)(b64, alphabet);
+    return textDecoder.decode(bytes);
+}
+//# sourceMappingURL=utf8-from-base64.js.map

package/dist/utf8-from-base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8-from-base64.js","sourceRoot":"","sources":["../src/utf8-from-base64.ts"],"names":[],"mappings":";;;AAgBA,wDAMC;AAtBD,yDAAoD;AACpD,6DAAqD;AAGrD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAEd,QAAA,kBAAkB,GAAG,MAAM;IACtC,CAAC,CAAC,SAAS,kBAAkB,CACzB,GAAW,EACX,WAA2B,QAAQ;QAEnC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IACpD,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,WAAW,EAAE,CAAA;AACnD,SAAgB,sBAAsB,CACpC,GAAW,EACX,QAAyB;IAEzB,MAAM,KAAK,GAAG,IAAA,wBAAU,EAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;IACvC,OAAO,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAClC,CAAC","sourcesContent":["import { fromString } from 'uint8arrays/from-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\n\nconst Buffer = NodeJSBuffer\n\nexport const utf8FromBase64Node = Buffer\n  ? function utf8FromBase64Node(\n      b64: string,\n      alphabet: Base64Alphabet = 'base64',\n    ): string {\n      return Buffer.from(b64, alphabet).toString('utf8')\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nconst textDecoder = /*#__PURE__*/ new TextDecoder()\nexport function utf8FromBase64Ponyfill(\n  b64: string,\n  alphabet?: Base64Alphabet,\n): string {\n  const bytes = fromString(b64, alphabet)\n  return textDecoder.decode(bytes)\n}\n"]}

package/dist/utf8-to-base64.d.ts

@@ -0,0 +1,4 @@
+import { Base64Alphabet } from './uint8array-base64.js';
+export declare const utf8ToBase64Node: ((text: string, alphabet?: Base64Alphabet) => string) | null;
+export declare function utf8ToBase64Ponyfill(text: string, alphabet?: Base64Alphabet): string;
+//# sourceMappingURL=utf8-to-base64.d.ts.map

package/dist/utf8-to-base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8-to-base64.d.ts","sourceRoot":"","sources":["../src/utf8-to-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAKvD,eAAO,MAAM,gBAAgB,UACO,MAAM,aAAa,cAAc,KAAG,MAAM,QAIpC,CAAA;AAG1C,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,CAGR"}

package/dist/utf8-to-base64.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8ToBase64Node = void 0;
+exports.utf8ToBase64Ponyfill = utf8ToBase64Ponyfill;
+const to_string_1 = require("uint8arrays/to-string");
+const nodejs_buffer_js_1 = require("./lib/nodejs-buffer.js");
+const uint8array_to_base64_js_1 = require("./uint8array-to-base64.js");
+const Buffer = nodejs_buffer_js_1.NodeJSBuffer;
+exports.utf8ToBase64Node = Buffer
+    ? function utf8ToBase64Node(text, alphabet) {
+        const buffer = Buffer.from(text, 'utf8');
+        return uint8array_to_base64_js_1.toBase64Node(buffer, alphabet);
+    }
+    : /* v8 ignore next -- @preserve */ null;
+const textEncoder = /*#__PURE__*/ new TextEncoder();
+function utf8ToBase64Ponyfill(text, alphabet) {
+    const bytes = textEncoder.encode(text);
+    return (0, to_string_1.toString)(bytes, alphabet);
+}
+//# sourceMappingURL=utf8-to-base64.js.map

package/dist/utf8-to-base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8-to-base64.js","sourceRoot":"","sources":["../src/utf8-to-base64.ts"],"names":[],"mappings":";;;AAeA,oDAMC;AArBD,qDAAgD;AAChD,6DAAqD;AAErD,uEAAwD;AAExD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAEd,QAAA,gBAAgB,GAAG,MAAM;IACpC,CAAC,CAAC,SAAS,gBAAgB,CAAC,IAAY,EAAE,QAAyB;QAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACxC,OAAO,sCAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACxC,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,WAAW,EAAE,CAAA;AACnD,SAAgB,oBAAoB,CAClC,IAAY,EACZ,QAAyB;IAEzB,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACtC,OAAO,IAAA,oBAAQ,EAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AAClC,CAAC","sourcesContent":["import { toString } from 'uint8arrays/to-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.js'\nimport { Base64Alphabet } from './uint8array-base64.js'\nimport { toBase64Node } from './uint8array-to-base64.js'\n\nconst Buffer = NodeJSBuffer\n\nexport const utf8ToBase64Node = Buffer\n  ? function utf8ToBase64Node(text: string, alphabet?: Base64Alphabet): string {\n      const buffer = Buffer.from(text, 'utf8')\n      return toBase64Node!(buffer, alphabet)\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nconst textEncoder = /*#__PURE__*/ new TextEncoder()\nexport function utf8ToBase64Ponyfill(\n  text: string,\n  alphabet?: Base64Alphabet,\n): string {\n  const bytes = textEncoder.encode(text)\n  return toString(bytes, alphabet)\n}\n"]}

package/dist/utf8.d.ts

@@ -1,3 +1,6 @@
+import { Base64Alphabet } from './uint8array.js';
 export declare const graphemeLen: (str: string) => number;
 export declare const utf8Len: (string: string) => number;
+export declare const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string;
+export declare const utf8FromBase64: (b64: string, alphabet?: Base64Alphabet) => string;
 //# sourceMappingURL=utf8.d.ts.map

package/dist/utf8.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MACD,CAAA;AAS1C,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAsC,CAAA"}
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAShD,eAAO,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAEY,CAAA;AAUvD,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAEQ,CAAA;AAElD,eAAO,MAAM,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,MAEf,CAAA;AAExD,eAAO,MAAM,cAAc,EAAE,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,MAEqD,CAAA"}

package/dist/utf8.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.utf8Len = exports.graphemeLen = void 0;
+exports.utf8FromBase64 = exports.utf8ToBase64 = exports.utf8Len = exports.graphemeLen = void 0;
+const utf8_from_base64_js_1 = require("./utf8-from-base64.js");
 const utf8_grapheme_len_js_1 = require("./utf8-grapheme-len.js");
 const utf8_len_js_1 = require("./utf8-len.js");
-exports.graphemeLen = utf8_grapheme_len_js_1.graphemeLenNative ?? utf8_grapheme_len_js_1.graphemeLenPonyfill;
+const utf8_to_base64_js_1 = require("./utf8-to-base64.js");
+exports.graphemeLen = 
+/* v8 ignore next -- @preserve */ utf8_grapheme_len_js_1.graphemeLenNative ??
+    /* v8 ignore next -- @preserve */ utf8_grapheme_len_js_1.graphemeLenPonyfill;
+/* v8 ignore next -- @preserve */
 if (exports.graphemeLen === utf8_grapheme_len_js_1.graphemeLenPonyfill) {
     /*#__PURE__*/
     console.warn('[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.');
 }
-exports.utf8Len = utf8_len_js_1.utf8LenNode ?? utf8_len_js_1.utf8LenCompute;
+exports.utf8Len = 
+/* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenNode ??
+    /* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenCompute;
+exports.utf8ToBase64 = 
+/* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Node ??
+    /* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Ponyfill;
+exports.utf8FromBase64 = 
+/* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Node ??
+    /* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Ponyfill;
 //# sourceMappingURL=utf8.js.map

package/dist/utf8.js.map

@@ -1 +1 @@
-{"version":3,"file":"utf8.js","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":";;;AAAA,iEAA+E;AAC/E,+CAA2D;AAE9C,QAAA,WAAW,GACtB,wCAAiB,IAAI,0CAAmB,CAAA;AAE1C,IAAI,mBAAW,KAAK,0CAAmB,EAAE,CAAC;IACxC,aAAa;IACb,OAAO,CAAC,IAAI,CACV,oHAAoH,CACrH,CAAA;AACH,CAAC;AAEY,QAAA,OAAO,GAA+B,yBAAW,IAAI,4BAAc,CAAA","sourcesContent":["import { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'\nimport { utf8LenCompute, utf8LenNode } from './utf8-len.js'\n\nexport const graphemeLen: (str: string) => number =\n  graphemeLenNative ?? graphemeLenPonyfill\n\nif (graphemeLen === graphemeLenPonyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\nexport const utf8Len: (string: string) => number = utf8LenNode ?? utf8LenCompute\n"]}
+{"version":3,"file":"utf8.js","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":";;;AACA,+DAG8B;AAC9B,iEAA+E;AAC/E,+CAA2D;AAC3D,2DAA4E;AAE/D,QAAA,WAAW;AACtB,iCAAiC,CAAC,wCAAiB;IACnD,iCAAiC,CAAC,0CAAmB,CAAA;AAEvD,iCAAiC;AACjC,IAAI,mBAAW,KAAK,0CAAmB,EAAE,CAAC;IACxC,aAAa;IACb,OAAO,CAAC,IAAI,CACV,oHAAoH,CACrH,CAAA;AACH,CAAC;AAEY,QAAA,OAAO;AAClB,iCAAiC,CAAC,yBAAW;IAC7C,iCAAiC,CAAC,4BAAc,CAAA;AAErC,QAAA,YAAY;AACvB,iCAAiC,CAAC,oCAAgB;IAClD,iCAAiC,CAAC,wCAAoB,CAAA;AAE3C,QAAA,cAAc;AAIzB,iCAAiC,CAAC,wCAAkB;IACpD,iCAAiC,CAAC,4CAAsB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array.js'\nimport {\n  utf8FromBase64Node,\n  utf8FromBase64Ponyfill,\n} from './utf8-from-base64.js'\nimport { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'\nimport { utf8LenCompute, utf8LenNode } from './utf8-len.js'\nimport { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'\n\nexport const graphemeLen: (str: string) => number =\n  /* v8 ignore next -- @preserve */ graphemeLenNative ??\n  /* v8 ignore next -- @preserve */ graphemeLenPonyfill\n\n/* v8 ignore next -- @preserve */\nif (graphemeLen === graphemeLenPonyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Intl.Segmenter is not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\nexport const utf8Len: (string: string) => number =\n  /* v8 ignore next -- @preserve */ utf8LenNode ??\n  /* v8 ignore next -- @preserve */ utf8LenCompute\n\nexport const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =\n  /* v8 ignore next -- @preserve */ utf8ToBase64Node ??\n  /* v8 ignore next -- @preserve */ utf8ToBase64Ponyfill\n\nexport const utf8FromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ utf8FromBase64Node ??\n  /* v8 ignore next -- @preserve */ utf8FromBase64Ponyfill\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-data",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "license": "MIT",
   "description": "Core utilities for AT Lexicons",
   "keywords": [

package/src/blob.test.ts

@@ -1,29 +1,39 @@
 import { describe, expect, it } from 'vitest'
-import { isBlobRef, isLegacyBlobRef } from './blob.js'
-import { parseCid } from './cid.js'
+import {
+  BlobRef,
+  LegacyBlobRef,
+  enumBlobRefs,
+  isBlobRef,
+  isLegacyBlobRef,
+} from './blob.js'
+import { RawCid, parseCid } from './cid.js'
+import { LexArray, LexMap, LexValue } from './lex.js'
 
 // await cidForRawBytes(Buffer.from('Hello, World!'))
-const blobCid = parseCid(
+const validBlobCid = parseCid(
   'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+  { flavor: 'raw' },
 )
+
 // await cidForLex(Buffer.from('Hello, World!'))
-const lexCid = parseCid(
+const invalidBlobCid = parseCid(
   'bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy',
+  { flavor: 'cbor' },
 )
 
 describe(isBlobRef, () => {
   it('tests valid blobCid and lexCid', () => {
-    expect(blobCid.code).toBe(0x55) // raw
-    expect(blobCid.multihash.code).toBe(0x12) // sha2-256
-    expect(lexCid.code).toBe(0x71) // dag-cbor
-    expect(lexCid.multihash.code).toBe(0x12) // sha2-256
+    expect(validBlobCid.code).toBe(0x55) // raw
+    expect(validBlobCid.multihash.code).toBe(0x12) // sha2-256
+    expect(invalidBlobCid.code).toBe(0x71) // dag-cbor
+    expect(invalidBlobCid.multihash.code).toBe(0x12) // sha2-256
   })
 
   it('parses valid blob', () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000,
       }),
@@ -33,7 +43,7 @@ describe(isBlobRef, () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: lexCid,
+          ref: invalidBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -43,11 +53,22 @@ describe(isBlobRef, () => {
     ).toBe(true)
   })
 
+  it('performs strict validation by default', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: invalidBlobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(false)
+  })
+
   it('rejects invalid inputs', () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: { $link: blobCid.toString() },
+        ref: { $link: validBlobCid.toString() },
         mimeType: 'image/jpeg',
         size: '10000',
       }),
@@ -56,7 +77,7 @@ describe(isBlobRef, () => {
     expect(
       isBlobRef({
         // $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000,
       }),
@@ -65,7 +86,7 @@ describe(isBlobRef, () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: { toString: () => 'image/jpeg' },
         size: 10000,
       }),
@@ -75,7 +96,7 @@ describe(isBlobRef, () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: { $link: blobCid.toString() },
+          ref: { $link: validBlobCid.toString() },
           mimeType: 'image/jpeg',
           size: '10000',
         },
@@ -112,7 +133,7 @@ describe(isBlobRef, () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000.5,
       }),
@@ -124,7 +145,7 @@ describe(isBlobRef, () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: blobCid,
+          ref: validBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -136,7 +157,7 @@ describe(isBlobRef, () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: lexCid,
+          ref: invalidBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -149,7 +170,7 @@ describe(isBlobRef, () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000,
         extra: 'not allowed',
@@ -160,7 +181,7 @@ describe(isBlobRef, () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: blobCid,
+          ref: validBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
           extra: 'not allowed',
@@ -194,14 +215,14 @@ describe(isLegacyBlobRef, () => {
   it('parses valid legacy blob', () => {
     expect(
       isLegacyBlobRef({
-        cid: blobCid.toString(),
+        cid: validBlobCid.toString(),
         mimeType: 'image/jpeg',
       }),
     ).toBe(true)
 
     expect(
       isLegacyBlobRef({
-        cid: lexCid.toString(),
+        cid: invalidBlobCid.toString(),
         mimeType: 'image/jpeg',
       }),
     ).toBe(true)
@@ -230,21 +251,21 @@ describe(isLegacyBlobRef, () => {
 
     expect(
       isLegacyBlobRef({
-        cid: lexCid.toString(),
+        cid: invalidBlobCid.toString(),
         mimeType: { toString: () => 'image/jpeg' },
       }),
     ).toBe(false)
 
     expect(
       isLegacyBlobRef({
-        cid: lexCid.toString(),
+        cid: invalidBlobCid.toString(),
         mimeType: 3,
       }),
     ).toBe(false)
 
     expect(
       isLegacyBlobRef({
-        cid: lexCid.toString(),
+        cid: invalidBlobCid.toString(),
         mimeType: '',
       }),
     ).toBe(false)
@@ -258,10 +279,114 @@ describe(isLegacyBlobRef, () => {
   it('rejects extra keys', () => {
     expect(
       isLegacyBlobRef({
-        cid: blobCid.toString(),
+        cid: validBlobCid.toString(),
         mimeType: 'image/jpeg',
         extra: 'not allowed',
       }),
     ).toBe(false)
   })
 })
+
+describe(enumBlobRefs, () => {
+  const valid1: BlobRef<RawCid> = {
+    $type: 'blob',
+    ref: validBlobCid,
+    mimeType: 'image/png',
+    size: 2048,
+  }
+
+  const valid2: BlobRef<RawCid> = {
+    $type: 'blob',
+    ref: validBlobCid,
+    mimeType: 'image/jpeg',
+    size: 1024,
+  }
+
+  const invalid: BlobRef = {
+    $type: 'blob',
+    ref: invalidBlobCid,
+    mimeType: 'image/jpeg',
+    size: 1024,
+  }
+
+  const legacy: LegacyBlobRef = {
+    cid: validBlobCid.toString(),
+    mimeType: 'image/gif',
+  }
+
+  const data: LexValue = {
+    name: 'example',
+    file: { deeply: { nested: { in: { object: { valid1 } } } } },
+    attachments: [valid2, invalid, legacy, { description: 'not a blob' }],
+  }
+
+  it('enumerates valid BlobRefs by default', () => {
+    const refs = Array.from(enumBlobRefs(data))
+    expect(refs).toHaveLength(2)
+    expect(refs.includes(valid1)).toBe(true)
+    expect(refs.includes(valid2)).toBe(true)
+  })
+
+  describe('strict support', () => {
+    it('enumerates valid BlobRefs in strict mode', () => {
+      const refs = Array.from(enumBlobRefs(data, { strict: true }))
+      expect(refs).toHaveLength(2)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+    })
+
+    it('enumerates all BlobRefs in non-strict mode', () => {
+      const refs = Array.from(enumBlobRefs(data, { strict: false }))
+      expect(refs).toHaveLength(3)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+      expect(refs.includes(invalid)).toBe(true)
+    })
+  })
+
+  describe('legacy support', () => {
+    it('returns LegacyBlobRefs when legacy option is enabled', () => {
+      const refs = Array.from(enumBlobRefs(data, { allowLegacy: true }))
+      expect(refs).toHaveLength(3)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+      expect(refs.includes(legacy)).toBe(true)
+    })
+  })
+
+  describe('safety', () => {
+    it('handles cyclic structures without infinite loops', () => {
+      const cyclicArray: LexArray = [valid2]
+      const cyclicObject: LexMap = {
+        name: 'cyclic',
+        blob: valid1,
+      }
+
+      // Creating a cycle
+      cyclicArray.push(cyclicArray)
+      cyclicObject.self = cyclicObject
+
+      const refs = Array.from(
+        enumBlobRefs({
+          cyclicObject,
+          cyclicArray,
+        }),
+      )
+      expect(refs).toHaveLength(2)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+    })
+
+    it('handles deep structures without exceeding call stack', () => {
+      // Creating a deep nested structure
+      let deepData: LexMap = { blob: valid1 }
+      for (let i = 0; i < 100_000; i++) {
+        deepData = { nested: deepData }
+      }
+
+      const refs = Array.from(enumBlobRefs(deepData))
+      expect(refs).toHaveLength(1)
+      expect(refs[0]).toBe(valid1)
+    })
+  })
+})