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

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;

package/dist/cid.js.map

@@ -1 +1 @@
-{"version":3,"file":"cid.js","sourceRoot":"","sources":["../src/cid.ts"],"names":[],"mappings":"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","sourcesContent":["import { CID } from 'multiformats/cid'\nimport { create as createDigest } from 'multiformats/hashes/digest'\nimport { sha256, sha512 } from 'multiformats/hashes/sha2'\nimport { isUint8, toHexString } from './lib/util.js'\nimport { isObject } from './object.js'\nimport { ui8Equals } from './uint8array.js'\n\n/**\n * Codec code that indicates the CID references a CBOR-encoded data structure.\n *\n * Used when encoding structured data in AT Protocol repositories.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport const CBOR_DATA_CODEC = 0x71\nexport type CBOR_DATA_CODEC = typeof CBOR_DATA_CODEC\n\n/**\n * Codec code that indicates the CID references raw binary data (like media blobs).\n *\n * Used in DASL CIDs for binary blobs like images and media.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport const RAW_DATA_CODEC = 0x55\nexport type RAW_DATA_CODEC = typeof RAW_DATA_CODEC\n\n/**\n * Hash code that indicates that a CID uses SHA-256.\n */\nexport const SHA256_HASH_CODE = sha256.code\nexport type SHA256_HASH_CODE = typeof SHA256_HASH_CODE\n\n/**\n * Hash code that indicates that a CID uses SHA-512.\n */\nexport const SHA512_HASH_CODE = sha512.code\nexport type SHA512_HASH_CODE = typeof SHA512_HASH_CODE\n\n/**\n * Represent the hash part of a CID, which includes the hash algorithm code and\n * the raw digest bytes.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport interface Multihash<THashCode extends number = number> {\n  /**\n   * Code of the hash algorithm (e.g., SHA256_HASH_CODE).\n   */\n  code: THashCode\n\n  /**\n   * Raw digest bytes.\n   */\n  digest: Uint8Array\n}\n\n/**\n * Compares two {@link Multihash} for equality.\n *\n * @param a - First {@link Multihash}\n * @param b - Second {@link Multihash}\n * @returns `true` if both multihashes have the same code and digest\n */\nexport function multihashEquals(a: Multihash, b: Multihash): boolean {\n  if (a === b) return true\n  return a.code === b.code && ui8Equals(a.digest, b.digest)\n}\n\ndeclare module 'multiformats/cid' {\n  /**\n   * @deprecated use the {@link Cid} interface from `@atproto/lex-data`, and\n   * related helpers ({@link isCid}, {@link ifCid}, {@link asCid},\n   * {@link parseCid}, {@link decodeCid}), instead.\n   *\n   * This is marked as deprecated because we want to discourage direct usage of\n   * `multiformats/cid` in dependent packages, and instead have them rely on the\n   * {@link Cid} interface from `@atproto/lex-data`. The {@link CID} class from\n   * `multiformats` version <10 has compatibility issues with certain TypeScript\n   * configuration, which can lead to type errors in dependent packages.\n   *\n   * We are stuck with version 9 because `@atproto` packages did not drop\n   * CommonJS support yet, and multiformats version 10 only supports ES modules.\n   *\n   * In order to avoid compatibility issues, while preparing for future breaking\n   * changes (CID in multiformats v10+ has a slightly different interface), as\n   * we update or swap out `multiformats`, `@atproto/lex-data` provides its own\n   * stable {@link Cid} interface.\n   */\n  interface CID {}\n}\n\n// multiformats' CID class is not very portable because:\n//\n// - In dependent packages that use \"moduleResolution\" set to \"node16\",\n//   \"nodenext\" or \"bundler\", TypeScript fails to properly resolve the\n//   multiformats package when importing CID from @atproto/lex-data. This causes\n//   type errors in those packages. This is caused by the fact that the\n//   multiformats version <10 (which is the last version that supports CommonJS)\n//   uses \"exports\" field in package.json, which do not contain \"types\"\n//   entrypoints.\n//   https://www.npmjs.com/package/multiformats/v/9.9.0?activeTab=code\n// - By defining our own interface and helper functions, we can have more\n//   control over the public API exposed by this package.\n// - It allow us to have a stable interface in case we need to swap out, or\n//   eventually update multiformats (should we choose to drop CommonJS support)\n//   in the future.\n\n// @NOTE Even though it is not portable, we still re-export CID here so that\n// dependent packages where it can be used, have access to it (instead of\n// importing directly from \"multiformats\" or \"multiformats/cid\").\nexport { /** @deprecated */ CID }\n\n/**\n * Converts a {@link Cid} to a multiformats {@link CID} instance.\n *\n * @deprecated Packages depending on `@atproto/lex-data` should use the\n * {@link Cid} interface instead of relying on `multiformats`'s {@link CID}\n * implementation directly. This is to avoid compatibility issues, and in order\n * to allow better portability, compatibility and future updates.\n */\nexport function asMultiformatsCID<\n  TVersion extends 0 | 1 = 0 | 1,\n  TCodec extends number = number,\n  THashCode extends number = number,\n>(input: Cid<TVersion, TCodec, THashCode>) {\n  const cid =\n    // Already a multiformats CID instance\n    CID.asCID(input) ??\n    // Create a new multiformats CID instance\n    CID.create(\n      input.version,\n      input.code,\n      createDigest(input.multihash.code, input.multihash.digest),\n    )\n\n  // @NOTE: the \"satisfies\" operator is used here to ensure that the Cid\n  // interface is indeed compatible with multiformats' CID implementation, which\n  // allows us to safely rely on multiformats' CID implementation where Cid are\n  // needed.\n  return cid satisfies Cid as CID & Cid<TVersion, TCodec, THashCode>\n}\n\n/**\n * Content Identifier (CID) for addressing content by its hash.\n *\n * CIDs are self-describing content addresses used throughout AT Protocol for\n * linking to data by its cryptographic hash. This interface provides a\n * stable API that is compatible with the `multiformats` library but avoids\n * direct dependency issues.\n *\n * @typeParam TVersion - CID version (0 or 1)\n * @typeParam TCodec - Multicodec content type code\n * @typeParam THashCode - Multihash algorithm code\n *\n * @example\n * ```typescript\n * import type { Cid } from '@atproto/lex-data'\n * import { parseCid, isCid } from '@atproto/lex-data'\n *\n * // Parse a CID from a string\n * const cid: Cid = parseCid('bafyreib...')\n *\n * // Check if a value is a CID\n * if (isCid(value)) {\n *   console.log(cid.toString())\n * }\n * ```\n *\n * @see {@link isCid} to check if a value is a valid CID\n * @see {@link parseCid} to parse a CID from a string\n * @see {@link decodeCid} to decode a CID from bytes\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport interface Cid<\n  TVersion extends 0 | 1 = 0 | 1,\n  TCodec extends number = number,\n  THashCode extends number = number,\n> {\n  // @NOTE This interface is compatible with multiformats' CID implementation\n  // which we are using under the hood.\n\n  /** CID version (0 or 1). AT Protocol uses CIDv1. */\n  readonly version: TVersion\n  /** Coded (e.g., {@link CBOR_DATA_CODEC}, {@link RAW_DATA_CODEC}). */\n  readonly code: TCodec\n  /** The multihash containing the hash algorithm and digest. */\n  readonly multihash: Multihash<THashCode>\n\n  /**\n   * Binary representation of the whole CID.\n   */\n  readonly bytes: Uint8Array\n\n  /**\n   * Compares this CID with another for equality.\n   *\n   * @param other - The CID to compare with\n   * @returns `true` if the CIDs are equal\n   */\n  equals(other: Cid): boolean\n\n  /**\n   * Returns the string representation of this CID (base32 for v1, base58btc for v0).\n   */\n  toString(): string\n}\n\n/**\n * Represents the CID of raw binary data (like media blobs).\n *\n * The use of {@link SHA256_HASH_CODE} is recommended but not required for raw CIDs.\n *\n * @see {@link https://atproto.com/specs/data-model#link-and-cid-formats AT Protocol Data Model - Link and CID Formats}\n */\nexport type RawCid = Cid<1, RAW_DATA_CODEC>\n\n/**\n * Type guard to check if a CID is a raw binary CID.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is a version 1 CID with raw multicodec\n */\nexport function isRawCid(cid: Cid): cid is RawCid {\n  return cid.version === 1 && cid.code === RAW_DATA_CODEC\n}\n\n/**\n * Represents a DASL compliant CID.\n *\n * DASL CIDs are version 1 CIDs using either raw or DAG-CBOR multicodec\n * with SHA-256 multihash.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport type DaslCid = Cid<1, RAW_DATA_CODEC | CBOR_DATA_CODEC, SHA256_HASH_CODE>\n\n/**\n * Type guard to check if a CID is DASL compliant.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is DASL compliant (v1, raw/dag-cbor, sha256)\n */\nexport function isDaslCid(cid: Cid): cid is DaslCid {\n  return (\n    cid.version === 1 &&\n    (cid.code === RAW_DATA_CODEC || cid.code === CBOR_DATA_CODEC) &&\n    cid.multihash.code === SHA256_HASH_CODE &&\n    cid.multihash.digest.byteLength === 0x20 // Should always be 32 bytes (256 bits) for SHA-256, but double-checking anyways\n  )\n}\n\n/**\n * Represents the CID of AT Protocol DAG-CBOR data (like repository MST nodes).\n *\n * CBOR CIDs are version 1 CIDs using DAG-CBOR multicodec with SHA-256 multihash.\n *\n * @see {@link https://atproto.com/specs/data-model#link-and-cid-formats AT Protocol Data Model - Link and CID Formats}\n */\nexport type CborCid = Cid<1, CBOR_DATA_CODEC, SHA256_HASH_CODE>\n\n/**\n * Type guard to check if a CID is a DAG-CBOR CID.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is a DAG-CBOR CID (v1, dag-cbor, sha256)\n */\nexport function isCborCid(cid: Cid): cid is CborCid {\n  return cid.code === CBOR_DATA_CODEC && isDaslCid(cid)\n}\n\n/**\n * Options for checking CID flavor constraints.\n */\nexport type CheckCidOptions = {\n  /**\n   * The CID flavor to check for.\n   * - `'raw'` - Raw binary CID ({@link RawCid})\n   * - `'cbor'` - DAG-CBOR CID ({@link CborCid})\n   * - `'dasl'` - DASL compliant CID ({@link DaslCid})\n   */\n  flavor?: 'raw' | 'cbor' | 'dasl'\n}\n\n/**\n * Infers the CID type based on check options.\n *\n * @typeParam TOptions - The options used for checking\n */\nexport type InferCheckedCid<TOptions extends CheckCidOptions> =\n  TOptions extends { flavor: 'raw' }\n    ? RawCid\n    : TOptions extends { flavor: 'cbor' }\n      ? CborCid\n      : Cid\n\n/**\n * Type guard to check whether a {@link Cid} instance meets specific flavor\n * constraints.\n */\nexport function checkCid<TOptions extends CheckCidOptions>(\n  cid: Cid,\n  options: TOptions,\n): cid is InferCheckedCid<TOptions>\nexport function checkCid(cid: Cid, options?: CheckCidOptions): boolean\nexport function checkCid(cid: Cid, options?: CheckCidOptions): boolean {\n  switch (options?.flavor) {\n    case undefined:\n      return true\n    case 'cbor':\n      return isCborCid(cid)\n    case 'dasl':\n      return isDaslCid(cid)\n    case 'raw':\n      return isRawCid(cid)\n    default:\n      throw new TypeError(`Unknown CID flavor: ${options?.flavor}`)\n  }\n}\n\n/**\n * Type guard to check whether a value is a valid {@link Cid} instance,\n * optionally checking for specific flavor constraints.\n */\nexport function isCid<TOptions extends CheckCidOptions>(\n  value: unknown,\n  options: TOptions,\n): value is InferCheckedCid<TOptions>\nexport function isCid(value: unknown, options?: CheckCidOptions): value is Cid\nexport function isCid(value: unknown, options?: CheckCidOptions): value is Cid {\n  return isCidImplementation(value) && checkCid(value, options)\n}\n\n/**\n * Returns the input value as a {@link Cid} if it is valid, or `null` otherwise.\n */\nexport function ifCid<TValue, TOptions extends CheckCidOptions>(\n  value: unknown,\n  options: TOptions,\n): (TValue & InferCheckedCid<TOptions>) | null\nexport function ifCid<TValue>(\n  value: TValue,\n  options?: CheckCidOptions,\n): (TValue & Cid) | null\nexport function ifCid(value: unknown, options?: CheckCidOptions): Cid | null {\n  if (isCid(value, options)) return value\n  return null\n}\n\n/**\n * Returns the input value as a {@link Cid} if it is valid.\n *\n * @throws if the input is not a valid {@link Cid}.\n */\nexport function asCid<TValue, TOptions extends CheckCidOptions>(\n  value: TValue,\n  options: TOptions,\n): TValue & InferCheckedCid<TOptions>\nexport function asCid<TValue>(\n  value: TValue,\n  options?: CheckCidOptions,\n): TValue & Cid\nexport function asCid(value: unknown, options?: CheckCidOptions): Cid {\n  if (isCid(value, options)) return value\n  throw new Error(\n    `Invalid ${options?.flavor ? `${options.flavor} CID` : 'CID'} \"${value}\"`,\n  )\n}\n\n/**\n * Decodes a CID from its binary representation.\n *\n * @see {@link https://dasl.ing/cid.html DASL-CIDs}\n * @throws if the input do not represent a valid DASL {@link Cid}\n */\nexport function decodeCid<TOptions extends CheckCidOptions>(\n  cidBytes: Uint8Array,\n  options: TOptions,\n): InferCheckedCid<TOptions>\nexport function decodeCid(cidBytes: Uint8Array, options?: CheckCidOptions): Cid\nexport function decodeCid(\n  cidBytes: Uint8Array,\n  options?: CheckCidOptions,\n): Cid {\n  const cid = CID.decode(cidBytes)\n  return asCid(cid, options)\n}\n\n/**\n * Parses a CID string into a Cid object.\n *\n * @throws if the input is not a valid CID string.\n */\nexport function parseCid<TOptions extends CheckCidOptions>(\n  input: string,\n  options: TOptions,\n): InferCheckedCid<TOptions>\nexport function parseCid(input: string, options?: CheckCidOptions): Cid\nexport function parseCid(input: string, options?: CheckCidOptions): Cid {\n  const cid = CID.parse(input)\n  return asCid(cid, options)\n}\n\n/**\n * Validates that a string is a valid CID representation.\n *\n * Unlike {@link parseCid}, this function returns a boolean instead of throwing.\n * It also verifies that the string is the canonical representation of the CID.\n *\n * @param input - The string to validate\n * @param options - Optional flavor constraints\n * @returns `true` if the string is a valid CID\n */\nexport function validateCidString(\n  input: string,\n  options?: CheckCidOptions,\n): boolean {\n  return parseCidSafe(input, options)?.toString() === input\n}\n\n/**\n * Safely parses a CID string, returning `null` on failure instead of throwing.\n *\n * @param input - The string to parse\n * @param options - Optional flavor constraints\n * @returns The parsed CID, or `null` if parsing fails\n *\n * @example\n * ```typescript\n * import { parseCidSafe } from '@atproto/lex-data'\n *\n * const cid = parseCidSafe('bafyreib...')\n * if (cid) {\n *   console.log(cid.toString())\n * }\n * ```\n */\nexport function parseCidSafe<TOptions extends CheckCidOptions>(\n  input: string,\n  options: TOptions,\n): InferCheckedCid<TOptions> | null\nexport function parseCidSafe(\n  input: string,\n  options?: CheckCidOptions,\n): Cid | null\nexport function parseCidSafe(\n  input: string,\n  options?: CheckCidOptions,\n): Cid | null {\n  try {\n    return parseCid(input, options)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Ensures that a string is a valid CID representation.\n *\n * @param input - The string to validate\n * @param options - Optional flavor constraints\n * @throws If the string is not a valid CID\n */\nexport function ensureValidCidString(\n  input: string,\n  options?: CheckCidOptions,\n): void {\n  if (!validateCidString(input, options)) {\n    throw new Error(`Invalid CID string \"${input}\"`)\n  }\n}\n\n/**\n * Verifies whether the multihash of a given {@link cid} matches the hash of the provided {@link bytes}.\n * @params cid The CID to match against the bytes.\n * @params bytes The bytes to verify.\n * @returns true if the CID matches the bytes, false otherwise.\n */\nexport async function isCidForBytes(\n  cid: Cid,\n  bytes: Uint8Array,\n): Promise<boolean> {\n  if (cid.multihash.code === sha256.code) {\n    const multihash = await sha256.digest(bytes)\n    return multihashEquals(multihash, cid.multihash)\n  }\n\n  if (cid.multihash.code === sha512.code) {\n    const multihash = await sha512.digest(bytes)\n    return multihashEquals(multihash, cid.multihash)\n  }\n\n  // Don't know how to verify other multihash codes\n  throw new Error(\n    `Unsupported CID multihash code: ${toHexString(cid.multihash.code)}`,\n  )\n}\n\n/**\n * Creates a CID from a multicodec, multihash code, and digest.\n *\n * @param code - The multicodec content type code\n * @param multihashCode - The multihash algorithm code\n * @param digest - The raw hash digest bytes\n * @returns A new CIDv1 instance\n *\n * @example\n * ```typescript\n * import { createCid, RAW_DATA_CODEC, SHA256_HASH_CODE } from '@atproto/lex-data'\n *\n * const cid = createCid(RAW_DATA_CODEC, SHA256_HASH_CODE, hashDigest)\n * ```\n */\nexport function createCid<TCodec extends number, THashCode extends number>(\n  code: TCodec,\n  multihashCode: THashCode,\n  digest: Uint8Array,\n) {\n  const cid: Cid = CID.createV1(code, createDigest(multihashCode, digest))\n  return cid as Cid<1, TCodec, THashCode>\n}\n\n/**\n * Creates a DAG-CBOR CID for the given CBOR bytes.\n *\n * Computes the SHA-256 hash of the bytes and creates a CIDv1 with DAG-CBOR multicodec.\n *\n * @param bytes - The CBOR-encoded bytes to hash\n * @returns A promise that resolves to the CborCid\n */\nexport async function cidForCbor(bytes: Uint8Array): Promise<CborCid> {\n  const multihash = await sha256.digest(bytes)\n  return CID.createV1(CBOR_DATA_CODEC, multihash) as CborCid\n}\n\n/**\n * Creates a raw CID for the given binary bytes.\n *\n * Computes the SHA-256 hash of the bytes and creates a CIDv1 with raw multicodec.\n *\n * @param bytes - The raw binary bytes to hash\n * @returns A promise that resolves to the RawCid\n */\nexport async function cidForRawBytes(bytes: Uint8Array): Promise<RawCid> {\n  const multihash = await sha256.digest(bytes)\n  return CID.createV1(RAW_DATA_CODEC, multihash) as RawCid\n}\n\n/**\n * Creates a raw CID from an existing SHA-256 hash digest.\n *\n * @param digest - The SHA-256 hash digest (must be 32 bytes)\n * @returns A RawCid with the given digest\n * @throws If the digest is not a valid SHA-256 hash (not 32 bytes)\n */\nexport function cidForRawHash(digest: Uint8Array): RawCid {\n  // Fool-proofing\n  if (digest.length !== 0x20) {\n    throw new Error(\n      `Invalid SHA-256 hash length: ${toHexString(digest.length)}`,\n    )\n  }\n  return createCid(RAW_DATA_CODEC, sha256.code, digest)\n}\n\nfunction isCidImplementation(value: unknown): value is Cid {\n  if (CID.asCID(value)) {\n    // CIDs created using older multiformats versions did not have a \"bytes\"\n    // property.\n    return (value as { bytes?: Uint8Array }).bytes != null\n  } else {\n    // Unknown implementation, do a structural check\n    try {\n      if (!isObject(value)) return false\n\n      const val = value as Record<string, unknown>\n      if (val.version !== 0 && val.version !== 1) return false\n      if (!isUint8(val.code)) return false\n\n      if (!isObject(val.multihash)) return false\n      const mh = val.multihash as Record<string, unknown>\n      if (!isUint8(mh.code)) return false\n      if (!(mh.digest instanceof Uint8Array)) return false\n\n      // Ensure that the bytes array is consistent with other properties\n      if (!(val.bytes instanceof Uint8Array)) return false\n      if (val.bytes[0] !== val.version) return false\n      if (val.bytes[1] !== val.code) return false\n      if (val.bytes[2] !== mh.code) return false\n      if (val.bytes[3] !== mh.digest.length) return false\n      if (val.bytes.length !== 4 + mh.digest.length) return false\n      if (!ui8Equals(val.bytes.subarray(4), mh.digest)) return false\n\n      if (typeof val.equals !== 'function') return false\n      if (val.equals(val) !== true) return false\n\n      return true\n    } catch {\n      return false\n    }\n  }\n}\n"]}
+{"version":3,"file":"cid.js","sourceRoot":"","sources":["../src/cid.ts"],"names":[],"mappings":"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","sourcesContent":["import { CID } from 'multiformats/cid'\nimport { create as createDigest } from 'multiformats/hashes/digest'\nimport { sha256, sha512 } from 'multiformats/hashes/sha2'\nimport { isUint8, toHexString } from './lib/util.js'\nimport { isObject } from './object.js'\nimport { ui8Equals } from './uint8array.js'\n\n/**\n * Codec code that indicates the CID references a CBOR-encoded data structure.\n *\n * Used when encoding structured data in AT Protocol repositories.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport const CBOR_DATA_CODEC = 0x71\nexport type CBOR_DATA_CODEC = typeof CBOR_DATA_CODEC\n\n/**\n * Codec code that indicates the CID references raw binary data (like media blobs).\n *\n * Used in DASL CIDs for binary blobs like images and media.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport const RAW_DATA_CODEC = 0x55\nexport type RAW_DATA_CODEC = typeof RAW_DATA_CODEC\n\n/**\n * Hash code that indicates that a CID uses SHA-256.\n */\nexport const SHA256_HASH_CODE = sha256.code\nexport type SHA256_HASH_CODE = typeof SHA256_HASH_CODE\n\n/**\n * Hash code that indicates that a CID uses SHA-512.\n */\nexport const SHA512_HASH_CODE = sha512.code\nexport type SHA512_HASH_CODE = typeof SHA512_HASH_CODE\n\n/**\n * Represent the hash part of a CID, which includes the hash algorithm code and\n * the raw digest bytes.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport interface Multihash<THashCode extends number = number> {\n  /**\n   * Code of the hash algorithm (e.g., SHA256_HASH_CODE).\n   */\n  code: THashCode\n\n  /**\n   * Raw digest bytes.\n   */\n  digest: Uint8Array\n}\n\n/**\n * Compares two {@link Multihash} for equality.\n *\n * @param a - First {@link Multihash}\n * @param b - Second {@link Multihash}\n * @returns `true` if both multihashes have the same code and digest\n */\nexport function multihashEquals(a: Multihash, b: Multihash): boolean {\n  if (a === b) return true\n  return a.code === b.code && ui8Equals(a.digest, b.digest)\n}\n\ndeclare module 'multiformats/cid' {\n  /**\n   * @deprecated use the {@link Cid} interface from `@atproto/lex-data`, and\n   * related helpers ({@link isCid}, {@link ifCid}, {@link asCid},\n   * {@link parseCid}, {@link decodeCid}), instead.\n   *\n   * This is marked as deprecated because we want to discourage direct usage of\n   * `multiformats/cid` in dependent packages, and instead have them rely on the\n   * {@link Cid} interface from `@atproto/lex-data`. The {@link CID} class from\n   * `multiformats` version <10 has compatibility issues with certain TypeScript\n   * configuration, which can lead to type errors in dependent packages.\n   *\n   * We are stuck with version 9 because `@atproto` packages did not drop\n   * CommonJS support yet, and multiformats version 10 only supports ES modules.\n   *\n   * In order to avoid compatibility issues, while preparing for future breaking\n   * changes (CID in multiformats v10+ has a slightly different interface), as\n   * we update or swap out `multiformats`, `@atproto/lex-data` provides its own\n   * stable {@link Cid} interface.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface CID {}\n}\n\n// multiformats' CID class is not very portable because:\n//\n// - In dependent packages that use \"moduleResolution\" set to \"node16\",\n//   \"nodenext\" or \"bundler\", TypeScript fails to properly resolve the\n//   multiformats package when importing CID from @atproto/lex-data. This causes\n//   type errors in those packages. This is caused by the fact that the\n//   multiformats version <10 (which is the last version that supports CommonJS)\n//   uses \"exports\" field in package.json, which do not contain \"types\"\n//   entrypoints.\n//   https://www.npmjs.com/package/multiformats/v/9.9.0?activeTab=code\n// - By defining our own interface and helper functions, we can have more\n//   control over the public API exposed by this package.\n// - It allow us to have a stable interface in case we need to swap out, or\n//   eventually update multiformats (should we choose to drop CommonJS support)\n//   in the future.\n\n// @NOTE Even though it is not portable, we still re-export CID here so that\n// dependent packages where it can be used, have access to it (instead of\n// importing directly from \"multiformats\" or \"multiformats/cid\").\nexport { /** @deprecated */ CID }\n\n/**\n * Converts a {@link Cid} to a multiformats {@link CID} instance.\n *\n * @deprecated Packages depending on `@atproto/lex-data` should use the\n * {@link Cid} interface instead of relying on `multiformats`'s {@link CID}\n * implementation directly. This is to avoid compatibility issues, and in order\n * to allow better portability, compatibility and future updates.\n */\nexport function asMultiformatsCID<\n  TVersion extends 0 | 1 = 0 | 1,\n  TCodec extends number = number,\n  THashCode extends number = number,\n>(input: Cid<TVersion, TCodec, THashCode>) {\n  const cid =\n    // Already a multiformats CID instance\n    CID.asCID(input) ??\n    // Create a new multiformats CID instance\n    CID.create(\n      input.version,\n      input.code,\n      createDigest(input.multihash.code, input.multihash.digest),\n    )\n\n  // @NOTE: the \"satisfies\" operator is used here to ensure that the Cid\n  // interface is indeed compatible with multiformats' CID implementation, which\n  // allows us to safely rely on multiformats' CID implementation where Cid are\n  // needed.\n  return cid satisfies Cid as CID & Cid<TVersion, TCodec, THashCode>\n}\n\n/**\n * Content Identifier (CID) for addressing content by its hash.\n *\n * CIDs are self-describing content addresses used throughout AT Protocol for\n * linking to data by its cryptographic hash. This interface provides a\n * stable API that is compatible with the `multiformats` library but avoids\n * direct dependency issues.\n *\n * @typeParam TVersion - CID version (0 or 1)\n * @typeParam TCodec - Multicodec content type code\n * @typeParam THashCode - Multihash algorithm code\n *\n * @example\n * ```typescript\n * import type { Cid } from '@atproto/lex-data'\n * import { parseCid, isCid } from '@atproto/lex-data'\n *\n * // Parse a CID from a string\n * const cid: Cid = parseCid('bafyreib...')\n *\n * // Check if a value is a CID\n * if (isCid(value)) {\n *   console.log(cid.toString())\n * }\n * ```\n *\n * @see {@link isCid} to check if a value is a valid CID\n * @see {@link parseCid} to parse a CID from a string\n * @see {@link decodeCid} to decode a CID from bytes\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport interface Cid<\n  TVersion extends 0 | 1 = 0 | 1,\n  TCodec extends number = number,\n  THashCode extends number = number,\n> {\n  // @NOTE This interface is compatible with multiformats' CID implementation\n  // which we are using under the hood.\n\n  /** CID version (0 or 1). AT Protocol uses CIDv1. */\n  readonly version: TVersion\n  /** Coded (e.g., {@link CBOR_DATA_CODEC}, {@link RAW_DATA_CODEC}). */\n  readonly code: TCodec\n  /** The multihash containing the hash algorithm and digest. */\n  readonly multihash: Multihash<THashCode>\n\n  /**\n   * Binary representation of the whole CID.\n   */\n  readonly bytes: Uint8Array\n\n  /**\n   * Compares this CID with another for equality.\n   *\n   * @param other - The CID to compare with\n   * @returns `true` if the CIDs are equal\n   */\n  equals(other: Cid): boolean\n\n  /**\n   * Returns the string representation of this CID (base32 for v1, base58btc for v0).\n   */\n  toString(): string\n}\n\n/**\n * Represents the CID of raw binary data (like media blobs).\n *\n * The use of {@link SHA256_HASH_CODE} is recommended but not required for raw CIDs.\n *\n * @see {@link https://atproto.com/specs/data-model#link-and-cid-formats AT Protocol Data Model - Link and CID Formats}\n */\nexport type RawCid = Cid<1, RAW_DATA_CODEC>\n\n/**\n * Type guard to check if a CID is a raw binary CID.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is a version 1 CID with raw multicodec\n */\nexport function isRawCid(cid: Cid): cid is RawCid {\n  return cid.version === 1 && cid.code === RAW_DATA_CODEC\n}\n\n/**\n * Represents a DASL compliant CID.\n *\n * DASL CIDs are version 1 CIDs using either raw or DAG-CBOR multicodec\n * with SHA-256 multihash.\n *\n * @see {@link https://dasl.ing/cid.html Content IDs (DASL)}\n */\nexport type DaslCid = Cid<1, RAW_DATA_CODEC | CBOR_DATA_CODEC, SHA256_HASH_CODE>\n\n/**\n * Type guard to check if a CID is DASL compliant.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is DASL compliant (v1, raw/dag-cbor, sha256)\n */\nexport function isDaslCid(cid: Cid): cid is DaslCid {\n  return (\n    cid.version === 1 &&\n    (cid.code === RAW_DATA_CODEC || cid.code === CBOR_DATA_CODEC) &&\n    cid.multihash.code === SHA256_HASH_CODE &&\n    cid.multihash.digest.byteLength === 0x20 // Should always be 32 bytes (256 bits) for SHA-256, but double-checking anyways\n  )\n}\n\n/**\n * Represents the CID of AT Protocol DAG-CBOR data (like repository MST nodes).\n *\n * CBOR CIDs are version 1 CIDs using DAG-CBOR multicodec with SHA-256 multihash.\n *\n * @see {@link https://atproto.com/specs/data-model#link-and-cid-formats AT Protocol Data Model - Link and CID Formats}\n */\nexport type CborCid = Cid<1, CBOR_DATA_CODEC, SHA256_HASH_CODE>\n\n/**\n * Type guard to check if a CID is a DAG-CBOR CID.\n *\n * @param cid - The CID to check\n * @returns `true` if the CID is a DAG-CBOR CID (v1, dag-cbor, sha256)\n */\nexport function isCborCid(cid: Cid): cid is CborCid {\n  return cid.code === CBOR_DATA_CODEC && isDaslCid(cid)\n}\n\n/**\n * Options for checking CID flavor constraints.\n */\nexport type CheckCidOptions = {\n  /**\n   * The CID flavor to check for.\n   * - `'raw'` - Raw binary CID ({@link RawCid})\n   * - `'cbor'` - DAG-CBOR CID ({@link CborCid})\n   * - `'dasl'` - DASL compliant CID ({@link DaslCid})\n   */\n  flavor?: 'raw' | 'cbor' | 'dasl'\n}\n\n/**\n * Infers the CID type based on check options.\n *\n * @typeParam TOptions - The options used for checking\n */\nexport type InferCheckedCid<TOptions extends CheckCidOptions> =\n  TOptions extends { flavor: 'raw' }\n    ? RawCid\n    : TOptions extends { flavor: 'cbor' }\n      ? CborCid\n      : Cid\n\n/**\n * Type guard to check whether a {@link Cid} instance meets specific flavor\n * constraints.\n */\nexport function checkCid<TOptions extends CheckCidOptions>(\n  cid: Cid,\n  options: TOptions,\n): cid is InferCheckedCid<TOptions>\nexport function checkCid(cid: Cid, options?: CheckCidOptions): boolean\nexport function checkCid(cid: Cid, options?: CheckCidOptions): boolean {\n  switch (options?.flavor) {\n    case undefined:\n      return true\n    case 'cbor':\n      return isCborCid(cid)\n    case 'dasl':\n      return isDaslCid(cid)\n    case 'raw':\n      return isRawCid(cid)\n    default:\n      throw new TypeError(`Unknown CID flavor: ${options?.flavor}`)\n  }\n}\n\n/**\n * Type guard to check whether a value is a valid {@link Cid} instance,\n * optionally checking for specific flavor constraints.\n */\nexport function isCid<TOptions extends CheckCidOptions>(\n  value: unknown,\n  options: TOptions,\n): value is InferCheckedCid<TOptions>\nexport function isCid(value: unknown, options?: CheckCidOptions): value is Cid\nexport function isCid(value: unknown, options?: CheckCidOptions): value is Cid {\n  return isCidImplementation(value) && checkCid(value, options)\n}\n\n/**\n * Returns the input value as a {@link Cid} if it is valid, or `null` otherwise.\n */\nexport function ifCid<TValue, TOptions extends CheckCidOptions>(\n  value: unknown,\n  options: TOptions,\n): (TValue & InferCheckedCid<TOptions>) | null\nexport function ifCid<TValue>(\n  value: TValue,\n  options?: CheckCidOptions,\n): (TValue & Cid) | null\nexport function ifCid(value: unknown, options?: CheckCidOptions): Cid | null {\n  if (isCid(value, options)) return value\n  return null\n}\n\n/**\n * Returns the input value as a {@link Cid} if it is valid.\n *\n * @throws if the input is not a valid {@link Cid}.\n */\nexport function asCid<TValue, TOptions extends CheckCidOptions>(\n  value: TValue,\n  options: TOptions,\n): TValue & InferCheckedCid<TOptions>\nexport function asCid<TValue>(\n  value: TValue,\n  options?: CheckCidOptions,\n): TValue & Cid\nexport function asCid(value: unknown, options?: CheckCidOptions): Cid {\n  if (isCid(value, options)) return value\n  throw new Error(\n    `Invalid ${options?.flavor ? `${options.flavor} CID` : 'CID'} \"${value}\"`,\n  )\n}\n\n/**\n * Decodes a CID from its binary representation.\n *\n * @see {@link https://dasl.ing/cid.html DASL-CIDs}\n * @throws if the input do not represent a valid DASL {@link Cid}\n */\nexport function decodeCid<TOptions extends CheckCidOptions>(\n  cidBytes: Uint8Array,\n  options: TOptions,\n): InferCheckedCid<TOptions>\nexport function decodeCid(cidBytes: Uint8Array, options?: CheckCidOptions): Cid\nexport function decodeCid(\n  cidBytes: Uint8Array,\n  options?: CheckCidOptions,\n): Cid {\n  const cid = CID.decode(cidBytes)\n  return asCid(cid, options)\n}\n\n/**\n * Parses a CID string into a Cid object.\n *\n * @throws if the input is not a valid CID string.\n */\nexport function parseCid<TOptions extends CheckCidOptions>(\n  input: string,\n  options: TOptions,\n): InferCheckedCid<TOptions>\nexport function parseCid(input: string, options?: CheckCidOptions): Cid\nexport function parseCid(input: string, options?: CheckCidOptions): Cid {\n  const cid = CID.parse(input)\n  return asCid(cid, options)\n}\n\n/**\n * Validates that a string is a valid CID representation.\n *\n * Unlike {@link parseCid}, this function returns a boolean instead of throwing.\n * It also verifies that the string is the canonical representation of the CID.\n *\n * @param input - The string to validate\n * @param options - Optional flavor constraints\n * @returns `true` if the string is a valid CID\n */\nexport function validateCidString(\n  input: string,\n  options?: CheckCidOptions,\n): boolean {\n  return parseCidSafe(input, options)?.toString() === input\n}\n\n/**\n * Safely parses a CID string, returning `null` on failure instead of throwing.\n *\n * @param input - The string to parse\n * @param options - Optional flavor constraints\n * @returns The parsed CID, or `null` if parsing fails\n *\n * @example\n * ```typescript\n * import { parseCidSafe } from '@atproto/lex-data'\n *\n * const cid = parseCidSafe('bafyreib...')\n * if (cid) {\n *   console.log(cid.toString())\n * }\n * ```\n */\nexport function parseCidSafe<TOptions extends CheckCidOptions>(\n  input: string,\n  options: TOptions,\n): InferCheckedCid<TOptions> | null\nexport function parseCidSafe(\n  input: string,\n  options?: CheckCidOptions,\n): Cid | null\nexport function parseCidSafe(\n  input: string,\n  options?: CheckCidOptions,\n): Cid | null {\n  try {\n    return parseCid(input, options)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Ensures that a string is a valid CID representation.\n *\n * @param input - The string to validate\n * @param options - Optional flavor constraints\n * @throws If the string is not a valid CID\n */\nexport function ensureValidCidString(\n  input: string,\n  options?: CheckCidOptions,\n): void {\n  if (!validateCidString(input, options)) {\n    throw new Error(`Invalid CID string \"${input}\"`)\n  }\n}\n\n/**\n * Verifies whether the multihash of a given {@link cid} matches the hash of the provided {@link bytes}.\n * @params cid The CID to match against the bytes.\n * @params bytes The bytes to verify.\n * @returns true if the CID matches the bytes, false otherwise.\n */\nexport async function isCidForBytes(\n  cid: Cid,\n  bytes: Uint8Array,\n): Promise<boolean> {\n  if (cid.multihash.code === sha256.code) {\n    const multihash = await sha256.digest(bytes)\n    return multihashEquals(multihash, cid.multihash)\n  }\n\n  if (cid.multihash.code === sha512.code) {\n    const multihash = await sha512.digest(bytes)\n    return multihashEquals(multihash, cid.multihash)\n  }\n\n  // Don't know how to verify other multihash codes\n  throw new Error(\n    `Unsupported CID multihash code: ${toHexString(cid.multihash.code)}`,\n  )\n}\n\n/**\n * Creates a CID from a multicodec, multihash code, and digest.\n *\n * @param code - The multicodec content type code\n * @param multihashCode - The multihash algorithm code\n * @param digest - The raw hash digest bytes\n * @returns A new CIDv1 instance\n *\n * @example\n * ```typescript\n * import { createCid, RAW_DATA_CODEC, SHA256_HASH_CODE } from '@atproto/lex-data'\n *\n * const cid = createCid(RAW_DATA_CODEC, SHA256_HASH_CODE, hashDigest)\n * ```\n */\nexport function createCid<TCodec extends number, THashCode extends number>(\n  code: TCodec,\n  multihashCode: THashCode,\n  digest: Uint8Array,\n) {\n  const cid: Cid = CID.createV1(code, createDigest(multihashCode, digest))\n  return cid as Cid<1, TCodec, THashCode>\n}\n\n/**\n * Creates a DAG-CBOR CID for the given CBOR bytes.\n *\n * Computes the SHA-256 hash of the bytes and creates a CIDv1 with DAG-CBOR multicodec.\n *\n * @param bytes - The CBOR-encoded bytes to hash\n * @returns A promise that resolves to the CborCid\n */\nexport async function cidForCbor(bytes: Uint8Array): Promise<CborCid> {\n  const multihash = await sha256.digest(bytes)\n  return CID.createV1(CBOR_DATA_CODEC, multihash) as CborCid\n}\n\n/**\n * Creates a raw CID for the given binary bytes.\n *\n * Computes the SHA-256 hash of the bytes and creates a CIDv1 with raw multicodec.\n *\n * @param bytes - The raw binary bytes to hash\n * @returns A promise that resolves to the RawCid\n */\nexport async function cidForRawBytes(bytes: Uint8Array): Promise<RawCid> {\n  const multihash = await sha256.digest(bytes)\n  return CID.createV1(RAW_DATA_CODEC, multihash) as RawCid\n}\n\n/**\n * Creates a raw CID from an existing SHA-256 hash digest.\n *\n * @param digest - The SHA-256 hash digest (must be 32 bytes)\n * @returns A RawCid with the given digest\n * @throws If the digest is not a valid SHA-256 hash (not 32 bytes)\n */\nexport function cidForRawHash(digest: Uint8Array): RawCid {\n  // Fool-proofing\n  if (digest.length !== 0x20) {\n    throw new Error(\n      `Invalid SHA-256 hash length: ${toHexString(digest.length)}`,\n    )\n  }\n  return createCid(RAW_DATA_CODEC, sha256.code, digest)\n}\n\nfunction isCidImplementation(value: unknown): value is Cid {\n  if (CID.asCID(value)) {\n    // CIDs created using older multiformats versions did not have a \"bytes\"\n    // property.\n    return (value as { bytes?: Uint8Array }).bytes != null\n  } else {\n    // Unknown implementation, do a structural check\n    try {\n      if (!isObject(value)) return false\n\n      const val = value as Record<string, unknown>\n      if (val.version !== 0 && val.version !== 1) return false\n      if (!isUint8(val.code)) return false\n\n      if (!isObject(val.multihash)) return false\n      const mh = val.multihash as Record<string, unknown>\n      if (!isUint8(mh.code)) return false\n      if (!(mh.digest instanceof Uint8Array)) return false\n\n      // Ensure that the bytes array is consistent with other properties\n      if (!(val.bytes instanceof Uint8Array)) return false\n      if (val.bytes[0] !== val.version) return false\n      if (val.bytes[1] !== val.code) return false\n      if (val.bytes[2] !== mh.code) return false\n      if (val.bytes[3] !== mh.digest.length) return false\n      if (val.bytes.length !== 4 + mh.digest.length) return false\n      if (!ui8Equals(val.bytes.subarray(4), mh.digest)) return false\n\n      if (typeof val.equals !== 'function') return false\n      if (val.equals(val) !== true) return false\n\n      return true\n    } catch {\n      return false\n    }\n  }\n}\n"]}

