@atproto/lex-data 0.0.0

package/dist/uint8array-from-base64.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64Node = exports.fromBase64Native = void 0;
+exports.fromBase64Ponyfill = fromBase64Ponyfill;
+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.fromBase64Native = typeof Uint8Array.fromBase64 === 'function'
+    ? function fromBase64Native(b64) {
+        return Uint8Array.fromBase64(b64, { lastChunkHandling: 'loose' });
+    }
+    : null;
+exports.fromBase64Node = Buffer
+    ? function fromBase64Node(b64) {
+        const bytes = Buffer.from(b64, 'base64');
+        verifyBase64ForBytes(b64, bytes);
+        // Convert to Uint8Array because even though Buffer is a sub class of
+        // Uint8Array, it serializes differently to Uint8Array (e.g. in JSON) and
+        // results in unexpected behavior downstream (e.g. in tests)
+        return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    : null;
+function fromBase64Ponyfill(b64) {
+    const bytes = (0, from_string_1.fromString)(b64, 'base64');
+    verifyBase64ForBytes(b64, bytes);
+    return bytes;
+}
+// @NOTE NodeJS will silently stop decoding at the first invalid character,
+// while "uint8arrays/from-string" will not validate that the padding is
+// correct. The following function performs basic validation to ensure that the
+// input was a valid base64 string. The availability of the "bytes" allows
+// to perform checks with O[1] complexity.
+function verifyBase64ForBytes(b64, bytes) {
+    const paddingCount = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0;
+    const trimmedLength = b64.length - paddingCount;
+    const expectedByteLength = Math.floor((trimmedLength * 3) / 4);
+    if (bytes.length !== expectedByteLength) {
+        throw new Error('Invalid base64 string');
+    }
+    const expectedB64Length = (bytes.length / 3) * 4;
+    const expectedPaddingCount = expectedB64Length % 4 === 0 ? 0 : 4 - (expectedB64Length % 4);
+    const expectedFullB64Length = expectedB64Length + expectedPaddingCount;
+    if (b64.length > expectedFullB64Length) {
+        throw new Error('Invalid base64 string');
+    }
+    // The previous might still allow false positive if only the last few
+    // chars are invalid.
+    for (let i = Math.ceil(expectedB64Length); i < b64.length - paddingCount; i++) {
+        const code = b64.charCodeAt(i);
+        if (!(code >= 65 && code <= 90) && // A-Z
+            !(code >= 97 && code <= 122) && // a-z
+            !(code >= 48 && code <= 57) && // 0-9
+            code !== 43 && // +
+            code !== 47 // /
+        ) {
+            throw new Error('Invalid base64 string');
+        }
+    }
+}
+//# sourceMappingURL=uint8array-from-base64.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array-from-base64.js","sourceRoot":"","sources":["../src/uint8array-from-base64.ts"],"names":[],"mappings":";;;AAuCA,gDAIC;AA3CD,yDAAoD;AACpD,6DAAqD;AAErD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAkBd,QAAA,gBAAgB,GAC3B,OAAO,UAAU,CAAC,UAAU,KAAK,UAAU;IACzC,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAW;QACnC,OAAO,UAAU,CAAC,UAAW,CAAC,GAAG,EAAE,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,CAAA;IACpE,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAEG,QAAA,cAAc,GAAG,MAAM;IAClC,CAAC,CAAC,SAAS,cAAc,CAAC,GAAW;QACjC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;QACxC,oBAAoB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAChC,qEAAqE;QACrE,yEAAyE;QACzE,4DAA4D;QAC5D,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;IACzE,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAER,SAAgB,kBAAkB,CAAC,GAAW;IAC5C,MAAM,KAAK,GAAG,IAAA,wBAAU,EAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;IACvC,oBAAoB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAChC,OAAO,KAAK,CAAA;AACd,CAAC;AAED,2EAA2E;AAC3E,wEAAwE;AACxE,+EAA+E;AAC/E,0EAA0E;AAC1E,0CAA0C;AAC1C,SAAS,oBAAoB,CAAC,GAAW,EAAE,KAAiB;IAC1D,MAAM,YAAY,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACvE,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,GAAG,YAAY,CAAA;IAC/C,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9D,IAAI,KAAK,CAAC,MAAM,KAAK,kBAAkB,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;IAC1C,CAAC;IAED,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;IAChD,MAAM,oBAAoB,GACxB,iBAAiB,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAA;IAC/D,MAAM,qBAAqB,GAAG,iBAAiB,GAAG,oBAAoB,CAAA;IACtE,IAAI,GAAG,CAAC,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;IAC1C,CAAC;IAED,qEAAqE;IACrE,qBAAqB;IACrB,KACE,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EACpC,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,YAAY,EAC7B,CAAC,EAAE,EACH,CAAC;QACD,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QAC9B,IACE,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,IAAI,MAAM;YACrC,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,GAAG,CAAC,IAAI,MAAM;YACtC,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,IAAI,MAAM;YACrC,IAAI,KAAK,EAAE,IAAI,IAAI;YACnB,IAAI,KAAK,EAAE,CAAC,IAAI;UAChB,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;QAC1C,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import { fromString } from 'uint8arrays/from-string'\nimport { NodeJSBuffer } from './lib/nodejs-buffer.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(b64: string): Uint8Array {\n        return Uint8Array.fromBase64!(b64, { lastChunkHandling: 'loose' })\n      }\n    : null\n\nexport const fromBase64Node = Buffer\n  ? function fromBase64Node(b64: string): Uint8Array {\n      const bytes = Buffer.from(b64, 'base64')\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(b64: string): Uint8Array {\n  const bytes = fromString(b64, 'base64')\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

@@ -0,0 +1,16 @@
+declare global {
+    interface Uint8Array {
+        /**
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64 Uint8Array.prototype.toBase64()}
+         */
+        toBase64?: (options?: {
+            /** @default 'base64' */
+            alphabet?: 'base64' | 'base64url';
+            omitPadding?: boolean;
+        }) => string;
+    }
+}
+export declare const toBase64Native: ((bytes: Uint8Array) => string) | null;
+export declare const toBase64Node: ((bytes: Uint8Array) => string) | null;
+export declare function toBase64Ponyfill(bytes: Uint8Array): string;
+//# sourceMappingURL=uint8array-to-base64.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array-to-base64.d.ts","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":"AAKA,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,WAEU,UAAU,KAAG,MAAM,QAG9C,CAAA;AAEV,eAAO,MAAM,YAAY,WACQ,UAAU,KAAG,MAAM,QAc5C,CAAA;AAER,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D"}

package/dist/uint8array-to-base64.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64Node = exports.toBase64Native = void 0;
+exports.toBase64Ponyfill = toBase64Ponyfill;
+const to_string_1 = require("uint8arrays/to-string");
+const nodejs_buffer_js_1 = require("./lib/nodejs-buffer.js");
+const Buffer = nodejs_buffer_js_1.NodeJSBuffer;
+exports.toBase64Native = typeof Uint8Array.prototype.toBase64 === 'function'
+    ? function toBase64Native(bytes) {
+        return bytes.toBase64({ omitPadding: true });
+    }
+    : null;
+exports.toBase64Node = Buffer
+    ? function toBase64Node(bytes) {
+        const b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes)).toString('base64');
+        // @NOTE We strip padding for strict compatibility with
+        // uint8arrays.toString behavior. Tests failing because of the presence of
+        // padding are not really synonymous with an actual error and we might
+        // (should?) actually want to keep the padding at some point.
+        return b64.charCodeAt(b64.length - 1) === /* '=' */ 0x3d
+            ? b64.charCodeAt(b64.length - 2) === /* '=' */ 0x3d
+                ? b64.slice(0, -2) // '=='
+                : b64.slice(0, -1) // '='
+            : b64;
+    }
+    : null;
+function toBase64Ponyfill(bytes) {
+    return (0, to_string_1.toString)(bytes, 'base64');
+}
+//# sourceMappingURL=uint8array-to-base64.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array-to-base64.js","sourceRoot":"","sources":["../src/uint8array-to-base64.ts"],"names":[],"mappings":";;;AA0CA,4CAEC;AA5CD,qDAAgD;AAChD,6DAAqD;AAErD,MAAM,MAAM,GAAG,+BAAY,CAAA;AAed,QAAA,cAAc,GACzB,OAAO,UAAU,CAAC,SAAS,CAAC,QAAQ,KAAK,UAAU;IACjD,CAAC,CAAC,SAAS,cAAc,CAAC,KAAiB;QACvC,OAAO,KAAK,CAAC,QAAS,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/C,CAAC;IACH,CAAC,CAAC,IAAI,CAAA;AAEG,QAAA,YAAY,GAAG,MAAM;IAChC,CAAC,CAAC,SAAS,YAAY,CAAC,KAAiB;QACrC,MAAM,GAAG,GAAG,CACV,KAAK,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CACrD,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;QACpB,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,CAAC,KAAiB;IAChD,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'\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(bytes: Uint8Array): string {\n        return bytes.toBase64!({ omitPadding: true })\n      }\n    : null\n\nexport const toBase64Node = Buffer\n  ? function toBase64Node(bytes: Uint8Array): string {\n      const b64 = (\n        bytes instanceof Buffer ? bytes : Buffer.from(bytes)\n      ).toString('base64')\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(bytes: Uint8Array): string {\n  return toString(bytes, 'base64')\n}\n"]}

