nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/{info.mjs → _deps/unwasm.mjs}

@@ -1,3281 +1,9 @@
-import { F as pm, M as MagicString, P as Parser, G as decode, H as encode, I as createUnimport, J as genSafeVariableName, K as genImport, L as genString, O as genObjectFromRaw, b as glob, n as mime, r as resolveModulePath, w as writeFile } from './index.mjs';
-import sysPath__default, { win32, posix, isAbsolute, resolve as resolve$1 } from 'path';
-import { defineEnv } from 'unenv';
-import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
-import { j as join, r as resolve$2, i as isAbsolute$3, b as basename$1, d as dirname$1, e as extname$1, a as relative } from './pathe.M-eThtNZ.mjs';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { createRequire, builtinModules } from 'node:module';
-import { hash } from 'ohash';
-import { defu } from 'defu';
-import fs, { promises, existsSync } from 'node:fs';
-import path, { resolve as resolve$3, isAbsolute as isAbsolute$2, normalize, dirname, basename, extname } from 'node:path';
-import { Buffer as Buffer$1 } from 'node:buffer';
-import process$1 from 'node:process';
-import * as querystring from 'node:querystring';
-import { g as getDefaultExportFromCjs, r as requireEtag } from './app.mjs';
-import require$$0 from 'constants';
-import { camelCase } from 'scule';
-import { readFile, mkdir, unlink, symlink } from 'node:fs/promises';
-import 'node:os';
+import { existsSync, promises } from 'node:fs';
+import { M as MagicString } from './magic-string.mjs';
+import { c as createUnplugin } from './unplugin.mjs';
 import { createHash } from 'node:crypto';
