extension-develop 3.15.1 → 3.16.0

package/dist/0~branding.mjs

@@ -0,0 +1,26 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+function scrubBrand(txt, brand = 'Extension.js') {
+    if (!txt) return txt;
+    const safeBrand = brand.replace(/\$/g, '$$$$');
+    const preserved = [];
+    const preserve = (value)=>{
+        const token = `__EXT_BRAND_PRESERVE_${preserved.length}__`;
+        preserved.push(value);
+        return token;
+    };
+    let output = txt.replace(/\bRspack\b(?=\s+performance recommendations:)/gi, preserve).replace(/https?:\/\/rspack\.(?:rs|dev)\/[^\s)]+/gi, preserve).replace(/(?<!@)\bRspack\b/gi, safeBrand).replace(/(?<!@)\bWebpack\b/gi, safeBrand).replace(/(?<!@)\bwebpack-dev-server\b/gi, `${safeBrand} dev server`).replace(/(?<!@)\bRspackDevServer\b/gi, `${safeBrand} dev server`).replace(/ModuleBuildError:\s*/g, '').replace(/ModuleParseError:\s*/g, '').replace(/Error:\s*Module\s+build\s+failed.*?\n/gi, '').replace(/\n{3,}/g, '\n\n').replace(/\n{2}(?=WARNING in )/g, '\n');
+    preserved.forEach((value, index)=>{
+        output = output.replace(`__EXT_BRAND_PRESERVE_${index}__`, value);
+    });
+    return output;
+}
+function makeSanitizedConsole(brand = 'Extension.js') {
+    const sanitize = (a)=>'string' == typeof a ? scrubBrand(a, brand) : a;
+    return {
+        log: (...args)=>console.log(...args.map(sanitize)),
+        info: (...args)=>console.info(...args.map(sanitize)),
+        warn: (...args)=>console.warn(...args.map(sanitize)),
+        error: (...args)=>console.error(...args.map(sanitize))
+    };
+}
+export { makeSanitizedConsole, scrubBrand };

package/dist/0~dev-server.mjs

