@atproto/lex-json 0.0.0

package/dist/blob.d.ts

@@ -0,0 +1,5 @@
+import { BlobRef, LexMap } from '@atproto/lex-data';
+export declare function parseBlobRef(input: LexMap, options?: {
+    strict?: boolean;
+}): BlobRef | undefined;
+//# sourceMappingURL=blob.d.ts.map

package/dist/blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAa,MAAM,mBAAmB,CAAA;AAG9D,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7B,OAAO,GAAG,SAAS,CAwBrB"}

package/dist/blob.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBlobRef = parseBlobRef;
+const lex_data_1 = require("@atproto/lex-data");
+const link_js_1 = require("./link.js");
+function parseBlobRef(input, options) {
+    if (input.$type !== 'blob')
+        return undefined;
+    const ref = input?.ref;
+    if (!ref || typeof ref !== 'object')
+        return undefined;
+    // @NOTE Because json to lex conversion can be performed both in a depth-first
+    // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via
+    // jsonToLex), the `ref` property may either be a LexMap with a $link
+    // property, or it may already be a CID instance.
+    if ('$link' in ref) {
+        const cid = (0, link_js_1.parseLexLink)(ref);
+        if (!cid)
+            return undefined;
+        const blob = { ...input, ref: cid };
+        if ((0, lex_data_1.isBlobRef)(blob, options))
+            return blob;
+    }
+    if ((0, lex_data_1.isBlobRef)(input)) {
+        return input;
+    }
+    return undefined;
+}
+//# sourceMappingURL=blob.js.map

