@atproto/lex-data 0.0.9 → 0.0.11

package/dist/lex.d.ts

@@ -1,18 +1,200 @@
 import { Cid } from './cid.js';
+/**
+ * Primitive values in the Lexicon data model.
+ *
+ * Represents the basic scalar types that can appear in AT Protocol data:
+ * - `number` - Integer values only (no floats)
+ * - `string` - UTF-8 text
+ * - `boolean` - true or false
+ * - `null` - Explicit null value
+ * - `Cid` - Content Identifier (link by hash)
+ * - `Uint8Array` - Binary data (bytes)
+ *
+ * @see {@link LexValue} for the complete recursive value type
+ */
 export type LexScalar = number | string | boolean | null | Cid | Uint8Array;
+/**
+ * Any valid Lexicon value (recursive type).
+ *
+ * This is the union of all types that can appear in AT Protocol Lexicon data:
+ * - {@link LexScalar} - Primitive values (number, string, boolean, null, Cid, Uint8Array)
+ * - `LexValue[]` - Arrays of LexValues
+ * - `{ [key: string]?: LexValue }` - Objects with string keys and LexValue values
+ *
+ * @example
+ * ```typescript
+ * import type { LexValue } from '@atproto/lex'
+ *
+ * const scalar: LexValue = 'hello'
+ * const array: LexValue = [1, 2, 3]
+ * const object: LexValue = { name: 'Alice', age: 30 }
+ * ```
+ *
+ * @see {@link LexScalar} for primitive value types
+ * @see {@link LexMap} for object types
+ * @see {@link LexArray} for array types
+ */
 export type LexValue = LexScalar | LexValue[] | {
     [_ in string]?: LexValue;
 };
+/**
+ * Object with string keys and LexValue values.
+ *
+ * Represents a plain object in the Lexicon data model where all values
+ * must be valid {@link LexValue} types.
+ *
+ * @example
+ * ```typescript
+ * import type { LexMap } from '@atproto/lex'
+ *
+ * const user: LexMap = {
+ *   name: 'Alice',
+ *   age: 30,
+ *   tags: ['admin', 'user']
+ * }
+ * ```
+ *
+ * @see {@link TypedLexMap} for objects with a required `$type` property
+ */
 export type LexMap = {
     [_ in string]?: LexValue;
 };
+/**
+ * Array of {@link LexValue} elements.
+ *
+ * @example
+ * ```typescript
+ * import type { LexArray } from '@atproto/lex'
+ *
+ * const items: LexArray = [1, 'two', { three: 3 }]
+ * ```
+ */
 export type LexArray = LexValue[];
+/**
+ * Type guard to check if a value is a valid {@link LexMap}.
+ *
+ * Returns true if the value is a plain object where all values are valid
+ * {@link LexValue} types.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexMap
+ *
+ * @example
+ * ```typescript
+ * import { isLexMap } from '@atproto/lex'
+ *
+ * if (isLexMap(data)) {
+ *   // data is narrowed to LexMap
+ *   console.log(Object.keys(data))
+ * }
+ * ```
+ */
 export declare function isLexMap(value: unknown): value is LexMap;
+/**
+ * Type guard to check if a value is a valid {@link LexArray}.
+ *
+ * Returns true if the value is an array where all elements are valid
+ * {@link LexValue} types.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexArray
+ *
+ * @example
+ * ```typescript
+ * import { isLexArray } from '@atproto/lex'
+ *
+ * if (isLexArray(data)) {
+ *   // data is narrowed to LexArray
+ *   data.forEach(item => console.log(item))
+ * }
+ * ```
+ */
 export declare function isLexArray(value: unknown): value is LexArray;
+/**
+ * Type guard to check if a value is a valid {@link LexScalar}.
+ *
+ * Returns true if the value is one of the primitive Lexicon types:
+ * number (integer only), string, boolean, null, Cid, or Uint8Array.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexScalar
+ *
+ * @example
+ * ```typescript
+ * import { isLexScalar } from '@atproto/lex'
+ *
+ * isLexScalar('hello')     // true
+ * isLexScalar(42)          // true
+ * isLexScalar(3.14)        // false (floats not allowed)
+ * isLexScalar([1, 2])      // false (arrays are not scalars)
+ * ```
+ */
 export declare function isLexScalar(value: unknown): value is LexScalar;
+/**
+ * Type guard to check if a value is a valid {@link LexValue}.
+ *
+ * Performs a deep check to validate that the value (and all nested values)
+ * conform to the Lexicon data model. This includes checking for:
+ * - Valid scalar types (number, string, boolean, null, Cid, Uint8Array)
+ * - Arrays containing only valid LexValues
+ * - Plain objects with string keys and valid LexValue values
+ * - No cyclic references (which cannot be serialized to JSON or CBOR)
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexValue
+ *
+ * @example
+ * ```typescript
+ * import { isLexValue } from '@atproto/lex'
+ *
+ * isLexValue({ name: 'Alice', tags: ['admin'] })  // true
+ * isLexValue(new Date())                           // false (not a plain object)
+ * isLexValue({ fn: () => {} })                     // false (functions not allowed)
+ * ```
+ */
 export declare function isLexValue(value: unknown): value is LexValue;
