fix

book/node_modules/honkit/lib/cli/build.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    name: string;
+    description: string;
+    options: ({
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    } | {
+        name: string;
+        description: string;
+        defaults: boolean;
+    })[];
+    exec: (args: any, kwargs: any) => any;
+};
+export default _default;
+//# sourceMappingURL=build.d.ts.map

book/node_modules/honkit/lib/cli/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAQA,wBAsBE"}

book/node_modules/honkit/lib/cli/build.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const getOutputFolder_1 = __importDefault(require("./getOutputFolder"));
+const page_cache_1 = require("../output/page-cache");
+exports.default = {
+    name: "build [book] [output]",
+    description: "build a book",
+    options: [options_1.default.log, options_1.default.format, options_1.default.timing, options_1.default.reload],
+    exec: function (args, kwargs) {
+        const book = (0, getBook_1.default)(args, kwargs);
+        const outputFolder = (0, getOutputFolder_1.default)(args);
+        const Generator = output_1.default.getGenerator(kwargs.format);
+        if (kwargs.reload) {
+            book.getLogger().info.ok(`Clear cache`);
+            (0, page_cache_1.clearCache)();
+        }
+        return parse_1.default.parseBook(book)
+            .then((resultBook) => {
+            return output_1.default.generate(Generator, resultBook, {
+                root: outputFolder
+            });
+        })
+            .fin(() => {
+            if (kwargs.timing)
+                timing_1.default.dump(book.getLogger());
+        });
+    }
+};

book/node_modules/honkit/lib/cli/buildEbook.d.ts

@@ -0,0 +1,12 @@
+export default function (format: any): {
+    name: string;
+    description: string;
+    options: {
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    }[];
+    exec: (args: any, kwargs: any) => any;
+};
+//# sourceMappingURL=buildEbook.d.ts.map

book/node_modules/honkit/lib/cli/buildEbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildEbook.d.ts","sourceRoot":"","sources":["../../src/cli/buildEbook.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,OAAO,WAAW,MAAM,KAAA;;;;;;;;;;EA4D9B"}

