@atproto/lex-data 0.0.15 → 0.1.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atproto/lex-data
 
+## 0.1.0-next.0
+
+### Minor Changes
+
+- [#4929](https://github.com/bluesky-social/atproto/pull/4929) [`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Drop support for Node.js 18 and 20. Node.js 22 is now the minimum supported version. Docker images now use Node.js 24.
+
+- [#4943](https://github.com/bluesky-social/atproto/pull/4943) [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Convert to pure ESM. All packages now ship `"type": "module"` with ES module output and Node16 module resolution.
+
+  Node.js 22's `require()` compatibility layer can still load these packages in CommonJS code.
+
+- [#4930](https://github.com/bluesky-social/atproto/pull/4930) [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9) Thanks [@devinivy](https://github.com/devinivy)! - Build with TypeScript 6.0. Emitted `.d.ts` files now use TypeScript 6's stricter `Uint8Array<ArrayBuffer>` typing in places where Web/Node APIs require buffer-backed (not shared-memory) byte arrays. Consumers compiling against these types on older TypeScript should see no runtime impact, but may need to widen or cast in spots that previously relied on `Uint8Array` defaulting to `<ArrayBufferLike>`.
+
+  Internal: tsconfig `moduleResolution: "node"` is silenced via `ignoreDeprecations: "6.0"` for now; the proper migration to `node16`/`bundler` resolution is deferred.
+
 ## 0.0.15
 
 ### Patch Changes

package/dist/blob.js

@@ -1,15 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBlobRef = isBlobRef;
-exports.getBlobMime = getBlobMime;
-exports.getBlobSize = getBlobSize;
-exports.getBlobCid = getBlobCid;
-exports.getBlobCidString = getBlobCidString;
-exports.isTypedBlobRef = isTypedBlobRef;
-exports.isLegacyBlobRef = isLegacyBlobRef;
-exports.enumBlobRefs = enumBlobRefs;
-const cid_js_1 = require("./cid.js");
-const object_js_1 = require("./object.js");
+import { ifCid, parseCid, validateCidString, } from './cid.js';
+import { isPlainObject, isPlainProto } from './object.js';
 /**
  * Options to use with {@link ifCid}, {@link validateCidString}, and related CID
  * validation functions when validating CIDs in BlobRefs, in strict mode. This
@@ -21,12 +11,12 @@ const STRICT_CID_CHECK_OPTIONS = { flavor: 'raw' };
 // Number.isSafeInteger is actually safe to use with non-number values, so we
 // can use it as a type guard.
 const isSafeInteger = Number.isSafeInteger;
-function isBlobRef(input, options) {
+export function isBlobRef(input, options) {
     return input?.$type === 'blob'
         ? isTypedBlobRef(input, options)
         : isLegacyBlobRef(input, options);
 }
-function getBlobMime(blob) {
+export function getBlobMime(blob) {
     return blob?.mimeType;
 }
 /**
@@ -51,24 +41,24 @@ function getBlobMime(blob) {
  * }
  * ```
  */
-function getBlobSize(blob) {
+export function getBlobSize(blob) {
     if ('$type' in blob && blob.size >= 0)
         return blob.size;
     // LegacyBlobRef doesn't have size information
     return undefined;
 }
-function getBlobCid(blob) {
+export function getBlobCid(blob) {
     if (!blob)
         return undefined;
-    return '$type' in blob ? blob.ref : (0, cid_js_1.parseCid)(blob.cid);
+    return '$type' in blob ? blob.ref : parseCid(blob.cid);
 }
-function getBlobCidString(blob) {
+export function getBlobCidString(blob) {
     if (!blob)
         return undefined;
     return '$type' in blob ? blob.ref.toString() : blob.cid;
 }
-function isTypedBlobRef(input, options) {
-    if (!(0, object_js_1.isPlainObject)(input)) {
+export function isTypedBlobRef(input, options) {
+    if (!isPlainObject(input)) {
         return false;
     }
     if (input?.$type !== 'blob') {
@@ -97,7 +87,7 @@ function isTypedBlobRef(input, options) {
             return false;
         }
     }
-    const cid = (0, cid_js_1.ifCid)(ref, 
+    const cid = ifCid(ref, 
     // Strict unless explicitly disabled
     options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS);
     if (!cid) {
@@ -125,8 +115,8 @@ function isTypedBlobRef(input, options) {
  *
  * @see {@link isTypedBlobRef} for checking the current blob reference format
  */
-function isLegacyBlobRef(input, options) {
-    if (!(0, object_js_1.isPlainObject)(input)) {
+export function isLegacyBlobRef(input, options) {
+    if (!isPlainObject(input)) {
         return false;
     }
     const { cid, mimeType } = input;
@@ -141,12 +131,12 @@ function isLegacyBlobRef(input, options) {
             return false;
         }
     }
-    if (!(0, cid_js_1.validateCidString)(cid, options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS)) {
+    if (!validateCidString(cid, options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS)) {
         return false;
     }
     return true;
 }
-function* enumBlobRefs(input, options) {
+export function* enumBlobRefs(input, options) {
     // LegacyBlobRef not included by default
     const includeLegacy = options?.allowLegacy === true;
     // Using a stack to avoid recursion depth issues.
@@ -164,7 +154,7 @@ function* enumBlobRefs(input, options) {
                 visited.add(value);
                 stack.push(...value);
             }
-            else if ((0, object_js_1.isPlainProto)(value)) {
+            else if (isPlainProto(value)) {
                 if (visited.has(value))
                     continue;
                 visited.add(value);

package/dist/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CheckCidOptions,\n  Cid,\n  RawCid,\n  ifCid,\n  parseCid,\n  validateCidString,\n} from './cid.js'\nimport { LexValue } from './lex.js'\nimport { isPlainObject, isPlainProto } from './object.js'\n\n/**\n * Options to use with {@link ifCid}, {@link validateCidString}, and related CID\n * validation functions when validating CIDs in BlobRefs, in strict mode. This\n * ensures that the CID is a {@link RawCid} (CID v1, raw multicodec, sha256\n * multihash), which is the expected format for blob references in the AT\n * Protocol data model.\n */\nconst STRICT_CID_CHECK_OPTIONS: CheckCidOptions = { flavor: 'raw' }\n\n// Number.isSafeInteger is actually safe to use with non-number values, so we\n// can use it as a type guard.\nconst isSafeInteger = Number.isSafeInteger as (v: unknown) => v is number\n\n/**\n * Reference to binary data (like images, videos, etc.) in the AT Protocol data\n * model.\n *\n * This type represents a reference to a blob of binary data, identified by its\n * content hash (CID) and accompanied by metadata such as MIME type and size.\n *\n * The {@link BlobRef} type is a union of the current {@link TypedBlobRef}\n * format and the legacy {@link LegacyBlobRef} format.\n */\nexport type BlobRef<Ref extends Cid = Cid> = TypedBlobRef<Ref> | LegacyBlobRef\n\n/**\n * Options for validating a {@link BlobRef}.\n */\nexport type BlobRefCheckOptions = {\n  /**\n   * If `false`, skips strict CID validation of {@link BlobRef.ref}, allowing\n   * any valid CID. Otherwise, validates that the CID is v1, uses the raw\n   * multicodec, and has a sha256 multihash.\n   *\n   * @default true\n   */\n  strict?: boolean\n}\n\n/**\n * Type guard to check if a value is a valid {@link BlobRef}, which can be\n * either a {@link TypedBlobRef} or a {@link LegacyBlobRef}. By default, strict\n * CID validation is applied to ensure that the CID in the blob reference is in\n * the expected format for the AT Protocol, but this can be relaxed with the\n * `strict: false` option.\n */\nexport function isBlobRef(input: unknown): input is BlobRef<RawCid>\nexport function isBlobRef<TOptions extends BlobRefCheckOptions>(\n  input: unknown,\n  options: TOptions,\n): input is LegacyBlobRef | InferTypedBlobRef<TOptions>\nexport function isBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is BlobRef<RawCid>\nexport function isBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is BlobRef {\n  return (input as any)?.$type === 'blob'\n    ? isTypedBlobRef(input, options)\n    : isLegacyBlobRef(input, options)\n}\n\n/**\n * Extracts the MIME type from a {@link BlobRef}.\n *\n * @example\n * ```ts\n * const mimeType = getBlobMime(blobRef)\n * console.log(mimeType)  // e.g., 'image/jpeg'\n * ```\n */\nexport function getBlobMime(blob: BlobRef): string\nexport function getBlobMime(blob?: BlobRef): string | undefined\nexport function getBlobMime(blob?: BlobRef): string | undefined {\n  return blob?.mimeType\n}\n\n/**\n * Extracts the size (in bytes) from a {@link TypedBlobRef}. For\n * {@link LegacyBlobRef}, size information is not available, so this function\n * returns `undefined` for legacy refs.\n *\n * @note The size property, in blob refs, cannot be 100% trusted since the PDS\n * might not have a local copy of the blob (to check the size against) and might\n * just be passing through the blob ref from the client without validating it.\n * So, while this function can be useful for getting size information when\n * available, it should not be solely relied upon for critical functionality\n * without additional validation.\n *\n * @example\n * ```ts\n * const size = getBlobSize(blobRef)\n * if (size !== undefined) {\n *   console.log(`Blob size: ${size} bytes`)\n * } else {\n *   console.log('Size information not available for legacy blob ref')\n * }\n * ```\n */\nexport function getBlobSize(blob: BlobRef): number | undefined {\n  if ('$type' in blob && blob.size >= 0) return blob.size\n  // LegacyBlobRef doesn't have size information\n  return undefined\n}\n\n/**\n * Extracts the {@link Cid} from a {@link BlobRef}.\n *\n * @throws If the input input is a {@link LegacyBlobRef} with an invalid CID string\n * @example\n * ```ts\n * const cid = getBlobCid(blobRef)\n * console.log(cid.bytes)\n * ```\n */\nexport function getBlobCid(blob: BlobRef): Cid\nexport function getBlobCid(blob?: BlobRef): Cid | undefined\nexport function getBlobCid(blob?: BlobRef): Cid | undefined {\n  if (!blob) return undefined\n  return '$type' in blob ? blob.ref : parseCid(blob.cid)\n}\n\n/**\n * Extracts the CID string from a {@link BlobRef}.\n *\n * This is similar to `getBlobCid(blob).toString()` but is more optimized since\n * the CID string is already available in the legacy format and we can avoid\n * parsing it into a CID object just to convert it back to a string.\n *\n * @example\n * ```ts\n * const cidString = getBlobCidString(blobRef)\n * console.log(cidString)\n * ```\n */\nexport function getBlobCidString(blob: BlobRef): string\nexport function getBlobCidString(blob?: BlobRef): string | undefined\nexport function getBlobCidString(blob?: BlobRef): string | undefined {\n  if (!blob) return undefined\n  return '$type' in blob ? blob.ref.toString() : blob.cid\n}\n\n/**\n * Reference to binary data (like images, videos, etc.) in the AT Protocol data model.\n *\n * A {@link TypedBlobRef} is a {@link LexMap} with a specific structure that\n * identifies binary content by its content hash (CID), along with metadata\n * about the content type and size.\n *\n * @typeParam Ref - The type of CID reference, defaults to any {@link Cid}\n *\n * @example\n * ```typescript\n * import type { TypedBlobRef } from '@atproto/lex-data'\n *\n * const imageRef: TypedBlobRef = {\n *   $type: 'blob',\n *   mimeType: 'image/jpeg',\n *   ref: cid,  // CID of the blob content\n *   size: 12345\n * }\n * ```\n *\n * @see {@link isTypedBlobRef} to check if a value is a valid {@link TypedBlobRef}\n * @see {@link LegacyBlobRef} for the older blob reference format\n */\nexport type TypedBlobRef<Ref extends Cid = Cid> = {\n  $type: 'blob'\n  mimeType: string\n  ref: Ref\n  size: number\n}\n\n/**\n * Infers the BlobRef type based on the check options.\n *\n * @typeParam TOptions - The options used for checking\n */\nexport type InferTypedBlobRef<TOptions extends BlobRefCheckOptions> =\n  TOptions extends { strict: false }\n    ? TypedBlobRef\n    : { strict: boolean } extends TOptions\n      ? TypedBlobRef\n      : TypedBlobRef<RawCid>\n\n/**\n * Type guard to check if a value is a valid {@link BlobRef}.\n *\n * Validates the structure of the input including:\n * - `$type` must be `'blob'`\n * - `mimeType` must be a valid MIME type string (containing '/')\n * - `size` must be a non-negative safe integer\n * - `ref` must be a valid CID (strict validation by default)\n *\n * @param input - The value to check\n * @param options - Optional validation options\n * @returns `true` if the input is a valid BlobRef\n *\n * @example\n * ```typescript\n * import { isTypedBlobRef } from '@atproto/lex-data'\n *\n * if (isTypedBlobRef(data)) {\n *   console.log(data.mimeType)  // e.g., 'image/jpeg'\n *   console.log(data.size)      // e.g., 12345\n * }\n *\n * // Allow any valid CID (not just raw CIDs)\n * if (isTypedBlobRef(data, { strict: false })) {\n *   // ...\n * }\n * ```\n */\nexport function isTypedBlobRef(input: unknown): input is TypedBlobRef<RawCid>\nexport function isTypedBlobRef<TOptions extends BlobRefCheckOptions>(\n  input: unknown,\n  options: TOptions,\n): input is InferTypedBlobRef<TOptions>\nexport function isTypedBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is TypedBlobRef<RawCid>\nexport function isTypedBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is TypedBlobRef {\n  if (!isPlainObject(input)) {\n    return false\n  }\n\n  if (input?.$type !== 'blob') {\n    return false\n  }\n\n  const { mimeType, size, ref } = input\n  // @NOTE Very basic mime validation\n  if (typeof mimeType !== 'string' || !mimeType.includes('/')) {\n    return false\n  }\n\n  if (size === -1 && options?.strict === false) {\n    // In non-strict mode, allow size to be -1 to accommodate legacy blob refs\n    // that don't include size information.\n  } else if (!isSafeInteger(size) || size < 0) {\n    return false\n  }\n\n  if (typeof ref !== 'object' || ref === null) {\n    return false\n  }\n\n  for (const key in input) {\n    if (\n      key !== '$type' &&\n      key !== 'mimeType' &&\n      key !== 'ref' &&\n      key !== 'size'\n    ) {\n      return false\n    }\n  }\n\n  const cid = ifCid(\n    ref,\n    // Strict unless explicitly disabled\n    options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS,\n  )\n  if (!cid) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Legacy format for blob references used in older AT Protocol data.\n *\n * This is the older format that stores the CID as a string rather than\n * as a structured CID object. New code should use {@link BlobRef} instead.\n *\n * @example\n * ```typescript\n * import type { LegacyBlobRef } from '@atproto/lex-data'\n *\n * const legacyRef: LegacyBlobRef = {\n *   cid: 'bafyreib...',\n *   mimeType: 'image/jpeg'\n * }\n * ```\n *\n * @see {@link isLegacyBlobRef} to check if a value is a LegacyBlobRef\n * @see {@link BlobRef} for the current blob reference format\n * @deprecated Use {@link BlobRef} for new code\n */\nexport type LegacyBlobRef = {\n  cid: string\n  mimeType: string\n}\n\n/**\n * Type guard to check if a value is a valid {@link LegacyBlobRef}.\n *\n * Validates the structure of the input:\n * - `cid` must be a valid CID string\n * - `mimeType` must be a non-empty string\n * - No additional properties allowed\n *\n * @example\n * ```typescript\n * import { isLegacyBlobRef } from '@atproto/lex-data'\n *\n * if (isLegacyBlobRef(data)) {\n *   console.log(data.cid)       // CID as string\n *   console.log(data.mimeType)  // e.g., 'image/jpeg'\n * }\n * ```\n *\n * @see {@link isTypedBlobRef} for checking the current blob reference format\n */\nexport function isLegacyBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is LegacyBlobRef {\n  if (!isPlainObject(input)) {\n    return false\n  }\n\n  const { cid, mimeType } = input\n  if (typeof cid !== 'string') {\n    return false\n  }\n\n  if (typeof mimeType !== 'string' || mimeType.length === 0) {\n    return false\n  }\n\n  for (const key in input) {\n    if (key !== 'cid' && key !== 'mimeType') {\n      return false\n    }\n  }\n\n  if (\n    !validateCidString(\n      cid,\n      options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS,\n    )\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Options for enumerating blob references within a {@link LexValue}.\n */\nexport type EnumBlobRefsOptions = BlobRefCheckOptions & {\n  /**\n   * If `true`, also yields {@link LegacyBlobRef} objects in addition to\n   * {@link BlobRef} objects.\n   *\n   * @default false\n   */\n  allowLegacy?: boolean\n}\n\n/**\n * Infers the yielded type of {@link enumBlobRefs} based on options.\n *\n * @typeParam TOptions - The options used for enumeration\n */\nexport type InferEnumBlobRefs<TOptions extends EnumBlobRefsOptions> =\n  TOptions extends { allowLegacy: true }\n    ? InferTypedBlobRef<TOptions> | LegacyBlobRef\n    : { allowLegacy: boolean } extends TOptions\n      ? InferTypedBlobRef<TOptions> | LegacyBlobRef\n      : InferTypedBlobRef<TOptions>\n\n/**\n * Generator that enumerates all {@link BlobRef}s (and, optionally,\n * {@link LegacyBlobRef}s) found within a {@link LexValue}.\n *\n * Performs a deep traversal of the input value, yielding any blob references\n * found. This is useful for extracting all media references from a record.\n *\n * @param input - The LexValue to search for blob references\n * @param options - Optional configuration for the enumeration\n * @yields Each blob reference found in the input\n *\n * @example\n * ```typescript\n * import { enumBlobRefs } from '@atproto/lex-data'\n *\n * const record = {\n *   text: 'Hello',\n *   images: [\n *     { $type: 'blob', mimeType: 'image/jpeg', ref: cid1, size: 1000 },\n *     { $type: 'blob', mimeType: 'image/png', ref: cid2, size: 2000 }\n *   ]\n * }\n *\n * for (const blobRef of enumBlobRefs(record)) {\n *   console.log(blobRef.mimeType, blobRef.size)\n * }\n *\n * // Include legacy blob references\n * for (const ref of enumBlobRefs(record, { allowLegacy: true, strict: false })) {\n *   // ref may be BlobRef or LegacyBlobRef, with relaxed CID validation\n * }\n * ```\n */\nexport function enumBlobRefs(\n  input: LexValue,\n): Generator<BlobRef<RawCid>, void, unknown>\nexport function enumBlobRefs<TOptions extends EnumBlobRefsOptions>(\n  input: LexValue,\n  options: TOptions,\n): Generator<InferEnumBlobRefs<TOptions>, void, unknown>\nexport function enumBlobRefs(\n  input: LexValue,\n  options?: EnumBlobRefsOptions,\n): Generator<BlobRef, void, unknown>\nexport function* enumBlobRefs(\n  input: LexValue,\n  options?: EnumBlobRefsOptions,\n): Generator<BlobRef, void, unknown> {\n  // LegacyBlobRef not included by default\n  const includeLegacy = options?.allowLegacy === true\n\n  // Using a stack to avoid recursion depth issues.\n  const stack: LexValue[] = [input]\n\n  // Since we are using a stack, we could end-up in an infinite loop with cyclic\n  // structures. Cyclic structures are not valid LexValues and should, thus,\n  // never occur, but let's be safe.\n  const visited = new Set<object>()\n\n  do {\n    const value = stack.pop()!\n\n    if (value != null && typeof value === 'object') {\n      if (Array.isArray(value)) {\n        if (visited.has(value)) continue\n        visited.add(value)\n        stack.push(...value)\n      } else if (isPlainProto(value)) {\n        if (visited.has(value)) continue\n        visited.add(value)\n        if (isTypedBlobRef(value, options)) {\n          yield value\n        } else if (includeLegacy && isLegacyBlobRef(value, options)) {\n          yield value\n        } else {\n          for (const v of Object.values(value)) {\n            if (v != null) stack.push(v)\n          }\n        }\n      }\n    }\n  } while (stack.length > 0)\n\n  // Optimization: ease GC's work\n  visited.clear()\n}\n"]}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CheckCidOptions,\n  Cid,\n  RawCid,\n  ifCid,\n  parseCid,\n  validateCidString,\n} from './cid.js'\nimport { LexValue } from './lex.js'\nimport { isPlainObject, isPlainProto } from './object.js'\n\n/**\n * Options to use with {@link ifCid}, {@link validateCidString}, and related CID\n * validation functions when validating CIDs in BlobRefs, in strict mode. This\n * ensures that the CID is a {@link RawCid} (CID v1, raw multicodec, sha256\n * multihash), which is the expected format for blob references in the AT\n * Protocol data model.\n */\nconst STRICT_CID_CHECK_OPTIONS: CheckCidOptions = { flavor: 'raw' }\n\n// Number.isSafeInteger is actually safe to use with non-number values, so we\n// can use it as a type guard.\nconst isSafeInteger = Number.isSafeInteger as (v: unknown) => v is number\n\n/**\n * Reference to binary data (like images, videos, etc.) in the AT Protocol data\n * model.\n *\n * This type represents a reference to a blob of binary data, identified by its\n * content hash (CID) and accompanied by metadata such as MIME type and size.\n *\n * The {@link BlobRef} type is a union of the current {@link TypedBlobRef}\n * format and the legacy {@link LegacyBlobRef} format.\n */\nexport type BlobRef<Ref extends Cid = Cid> = TypedBlobRef<Ref> | LegacyBlobRef\n\n/**\n * Options for validating a {@link BlobRef}.\n */\nexport type BlobRefCheckOptions = {\n  /**\n   * If `false`, skips strict CID validation of {@link BlobRef.ref}, allowing\n   * any valid CID. Otherwise, validates that the CID is v1, uses the raw\n   * multicodec, and has a sha256 multihash.\n   *\n   * @default true\n   */\n  strict?: boolean\n}\n\n/**\n * Type guard to check if a value is a valid {@link BlobRef}, which can be\n * either a {@link TypedBlobRef} or a {@link LegacyBlobRef}. By default, strict\n * CID validation is applied to ensure that the CID in the blob reference is in\n * the expected format for the AT Protocol, but this can be relaxed with the\n * `strict: false` option.\n */\nexport function isBlobRef(input: unknown): input is BlobRef<RawCid>\nexport function isBlobRef<TOptions extends BlobRefCheckOptions>(\n  input: unknown,\n  options: TOptions,\n): input is LegacyBlobRef | InferTypedBlobRef<TOptions>\nexport function isBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is BlobRef<RawCid>\nexport function isBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is BlobRef {\n  return (input as any)?.$type === 'blob'\n    ? isTypedBlobRef(input, options)\n    : isLegacyBlobRef(input, options)\n}\n\n/**\n * Extracts the MIME type from a {@link BlobRef}.\n *\n * @example\n * ```ts\n * const mimeType = getBlobMime(blobRef)\n * console.log(mimeType)  // e.g., 'image/jpeg'\n * ```\n */\nexport function getBlobMime(blob: BlobRef): string\nexport function getBlobMime(blob?: BlobRef): string | undefined\nexport function getBlobMime(blob?: BlobRef): string | undefined {\n  return blob?.mimeType\n}\n\n/**\n * Extracts the size (in bytes) from a {@link TypedBlobRef}. For\n * {@link LegacyBlobRef}, size information is not available, so this function\n * returns `undefined` for legacy refs.\n *\n * @note The size property, in blob refs, cannot be 100% trusted since the PDS\n * might not have a local copy of the blob (to check the size against) and might\n * just be passing through the blob ref from the client without validating it.\n * So, while this function can be useful for getting size information when\n * available, it should not be solely relied upon for critical functionality\n * without additional validation.\n *\n * @example\n * ```ts\n * const size = getBlobSize(blobRef)\n * if (size !== undefined) {\n *   console.log(`Blob size: ${size} bytes`)\n * } else {\n *   console.log('Size information not available for legacy blob ref')\n * }\n * ```\n */\nexport function getBlobSize(blob: BlobRef): number | undefined {\n  if ('$type' in blob && blob.size >= 0) return blob.size\n  // LegacyBlobRef doesn't have size information\n  return undefined\n}\n\n/**\n * Extracts the {@link Cid} from a {@link BlobRef}.\n *\n * @throws If the input input is a {@link LegacyBlobRef} with an invalid CID string\n * @example\n * ```ts\n * const cid = getBlobCid(blobRef)\n * console.log(cid.bytes)\n * ```\n */\nexport function getBlobCid(blob: BlobRef): Cid\nexport function getBlobCid(blob?: BlobRef): Cid | undefined\nexport function getBlobCid(blob?: BlobRef): Cid | undefined {\n  if (!blob) return undefined\n  return '$type' in blob ? blob.ref : parseCid(blob.cid)\n}\n\n/**\n * Extracts the CID string from a {@link BlobRef}.\n *\n * This is similar to `getBlobCid(blob).toString()` but is more optimized since\n * the CID string is already available in the legacy format and we can avoid\n * parsing it into a CID object just to convert it back to a string.\n *\n * @example\n * ```ts\n * const cidString = getBlobCidString(blobRef)\n * console.log(cidString)\n * ```\n */\nexport function getBlobCidString(blob: BlobRef): string\nexport function getBlobCidString(blob?: BlobRef): string | undefined\nexport function getBlobCidString(blob?: BlobRef): string | undefined {\n  if (!blob) return undefined\n  return '$type' in blob ? blob.ref.toString() : blob.cid\n}\n\n/**\n * Reference to binary data (like images, videos, etc.) in the AT Protocol data model.\n *\n * A {@link TypedBlobRef} is a {@link LexMap} with a specific structure that\n * identifies binary content by its content hash (CID), along with metadata\n * about the content type and size.\n *\n * @typeParam Ref - The type of CID reference, defaults to any {@link Cid}\n *\n * @example\n * ```typescript\n * import type { TypedBlobRef } from '@atproto/lex-data'\n *\n * const imageRef: TypedBlobRef = {\n *   $type: 'blob',\n *   mimeType: 'image/jpeg',\n *   ref: cid,  // CID of the blob content\n *   size: 12345\n * }\n * ```\n *\n * @see {@link isTypedBlobRef} to check if a value is a valid {@link TypedBlobRef}\n * @see {@link LegacyBlobRef} for the older blob reference format\n */\nexport type TypedBlobRef<Ref extends Cid = Cid> = {\n  $type: 'blob'\n  mimeType: string\n  ref: Ref\n  size: number\n}\n\n/**\n * Infers the BlobRef type based on the check options.\n *\n * @typeParam TOptions - The options used for checking\n */\nexport type InferTypedBlobRef<TOptions extends BlobRefCheckOptions> =\n  TOptions extends { strict: false }\n    ? TypedBlobRef\n    : { strict: boolean } extends TOptions\n      ? TypedBlobRef\n      : TypedBlobRef<RawCid>\n\n/**\n * Type guard to check if a value is a valid {@link BlobRef}.\n *\n * Validates the structure of the input including:\n * - `$type` must be `'blob'`\n * - `mimeType` must be a valid MIME type string (containing '/')\n * - `size` must be a non-negative safe integer\n * - `ref` must be a valid CID (strict validation by default)\n *\n * @param input - The value to check\n * @param options - Optional validation options\n * @returns `true` if the input is a valid BlobRef\n *\n * @example\n * ```typescript\n * import { isTypedBlobRef } from '@atproto/lex-data'\n *\n * if (isTypedBlobRef(data)) {\n *   console.log(data.mimeType)  // e.g., 'image/jpeg'\n *   console.log(data.size)      // e.g., 12345\n * }\n *\n * // Allow any valid CID (not just raw CIDs)\n * if (isTypedBlobRef(data, { strict: false })) {\n *   // ...\n * }\n * ```\n */\nexport function isTypedBlobRef(input: unknown): input is TypedBlobRef<RawCid>\nexport function isTypedBlobRef<TOptions extends BlobRefCheckOptions>(\n  input: unknown,\n  options: TOptions,\n): input is InferTypedBlobRef<TOptions>\nexport function isTypedBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is TypedBlobRef<RawCid>\nexport function isTypedBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is TypedBlobRef {\n  if (!isPlainObject(input)) {\n    return false\n  }\n\n  if (input?.$type !== 'blob') {\n    return false\n  }\n\n  const { mimeType, size, ref } = input\n  // @NOTE Very basic mime validation\n  if (typeof mimeType !== 'string' || !mimeType.includes('/')) {\n    return false\n  }\n\n  if (size === -1 && options?.strict === false) {\n    // In non-strict mode, allow size to be -1 to accommodate legacy blob refs\n    // that don't include size information.\n  } else if (!isSafeInteger(size) || size < 0) {\n    return false\n  }\n\n  if (typeof ref !== 'object' || ref === null) {\n    return false\n  }\n\n  for (const key in input) {\n    if (\n      key !== '$type' &&\n      key !== 'mimeType' &&\n      key !== 'ref' &&\n      key !== 'size'\n    ) {\n      return false\n    }\n  }\n\n  const cid = ifCid(\n    ref,\n    // Strict unless explicitly disabled\n    options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS,\n  )\n  if (!cid) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Legacy format for blob references used in older AT Protocol data.\n *\n * This is the older format that stores the CID as a string rather than\n * as a structured CID object. New code should use {@link BlobRef} instead.\n *\n * @example\n * ```typescript\n * import type { LegacyBlobRef } from '@atproto/lex-data'\n *\n * const legacyRef: LegacyBlobRef = {\n *   cid: 'bafyreib...',\n *   mimeType: 'image/jpeg'\n * }\n * ```\n *\n * @see {@link isLegacyBlobRef} to check if a value is a LegacyBlobRef\n * @see {@link BlobRef} for the current blob reference format\n * @deprecated Use {@link BlobRef} for new code\n */\nexport type LegacyBlobRef = {\n  cid: string\n  mimeType: string\n}\n\n/**\n * Type guard to check if a value is a valid {@link LegacyBlobRef}.\n *\n * Validates the structure of the input:\n * - `cid` must be a valid CID string\n * - `mimeType` must be a non-empty string\n * - No additional properties allowed\n *\n * @example\n * ```typescript\n * import { isLegacyBlobRef } from '@atproto/lex-data'\n *\n * if (isLegacyBlobRef(data)) {\n *   console.log(data.cid)       // CID as string\n *   console.log(data.mimeType)  // e.g., 'image/jpeg'\n * }\n * ```\n *\n * @see {@link isTypedBlobRef} for checking the current blob reference format\n */\nexport function isLegacyBlobRef(\n  input: unknown,\n  options?: BlobRefCheckOptions,\n): input is LegacyBlobRef {\n  if (!isPlainObject(input)) {\n    return false\n  }\n\n  const { cid, mimeType } = input\n  if (typeof cid !== 'string') {\n    return false\n  }\n\n  if (typeof mimeType !== 'string' || mimeType.length === 0) {\n    return false\n  }\n\n  for (const key in input) {\n    if (key !== 'cid' && key !== 'mimeType') {\n      return false\n    }\n  }\n\n  if (\n    !validateCidString(\n      cid,\n      options?.strict === false ? undefined : STRICT_CID_CHECK_OPTIONS,\n    )\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Options for enumerating blob references within a {@link LexValue}.\n */\nexport type EnumBlobRefsOptions = BlobRefCheckOptions & {\n  /**\n   * If `true`, also yields {@link LegacyBlobRef} objects in addition to\n   * {@link BlobRef} objects.\n   *\n   * @default false\n   */\n  allowLegacy?: boolean\n}\n\n/**\n * Infers the yielded type of {@link enumBlobRefs} based on options.\n *\n * @typeParam TOptions - The options used for enumeration\n */\nexport type InferEnumBlobRefs<TOptions extends EnumBlobRefsOptions> =\n  TOptions extends { allowLegacy: true }\n    ? InferTypedBlobRef<TOptions> | LegacyBlobRef\n    : { allowLegacy: boolean } extends TOptions\n      ? InferTypedBlobRef<TOptions> | LegacyBlobRef\n      : InferTypedBlobRef<TOptions>\n\n/**\n * Generator that enumerates all {@link BlobRef}s (and, optionally,\n * {@link LegacyBlobRef}s) found within a {@link LexValue}.\n *\n * Performs a deep traversal of the input value, yielding any blob references\n * found. This is useful for extracting all media references from a record.\n *\n * @param input - The LexValue to search for blob references\n * @param options - Optional configuration for the enumeration\n * @yields Each blob reference found in the input\n *\n * @example\n * ```typescript\n * import { enumBlobRefs } from '@atproto/lex-data'\n *\n * const record = {\n *   text: 'Hello',\n *   images: [\n *     { $type: 'blob', mimeType: 'image/jpeg', ref: cid1, size: 1000 },\n *     { $type: 'blob', mimeType: 'image/png', ref: cid2, size: 2000 }\n *   ]\n * }\n *\n * for (const blobRef of enumBlobRefs(record)) {\n *   console.log(blobRef.mimeType, blobRef.size)\n * }\n *\n * // Include legacy blob references\n * for (const ref of enumBlobRefs(record, { allowLegacy: true, strict: false })) {\n *   // ref may be BlobRef or LegacyBlobRef, with relaxed CID validation\n * }\n * ```\n */\nexport function enumBlobRefs(\n  input: LexValue,\n): Generator<BlobRef<RawCid>, void, unknown>\nexport function enumBlobRefs<TOptions extends EnumBlobRefsOptions>(\n  input: LexValue,\n  options: TOptions,\n): Generator<InferEnumBlobRefs<TOptions>, void, unknown>\nexport function enumBlobRefs(\n  input: LexValue,\n  options?: EnumBlobRefsOptions,\n): Generator<BlobRef, void, unknown>\nexport function* enumBlobRefs(\n  input: LexValue,\n  options?: EnumBlobRefsOptions,\n): Generator<BlobRef, void, unknown> {\n  // LegacyBlobRef not included by default\n  const includeLegacy = options?.allowLegacy === true\n\n  // Using a stack to avoid recursion depth issues.\n  const stack: LexValue[] = [input]\n\n  // Since we are using a stack, we could end-up in an infinite loop with cyclic\n  // structures. Cyclic structures are not valid LexValues and should, thus,\n  // never occur, but let's be safe.\n  const visited = new Set<object>()\n\n  do {\n    const value = stack.pop()!\n\n    if (value != null && typeof value === 'object') {\n      if (Array.isArray(value)) {\n        if (visited.has(value)) continue\n        visited.add(value)\n        stack.push(...value)\n      } else if (isPlainProto(value)) {\n        if (visited.has(value)) continue\n        visited.add(value)\n        if (isTypedBlobRef(value, options)) {\n          yield value\n        } else if (includeLegacy && isLegacyBlobRef(value, options)) {\n          yield value\n        } else {\n          for (const v of Object.values(value)) {\n            if (v != null) stack.push(v)\n          }\n        }\n      }\n    }\n  } while (stack.length > 0)\n\n  // Optimization: ease GC's work\n  visited.clear()\n}\n"]}

package/dist/cid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cid.d.ts","sourceRoot":"","sources":["../src/cid.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cid.d.ts","sourceRoot":"","sources":["../src/cid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAOtC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAO,CAAA;AACnC,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAA;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,KAAO,CAAA;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,gBAAgB,IAAc,CAAA;AAC3C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AAEtD;;GAEG;AACH,eAAO,MAAM,gBAAgB,IAAc,CAAA;AAC3C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,SAAS,CAAC,SAAS,SAAS,MAAM,GAAG,MAAM;IAC1D;;OAEG;IACH,IAAI,EAAE,SAAS,CAAA;IAEf;;OAEG;IACH,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAGnE;AAED,OAAO,QAAQ,kBAAkB,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IAEH,UAAU,GAAG;KAAG;CACjB;AAqBD,OAAO,EAAE,kBAAkB,CAAC,GAAG,EAAE,CAAA;AAEjC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAC9B,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,SAAS,SAAS,MAAM,GAAG,MAAM,EACjC,KAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,GAeX,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CACnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,GAAG,CAClB,QAAQ,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAC9B,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,SAAS,SAAS,MAAM,GAAG,MAAM;IAKjC,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,CAAA;IAExC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAE1B;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAA;IAE3B;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAA;CACnB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;AAE3C;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,CAEhD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG,GAAG,CAAC,CAAC,EAAE,cAAc,GAAG,eAAe,EAAE,gBAAgB,CAAC,CAAA;AAEhF;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAOlD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,GAAG,CAAC,CAAC,EAAE,eAAe,EAAE,gBAAgB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAElD;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;CACjC,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,QAAQ,SAAS,eAAe,IAC1D,QAAQ,SAAS;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GAC9B,MAAM,GACN,QAAQ,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GACjC,OAAO,GACP,GAAG,CAAA;AAEX;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAS,eAAe,EACvD,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,QAAQ,GAChB,GAAG,IAAI,eAAe,CAAC,QAAQ,CAAC,CAAA;AACnC,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAA;AAgBtE;;;GAGG;AACH,wBAAgB,KAAK,CAAC,QAAQ,SAAS,eAAe,EACpD,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,QAAQ,GAChB,KAAK,IAAI,eAAe,CAAC,QAAQ,CAAC,CAAA;AACrC,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,KAAK,IAAI,GAAG,CAAA;AAK9E;;GAEG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,QAAQ,SAAS,eAAe,EAC5D,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,QAAQ,GAChB,CAAC,MAAM,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAA;AAC9C,wBAAgB,KAAK,CAAC,MAAM,EAC1B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,CAAA;AAMxB;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,QAAQ,SAAS,eAAe,EAC5D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,GAChB,MAAM,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAA;AACrC,wBAAgB,KAAK,CAAC,MAAM,EAC1B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,GAAG,GAAG,CAAA;AAQf;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,QAAQ,SAAS,eAAe,EACxD,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,QAAQ,GAChB,eAAe,CAAC,QAAQ,CAAC,CAAA;AAC5B,wBAAgB,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,GAAG,CAAA;AAS/E;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAS,eAAe,EACvD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,GAChB,eAAe,CAAC,QAAQ,CAAC,CAAA;AAC5B,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,GAAG,CAAA;AAMvE;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAET;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,SAAS,eAAe,EAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,GAChB,eAAe,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAA;AACnC,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,GAAG,GAAG,IAAI,CAAA;AAYb;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,IAAI,CAIN;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,OAAO,CAAC,CAelB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,EACvE,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,SAAS,EACxB,MAAM,EAAE,UAAU,GAGJ,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CACxC;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAGpE;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAGvE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAQxD"}

package/dist/cid.js

@@ -1,32 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CID = exports.SHA512_HASH_CODE = exports.SHA256_HASH_CODE = exports.RAW_DATA_CODEC = exports.CBOR_DATA_CODEC = void 0;
-exports.multihashEquals = multihashEquals;
-exports.asMultiformatsCID = asMultiformatsCID;
-exports.isRawCid = isRawCid;
-exports.isDaslCid = isDaslCid;
-exports.isCborCid = isCborCid;
-exports.checkCid = checkCid;
-exports.isCid = isCid;
-exports.ifCid = ifCid;
-exports.asCid = asCid;
-exports.decodeCid = decodeCid;
-exports.parseCid = parseCid;
-exports.validateCidString = validateCidString;
-exports.parseCidSafe = parseCidSafe;
-exports.ensureValidCidString = ensureValidCidString;
-exports.isCidForBytes = isCidForBytes;
-exports.createCid = createCid;
-exports.cidForCbor = cidForCbor;
-exports.cidForRawBytes = cidForRawBytes;
-exports.cidForRawHash = cidForRawHash;
-const cid_1 = require("multiformats/cid");
-Object.defineProperty(exports, "CID", { enumerable: true, get: function () { return cid_1.CID; } });
-const digest_1 = require("multiformats/hashes/digest");
-const sha2_1 = require("multiformats/hashes/sha2");
-const util_js_1 = require("./lib/util.js");
-const object_js_1 = require("./object.js");
-const uint8array_js_1 = require("./uint8array.js");
+import { CID } from 'multiformats/cid';
+import { create as createDigest } from 'multiformats/hashes/digest';
+import { sha256, sha512 } from 'multiformats/hashes/sha2';
+import { isUint8, toHexString } from './lib/util.js';
+import { isObject } from './object.js';
+import { ui8Equals } from './uint8array.js';
 /**
  * Codec code that indicates the CID references a CBOR-encoded data structure.
  *
@@ -34,7 +11,7 @@ const uint8array_js_1 = require("./uint8array.js");
  *
  * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}
  */
-exports.CBOR_DATA_CODEC = 0x71;
+export const CBOR_DATA_CODEC = 0x71;
 /**
  * Codec code that indicates the CID references raw binary data (like media blobs).
  *
@@ -42,15 +19,15 @@ exports.CBOR_DATA_CODEC = 0x71;
  *
  * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}
  */
-exports.RAW_DATA_CODEC = 0x55;
+export const RAW_DATA_CODEC = 0x55;
 /**
  * Hash code that indicates that a CID uses SHA-256.
  */
-exports.SHA256_HASH_CODE = sha2_1.sha256.code;
+export const SHA256_HASH_CODE = sha256.code;
 /**
  * Hash code that indicates that a CID uses SHA-512.
  */
-exports.SHA512_HASH_CODE = sha2_1.sha512.code;
+export const SHA512_HASH_CODE = sha512.code;
 /**
  * Compares two {@link Multihash} for equality.
  *
@@ -58,11 +35,30 @@ exports.SHA512_HASH_CODE = sha2_1.sha512.code;
  * @param b - Second {@link Multihash}
  * @returns `true` if both multihashes have the same code and digest
  */
-function multihashEquals(a, b) {
+export function multihashEquals(a, b) {
     if (a === b)
         return true;
-    return a.code === b.code && (0, uint8array_js_1.ui8Equals)(a.digest, b.digest);
+    return a.code === b.code && ui8Equals(a.digest, b.digest);
 }
+// multiformats' CID class is not very portable because:
+//
+// - In dependent packages that use "moduleResolution" set to "node16",
+//   "nodenext" or "bundler", TypeScript fails to properly resolve the
+//   multiformats package when importing CID from @atproto/lex-data. This causes
+//   type errors in those packages. This is caused by the fact that the
+//   multiformats version <10 (which is the last version that supports CommonJS)
+//   uses "exports" field in package.json, which do not contain "types"
+//   entrypoints.
+//   https://www.npmjs.com/package/multiformats/v/9.9.0?activeTab=code
+// - By defining our own interface and helper functions, we can have more
+//   control over the public API exposed by this package.
+// - It allow us to have a stable interface in case we need to swap out, or
+//   eventually update multiformats (should we choose to drop CommonJS support)
+//   in the future.
+// @NOTE Even though it is not portable, we still re-export CID here so that
+// dependent packages where it can be used, have access to it (instead of
+// importing directly from "multiformats" or "multiformats/cid").
+export { /** @deprecated */ CID };
 /**
  * Converts a {@link Cid} to a multiformats {@link CID} instance.
  *
@@ -71,12 +67,12 @@ function multihashEquals(a, b) {
  * implementation directly. This is to avoid compatibility issues, and in order
  * to allow better portability, compatibility and future updates.
  */
-function asMultiformatsCID(input) {
+export function asMultiformatsCID(input) {
     const cid = 
     // Already a multiformats CID instance
-    cid_1.CID.asCID(input) ??
+    CID.asCID(input) ??
         // Create a new multiformats CID instance
-        cid_1.CID.create(input.version, input.code, (0, digest_1.create)(input.multihash.code, input.multihash.digest));
+        CID.create(input.version, input.code, createDigest(input.multihash.code, input.multihash.digest));
     // @NOTE: the "satisfies" operator is used here to ensure that the Cid
     // interface is indeed compatible with multiformats' CID implementation, which
     // allows us to safely rely on multiformats' CID implementation where Cid are
@@ -89,8 +85,8 @@ function asMultiformatsCID(input) {
  * @param cid - The CID to check
  * @returns `true` if the CID is a version 1 CID with raw multicodec
  */
-function isRawCid(cid) {
-    return cid.version === 1 && cid.code === exports.RAW_DATA_CODEC;
+export function isRawCid(cid) {
+    return cid.version === 1 && cid.code === RAW_DATA_CODEC;
 }
 /**
  * Type guard to check if a CID is DASL compliant.
@@ -98,10 +94,10 @@ function isRawCid(cid) {
  * @param cid - The CID to check
  * @returns `true` if the CID is DASL compliant (v1, raw/dag-cbor, sha256)
  */
-function isDaslCid(cid) {
+export function isDaslCid(cid) {
     return (cid.version === 1 &&
-        (cid.code === exports.RAW_DATA_CODEC || cid.code === exports.CBOR_DATA_CODEC) &&
-        cid.multihash.code === exports.SHA256_HASH_CODE &&
+        (cid.code === RAW_DATA_CODEC || cid.code === CBOR_DATA_CODEC) &&
+        cid.multihash.code === SHA256_HASH_CODE &&
         cid.multihash.digest.byteLength === 0x20 // Should always be 32 bytes (256 bits) for SHA-256, but double-checking anyways
     );
 }
@@ -111,10 +107,10 @@ function isDaslCid(cid) {
  * @param cid - The CID to check
  * @returns `true` if the CID is a DAG-CBOR CID (v1, dag-cbor, sha256)
  */
-function isCborCid(cid) {
-    return cid.code === exports.CBOR_DATA_CODEC && isDaslCid(cid);
+export function isCborCid(cid) {
+    return cid.code === CBOR_DATA_CODEC && isDaslCid(cid);
 }
-function checkCid(cid, options) {
+export function checkCid(cid, options) {
     switch (options?.flavor) {
         case undefined:
             return true;
@@ -128,25 +124,25 @@ function checkCid(cid, options) {
             throw new TypeError(`Unknown CID flavor: ${options?.flavor}`);
     }
 }
-function isCid(value, options) {
+export function isCid(value, options) {
     return isCidImplementation(value) && checkCid(value, options);
 }
-function ifCid(value, options) {
+export function ifCid(value, options) {
     if (isCid(value, options))
         return value;
     return null;
 }
-function asCid(value, options) {
+export function asCid(value, options) {
     if (isCid(value, options))
         return value;
     throw new Error(`Invalid ${options?.flavor ? `${options.flavor} CID` : 'CID'} "${value}"`);
 }
-function decodeCid(cidBytes, options) {
-    const cid = cid_1.CID.decode(cidBytes);
+export function decodeCid(cidBytes, options) {
+    const cid = CID.decode(cidBytes);
     return asCid(cid, options);
 }
-function parseCid(input, options) {
-    const cid = cid_1.CID.parse(input);
+export function parseCid(input, options) {
+    const cid = CID.parse(input);
     return asCid(cid, options);
 }
 /**
@@ -159,10 +155,10 @@ function parseCid(input, options) {
  * @param options - Optional flavor constraints
  * @returns `true` if the string is a valid CID
  */
-function validateCidString(input, options) {
+export function validateCidString(input, options) {
     return parseCidSafe(input, options)?.toString() === input;
 }
-function parseCidSafe(input, options) {
+export function parseCidSafe(input, options) {
     try {
         return parseCid(input, options);
     }
@@ -177,7 +173,7 @@ function parseCidSafe(input, options) {
  * @param options - Optional flavor constraints
  * @throws If the string is not a valid CID
  */
-function ensureValidCidString(input, options) {
+export function ensureValidCidString(input, options) {
     if (!validateCidString(input, options)) {
         throw new Error(`Invalid CID string "${input}"`);
     }
@@ -188,17 +184,17 @@ function ensureValidCidString(input, options) {
  * @params bytes The bytes to verify.
  * @returns true if the CID matches the bytes, false otherwise.
  */
-async function isCidForBytes(cid, bytes) {
-    if (cid.multihash.code === sha2_1.sha256.code) {
-        const multihash = await sha2_1.sha256.digest(bytes);
+export async function isCidForBytes(cid, bytes) {
+    if (cid.multihash.code === sha256.code) {
+        const multihash = await sha256.digest(bytes);
         return multihashEquals(multihash, cid.multihash);
     }
-    if (cid.multihash.code === sha2_1.sha512.code) {
-        const multihash = await sha2_1.sha512.digest(bytes);
+    if (cid.multihash.code === sha512.code) {
+        const multihash = await sha512.digest(bytes);
         return multihashEquals(multihash, cid.multihash);
     }
     // Don't know how to verify other multihash codes
-    throw new Error(`Unsupported CID multihash code: ${(0, util_js_1.toHexString)(cid.multihash.code)}`);
+    throw new Error(`Unsupported CID multihash code: ${toHexString(cid.multihash.code)}`);
 }
 /**
  * Creates a CID from a multicodec, multihash code, and digest.
@@ -215,8 +211,8 @@ async function isCidForBytes(cid, bytes) {
  * const cid = createCid(RAW_DATA_CODEC, SHA256_HASH_CODE, hashDigest)
  * ```
  */
-function createCid(code, multihashCode, digest) {
-    const cid = cid_1.CID.createV1(code, (0, digest_1.create)(multihashCode, digest));
+export function createCid(code, multihashCode, digest) {
+    const cid = CID.createV1(code, createDigest(multihashCode, digest));
     return cid;
 }
 /**
@@ -227,9 +223,9 @@ function createCid(code, multihashCode, digest) {
  * @param bytes - The CBOR-encoded bytes to hash
  * @returns A promise that resolves to the CborCid
  */
-async function cidForCbor(bytes) {
-    const multihash = await sha2_1.sha256.digest(bytes);
-    return cid_1.CID.createV1(exports.CBOR_DATA_CODEC, multihash);
+export async function cidForCbor(bytes) {
+    const multihash = await sha256.digest(bytes);
+    return CID.createV1(CBOR_DATA_CODEC, multihash);
 }
 /**
  * Creates a raw CID for the given binary bytes.
@@ -239,9 +235,9 @@ async function cidForCbor(bytes) {
  * @param bytes - The raw binary bytes to hash
  * @returns A promise that resolves to the RawCid
  */
-async function cidForRawBytes(bytes) {
-    const multihash = await sha2_1.sha256.digest(bytes);
-    return cid_1.CID.createV1(exports.RAW_DATA_CODEC, multihash);
+export async function cidForRawBytes(bytes) {
+    const multihash = await sha256.digest(bytes);
+    return CID.createV1(RAW_DATA_CODEC, multihash);
 }
 /**
  * Creates a raw CID from an existing SHA-256 hash digest.
@@ -250,15 +246,15 @@ async function cidForRawBytes(bytes) {
  * @returns A RawCid with the given digest
  * @throws If the digest is not a valid SHA-256 hash (not 32 bytes)
  */
-function cidForRawHash(digest) {
+export function cidForRawHash(digest) {
     // Fool-proofing
     if (digest.length !== 0x20) {
-        throw new Error(`Invalid SHA-256 hash length: ${(0, util_js_1.toHexString)(digest.length)}`);
+        throw new Error(`Invalid SHA-256 hash length: ${toHexString(digest.length)}`);
     }
-    return createCid(exports.RAW_DATA_CODEC, sha2_1.sha256.code, digest);
+    return createCid(RAW_DATA_CODEC, sha256.code, digest);
 }
 function isCidImplementation(value) {
-    if (cid_1.CID.asCID(value)) {
+    if (CID.asCID(value)) {
         // CIDs created using older multiformats versions did not have a "bytes"
         // property.
         return value.bytes != null;
@@ -266,17 +262,17 @@ function isCidImplementation(value) {
     else {
         // Unknown implementation, do a structural check
         try {
-            if (!(0, object_js_1.isObject)(value))
+            if (!isObject(value))
                 return false;
             const val = value;
             if (val.version !== 0 && val.version !== 1)
                 return false;
-            if (!(0, util_js_1.isUint8)(val.code))
+            if (!isUint8(val.code))
                 return false;
-            if (!(0, object_js_1.isObject)(val.multihash))
+            if (!isObject(val.multihash))
                 return false;
             const mh = val.multihash;
-            if (!(0, util_js_1.isUint8)(mh.code))
+            if (!isUint8(mh.code))
                 return false;
             if (!(mh.digest instanceof Uint8Array))
                 return false;
@@ -293,7 +289,7 @@ function isCidImplementation(value) {
                 return false;
             if (val.bytes.length !== 4 + mh.digest.length)
                 return false;
-            if (!(0, uint8array_js_1.ui8Equals)(val.bytes.subarray(4), mh.digest))
+            if (!ui8Equals(val.bytes.subarray(4), mh.digest))
                 return false;
             if (typeof val.equals !== 'function')
                 return false;