-import { connectors } from 'db0';
-import { transform } from 'esbuild';
-import { withTrailingSlash } from 'ufo';
-import { normalizeKey, builtinDrivers } from 'unstorage';
-import { rollupNodeFileTrace } from 'nf3';
-import { hasTemplateSyntax, compileTemplateToString, RENDER_CONTEXT_KEYS } from 'rendu';
-import { version } from 'nitro/meta';
-
-// @ts-check
-/** @typedef { import('estree').BaseNode} BaseNode */
-
-/** @typedef {{
-	skip: () => void;
-	remove: () => void;
-	replace: (node: BaseNode) => void;
-}} WalkerContext */
-
-class WalkerBase {
-	constructor() {
-		/** @type {boolean} */
-		this.should_skip = false;
-
-		/** @type {boolean} */
-		this.should_remove = false;
-
-		/** @type {BaseNode | null} */
-		this.replacement = null;
-
-		/** @type {WalkerContext} */
-		this.context = {
-			skip: () => (this.should_skip = true),
-			remove: () => (this.should_remove = true),
-			replace: (node) => (this.replacement = node)
-		};
-	}
-
-	/**
-	 *
-	 * @param {any} parent
-	 * @param {string} prop
-	 * @param {number} index
-	 * @param {BaseNode} node
-	 */
-	replace(parent, prop, index, node) {
-		if (parent) {
-			if (index !== null) {
-				parent[prop][index] = node;
-			} else {
-				parent[prop] = node;
-			}
-		}
-	}
-
-	/**
-	 *
-	 * @param {any} parent
-	 * @param {string} prop
-	 * @param {number} index
-	 */
-	remove(parent, prop, index) {
-		if (parent) {
-			if (index !== null) {
-				parent[prop].splice(index, 1);
-			} else {
-				delete parent[prop];
-			}
-		}
-	}
-}
-
-// @ts-check
-
-/** @typedef { import('estree').BaseNode} BaseNode */
-/** @typedef { import('./walker.js').WalkerContext} WalkerContext */
-
-/** @typedef {(
- *    this: WalkerContext,
- *    node: BaseNode,
- *    parent: BaseNode,
- *    key: string,
- *    index: number
- * ) => void} SyncHandler */
-
-class SyncWalker extends WalkerBase {
-	/**
-	 *
-	 * @param {SyncHandler} enter
-	 * @param {SyncHandler} leave
-	 */
-	constructor(enter, leave) {
-		super();
-
-		/** @type {SyncHandler} */
-		this.enter = enter;
-
-		/** @type {SyncHandler} */
-		this.leave = leave;
-	}
-
-	/**
-	 *
-	 * @param {BaseNode} node
-	 * @param {BaseNode} parent
-	 * @param {string} [prop]
-	 * @param {number} [index]
-	 * @returns {BaseNode}
-	 */
-	visit(node, parent, prop, index) {
-		if (node) {
-			if (this.enter) {
-				const _should_skip = this.should_skip;
-				const _should_remove = this.should_remove;
-				const _replacement = this.replacement;
-				this.should_skip = false;
-				this.should_remove = false;
-				this.replacement = null;
-
-				this.enter.call(this.context, node, parent, prop, index);
-
-				if (this.replacement) {
-					node = this.replacement;
-					this.replace(parent, prop, index, node);
-				}
-
-				if (this.should_remove) {
-					this.remove(parent, prop, index);
-				}
-
-				const skipped = this.should_skip;
-				const removed = this.should_remove;
-
-				this.should_skip = _should_skip;
-				this.should_remove = _should_remove;
-				this.replacement = _replacement;
-
-				if (skipped) return node;
-				if (removed) return null;
-			}
-
-			for (const key in node) {
-				const value = node[key];
-
-				if (typeof value !== "object") {
-					continue;
-				} else if (Array.isArray(value)) {
-					for (let i = 0; i < value.length; i += 1) {
-						if (value[i] !== null && typeof value[i].type === 'string') {
-							if (!this.visit(value[i], node, key, i)) {
-								// removed
-								i--;
-							}
-						}
-					}
-				} else if (value !== null && typeof value.type === "string") {
-					this.visit(value, node, key, null);
-				}
-			}
-
-			if (this.leave) {
-				const _replacement = this.replacement;
-				const _should_remove = this.should_remove;
-				this.replacement = null;
-				this.should_remove = false;
-
-				this.leave.call(this.context, node, parent, prop, index);
-
-				if (this.replacement) {
-					node = this.replacement;
-					this.replace(parent, prop, index, node);
-				}
-
-				if (this.should_remove) {
-					this.remove(parent, prop, index);
-				}
-
-				const removed = this.should_remove;
-
-				this.replacement = _replacement;
-				this.should_remove = _should_remove;
-
-				if (removed) return null;
-			}
-		}
-
-		return node;
-	}
-}
-
-// @ts-check
-
-/** @typedef { import('estree').BaseNode} BaseNode */
-/** @typedef { import('./sync.js').SyncHandler} SyncHandler */
-/** @typedef { import('./async.js').AsyncHandler} AsyncHandler */
-
-/**
- *
- * @param {BaseNode} ast
- * @param {{
- *   enter?: SyncHandler
- *   leave?: SyncHandler
- * }} walker
- * @returns {BaseNode}
- */
-function walk(ast, { enter, leave }) {
-	const instance = new SyncWalker(enter, leave);
-	return instance.visit(ast, null);
-}
-
-const extractors = {
-    ArrayPattern(names, param) {
-        for (const element of param.elements) {
-            if (element)
-                extractors[element.type](names, element);
-        }
-    },
-    AssignmentPattern(names, param) {
-        extractors[param.left.type](names, param.left);
-    },
-    Identifier(names, param) {
-        names.push(param.name);
-    },
-    MemberExpression() { },
-    ObjectPattern(names, param) {
-        for (const prop of param.properties) {
-            // @ts-ignore Typescript reports that this is not a valid type
-            if (prop.type === 'RestElement') {
-                extractors.RestElement(names, prop);
-            }
-            else {
-                extractors[prop.value.type](names, prop.value);
-            }
-        }
-    },
-    RestElement(names, param) {
-        extractors[param.argument.type](names, param.argument);
-    }
-};
-const extractAssignedNames = function extractAssignedNames(param) {
-    const names = [];
-    extractors[param.type](names, param);
-    return names;
-};
-
-const blockDeclarations = {
-    const: true,
-    let: true
-};
-class Scope {
-    constructor(options = {}) {
-        this.parent = options.parent;
-        this.isBlockScope = !!options.block;
-        this.declarations = Object.create(null);
-        if (options.params) {
-            options.params.forEach((param) => {
-                extractAssignedNames(param).forEach((name) => {
-                    this.declarations[name] = true;
-                });
-            });
-        }
-    }
-    addDeclaration(node, isBlockDeclaration, isVar) {
-        if (!isBlockDeclaration && this.isBlockScope) {
-            // it's a `var` or function node, and this
-            // is a block scope, so we need to go up
-            this.parent.addDeclaration(node, isBlockDeclaration, isVar);
-        }
-        else if (node.id) {
-            extractAssignedNames(node.id).forEach((name) => {
-                this.declarations[name] = true;
-            });
-        }
-    }
-    contains(name) {
-        return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);
-    }
-}
-const attachScopes = function attachScopes(ast, propertyName = 'scope') {
-    let scope = new Scope();
-    walk(ast, {
-        enter(n, parent) {
-            const node = n;
-            // function foo () {...}
-            // class Foo {...}
-            if (/(?:Function|Class)Declaration/.test(node.type)) {
-                scope.addDeclaration(node, false, false);
-            }
-            // var foo = 1
-            if (node.type === 'VariableDeclaration') {
-                const { kind } = node;
-                const isBlockDeclaration = blockDeclarations[kind];
-                node.declarations.forEach((declaration) => {
-                    scope.addDeclaration(declaration, isBlockDeclaration, true);
-                });
-            }
-            let newScope;
-            // create new function scope
-            if (node.type.includes('Function')) {
-                const func = node;
-                newScope = new Scope({
-                    parent: scope,
-                    block: false,
-                    params: func.params
-                });
-                // named function expressions - the name is considered
-                // part of the function's scope
-                if (func.type === 'FunctionExpression' && func.id) {
-                    newScope.addDeclaration(func, false, false);
-                }
-            }
-            // create new for scope
-            if (/For(?:In|Of)?Statement/.test(node.type)) {
-                newScope = new Scope({
-                    parent: scope,
-                    block: true
-                });
-            }
-            // create new block scope
-            if (node.type === 'BlockStatement' && !parent.type.includes('Function')) {
-                newScope = new Scope({
-                    parent: scope,
-                    block: true
-                });
-            }
-            // catch clause has its own block scope
-            if (node.type === 'CatchClause') {
-                newScope = new Scope({
-                    parent: scope,
-                    params: node.param ? [node.param] : [],
-                    block: true
-                });
-            }
-            if (newScope) {
-                Object.defineProperty(node, propertyName, {
-                    value: newScope,
-                    configurable: true
-                });
-                scope = newScope;
-            }
-        },
-        leave(n) {
-            const node = n;
-            if (node[propertyName])
-                scope = scope.parent;
-        }
-    });
-    return scope;
-};
-
-// Helper since Typescript can't detect readonly arrays with Array.isArray
-function isArray$1(arg) {
-    return Array.isArray(arg);
-}
-function ensureArray(thing) {
-    if (isArray$1(thing))
-        return thing;
-    if (thing == null)
-        return [];
-    return [thing];
-}
-
-const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
-const normalizePath$2 = function normalizePath(filename) {
-    return filename.replace(normalizePathRegExp, posix.sep);
-};
-
-function getMatcherString$2(id, resolutionBase) {
-    if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
-        return normalizePath$2(id);
-    }
-    // resolve('') is valid and will default to process.cwd()
-    const basePath = normalizePath$2(resolve$1(resolutionBase || ''))
-        // escape all possible (posix + win) path characters that might interfere with regex
-        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
-    // Note that we use posix.join because:
-    // 1. the basePath has been normalized to use /
-    // 2. the incoming glob (id) matcher, also uses /
-    // otherwise Node will force backslash (\) on windows
-    return posix.join(basePath, normalizePath$2(id));
-}
-const createFilter$2 = function createFilter(include, exclude, options) {
-    const resolutionBase = options && options.resolve;
-    const getMatcher = (id) => id instanceof RegExp
-        ? id
-        : {
-            test: (what) => {
-                // this refactor is a tad overly verbose but makes for easy debugging
-                const pattern = getMatcherString$2(id, resolutionBase);
-                const fn = pm(pattern, { dot: true });
-                const result = fn(what);
-                return result;
-            }
-        };
-    const includeMatchers = ensureArray(include).map(getMatcher);
-    const excludeMatchers = ensureArray(exclude).map(getMatcher);
-    if (!includeMatchers.length && !excludeMatchers.length)
-        return (id) => typeof id === 'string' && !id.includes('\0');
-    return function result(id) {
-        if (typeof id !== 'string')
-            return false;
-        if (id.includes('\0'))
-            return false;
-        const pathId = normalizePath$2(id);
-        for (let i = 0; i < excludeMatchers.length; ++i) {
-            const matcher = excludeMatchers[i];
-            if (matcher instanceof RegExp) {
-                matcher.lastIndex = 0;
-            }
-            if (matcher.test(pathId))
-                return false;
-        }
-        for (let i = 0; i < includeMatchers.length; ++i) {
-            const matcher = includeMatchers[i];
-            if (matcher instanceof RegExp) {
-                matcher.lastIndex = 0;
-            }
-            if (matcher.test(pathId))
-                return true;
-        }
-        return !includeMatchers.length;
-    };
-};
-
-const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
-const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
-const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
-forbiddenIdentifiers.add('');
-const makeLegalIdentifier = function makeLegalIdentifier(str) {
-    let identifier = str
-        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
-        .replace(/[^$_a-zA-Z0-9]/g, '_');
-    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
-        identifier = `_${identifier}`;
-    }
-    return identifier || '_';
-};
-
-function stringify(obj) {
-    return (JSON.stringify(obj) || 'undefined').replace(/[\u2028\u2029]/g, (char) => `\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
-}
-function serializeArray(arr, indent, baseIndent) {
-    let output = '[';
-    const separator = indent ? `\n${baseIndent}${indent}` : '';
-    for (let i = 0; i < arr.length; i++) {
-        const key = arr[i];
-        output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;
-    }
-    return `${output}${indent ? `\n${baseIndent}` : ''}]`;
-}
-function serializeObject(obj, indent, baseIndent) {
-    let output = '{';
-    const separator = indent ? `\n${baseIndent}${indent}` : '';
-    const entries = Object.entries(obj);
-    for (let i = 0; i < entries.length; i++) {
-        const [key, value] = entries[i];
-        const stringKey = makeLegalIdentifier(key) === key ? key : stringify(key);
-        output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(value, indent, baseIndent + indent)}`;
-    }
-    return `${output}${indent ? `\n${baseIndent}` : ''}}`;
-}
-function serialize(obj, indent, baseIndent) {
-    if (typeof obj === 'object' && obj !== null) {
-        if (Array.isArray(obj))
-            return serializeArray(obj, indent, baseIndent);
-        if (obj instanceof Date)
-            return `new Date(${obj.getTime()})`;
-        if (obj instanceof RegExp)
-            return obj.toString();
-        return serializeObject(obj, indent, baseIndent);
-    }
-    if (typeof obj === 'number') {
-        if (obj === Infinity)
-            return 'Infinity';
-        if (obj === -Infinity)
-            return '-Infinity';
-        if (obj === 0)
-            return 1 / obj === Infinity ? '0' : '-0';
-        if (obj !== obj)
-            return 'NaN'; // eslint-disable-line no-self-compare
-    }
-    if (typeof obj === 'symbol') {
-        const key = Symbol.keyFor(obj);
-        // eslint-disable-next-line no-undefined
-        if (key !== undefined)
-            return `Symbol.for(${stringify(key)})`;
-    }
-    if (typeof obj === 'bigint')
-        return `${obj}n`;
-    return stringify(obj);
-}
-// isWellFormed exists from Node.js 20
-const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
-function isWellFormedString(input) {
-    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
-    if (hasStringIsWellFormed)
-        return input.isWellFormed();
-    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
-    return !/\p{Surrogate}/u.test(input);
-}
-const dataToEsm = function dataToEsm(data, options = {}) {
-    var _a, _b;
-    const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
-    const _ = options.compact ? '' : ' ';
-    const n = options.compact ? '' : '\n';
-    const declarationType = options.preferConst ? 'const' : 'var';
-    if (options.namedExports === false ||
-        typeof data !== 'object' ||
-        Array.isArray(data) ||
-        data instanceof Date ||
-        data instanceof RegExp ||
-        data === null) {
-        const code = serialize(data, options.compact ? null : t, '');
-        const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
-        return `export default${magic}${code};`;
-    }
-    let maxUnderbarPrefixLength = 0;
-    for (const key of Object.keys(data)) {
-        const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
-        if (underbarPrefixLength > maxUnderbarPrefixLength) {
-            maxUnderbarPrefixLength = underbarPrefixLength;
-        }
-    }
-    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
-    let namedExportCode = '';
-    const defaultExportRows = [];
-    const arbitraryNameExportRows = [];
-    for (const [key, value] of Object.entries(data)) {
-        if (key === makeLegalIdentifier(key)) {
-            if (options.objectShorthand)
-                defaultExportRows.push(key);
-            else
-                defaultExportRows.push(`${key}:${_}${key}`);
-            namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
-        }
-        else {
-            defaultExportRows.push(`${stringify(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
-            if (options.includeArbitraryNames && isWellFormedString(key)) {
-                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
-                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
-                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
-            }
-        }
-    }
-    const arbitraryExportCode = arbitraryNameExportRows.length > 0
-        ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}`
-        : '';
-    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
-    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
-};
-
-function escape(str) {
-  return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
-}
-
-function ensureFunction(functionOrValue) {
-  if (typeof functionOrValue === 'function') { return functionOrValue; }
-  return function () { return functionOrValue; };
-}
-
-function longest(a, b) {
-  return b.length - a.length;
-}
-
-function getReplacements(options) {
-  if (options.values) {
-    return Object.assign({}, options.values);
-  }
-  var values = Object.assign({}, options);
-  delete values.delimiters;
-  delete values.include;
-  delete values.exclude;
-  delete values.sourcemap;
-  delete values.sourceMap;
-  delete values.objectGuards;
-  delete values.preventAssignment;
-  return values;
-}
-
-function mapToFunctions(object) {
-  return Object.keys(object).reduce(function (fns, key) {
-    var functions = Object.assign({}, fns);
-    functions[key] = ensureFunction(object[key]);
-    return functions;
-  }, {});
-}
-
-var objKeyRegEx =
-  /^([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)(\.([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))+$/;
-function expandTypeofReplacements(replacements) {
-  Object.keys(replacements).forEach(function (key) {
-    var objMatch = key.match(objKeyRegEx);
-    if (!objMatch) { return; }
-    var dotIndex = objMatch[1].length;
-    do {
-      // eslint-disable-next-line no-param-reassign
-      replacements[("typeof " + (key.slice(0, dotIndex)))] = '"object"';
-      dotIndex = key.indexOf('.', dotIndex + 1);
-    } while (dotIndex !== -1);
-  });
-}
-
-function replace$1(options) {
-  if ( options === void 0 ) options = {};
-
-  var filter = createFilter$2(options.include, options.exclude);
-  var delimiters = options.delimiters; if ( delimiters === void 0 ) delimiters = ['\\b', '\\b(?!\\.)'];
-  var preventAssignment = options.preventAssignment;
-  var objectGuards = options.objectGuards;
-  var replacements = getReplacements(options);
-  if (objectGuards) { expandTypeofReplacements(replacements); }
-  var functionValues = mapToFunctions(replacements);
-  var keys = Object.keys(functionValues).sort(longest).map(escape);
-  var lookbehind = preventAssignment ? '(?<!\\b(?:const|let|var)\\s*)' : '';
-  var lookahead = preventAssignment ? '(?!\\s*=[^=])' : '';
-  var pattern = new RegExp(
-    ("" + lookbehind + (delimiters[0]) + "(" + (keys.join('|')) + ")" + (delimiters[1]) + lookahead),
-    'g'
-  );
-
-  return {
-    name: 'replace',
-
-    buildStart: function buildStart() {
-      if (![true, false].includes(preventAssignment)) {
-        this.warn({
-          message:
-            "@rollup/plugin-replace: 'preventAssignment' currently defaults to false. It is recommended to set this option to `true`, as the next major version will default this option to `true`."
-        });
-      }
-    },
-
-    renderChunk: function renderChunk(code, chunk) {
-      var id = chunk.fileName;
-      if (!keys.length) { return null; }
-      if (!filter(id)) { return null; }
-      return executeReplacement(code, id);
-    },
-
-    transform: function transform(code, id) {
-      if (!keys.length) { return null; }
-      if (!filter(id)) { return null; }
-      return executeReplacement(code, id);
-    }
-  };
-
-  function executeReplacement(code, id) {
-    var magicString = new MagicString(code);
-    if (!codeHasReplacements(code, id, magicString)) {
-      return null;
-    }
-
-    var result = { code: magicString.toString() };
-    if (isSourceMapEnabled()) {
-      result.map = magicString.generateMap({ hires: true });
-    }
-    return result;
-  }
-
-  function codeHasReplacements(code, id, magicString) {
-    var result = false;
-    var match;
-
-    // eslint-disable-next-line no-cond-assign
-    while ((match = pattern.exec(code))) {
-      result = true;
-
-      var start = match.index;
-      var end = start + match[0].length;
-      var replacement = String(functionValues[match[1]](id));
-      magicString.overwrite(start, end, replacement);
-    }
-    return result;
-  }
-
-  function isSourceMapEnabled() {
-    return options.sourceMap !== false && options.sourcemap !== false;
-  }
-}
-
-const NO_REPLACE_RE = /ROLLUP_NO_REPLACE|\\0raw:/;
-function replace(options) {
-  const _plugin = replace$1(options);
-  return {
-    ..._plugin,
-    // https://github.com/rollup/plugins/blob/master/packages/replace/src/index.js#L94
-    renderChunk(code, chunk, options2) {
-      if (!NO_REPLACE_RE.test(code)) {
-        return _plugin.renderChunk.call(this, code, chunk, options2);
-      }
-    }
-  };
-}
-
-function baseBuildConfig(nitro) {
-  const buildServerDir = join(nitro.options.buildDir, "dist/server");
-  const presetsDir = resolve$2(runtimeDir, "../presets");
-  const extensions = [".ts", ".mjs", ".js", ".json", ".node", ".tsx", ".jsx"];
-  const isNodeless = nitro.options.node === false;
-  let NODE_ENV = nitro.options.dev ? "development" : "production";
-  if (nitro.options.preset === "nitro-prerender") {
-    NODE_ENV = "prerender";
-  }
-  const buildEnvVars = {
-    NODE_ENV,
-    prerender: nitro.options.preset === "nitro-prerender",
-    server: true,
-    client: false,
-    dev: String(nitro.options.dev),
-    DEBUG: nitro.options.dev
-  };
-  const staticFlags = {
-    dev: nitro.options.dev,
-    preset: nitro.options.preset,
-    prerender: nitro.options.preset === "nitro-prerender",
-    server: true,
-    client: false,
-    nitro: true,
-    baseURL: nitro.options.baseURL,
-    // @ts-expect-error
-    "versions.nitro": "",
-    "versions?.nitro": "",
-    // Internal
-    _asyncContext: nitro.options.experimental.asyncContext,
-    _websocket: nitro.options.experimental.websocket,
-    _tasks: nitro.options.experimental.tasks
-  };
-  const replacements = {
-    "typeof window": '"undefined"',
-    _import_meta_url_: "import.meta.url",
-    "globalThis.process.": "process.",
-    "process.env.RUNTIME_CONFIG": () => JSON.stringify(nitro.options.runtimeConfig, null, 2),
-    ...Object.fromEntries(
-      Object.entries(buildEnvVars).map(([key, val]) => [
-        `process.env.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(buildEnvVars).map(([key, val]) => [
-        `import.meta.env.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(staticFlags).map(([key, val]) => [
-        `process.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...Object.fromEntries(
-      Object.entries(staticFlags).map(([key, val]) => [
-        `import.meta.${key}`,
-        JSON.stringify(val)
-      ])
-    ),
-    ...nitro.options.replace
-  };
-  const { env } = defineEnv({
-    nodeCompat: isNodeless,
-    npmShims: true,
-    resolve: true,
-    presets: nitro.options.unenv,
-    overrides: {
-      alias: nitro.options.alias
-    }
-  });
-  const aliases = resolveAliases({
-    "#internal/nitro": runtimeDir,
-    "nitro/runtime": runtimeDir,
-    "nitropack/runtime": runtimeDir,
-    // Backwards compatibility
-    ...env.alias
-  });
-  return {
-    buildServerDir,
-    presetsDir,
-    extensions,
-    isNodeless,
-    buildEnvVars,
-    staticFlags,
-    replacements,
-    env,
-    aliases
-  };
-}
-function resolveAliases(_aliases) {
-  const aliases = Object.fromEntries(
-    Object.entries(_aliases).sort(
-      ([a], [b]) => b.split("/").length - a.split("/").length || b.length - a.length
-    )
-  );
-  for (const key in aliases) {
-    for (const alias in aliases) {
-      if (!["~", "@", "#"].includes(alias[0])) {
-        continue;
-      }
-      if (alias === "@" && !aliases[key].startsWith("@/")) {
-        continue;
-      }
-      if (aliases[key].startsWith(alias)) {
-        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
-      }
-    }
-  }
-  return aliases;
-}
-
-//#region src/utils/general.ts
-function toArray$2(array) {
-	array = array || [];
-	if (Array.isArray(array)) return array;
-	return [array];
-}
-
-//#endregion
-//#region src/utils/filter.ts
-const BACKSLASH_REGEX = /\\/g;
-function normalize$1(path$1) {
-	return path$1.replace(BACKSLASH_REGEX, "/");
-}
-const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
-function isAbsolute$1(path$1) {
-	return ABSOLUTE_PATH_REGEX.test(path$1);
-}
-function getMatcherString$1(glob, cwd) {
-	if (glob.startsWith("**") || isAbsolute$1(glob)) return normalize$1(glob);
-	const resolved = resolve$3(cwd, glob);
-	return normalize$1(resolved);
-}
-function patternToIdFilter(pattern) {
-	if (pattern instanceof RegExp) return (id) => {
-		const normalizedId = normalize$1(id);
-		const result = pattern.test(normalizedId);
-		pattern.lastIndex = 0;
-		return result;
-	};
-	const cwd = process.cwd();
-	const glob = getMatcherString$1(pattern, cwd);
-	const matcher = pm(glob, { dot: true });
-	return (id) => {
-		const normalizedId = normalize$1(id);
-		return matcher(normalizedId);
-	};
-}
-function patternToCodeFilter(pattern) {
-	if (pattern instanceof RegExp) return (code) => {
-		const result = pattern.test(code);
-		pattern.lastIndex = 0;
-		return result;
-	};
-	return (code) => code.includes(pattern);
-}
-function createFilter$1(exclude, include) {
-	if (!exclude && !include) return;
-	return (input) => {
-		if (exclude?.some((filter) => filter(input))) return false;
-		if (include?.some((filter) => filter(input))) return true;
-		return !(include && include.length > 0);
-	};
-}
-function normalizeFilter(filter) {
-	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
-	if (Array.isArray(filter)) return { include: filter };
-	return {
-		exclude: filter.exclude ? toArray$2(filter.exclude) : void 0,
-		include: filter.include ? toArray$2(filter.include) : void 0
-	};
-}
-function createIdFilter(filter) {
-	if (!filter) return;
-	const { exclude, include } = normalizeFilter(filter);
-	const excludeFilter = exclude?.map(patternToIdFilter);
-	const includeFilter = include?.map(patternToIdFilter);
-	return createFilter$1(excludeFilter, includeFilter);
-}
-function createCodeFilter(filter) {
-	if (!filter) return;
-	const { exclude, include } = normalizeFilter(filter);
-	const excludeFilter = exclude?.map(patternToCodeFilter);
-	const includeFilter = include?.map(patternToCodeFilter);
-	return createFilter$1(excludeFilter, includeFilter);
-}
-function createFilterForId(filter) {
-	const filterFunction = createIdFilter(filter);
-	return filterFunction ? (id) => !!filterFunction(id) : void 0;
-}
-function createFilterForTransform(idFilter, codeFilter) {
-	if (!idFilter && !codeFilter) return;
-	const idFilterFunction = createIdFilter(idFilter);
-	const codeFilterFunction = createCodeFilter(codeFilter);
-	return (id, code) => {
-		let fallback = true;
-		if (idFilterFunction) fallback &&= idFilterFunction(id);
-		if (!fallback) return false;
-		if (codeFilterFunction) fallback &&= codeFilterFunction(code);
-		return fallback;
-	};
-}
-function normalizeObjectHook(name, hook) {
-	let handler;
-	let filter;
-	if (typeof hook === "function") handler = hook;
-	else {
-		handler = hook.handler;
-		const hookFilter = hook.filter;
-		if (name === "resolveId" || name === "load") filter = createFilterForId(hookFilter?.id);
-		else filter = createFilterForTransform(hookFilter?.id, hookFilter?.code);
-	}
-	return {
-		handler,
-		filter: filter || (() => true)
-	};
-}
-
-//#endregion
-//#region src/utils/context.ts
-function parse$1(code, opts = {}) {
-	return Parser.parse(code, {
-		sourceType: "module",
-		ecmaVersion: "latest",
-		locations: true,
-		...opts
-	});
-}
-
-//#region src/utils/webpack-like.ts
-function transformUse(data, plugin, transformLoader) {
-	if (data.resource == null) return [];
-	const id = normalizeAbsolutePath(data.resource + (data.resourceQuery || ""));
-	if (plugin.transformInclude && !plugin.transformInclude(id)) return [];
-	const { filter } = normalizeObjectHook("load", plugin.transform);
-	if (!filter(id)) return [];
-	return [{
-		loader: transformLoader,
-		options: { plugin },
-		ident: plugin.name
-	}];
-}
-/**
-* Normalizes a given path when it's absolute. Normalizing means returning a new path by converting
-* the input path to the native os format. This is useful in cases where we want to normalize
-* the `id` argument of a hook. Any absolute ids should be in the default format
-* of the operating system. Any relative imports or node_module imports should remain
-* untouched.
-*
-* @param path - Path to normalize.
-* @returns a new normalized path.
-*/
-function normalizeAbsolutePath(path$1) {
-	if (isAbsolute$2(path$1)) return normalize(path$1);
-	else return path$1;
-}
-
-//#region src/rspack/context.ts
-function createBuildContext$1(compiler, compilation, loaderContext) {
-	return {
-		getNativeBuildContext() {
-			return {
-				framework: "rspack",
-				compiler,
-				compilation,
-				loaderContext
-			};
-		},
-		addWatchFile(file) {
-			const cwd = process.cwd();
-			compilation.fileDependencies.add(resolve$3(cwd, file));
-		},
-		getWatchFiles() {
-			return Array.from(compilation.fileDependencies);
-		},
-		parse: parse$1,
-		emitFile(emittedFile) {
-			const outFileName = emittedFile.fileName || emittedFile.name;
-			if (emittedFile.source && outFileName) {
-				const { sources } = compilation.compiler.webpack;
-				compilation.emitAsset(outFileName, new sources.RawSource(typeof emittedFile.source === "string" ? emittedFile.source : Buffer$1.from(emittedFile.source)));
-			}
-		}
-	};
-}
-function normalizeMessage$1(error) {
-	const err = new Error(typeof error === "string" ? error : error.message);
-	if (typeof error === "object") {
-		err.stack = error.stack;
-		err.cause = error.meta;
-	}
-	return err;
-}
-
-//#region src/rspack/utils.ts
-function encodeVirtualModuleId(id, plugin) {
-	return resolve$3(plugin.__virtualModulePrefix, encodeURIComponent(id));
-}
-function decodeVirtualModuleId(encoded, _plugin) {
-	return decodeURIComponent(basename(encoded));
-}
-function isVirtualModuleId(encoded, plugin) {
-	return dirname(encoded) === plugin.__virtualModulePrefix;
-}
-var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin {
-	name = "FakeVirtualModulesPlugin";
-	static counters = /* @__PURE__ */ new Map();
-	static initCleanup = false;
-	constructor(plugin) {
-		this.plugin = plugin;
-		if (!FakeVirtualModulesPlugin.initCleanup) {
-			FakeVirtualModulesPlugin.initCleanup = true;
-			process.once("exit", () => {
-				FakeVirtualModulesPlugin.counters.forEach((_, dir) => {
-					fs.rmSync(dir, {
-						recursive: true,
-						force: true
-					});
-				});
-			});
-		}
-	}
-	apply(compiler) {
-		const dir = this.plugin.__virtualModulePrefix;
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		const counter = FakeVirtualModulesPlugin.counters.get(dir) ?? 0;
-		FakeVirtualModulesPlugin.counters.set(dir, counter + 1);
-		compiler.hooks.shutdown.tap(this.name, () => {
-			const counter$1 = (FakeVirtualModulesPlugin.counters.get(dir) ?? 1) - 1;
-			if (counter$1 === 0) {
-				FakeVirtualModulesPlugin.counters.delete(dir);
-				fs.rmSync(dir, {
-					recursive: true,
-					force: true
-				});
-			} else FakeVirtualModulesPlugin.counters.set(dir, counter$1);
-		});
-	}
-	async writeModule(file) {
-		return fs.promises.writeFile(file, "");
-	}
-};
-
-//#region src/webpack/context.ts
-function contextOptionsFromCompilation(compilation) {
-	return {
-		addWatchFile(file) {
-			(compilation.fileDependencies ?? compilation.compilationDependencies).add(file);
-		},
-		getWatchFiles() {
-			return Array.from(compilation.fileDependencies ?? compilation.compilationDependencies);
-		}
-	};
-}
-const require = createRequire(import.meta.url);
-function getSource(fileSource) {
-	const webpack = require("webpack");
-	return new webpack.sources.RawSource(typeof fileSource === "string" ? fileSource : Buffer$1.from(fileSource.buffer));
-}
-function createBuildContext(options, compiler, compilation, loaderContext) {
-	return {
-		parse: parse$1,
-		addWatchFile(id) {
-			options.addWatchFile(resolve$3(process$1.cwd(), id));
-		},
-		emitFile(emittedFile) {
-			const outFileName = emittedFile.fileName || emittedFile.name;
-			if (emittedFile.source && outFileName) {
-				if (!compilation) throw new Error("unplugin/webpack: emitFile outside supported hooks  (buildStart, buildEnd, load, transform, watchChange)");
-				compilation.emitAsset(outFileName, getSource(emittedFile.source));
-			}
-		},
-		getWatchFiles() {
-			return options.getWatchFiles();
-		},
-		getNativeBuildContext() {
-			return {
-				framework: "webpack",
-				compiler,
-				compilation,
-				loaderContext
-			};
-		}
-	};
-}
-function normalizeMessage(error) {
-	const err = new Error(typeof error === "string" ? error : error.message);
-	if (typeof error === "object") {
-		err.stack = error.stack;
-		err.cause = error.meta;
-	}
-	return err;
-}
-
-// Matches the scheme of a URL, eg "http://"
-const schemeRegex = /^[\w+.-]+:\/\//;
-/**
- * Matches the parts of a URL:
- * 1. Scheme, including ":", guaranteed.
- * 2. User/password, including "@", optional.
- * 3. Host, guaranteed.
- * 4. Port, including ":", optional.
- * 5. Path, including "/", optional.
- * 6. Query, including "?", optional.
- * 7. Hash, including "#", optional.
- */
-const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
-/**
- * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
- * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
- *
- * 1. Host, optional.
- * 2. Path, which may include "/", guaranteed.
- * 3. Query, including "?", optional.
- * 4. Hash, including "#", optional.
- */
-const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-function isAbsoluteUrl(input) {
-    return schemeRegex.test(input);
-}
-function isSchemeRelativeUrl(input) {
-    return input.startsWith('//');
-}
-function isAbsolutePath(input) {
-    return input.startsWith('/');
-}
-function isFileUrl(input) {
-    return input.startsWith('file:');
-}
-function isRelative(input) {
-    return /^[.?#]/.test(input);
-}
-function parseAbsoluteUrl(input) {
-    const match = urlRegex.exec(input);
-    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
-}
-function parseFileUrl(input) {
-    const match = fileRegex.exec(input);
-    const path = match[2];
-    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
-}
-function makeUrl(scheme, user, host, port, path, query, hash) {
-    return {
-        scheme,
-        user,
-        host,
-        port,
-        path,
-        query,
-        hash,
-        type: 7 /* Absolute */,
-    };
-}
-function parseUrl(input) {
-    if (isSchemeRelativeUrl(input)) {
-        const url = parseAbsoluteUrl('http:' + input);
-        url.scheme = '';
-        url.type = 6 /* SchemeRelative */;
-        return url;
-    }
-    if (isAbsolutePath(input)) {
-        const url = parseAbsoluteUrl('http://foo.com' + input);
-        url.scheme = '';
-        url.host = '';
-        url.type = 5 /* AbsolutePath */;
-        return url;
-    }
-    if (isFileUrl(input))
-        return parseFileUrl(input);
-    if (isAbsoluteUrl(input))
-        return parseAbsoluteUrl(input);
-    const url = parseAbsoluteUrl('http://foo.com/' + input);
-    url.scheme = '';
-    url.host = '';
-    url.type = input
-        ? input.startsWith('?')
-            ? 3 /* Query */
-            : input.startsWith('#')
-                ? 2 /* Hash */
-                : 4 /* RelativePath */
-        : 1 /* Empty */;
-    return url;
-}
-function stripPathFilename(path) {
-    // If a path ends with a parent directory "..", then it's a relative path with excess parent
-    // paths. It's not a file, so we can't strip it.
-    if (path.endsWith('/..'))
-        return path;
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-function mergePaths(url, base) {
-    normalizePath$1(base, base.type);
-    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
-    // path).
-    if (url.path === '/') {
-        url.path = base.path;
-    }
-    else {
-        // Resolution happens relative to the base path's directory, not the file.
-        url.path = stripPathFilename(base.path) + url.path;
-    }
-}
-/**
- * The path can have empty directories "//", unneeded parents "foo/..", or current directory
- * "foo/.". We need to normalize to a standard representation.
- */
-function normalizePath$1(url, type) {
-    const rel = type <= 4 /* RelativePath */;
-    const pieces = url.path.split('/');
-    // We need to preserve the first piece always, so that we output a leading slash. The item at
-    // pieces[0] is an empty string.
-    let pointer = 1;
-    // Positive is the number of real directories we've output, used for popping a parent directory.
-    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
-    let positive = 0;
-    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
-    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
-    // real directory, we won't need to append, unless the other conditions happen again.
-    let addTrailingSlash = false;
-    for (let i = 1; i < pieces.length; i++) {
-        const piece = pieces[i];
-        // An empty directory, could be a trailing slash, or just a double "//" in the path.
-        if (!piece) {
-            addTrailingSlash = true;
-            continue;
-        }
-        // If we encounter a real directory, then we don't need to append anymore.
-        addTrailingSlash = false;
-        // A current directory, which we can always drop.
-        if (piece === '.')
-            continue;
-        // A parent directory, we need to see if there are any real directories we can pop. Else, we
-        // have an excess of parents, and we'll need to keep the "..".
-        if (piece === '..') {
-            if (positive) {
-                addTrailingSlash = true;
-                positive--;
-                pointer--;
-            }
-            else if (rel) {
-                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
-                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
-                pieces[pointer++] = piece;
-            }
-            continue;
-        }
-        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
-        // any popped or dropped directories.
-        pieces[pointer++] = piece;
-        positive++;
-    }
-    let path = '';
-    for (let i = 1; i < pointer; i++) {
-        path += '/' + pieces[i];
-    }
-    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
-        path += '/';
-    }
-    url.path = path;
-}
-/**
- * Attempts to resolve `input` URL/path relative to `base`.
- */
-function resolve(input, base) {
-    if (!input && !base)
-        return '';
-    const url = parseUrl(input);
-    let inputType = url.type;
-    if (base && inputType !== 7 /* Absolute */) {
-        const baseUrl = parseUrl(base);
-        const baseType = baseUrl.type;
-        switch (inputType) {
-            case 1 /* Empty */:
-                url.hash = baseUrl.hash;
-            // fall through
-            case 2 /* Hash */:
-                url.query = baseUrl.query;
-            // fall through
-            case 3 /* Query */:
-            case 4 /* RelativePath */:
-                mergePaths(url, baseUrl);
-            // fall through
-            case 5 /* AbsolutePath */:
-                // The host, user, and port are joined, you can't copy one without the others.
-                url.user = baseUrl.user;
-                url.host = baseUrl.host;
-                url.port = baseUrl.port;
-            // fall through
-            case 6 /* SchemeRelative */:
-                // The input doesn't have a schema at least, so we need to copy at least that over.
-                url.scheme = baseUrl.scheme;
-        }
-        if (baseType > inputType)
-            inputType = baseType;
-    }
-    normalizePath$1(url, inputType);
-    const queryHash = url.query + url.hash;
-    switch (inputType) {
-        // This is impossible, because of the empty checks at the start of the function.
-        // case UrlType.Empty:
-        case 2 /* Hash */:
-        case 3 /* Query */:
-            return queryHash;
-        case 4 /* RelativePath */: {
-            // The first char is always a "/", and we need it to be relative.
-            const path = url.path.slice(1);
-            if (!path)
-                return queryHash || '.';
-            if (isRelative(base || input) && !isRelative(path)) {
-                // If base started with a leading ".", or there is no base and input started with a ".",
-                // then we need to ensure that the relative path starts with a ".". We don't know if
-                // relative starts with a "..", though, so check before prepending.
-                return './' + path + queryHash;
-            }
-            return path + queryHash;
-        }
-        case 5 /* AbsolutePath */:
-            return url.path + queryHash;
-        default:
-            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
-    }
-}
-
-// src/trace-mapping.ts
-
-// src/strip-filename.ts
-function stripFilename(path) {
-  if (!path) return "";
-  const index = path.lastIndexOf("/");
-  return path.slice(0, index + 1);
-}
-
-// src/resolve.ts
-function resolver(mapUrl, sourceRoot) {
-  const from = stripFilename(mapUrl);
-  const prefix = sourceRoot ? sourceRoot + "/" : "";
-  return (source) => resolve(prefix + (source || ""), from);
-}
-
-// src/sourcemap-segment.ts
-var COLUMN$1 = 0;
-
-// src/sort.ts
-function maybeSort(mappings, owned) {
-  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-  if (unsortedIndex === mappings.length) return mappings;
-  if (!owned) mappings = mappings.slice();
-  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-    mappings[i] = sortSegments(mappings[i], owned);
-  }
-  return mappings;
-}
-function nextUnsortedSegmentLine(mappings, start) {
-  for (let i = start; i < mappings.length; i++) {
-    if (!isSorted(mappings[i])) return i;
-  }
-  return mappings.length;
-}
-function isSorted(line) {
-  for (let j = 1; j < line.length; j++) {
-    if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) {
-      return false;
-    }
-  }
-  return true;
-}
-function sortSegments(line, owned) {
-  if (!owned) line = line.slice();
-  return line.sort(sortComparator);
-}
-function sortComparator(a, b) {
-  return a[COLUMN$1] - b[COLUMN$1];
-}
-
-// src/binary-search.ts
-var found = false;
-function binarySearch(haystack, needle, low, high) {
-  while (low <= high) {
-    const mid = low + (high - low >> 1);
-    const cmp = haystack[mid][COLUMN$1] - needle;
-    if (cmp === 0) {
-      found = true;
-      return mid;
-    }
-    if (cmp < 0) {
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-  found = false;
-  return low - 1;
-}
-function lowerBound(haystack, needle, index) {
-  for (let i = index - 1; i >= 0; index = i--) {
-    if (haystack[i][COLUMN$1] !== needle) break;
-  }
-  return index;
-}
-function memoizedState() {
-  return {
-    lastKey: -1,
-    lastNeedle: -1,
-    lastIndex: -1
-  };
-}
-function memoizedBinarySearch(haystack, needle, state, key) {
-  const { lastKey, lastNeedle, lastIndex } = state;
-  let low = 0;
-  let high = haystack.length - 1;
-  if (key === lastKey) {
-    if (needle === lastNeedle) {
-      found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
-      return lastIndex;
-    }
-    if (needle >= lastNeedle) {
-      low = lastIndex === -1 ? 0 : lastIndex;
-    } else {
-      high = lastIndex;
-    }
-  }
-  state.lastKey = key;
-  state.lastNeedle = needle;
-  return state.lastIndex = binarySearch(haystack, needle, low, high);
-}
-
-// src/types.ts
-function parse(map) {
-  return typeof map === "string" ? JSON.parse(map) : map;
-}
-var TraceMap = class {
-  constructor(map, mapUrl) {
-    const isString = typeof map === "string";
-    if (!isString && map._decodedMemo) return map;
-    const parsed = parse(map);
-    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-    this.version = version;
-    this.file = file;
-    this.names = names || [];
-    this.sourceRoot = sourceRoot;
-    this.sources = sources;
-    this.sourcesContent = sourcesContent;
-    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
-    const resolve = resolver(mapUrl, sourceRoot);
-    this.resolvedSources = sources.map(resolve);
-    const { mappings } = parsed;
-    if (typeof mappings === "string") {
-      this._encoded = mappings;
-      this._decoded = void 0;
-    } else if (Array.isArray(mappings)) {
-      this._encoded = void 0;
-      this._decoded = maybeSort(mappings, isString);
-    } else if (parsed.sections) {
-      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
-    } else {
-      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
-    }
-    this._decodedMemo = memoizedState();
-    this._bySources = void 0;
-    this._bySourceMemos = void 0;
-  }
-};
-function cast$1(map) {
-  return map;
-}
-function decodedMappings(map) {
-  var _a;
-  return (_a = cast$1(map))._decoded || (_a._decoded = decode(cast$1(map)._encoded));
-}
-function traceSegment(map, line, column) {
-  const decoded = decodedMappings(map);
-  if (line >= decoded.length) return null;
-  const segments = decoded[line];
-  const index = traceSegmentInternal(
-    segments,
-    cast$1(map)._decodedMemo,
-    line,
-    column);
-  return index === -1 ? null : segments[index];
-}
-function traceSegmentInternal(segments, memo, line, column, bias) {
-  let index = memoizedBinarySearch(segments, column, memo, line);
-  if (found) {
-    index = (lowerBound)(segments, column, index);
-  }
-  if (index === -1 || index === segments.length) return -1;
-  return index;
-}
-
-// src/set-array.ts
-var SetArray = class {
-  constructor() {
-    this._indexes = { __proto__: null };
-    this.array = [];
-  }
-};
-function cast(set) {
-  return set;
-}
-function get(setarr, key) {
-  return cast(setarr)._indexes[key];
-}
-function put(setarr, key) {
-  const index = get(setarr, key);
-  if (index !== void 0) return index;
-  const { array, _indexes: indexes } = cast(setarr);
-  const length = array.push(key);
-  return indexes[key] = length - 1;
-}
-function remove(setarr, key) {
-  const index = get(setarr, key);
-  if (index === void 0) return;
-  const { array, _indexes: indexes } = cast(setarr);
-  for (let i = index + 1; i < array.length; i++) {
-    const k = array[i];
-    array[i - 1] = k;
-    indexes[k]--;
-  }
-  indexes[key] = void 0;
-  array.pop();
-}
-
-// src/sourcemap-segment.ts
-var COLUMN = 0;
-var SOURCES_INDEX = 1;
-var SOURCE_LINE = 2;
-var SOURCE_COLUMN = 3;
-var NAMES_INDEX = 4;
-
-// src/gen-mapping.ts
-var NO_NAME = -1;
-var GenMapping = class {
-  constructor({ file, sourceRoot } = {}) {
-    this._names = new SetArray();
-    this._sources = new SetArray();
-    this._sourcesContent = [];
-    this._mappings = [];
-    this.file = file;
-    this.sourceRoot = sourceRoot;
-    this._ignoreList = new SetArray();
-  }
-};
-function cast2(map) {
-  return map;
-}
-var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
-  return addSegmentInternal(
-    true,
-    map,
-    genLine,
-    genColumn,
-    source,
-    sourceLine,
-    sourceColumn,
-    name);
-};
-function setSourceContent(map, source, content) {
-  const {
-    _sources: sources,
-    _sourcesContent: sourcesContent
-    // _originalScopes: originalScopes,
-  } = cast2(map);
-  const index = put(sources, source);
-  sourcesContent[index] = content;
-}
-function setIgnore(map, source, ignore = true) {
-  const {
-    _sources: sources,
-    _sourcesContent: sourcesContent,
-    _ignoreList: ignoreList
-    // _originalScopes: originalScopes,
-  } = cast2(map);
-  const index = put(sources, source);
-  if (index === sourcesContent.length) sourcesContent[index] = null;
-  if (ignore) put(ignoreList, index);
-  else remove(ignoreList, index);
-}
-function toDecodedMap(map) {
-  const {
-    _mappings: mappings,
-    _sources: sources,
-    _sourcesContent: sourcesContent,
-    _names: names,
-    _ignoreList: ignoreList
-    // _originalScopes: originalScopes,
-    // _generatedRanges: generatedRanges,
-  } = cast2(map);
-  removeEmptyFinalLines(mappings);
-  return {
-    version: 3,
-    file: map.file || void 0,
-    names: names.array,
-    sourceRoot: map.sourceRoot || void 0,
-    sources: sources.array,
-    sourcesContent,
-    mappings,
-    // originalScopes,
-    // generatedRanges,
-    ignoreList: ignoreList.array
-  };
-}
-function toEncodedMap(map) {
-  const decoded = toDecodedMap(map);
-  return Object.assign({}, decoded, {
-    // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
-    // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
-    mappings: encode(decoded.mappings)
-  });
-}
-function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
-  const {
-    _mappings: mappings,
-    _sources: sources,
-    _sourcesContent: sourcesContent,
-    _names: names
-    // _originalScopes: originalScopes,
-  } = cast2(map);
-  const line = getIndex(mappings, genLine);
-  const index = getColumnIndex(line, genColumn);
-  if (!source) {
-    if (skipSourceless(line, index)) return;
-    return insert(line, index, [genColumn]);
-  }
-  const sourcesIndex = put(sources, source);
-  const namesIndex = name ? put(names, name) : NO_NAME;
-  if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = null;
-  if (skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
-    return;
-  }
-  return insert(
-    line,
-    index,
-    name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
-  );
-}
-function getIndex(arr, index) {
-  for (let i = arr.length; i <= index; i++) {
-    arr[i] = [];
-  }
-  return arr[index];
-}
-function getColumnIndex(line, genColumn) {
-  let index = line.length;
-  for (let i = index - 1; i >= 0; index = i--) {
-    const current = line[i];
-    if (genColumn >= current[COLUMN]) break;
-  }
-  return index;
-}
-function insert(array, index, value) {
-  for (let i = array.length; i > index; i--) {
-    array[i] = array[i - 1];
-  }
-  array[index] = value;
-}
-function removeEmptyFinalLines(mappings) {
-  const { length } = mappings;
-  let len = length;
-  for (let i = len - 1; i >= 0; len = i, i--) {
-    if (mappings[i].length > 0) break;
-  }
-  if (len < length) mappings.length = len;
-}
-function skipSourceless(line, index) {
-  if (index === 0) return true;
-  const prev = line[index - 1];
-  return prev.length === 1;
-}
-function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
-  if (index === 0) return false;
-  const prev = line[index - 1];
-  if (prev.length === 1) return false;
-  return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
-}
-
-// src/build-source-map-tree.ts
-var SOURCELESS_MAPPING = /* @__PURE__ */ SegmentObject("", -1, -1, "", null, false);
-var EMPTY_SOURCES = [];
-function SegmentObject(source, line, column, name, content, ignore) {
-  return { source, line, column, name, content, ignore };
-}
-function Source(map, sources, source, content, ignore) {
-  return {
-    map,
-    sources,
-    source,
-    content,
-    ignore
-  };
-}
-function MapSource(map, sources) {
-  return Source(map, sources, "", null, false);
-}
-function OriginalSource(source, content, ignore) {
-  return Source(null, EMPTY_SOURCES, source, content, ignore);
-}
-function traceMappings(tree) {
-  const gen = new GenMapping({ file: tree.map.file });
-  const { sources: rootSources, map } = tree;
-  const rootNames = map.names;
-  const rootMappings = decodedMappings(map);
-  for (let i = 0; i < rootMappings.length; i++) {
-    const segments = rootMappings[i];
-    for (let j = 0; j < segments.length; j++) {
-      const segment = segments[j];
-      const genCol = segment[0];
-      let traced = SOURCELESS_MAPPING;
-      if (segment.length !== 1) {
-        const source2 = rootSources[segment[1]];
-        traced = originalPositionFor(
-          source2,
-          segment[2],
-          segment[3],
-          segment.length === 5 ? rootNames[segment[4]] : ""
-        );
-        if (traced == null) continue;
-      }
-      const { column, line, name, content, source, ignore } = traced;
-      maybeAddSegment(gen, i, genCol, source, line, column, name);
-      if (source && content != null) setSourceContent(gen, source, content);
-      if (ignore) setIgnore(gen, source, true);
-    }
-  }
-  return gen;
-}
-function originalPositionFor(source, line, column, name) {
-  if (!source.map) {
-    return SegmentObject(source.source, line, column, name, source.content, source.ignore);
-  }
-  const segment = traceSegment(source.map, line, column);
-  if (segment == null) return null;
-  if (segment.length === 1) return SOURCELESS_MAPPING;
-  return originalPositionFor(
-    source.sources[segment[1]],
-    segment[2],
-    segment[3],
-    segment.length === 5 ? source.map.names[segment[4]] : name
-  );
-}
-
-// src/build-source-map-tree.ts
-function asArray(value) {
-  if (Array.isArray(value)) return value;
-  return [value];
-}
-function buildSourceMapTree(input, loader) {
-  const maps = asArray(input).map((m) => new TraceMap(m, ""));
-  const map = maps.pop();
-  for (let i = 0; i < maps.length; i++) {
-    if (maps[i].sources.length > 1) {
-      throw new Error(
-        `Transformation map ${i} must have exactly one source file.
-Did you specify these with the most recent transformation maps first?`
-      );
-    }
-  }
-  let tree = build(map, loader, "", 0);
-  for (let i = maps.length - 1; i >= 0; i--) {
-    tree = MapSource(maps[i], [tree]);
-  }
-  return tree;
-}
-function build(map, loader, importer, importerDepth) {
-  const { resolvedSources, sourcesContent, ignoreList } = map;
-  const depth = importerDepth + 1;
-  const children = resolvedSources.map((sourceFile, i) => {
-    const ctx = {
-      importer,
-      depth,
-      source: sourceFile || "",
-      content: void 0,
-      ignore: void 0
-    };
-    const sourceMap = loader(ctx.source, ctx);
-    const { source} = ctx;
-    if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);
-    const sourceContent = sourcesContent ? sourcesContent[i] : null;
-    const ignored = ignoreList ? ignoreList.includes(i) : false;
-    return OriginalSource(source, sourceContent, ignored);
-  });
-  return MapSource(map, children);
-}
-var SourceMap = class {
-  constructor(map, options) {
-    const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
-    this.version = out.version;
-    this.file = out.file;
-    this.mappings = out.mappings;
-    this.names = out.names;
-    this.ignoreList = out.ignoreList;
-    this.sourceRoot = out.sourceRoot;
-    this.sources = out.sources;
-    if (!options.excludeContent) {
-      this.sourcesContent = out.sourcesContent;
-    }
-  }
-  toString() {
-    return JSON.stringify(this);
-  }
-};
-
-// src/remapping.ts
-function remapping(input, loader, options) {
-  const opts = { excludeContent: true, decodedMappings: false };
-  const tree = buildSourceMapTree(input, loader);
-  return new SourceMap(traceMappings(tree), opts);
-}
-
-var virtualStats = {};
-
-var hasRequiredVirtualStats;
-
-function requireVirtualStats () {
-	if (hasRequiredVirtualStats) return virtualStats;
-	hasRequiredVirtualStats = 1;
-	var __importDefault = (virtualStats && virtualStats.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(virtualStats, "__esModule", { value: true });
-	virtualStats.VirtualStats = void 0;
-	const constants_1 = __importDefault(require$$0);
-	class VirtualStats {
-	    constructor(config) {
-	        for (const key in config) {
-	            if (!Object.prototype.hasOwnProperty.call(config, key)) {
-	                continue;
-	            }
-	            this[key] = config[key];
-	        }
-	    }
-	    _checkModeProperty(property) {
-	        return (this.mode & constants_1.default.S_IFMT) === property;
-	    }
-	    isDirectory() {
-	        return this._checkModeProperty(constants_1.default.S_IFDIR);
-	    }
-	    isFile() {
-	        return this._checkModeProperty(constants_1.default.S_IFREG);
-	    }
-	    isBlockDevice() {
-	        return this._checkModeProperty(constants_1.default.S_IFBLK);
-	    }
-	    isCharacterDevice() {
-	        return this._checkModeProperty(constants_1.default.S_IFCHR);
-	    }
-	    isSymbolicLink() {
-	        return this._checkModeProperty(constants_1.default.S_IFLNK);
-	    }
-	    isFIFO() {
-	        return this._checkModeProperty(constants_1.default.S_IFIFO);
-	    }
-	    isSocket() {
-	        return this._checkModeProperty(constants_1.default.S_IFSOCK);
-	    }
-	}
-	virtualStats.VirtualStats = VirtualStats;
-	
-	return virtualStats;
-}
-
-var lib;
-var hasRequiredLib;
-
-function requireLib () {
-	if (hasRequiredLib) return lib;
-	hasRequiredLib = 1;
-	var __importDefault = (lib && lib.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	const path_1 = __importDefault(sysPath__default);
-	const virtual_stats_1 = requireVirtualStats();
-	let inode = 45000000;
-	const ALL = 'all';
-	const STATIC = 'static';
-	const DYNAMIC = 'dynamic';
-	function checkActivation(instance) {
-	    if (!instance._compiler) {
-	        throw new Error('You must use this plugin only after creating webpack instance!');
-	    }
-	}
-	function getModulePath(filePath, compiler) {
-	    return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(compiler.context, filePath);
-	}
-	function createWebpackData(result) {
-	    return (backendOrStorage) => {
-	        if (backendOrStorage._data) {
-	            const curLevelIdx = backendOrStorage._currentLevel;
-	            const curLevel = backendOrStorage._levels[curLevelIdx];
-	            return {
-	                result,
-	                level: curLevel,
-	            };
-	        }
-	        return [null, result];
-	    };
-	}
-	function getData(storage, key) {
-	    if (storage._data instanceof Map) {
-	        return storage._data.get(key);
-	    }
-	    else if (storage._data) {
-	        return storage.data[key];
-	    }
-	    else if (storage.data instanceof Map) {
-	        return storage.data.get(key);
-	    }
-	    else {
-	        return storage.data[key];
-	    }
-	}
-	function setData(backendOrStorage, key, valueFactory) {
-	    const value = valueFactory(backendOrStorage);
-	    if (backendOrStorage._data instanceof Map) {
-	        backendOrStorage._data.set(key, value);
-	    }
-	    else if (backendOrStorage._data) {
-	        backendOrStorage.data[key] = value;
-	    }
-	    else if (backendOrStorage.data instanceof Map) {
-	        backendOrStorage.data.set(key, value);
-	    }
-	    else {
-	        backendOrStorage.data[key] = value;
-	    }
-	}
-	function getStatStorage(fileSystem) {
-	    if (fileSystem._statStorage) {
-	        return fileSystem._statStorage;
-	    }
-	    else if (fileSystem._statBackend) {
-	        return fileSystem._statBackend;
-	    }
-	    else {
-	        throw new Error("Couldn't find a stat storage");
-	    }
-	}
-	function getFileStorage(fileSystem) {
-	    if (fileSystem._readFileStorage) {
-	        return fileSystem._readFileStorage;
-	    }
-	    else if (fileSystem._readFileBackend) {
-	        return fileSystem._readFileBackend;
-	    }
-	    else {
-	        throw new Error("Couldn't find a readFileStorage");
-	    }
-	}
-	function getReadDirBackend(fileSystem) {
-	    if (fileSystem._readdirBackend) {
-	        return fileSystem._readdirBackend;
-	    }
-	    else if (fileSystem._readdirStorage) {
-	        return fileSystem._readdirStorage;
-	    }
-	    else {
-	        throw new Error("Couldn't find a readDirStorage from Webpack Internals");
-	    }
-	}
-	function getRealpathBackend(fileSystem) {
-	    if (fileSystem._realpathBackend) {
-	        return fileSystem._realpathBackend;
-	    }
-	}
-	class VirtualModulesPlugin {
-	    constructor(modules) {
-	        this._compiler = null;
-	        this._watcher = null;
-	        this._staticModules = modules || null;
-	    }
-	    getModuleList(filter = ALL) {
-	        var _a, _b;
-	        let modules = {};
-	        const shouldGetStaticModules = filter === ALL || filter === STATIC;
-	        const shouldGetDynamicModules = filter === ALL || filter === DYNAMIC;
-	        if (shouldGetStaticModules) {
-	            modules = Object.assign(Object.assign({}, modules), this._staticModules);
-	        }
-	        if (shouldGetDynamicModules) {
-	            const finalInputFileSystem = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.inputFileSystem;
-	            const virtualFiles = (_b = finalInputFileSystem === null || finalInputFileSystem === void 0 ? void 0 : finalInputFileSystem._virtualFiles) !== null && _b !== void 0 ? _b : {};
-	            const dynamicModules = {};
-	            Object.keys(virtualFiles).forEach((key) => {
-	                dynamicModules[key] = virtualFiles[key].contents;
-	            });
-	            modules = Object.assign(Object.assign({}, modules), dynamicModules);
-	        }
-	        return modules;
-	    }
-	    writeModule(filePath, contents) {
-	        if (!this._compiler) {
-	            throw new Error(`Plugin has not been initialized`);
-	        }
-	        checkActivation(this);
-	        const len = contents ? contents.length : 0;
-	        const time = Date.now();
-	        const date = new Date(time);
-	        const stats = new virtual_stats_1.VirtualStats({
-	            dev: 8675309,
-	            nlink: 0,
-	            uid: 1000,
-	            gid: 1000,
-	            rdev: 0,
-	            blksize: 4096,
-	            ino: inode++,
-	            mode: 33188,
-	            size: len,
-	            blocks: Math.floor(len / 4096),
-	            atime: date,
-	            mtime: date,
-	            ctime: date,
-	            birthtime: date,
-	        });
-	        const modulePath = getModulePath(filePath, this._compiler);
-	        if (process.env.WVM_DEBUG)
-	            console.log(this._compiler.name, 'Write virtual module:', modulePath, contents);
-	        let finalWatchFileSystem = this._watcher && this._watcher.watchFileSystem;
-	        while (finalWatchFileSystem && finalWatchFileSystem.wfs) {
-	            finalWatchFileSystem = finalWatchFileSystem.wfs;
-	        }
-	        let finalInputFileSystem = this._compiler.inputFileSystem;
-	        while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) {
-	            finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-	        }
-	        finalInputFileSystem._writeVirtualFile(modulePath, stats, contents);
-	        if (finalWatchFileSystem &&
-	            finalWatchFileSystem.watcher &&
-	            (finalWatchFileSystem.watcher.fileWatchers.size || finalWatchFileSystem.watcher.fileWatchers.length)) {
-	            const fileWatchers = finalWatchFileSystem.watcher.fileWatchers instanceof Map
-	                ? Array.from(finalWatchFileSystem.watcher.fileWatchers.values())
-	                : finalWatchFileSystem.watcher.fileWatchers;
-	            for (let fileWatcher of fileWatchers) {
-	                if ('watcher' in fileWatcher) {
-	                    fileWatcher = fileWatcher.watcher;
-	                }
-	                if (fileWatcher.path === modulePath) {
-	                    if (process.env.DEBUG)
-	                        console.log(this._compiler.name, 'Emit file change:', modulePath, time);
-	                    delete fileWatcher.directoryWatcher._cachedTimeInfoEntries;
-	                    fileWatcher.emit('change', time, null);
-	                }
-	            }
-	        }
-	    }
-	    apply(compiler) {
-	        this._compiler = compiler;
-	        const afterEnvironmentHook = () => {
-	            let finalInputFileSystem = compiler.inputFileSystem;
-	            while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) {
-	                finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-	            }
-	            if (!finalInputFileSystem._writeVirtualFile) {
-	                const originalPurge = finalInputFileSystem.purge;
-	                finalInputFileSystem.purge = () => {
-	                    originalPurge.apply(finalInputFileSystem, []);
-	                    if (finalInputFileSystem._virtualFiles) {
-	                        Object.keys(finalInputFileSystem._virtualFiles).forEach((file) => {
-	                            const data = finalInputFileSystem._virtualFiles[file];
-	                            finalInputFileSystem._writeVirtualFile(file, data.stats, data.contents);
-	                        });
-	                    }
-	                };
-	                finalInputFileSystem._writeVirtualFile = (file, stats, contents) => {
-	                    const statStorage = getStatStorage(finalInputFileSystem);
-	                    const fileStorage = getFileStorage(finalInputFileSystem);
-	                    const readDirStorage = getReadDirBackend(finalInputFileSystem);
-	                    const realPathStorage = getRealpathBackend(finalInputFileSystem);
-	                    finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
-	                    finalInputFileSystem._virtualFiles[file] = { stats: stats, contents: contents };
-	                    setData(statStorage, file, createWebpackData(stats));
-	                    setData(fileStorage, file, createWebpackData(contents));
-	                    const segments = file.split(/[\\/]/);
-	                    let count = segments.length - 1;
-	                    const minCount = segments[0] ? 1 : 0;
-	                    while (count > minCount) {
-	                        const dir = segments.slice(0, count).join(path_1.default.sep) || path_1.default.sep;
-	                        try {
-	                            finalInputFileSystem.readdirSync(dir);
-	                        }
-	                        catch (e) {
-	                            const time = Date.now();
-	                            const dirStats = new virtual_stats_1.VirtualStats({
-	                                dev: 8675309,
-	                                nlink: 0,
-	                                uid: 1000,
-	                                gid: 1000,
-	                                rdev: 0,
-	                                blksize: 4096,
-	                                ino: inode++,
-	                                mode: 16877,
-	                                size: stats.size,
-	                                blocks: Math.floor(stats.size / 4096),
-	                                atime: time,
-	                                mtime: time,
-	                                ctime: time,
-	                                birthtime: time,
-	                            });
-	                            setData(readDirStorage, dir, createWebpackData([]));
-	                            if (realPathStorage) {
-	                                setData(realPathStorage, dir, createWebpackData(dir));
-	                            }
-	                            setData(statStorage, dir, createWebpackData(dirStats));
-	                        }
-	                        let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
-	                        dirData = dirData[1] || dirData.result;
-	                        const filename = segments[count];
-	                        if (dirData.indexOf(filename) < 0) {
-	                            const files = dirData.concat([filename]).sort();
-	                            setData(getReadDirBackend(finalInputFileSystem), dir, createWebpackData(files));
-	                        }
-	                        else {
-	                            break;
-	                        }
-	                        count--;
-	                    }
-	                };
-	            }
-	        };
-	        const afterResolversHook = () => {
-	            if (this._staticModules) {
-	                for (const [filePath, contents] of Object.entries(this._staticModules)) {
-	                    this.writeModule(filePath, contents);
-	                }
-	                this._staticModules = null;
-	            }
-	        };
-	        const version = typeof compiler.webpack === 'undefined' ? 4 : 5;
-	        const watchRunHook = (watcher, callback) => {
-	            this._watcher = watcher.compiler || watcher;
-	            const virtualFiles = compiler.inputFileSystem._virtualFiles;
-	            const fts = compiler.fileTimestamps;
-	            if (virtualFiles && fts && typeof fts.set === 'function') {
-	                Object.keys(virtualFiles).forEach((file) => {
-	                    const mtime = +virtualFiles[file].stats.mtime;
-	                    fts.set(file, version === 4
-	                        ? mtime
-	                        : {
-	                            safeTime: mtime,
-	                            timestamp: mtime,
-	                        });
-	                });
-	            }
-	            callback();
-	        };
-	        if (compiler.hooks) {
-	            compiler.hooks.afterEnvironment.tap('VirtualModulesPlugin', afterEnvironmentHook);
-	            compiler.hooks.afterResolvers.tap('VirtualModulesPlugin', afterResolversHook);
-	            compiler.hooks.watchRun.tapAsync('VirtualModulesPlugin', watchRunHook);
-	        }
-	        else {
-	            compiler.plugin('after-environment', afterEnvironmentHook);
-	            compiler.plugin('after-resolvers', afterResolversHook);
-	            compiler.plugin('watch-run', watchRunHook);
-	        }
-	    }
-	}
-	lib = VirtualModulesPlugin;
-	
-	return lib;
-}
-
-var libExports = requireLib();
-const VirtualModulesPlugin = /*@__PURE__*/getDefaultExportFromCjs(libExports);
-
-//#region src/esbuild/utils.ts
-const ExtToLoader = {
-	".js": "js",
-	".mjs": "js",
-	".cjs": "js",
-	".jsx": "jsx",
-	".ts": "ts",
-	".cts": "ts",
-	".mts": "ts",
-	".tsx": "tsx",
-	".css": "css",
-	".less": "css",
-	".stylus": "css",
-	".scss": "css",
-	".sass": "css",
-	".json": "json",
-	".txt": "text"
-};
-function guessLoader(code, id) {
-	return ExtToLoader[path.extname(id).toLowerCase()] || "js";
-}
-function unwrapLoader(loader, code, id) {
-	if (typeof loader === "function") return loader(code, id);
-	return loader;
-}
-function fixSourceMap(map) {
-	if (!Object.prototype.hasOwnProperty.call(map, "toString")) Object.defineProperty(map, "toString", {
-		enumerable: false,
-		value: function toString() {
-			return JSON.stringify(this);
-		}
-	});
-	if (!Object.prototype.hasOwnProperty.call(map, "toUrl")) Object.defineProperty(map, "toUrl", {
-		enumerable: false,
-		value: function toUrl() {
-			return `data:application/json;charset=utf-8;base64,${Buffer$1.from(this.toString()).toString("base64")}`;
-		}
-	});
-	return map;
-}
-const nullSourceMap = {
-	names: [],
-	sources: [],
-	mappings: "",
-	version: 3
-};
-function combineSourcemaps(filename, sourcemapList) {
-	sourcemapList = sourcemapList.filter((m) => m.sources);
-	if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0)) return { ...nullSourceMap };
-	let map;
-	let mapIndex = 1;
-	const useArrayInterface = sourcemapList.slice(0, -1).find((m) => m.sources.length !== 1) === void 0;
-	if (useArrayInterface) map = remapping(sourcemapList, () => null);
-	else map = remapping(sourcemapList[0], (sourcefile) => {
-		if (sourcefile === filename && sourcemapList[mapIndex]) return sourcemapList[mapIndex++];
-		else return { ...nullSourceMap };
-	});
-	if (!map.file) delete map.file;
-	return map;
-}
-function createBuildContext$2(build) {
-	const watchFiles = [];
-	const { initialOptions } = build;
-	return {
-		parse: parse$1,
-		addWatchFile() {
-			throw new Error("unplugin/esbuild: addWatchFile outside supported hooks (resolveId, load, transform)");
-		},
-		emitFile(emittedFile) {
-			const outFileName = emittedFile.fileName || emittedFile.name;
-			if (initialOptions.outdir && emittedFile.source && outFileName) {
-				const outPath = path.resolve(initialOptions.outdir, outFileName);
-				const outDir = path.dirname(outPath);
-				if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
-				fs.writeFileSync(outPath, emittedFile.source);
-			}
-		},
-		getWatchFiles() {
-			return watchFiles;
-		},
-		getNativeBuildContext() {
-			return {
-				framework: "esbuild",
-				build
-			};
-		}
-	};
-}
-function createPluginContext(context) {
-	const errors = [];
-	const warnings = [];
-	const pluginContext = {
-		error(message) {
-			errors.push(normalizeMessage$2(message));
-		},
-		warn(message) {
-			warnings.push(normalizeMessage$2(message));
-		}
-	};
-	const mixedContext = {
-		...context,
-		...pluginContext,
-		addWatchFile(id) {
-			context.getWatchFiles().push(id);
-		}
-	};
-	return {
-		errors,
-		warnings,
-		mixedContext
-	};
-}
-function normalizeMessage$2(message) {
-	if (typeof message === "string") message = { message };
-	return {
-		id: message.id,
-		pluginName: message.plugin,
-		text: message.message,
-		location: message.loc ? {
-			file: message.loc.file,
-			line: message.loc.line,
-			column: message.loc.column
-		} : null,
-		detail: message.meta,
-		notes: []
-	};
-}
-function processCodeWithSourceMap(map, code) {
-	if (map) {
-		if (!map.sourcesContent || map.sourcesContent.length === 0) map.sourcesContent = [code];
-		map = fixSourceMap(map);
-		code += `\n//# sourceMappingURL=${map.toUrl()}`;
-	}
-	return code;
-}
-
-//#endregion
-//#region src/esbuild/index.ts
-function getEsbuildPlugin(factory) {
-	return (userOptions) => {
-		const meta = { framework: "esbuild" };
-		const plugins = toArray$2(factory(userOptions, meta));
-		const setupPlugins = async (build) => {
-			const setup = buildSetup();
-			const loaders = [];
-			for (const plugin of plugins) {
-				const loader = {};
-				await setup(plugin)({
-					...build,
-					onLoad(_options, callback) {
-						loader.options = _options;
-						loader.onLoadCb = callback;
-					},
-					onTransform(_options, callback) {
-						loader.options ||= _options;
-						loader.onTransformCb = callback;
-					}
-				}, build);
-				if (loader.onLoadCb || loader.onTransformCb) loaders.push(loader);
-			}
-			if (loaders.length) build.onLoad(loaders.length === 1 ? loaders[0].options : { filter: /.*/ }, async (args) => {
-				function checkFilter(options) {
-					return loaders.length === 1 || !options?.filter || options.filter.test(args.path);
-				}
-				let result;
-				for (const { options, onLoadCb } of loaders) {
-					if (!checkFilter(options)) continue;
-					if (onLoadCb) result = await onLoadCb(args);
-					if (result?.contents) break;
-				}
-				let fsContentsCache;
-				for (const { options, onTransformCb } of loaders) {
-					if (!checkFilter(options)) continue;
-					if (onTransformCb) {
-						const newArgs = {
-							...result,
-							...args,
-							async getContents() {
-								if (result?.contents) return result.contents;
-								if (fsContentsCache) return fsContentsCache;
-								return fsContentsCache = await fs.promises.readFile(args.path, "utf8");
-							}
-						};
-						const _result = await onTransformCb(newArgs);
-						if (_result?.contents) result = _result;
-					}
-				}
-				if (result?.contents) return result;
-			});
-		};
-		return {
-			name: (plugins.length === 1 ? plugins[0].name : meta.esbuildHostName) ?? `unplugin-host:${plugins.map((p) => p.name).join(":")}`,
-			setup: setupPlugins
-		};
-	};
-}
-function buildSetup() {
-	return (plugin) => {
-		return (build, rawBuild) => {
-			const context = createBuildContext$2(rawBuild);
-			const { onStart, onEnd, onResolve, onLoad, onTransform, initialOptions } = build;
-			const onResolveFilter = plugin.esbuild?.onResolveFilter ?? /.*/;
-			const onLoadFilter = plugin.esbuild?.onLoadFilter ?? /.*/;
-			const loader = plugin.esbuild?.loader ?? guessLoader;
-			plugin.esbuild?.config?.call(context, initialOptions);
-			if (plugin.buildStart) onStart(() => plugin.buildStart.call(context));
-			if (plugin.buildEnd || plugin.writeBundle) onEnd(async () => {
-				if (plugin.buildEnd) await plugin.buildEnd.call(context);
-				if (plugin.writeBundle) await plugin.writeBundle();
-			});
-			if (plugin.resolveId) onResolve({ filter: onResolveFilter }, async (args) => {
-				const id = args.path;
-				if (initialOptions.external?.includes(id)) return;
-				const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
-				if (!filter(id)) return;
-				const { errors, warnings, mixedContext } = createPluginContext(context);
-				const isEntry = args.kind === "entry-point";
-				const result = await handler.call(mixedContext, id, isEntry ? void 0 : args.importer, { isEntry });
-				if (typeof result === "string") return {
-					path: result,
-					namespace: plugin.name,
-					errors,
-					warnings,
-					watchFiles: mixedContext.getWatchFiles()
-				};
-				else if (typeof result === "object" && result !== null) return {
-					path: result.id,
-					external: result.external,
-					namespace: plugin.name,
-					errors,
-					warnings,
-					watchFiles: mixedContext.getWatchFiles()
-				};
-			});
-			if (plugin.load) onLoad({ filter: onLoadFilter }, async (args) => {
-				const { handler, filter } = normalizeObjectHook("load", plugin.load);
-				const id = args.path + (args.suffix || "");
-				if (plugin.loadInclude && !plugin.loadInclude(id)) return;
-				if (!filter(id)) return;
-				const { errors, warnings, mixedContext } = createPluginContext(context);
-				let code;
-				let map;
-				const result = await handler.call(mixedContext, id);
-				if (typeof result === "string") code = result;
-				else if (typeof result === "object" && result !== null) {
-					code = result.code;
-					map = result.map;
-				}
-				if (code === void 0) return null;
-				if (map) code = processCodeWithSourceMap(map, code);
-				const resolveDir = path.dirname(args.path);
-				return {
-					contents: code,
-					errors,
-					warnings,
-					watchFiles: mixedContext.getWatchFiles(),
-					loader: unwrapLoader(loader, code, args.path),
-					resolveDir
-				};
-			});
-			if (plugin.transform) onTransform({ filter: onLoadFilter }, async (args) => {
-				const { handler, filter } = normalizeObjectHook("transform", plugin.transform);
-				const id = args.path + (args.suffix || "");
-				if (plugin.transformInclude && !plugin.transformInclude(id)) return;
-				let code = await args.getContents();
-				if (!filter(id, code)) return;
-				const { mixedContext, errors, warnings } = createPluginContext(context);
-				const resolveDir = path.dirname(args.path);
-				let map;
-				const result = await handler.call(mixedContext, code, id);
-				if (typeof result === "string") code = result;
-				else if (typeof result === "object" && result !== null) {
-					code = result.code;
-					if (map && result.map) map = combineSourcemaps(args.path, [result.map === "string" ? JSON.parse(result.map) : result.map, map]);
-					else if (typeof result.map === "string") map = JSON.parse(result.map);
-					else map = result.map;
-				}
-				if (code) {
-					if (map) code = processCodeWithSourceMap(map, code);
-					return {
-						contents: code,
-						errors,
-						warnings,
-						watchFiles: mixedContext.getWatchFiles(),
-						loader: unwrapLoader(loader, code, args.path),
-						resolveDir
-					};
-				}
-			});
-			if (plugin.esbuild?.setup) return plugin.esbuild.setup(rawBuild);
-		};
-	};
-}
-
-//#endregion
-//#region src/farm/context.ts
-function createFarmContext(context, currentResolveId) {
-	return {
-		parse: parse$1,
-		addWatchFile(id) {
-			context.addWatchFile(id, currentResolveId || id);
-		},
-		emitFile(emittedFile) {
-			const outFileName = emittedFile.fileName || emittedFile.name;
-			if (emittedFile.source && outFileName) context.emitFile({
-				resolvedPath: outFileName,
-				name: outFileName,
-				content: [...Buffer$1.from(emittedFile.source)],
-				resourceType: extname(outFileName)
-			});
-		},
-		getWatchFiles() {
-			return context.getWatchFiles();
-		},
-		getNativeBuildContext() {
-			return {
-				framework: "farm",
-				context
-			};
-		}
-	};
-}
-function unpluginContext(context) {
-	return {
-		error: (error) => context.error(typeof error === "string" ? new Error(error) : error),
-		warn: (error) => context.warn(typeof error === "string" ? new Error(error) : error)
-	};
-}
-
-//#endregion
-//#region src/farm/utils.ts
-function convertEnforceToPriority(value) {
-	const defaultPriority = 100;
-	const enforceToPriority = {
-		pre: 102,
-		post: 98
-	};
-	return enforceToPriority[value] !== void 0 ? enforceToPriority[value] : defaultPriority;
-}
-function convertWatchEventChange(value) {
-	const watchEventChange = {
-		Added: "create",
-		Updated: "update",
-		Removed: "delete"
-	};
-	return watchEventChange[value];
-}
-function isString(variable) {
-	return typeof variable === "string";
-}
-function isObject(variable) {
-	return typeof variable === "object" && variable !== null;
-}
-function customParseQueryString(url) {
-	if (!url) return [];
-	const queryString = url.split("?")[1];
-	const parsedParams = querystring.parse(queryString);
-	const paramsArray = [];
-	for (const key in parsedParams) paramsArray.push([key, parsedParams[key]]);
-	return paramsArray;
-}
-function encodeStr(str) {
-	const len = str.length;
-	if (len === 0) return str;
-	const firstNullIndex = str.indexOf("\0");
-	if (firstNullIndex === -1) return str;
-	const result = Array.from({ length: len + countNulls(str, firstNullIndex) });
-	let pos = 0;
-	for (let i = 0; i < firstNullIndex; i++) result[pos++] = str[i];
-	for (let i = firstNullIndex; i < len; i++) {
-		const char = str[i];
-		if (char === "\0") {
-			result[pos++] = "\\";
-			result[pos++] = "0";
-		} else result[pos++] = char;
-	}
-	return path.posix.normalize(result.join(""));
-}
-function decodeStr(str) {
-	const len = str.length;
-	if (len === 0) return str;
-	const firstIndex = str.indexOf("\\0");
-	if (firstIndex === -1) return str;
-	const result = Array.from({ length: len - countBackslashZeros(str, firstIndex) });
-	let pos = 0;
-	for (let i$1 = 0; i$1 < firstIndex; i$1++) result[pos++] = str[i$1];
-	let i = firstIndex;
-	while (i < len) if (str[i] === "\\" && str[i + 1] === "0") {
-		result[pos++] = "\0";
-		i += 2;
-	} else result[pos++] = str[i++];
-	return path.posix.normalize(result.join(""));
-}
-function getContentValue(content) {
-	if (content === null || content === void 0) throw new Error("Content cannot be null or undefined");
-	const strContent = typeof content === "string" ? content : content.code || "";
-	return encodeStr(strContent);
-}
-function countNulls(str, startIndex) {
-	let count = 0;
-	const len = str.length;
-	for (let i = startIndex; i < len; i++) if (str[i] === "\0") count++;
-	return count;
-}
-function countBackslashZeros(str, startIndex) {
-	let count = 0;
-	const len = str.length;
-	for (let i = startIndex; i < len - 1; i++) if (str[i] === "\\" && str[i + 1] === "0") {
-		count++;
-		i++;
-	}
-	return count;
-}
-function removeQuery(pathe) {
-	const queryIndex = pathe.indexOf("?");
-	if (queryIndex !== -1) return path.posix.normalize(pathe.slice(0, queryIndex));
-	return path.posix.normalize(pathe);
-}
-function isStartsWithSlash(str) {
-	return str?.startsWith("/");
-}
-function appendQuery(id, query) {
-	if (!query.length) return id;
-	return `${id}?${stringifyQuery(query)}`;
-}
-function stringifyQuery(query) {
-	if (!query.length) return "";
-	let queryStr = "";
-	for (const [key, value] of query) queryStr += `${key}${value ? `=${value}` : ""}&`;
-	return `${queryStr.slice(0, -1)}`;
-}
-const CSS_LANGS_RES = [
-	[/\.(less)(?:$|\?)/, "less"],
-	[/\.(scss|sass)(?:$|\?)/, "sass"],
-	[/\.(styl|stylus)(?:$|\?)/, "stylus"],
-	[/\.(css)(?:$|\?)/, "css"]
-];
-const JS_LANGS_RES = [
-	[/\.(js|mjs|cjs)(?:$|\?)/, "js"],
-	[/\.(jsx)(?:$|\?)/, "jsx"],
-	[/\.(ts|cts|mts)(?:$|\?)/, "ts"],
-	[/\.(tsx)(?:$|\?)/, "tsx"]
-];
-function getCssModuleType(id) {
-	for (const [reg, lang] of CSS_LANGS_RES) if (reg.test(id)) return lang;
-	return null;
-}
-function getJsModuleType(id) {
-	for (const [reg, lang] of JS_LANGS_RES) if (reg.test(id)) return lang;
-	return null;
-}
-function formatLoadModuleType(id) {
-	const cssModuleType = getCssModuleType(id);
-	if (cssModuleType) return cssModuleType;
-	const jsModuleType = getJsModuleType(id);
-	if (jsModuleType) return jsModuleType;
-	return "js";
-}
-function formatTransformModuleType(id) {
-	return formatLoadModuleType(id);
-}
-
-//#endregion
-//#region src/farm/index.ts
-function getFarmPlugin(factory) {
-	return ((userOptions) => {
-		const meta = { framework: "farm" };
-		const rawPlugins = toArray$2(factory(userOptions, meta));
-		const plugins = rawPlugins.map((rawPlugin) => {
-			const plugin = toFarmPlugin(rawPlugin, userOptions);
-			if (rawPlugin.farm) Object.assign(plugin, rawPlugin.farm);
-			return plugin;
-		});
-		return plugins.length === 1 ? plugins[0] : plugins;
-	});
-}
-function toFarmPlugin(plugin, options) {
-	const farmPlugin = {
-		name: plugin.name,
-		priority: convertEnforceToPriority(plugin.enforce)
-	};
-	if (plugin.farm) Object.keys(plugin.farm).forEach((key) => {
-		const value = plugin.farm[key];
-		if (value) Reflect.set(farmPlugin, key, value);
-	});
-	if (plugin.buildStart) {
-		const _buildStart = plugin.buildStart;
-		farmPlugin.buildStart = { async executor(_, context) {
-			await _buildStart.call(createFarmContext(context));
-		} };
-	}
-	if (plugin.resolveId) {
-		const _resolveId = plugin.resolveId;
-		let filters = [];
-		if (options) filters = options?.filters ?? [];
-		farmPlugin.resolve = {
-			filters: {
-				sources: filters.length ? filters : [".*"],
-				importers: [".*"]
-			},
-			async executor(params, context) {
-				const resolvedIdPath = path.resolve(params.importer ?? "");
-				const id = decodeStr(params.source);
-				const { handler, filter } = normalizeObjectHook("resolveId", _resolveId);
-				if (!filter(id)) return null;
-				let isEntry = false;
-				if (isObject(params.kind) && "entry" in params.kind) {
-					const kindWithEntry = params.kind;
-					isEntry = kindWithEntry.entry === "index";
-				}
-				const farmContext = createFarmContext(context, resolvedIdPath);
-				const resolveIdResult = await handler.call(Object.assign(unpluginContext(context), farmContext), id, resolvedIdPath ?? null, { isEntry });
-				if (isString(resolveIdResult)) return {
-					resolvedPath: removeQuery(encodeStr(resolveIdResult)),
-					query: customParseQueryString(resolveIdResult),
-					sideEffects: true,
-					external: false,
-					meta: {}
-				};
-				if (isObject(resolveIdResult)) return {
-					resolvedPath: removeQuery(encodeStr(resolveIdResult?.id)),
-					query: customParseQueryString(resolveIdResult?.id),
-					sideEffects: false,
-					external: Boolean(resolveIdResult?.external),
-					meta: {}
-				};
-				if (!isStartsWithSlash(params.source)) return null;
-			}
-		};
-	}
-	if (plugin.load) {
-		const _load = plugin.load;
-		farmPlugin.load = {
-			filters: { resolvedPaths: [".*"] },
-			async executor(params, context) {
-				const resolvedPath = decodeStr(params.resolvedPath);
-				const id = appendQuery(resolvedPath, params.query);
-				const loader = formatTransformModuleType(id);
-				if (plugin.loadInclude && !plugin.loadInclude?.(id)) return null;
-				const { handler, filter } = normalizeObjectHook("load", _load);
-				if (!filter(id)) return null;
-				const farmContext = createFarmContext(context, id);
-				const content = await handler.call(Object.assign(unpluginContext(context), farmContext), id);
-				const loadFarmResult = {
-					content: getContentValue(content),
-					moduleType: loader
-				};
-				return loadFarmResult;
-			}
-		};
-	}
-	if (plugin.transform) {
-		const _transform = plugin.transform;
-		farmPlugin.transform = {
-			filters: {
-				resolvedPaths: [".*"],
-				moduleTypes: [".*"]
-			},
-			async executor(params, context) {
-				const resolvedPath = decodeStr(params.resolvedPath);
-				const id = appendQuery(resolvedPath, params.query);
-				const loader = formatTransformModuleType(id);
-				if (plugin.transformInclude && !plugin.transformInclude(id)) return null;
-				const { handler, filter } = normalizeObjectHook("transform", _transform);
-				if (!filter(id, params.content)) return null;
-				const farmContext = createFarmContext(context, id);
-				const resource = await handler.call(Object.assign(unpluginContext(context), farmContext), params.content, id);
-				if (resource && typeof resource !== "string") {
-					const transformFarmResult = {
-						content: getContentValue(resource),
-						moduleType: loader,
-						sourceMap: typeof resource.map === "object" && resource.map !== null ? JSON.stringify(resource.map) : void 0
-					};
-					return transformFarmResult;
-				}
-			}
-		};
-	}
-	if (plugin.watchChange) {
-		const _watchChange = plugin.watchChange;
-		farmPlugin.updateModules = { async executor(param, context) {
-			const updatePathContent = param.paths[0];
-			const ModifiedPath = updatePathContent[0];
-			const eventChange = convertWatchEventChange(updatePathContent[1]);
-			await _watchChange.call(createFarmContext(context), ModifiedPath, { event: eventChange });
-		} };
-	}
-	if (plugin.buildEnd) {
-		const _buildEnd = plugin.buildEnd;
-		farmPlugin.buildEnd = { async executor(_, context) {
-			await _buildEnd.call(createFarmContext(context));
-		} };
-	}
-	if (plugin.writeBundle) {
-		const _writeBundle = plugin.writeBundle;
-		farmPlugin.finish = { async executor() {
-			await _writeBundle();
-		} };
-	}
-	return farmPlugin;
-}
-
-//#endregion
-//#region src/rollup/index.ts
-function getRollupPlugin(factory) {
-	return ((userOptions) => {
-		const meta = { framework: "rollup" };
-		const rawPlugins = toArray$2(factory(userOptions, meta));
-		const plugins = rawPlugins.map((plugin) => toRollupPlugin(plugin, "rollup"));
-		return plugins.length === 1 ? plugins[0] : plugins;
-	});
-}
-function toRollupPlugin(plugin, key) {
-	const nativeFilter = key === "rolldown";
-	if (plugin.resolveId && !nativeFilter && typeof plugin.resolveId === "object" && plugin.resolveId.filter) {
-		const resolveIdHook = plugin.resolveId;
-		const { handler, filter } = normalizeObjectHook("load", resolveIdHook);
-		replaceHookHandler("resolveId", resolveIdHook, function(...args) {
-			const [id] = args;
-			const supportFilter = supportNativeFilter(this, key);
-			if (!supportFilter && !filter(id)) return;
-			return handler.apply(this, args);
-		});
-	}
-	if (plugin.load && (plugin.loadInclude || !nativeFilter && typeof plugin.load === "object" && plugin.load.filter)) {
-		const loadHook = plugin.load;
-		const { handler, filter } = normalizeObjectHook("load", loadHook);
-		replaceHookHandler("load", loadHook, function(...args) {
-			const [id] = args;
-			if (plugin.loadInclude && !plugin.loadInclude(id)) return;
-			const supportFilter = supportNativeFilter(this, key);
-			if (!supportFilter && !filter(id)) return;
-			return handler.apply(this, args);
-		});
-	}
-	if (plugin.transform && (plugin.transformInclude || !nativeFilter && typeof plugin.transform === "object" && plugin.transform.filter)) {
-		const transformHook = plugin.transform;
-		const { handler, filter } = normalizeObjectHook("transform", transformHook);
-		replaceHookHandler("transform", transformHook, function(...args) {
-			const [code, id] = args;
-			if (plugin.transformInclude && !plugin.transformInclude(id)) return;
-			const supportFilter = supportNativeFilter(this, key);
-			if (!supportFilter && !filter(id, code)) return;
-			return handler.apply(this, args);
-		});
-	}
-	if (plugin[key]) Object.assign(plugin, plugin[key]);
-	return plugin;
-	function replaceHookHandler(name, hook, handler) {
-		if (typeof hook === "function") plugin[name] = handler;
-		else hook.handler = handler;
-	}
-}
-function supportNativeFilter(context, framework) {
-	if (framework === "unloader") return false;
-	if (framework === "vite") return !!context?.meta?.viteVersion;
-	if (framework === "rolldown") return true;
-	const rollupVersion = context?.meta?.rollupVersion;
-	if (!rollupVersion) return false;
-	const [major, minor] = rollupVersion.split(".");
-	return Number(major) > 4 || Number(major) === 4 && Number(minor) >= 40;
-}
-
-//#endregion
-//#region src/rolldown/index.ts
-function getRolldownPlugin(factory) {
-	return ((userOptions) => {
-		const meta = { framework: "rolldown" };
-		const rawPlugins = toArray$2(factory(userOptions, meta));
-		const plugins = rawPlugins.map((rawPlugin) => {
-			const plugin = toRollupPlugin(rawPlugin, "rolldown");
-			return plugin;
-		});
-		return plugins.length === 1 ? plugins[0] : plugins;
-	});
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsdown@0.14.1_publint@0.3.5_typescript@5.9.2_unplugin-unused@0.5.2_vue-tsc@3.0.6_typescript@5.9.2_/node_modules/tsdown/esm-shims.js
-const getFilename = () => fileURLToPath(import.meta.url);
-const getDirname = () => path.dirname(getFilename());
-const __dirname = /* @__PURE__ */ getDirname();
-
-//#endregion
-//#region src/rspack/index.ts
-const TRANSFORM_LOADER$1 = resolve$3(__dirname, "rspack/loaders/transform");
-const LOAD_LOADER$1 = resolve$3(__dirname, "rspack/loaders/load");
-function getRspackPlugin(factory) {
-	return (userOptions) => {
-		return { apply(compiler) {
-			const VIRTUAL_MODULE_PREFIX = resolve$3(compiler.options.context ?? process.cwd(), "node_modules/.virtual", process.pid.toString());
-			const meta = {
-				framework: "rspack",
-				rspack: { compiler }
-			};
-			const rawPlugins = toArray$2(factory(userOptions, meta));
-			for (const rawPlugin of rawPlugins) {
-				const plugin = Object.assign(rawPlugin, {
-					__unpluginMeta: meta,
-					__virtualModulePrefix: VIRTUAL_MODULE_PREFIX
-				});
-				const externalModules = /* @__PURE__ */ new Set();
-				if (plugin.resolveId) {
-					const createPlugin = (plugin$1) => {
-						if (compiler.rspack.experiments.VirtualModulesPlugin) return new compiler.rspack.experiments.VirtualModulesPlugin();
-						return new FakeVirtualModulesPlugin(plugin$1);
-					};
-					const vfs = createPlugin(plugin);
-					vfs.apply(compiler);
-					const vfsModules = /* @__PURE__ */ new Map();
-					plugin.__vfsModules = vfsModules;
-					plugin.__vfs = vfs;
-					compiler.hooks.compilation.tap(plugin.name, (compilation, { normalModuleFactory }) => {
-						normalModuleFactory.hooks.resolve.tapPromise(plugin.name, async (resolveData) => {
-							const id = normalizeAbsolutePath(resolveData.request);
-							const requestContext = resolveData.contextInfo;
-							let importer = requestContext.issuer !== "" ? requestContext.issuer : void 0;
-							const isEntry = requestContext.issuer === "";
-							if (importer?.startsWith(plugin.__virtualModulePrefix)) importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
-							const context = createBuildContext$1(compiler, compilation);
-							let error;
-							const pluginContext = {
-								error(msg) {
-									if (error == null) error = normalizeMessage$1(msg);
-									else console.error(`unplugin/rspack: multiple errors returned from resolveId hook: ${msg}`);
-								},
-								warn(msg) {
-									console.warn(`unplugin/rspack: warning from resolveId hook: ${msg}`);
-								}
-							};
-							const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
-							if (!filter(id)) return;
-							const resolveIdResult = await handler.call({
-								...context,
-								...pluginContext
-							}, id, importer, { isEntry });
-							if (error != null) throw error;
-							if (resolveIdResult == null) return;
-							let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
-							const isExternal = typeof resolveIdResult === "string" ? false : resolveIdResult.external === true;
-							if (isExternal) externalModules.add(resolved);
-							let isVirtual = true;
-							try {
-								(compiler.inputFileSystem?.statSync ?? fs.statSync)(resolved);
-								isVirtual = false;
-							} catch {
-								isVirtual = !isVirtualModuleId(resolved, plugin);
-							}
-							if (isVirtual) {
-								const encodedVirtualPath = encodeVirtualModuleId(resolved, plugin);
-								if (!vfsModules.has(resolved)) {
-									const fsPromise = Promise.resolve(vfs.writeModule(encodedVirtualPath, ""));
-									vfsModules.set(resolved, fsPromise);
-									await fsPromise;
-								} else await vfsModules.get(resolved);
-								resolved = encodedVirtualPath;
-							}
-							resolveData.request = resolved;
-						});
-					});
-				}
-				if (plugin.load) compiler.options.module.rules.unshift({
-					enforce: plugin.enforce,
-					include(id) {
-						if (isVirtualModuleId(id, plugin)) id = decodeVirtualModuleId(id);
-						if (plugin.loadInclude && !plugin.loadInclude(id)) return false;
-						const { filter } = normalizeObjectHook("load", plugin.load);
-						if (!filter(id)) return false;
-						return !externalModules.has(id);
-					},
-					use: [{
-						loader: LOAD_LOADER$1,
-						options: { plugin }
-					}],
-					type: "javascript/auto"
-				});
-				if (plugin.transform) compiler.options.module.rules.unshift({
-					enforce: plugin.enforce,
-					use(data) {
-						return transformUse(data, plugin, TRANSFORM_LOADER$1);
-					}
-				});
-				if (plugin.rspack) plugin.rspack(compiler);
-				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-					const context = createBuildContext$1(compiler, compilation);
-					if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
-						const promises = [];
-						if (compiler.modifiedFiles) compiler.modifiedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" }))));
-						if (compiler.removedFiles) compiler.removedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" }))));
-						await Promise.all(promises);
-					}
-					if (plugin.buildStart) return await plugin.buildStart.call(context);
-				});
-				if (plugin.buildEnd) compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-					await plugin.buildEnd.call(createBuildContext$1(compiler, compilation));
-				});
-				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
-					await plugin.writeBundle();
-				});
-			}
-		} };
-	};
-}
-
-//#endregion
-//#region src/unloader/index.ts
-function getUnloaderPlugin(factory) {
-	return ((userOptions) => {
-		const meta = { framework: "unloader" };
-		const rawPlugins = toArray$2(factory(userOptions, meta));
-		const plugins = rawPlugins.map((rawPlugin) => {
-			const plugin = toRollupPlugin(rawPlugin, "unloader");
-			return plugin;
-		});
-		return plugins.length === 1 ? plugins[0] : plugins;
-	});
-}
-
-//#endregion
-//#region src/vite/index.ts
-function getVitePlugin(factory) {
-	return ((userOptions) => {
-		const meta = { framework: "vite" };
-		const rawPlugins = toArray$2(factory(userOptions, meta));
-		const plugins = rawPlugins.map((rawPlugin) => {
-			const plugin = toRollupPlugin(rawPlugin, "vite");
-			return plugin;
-		});
-		return plugins.length === 1 ? plugins[0] : plugins;
-	});
-}
-
-//#endregion
-//#region src/webpack/index.ts
-const TRANSFORM_LOADER = resolve$3(__dirname, "webpack/loaders/transform");
-const LOAD_LOADER = resolve$3(__dirname, "webpack/loaders/load");
-function getWebpackPlugin(factory) {
-	return (userOptions) => {
-		return { apply(compiler) {
-			const VIRTUAL_MODULE_PREFIX = resolve$3(compiler.options.context ?? process$1.cwd(), "_virtual_");
-			const meta = {
-				framework: "webpack",
-				webpack: { compiler }
-			};
-			const rawPlugins = toArray$2(factory(userOptions, meta));
-			for (const rawPlugin of rawPlugins) {
-				const plugin = Object.assign(rawPlugin, {
-					__unpluginMeta: meta,
-					__virtualModulePrefix: VIRTUAL_MODULE_PREFIX
-				});
-				const externalModules = /* @__PURE__ */ new Set();
-				if (plugin.resolveId) {
-					let vfs = compiler.options.plugins.find((i) => i instanceof VirtualModulesPlugin);
-					if (!vfs) {
-						vfs = new VirtualModulesPlugin();
-						compiler.options.plugins.push(vfs);
-					}
-					const vfsModules = /* @__PURE__ */ new Set();
-					plugin.__vfsModules = vfsModules;
-					plugin.__vfs = vfs;
-					const resolverPlugin = { apply(resolver) {
-						const target = resolver.ensureHook("resolve");
-						resolver.getHook("resolve").tapAsync(plugin.name, async (request, resolveContext, callback) => {
-							if (!request.request) return callback();
-							if (normalizeAbsolutePath(request.request).startsWith(plugin.__virtualModulePrefix)) return callback();
-							const id = normalizeAbsolutePath(request.request);
-							const requestContext = request.context;
-							let importer = requestContext.issuer !== "" ? requestContext.issuer : void 0;
-							const isEntry = requestContext.issuer === "";
-							if (importer?.startsWith(plugin.__virtualModulePrefix)) importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
-							const fileDependencies = /* @__PURE__ */ new Set();
-							const context = createBuildContext({
-								addWatchFile(file) {
-									fileDependencies.add(file);
-									resolveContext.fileDependencies?.add(file);
-								},
-								getWatchFiles() {
-									return Array.from(fileDependencies);
-								}
-							}, compiler);
-							let error;
-							const pluginContext = {
-								error(msg) {
-									if (error == null) error = normalizeMessage(msg);
-									else console.error(`unplugin/webpack: multiple errors returned from resolveId hook: ${msg}`);
-								},
-								warn(msg) {
-									console.warn(`unplugin/webpack: warning from resolveId hook: ${msg}`);
-								}
-							};
-							const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
-							if (!filter(id)) return callback();
-							const resolveIdResult = await handler.call({
-								...context,
-								...pluginContext
-							}, id, importer, { isEntry });
-							if (error != null) return callback(error);
-							if (resolveIdResult == null) return callback();
-							let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
-							const isExternal = typeof resolveIdResult === "string" ? false : resolveIdResult.external === true;
-							if (isExternal) externalModules.add(resolved);
-							if (!fs.existsSync(resolved)) {
-								resolved = normalizeAbsolutePath(plugin.__virtualModulePrefix + encodeURIComponent(resolved));
-								if (!vfsModules.has(resolved)) {
-									plugin.__vfs.writeModule(resolved, "");
-									vfsModules.add(resolved);
-								}
-							}
-							const newRequest = {
-								...request,
-								request: resolved
-							};
-							resolver.doResolve(target, newRequest, null, resolveContext, callback);
-						});
-					} };
-					compiler.options.resolve.plugins = compiler.options.resolve.plugins || [];
-					compiler.options.resolve.plugins.push(resolverPlugin);
-				}
-				if (plugin.load) compiler.options.module.rules.unshift({
-					include(id) {
-						return shouldLoad(id, plugin, externalModules);
-					},
-					enforce: plugin.enforce,
-					use: [{
-						loader: LOAD_LOADER,
-						options: { plugin }
-					}],
-					type: "javascript/auto"
-				});
-				if (plugin.transform) compiler.options.module.rules.unshift({
-					enforce: plugin.enforce,
-					use(data) {
-						return transformUse(data, plugin, TRANSFORM_LOADER);
-					}
-				});
-				if (plugin.webpack) plugin.webpack(compiler);
-				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-					const context = createBuildContext(contextOptionsFromCompilation(compilation), compiler, compilation);
-					if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
-						const promises = [];
-						if (compiler.modifiedFiles) compiler.modifiedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" }))));
-						if (compiler.removedFiles) compiler.removedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" }))));
-						await Promise.all(promises);
-					}
-					if (plugin.buildStart) return await plugin.buildStart.call(context);
-				});
-				if (plugin.buildEnd) compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-					await plugin.buildEnd.call(createBuildContext(contextOptionsFromCompilation(compilation), compiler, compilation));
-				});
-				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
-					await plugin.writeBundle();
-				});
-			}
-		} };
-	};
-}
-function shouldLoad(id, plugin, externalModules) {
-	if (id.startsWith(plugin.__virtualModulePrefix)) id = decodeURIComponent(id.slice(plugin.__virtualModulePrefix.length));
-	if (plugin.loadInclude && !plugin.loadInclude(id)) return false;
-	const { filter } = normalizeObjectHook("load", plugin.load);
-	if (!filter(id)) return false;
-	return !externalModules.has(id);
-}
-
-//#endregion
-//#region src/define.ts
-function createUnplugin(factory) {
-	return {
-		get esbuild() {
-			return getEsbuildPlugin(factory);
-		},
-		get rollup() {
-			return getRollupPlugin(factory);
-		},
-		get vite() {
-			return getVitePlugin(factory);
-		},
-		get rolldown() {
-			return getRolldownPlugin(factory);
-		},
-		get webpack() {
-			return getWebpackPlugin(factory);
-		},
-		get rspack() {
-			return getRspackPlugin(factory);
-		},
-		get farm() {
-			return getFarmPlugin(factory);
-		},
-		get unloader() {
-			return getUnloaderPlugin(factory);
-		},
-		get raw() {
-			return factory;
-		}
-	};
-}
-
-//#region src/path.ts
-/**
-* Converts path separators to forward slash.
-*/
-function normalizePath(filename) {
-	return filename.replaceAll("\\", "/");
-}
-
-//#endregion
-//#region src/utils.ts
-const isArray = Array.isArray;
-function toArray$1(thing) {
-	if (isArray(thing)) return thing;
-	if (thing == null) return [];
-	return [thing];
-}
-
-//#endregion
-//#region src/filter.ts
-const escapeMark = "[_#EsCaPe#_]";
-function getMatcherString(id, resolutionBase) {
-	if (isAbsolute$3(id) || id.startsWith("**")) return normalizePath(id);
-	const basePath = normalizePath(resolve$2("")).replaceAll(/[-^$*+?.()|[\]{}]/g, `${escapeMark}$&`);
-	return join(basePath, normalizePath(id)).replaceAll(escapeMark, "\\");
-}
-/**
-* Constructs a filter function which can be used to determine whether or not
-* certain modules should be operated upon.
-* @param include If `include` is omitted or has zero length, filter will return `true` by default.
-* @param exclude ID must not match any of the `exclude` patterns.
-* @param options Additional options.
-* @param options.resolve Optionally resolves the patterns against a directory other than `process.cwd()`.
-* If a `string` is specified, then the value will be used as the base directory.
-* Relative paths will be resolved against `process.cwd()` first.
-* If `false`, then the patterns will not be resolved against any directory.
-* This can be useful if you want to create a filter for virtual module names.
-*/
-function createFilter(include, exclude, options) {
-	const getMatcher = (id) => id instanceof RegExp ? id : { test: (what) => {
-		const pattern = getMatcherString(id);
-		return pm(pattern, { dot: true })(what);
-	} };
-	const includeMatchers = toArray$1(include).map(getMatcher);
-	const excludeMatchers = toArray$1(exclude).map(getMatcher);
-	if (!includeMatchers.length && !excludeMatchers.length) return (id) => typeof id === "string" && !id.includes("\0");
-	return function result(id) {
-		if (typeof id !== "string") return false;
-		if (id.includes("\0")) return false;
-		const pathId = normalizePath(id);
-		for (const matcher of excludeMatchers) {
-			if (matcher instanceof RegExp) matcher.lastIndex = 0;
-			if (matcher.test(pathId)) return false;
-		}
-		for (const matcher of includeMatchers) {
-			if (matcher instanceof RegExp) matcher.lastIndex = 0;
-			if (matcher.test(pathId)) return true;
-		}
-		return !includeMatchers.length;
-	};
-}
-
-const defaultIncludes = [/\.[jt]sx?$/, /\.vue$/, /\.vue\?vue/, /\.svelte$/];
-const defaultExcludes = [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/];
-function toArray(x) {
-  return x == null ? [] : Array.isArray(x) ? x : [x];
-}
-const unplugin$1 = createUnplugin((options = {}) => {
-  const ctx = createUnimport(options);
-  const filter = createFilter(
-    toArray(options.include || []).length ? options.include : defaultIncludes,
-    options.exclude || defaultExcludes
-  );
-  const dts = options.dts === true ? "unimport.d.ts" : options.dts;
-  const {
-    autoImport = true
-  } = options;
-  return {
-    name: "unimport",
-    enforce: "post",
-    transformInclude(id) {
-      return filter(id);
-    },
-    async transform(code, id) {
-      const s = new MagicString(code);
-      await ctx.injectImports(s, id, {
-        autoImport
-      });
-      if (!s.hasChanged())
-        return;
-      return {
-        code: s.toString(),
-        map: s.generateMap()
-      };
-    },
-    async buildStart() {
-      await ctx.init();
-      if (dts)
-        return promises.writeFile(dts, await ctx.generateTypeDeclarations(), "utf-8");
-    }
-  };
-});
+import { a as genSafeVariableName, b as genImport, c as genString, d as genObjectFromRaw } from './knitwork.mjs';
+import { b as basename } from './pathe.mjs';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -9887,7 +6615,7 @@ async function getWasmImports(asset, _opts) {
       resolved: true
     };
   }