book/node_modules/honkit/lib/cli/buildEbook.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const path_1 = __importDefault(require("path"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const page_cache_1 = require("../output/page-cache");
+const tmpdir_1 = require("../fs/tmpdir");
+function default_1(format) {
+    return {
+        name: `${format} [book] [output]`,
+        description: "build a book into an ebook file",
+        options: [options_1.default.log],
+        exec: function (args, kwargs) {
+            const extension = `.${format}`;
+            // Output file will be stored in
+            const outputFile = args[1] || `book${extension}`;
+            // Create temporary directory
+            const outputFolder = (0, tmpdir_1.createTmpDirWithRealPath)();
+            const book = (0, getBook_1.default)(args, kwargs);
+            const logger = book.getLogger();
+            const Generator = output_1.default.getGenerator("ebook");
+            if (kwargs.reload) {
+                (0, page_cache_1.clearCache)();
+            }
+            return (parse_1.default.parseBook(book)
+                .then((resultBook) => {
+                return output_1.default.generate(Generator, resultBook, {
+                    root: outputFolder,
+                    format: format
+                });
+            })
+                // Extract ebook file
+                .then((output) => {
+                const book = output.getBook();
+                const languages = book.getLanguages();
+                if (book.isMultilingual()) {
+                    return promise_1.default.forEach(languages.getList(), (lang) => {
+                        const langID = lang.getID();
+                        const langOutputFile = path_1.default.join(path_1.default.dirname(outputFile), `${path_1.default.basename(outputFile, extension)}_${langID}${extension}`);
+                        return fs_1.default.copy(path_1.default.resolve(outputFolder, langID, `index${extension}`), langOutputFile);
+                    }).thenResolve(languages.getCount());
+                }
+                else {
+                    return fs_1.default.copy(path_1.default.resolve(outputFolder, `index${extension}`), outputFile).thenResolve(1);
+                }
+            })
+                // Log end
+                .then((count) => {
+                logger.info.ok(`${count} file(s) generated`);
+                logger.debug("cleaning up... ");
+                return logger.debug.promise(fs_1.default.rmDir(outputFolder));
+            }));
+        }
+    };
+}

book/node_modules/honkit/lib/cli/getBook.d.ts

@@ -0,0 +1,12 @@
+import Book from "../models/book";
+/**
+ Return a book instance to work on from
+ command line args/kwargs
+
+ @param {Array} args
+ @param {Object} kwargs
+ @return {Book}
+ */
+declare function getBook(args: any, kwargs: any): Book;
+export default getBook;
+//# sourceMappingURL=getBook.d.ts.map

book/node_modules/honkit/lib/cli/getBook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBook.d.ts","sourceRoot":"","sources":["../../src/cli/getBook.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,gBAAgB,CAAC;AAGlC;;;;;;;GAOG;AAEH,iBAAS,OAAO,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,QAS5B;AAED,eAAe,OAAO,CAAC"}

book/node_modules/honkit/lib/cli/getBook.js

@@ -0,0 +1,24 @@
+"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 book_1 = __importDefault(require("../models/book"));
+const node_1 = __importDefault(require("../fs/node"));
+/**
+ Return a book instance to work on from
+ command line args/kwargs
+
+ @param {Array} args
+ @param {Object} kwargs
+ @return {Book}
+ */
+function getBook(args, kwargs) {
+    const input = path_1.default.resolve(args[0] || process.cwd());
+    const logLevel = kwargs.log;
+    const fs = (0, node_1.default)(input);
+    const book = book_1.default.createForFS(fs);
+    return book.setLogLevel(logLevel);
+}
+exports.default = getBook;

book/node_modules/honkit/lib/cli/getOutputFolder.d.ts

@@ -0,0 +1,9 @@
+/**
+ Return path to output folder
+
+ @param {Array} args
+ @return {string}
+ */
+declare function getOutputFolder(args: any): string;
+export default getOutputFolder;
+//# sourceMappingURL=getOutputFolder.d.ts.map

book/node_modules/honkit/lib/cli/getOutputFolder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOutputFolder.d.ts","sourceRoot":"","sources":["../../src/cli/getOutputFolder.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,iBAAS,eAAe,CAAC,IAAI,KAAA,UAM5B;AAED,eAAe,eAAe,CAAC"}

book/node_modules/honkit/lib/cli/getOutputFolder.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 path_1 = __importDefault(require("path"));
+/**
+ Return path to output folder
+
+ @param {Array} args
+ @return {string}
+ */
+function getOutputFolder(args) {
+    const bookRoot = path_1.default.resolve(args[0] || process.cwd());
+    const defaultOutputRoot = path_1.default.join(bookRoot, "_book");
+    const outputFolder = args[1] ? path_1.default.resolve(process.cwd(), args[1]) : defaultOutputRoot;
+    return outputFolder;
+}
+exports.default = getOutputFolder;

book/node_modules/honkit/lib/cli/index.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    name: string;
+    description: string;
+    options: ({
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    } | {
+        name: string;
+        description: string;
+        defaults: boolean;
+    } | {
+        name: string;
+        description: string;
+        defaults: number;
+    } | {
+        name: string;
+        description: string;
+        defaults: string;
+    })[];
+    exec: (args: any, kwargs: any) => any;
+}[];
+export default _default;
+//# sourceMappingURL=index.d.ts.map

book/node_modules/honkit/lib/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAKA,wBAAsG"}

book/node_modules/honkit/lib/cli/index.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 buildEbook_1 = __importDefault(require("./buildEbook"));
+const build_1 = __importDefault(require("./build"));
+const serve_1 = __importDefault(require("./serve"));
+const parse_1 = __importDefault(require("./parse"));
+const init_1 = __importDefault(require("./init"));
+exports.default = [build_1.default, serve_1.default, parse_1.default, init_1.default, (0, buildEbook_1.default)("pdf"), (0, buildEbook_1.default)("epub"), (0, buildEbook_1.default)("mobi")];

book/node_modules/honkit/lib/cli/init.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    name: string;
+    description: string;
+    options: {
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    }[];
+    exec: (args: any, kwargs: any) => any;
+};
+export default _default;
+//# sourceMappingURL=init.d.ts.map