package/dist/uint8array.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Encodes a Uint8Array into a base64 string.
+ *
+ * @returns The base64 encoded string
+ */
+export declare const toBase64: (bytes: Uint8Array) => string;
+/**
+ * Decodes a base64 string into a Uint8Array.
+ *
+ * @returns The decoded {@link Uint8Array}
+ * @throws If the input is not a valid base64 string
+ */
+export declare const fromBase64: (b64: string) => Uint8Array;
+/**
+ * Coerces various binary data representations into a Uint8Array.
+ *
+ * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.
+ */
+export declare function asUint8Array(input: unknown): Uint8Array | undefined;
+export declare function ui8Equals(a: Uint8Array, b: Uint8Array): boolean;
+//# sourceMappingURL=uint8array.d.ts.map

package/dist/uint8array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,MACM,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,UACgB,CAAA;AAS1D;;;;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"}

package/dist/uint8array.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = exports.toBase64 = void 0;
+exports.asUint8Array = asUint8Array;
+exports.ui8Equals = ui8Equals;
+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 /
+// Uint8Array.prototype.toBase64 is widely supported, and mark fromBase64 /
+// toBase64 as deprecated. We can also drop NodeJS specific implementations
+// once NodeJS <24 is no longer supported.
+/**
+ * Encodes a Uint8Array into a base64 string.
+ *
+ * @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;
+/**
+ * Decodes a base64 string into a Uint8Array.
+ *
+ * @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;
+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.');
+}
+/**
+ * Coerces various binary data representations into a Uint8Array.
+ *
+ * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.
+ */
+function asUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    if (input instanceof ArrayBuffer) {
+        return new Uint8Array(input);
+    }
+    return undefined;
+}
+function ui8Equals(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=uint8array.js.map

package/dist/uint8array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8array.js","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":";;;AA6CA,oCAkBC;AAED,8BAYC;AA7ED,2EAIoC;AACpC,uEAIkC;AAElC,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,0CAA0C;AAE1C;;;;GAIG;AACU,QAAA,QAAQ,GACnB,wCAAc,IAAI,sCAAY,IAAI,0CAAgB,CAAA;AAEpD;;;;;GAKG;AACU,QAAA,UAAU,GACrB,4CAAgB,IAAI,0CAAc,IAAI,8CAAkB,CAAA;AAE1D,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 {\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\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: (bytes: Uint8Array) => string =\n  toBase64Native ?? toBase64Node ?? toBase64Ponyfill\n\n/**\n * Decodes a base64 string into a Uint8Array.\n *\n * @returns The decoded {@link Uint8Array}\n * @throws If the input is not a valid base64 string\n */\nexport const fromBase64: (b64: string) => Uint8Array =\n  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"]}

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

@@ -0,0 +1,3 @@
+export declare const graphemeLenNative: ((str: string) => number) | null;
+export declare function graphemeLenPonyfill(str: string): number;
+//# sourceMappingURL=utf8-grapheme-len.d.ts.map

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

@@ -0,0 +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"}

package/dist/utf8-grapheme-len.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphemeLenNative = void 0;
+exports.graphemeLenPonyfill = graphemeLenPonyfill;
+const grapheme_1 = require("unicode-segmenter/grapheme");
+// @TODO: Drop usage of "unicode-segmenter" package when Intl.Segmenter is
+// widely supported.
+// 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;
+exports.graphemeLenNative = segmenter
+    ? function graphemeLenNative(str) {
+        let length = 0;
+        for (const _ of segmenter.segment(str))
+            length++;
+        return length;
+    }
+    : null;
+function graphemeLenPonyfill(str) {
+    return (0, grapheme_1.countGraphemes)(str);
+}
+//# sourceMappingURL=utf8-grapheme-len.js.map

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

@@ -0,0 +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"]}

package/dist/utf8-len.d.ts

@@ -0,0 +1,3 @@
+export declare const utf8LenNode: ((string: string) => number) | null;
+export declare function utf8LenCompute(string: string): number;
+//# sourceMappingURL=utf8-len.d.ts.map

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

@@ -0,0 +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"}

package/dist/utf8-len.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8LenNode = void 0;
+exports.utf8LenCompute = utf8LenCompute;
+const nodejs_buffer_js_1 = require("./lib/nodejs-buffer.js");
+// @NOTE This file is not meant to be exported directly. Instead, we re-export
+// public functions from ./utf8.ts. The reason for this separation is that this
+// file allows to test both the NodeJS-optimized and ponyfill implementations.
+exports.utf8LenNode = nodejs_buffer_js_1.NodeJSBuffer
+    ? function utf8LenNode(string) {
+        return nodejs_buffer_js_1.NodeJSBuffer.byteLength(string, 'utf8');
+    }
+    : 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
+    // as it requires allocating a new Uint8Array and copying data:
+    // return new TextEncoder().encode(string).byteLength
+    // The base length is the string length (all ASCII)
+    let len = string.length;
+    let code;
+    // The loop calculates the number of additional bytes needed for
+    // non-ASCII characters
+    for (let i = 0; i < string.length; i += 1) {
+        code = string.charCodeAt(i);
+        if (code <= 0x7f) {
+            // ASCII, 1 byte
+        }
+        else if (code <= 0x7ff) {
+            // 2 bytes char
+            len += 1;
+        }
+        else {
+            // 3 bytes char
+            len += 2;
+            // If the current char is a high surrogate, and the next char is a low
+            // surrogate, skip the next char as the total is a 4 bytes char
+            // (represented as a surrogate pair in UTF-16) and was already accounted
+            // for.
+            if (code >= 0xd800 && code <= 0xdbff) {
+                code = string.charCodeAt(i + 1);
+                if (code >= 0xdc00 && code <= 0xdfff) {
+                    i++;
+                }
+            }
+        }
+    }
+    return len;
+}
+//# sourceMappingURL=utf8-len.js.map

package/dist/utf8-len.js.map

@@ -0,0 +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"]}

package/dist/utf8.d.ts

@@ -0,0 +1,3 @@
+export declare const graphemeLen: (str: string) => number;
+export declare const utf8Len: (string: string) => number;
+//# sourceMappingURL=utf8.d.ts.map

package/dist/utf8.d.ts.map

@@ -0,0 +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"}

package/dist/utf8.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8Len = exports.graphemeLen = void 0;
+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;
+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;
+//# sourceMappingURL=utf8.js.map

package/dist/utf8.js.map

@@ -0,0 +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"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@atproto/lex-data",
+  "version": "0.0.0",
+  "license": "MIT",
+  "description": "Core utilities for AT Lexicons",
+  "keywords": [
+    "atproto",
+    "lexicon",
+    "utilities"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/lex/lex-data"
+  },
+  "files": [
+    "./src",
+    "./tsconfig.build.json",
+    "./tsconfig.tests.json",
+    "./tsconfig.json",
+    "./dist"
+  ],
+  "sideEffects": false,
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/index.js",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@atproto/syntax": "workspace:*",
+    "multiformats": "^9.9.0",
+    "tslib": "^2.8.1",
+    "uint8arrays": "3.0.0",
+    "unicode-segmenter": "^0.14.0"
+  },
+  "devDependencies": {
+    "core-js": "^3",
+    "jest": "^28.1.2"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "test": "jest"
+  }
+}