package/dist/index.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./blob.js"), exports);
-tslib_1.__exportStar(require("./cid.js"), exports);
-tslib_1.__exportStar(require("./lex-equals.js"), exports);
-tslib_1.__exportStar(require("./lex-error.js"), exports);
-tslib_1.__exportStar(require("./lex.js"), exports);
-tslib_1.__exportStar(require("./object.js"), exports);
-tslib_1.__exportStar(require("./uint8array.js"), exports);
-tslib_1.__exportStar(require("./utf8.js"), exports);
+export * from './blob.js';
+export * from './cid.js';
+export * from './lex-equals.js';
+export * from './lex-error.js';
+export * from './lex.js';
+export * from './object.js';
+export * from './uint8array.js';
+export * from './utf8.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,mDAAwB;AACxB,0DAA+B;AAC/B,yDAA8B;AAC9B,mDAAwB;AACxB,sDAA2B;AAC3B,0DAA+B;AAC/B,oDAAyB","sourcesContent":["export * from './blob.js'\nexport * from './cid.js'\nexport * from './lex-equals.js'\nexport * from './lex-error.js'\nexport * from './lex.js'\nexport * from './object.js'\nexport * from './uint8array.js'\nexport * from './utf8.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA","sourcesContent":["export * from './blob.js'\nexport * from './cid.js'\nexport * from './lex-equals.js'\nexport * from './lex-error.js'\nexport * from './lex.js'\nexport * from './object.js'\nexport * from './uint8array.js'\nexport * from './utf8.js'\n"]}