-  const { readPackageJSON } = await import('./index.mjs').then(function (n) { return n.W; });
+  const { readPackageJSON } = await import('./pkg-types.mjs').then(function (n) { return n.i; });
   const pkgJSON = await readPackageJSON(asset.id);
   let resolved = true;
   const imports = [];
@@ -10165,7 +6893,7 @@ const unplugin = createUnplugin((opts) => {
       }
       const buff = Buffer.from(code, "binary");
       const isModule = id.endsWith("?module");
-      const name = `wasm/${basename$1(id.split("?")[0], ".wasm")}-${sha1(buff)}.wasm`;
+      const name = `wasm/${basename(id.split("?")[0], ".wasm")}-${sha1(buff)}.wasm`;
       const parsed = isModule ? { imports: [], exports: ["default"] } : parse(name, buff);
       const asset = assets[name] = {
         name,
@@ -10228,930 +6956,4 @@ const unplugin = createUnplugin((opts) => {
 });
 const rollup = unplugin.rollup;
 
-const PREFIX = "\0virtual:";
-function virtual(modules, cache = {}) {
-  const _modules = /* @__PURE__ */ new Map();
-  for (const [id, mod] of Object.entries(modules)) {
-    cache[id] = mod;
-    _modules.set(id, mod);
-    _modules.set(resolve$2(id), mod);
-  }
-  return {
-    name: "virtual",
-    resolveId(id, importer) {
-      if (id in modules) {
-        return PREFIX + id;
-      }
-      if (importer) {
-        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
-        const resolved = resolve$2(dirname$1(importerNoPrefix), id);
-        if (_modules.has(resolved)) {
-          return PREFIX + resolved;
-        }
-      }
-      return null;
-    },
-    async load(id) {
-      if (!id.startsWith(PREFIX)) {
-        return null;
-      }
-      const idNoPrefix = id.slice(PREFIX.length);
-      if (!_modules.has(idNoPrefix)) {
-        return null;
-      }
-      let m = _modules.get(idNoPrefix);
-      if (typeof m === "function") {
-        m = await m();
-      }
-      if (!m) {
-        return null;
-      }
-      cache[id.replace(PREFIX, "")] = m;
-      return {
-        code: m,
-        map: null
-      };
-    }
-  };
-}
-
-function database(nitro) {
-  if (!nitro.options.experimental.database) {
-    return virtual(
-      {
-        "#nitro-internal-virtual/database": () => {
-          return (
-            /* js */
-            `export const connectionConfigs = {};`
-          );
-        }
-      },
-      nitro.vfs
-    );
-  }
-  const dbConfigs = nitro.options.dev && nitro.options.devDatabase || nitro.options.database;
-  const connectorsNames = [
-    ...new Set(
-      Object.values(dbConfigs || {}).map((config) => config?.connector)
-    )
-  ].filter(Boolean);
-  for (const name of connectorsNames) {
-    if (!connectors[name]) {
-      throw new Error(`Database connector "${name}" is invalid.`);
-    }
-  }
-  return virtual(
-    {
-      "#nitro-internal-virtual/database": () => {
-        return `
-${connectorsNames.map(
-          (name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`
-        ).join("\n")}
-
-export const connectionConfigs = {
-  ${Object.entries(dbConfigs || {}).map(
-          ([name, { connector, options }]) => `${name}: {
-          connector: ${camelCase(connector)}Connector,
-          options: ${JSON.stringify(options)}
-        }`
-        ).join(",\n")}
-};
-        `;
-      }
-    },
-    nitro.vfs
-  );
-}
-
-const RuntimeRouteRules = [
-  "headers",
-  "redirect",
-  "proxy",
-  "cache"
-];
-function routing(nitro) {
-  return virtual(
-    {
-      // --- routing (routes, routeRules and middleware) ---
-      "#nitro-internal-virtual/routing": () => {
-        const allHandlers = uniqueBy(
-          [
-            ...Object.values(nitro.routing.routes.routes).map((h) => h.data),
-            ...Object.values(nitro.routing.routedMiddleware.routes).map(
-              (h) => h.data
-            ),
-            ...nitro.routing.globalMiddleware
-          ],
-          "_importHash"
-        );
-        const h3Imports = [
-          (nitro.options.serverEntry || allHandlers.some((h) => !h.lazy)) && "toEventHandler",
-          allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
-        ].filter(Boolean);
-        return (
-          /* js */
-          `
-import * as __routeRules__ from "nitro/runtime/internal/route-rules";
-${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
-import {${h3Imports.join(", ")}} from "h3";
-
-export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
-
-${allHandlers.filter((h) => !h.lazy).map((h) => (
-            /* js */
-            `import ${h._importHash} from "${h.handler}";`
-          )).join("\n")}
-
-${allHandlers.filter((h) => h.lazy).map(
-            (h) => (
-              /* js */
-              `const ${h._importHash} = defineLazyEventHandler(() => import("${h.handler}"));`
-            )
-          ).join("\n")}
-
-export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
-
-export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
-
-export const globalMiddleware = [${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}];
-
-${nitro.options.serverEntry && /* js */
-          `const serverEntry = toEventHandler(__serverEntry__);
-if (serverEntry) { globalMiddleware.push(serverEntry) }`}
-  `
-        );
-      },
-      // --- routing-meta ---
-      "#nitro-internal-virtual/routing-meta": () => {
-        const routeHandlers = uniqueBy(
-          Object.values(nitro.routing.routes.routes).map((h) => h.data),
-          "_importHash"
-        );
-        return (
-          /* js */
-          `
-  ${routeHandlers.map(
-            (h) => (
-              /* js */
-              `import ${h._importHash}Meta from "${h.handler}?meta";`
-            )
-          ).join("\n")}
-export const handlersMeta = [
-  ${routeHandlers.map(
-            (h) => (
-              /* js */
-              `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(
-                h.method?.toLowerCase()
-              )}, meta: ${h._importHash}Meta }`
-            )
-          ).join(",\n")}
-  ];
-        `.trim()
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-function uniqueBy(arr, key) {
-  return [...new Map(arr.map((item) => [item[key], item])).values()];
-}
-function serializeHandler(h) {
-  return `{${[
-    `route:${JSON.stringify(h.route)}`,
-    h.method && `method:${JSON.stringify(h.method)}`,
-    h.meta && `meta:${JSON.stringify(h.meta)}`,
-    `handler:${h.lazy ? h._importHash : `toEventHandler(${h._importHash})`}`
-  ].filter(Boolean).join(",")}}`;
-}
-function serializeRouteRule(h) {
-  return `[${Object.entries(h).filter(([name, options]) => options !== void 0 && name[0] !== "_").map(([name, options]) => {
-    return `{${[
-      `name:${JSON.stringify(name)}`,
-      `route:${JSON.stringify(h._route)}`,
-      h._method && `method:${JSON.stringify(h._method)}`,
-      RuntimeRouteRules.includes(name) && `handler:__routeRules__.${name}`,
-      `options:${JSON.stringify(options)}`
-    ].filter(Boolean).join(",")}}`;
-  }).join(",")}]`;
-}
-
-const virtualPrefix = "\0nitro-handler-meta:";
-const esbuildLoaders = {
-  ".ts": "ts",
-  ".js": "js",
-  ".tsx": "tsx",
-  ".jsx": "jsx"
-};
-function routeMeta(nitro) {
-  return {
-    name: "nitro:route-meta",
-    async resolveId(id, importer, resolveOpts) {
-      if (id.startsWith("\0")) {
-        return;
-      }
-      if (id.endsWith(`?meta`)) {
-        const resolved = await this.resolve(
-          id.replace(`?meta`, ``),
-          importer,
-          resolveOpts
-        );
-        if (!resolved) {
-          return;
-        }
-        return virtualPrefix + resolved.id;
-      }
-    },
-    load(id) {
-      if (id.startsWith(virtualPrefix)) {
-        const fullPath = id.slice(virtualPrefix.length);
-        return readFile(fullPath, { encoding: "utf8" });
-      }
-    },
-    async transform(code, id) {
-      if (!id.startsWith(virtualPrefix)) {
-        return;
-      }
-      let meta = null;
-      try {
-        const ext = extname$1(id);
-        const jsCode = await transform(code, {
-          loader: esbuildLoaders[ext]
-        }).then((r) => r.code);
-        const ast = this.parse(jsCode);
-        for (const node of ast.body) {
-          if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "defineRouteMeta" && node.expression.arguments.length === 1) {
-            meta = astToObject(node.expression.arguments[0]);
-            break;
-          }
-        }
-      } catch (error) {
-        nitro.logger.warn(
-          `[handlers-meta] Cannot extra route meta for: ${id}: ${error}`
-        );
-      }
-      return {
-        code: `export default ${JSON.stringify(meta)};`,
-        map: null
-      };
-    }
-  };
-}
-function astToObject(node) {
-  switch (node.type) {
-    case "ObjectExpression": {
-      const obj = {};
-      for (const prop of node.properties) {
-        if (prop.type === "Property") {
-          const key = prop.key.name ?? prop.key.value;
-          obj[key] = astToObject(prop.value);
-        }
-      }
-      return obj;
-    }
-    case "ArrayExpression": {
-      return node.elements.map((el) => astToObject(el)).filter(Boolean);
-    }
-    case "Literal": {
-      return node.value;
-    }
-  }
-}
-
-function serverMain(nitro) {
-  return {
-    name: "nitro:server-main",
-    renderChunk(code, chunk) {
-      if (chunk.isEntry) {
-        return {
-          code: `globalThis.__nitro_main__ = import.meta.url; ${code}`,
-          map: null
-        };
-      }
-    }
-  };
-}
-
-var etagExports = requireEtag();
-const createEtag = /*@__PURE__*/getDefaultExportFromCjs(etagExports);
-
-const readAssetHandler = {
-  true: "node",
-  node: "node",
-  false: "null",
-  deno: "deno",
-  inline: "inline"
-};
-function publicAssets(nitro) {
-  return virtual(
-    {
-      // #nitro-internal-virtual/public-assets-data
-      "#nitro-internal-virtual/public-assets-data": async () => {
-        const assets = {};
-        const files = await glob("**", {
-          cwd: nitro.options.output.publicDir,
-          absolute: false,
-          dot: true
-        });
-        for (const id of files) {
-          let mimeType = mime.getType(id.replace(/\.(gz|br)$/, "")) || "text/plain";
-          if (mimeType.startsWith("text")) {
-            mimeType += "; charset=utf-8";
-          }
-          const fullPath = resolve$2(nitro.options.output.publicDir, id);
-          const assetData = await promises.readFile(fullPath);
-          const etag = createEtag(assetData);
-          const stat = await promises.stat(fullPath);
-          const assetId = "/" + decodeURIComponent(id);
-          let encoding;
-          if (id.endsWith(".gz")) {
-            encoding = "gzip";
-          } else if (id.endsWith(".br")) {
-            encoding = "br";
-          }
-          assets[assetId] = {
-            type: nitro._prerenderMeta?.[assetId]?.contentType || mimeType,
-            encoding,
-            etag,
-            mtime: stat.mtime.toJSON(),
-            size: stat.size,
-            path: relative(nitro.options.output.serverDir, fullPath),
-            data: nitro.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
-          };
-        }
-        return `export default ${JSON.stringify(assets, null, 2)};`;
-      },
-      // #nitro-internal-virtual/public-assets-node
-      "#nitro-internal-virtual/public-assets-node": () => {
-        return `
-import { promises as fsp } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { resolve, dirname } from 'node:path'
-import assets from '#nitro-internal-virtual/public-assets-data'
-export function readAsset (id) {
-  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
-  return fsp.readFile(resolve(serverDir, assets[id].path))
-}`;
-      },
-      // #nitro-internal-virtual/public-assets-deno
-      "#nitro-internal-virtual/public-assets-deno": () => {
-        return `
-import assets from '#nitro-internal-virtual/public-assets-data'
-export function readAsset (id) {
-  // https://deno.com/deploy/docs/serve-static-assets
-  const path = '.' + decodeURIComponent(new URL(\`../public\${id}\`, 'file://').pathname)
-  return Deno.readFile(path);
-}`;
-      },
-      // #nitro-internal-virtual/public-assets-null
-      "#nitro-internal-virtual/public-assets-null": () => {
-        return `
-    export function readAsset (id) {
-        return Promise.resolve(null);
-    }`;
-      },
-      // #nitro-internal-virtual/public-assets-inline
-      "#nitro-internal-virtual/public-assets-inline": () => {
-        return `
-  import assets from '#nitro-internal-virtual/public-assets-data'
-  export function readAsset (id) {
-    if (!assets[id]) { return undefined }
-    if (assets[id]._data) { return assets[id]._data }
-    if (!assets[id].data) { return assets[id].data }
-    assets[id]._data = Uint8Array.from(atob(assets[id].data), (c) => c.charCodeAt(0))
-    return assets[id]._data
-}`;
-      },
-      // #nitro-internal-virtual/public-assets
-      "#nitro-internal-virtual/public-assets": () => {
-        const publicAssetBases = Object.fromEntries(
-          nitro.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [
-            withTrailingSlash(dir.baseURL),
-            { maxAge: dir.maxAge }
-          ])
-        );
-        const handlerName = readAssetHandler[nitro.options.serveStatic] || "null";
-        const readAssetImport = `#nitro-internal-virtual/public-assets-${handlerName}`;
-        return `
-import assets from '#nitro-internal-virtual/public-assets-data'
-export { readAsset } from "${readAssetImport}"
-export const publicAssetBases = ${JSON.stringify(publicAssetBases)}
-
-export function isPublicAssetURL(id = '') {
-  if (assets[id]) {
-    return true
-  }
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return true }
-  }
-  return false
-}
-
-export function getPublicAssetMeta(id = '') {
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return publicAssetBases[base] }
-  }
-  return {}
-}
-
-export function getAsset (id) {
-  return assets[id]
-}
-`;
-      }
-    },
-    nitro.vfs
-  );
-}
-
-const HELPER_ID = "\0raw-helpers";
-function raw(opts = {}) {
-  const extensions = /* @__PURE__ */ new Set([
-    ".md",
-    ".mdx",
-    ".txt",
-    ".css",
-    ".htm",
-    ".html",
-    ".sql",
-    ...opts.extensions || []
-  ]);
-  return {
-    name: "raw",
-    async resolveId(id, importer, resolveOpts) {
-      if (id === HELPER_ID) {
-        return id;
-      }
-      if (id[0] === "\0") {
-        return;
-      }
-      const withRawSpecifier = id.startsWith("raw:");
-      if (withRawSpecifier) {
-        id = id.slice(4);
-      }
-      if (!withRawSpecifier && !extensions.has(extname$1(id))) {
-        return;
-      }
-      const resolvedId = (await this.resolve(id, importer, resolveOpts))?.id;
-      if (!resolvedId || resolvedId.startsWith("\0")) {
-        return resolvedId;
-      }
-      if (!withRawSpecifier && !extensions.has(extname$1(resolvedId))) {
-        return;
-      }
-      return { id: "\0raw:" + resolvedId };
-    },
-    load(id) {
-      if (id === HELPER_ID) {
-        return getHelpers();
-      }
-      if (id.startsWith("\0raw:")) {
-        return promises.readFile(id.slice(5), isBinary(id) ? "binary" : "utf8");
-      }
-    },
-    transform(code, id) {
-      if (!id.startsWith("\0raw:")) {
-        return;
-      }
-      if (isBinary(id)) {
-        const serialized = Buffer.from(code, "binary").toString("base64");
-        return {
-          code: `// ROLLUP_NO_REPLACE 
- import {base64ToUint8Array } from "${HELPER_ID}" 
- export default base64ToUint8Array("${serialized}")`,
-          map: null
-        };
-      }
-      return {
-        code: `// ROLLUP_NO_REPLACE 
- export default ${JSON.stringify(code)}`,
-        map: null,
-        moduleType: "js"
-      };
-    }
-  };
-}
-function isBinary(id) {
-  const idMime = mime.getType(id) || "";
-  if (idMime.startsWith("text/")) {
-    return false;
-  }
-  if (/application\/(json|sql|xml|yaml)/.test(idMime)) {
-    return false;
-  }
-  return true;
-}
-function getHelpers() {
-  const js = String.raw;
-  return js`
-export function base64ToUint8Array(str) {
-  const data = atob(str);
-  const size = data.length;
-  const bytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    bytes[i] = data.charCodeAt(i);
-  }
-  return bytes;
-}
-  `;
-}
-
-function serverAssets(nitro) {
-  if (nitro.options.dev || nitro.options.preset === "nitro-prerender") {
-    return virtual(
-      { "#nitro-internal-virtual/server-assets": getAssetsDev(nitro) },
-      nitro.vfs
-    );
-  }
-  return virtual(
-    {
-      "#nitro-internal-virtual/server-assets": async () => {
-        const assets = {};
-        for (const asset of nitro.options.serverAssets) {
-          const files = await glob(asset.pattern || "**/*", {
-            cwd: asset.dir,
-            absolute: false,
-            ignore: asset.ignore
-          });
-          for (const _id of files) {
-            const fsPath = resolve$2(asset.dir, _id);
-            const id = asset.baseName + "/" + _id;
-            assets[id] = { fsPath, meta: {} };
-            let type = mime.getType(id) || "text/plain";
-            if (type.startsWith("text")) {
-              type += "; charset=utf-8";
-            }
-            const etag = createEtag(await promises.readFile(fsPath));
-            const mtime = await promises.stat(fsPath).then((s) => s.mtime.toJSON());
-            assets[id].meta = { type, etag, mtime };
-          }
-        }
-        return getAssetProd(assets);
-      }
-    },
-    nitro.vfs
-  );
-}
-function getAssetsDev(nitro) {
-  return `
-import { createStorage } from 'unstorage'
-import fsDriver from 'unstorage/drivers/fs'
-
-const serverAssets = ${JSON.stringify(nitro.options.serverAssets)}
-
-export const assets = createStorage()
-
-for (const asset of serverAssets) {
-  assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
-}`;
-}
-function getAssetProd(assets) {
-  return `
-const _assets = {
-${Object.entries(assets).map(
-    ([id, asset]) => `  [${JSON.stringify(
-      normalizeKey(id)
-    )}]: {
-    import: () => import(${JSON.stringify(
-      "raw:" + asset.fsPath
-    )}).then(r => r.default || r),
-    meta: ${JSON.stringify(
-      asset.meta
-    )}
-  }`
-  ).join(",\n")}
-}
-
-const normalizeKey = ${normalizeKey.toString()}
-
-export const assets = {
-  getKeys() {
-    return Promise.resolve(Object.keys(_assets))
-  },
-  hasItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(id in _assets)
-  },
-  getItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
-  },
-  getMeta (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
-  }
-}
-`;
-}
-
-function storage(nitro) {
-  const mounts = [];
-  const isDevOrPrerender = nitro.options.dev || nitro.options.preset === "nitro-prerender";
-  const storageMounts = isDevOrPrerender ? { ...nitro.options.storage, ...nitro.options.devStorage } : nitro.options.storage;
-  for (const path in storageMounts) {
-    const mount = storageMounts[path];
-    mounts.push({
-      path,
-      driver: builtinDrivers[mount.driver] || mount.driver,
-      opts: mount
-    });
-  }
-  const driverImports = [...new Set(mounts.map((m) => m.driver))];
-  const bundledStorageCode = `
-import { prefixStorage } from 'unstorage'
-import overlay from 'unstorage/drivers/overlay'
-import memory from 'unstorage/drivers/memory'
-
-const bundledStorage = ${JSON.stringify(nitro.options.bundledStorage)}
-for (const base of bundledStorage) {
-  storage.mount(base, overlay({
-    layers: [
-      memory(),
-      // TODO
-      // prefixStorage(storage, base),
-      prefixStorage(storage, 'assets:nitro:bundled:' + base)
-    ]
-  }))
-}`;
-  return virtual(
-    {
-      "#nitro-internal-virtual/storage": (
-        /* js */
-        `
-import { createStorage } from 'unstorage'
-import { assets } from '#nitro-internal-virtual/server-assets'
-
-${driverImports.map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
-
-export function initStorage() {
-  const storage = createStorage({})
-  storage.mount('/assets', assets)
-  ${mounts.map(
-          (m) => `storage.mount('${m.path}', ${genSafeVariableName(
-            m.driver
-          )}(${JSON.stringify(m.opts)}))`
-        ).join("\n")}
-
-  ${!isDevOrPrerender && nitro.options.bundledStorage.length > 0 ? bundledStorageCode : ""}
-  return storage
-}
-`
-      )
-    },
-    nitro.vfs
-  );
-}
-
-function errorHandler(nitro) {
-  return virtual(
-    {
-      "#nitro-internal-virtual/error-handler": () => {
-        const errorHandlers = Array.isArray(nitro.options.errorHandler) ? nitro.options.errorHandler : [nitro.options.errorHandler];
-        const builtinHandler = join(
-          runtimeDir,
-          `internal/error/${nitro.options.dev ? "dev" : "prod"}`
-        );
-        return (
-          /* js */
-          `
-${errorHandlers.map((h, i) => `import errorHandler$${i} from "${h}";`).join("\n")}
-
-const errorHandlers = [${errorHandlers.map((_, i) => `errorHandler$${i}`).join(", ")}];
-
-import { defaultHandler } from "${builtinHandler}";
-
-export default async function(error, event) {
-  for (const handler of errorHandlers) {
-    try {
-      const response = await handler(error, event, { defaultHandler });
-      if (response) {
-        return response;
-      }
-    } catch(error) {
-      // Handler itself thrown, log and continue
-      console.error(error);
-    }
-  }
-  // H3 will handle fallback
-}
-`
-        );
-      }
-    },
-    nitro.vfs
-  );
-}
-
-function rendererTemplate(nitro) {
-  return virtual(
-    {
-      "#nitro-internal-virtual/renderer-template": async () => {
-        if (typeof nitro.options.renderer?.template !== "string") {
-          return `export const rendererTemplate = () => '<!-- renderer.template is not set -->'; export const rendererTemplateFile = undefined;`;
-        }
-        if (nitro.options.dev) {
-          return `import { readFile } from 'node:fs/promises';export const rendererTemplate = () => readFile(${JSON.stringify(nitro.options.renderer?.template)}, "utf8"); export const rendererTemplateFile = ${JSON.stringify(
-            nitro.options.renderer?.template
-          )};`;
-        } else {
-          const html = await readFile(nitro.options.renderer?.template, "utf8");
-          if (hasTemplateSyntax(html)) {
-            const template = compileTemplateToString(html, {
-              contextKeys: [...RENDER_CONTEXT_KEYS]
-            });
-            return (
-              /* js */
-              `
-            import { renderToResponse } from 'rendu'
-            const template = ${template};
-            export const rendererTemplate = (request) => renderToResponse(template, { request })
-            `
-            );
-          } else {
-            return (
-              /* js */
-              `
-              import { HTTPResponse } from "h3";
-              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
-            `
-            );
-          }
-        }
-      }
-    },
-    nitro.vfs
-  );
-}
-
-function baseBuildPlugins(nitro, base) {
-  const plugins = [];
-  if (nitro.options.imports) {
-    plugins.push(unplugin$1.rollup(nitro.options.imports));
-  }
-  plugins.push(raw());
-  if (nitro.options.experimental.wasm) {
-    plugins.push(rollup(nitro.options.wasm || {}));
-  }
-  plugins.push(serverMain());
-  const nitroPlugins = [...new Set(nitro.options.plugins)];
-  plugins.push(
-    virtual(
-      {
-        "#nitro-internal-virtual/plugins": (
-          /* js */
-          `
-  ${nitroPlugins.map(
-            (plugin) => `import _${hash(plugin).replace(/-/g, "")} from '${plugin}';`
-          ).join("\n")}
-
-  export const plugins = [
-    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
-  ]
-      `
-        )
-      },
-      nitro.vfs
-    )
-  );
-  plugins.push(serverAssets(nitro));
-  plugins.push(publicAssets(nitro));
-  plugins.push(storage(nitro));
-  plugins.push(database(nitro));
-  plugins.push(routing(nitro));
-  if (nitro.options.experimental.openAPI) {
-    plugins.push(routeMeta(nitro));
-  }
-  plugins.push(errorHandler(nitro));
-  plugins.push(
-    virtual(
-      {
-        "#nitro-internal-pollyfills": base.env.polyfill.map((p) => (
-          /* js */
-          `import '${p}';`
-        )).join("\n") || /* js */
-        `/* No polyfills */`
-      },
-      nitro.vfs
-    )
-  );
-  plugins.push(virtual(nitro.options.virtual, nitro.vfs));
-  if (nitro.options.renderer?.template) {
-    plugins.push(rendererTemplate(nitro));
-  }
-  if (nitro.options.noExternals) {
-    plugins.push({
-      name: "no-externals",
-      async resolveId(id, importer, resolveOpts) {
-        if (resolveOpts.custom?.skipNoExternals) {
-          return;
-        }
-        id = base.aliases[id] || id;
-        if (base.env.external.includes(id) || nitro.options.node && (id.startsWith("node:") || builtinModules.includes(id))) {
-          return { id, external: true };
-        }
-        const resolved = await this.resolve(id, importer, resolveOpts);
-        if (!resolved) {
-          const _resolved = resolveModulePath(id, {
-            try: true,
-            from: importer && isAbsolute$3(importer) ? [pathToFileURL(importer), ...nitro.options.nodeModulesDirs] : nitro.options.nodeModulesDirs,
-            suffixes: ["", "/index"],
-            extensions: [".mjs", ".cjs", ".js", ".mts", ".cts", ".ts", ".json"],
-            conditions: [
-              "default",
-              nitro.options.dev ? "development" : "production",
-              "node",
-              "import",
-              "require"
-            ]
-          });
-          if (_resolved) {
-            return { id: _resolved, external: false };
-          }
-        }
-        if (!resolved || resolved.external && !id.endsWith(".wasm")) {
-          throw new Error(
-            `Cannot resolve ${JSON.stringify(id)} from ${JSON.stringify(
-              importer
-            )} and externals are not allowed!`
-          );
-        }
-      }
-    });
-  } else {
-    plugins.push(
-      rollupNodeFileTrace(
-        defu(nitro.options.externals, {
-          outDir: nitro.options.output.serverDir,
-          moduleDirectories: nitro.options.nodeModulesDirs,
-          external: [
-            ...nitro.options.dev ? [nitro.options.buildDir] : [],
-            ...nitro.options.nodeModulesDirs
-          ],
-          inline: [
-            "#",
-            "~",
-            "@/",
-            "~~",
-            "@@/",
-            "virtual:",
-            "nitro/runtime",
-            "nitro/runtime",
-            dirname$1(nitro.options.entry),
-            ...nitro.options.experimental.wasm ? [(id) => id?.endsWith(".wasm")] : [],
-            runtimeDir,
-            nitro.options.srcDir,
-            ...nitro.options.handlers.map((m) => m.handler).filter((i) => typeof i === "string"),
-            ...nitro.options.dev || nitro.options.preset === "nitro-prerender" || nitro.options.experimental.bundleRuntimeDependencies === false ? [] : runtimeDependencies
-          ],
-          traceOptions: {
-            base: "/",
-            processCwd: nitro.options.rootDir,
-            exportsOnly: true
-          },
-          traceAlias: {
-            "h3-nightly": "h3",
-            ...nitro.options.externals?.traceAlias
-          },
-          exportConditions: nitro.options.exportConditions,
-          writePackageJson: true
-        })
-      )
-    );
-  }
-  return plugins;
-}
-
-const presetsWithConfig = ["awsAmplify", "awsLambda", "azure", "cloudflare", "firebase", "netlify", "vercel"];
-
-async function writeBuildInfo(nitro) {
-  const buildInfoPath = resolve$2(nitro.options.output.dir, "nitro.json");
-  const buildInfo = {
-    date: (/* @__PURE__ */ new Date()).toJSON(),
-    preset: nitro.options.preset,
-    framework: nitro.options.framework,
-    versions: {
-      nitro: version
-    },
-    commands: {
-      preview: nitro.options.commands.preview,
-      deploy: nitro.options.commands.deploy
-    },
-    config: {
-      ...Object.fromEntries(
-        presetsWithConfig.map((key) => [key, nitro.options[key]])
-      )
-    }
-  };
-  await writeFile(buildInfoPath, JSON.stringify(buildInfo, null, 2), true);
-  const lastBuild = resolve$2(
-    nitro.options.rootDir,
-    "node_modules/.nitro/last-build"
-  );
-  await mkdir(dirname(lastBuild), { recursive: true });
-  await unlink(lastBuild).catch(() => {
-  });
-  await symlink(nitro.options.output.dir, lastBuild).catch(console.warn);
-  return buildInfo;
-}
-
-export { attachScopes as a, baseBuildConfig as b, createFilter$2 as c, baseBuildPlugins as d, writeBuildInfo as e, extractAssignedNames as f, dataToEsm as g, createFilter as h, makeLegalIdentifier as m, replace as r, walk as w };
+export { rollup as r };