package/dist/blob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":";;AAGA,oCA2BC;AA9BD,gDAA8D;AAC9D,uCAAwC;AAExC,SAAgB,YAAY,CAC1B,KAAa,EACb,OAA8B;IAE9B,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,SAAS,CAAA;IAE5C,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAA;IACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IAErD,8EAA8E;IAC9E,oEAAoE;IACpE,qEAAqE;IACrE,iDAAiD;IAEjD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAE1B,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;QACnC,IAAI,IAAA,oBAAS,EAAC,IAAI,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;IAC3C,CAAC;IAED,IAAI,IAAA,oBAAS,EAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC","sourcesContent":["import { BlobRef, LexMap, isBlobRef } from '@atproto/lex-data'\nimport { parseLexLink } from './link.js'\n\nexport function parseBlobRef(\n  input: LexMap,\n  options?: { strict?: boolean },\n): BlobRef | undefined {\n  if (input.$type !== 'blob') return undefined\n\n  const ref = input?.ref\n  if (!ref || typeof ref !== 'object') return undefined\n\n  // @NOTE Because json to lex conversion can be performed both in a depth-first\n  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via\n  // jsonToLex), the `ref` property may either be a LexMap with a $link\n  // property, or it may already be a CID instance.\n\n  if ('$link' in ref) {\n    const cid = parseLexLink(ref)\n    if (!cid) return undefined\n\n    const blob = { ...input, ref: cid }\n    if (isBlobRef(blob, options)) return blob\n  }\n\n  if (isBlobRef(input)) {\n    return input\n  }\n\n  return undefined\n}\n"]}

package/dist/bytes.d.ts

@@ -0,0 +1,6 @@
+import { JsonValue } from './json.js';
+export declare function parseLexBytes(input?: {
+    $bytes?: unknown;
+}): Uint8Array | undefined;
+export declare function encodeLexBytes(bytes: Uint8Array): JsonValue;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAErC,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE;IACpC,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,GAAG,UAAU,GAAG,SAAS,CAgBzB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAE3D"}

package/dist/bytes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLexBytes = parseLexBytes;
+exports.encodeLexBytes = encodeLexBytes;
+const lex_data_1 = require("@atproto/lex-data");
+function parseLexBytes(input) {
+    if (!input || !('$bytes' in input)) {
+        return undefined;
+    }
+    for (const key in input) {
+        if (key !== '$bytes') {
+            return undefined;
+        }
+    }
+    if (typeof input.$bytes !== 'string') {
+        throw new TypeError('$bytes must be a base64-encoded string');
+    }
+    return (0, lex_data_1.fromBase64)(input.$bytes);
+}
+function encodeLexBytes(bytes) {
+    return { $bytes: (0, lex_data_1.toBase64)(bytes) };
+}
+//# sourceMappingURL=bytes.js.map

package/dist/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":";;AAGA,sCAkBC;AAED,wCAEC;AAzBD,gDAAwD;AAGxD,SAAgB,aAAa,CAAC,KAE7B;IACC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC;IAED,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QACrC,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAA;IAC/D,CAAC;IAED,OAAO,IAAA,qBAAU,EAAC,KAAK,CAAC,MAAM,CAAC,CAAA;AACjC,CAAC;AAED,SAAgB,cAAc,CAAC,KAAiB;IAC9C,OAAO,EAAE,MAAM,EAAE,IAAA,mBAAQ,EAAC,KAAK,CAAC,EAAE,CAAA;AACpC,CAAC","sourcesContent":["import { fromBase64, toBase64 } from '@atproto/lex-data'\nimport { JsonValue } from './json.js'\n\nexport function parseLexBytes(input?: {\n  $bytes?: unknown\n}): Uint8Array | undefined {\n  if (!input || !('$bytes' in input)) {\n    return undefined\n  }\n\n  for (const key in input) {\n    if (key !== '$bytes') {\n      return undefined\n    }\n  }\n\n  if (typeof input.$bytes !== 'string') {\n    throw new TypeError('$bytes must be a base64-encoded string')\n  }\n\n  return fromBase64(input.$bytes)\n}\n\nexport function encodeLexBytes(bytes: Uint8Array): JsonValue {\n  return { $bytes: toBase64(bytes) }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './bytes.js';
+export * from './json.js';
+export * from './lex-json.js';
+export * from './link.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA"}

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bytes.js"), exports);
+tslib_1.__exportStar(require("./json.js"), exports);
+tslib_1.__exportStar(require("./lex-json.js"), exports);
+tslib_1.__exportStar(require("./link.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAA0B;AAC1B,oDAAyB;AACzB,wDAA6B;AAC7B,oDAAyB","sourcesContent":["export * from './bytes.js'\nexport * from './json.js'\nexport * from './lex-json.js'\nexport * from './link.js'\n"]}

package/dist/json.d.ts

@@ -0,0 +1,8 @@
+export type JsonScalar = number | string | boolean | null;
+export type JsonValue = JsonScalar | JsonValue[] | {
+    [_ in string]?: JsonValue;
+};
+export type JsonObject = {
+    [_ in string]?: JsonValue;
+};
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AACzD,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,EAAE,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,SAAS;CAAE,CAAA;AAChF,MAAM,MAAM,UAAU,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,SAAS;CAAE,CAAA"}

package/dist/json.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"","sourcesContent":["export type JsonScalar = number | string | boolean | null\nexport type JsonValue = JsonScalar | JsonValue[] | { [_ in string]?: JsonValue }\nexport type JsonObject = { [_ in string]?: JsonValue }\n"]}

package/dist/lex-json.d.ts

@@ -0,0 +1,14 @@
+import { LexValue } from '@atproto/lex-data';
+import { JsonValue } from './json.js';
+export declare function lexStringify(input: LexValue): string;
+export type LexParseOptions = {
+    /**
+     * Forbids the presence of invalid Lex values (e.g. non-integer numbers,
+     * malformed $link, $bytes, blob objects, etc.)
+     */
+    strict?: boolean;
+};
+export declare function lexParse(input: string, options?: LexParseOptions): LexValue;
+export declare function jsonToLex(value: JsonValue, options?: LexParseOptions): LexValue;
+export declare function lexToJson(value: LexValue): JsonValue;
+//# sourceMappingURL=lex-json.d.ts.map

package/dist/lex-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-json.d.ts","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,QAAQ,EAET,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAc,SAAS,EAAE,MAAM,WAAW,CAAA;AAGjD,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAKpD;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAmC,GAC3C,QAAQ,CAiBV;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,eAAmC,GAC3C,QAAQ,CAsBV;AA+CD,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAqBpD"}

package/dist/lex-json.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexStringify = lexStringify;
+exports.lexParse = lexParse;
+exports.jsonToLex = jsonToLex;
+exports.lexToJson = lexToJson;
+const lex_data_1 = require("@atproto/lex-data");
+const blob_js_1 = require("./blob.js");
+const bytes_js_1 = require("./bytes.js");
+const link_js_1 = require("./link.js");
+function lexStringify(input) {
+    // @NOTE Because of the way the "replacer" works in JSON.stringify, it's
+    // simpler to convert Lex to JSON first rather than trying to do it
+    // on-the-fly.
+    return JSON.stringify(lexToJson(input));
+}
+function lexParse(input, options = { strict: false }) {
+    return JSON.parse(input, function (key, value) {
+        switch (typeof value) {
+            case 'object':
+                if (value === null)
+                    return null;
+                if (Array.isArray(value))
+                    return value;
+                return parseSpecialJsonObject(value, options) ?? value;
+            case 'number':
+                if (Number.isInteger(value))
+                    return value;
+                if (options.strict) {
+                    throw new TypeError(`Invalid non-integer number: ${value}`);
+                }
+            // fallthrough
+            default:
+                return value;
+        }
+    });
+}
+function jsonToLex(value, options = { strict: false }) {
+    switch (typeof value) {
+        case 'object': {
+            if (value === null)
+                return null;
+            if (Array.isArray(value))
+                return jsonArrayToLex(value, options);
+            return (parseSpecialJsonObject(value, options) ??
+                jsonObjectToLexMap(value, options));
+        }
+        case 'number':
+            if (Number.isInteger(value))
+                return value;
+            if (options.strict) {
+                throw new TypeError(`Invalid non-integer number: ${value}`);
+            }
+        // fallthrough
+        case 'boolean':
+        case 'string':
+            return value;
+        default:
+            throw new TypeError(`Invalid JSON value: ${typeof value}`);
+    }
+}
+function jsonArrayToLex(input, options) {
+    // Lazily copy value
+    let copy;
+    for (let i = 0; i < input.length; i++) {
+        const inputItem = input[i];
+        const item = jsonToLex(inputItem, options);
+        if (item !== inputItem) {
+            copy ?? (copy = Array.from(input));
+            copy[i] = item;
+        }
+    }
+    return copy ?? input;
+}
+function jsonObjectToLexMap(input, options) {
+    // Lazily copy value
+    let copy = undefined;
+    for (const [key, jsonValue] of Object.entries(input)) {
+        // Prevent prototype pollution
+        if (key === '__proto__') {
+            throw new TypeError('Invalid key: __proto__');
+        }
+        // Ignore (strip) undefined values
+        if (jsonValue === undefined) {
+            copy ?? (copy = { ...input });
+            delete copy[key];
+            continue;
+        }
+        const value = jsonToLex(jsonValue, options);
+        if (value !== jsonValue) {
+            copy ?? (copy = { ...input });
+            copy[key] = value;
+        }
+    }
+    return copy ?? input;
+}
+function lexToJson(value) {
+    switch (typeof value) {
+        case 'object':
+            if (value === null) {
+                return value;
+            }
+            else if (Array.isArray(value)) {
+                return lexArrayToJson(value);
+            }
+            else if ((0, lex_data_1.isCid)(value)) {
+                return (0, link_js_1.encodeLexLink)(value);
+            }
+            else if (value instanceof Uint8Array) {
+                return (0, bytes_js_1.encodeLexBytes)(value);
+            }
+            else {
+                return encodeLexMap(value);
+            }
+        case 'boolean':
+        case 'string':
+        case 'number':
+            return value;
+        default:
+            throw new TypeError(`Invalid Lex value: ${typeof value}`);
+    }
+}
+function lexArrayToJson(input) {
+    // Lazily copy value
+    let copy;
+    for (let i = 0; i < input.length; i++) {
+        const inputItem = input[i];
+        const item = lexToJson(inputItem);
+        if (item !== inputItem) {
+            copy ?? (copy = Array.from(input));
+            copy[i] = item;
+        }
+    }
+    return copy ?? input;
+}
+function encodeLexMap(input) {
+    // Lazily copy value
+    let copy = undefined;
+    for (const [key, lexValue] of Object.entries(input)) {
+        // Prevent prototype pollution
+        if (key === '__proto__') {
+            throw new TypeError('Invalid key: __proto__');
+        }
+        // Ignore (strip) undefined values
+        if (lexValue === undefined) {
+            copy ?? (copy = { ...input });
+            delete copy[key];
+            continue;
+        }
+        const jsonValue = lexToJson(lexValue);
+        if (jsonValue !== lexValue) {
+            copy ?? (copy = { ...input });
+            copy[key] = jsonValue;
+        }
+    }
+    return copy ?? input;
+}
+function parseSpecialJsonObject(input, options) {
+    // Hot path: use hints to avoid parsing when possible
+    if (input.$link !== undefined) {
+        const cid = (0, link_js_1.parseLexLink)(input);
+        if (cid)
+            return cid;
+        if (options.strict)
+            throw new TypeError(`Invalid $link object`);
+    }
+    else if (input.$bytes !== undefined) {
+        const bytes = (0, bytes_js_1.parseLexBytes)(input);
+        if (bytes)
+            return bytes;
+        if (options.strict)
+            throw new TypeError(`Invalid $bytes object`);
+    }
+    else if (input.$type !== undefined) {
+        // @NOTE Since blobs are "just" regular lex objects with a special shape,
+        // and because an object that does not conform to the blob shape would still
+        // result in undefined being returned, we only attempt to parse blobs when
+        // the strict option is enabled.
+        if (options.strict) {
+            if (input.$type === 'blob') {
+                const blob = (0, blob_js_1.parseBlobRef)(input, options);
+                if (blob)
+                    return blob;
+                throw new TypeError(`Invalid blob object`);
+            }
+            else if (typeof input.$type !== 'string') {
+                throw new TypeError(`Invalid $type property (${typeof input.$type})`);
+            }
+            else if (input.$type.length === 0) {
+                throw new TypeError(`Empty $type property`);
+            }
+        }
+    }
+    // @NOTE We ignore legacy blob representation here. They can be handled at the
+    // application level if needed.
+    return undefined;
+}
+//# sourceMappingURL=lex-json.js.map

package/dist/lex-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-json.js","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  CID,\n  LexArray,\n  LexMap,\n  LexValue,\n  isCid,\n} from '@atproto/lex-data'\nimport { parseBlobRef } from './blob.js'\nimport { encodeLexBytes, parseLexBytes } from './bytes.js'\nimport { JsonObject, JsonValue } from './json.js'\nimport { encodeLexLink, parseLexLink } from './link.js'\n\nexport function lexStringify(input: LexValue): string {\n  // @NOTE Because of the way the \"replacer\" works in JSON.stringify, it's\n  // simpler to convert Lex to JSON first rather than trying to do it\n  // on-the-fly.\n  return JSON.stringify(lexToJson(input))\n}\n\nexport type LexParseOptions = {\n  /**\n   * Forbids the presence of invalid Lex values (e.g. non-integer numbers,\n   * malformed $link, $bytes, blob objects, etc.)\n   */\n  strict?: boolean\n}\n\nexport function lexParse(\n  input: string,\n  options: LexParseOptions = { strict: false },\n): LexValue {\n  return JSON.parse(input, function (key: string, value: JsonValue): LexValue {\n    switch (typeof value) {\n      case 'object':\n        if (value === null) return null\n        if (Array.isArray(value)) return value\n        return parseSpecialJsonObject(value, options) ?? value\n      case 'number':\n        if (Number.isInteger(value)) return value\n        if (options.strict) {\n          throw new TypeError(`Invalid non-integer number: ${value}`)\n        }\n      // fallthrough\n      default:\n        return value\n    }\n  })\n}\n\nexport function jsonToLex(\n  value: JsonValue,\n  options: LexParseOptions = { strict: false },\n): LexValue {\n  switch (typeof value) {\n    case 'object': {\n      if (value === null) return null\n      if (Array.isArray(value)) return jsonArrayToLex(value, options)\n      return (\n        parseSpecialJsonObject(value, options) ??\n        jsonObjectToLexMap(value, options)\n      )\n    }\n    case 'number':\n      if (Number.isInteger(value)) return value\n      if (options.strict) {\n        throw new TypeError(`Invalid non-integer number: ${value}`)\n      }\n    // fallthrough\n    case 'boolean':\n    case 'string':\n      return value\n    default:\n      throw new TypeError(`Invalid JSON value: ${typeof value}`)\n  }\n}\n\nfunction jsonArrayToLex(\n  input: JsonValue[],\n  options: LexParseOptions,\n): LexValue[] {\n  // Lazily copy value\n  let copy: LexValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = jsonToLex(inputItem, options)\n    if (item !== inputItem) {\n      copy ??= Array.from(input)\n      copy[i] = item\n    }\n  }\n  return copy ?? input\n}\n\nfunction jsonObjectToLexMap(\n  input: JsonObject,\n  options: LexParseOptions,\n): LexMap {\n  // Lazily copy value\n  let copy: LexMap | undefined = undefined\n  for (const [key, jsonValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (jsonValue === undefined) {\n      copy ??= { ...input }\n      delete copy[key]\n      continue\n    }\n\n    const value = jsonToLex(jsonValue!, options)\n    if (value !== jsonValue) {\n      copy ??= { ...input }\n      copy[key] = value\n    }\n  }\n  return copy ?? input\n}\n\nexport function lexToJson(value: LexValue): JsonValue {\n  switch (typeof value) {\n    case 'object':\n      if (value === null) {\n        return value\n      } else if (Array.isArray(value)) {\n        return lexArrayToJson(value)\n      } else if (isCid(value)) {\n        return encodeLexLink(value)\n      } else if (value instanceof Uint8Array) {\n        return encodeLexBytes(value)\n      } else {\n        return encodeLexMap(value)\n      }\n    case 'boolean':\n    case 'string':\n    case 'number':\n      return value\n    default:\n      throw new TypeError(`Invalid Lex value: ${typeof value}`)\n  }\n}\n\nfunction lexArrayToJson(input: LexArray): JsonValue[] {\n  // Lazily copy value\n  let copy: JsonValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = lexToJson(inputItem)\n    if (item !== inputItem) {\n      copy ??= Array.from(input) as JsonValue[]\n      copy[i] = item\n    }\n  }\n  return copy ?? (input as JsonValue[])\n}\n\nfunction encodeLexMap(input: LexMap): JsonObject {\n  // Lazily copy value\n  let copy: JsonObject | undefined = undefined\n  for (const [key, lexValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (lexValue === undefined) {\n      copy ??= { ...input } as JsonObject\n      delete copy[key]\n      continue\n    }\n\n    const jsonValue = lexToJson(lexValue!)\n    if (jsonValue !== lexValue) {\n      copy ??= { ...input } as JsonObject\n      copy[key] = jsonValue\n    }\n  }\n  return copy ?? (input as JsonObject)\n}\n\nfunction parseSpecialJsonObject(\n  input: LexMap,\n  options: LexParseOptions,\n): CID | Uint8Array | BlobRef | undefined {\n  // Hot path: use hints to avoid parsing when possible\n\n  if (input.$link !== undefined) {\n    const cid = parseLexLink(input)\n    if (cid) return cid\n    if (options.strict) throw new TypeError(`Invalid $link object`)\n  } else if (input.$bytes !== undefined) {\n    const bytes = parseLexBytes(input)\n    if (bytes) return bytes\n    if (options.strict) throw new TypeError(`Invalid $bytes object`)\n  } else if (input.$type !== undefined) {\n    // @NOTE Since blobs are \"just\" regular lex objects with a special shape,\n    // and because an object that does not conform to the blob shape would still\n    // result in undefined being returned, we only attempt to parse blobs when\n    // the strict option is enabled.\n    if (options.strict) {\n      if (input.$type === 'blob') {\n        const blob = parseBlobRef(input, options)\n        if (blob) return blob\n        throw new TypeError(`Invalid blob object`)\n      } else if (typeof input.$type !== 'string') {\n        throw new TypeError(`Invalid $type property (${typeof input.$type})`)\n      } else if (input.$type.length === 0) {\n        throw new TypeError(`Empty $type property`)\n      }\n    }\n  }\n\n  // @NOTE We ignore legacy blob representation here. They can be handled at the\n  // application level if needed.\n\n  return undefined\n}\n"]}

package/dist/link.d.ts

@@ -0,0 +1,7 @@
+import { CID } from '@atproto/lex-data';
+import { JsonValue } from './json.js';
+export declare function parseLexLink(input?: {
+    $link?: unknown;
+}): CID | undefined;
+export declare function encodeLexLink(cid: CID): JsonValue;
+//# sourceMappingURL=link.d.ts.map

package/dist/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../src/link.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAErC,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,GAAG,GAAG,SAAS,CA6BzE;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAEjD"}

package/dist/link.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLexLink = parseLexLink;
+exports.encodeLexLink = encodeLexLink;
+const lex_data_1 = require("@atproto/lex-data");
+function parseLexLink(input) {
+    if (!input || !('$link' in input)) {
+        return undefined;
+    }
+    for (const key in input) {
+        if (key !== '$link') {
+            return undefined;
+        }
+    }
+    if (typeof input.$link !== 'string') {
+        throw new TypeError('$link must be a base32-encoded CID string');
+    }
+    if (input.$link.length === 0) {
+        throw new TypeError('CID string in $link cannot be empty');
+    }
+    // Arbitrary limit to prevent DoS via extremely long CIDs
+    if (input.$link.length > 2048) {
+        throw new TypeError('CID string in $link is too long');
+    }
+    try {
+        return lex_data_1.CID.parse(input.$link);
+    }
+    catch (cause) {
+        throw new TypeError('Invalid CID string in $link', { cause });
+    }
+}
+function encodeLexLink(cid) {
+    return { $link: cid.toString() };
+}
+//# sourceMappingURL=link.js.map

package/dist/link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.js","sourceRoot":"","sources":["../src/link.ts"],"names":[],"mappings":";;AAGA,oCA6BC;AAED,sCAEC;AApCD,gDAAuC;AAGvC,SAAgB,YAAY,CAAC,KAA2B;IACtD,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,OAAO,IAAI,KAAK,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,GAAG,KAAK,OAAO,EAAE,CAAC;YACpB,OAAO,SAAS,CAAA;QAClB,CAAC;IACH,CAAC;IAED,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACpC,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAA;IAClE,CAAC;IAED,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,SAAS,CAAC,qCAAqC,CAAC,CAAA;IAC5D,CAAC;IAED,yDAAyD;IACzD,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QAC9B,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAA;IACxD,CAAC;IAED,IAAI,CAAC;QACH,OAAO,cAAG,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,SAAS,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,CAAC,CAAA;IAC/D,CAAC;AACH,CAAC;AAED,SAAgB,aAAa,CAAC,GAAQ;IACpC,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAA;AAClC,CAAC","sourcesContent":["import { CID } from '@atproto/lex-data'\nimport { JsonValue } from './json.js'\n\nexport function parseLexLink(input?: { $link?: unknown }): CID | undefined {\n  if (!input || !('$link' in input)) {\n    return undefined\n  }\n\n  for (const key in input) {\n    if (key !== '$link') {\n      return undefined\n    }\n  }\n\n  if (typeof input.$link !== 'string') {\n    throw new TypeError('$link must be a base32-encoded CID string')\n  }\n\n  if (input.$link.length === 0) {\n    throw new TypeError('CID string in $link cannot be empty')\n  }\n\n  // Arbitrary limit to prevent DoS via extremely long CIDs\n  if (input.$link.length > 2048) {\n    throw new TypeError('CID string in $link is too long')\n  }\n\n  try {\n    return CID.parse(input.$link)\n  } catch (cause) {\n    throw new TypeError('Invalid CID string in $link', { cause })\n  }\n}\n\nexport function encodeLexLink(cid: CID): JsonValue {\n  return { $link: cid.toString() }\n}\n"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@atproto/lex-json",
+  "version": "0.0.0",
+  "license": "MIT",
+  "description": "Lexicon encoding utilities for AT Lexicon data in JSON format",
+  "keywords": [
+    "atproto",
+    "lex",
+    "data",
+    "json",
+    "encoding",
+    "utilities"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/lex/lex-json"
+  },
+  "files": [
+    "./src",
+    "./dist"
+  ],
+  "sideEffects": false,
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/index.js",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@atproto/lex-data": "workspace:*",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "jest": "^28.1.2"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "test": "jest"
+  }
+}

package/src/blob.ts

@@ -0,0 +1,31 @@
+import { BlobRef, LexMap, isBlobRef } from '@atproto/lex-data'
+import { parseLexLink } from './link.js'
+
+export function parseBlobRef(
+  input: LexMap,
+  options?: { strict?: boolean },
+): BlobRef | undefined {
+  if (input.$type !== 'blob') return undefined
+
+  const ref = input?.ref
+  if (!ref || typeof ref !== 'object') return undefined
+
+  // @NOTE Because json to lex conversion can be performed both in a depth-first
+  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via
+  // jsonToLex), the `ref` property may either be a LexMap with a $link
+  // property, or it may already be a CID instance.
+
+  if ('$link' in ref) {
+    const cid = parseLexLink(ref)
+    if (!cid) return undefined
+
+    const blob = { ...input, ref: cid }
+    if (isBlobRef(blob, options)) return blob
+  }
+
+  if (isBlobRef(input)) {
+    return input
+  }
+
+  return undefined
+}

package/src/bytes.ts

@@ -0,0 +1,26 @@
+import { fromBase64, toBase64 } from '@atproto/lex-data'
+import { JsonValue } from './json.js'
+
+export function parseLexBytes(input?: {
+  $bytes?: unknown
+}): Uint8Array | undefined {
+  if (!input || !('$bytes' in input)) {
+    return undefined
+  }
+
+  for (const key in input) {
+    if (key !== '$bytes') {
+      return undefined
+    }
+  }
+
+  if (typeof input.$bytes !== 'string') {
+    throw new TypeError('$bytes must be a base64-encoded string')
+  }
+
+  return fromBase64(input.$bytes)
+}
+
+export function encodeLexBytes(bytes: Uint8Array): JsonValue {
+  return { $bytes: toBase64(bytes) }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './bytes.js'
+export * from './json.js'
+export * from './lex-json.js'
+export * from './link.js'

package/src/json.ts

@@ -0,0 +1,3 @@
+export type JsonScalar = number | string | boolean | null
+export type JsonValue = JsonScalar | JsonValue[] | { [_ in string]?: JsonValue }
+export type JsonObject = { [_ in string]?: JsonValue }

package/src/lex-json.test.ts

@@ -0,0 +1,511 @@
+import { CID, LexValue, lexEquals } from '@atproto/lex-data'
+import { JsonValue } from './json.js'
+import { jsonToLex, lexParse, lexStringify, lexToJson } from './lex-json.js'
+
+export const validVectors: Array<{
+  name: string
+  json: JsonValue
+  lex: LexValue
+}> = [
+  {
+    name: 'pure json',
+    json: {
+      string: 'abc',
+      unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧',
+      integer: 123,
+      bool: true,
+      null: null,
+      array: ['abc', 'def', 'ghi'],
+      object: {
+        string: 'abc',
+        number: 123,
+        bool: true,
+        arr: ['abc', 'def', 'ghi'],
+      },
+    },
+    lex: {
+      string: 'abc',
+      unicode: 'a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧',
+      integer: 123,
+      bool: true,
+      null: null,
+      array: ['abc', 'def', 'ghi'],
+      object: {
+        string: 'abc',
+        number: 123,
+        bool: true,
+        arr: ['abc', 'def', 'ghi'],
+      },
+    },
+  },
+  {
+    name: 'lex data',
+    json: {
+      a: {
+        $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      },
+      b: {
+        $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+      },
+      c: {
+        $type: 'blob',
+        ref: {
+          $link: 'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+        },
+        mimeType: 'image/jpeg',
+        size: 10000,
+      },
+    },
+    lex: {
+      a: CID.parse(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      ),
+      b: new Uint8Array([
+        156, 81, 17, 142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253,
+        65, 60, 242, 11, 98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194,
+        204, 141,
+      ]),
+      c: {
+        $type: 'blob',
+        ref: CID.parse(
+          'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+        ),
+        mimeType: 'image/jpeg',
+        size: 10000,
+      },
+    },
+  },
+  {
+    name: 'lexArray',
+    json: [
+      {
+        $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      },
+      {
+        $link: 'bafyreigoxt64qghytzkr6ik7qvtzc7lyytiq5xbbrokbxjows2wp7vmo6q',
+      },
+      {
+        $link: 'bafyreiaizynclnqiolq7byfpjjtgqzn4sfrsgn7z2hhf6bo4utdwkin7ke',
+      },
+      {
+        $link: 'bafyreifd4w4tcr5tluxz7osjtnofffvtsmgdqcfrfi6evjde4pl27lrjpy',
+      },
+    ],
+    lex: [
+      CID.parse('bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'),
+      CID.parse('bafyreigoxt64qghytzkr6ik7qvtzc7lyytiq5xbbrokbxjows2wp7vmo6q'),
+      CID.parse('bafyreiaizynclnqiolq7byfpjjtgqzn4sfrsgn7z2hhf6bo4utdwkin7ke'),
+      CID.parse('bafyreifd4w4tcr5tluxz7osjtnofffvtsmgdqcfrfi6evjde4pl27lrjpy'),
+    ],
+  },
+  {
+    name: 'root cid',
+    json: {
+      $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+    },
+    lex: CID.parse(
+      'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+    ),
+  },
+  {
+    name: 'root bytes',
+    json: {
+      $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+    },
+    lex: new Uint8Array([
+      156, 81, 17, 142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253, 65,
+      60, 242, 11, 98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194, 204,
+      141,
+    ]),
+  },
+  {
+    name: 'lexNested',
+    json: {
+      a: {
+        b: [
+          {
+            d: [
+              {
+                $link:
+                  'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+              },
+              {
+                $link:
+                  'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+              },
+            ],
+            e: [
+              {
+                $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+              },
+              {
+                $bytes: 'iE+sPoHobU9tSIqGI+309LLCcWQIRmEXwxcoDt19tas',
+              },
+            ],
+          },
+        ],
+      },
+    },
+    lex: {
+      a: {
+        b: [
+          {
+            d: [
+              CID.parse(
+                'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+              ),
+              CID.parse(
+                'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+              ),
+            ],
+            e: [
+              new Uint8Array([
+                156, 81, 17, 142, 242, 203, 139, 15, 106, 155, 142, 73, 174,
+                161, 253, 65, 60, 242, 11, 98, 238, 213, 118, 248, 157, 238,
+                190, 176, 26, 194, 204, 141,
+              ]),
+              new Uint8Array([
+                136, 79, 172, 62, 129, 232, 109, 79, 109, 72, 138, 134, 35, 237,
+                244, 244, 178, 194, 113, 100, 8, 70, 97, 23, 195, 23, 40, 14,
+                221, 125, 181, 171,
+              ]),
+            ],
+          },
+        ],
+      },
+    },
+  },
+  {
+    name: 'empty structures',
+    json: {
+      emptyObject: {},
+      emptyArray: [],
+      emtyBytes: { $bytes: '' },
+    },
+    lex: {
+      emptyObject: {},
+      emptyArray: [],
+      emtyBytes: new Uint8Array([]),
+    },
+  },
+  {
+    name: 'mixed types in array',
+    json: {
+      arr: [
+        'string',
+        123,
+        true,
+        null,
+        {
+          $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        },
+        { $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0' },
+        { nested: 'object' },
+        ['nested', 'array'],
+      ],
+    },
+    lex: {
+      arr: [
+        'string',
+        123,
+        true,
+        null,
+        CID.parse(
+          'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        ),
+        new Uint8Array([
+          156, 81, 17, 142, 242, 203, 139, 15, 106, 155, 142, 73, 174, 161, 253,
+          65, 60, 242, 11, 98, 238, 213, 118, 248, 157, 238, 190, 176, 26, 194,
+          204, 141,
+        ]),
+        { nested: 'object' },
+        ['nested', 'array'],
+      ],
+    },
+  },
+  {
+    name: "mismatched order in object doesn't affect equality",
+    json: {
+      a: 'valueA',
+      b: 'valueB',
+      c: {
+        $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      },
+      d: {
+        a: 'valueA',
+        b: 'valueB',
+      },
+    },
+    lex: {
+      c: CID.parse(
+        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      ),
+      d: {
+        b: 'valueB',
+        a: 'valueA',
+      },
+      a: 'valueA',
+      b: 'valueB',
+    },
+  },
+]
+
+export const acceptableVectors: Array<{
+  note: string
+  json: JsonValue
+}> = [
+  {
+    note: 'non string $type',
+    json: {
+      $type: 3124,
+      foo: 'bar',
+    },
+  },
+  {
+    note: 'object with float values',
+    json: {
+      a: 1.5,
+    },
+  },
+  {
+    note: 'blob with wrong field type',
+    json: {
+      $type: 'blob',
+      ref: 'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+      mimeType: 'image/jpeg',
+      size: 10000,
+    },
+  },
+  {
+    note: 'blob with missing key',
+    json: {
+      $type: 'blob',
+      mimeType: 'image/jpeg',
+      size: 10000,
+    },
+  },
+  {
+    note: 'blob with extra fields',
+    json: {
+      $type: 'blob',
+      ref: {
+        $link: 'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
+      },
+      mimeType: 'image/jpeg',
+      size: 10000,
+      other: 'blah',
+    },
+  },
+  {
+    note: 'bytes with extra fields',
+    json: {
+      $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+      other: 'blah',
+    },
+  },
+  {
+    note: 'link with extra fields',
+    json: {
+      $link: 'bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity',
+      other: 'blah',
+    },
+  },
+  {
+    note: '$bytes and $link',
+    json: {
+      $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+      $link: 'bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity',
+    },
+  },
+  {
+    note: '$bytes and $type',
+    json: {
+      $type: 'bytes',
+      $bytes: 'nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0',
+    },
+  },
+  {
+    note: '$link and $type',
+    json: {
+      $type: 'blob',
+      $link: 'bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity',
+    },
+  },
+]
+
+export const invalidVectors: Array<{
+  note: string
+  json: JsonValue
+}> = [
+  {
+    note: 'bytes with wrong field type',
+    json: {
+      $bytes: [1, 2, 3],
+    },
+  },
+  {
+    note: 'invalid base64 in $bytes',
+    json: {
+      $bytes: '🐻',
+    },
+  },
+  {
+    note: 'link with wrong field type',
+    json: {
+      $link: 1234,
+    },
+  },
+  {
+    note: 'link with bogus CID',
+    json: {
+      $link: '.',
+    },
+  },
+]
+
+describe('lexParse', () => {
+  describe('valid vectors', () => {
+    for (const { name, json, lex } of validVectors) {
+      describe(name, () => {
+        it('parses lex from string', () => {
+          expect(
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: false })),
+          ).toBe(true)
+          expect(
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: true })),
+          ).toBe(true)
+        })
+      })
+    }
+  })
+
+  describe('acceptable vectors', () => {
+    for (const { note, json } of acceptableVectors) {
+      describe(note, () => {
+        it('parses lex from string in non-strict mode', () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: false }),
+          ).not.toThrow()
+        })
+
+        it('parses lex from string in strict mode', () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: true }),
+          ).toThrow()
+        })
+      })
+    }
+  })
+
+  describe('invalid vectors', () => {
+    for (const { note, json } of invalidVectors) {
+      describe(note, () => {
+        it('throws when parsing malformed JSON', () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: false }),
+          ).toThrow()
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: true }),
+          ).toThrow()
+        })
+      })
+    }
+  })
+})
+
+describe('lexStringify', () => {
+  describe('valid vectors', () => {
+    for (const { name, json, lex } of validVectors) {
+      describe(name, () => {
+        it('stringifies lex to string', () => {
+          expect(JSON.parse(lexStringify(lex))).toEqual(json)
+        })
+      })
+    }
+  })
+})
+
+describe('jsonToLex', () => {
+  describe('valid vectors', () => {
+    for (const { name, json, lex } of validVectors) {
+      describe(name, () => {
+        it('converts json to lex (in strict mode)', () => {
+          expect(lexEquals(jsonToLex(json, { strict: true }), lex)).toBe(true)
+          expect(lexEquals(lex, jsonToLex(json, { strict: true }))).toBe(true)
+        })
+
+        it('converts json to lex (in non-strict mode)', () => {
+          expect(lexEquals(jsonToLex(json, { strict: false }), lex)).toBe(true)
+          expect(lexEquals(lex, jsonToLex(json, { strict: false }))).toBe(true)
+        })
+      })
+    }
+  })
+
+  describe('acceptable vectors', () => {
+    for (const { note, json } of acceptableVectors) {
+      describe(note, () => {
+        it('parses lex from json in strict mode', () => {
+          expect(() => jsonToLex(json, { strict: true })).toThrow()
+        })
+
+        it('parses lex from json in non-strict mode', () => {
+          expect(() => jsonToLex(json, { strict: false })).not.toThrow()
+        })
+      })
+    }
+  })
+
+  describe('invalid vectors', () => {
+    for (const { note, json } of invalidVectors) {
+      describe(note, () => {
+        it(`throws for malformed object`, () => {
+          expect(() => jsonToLex(json, { strict: true })).toThrow()
+        })
+
+        it('throws for nested malformed object', () => {
+          expect(() => jsonToLex({ nested: json }, { strict: true })).toThrow()
+          expect(() => jsonToLex([json], { strict: true })).toThrow()
+        })
+      })
+    }
+  })
+})
+
+describe('lexToJson', () => {
+  describe('valid vectors', () => {
+    for (const { name, json, lex } of validVectors) {
+      describe(name, () => {
+        it('converts lex to json', () => {
+          expect(lexToJson(lex)).toEqual(json)
+          expect(lexToJson(lex)).toEqual(json)
+        })
+      })
+    }
+  })
+})
+
+describe('json > lex > json', () => {
+  describe('valid vectors', () => {
+    for (const { name, json } of validVectors) {
+      describe(name, () => {
+        it('converts json to lex', () => {
+          expect(lexToJson(jsonToLex(json))).toEqual(json)
+        })
+      })
+    }
+  })
+})
+
+describe('lex > json > lex', () => {
+  describe('valid vectors', () => {
+    for (const { name, lex } of validVectors) {
+      describe(name, () => {
+        it('converts lex to json', () => {
+          expect(lexEquals(jsonToLex(lexToJson(lex)), lex)).toBe(true)
+          expect(lexEquals(lex, jsonToLex(lexToJson(lex)))).toBe(true)
+        })
+      })
+    }
+  })
+})

