@atproto/lex-data 0.0.3 → 0.0.5

package/dist/uint8array-concat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array-concat.js","sourceRoot":"","sources":["../src/uint8array-concat.ts"],"names":[],"mappings":";;;AAUA,8CAUC;AApBD,6DAAqD;AAErD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAEd,QAAA,aAAa,GAAG,MAAM;IACjC,CAAC,CAAC,SAAS,aAAa,CAAC,KAA4B;QACjD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,SAAgB,iBAAiB,CAAC,KAA4B;IAC5D,IAAI,WAAW,GAAG,CAAC,CAAA;IACnB,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,WAAW,IAAI,GAAG,CAAC,MAAM,CAAA;IAClD,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,CAAA;IAC1C,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACvB,MAAM,IAAI,GAAG,CAAC,MAAM,CAAA;IACtB,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC","sourcesContent":["import { NodeJSBuffer } from './lib/nodejs-buffer.js'\n\nconst Buffer = NodeJSBuffer\n\nexport const ui8ConcatNode = Buffer\n  ? function ui8ConcatNode(array: readonly Uint8Array[]): Uint8Array {\n      return Buffer.concat(array)\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function ui8ConcatPonyfill(array: readonly Uint8Array[]): Uint8Array {\n  let totalLength = 0\n  for (const arr of array) totalLength += arr.length\n  const result = new Uint8Array(totalLength)\n  let offset = 0\n  for (const arr of array) {\n    result.set(arr, offset)\n    offset += arr.length\n  }\n  return result\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"uint8array-from-base64.d.ts","sourceRoot":"","sources":["../src/uint8array-from-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAIvD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B;;WAEG;QACH,UAAU,CAAC,EAAE,CACX,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;YACR,wBAAwB;YACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAA;YACjC,iBAAiB,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,qBAAqB,CAAA;SAC/D,KACE,UAAU,CAAA;KAChB;CACF;AAED,eAAO,MAAM,gBAAgB,SAGhB,MAAM,aACD,cAAc,KACvB,UAAU,QAMT,CAAA;AAEV,eAAO,MAAM,cAAc,SAEhB,MAAM,aACD,cAAc,KACvB,UAAU,QAQT,CAAA;AAER,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,cAAyB,GAClC,UAAU,CAIZ"}
+{"version":3,"file":"uint8array-from-base64.d.ts","sourceRoot":"","sources":["../src/uint8array-from-base64.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAIvD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B;;WAEG;QACH,UAAU,CAAC,EAAE,CACX,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;YACR,wBAAwB;YACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAA;YACjC,iBAAiB,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,qBAAqB,CAAA;SAC/D,KACE,UAAU,CAAA;KAChB;CACF;AAED,eAAO,MAAM,gBAAgB,SAGhB,MAAM,aACD,cAAc,KACvB,UAAU,QAMT,CAAA;AAEV,eAAO,MAAM,cAAc,SAEhB,MAAM,aACD,cAAc,KACvB,UAAU,QAQyB,CAAA;AAE1C,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,cAAyB,GAClC,UAAU,CAIZ"}

package/dist/uint8array-from-base64.js

@@ -22,7 +22,7 @@ exports.fromBase64Node = Buffer
         // results in unexpected behavior downstream (e.g. in tests)
         return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 function fromBase64Ponyfill(b64, alphabet = 'base64') {
     const bytes = (0, from_string_1.fromString)(b64, b64.endsWith('=') ? `${alphabet}pad` : alphabet);
     verifyBase64ForBytes(b64, bytes);

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  : 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    : 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.d.ts

@@ -21,4 +21,5 @@ export declare const fromBase64: (b64: string, alphabet?: Base64Alphabet) => Uin
  */
 export declare function asUint8Array(input: unknown): Uint8Array | undefined;
 export declare function ui8Equals(a: Uint8Array, b: Uint8Array): boolean;
+export declare const ui8Concat: (array: readonly Uint8Array[]) => Uint8Array;
 //# sourceMappingURL=uint8array.d.ts.map

package/dist/uint8array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAYvD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAA2D,CAAA;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAAqE,CAAA;AAS1E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D"}
+{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAG+C,CAAA;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAGiD,CAAA;AAUtD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D;AAED,eAAO,MAAM,SAAS,8CAE+B,CAAA"}

package/dist/uint8array.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromBase64 = exports.toBase64 = void 0;
+exports.ui8Concat = exports.fromBase64 = exports.toBase64 = void 0;
 exports.asUint8Array = asUint8Array;
 exports.ui8Equals = ui8Equals;
+const uint8array_concat_js_1 = require("./uint8array-concat.js");
 const uint8array_from_base64_js_1 = require("./uint8array-from-base64.js");
 const uint8array_to_base64_js_1 = require("./uint8array-to-base64.js");
 // @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /
@@ -14,7 +15,10 @@ const uint8array_to_base64_js_1 = require("./uint8array-to-base64.js");
  *
  * @returns The base64 encoded string
  */
-exports.toBase64 = uint8array_to_base64_js_1.toBase64Native ?? uint8array_to_base64_js_1.toBase64Node ?? uint8array_to_base64_js_1.toBase64Ponyfill;
+exports.toBase64 = 
+/* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Native ??
+    /* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Node ??
+    /* v8 ignore next -- @preserve */ uint8array_to_base64_js_1.toBase64Ponyfill;
 /**
  * Decodes a base64 string into a Uint8Array. This function supports both padded
  * and unpadded base64 strings.
@@ -22,7 +26,11 @@ exports.toBase64 = uint8array_to_base64_js_1.toBase64Native ?? uint8array_to_bas
  * @returns The decoded {@link Uint8Array}
  * @throws If the input is not a valid base64 string
  */
-exports.fromBase64 = uint8array_from_base64_js_1.fromBase64Native ?? uint8array_from_base64_js_1.fromBase64Node ?? uint8array_from_base64_js_1.fromBase64Ponyfill;
+exports.fromBase64 = 
+/* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Native ??
+    /* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Node ??
+    /* v8 ignore next -- @preserve */ uint8array_from_base64_js_1.fromBase64Ponyfill;
+/* v8 ignore next -- @preserve */
 if (exports.toBase64 === uint8array_to_base64_js_1.toBase64Ponyfill || exports.fromBase64 === uint8array_from_base64_js_1.fromBase64Ponyfill) {
     /*#__PURE__*/
     console.warn('[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.');
@@ -55,4 +63,7 @@ function ui8Equals(a, b) {
     }
     return true;
 }
+exports.ui8Concat = 
+/* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatNode ??
+    /* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatPonyfill;
 //# sourceMappingURL=uint8array.js.map

package/dist/uint8array.js.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AAqDA,oCAkBC;AAED,8BAYC;AApFD,2EAIoC;AACpC,uEAIkC;AAIlC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ,GAGP,wCAAc,IAAI,sCAAY,IAAI,0CAAgB,CAAA;AAEhE;;;;;;GAMG;AACU,QAAA,UAAU,GAGL,4CAAgB,IAAI,0CAAc,IAAI,8CAAkB,CAAA;AAE1E,IAAI,gBAAQ,KAAK,0CAAgB,IAAI,kBAAU,KAAK,8CAAkB,EAAE,CAAC;IACvE,aAAa;IACb,OAAO,CAAC,IAAI,CACV,wJAAwJ,CACzJ,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,UAAU,CACnB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAChD,CAAA;IACH,CAAC;IAED,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QACjC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAgB,SAAS,CAAC,CAAa,EAAE,CAAa;IACpD,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClB,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["import { Base64Alphabet } from './uint8array-base64.js'\nimport {\n  fromBase64Native,\n  fromBase64Node,\n  fromBase64Ponyfill,\n} from './uint8array-from-base64.js'\nimport {\n  toBase64Native,\n  toBase64Node,\n  toBase64Ponyfill,\n} from './uint8array-to-base64.js'\n\nexport type { Base64Alphabet }\n\n// @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /\n// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /\n// toBase64 as deprecated. We can also drop NodeJS specific implementations\n// once NodeJS <24 is no longer supported.\n\n/**\n * Encodes a Uint8Array into a base64 string.\n *\n * @returns The base64 encoded string\n */\nexport const toBase64: (\n  bytes: Uint8Array,\n  alphabet?: Base64Alphabet,\n) => string = toBase64Native ?? toBase64Node ?? toBase64Ponyfill\n\n/**\n * Decodes a base64 string into a Uint8Array. This function supports both padded\n * and unpadded base64 strings.\n *\n * @returns The decoded {@link Uint8Array}\n * @throws If the input is not a valid base64 string\n */\nexport const fromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => Uint8Array = fromBase64Native ?? fromBase64Node ?? fromBase64Ponyfill\n\nif (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\n/**\n * Coerces various binary data representations into a Uint8Array.\n *\n * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.\n */\nexport function asUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  if (ArrayBuffer.isView(input)) {\n    return new Uint8Array(\n      input.buffer,\n      input.byteOffset,\n      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,\n    )\n  }\n\n  if (input instanceof ArrayBuffer) {\n    return new Uint8Array(input)\n  }\n\n  return undefined\n}\n\nexport function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false\n  }\n\n  for (let i = 0; i < a.byteLength; i++) {\n    if (a[i] !== b[i]) {\n      return false\n    }\n  }\n\n  return true\n}\n"]}
+{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AA6DA,oCAkBC;AAED,8BAYC;AA5FD,iEAAyE;AACzE,2EAIoC;AACpC,uEAIkC;AAIlC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ;AAInB,iCAAiC,CAAC,wCAAc;IAChD,iCAAiC,CAAC,sCAAY;IAC9C,iCAAiC,CAAC,0CAAgB,CAAA;AAEpD;;;;;;GAMG;AACU,QAAA,UAAU;AAIrB,iCAAiC,CAAC,4CAAgB;IAClD,iCAAiC,CAAC,0CAAc;IAChD,iCAAiC,CAAC,8CAAkB,CAAA;AAEtD,iCAAiC;AACjC,IAAI,gBAAQ,KAAK,0CAAgB,IAAI,kBAAU,KAAK,8CAAkB,EAAE,CAAC;IACvE,aAAa;IACb,OAAO,CAAC,IAAI,CACV,wJAAwJ,CACzJ,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,UAAU,CACnB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAChD,CAAA;IACH,CAAC;IAED,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QACjC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,SAAgB,SAAS,CAAC,CAAa,EAAE,CAAa;IACpD,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClB,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAEY,QAAA,SAAS;AACpB,iCAAiC,CAAC,oCAAa;IAC/C,iCAAiC,CAAC,wCAAiB,CAAA","sourcesContent":["import { Base64Alphabet } from './uint8array-base64.js'\nimport { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'\nimport {\n  fromBase64Native,\n  fromBase64Node,\n  fromBase64Ponyfill,\n} from './uint8array-from-base64.js'\nimport {\n  toBase64Native,\n  toBase64Node,\n  toBase64Ponyfill,\n} from './uint8array-to-base64.js'\n\nexport type { Base64Alphabet }\n\n// @TODO drop dependency on uint8arrays package once Uint8Array.fromBase64 /\n// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /\n// toBase64 as deprecated. We can also drop NodeJS specific implementations\n// once NodeJS <24 is no longer supported.\n\n/**\n * Encodes a Uint8Array into a base64 string.\n *\n * @returns The base64 encoded string\n */\nexport const toBase64: (\n  bytes: Uint8Array,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ toBase64Native ??\n  /* v8 ignore next -- @preserve */ toBase64Node ??\n  /* v8 ignore next -- @preserve */ toBase64Ponyfill\n\n/**\n * Decodes a base64 string into a Uint8Array. This function supports both padded\n * and unpadded base64 strings.\n *\n * @returns The decoded {@link Uint8Array}\n * @throws If the input is not a valid base64 string\n */\nexport const fromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => Uint8Array =\n  /* v8 ignore next -- @preserve */ fromBase64Native ??\n  /* v8 ignore next -- @preserve */ fromBase64Node ??\n  /* v8 ignore next -- @preserve */ fromBase64Ponyfill\n\n/* v8 ignore next -- @preserve */\nif (toBase64 === toBase64Ponyfill || fromBase64 === fromBase64Ponyfill) {\n  /*#__PURE__*/\n  console.warn(\n    '[@atproto/lex-data]: Uint8Array.fromBase64 / Uint8Array.prototype.toBase64 not available in this environment. Falling back to ponyfill implementation.',\n  )\n}\n\n/**\n * Coerces various binary data representations into a Uint8Array.\n *\n * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.\n */\nexport function asUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  if (ArrayBuffer.isView(input)) {\n    return new Uint8Array(\n      input.buffer,\n      input.byteOffset,\n      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,\n    )\n  }\n\n  if (input instanceof ArrayBuffer) {\n    return new Uint8Array(input)\n  }\n\n  return undefined\n}\n\nexport function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.byteLength !== b.byteLength) {\n    return false\n  }\n\n  for (let i = 0; i < a.byteLength; i++) {\n    if (a[i] !== b[i]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nexport const ui8Concat =\n  /* v8 ignore next -- @preserve */ ui8ConcatNode ??\n  /* v8 ignore next -- @preserve */ ui8ConcatPonyfill\n"]}

package/dist/utf8-grapheme-len.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utf8-grapheme-len.d.ts","sourceRoot":"","sources":["../src/utf8-grapheme-len.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,iBAAiB,SACM,MAAM,KAAG,MAAM,QAK3C,CAAA;AAER,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD"}
+{"version":3,"file":"utf8-grapheme-len.d.ts","sourceRoot":"","sources":["../src/utf8-grapheme-len.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,iBAAiB,SACM,MAAM,KAAG,MAAM,QAKT,CAAA;AAE1C,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/utf8-grapheme-len.js

@@ -8,7 +8,7 @@ const grapheme_1 = require("unicode-segmenter/grapheme");
 // https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter
 const segmenter = 'Segmenter' in Intl && typeof Intl.Segmenter === 'function'
     ? /*#__PURE__*/ new Intl.Segmenter()
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 exports.graphemeLenNative = segmenter
     ? function graphemeLenNative(str) {
         let length = 0;
@@ -16,7 +16,7 @@ exports.graphemeLenNative = segmenter
             length++;
         return length;
     }
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 function graphemeLenPonyfill(str) {
     return (0, grapheme_1.countGraphemes)(str);
 }

package/dist/utf8-grapheme-len.js.map

@@ -1 +1 @@
-{"version":3,"file":"utf8-grapheme-len.js","sourceRoot":"","sources":["../src/utf8-grapheme-len.ts"],"names":[],"mappings":";;;AAkBA,kDAEC;AApBD,yDAA2D;AAE3D,0EAA0E;AAC1E,oBAAoB;AACpB,+FAA+F;AAC/F,MAAM,SAAS,GACb,WAAW,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,UAAU;IACzD,CAAC,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE;IACpC,CAAC,CAAC,IAAI,CAAA;AAEG,QAAA,iBAAiB,GAAG,SAAS;IACxC,CAAC,CAAC,SAAS,iBAAiB,CAAC,GAAW;QACpC,IAAI,MAAM,GAAG,CAAC,CAAA;QACd,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC;YAAE,MAAM,EAAE,CAAA;QAChD,OAAO,MAAM,CAAA;IACf,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAER,SAAgB,mBAAmB,CAAC,GAAW;IAC7C,OAAO,IAAA,yBAAc,EAAC,GAAG,CAAC,CAAA;AAC5B,CAAC","sourcesContent":["import { countGraphemes } from 'unicode-segmenter/grapheme'\n\n// @TODO: Drop usage of \"unicode-segmenter\" package when Intl.Segmenter is\n// widely supported.\n// https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter\nconst segmenter =\n  'Segmenter' in Intl && typeof Intl.Segmenter === 'function'\n    ? /*#__PURE__*/ new Intl.Segmenter()\n    : null\n\nexport const graphemeLenNative = segmenter\n  ? function graphemeLenNative(str: string): number {\n      let length = 0\n      for (const _ of segmenter.segment(str)) length++\n      return length\n    }\n  : null\n\nexport function graphemeLenPonyfill(str: string): number {\n  return countGraphemes(str)\n}\n"]}
+{"version":3,"file":"utf8-grapheme-len.js","sourceRoot":"","sources":["../src/utf8-grapheme-len.ts"],"names":[],"mappings":";;;AAkBA,kDAEC;AApBD,yDAA2D;AAE3D,0EAA0E;AAC1E,oBAAoB;AACpB,+FAA+F;AAC/F,MAAM,SAAS,GACb,WAAW,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,UAAU;IACzD,CAAC,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE;IACpC,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE/B,QAAA,iBAAiB,GAAG,SAAS;IACxC,CAAC,CAAC,SAAS,iBAAiB,CAAC,GAAW;QACpC,IAAI,MAAM,GAAG,CAAC,CAAA;QACd,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC;YAAE,MAAM,EAAE,CAAA;QAChD,OAAO,MAAM,CAAA;IACf,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,SAAgB,mBAAmB,CAAC,GAAW;IAC7C,OAAO,IAAA,yBAAc,EAAC,GAAG,CAAC,CAAA;AAC5B,CAAC","sourcesContent":["import { countGraphemes } from 'unicode-segmenter/grapheme'\n\n// @TODO: Drop usage of \"unicode-segmenter\" package when Intl.Segmenter is\n// widely supported.\n// https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter\nconst segmenter =\n  'Segmenter' in Intl && typeof Intl.Segmenter === 'function'\n    ? /*#__PURE__*/ new Intl.Segmenter()\n    : /* v8 ignore next -- @preserve */ null\n\nexport const graphemeLenNative = segmenter\n  ? function graphemeLenNative(str: string): number {\n      let length = 0\n      for (const _ of segmenter.segment(str)) length++\n      return length\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function graphemeLenPonyfill(str: string): number {\n  return countGraphemes(str)\n}\n"]}

package/dist/utf8-len.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utf8-len.d.ts","sourceRoot":"","sources":["../src/utf8-len.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,YACS,MAAM,KAAG,MAAM,QAGxC,CAAA;AAER,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAsCrD"}
+{"version":3,"file":"utf8-len.d.ts","sourceRoot":"","sources":["../src/utf8-len.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,YACS,MAAM,KAAG,MAAM,QAGN,CAAA;AAE1C,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAsCrD"}

package/dist/utf8-len.js

@@ -10,7 +10,7 @@ exports.utf8LenNode = nodejs_buffer_js_1.NodeJSBuffer
     ? function utf8LenNode(string) {
         return nodejs_buffer_js_1.NodeJSBuffer.byteLength(string, 'utf8');
     }
-    : null;
+    : /* v8 ignore next -- @preserve */ null;
 function utf8LenCompute(string) {
     // The code below is similar to TextEncoder's implementation of UTF-8
     // encoding. However, using TextEncoder to get the byte length is slower

package/dist/utf8-len.js.map

@@ -1 +1 @@
-{"version":3,"file":"utf8-len.js","sourceRoot":"","sources":["../src/utf8-len.ts"],"names":[],"mappings":";;;AAYA,wCAsCC;AAlDD,6DAAqD;AAErD,8EAA8E;AAC9E,+EAA+E;AAC/E,8EAA8E;AAEjE,QAAA,WAAW,GAAG,+BAAY;IACrC,CAAC,CAAC,SAAS,WAAW,CAAC,MAAc;QACjC,OAAO,+BAAa,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAER,SAAgB,cAAc,CAAC,MAAc;IAC3C,qEAAqE;IACrE,wEAAwE;IACxE,+DAA+D;IAE/D,qDAAqD;IAErD,mDAAmD;IACnD,IAAI,GAAG,GAAG,MAAM,CAAC,MAAM,CAAA;IACvB,IAAI,IAAY,CAAA;IAEhB,gEAAgE;IAChE,uBAAuB;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QAE3B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,gBAAgB;QAClB,CAAC;aAAM,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,eAAe;YACf,GAAG,IAAI,CAAC,CAAA;QACV,CAAC;aAAM,CAAC;YACN,eAAe;YACf,GAAG,IAAI,CAAC,CAAA;YACR,sEAAsE;YACtE,+DAA+D;YAC/D,wEAAwE;YACxE,OAAO;YACP,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;gBACrC,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;gBAC/B,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;oBACrC,CAAC,EAAE,CAAA;gBACL,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAA;AACZ,CAAC","sourcesContent":["import { NodeJSBuffer } from './lib/nodejs-buffer.js'\n\n// @NOTE This file is not meant to be exported directly. Instead, we re-export\n// public functions from ./utf8.ts. The reason for this separation is that this\n// file allows to test both the NodeJS-optimized and ponyfill implementations.\n\nexport const utf8LenNode = NodeJSBuffer\n  ? function utf8LenNode(string: string): number {\n      return NodeJSBuffer!.byteLength(string, 'utf8')\n    }\n  : null\n\nexport function utf8LenCompute(string: string): number {\n  // The code below is similar to TextEncoder's implementation of UTF-8\n  // encoding. However, using TextEncoder to get the byte length is slower\n  // as it requires allocating a new Uint8Array and copying data:\n\n  // return new TextEncoder().encode(string).byteLength\n\n  // The base length is the string length (all ASCII)\n  let len = string.length\n  let code: number\n\n  // The loop calculates the number of additional bytes needed for\n  // non-ASCII characters\n  for (let i = 0; i < string.length; i += 1) {\n    code = string.charCodeAt(i)\n\n    if (code <= 0x7f) {\n      // ASCII, 1 byte\n    } else if (code <= 0x7ff) {\n      // 2 bytes char\n      len += 1\n    } else {\n      // 3 bytes char\n      len += 2\n      // If the current char is a high surrogate, and the next char is a low\n      // surrogate, skip the next char as the total is a 4 bytes char\n      // (represented as a surrogate pair in UTF-16) and was already accounted\n      // for.\n      if (code >= 0xd800 && code <= 0xdbff) {\n        code = string.charCodeAt(i + 1)\n        if (code >= 0xdc00 && code <= 0xdfff) {\n          i++\n        }\n      }\n    }\n  }\n\n  return len\n}\n"]}
+{"version":3,"file":"utf8-len.js","sourceRoot":"","sources":["../src/utf8-len.ts"],"names":[],"mappings":";;;AAYA,wCAsCC;AAlDD,6DAAqD;AAErD,8EAA8E;AAC9E,+EAA+E;AAC/E,8EAA8E;AAEjE,QAAA,WAAW,GAAG,+BAAY;IACrC,CAAC,CAAC,SAAS,WAAW,CAAC,MAAc;QACjC,OAAO,+BAAa,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,CAAC;IACH,CAAC,CAAC,iCAAiC,CAAC,IAAI,CAAA;AAE1C,SAAgB,cAAc,CAAC,MAAc;IAC3C,qEAAqE;IACrE,wEAAwE;IACxE,+DAA+D;IAE/D,qDAAqD;IAErD,mDAAmD;IACnD,IAAI,GAAG,GAAG,MAAM,CAAC,MAAM,CAAA;IACvB,IAAI,IAAY,CAAA;IAEhB,gEAAgE;IAChE,uBAAuB;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QAE3B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,gBAAgB;QAClB,CAAC;aAAM,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,eAAe;YACf,GAAG,IAAI,CAAC,CAAA;QACV,CAAC;aAAM,CAAC;YACN,eAAe;YACf,GAAG,IAAI,CAAC,CAAA;YACR,sEAAsE;YACtE,+DAA+D;YAC/D,wEAAwE;YACxE,OAAO;YACP,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;gBACrC,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;gBAC/B,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;oBACrC,CAAC,EAAE,CAAA;gBACL,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAA;AACZ,CAAC","sourcesContent":["import { NodeJSBuffer } from './lib/nodejs-buffer.js'\n\n// @NOTE This file is not meant to be exported directly. Instead, we re-export\n// public functions from ./utf8.ts. The reason for this separation is that this\n// file allows to test both the NodeJS-optimized and ponyfill implementations.\n\nexport const utf8LenNode = NodeJSBuffer\n  ? function utf8LenNode(string: string): number {\n      return NodeJSBuffer!.byteLength(string, 'utf8')\n    }\n  : /* v8 ignore next -- @preserve */ null\n\nexport function utf8LenCompute(string: string): number {\n  // The code below is similar to TextEncoder's implementation of UTF-8\n  // encoding. However, using TextEncoder to get the byte length is slower\n  // as it requires allocating a new Uint8Array and copying data:\n\n  // return new TextEncoder().encode(string).byteLength\n\n  // The base length is the string length (all ASCII)\n  let len = string.length\n  let code: number\n\n  // The loop calculates the number of additional bytes needed for\n  // non-ASCII characters\n  for (let i = 0; i < string.length; i += 1) {\n    code = string.charCodeAt(i)\n\n    if (code <= 0x7f) {\n      // ASCII, 1 byte\n    } else if (code <= 0x7ff) {\n      // 2 bytes char\n      len += 1\n    } else {\n      // 3 bytes char\n      len += 2\n      // If the current char is a high surrogate, and the next char is a low\n      // surrogate, skip the next char as the total is a 4 bytes char\n      // (represented as a surrogate pair in UTF-16) and was already accounted\n      // for.\n      if (code >= 0xd800 && code <= 0xdbff) {\n        code = string.charCodeAt(i + 1)\n        if (code >= 0xdc00 && code <= 0xdfff) {\n          i++\n        }\n      }\n    }\n  }\n\n  return len\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-data",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "description": "Core utilities for AT Lexicons",
   "keywords": [
@@ -28,10 +28,10 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "browser": "./dist/index.js",
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "dependencies": {
@@ -43,10 +43,10 @@
   },
   "devDependencies": {
     "core-js": "^3",
-    "jest": "^28.1.2"
+    "vitest": "^4.0.16"
   },
   "scripts": {
     "build": "tsc --build tsconfig.build.json",
-    "test": "jest"
+    "test": "vitest run"
   }
 }

package/src/blob.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { isBlobRef, isLegacyBlobRef } from './blob.js'
 import { parseCid } from './cid.js'
 
@@ -10,7 +11,7 @@ const lexCid = parseCid(
   'bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy',
 )
 
-describe('isBlobRef', () => {
+describe(isBlobRef, () => {
   it('tests valid blobCid and lexCid', () => {
     expect(blobCid.code).toBe(0x55) // raw
     expect(blobCid.multihash.code).toBe(0x12) // sha2-256
@@ -51,6 +52,25 @@ describe('isBlobRef', () => {
         size: '10000',
       }),
     ).toBe(false)
+
+    expect(
+      isBlobRef({
+        // $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(false)
+
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: { toString: () => 'image/jpeg' },
+        size: 10000,
+      }),
+    ).toBe(false)
+
     expect(
       isBlobRef(
         {
@@ -81,6 +101,22 @@ describe('isBlobRef', () => {
         { strict: true },
       ),
     ).toBe(false)
+
+    expect(isBlobRef('not an object')).toBe(false)
+    expect(isBlobRef([])).toBe(false)
+    expect(isBlobRef(new Date())).toBe(false)
+    expect(isBlobRef(new Map())).toBe(false)
+  })
+
+  it('rejects non-integer size', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000.5,
+      }),
+    ).toBe(false)
   })
 
   it('rejects invalid CID/multihash code', () => {
@@ -133,9 +169,28 @@ describe('isBlobRef', () => {
       ),
     ).toBe(false)
   })
+
+  describe('strict mode', () => {
+    it('rejects invalid CID version', () => {
+      const cidV0 = parseCid(
+        'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // CID v0
+      )
+      expect(
+        isBlobRef(
+          {
+            $type: 'blob',
+            ref: cidV0,
+            mimeType: 'image/jpeg',
+            size: 10000,
+          },
+          { strict: true },
+        ),
+      ).toBe(false)
+    })
+  })
 })
 
-describe('isLegacyBlobRef', () => {
+describe(isLegacyBlobRef, () => {
   it('parses valid legacy blob', () => {
     expect(
       isLegacyBlobRef({
@@ -172,6 +227,32 @@ describe('isLegacyBlobRef', () => {
         mimeType: 'image/jpeg',
       }),
     ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: lexCid.toString(),
+        mimeType: { toString: () => 'image/jpeg' },
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: lexCid.toString(),
+        mimeType: 3,
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: lexCid.toString(),
+        mimeType: '',
+      }),
+    ).toBe(false)
+
+    expect(isLegacyBlobRef([])).toBe(false)
+    expect(isLegacyBlobRef('not an object')).toBe(false)
+    expect(isLegacyBlobRef(new Date())).toBe(false)
+    expect(isLegacyBlobRef(new Map())).toBe(false)
   })
 
   it('rejects extra keys', () => {

package/src/blob.ts

@@ -7,6 +7,9 @@ import {
 } from './cid.js'
 import { isPlainObject } from './object.js'
 
+/**
+ * @note {@link BlobRef} is just a {@link LexMap} with a specific shape.
+ */
 export type BlobRef = {
   $type: 'blob'
   mimeType: string
@@ -32,7 +35,7 @@ export function isBlobRef(
     return false
   }
 
-  if (typeof size !== 'number' || size < 0 || !Number.isInteger(size)) {
+  if (typeof size !== 'number' || size < 0 || !Number.isSafeInteger(size)) {
     return false
   }
 
@@ -71,6 +74,9 @@ export function isBlobRef(
   return true
 }
 
+/**
+ * @note {@link LegacyBlobRef} is just a {@link LexMap} with a specific shape.
+ */
 export type LegacyBlobRef = {
   cid: string
   mimeType: string
@@ -86,7 +92,7 @@ export function isLegacyBlobRef(input: unknown): input is LegacyBlobRef {
     return false
   }
 
-  if (typeof mimeType !== 'string') {
+  if (typeof mimeType !== 'string' || mimeType.length === 0) {
     return false
   }
 

package/src/cid.test.ts

@@ -0,0 +1,126 @@
+import { CID } from 'multiformats/cid'
+import { sha256, sha512 } from 'multiformats/hashes/sha2'
+import { describe, expect, it } from 'vitest'
+import {
+  RAW_BIN_MULTICODEC,
+  createCid,
+  decodeCid,
+  ensureValidCidString,
+  isCid,
+  parseCid,
+  parseCidString,
+} from './cid.js'
+
+describe(isCid, () => {
+  describe('non-strict mode', () => {
+    it('returns true for parsed CIDs', () => {
+      const cid = parseCid(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      )
+      expect(isCid(cid)).toBe(true)
+    })
+
+    it('returns true for CID v0 and v1', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cidV0 = CID.createV0(digest)
+      const cidV1 = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cidV0)).toBe(true)
+      expect(isCid(cidV1)).toBe(true)
+    })
+
+    it('returns false for invalid CIDs', () => {
+      expect(isCid(new Date())).toBe(false)
+      expect(isCid({})).toBe(false)
+      expect(isCid('not a cid')).toBe(false)
+    })
+  })
+
+  describe('strict mode', () => {
+    it('returns true for valid CIDs in strict mode', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cid, { strict: true })).toBe(true)
+    })
+
+    it('rejects CID v0 when strict option is set', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV0(digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+
+    it('rejects CIDs with invalid hash algorithm', async () => {
+      const digest = await sha512.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+
+    it('rejects CIDs with invalid code', async () => {
+      const digest = await sha256.digest(Buffer.from('hello world'))
+      const cid = CID.createV1(3333, digest)
+      expect(isCid(cid, { strict: true })).toBe(false)
+    })
+  })
+})
+
+describe(createCid, () => {
+  it('creates a valid CID v1', async () => {
+    const digest = await sha256.digest(Buffer.from('hello world'))
+    const cid = createCid(RAW_BIN_MULTICODEC, digest)
+    expect(cid.version).toBe(1)
+    expect(cid.code).toBe(RAW_BIN_MULTICODEC)
+    expect(cid.multihash.code).toBe(sha256.code)
+    expect(cid.multihash.digest).toEqual(digest.digest)
+  })
+})
+
+describe(decodeCid, () => {
+  it('decodes CID from bytes', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCid(cidStr)
+    const bytes = cid.bytes
+    const decodedCid = decodeCid(bytes)
+    expect(decodedCid.toString()).toBe(cidStr)
+  })
+})
+
+describe(parseCid, () => {
+  it('parses valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCid(cidStr)
+    expect(cid.toString()).toBe(cidStr)
+  })
+
+  it('throws for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    expect(() => parseCid(invalidCidStr)).toThrow()
+  })
+})
+
+describe(parseCidString, () => {
+  it('parses valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    const cid = parseCidString(cidStr)
+    expect(cid).toBeDefined()
+    expect(cid!.toString()).toBe(cidStr)
+  })
+
+  it('returns undefined for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    const cid = parseCidString(invalidCidStr)
+    expect(cid).toBeUndefined()
+  })
+})
+
+describe(ensureValidCidString, () => {
+  it('does not throw for valid CIDs', () => {
+    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+    expect(() => ensureValidCidString(cidStr)).not.toThrow()
+  })
+
+  it('throws for invalid CIDs', () => {
+    const invalidCidStr = 'invalidcidstring'
+    expect(() => ensureValidCidString(invalidCidStr)).toThrow(
+      'Invalid CID string',
+    )
+  })
+})

package/src/cid.ts

@@ -22,21 +22,20 @@ declare module 'multiformats/cid' {
    * `multiformats/cid` in dependent packages, and instead have them rely on the
    * {@link Cid} interface from `@atproto/lex-data`. The {@link CID} class from
    * `multiformats` version <10 has compatibility issues with certain TypeScript
-   * module resolution strategies, which can lead to type errors in dependent
-   * packages.
+   * configuration, which can lead to type errors in dependent packages.
    *
    * We are stuck with version 9 because `@atproto` packages did not drop
    * CommonJS support yet, and multiformats version 10 only supports ES modules.
    *
    * In order to avoid compatibility issues, while preparing for future breaking
    * changes (CID in multiformats v10+ has a slightly different interface), as
-   * we update or swap out `multiformats`, we provide our own stable `Cid`
+   * we update or swap out `multiformats`, we provide our own stable {@link Cid}
    * interface.
    */
   interface CID {}
 }
 
-// CID form "multiformats" is not very portable because:
+// multiformats' CID class is not very portable because:
 //
 // - In dependent packages that use "moduleResolution" set to "node16",
 //   "nodenext" or "bundler", TypeScript fails to properly resolve the
@@ -46,14 +45,15 @@ declare module 'multiformats/cid' {
 //   uses "exports" field in package.json, which do not contain "types"
 //   entrypoints.
 //   https://www.npmjs.com/package/multiformats/v/9.9.0?activeTab=code
-// - By defining our own Cid interface and related functions, we can have more
-//   control over the API we expose to dependent packages.
+// - By defining our own interface and helper functions, we can have more
+//   control over the public API exposed by this package.
 // - It allow us to have a stable interface in case we need to swap out, or
 //   eventually update multiformats (should we choose to drop CommonJS support)
 //   in the future.
 
 // @NOTE Even though it is not portable, we still re-export CID here so that
-// dependent packages where it can be used, have access to it.
+// dependent packages where it can be used, have access to it (instead of
+// importing directly from "multiformats" or"multiformats/cid").
 export { CID }
 
 /**

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './blob.js'
 export * from './cid.js'
 export * from './language.js'
 export * from './lex-equals.js'
+export * from './lex-error.js'
 export * from './lex.js'
 export * from './object.js'
 export * from './uint8array.js'