package/dist/lex-equals.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lexEquals = lexEquals;
-const cid_js_1 = require("./cid.js");
-const object_js_1 = require("./object.js");
-const uint8array_js_1 = require("./uint8array.js");
+import { ifCid, isCid } from './cid.js';
+import { isPlainObject } from './object.js';
+import { ui8Equals } from './uint8array.js';
 /**
  * Performs deep equality comparison between two {@link LexValue}s.
  *
@@ -42,7 +39,7 @@ const uint8array_js_1 = require("./uint8array.js");
  * lexEquals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true
  * ```
  */
-function lexEquals(a, b) {
+export function lexEquals(a, b) {
     if (Object.is(a, b)) {
         return true;
     }
@@ -72,20 +69,20 @@ function lexEquals(a, b) {
     if (ArrayBuffer.isView(a)) {
         if (!ArrayBuffer.isView(b))
             return false;
-        return (0, uint8array_js_1.ui8Equals)(a, b);
+        return ui8Equals(a, b);
     }
     else if (ArrayBuffer.isView(b)) {
         return false;
     }
-    if ((0, cid_js_1.isCid)(a)) {
+    if (isCid(a)) {
         // @NOTE CID.equals returns its argument when it is falsy (e.g. null or
         // undefined) so we need to explicitly check that the output is "true".
-        return (0, cid_js_1.ifCid)(b)?.equals(a) === true;
+        return ifCid(b)?.equals(a) === true;
     }
-    else if ((0, cid_js_1.isCid)(b)) {
+    else if (isCid(b)) {
         return false;
     }
-    if (!(0, object_js_1.isPlainObject)(a) || !(0, object_js_1.isPlainObject)(b)) {
+    if (!isPlainObject(a) || !isPlainObject(b)) {
         // Foolproof (should never happen)
         throw new TypeError('Invalid LexValue (expected CID, Uint8Array, or LexMap)');
     }

package/dist/lex-equals.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex-equals.js","sourceRoot":"","sources":["../src/lex-equals.ts"],"names":[],"mappings":"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","sourcesContent":["import { ifCid, isCid } from './cid.js'\nimport { LexValue } from './lex.js'\nimport { isPlainObject } from './object.js'\nimport { ui8Equals } from './uint8array.js'\n\n/**\n * Performs deep equality comparison between two {@link LexValue}s.\n *\n * This function correctly handles all Lexicon data types including:\n * - Primitives (string, number, boolean, null)\n * - Arrays (recursive element comparison)\n * - Objects/LexMaps (recursive key-value comparison)\n * - Uint8Arrays (byte-by-byte comparison)\n * - CIDs (using CID equality)\n *\n * @param a - First LexValue to compare\n * @param b - Second LexValue to compare\n * @returns `true` if the values are deeply equal\n * @throws {TypeError} If either value is not a valid LexValue (e.g., contains unsupported types)\n *\n * @example\n * ```typescript\n * import { lexEquals } from '@atproto/lex-data'\n *\n * // Primitives\n * lexEquals('hello', 'hello')  // true\n * lexEquals(42, 42)            // true\n *\n * // Arrays\n * lexEquals([1, 2, 3], [1, 2, 3])  // true\n * lexEquals([1, 2], [1, 2, 3])     // false\n *\n * // Objects\n * lexEquals({ a: 1, b: 2 }, { a: 1, b: 2 })  // true\n * lexEquals({ a: 1 }, { a: 1, b: 2 })        // false\n *\n * // CIDs\n * lexEquals(cid1, cid2)  // true if CIDs are equal\n *\n * // Uint8Arrays\n * lexEquals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true\n * ```\n */\nexport function lexEquals(a: LexValue, b: LexValue): boolean {\n  if (Object.is(a, b)) {\n    return true\n  }\n\n  if (\n    a == null ||\n    b == null ||\n    typeof a !== 'object' ||\n    typeof b !== 'object'\n  ) {\n    return false\n  }\n\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b)) {\n      return false\n    }\n    if (a.length !== b.length) {\n      return false\n    }\n    for (let i = 0; i < a.length; i++) {\n      if (!lexEquals(a[i], b[i])) {\n        return false\n      }\n    }\n    return true\n  } else if (Array.isArray(b)) {\n    return false\n  }\n\n  if (ArrayBuffer.isView(a)) {\n    if (!ArrayBuffer.isView(b)) return false\n    return ui8Equals(a, b)\n  } else if (ArrayBuffer.isView(b)) {\n    return false\n  }\n\n  if (isCid(a)) {\n    // @NOTE CID.equals returns its argument when it is falsy (e.g. null or\n    // undefined) so we need to explicitly check that the output is \"true\".\n    return ifCid(b)?.equals(a) === true\n  } else if (isCid(b)) {\n    return false\n  }\n\n  if (!isPlainObject(a) || !isPlainObject(b)) {\n    // Foolproof (should never happen)\n    throw new TypeError(\n      'Invalid LexValue (expected CID, Uint8Array, or LexMap)',\n    )\n  }\n\n  const aKeys = Object.keys(a)\n  const bKeys = Object.keys(b)\n\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n\n  for (const key of aKeys) {\n    const aVal = a[key]\n    const bVal = b[key]\n\n    // Needed because of the optional index signature in the Lex object type\n    // though, in practice, aVal should never be undefined here.\n    if (aVal === undefined) {\n      if (bVal === undefined && bKeys.includes(key)) continue\n      return false\n    } else if (bVal === undefined) {\n      return false\n    }\n\n    if (!lexEquals(aVal, bVal)) {\n      return false\n    }\n  }\n\n  return true\n}\n"]}
+{"version":3,"file":"lex-equals.js","sourceRoot":"","sources":["../src/lex-equals.ts"],"names":[],"mappings":"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","sourcesContent":["import { ifCid, isCid } from './cid.js'\nimport { LexValue } from './lex.js'\nimport { isPlainObject } from './object.js'\nimport { ui8Equals } from './uint8array.js'\n\n/**\n * Performs deep equality comparison between two {@link LexValue}s.\n *\n * This function correctly handles all Lexicon data types including:\n * - Primitives (string, number, boolean, null)\n * - Arrays (recursive element comparison)\n * - Objects/LexMaps (recursive key-value comparison)\n * - Uint8Arrays (byte-by-byte comparison)\n * - CIDs (using CID equality)\n *\n * @param a - First LexValue to compare\n * @param b - Second LexValue to compare\n * @returns `true` if the values are deeply equal\n * @throws {TypeError} If either value is not a valid LexValue (e.g., contains unsupported types)\n *\n * @example\n * ```typescript\n * import { lexEquals } from '@atproto/lex-data'\n *\n * // Primitives\n * lexEquals('hello', 'hello')  // true\n * lexEquals(42, 42)            // true\n *\n * // Arrays\n * lexEquals([1, 2, 3], [1, 2, 3])  // true\n * lexEquals([1, 2], [1, 2, 3])     // false\n *\n * // Objects\n * lexEquals({ a: 1, b: 2 }, { a: 1, b: 2 })  // true\n * lexEquals({ a: 1 }, { a: 1, b: 2 })        // false\n *\n * // CIDs\n * lexEquals(cid1, cid2)  // true if CIDs are equal\n *\n * // Uint8Arrays\n * lexEquals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true\n * ```\n */\nexport function lexEquals(a: LexValue, b: LexValue): boolean {\n  if (Object.is(a, b)) {\n    return true\n  }\n\n  if (\n    a == null ||\n    b == null ||\n    typeof a !== 'object' ||\n    typeof b !== 'object'\n  ) {\n    return false\n  }\n\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b)) {\n      return false\n    }\n    if (a.length !== b.length) {\n      return false\n    }\n    for (let i = 0; i < a.length; i++) {\n      if (!lexEquals(a[i], b[i])) {\n        return false\n      }\n    }\n    return true\n  } else if (Array.isArray(b)) {\n    return false\n  }\n\n  if (ArrayBuffer.isView(a)) {\n    if (!ArrayBuffer.isView(b)) return false\n    return ui8Equals(a, b)\n  } else if (ArrayBuffer.isView(b)) {\n    return false\n  }\n\n  if (isCid(a)) {\n    // @NOTE CID.equals returns its argument when it is falsy (e.g. null or\n    // undefined) so we need to explicitly check that the output is \"true\".\n    return ifCid(b)?.equals(a) === true\n  } else if (isCid(b)) {\n    return false\n  }\n\n  if (!isPlainObject(a) || !isPlainObject(b)) {\n    // Foolproof (should never happen)\n    throw new TypeError(\n      'Invalid LexValue (expected CID, Uint8Array, or LexMap)',\n    )\n  }\n\n  const aKeys = Object.keys(a)\n  const bKeys = Object.keys(b)\n\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n\n  for (const key of aKeys) {\n    const aVal = a[key]\n    const bVal = b[key]\n\n    // Needed because of the optional index signature in the Lex object type\n    // though, in practice, aVal should never be undefined here.\n    if (aVal === undefined) {\n      if (bVal === undefined && bKeys.includes(key)) continue\n      return false\n    } else if (bVal === undefined) {\n      return false\n    }\n\n    if (!lexEquals(aVal, bVal)) {\n      return false\n    }\n  }\n\n  return true\n}\n"]}

package/dist/lex-error.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LexError = void 0;
 /**
  * Error class for Lexicon-related errors.
  *
@@ -10,9 +7,7 @@ exports.LexError = void 0;
  *
  * @typeParam N - The specific error code type
  */
-class LexError extends Error {
-    error;
-    name = 'LexError';
+export class LexError extends Error {
     /**
      * @param error - The error code identifying the type of error, typically used in XRPC error payloads
      * @param message - Optional human-readable error message
@@ -22,6 +17,7 @@ class LexError extends Error {
     options) {
         super(message, options);
         this.error = error;
+        this.name = 'LexError';
     }
     /**
      * Returns a string representation of this error.
@@ -42,5 +38,4 @@ class LexError extends Error {
         return { error, message: message || undefined };
     }
 }
-exports.LexError = LexError;
 //# sourceMappingURL=lex-error.js.map

package/dist/lex-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex-error.js","sourceRoot":"","sources":["../src/lex-error.ts"],"names":[],"mappings":";;;AAsCA;;;;;;;;GAQG;AACH,MAAa,QAAgD,SAAQ,KAAK;IAS7D;IARX,IAAI,GAAG,UAAU,CAAA;IAEjB;;;;OAIG;IACH,YACW,KAAQ,EACjB,OAAgB,EAAE,gDAAgD;IAClE,OAAsB;QAEtB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAJd,UAAK,GAAL,KAAK,CAAG;IAKnB,CAAC;IAED;;;;OAIG;IACH,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,CAAA;IACxD,CAAC;IAED;;;;;OAKG;IACH,MAAM;QACJ,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QAC/B,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,CAAA;IACjD,CAAC;CACF;AAnCD,4BAmCC","sourcesContent":["/**\n * Error code type for Lexicon errors.\n *\n * Error codes identify the type of error that occurred (e.g., 'InvalidRequest').\n *\n * @example\n * ```typescript\n * import type { LexErrorCode } from '@atproto/lex-data'\n *\n * const errorCode: LexErrorCode = 'InvalidRequest'\n * ```\n */\nexport type LexErrorCode = string & NonNullable<unknown>\n\n/**\n * JSON-serializable error data structure.\n *\n * This is the standard format for error responses in the AT Protocol XRPC protocol.\n *\n * @typeParam N - The specific error code type\n *\n * @example\n * ```typescript\n * import type { LexErrorData } from '@atproto/lex-data'\n *\n * const errorData: LexErrorData = {\n *   error: 'InvalidRequest',\n *   message: 'Missing required field: handle'\n * }\n * ```\n */\nexport type LexErrorData<N extends LexErrorCode = LexErrorCode> = {\n  /** The error code identifying the type of error. */\n  error: N\n  /** Optional human-readable error message. */\n  message?: string\n}\n\n/**\n * Error class for Lexicon-related errors.\n *\n * LexError extends the standard JavaScript {@link Error} with AT\n * Protocol-specific functionality including an `error` code property and\n * methods for representation as (XRPC) error responses payloads.\n *\n * @typeParam N - The specific error code type\n */\nexport class LexError<N extends LexErrorCode = LexErrorCode> extends Error {\n  name = 'LexError'\n\n  /**\n   * @param error - The error code identifying the type of error, typically used in XRPC error payloads\n   * @param message - Optional human-readable error message\n   * @param options - Standard Error options (e.g., cause)\n   */\n  constructor(\n    readonly error: N,\n    message?: string, // Defaults to empty string in Error constructor\n    options?: ErrorOptions,\n  ) {\n    super(message, options)\n  }\n\n  /**\n   * Returns a string representation of this error.\n   *\n   * @returns A formatted string: \"LexErrorClass: [MyErrorCode] My message\"\n   */\n  toString(): string {\n    return `${this.name}: [${this.error}] ${this.message}`\n  }\n\n  /**\n   * Converts this error to a JSON-serializable object.\n   *\n   * @returns The error data suitable for JSON serialization\n   * @note The `error` generic is *not* constrained to {@link N} to allow subclasses to override the error code type.\n   */\n  toJSON(): LexErrorData<LexErrorCode> {\n    const { error, message } = this\n    return { error, message: message || undefined }\n  }\n}\n"]}
+{"version":3,"file":"lex-error.js","sourceRoot":"","sources":["../src/lex-error.ts"],"names":[],"mappings":"AAsCA;;;;;;;;GAQG;AACH,MAAM,OAAO,QAAgD,SAAQ,KAAK;IAGxE;;;;OAIG;IACH,YACW,KAAQ,EACjB,OAAgB,EAAE,gDAAgD;IAClE,OAAsB;QAEtB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAJd,UAAK,GAAL,KAAK,CAAG;QARnB,SAAI,GAAG,UAAU,CAAA;IAajB,CAAC;IAED;;;;OAIG;IACH,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,CAAA;IACxD,CAAC;IAED;;;;;OAKG;IACH,MAAM;QACJ,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QAC/B,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,CAAA;IACjD,CAAC;CACF","sourcesContent":["/**\n * Error code type for Lexicon errors.\n *\n * Error codes identify the type of error that occurred (e.g., 'InvalidRequest').\n *\n * @example\n * ```typescript\n * import type { LexErrorCode } from '@atproto/lex-data'\n *\n * const errorCode: LexErrorCode = 'InvalidRequest'\n * ```\n */\nexport type LexErrorCode = string & NonNullable<unknown>\n\n/**\n * JSON-serializable error data structure.\n *\n * This is the standard format for error responses in the AT Protocol XRPC protocol.\n *\n * @typeParam N - The specific error code type\n *\n * @example\n * ```typescript\n * import type { LexErrorData } from '@atproto/lex-data'\n *\n * const errorData: LexErrorData = {\n *   error: 'InvalidRequest',\n *   message: 'Missing required field: handle'\n * }\n * ```\n */\nexport type LexErrorData<N extends LexErrorCode = LexErrorCode> = {\n  /** The error code identifying the type of error. */\n  error: N\n  /** Optional human-readable error message. */\n  message?: string\n}\n\n/**\n * Error class for Lexicon-related errors.\n *\n * LexError extends the standard JavaScript {@link Error} with AT\n * Protocol-specific functionality including an `error` code property and\n * methods for representation as (XRPC) error responses payloads.\n *\n * @typeParam N - The specific error code type\n */\nexport class LexError<N extends LexErrorCode = LexErrorCode> extends Error {\n  name = 'LexError'\n\n  /**\n   * @param error - The error code identifying the type of error, typically used in XRPC error payloads\n   * @param message - Optional human-readable error message\n   * @param options - Standard Error options (e.g., cause)\n   */\n  constructor(\n    readonly error: N,\n    message?: string, // Defaults to empty string in Error constructor\n    options?: ErrorOptions,\n  ) {\n    super(message, options)\n  }\n\n  /**\n   * Returns a string representation of this error.\n   *\n   * @returns A formatted string: \"LexErrorClass: [MyErrorCode] My message\"\n   */\n  toString(): string {\n    return `${this.name}: [${this.error}] ${this.message}`\n  }\n\n  /**\n   * Converts this error to a JSON-serializable object.\n   *\n   * @returns The error data suitable for JSON serialization\n   * @note The `error` generic is *not* constrained to {@link N} to allow subclasses to override the error code type.\n   */\n  toJSON(): LexErrorData<LexErrorCode> {\n    const { error, message } = this\n    return { error, message: message || undefined }\n  }\n}\n"]}