package/src/blob.test.ts

@@ -0,0 +1,186 @@
+import { isBlobRef, isLegacyBlobRef } from './blob.js'
+import { CID } from './cid.js'
+
+// await cidForRawBytes(Buffer.from('Hello, World!'))
+const blobCid = CID.parse(
+  'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+)
+// await cidForLex(Buffer.from('Hello, World!'))
+const lexCid = CID.parse(
+  'bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy',
+)
+
+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
+  })
+
+  it('parses valid blob', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(true)
+
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          ref: lexCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        // In non-strict mode, any CID should be accepted
+        { strict: false },
+      ),
+    ).toBe(true)
+  })
+
+  it('rejects invalid inputs', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: { $link: blobCid.toString() },
+        mimeType: 'image/jpeg',
+        size: '10000',
+      }),
+    ).toBe(false)
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          ref: { $link: blobCid.toString() },
+          mimeType: 'image/jpeg',
+          size: '10000',
+        },
+        { strict: true },
+      ),
+    ).toBe(false)
+
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(false)
+
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: true },
+      ),
+    ).toBe(false)
+  })
+
+  it('rejects invalid CID/multihash code', () => {
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: true },
+      ),
+    ).toBe(true)
+
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          ref: lexCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+        },
+        { strict: true },
+      ),
+    ).toBe(false)
+  })
+
+  it('rejects extra keys', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: blobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+        extra: 'not allowed',
+      }),
+    ).toBe(false)
+
+    expect(
+      isBlobRef(
+        {
+          $type: 'blob',
+          ref: blobCid,
+          mimeType: 'image/jpeg',
+          size: 10000,
+          extra: 'not allowed',
+        },
+        { strict: true },
+      ),
+    ).toBe(false)
+  })
+})
+
+describe('isLegacyBlobRef', () => {
+  it('parses valid legacy blob', () => {
+    expect(
+      isLegacyBlobRef({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+      }),
+    ).toBe(true)
+
+    expect(
+      isLegacyBlobRef({
+        cid: lexCid.toString(),
+        mimeType: 'image/jpeg',
+      }),
+    ).toBe(true)
+  })
+
+  it('rejects invalid inputs', () => {
+    expect(
+      isLegacyBlobRef({
+        cid: 'babbaaa',
+        mimeType: 'image/jpeg',
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: 12345,
+        mimeType: 'image/jpeg',
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        mimeType: 'image/jpeg',
+      }),
+    ).toBe(false)
+  })
+
+  it('rejects extra keys', () => {
+    expect(
+      isLegacyBlobRef({
+        cid: blobCid.toString(),
+        mimeType: 'image/jpeg',
+        extra: 'not allowed',
+      }),
+    ).toBe(false)
+  })
+})