@atproto/lex-data 0.0.4 → 0.0.6

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/dist/utf8-to-base64.d.ts

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

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

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

package/dist/utf8-to-base64.js

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

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

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

package/dist/utf8.d.ts

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

package/dist/utf8.d.ts.map

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

package/dist/utf8.js

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

package/dist/utf8.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-data",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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,28 +1,36 @@
-import { isBlobRef, isLegacyBlobRef } from './blob.js'
+import { describe, expect, it } from 'vitest'
+import {
+  BlobRef,
+  LegacyBlobRef,
+  enumBlobRefs,
+  isBlobRef,
+  isLegacyBlobRef,
+} from './blob.js'
 import { parseCid } from './cid.js'
+import { LexArray, LexMap, LexValue } from './lex.js'
 
 // await cidForRawBytes(Buffer.from('Hello, World!'))
-const blobCid = parseCid(
+const validBlobCid = parseCid(
   'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
 )
 // await cidForLex(Buffer.from('Hello, World!'))
-const lexCid = parseCid(
+const invalidBlobCid = 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
-    expect(lexCid.code).toBe(0x71) // dag-cbor
-    expect(lexCid.multihash.code).toBe(0x12) // sha2-256
+    expect(validBlobCid.code).toBe(0x55) // raw
+    expect(validBlobCid.multihash.code).toBe(0x12) // sha2-256
+    expect(invalidBlobCid.code).toBe(0x71) // dag-cbor
+    expect(invalidBlobCid.multihash.code).toBe(0x12) // sha2-256
   })
 
   it('parses valid blob', () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000,
       }),
@@ -32,7 +40,7 @@ describe('isBlobRef', () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: lexCid,
+          ref: invalidBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -42,20 +50,50 @@ describe('isBlobRef', () => {
     ).toBe(true)
   })
 
+  it('performs strict validation by default', () => {
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: invalidBlobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(false)
+  })
+
   it('rejects invalid inputs', () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: { $link: blobCid.toString() },
+        ref: { $link: validBlobCid.toString() },
         mimeType: 'image/jpeg',
         size: '10000',
       }),
     ).toBe(false)
