@atproto/lex-data 0.0.7 → 0.0.9

package/dist/uint8array.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ui8Concat = exports.fromBase64 = exports.toBase64 = void 0;
+exports.ifUint8Array = ifUint8Array;
 exports.asUint8Array = asUint8Array;
 exports.ui8Equals = ui8Equals;
 const uint8array_concat_js_1 = require("./uint8array-concat.js");
@@ -17,8 +18,8 @@ const uint8array_to_base64_js_1 = require("./uint8array-to-base64.js");
  */
 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;
+    uint8array_to_base64_js_1.toBase64Node ??
+    uint8array_to_base64_js_1.toBase64Ponyfill;
 /**
  * Decodes a base64 string into a Uint8Array. This function supports both padded
  * and unpadded base64 strings.
@@ -28,13 +29,19 @@ exports.toBase64 =
  */
 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;
+    uint8array_from_base64_js_1.fromBase64Node ??
+    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.');
 }
+function ifUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    return undefined;
+}
 /**
  * Coerces various binary data representations into a Uint8Array.
  *
@@ -64,6 +71,5 @@ 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;
+/* v8 ignore next -- @preserve */ uint8array_concat_js_1.ui8ConcatNode ?? 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":";;;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"]}
+{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AAwDA,oCAMC;AAOD,oCAkBC;AAED,8BAYC;AApGD,iEAAyE;AACzE,2EAIoC;AACpC,uEAIkC;AAIlC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ;AAInB,iCAAiC,CAAC,wCAAc;IAChD,sCAAY;IACZ,0CAAgB,CAAA;AAElB;;;;;;GAMG;AACU,QAAA,UAAU;AAIrB,iCAAiC,CAAC,4CAAgB;IAClD,0CAAc;IACd,8CAAkB,CAAA;AAEpB,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,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAChC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,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,IAAI,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  toBase64Node ??\n  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  fromBase64Node ??\n  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\nexport function ifUint8Array(input: unknown): Uint8Array | undefined {\n  if (input instanceof Uint8Array) {\n    return input\n  }\n\n  return undefined\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 ?? ui8ConcatPonyfill\n"]}

package/dist/utf8.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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,MACiC,CAAA;AAU5E,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MACuB,CAAA;AAEjE,eAAO,MAAM,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,MACK,CAAA;AAE5E,eAAO,MAAM,cAAc,EAAE,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,MAC2E,CAAA"}

package/dist/utf8.js

@@ -6,20 +6,16 @@ const utf8_grapheme_len_js_1 = require("./utf8-grapheme-len.js");
 const utf8_len_js_1 = require("./utf8-len.js");
 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 */ utf8_grapheme_len_js_1.graphemeLenNative ?? 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 = 
-/* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenNode ??
-    /* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenCompute;
+/* v8 ignore next -- @preserve */ utf8_len_js_1.utf8LenNode ?? 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;
+/* v8 ignore next -- @preserve */ utf8_to_base64_js_1.utf8ToBase64Node ?? 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;
+/* v8 ignore next -- @preserve */ utf8_from_base64_js_1.utf8FromBase64Node ?? 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":";;;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"]}
+{"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,IAAI,0CAAmB,CAAA;AAE5E,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,IAAI,4BAAc,CAAA;AAEpD,QAAA,YAAY;AACvB,iCAAiC,CAAC,oCAAgB,IAAI,wCAAoB,CAAA;AAE/D,QAAA,cAAc;AAIzB,iCAAiC,CAAC,wCAAkB,IAAI,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 ?? 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 ?? utf8LenCompute\n\nexport const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =\n  /* v8 ignore next -- @preserve */ utf8ToBase64Node ?? utf8ToBase64Ponyfill\n\nexport const utf8FromBase64: (\n  b64: string,\n  alphabet?: Base64Alphabet,\n) => string =\n  /* v8 ignore next -- @preserve */ utf8FromBase64Node ?? utf8FromBase64Ponyfill\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-data",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "license": "MIT",
   "description": "Core utilities for AT Lexicons",
   "keywords": [
@@ -38,8 +38,7 @@
     "multiformats": "^9.9.0",
     "tslib": "^2.8.1",
     "uint8arrays": "3.0.0",
-    "unicode-segmenter": "^0.14.0",
-    "@atproto/syntax": "0.4.2"
+    "unicode-segmenter": "^0.14.0"
   },
   "devDependencies": {
     "core-js": "^3",

package/src/cid-implementation.test.ts

@@ -0,0 +1,137 @@
+/* eslint-disable import/no-deprecated */
+
+import { base32 } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
+import { create as createDigest } from 'multiformats/hashes/digest'
+import { assert, describe, expect, it } from 'vitest'
+import { Cid } from './cid.js'
+import { ui8Equals } from './uint8array.js'
+
+export class BytesCid implements Cid {
+  constructor(readonly bytes: Uint8Array) {
+    if (this.bytes.length < 4) {
+      throw new Error('CID bytes are too short')
+    }
+    if (this.bytes[0] > 1) {
+      throw new Error('Unsupported CID version')
+    }
+    if (this.bytes.length !== 4 + this.bytes[3]) {
+      throw new Error('CID bytes length mismatch')
+    }
+  }
+
+  get version() {
+    return this.bytes[0] as 0 | 1
+  }
+
+  get code() {
+    return this.bytes[1]
+  }
+
+  get multihash() {
+    const code = this.bytes[2]
+    const digest = this.bytes.subarray(4)
+    return { code, digest }
+  }
+
+  equals(other: Cid): boolean {
+    return ui8Equals(this.bytes, other.bytes)
+  }
+
+  toString(): string {
+    return base32.encode(this.bytes)
+  }
+}
+
+describe(BytesCid, () => {
+  it('creates a BytesCid from valid bytes', () => {
+    const bytes = new Uint8Array([1, 0x55, 0x12, 3, 1, 2, 3])
+    const cid = new BytesCid(bytes)
+
+    assert(cid.version === 1)
+    assert(cid.code === 0x55)
+    assert(cid.multihash.code === 0x12)
+    assert(ui8Equals(cid.multihash.digest, new Uint8Array([1, 2, 3])))
+    assert(ui8Equals(cid.bytes, bytes))
+    assert(typeof cid.toString === 'function')
+    assert(typeof cid.equals === 'function')
+  })
+
+  it('throws an error for invalid CID bytes', () => {
+    expect(
+      () => new BytesCid(new Uint8Array([2, 0x55, 0x12, 3, 1, 2, 3])),
+    ).toThrowError('Unsupported CID version')
+    expect(() => new BytesCid(new Uint8Array([1, 0x55, 0x12]))).toThrowError(
+      'CID bytes are too short',
+    )
+    expect(
+      () => new BytesCid(new Uint8Array([1, 0x55, 0x12, 4, 1, 2, 3])),
+    ).toThrowError('CID bytes length mismatch')
+  })
+})
+
+/**
+ * A minimal custom implementation of the `Cid` interface for testing purposes.
+ */
+export function createCustomCid<
+  TVersion extends 0 | 1,
+  TCode extends number,
+  TMultihashCode extends number,
+>(
+  version: TVersion,
+  code: TCode,
+  multihashCode: TMultihashCode,
+  digest: Uint8Array,
+): Cid<TVersion, TCode, TMultihashCode> {
+  return {
+    version,
+    code,
+    multihash: { code: multihashCode, digest },
+    bytes: new Uint8Array([
+      version,
+      code,
+      multihashCode,
+      digest.length,
+      ...digest,
+    ]),
+    toString,
+    equals,
+  }
+}
+
+function equals(this: Cid, other: Cid): boolean {
+  return (
+    this.version === other.version &&
+    this.code === other.code &&
+    this.multihash.code === other.multihash.code &&
+    ui8Equals(this.multihash.digest, other.multihash.digest)
+  )
+}
+
+function toString(this: Cid): string {
+  return CID.create(
+    this.version,
+    this.code,
+    createDigest(this.multihash.code, this.multihash.digest),
+  ).toString()
+}
+
+describe(createCustomCid, () => {
+  it('creates a CID with the specified properties', () => {
+    const digest = new Uint8Array([1, 2, 3, 4, 5])
+    const customCid = createCustomCid(1, 0x55, 0x12, digest)
+
+    assert(customCid.version === 1)
+    assert(customCid.code === 0x55)
+    assert(customCid.multihash.code === 0x12)
+    assert(ui8Equals(customCid.multihash.digest, digest))
+    assert(
+      ui8Equals(
+        customCid.bytes,
+        new Uint8Array([1, 0x55, 0x12, 5, 1, 2, 3, 4, 5]),
+      ),
+    )
+    assert(typeof customCid.toString === 'function')
+    assert(typeof customCid.equals === 'function')
+  })
+})

package/src/cid.test.ts

@@ -1,23 +1,51 @@
+/* eslint-disable import/no-deprecated */
+
 import { CID } from 'multiformats/cid'
 import { sha256, sha512 } from 'multiformats/hashes/sha2'
 import { describe, expect, it } from 'vitest'
+import { BytesCid, createCustomCid } from './cid-implementation.test.js'
 import {
+  Cid,
   DAG_CBOR_MULTICODEC,
   RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  asMultiformatsCID,
+  cidForRawHash,
   decodeCid,
   ensureValidCidString,
   isCid,
+  isCidForBytes,
   parseCid,
-  parseCidString,
+  parseCidSafe,
 } from './cid.js'
+import { ui8Equals } from './uint8array.js'
+
+const invalidCidStr = 'invalidcidstring'
+
+const cborCidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+const cborCid = parseCid(cborCidStr, { flavor: 'cbor' })
+
+const rawCidStr = 'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4'
+const rawCid = parseCid(rawCidStr, { flavor: 'raw' })
+
+const rawCidLike: Cid = createCustomCid(
+  1,
+  RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  rawCid.multihash.digest,
+)
+const rawBytesCid = new BytesCid(rawCid.bytes)
 
 describe(isCid, () => {
   describe('non-strict mode', () => {
     it('returns true for parsed CIDs', () => {
-      const cid = parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      )
-      expect(isCid(cid)).toBe(true)
+      expect(isCid(cborCid)).toBe(true)
+      expect(isCid(rawCid)).toBe(true)
+    })
+
+    it('returns true for custom compatible CID implementations', () => {
+      expect(isCid(rawCidLike)).toBe(true)
+      expect(isCid(rawBytesCid)).toBe(true)
     })
 
     it('returns true for CID v0 and v1', async () => {
@@ -88,56 +116,237 @@ describe(isCid, () => {
       })
     })
   })
+
+  describe('alternative cid implementations', () => {
+    it('accepts compatible CID implementations', () => {
+      expect(isCid(rawCidLike)).toBe(true)
+    })
+
+    it('rejects non-matching version', () => {
+      expect(isCid({ ...rawCidLike, version: 0 })).toBe(false)
+    })
+
+    it('rejects non-matching code', () => {
+      expect(isCid({ ...rawCidLike, code: -1 })).toBe(false)
+      expect(isCid({ ...rawCidLike, code: 0 })).toBe(false)
+      expect(isCid({ ...rawCidLike, code: 256 })).toBe(false)
+    })
+
+    it('rejects invalid bytes property', () => {
+      expect(isCid({ ...rawCidLike, bytes: undefined })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: 12 })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: {} })).toBe(false)
+      expect(isCid({ ...rawCidLike, bytes: [] })).toBe(false)
+
+      expect(
+        isCid({
+          ...rawCidLike,
+          bytes: rawCidLike.bytes.subarray(0, rawCidLike.bytes.length - 1),
+        }),
+      ).toBe(false)
+
+      const bytes = new Uint8Array(rawCidLike.bytes.length)
+
+      bytes.set(rawCidLike.bytes)
+      expect(isCid({ ...rawCidLike, bytes })).toBe(true)
+
+      bytes[0] = bytes[0] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
+
+      bytes[3] = bytes[3] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
+
+      bytes[6] = bytes[6] ^ 0xff
+      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
+      bytes.set(rawCidLike.bytes)
+    })
+
+    describe('multihash property', () => {
+      it('rejects non-matching object', () => {
+        expect(isCid({ ...rawCidLike, multihash: undefined })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: 12 })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: {} })).toBe(false)
+        expect(isCid({ ...rawCidLike, multihash: [] })).toBe(false)
+      })
+
+      it('rejects non-matching code', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: -1 },
+          }),
+        ).toBe(false)
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: 0 },
+          }),
+        ).toBe(false)
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, code: 256 },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non Uint8Array digest', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non Uint8Array digest', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
+          }),
+        ).toBe(false)
+      })
+
+      it('rejects non-matching digest', () => {
+        const differentDigest = new Uint8Array(32)
+        differentDigest[0] = 1
+        expect(
+          isCid({
+            ...rawCidLike,
+            multihash: { ...rawCidLike.multihash, digest: differentDigest },
+          }),
+        ).toBe(false)
+      })
+    })
+
+    describe('equals() method', () => {
+      it('rejects objects without equals method', () => {
+        expect(isCid({ ...rawCidLike, equals: undefined })).toBe(false)
+        expect(isCid({ ...rawCidLike, equals: () => false })).toBe(false)
+      })
+
+      it('rejects object with throwing equals method', () => {
+        expect(
+          isCid({
+            ...rawCidLike,
+            equals: () => {
+              throw new Error('fail')
+            },
+          }),
+        ).toBe(false)
+      })
+    })
+  })
 })
 
 describe(decodeCid, () => {
   it('decodes CID from bytes', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
+    const cid = parseCid(cborCidStr)
     const bytes = cid.bytes
     const decodedCid = decodeCid(bytes)
-    expect(decodedCid.toString()).toBe(cidStr)
+    expect(decodedCid.toString()).toBe(cborCidStr)
   })
 })
 
 describe(parseCid, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
-    expect(cid.toString()).toBe(cidStr)
+    expect(parseCid(cborCidStr).toString()).toBe(cborCidStr)
+    expect(parseCid(rawCidStr).toString()).toBe(rawCidStr)
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     expect(() => parseCid(invalidCidStr)).toThrow()
   })
 })
 