book/node_modules/honkit/lib/cli/init.d.ts.map

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

book/node_modules/honkit/lib/cli/init.js

@@ -0,0 +1,17 @@
+"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 options_1 = __importDefault(require("./options"));
+const init_1 = __importDefault(require("../init"));
+exports.default = {
+    name: "init [book]",
+    description: "setup and create files for chapters",
+    options: [options_1.default.log],
+    exec: function (args, kwargs) {
+        const bookRoot = path_1.default.resolve(process.cwd(), args[0] || "./");
+        return (0, init_1.default)(bookRoot);
+    }
+};

book/node_modules/honkit/lib/cli/options.d.ts

@@ -0,0 +1,26 @@
+declare const _default: {
+    log: {
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    };
+    format: {
+        name: string;
+        description: string;
+        values: string[];
+        defaults: string;
+    };
+    timing: {
+        name: string;
+        description: string;
+        defaults: boolean;
+    };
+    reload: {
+        name: string;
+        description: string;
+        defaults: boolean;
+    };
+};
+export default _default;
+//# sourceMappingURL=options.d.ts.map

book/node_modules/honkit/lib/cli/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/cli/options.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAgCA,wBAKE"}

book/node_modules/honkit/lib/cli/options.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("../utils/logger"));
+const logOptions = {
+    name: "log",
+    description: "Minimum log level to display",
+    values: logger_1.default.LEVELS.keySeq()
+        .map((s) => {
+        return s.toLowerCase();
+    })
+        .toJS(),
+    defaults: "info"
+};
+const formatOption = {
+    name: "format",
+    description: "Format to build to",
+    values: ["website", "json", "ebook"],
+    defaults: "website"
+};
+const timingOption = {
+    name: "timing",
+    description: "Print timing debug information",
+    defaults: false
+};
+const reloadOption = {
+    name: "reload",
+    description: "Prune cache. Remove file cache",
+    defaults: false
+};
+exports.default = {
+    log: logOptions,
+    format: formatOption,
+    timing: timingOption,
+    reload: reloadOption
+};

book/node_modules/honkit/lib/cli/parse.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    name: string;
+    description: string;
+    options: {
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    }[];
+    exec: (args: any, kwargs: any) => any;
+};
+export default _default;
+//# sourceMappingURL=parse.d.ts.map

book/node_modules/honkit/lib/cli/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/cli/parse.ts"],"names":[],"mappings":";;;;;;;;;;;AAmDA,wBAwBE"}

book/node_modules/honkit/lib/cli/parse.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const parse_1 = __importDefault(require("../parse"));
+function printBook(book) {
+    const logger = book.getLogger();
+    const config = book.getConfig();
+    const configFile = config.getFile();
+    const summary = book.getSummary();
+    const summaryFile = summary.getFile();
+    const readme = book.getReadme();
+    const readmeFile = readme.getFile();
+    const glossary = book.getGlossary();
+    const glossaryFile = glossary.getFile();
+    if (configFile.exists()) {
+        logger.info.ln("Configuration file is", configFile.getPath());
+    }
+    if (readmeFile.exists()) {
+        logger.info.ln("Introduction file is", readmeFile.getPath());
+    }
+    if (glossaryFile.exists()) {
+        logger.info.ln("Glossary file is", glossaryFile.getPath());
+    }
+    if (summaryFile.exists()) {
+        logger.info.ln("Table of Contents file is", summaryFile.getPath());
+    }
+}
+function printMultingualBook(book) {
+    const logger = book.getLogger();
+    const languages = book.getLanguages();
+    const books = book.getBooks();
+    logger.info.ln(`${languages.size} languages`);
+    const file = languages.getFile();
+    const list = languages.getList();
+    list.valueSeq().forEach((lang) => {
+        logger.info.ln("Language:", lang.getTitle());
+        printBook(books.get(lang.getID()));
+        logger.info.ln("");
+    });
+}
+exports.default = {
+    name: "parse [book]",
+    description: "parse and print debug information about a book",
+    options: [options_1.default.log],
+    exec: function (args, kwargs) {
+        const book = (0, getBook_1.default)(args, kwargs);
+        const logger = book.getLogger();
+        return parse_1.default.parseBook(book).then((resultBook) => {
+            const rootFolder = book.getRoot();
+            const contentFolder = book.getContentRoot();
+            logger.info.ln("Book located in:", rootFolder);
+            if (contentFolder != rootFolder) {
+                logger.info.ln("Content located in:", contentFolder);
+            }
+            if (resultBook.isMultilingual()) {
+                printMultingualBook(resultBook);
+            }
+            else {
+                printBook(resultBook);
+            }
+        });
+    }
+};