@@ -0,0 +1,488 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import fs from "fs";
+import { Writable } from "stream";
+import { rspack } from "@rspack/core";
+import { RspackDevServer } from "@rspack/dev-server";
+import { merge } from "webpack-merge";
+import { createPlaywrightMetadataWriter, autoExitModeEnabled, autoExitForceKill, loadCommandConfig, extensionJsRunnerError, portInUse, devServerStartTimeout, autoExitTriggered, loadCustomConfig, loadBrowserConfig, sanitize, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./946.mjs";
+import { setupNoBrowserBannerOnFirstDone, webpackConfig, setupCompilerLifecycleHooks } from "./0~rspack-config.mjs";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_crypto from "crypto";
+import * as __rspack_external_net from "net";
+import * as __rspack_external_fs from "fs";
+async function findAvailablePortNear(startPort, maxAttempts = 20, host = '127.0.0.1') {
+    if (0 === startPort) return new Promise((resolve, reject)=>{
+        const server = __rspack_external_net.createServer();
+        server.once('error', (err)=>reject(err));
+        server.once('listening', ()=>{
+            const addr = server.address();
+            server.close(()=>resolve(addr.port));
+        });
+        server.listen(0, host);
+    });
+    function tryPort(port) {
+        return new Promise((resolve)=>{
+            const server = __rspack_external_net.createServer();
+            server.once('error', ()=>resolve(false));
+            server.once('listening', ()=>{
+                server.close(()=>resolve(true));
+            });
+            server.listen(port, host);
+        });
+    }
+    let candidate = startPort;
+    for(let i = 0; i < maxAttempts; i++){
+        const ok = await tryPort(candidate);
+        if (ok) return candidate;
+        candidate += 1;
+    }
+    throw new Error(`Could not find an available port near ${startPort} after ${maxAttempts} attempts`);
+}
+function resolveInstanceIdOverride() {
+    const raw = process.env.EXTENSION_INSTANCE_ID || process.env.EXTENSION_DEV_INSTANCE_ID || process.env.EXTJS_INSTANCE_ID || '';
+    const value = String(raw).trim();
+    if (!value) return;
+    return value.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64) || void 0;
+}
+class PortManager {
+    basePort;
+    currentInstance = null;
+    constructor(_browser, _projectPath, basePort = 8080){
+        this.basePort = basePort;
+    }
+    async allocatePorts(_browser, _projectPath, requestedPort) {
+        try {
+            const isValidRequested = 'number' == typeof requestedPort && requestedPort >= 0 && requestedPort < 65536;
+            const base = isValidRequested ? requestedPort : this.basePort;
+            const port = await findAvailablePortNear(base);
+            const webSocketPort = await findAvailablePortNear(port + 1);
+            const instanceId = resolveInstanceIdOverride() || __rspack_external_crypto.randomBytes(8).toString('hex');
+            this.currentInstance = {
+                instanceId,
+                port,
+                webSocketPort
+            };
+            return {
+                port,
+                webSocketPort,
+                instanceId
+            };
+        } catch (error) {
+            throw error;
+        }
+    }
+    getCurrentInstance() {
+        return this.currentInstance;
+    }
+    async updateExtensionId(extensionId) {
+        if (this.currentInstance) this.currentInstance.extensionId = extensionId;
+    }
+    async terminateCurrentInstance() {
+        this.currentInstance = null;
+    }
+    getPortInfo(allocation) {
+        return `Port: ${allocation.port}, WebSocket: ${allocation.webSocketPort}, Instance: ${allocation.instanceId.slice(0, 8)}`;
+    }
+    async isPortInUse(port) {
+        return new Promise((resolve)=>{
+            const server = __rspack_external_net.createServer();
+            server.once('error', ()=>resolve(true));
+            server.once('listening', ()=>{
+                server.close(()=>resolve(false));
+            });
+            server.listen(port, '127.0.0.1');
+        });
+    }
+    async getRunningInstances() {
+        return this.currentInstance ? [
+            this.currentInstance
+        ] : [];
+    }
+    async getStats() {
+        return {
+            total: this.currentInstance ? 1 : 0,
+            running: this.currentInstance ? 1 : 0,
+            terminated: 0,
+            error: 0
+        };
+    }
+}
+function hasDependency(projectPath, dependency) {
+    const findNearestPackageJsonDirectory = (startPath)=>{
+        let currentDirectory = startPath;
+        const maxDepth = 4;
+        for(let i = 0; i < maxDepth; i++){
+            const candidate = __rspack_external_path.join(currentDirectory, 'package.json');
+            if (__rspack_external_fs.existsSync(candidate)) return currentDirectory;
+            const parentDirectory = __rspack_external_path.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) break;
+            currentDirectory = parentDirectory;
+        }
+    };
+    const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+    if (!packageJsonDirectory) return false;
+    const packageJsonPath = __rspack_external_path.join(packageJsonDirectory, 'package.json');
+    if (!__rspack_external_fs.existsSync(packageJsonPath)) return false;
+    const packageJson = JSON.parse(__rspack_external_fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    return !!dependencies[dependency] || !!devDependencies[dependency];
+}
+function isUsingJSFramework(projectPath) {
+    const frameworks = [
+        'react',
+        'vue',
+        '@angular/core',
+        'svelte',
+        'solid-js',
+        'preact'
+    ];
+    return frameworks.some((fw)=>hasDependency(projectPath, fw));
+}
+function parseMilliseconds(value) {
+    if ('number' == typeof value) return Number.isFinite(value) && value > 0 ? value : null;
+    if ('string' == typeof value) {
+        const parsed = parseInt(value, 10);
+        return !Number.isNaN(parsed) && parsed > 0 ? parsed : null;
+    }
+    return null;
+}
+function setupAutoExit(autoExitMsRaw, forceKillMsRaw, onCleanup) {
+    let autoExitTimer = null;
+    let forceKillTimer = null;
+    const autoExitMs = parseMilliseconds(autoExitMsRaw);
+    if (null === autoExitMs) return ()=>{};
+    try {
+        console.log(autoExitModeEnabled(autoExitMs));
+    } catch  {}
+    autoExitTimer = setTimeout(async ()=>{
+        try {
+            console.log(autoExitTriggered(autoExitMs));
+        } catch  {}
+        await onCleanup();
+    }, autoExitMs);
+    const parsedForceKillMs = parseMilliseconds(forceKillMsRaw);
+    const forceKillMs = null !== parsedForceKillMs && parsedForceKillMs > 0 ? parsedForceKillMs : autoExitMs + 4000;
+    forceKillTimer = setTimeout(()=>{
+        try {
+            console.log(autoExitForceKill(forceKillMs));
+        } catch  {}
+        process.exit(0);
+    }, forceKillMs);
+    function cancelAutoExitTimers() {
+        if (null !== autoExitTimer) {
+            clearTimeout(autoExitTimer);
+            autoExitTimer = null;
+        }
+        if (null !== forceKillTimer) {
+            clearTimeout(forceKillTimer);
+            forceKillTimer = null;
+        }
+    }
+    return cancelAutoExitTimers;
+}
+function closeAll(devServer, portManager) {
+    return devServer.stop().then(async ()=>{
+        await portManager.terminateCurrentInstance();
+        setTimeout(()=>process.exit(), 500);
+    }).catch(async (error)=>{
+        console.log(extensionJsRunnerError(error));
+        await portManager.terminateCurrentInstance();
+        setTimeout(()=>process.exit(1), 500);
+    });
+}
+function setupCleanupHandlers(devServer, portManager) {
+    let isShuttingDown = false;
+    const cleanup = async ()=>{
+        if (isShuttingDown) return;
+        isShuttingDown = true;
+        try {
+            await closeAll(devServer, portManager);
+        } catch (error) {
+            console.error('[Extension.js Runner] Error during cleanup.', error);
+            process.exit(1);
+        }
+    };
+    process.on('uncaughtException', async (error)=>{
+        console.error('[Extension.js Runner] Uncaught exception.', error);
+        await cleanup();
+    });
+    process.on('unhandledRejection', async (reason, promise)=>{
+        console.error('[Extension.js Runner] Unhandled rejection.', promise, reason);
+        await cleanup();
+    });
+    const cancelAutoExit = setupAutoExit(process.env.EXTENSION_AUTO_EXIT_MS, process.env.EXTENSION_FORCE_KILL_MS, cleanup);
+    const cancelAndCleanup = async ()=>{
+        try {
+            cancelAutoExit();
+        } catch  {}
+        await cleanup();
+    };
+    process.on('ERROR', cancelAndCleanup);
+    process.on('SIGINT', cancelAndCleanup);
+    process.on('SIGTERM', cancelAndCleanup);
+    process.on('SIGHUP', cancelAndCleanup);
+    return cancelAutoExit;
+}
+function shouldWriteAssetToDisk(filePath) {
+    return !/(?:^|[/\\])manifest\.json$/i.test(filePath);
+}
+function isSamePath(left, right) {
+    return __rspack_external_path.resolve(left) === __rspack_external_path.resolve(right);
+}
+function isManifestTempPath(filePath) {
+    const base = __rspack_external_path.basename(filePath);
+    return base.startsWith('.manifest.') && base.endsWith('.tmp');
+}
+function createDiscardWriteStream() {
+    const stream = new Writable({
+        write (_chunk, _encoding, callback) {
+            callback();
+        }
+    });
+    stream.on('finish', ()=>{
+        stream.emit('close');
+    });
+    process.nextTick(()=>{
+        stream.emit('open', 0);
+    });
+    return stream;
+}
+const guardedManifestDiskWritePaths = new Set();
+let isManifestDiskWriteGuardInstalled = false;
+function hasGuardedManifestDiskPath(filePath) {
+    if ('string' != typeof filePath) return false;
+    const resolvedPath = __rspack_external_path.resolve(filePath);
+    for (const guardedPath of guardedManifestDiskWritePaths)if (isSamePath(guardedPath, resolvedPath)) return true;
+    return false;
+}
+function suppressManifestOutputWrites(compiler, manifestOutputPath) {
+    const outputFileSystem = compiler?.outputFileSystem;
+    if (!outputFileSystem || outputFileSystem.__extensionjsManifestWriteGuard) return;
+    const isManifestPath = (filePath)=>'string' == typeof filePath && isSamePath(filePath, manifestOutputPath);
+    if ('function' == typeof outputFileSystem.writeFile) {
+        const originalWriteFile = outputFileSystem.writeFile.bind(outputFileSystem);
+        outputFileSystem.writeFile = (filePath, ...args)=>{
+            if (isManifestPath(filePath)) {
+                const callback = args[args.length - 1];
+                if ('function' == typeof callback) callback(null);
+                return;
+            }
+            return originalWriteFile(filePath, ...args);
+        };
+    }
+    if ('function' == typeof outputFileSystem.writeFileSync) {
+        const originalWriteFileSync = outputFileSystem.writeFileSync.bind(outputFileSystem);
+        outputFileSystem.writeFileSync = (filePath, ...args)=>{
+            if (isManifestPath(filePath)) return;
+            return originalWriteFileSync(filePath, ...args);
+        };
+    }
+    if ('function' == typeof outputFileSystem.createWriteStream) {
+        const originalCreateWriteStream = outputFileSystem.createWriteStream.bind(outputFileSystem);
+        outputFileSystem.createWriteStream = (filePath, ...args)=>{
+            if (isManifestPath(filePath)) {
+                const stream = createDiscardWriteStream();
+                stream.path = filePath;
+                return stream;
+            }
+            return originalCreateWriteStream(filePath, ...args);
+        };
+    }
+    if ('function' == typeof outputFileSystem?.promises?.writeFile) {
+        const originalPromiseWriteFile = outputFileSystem.promises.writeFile.bind(outputFileSystem.promises);
+        outputFileSystem.promises.writeFile = async (filePath, ...args)=>{
+            if (isManifestPath(filePath)) return;
+            return originalPromiseWriteFile(filePath, ...args);
+        };
+    }
+    outputFileSystem.__extensionjsManifestWriteGuard = true;
+}
+function installManifestDiskWriteGuard(manifestOutputPath) {
+    const guardKey = __rspack_external_path.resolve(manifestOutputPath);
+    guardedManifestDiskWritePaths.add(guardKey);
+    if (isManifestDiskWriteGuardInstalled) return;
+    const guardedFs = fs;
+    const isManifestPath = (filePath)=>hasGuardedManifestDiskPath(filePath);
+    const allowManifestRename = (fromPath, toPath)=>'string' == typeof fromPath && 'string' == typeof toPath && isManifestPath(toPath) && isManifestTempPath(fromPath);
+    const originalWriteFile = guardedFs.writeFile.bind(guardedFs);
+    guardedFs.writeFile = (filePath, ...args)=>{
+        if (isManifestPath(filePath)) {
+            const callback = args[args.length - 1];
+            if ('function' == typeof callback) callback(null);
+            return;
+        }
+        return originalWriteFile(filePath, ...args);
+    };
+    const originalWriteFileSync = guardedFs.writeFileSync.bind(guardedFs);
+    guardedFs.writeFileSync = (filePath, ...args)=>{
+        if (isManifestPath(filePath)) return;
+        return originalWriteFileSync(filePath, ...args);
+    };
+    const originalCreateWriteStream = guardedFs.createWriteStream.bind(guardedFs);
+    guardedFs.createWriteStream = (filePath, ...args)=>{
+        if (isManifestPath(filePath)) {
+            const stream = createDiscardWriteStream();
+            stream.path = String(filePath);
+            return stream;
+        }
+        return originalCreateWriteStream(filePath, ...args);
+    };
+    const originalOpen = guardedFs.open.bind(guardedFs);
+    guardedFs.open = (pathLike, flags, ...args)=>{
+        const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+        return originalOpen(nextPath, flags, ...args);
+    };
+    const originalOpenSync = guardedFs.openSync.bind(guardedFs);
+    guardedFs.openSync = (pathLike, flags, ...args)=>{
+        const nextPath = isManifestPath(pathLike) ? '/dev/null' : pathLike;
+        return originalOpenSync(nextPath, flags, ...args);
+    };
+    const originalRename = guardedFs.rename.bind(guardedFs);
+    guardedFs.rename = (oldPath, newPath, callback)=>{
+        if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) {
+            if ('function' == typeof callback) callback(null);
+            return;
+        }
+        return originalRename(oldPath, newPath, callback);
+    };
+    const originalRenameSync = guardedFs.renameSync.bind(guardedFs);
+    guardedFs.renameSync = (oldPath, newPath)=>{
+        if (isManifestPath(newPath) && !allowManifestRename(oldPath, newPath)) return;
+        return originalRenameSync(oldPath, newPath);
+    };
+    if (guardedFs.promises?.writeFile) {
+        const originalPromiseWriteFile = guardedFs.promises.writeFile.bind(guardedFs.promises);
+        guardedFs.promises.writeFile = async (filePath, ...args)=>{
+            if (isManifestPath(filePath)) return;
+            return originalPromiseWriteFile(filePath, ...args);
+        };
+    }
+    isManifestDiskWriteGuardInstalled = true;
+}
+async function dev_server_devServer(projectStructure, devOptions) {
+    process.env.EXTENSION_BROWSER_LAUNCH_ENABLED = devOptions.noBrowser ? '0' : '1';
+    const { manifestPath, packageJsonPath } = projectStructure;
+    __rspack_external_path.dirname(manifestPath);
+    const packageJsonDir = __rspack_external_path.dirname(packageJsonPath);
+    const commandConfig = await loadCommandConfig(packageJsonDir, 'dev');
+    const browserConfig = await loadBrowserConfig(packageJsonDir, devOptions.browser);
+    const portManager = new PortManager(devOptions.browser, packageJsonDir, 8080);
+    const desiredPort = 'string' == typeof devOptions.port ? parseInt(devOptions.port, 10) : devOptions.port;
+    const portAllocation = await portManager.allocatePorts(devOptions.browser, packageJsonDir, desiredPort);
+    const currentInstance = portManager.getCurrentInstance();
+    if (!currentInstance) throw new Error('Failed to create instance');
+    const port = portAllocation.port;
+    const devServerHost = devOptions.host || '127.0.0.1';
+    const devServerWebSocketURL = {
+        protocol: 'ws',
+        hostname: devServerHost,
+        port
+    };
+    process.env.EXTENSION_DEV_SERVER_PROTOCOL = devServerWebSocketURL.protocol;
+    process.env.EXTENSION_DEV_SERVER_HOST = devServerHost;
+    process.env.EXTENSION_DEV_SERVER_PORT = String(port);
+    process.env.EXTENSION_DEV_SERVER_PATH = '/ws';
+    const safeBrowserConfig = sanitize(browserConfig);
+    const safeCommandConfig = sanitize(commandConfig);
+    const safeDevOptions = sanitize(devOptions);
+    const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
+    const mergedExtensionsConfig = safeDevOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+    const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
+        projectRoot: packageJsonDir,
+        browser: devOptions.browser,
+        config: mergedExtensionsConfig
+    });
+    const baseConfig = webpackConfig(projectStructure, {
+        ...safeBrowserConfig,
+        ...safeCommandConfig,
+        ...safeDevOptions,
+        extensions: resolvedExtensionsConfig,
+        browser: devOptions.browser,
+        mode: 'development',
+        instanceId: currentInstance.instanceId,
+        port: portAllocation.port,
+        output: {
+            clean: false,
+            path: __rspack_external_path.join(packageJsonDir, 'dist', devOptions.browser)
+        }
+    });
+    const customWebpackConfig = await loadCustomConfig(packageJsonDir);
+    const finalConfig = customWebpackConfig(baseConfig);
+    const compilerConfig = merge(finalConfig, {});
+    const compiler = rspack(compilerConfig);
+    const manifestOutputPath = __rspack_external_path.join(packageJsonDir, 'dist', devOptions.browser, 'manifest.json');
+    installManifestDiskWriteGuard(manifestOutputPath);
+    suppressManifestOutputWrites(compiler, manifestOutputPath);
+    const metadata = createPlaywrightMetadataWriter({
+        packageJsonDir,
+        browser: String(devOptions.browser || 'chromium'),
+        command: 'dev',
+        distPath: __rspack_external_path.join(packageJsonDir, 'dist', String(devOptions.browser || 'chromium')),
+        manifestPath,
+        port
+    });
+    setupCompilerLifecycleHooks(compiler);
+    if (devOptions.noBrowser) setupNoBrowserBannerOnFirstDone({
+        compiler,
+        browser: String(devOptions.browser || 'chromium'),
+        manifestPath,
+        readyPath: metadata.readyPath
+    });
+    if (void 0 !== devOptions.port && devOptions.port !== port) console.log(portInUse(devOptions.port, port));
+    const serverConfig = {
+        host: devServerHost,
+        allowedHosts: 'all',
+        static: {
+            directory: __rspack_external_path.join(packageJsonDir, 'public'),
+            watch: false
+        },
+        compress: false,
+        devMiddleware: {
+            writeToDisk: shouldWriteAssetToDisk,
+            stats: {
+                all: false
+            }
+        },
+        watchFiles: {
+            paths: [
+                __rspack_external_path.join(packageJsonDir, 'public', '**/*'),
+                ...isUsingJSFramework(packageJsonDir) ? [] : [
+                    __rspack_external_path.join(packageJsonDir, '**/*.html')
+                ]
+            ],
+            options: {
+                ignored: [
+                    __rspack_external_path.join(packageJsonDir, 'dist', '**/*')
+                ],
+                ignoreInitial: true,
+                usePolling: true,
+                interval: 1000
+            }
+        },
+        client: false,
+        headers: {
+            'Access-Control-Allow-Origin': '*'
+        },
+        port,
+        hot: true,
+        liveReload: true
+    };
+    const devServer = new RspackDevServer(serverConfig, compiler);
+    const START_TIMEOUT_MS = parseInt(String(process.env.EXTENSION_START_TIMEOUT_MS || '30000'), 10);
+    let startTimeout;
+    try {
+        startTimeout = setTimeout(()=>{
+            console.error(devServerStartTimeout(START_TIMEOUT_MS));
+        }, START_TIMEOUT_MS);
+        await devServer.start();
+        if (startTimeout) clearTimeout(startTimeout);
+    } catch (error) {
+        if (startTimeout) clearTimeout(startTimeout);
+        metadata.writeError('dev_server_start_failed', error instanceof Error ? error.message : String(error));
+        console.log(extensionJsRunnerError(error));
+        process.exit(1);
+    }
+    setupCleanupHandlers(devServer, portManager);
+}
+export { dev_server_devServer as devServer };

package/dist/0~rslib-runtime.mjs

@@ -0,0 +1,40 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+var __webpack_modules__ = {};
+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__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+export { __webpack_require__ };