@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/generated-ui-source.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generatedUiSourceRequiresRewrite: ()=>generatedUiSourceRequiresRewrite,
+    writeGeneratedUiSourceIfChanged: ()=>writeGeneratedUiSourceIfChanged
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
+const external_io_cjs_namespaceObject = require("./io.cjs");
+const multiCharacterTokens = [
+    '===',
+    '!==',
+    '**=',
+    '&&=',
+    '||=',
+    '??=',
+    '...',
+    '=>',
+    '==',
+    '!=',
+    '<=',
+    '>=',
+    '++',
+    '--',
+    '&&',
+    '||',
+    '??',
+    '?.',
+    '**',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '&=',
+    '|=',
+    '^=',
+    '</',
+    '/>'
+];
+function isIdentifierPart(character) {
+    return /[$_\p{ID_Continue}\u200C\u200D]/u.test(character);
+}
+function generatedUiSourceTokens(source) {
+    const tokens = [];
+    let index = 0;
+    while(index < source.length){
+        const character = source[index] ?? '';
+        if (/\s/u.test(character)) {
+            index += 1;
+            continue;
+        }
+        if (source.startsWith('//', index)) {
+            const lineEnd = source.indexOf('\n', index + 2);
+            index = lineEnd < 0 ? source.length : lineEnd + 1;
+            continue;
+        }
+        if (source.startsWith('/*', index)) {
+            const commentEnd = source.indexOf('*/', index + 2);
+            index = commentEnd < 0 ? source.length : commentEnd + 2;
+            continue;
+        }
+        if ("'" === character || '"' === character || '`' === character) {
+            const quote = character;
+            const start = index;
+            index += 1;
+            let escaped = false;
+            while(index < source.length){
+                const current = source[index] ?? '';
+                index += 1;
+                if (escaped) escaped = false;
+                else if ('\\' === current) escaped = true;
+                else if (current === quote) break;
+            }
+            tokens.push(`literal:${source.slice(start, index)}`);
+            continue;
+        }
+        if (isIdentifierPart(character)) {
+            const start = index;
+            index += 1;
+            while(isIdentifierPart(source[index] ?? ''))index += 1;
+            tokens.push(`word:${source.slice(start, index)}`);
+            continue;
+        }
+        const multiCharacterToken = multiCharacterTokens.find((token)=>source.startsWith(token, index));
+        if (multiCharacterToken) {
+            tokens.push(`punctuator:${multiCharacterToken}`);
+            index += multiCharacterToken.length;
+            continue;
+        }
+        tokens.push(`punctuator:${character}`);
+        index += 1;
+    }
+    return tokens;
+}
+function generatedUiSourceRequiresRewrite(existingSource, nextSource) {
+    return !(0, external_node_util_namespaceObject.isDeepStrictEqual)(generatedUiSourceTokens(existingSource), generatedUiSourceTokens(nextSource));
+}
+function writeGeneratedUiSourceIfChanged(io, filePath, nextSource) {
+    if (external_node_fs_default().existsSync(filePath) && !generatedUiSourceRequiresRewrite(external_node_fs_default().readFileSync(filePath, 'utf-8'), nextSource)) return false;
+    return (0, external_io_cjs_namespaceObject.writeTextIfChanged)(io, filePath, nextSource);
+}
+exports.generatedUiSourceRequiresRewrite = __webpack_exports__.generatedUiSourceRequiresRewrite;
+exports.writeGeneratedUiSourceIfChanged = __webpack_exports__.writeGeneratedUiSourceIfChanged;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generatedUiSourceRequiresRewrite",
+    "writeGeneratedUiSourceIfChanged"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/help.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const migrateStrictEffectHelp = `Usage:
+  modern-js-create ultramodern migrate-strict-effect --version <version> [--dry-run] [--skip-install]
+
+Updates generated UltraModern package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct Effect API topology metadata, strict
+Effect pnpm overrides/trust policy, framework-owned TypeScript config
+surfaces, and the pnpm lockfile. Source code still has to pass pnpm api:check
+and pnpm contract:check.
+
+When the compact config is absent but legacy UltraModern 3.2 metadata is
+present, the compact config is synthesized from it first. Shell-only
+workspaces skip the backend-federation and Zerops runtime stages. Pass
+--dry-run to print the planned filesystem changes without writing anything
+(implies --skip-install).
+`;
+__webpack_require__.d(__webpack_exports__, {}, {
+    migrateStrictEffectHelp: migrateStrictEffectHelp
+});
+exports.migrateStrictEffectHelp = __webpack_exports__.migrateStrictEffectHelp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "migrateStrictEffectHelp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/install.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runPnpmLockfileRefresh: ()=>runPnpmLockfileRefresh
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+function runPnpmLockfileRefresh(context) {
+    const result = (0, external_node_child_process_namespaceObject.spawnSync)('pnpm', [
+        'install',
+        '--lockfile-only',
+        "--ignore-scripts"
+    ], {
+        cwd: context.workspaceRoot,
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+exports.runPnpmLockfileRefresh = __webpack_exports__.runPnpmLockfileRefresh;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runPnpmLockfileRefresh"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-tooling/commands/migrate-strict-effect/io.cjs

@@ -0,0 +1,350 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createMigrationIo: ()=>createMigrationIo,
+    listWorkspacePackageFiles: ()=>listWorkspacePackageFiles,
+    readJsonFile: ()=>readJsonFile,
+    writeJsonFile: ()=>writeJsonFile,
+    writeJsonIfChanged: ()=>writeJsonIfChanged,
+    writeTextIfChanged: ()=>writeTextIfChanged
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const stagingExcludedEntries = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function lstatIfExists(filePath) {
+    try {
+        return external_node_fs_default().lstatSync(filePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+}
+function capturePath(filePath) {
+    const stat = lstatIfExists(filePath);
+    if (!stat) return;
+    const mode = 4095 & stat.mode;
+    if (stat.isFile()) return {
+        content: external_node_fs_default().readFileSync(filePath),
+        mode,
+        type: 'file'
+    };
+    if (stat.isDirectory()) {
+        const entries = new Map();
+        for (const entry of external_node_fs_default().readdirSync(filePath).sort((left, right)=>left.localeCompare(right))){
+            const snapshot = capturePath(external_node_path_default().join(filePath, entry));
+            if (snapshot) entries.set(entry, snapshot);
+        }
+        return {
+            entries,
+            mode,
+            type: 'directory'
+        };
+    }
+    if (stat.isSymbolicLink()) return {
+        mode,
+        target: external_node_fs_default().readlinkSync(filePath),
+        type: 'symlink'
+    };
+    throw new Error(`Unsupported migration transaction path: ${filePath}`);
+}
+function removePath(filePath) {
+    external_node_fs_default().rmSync(filePath, {
+        force: true,
+        recursive: true
+    });
+}
+function chmodSymlinkIfSupported(filePath, mode) {
+    if ('function' == typeof external_node_fs_default().lchmodSync) external_node_fs_default().lchmodSync(filePath, mode);
+}
+function restorePath(filePath, snapshot) {
+    if (!snapshot) return void removePath(filePath);
+    const current = lstatIfExists(filePath);
+    if ('file' === snapshot.type) {
+        if (!current?.isFile() || current.isSymbolicLink()) {
+            removePath(filePath);
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+                recursive: true
+            });
+        }
+        external_node_fs_default().writeFileSync(filePath, snapshot.content);
+        external_node_fs_default().chmodSync(filePath, snapshot.mode);
+        return;
+    }
+    if ('symlink' === snapshot.type) {
+        if (!current?.isSymbolicLink() || external_node_fs_default().readlinkSync(filePath) !== snapshot.target) {
+            removePath(filePath);
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+                recursive: true
+            });
+            external_node_fs_default().symlinkSync(snapshot.target, filePath);
+        }
+        chmodSymlinkIfSupported(filePath, snapshot.mode);
+        return;
+    }
+    if (!current?.isDirectory() || current.isSymbolicLink()) {
+        removePath(filePath);
+        external_node_fs_default().mkdirSync(filePath, {
+            recursive: true
+        });
+    }
+    for (const entry of external_node_fs_default().readdirSync(filePath))if (!snapshot.entries.has(entry)) removePath(external_node_path_default().join(filePath, entry));
+    for (const [entry, childSnapshot] of snapshot.entries)restorePath(external_node_path_default().join(filePath, entry), childSnapshot);
+    external_node_fs_default().chmodSync(filePath, snapshot.mode);
+}
+function copyWorkspaceEntry(sourcePath, destinationPath) {
+    const stat = external_node_fs_default().lstatSync(sourcePath);
+    if (stat.isDirectory()) {
+        external_node_fs_default().mkdirSync(destinationPath, {
+            mode: 4095 & stat.mode
+        });
+        for (const entry of external_node_fs_default().readdirSync(sourcePath))if (!stagingExcludedEntries.has(entry)) copyWorkspaceEntry(external_node_path_default().join(sourcePath, entry), external_node_path_default().join(destinationPath, entry));
+        external_node_fs_default().chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isFile()) {
+        external_node_fs_default().copyFileSync(sourcePath, destinationPath, external_node_fs_default().constants.COPYFILE_FICLONE);
+        external_node_fs_default().chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        external_node_fs_default().symlinkSync(external_node_fs_default().readlinkSync(sourcePath), destinationPath);
+        chmodSymlinkIfSupported(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    throw new Error(`Unsupported migration staging path: ${sourcePath}`);
+}
+function isPromiseLike(value) {
+    return ('object' == typeof value || 'function' == typeof value) && null !== value && 'function' == typeof value.then;
+}
+function createMigrationIo(workspaceRoot, dryRun) {
+    const absoluteWorkspaceRoot = external_node_path_default().resolve(workspaceRoot);
+    const plan = [];
+    let activeTransaction;
+    const rel = (p)=>(external_node_path_default().relative(absoluteWorkspaceRoot, p) || external_node_path_default().basename(p)).split(external_node_path_default().sep).join('/');
+    const assertWorkspacePath = (filePath)=>{
+        const absolutePath = external_node_path_default().resolve(filePath);
+        const relativePath = external_node_path_default().relative(absoluteWorkspaceRoot, absolutePath);
+        if ('' === relativePath || '..' === relativePath || relativePath.startsWith(`..${external_node_path_default().sep}`) || external_node_path_default().isAbsolute(relativePath)) throw new Error(`Refusing to mutate outside workspace: ${filePath}`);
+        return absolutePath;
+    };
+    const captureForRollback = (filePath)=>{
+        if (!activeTransaction || activeTransaction.snapshots.has(filePath)) return;
+        activeTransaction.snapshots.set(filePath, capturePath(filePath));
+        activeTransaction.order.push(filePath);
+    };
+    const captureMissingParents = (filePath)=>{
+        const missing = [];
+        let current = external_node_path_default().dirname(filePath);
+        while(current !== absoluteWorkspaceRoot && !lstatIfExists(current)){
+            missing.push(current);
+            current = external_node_path_default().dirname(current);
+        }
+        for (const missingDirectory of missing.reverse())captureForRollback(missingDirectory);
+    };
+    const rollback = (transaction)=>{
+        for (const filePath of [
+            ...transaction.order
+        ].reverse())restorePath(filePath, transaction.snapshots.get(filePath));
+    };
+    const finishWithError = (transaction, error)=>{
+        try {
+            rollback(transaction);
+        } catch (rollbackError) {
+            throw new Error(`Migration failed (${String(error)}) and rollback failed (${String(rollbackError)}).`);
+        } finally{
+            activeTransaction = void 0;
+        }
+        throw error;
+    };
+    const io = {
+        workspaceRoot: absoluteWorkspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().readFileSync(absolutePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(absolutePath)}`);
+                return true;
+            }
+            captureMissingParents(absolutePath);
+            captureForRollback(absolutePath);
+            const current = lstatIfExists(absolutePath);
+            if (current?.isSymbolicLink()) {
+                const linkedPath = external_node_path_default().resolve(external_node_path_default().dirname(absolutePath), external_node_fs_default().readlinkSync(absolutePath));
+                let targetPath = linkedPath;
+                try {
+                    targetPath = external_node_fs_default().realpathSync.native(absolutePath);
+                } catch  {}
+                const absoluteTargetPath = assertWorkspacePath(targetPath);
+                captureMissingParents(absoluteTargetPath);
+                captureForRollback(absoluteTargetPath);
+            }
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
+                recursive: true
+            });
+            external_node_fs_default().writeFileSync(absolutePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (!lstatIfExists(absolutePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(absolutePath)}`);
+                return true;
+            }
+            captureForRollback(absolutePath);
+            external_node_fs_default().rmSync(absolutePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        },
+        transaction (operation, options) {
+            if (activeTransaction) throw new Error('Nested migration transactions are not supported.');
+            const transaction = {
+                order: [],
+                snapshots: new Map()
+            };
+            activeTransaction = transaction;
+            const finish = (result)=>{
+                try {
+                    if (options?.commitWhen && !options.commitWhen(result)) rollback(transaction);
+                    return result;
+                } finally{
+                    activeTransaction = void 0;
+                }
+            };
+            try {
+                const result = operation();
+                if (isPromiseLike(result)) return Promise.resolve(result).then((value)=>finish(value), (error)=>finishWithError(transaction, error));
+                return finish(result);
+            } catch (error) {
+                return finishWithError(transaction, error);
+            }
+        },
+        withStagedWorkspace (operation) {
+            const temporaryRoot = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'ultramodern-migration-'));
+            const stagedWorkspaceRoot = external_node_path_default().join(temporaryRoot, 'workspace');
+            try {
+                copyWorkspaceEntry(absoluteWorkspaceRoot, stagedWorkspaceRoot);
+                const result = operation(stagedWorkspaceRoot);
+                if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
+                    external_node_fs_default().rmSync(temporaryRoot, {
+                        force: true,
+                        recursive: true
+                    });
+                });
+                external_node_fs_default().rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                return result;
+            } catch (error) {
+                external_node_fs_default().rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                throw error;
+            }
+        }
+    };
+    return io;
+}
+function readJsonFile(filePath) {
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeJsonIfChanged(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextIfChanged(io, filePath, value) {
+    return io.write(filePath, value);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = external_node_path_default().join(workspaceRoot, directory);
+        if (external_node_fs_default().existsSync(absoluteDirectory)) for (const entry of external_node_fs_default().readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = `${directory}/${entry.name}/package.json`;
+            if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+exports.createMigrationIo = __webpack_exports__.createMigrationIo;
+exports.listWorkspacePackageFiles = __webpack_exports__.listWorkspacePackageFiles;
+exports.readJsonFile = __webpack_exports__.readJsonFile;
+exports.writeJsonFile = __webpack_exports__.writeJsonFile;
+exports.writeJsonIfChanged = __webpack_exports__.writeJsonIfChanged;
+exports.writeTextIfChanged = __webpack_exports__.writeTextIfChanged;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMigrationIo",
+    "listWorkspacePackageFiles",
+    "readJsonFile",
+    "writeJsonFile",
+    "writeJsonIfChanged",
+    "writeTextIfChanged"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});