-describe(parseCidString, () => {
+describe(isCidForBytes, () => {
+  describe('raw', () => {
+    it('returns true for valid raw CID bytes', async () => {
+      for (const hasher of [sha256, sha512]) {
+        const data = new TextEncoder().encode('hello world')
+        const digest = await hasher.digest(data)
+        const cid = CID.createV1(RAW_MULTICODEC, digest)
+        expect(await isCidForBytes(cid, data)).toBe(true)
+
+        data[0] = data[0] ^ 0xff
+        expect(await isCidForBytes(cid, data)).toBe(false)
+      }
+    })
+  })
+
+  describe('cbor', () => {
+    it('returns true for valid cbor CID bytes', async () => {
+      for (const hasher of [sha256, sha512]) {
+        // @NOTE this is not valid CBOR, but sufficient for testing the hash
+        const data = new TextEncoder().encode('hello world')
+        const digest = await hasher.digest(data)
+        const cid = CID.createV1(DAG_CBOR_MULTICODEC, digest)
+        expect(await isCidForBytes(cid, data)).toBe(true)
+
+        data[0] = data[0] ^ 0xff
+        expect(await isCidForBytes(cid, data)).toBe(false)
+      }
+    })
+  })
+})
+
+describe(parseCidSafe, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCidString(cidStr)
-    expect(cid).toBeDefined()
-    expect(cid!.toString()).toBe(cidStr)
+    expect(parseCidSafe(cborCidStr)?.toString()).toBe(cborCidStr)
+    expect(parseCidSafe(rawCidStr)?.toString()).toBe(rawCidStr)
   })
 
   it('returns undefined for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
-    const cid = parseCidString(invalidCidStr)
-    expect(cid).toBeUndefined()
+    expect(parseCidSafe(invalidCidStr)).toBeNull()
   })
 })
 
 describe(ensureValidCidString, () => {
   it('does not throw for valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    expect(() => ensureValidCidString(cidStr)).not.toThrow()
+    expect(() => ensureValidCidString(cborCidStr)).not.toThrow()
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     expect(() => ensureValidCidString(invalidCidStr)).toThrow(
       'Invalid CID string',
     )
   })
 })