package/src/lex-json.ts

@@ -0,0 +1,221 @@
+import {
+  BlobRef,
+  CID,
+  LexArray,
+  LexMap,
+  LexValue,
+  isCid,
+} from '@atproto/lex-data'
+import { parseBlobRef } from './blob.js'
+import { encodeLexBytes, parseLexBytes } from './bytes.js'
+import { JsonObject, JsonValue } from './json.js'
+import { encodeLexLink, parseLexLink } from './link.js'
+
+export function lexStringify(input: LexValue): string {
+  // @NOTE Because of the way the "replacer" works in JSON.stringify, it's
+  // simpler to convert Lex to JSON first rather than trying to do it
+  // on-the-fly.
+  return JSON.stringify(lexToJson(input))
+}
+
+export type LexParseOptions = {
+  /**
+   * Forbids the presence of invalid Lex values (e.g. non-integer numbers,
+   * malformed $link, $bytes, blob objects, etc.)
+   */
+  strict?: boolean
+}
+
+export function lexParse(
+  input: string,
+  options: LexParseOptions = { strict: false },
+): LexValue {
+  return JSON.parse(input, function (key: string, value: JsonValue): LexValue {
+    switch (typeof value) {
+      case 'object':
+        if (value === null) return null
+        if (Array.isArray(value)) return value
+        return parseSpecialJsonObject(value, options) ?? value
+      case 'number':
+        if (Number.isInteger(value)) return value
+        if (options.strict) {
+          throw new TypeError(`Invalid non-integer number: ${value}`)
+        }
+      // fallthrough
+      default:
+        return value
+    }
+  })
+}
+
+export function jsonToLex(
+  value: JsonValue,
+  options: LexParseOptions = { strict: false },
+): LexValue {
+  switch (typeof value) {
+    case 'object': {
+      if (value === null) return null
+      if (Array.isArray(value)) return jsonArrayToLex(value, options)
+      return (
+        parseSpecialJsonObject(value, options) ??
+        jsonObjectToLexMap(value, options)
+      )
+    }
+    case 'number':
+      if (Number.isInteger(value)) return value
+      if (options.strict) {
+        throw new TypeError(`Invalid non-integer number: ${value}`)
+      }
+    // fallthrough
+    case 'boolean':
+    case 'string':
+      return value
+    default:
+      throw new TypeError(`Invalid JSON value: ${typeof value}`)
+  }
+}
+
+function jsonArrayToLex(
+  input: JsonValue[],
+  options: LexParseOptions,
+): LexValue[] {
+  // Lazily copy value
+  let copy: LexValue[] | undefined
+  for (let i = 0; i < input.length; i++) {
+    const inputItem = input[i]
+    const item = jsonToLex(inputItem, options)
+    if (item !== inputItem) {
+      copy ??= Array.from(input)
+      copy[i] = item
+    }
+  }
+  return copy ?? input
+}
+
+function jsonObjectToLexMap(
+  input: JsonObject,
+  options: LexParseOptions,
+): LexMap {
+  // Lazily copy value
+  let copy: LexMap | undefined = undefined
+  for (const [key, jsonValue] of Object.entries(input)) {
+    // Prevent prototype pollution
+    if (key === '__proto__') {
+      throw new TypeError('Invalid key: __proto__')
+    }
+
+    // Ignore (strip) undefined values
+    if (jsonValue === undefined) {
+      copy ??= { ...input }
+      delete copy[key]
+      continue
+    }
+
+    const value = jsonToLex(jsonValue!, options)
+    if (value !== jsonValue) {
+      copy ??= { ...input }
+      copy[key] = value
+    }
+  }
+  return copy ?? input
+}
+
+export function lexToJson(value: LexValue): JsonValue {
+  switch (typeof value) {
+    case 'object':
+      if (value === null) {
+        return value
+      } else if (Array.isArray(value)) {
+        return lexArrayToJson(value)
+      } else if (isCid(value)) {
+        return encodeLexLink(value)
+      } else if (value instanceof Uint8Array) {
+        return encodeLexBytes(value)
+      } else {
+        return encodeLexMap(value)
+      }
+    case 'boolean':
+    case 'string':
+    case 'number':
+      return value
+    default:
+      throw new TypeError(`Invalid Lex value: ${typeof value}`)
+  }
+}
+
+function lexArrayToJson(input: LexArray): JsonValue[] {
+  // Lazily copy value
+  let copy: JsonValue[] | undefined
+  for (let i = 0; i < input.length; i++) {
+    const inputItem = input[i]
+    const item = lexToJson(inputItem)
+    if (item !== inputItem) {
+      copy ??= Array.from(input) as JsonValue[]
+      copy[i] = item
+    }
+  }
+  return copy ?? (input as JsonValue[])
+}
+
+function encodeLexMap(input: LexMap): JsonObject {
+  // Lazily copy value
+  let copy: JsonObject | undefined = undefined
+  for (const [key, lexValue] of Object.entries(input)) {
+    // Prevent prototype pollution
+    if (key === '__proto__') {
+      throw new TypeError('Invalid key: __proto__')
+    }
+
+    // Ignore (strip) undefined values
+    if (lexValue === undefined) {
+      copy ??= { ...input } as JsonObject
+      delete copy[key]
+      continue
+    }
+
+    const jsonValue = lexToJson(lexValue!)
+    if (jsonValue !== lexValue) {
+      copy ??= { ...input } as JsonObject
+      copy[key] = jsonValue
+    }
+  }
+  return copy ?? (input as JsonObject)
+}
+
+function parseSpecialJsonObject(
+  input: LexMap,
+  options: LexParseOptions,
+): CID | Uint8Array | BlobRef | undefined {
+  // Hot path: use hints to avoid parsing when possible
+
+  if (input.$link !== undefined) {
+    const cid = parseLexLink(input)
+    if (cid) return cid
+    if (options.strict) throw new TypeError(`Invalid $link object`)
+  } else if (input.$bytes !== undefined) {
+    const bytes = parseLexBytes(input)
+    if (bytes) return bytes
+    if (options.strict) throw new TypeError(`Invalid $bytes object`)
+  } else if (input.$type !== undefined) {
+    // @NOTE Since blobs are "just" regular lex objects with a special shape,
+    // and because an object that does not conform to the blob shape would still
+    // result in undefined being returned, we only attempt to parse blobs when
+    // the strict option is enabled.
+    if (options.strict) {
+      if (input.$type === 'blob') {
+        const blob = parseBlobRef(input, options)
+        if (blob) return blob
+        throw new TypeError(`Invalid blob object`)
+      } else if (typeof input.$type !== 'string') {
+        throw new TypeError(`Invalid $type property (${typeof input.$type})`)
+      } else if (input.$type.length === 0) {
+        throw new TypeError(`Empty $type property`)
+      }
+    }
+  }
+
+  // @NOTE We ignore legacy blob representation here. They can be handled at the
+  // application level if needed.
+
+  return undefined
+}

package/src/link.ts

@@ -0,0 +1,37 @@
+import { CID } from '@atproto/lex-data'
+import { JsonValue } from './json.js'
+
+export function parseLexLink(input?: { $link?: unknown }): CID | undefined {
+  if (!input || !('$link' in input)) {
+    return undefined
+  }
+
+  for (const key in input) {
+    if (key !== '$link') {
+      return undefined
+    }
+  }
+
+  if (typeof input.$link !== 'string') {
+    throw new TypeError('$link must be a base32-encoded CID string')
+  }
+
+  if (input.$link.length === 0) {
+    throw new TypeError('CID string in $link cannot be empty')
+  }
+
+  // Arbitrary limit to prevent DoS via extremely long CIDs
+  if (input.$link.length > 2048) {
+    throw new TypeError('CID string in $link is too long')
+  }
+
+  try {
+    return CID.parse(input.$link)
+  } catch (cause) {
+    throw new TypeError('Invalid CID string in $link', { cause })
+  }
+}
+
+export function encodeLexLink(cid: CID): JsonValue {
+  return { $link: cid.toString() }
+}