crx-monkey-next 0.0.1

package/dist/node/main.js

@@ -0,0 +1,2759 @@
+import cac from 'cac';
+import sourceMapSupport from 'source-map-support';
+import { injectable, inject, Container } from 'inversify';
+import path, { dirname, resolve, basename, isAbsolute } from 'path';
+import fsExtra, { exists } from 'fs-extra';
+import crypto$1 from 'crypto';
+import fs, { promises, existsSync, watch } from 'fs';
+import chalk from 'chalk';
+import moment from 'moment';
+import fsExtra$1, { outputFileSync } from 'fs-extra/esm';
+import consola from 'consola';
+import MurmurHash3 from 'murmurhash3js';
+import prettier from 'prettier';
+import { WebSocketServer } from 'ws';
+import express from 'express';
+
+var version = "0.0.1";
+var packageJson = {
+	version: version};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * If user used windows, path scheme would be changed file:// and absolutable.
+ * @param filePath
+ * @returns
+ */
+function resolveFilePath(filePath) {
+    if (process.env.OS === 'Windows_NT') {
+        if (path.isAbsolute(filePath)) {
+            const resolved = path.resolve(filePath);
+            return 'file://' + resolved;
+        }
+        else {
+            const resolved = path.resolve(__dirname, filePath);
+            return 'file://' + resolved;
+        }
+    }
+    else {
+        return filePath;
+    }
+}
+/**
+ * Import a JS dynamically without any cache.
+ * @param filePath
+ * @returns A module.
+ */
+async function noCacheImport(filePath, base = './') {
+    if (!exists(filePath)) {
+        throw new Error(`The module '${filePath}' does not exist`);
+    }
+    const data = fsExtra.readFileSync(filePath, {});
+    const tmpFilePath = path.resolve(base, crypto$1.randomUUID());
+    await fsExtra.outputFile(tmpFilePath, data.toString());
+    try {
+        const module = (await import(tmpFilePath));
+        fsExtra.removeSync(tmpFilePath);
+        return module;
+    }
+    catch (e) {
+        fsExtra.removeSync(tmpFilePath);
+        throw e;
+    }
+}
+
+var ConfigLoader_1;
+/**
+ * Load and store the config from project.
+ */
+let ConfigLoader = class ConfigLoader {
+    static { ConfigLoader_1 = this; }
+    static configFileNamePatterns = ['crxm.config.js'];
+    loadedConfig = null;
+    configPath = null;
+    /**
+     * Load config from project
+     */
+    async loadConfig() {
+        const confPath = await this.searchConfig();
+        await this.loadConfigDetail(confPath);
+    }
+    /**
+     * Use config loaded.
+     */
+    useConfig() {
+        if (this.loadedConfig === null) {
+            throw new Error('The config has never been loaded, please loadConfig() before using.');
+        }
+        return this.loadedConfig;
+    }
+    /**
+     * Get loaded config path.
+     */
+    useConfigPath() {
+        if (this.configPath === null) {
+            throw new Error('The config has never been loaded, please loadConfig() before using config path.');
+        }
+        return this.configPath;
+    }
+    /**
+     * Get the path of config file deeply.
+     * @returns
+     */
+    async searchConfig() {
+        return await new Promise((resolve, reject) => {
+            let dir = process.cwd();
+            const searchThen = (result) => {
+                if (result !== null) {
+                    resolve(dir + '/' + result);
+                }
+                else {
+                    const splited = dir.split('/');
+                    if (splited.length === 1) {
+                        reject(new Error('The config file not found. Please create "crxm.config.js"'));
+                    }
+                    else {
+                        splited.pop();
+                        dir = splited.join('/');
+                        void this.configSearchInDir(dir).then(searchThen);
+                    }
+                }
+            };
+            void this.configSearchInDir(dir).then(searchThen);
+        });
+    }
+    /**
+     * Get the path of config file from directory.
+     * @returns
+     */
+    async configSearchInDir(dir) {
+        return await new Promise((resolve) => {
+            void promises.readdir(dir + '/').then((files) => {
+                files.forEach((fileName) => {
+                    ConfigLoader_1.configFileNamePatterns.forEach((fileNamePattern) => {
+                        if (fileName === fileNamePattern) {
+                            resolve(fileName);
+                        }
+                    });
+                });
+                resolve(null);
+            });
+        });
+    }
+    /**
+     * Import config file then set to value.
+     * @param confPath
+     */
+    async loadConfigDetail(confPath) {
+        const configAbsolutePath = resolveFilePath(confPath);
+        const buildConfig = await noCacheImport(configAbsolutePath, dirname(configAbsolutePath));
+        if (buildConfig.default === undefined) {
+            throw new Error(`The config is not exported as default in "${configAbsolutePath}".`);
+        }
+        const exportedConfig = buildConfig.default;
+        if (exportedConfig === undefined) {
+            throw new Error(`The config is not exported as default in "${configAbsolutePath}".`);
+        }
+        this.loadedConfig = exportedConfig;
+        this.configPath = confPath;
+    }
+};
+ConfigLoader = ConfigLoader_1 = __decorate([
+    injectable()
+], ConfigLoader);
+
+/**
+ * For inversify
+ */
+const TYPES = {
+    ConfigLoader: Symbol.for('I_ConfigLoader'),
+    ManifestLoader: Symbol.for('I_ManifestLoader'),
+    ManifestParser: Symbol.for('I_ManifestParser'),
+    CrxmBundler: Symbol.for('I_CrxmBundler'),
+    Watcher: Symbol.for('I_Watcher'),
+    BundlerRegisterer: Symbol.for('I_BundlerRegisterer'),
+    Distributior: Symbol.for('I_Distributior'),
+    ManifestFactory: Symbol.for('I_ManifestFactory'),
+    UserscriptBundler: Symbol.for('I_UserscriptBundler'),
+    UserscriptHeaderFactory: Symbol.for('I_UserscriptHeaderFactory'),
+    UserscriptRegisterer: Symbol.for('I_UserscriptRegisterer'),
+    Logger: Symbol.for('I_Logger'),
+    SockServer: Symbol.for('I_SockServer'),
+    CreateDevClient: Symbol.for('I_CreateDevClient'),
+    FileServer: Symbol.for('I_FileServer'),
+    BuildID: Symbol.for('BuildID'),
+    CacheDir: Symbol.for('CacheDir'),
+    IsWatch: Symbol.for('IsWatch'),
+};
+
+/**
+ * Load and store the manifest from project.
+ */
+let ManifestLoader = class ManifestLoader {
+    configLoader;
+    loadedManifest = null;
+    manifestPath;
+    constructor(configLoader) {
+        this.configLoader = configLoader;
+        // Get manifest file path.
+        const config = this.configLoader.useConfig();
+        const confPath = this.configLoader.useConfigPath();
+        const projectDir = dirname(confPath);
+        this.manifestPath = resolve(projectDir, config.manifest);
+    }
+    /**
+     * Load manifest from project.
+     * @param manifestPath
+     */
+    async loadManifest() {
+        // Get manfest path\
+        const resolvedManifestPath = resolveFilePath(this.manifestPath);
+        if (!existsSync(resolvedManifestPath)) {
+            throw new Error(`The manifest does not exist "${this.manifestPath}".`);
+        }
+        await noCacheImport(resolvedManifestPath).then((manifest) => {
+            const exportedManifest = manifest.default;
+            if (exportedManifest === undefined) {
+                throw new Error(`The manifest is not exported as default in "${this.manifestPath}".`);
+            }
+            if (exportedManifest === undefined) {
+                throw new Error(`The manifest is not exported as default in "${this.manifestPath}".`);
+            }
+            this.loadedManifest = exportedManifest;
+        });
+    }
+    /**
+     * Use manifest loaded.
+     * @returns
+     */
+    useManifest() {
+        if (this.loadedManifest === null) {
+            throw new Error('The manifest has never been loaded, please loadManifest() before using manifest.');
+        }
+        return this.loadedManifest;
+    }
+};
+ManifestLoader = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [Object])
+], ManifestLoader);
+
+let ManifestParser = class ManifestParser {
+    configLoader;
+    _parseResult = null;
+    constructor(configLoader) {
+        this.configLoader = configLoader;
+    }
+    get parseResult() {
+        if (this._parseResult === null) {
+            throw new Error('The manifest has never been parsed. Plaese parse your manifest before getting a result.');
+        }
+        return this._parseResult;
+    }
+    /**
+     * Get all resources written in manifest.
+     * @param manifest
+     * @returns
+     */
+    parse(manifest) {
+        this._parseResult = {
+            resources: this.getAllResources(manifest),
+            icons: this.getAllIcons(manifest),
+        };
+        return this._parseResult;
+    }
+    getAllIcons(manifest) {
+        const icons = manifest.icons;
+        if (icons === undefined) {
+            return null;
+        }
+        else {
+            const result = {};
+            Object.keys(icons).map((size) => {
+                const sizeN = size;
+                const filePathRelative = icons[sizeN];
+                const absolute = resolve(filePathRelative);
+                result[sizeN] = {
+                    raw: filePathRelative,
+                    path: absolute,
+                    size: sizeN,
+                };
+            });
+            return result;
+        }
+    }
+    /**
+     * Get all typescript and css filenames which are written in 'manifest.js' in project.
+     * @param manifest
+     * @returns
+     */
+    getAllResources(manifest) {
+        const confPath = this.configLoader.useConfigPath();
+        const projectDir = dirname(confPath);
+        const sw = [];
+        const contentResources = [];
+        const cssResources = [];
+        const swRaw = [];
+        const contentResourcesRaw = [];
+        const cssResourcesRaw = [];
+        const popupHtml = [];
+        const popupHtmlRaw = [];
+        if (manifest?.background?.service_worker !== undefined) {
+            swRaw.push(manifest.background.service_worker);
+            sw.push(resolve(projectDir, manifest.background.service_worker));
+        }
+        if (manifest?.action?.default_popup !== undefined) {
+            popupHtmlRaw.push(manifest.action.default_popup);
+            popupHtml.push(resolve(projectDir, manifest.action.default_popup));
+        }
+        manifest.content_scripts.forEach(({ js, css }) => {
+            if (js !== undefined) {
+                js.map((p) => {
+                    if (!contentResourcesRaw.includes(p)) {
+                        contentResourcesRaw.push(p);
+                        contentResources.push(resolve(projectDir, p));
+                    }
+                });
+            }
+            if (css !== undefined) {
+                css.map((p) => {
+                    if (!cssResourcesRaw.includes(p)) {
+                        cssResourcesRaw.push(p);
+                        cssResources.push(resolve(projectDir, p));
+                    }
+                });
+            }
+        });
+        return {
+            scriptResources: {
+                sw: sw,
+                content: contentResources,
+            },
+            cssResources,
+            htmlResources: {
+                popup: popupHtml,
+            },
+            raw: {
+                scriptResources: {
+                    sw: swRaw,
+                    content: contentResourcesRaw,
+                },
+                cssResources: cssResourcesRaw,
+                htmlResources: {
+                    popup: popupHtmlRaw,
+                },
+            },
+        };
+    }
+};
+ManifestParser = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [Object])
+], ManifestParser);
+
+let Logger = class Logger {
+    configLoader;
+    logLevel = 'info';
+    constructor(configLoader) {
+        this.configLoader = configLoader;
+    }
+    showInfo() {
+        const { server: { host, port, websocket }, output: { chrome }, manifest, } = this.configLoader.useConfig();
+        if (chrome === undefined) {
+            throw new Error('');
+        }
+        const chromePathAbsolute = resolve(dirname(manifest), chrome);
+        console.log(`\n  ${chalk.cyanBright('CRX MONEKY')} v${packageJson.version}`);
+        console.log(`\n  You can install development userscript:\n    ${chalk.greenBright(`http://${host}:${port}/dev.user.js`)}`);
+        console.log(`\n  You can install development chrome extension:\n    ${chalk.greenBright(chromePathAbsolute)}`);
+        console.log(`\n  Websocket running on:\n    ${chalk.greenBright(`http://${host}:${websocket}`)}`);
+        console.log('');
+    }
+    initialize() {
+        console.clear();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dispatchLog(...detail) {
+        if (this.logLevel === 'debug' || this.logLevel === 'error' || this.logLevel === 'info') {
+            console.log(...[`[${this.getDateNowFormated()}] ${chalk.bgGreen(' LOG ')} `, ...detail]);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dispatchErr(...detail) {
+        if (this.logLevel === 'debug' || this.logLevel === 'error') {
+            console.log(...[`[${this.getDateNowFormated()}] ${chalk.bgRed(' ERROR ')}`, ...detail]);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dispatchDebug(...detail) {
+        if (this.logLevel === 'debug') {
+            console.log(...[`[${this.getDateNowFormated()}] ${chalk.bgCyan(' DEBUG ')}`, ...detail]);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dispatchConsole(...detail) {
+        if (this.logLevel === 'debug' || this.logLevel === 'error' || this.logLevel === 'info') {
+            console.log(...[`[${this.getDateNowFormated()}] ${chalk.bgYellow(' CONSOLE ')}`, ...detail]);
+        }
+    }
+    getDateNowFormated() {
+        const formattedDate = moment().format('YYYY/MM/DD HH:mm:ss');
+        return formattedDate;
+    }
+};
+Logger = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [ConfigLoader])
+], Logger);
+
+/**
+ * Manage all bundler
+ */
+let CrxmBundler = class CrxmBundler {
+    configLoader;
+    logger;
+    targets = {};
+    _compileResults = {};
+    watchers = [];
+    updateHandlers = [];
+    constructor(configLoader, logger) {
+        this.configLoader = configLoader;
+        this.logger = logger;
+    }
+    get compileResults() {
+        return this._compileResults;
+    }
+    addTarget(entryPoint, usingPlugin, flag = '') {
+        const hash = crypto.randomUUID();
+        this.targets[hash] = { entryPoint, usingPlugin, hash, flag };
+        return hash;
+    }
+    removeTarget(targetEntryPoint, flag = null) {
+        const hash = this.getInternalHashFromPath(targetEntryPoint, flag);
+        delete this.targets[hash];
+    }
+    getInternalHashFromPath(filePath, targetFlag = null) {
+        let hash;
+        if (targetFlag !== null) {
+            // flag filter
+            hash = Object.keys(this.targets).filter((hash) => {
+                const { entryPoint, flag } = this.targets[hash];
+                return entryPoint === filePath && flag === targetFlag;
+            })[0];
+        }
+        else {
+            hash = Object.keys(this.targets).filter((hash) => {
+                const { entryPoint } = this.targets[hash];
+                return entryPoint === filePath;
+            })[0];
+        }
+        return hash;
+    }
+    getBuildResultFromPath(filePath) {
+        const hash = this.getInternalHashFromPath(filePath);
+        return this._compileResults[hash];
+    }
+    async build() {
+        await this.compileAll();
+    }
+    /**
+     * Watching scripts
+     */
+    async watch() {
+        if (this.watchers?.length !== 0) {
+            throw new Error('Script watching must be started after stopping before watching');
+        }
+        await this.watchAll();
+    }
+    /**
+     * Stop watching scripts
+     */
+    async stopWatch() {
+        await Promise.all(this.watchers.map(async (watcher) => {
+            await watcher.stop();
+        }));
+        this.watchers = [];
+    }
+    /**
+     * Register the handler be runned when scripts updated.
+     * @param handler
+     */
+    addListener(handler) {
+        this.updateHandlers.push(handler);
+    }
+    /**
+     * Remove the handler be runned when scripts updated.
+     * @param handler
+     */
+    removeListener(handler) {
+        const newHandlers = this.updateHandlers.filter((h) => h !== handler);
+        this.updateHandlers = newHandlers;
+    }
+    /**
+     * Start watching for all sources by using plugins.
+     */
+    async watchAll() {
+        const watchers = [];
+        const absolutePaths = await this.getTargetAbsolutePaths();
+        await Promise.all(Object.keys(absolutePaths).map(async (hash) => {
+            const absolutePath = resolveFilePath(absolutePaths[hash]);
+            const { usingPlugin } = this.targets[hash];
+            if (await fsExtra.exists(absolutePath)) {
+                const { plugin, name } = usingPlugin.watch;
+                const resultSender = (result) => {
+                    this.logger.dispatchDebug(`✨ [${name}] Builded  ${chalk.gray('"' + absolutePath + '"')}`);
+                    // Register result.
+                    this._compileResults[hash] = result;
+                    // Dispatch update
+                    this.updateHandlers.forEach((h) => {
+                        h(this.targets[hash]);
+                    });
+                };
+                this.watchers.push(await plugin(absolutePath, resultSender, this));
+            }
+            else {
+                throw new Error(`Entrypoint '${absolutePath} does not exist.'`);
+            }
+        }));
+        this.watchers = watchers;
+    }
+    async compileForce(hash) {
+        const target = this.targets[hash];
+        const absolutePaths = await this.getTargetAbsolutePaths();
+        const absolutePath = resolveFilePath(absolutePaths[hash]);
+        this._compileResults[hash] = await target.usingPlugin.build.plugin(absolutePath, this);
+        return target;
+    }
+    /**
+     * Compile all sources by using plugins.
+     */
+    async compileAll() {
+        const compileResults = {};
+        const absolutePaths = await this.getTargetAbsolutePaths();
+        await Promise.all(Object.keys(absolutePaths).map(async (hash) => {
+            const absolutePath = resolveFilePath(absolutePaths[hash]);
+            const { usingPlugin } = this.targets[hash];
+            if (await fsExtra.exists(absolutePath)) {
+                compileResults[hash] = await usingPlugin.build.plugin(absolutePath, this);
+                this.logger.dispatchDebug(`✨ [${usingPlugin.build.name}] Build successful!`);
+            }
+            else {
+                throw new Error(`Entrypoint '${absolutePath} does not exist.'`);
+            }
+        }));
+        this._compileResults = compileResults;
+        return;
+    }
+    /**
+     * Get the file's which in the project absolute path.
+     * @returns
+     */
+    async getTargetAbsolutePaths() {
+        const path = this.configLoader.useConfigPath();
+        const projectDir = dirname(path);
+        const paths = {};
+        Object.keys(this.targets).map((hash) => {
+            const { entryPoint } = this.targets[hash];
+            paths[hash] = resolve(projectDir, entryPoint);
+        });
+        return paths;
+    }
+};
+CrxmBundler = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __param(1, inject(TYPES.Logger)),
+    __metadata("design:paramtypes", [ConfigLoader,
+        Logger])
+], CrxmBundler);
+
+/**
+ * Watch config and manifest
+ */
+let Watcher = class Watcher {
+    configLoader;
+    manifestLoader;
+    logger;
+    configPath;
+    configWatcher = null;
+    manifestWatcher = null;
+    updateHandlers = [];
+    constructor(configLoader, manifestLoader, logger) {
+        this.configLoader = configLoader;
+        this.manifestLoader = manifestLoader;
+        this.logger = logger;
+        this.configPath = this.configLoader.useConfigPath();
+    }
+    /**
+     * Start watching config and manifest
+     */
+    async start() {
+        // Start config watching
+        if (this.configWatcher !== null) {
+            throw new Error('The config watching is running now, stop it before using start.');
+        }
+        this.configWatcher = watch(this.configPath);
+        const stack = [];
+        this.configWatcher.addListener('change', async () => {
+            stack.push(async () => {
+                this.logger.dispatchLog(`🚩 Config updated ${chalk.gray('"' + this.configPath + '"')}`);
+                await this.onUpdateConfig();
+            });
+        });
+        setInterval(async () => {
+            if (stack[0] !== undefined) {
+                await stack[0]();
+                stack.splice(0, 1);
+            }
+        }, 1000);
+        this.startManifestWatch(this.getManifestPath());
+    }
+    /**
+     * Stop watching
+     */
+    async stop() {
+        this.stopManifestWatch();
+        if (this.configWatcher !== null) {
+            this.configWatcher.close();
+            this.configWatcher = null;
+        }
+    }
+    addListener(handler) {
+        this.updateHandlers.push(handler);
+    }
+    removeListener(handler) {
+        const newHandlers = this.updateHandlers.filter((h) => h !== handler);
+        this.updateHandlers = newHandlers;
+    }
+    /**
+     * Watching manifest file in project
+     * @param manifestPath
+     */
+    startManifestWatch(manifestPath) {
+        if (this.manifestWatcher !== null) {
+            throw new Error('The manifest watching is running now, stop it before using start.');
+        }
+        this.manifestWatcher = watch(manifestPath, {});
+        const stack = [];
+        this.manifestWatcher.addListener('change', async () => {
+            stack.push(async () => {
+                this.logger.dispatchLog(`🚩 Manifest updated ${chalk.gray('"' + manifestPath + '"')}`);
+                await this.onUpdateManifest();
+            });
+        });
+        setInterval(async () => {
+            if (stack[0] !== undefined) {
+                await stack[0]();
+                stack.splice(0, 1);
+            }
+        }, 1000);
+    }
+    /**
+     * Stop watching manifest file in project
+     * @param manifestPath
+     */
+    stopManifestWatch() {
+        if (this.manifestWatcher !== null) {
+            this.manifestWatcher.close();
+            this.manifestWatcher = null;
+        }
+    }
+    /**
+     * Run on updated config file.
+     */
+    async onUpdateConfig() {
+        await this.configLoader.loadConfig();
+        const manifestPath = this.getManifestPath();
+        await this.manifestLoader.loadManifest();
+        this.stopManifestWatch();
+        await Promise.all(this.updateHandlers.map(async (h) => {
+            await h('config');
+        }));
+        this.startManifestWatch(manifestPath);
+    }
+    /**
+     * Run on updated manifest file.
+     */
+    async onUpdateManifest() {
+        await this.manifestLoader.loadManifest();
+        await Promise.all(this.updateHandlers.map(async (h) => {
+            await h('manifest');
+        }));
+    }
+    /**
+     * Get manifest's filepath from config.
+     * @returns
+     */
+    getManifestPath() {
+        const confPath = this.configLoader.useConfigPath();
+        const projectDir = dirname(confPath);
+        const manifestPath = resolve(projectDir, this.configLoader.useConfig().manifest);
+        return manifestPath;
+    }
+};
+Watcher = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __param(1, inject(TYPES.ManifestLoader)),
+    __param(2, inject(TYPES.Logger)),
+    __metadata("design:paramtypes", [ConfigLoader,
+        ManifestLoader,
+        Logger])
+], Watcher);
+
+/**
+ * Get all messages each language in a locale dir in the project.
+ * @param key
+ * @returns All messages each language.
+ */
+async function geti18nMessages(key) {
+    const result = { en: key };
+    const match = key.match(/__MSG_(.*)__/);
+    if (match !== null) {
+        const i18nKey = match[1];
+        const localesPath = getlocalesPath();
+        if (fsExtra$1.pathExistsSync(localesPath)) {
+            const langKeys = getEnableLangs(localesPath);
+            await Promise.all(langKeys.map(async (langKey) => {
+                const msg = await getMessage(langKey, i18nKey);
+                if (msg !== null) {
+                    result[langKey] = msg;
+                }
+            }));
+        }
+    }
+    return result;
+}
+/**
+ * Get a message in a locale dir in the project.
+ * @param key
+ * @returns A message
+ */
+async function getMessage(langKey, key) {
+    const localesPath = getlocalesPath();
+    const messagesJsonPath = path.resolve(localesPath, langKey, 'messages.json');
+    const messagesJson = await fsExtra$1.readJSON(messagesJsonPath);
+    const message = messagesJson[key].message;
+    if (message !== undefined) {
+        return message;
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Get exist languages in a locale dir in the project.
+ * @param localesPath
+ * @returns Exist languages in a locale dir in the project.
+ */
+function getEnableLangs(localesPath) {
+    const langs = fs.readdirSync(localesPath);
+    if (!langs.includes('en')) {
+        throw consola.error(new Error('There is no en directory in the _locales directory.'));
+    }
+    return langs;
+}
+function getlocalesPath() {
+    const config = container.get(TYPES.ConfigLoader).useConfig();
+    const dir = path.dirname(config.manifest);
+    return path.resolve(dir, '_locales');
+}
+/**
+ * Copy a locales dir in the src to dist in the project.
+ */
+async function copyLocales() {
+    const localesPath = getlocalesPath();
+    const config = container.get(TYPES.ConfigLoader).useConfig();
+    if ((await fsExtra$1.pathExists(localesPath)) && config.output.chrome !== undefined) {
+        await fsExtra$1.copy(localesPath, path.join(config.output.chrome, '_locales'));
+    }
+}
+
+/**
+ * Create post-build manifest from original manifest
+ */
+let ManifestFactory = class ManifestFactory {
+    manifestLoader;
+    rawManifest;
+    workspace;
+    definedCustomKeysByCrxMonkeyInContentScrpt = [
+        'use_isolated_connection',
+        'userscript_direct_inject',
+        'trusted_inject',
+    ];
+    constructor(manifestLoader) {
+        this.manifestLoader = manifestLoader;
+        this.rawManifest = this.manifestLoader.useManifest();
+        this.workspace = structuredClone(this.rawManifest);
+    }
+    /**
+     * Reload manifest from loader.
+     */
+    initialize() {
+        this.rawManifest = this.manifestLoader.useManifest();
+        this.workspace = structuredClone(this.rawManifest);
+    }
+    /**
+     * Extension Name -> [Dev] Extension Name
+     */
+    enableDevMode() {
+        const i18nNameMatch = this.workspace.name.match(/__MSG_(.*)__/);
+        if (i18nNameMatch !== null) {
+            getMessage('en', i18nNameMatch[1]).then((msg) => {
+                if (msg !== null) {
+                    this.workspace.name = '[Dev] ' + msg;
+                }
+            });
+        }
+        else {
+            this.workspace.name = '[Dev] ' + this.workspace.name;
+        }
+    }
+    /**
+     * Output the current manifest data.
+     * @returns
+     */
+    getWorkspace() {
+        return this.absorbCustomKeys(this.workspace);
+    }
+    /**
+     * Get manifest data absorbed defined custom keys by crx-monkey.
+     * @returns
+     */
+    getResult() {
+        return this.absorbCustomKeys(this.workspace);
+    }
+    resolve(sourcePath, targetPath) {
+        // sw
+        if (this.workspace.background !== undefined &&
+            this.workspace.background.service_worker === sourcePath) {
+            this.workspace.background = {
+                ...this.workspace.background,
+                service_worker: targetPath,
+            };
+        }
+        // popup
+        if (this.workspace.action !== undefined && this.workspace.action.default_popup === sourcePath) {
+            this.workspace.action = {
+                ...this.workspace.action,
+                default_popup: targetPath,
+            };
+        }
+        if (this.workspace.content_scripts !== undefined) {
+            // content js
+            this.workspace.content_scripts.forEach((script) => {
+                if (script.js !== undefined) {
+                    script.js = script.js.map((js) => {
+                        if (js === sourcePath) {
+                            return targetPath;
+                        }
+                        else {
+                            return js;
+                        }
+                    });
+                }
+                // content css
+                if (script.css !== undefined) {
+                    script.css = script.css.map((css) => {
+                        if (css === sourcePath) {
+                            return targetPath;
+                        }
+                        else {
+                            return css;
+                        }
+                    });
+                }
+            });
+        }
+        // Icons
+        const icons = structuredClone(this.workspace.icons);
+        if (icons !== undefined) {
+            const newIcons = {
+                ...icons,
+            };
+            Object.keys(icons).forEach((size) => {
+                const sizeN = size;
+                const icon = icons[sizeN];
+                if (icon === sourcePath) {
+                    newIcons[sizeN] = targetPath;
+                }
+            });
+            this.workspace.icons = newIcons;
+        }
+    }
+    addContentScript(js, css, matches, world = 'ISOLATED', run_at = undefined) {
+        if (this.workspace.content_scripts !== undefined) {
+            this.workspace.content_scripts.push({
+                matches,
+                js,
+                css,
+                world,
+                run_at,
+            });
+        }
+    }
+    absorbCustomKeys(original) {
+        const result = structuredClone(original);
+        if (original.content_scripts !== undefined && result.content_scripts !== undefined) {
+            original.content_scripts.forEach((content_script, index) => {
+                Object.keys(content_script).forEach((key) => {
+                    if (this.definedCustomKeysByCrxMonkeyInContentScrpt.includes(key)) {
+                        if (result.content_scripts !== undefined) {
+                            delete result.content_scripts[index][key];
+                        }
+                    }
+                });
+            });
+        }
+        return result;
+    }
+};
+ManifestFactory = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ManifestLoader)),
+    __metadata("design:paramtypes", [ManifestLoader])
+], ManifestFactory);
+
+/**
+ * Generate a string of code to properly execute a functionalized script at each timing
+ */
+class CodeInjector {
+    // Record<MatchPattern, Content>
+    contents = [];
+    /**
+     * Register function names for functionized scripts
+     * @param funcName
+     * @param matches
+     * @param run_at
+     */
+    addContent(contentScript) {
+        const { run_at, matches, js, css, trusted_inject, userscript_direct_inject } = contentScript;
+        if (matches !== undefined) {
+            const funcNames = [];
+            if (js !== undefined) {
+                funcNames.push(...js.map((filePath) => convertFilePathToFuncName(filePath)));
+            }
+            if (css !== undefined) {
+                funcNames.push(...css.map((filePath) => convertFilePathToFuncName(filePath)));
+            }
+            this.contents.push({
+                funcNames,
+                matches,
+                useDirectInject: userscript_direct_inject !== undefined ? userscript_direct_inject : false,
+                useTrustedScript: trusted_inject !== undefined ? trusted_inject : true,
+                run_at: run_at === undefined ? 'document_idle' : run_at,
+            });
+        }
+    }
+    /**
+     * Get code
+     * @returns
+     */
+    getCode() {
+        let code = '';
+        this.contents.forEach(({ matches, useTrustedScript, funcNames, run_at, useDirectInject }) => {
+            const varHash = crypto.randomUUID().replaceAll('-', '_');
+            const createScriptElementVarName = () => {
+                return 'crxm_script_' + varHash + crypto.randomUUID().replaceAll('-', '_');
+            };
+            // match if
+            code +=
+                '\n\nif(' +
+                    matches
+                        .map((match) => {
+                        if (match === '<all_urls>') {
+                            return 'true';
+                        }
+                        return `location.href.match('^${match}') !== null`;
+                    })
+                        .join(',') +
+                    '){';
+            let codeInner = '';
+            if (useDirectInject) {
+                // Define idle scripts element
+                const scriptElementVarName = createScriptElementVarName();
+                codeInner += `\nconst ${scriptElementVarName} = document.createElement("script");`;
+                if (useTrustedScript) {
+                    // Is this browser supported trustedTypes?
+                    codeInner += '\nif(unsafeWindow.trustedTypes !== undefined){';
+                    // If supported, it would be create policy.
+                    codeInner += `\nconst policy_${varHash} = unsafeWindow.trustedTypes.createPolicy("crxm-trusted-inject-policy", {createScript: (input) => input,});`;
+                    funcNames.forEach((funcName) => {
+                        codeInner += `\n${scriptElementVarName}.text = policy_${varHash}.createScript(${scriptElementVarName}.text + \`(\${${funcName}.toString()})();\`);\n`;
+                    });
+                    // end trustedTypes if
+                    codeInner += '} else {';
+                    //  For environments that do not support trustedTypes
+                    funcNames.forEach((funcName) => {
+                        codeInner += `\n${scriptElementVarName}.innerHTML = ${scriptElementVarName}.innerHTML + \`(\${${funcName}.toString()})();\``;
+                    });
+                    // end trusted else
+                    codeInner += '}';
+                }
+                else {
+                    // Dont use trustedTypes
+                    funcNames.forEach((funcName) => {
+                        codeInner += `\n${scriptElementVarName}.innerHTML = ${scriptElementVarName}.innerHTML + \`(\${${funcName}.toString()})();\``;
+                    });
+                }
+                codeInner += `\nunsafeWindow.document.body.appendChild(${scriptElementVarName});\n`;
+            }
+            else {
+                funcNames.forEach((funcName) => {
+                    codeInner += `\n${funcName}();`;
+                });
+            }
+            if (run_at === 'document_start') {
+                code += codeInner;
+            }
+            else {
+                code += this.getCodeWrappedInjectTiming(codeInner, run_at);
+            }
+            // end match if
+            code += '}';
+        });
+        return code;
+        /*if (CodeInjector.useDomInject) {
+          return this.getCodeDomInject(CodeInjector.useTrustedScript);
+        } else {
+          return this.getCodeDirectRun();
+        }*/
+    }
+    /**
+     * Wrap code with appropriate syntax depending on run-at
+     * @param code
+     * @param runAt
+     * @returns
+     */
+    getCodeWrappedInjectTiming(code, runAt) {
+        if (runAt === 'document_idle') {
+            return ('["DOMContentLoaded", "crxm_DOMContentLoaded"].forEach((eventType) => {' +
+                'document.addEventListener(eventType, () => {setTimeout(() => {' +
+                code +
+                '\n}, 1)})});\n');
+        }
+        else if (runAt === 'document_end') {
+            return ('["DOMContentLoaded", "crxm_DOMContentLoaded"].forEach((eventType) => {' +
+                'document.addEventListener(eventType, () => {' +
+                code +
+                '\n})});\n');
+        }
+        else {
+            return code;
+        }
+    }
+}
+
+let UserscriptHeaderFactory = class UserscriptHeaderFactory {
+    detail = [];
+    constructor(selfInstance = null) {
+        if (selfInstance !== null) {
+            this.initialize();
+            this.detail = structuredClone(selfInstance.detail);
+        }
+    }
+    initialize() {
+        this.detail = [];
+    }
+    /**
+     * Push header item.
+     * @param key
+     * @param value
+     */
+    push(key, value) {
+        // The name should be at the beginning of the metadata.
+        if (key !== undefined && key.toString().match(/^@name/)) {
+            this.detail.unshift([key, value]);
+        }
+        else {
+            this.detail.push([key, value]);
+        }
+    }
+    /**
+     * Output created header.
+     * @returns Userscript header string.
+     */
+    toString() {
+        const header = [];
+        header.push('// ==UserScript==');
+        this.detail.forEach(([key, value]) => {
+            header.push(`// ${key} ${value}`);
+        });
+        header.push('// ==/UserScript==');
+        return header.join('\n');
+    }
+    /**
+     * Replace header item.
+     * @param key
+     * @param value
+     */
+    replace(key, value) {
+        this.detail.forEach(([detailKey], index) => {
+            if (key === detailKey) {
+                this.detail[index] = [key, value];
+            }
+        });
+    }
+    /**
+     * Is exist the key in created header??
+     * @param key
+     * @returns
+     */
+    exist(key) {
+        this.detail.forEach(([detailKey]) => {
+            if (key === detailKey) {
+                return true;
+            }
+        });
+        return false;
+    }
+};
+UserscriptHeaderFactory = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], UserscriptHeaderFactory);
+
+/**
+ * Properly bundle each build result as a single user script
+ */
+let UserscriptBundler = class UserscriptBundler {
+    manifestFactory;
+    headerFactory;
+    configLoader;
+    codeWorkspace = '';
+    codeBlocks = {};
+    constructor(manifestFactory, headerFactory, configLoader) {
+        this.manifestFactory = manifestFactory;
+        this.headerFactory = headerFactory;
+        this.configLoader = configLoader;
+    }
+    initialize() {
+        this.codeBlocks = {};
+        this.codeWorkspace = '';
+    }
+    /**
+     * Add build result.
+     * @param jsFilePath
+     * @param codeBinaly
+     */
+    addBuildResult(jsFilePath, codeBinaly) {
+        const codeBlock = new UserJsCodeBlock(jsFilePath, codeBinaly);
+        this.codeBlocks[jsFilePath] = codeBlock;
+    }
+    addStyle(cssFilePath, code) {
+        const codeBlock = new UserJsStyleBlock(cssFilePath, code);
+        this.codeBlocks[cssFilePath] = codeBlock;
+    }
+    createCode() {
+        this.codeWorkspace = '';
+        /**
+         * Insert Header
+         */
+        this.codeWorkspace += this.headerFactory.toString() + '\n';
+        /**
+         * Insert functioned build results.
+         */
+        Object.keys(this.codeBlocks).forEach((filePath) => {
+            const codeBlock = this.codeBlocks[filePath];
+            const functionalized = codeBlock.getFunctionalized();
+            this.codeWorkspace += functionalized;
+        });
+        /**
+         * Insert inject method.
+         */
+        const codeInjector = new CodeInjector();
+        const contentScripts = this.manifestFactory.rawManifest.content_scripts;
+        if (contentScripts !== undefined) {
+            contentScripts.forEach((contentScript) => {
+                codeInjector.addContent(contentScript);
+            });
+        }
+        this.codeWorkspace += codeInjector.getCode();
+        return this.codeWorkspace;
+    }
+};
+UserscriptBundler = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ManifestFactory)),
+    __param(1, inject(TYPES.UserscriptHeaderFactory)),
+    __param(2, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [ManifestFactory,
+        UserscriptHeaderFactory,
+        ConfigLoader])
+], UserscriptBundler);
+class UserJsCodeBlock {
+    filePath;
+    content;
+    constructor(filePath, content) {
+        this.filePath = filePath;
+        this.content = content;
+    }
+    getFunctionalized() {
+        let result = '';
+        const text = new TextDecoder().decode(this.content);
+        result += `\n// ${this.filePath}\n function ${convertFilePathToFuncName(this.filePath)}() {\n${text}}\n`;
+        return result;
+    }
+    getFunctionalizedFuncName() {
+        return convertFilePathToFuncName(this.filePath);
+    }
+}
+class UserJsStyleBlock {
+    filePath;
+    content;
+    constructor(filePath, content) {
+        this.filePath = filePath;
+        this.content = content;
+    }
+    getFunctionalized() {
+        let result = '';
+        const text = new TextDecoder().decode(this.content);
+        result += `\n// ${this.filePath}\n function ${convertFilePathToFuncName(this.filePath)}() {
+const e = document.createElement("style");
+e.innerHTML = \`${text}\`;
+document.head.appendChild(e)
+console.log(e)}\n`;
+        return result;
+    }
+    getFunctionalizedFuncName() {
+        return convertFilePathToFuncName(this.filePath);
+    }
+}
+/**
+ * File path convert to base64 and it included "=" convert to "$".
+ * @param filePath
+ * @returns
+ */
+function convertFilePathToFuncName(filePath) {
+    return btoa(filePath).replaceAll('=', '$');
+}
+
+/**
+ * A content to be convined with service_worker of development script generated by crx-monkey.
+ * @param host SockServer host
+ * @param sockPort SockServer port
+ */
+function developSw(host, sockPort) {
+    function startWebsocket25secLife() {
+        const websocket = new WebSocket(`ws://${host}:${sockPort}`);
+        websocket.addEventListener('message', ({ data }) => {
+            const response = JSON.parse(data);
+            if (response.type === 'reload') {
+                switch (response.content) {
+                    case 'RELOAD_CONTENT_SCRIPT':
+                    case 'RELOAD_SW':
+                    case 'RELOAD_CSS':
+                    case 'RELOAD_POPUP_JS':
+                    case 'RELOAD_POPUP_HTML':
+                    case 'ALL':
+                        chrome.runtime.reload();
+                        break;
+                }
+            }
+        });
+        setTimeout(() => {
+            websocket.close();
+        }, 25 * 1000);
+    }
+    // Keep a service_worker life.
+    startWebsocket25secLife();
+    setInterval(() => {
+        startWebsocket25secLife();
+    }, 25 * 1000);
+}
+
+function userjs(host, port, websocketPort, bindGM, disableSock, buildId) {
+    unsafeWindow.__CRX_CONTENT_BUILD_ID = buildId;
+    if (!disableSock) {
+        const websocket = new WebSocket(`ws://${host}:${websocketPort}`);
+        websocket.addEventListener('message', ({ data }) => {
+            const { type, content } = JSON.parse(data);
+            if (type === 'reload') {
+                switch (content) {
+                    case 'RELOAD_CSS':
+                    case 'RELOAD_CONTENT_SCRIPT':
+                        console.log('[crxm] reloading...');
+                        location.reload();
+                        break;
+                }
+            }
+        });
+        websocket.addEventListener('open', () => {
+            console.log('[crxm] A reload server connected..');
+            window.addEventListener('message', (e) => {
+                const { data } = e;
+                /**
+                 * Client can listen a result by using of this.
+                 */
+                const handlers = {
+                    'console-log': () => {
+                        const preload = {
+                            type: 'console',
+                            content: {
+                                type: 'log',
+                                contents: data.detail,
+                            },
+                        };
+                        websocket.send(JSON.stringify(preload));
+                    },
+                    'console-error': () => {
+                        const preload = {
+                            type: 'console',
+                            content: {
+                                type: 'error',
+                                contents: data.detail,
+                            },
+                        };
+                        websocket.send(JSON.stringify(preload));
+                    },
+                    'console-warn': () => {
+                        const preload = {
+                            type: 'console',
+                            content: {
+                                type: 'warn',
+                                contents: data.detail,
+                            },
+                        };
+                        websocket.send(JSON.stringify(preload));
+                    },
+                };
+                /**
+                 * # BuildId Check
+                 * If a build id of recieved message isn't equiavalent with a buildId of isolatedConnector,
+                 * wouldn't be runned the handler so It can prevent being runned from other scripts.
+                 */
+                if (data.crxContentBuildId === buildId) {
+                    const handler = handlers[data.type];
+                    if (handler !== undefined) {
+                        handler();
+                    }
+                }
+            });
+        });
+        websocket.addEventListener('close', () => {
+            console.log('[crxm] A reload server disconnected..');
+        });
+    }
+    function watchScriptDiff(initialCode) {
+        const scriptContentTmp = initialCode;
+        setInterval(() => {
+            getResponse().then((code) => {
+                if (scriptContentTmp !== code) {
+                    location.reload();
+                }
+            });
+        }, 1000);
+        return scriptContentTmp;
+    }
+    async function getResponse() {
+        return new Promise((resolve) => {
+            GM.xmlHttpRequest({
+                url: `http://${host}:${port}/userscript`,
+                onload: (e) => {
+                    resolve(e.responseText);
+                },
+            });
+        });
+    }
+    let loaded = false;
+    document.addEventListener('DOMContentLoaded', () => {
+        loaded = true;
+    });
+    getResponse().then((code) => {
+        if (typeof code === 'string') {
+            if (disableSock) {
+                watchScriptDiff(code);
+            }
+            const injectCode = code;
+            /*
+              if (bindGM) {
+                const bindGMverName = btoa(crypto.randomUUID()).replaceAll('=', '$');
+                unsafeWindow[bindGMverName] = GM;
+                injectCode = `const ${bindGMHash} = window["${bindGMverName}"];` + injectCode;
+              }
+              */
+            const scriptElem = document.createElement('script');
+            scriptElem.textContent = injectCode;
+            unsafeWindow.document.body.appendChild(scriptElem);
+            if (loaded) {
+                document.dispatchEvent(new Event('crxm_DOMContentLoaded'));
+            }
+        }
+    });
+}
+
+function developmentContentScript(crxContentBuildId, host, websocketPort) {
+    const websocket = new WebSocket(`ws://${host}:${websocketPort}`);
+    websocket.addEventListener('open', () => {
+        console.log('[crxm] A reload server connected..');
+    });
+    websocket.addEventListener('close', () => {
+        console.log('[crxm] A reload server disconnected..');
+    });
+    websocket.addEventListener('message', ({ data }) => {
+        const response = JSON.parse(data);
+        if (response.type === 'reload') {
+            switch (response.content) {
+                case 'RELOAD_CSS':
+                case 'RELOAD_CONTENT_SCRIPT':
+                    location.reload();
+                    break;
+            }
+        }
+    });
+    window.addEventListener('message', (e) => {
+        const { data } = e;
+        /**
+         * Client can listen a result by using of this.
+         */
+        const handlers = {
+            'console-log': () => {
+                const preload = {
+                    type: 'console',
+                    content: {
+                        type: 'log',
+                        contents: data.detail,
+                    },
+                };
+                websocket.send(JSON.stringify(preload));
+            },
+            'console-error': () => {
+                const preload = {
+                    type: 'console',
+                    content: {
+                        type: 'error',
+                        contents: data.detail,
+                    },
+                };
+                websocket.send(JSON.stringify(preload));
+            },
+            'console-warn': () => {
+                const preload = {
+                    type: 'console',
+                    content: {
+                        type: 'warn',
+                        contents: data.detail,
+                    },
+                };
+                websocket.send(JSON.stringify(preload));
+            },
+        };
+        /**
+         * # BuildId Check
+         * If a build id of recieved message isn't equiavalent with a buildId of isolatedConnector,
+         * wouldn't be runned the handler so It can prevent being runned from other scripts.
+         */
+        if (data.crxContentBuildId === crxContentBuildId) {
+            const handler = handlers[data.type];
+            if (handler !== undefined) {
+                handler();
+            }
+        }
+    });
+}
+function isolatedConnector(crxContentBuildId, config) {
+    const messageListeners = {};
+    /**
+     * How it works?
+     *
+     * 1. A client (e.g. contentscripts.ts in MAIN world) : dispatch message to window.
+     * 2. This EventListener recieved.
+     * 3. This EventListener dispatchs CustomEvent that 'crx-isolated-connector-result' to window.
+     * 4. A client recieved CustomEvent as result.
+     */
+    window.addEventListener('message', (e) => {
+        const { data, target } = e;
+        /**
+         * Send event of response to target.
+         * @param name custom event name.
+         * @param type custom event type.
+         * @param detail custom event detail.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint, @typescript-eslint/no-explicit-any
+        function dispatch(name, type, detail) {
+            if (target !== null) {
+                target.dispatchEvent(new CustomEvent(name, {
+                    detail: {
+                        type,
+                        data: detail,
+                        actionId: data.actionId,
+                    },
+                }));
+            }
+        }
+        /**
+         * Client can listen a result by using of this.
+         */
+        const responseEventName = 'crx-isolated-connector-result';
+        const handlers = {
+            'get-id': () => {
+                // Send extension runtime id.
+                dispatch(responseEventName, 'get-id', chrome.runtime.id);
+            },
+            'get-conf': () => {
+                // Send crx-monkey config stringified.
+                dispatch(responseEventName, 'get-conf', config);
+            },
+            'on-message': () => {
+                // Append a message listener from client.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const handleMessage = (request, sender) => {
+                    dispatch(responseEventName, 'on-message', { request, sender });
+                };
+                messageListeners[data.actionId] = handleMessage;
+                chrome.runtime.onMessage.addListener(handleMessage);
+            },
+            'remove-on-message': () => {
+                // Remove a message listener from client.
+                if (messageListeners[data.actionId] !== undefined) {
+                    chrome.runtime.onMessage.removeListener(messageListeners[data.actionId]);
+                }
+            },
+            'send-message': () => {
+                // Send a message from client.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                chrome.runtime.sendMessage(data.detail.message, data.detail.options, (response) => {
+                    dispatch(responseEventName, 'send-message', { response });
+                });
+            },
+        };
+        /**
+         * # BuildId Check
+         * If a build id of recieved message isn't equiavalent with a buildId of isolatedConnector,
+         * wouldn't be runned the handler so It can prevent being runned from other scripts.
+         */
+        if (data.crxContentBuildId === crxContentBuildId) {
+            const handler = handlers[data.type];
+            if (handler !== undefined) {
+                handler();
+            }
+        }
+    });
+}
+
+let CreateDevClient = class CreateDevClient {
+    configLoader;
+    bundler;
+    headerFactory;
+    manifestFactory;
+    buildId;
+    constructor(configLoader, bundler, headerFactory, manifestFactory, buildId) {
+        this.configLoader = configLoader;
+        this.bundler = bundler;
+        this.headerFactory = headerFactory;
+        this.manifestFactory = manifestFactory;
+        this.buildId = buildId;
+    }
+    /**
+     * Make code for service worker on developement.
+     */
+    outputDevelomentSw(code) {
+        const { server: { host, websocket }, } = this.configLoader.useConfig();
+        if (host === undefined || websocket === undefined) {
+            throw new Error("Server host or websocket's port were not specificated");
+        }
+        const decoder = new TextDecoder('utf-8');
+        const originalCode = decoder.decode(code);
+        const devCode = stringifyFunction(developSw, [host, websocket]);
+        const result = devCode + '\n\n' + originalCode;
+        return result;
+    }
+    outputDevelopmentUserjs() {
+        const { server: { disable_sock_in_userjs, host, port, websocket }, } = this.configLoader.useConfig();
+        if (host === undefined || websocket === undefined || port === undefined) {
+            throw new Error("Server host, port or  websocket's port were not specificated");
+        }
+        const disableSock = disable_sock_in_userjs === undefined ? false : disable_sock_in_userjs;
+        const newFactory = new UserscriptHeaderFactory(this.headerFactory);
+        // for loading code from server in development mode.
+        newFactory.push('@grant', 'GM_xmlhttpRequest');
+        const code = [
+            newFactory.toString(),
+            '',
+            stringifyFunction(userjs, [host, port, websocket, false, disableSock, this.buildId]),
+        ].join('\n');
+        return code;
+    }
+    outputDevExtension() {
+        const { output: { chrome }, server: { host, websocket }, } = this.configLoader.useConfig();
+        if (chrome === undefined || host === undefined || websocket === undefined) {
+            throw new Error('');
+        }
+        /**
+         * Development contentscript in isolated env
+         */
+        const devScriptIsolatedFileName = 'crxm-development.js';
+        const devScriptIsolatedPath = resolve(chrome, devScriptIsolatedFileName);
+        const devScriptIsolatedCode = stringifyFunction(developmentContentScript, [
+            this.buildId,
+            host,
+            websocket,
+        ]);
+        fsExtra$1.outputFileSync(devScriptIsolatedPath, devScriptIsolatedCode);
+        this.manifestFactory.addContentScript([devScriptIsolatedFileName], [], ['<all_urls>'], 'ISOLATED');
+    }
+    /**
+     * Include isolated connector
+     */
+    outputIsolatedConnector() {
+        const { output: { chrome }, server: { host, websocket }, } = this.configLoader.useConfig();
+        if (chrome === undefined || host === undefined || websocket === undefined) {
+            throw new Error('');
+        }
+        let includeConnector = false;
+        const isolatedmatches = [];
+        this.manifestFactory.rawManifest.content_scripts.forEach(({ use_isolated_connection, matches }) => {
+            if (use_isolated_connection) {
+                isolatedmatches.push(...(matches !== undefined ? matches : []));
+                includeConnector = true;
+            }
+        });
+        if (includeConnector) {
+            const isoFileName = 'crxm-isolated-connector.js';
+            const isoConnectorPath = resolve(chrome, isoFileName);
+            outputFileSync(isoConnectorPath, `${stringifyFunction(isolatedConnector, [this.buildId, JSON.stringify(this.configLoader.useConfig())])}\n`);
+            this.manifestFactory.addContentScript([isoFileName], [], [...isolatedmatches], 'ISOLATED', 'document_start');
+        }
+    }
+};
+CreateDevClient = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __param(1, inject(TYPES.CrxmBundler)),
+    __param(2, inject(TYPES.UserscriptHeaderFactory)),
+    __param(3, inject(TYPES.ManifestFactory)),
+    __param(4, inject(TYPES.BuildID)),
+    __metadata("design:paramtypes", [ConfigLoader,
+        CrxmBundler,
+        UserscriptHeaderFactory,
+        ManifestFactory, String])
+], CreateDevClient);
+/**
+ * Stringify a function that binded args.
+ * @param target function
+ * @param args args
+ * @returns A function stringified.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function stringifyFunction(target, args) {
+    const raw = target.toString();
+    const newArgs = args.map((arg) => {
+        if (typeof arg === 'string') {
+            return `'${arg}'`;
+        }
+        else {
+            return String(arg);
+        }
+    });
+    const code = `(${raw})(${newArgs.join(', ')});`;
+    return code;
+}
+
+let Distributior = class Distributior {
+    bundler;
+    manifestLoader;
+    manifestParser;
+    manifestFactory;
+    configLoader;
+    userscriptBundler;
+    createDev;
+    isWatch;
+    buildId;
+    defines = {
+        content: [],
+        sw: [],
+        popup: [],
+    };
+    constructor(bundler, manifestLoader, manifestParser, manifestFactory, configLoader, userscriptBundler, createDev, isWatch, buildId) {
+        this.bundler = bundler;
+        this.manifestLoader = manifestLoader;
+        this.manifestParser = manifestParser;
+        this.manifestFactory = manifestFactory;
+        this.configLoader = configLoader;
+        this.userscriptBundler = userscriptBundler;
+        this.createDev = createDev;
+        this.isWatch = isWatch;
+        this.buildId = buildId;
+    }
+    /**
+     * Output bundled file
+     * This must be used after bundled.
+     */
+    dist() {
+        this.outputBundled();
+        //this.copyAssetsDir();
+    }
+    /**
+     * Remove dist
+     */
+    async cleanupDist() {
+        const { output } = this.configLoader.useConfig();
+        if (output.chrome !== undefined) {
+            const dist = dirname(output.chrome);
+            await fsExtra.remove(dist);
+        }
+    }
+    initializeDefine() {
+        this.defines = {
+            content: [],
+            sw: [],
+            popup: [],
+        };
+    }
+    /**
+     * Variables to add to your code
+     * @param name
+     * @param value
+     * @param to
+     */
+    addDefine(name, value, to) {
+        this.defines[to].push({ name, value });
+    }
+    createDefineCode(defines) {
+        return (defines
+            .map(({ name, value }) => {
+            return `var ${name} = ${value};`;
+        })
+            .join('\n') + '\n');
+    }
+    /**
+     * Output bundled file
+     */
+    outputBundled() {
+        const { output } = this.configLoader.useConfig();
+        if (output.chrome !== undefined) {
+            this.chromeBundle(output.chrome);
+            this.copyPublicDir(output.chrome);
+            this.copyIcons(output.chrome);
+            this.outputManifest(output.chrome);
+        }
+        if (output.userjs !== undefined) {
+            this.userjsBundle(output.userjs);
+        }
+    }
+    /**
+     * Convert a file extension that is .ts to .js.
+     * @param filePath
+     * @returns A filePath that extension converted to .js.
+     */
+    changeExt(filePath, newExt) {
+        const rawFileNameSplited = basename(filePath).split('.');
+        rawFileNameSplited[rawFileNameSplited.length - 1] = newExt;
+        const newFilename = rawFileNameSplited.join('.');
+        return newFilename;
+    }
+    /**
+     * Output manifest file.
+     * This operation must be used after all transpiling.
+     * @param outputPath
+     */
+    outputManifest(outputPath) {
+        const manifest = this.manifestFactory.getWorkspace();
+        fsExtra.outputFileSync(resolve(outputPath, 'manifest.json'), JSON.stringify(manifest, undefined, 2));
+    }
+    /**
+     * Output for chrome
+     * @param distPath
+     */
+    chromeBundle(distPath) {
+        const { resources: { scriptResources, cssResources, htmlResources: { popup }, raw, }, } = this.manifestParser.parseResult;
+        scriptResources.content.forEach((path, i) => {
+            const result = this.bundler.getBuildResultFromPath(path);
+            if (result !== undefined) {
+                const extChanged = this.changeExt(path, 'js');
+                const endemicHash = MurmurHash3.x86.hash32(path).toString();
+                const fileName = endemicHash + '_' + extChanged;
+                const outputPath = resolve(distPath, fileName);
+                const decoder = new TextDecoder();
+                const decorded = decoder.decode(result);
+                let code = this.createDefineCode(this.defines.content) + decorded;
+                if (this.isWatch) {
+                    code = `window.__CRX_CONTENT_BUILD_ID = '${this.buildId}';\n` + code;
+                }
+                fsExtra.outputFileSync(outputPath, code);
+                this.manifestFactory.resolve(raw.scriptResources.content[i], fileName);
+            }
+        });
+        scriptResources.sw.forEach((path, i) => {
+            const buildResult = this.bundler.getBuildResultFromPath(path);
+            const extChanged = this.changeExt(path, 'js');
+            const endemicHash = MurmurHash3.x86.hash32(path).toString();
+            const fileName = endemicHash + '_' + extChanged;
+            const outputPath = resolve(distPath, fileName);
+            if (buildResult !== undefined) {
+                let code;
+                if (this.isWatch) {
+                    code =
+                        this.createDefineCode(this.defines.sw) + this.createDev.outputDevelomentSw(buildResult);
+                }
+                else {
+                    const decoder = new TextDecoder();
+                    code = this.createDefineCode(this.defines.sw) + decoder.decode(buildResult);
+                }
+                fsExtra.outputFileSync(outputPath, code);
+                this.manifestFactory.resolve(raw.scriptResources.sw[i], fileName);
+            }
+        });
+        cssResources.forEach((path, i) => {
+            const result = this.bundler.getBuildResultFromPath(path);
+            const extChanged = this.changeExt(path, 'css');
+            const endemicHash = MurmurHash3.x86.hash32(path).toString();
+            const fileName = endemicHash + '_' + extChanged;
+            const outputPath = resolve(distPath, fileName);
+            if (result !== undefined) {
+                fsExtra.outputFileSync(outputPath, result);
+                this.manifestFactory.resolve(raw.cssResources[i], fileName);
+            }
+        });
+        popup.forEach((path, i) => {
+            const result = this.bundler.getBuildResultFromPath(path);
+            const endemicHash = MurmurHash3.x86.hash32(path).toString();
+            const fileName = endemicHash + '.html';
+            const outputPath = resolve(distPath, fileName);
+            if (result !== undefined) {
+                const decoder = new TextDecoder();
+                const code = this.createDefineCode(this.defines.popup) + decoder.decode(result);
+                fsExtra.outputFileSync(outputPath, code);
+                this.manifestFactory.resolve(raw.htmlResources.popup[i], fileName);
+            }
+        });
+    }
+    async userjsBundle(distPath) {
+        const { resources: { scriptResources, raw, cssResources }, } = this.manifestParser.parseResult;
+        scriptResources.content.forEach((path, i) => {
+            const result = this.bundler.getBuildResultFromPath(path);
+            if (result !== undefined) {
+                this.userscriptBundler.addBuildResult(raw.scriptResources.content[i], result);
+            }
+        });
+        cssResources.forEach((path, i) => {
+            const result = this.bundler.getBuildResultFromPath(path);
+            if (result !== undefined) {
+                this.userscriptBundler.addStyle(raw.cssResources[i], result);
+            }
+        });
+        const output = resolve(distPath);
+        const bundleResult = this.userscriptBundler.createCode();
+        if (bundleResult !== undefined) {
+            const formated = await prettier.format(bundleResult, {
+                format: true,
+                parser: 'babel',
+                semi: true,
+            });
+            fsExtra.outputFileSync(output, formated);
+        }
+        if (this.isWatch) {
+            const code = this.createDev.outputDevelopmentUserjs();
+            const output = resolve(dirname(distPath), 'dev.user.js');
+            fsExtra.outputFileSync(output, code);
+        }
+    }
+    copyPublicDir(distPath) {
+        const { public: publicDir } = this.configLoader.useConfig();
+        if (publicDir !== undefined) {
+            fsExtra.copySync(publicDir, resolve(distPath, 'public'), {
+                overwrite: true,
+            });
+        }
+    }
+    copyIcons(distPath) {
+        const { icons } = this.manifestParser.parseResult;
+        if (icons !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            Object.entries(icons).forEach(([key, { raw, path, size }]) => {
+                const fileName = basename(path);
+                const output = resolve(distPath, 'assets/icons', fileName);
+                fsExtra.copySync(path, output);
+                this.manifestFactory.resolve(raw, 'assets/icons/' + fileName);
+            });
+        }
+    }
+};
+Distributior = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.CrxmBundler)),
+    __param(1, inject(TYPES.ManifestLoader)),
+    __param(2, inject(TYPES.ManifestParser)),
+    __param(3, inject(TYPES.ManifestFactory)),
+    __param(4, inject(TYPES.ConfigLoader)),
+    __param(5, inject(TYPES.UserscriptBundler)),
+    __param(6, inject(TYPES.CreateDevClient)),
+    __param(7, inject(TYPES.IsWatch)),
+    __param(8, inject(TYPES.BuildID)),
+    __metadata("design:paramtypes", [CrxmBundler,
+        ManifestLoader,
+        ManifestParser,
+        ManifestFactory,
+        ConfigLoader,
+        UserscriptBundler,
+        CreateDevClient, Boolean, String])
+], Distributior);
+
+let BundlerRegisterer = class BundlerRegisterer {
+    manifestLoader;
+    manifestParser;
+    configLoader;
+    watcher;
+    bundler;
+    logger;
+    isWatch;
+    distributior;
+    contentScripts = [];
+    sw = [];
+    cssResources = [];
+    htmlResources = [];
+    constructor(manifestLoader, manifestParser, configLoader, watcher, bundler, logger, isWatch, distributior) {
+        this.manifestLoader = manifestLoader;
+        this.manifestParser = manifestParser;
+        this.configLoader = configLoader;
+        this.watcher = watcher;
+        this.bundler = bundler;
+        this.logger = logger;
+        this.isWatch = isWatch;
+        this.distributior = distributior;
+    }
+    /**
+     * Register all build targets for bundler from manifest.
+     */
+    registerAll() {
+        const fileChangeResult = this.fileChangeCheck();
+        /**
+         * Add added targets to bundle targets.
+         */
+        const addTargetGroups = [
+            ['content', fileChangeResult.script.content.added],
+            ['sw', fileChangeResult.script.sw.added],
+            ['css', fileChangeResult.css.added],
+            ['html', fileChangeResult.html.added],
+        ];
+        for (const [flag, paths] of addTargetGroups) {
+            for (const path of paths) {
+                const buildPlugin = this.getAppropriateBuildPlugin(path);
+                const watchPlugin = this.getAppropriateWatchPlugin(path);
+                if (!buildPlugin) {
+                    console.error(`Could not find the appropriate plugin for building "${path}"`);
+                    continue;
+                }
+                if (!watchPlugin) {
+                    console.error(`Could not find the appropriate plugin for watching "${path}"`);
+                    continue;
+                }
+                this.bundler.addTarget(path, { build: buildPlugin, watch: watchPlugin }, flag);
+            }
+        }
+        /**
+         * Remove removed targets from bundle targets.
+         */
+        const rmTargetGroups = [
+            ['content', fileChangeResult.script.content.removed],
+            ['sw', fileChangeResult.script.sw.removed],
+            ['css', fileChangeResult.css.removed],
+            ['html', fileChangeResult.html.removed],
+        ];
+        for (const [flag, paths] of rmTargetGroups) {
+            for (const path of paths) {
+                this.bundler.removeTarget(path, flag);
+            }
+        }
+        this.defineAllVars();
+    }
+    /**
+     * Load and register variables written in a conifg add to the bundled code
+     */
+    defineAllVars() {
+        const { define } = this.configLoader.useConfig();
+        if (define.contentscripts !== undefined) {
+            Object.entries(define.contentscripts).forEach(([name, value]) => {
+                this.distributior.addDefine(name, value, 'content');
+            });
+        }
+        if (define.sw !== undefined) {
+            Object.entries(define.sw).forEach(([name, value]) => {
+                this.distributior.addDefine(name, value, 'sw');
+            });
+        }
+        if (define.popup !== undefined) {
+            Object.entries(define.popup).forEach(([name, value]) => {
+                this.distributior.addDefine(name, value, 'popup');
+            });
+        }
+    }
+    /**
+     * Get build plugin
+     * @param filePath
+     * @returns
+     */
+    getAppropriateBuildPlugin(filePath) {
+        const { build } = this.configLoader.useConfig();
+        for (const [pattern, plugin] of Object.entries(build)) {
+            const regex = new RegExp(pattern);
+            if (regex.test(filePath)) {
+                return plugin;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get watch plugin
+     * @param filePath
+     * @returns
+     */
+    getAppropriateWatchPlugin(filePath) {
+        const { watch } = this.configLoader.useConfig();
+        for (const [pattern, plugin] of Object.entries(watch)) {
+            const regex = new RegExp(pattern);
+            if (regex.test(filePath)) {
+                return plugin;
+            }
+        }
+        return null;
+    }
+    /**
+     * Compare file change.
+     * @returns
+     */
+    fileChangeCheck() {
+        const manifest = this.manifestLoader.useManifest();
+        const confPath = this.configLoader.useConfigPath();
+        const projectDir = dirname(confPath);
+        const parsed = this.manifestParser.parse(manifest);
+        const { resources: { scriptResources: { sw, content }, cssResources, htmlResources, }, } = parsed;
+        /**
+         * content Script
+         */
+        const contentResourcesAbsoluted = content.map((scriptPath) => {
+            return resolve(projectDir, scriptPath);
+        });
+        const contentScriptAdded = [];
+        const contentScriptRemoved = [];
+        contentResourcesAbsoluted.forEach((absolutePath) => {
+            if (!this.contentScripts.includes(absolutePath)) {
+                // It's new file
+                this.contentScripts.push(absolutePath);
+                contentScriptAdded.push(absolutePath);
+                this.logger.dispatchDebug(`👀 New content script detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        this.contentScripts.forEach((absolutePath) => {
+            if (!contentResourcesAbsoluted.includes(absolutePath)) {
+                // It's removed file
+                this.contentScripts = this.contentScripts.filter((x) => x !== absolutePath);
+                contentScriptRemoved.push(absolutePath);
+                this.logger.dispatchDebug(`👓 Removed content script detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        /**
+         * sw
+         */
+        const swResourcesAbsoluted = sw.map((scriptPath) => {
+            return resolve(projectDir, scriptPath);
+        });
+        const swAdded = [];
+        const swRemoved = [];
+        swResourcesAbsoluted.forEach((absolutePath) => {
+            if (!this.sw.includes(absolutePath)) {
+                // It's new file
+                this.sw.push(absolutePath);
+                swAdded.push(absolutePath);
+                this.logger.dispatchDebug(`👀 New service worker detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        this.sw.forEach((absolutePath) => {
+            if (!swResourcesAbsoluted.includes(absolutePath)) {
+                // It's removed file
+                this.sw = this.sw.filter((x) => x !== absolutePath);
+                swRemoved.push(absolutePath);
+                this.logger.dispatchDebug(`👓 Removed service worker detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        /**
+         * CSS
+         */
+        const cssResourcesAbsoluted = cssResources.map((scriptPath) => {
+            return resolve(projectDir, scriptPath);
+        });
+        const cssAdded = [];
+        const cssRemoved = [];
+        cssResourcesAbsoluted.forEach((absolutePath) => {
+            if (!this.cssResources.includes(absolutePath)) {
+                // It's new file
+                this.cssResources.push(absolutePath);
+                cssAdded.push(absolutePath);
+                this.logger.dispatchDebug(`👀 New css detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        this.cssResources.forEach((absolutePath) => {
+            if (!cssResourcesAbsoluted.includes(absolutePath)) {
+                // It's removed file
+                this.cssResources = this.cssResources.filter((x) => x !== absolutePath);
+                cssRemoved.push(absolutePath);
+                this.logger.dispatchDebug(`👓 Removed css detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        /**
+         * html
+         */
+        const htmlResourcesAbsoluted = htmlResources.popup.map((htmlPath) => {
+            return resolve(projectDir, htmlPath);
+        });
+        const htmlAdded = [];
+        const htmlRemoved = [];
+        htmlResourcesAbsoluted.forEach((absolutePath) => {
+            if (!this.htmlResources.includes(absolutePath)) {
+                // It's new file
+                this.htmlResources.push(absolutePath);
+                htmlAdded.push(absolutePath);
+                this.logger.dispatchDebug(`👀 New html detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        this.htmlResources.forEach((absolutePath) => {
+            if (!htmlResourcesAbsoluted.includes(absolutePath)) {
+                // It's removed file
+                this.htmlResources = this.htmlResources.filter((x) => x !== absolutePath);
+                htmlRemoved.push(absolutePath);
+                this.logger.dispatchDebug(`👓 Removed html detected ${chalk.gray('"' + absolutePath + '"')}`);
+            }
+        });
+        return {
+            script: {
+                sw: {
+                    added: swAdded,
+                    removed: swRemoved,
+                },
+                content: {
+                    added: contentScriptAdded,
+                    removed: contentScriptRemoved,
+                },
+            },
+            css: {
+                added: cssAdded,
+                removed: cssRemoved,
+            },
+            html: {
+                added: htmlAdded,
+                removed: htmlRemoved,
+            },
+        };
+    }
+};
+BundlerRegisterer = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ManifestLoader)),
+    __param(1, inject(TYPES.ManifestParser)),
+    __param(2, inject(TYPES.ConfigLoader)),
+    __param(3, inject(TYPES.Watcher)),
+    __param(4, inject(TYPES.CrxmBundler)),
+    __param(5, inject(TYPES.Logger)),
+    __param(6, inject(TYPES.IsWatch)),
+    __param(7, inject(TYPES.Distributior)),
+    __metadata("design:paramtypes", [ManifestLoader,
+        ManifestParser,
+        ConfigLoader,
+        Watcher,
+        CrxmBundler,
+        Logger, Boolean, Distributior])
+], BundlerRegisterer);
+
+let UserscriptRegisterer = class UserscriptRegisterer {
+    manifestFactory;
+    headerFactory;
+    manifestParser;
+    manifestLoader;
+    configLoader;
+    constructor(manifestFactory, headerFactory, manifestParser, manifestLoader, configLoader) {
+        this.manifestFactory = manifestFactory;
+        this.headerFactory = headerFactory;
+        this.manifestParser = manifestParser;
+        this.manifestLoader = manifestLoader;
+        this.configLoader = configLoader;
+    }
+    async sync() {
+        await this.setManifestToUserscript();
+    }
+    async setManifestToUserscript() {
+        const rawManifest = this.manifestLoader.useManifest();
+        const userscriptHeaderFactory = this.headerFactory;
+        if (rawManifest.content_scripts !== undefined) {
+            const { allMatches } = this.createMatchMap();
+            if (!allMatches.includes('<all_urls>')) {
+                userscriptHeaderFactory.push('@match', 'http://*/*');
+                userscriptHeaderFactory.push('@match', 'https://*/*');
+            }
+        }
+        /**
+         * Set version designation by manifest to header.
+         */
+        userscriptHeaderFactory.push('@version', rawManifest.version);
+        /*
+        if (rawManifest.run_at !== undefined) {
+          userscriptHeaderFactory.push(
+            '@run-at',
+            this.convertChromeRunAtToUserJsRunAt(rawManifest.run_at),
+          );
+        } else {*/
+        userscriptHeaderFactory.push('@run-at', 'document-start');
+        // }
+        /**
+         * Set name.
+         * If can not found locale message, even if language key is not en, it will be en.
+         */
+        const names = await geti18nMessages(rawManifest.name);
+        Object.keys(names).forEach((lang) => {
+            if (lang === 'en') {
+                // default is en.
+                userscriptHeaderFactory.push('@name', names[lang]);
+            }
+            else {
+                userscriptHeaderFactory.push(`@name:${lang}`, names[lang]);
+            }
+        });
+        /**
+         * Set description.
+         * If can not found locale message, even if language key is not en, it will be en.
+         */
+        if (rawManifest.description !== undefined) {
+            const descriptions = await geti18nMessages(rawManifest.description);
+            Object.keys(descriptions).forEach((lang) => {
+                if (lang === 'en') {
+                    userscriptHeaderFactory.push('@description', descriptions[lang]);
+                }
+                else {
+                    userscriptHeaderFactory.push(`@description:${lang}`, descriptions[lang]);
+                }
+            });
+        }
+        if (rawManifest.content_scripts !== undefined) {
+            let useDirectInject = false;
+            rawManifest.content_scripts.forEach(({ userscript_direct_inject }) => {
+                if (userscript_direct_inject) {
+                    useDirectInject = true;
+                }
+            });
+            if (useDirectInject) {
+                userscriptHeaderFactory.push('@grant', 'unsafeWindow');
+            }
+        }
+        /**
+         * Icon
+         */
+        const icons = this.manifestParser.parseResult.icons;
+        if (icons !== null) {
+            const keys = Object.keys(icons);
+            if (keys.length === 0)
+                return undefined;
+            const minSize = Math.min(...keys.map(Number));
+            const minIcon = icons[minSize];
+            const base64 = this.convertImgToBase64(minIcon.path);
+            userscriptHeaderFactory.push('@icon', base64);
+        }
+        /**
+         * Add aditional headers
+         */
+        const { header } = this.configLoader.useConfig();
+        if (header !== undefined) {
+            header.forEach(([key, value]) => {
+                userscriptHeaderFactory.push(key, value);
+            });
+        }
+    }
+    /**
+     * Enumerate all js and css paths from conetnt_scripts in manifestjson
+     * @param contentScripts
+     * @param jsFiles
+     * @param cssFiles
+     * @returns
+     */
+    createMatchMap() {
+        const { scriptResources, cssResources } = this.manifestParser.parseResult.resources.raw;
+        const { content_scripts } = this.manifestLoader.useManifest();
+        const allMatches = [];
+        const matchMap = {};
+        scriptResources.content.forEach((jsPath) => {
+            matchMap[jsPath] = [];
+        });
+        cssResources.forEach((cssPath) => {
+            matchMap[cssPath] = [];
+        });
+        content_scripts.forEach((contentScript) => {
+            const matches = contentScript.matches;
+            if (matches !== undefined) {
+                matches.forEach((match) => {
+                    if (!allMatches.includes(match)) {
+                        allMatches.push(match);
+                    }
+                });
+                contentScript.js?.forEach((jsPath) => {
+                    matchMap[jsPath].push(...matches);
+                });
+                contentScript.css?.forEach((cssPath) => {
+                    matchMap[cssPath].push(...matches);
+                });
+            }
+        });
+        return { matchMap, allMatches };
+    }
+    /**
+     * Run_at in chrome extension manifest convert to runAt in userscript.
+     * @param chromeRunAt
+     * @returns
+     */
+    convertChromeRunAtToUserJsRunAt(chromeRunAt) {
+        if (chromeRunAt === 'document_start') {
+            return 'document-start';
+        }
+        else if (chromeRunAt === 'document_end') {
+            return 'document-end';
+        }
+        else if (chromeRunAt === 'document_idle') {
+            return 'document-idle';
+        }
+        else {
+            throw new Error([
+                'Unknown run_at type.',
+                'Please specify a valid run_at',
+                'Chrome Reference: https://developer.chrome.com/docs/extensions/reference/api/extensionTypes?hl=ja#type-RunAt',
+            ].join('\n'));
+        }
+    }
+    /**
+     * Convert image to base64 string.
+     * @param imgPath Local image file path.
+     * @returns
+     */
+    convertImgToBase64(imgPath) {
+        const icon = fsExtra.readFileSync(imgPath);
+        const buf = Buffer.from(icon).toString('base64');
+        return `data:image/png;base64,${buf}`;
+    }
+};
+UserscriptRegisterer = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ManifestFactory)),
+    __param(1, inject(TYPES.UserscriptHeaderFactory)),
+    __param(2, inject(TYPES.ManifestParser)),
+    __param(3, inject(TYPES.ManifestLoader)),
+    __param(4, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [ManifestFactory,
+        UserscriptHeaderFactory,
+        ManifestParser,
+        ManifestLoader,
+        ConfigLoader])
+], UserscriptRegisterer);
+
+/**
+ * The websocket server of manage auto reload.
+ */
+let SockServer = class SockServer {
+    configLoader;
+    logger;
+    wserver;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    listeners = [];
+    /**
+     * Start and setup server.
+     * @param host
+     * @param port
+     */
+    constructor(configLoader, logger) {
+        this.configLoader = configLoader;
+        this.logger = logger;
+        const { server: { host, websocket }, } = this.configLoader.useConfig();
+        this.wserver = new WebSocketServer({
+            port: websocket,
+            host: host,
+        });
+        //this.setup();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unnecessary-type-constraint
+    addMsgListener(listener) {
+        this.listeners.push(listener);
+    }
+    dispatch(msg) {
+        this.listeners.forEach((l) => {
+            l(msg);
+        });
+    }
+    setup() {
+        this.wserver.addListener('connection', (socket) => {
+            this.sendMsg(socket, {
+                type: 'connected',
+                content: null,
+            });
+            socket.addEventListener('message', (e) => {
+                if (typeof e.data === 'string') {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const data = JSON.parse(e.data);
+                    this.dispatch(data);
+                }
+                this.sendMsg(socket, {
+                    type: 'send_ok',
+                    content: null,
+                });
+            });
+        });
+    }
+    /**
+     * Send reload signal to websocket client.
+     * @param token
+     */
+    reload(token) {
+        this.wserver.clients.forEach((client) => {
+            this.sendMsg(client, {
+                type: 'reload',
+                content: token,
+            });
+        });
+        this.logger.dispatchDebug(`🔃 Dispatch reload ${chalk.gray('"' + token + '"')}`);
+    }
+    sendMsg(socket, data) {
+        socket.send(JSON.stringify(data));
+    }
+    dispose() {
+        this.wserver.close();
+    }
+};
+SockServer = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __param(1, inject(TYPES.Logger)),
+    __metadata("design:paramtypes", [ConfigLoader,
+        Logger])
+], SockServer);
+
+/*
+/**
+ * The server of send to script code.
+ */
+let FileServer = class FileServer {
+    configLoader;
+    app;
+    server = null;
+    constructor(configLoader) {
+        this.configLoader = configLoader;
+        const { server: { host, port }, } = this.configLoader.useConfig();
+        if (host === undefined || port === undefined) {
+            throw new Error("Server host, port or  websocket's port were not specificated");
+        }
+        this.app = express();
+    }
+    /**
+     * Start server.
+     * @returns
+     */
+    async start() {
+        this.setup();
+        const { server: { host, port }, } = this.configLoader.useConfig();
+        if (host === undefined || port === undefined) {
+            throw new Error("Server host, port or  websocket's port were not specificated");
+        }
+        return new Promise((resolve) => {
+            this.server = this.app.listen(port, host, () => {
+                resolve(1);
+            });
+        });
+    }
+    async dispose() {
+        if (this.server === null) {
+            throw consola.error(new Error('Dispose can be used after Watch is started'));
+        }
+        this.server.close();
+        this.server = null;
+    }
+    setup() {
+        const { output: { chrome, userjs }, manifest, } = this.configLoader.useConfig();
+        if (chrome === undefined || userjs === undefined) {
+            throw new Error('');
+        }
+        this.app.get('/userscript', (req, res) => {
+            let filepath = userjs;
+            if (!isAbsolute(userjs)) {
+                filepath = resolve(dirname(manifest), userjs);
+            }
+            if (fsExtra.existsSync(filepath)) {
+                res.sendFile(filepath);
+            }
+            else {
+                res.send(400);
+            }
+        });
+        this.app.get('/dev.user.js', (req, res) => {
+            let filepath = userjs;
+            if (!isAbsolute(userjs)) {
+                filepath = resolve(dirname(manifest), dirname(userjs), 'dev.user.js');
+            }
+            if (fsExtra.existsSync(filepath)) {
+                res.sendFile(filepath);
+            }
+            else {
+                res.send(400);
+            }
+        });
+    }
+};
+FileServer = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ConfigLoader)),
+    __metadata("design:paramtypes", [ConfigLoader])
+], FileServer);
+
+/**
+ * DI container
+ */
+const container = new Container();
+/**
+ * Classes
+ */
+container.bind(TYPES.Logger).to(Logger).inSingletonScope();
+container.bind(TYPES.ConfigLoader).to(ConfigLoader).inSingletonScope();
+container.bind(TYPES.ManifestLoader).to(ManifestLoader).inSingletonScope();
+container.bind(TYPES.ManifestParser).to(ManifestParser).inSingletonScope();
+container.bind(TYPES.CrxmBundler).to(CrxmBundler).inSingletonScope();
+container.bind(TYPES.Watcher).to(Watcher).inSingletonScope();
+container.bind(TYPES.BundlerRegisterer).to(BundlerRegisterer).inSingletonScope();
+container.bind(TYPES.Distributior).to(Distributior).inSingletonScope();
+container.bind(TYPES.ManifestFactory).to(ManifestFactory).inSingletonScope();
+container.bind(TYPES.UserscriptBundler).to(UserscriptBundler).inSingletonScope();
+container
+    .bind(TYPES.UserscriptHeaderFactory)
+    .to(UserscriptHeaderFactory)
+    .inSingletonScope();
+container
+    .bind(TYPES.UserscriptRegisterer)
+    .to(UserscriptRegisterer)
+    .inSingletonScope();
+container.bind(TYPES.SockServer).to(SockServer).inSingletonScope();
+container.bind(TYPES.CreateDevClient).to(CreateDevClient).inSingletonScope();
+container.bind(TYPES.FileServer).to(FileServer).inSingletonScope();
+/**
+ * Values
+ */
+container.bind(TYPES.CacheDir).toConstantValue('.crxm');
+
+/**
+ * Start develop mode.
+ */
+async function dev() {
+    container.bind(TYPES.IsWatch).toConstantValue(true);
+    container.bind(TYPES.BuildID).toConstantValue(crypto.randomUUID());
+    const logger = container.get(TYPES.Logger);
+    //logger.initialize();
+    const configLoader = container.get(TYPES.ConfigLoader);
+    // Load the config from project.
+    await configLoader.loadConfig();
+    const { logLevel } = configLoader.useConfig();
+    logger.logLevel = logLevel;
+    logger.showInfo();
+    const manifestLoader = container.get(TYPES.ManifestLoader);
+    // Load the manifest from project.
+    await manifestLoader.loadManifest();
+    const manifestFactory = container.get(TYPES.ManifestFactory);
+    const watcher = container.get(TYPES.Watcher);
+    const bundler = container.get(TYPES.CrxmBundler);
+    const distributior = container.get(TYPES.Distributior);
+    const registerer = container.get(TYPES.BundlerRegisterer);
+    const userscriptRegisterer = container.get(TYPES.UserscriptRegisterer);
+    const userscriptHeaderFactory = container.get(TYPES.UserscriptHeaderFactory);
+    const userscriptBundler = container.get(TYPES.UserscriptBundler);
+    const sockServer = container.get(TYPES.SockServer);
+    const createDevClient = container.get(TYPES.CreateDevClient);
+    const fileServer = container.get(TYPES.FileServer);
+    await distributior.cleanupDist();
+    copyLocales();
+    // The websocket server for hotreload.
+    sockServer.setup();
+    fileServer.start();
+    // Register all build targets for bundler from manifest.
+    registerer.registerAll();
+    userscriptBundler.initialize();
+    await userscriptRegisterer.sync();
+    createDevClient.outputDevExtension();
+    createDevClient.outputIsolatedConnector();
+    // Bundle
+    await bundler.watch();
+    // Output bundled file to dist
+    distributior.dist();
+    // On updated manifest or config
+    watcher.addListener(async () => {
+        const { logLevel } = configLoader.useConfig();
+        logger.logLevel = logLevel;
+        logger.showInfo();
+        // Reload manifest from loader
+        manifestFactory.initialize();
+        // Register all build targets for bundler from manifest.
+        registerer.registerAll();
+        userscriptBundler.initialize();
+        userscriptHeaderFactory.initialize();
+        await userscriptRegisterer.sync();
+        createDevClient.outputDevExtension();
+        createDevClient.outputIsolatedConnector();
+        // Bundle
+        await bundler.stopWatch();
+        await bundler.watch();
+        // Output bundled file to dist
+        distributior.dist();
+        await fileServer.dispose();
+        await fileServer.start();
+        sockServer.reload('ALL');
+    });
+    // On updated script
+    bundler.addListener((target) => {
+        distributior.dist();
+        if (target.flag === 'content') {
+            sockServer.reload('RELOAD_CONTENT_SCRIPT');
+        }
+        else if (target.flag === 'sw') {
+            sockServer.reload('RELOAD_SW');
+        }
+        else if (target.flag === 'css') {
+            sockServer.reload('RELOAD_CSS');
+        }
+        else if (target.flag === 'html_script') {
+            sockServer.reload('RELOAD_POPUP_JS');
+        }
+        else if (target.flag === 'html' || target.flag === 'html_css') {
+            sockServer.reload('RELOAD_POPUP_HTML');
+        }
+        else {
+            sockServer.reload('ALL');
+        }
+    });
+    sockServer.addMsgListener((msg) => {
+        if (msg.type === 'console') {
+            switch (msg.content.type) {
+                case 'log':
+                    logger.dispatchConsole(msg.content.contents);
+                    break;
+                case 'error':
+                    logger.dispatchConsole(`${chalk.bgRed(' ERROR ')} ${msg.content.contents}`);
+                    break;
+                case 'warn':
+                    logger.dispatchConsole(`${chalk.bgYellow(' WARN ')} ${msg.content.contents}`);
+                    break;
+            }
+        }
+    });
+    watcher.start();
+}
+
+/**
+ * Nice visibility stack trace.
+ * @param e
+ */
+function errorHandler(e) {
+    const logger = container.get(TYPES.Logger); /*
+    dispatchErr(`${chalk.bgRed(` CRXM ${e.name} `)} ${chalk.bold(e.message)}`);
+  
+    const stack = e.stack?.split('\n');
+    stack?.shift();
+    console.error(stack?.map((l) => chalk.gray(l)).join('\n'));*/
+    const msg = `❌ ${chalk.bold(e.name + ':')} ${chalk.bold(e.message)}`;
+    const stack = e.stack?.split('\n');
+    stack?.shift();
+    const stackStr = stack?.map((l) => chalk.gray(l)).join('\n');
+    logger.dispatchErr(msg, stackStr);
+}
+
+/**
+ * Build extension.
+ */
+async function build() {
+    try {
+        container.bind(TYPES.IsWatch).toConstantValue(false);
+        container.bind(TYPES.BuildID).toConstantValue(crypto.randomUUID());
+        const logger = container.get(TYPES.Logger);
+        logger.initialize();
+        const configLoader = container.get(TYPES.ConfigLoader);
+        // Load the config from project.
+        await configLoader.loadConfig();
+        const { logLevel } = configLoader.useConfig();
+        logger.logLevel = logLevel;
+        logger.dispatchLog('Building...');
+        const manifestLoader = container.get(TYPES.ManifestLoader);
+        // Load the manifest from project.
+        await manifestLoader.loadManifest();
+        const bundler = container.get(TYPES.CrxmBundler);
+        const distributior = container.get(TYPES.Distributior);
+        const registerer = container.get(TYPES.BundlerRegisterer);
+        const userscriptRegisterer = container.get(TYPES.UserscriptRegisterer);
+        const userscriptBundler = container.get(TYPES.UserscriptBundler);
+        await distributior.cleanupDist();
+        copyLocales();
+        // Register all build targets for bundler from manifest.
+        registerer.registerAll();
+        userscriptBundler.initialize();
+        await userscriptRegisterer.sync();
+        // Bundle
+        await bundler.build();
+        // Output bundled file to dist
+        distributior.dist();
+        logger.dispatchLog(`Build successful!`);
+    }
+    catch (e) {
+        const err = e;
+        errorHandler(err);
+    }
+}
+
+/**
+ * The main endpoint for node of crx-monkey.
+ * Scripts in this file are used from console.
+ */
+// For stacktrace.
+sourceMapSupport.install();
+// Register cli
+const cli = cac('crx monkey');
+cli.command('dev', 'Start develop mode.').action(() => {
+    dev();
+});
+cli.command('build', 'Build extension').action(() => {
+    build();
+});
+cli.version(packageJson.version);
+cli.help();
+cli.parse(process.argv, { run: false });
+if (cli.matchedCommand === undefined) {
+    cli.outputHelp();
+}
+else {
+    await cli.runMatchedCommand();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../../node_modules/tslib/tslib.es6.js","../../src/node/file.ts","../../src/node/ConfigLoader.ts","../../src/node/types.ts","../../src/node/manifest/ManifestLoader.ts","../../src/node/manifest/ManifestParser.ts","../../src/node/Logger.ts","../../src/node/CrxmBundler.ts","../../src/node/Watcher.ts","../../src/node/manifest/i18n.ts","../../src/node/manifest/ManifestFactory.ts","../../src/node/userscript/CodeInjector.ts","../../src/node/userscript/UserscriptHeader.ts","../../src/node/userscript/UserscriptBundler.ts","../../src/node/development/codes/sw.ts","../../src/node/development/codes/userjs.ts","../../src/node/development/codes/extension.ts","../../src/node/development/CreateDevClient.ts","../../src/node/Distributior.ts","../../src/node/BundlerRegisterer.ts","../../src/node/userscript/UserscriptRegisterer.ts","../../src/node/server/SockServer.ts","../../src/node/server/FileServer.ts","../../src/node/inversify.config.ts","../../src/node/dev.ts","../../src/node/utils.ts","../../src/node/build.ts","../../src/node/main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n",null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["fse","crypto","packageJ","fsExtra"],"mappings":"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","x_google_ignoreList":[0]}