book/node_modules/honkit/lib/cli/serve.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    name: string;
+    description: string;
+    options: ({
+        name: string;
+        description: string;
+        values: any;
+        defaults: string;
+    } | {
+        name: string;
+        description: string;
+        defaults: boolean;
+    } | {
+        name: string;
+        description: string;
+        defaults: number;
+    } | {
+        name: string;
+        description: string;
+        defaults: string;
+    })[];
+    exec: (args: any, kwargs: any) => any;
+};
+export default _default;
+//# sourceMappingURL=serve.d.ts.map

book/node_modules/honkit/lib/cli/serve.d.ts.map

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

book/node_modules/honkit/lib/cli/serve.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiny_lr_1 = __importDefault(require("tiny-lr"));
+const open_1 = __importDefault(require("open"));
+const immutable_1 = __importDefault(require("immutable"));
+const parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const modifiers_1 = __importDefault(require("../modifiers"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const getOutputFolder_1 = __importDefault(require("./getOutputFolder"));
+const server_1 = __importDefault(require("./server"));
+const watch_1 = __importDefault(require("./watch"));
+const page_cache_1 = require("../output/page-cache");
+const fs_1 = __importDefault(require("fs"));
+let server, lrServer, lrPath;
+function waitForCtrlC() {
+    const d = promise_1.default.defer();
+    process.on("SIGINT", () => {
+        d.resolve();
+    });
+    return d.promise;
+}
+function startServer(args, kwargs) {
+    const outputFolder = (0, getOutputFolder_1.default)(args);
+    const port = kwargs.port;
+    const browser = kwargs["browser"];
+    const book = (0, getBook_1.default)(args, kwargs);
+    const hasWatch = kwargs["watch"];
+    const hasOpen = kwargs["open"];
+    const hasLiveReloading = kwargs["live"];
+    const reload = kwargs["reload"];
+    const Generator = output_1.default.getGenerator(kwargs.format);
+    const logger = book.getLogger();
+    logger.info.ok("Starting server ...");
+    let lastOutput = null;
+    return promise_1.default.all([
+        server.start(outputFolder, port),
+        generateBook({
+            book,
+            outputFolder,
+            hasLiveReloading,
+            Generator,
+            reload
+        }).then((output) => {
+            lastOutput = output;
+            return output;
+        })
+    ])
+        .then(() => {
+        console.log(`Serving book on http://localhost:${port}`);
+        if (hasOpen) {
+            (0, open_1.default)(`http://localhost:${port}`, { app: browser });
+        }
+    })
+        .then(() => {
+        if (!hasWatch) {
+            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]
+                            }
+                        });
+                    }
+                });
+            }
+            // Asciidoc files are not supported for incremental build
+            logger.info.ok("Rebuild " + filepath);
+            return generateBook({
+                book,
+                outputFolder,
+                hasLiveReloading,
+                Generator,
+                reload
+            }).then((output) => {
+                lastOutput = output;
+            });
+        });
+    });
+}
+function generateBook({ book, outputFolder, hasLiveReloading, Generator, reload }) {
+    // Stop server if running
+    if (reload) {
+        book.getLogger().info.ok(`Clear cache`);
+        (0, page_cache_1.clearCache)();
+    }
+    return parse_1.default.parseBook(book).then((resultBook) => {
+        if (hasLiveReloading) {
+            // Enable livereload plugin
+            let config = resultBook.getConfig();
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+            config = modifiers_1.default.Config.addPlugin(config, "livereload");
+            resultBook = resultBook.set("config", config);
+        }
+        return output_1.default.generate(Generator, resultBook, {
+            root: outputFolder
+        });
+    });
+}
+function incrementalBuild({ output, Generator }) {
+    return output_1.default.incrementalBuild(Generator, output);
+}
+exports.default = {
+    name: "serve [book] [output]",
+    description: "serve the book as a website for testing",
+    options: [
+        {
+            name: "port",
+            description: "Port for server to listen on",
+            defaults: 4000
+        },
+        {
+            name: "lrport",
+            description: "Port for livereload server to listen on",
+            defaults: 35729
+        },
+        {
+            name: "watch",
+            description: "Enable file watcher and live reloading",
+            defaults: true
+        },
+        {
+            name: "live",
+            description: "Enable live reloading",
+            defaults: true
+        },
+        {
+            name: "open",
+            description: "Enable opening book in browser",
+            defaults: false
+        },
+        {
+            name: "browser",
+            description: "Specify browser for opening book",
+            defaults: ""
+        },
+        options_1.default.log,
+        options_1.default.format,
+        options_1.default.reload
+    ],
+    exec: function (args, kwargs) {
+        server = new server_1.default();
+        const hasWatch = kwargs["watch"];
+        const hasLiveReloading = kwargs["live"];
+        return (0, promise_1.default)()
+            .then(() => {
+            if (!hasWatch || !hasLiveReloading) {
+                return;
+            }
+            lrServer = (0, tiny_lr_1.default)({});
+            return promise_1.default.nfcall(lrServer.listen.bind(lrServer), kwargs.lrport).then(() => {
+                console.log("Live reload server started on port:", kwargs.lrport);
+                console.log("Press CTRL+C to quit ...");
+                console.log("");
+            });
+        })
+            .then(() => {
+            return startServer(args, kwargs);
+        });
+    }
+};

