@addfox/common 0.1.1-beta.2

package/dist/cjs/index.cjs

@@ -0,0 +1,756 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    memoize: ()=>memoize,
+    writeExtensionErrorBlock: ()=>writeExtensionErrorBlock,
+    setAddfoxLoggerRawWrites: ()=>setAddfoxLoggerRawWrites,
+    unflatten: ()=>unflatten,
+    StageHookManager: ()=>StageHookManager,
+    compose: ()=>compose,
+    get: ()=>get,
+    log: ()=>log,
+    deepMerge: ()=>deepMerge,
+    logDoneWithValue: ()=>logDoneWithValue,
+    partial: ()=>partial,
+    popWebExtStdoutOrigin: ()=>popWebExtStdoutOrigin,
+    tap: ()=>tap,
+    AddfoxError: ()=>AddfoxError,
+    pipeAsync: ()=>pipeAsync,
+    ANSI_COLORS: ()=>ANSI_COLORS,
+    logger: ()=>logger,
+    omit: ()=>omit,
+    flatten: ()=>flatten,
+    isEmpty: ()=>isEmpty,
+    pipe: ()=>pipe,
+    error: ()=>logger_error,
+    warn: ()=>warn,
+    logEntriesTable: ()=>logEntriesTable,
+    mapValues: ()=>mapValues,
+    createError: ()=>createError,
+    logDoneTimed: ()=>logDoneTimed,
+    isPlainObject: ()=>isPlainObject,
+    exitWithError: ()=>exitWithError,
+    pushWebExtStdoutOrigin: ()=>pushWebExtStdoutOrigin,
+    createPipeline: ()=>createPipeline,
+    tryCatchAsync: ()=>tryCatchAsync,
+    tryCatch: ()=>tryCatch,
+    set: ()=>set,
+    applyMiddleware: ()=>applyMiddleware,
+    getWebExtStdoutOriginDepth: ()=>getWebExtStdoutOriginDepth,
+    isAddfoxError: ()=>isAddfoxError,
+    ADDFOX_ERROR_CODES: ()=>ADDFOX_ERROR_CODES,
+    HookManager: ()=>HookManager,
+    createCache: ()=>createCache,
+    curry: ()=>curry,
+    filter: ()=>filter,
+    memoizeAsync: ()=>memoizeAsync,
+    pick: ()=>pick,
+    Logger: ()=>Logger,
+    formatDuration: ()=>formatDuration,
+    logDone: ()=>logDone,
+    formatError: ()=>formatError,
+    has: ()=>has
+});
+const external_node_util_namespaceObject = require("node:util");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_cli_table3_namespaceObject = require("cli-table3");
+var external_cli_table3_default = /*#__PURE__*/ __webpack_require__.n(external_cli_table3_namespaceObject);
+const ANSI_COLORS = {
+    ORANGE: "\x1b[38;5;208m",
+    DONE: "\x1b[1m\x1b[32m",
+    TIME: "\x1b[38;5;245m",
+    VALUE: "\x1b[38;5;75m",
+    PURPLE: "\x1b[38;5;141m",
+    ERROR_BADGE: "\x1b[41m\x1b[93m",
+    RED: "\x1b[31m",
+    RESET: "\x1b[0m"
+};
+class Logger {
+    prefix;
+    showTimestamp;
+    useColors;
+    rawWrites = null;
+    constructor(options = {}){
+        this.prefix = options.prefix ?? "[Addfox]";
+        this.showTimestamp = options.showTimestamp ?? false;
+        this.useColors = options.useColors ?? true;
+        this.rawWrites = options.rawWrites ?? null;
+    }
+    setRawWrites(writes) {
+        this.rawWrites = writes;
+    }
+    getWrites() {
+        if (this.rawWrites) return this.rawWrites;
+        return {
+            stdout: process.stdout.write.bind(process.stdout),
+            stderr: process.stderr.write.bind(process.stderr)
+        };
+    }
+    formatPrefix() {
+        if (!this.useColors) return `${this.prefix} `;
+        return `${ANSI_COLORS.ORANGE}${this.prefix}${ANSI_COLORS.RESET} `;
+    }
+    formatTimestamp() {
+        if (!this.showTimestamp) return "";
+        const now = new Date();
+        const timeStr = now.toLocaleTimeString();
+        return this.useColors ? `${ANSI_COLORS.TIME}${timeStr}${ANSI_COLORS.RESET} ` : `${timeStr} `;
+    }
+    writeLines(stream, text) {
+        const w = this.getWrites()[stream];
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        for (const line of text.split("\n"))w(prefix + line + "\n", "utf8");
+    }
+    info(...args) {
+        this.writeLines("stdout", (0, external_node_util_namespaceObject.format)(...args));
+    }
+    log(...args) {
+        this.info(...args);
+    }
+    success(...args) {
+        const text = (0, external_node_util_namespaceObject.format)(...args);
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        for (const line of text.split("\n"))w(prefix + donePrefix + line + "\n", "utf8");
+    }
+    successWithValue(label, value) {
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        const valueColored = this.useColors ? `${ANSI_COLORS.VALUE}${value}${ANSI_COLORS.RESET}` : value;
+        const line = donePrefix + label + " " + valueColored;
+        w(prefix + line + "\n", "utf8");
+    }
+    successWithDuration(message, ms) {
+        const timeStr = this.formatDuration(ms);
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        const timeColored = this.useColors ? `${ANSI_COLORS.TIME}${timeStr}${ANSI_COLORS.RESET}` : timeStr;
+        const line = donePrefix + message + " " + timeColored;
+        w(prefix + line + "\n", "utf8");
+    }
+    warn(...args) {
+        this.writeLines("stderr", (0, external_node_util_namespaceObject.format)(...args));
+    }
+    error(...args) {
+        const text = (0, external_node_util_namespaceObject.format)(...args);
+        const w = this.getWrites().stderr;
+        const lines = text.split("\n");
+        const errorBadge = this.useColors ? `${ANSI_COLORS.ERROR_BADGE} error ${ANSI_COLORS.RESET} ` : " error  ";
+        const redPrefix = this.useColors ? ANSI_COLORS.RED : "";
+        const resetSuffix = this.useColors ? ANSI_COLORS.RESET : "";
+        w("\n", "utf8");
+        if (lines.length > 0) {
+            w(errorBadge + redPrefix + lines[0] + resetSuffix + "\n", "utf8");
+            for(let i = 1; i < lines.length; i++)w(redPrefix + lines[i] + resetSuffix + "\n", "utf8");
+        }
+        w("\n", "utf8");
+    }
+    writeErrorBlock(lines) {
+        const w = this.getWrites().stderr;
+        const errorBadge = this.useColors ? `${ANSI_COLORS.ERROR_BADGE} error ${ANSI_COLORS.RESET} ` : " error  ";
+        const redPrefix = this.useColors ? ANSI_COLORS.RED : "";
+        const resetSuffix = this.useColors ? ANSI_COLORS.RESET : "";
+        w("\n", "utf8");
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i];
+            w(0 === i ? errorBadge + redPrefix + line + resetSuffix + "\n" : redPrefix + line + resetSuffix + "\n", "utf8");
+        }
+        w("\n", "utf8");
+    }
+    formatDuration(ms) {
+        if (ms >= 1000) return (ms / 1000).toFixed(2) + "s";
+        return ms + "ms";
+    }
+    logEntriesTable(entries, options) {
+        if (0 === entries.length) return;
+        const root = options?.root;
+        const headColor = this.useColors ? ANSI_COLORS.PURPLE : "";
+        const resetColor = this.useColors ? ANSI_COLORS.RESET : "";
+        const table = new (external_cli_table3_default())({
+            head: [
+                headColor + "Entry" + resetColor,
+                headColor + "File" + resetColor
+            ],
+            style: {
+                head: [],
+                border: []
+            },
+            chars: {
+                top: "╌",
+                "top-mid": "┬",
+                "top-left": "┌",
+                "top-right": "┐",
+                bottom: "╌",
+                "bottom-mid": "┴",
+                "bottom-left": "└",
+                "bottom-right": "┘",
+                left: "│",
+                "left-mid": "├",
+                mid: "╌",
+                "mid-mid": "┼",
+                right: "│",
+                "right-mid": "┤",
+                middle: "│"
+            }
+        });
+        for (const e of entries){
+            const fileDisplay = void 0 !== root ? this.fileLink(e.scriptPath, external_node_path_default().relative(root, e.scriptPath).replace(/\\/g, "/")) : e.scriptPath;
+            table.push([
+                e.name,
+                fileDisplay
+            ]);
+        }
+        const w = this.getWrites().stdout;
+        w(table.toString() + "\n", "utf8");
+    }
+    fileLink(absolutePath, displayText) {
+        const url = (0, external_node_url_namespaceObject.pathToFileURL)(absolutePath).href;
+        if (!this.useColors) return displayText;
+        return "\x1b]8;;" + url + "\x07" + displayText + "\x1b]8;;\x07";
+    }
+}
+const logger = new Logger();
+function log(...args) {
+    logger.log(...args);
+}
+function logDone(...args) {
+    logger.success(...args);
+}
+function logDoneTimed(message, ms) {
+    logger.successWithDuration(message, ms);
+}
+function logDoneWithValue(label, value) {
+    logger.successWithValue(label, value);
+}
+function formatDuration(ms) {
+    return logger.formatDuration(ms);
+}
+function warn(...args) {
+    logger.warn(...args);
+}
+function logger_error(...args) {
+    logger.error(...args);
+}
+function writeExtensionErrorBlock(lines) {
+    logger.writeErrorBlock(lines);
+}
+function logEntriesTable(entries, options) {
+    logger.logEntriesTable(entries, options);
+}
+function setAddfoxLoggerRawWrites(writes) {
+    logger.setRawWrites(writes);
+}
+const ADDFOX_ERROR_CODES = {
+    CONFIG_NOT_FOUND: "ADDFOX_CONFIG_NOT_FOUND",
+    CONFIG_LOAD_FAILED: "ADDFOX_CONFIG_LOAD_FAILED",
+    MANIFEST_MISSING: "ADDFOX_MANIFEST_MISSING",
+    APP_DIR_MISSING: "ADDFOX_APP_DIR_MISSING",
+    NO_ENTRIES: "ADDFOX_NO_ENTRIES",
+    ENTRY_SCRIPT_FROM_HTML: "ADDFOX_ENTRY_SCRIPT_FROM_HTML",
+    INVALID_BROWSER: "ADDFOX_INVALID_BROWSER",
+    UNKNOWN_COMMAND: "ADDFOX_UNKNOWN_COMMAND",
+    RSTEST_CONFIG_NOT_FOUND: "ADDFOX_RSTEST_CONFIG_NOT_FOUND",
+    RSDOCTOR_NOT_INSTALLED: "ADDFOX_RSDOCTOR_NOT_INSTALLED",
+    RSBUILD_CONFIG_ERROR: "ADDFOX_RSBUILD_CONFIG_ERROR",
+    BUILD_ERROR: "ADDFOX_BUILD_ERROR",
+    ZIP_OUTPUT: "ADDFOX_ZIP_OUTPUT",
+    ZIP_ARCHIVE: "ADDFOX_ZIP_ARCHIVE"
+};
+class AddfoxError extends Error {
+    code;
+    details;
+    hint;
+    cause;
+    constructor(options){
+        super(options.message);
+        this.name = "AddfoxError";
+        this.code = options.code;
+        this.details = options.details;
+        this.hint = options.hint;
+        this.cause = options.cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            details: this.details,
+            hint: this.hint,
+            stack: this.stack,
+            cause: this.cause
+        };
+    }
+    format() {
+        const parts = [
+            `[${this.code}] ${this.message}`
+        ];
+        if (this.details) parts.push(`  Details: ${this.details}`);
+        if (this.hint) parts.push(`  Hint: ${this.hint}`);
+        return parts.join("\n");
+    }
+    toString() {
+        return this.format();
+    }
+}
+function createError(code, message, options) {
+    return new AddfoxError({
+        code,
+        message,
+        ...options
+    });
+}
+function isAddfoxError(error) {
+    return error instanceof AddfoxError;
+}
+function formatError(error) {
+    if (isAddfoxError(error)) return error.format();
+    if (error instanceof Error) return error.stack ?? error.message;
+    return String(error);
+}
+function exitWithError(_err, exitCode = 1) {
+    process.exit(exitCode);
+}
+function createCache() {
+    const store = new Map();
+    return {
+        get (key) {
+            const entry = store.get(key);
+            if (!entry) return;
+            if (entry.expiresAt && Date.now() > entry.expiresAt) return void store.delete(key);
+            return entry.value;
+        },
+        set (key, value, ttlMs) {
+            const entry = {
+                value,
+                expiresAt: ttlMs ? Date.now() + ttlMs : void 0
+            };
+            store.set(key, entry);
+        },
+        has (key) {
+            const entry = store.get(key);
+            if (!entry) return false;
+            if (entry.expiresAt && Date.now() > entry.expiresAt) {
+                store.delete(key);
+                return false;
+            }
+            return true;
+        },
+        delete (key) {
+            return store.delete(key);
+        },
+        clear () {
+            store.clear();
+        },
+        keys () {
+            const now = Date.now();
+            const keys = [];
+            for (const [key, entry] of store)if (!entry.expiresAt || now <= entry.expiresAt) keys.push(key);
+            return keys;
+        },
+        size () {
+            return this.keys().length;
+        }
+    };
+}
+function memoize(fn, keyFn) {
+    const cache = createCache();
+    return (...args)=>{
+        const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+        if (cache.has(key)) return cache.get(key);
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+function memoizeAsync(fn, keyFn) {
+    const cache = createCache();
+    const pending = new Map();
+    return async (...args)=>{
+        const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+        if (cache.has(key)) return cache.get(key);
+        if (pending.has(key)) return pending.get(key);
+        const promise = fn(...args).finally(()=>{
+            pending.delete(key);
+        });
+        pending.set(key, promise);
+        const result = await promise;
+        cache.set(key, result);
+        return result;
+    };
+}
+function pipe(...fns) {
+    return (x)=>fns.reduce((v, f)=>f(v), x);
+}
+function pipeAsync(...fns) {
+    return async (x)=>{
+        let result = x;
+        for (const fn of fns)result = await fn(result);
+        return result;
+    };
+}
+function compose(...fns) {
+    return (x)=>fns.reduceRight((v, f)=>f(v), x);
+}
+function createPipeline(...steps) {
+    return async (input)=>{
+        let result = input;
+        for (const step of steps)result = await step(result);
+        return result;
+    };
+}
+function applyMiddleware(value, middlewares) {
+    let index = 0;
+    function next() {
+        if (index >= middlewares.length) return value;
+        const middleware = middlewares[index++];
+        return middleware(value, next);
+    }
+    return next();
+}
+function curry(fn) {
+    return (a)=>(b)=>fn(a, b);
+}
+function partial(fn, a) {
+    return (...rest)=>fn(a, ...rest);
+}
+function tap(fn) {
+    return (x)=>{
+        fn(x);
+        return x;
+    };
+}
+function tryCatch(fn, onError) {
+    try {
+        return fn();
+    } catch (error) {
+        return onError?.(error);
+    }
+}
+async function tryCatchAsync(fn, onError) {
+    try {
+        return await fn();
+    } catch (error) {
+        return onError?.(error);
+    }
+}
+function deepMerge(target, source) {
+    const result = {
+        ...target
+    };
+    for (const key of Object.keys(source)){
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (null === sourceValue || 'object' != typeof sourceValue || Array.isArray(sourceValue) || null === targetValue || 'object' != typeof targetValue || Array.isArray(targetValue)) result[key] = sourceValue;
+        else result[key] = deepMerge(targetValue, sourceValue);
+    }
+    return result;
+}
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys)if (key in obj) result[key] = obj[key];
+    return result;
+}
+function omit(obj, keys) {
+    const result = {
+        ...obj
+    };
+    for (const key of keys)delete result[key];
+    return result;
+}
+function get(obj, path, defaultValue) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (null == current) return defaultValue;
+        current = current[key];
+    }
+    return current ?? defaultValue;
+}
+function set(obj, path, value) {
+    const keys = path.split('.');
+    const result = {
+        ...obj
+    };
+    let current = result;
+    for(let i = 0; i < keys.length - 1; i++){
+        const key = keys[i];
+        if (!(key in current) || 'object' != typeof current[key]) current[key] = {};
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+    return result;
+}
+function has(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (null == current || 'object' != typeof current || !(key in current)) return false;
+        current = current[key];
+    }
+    return true;
+}
+function flatten(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)){
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (null === value || 'object' != typeof value || Array.isArray(value)) result[newKey] = value;
+        else Object.assign(result, flatten(value, newKey));
+    }
+    return result;
+}
+function unflatten(obj) {
+    let result = {};
+    for (const [key, value] of Object.entries(obj))result = set(result, key, value);
+    return result;
+}
+function filter(obj, predicate) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj))if (predicate(key, value)) result[key] = value;
+    return result;
+}
+function mapValues(obj, fn) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj))result[key] = fn(value, key);
+    return result;
+}
+function isPlainObject(value) {
+    if (null === value || 'object' != typeof value) return false;
+    const proto = Object.getPrototypeOf(value);
+    return null === proto || proto === Object.prototype;
+}
+function isEmpty(value) {
+    if (null == value) return true;
+    if ('string' == typeof value || Array.isArray(value)) return 0 === value.length;
+    if (isPlainObject(value)) return 0 === Object.keys(value).length;
+    return false;
+}
+class HookManager {
+    registry = new Map();
+    options;
+    constructor(options = {}){
+        this.options = {
+            parallel: false,
+            bail: false,
+            ...options
+        };
+    }
+    register(stage, phase, handler) {
+        const key = this.getKey(stage, phase);
+        if (!this.registry.has(key)) this.registry.set(key, []);
+        const hooks = this.registry.get(key);
+        hooks.push(handler);
+        return ()=>{
+            const index = hooks.indexOf(handler);
+            if (index > -1) hooks.splice(index, 1);
+        };
+    }
+    async execute(stage, phase, payload) {
+        const key = this.getKey(stage, phase);
+        const hooks = this.registry.get(key) || [];
+        if (0 === hooks.length) return;
+        if (this.options.parallel) if (this.options.bail) await Promise.all(hooks.map((hook)=>hook(payload)));
+        else {
+            const results = await Promise.allSettled(hooks.map((hook)=>hook(payload)));
+            const errors = results.filter((r)=>'rejected' === r.status).map((r)=>r.reason);
+            if (errors.length > 0) throw new AggregateError(errors, `Hook execution failed for ${String(stage)}:${phase}`);
+        }
+        else for (const hook of hooks)try {
+            await hook(payload);
+        } catch (error) {
+            if (this.options.bail) throw error;
+            console.error(`Hook error in ${String(stage)}:${phase}:`, error);
+        }
+    }
+    has(stage, phase) {
+        const key = this.getKey(stage, phase);
+        return (this.registry.get(key)?.length || 0) > 0;
+    }
+    count(stage, phase) {
+        const key = this.getKey(stage, phase);
+        return this.registry.get(key)?.length || 0;
+    }
+    clear(stage, phase) {
+        if (void 0 === stage) this.registry.clear();
+        else if (void 0 === phase) {
+            this.registry.delete(this.getKey(stage, 'before'));
+            this.registry.delete(this.getKey(stage, 'after'));
+        } else this.registry.delete(this.getKey(stage, phase));
+    }
+    getKey(stage, phase) {
+        return `${String(stage)}:${phase}`;
+    }
+    for(stage) {
+        return new StageHookManager(this, stage);
+    }
+}
+class StageHookManager {
+    manager;
+    stage;
+    constructor(manager, stage){
+        this.manager = manager;
+        this.stage = stage;
+    }
+    before(handler) {
+        return this.manager.register(this.stage, 'before', handler);
+    }
+    after(handler) {
+        return this.manager.register(this.stage, 'after', handler);
+    }
+    async runBefore(payload) {
+        return this.manager.execute(this.stage, 'before', payload);
+    }
+    async runAfter(payload) {
+        return this.manager.execute(this.stage, 'after', payload);
+    }
+}
+let webExtStdoutOriginDepth = 0;
+function pushWebExtStdoutOrigin() {
+    webExtStdoutOriginDepth += 1;
+}
+function popWebExtStdoutOrigin() {
+    webExtStdoutOriginDepth = Math.max(0, webExtStdoutOriginDepth - 1);
+}
+function getWebExtStdoutOriginDepth() {
+    return webExtStdoutOriginDepth;
+}
+exports.ADDFOX_ERROR_CODES = __webpack_exports__.ADDFOX_ERROR_CODES;
+exports.ANSI_COLORS = __webpack_exports__.ANSI_COLORS;
+exports.AddfoxError = __webpack_exports__.AddfoxError;
+exports.HookManager = __webpack_exports__.HookManager;
+exports.Logger = __webpack_exports__.Logger;
+exports.StageHookManager = __webpack_exports__.StageHookManager;
+exports.applyMiddleware = __webpack_exports__.applyMiddleware;
+exports.compose = __webpack_exports__.compose;
+exports.createCache = __webpack_exports__.createCache;
+exports.createError = __webpack_exports__.createError;
+exports.createPipeline = __webpack_exports__.createPipeline;
+exports.curry = __webpack_exports__.curry;
+exports.deepMerge = __webpack_exports__.deepMerge;
+exports.error = __webpack_exports__.error;
+exports.exitWithError = __webpack_exports__.exitWithError;
+exports.filter = __webpack_exports__.filter;
+exports.flatten = __webpack_exports__.flatten;
+exports.formatDuration = __webpack_exports__.formatDuration;
+exports.formatError = __webpack_exports__.formatError;
+exports.get = __webpack_exports__.get;
+exports.getWebExtStdoutOriginDepth = __webpack_exports__.getWebExtStdoutOriginDepth;
+exports.has = __webpack_exports__.has;
+exports.isAddfoxError = __webpack_exports__.isAddfoxError;
+exports.isEmpty = __webpack_exports__.isEmpty;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.log = __webpack_exports__.log;
+exports.logDone = __webpack_exports__.logDone;
+exports.logDoneTimed = __webpack_exports__.logDoneTimed;
+exports.logDoneWithValue = __webpack_exports__.logDoneWithValue;
+exports.logEntriesTable = __webpack_exports__.logEntriesTable;
+exports.logger = __webpack_exports__.logger;
+exports.mapValues = __webpack_exports__.mapValues;
+exports.memoize = __webpack_exports__.memoize;
+exports.memoizeAsync = __webpack_exports__.memoizeAsync;
+exports.omit = __webpack_exports__.omit;
+exports.partial = __webpack_exports__.partial;
+exports.pick = __webpack_exports__.pick;
+exports.pipe = __webpack_exports__.pipe;
+exports.pipeAsync = __webpack_exports__.pipeAsync;
+exports.popWebExtStdoutOrigin = __webpack_exports__.popWebExtStdoutOrigin;
+exports.pushWebExtStdoutOrigin = __webpack_exports__.pushWebExtStdoutOrigin;
+exports.set = __webpack_exports__.set;
+exports.setAddfoxLoggerRawWrites = __webpack_exports__.setAddfoxLoggerRawWrites;
+exports.tap = __webpack_exports__.tap;
+exports.tryCatch = __webpack_exports__.tryCatch;
+exports.tryCatchAsync = __webpack_exports__.tryCatchAsync;
+exports.unflatten = __webpack_exports__.unflatten;
+exports.warn = __webpack_exports__.warn;
+exports.writeExtensionErrorBlock = __webpack_exports__.writeExtensionErrorBlock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ADDFOX_ERROR_CODES",
+    "ANSI_COLORS",
+    "AddfoxError",
+    "HookManager",
+    "Logger",
+    "StageHookManager",
+    "applyMiddleware",
+    "compose",
+    "createCache",
+    "createError",
+    "createPipeline",
+    "curry",
+    "deepMerge",
+    "error",
+    "exitWithError",
+    "filter",
+    "flatten",
+    "formatDuration",
+    "formatError",
+    "get",
+    "getWebExtStdoutOriginDepth",
+    "has",
+    "isAddfoxError",
+    "isEmpty",
+    "isPlainObject",
+    "log",
+    "logDone",
+    "logDoneTimed",
+    "logDoneWithValue",
+    "logEntriesTable",
+    "logger",
+    "mapValues",
+    "memoize",
+    "memoizeAsync",
+    "omit",
+    "partial",
+    "pick",
+    "pipe",
+    "pipeAsync",
+    "popWebExtStdoutOrigin",
+    "pushWebExtStdoutOrigin",
+    "set",
+    "setAddfoxLoggerRawWrites",
+    "tap",
+    "tryCatch",
+    "tryCatchAsync",
+    "unflatten",
+    "warn",
+    "writeExtensionErrorBlock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});