+
+describe(cidForRawHash, () => {
+  it('creates a RawCid from a SHA-256 hash', () => {
+    const hash = new Uint8Array(32)
+    const cid = cidForRawHash(hash)
+    expect(cid.code).toBe(RAW_MULTICODEC)
+    expect(cid.multihash.code).toBe(SHA256_MULTIHASH)
+    expect(ui8Equals(cid.multihash.digest, hash)).toBe(true)
+  })
+
+  it('rejects hashes on invalid lengths', () => {
+    expect(() => cidForRawHash(new Uint8Array(31))).toThrow(
+      'Invalid SHA-256 hash length',
+    )
+    expect(() => cidForRawHash(new Uint8Array(33))).toThrow(
+      'Invalid SHA-256 hash length',
+    )
+  })
+})
+
+describe(asMultiformatsCID, () => {
+  it('converts compatible CID to multiformats CID', () => {
+    for (const cid of [cborCid, rawCid, rawCidLike, rawBytesCid]) {
+      expect(asMultiformatsCID(cid)).toBeInstanceOf(CID)
+      expect(asMultiformatsCID(cid)).toMatchObject({
+        version: cid.version,
+        code: cid.code,
+        multihash: {
+          code: cid.multihash.code,
+          digest: cid.multihash.digest,
+        },
+      })
+    }
+  })
+})