honkit 6.0.4 → 6.1.5

package/lib/__tests__/__fixtures__/honkit/book.d.ts

@@ -0,0 +1,7 @@
+export let root: string;
+export let title: string;
+export let gitbook: string;
+export namespace variables {
+    let version: string;
+}
+//# sourceMappingURL=book.d.ts.map

package/lib/__tests__/__fixtures__/honkit/book.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"book.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/__fixtures__/honkit/book.js"],"names":[],"mappings":""}

package/lib/__tests__/__fixtures__/honkit/book.js

@@ -0,0 +1,9 @@
+module.exports = {
+    root: "./docs",
+    title: "HonKit Documentation",
+    // Enforce use of HonKit v3
+    gitbook: "3.1.1",
+    variables: {
+        version: "3.1.1",
+    },
+};

package/lib/__tests__/e2e.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=e2e.test.d.ts.map

package/lib/__tests__/e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/e2e.test.ts"],"names":[],"mappings":""}

package/lib/__tests__/e2e.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bin_1 = require("../bin");
+const path_1 = __importDefault(require("path"));
+const jest_mock_process_1 = require("jest-mock-process");
+const jest_serializer_strip_ansi_1 = require("@relmify/jest-serializer-strip-ansi");
+const CWD = process.cwd();
+const cwdPlugin = {
+    test: (value) => typeof value === "string" && value.includes(CWD),
+    print: (value, serialize) => {
+        if (typeof value === "string") {
+            return serialize(value.split(CWD).join("<CWD>").replace(/\\/g, "/"));
+        }
+        return value;
+    },
+};
+expect.addSnapshotSerializer(jest_serializer_strip_ansi_1.stripAnsi);
+expect.addSnapshotSerializer(cwdPlugin);
+describe("e2e", function () {
+    let stdoutMock;
+    beforeEach(() => {
+        stdoutMock = (0, jest_mock_process_1.mockProcessStdout)();
+    });
+    afterEach(() => {
+        stdoutMock.mockRestore();
+    });
+    it("`honkit parse` for multilang", async () => {
+        await (0, bin_1.run)([process.argv[0], "honkit", "parse", path_1.default.join(__dirname, "__fixtures__/multilang")]);
+        expect(stdoutMock.mock.calls).toMatchInlineSnapshot(`
+            [
+              [
+                "info: parsing multilingual book, with 2 languages 
+            ",
+              ],
+              [
+                "warn: no summary file in this book 
+            ",
+              ],
+              [
+                "warn: no summary file in this book 
+            ",
+              ],
+              [
+                "info: Book located in: <CWD>/src/__tests__/__fixtures__/multilang 
+            ",
+              ],
+              [
+                "info: 2 languages 
+            ",
+              ],
+              [
+                "info: Language: English 
+            ",
+              ],
+              [
+                "info: Introduction file is README.md 
+            ",
+              ],
+              [
+                "info:  
+            ",
+              ],
+              [
+                "info: Language: Japanese 
+            ",
+              ],
+              [
+                "info: Introduction file is README.md 
+            ",
+              ],
+              [
+                "info:  
+            ",
+              ],
+            ]
+        `);
+    });
+});

package/lib/__tests__/init.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.d.ts.map

package/lib/__tests__/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/__tests__/init.ts"],"names":[],"mappings":""}

package/lib/__tests__/init.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tmp_1 = __importDefault(require("tmp"));
+const init_1 = __importDefault(require("../init"));
+describe("initBook", () => {
+    let dir;
+    beforeEach(() => {
+        dir = tmp_1.default.dirSync();
+    });
+    test("should create a README and SUMMARY for empty book", () => {
+        return (0, init_1.default)(dir.name).then(() => {
+            expect(dir.name).toHaveFile("README.md");
+            expect(dir.name).toHaveFile("SUMMARY.md");
+        });
+    });
+});

package/lib/__tests__/satisfies.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=satisfies.d.ts.map