-export type TypedLexMap = LexMap & {
-    $type: string;
+/**
+ * A {@link LexMap} with a required `$type` property.
+ *
+ * Used to represent typed objects in the Lexicon data model, where the
+ * `$type` property identifies the Lexicon schema that defines the object's
+ * structure.
+ *
+ * @example
+ * ```typescript
+ * import type { TypedLexMap } from '@atproto/lex'
+ *
+ * const post: TypedLexMap = {
+ *   $type: 'app.bsky.feed.post',
+ *   text: 'Hello world!',
+ *   createdAt: '2024-01-01T00:00:00Z'
+ * }
+ * ```
+ *
+ * @see {@link isTypedLexMap} to check if a value is a TypedLexMap
+ */
+export type TypedLexMap<T extends string = string> = LexMap & {
+    $type: T;
 };
+/**
+ * Type guard to check if a value is a {@link TypedLexMap}.
+ *
+ * Returns true if the value is a valid {@link LexMap} with a non-empty
+ * `$type` string property.
+ *
+ * @param value - The LexValue to check
+ * @returns `true` if the value is a TypedLexMap
+ *
+ * @example
+ * ```typescript
+ * import { isTypedLexMap } from '@atproto/lex'
+ *
+ * const data = { $type: 'app.bsky.feed.post', text: 'Hello' }
+ *
+ * if (isTypedLexMap(data)) {
+ *   console.log(data.$type)  // 'app.bsky.feed.post'
+ * }
+ * ```
+ */
 export declare function isTypedLexMap(value: LexValue): value is TypedLexMap;
 //# sourceMappingURL=lex.d.ts.map

package/dist/lex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lex.d.ts","sourceRoot":"","sources":["../src/lex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAS,MAAM,UAAU,CAAA;AAGrC,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,GAAG,GAAG,UAAU,CAAA;AAC3E,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,EAAE,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,QAAQ;CAAE,CAAA;AAC5E,MAAM,MAAM,MAAM,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,QAAQ;CAAE,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,QAAQ,EAAE,CAAA;AAEjC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAa9D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CA8C5D;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AACpD,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,IAAI,WAAW,CAInE"}
+{"version":3,"file":"lex.d.ts","sourceRoot":"","sources":["../src/lex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAS,MAAM,UAAU,CAAA;AAGrC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,GAAG,GAAG,UAAU,CAAA;AAE3E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,EAAE,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,QAAQ;CAAE,CAAA;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,MAAM,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,QAAQ;CAAE,CAAA;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,EAAE,CAAA;AAEjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAa9D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CA8C5D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,GAAG;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AAE1E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,IAAI,WAAW,CAInE"}

package/dist/lex.js

@@ -7,12 +7,69 @@ exports.isLexValue = isLexValue;
 exports.isTypedLexMap = isTypedLexMap;
 const cid_js_1 = require("./cid.js");
 const object_js_1 = require("./object.js");
+/**
+ * Type guard to check if a value is a valid {@link LexMap}.
+ *
+ * Returns true if the value is a plain object where all values are valid
+ * {@link LexValue} types.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexMap
+ *
+ * @example
+ * ```typescript
+ * import { isLexMap } from '@atproto/lex'
+ *
+ * if (isLexMap(data)) {
+ *   // data is narrowed to LexMap
+ *   console.log(Object.keys(data))
+ * }
+ * ```
+ */
 function isLexMap(value) {
     return (0, object_js_1.isPlainObject)(value) && Object.values(value).every(isLexValue);
 }
+/**
+ * Type guard to check if a value is a valid {@link LexArray}.
+ *
+ * Returns true if the value is an array where all elements are valid
+ * {@link LexValue} types.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexArray
+ *
+ * @example
+ * ```typescript
+ * import { isLexArray } from '@atproto/lex'
+ *
+ * if (isLexArray(data)) {
+ *   // data is narrowed to LexArray
+ *   data.forEach(item => console.log(item))
+ * }
+ * ```
+ */
 function isLexArray(value) {
     return Array.isArray(value) && value.every(isLexValue);
 }
+/**
+ * Type guard to check if a value is a valid {@link LexScalar}.
+ *
+ * Returns true if the value is one of the primitive Lexicon types:
+ * number (integer only), string, boolean, null, Cid, or Uint8Array.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexScalar
+ *
+ * @example
+ * ```typescript
+ * import { isLexScalar } from '@atproto/lex'
+ *
+ * isLexScalar('hello')     // true
+ * isLexScalar(42)          // true
+ * isLexScalar(3.14)        // false (floats not allowed)
+ * isLexScalar([1, 2])      // false (arrays are not scalars)
+ * ```
+ */
 function isLexScalar(value) {
     switch (typeof value) {
         case 'object':
@@ -28,6 +85,28 @@ function isLexScalar(value) {
             return false;
     }
 }
+/**
+ * Type guard to check if a value is a valid {@link LexValue}.
+ *
+ * Performs a deep check to validate that the value (and all nested values)
+ * conform to the Lexicon data model. This includes checking for:
+ * - Valid scalar types (number, string, boolean, null, Cid, Uint8Array)
+ * - Arrays containing only valid LexValues
+ * - Plain objects with string keys and valid LexValue values
+ * - No cyclic references (which cannot be serialized to JSON or CBOR)
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid LexValue
+ *
+ * @example
+ * ```typescript
+ * import { isLexValue } from '@atproto/lex'
+ *
+ * isLexValue({ name: 'Alice', tags: ['admin'] })  // true
+ * isLexValue(new Date())                           // false (not a plain object)
+ * isLexValue({ fn: () => {} })                     // false (functions not allowed)
+ * ```
+ */
 function isLexValue(value) {
     // Using a stack to avoid recursion depth issues.
     const stack = [value];
@@ -78,6 +157,26 @@ function isLexValue(value) {
     visited.clear();
     return true;
 }
+/**
+ * Type guard to check if a value is a {@link TypedLexMap}.
+ *
+ * Returns true if the value is a valid {@link LexMap} with a non-empty
+ * `$type` string property.
+ *
+ * @param value - The LexValue to check
+ * @returns `true` if the value is a TypedLexMap
+ *
+ * @example
+ * ```typescript
+ * import { isTypedLexMap } from '@atproto/lex'
+ *
+ * const data = { $type: 'app.bsky.feed.post', text: 'Hello' }
+ *
+ * if (isTypedLexMap(data)) {
+ *   console.log(data.$type)  // 'app.bsky.feed.post'
+ * }
+ * ```
+ */
 function isTypedLexMap(value) {
     return (isLexMap(value) && typeof value.$type === 'string' && value.$type.length > 0);
 }

package/dist/lex.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex.js","sourceRoot":"","sources":["../src/lex.ts"],"names":[],"mappings":"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","sourcesContent":["import { Cid, isCid } from './cid.js'\nimport { isPlainObject, isPlainProto } from './object.js'\n\nexport type LexScalar = number | string | boolean | null | Cid | Uint8Array\nexport type LexValue = LexScalar | LexValue[] | { [_ in string]?: LexValue }\nexport type LexMap = { [_ in string]?: LexValue }\nexport type LexArray = LexValue[]\n\nexport function isLexMap(value: unknown): value is LexMap {\n  return isPlainObject(value) && Object.values(value).every(isLexValue)\n}\n\nexport function isLexArray(value: unknown): value is LexArray {\n  return Array.isArray(value) && value.every(isLexValue)\n}\n\nexport function isLexScalar(value: unknown): value is LexScalar {\n  switch (typeof value) {\n    case 'object':\n      return value === null || value instanceof Uint8Array || isCid(value)\n    case 'string':\n    case 'boolean':\n      return true\n    case 'number':\n      if (Number.isInteger(value)) return true\n    // fallthrough\n    default:\n      return false\n  }\n}\n\nexport function isLexValue(value: unknown): value is LexValue {\n  // Using a stack to avoid recursion depth issues.\n  const stack: unknown[] = [value]\n  // Cyclic structures are not valid LexValues as they cannot be serialized to\n  // JSON or CBOR. This also allows us to avoid infinite loops when traversing\n  // the structure.\n  const visited = new Set<object>()\n\n  do {\n    const value = stack.pop()!\n\n    // Optimization: we are not using `isLexScalar` here to avoid extra function\n    // calls, and to avoid computing `typeof value` multiple times.\n    switch (typeof value) {\n      case 'object':\n        if (value === null) {\n          // LexScalar\n        } else if (isPlainProto(value)) {\n          if (visited.has(value)) return false\n          visited.add(value)\n          stack.push(...Object.values(value))\n        } else if (Array.isArray(value)) {\n          if (visited.has(value)) return false\n          visited.add(value)\n          stack.push(...value)\n        } else if (value instanceof Uint8Array || isCid(value)) {\n          // LexScalar\n        } else {\n          return false\n        }\n        break\n      case 'string':\n      case 'boolean':\n        break\n      case 'number':\n        if (Number.isInteger(value)) break\n      // fallthrough\n      default:\n        return false\n    }\n  } while (stack.length > 0)\n\n  // Optimization: ease GC's work\n  visited.clear()\n\n  return true\n}\n\nexport type TypedLexMap = LexMap & { $type: string }\nexport function isTypedLexMap(value: LexValue): value is TypedLexMap {\n  return (\n    isLexMap(value) && typeof value.$type === 'string' && value.$type.length > 0\n  )\n}\n"]}
+{"version":3,"file":"lex.js","sourceRoot":"","sources":["../src/lex.ts"],"names":[],"mappings":"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","sourcesContent":["import { Cid, isCid } from './cid.js'\nimport { isPlainObject, isPlainProto } from './object.js'\n\n/**\n * Primitive values in the Lexicon data model.\n *\n * Represents the basic scalar types that can appear in AT Protocol data:\n * - `number` - Integer values only (no floats)\n * - `string` - UTF-8 text\n * - `boolean` - true or false\n * - `null` - Explicit null value\n * - `Cid` - Content Identifier (link by hash)\n * - `Uint8Array` - Binary data (bytes)\n *\n * @see {@link LexValue} for the complete recursive value type\n */\nexport type LexScalar = number | string | boolean | null | Cid | Uint8Array\n\n/**\n * Any valid Lexicon value (recursive type).\n *\n * This is the union of all types that can appear in AT Protocol Lexicon data:\n * - {@link LexScalar} - Primitive values (number, string, boolean, null, Cid, Uint8Array)\n * - `LexValue[]` - Arrays of LexValues\n * - `{ [key: string]?: LexValue }` - Objects with string keys and LexValue values\n *\n * @example\n * ```typescript\n * import type { LexValue } from '@atproto/lex'\n *\n * const scalar: LexValue = 'hello'\n * const array: LexValue = [1, 2, 3]\n * const object: LexValue = { name: 'Alice', age: 30 }\n * ```\n *\n * @see {@link LexScalar} for primitive value types\n * @see {@link LexMap} for object types\n * @see {@link LexArray} for array types\n */\nexport type LexValue = LexScalar | LexValue[] | { [_ in string]?: LexValue }\n\n/**\n * Object with string keys and LexValue values.\n *\n * Represents a plain object in the Lexicon data model where all values\n * must be valid {@link LexValue} types.\n *\n * @example\n * ```typescript\n * import type { LexMap } from '@atproto/lex'\n *\n * const user: LexMap = {\n *   name: 'Alice',\n *   age: 30,\n *   tags: ['admin', 'user']\n * }\n * ```\n *\n * @see {@link TypedLexMap} for objects with a required `$type` property\n */\nexport type LexMap = { [_ in string]?: LexValue }\n\n/**\n * Array of {@link LexValue} elements.\n *\n * @example\n * ```typescript\n * import type { LexArray } from '@atproto/lex'\n *\n * const items: LexArray = [1, 'two', { three: 3 }]\n * ```\n */\nexport type LexArray = LexValue[]\n\n/**\n * Type guard to check if a value is a valid {@link LexMap}.\n *\n * Returns true if the value is a plain object where all values are valid\n * {@link LexValue} types.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid LexMap\n *\n * @example\n * ```typescript\n * import { isLexMap } from '@atproto/lex'\n *\n * if (isLexMap(data)) {\n *   // data is narrowed to LexMap\n *   console.log(Object.keys(data))\n * }\n * ```\n */\nexport function isLexMap(value: unknown): value is LexMap {\n  return isPlainObject(value) && Object.values(value).every(isLexValue)\n}\n\n/**\n * Type guard to check if a value is a valid {@link LexArray}.\n *\n * Returns true if the value is an array where all elements are valid\n * {@link LexValue} types.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid LexArray\n *\n * @example\n * ```typescript\n * import { isLexArray } from '@atproto/lex'\n *\n * if (isLexArray(data)) {\n *   // data is narrowed to LexArray\n *   data.forEach(item => console.log(item))\n * }\n * ```\n */\nexport function isLexArray(value: unknown): value is LexArray {\n  return Array.isArray(value) && value.every(isLexValue)\n}\n\n/**\n * Type guard to check if a value is a valid {@link LexScalar}.\n *\n * Returns true if the value is one of the primitive Lexicon types:\n * number (integer only), string, boolean, null, Cid, or Uint8Array.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid LexScalar\n *\n * @example\n * ```typescript\n * import { isLexScalar } from '@atproto/lex'\n *\n * isLexScalar('hello')     // true\n * isLexScalar(42)          // true\n * isLexScalar(3.14)        // false (floats not allowed)\n * isLexScalar([1, 2])      // false (arrays are not scalars)\n * ```\n */\nexport function isLexScalar(value: unknown): value is LexScalar {\n  switch (typeof value) {\n    case 'object':\n      return value === null || value instanceof Uint8Array || isCid(value)\n    case 'string':\n    case 'boolean':\n      return true\n    case 'number':\n      if (Number.isInteger(value)) return true\n    // fallthrough\n    default:\n      return false\n  }\n}\n\n/**\n * Type guard to check if a value is a valid {@link LexValue}.\n *\n * Performs a deep check to validate that the value (and all nested values)\n * conform to the Lexicon data model. This includes checking for:\n * - Valid scalar types (number, string, boolean, null, Cid, Uint8Array)\n * - Arrays containing only valid LexValues\n * - Plain objects with string keys and valid LexValue values\n * - No cyclic references (which cannot be serialized to JSON or CBOR)\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid LexValue\n *\n * @example\n * ```typescript\n * import { isLexValue } from '@atproto/lex'\n *\n * isLexValue({ name: 'Alice', tags: ['admin'] })  // true\n * isLexValue(new Date())                           // false (not a plain object)\n * isLexValue({ fn: () => {} })                     // false (functions not allowed)\n * ```\n */\nexport function isLexValue(value: unknown): value is LexValue {\n  // Using a stack to avoid recursion depth issues.\n  const stack: unknown[] = [value]\n  // Cyclic structures are not valid LexValues as they cannot be serialized to\n  // JSON or CBOR. This also allows us to avoid infinite loops when traversing\n  // the structure.\n  const visited = new Set<object>()\n\n  do {\n    const value = stack.pop()!\n\n    // Optimization: we are not using `isLexScalar` here to avoid extra function\n    // calls, and to avoid computing `typeof value` multiple times.\n    switch (typeof value) {\n      case 'object':\n        if (value === null) {\n          // LexScalar\n        } else if (isPlainProto(value)) {\n          if (visited.has(value)) return false\n          visited.add(value)\n          stack.push(...Object.values(value))\n        } else if (Array.isArray(value)) {\n          if (visited.has(value)) return false\n          visited.add(value)\n          stack.push(...value)\n        } else if (value instanceof Uint8Array || isCid(value)) {\n          // LexScalar\n        } else {\n          return false\n        }\n        break\n      case 'string':\n      case 'boolean':\n        break\n      case 'number':\n        if (Number.isInteger(value)) break\n      // fallthrough\n      default:\n        return false\n    }\n  } while (stack.length > 0)\n\n  // Optimization: ease GC's work\n  visited.clear()\n\n  return true\n}\n\n/**\n * A {@link LexMap} with a required `$type` property.\n *\n * Used to represent typed objects in the Lexicon data model, where the\n * `$type` property identifies the Lexicon schema that defines the object's\n * structure.\n *\n * @example\n * ```typescript\n * import type { TypedLexMap } from '@atproto/lex'\n *\n * const post: TypedLexMap = {\n *   $type: 'app.bsky.feed.post',\n *   text: 'Hello world!',\n *   createdAt: '2024-01-01T00:00:00Z'\n * }\n * ```\n *\n * @see {@link isTypedLexMap} to check if a value is a TypedLexMap\n */\nexport type TypedLexMap<T extends string = string> = LexMap & { $type: T }\n\n/**\n * Type guard to check if a value is a {@link TypedLexMap}.\n *\n * Returns true if the value is a valid {@link LexMap} with a non-empty\n * `$type` string property.\n *\n * @param value - The LexValue to check\n * @returns `true` if the value is a TypedLexMap\n *\n * @example\n * ```typescript\n * import { isTypedLexMap } from '@atproto/lex'\n *\n * const data = { $type: 'app.bsky.feed.post', text: 'Hello' }\n *\n * if (isTypedLexMap(data)) {\n *   console.log(data.$type)  // 'app.bsky.feed.post'\n * }\n * ```\n */\nexport function isTypedLexMap(value: LexValue): value is TypedLexMap {\n  return (\n    isLexMap(value) && typeof value.$type === 'string' && value.$type.length > 0\n  )\n}\n"]}

package/dist/object.d.ts

@@ -1,15 +1,65 @@
 /**
  * Checks whether the input is an object (not null).
+ *
+ * Returns true for any non-null value with typeof 'object', including
+ * arrays, plain objects, class instances, etc.
+ *
+ * @param input - The value to check
+ * @returns `true` if the input is an object (not null)
+ *
+ * @example
+ * ```typescript
+ * import { isObject } from '@atproto/lex-data'
+ *
+ * isObject({})           // true
+ * isObject([1, 2, 3])    // true
+ * isObject(new Date())   // true
+ * isObject(null)         // false
+ * isObject('string')     // false
+ * ```
  */
 export declare function isObject(input: unknown): input is object;
 /**
- * Checks whether the input is an object (not null) whose prototype is either
- * null or `Object.prototype`.
+ * Checks whether the input is a plain object.
+ *
+ * A plain object is an object (not null) whose prototype is either null
+ * or `Object.prototype`. This excludes arrays, class instances, and other
+ * special objects.
+ *
+ * @param input - The value to check
+ * @returns `true` if the input is a plain object
+ *
+ * @example
+ * ```typescript
+ * import { isPlainObject } from '@atproto/lex-data'
+ *
+ * isPlainObject({})                    // true
+ * isPlainObject({ a: 1 })              // true
+ * isPlainObject(Object.create(null))   // true
+ * isPlainObject([1, 2, 3])             // false
+ * isPlainObject(new Date())            // false
+ * isPlainObject(null)                  // false
+ * ```
  */
 export declare function isPlainObject(input: unknown): input is Record<string, unknown>;
 /**
- * Checks whether the prototype of the input object is either null or
- * `Object.prototype`.
+ * Checks whether the prototype of an object is plain (null or Object.prototype).
+ *
+ * This is useful for checking if an object is a plain object without
+ * checking that it's non-null first (the null check is already done).
+ *
+ * @param input - The object to check (must be non-null)
+ * @returns `true` if the object's prototype is plain
+ *
+ * @example
+ * ```typescript
+ * import { isPlainProto } from '@atproto/lex-data'
+ *
+ * isPlainProto({})                    // true
+ * isPlainProto(Object.create(null))   // true
+ * isPlainProto([1, 2, 3])             // false (Array.prototype)
+ * isPlainProto(new Date())            // false (Date.prototype)
+ * ```
  */
 export declare function isPlainProto(input: object): input is Record<string, unknown>;
 //# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAKD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,oCAE3C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAU5E"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAKD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,oCAE3C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAU5E"}

package/dist/object.js

@@ -5,6 +5,23 @@ exports.isPlainObject = isPlainObject;
 exports.isPlainProto = isPlainProto;
 /**
  * Checks whether the input is an object (not null).
+ *
+ * Returns true for any non-null value with typeof 'object', including
+ * arrays, plain objects, class instances, etc.
+ *
+ * @param input - The value to check
+ * @returns `true` if the input is an object (not null)
+ *
+ * @example
+ * ```typescript
+ * import { isObject } from '@atproto/lex-data'
+ *
+ * isObject({})           // true
+ * isObject([1, 2, 3])    // true
+ * isObject(new Date())   // true
+ * isObject(null)         // false
+ * isObject('string')     // false
+ * ```
  */
 function isObject(input) {
     return input != null && typeof input === 'object';
@@ -12,15 +29,48 @@ function isObject(input) {
 const ObjectProto = Object.prototype;
 const ObjectToString = Object.prototype.toString;
 /**
- * Checks whether the input is an object (not null) whose prototype is either
- * null or `Object.prototype`.
+ * Checks whether the input is a plain object.
+ *
+ * A plain object is an object (not null) whose prototype is either null
+ * or `Object.prototype`. This excludes arrays, class instances, and other
+ * special objects.
+ *
+ * @param input - The value to check
+ * @returns `true` if the input is a plain object
+ *
+ * @example
+ * ```typescript
+ * import { isPlainObject } from '@atproto/lex-data'
+ *
+ * isPlainObject({})                    // true
+ * isPlainObject({ a: 1 })              // true
+ * isPlainObject(Object.create(null))   // true
+ * isPlainObject([1, 2, 3])             // false
+ * isPlainObject(new Date())            // false
+ * isPlainObject(null)                  // false
+ * ```
  */
 function isPlainObject(input) {
     return isObject(input) && isPlainProto(input);
 }
 /**
- * Checks whether the prototype of the input object is either null or
- * `Object.prototype`.
+ * Checks whether the prototype of an object is plain (null or Object.prototype).
+ *
+ * This is useful for checking if an object is a plain object without
+ * checking that it's non-null first (the null check is already done).
+ *
+ * @param input - The object to check (must be non-null)
+ * @returns `true` if the object's prototype is plain
+ *
+ * @example
+ * ```typescript
+ * import { isPlainProto } from '@atproto/lex-data'
+ *
+ * isPlainProto({})                    // true
+ * isPlainProto(Object.create(null))   // true
+ * isPlainProto([1, 2, 3])             // false (Array.prototype)
+ * isPlainProto(new Date())            // false (Date.prototype)
+ * ```
  */
 function isPlainProto(input) {
     const proto = Object.getPrototypeOf(input);

package/dist/object.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":";;AAGA,4BAEC;AASD,sCAEC;AAMD,oCAUC;AAhCD;;GAEG;AACH,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAA;AACnD,CAAC;AAED,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAA;AACpC,MAAM,cAAc,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAA;AAEhD;;;GAGG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,KAAK,CAAC,CAAA;AAC/C,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,KAAa;IACxC,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;IAC1C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAC/B,OAAO,CACL,CAAC,KAAK,KAAK,WAAW;QACpB,sEAAsE;QACtE,6BAA6B;QAC7B,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;QACxC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,iBAAiB,CACjD,CAAA;AACH,CAAC","sourcesContent":["/**\n * Checks whether the input is an object (not null).\n */\nexport function isObject(input: unknown): input is object {\n  return input != null && typeof input === 'object'\n}\n\nconst ObjectProto = Object.prototype\nconst ObjectToString = Object.prototype.toString\n\n/**\n * Checks whether the input is an object (not null) whose prototype is either\n * null or `Object.prototype`.\n */\nexport function isPlainObject(input: unknown) {\n  return isObject(input) && isPlainProto(input)\n}\n\n/**\n * Checks whether the prototype of the input object is either null or\n * `Object.prototype`.\n */\nexport function isPlainProto(input: object): input is Record<string, unknown> {\n  const proto = Object.getPrototypeOf(input)\n  if (proto === null) return true\n  return (\n    (proto === ObjectProto ||\n      // Needed to support NodeJS's `runInNewContext` which produces objects\n      // with a different prototype\n      Object.getPrototypeOf(proto) === null) &&\n    ObjectToString.call(input) === '[object Object]'\n  )\n}\n"]}
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":";;AAoBA,4BAEC;AA2BD,sCAEC;AAqBD,oCAUC;AAlFD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAA;AACnD,CAAC;AAED,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAA;AACpC,MAAM,cAAc,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,KAAK,CAAC,CAAA;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,YAAY,CAAC,KAAa;IACxC,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;IAC1C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAC/B,OAAO,CACL,CAAC,KAAK,KAAK,WAAW;QACpB,sEAAsE;QACtE,6BAA6B;QAC7B,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;QACxC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,iBAAiB,CACjD,CAAA;AACH,CAAC","sourcesContent":["/**\n * Checks whether the input is an object (not null).\n *\n * Returns true for any non-null value with typeof 'object', including\n * arrays, plain objects, class instances, etc.\n *\n * @param input - The value to check\n * @returns `true` if the input is an object (not null)\n *\n * @example\n * ```typescript\n * import { isObject } from '@atproto/lex-data'\n *\n * isObject({})           // true\n * isObject([1, 2, 3])    // true\n * isObject(new Date())   // true\n * isObject(null)         // false\n * isObject('string')     // false\n * ```\n */\nexport function isObject(input: unknown): input is object {\n  return input != null && typeof input === 'object'\n}\n\nconst ObjectProto = Object.prototype\nconst ObjectToString = Object.prototype.toString\n\n/**\n * Checks whether the input is a plain object.\n *\n * A plain object is an object (not null) whose prototype is either null\n * or `Object.prototype`. This excludes arrays, class instances, and other\n * special objects.\n *\n * @param input - The value to check\n * @returns `true` if the input is a plain object\n *\n * @example\n * ```typescript\n * import { isPlainObject } from '@atproto/lex-data'\n *\n * isPlainObject({})                    // true\n * isPlainObject({ a: 1 })              // true\n * isPlainObject(Object.create(null))   // true\n * isPlainObject([1, 2, 3])             // false\n * isPlainObject(new Date())            // false\n * isPlainObject(null)                  // false\n * ```\n */\nexport function isPlainObject(input: unknown) {\n  return isObject(input) && isPlainProto(input)\n}\n\n/**\n * Checks whether the prototype of an object is plain (null or Object.prototype).\n *\n * This is useful for checking if an object is a plain object without\n * checking that it's non-null first (the null check is already done).\n *\n * @param input - The object to check (must be non-null)\n * @returns `true` if the object's prototype is plain\n *\n * @example\n * ```typescript\n * import { isPlainProto } from '@atproto/lex-data'\n *\n * isPlainProto({})                    // true\n * isPlainProto(Object.create(null))   // true\n * isPlainProto([1, 2, 3])             // false (Array.prototype)\n * isPlainProto(new Date())            // false (Date.prototype)\n * ```\n */\nexport function isPlainProto(input: object): input is Record<string, unknown> {\n  const proto = Object.getPrototypeOf(input)\n  if (proto === null) return true\n  return (\n    (proto === ObjectProto ||\n      // Needed to support NodeJS's `runInNewContext` which produces objects\n      // with a different prototype\n      Object.getPrototypeOf(proto) === null) &&\n    ObjectToString.call(input) === '[object Object]'\n  )\n}\n"]}

package/dist/uint8array.d.ts

@@ -3,24 +3,116 @@ export type { Base64Alphabet };
 /**
  * Encodes a Uint8Array into a base64 string.
  *
+ * Uses native Uint8Array.prototype.toBase64 when available (Node.js 24+, modern browsers),
+ * falling back to Node.js Buffer or a ponyfill implementation.
+ *
+ * @param bytes - The binary data to encode
+ * @param alphabet - The base64 alphabet to use ('base64' or 'base64url'), defaults to 'base64'
  * @returns The base64 encoded string
+ *
+ * @example
+ * ```typescript
+ * import { toBase64 } from '@atproto/lex-data'
+ *
+ * const bytes = new Uint8Array([72, 101, 108, 108, 111])
+ * toBase64(bytes)           // 'SGVsbG8='
+ * toBase64(bytes, 'base64url')  // 'SGVsbG8' (URL-safe, no padding)
+ * ```
  */
 export declare const toBase64: (bytes: Uint8Array, alphabet?: Base64Alphabet) => string;
 /**
- * Decodes a base64 string into a Uint8Array. This function supports both padded
- * and unpadded base64 strings.
+ * Decodes a base64 string into a Uint8Array.
+ *
+ * Supports both padded and unpadded base64 strings. Uses native
+ * Uint8Array.fromBase64 when available, falling back to Node.js Buffer
+ * or a ponyfill implementation.
  *
- * @returns The decoded {@link Uint8Array}
+ * @param b64 - The base64 string to decode
+ * @param alphabet - The base64 alphabet to use ('base64' or 'base64url'), defaults to 'base64'
+ * @returns The decoded binary data
  * @throws If the input is not a valid base64 string
+ *
+ * @example
+ * ```typescript
+ * import { fromBase64 } from '@atproto/lex-data'
+ *
+ * fromBase64('SGVsbG8=')       // Uint8Array([72, 101, 108, 108, 111])
+ * fromBase64('SGVsbG8', 'base64url')  // Same, URL-safe alphabet
+ * ```
  */
 export declare const fromBase64: (b64: string, alphabet?: Base64Alphabet) => Uint8Array;
+/**
+ * Returns the input if it is a Uint8Array, otherwise returns undefined.
+ *
+ * @param input - The value to check
+ * @returns The input if it's a Uint8Array, otherwise undefined
+ *
+ * @example
+ * ```typescript
+ * import { ifUint8Array } from '@atproto/lex-data'
+ *
+ * ifUint8Array(new Uint8Array([1, 2]))  // Uint8Array([1, 2])
+ * ifUint8Array('not binary')            // undefined
+ * ifUint8Array(new ArrayBuffer(4))      // undefined
+ * ```
+ */
 export declare function ifUint8Array(input: unknown): Uint8Array | undefined;
 /**
  * Coerces various binary data representations into a Uint8Array.
  *
- * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.
+ * Handles the following input types:
+ * - `Uint8Array` - Returned as-is
+ * - `ArrayBufferView` (e.g., DataView, other TypedArrays) - Converted to Uint8Array
+ * - `ArrayBuffer` - Wrapped in a Uint8Array
+ *
+ * @param input - The value to convert
+ * @returns A Uint8Array, or `undefined` if the input could not be converted
+ *
+ * @example
+ * ```typescript
+ * import { asUint8Array } from '@atproto/lex-data'
+ *
+ * asUint8Array(new Uint8Array([1, 2]))     // Uint8Array([1, 2])
+ * asUint8Array(new ArrayBuffer(4))         // Uint8Array of length 4
+ * asUint8Array(new Int16Array([1, 2]))     // Uint8Array view of the buffer
+ * asUint8Array('string')                   // undefined
+ * ```
  */
 export declare function asUint8Array(input: unknown): Uint8Array | undefined;
+/**
+ * Compares two Uint8Arrays for byte-by-byte equality.
+ *
+ * @param a - First Uint8Array to compare
+ * @param b - Second Uint8Array to compare
+ * @returns `true` if both arrays have the same length and identical bytes
+ *
+ * @example
+ * ```typescript
+ * import { ui8Equals } from '@atproto/lex-data'
+ *
+ * ui8Equals(new Uint8Array([1, 2]), new Uint8Array([1, 2]))  // true
+ * ui8Equals(new Uint8Array([1, 2]), new Uint8Array([1, 3]))  // false
+ * ui8Equals(new Uint8Array([1]), new Uint8Array([1, 2]))     // false
+ * ```
+ */
 export declare function ui8Equals(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Concatenates multiple Uint8Arrays into a single Uint8Array.
+ *
+ * Uses Node.js Buffer.concat when available for performance,
+ * falling back to a ponyfill implementation.
+ *
+ * @param arrays - The Uint8Arrays to concatenate
+ * @returns A new Uint8Array containing all input bytes in order
+ *
+ * @example
+ * ```typescript
+ * import { ui8Concat } from '@atproto/lex-data'
+ *
+ * const a = new Uint8Array([1, 2])
+ * const b = new Uint8Array([3, 4])
+ * ui8Concat([a, b])  // Uint8Array([1, 2, 3, 4])
+ * ```
+ */
 export declare const ui8Concat: (array: readonly Uint8Array[]) => Uint8Array;
 //# sourceMappingURL=uint8array.d.ts.map

package/dist/uint8array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAGa,CAAA;AAElB;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAGe,CAAA;AAUpB,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D;AAED,eAAO,MAAM,SAAS,8CACgD,CAAA"}
+{"version":3,"file":"uint8array.d.ts","sourceRoot":"","sources":["../src/uint8array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAavD,YAAY,EAAE,cAAc,EAAE,CAAA;AAO9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,EAAE,CACrB,KAAK,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,cAAc,KACtB,MAGa,CAAA;AAElB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,UAAU,EAAE,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,cAAc,KACtB,UAGe,CAAA;AAUpB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAMnE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAkBnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAY/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,8CACgD,CAAA"}