book/node_modules/honkit/lib/cli/server.d.ts

@@ -0,0 +1,28 @@
+import events from "events";
+declare class Server extends events.EventEmitter {
+    private running;
+    private dir;
+    private port;
+    private sockets;
+    constructor();
+    /**
+     Return true if the server is running
+
+     @return {boolean}
+     */
+    isRunning(): boolean;
+    /**
+     Stop the server
+
+     @return {Promise}
+     */
+    stop(): any;
+    /**
+     Start the server
+
+     @return {Promise}
+     */
+    start(dir: any, port: any): any;
+}
+export default Server;
+//# sourceMappingURL=server.d.ts.map

book/node_modules/honkit/lib/cli/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/cli/server.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAO5B,cAAM,MAAO,SAAQ,MAAM,CAAC,YAAY;IACpC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,GAAG,CAAO;IAClB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,OAAO,CAAQ;;IASvB;;;;OAIG;IACH,SAAS;IAIT;;;;OAIG;IACH,IAAI;IAqBJ;;;;OAIG;IACH,KAAK,CAAC,GAAG,KAAA,EAAE,IAAI,KAAA;CA0DlB;AAcD,eAAe,MAAM,CAAC"}

book/node_modules/honkit/lib/cli/server.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const http_1 = __importDefault(require("http"));
+const send_1 = __importDefault(require("send"));
+const url_1 = __importDefault(require("url"));
+const promise_1 = __importDefault(require("../utils/promise"));
+class Server extends events_1.default.EventEmitter {
+    running;
+    dir;
+    port;
+    sockets;
+    constructor() {
+        super();
+        this.running = null;
+        this.dir = null;
+        this.port = 0;
+        this.sockets = [];
+    }
+    /**
+     Return true if the server is running
+
+     @return {boolean}
+     */
+    isRunning() {
+        return !!this.running;
+    }
+    /**
+     Stop the server
+
+     @return {Promise}
+     */
+    stop() {
+        const that = this;
+        if (!this.isRunning())
+            return (0, promise_1.default)();
+        const d = promise_1.default.defer();
+        this.running.close((err) => {
+            that.running = null;
+            that.emit("state", false);
+            if (err)
+                d.reject(err);
+            else
+                d.resolve();
+        });
+        for (let i = 0; i < this.sockets.length; i++) {
+            this.sockets[i].destroy();
+        }
+        return d.promise;
+    }
+    /**
+     Start the server
+
+     @return {Promise}
+     */
+    start(dir, port) {
+        const that = this;
+        let pre = (0, promise_1.default)();
+        port = port || 8004;
+        if (that.isRunning())
+            pre = this.stop();
+        return pre.then(() => {
+            const d = promise_1.default.defer();
+            that.running = http_1.default.createServer((req, res) => {
+                // Render error
+                function error(err) {
+                    res.statusCode = err.status || 500;
+                    res.end(err.message);
+                }
+                // Redirect to directory's index.html
+                function redirect() {
+                    const resultURL = urlTransform(req.url, (parsed) => {
+                        parsed.pathname += "/";
+                        return parsed;
+                    });
+                    res.statusCode = 301;
+                    res.setHeader("Location", resultURL);
+                    res.end(`Redirecting to ${resultURL}`);
+                }
+                res.setHeader("X-Current-Location", req.url);
+                // Send file
+                (0, send_1.default)(req, url_1.default.parse(req.url).pathname, {
+                    root: dir
+                })
+                    .on("error", error)
+                    .on("directory", redirect)
+                    .pipe(res);
+            });
+            that.running.on("connection", (socket) => {
+                that.sockets.push(socket);
+                socket.setTimeout(4000);
+                socket.on("close", () => {
+                    that.sockets.splice(that.sockets.indexOf(socket), 1);
+                });
+            });
+            that.running.listen(port, () => {
+                that.port = port;
+                that.dir = dir;
+                that.emit("state", true);
+                d.resolve();
+            });
+            return d.promise;
+        });
+    }
+}
+/**
+ urlTransform is a helper function that allows a function to transform
+ a url string in it's parsed form and returns the new url as a string
+
+ @param {string} uri
+ @param {Function} fn
+ @return {string}
+ */
+function urlTransform(uri, fn) {
+    return url_1.default.format(fn(url_1.default.parse(uri)));
+}
+exports.default = Server;