package/lib/__tests__/satisfies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"satisfies.d.ts","sourceRoot":"","sources":["../../src/__tests__/satisfies.ts"],"names":[],"mappings":""}

package/lib/__tests__/satisfies.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const honkit_1 = __importDefault(require("../honkit"));
+describe("satisfies", () => {
+    test("should return true for *", () => {
+        expect(honkit_1.default.satisfies("*")).toBe(true);
+    });
+});

package/lib/__tests__/snapshot-asciidoc.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot-asciidoc.d.ts.map

package/lib/__tests__/snapshot-asciidoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-asciidoc.d.ts","sourceRoot":"","sources":["../../src/__tests__/snapshot-asciidoc.ts"],"names":[],"mappings":""}

package/lib/__tests__/snapshot-asciidoc.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const internal_test_utils_1 = require("@honkit/internal-test-utils");
+const bin = __importStar(require("../bin"));
+it("asciidoc snapshot", async () => {
+    const bookDir = path_1.default.join(__dirname, "__fixtures__/asciidoc");
+    const outputDir = path_1.default.join(__dirname, "__fixtures__/asciidoc/_book");
+    await bin.run([process.argv[0], ".", "build", bookDir, "--reload"]);
+    const maskContent = (content) => {
+        return content
+            .replace(/gitbook\.page\.hasChanged\(.*\);/g, ``)
+            .replace(/<meta name="generator" content="HonKit .*">/g, "");
+    };
+    for await (const item of (0, internal_test_utils_1.iterateDirectoryContents)({
+        baseDir: outputDir,
+        allowExtensions: [".html"],
+        maskContent
+    })) {
+        expect(item).toMatchSnapshot(item.filePath);
+    }
+}, 60 * 1000);

package/lib/__tests__/snapshot-honkit.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot-honkit.d.ts.map

package/lib/__tests__/snapshot-honkit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-honkit.d.ts","sourceRoot":"","sources":["../../src/__tests__/snapshot-honkit.ts"],"names":[],"mappings":""}

package/lib/__tests__/snapshot-honkit.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const internal_test_utils_1 = require("@honkit/internal-test-utils");
+const bin = __importStar(require("../bin"));
+it("HonKit snapshots", async () => {
+    const bookDir = path_1.default.join(__dirname, "__fixtures__/honkit");
+    const outputDir = path_1.default.join(__dirname, "__fixtures__/honkit/_book");
+    await bin.run([process.argv[0], ".", "build", bookDir, "--reload"]);
+    const maskContent = (content) => {
+        return content
+            .replace(/gitbook\.page\.hasChanged\(.*\);/g, ``)
+            .replace(/<meta name="generator" content="HonKit .*">/g, "");
+    };
+    for await (const item of (0, internal_test_utils_1.iterateDirectoryContents)({
+        baseDir: outputDir,
+        allowExtensions: [".html"],
+        maskContent
+    })) {
+        expect(item).toMatchSnapshot(item.filePath);
+    }
+}, 60 * 1000);

package/lib/cli/__tests__/watch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watch.test.d.ts.map

package/lib/cli/__tests__/watch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.test.d.ts","sourceRoot":"","sources":["../../../src/cli/__tests__/watch.test.ts"],"names":[],"mappings":""}