+
+    expect(
+      isBlobRef({
+        // $type: 'blob',
+        ref: validBlobCid,
+        mimeType: 'image/jpeg',
+        size: 10000,
+      }),
+    ).toBe(false)
+
+    expect(
+      isBlobRef({
+        $type: 'blob',
+        ref: validBlobCid,
+        mimeType: { toString: () => 'image/jpeg' },
+        size: 10000,
+      }),
+    ).toBe(false)
+
     expect(
       isBlobRef(
         {
           $type: 'blob',
-          ref: { $link: blobCid.toString() },
+          ref: { $link: validBlobCid.toString() },
           mimeType: 'image/jpeg',
           size: '10000',
         },
@@ -81,6 +119,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: validBlobCid,
+        mimeType: 'image/jpeg',
+        size: 10000.5,
+      }),
+    ).toBe(false)
   })
 
   it('rejects invalid CID/multihash code', () => {
@@ -88,7 +142,7 @@ describe('isBlobRef', () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: blobCid,
+          ref: validBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -100,7 +154,7 @@ describe('isBlobRef', () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: lexCid,
+          ref: invalidBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
         },
@@ -113,7 +167,7 @@ describe('isBlobRef', () => {
     expect(
       isBlobRef({
         $type: 'blob',
-        ref: blobCid,
+        ref: validBlobCid,
         mimeType: 'image/jpeg',
         size: 10000,
         extra: 'not allowed',
@@ -124,7 +178,7 @@ describe('isBlobRef', () => {
       isBlobRef(
         {
           $type: 'blob',
-          ref: blobCid,
+          ref: validBlobCid,
           mimeType: 'image/jpeg',
           size: 10000,
           extra: 'not allowed',
@@ -133,20 +187,39 @@ 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({
-        cid: blobCid.toString(),
+        cid: validBlobCid.toString(),
         mimeType: 'image/jpeg',
       }),
     ).toBe(true)
 
     expect(
       isLegacyBlobRef({
-        cid: lexCid.toString(),
+        cid: invalidBlobCid.toString(),
         mimeType: 'image/jpeg',
       }),
     ).toBe(true)
@@ -172,15 +245,145 @@ describe('isLegacyBlobRef', () => {
         mimeType: 'image/jpeg',
       }),
     ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: invalidBlobCid.toString(),
+        mimeType: { toString: () => 'image/jpeg' },
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: invalidBlobCid.toString(),
+        mimeType: 3,
+      }),
+    ).toBe(false)
+
+    expect(
+      isLegacyBlobRef({
+        cid: invalidBlobCid.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', () => {
     expect(
       isLegacyBlobRef({
-        cid: blobCid.toString(),
+        cid: validBlobCid.toString(),
         mimeType: 'image/jpeg',
         extra: 'not allowed',
       }),
     ).toBe(false)
   })
 })
+
+describe(enumBlobRefs, () => {
+  const valid1: BlobRef = {
+    $type: 'blob',
+    ref: validBlobCid,
+    mimeType: 'image/png',
+    size: 2048,
+  }
+
+  const valid2: BlobRef = {
+    $type: 'blob',
+    ref: validBlobCid,
+    mimeType: 'image/jpeg',
+    size: 1024,
+  }
+
+  const invalid: BlobRef = {
+    $type: 'blob',
+    ref: invalidBlobCid,
+    mimeType: 'image/jpeg',
+    size: 1024,
+  }
+
+  const legacy: LegacyBlobRef = {
+    cid: validBlobCid.toString(),
+    mimeType: 'image/gif',
+  }
+
+  const data: LexValue = {
+    name: 'example',
+    file: { deeply: { nested: { in: { object: { valid1 } } } } },
+    attachments: [valid2, invalid, legacy, { description: 'not a blob' }],
+  }
+
+  it('enumerates valid BlobRefs by default', () => {
+    const refs = Array.from(enumBlobRefs(data))
+    expect(refs).toHaveLength(2)
+    expect(refs.includes(valid1)).toBe(true)
+    expect(refs.includes(valid2)).toBe(true)
+  })
+
+  describe('strict support', () => {
+    it('enumerates valid BlobRefs in strict mode', () => {
+      const refs = Array.from(enumBlobRefs(data, { strict: true }))
+      expect(refs).toHaveLength(2)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+    })
+
+    it('enumerates all BlobRefs in non-strict mode', () => {
+      const refs = Array.from(enumBlobRefs(data, { strict: false }))
+      expect(refs).toHaveLength(3)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+      expect(refs.includes(invalid)).toBe(true)
+    })
+  })
+
+  describe('legacy support', () => {
+    it('returns LegacyBlobRefs when legacy option is enabled', () => {
+      const refs = Array.from(enumBlobRefs(data, { allowLegacy: true }))
+      expect(refs).toHaveLength(3)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+      expect(refs.includes(legacy)).toBe(true)
+    })
+  })
+
+  describe('safety', () => {
+    it('handles cyclic structures without infinite loops', () => {
+      const cyclicArray: LexArray = [valid2]
+      const cyclicObject: LexMap = {
+        name: 'cyclic',
+        blob: valid1,
+      }
+
+      // Creating a cycle
+      cyclicArray.push(cyclicArray)
+      cyclicObject.self = cyclicObject
+
+      const refs = Array.from(
+        enumBlobRefs({
+          cyclicObject,
+          cyclicArray,
+        }),
+      )
+      expect(refs).toHaveLength(2)
+      expect(refs.includes(valid1)).toBe(true)
+      expect(refs.includes(valid2)).toBe(true)
+    })
+
+    it('handles deep structures without exceeding call stack', () => {
+      // Creating a deep nested structure
+      let deepData: LexMap = { blob: valid1 }
+      for (let i = 0; i < 100_000; i++) {
+        deepData = { nested: deepData }
+      }
+
+      const refs = Array.from(enumBlobRefs(deepData))
+      expect(refs).toHaveLength(1)
+      expect(refs[0]).toBe(valid1)
+    })
+  })
+})

package/src/blob.ts

@@ -5,7 +5,8 @@ import {
   asCid,
   parseCid,
 } from './cid.js'
-import { isPlainObject } from './object.js'
+import { LexValue } from './lex.js'
+import { isPlainObject, isPlainProto } from './object.js'
 
 /**
  * @note {@link BlobRef} is just a {@link LexMap} with a specific shape.
@@ -17,9 +18,20 @@ export type BlobRef = {
   size: number
 }
 
+export type BlobRefValidationOptions = {
+  /**
+   * If `false`, skips strict CID validation of {@link BlobRef.ref}, allowing
+   * any valid CID. Otherwise, validates that the CID is v1, uses the raw
+   * multicodec, and has a sha256 multihash.
+   *
+   * @defaults to `true`
+   */
+  strict?: boolean
+}
+
 export function isBlobRef(
   input: unknown,
-  options?: { strict?: boolean },
+  options?: BlobRefValidationOptions,
 ): input is BlobRef {
   if (!isPlainObject(input)) {
     return false
@@ -35,12 +47,7 @@ export function isBlobRef(
     return false
   }
 
-  if (
-    typeof size !== 'number' ||
-    size < 0 ||
-    !Number.isInteger(size) ||
-    !Number.isSafeInteger(size)
-  ) {
+  if (typeof size !== 'number' || size < 0 || !Number.isSafeInteger(size)) {
     return false
   }
 
@@ -64,7 +71,7 @@ export function isBlobRef(
     return false
   }
 
-  if (options?.strict) {
+  if (options?.strict !== false) {
     if (cid.version !== 1) {
       return false
     }
@@ -97,7 +104,7 @@ export function isLegacyBlobRef(input: unknown): input is LegacyBlobRef {
     return false
   }
 
-  if (typeof mimeType !== 'string') {
+  if (typeof mimeType !== 'string' || mimeType.length === 0) {
     return false
   }
 
@@ -115,3 +122,68 @@ export function isLegacyBlobRef(input: unknown): input is LegacyBlobRef {
 
   return true
 }
+
+export type EnumBlobRefsOptions = BlobRefValidationOptions & {
+  /**
+   * @defaults to `false`
+   */
+  allowLegacy?: boolean
+}
+
+/**
+ * Enumerates all {@link BlobRef}s (and, optionally, {@link LegacyBlobRef}s)
+ * found within a {@link LexValue}.
+ */
+export function enumBlobRefs(
+  input: LexValue,
+  options: EnumBlobRefsOptions & { allowLegacy: true },
+): Generator<BlobRef | LegacyBlobRef, void, unknown>
+export function enumBlobRefs(
+  input: LexValue,
+  options?: EnumBlobRefsOptions & { allowLegacy?: false },
+): Generator<BlobRef, void, unknown>
+export function enumBlobRefs(
+  input: LexValue,
+  options?: EnumBlobRefsOptions,
+): Generator<BlobRef | LegacyBlobRef, void, unknown>
+export function* enumBlobRefs(
+  input: LexValue,
+  options?: EnumBlobRefsOptions,
+): Generator<BlobRef | LegacyBlobRef, void, unknown> {
+  const includeLegacy = options?.allowLegacy === true
+
+  // Using a stack to avoid recursion depth issues.
+  const stack: LexValue[] = [input]
+
+  // Since we are using a stack, we could end-up in an infinite loop with cyclic
+  // structures. Cyclic structures are not valid LexValues and should, thus,
+  // never occur, but let's be safe.
+  const visited = new Set<object>()
+
+  do {
+    const value = stack.pop()!
+
+    if (value != null && typeof value === 'object') {
+      if (Array.isArray(value)) {
+        if (visited.has(value)) continue
+        visited.add(value)
+        stack.push(...value)
+      } else if (isPlainProto(value)) {
+        if (visited.has(value)) continue
+        visited.add(value)
+        if (isBlobRef(value, options)) {
+          yield value
+        } else if (includeLegacy && isLegacyBlobRef(value)) {
+          yield value
+        } else {
+          for (const v of Object.values(value)) {
+            if (v != null) stack.push(v)
+          }
+        }
+      }
+    }
+  } while (stack.length > 0)
+
+  // Optimization: ease GC's work
+  visited.clear()
+}