book/node_modules/honkit/lib/cli/watch.d.ts

@@ -0,0 +1,10 @@
+/**
+ Watch a folder and resolve promise once a file is modified
+
+ @param {string} dir
+ @param callback
+ @return {Promise}
+ */
+declare function watch(dir: any, callback: any): void;
+export default watch;
+//# sourceMappingURL=watch.d.ts.map

book/node_modules/honkit/lib/cli/watch.d.ts.map

@@ -0,0 +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"}

book/node_modules/honkit/lib/cli/watch.js

@@ -0,0 +1,37 @@
+"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 chokidar_1 = __importDefault(require("chokidar"));
+const parsers_1 = __importDefault(require("../parsers"));
+/**
+ Watch a folder and resolve promise once a file is modified
+
+ @param {string} dir
+ @param callback
+ @return {Promise}
+ */
+function watch(dir, callback) {
+    dir = path_1.default.resolve(dir);
+    const toWatch = ["book.json", "book.js", "_layouts/**"];
+    // Watch all parsable files
+    parsers_1.default.extensions.forEach((ext) => {
+        toWatch.push(`**/*${ext}`);
+    });
+    const watcher = chokidar_1.default.watch(toWatch, {
+        cwd: dir,
+        // prevent infinity loop
+        // https://github.com/honkit/honkit/issues/269
+        ignored: ["_book/**", "node_modules/**"],
+        ignoreInitial: true
+    });
+    watcher.on("all", (e, filepath) => {
+        callback(null, path_1.default.resolve(dir, filepath));
+    });
+    watcher.on("error", (err) => {
+        callback(err);
+    });
+}
+exports.default = watch;