package/lib/cli/__tests__/watch.test.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const watch_1 = __importDefault(require("../watch"));
+/**
+ * Normalize path separators to forward slashes for cross-platform comparison
+ */
+function normalizePath(filepath) {
+    return filepath.replace(/\\/g, "/");
+}
+describe("watch", () => {
+    // Increase timeout for file system operations (Windows may need more time)
+    jest.setTimeout(30000);
+    let tempDir;
+    let watchers = [];
+    beforeEach(() => {
+        tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "honkit-watch-test-"));
+    });
+    afterEach(async () => {
+        // Close all watchers
+        await Promise.all(watchers.map((w) => w.close()));
+        watchers = [];
+        // Cleanup temp directory
+        if (tempDir && fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    function createFile(relativePath, content = "# Test") {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    function modifyFile(relativePath, content) {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    /**
+     * Wait for watcher to be ready and stable
+     */
+    async function waitForReady(watcher) {
+        await new Promise((resolve) => {
+            watcher.on("ready", resolve);
+        });
+        // Give the watcher a moment to stabilize after ready event
+        // Windows needs more time for file system operations
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    /**
+     * Wait for a file change to be detected that matches the predicate
+     * Paths are normalized to forward slashes for cross-platform compatibility
+     */
+    function waitForChange(watcher, predicate, timeoutMs = 20000) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Timeout waiting for file change after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const handler = (_event, filepath) => {
+                const fullPath = normalizePath(path_1.default.resolve(tempDir, filepath));
+                if (predicate(fullPath)) {
+                    clearTimeout(timeout);
+                    watcher.off("all", handler);
+                    resolve(fullPath);
+                }
+            };
+            watcher.on("all", handler);
+        });
+    }
+    describe("issue #491 - custom output folder handling", () => {
+        it("should detect changes in custom output folder when not specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITHOUT specifying output folder
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify file in output folder and wait for detection
+            modifyFile("output/orphan.md", "# Modified");
+            const detected = await waitForChange(watcher, (f) => f.includes("output/orphan.md"));
+            expect(detected).toContain("output/orphan.md");
+        });
+        it("should NOT detect changes in custom output folder when specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITH output folder specified - it should be ignored
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: "output",
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files - output should be ignored, README should be detected
+            modifyFile("output/orphan.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change to be detected (proves watcher is working)
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify output folder change was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+        it("should handle absolute output folder paths", async () => {
+            createFile("README.md", "# README");
+            createFile("docs-output/file.md", "# File");
+            const detectedFiles = [];
+            const absoluteOutputPath = path_1.default.join(tempDir, "docs-output");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: absoluteOutputPath,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files
+            modifyFile("docs-output/file.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify docs-output was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("docs-output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+    });
+    describe("default _book folder", () => {
+        it("should NOT detect changes in _book folder", async () => {
+            createFile("file1.md", "# File 1");
+            createFile("file2.md", "# File 2");
+            createFile("_book/output.md", "# Output");
+            const detectedFiles = [];
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // First modify file1 to ensure watcher is working
+            modifyFile("file1.md", "# Modified File 1");
+            await waitForChange(watcher, (f) => f.includes("file1.md"));
+            // Now modify _book file (should be ignored)
+            modifyFile("_book/output.md", "# Modified");
+            // Modify file2 to confirm watcher still works
+            modifyFile("file2.md", "# Modified File 2");
+            await waitForChange(watcher, (f) => f.includes("file2.md"));
+            // Verify _book was NOT detected
+            const bookChanges = detectedFiles.filter((f) => f.includes("_book"));
+            expect(bookChanges).toHaveLength(0);
+        });
+    });
+    describe("source files", () => {
+        it("should detect changes to markdown files in source directory", async () => {
+            createFile("README.md", "# README");
+            createFile("orphan.md", "# Orphan - not in SUMMARY");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: () => { }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            modifyFile("orphan.md", "# Modified orphan");
+            const detected = await waitForChange(watcher, (f) => f.includes("orphan.md"));
+            expect(detected).toContain("orphan.md");
+        });
+    });
+});

package/lib/cli/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4IA,wBA6DE"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkJA,wBA6DE"}

package/lib/cli/serve.js

@@ -62,51 +62,57 @@ function startServer(args, kwargs) {
             return waitForCtrlC();
         }
         // update book immutably. does not use book again
-        return (0, watch_1.default)(book.getRoot(), (error, filepath) => {
-            if (error) {
-                console.error(error);
-                return;
-            }
-            // If the file does not exist in file system, show a warning and skip
-            // Probably, the file has been deleted
-            if (!fs_1.default.existsSync(filepath)) {
-                logger.warn.ok(`${filepath} does not exist in file system.`);
-                return;
-            }
-            // set livereload path
-            lrPath = filepath;
-            // TODO: use parse extension
-            // Incremental update for pages
-            if (lastOutput && filepath.endsWith(".md")) {
-                logger.warn.ok("Rebuild " + filepath);
-                const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
-                    incrementalChangeFileSet: immutable_1.default.Set([filepath])
-                });
-                return incrementalBuild({
-                    output: changedOutput,
-                    Generator
-                }).then(() => {
-                    if (lrPath && hasLiveReloading) {
-                        // trigger livereload
-                        lrServer.changed({
-                            body: {
-                                files: [lrPath]
-                            }
-                        });
-                    }
+        // Pass outputFolder to watch to prevent infinite rebuild loops
+        // https://github.com/honkit/honkit/issues/491
+        (0, watch_1.default)({
+            watchDir: book.getRoot(),
+            outputFolder,
+            callback: (error, filepath) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                // If the file does not exist in file system, show a warning and skip
+                // Probably, the file has been deleted
+                if (!fs_1.default.existsSync(filepath)) {
+                    logger.warn.ok(`${filepath} does not exist in file system.`);
+                    return;
+                }
+                // set livereload path
+                lrPath = filepath;
+                // TODO: use parse extension
+                // Incremental update for pages
+                if (lastOutput && filepath.endsWith(".md")) {
+                    logger.warn.ok("Rebuild " + filepath);
+                    const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
+                        incrementalChangeFileSet: immutable_1.default.Set([filepath])
+                    });
+                    return incrementalBuild({
+                        output: changedOutput,
+                        Generator
+                    }).then(() => {
+                        if (lrPath && hasLiveReloading) {
+                            // trigger livereload
+                            lrServer.changed({
+                                body: {
+                                    files: [lrPath]
+                                }
+                            });
+                        }
+                    });
+                }
+                // Asciidoc files are not supported for incremental build
+                logger.info.ok("Rebuild " + filepath);
+                return generateBook({
+                    book,
+                    outputFolder,
+                    hasLiveReloading,
+                    Generator,
+                    reload
+                }).then((output) => {
+                    lastOutput = output;
                 });
             }
-            // Asciidoc files are not supported for incremental build
-            logger.info.ok("Rebuild " + filepath);
-            return generateBook({
-                book,
-                outputFolder,
-                hasLiveReloading,
-                Generator,
-                reload
-            }).then((output) => {
-                lastOutput = output;
-            });
         });
     });
 }

package/lib/cli/watch.d.ts

@@ -1,10 +1,26 @@
+import { FSWatcher } from "chokidar";
+export interface WatchOptions {
+    /**
+     * Directory to watch
+     */
+    watchDir: string;
+    /**
+     * Callback when a file is modified
+     */
+    callback: (error: Error | null, filepath?: string) => void;
+    /**
+     * Output folder to ignore (in addition to _book and node_modules)
+     * This prevents infinite rebuild loops when using custom output folders
+     * @see https://github.com/honkit/honkit/issues/491
+     */
+    outputFolder?: string;
+}
 /**
- Watch a folder and resolve promise once a file is modified
-
- @param {string} dir
- @param callback
- @return {Promise}
+ * Watch a folder and call callback when a file is modified
+ *
+ * @param {WatchOptions} options
+ * @return {FSWatcher} The chokidar watcher instance
  */
-declare function watch(dir: any, callback: any): void;
+declare function watch(options: WatchOptions): FSWatcher;
 export default watch;
 //# sourceMappingURL=watch.d.ts.map

package/lib/cli/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,iBAAS,KAAK,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,QAwB3B;AAED,eAAe,KAAK,CAAC"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AACA,OAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,iBAAS,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CA0C/C;AAED,eAAe,KAAK,CAAC"}