@atproto/lex-installer 0.0.13 → 0.0.15

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @atproto/lex-installer
 
+## 0.0.15
+
+### Patch Changes
+
+- [#4601](https://github.com/bluesky-social/atproto/pull/4601) [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Fix `exports` field in package.json
+
+- [#4601](https://github.com/bluesky-social/atproto/pull/4601) [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add JSDoc
+
+- Updated dependencies [[`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015)]:
+  - @atproto/lex-schema@0.0.12
+  - @atproto/lex-document@0.0.13
+  - @atproto/lex-resolver@0.0.14
+  - @atproto/lex-cbor@0.0.11
+  - @atproto/lex-data@0.0.11
+  - @atproto/lex-builder@0.0.14
+
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies [[`369bb02`](https://github.com/bluesky-social/atproto/commit/369bb02b9f80f0e15e5242e54f09bd4e01117f3a)]:
+  - @atproto/lex-data@0.0.10
+  - @atproto/lex-resolver@0.0.13
+  - @atproto/lex-cbor@0.0.10
+  - @atproto/lex-document@0.0.12
+  - @atproto/lex-schema@0.0.11
+  - @atproto/lex-builder@0.0.13
+
 ## 0.0.13
 
 ### Patch Changes

package/dist/fs.d.ts

@@ -1,4 +1,102 @@
+/**
+ * Reads and parses a JSON file from the filesystem.
+ *
+ * @param path - Absolute or relative path to the JSON file
+ * @returns The parsed JSON content
+ * @throws {Error} When the file cannot be read (e.g., ENOENT, EACCES)
+ * @throws {SyntaxError} When the file contains invalid JSON
+ *
+ * @example
+ * ```typescript
+ * import { readJsonFile } from '@atproto/lex-installer'
+ *
+ * const manifest = await readJsonFile('./lexicons.manifest.json')
+ * ```
+ *
+ * @example
+ * Handle missing file:
+ * ```typescript
+ * import { readJsonFile, isEnoentError } from '@atproto/lex-installer'
+ *
+ * try {
+ *   const data = await readJsonFile('./config.json')
+ * } catch (err) {
+ *   if (isEnoentError(err)) {
+ *     console.log('File does not exist, using defaults')
+ *   } else {
+ *     throw err
+ *   }
+ * }
+ * ```
+ */
 export declare function readJsonFile(path: string): Promise<unknown>;
+/**
+ * Writes data as formatted JSON to a file.
+ *
+ * The function:
+ * - Creates parent directories if they don't exist
+ * - Formats JSON with 2-space indentation
+ * - Overwrites existing files
+ * - Sets file permissions to 0o644 (rw-r--r--)
+ *
+ * @param path - Absolute or relative path for the output file
+ * @param data - Data to serialize as JSON
+ * @throws {Error} When the file cannot be written
+ *
+ * @example
+ * ```typescript
+ * import { writeJsonFile } from '@atproto/lex-installer'
+ *
+ * await writeJsonFile('./output/data.json', {
+ *   name: 'example',
+ *   values: [1, 2, 3],
+ * })
+ * ```
+ *
+ * @example
+ * Write a lexicon document:
+ * ```typescript
+ * import { writeJsonFile } from '@atproto/lex-installer'
+ *
+ * await writeJsonFile('./lexicons/app/bsky/feed/post.json', lexiconDocument)
+ * ```
+ */
 export declare function writeJsonFile(path: string, data: unknown): Promise<void>;
+/**
+ * Checks if an error is an ENOENT (file not found) error.
+ *
+ * Useful for handling cases where a file may or may not exist,
+ * such as reading an optional configuration file.
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is an ENOENT error, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { readFile } from 'node:fs/promises'
+ * import { isEnoentError } from '@atproto/lex-installer'
+ *
+ * const config = await readFile('./config.json').catch((err) => {
+ *   if (isEnoentError(err)) {
+ *     return { defaults: true }
+ *   }
+ *   throw err
+ * })
+ * ```
+ *
+ * @example
+ * In try/catch:
+ * ```typescript
+ * try {
+ *   const manifest = await readFile('./lexicons.manifest.json', 'utf8')
+ * } catch (err) {
+ *   if (isEnoentError(err)) {
+ *     // File doesn't exist, create a new manifest
+ *     return { version: 1, lexicons: [], resolutions: {} }
+ *   }
+ *   throw err
+ * }
+ * ```
+ */
 export declare function isEnoentError(err: unknown): boolean;
 //# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAGA,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGjE;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEnD"}
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEnD"}

package/dist/fs.js

@@ -5,10 +5,72 @@ exports.writeJsonFile = writeJsonFile;
 exports.isEnoentError = isEnoentError;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+/**
+ * Reads and parses a JSON file from the filesystem.
+ *
+ * @param path - Absolute or relative path to the JSON file
+ * @returns The parsed JSON content
+ * @throws {Error} When the file cannot be read (e.g., ENOENT, EACCES)
+ * @throws {SyntaxError} When the file contains invalid JSON
+ *
+ * @example
+ * ```typescript
+ * import { readJsonFile } from '@atproto/lex-installer'
+ *
+ * const manifest = await readJsonFile('./lexicons.manifest.json')
+ * ```
+ *
+ * @example
+ * Handle missing file:
+ * ```typescript
+ * import { readJsonFile, isEnoentError } from '@atproto/lex-installer'
+ *
+ * try {
+ *   const data = await readJsonFile('./config.json')
+ * } catch (err) {
+ *   if (isEnoentError(err)) {
+ *     console.log('File does not exist, using defaults')
+ *   } else {
+ *     throw err
+ *   }
+ * }
+ * ```
+ */
 async function readJsonFile(path) {
     const contents = await (0, promises_1.readFile)(path, 'utf8');
     return JSON.parse(contents);
 }
+/**
+ * Writes data as formatted JSON to a file.
+ *
+ * The function:
+ * - Creates parent directories if they don't exist
+ * - Formats JSON with 2-space indentation
+ * - Overwrites existing files
+ * - Sets file permissions to 0o644 (rw-r--r--)
+ *
+ * @param path - Absolute or relative path for the output file
+ * @param data - Data to serialize as JSON
+ * @throws {Error} When the file cannot be written
+ *
+ * @example
+ * ```typescript
+ * import { writeJsonFile } from '@atproto/lex-installer'
+ *
+ * await writeJsonFile('./output/data.json', {
+ *   name: 'example',
+ *   values: [1, 2, 3],
+ * })
+ * ```
+ *
+ * @example
+ * Write a lexicon document:
+ * ```typescript
+ * import { writeJsonFile } from '@atproto/lex-installer'
+ *
+ * await writeJsonFile('./lexicons/app/bsky/feed/post.json', lexiconDocument)
+ * ```
+ */
 async function writeJsonFile(path, data) {
     await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), { recursive: true });
     const contents = JSON.stringify(data, null, 2);
@@ -18,6 +80,42 @@ async function writeJsonFile(path, data) {
         flag: 'w', // override
     });
 }
+/**
+ * Checks if an error is an ENOENT (file not found) error.
+ *
+ * Useful for handling cases where a file may or may not exist,
+ * such as reading an optional configuration file.
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is an ENOENT error, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { readFile } from 'node:fs/promises'
+ * import { isEnoentError } from '@atproto/lex-installer'
+ *
+ * const config = await readFile('./config.json').catch((err) => {
+ *   if (isEnoentError(err)) {
+ *     return { defaults: true }
+ *   }
+ *   throw err
+ * })
+ * ```
+ *
+ * @example
+ * In try/catch:
+ * ```typescript
+ * try {
+ *   const manifest = await readFile('./lexicons.manifest.json', 'utf8')
+ * } catch (err) {
+ *   if (isEnoentError(err)) {
+ *     // File doesn't exist, create a new manifest
+ *     return { version: 1, lexicons: [], resolutions: {} }
+ *   }
+ *   throw err
+ * }
+ * ```
+ */
 function isEnoentError(err) {
     return err instanceof Error && 'code' in err && err.code === 'ENOENT';
 }

package/dist/fs.js.map

@@ -1 +1 @@
-{"version":3,"file":"fs.js","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":";;AAGA,oCAGC;AAED,sCAWC;AAED,sCAEC;AAvBD,+CAA6D;AAC7D,yCAAmC;AAE5B,KAAK,UAAU,YAAY,CAAC,IAAY;IAC7C,MAAM,QAAQ,GAAG,MAAM,IAAA,mBAAQ,EAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAC7C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;AAC7B,CAAC;AAEM,KAAK,UAAU,aAAa,CACjC,IAAY,EACZ,IAAa;IAEb,MAAM,IAAA,gBAAK,EAAC,IAAA,mBAAO,EAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;IAC9C,MAAM,IAAA,oBAAS,EAAC,IAAI,EAAE,QAAQ,EAAE;QAC9B,QAAQ,EAAE,MAAM;QAChB,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,GAAG,EAAE,WAAW;KACvB,CAAC,CAAA;AACJ,CAAC;AAED,SAAgB,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,YAAY,KAAK,IAAI,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAA;AACvE,CAAC","sourcesContent":["import { mkdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname } from 'node:path'\n\nexport async function readJsonFile(path: string): Promise<unknown> {\n  const contents = await readFile(path, 'utf8')\n  return JSON.parse(contents)\n}\n\nexport async function writeJsonFile(\n  path: string,\n  data: unknown,\n): Promise<void> {\n  await mkdir(dirname(path), { recursive: true })\n  const contents = JSON.stringify(data, null, 2)\n  await writeFile(path, contents, {\n    encoding: 'utf8',\n    mode: 0o644,\n    flag: 'w', // override\n  })\n}\n\nexport function isEnoentError(err: unknown): boolean {\n  return err instanceof Error && 'code' in err && err.code === 'ENOENT'\n}\n"]}
+{"version":3,"file":"fs.js","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":";;AAkCA,oCAGC;AAiCD,sCAWC;AAsCD,sCAEC;AAzHD,+CAA6D;AAC7D,yCAAmC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACI,KAAK,UAAU,YAAY,CAAC,IAAY;IAC7C,MAAM,QAAQ,GAAG,MAAM,IAAA,mBAAQ,EAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAC7C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACI,KAAK,UAAU,aAAa,CACjC,IAAY,EACZ,IAAa;IAEb,MAAM,IAAA,gBAAK,EAAC,IAAA,mBAAO,EAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;IAC9C,MAAM,IAAA,oBAAS,EAAC,IAAI,EAAE,QAAQ,EAAE;QAC9B,QAAQ,EAAE,MAAM;QAChB,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,GAAG,EAAE,WAAW;KACvB,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,SAAgB,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,YAAY,KAAK,IAAI,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAA;AACvE,CAAC","sourcesContent":["import { mkdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname } from 'node:path'\n\n/**\n * Reads and parses a JSON file from the filesystem.\n *\n * @param path - Absolute or relative path to the JSON file\n * @returns The parsed JSON content\n * @throws {Error} When the file cannot be read (e.g., ENOENT, EACCES)\n * @throws {SyntaxError} When the file contains invalid JSON\n *\n * @example\n * ```typescript\n * import { readJsonFile } from '@atproto/lex-installer'\n *\n * const manifest = await readJsonFile('./lexicons.manifest.json')\n * ```\n *\n * @example\n * Handle missing file:\n * ```typescript\n * import { readJsonFile, isEnoentError } from '@atproto/lex-installer'\n *\n * try {\n *   const data = await readJsonFile('./config.json')\n * } catch (err) {\n *   if (isEnoentError(err)) {\n *     console.log('File does not exist, using defaults')\n *   } else {\n *     throw err\n *   }\n * }\n * ```\n */\nexport async function readJsonFile(path: string): Promise<unknown> {\n  const contents = await readFile(path, 'utf8')\n  return JSON.parse(contents)\n}\n\n/**\n * Writes data as formatted JSON to a file.\n *\n * The function:\n * - Creates parent directories if they don't exist\n * - Formats JSON with 2-space indentation\n * - Overwrites existing files\n * - Sets file permissions to 0o644 (rw-r--r--)\n *\n * @param path - Absolute or relative path for the output file\n * @param data - Data to serialize as JSON\n * @throws {Error} When the file cannot be written\n *\n * @example\n * ```typescript\n * import { writeJsonFile } from '@atproto/lex-installer'\n *\n * await writeJsonFile('./output/data.json', {\n *   name: 'example',\n *   values: [1, 2, 3],\n * })\n * ```\n *\n * @example\n * Write a lexicon document:\n * ```typescript\n * import { writeJsonFile } from '@atproto/lex-installer'\n *\n * await writeJsonFile('./lexicons/app/bsky/feed/post.json', lexiconDocument)\n * ```\n */\nexport async function writeJsonFile(\n  path: string,\n  data: unknown,\n): Promise<void> {\n  await mkdir(dirname(path), { recursive: true })\n  const contents = JSON.stringify(data, null, 2)\n  await writeFile(path, contents, {\n    encoding: 'utf8',\n    mode: 0o644,\n    flag: 'w', // override\n  })\n}\n\n/**\n * Checks if an error is an ENOENT (file not found) error.\n *\n * Useful for handling cases where a file may or may not exist,\n * such as reading an optional configuration file.\n *\n * @param err - The error to check\n * @returns `true` if the error is an ENOENT error, `false` otherwise\n *\n * @example\n * ```typescript\n * import { readFile } from 'node:fs/promises'\n * import { isEnoentError } from '@atproto/lex-installer'\n *\n * const config = await readFile('./config.json').catch((err) => {\n *   if (isEnoentError(err)) {\n *     return { defaults: true }\n *   }\n *   throw err\n * })\n * ```\n *\n * @example\n * In try/catch:\n * ```typescript\n * try {\n *   const manifest = await readFile('./lexicons.manifest.json', 'utf8')\n * } catch (err) {\n *   if (isEnoentError(err)) {\n *     // File doesn't exist, create a new manifest\n *     return { version: 1, lexicons: [], resolutions: {} }\n *   }\n *   throw err\n * }\n * ```\n */\nexport function isEnoentError(err: unknown): boolean {\n  return err instanceof Error && 'code' in err && err.code === 'ENOENT'\n}\n"]}

package/dist/index.d.ts

@@ -1,8 +1,91 @@
 import { LexInstallerOptions } from './lex-installer.js';
+/**
+ * Options for the {@link install} function.
+ *
+ * Extends {@link LexInstallerOptions} with additional options for controlling
+ * the installation behavior.
+ *
+ * @example
+ * ```typescript
+ * const options: LexInstallOptions = {
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   add: ['com.example.myLexicon', 'at://did:plc:xyz/com.example.otherLexicon'],
+ *   save: true,
+ *   ci: false,
+ * }
+ * ```
+ */
 export type LexInstallOptions = LexInstallerOptions & {
+    /**
+     * Array of lexicons to add to the installation. Can be NSID strings
+     * (e.g., 'com.example.myLexicon') or AT URIs
+     * (e.g., 'at://did:plc:xyz/com.example.myLexicon').
+     */
     add?: string[];
+    /**
+     * Whether to save the updated manifest after installation.
+     * When `true`, the manifest file will be written with any new lexicons.
+     * @default false
+     */
     save?: boolean;
+    /**
+     * Enable CI mode for strict manifest verification.
+     * When `true`, throws an error if the manifest is out of date,
+     * useful for continuous integration pipelines.
+     * @default false
+     */
     ci?: boolean;
 };
+/**
+ * Installs lexicons from the network based on the provided options.
+ *
+ * This is the main entry point for programmatic lexicon installation.
+ * It reads an existing manifest (if present), installs any new lexicons,
+ * and optionally saves the updated manifest.
+ *
+ * @param options - Configuration options for the installation
+ * @throws {Error} When the manifest file cannot be read (unless it doesn't exist)
+ * @throws {Error} When in CI mode and the manifest is out of date
+ *
+ * @example
+ * Install lexicons and save the manifest:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   add: ['app.bsky.feed.post', 'app.bsky.actor.profile'],
+ *   save: true,
+ * })
+ * ```
+ *
+ * @example
+ * Verify manifest in CI pipeline:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * // Throws if manifest is out of date
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   ci: true,
+ * })
+ * ```
+ *
+ * @example
+ * Install from specific AT URIs:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   add: ['at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post'],
+ *   save: true,
+ * })
+ * ```
+ */
 export declare function install(options: LexInstallOptions): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAMtE,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,GAAG;IACpD,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,EAAE,CAAC,EAAE,OAAO,CAAA;CACb,CAAA;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,iBAAiB,iBA2BvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAMtE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,GAAG;IACpD;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IAEd;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IAEd;;;;;OAKG;IACH,EAAE,CAAC,EAAE,OAAO,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,iBAAiB,iBA2BvD"}

package/dist/index.js

@@ -5,6 +5,56 @@ const tslib_1 = require("tslib");
 const fs_js_1 = require("./fs.js");
 const lex_installer_js_1 = require("./lex-installer.js");
 const lexicons_manifest_js_1 = require("./lexicons-manifest.js");
+/**
+ * Installs lexicons from the network based on the provided options.
+ *
+ * This is the main entry point for programmatic lexicon installation.
+ * It reads an existing manifest (if present), installs any new lexicons,
+ * and optionally saves the updated manifest.
+ *
+ * @param options - Configuration options for the installation
+ * @throws {Error} When the manifest file cannot be read (unless it doesn't exist)
+ * @throws {Error} When in CI mode and the manifest is out of date
+ *
+ * @example
+ * Install lexicons and save the manifest:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   add: ['app.bsky.feed.post', 'app.bsky.actor.profile'],
+ *   save: true,
+ * })
+ * ```
+ *
+ * @example
+ * Verify manifest in CI pipeline:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * // Throws if manifest is out of date
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   ci: true,
+ * })
+ * ```
+ *
+ * @example
+ * Install from specific AT URIs:
+ * ```typescript
+ * import { install } from '@atproto/lex-installer'
+ *
+ * await install({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   add: ['at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post'],
+ *   save: true,
+ * })
+ * ```
+ */
 async function install(options) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAaA,0BA2BC;;AAxCD,mCAAqD;AACrD,yDAAsE;AACtE,iEAG+B;AAQxB,KAAK,UAAU,OAAO,CAAC,OAA0B;;;QACtD,MAAM,QAAQ,GAAiC,MAAM,IAAA,oBAAY,EAC/D,OAAO,CAAC,QAAQ,CACjB,CAAC,IAAI,CACJ,CAAC,IAAI,EAAE,EAAE,CAAC,6CAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,EAC5C,CAAC,KAAc,EAAE,EAAE;YACjB,IAAI,IAAA,qBAAa,EAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAA;YAC1C,MAAM,IAAI,KAAK,CAAC,kCAAkC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAA;QAChE,CAAC,CACF,CAAA;QAED,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAEtC,iEAAiE;QACjE,MAAY,SAAS,0CAAG,IAAI,+BAAY,CAAC,OAAO,CAAC,OAAA,CAAA;QAEjD,MAAM,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAA;QAEhD,kBAAkB;QAClB,IAAI,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;QACrD,CAAC;QAED,4BAA4B;QAC5B,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACjB,MAAM,SAAS,CAAC,IAAI,EAAE,CAAA;QACxB,CAAC;;;;;;;;;;;CACF","sourcesContent":["import { isEnoentError, readJsonFile } from './fs.js'\nimport { LexInstaller, LexInstallerOptions } from './lex-installer.js'\nimport {\n  LexiconsManifest,\n  lexiconsManifestSchema,\n} from './lexicons-manifest.js'\n\nexport type LexInstallOptions = LexInstallerOptions & {\n  add?: string[]\n  save?: boolean\n  ci?: boolean\n}\n\nexport async function install(options: LexInstallOptions) {\n  const manifest: LexiconsManifest | undefined = await readJsonFile(\n    options.manifest,\n  ).then(\n    (json) => lexiconsManifestSchema.parse(json),\n    (cause: unknown) => {\n      if (isEnoentError(cause)) return undefined\n      throw new Error('Failed to read lexicons manifest', { cause })\n    },\n  )\n\n  const additions = new Set(options.add)\n\n  // Perform the installation using the existing manifest as \"hint\"\n  await using installer = new LexInstaller(options)\n\n  await installer.install({ additions, manifest })\n\n  // Verify lockfile\n  if (options.ci && (!manifest || !installer.equals(manifest))) {\n    throw new Error('Lexicons manifest is out of date')\n  }\n\n  // Save changes if requested\n  if (options.save) {\n    await installer.save()\n  }\n}\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAkGA,0BA2BC;;AA7HD,mCAAqD;AACrD,yDAAsE;AACtE,iEAG+B;AA2C/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACI,KAAK,UAAU,OAAO,CAAC,OAA0B;;;QACtD,MAAM,QAAQ,GAAiC,MAAM,IAAA,oBAAY,EAC/D,OAAO,CAAC,QAAQ,CACjB,CAAC,IAAI,CACJ,CAAC,IAAI,EAAE,EAAE,CAAC,6CAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,EAC5C,CAAC,KAAc,EAAE,EAAE;YACjB,IAAI,IAAA,qBAAa,EAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAA;YAC1C,MAAM,IAAI,KAAK,CAAC,kCAAkC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAA;QAChE,CAAC,CACF,CAAA;QAED,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAEtC,iEAAiE;QACjE,MAAY,SAAS,0CAAG,IAAI,+BAAY,CAAC,OAAO,CAAC,OAAA,CAAA;QAEjD,MAAM,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAA;QAEhD,kBAAkB;QAClB,IAAI,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAA;QACrD,CAAC;QAED,4BAA4B;QAC5B,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACjB,MAAM,SAAS,CAAC,IAAI,EAAE,CAAA;QACxB,CAAC;;;;;;;;;;;CACF","sourcesContent":["import { isEnoentError, readJsonFile } from './fs.js'\nimport { LexInstaller, LexInstallerOptions } from './lex-installer.js'\nimport {\n  LexiconsManifest,\n  lexiconsManifestSchema,\n} from './lexicons-manifest.js'\n\n/**\n * Options for the {@link install} function.\n *\n * Extends {@link LexInstallerOptions} with additional options for controlling\n * the installation behavior.\n *\n * @example\n * ```typescript\n * const options: LexInstallOptions = {\n *   lexicons: './lexicons',\n *   manifest: './lexicons.manifest.json',\n *   add: ['com.example.myLexicon', 'at://did:plc:xyz/com.example.otherLexicon'],\n *   save: true,\n *   ci: false,\n * }\n * ```\n */\nexport type LexInstallOptions = LexInstallerOptions & {\n  /**\n   * Array of lexicons to add to the installation. Can be NSID strings\n   * (e.g., 'com.example.myLexicon') or AT URIs\n   * (e.g., 'at://did:plc:xyz/com.example.myLexicon').\n   */\n  add?: string[]\n\n  /**\n   * Whether to save the updated manifest after installation.\n   * When `true`, the manifest file will be written with any new lexicons.\n   * @default false\n   */\n  save?: boolean\n\n  /**\n   * Enable CI mode for strict manifest verification.\n   * When `true`, throws an error if the manifest is out of date,\n   * useful for continuous integration pipelines.\n   * @default false\n   */\n  ci?: boolean\n}\n\n/**\n * Installs lexicons from the network based on the provided options.\n *\n * This is the main entry point for programmatic lexicon installation.\n * It reads an existing manifest (if present), installs any new lexicons,\n * and optionally saves the updated manifest.\n *\n * @param options - Configuration options for the installation\n * @throws {Error} When the manifest file cannot be read (unless it doesn't exist)\n * @throws {Error} When in CI mode and the manifest is out of date\n *\n * @example\n * Install lexicons and save the manifest:\n * ```typescript\n * import { install } from '@atproto/lex-installer'\n *\n * await install({\n *   lexicons: './lexicons',\n *   manifest: './lexicons.manifest.json',\n *   add: ['app.bsky.feed.post', 'app.bsky.actor.profile'],\n *   save: true,\n * })\n * ```\n *\n * @example\n * Verify manifest in CI pipeline:\n * ```typescript\n * import { install } from '@atproto/lex-installer'\n *\n * // Throws if manifest is out of date\n * await install({\n *   lexicons: './lexicons',\n *   manifest: './lexicons.manifest.json',\n *   ci: true,\n * })\n * ```\n *\n * @example\n * Install from specific AT URIs:\n * ```typescript\n * import { install } from '@atproto/lex-installer'\n *\n * await install({\n *   lexicons: './lexicons',\n *   manifest: './lexicons.manifest.json',\n *   add: ['at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post'],\n *   save: true,\n * })\n * ```\n */\nexport async function install(options: LexInstallOptions) {\n  const manifest: LexiconsManifest | undefined = await readJsonFile(\n    options.manifest,\n  ).then(\n    (json) => lexiconsManifestSchema.parse(json),\n    (cause: unknown) => {\n      if (isEnoentError(cause)) return undefined\n      throw new Error('Failed to read lexicons manifest', { cause })\n    },\n  )\n\n  const additions = new Set(options.add)\n\n  // Perform the installation using the existing manifest as \"hint\"\n  await using installer = new LexInstaller(options)\n\n  await installer.install({ additions, manifest })\n\n  // Verify lockfile\n  if (options.ci && (!manifest || !installer.equals(manifest))) {\n    throw new Error('Lexicons manifest is out of date')\n  }\n\n  // Save changes if requested\n  if (options.save) {\n    await installer.save()\n  }\n}\n"]}

package/dist/lex-installer.d.ts

@@ -6,11 +6,81 @@ import { AtUri, NSID } from '@atproto/syntax';
 import { LexiconsManifest } from './lexicons-manifest.js';
 import { NsidMap } from './nsid-map.js';
 import { NsidSet } from './nsid-set.js';
+/**
+ * Configuration options for the {@link LexInstaller} class.
+ *
+ * Extends {@link LexResolverOptions} with paths for lexicon storage
+ * and manifest management.
+ *
+ * @example
+ * ```typescript
+ * const options: LexInstallerOptions = {
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ *   update: false,
+ * }
+ * ```
+ */
 export type LexInstallerOptions = LexResolverOptions & {
+    /**
+     * Path to the directory where lexicon JSON files will be stored.
+     * The directory structure mirrors the NSID hierarchy
+     * (e.g., 'app.bsky.feed.post' becomes 'app/bsky/feed/post.json').
+     */
     lexicons: string;
+    /**
+     * Path to the manifest file that tracks installed lexicons and their resolutions.
+     */
     manifest: string;
+    /**
+     * When `true`, forces re-fetching of lexicons from the network even if they
+     * already exist locally. Useful for updating to newer versions.
+     * @default false
+     */
     update?: boolean;
 };
+/**
+ * Manages the installation of Lexicon schemas from the AT Protocol network.
+ *
+ * The `LexInstaller` class handles fetching, caching, and organizing lexicon
+ * documents. It tracks dependencies between lexicons and ensures all referenced
+ * schemas are installed. The class implements `AsyncDisposable` for proper
+ * resource cleanup.
+ *
+ * @example
+ * Basic usage with async disposal:
+ * ```typescript
+ * import { LexInstaller } from '@atproto/lex-installer'
+ *
+ * await using installer = new LexInstaller({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ * })
+ *
+ * await installer.install({
+ *   additions: ['app.bsky.feed.post'],
+ * })
+ *
+ * await installer.save()
+ * // Resources automatically cleaned up when block exits
+ * ```
+ *
+ * @example
+ * Manual disposal:
+ * ```typescript
+ * const installer = new LexInstaller({
+ *   lexicons: './lexicons',
+ *   manifest: './lexicons.manifest.json',
+ * })
+ *
+ * try {
+ *   await installer.install({ additions: ['app.bsky.actor.profile'] })
+ *   await installer.save()
+ * } finally {
+ *   await installer[Symbol.asyncDispose]()
+ * }
+ * ```
+ */
 export declare class LexInstaller implements AsyncDisposable {
     protected readonly options: LexInstallerOptions;
     protected readonly lexiconResolver: LexResolver;
@@ -2101,7 +2171,57 @@ export declare class LexInstaller implements AsyncDisposable {
     protected readonly manifest: LexiconsManifest;
     constructor(options: LexInstallerOptions);
     [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Compares the current manifest state with another manifest for equality.
+     *
+     * Both manifests are normalized before comparison to ensure consistent
+     * ordering of entries. Useful for detecting changes during CI verification.
+     *
+     * @param manifest - The manifest to compare against
+     * @returns `true` if the manifests are equivalent, `false` otherwise
+     */
     equals(manifest: LexiconsManifest): boolean;
+    /**
+     * Installs lexicons and their dependencies.
+     *
+     * This method processes explicit additions and restores entries from an
+     * existing manifest. It recursively resolves and installs all referenced
+     * lexicons to ensure complete dependency trees.
+     *
+     * @param options - Installation options
+     * @param options.additions - Iterable of lexicon identifiers to add.
+     *   Can be NSID strings or AT URIs.
+     * @param options.manifest - Existing manifest to use as a baseline.
+     *   Previously resolved URIs are preserved unless explicitly overridden.
+     *
+     * @example
+     * Install new lexicons:
+     * ```typescript
+     * await installer.install({
+     *   additions: ['app.bsky.feed.post', 'app.bsky.actor.profile'],
+     * })
+     * ```
+     *
+     * @example
+     * Install with existing manifest as hint:
+     * ```typescript
+     * const existingManifest = await readJsonFile('./lexicons.manifest.json')
+     * await installer.install({
+     *   additions: ['com.example.newLexicon'],
+     *   manifest: existingManifest,
+     * })
+     * ```
+     *
+     * @example
+     * Install from specific AT URIs:
+     * ```typescript
+     * await installer.install({
+     *   additions: [
+     *     'at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post',
+     *   ],
+     * })
+     * ```
+     */
     install({ additions, manifest, }?: {
         additions?: Iterable<string>;
         manifest?: LexiconsManifest;
@@ -2115,10 +2235,25 @@ export declare class LexInstaller implements AsyncDisposable {
         lexicon: LexiconDocument;
         uri: AtUri;
     }>;
+    /**
+     * Fetches a lexicon document from the network and saves it locally.
+     *
+     * The lexicon is retrieved from the specified AT URI, written to the
+     * local lexicons directory, and its metadata is recorded for the manifest.
+     *
+     * @param uri - The AT URI pointing to the lexicon document
+     * @returns An object containing the fetched lexicon document and its CID
+     */
     fetch(uri: AtUri): Promise<{
         lexicon: LexiconDocument;
         cid: Cid;
     }>;
+    /**
+     * Saves the current manifest to disk.
+     *
+     * The manifest is normalized before saving to ensure consistent ordering
+     * of entries, making it suitable for version control.
+     */
     save(): Promise<void>;
 }
 //# sourceMappingURL=lex-installer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lex-installer.d.ts","sourceRoot":"","sources":["../src/lex-installer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,OAAO,EAAE,GAAG,EAAa,MAAM,mBAAmB,CAAA;AAClD,OAAO,EACL,eAAe,EAQhB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAEvE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG;IACrD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qBAAa,YAAa,YAAW,eAAe;IAUtC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB;IAT3D,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAA;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACnD,SAAS,CAAC,QAAQ,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAiC;IAC7D,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAI5C;gBAE8B,OAAO,EAAE,mBAAmB;IAOrD,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO;IAOrC,OAAO,CAAC,EACZ,SAAS,EACT,QAAQ,GACT,GAAE;QACD,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;QAC5B,QAAQ,CAAC,EAAE,gBAAgB,CAAA;KACvB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0EtB,SAAS,CAAC,aAAa,IAAI,OAAO;cAclB,eAAe,CAAC,IAAI,EAAE,IAAI;iBAM/B,eAAe;aACnB,KAAK;;cAFI,cAAc,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC;QAClD,OAAO,EAAE,eAAe,CAAA;QACxB,GAAG,EAAE,KAAK,CAAA;KACX,CAAC;IAwBI,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;IAalE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}
+{"version":3,"file":"lex-installer.d.ts","sourceRoot":"","sources":["../src/lex-installer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,OAAO,EAAE,GAAG,EAAa,MAAM,mBAAmB,CAAA;AAClD,OAAO,EACL,eAAe,EAQhB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAEvE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,EACL,gBAAgB,EAEjB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG;IACrD;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,YAAa,YAAW,eAAe;IAUtC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB;IAT3D,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAA;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACnD,SAAS,CAAC,QAAQ,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAiC;IAC7D,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAI5C;gBAE8B,OAAO,EAAE,mBAAmB;IAOrD,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO;IAO3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,OAAO,CAAC,EACZ,SAAS,EACT,QAAQ,GACT,GAAE;QACD,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;QAC5B,QAAQ,CAAC,EAAE,gBAAgB,CAAA;KACvB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0EtB,SAAS,CAAC,aAAa,IAAI,OAAO;cAclB,eAAe,CAAC,IAAI,EAAE,IAAI;iBAM/B,eAAe;aACnB,KAAK;;cAFI,cAAc,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC;QAClD,OAAO,EAAE,eAAe,CAAA;QACxB,GAAG,EAAE,KAAK,CAAA;KACX,CAAC;IAwBF;;;;;;;;OAQG;IACG,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;IAaxE;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}