extension-develop 2.1.3 → 3.0.0-next.6

package/dist/resolve-paths-loader.js

@@ -0,0 +1,1387 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_modules__ = {
+    "@swc/core?782a": function(module) {
+        module.exports = require("@swc/core");
+    },
+    "@swc/core?7929": function(module) {
+        module.exports = import("@swc/core").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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 ('undefined' != 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__, {
+        default: ()=>resolvePathsLoader
+    });
+    const external_path_namespaceObject = require("path");
+    const external_fs_namespaceObject = require("fs");
+    const external_magic_string_namespaceObject = require("magic-string");
+    var external_magic_string_default = /*#__PURE__*/ __webpack_require__.n(external_magic_string_namespaceObject);
+    function getFilename(feature, filePath) {
+        const entryExt = external_path_namespaceObject.extname(filePath);
+        let fileOutputpath = feature;
+        if ([
+            '.js',
+            '.jsx',
+            '.tsx',
+            '.ts'
+        ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.js');
+        if ([
+            '.html',
+            '.njk',
+            '.nunjucks'
+        ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.html');
+        if ([
+            '.css',
+            '.scss',
+            '.sass',
+            '.less'
+        ].includes(entryExt)) fileOutputpath = fileOutputpath.replace(entryExt, '.css');
+        return unixify(fileOutputpath || '');
+    }
+    function unixify(filePath) {
+        return filePath.replace(/\\/g, '/');
+    }
+    function memberChainFromCallee(callee) {
+        const memberParts = [];
+        let currentExpression = callee;
+        while(currentExpression && 'ParenExpression' === currentExpression.type)currentExpression = currentExpression.expression;
+        while(currentExpression){
+            if ('Identifier' === currentExpression.type) {
+                memberParts.unshift(currentExpression.value);
+                break;
+            }
+            if ('MemberExpression' === currentExpression.type) {
+                const propertyNode = currentExpression.property;
+                if ((null == propertyNode ? void 0 : propertyNode.type) === 'Identifier') memberParts.unshift(propertyNode.value);
+                currentExpression = currentExpression.object;
+                continue;
+            }
+            break;
+        }
+        return memberParts;
+    }
+    function getPropName(propertyNode) {
+        if (!propertyNode || 'KeyValueProperty' !== propertyNode.type) return;
+        const keyNode = propertyNode.key;
+        if ((null == keyNode ? void 0 : keyNode.type) === 'Identifier') return keyNode.value;
+        if ((null == keyNode ? void 0 : keyNode.type) === 'StringLiteral') return keyNode.value;
+    }
+    function isHttpLike(input) {
+        return /^https?:\/\//i.test(input) || /^data:/i.test(input) || /^chrome:\/\//i.test(input) || /^moz-extension:\/\//i.test(input);
+    }
+    function hasGlob(input) {
+        return /[*?\[\]{}]/.test(input);
+    }
+    function resolveLiteralToOutput(literal, opts) {
+        const { manifestPath, packageJsonDir, authorFilePath } = opts;
+        const root = packageJsonDir || external_path_namespaceObject.dirname(manifestPath);
+        const canonicalUnixPath = unixify(literal || '');
+        if (!literal || isHttpLike(literal) || hasGlob(literal)) return;
+        if (/^\/public\//i.test(canonicalUnixPath)) {
+            const out = canonicalUnixPath.replace(/^\/public\//i, '');
+            return out;
+        }
+        if (/^(?:\.\/)?public\//i.test(canonicalUnixPath)) {
+            const out = canonicalUnixPath.replace(/^(?:\.\/)?public\//i, '');
+            return out;
+        }
+        if (/^\//.test(canonicalUnixPath)) {
+            const trimmed = canonicalUnixPath.replace(/^\//, '');
+            if (/^(?:pages|scripts)\//i.test(trimmed)) {
+                const abs = external_path_namespaceObject.join(root, trimmed);
+                return unixify(getFilename(trimmed, abs));
+            }
+            return trimmed;
+        }
+        const baseDir = /^(\.\/|\.\.\/)/.test(canonicalUnixPath) && authorFilePath ? external_path_namespaceObject.dirname(authorFilePath) : root;
+        const candidateAbsolutePath = external_path_namespaceObject.isAbsolute(literal) ? literal : external_path_namespaceObject.resolve(baseDir, literal);
+        const pathWithoutDotPrefix = canonicalUnixPath.replace(/^\.\//, '');
+        if (/^pages\//i.test(pathWithoutDotPrefix)) return unixify(getFilename(pathWithoutDotPrefix, candidateAbsolutePath));
+        if (/^scripts\//i.test(pathWithoutDotPrefix)) return unixify(getFilename(pathWithoutDotPrefix, candidateAbsolutePath));
+        try {
+            const normalizedRel = unixify(external_path_namespaceObject.relative(root, candidateAbsolutePath));
+            const relNoDotPrefix = normalizedRel.replace(/^\.\//, '');
+            if (/^public\//i.test(relNoDotPrefix)) return relNoDotPrefix.replace(/^public\//i, '');
+            if (/^pages\//i.test(relNoDotPrefix)) return unixify(getFilename(relNoDotPrefix, candidateAbsolutePath));
+            if (/^scripts\//i.test(relNoDotPrefix)) return unixify(getFilename(relNoDotPrefix, candidateAbsolutePath));
+        } catch  {}
+    }
+    function isStringLiteral(node) {
+        return node && 'StringLiteral' === node.type && 'string' == typeof node.value;
+    }
+    function isStaticTemplate(node) {
+        return node && 'TemplateLiteral' === node.type && Array.isArray(node.expressions) && 0 === node.expressions.length;
+    }
+    function evalStaticString(node) {
+        if (!node) return;
+        if (node && 'ParenExpression' === node.type) return evalStaticString(node.expression);
+        if (isStringLiteral(node)) return node.value;
+        if (isStaticTemplate(node)) {
+            var _node_quasis;
+            return null == (_node_quasis = node.quasis) ? void 0 : _node_quasis.map((quasi)=>quasi.raw ?? '').join('');
+        }
+        if (node && 'BinaryExpression' === node.type && '+' === node.operator) {
+            const left = evalStaticString(node.left);
+            const right = evalStaticString(node.right);
+            if ('string' == typeof left && 'string' == typeof right) return left + right;
+        }
+    }
+    function handleRuntimeCalls(node, source, rewriteValue, manifestPath) {
+        var _node_arguments;
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if ((method.endsWith('runtime.getURL') || method.endsWith('extension.getURL')) && (null == (_node_arguments = node.arguments) ? void 0 : _node_arguments[0])) {
+            const firstArgument = node.arguments[0].expression;
+            if (isStringLiteral(firstArgument)) {
+                const resolved = resolveLiteralToOutput(firstArgument.value, {
+                    manifestPath
+                });
+                rewriteValue(firstArgument, resolved, firstArgument.value);
+            } else if (isStaticTemplate(firstArgument)) {
+                const rawTemplate = source.slice(firstArgument.span.start + 1, firstArgument.span.end - 1);
+                const resolved = resolveLiteralToOutput(rawTemplate, {
+                    manifestPath
+                });
+                rewriteValue(firstArgument, resolved, rawTemplate);
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleActionAndPopup(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('action.setIcon') || method.endsWith('pageAction.setIcon') || method.endsWith('browserAction.setIcon')) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('path' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, valueNode.value);
+                } else if ((null == valueNode ? void 0 : valueNode.type) === 'ObjectExpression') {
+                    for (const innerProperty of valueNode.properties || [])if ('KeyValueProperty' === innerProperty.type && isStringLiteral(innerProperty.value)) {
+                        const resolved = resolveLiteralToOutput(innerProperty.value.value, {
+                            manifestPath
+                        });
+                        rewriteValue(innerProperty.value, resolved, innerProperty.value.value);
+                    } else if ('KeyValueProperty' === innerProperty.type && isStaticTemplate(innerProperty.value)) {
+                        const raw = source.slice(innerProperty.value.span.start + 1, innerProperty.value.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(innerProperty.value, resolved, raw);
+                    } else if ('KeyValueProperty' === innerProperty.type) {
+                        const raw = evalStaticString(innerProperty.value);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(innerProperty.value.span.start, innerProperty.value.span.end);
+                            rewriteValue(innerProperty.value, resolved, originalExpr);
+                        }
+                    }
+                } else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, raw);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        if (method.endsWith('action.setPopup') || method.endsWith('pageAction.setPopup') || method.endsWith('browserAction.setPopup')) {
+            var _node_arguments_1, _node_arguments1;
+            const firstArgument = null == (_node_arguments1 = node.arguments) ? void 0 : null == (_node_arguments_1 = _node_arguments1[0]) ? void 0 : _node_arguments_1.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('popup' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved);
+                } else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleDevtools(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('devtools.panels.create')) {
+            var _node_arguments_, _node_arguments, _node_arguments_1, _node_arguments1;
+            const iconArg = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[1]) ? void 0 : _node_arguments_.expression;
+            const pageArg = null == (_node_arguments1 = node.arguments) ? void 0 : null == (_node_arguments_1 = _node_arguments1[2]) ? void 0 : _node_arguments_1.expression;
+            let touched = false;
+            if (isStringLiteral(iconArg)) {
+                const resolved = resolveLiteralToOutput(iconArg.value, {
+                    manifestPath
+                });
+                rewriteValue(iconArg, resolved, iconArg.value);
+                touched = true;
+            } else if (isStaticTemplate(iconArg)) {
+                const rawTemplate = source.slice(iconArg.span.start + 1, iconArg.span.end - 1);
+                const resolved = resolveLiteralToOutput(rawTemplate, {
+                    manifestPath
+                });
+                rewriteValue(iconArg, resolved, rawTemplate);
+            } else {
+                const staticallyEvaluated = evalStaticString(iconArg);
+                if ('string' == typeof staticallyEvaluated) {
+                    const resolved = resolveLiteralToOutput(staticallyEvaluated, {
+                        manifestPath
+                    });
+                    const originalExpr = source.slice(iconArg.span.start, iconArg.span.end);
+                    rewriteValue(iconArg, resolved, originalExpr);
+                    touched = true;
+                }
+            }
+            if (isStringLiteral(pageArg)) {
+                const resolved = resolveLiteralToOutput(pageArg.value, {
+                    manifestPath
+                });
+                rewriteValue(pageArg, resolved, pageArg.value);
+                touched = true;
+            } else if (isStaticTemplate(pageArg)) {
+                const rawTemplate = source.slice(pageArg.span.start + 1, pageArg.span.end - 1);
+                const resolved = resolveLiteralToOutput(rawTemplate, {
+                    manifestPath
+                });
+                rewriteValue(pageArg, resolved, rawTemplate);
+            } else {
+                const staticallyEvaluated = evalStaticString(pageArg);
+                if ('string' == typeof staticallyEvaluated) {
+                    const resolved = resolveLiteralToOutput(staticallyEvaluated, {
+                        manifestPath
+                    });
+                    const originalExpr = source.slice(pageArg.span.start, pageArg.span.end);
+                    rewriteValue(pageArg, resolved, originalExpr);
+                    touched = true;
+                }
+            }
+            return touched;
+        }
+        return false;
+    }
+    function handleTabsAndWindows(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('tabs.create') || method.endsWith('windows.create')) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('url' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, valueNode.value);
+                } else if ((null == valueNode ? void 0 : valueNode.type) === 'ArrayExpression') for (const arrayElement of valueNode.elements || []){
+                    const literalNode = null == arrayElement ? void 0 : arrayElement.expression;
+                    if (isStringLiteral(literalNode)) {
+                        const resolved = resolveLiteralToOutput(literalNode.value, {
+                            manifestPath
+                        });
+                        rewriteValue(literalNode, resolved, literalNode.value);
+                    } else if (isStaticTemplate(literalNode)) {
+                        const raw = source.slice(literalNode.span.start + 1, literalNode.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(literalNode, resolved, raw);
+                    } else {
+                        const raw = evalStaticString(literalNode);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(literalNode.span.start, literalNode.span.end);
+                            rewriteValue(literalNode, resolved, originalExpr);
+                        }
+                    }
+                }
+                else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, raw);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        if (method.endsWith('tabs.update')) {
+            var _node_arguments_1, _node_arguments1, _node_arguments_2, _node_arguments2;
+            const optionsArgument = (null == (_node_arguments1 = node.arguments) ? void 0 : null == (_node_arguments_1 = _node_arguments1[1]) ? void 0 : _node_arguments_1.expression) || (null == (_node_arguments2 = node.arguments) ? void 0 : null == (_node_arguments_2 = _node_arguments2[0]) ? void 0 : _node_arguments_2.expression);
+            if ((null == optionsArgument ? void 0 : optionsArgument.type) === 'ObjectExpression') for (const propertyNode of optionsArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('url' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, valueNode.value);
+                } else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, raw);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleScripting(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith("scripting.registerContentScripts")) {
+            for (const argumentNode of node.arguments || []){
+                const arrayExpressionNode = null == argumentNode ? void 0 : argumentNode.expression;
+                if (arrayExpressionNode && 'ArrayExpression' === arrayExpressionNode.type) for (const arrayElement of arrayExpressionNode.elements || []){
+                    const objectExpressionNode = null == arrayElement ? void 0 : arrayElement.expression;
+                    if (objectExpressionNode && 'ObjectExpression' === objectExpressionNode.type) for (const propertyNode of objectExpressionNode.properties || []){
+                        if ('KeyValueProperty' !== propertyNode.type) continue;
+                        const keyName = getPropName(propertyNode);
+                        if ('js' !== keyName && 'css' !== keyName) continue;
+                        const valueNode = propertyNode.value;
+                        if ('ArrayExpression' === valueNode.type) for (const innerItem of valueNode.elements || []){
+                            const literalNode = null == innerItem ? void 0 : innerItem.expression;
+                            if (isStringLiteral(literalNode)) {
+                                const resolved = resolveLiteralToOutput(literalNode.value, {
+                                    manifestPath
+                                });
+                                rewriteValue(literalNode, resolved, literalNode.value);
+                            } else if (isStaticTemplate(literalNode)) {
+                                const raw = source.slice(literalNode.span.start + 1, literalNode.span.end - 1);
+                                const resolved = resolveLiteralToOutput(raw, {
+                                    manifestPath
+                                });
+                                rewriteValue(literalNode, resolved, raw);
+                            } else {
+                                const raw = evalStaticString(literalNode);
+                                if ('string' == typeof raw) {
+                                    const resolved = resolveLiteralToOutput(raw, {
+                                        manifestPath
+                                    });
+                                    const originalExpr = source.slice(literalNode.span.start, literalNode.span.end);
+                                    rewriteValue(literalNode, resolved, originalExpr);
+                                }
+                            }
+                        }
+                        else if (isStringLiteral(valueNode)) {
+                            const resolved = resolveLiteralToOutput(valueNode.value, {
+                                manifestPath
+                            });
+                            rewriteValue(valueNode, resolved, valueNode.value);
+                        } else if (isStaticTemplate(valueNode)) {
+                            const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            rewriteValue(valueNode, resolved, raw);
+                        } else {
+                            const raw = evalStaticString(valueNode);
+                            if ('string' == typeof raw) {
+                                const resolved = resolveLiteralToOutput(raw, {
+                                    manifestPath
+                                });
+                                const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                                rewriteValue(valueNode, resolved, originalExpr);
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        if (method.endsWith("scripting.executeScript") || method.endsWith("scripting.insertCSS")) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('files' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if ((null == valueNode ? void 0 : valueNode.type) === 'ArrayExpression') for (const arrayElement of valueNode.elements || []){
+                    const literalNode = null == arrayElement ? void 0 : arrayElement.expression;
+                    if (isStringLiteral(literalNode)) {
+                        const resolved = resolveLiteralToOutput(literalNode.value, {
+                            manifestPath
+                        });
+                        rewriteValue(literalNode, resolved, literalNode.value);
+                    } else if (isStaticTemplate(literalNode)) {
+                        const raw = source.slice(literalNode.span.start + 1, literalNode.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(literalNode, resolved, raw);
+                    } else {
+                        const raw = evalStaticString(literalNode);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(literalNode.span.start, literalNode.span.end);
+                            rewriteValue(literalNode, resolved, originalExpr);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleMv2Tabs(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('tabs.executeScript') || method.endsWith('tabs.insertCSS')) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('file' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, valueNode.value);
+                } else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, raw);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handlePanels(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('sidePanel.setOptions') || method.endsWith('sidebarAction.setPanel')) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if (method.endsWith('sidebarAction.setPanel')) {
+                const arg = firstArgument;
+                if (isStringLiteral(arg)) {
+                    const resolved = resolveLiteralToOutput(arg.value, {
+                        manifestPath
+                    });
+                    rewriteValue(arg, resolved, arg.value);
+                    return true;
+                }
+                if (isStaticTemplate(arg)) {
+                    const raw = source.slice(arg.span.start + 1, arg.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(arg, resolved, raw);
+                    return true;
+                }
+                {
+                    const raw = evalStaticString(arg);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(arg.span.start, arg.span.end);
+                        rewriteValue(arg, resolved, originalExpr);
+                        return true;
+                    }
+                }
+            }
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyName = getPropName(propertyNode);
+                if ('path' === keyName || 'panel' === keyName || 'page' === keyName) {
+                    const valueNode = propertyNode.value;
+                    if (isStringLiteral(valueNode)) {
+                        const resolved = resolveLiteralToOutput(valueNode.value, {
+                            manifestPath
+                        });
+                        rewriteValue(valueNode, resolved, valueNode.value);
+                    } else if (isStaticTemplate(valueNode)) {
+                        const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(valueNode, resolved, raw);
+                    } else {
+                        const raw = evalStaticString(valueNode);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                            rewriteValue(valueNode, resolved, originalExpr);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleNotifications(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('notifications.create') || method.endsWith('notifications.update')) {
+            var _node_arguments_, _node_arguments, _node_arguments_1, _node_arguments1;
+            const optionsArgument = (null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[1]) ? void 0 : _node_arguments_.expression) || (null == (_node_arguments1 = node.arguments) ? void 0 : null == (_node_arguments_1 = _node_arguments1[0]) ? void 0 : _node_arguments_1.expression);
+            if ((null == optionsArgument ? void 0 : optionsArgument.type) === 'ObjectExpression') {
+                let touched = false;
+                for (const propertyNode of optionsArgument.properties || []){
+                    if ('KeyValueProperty' !== propertyNode.type) continue;
+                    const keyName = getPropName(propertyNode);
+                    if ('iconUrl' === keyName || 'imageUrl' === keyName) {
+                        const valueNode = propertyNode.value;
+                        if (isStringLiteral(valueNode)) {
+                            const resolved = resolveLiteralToOutput(valueNode.value, {
+                                manifestPath
+                            });
+                            rewriteValue(valueNode, resolved, valueNode.value);
+                            touched = true;
+                        } else if (isStaticTemplate(valueNode)) {
+                            const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            rewriteValue(valueNode, resolved, raw);
+                            touched = true;
+                        } else {
+                            const raw = evalStaticString(valueNode);
+                            if ('string' == typeof raw) {
+                                const resolved = resolveLiteralToOutput(raw, {
+                                    manifestPath
+                                });
+                                const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                                rewriteValue(valueNode, resolved, originalExpr);
+                                touched = true;
+                            }
+                        }
+                    }
+                }
+                if (touched) return true;
+            }
+        }
+        return false;
+    }
+    function handleMenus(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('contextMenus.create') || method.endsWith('contextMenus.update') || method.endsWith('menus.create') || method.endsWith('menus.update')) {
+            var _node_arguments_, _node_arguments;
+            const firstArgument = null == (_node_arguments = node.arguments) ? void 0 : null == (_node_arguments_ = _node_arguments[0]) ? void 0 : _node_arguments_.expression;
+            if ((null == firstArgument ? void 0 : firstArgument.type) === 'ObjectExpression') for (const propertyNode of firstArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyNode = propertyNode.key;
+                const keyName = (null == keyNode ? void 0 : keyNode.type) === 'Identifier' ? keyNode.value : null == keyNode ? void 0 : keyNode.value;
+                if ('icons' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if ((null == valueNode ? void 0 : valueNode.type) === 'ObjectExpression') for (const innerProperty of valueNode.properties || []){
+                    if ('KeyValueProperty' !== innerProperty.type) continue;
+                    const innerValue = innerProperty.value;
+                    if (isStringLiteral(innerValue)) {
+                        const resolved = resolveLiteralToOutput(innerValue.value, {
+                            manifestPath
+                        });
+                        rewriteValue(innerValue, resolved, innerValue.value);
+                    } else if (isStaticTemplate(innerValue)) {
+                        const raw = source.slice(innerValue.span.start + 1, innerValue.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(innerValue, resolved, raw);
+                    } else {
+                        const raw = evalStaticString(innerValue);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(innerValue.span.start, innerValue.span.end);
+                            rewriteValue(innerValue, resolved, originalExpr);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    function handleDeclarativeContent(node, source, rewriteValue, manifestPath) {
+        if ('NewExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        const method = memberChain.join('.');
+        if (method.endsWith('declarativeContent.SetIcon')) {
+            var _node_arguments;
+            const arg0 = null == (_node_arguments = node.arguments) ? void 0 : _node_arguments[0];
+            const optionsArgument = arg0 && arg0.expression || arg0;
+            if ((null == optionsArgument ? void 0 : optionsArgument.type) === 'ObjectExpression') for (const propertyNode of optionsArgument.properties || []){
+                if ('KeyValueProperty' !== propertyNode.type) continue;
+                const keyNode = propertyNode.key;
+                const keyName = (null == keyNode ? void 0 : keyNode.type) === 'Identifier' ? keyNode.value : null == keyNode ? void 0 : keyNode.value;
+                if ('path' !== keyName) continue;
+                const valueNode = propertyNode.value;
+                if (isStringLiteral(valueNode)) {
+                    const resolved = resolveLiteralToOutput(valueNode.value, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, valueNode.value);
+                } else if ((null == valueNode ? void 0 : valueNode.type) === 'ObjectExpression') for (const innerProperty of valueNode.properties || []){
+                    if ('KeyValueProperty' !== innerProperty.type) continue;
+                    const innerValue = innerProperty.value;
+                    if (isStringLiteral(innerValue)) {
+                        const resolved = resolveLiteralToOutput(innerValue.value, {
+                            manifestPath
+                        });
+                        rewriteValue(innerValue, resolved, innerValue.value);
+                    } else if (isStaticTemplate(innerValue)) {
+                        const raw = source.slice(innerValue.span.start + 1, innerValue.span.end - 1);
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        rewriteValue(innerValue, resolved, raw);
+                    } else {
+                        const raw = evalStaticString(innerValue);
+                        if ('string' == typeof raw) {
+                            const resolved = resolveLiteralToOutput(raw, {
+                                manifestPath
+                            });
+                            const originalExpr = source.slice(innerValue.span.start, innerValue.span.end);
+                            rewriteValue(innerValue, resolved, originalExpr);
+                        }
+                    }
+                }
+                else if (isStaticTemplate(valueNode)) {
+                    const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+                    const resolved = resolveLiteralToOutput(raw, {
+                        manifestPath
+                    });
+                    rewriteValue(valueNode, resolved, raw);
+                } else {
+                    const raw = evalStaticString(valueNode);
+                    if ('string' == typeof raw) {
+                        const resolved = resolveLiteralToOutput(raw, {
+                            manifestPath
+                        });
+                        const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+                        rewriteValue(valueNode, resolved, originalExpr);
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    const ALLOWED_KEYS = new Set([
+        'url',
+        'file',
+        'files',
+        'path',
+        'popup',
+        'panel',
+        'page',
+        'iconUrl',
+        'imageUrl',
+        'default_icon',
+        'default_popup',
+        'default_panel'
+    ]);
+    function processValue(valueNode, source, rewriteValue, manifestPath) {
+        if (!valueNode) return;
+        if (isStringLiteral(valueNode)) {
+            const out = resolveLiteralToOutput(valueNode.value, {
+                manifestPath
+            });
+            rewriteValue(valueNode, out, valueNode.value);
+            return;
+        }
+        if (isStaticTemplate(valueNode)) {
+            const raw = source.slice(valueNode.span.start + 1, valueNode.span.end - 1);
+            const out = resolveLiteralToOutput(raw, {
+                manifestPath
+            });
+            rewriteValue(valueNode, out, raw);
+            return;
+        }
+        const raw = evalStaticString(valueNode);
+        if ('string' == typeof raw) {
+            const out = resolveLiteralToOutput(raw, {
+                manifestPath
+            });
+            const originalExpr = source.slice(valueNode.span.start, valueNode.span.end);
+            rewriteValue(valueNode, out, originalExpr);
+            return;
+        }
+    }
+    function walkCandidate(containerNode, onCandidateValue) {
+        if (!containerNode) return;
+        if ('ArrayExpression' === containerNode.type) {
+            for (const elementNode of containerNode.elements || [])onCandidateValue(null == elementNode ? void 0 : elementNode.expression);
+            return;
+        }
+        if ('ObjectExpression' === containerNode.type) for (const propertyNode of containerNode.properties || []){
+            var _propertyNode_value, _propertyNode_value1;
+            if ('KeyValueProperty' !== propertyNode.type) continue;
+            const key = getPropName(propertyNode);
+            if (key) {
+                if (ALLOWED_KEYS.has(key)) onCandidateValue(propertyNode.value);
+                if ((null == (_propertyNode_value = propertyNode.value) ? void 0 : _propertyNode_value.type) === 'ArrayExpression' || (null == (_propertyNode_value1 = propertyNode.value) ? void 0 : _propertyNode_value1.type) === 'ObjectExpression') {
+                    var _propertyNode_value2;
+                    if (('default_icon' === key || 'path' === key) && (null == (_propertyNode_value2 = propertyNode.value) ? void 0 : _propertyNode_value2.type) === 'ObjectExpression') {
+                        for (const sizeProp of propertyNode.value.properties || [])if ('KeyValueProperty' === sizeProp.type) onCandidateValue(sizeProp.value);
+                    } else walkCandidate(propertyNode.value, onCandidateValue);
+                }
+            }
+        }
+    }
+    function handleGenericApiPaths(node, source, rewriteValue, manifestPath) {
+        if ('CallExpression' !== node.type) return false;
+        const memberChain = memberChainFromCallee(node.callee);
+        const apiRoot = memberChain[0];
+        if ('chrome' !== apiRoot && 'browser' !== apiRoot) return false;
+        let touched = false;
+        for (const argumentNode of node.arguments || []){
+            const expressionNode = null == argumentNode ? void 0 : argumentNode.expression;
+            if (expressionNode) {
+                if ('ObjectExpression' === expressionNode.type || 'ArrayExpression' === expressionNode.type) walkCandidate(expressionNode, (candidateValue)=>{
+                    const touchedBefore = touched;
+                    processValue(candidateValue, source, rewriteValue, manifestPath);
+                    if (!touchedBefore) touched = true;
+                });
+            }
+        }
+        return touched;
+    }
+    function handleCallExpression(node, source, rewriteValue, manifestPath) {
+        if (handleRuntimeCalls(node, source, rewriteValue, manifestPath)) return;
+        if (handleActionAndPopup(node, source, rewriteValue, manifestPath)) return;
+        if (handleDevtools(node, source, rewriteValue, manifestPath)) return;
+        if (handleTabsAndWindows(node, source, rewriteValue, manifestPath)) return;
+        if (handleScripting(node, source, rewriteValue, manifestPath)) return;
+        if (handleMv2Tabs(node, source, rewriteValue, manifestPath)) return;
+        if (handlePanels(node, source, rewriteValue, manifestPath)) return;
+        if (handleNotifications(node, source, rewriteValue, manifestPath)) return;
+        if (handleMenus(node, source, rewriteValue, manifestPath)) return;
+        if (handleDeclarativeContent(node, source, rewriteValue, manifestPath)) return;
+        try {
+            handleGenericApiPaths(node, source, rewriteValue, manifestPath);
+        } catch  {}
+    }
+    function isJsxLikePath(filePath) {
+        return 'string' == typeof filePath && /\.[cm]?[jt]sx$/.test(String(filePath));
+    }
+    function stripNestedQuotes(value) {
+        const match = /^(['"])(.*)\1$/.exec(value);
+        return match ? match[2] : value;
+    }
+    function normalizeLiteralPayload(value) {
+        const withForwardSlashes = value.replace(/\\/g, '/');
+        const withCollapsed = withForwardSlashes.replace(/\/{2,}/g, '/');
+        return stripNestedQuotes(withCollapsed);
+    }
+    function isLikelyApiContextAt(source, atIndex) {
+        if ('number' != typeof atIndex) return false;
+        const start = Math.max(0, atIndex - 200);
+        const neighborhood = source.slice(start, atIndex);
+        return /(chrome|browser)\s*\.(?:tabs|windows|scripting|action|sidePanel|sidebarAction|devtools|runtime|extension)\b/.test(neighborhood);
+    }
+    function resolveAndNormalizeLiteral(literal, ctx) {
+        const normalizedInput = normalizeLiteralPayload(literal);
+        const resolved = resolveLiteralToOutput(normalizedInput, {
+            manifestPath: ctx.manifestPath,
+            packageJsonDir: ctx.packageJsonDir,
+            authorFilePath: ctx.authorFilePath
+        });
+        return normalizeLiteralPayload(resolved ?? normalizedInput);
+    }
+    function replaceRuntimeGetURL(source, input, ctx) {
+        const rx = /(\.(?:runtime|extension)\.getURL\()\s*(['"])(.*?)\2(\))/g;
+        function onMatch(full, pre, q, p, post, offset) {
+            try {
+                const resolved = resolveLiteralToOutput(normalizeLiteralPayload(p), {
+                    manifestPath: ctx.manifestPath,
+                    packageJsonDir: ctx.packageJsonDir,
+                    authorFilePath: ctx.authorFilePath
+                });
+                const computed = normalizeLiteralPayload(resolved ?? p);
+                try {
+                    var _ctx_onResolvedLiteral;
+                    null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, p, resolved ?? void 0, offset);
+                } catch  {}
+                return `${pre}${q}${computed}${q}${post}`;
+            } catch  {
+                return full;
+            }
+        }
+        return input.replace(rx, onMatch);
+    }
+    function replaceObjectKeyLiterals(source, input, keys, ctx) {
+        for (const key of keys){
+            const rx = new RegExp(`(${key}\\s*:\\s*)(['"])(.*?)\\2`, 'g');
+            function onMatch(full, pre, q, p, offset) {
+                try {
+                    const resolved = resolveLiteralToOutput(normalizeLiteralPayload(p), {
+                        manifestPath: ctx.manifestPath,
+                        packageJsonDir: ctx.packageJsonDir,
+                        authorFilePath: ctx.authorFilePath
+                    });
+                    const computed = normalizeLiteralPayload(resolved ?? p);
+                    try {
+                        if (isLikelyApiContextAt(source, offset)) {
+                            var _ctx_onResolvedLiteral;
+                            null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, p, resolved ?? void 0, offset);
+                        }
+                    } catch  {}
+                    return `${pre}${q}${computed}${q}`;
+                } catch  {
+                    return full;
+                }
+            }
+            input = input.replace(rx, onMatch);
+        }
+        return input;
+    }
+    function replaceStaticTemplateForKeys(source, input, keys, ctx) {
+        const rx = new RegExp(`((?:${keys.join('|')})\\s*:\\s*)\`([^\\\`$]*)\``, 'g');
+        function onMatch(full, pre, inner, offset) {
+            try {
+                const resolved = resolveLiteralToOutput(normalizeLiteralPayload(inner), {
+                    manifestPath: ctx.manifestPath,
+                    packageJsonDir: ctx.packageJsonDir,
+                    authorFilePath: ctx.authorFilePath
+                });
+                const computed = normalizeLiteralPayload(resolved ?? inner);
+                try {
+                    if (isLikelyApiContextAt(source, offset)) {
+                        var _ctx_onResolvedLiteral;
+                        null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, inner, resolved ?? void 0, offset);
+                    }
+                } catch  {}
+                return `${pre}'${computed}'`;
+            } catch  {
+                return full;
+            }
+        }
+        return input.replace(rx, onMatch);
+    }
+    function replaceConcatForKeys(source, input, keys, ctx) {
+        const rx = new RegExp(`((?:${keys.join('|')})\\s*:\\s*)((?:['"][^'"]*['"]\\s*\\+\\s*)+['"][^'"]*['"])`, 'g');
+        function onMatch(full, pre, expr, offset) {
+            try {
+                const partRe = /(['"])([^'"]*?)\1/g;
+                let m;
+                let concatenated = '';
+                while(m = partRe.exec(expr))concatenated += m[2];
+                const resolved = resolveLiteralToOutput(normalizeLiteralPayload(concatenated), {
+                    manifestPath: ctx.manifestPath,
+                    packageJsonDir: ctx.packageJsonDir,
+                    authorFilePath: ctx.authorFilePath
+                });
+                const computed = normalizeLiteralPayload(resolved ?? concatenated);
+                try {
+                    if (isLikelyApiContextAt(source, offset)) {
+                        var _ctx_onResolvedLiteral;
+                        null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, concatenated, resolved ?? void 0, offset);
+                    }
+                } catch  {}
+                return `${pre}'${computed}'`;
+            } catch  {
+                return full;
+            }
+        }
+        return input.replace(rx, onMatch);
+    }
+    function replaceFilesArray(source, input, ctx) {
+        const rx = /(files\s*:\s*\[)([^\]]*)(\])/g;
+        function onMatch(full, pre, inner, post, offset) {
+            try {
+                const replacedInner = inner.replace(/(['"])(.*?)(\1)/g, function(_m, q, p) {
+                    try {
+                        const computed = resolveAndNormalizeLiteral(p, ctx);
+                        return `${q}${computed ?? p}${q}`;
+                    } catch  {
+                        return `${q}${p}${q}`;
+                    }
+                });
+                try {
+                    if (isLikelyApiContextAt(source, offset)) {
+                        const re = /(['"])(.*?)(\1)/g;
+                        let match;
+                        while(match = re.exec(inner)){
+                            var _ctx_onResolvedLiteral;
+                            const raw = match[2];
+                            const resolved = resolveLiteralToOutput(normalizeLiteralPayload(raw), {
+                                manifestPath: ctx.manifestPath,
+                                packageJsonDir: ctx.packageJsonDir,
+                                authorFilePath: ctx.authorFilePath
+                            });
+                            null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, raw, resolved ?? void 0, offset + match.index);
+                        }
+                    }
+                } catch  {}
+                return `${pre}${replacedInner}${post}`;
+            } catch  {
+                return full;
+            }
+        }
+        return input.replace(rx, onMatch);
+    }
+    function replaceJsCssArrays(source, input, ctx) {
+        for (const key of [
+            'js',
+            'css'
+        ]){
+            const rxArr = new RegExp(`(${key}\\s*:\\s*\\[)([^\\]]*)(\\])`, 'g');
+            function onMatch(full, pre, inner, post, offset) {
+                try {
+                    const replacedInner = String(inner).replace(/(['"])(.*?)(\1)/g, function(_m, q, p) {
+                        try {
+                            const computed = resolveAndNormalizeLiteral(p, ctx);
+                            return `${q}${computed ?? p}${q}`;
+                        } catch  {
+                            return `${q}${p}${q}`;
+                        }
+                    });
+                    try {
+                        if (isLikelyApiContextAt(source, offset)) {
+                            const re = /(['"])(.*?)(\1)/g;
+                            let match;
+                            while(match = re.exec(inner)){
+                                var _ctx_onResolvedLiteral;
+                                const raw = match[2];
+                                const resolved = resolveLiteralToOutput(normalizeLiteralPayload(raw), {
+                                    manifestPath: ctx.manifestPath,
+                                    packageJsonDir: ctx.packageJsonDir,
+                                    authorFilePath: ctx.authorFilePath
+                                });
+                                null == (_ctx_onResolvedLiteral = ctx.onResolvedLiteral) || _ctx_onResolvedLiteral.call(ctx, raw, resolved ?? void 0, offset + match.index);
+                            }
+                        }
+                    } catch  {}
+                    return `${pre}${replacedInner}${post}`;
+                } catch  {
+                    return full;
+                }
+            }
+            input = input.replace(rxArr, onMatch);
+        }
+        return input;
+    }
+    function cleanupPublicRootLiterals(input) {
+        input = input.replace(/(['"])\/public\/([^'"]+?)\1/g, function(_m, q, p) {
+            return `${q}${normalizeLiteralPayload(p)}${q}`;
+        });
+        input = input.replace(/(['"])public\/(.*?)\1/g, function(_m, q, p) {
+            return `${q}${normalizeLiteralPayload(p)}${q}`;
+        });
+        return input;
+    }
+    function normalizeSpecialFolderExtensions(input) {
+        input = input.replace(/(['"])((?:pages|scripts)\/[^'"]+?)\.(ts|tsx)\1/g, function(_m, q, p) {
+            return `${q}${p}.js${q}`;
+        });
+        input = input.replace(/(['"])((?:pages|scripts)\/[^'"]+?)\.(njk|nunjucks)\1/g, function(_m, q, p) {
+            return `${q}${p}.html${q}`;
+        });
+        input = input.replace(/(['"])((?:pages|scripts)\/[^'"]+?)\.(scss|sass|less)\1/g, function(_m, q, p) {
+            return `${q}${p}.css${q}`;
+        });
+        return input;
+    }
+    function collapseAccidentalDoubleQuotes(input, keys) {
+        const keyUnion = `(?:${keys.join('|')})`;
+        input = input.replace(new RegExp(`(${keyUnion}\\s*:\\s*)''`, 'g'), "$1'");
+        input = input.replace(new RegExp(`(${keyUnion}\\s*:\\s*)""`, 'g'), '$1"');
+        input = input.replace(/:\s*''/g, ": '");
+        input = input.replace(/:\s*""/g, ': "');
+        input = input.replace(/:\s*''([^']+)'/g, ": '$1'");
+        input = input.replace(/:\s*\"\"([^\"]+)\"/g, ': "$1"');
+        input = input.replace(/''([^']*?)''/g, "'$1'");
+        input = input.replace(/""([^"]*?)""/g, '"$1"');
+        return input;
+    }
+    function textFallbackTransform(source, opts) {
+        let output = String(source);
+        const ctx = {
+            manifestPath: opts.manifestPath,
+            packageJsonDir: opts.packageJsonDir,
+            authorFilePath: opts.authorFilePath,
+            onResolvedLiteral: opts.onResolvedLiteral
+        };
+        output = replaceRuntimeGetURL(source, output, ctx);
+        const supportedKeys = [
+            'url',
+            'file',
+            'path',
+            'iconUrl',
+            'imageUrl',
+            'default_icon'
+        ];
+        output = replaceObjectKeyLiterals(source, output, supportedKeys, ctx);
+        output = replaceStaticTemplateForKeys(source, output, supportedKeys, ctx);
+        output = replaceConcatForKeys(source, output, supportedKeys, ctx);
+        output = replaceFilesArray(source, output, ctx);
+        output = replaceJsCssArrays(source, output, ctx);
+        if (!isJsxLikePath(opts.authorFilePath)) output = cleanupPublicRootLiterals(output);
+        output = normalizeSpecialFolderExtensions(output);
+        output = collapseAccidentalDoubleQuotes(output, supportedKeys);
+        return output;
+    }
+    const external_module_namespaceObject = require("module");
+    let swcRuntimeModule;
+    async function loadSwc() {
+        if (swcRuntimeModule) return swcRuntimeModule;
+        try {
+            const mod = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@swc/core?7929"));
+            swcRuntimeModule = (null == mod ? void 0 : mod.default) && mod.default.parse ? mod.default : mod;
+        } catch  {
+            try {
+                const mod = __webpack_require__("@swc/core?782a") || (0, external_module_namespaceObject.createRequire)('undefined' != typeof __filename ? __filename : __rslib_import_meta_url__)('@swc/core');
+                swcRuntimeModule = (null == mod ? void 0 : mod.default) && mod.default.parse ? mod.default : mod;
+            } catch  {}
+        }
+        return swcRuntimeModule || null;
+    }
+    async function parseWithSwc(swc, source, flags) {
+        return swc.parse(source, {
+            syntax: flags.isTS ? "typescript" : "ecmascript",
+            tsx: flags.isTS && flags.isJSX,
+            jsx: !flags.isTS && flags.isJSX,
+            target: 'es2022',
+            isModule: true
+        });
+    }
+    async function resolvePathsLoader(source) {
+        var _this_getOptions, _this;
+        const callback = this.async();
+        const options = (null == (_this_getOptions = (_this = this).getOptions) ? void 0 : _this_getOptions.call(_this)) || {};
+        const manifestPath = options.manifestPath;
+        const packageJsonDir = options.packageJsonDir;
+        const outputPath = String(options.outputPath || '');
+        const sourceMapsOpt = 'boolean' == typeof options.sourceMaps || 'auto' === options.sourceMaps ? options.sourceMaps : 'auto';
+        this.cacheable && this.cacheable();
+        const emittedBodies = new Set();
+        const emitStandardWarning = (headerFilePath, bodyLines)=>{
+            var _this_emitWarning, _this;
+            const bodyMessage = bodyLines.join('\n');
+            if (emittedBodies.has(bodyMessage)) return;
+            emittedBodies.add(bodyMessage);
+            const warning = new Error(bodyMessage);
+            warning.file = headerFilePath;
+            null == (_this_emitWarning = (_this = this).emitWarning) || _this_emitWarning.call(_this, warning);
+        };
+        const warnIfMissingPublic = (original, computed)=>{
+            try {
+                const canonical = unixify(original || '');
+                const authorUsedRoot = /^\//.test(canonical);
+                if (computed) {
+                    if (/^(?:pages|scripts)\//i.test(computed)) return;
+                    const root = packageJsonDir || external_path_namespaceObject.dirname(manifestPath);
+                    const sourcePublicAbs = external_path_namespaceObject.join(root, 'public', computed);
+                    if (!external_fs_namespaceObject.existsSync(sourcePublicAbs)) {
+                        const displayPath = authorUsedRoot && outputPath ? external_path_namespaceObject.join(outputPath, computed) : sourcePublicAbs;
+                        const lines = [
+                            'Check the path used in your extension API call.',
+                            'The path must point to an existing file that will be packaged with the extension.',
+                            `Found value: ${original ?? ''}`,
+                            `Resolved path: ${authorUsedRoot && outputPath ? external_path_namespaceObject.join(outputPath, computed) : sourcePublicAbs}`
+                        ];
+                        if (authorUsedRoot) lines.push("Paths starting with '/' are resolved from the extension output root (served from public/), not your source directory.");
+                        lines.push('', `NOT FOUND ${displayPath}`);
+                        emitStandardWarning(String(this.resourcePath), lines);
+                    }
+                } else if (original) {
+                    const looksNested = /(^|\/)src\/pages\//i.test(canonical) || /(^|\/)src\/scripts\//i.test(canonical);
+                    if (looksNested) {
+                        const root = packageJsonDir || external_path_namespaceObject.dirname(manifestPath);
+                        const abs = external_path_namespaceObject.join(root, canonical);
+                        const lines = [
+                            'Check the path used in your extension API call.',
+                            'The path must point to an existing file that will be packaged with the extension.',
+                            `Found value: ${original}`
+                        ];
+                        lines.push('', `NOT FOUND ${abs}`);
+                        emitStandardWarning(String(this.resourcePath), lines);
+                    }
+                }
+            } catch  {}
+        };
+        try {
+            const resourcePathUnix = unixify(String(this.resourcePath || ''));
+            if (resourcePathUnix.split('/').includes('public')) return callback(null, source);
+        } catch  {}
+        try {
+            const sourceString = String(source);
+            const containsEligiblePatterns = /(?:^|[^A-Za-z0-9_$])(chrome|browser)\s*\./.test(sourceString) || /(?:^|[^A-Za-z0-9_$])(?:runtime|extension)\s*\.?\s*getURL\s*\(/.test(sourceString) || /(?:^|[^A-Za-z0-9_$])\/public\//.test(sourceString) || /(?:^|[^A-Za-z0-9_$])public\//.test(sourceString) || /(?:^|[^A-Za-z0-9_$])\/pages\//.test(sourceString) || /(?:^|[^A-Za-z0-9_$])pages\//.test(sourceString) || /(?:^|[^A-Za-z0-9_$])\/scripts\//.test(sourceString) || /(?:^|[^A-Za-z0-9_$])scripts\//.test(sourceString);
+            if (!containsEligiblePatterns) return callback(null, source);
+        } catch  {}
+        let postTextSource;
+        try {
+            const out = textFallbackTransform(String(source), {
+                manifestPath,
+                packageJsonDir,
+                authorFilePath: String(this.resourcePath || ''),
+                onResolvedLiteral: (original, computed)=>warnIfMissingPublic(original, computed)
+            });
+            postTextSource = out;
+            const hasStaticTemplates = /`[^$`]*`/.test(out);
+            const hasBinaryConcats = /(['"`][^'"`]*['"`]\s*\+\s*['"`][^'"`]*['"`])/.test(out);
+            const hasApiRoots = /(?:^|[^A-Za-z0-9_$])(chrome|browser)\s*\./.test(out);
+            const needsStaticEval = (hasStaticTemplates || hasBinaryConcats) && hasApiRoots;
+            const enableMaps = 'auto' === sourceMapsOpt ? Boolean(this.sourceMap) : Boolean(sourceMapsOpt);
+            if (!needsStaticEval) {
+                if (out !== String(source) || enableMaps && /\.[cm]?tsx?$/.test(String(this.resourcePath || ''))) {
+                    const msAll = new (external_magic_string_default())(String(source));
+                    msAll.overwrite(0, String(source).length, out);
+                    const map = enableMaps ? msAll.generateMap({
+                        hires: true,
+                        source: String(this.resourcePath),
+                        includeContent: true
+                    }) : void 0;
+                    return callback(null, out, map);
+                }
+            }
+        } catch  {}
+        const swc = await loadSwc();
+        if (!swc) return callback(null, source);
+        let programAst;
+        try {
+            const isTS = /\.[cm]?tsx?$/.test(this.resourcePath);
+            const isJSX = /\.[cm]?[jt]sx$/.test(this.resourcePath);
+            const parseSource = 'string' == typeof postTextSource ? postTextSource : source;
+            programAst = await parseWithSwc(swc, parseSource, {
+                isTS,
+                isJSX
+            });
+        } catch  {
+            return callback(null, source);
+        }
+        const inputSource = 'string' == typeof postTextSource ? postTextSource : String(source);
+        const ms = new (external_magic_string_default())(inputSource);
+        let edited = false;
+        const rewriteValue = (node, computed, rawInput)=>{
+            if (!computed && 'string' == typeof rawInput) try {
+                const recomputed = resolveLiteralToOutput(rawInput, {
+                    manifestPath,
+                    packageJsonDir,
+                    authorFilePath: String(this.resourcePath || '')
+                });
+                if (recomputed) computed = recomputed;
+            } catch  {}
+            if (!computed) return;
+            try {
+                const span = null == node ? void 0 : node.span;
+                if (span && 'number' == typeof span.start && 'number' == typeof span.end) {
+                    const src = String(inputSource);
+                    const before = src[span.start - 1];
+                    const after = src[span.end];
+                    const isQuote = (c)=>"'" === c || '"' === c;
+                    if (isQuote(before) && before === after) {
+                        let start = span.start - 1;
+                        let end = span.end + 1;
+                        const q = before;
+                        const escaped = "'" === q ? String(computed).replace(/'/g, "\\'") : String(computed).replace(/"/g, '\\"');
+                        ms.overwrite(start, end, `${q}${escaped}${q}`);
+                    } else ms.overwrite(span.start, span.end, JSON.stringify(computed));
+                    edited = true;
+                }
+            } catch  {}
+        };
+        const walk = (currentNode)=>{
+            if (!currentNode || 'object' != typeof currentNode) return;
+            if ('CallExpression' === currentNode.type) try {
+                handleCallExpression(currentNode, String(inputSource), rewriteValue, manifestPath);
+            } catch  {}
+            for(const key in currentNode){
+                if (!Object.prototype.hasOwnProperty.call(currentNode, key)) continue;
+                const childNode = currentNode[key];
+                if (childNode) {
+                    if (Array.isArray(childNode)) childNode.forEach(walk);
+                    else if (childNode && 'string' == typeof childNode.type) walk(childNode);
+                }
+            }
+        };
+        walk(programAst);
+        try {
+            if (!edited) {
+                if ('string' == typeof postTextSource && postTextSource !== String(source)) {
+                    const enableMaps = 'auto' === sourceMapsOpt ? Boolean(this.sourceMap) : Boolean(sourceMapsOpt);
+                    const msAll = new (external_magic_string_default())(String(source));
+                    msAll.overwrite(0, String(source).length, postTextSource);
+                    const map = enableMaps ? msAll.generateMap({
+                        hires: true,
+                        source: String(this.resourcePath),
+                        includeContent: true
+                    }) : void 0;
+                    return callback(null, postTextSource, map);
+                }
+                return callback(null, source);
+            }
+            const enableMaps = 'auto' === sourceMapsOpt ? Boolean(this.sourceMap) : Boolean(sourceMapsOpt);
+            const code = ms.toString();
+            const map = enableMaps ? ms.generateMap({
+                hires: true,
+                source: String(this.resourcePath),
+                includeContent: true
+            }) : void 0;
+            return callback(null, code, map);
+        } catch  {
+            return callback(null, source);
+        }
+    }
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});