@vite-hub/workflow 0.0.1 → 0.0.2

package/dist/module-UYEnVfxy.js

@@ -1,1546 +0,0 @@
-import { t as normalizeWorkflowOptions } from "./config-DkgsQuXz.js";
-import { r as getCloudflareWorkflowClassName, t as createCloudflareWorkflowBindings } from "./cloudflare-CeHVSHoN.js";
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import path, { isAbsolute, join, relative, resolve } from "node:path";
-import fs, { existsSync, lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
-import { basename as basename$1, dirname, normalize, relative as relative$1, resolve as resolve$1 } from "pathe";
-import assert from "node:assert";
-import process$1 from "node:process";
-import v8 from "node:v8";
-import { format, inspect } from "node:util";
-//#region ../internal/src/build/paths.ts
-function generatedDirSegments(productName) {
-	return [".vitehub", productName];
-}
-function ensureGeneratedDir(rootDir, productName) {
-	return resolve$1(rootDir, ...generatedDirSegments(productName));
-}
-function computePackageDir(importMetaUrl) {
-	const currentFileDir = dirname(fileURLToPath(importMetaUrl));
-	return resolve$1(currentFileDir, basename$1(currentFileDir) === "internal" ? "../.." : "..");
-}
-function resolveRuntimeModule(packageDir, modulePath) {
-	const distFile = resolve$1(packageDir, "dist", `${modulePath}.js`);
-	return existsSync(distFile) ? distFile : resolve$1(packageDir, "src", `${modulePath}.ts`);
-}
-function createImportPath(fromFile, targetFile) {
-	const importPath = relative$1(realpathIfExists(dirname(fromFile)), realpathIfExists(targetFile));
-	return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}
-function realpathIfExists(path) {
-	try {
-		return realpathSync.native(path);
-	} catch {
-		return resolve$1(path);
-	}
-}
-//#endregion
-//#region ../internal/src/definition-catalog.ts
-const sourceFilePattern$1 = /\.(?:c|m)?[jt]s$/i;
-const declarationFilePattern$1 = /\.d\.(?:c|m)?[jt]s$/i;
-const ignoredDirs = new Set([
-	"node_modules",
-	"dist",
-	".nitro",
-	".output",
-	".nuxt",
-	".vercel",
-	".git",
-	".vitehub"
-]);
-function resolveDefinitionScanRoots(rootDir, scanDirs = []) {
-	return [...new Set([rootDir, ...scanDirs].filter(Boolean))];
-}
-function createDirectoryDefinitionSource(source, scanDirs, subdir, options = {}) {
-	return {
-		...options,
-		kind: "directory",
-		scanDirs,
-		source,
-		subdir
-	};
-}
-function createSuffixDefinitionSource(source, roots, pattern, normalizeName, options = {}) {
-	return {
-		...options,
-		kind: "suffix",
-		normalizeName,
-		pattern,
-		roots,
-		source
-	};
-}
-function readDirEntries$1(root) {
-	try {
-		return readdirSync(root, { withFileTypes: true });
-	} catch (error) {
-		if (error.code === "ENOENT") return [];
-		throw error;
-	}
-}
-function listMatchingFiles(root, predicate, options = {}) {
-	const files = [];
-	for (const entry of readDirEntries$1(root)) {
-		const absolute = resolve$1(root, entry.name);
-		if (entry.isDirectory() && !entry.isSymbolicLink()) {
-			if (entry.name.startsWith(".")) continue;
-			if (ignoredDirs.has(entry.name)) continue;
-			files.push(...listMatchingFiles(absolute, predicate, options));
-			continue;
-		}
-		if (entry.name.startsWith(".") && !options.includeHidden) continue;
-		if (entry.isFile() && predicate(entry.name)) files.push(absolute);
-	}
-	return files.sort();
-}
-function listSourceFiles(root, options = {}) {
-	return listMatchingFiles(root, (name) => sourceFilePattern$1.test(name) && !declarationFilePattern$1.test(name), options);
-}
-function normalizePathDefinitionName(rootDir, file) {
-	return relative$1(rootDir, file).replace(sourceFilePattern$1, "").replace(/\/index$/i, "");
-}
-function normalizeSuffixDefinitionName(rootDir, file, pattern, options = {}) {
-	const normalized = relative$1(rootDir, file).replace(pattern, "");
-	if (options.stripPrefix && normalized.startsWith(options.stripPrefix)) return normalized.slice(options.stripPrefix.length);
-	return normalized;
-}
-function sortDefinitions(definitions) {
-	return [...definitions.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-function registerDefinition(definitions, definition, sourceLabel) {
-	const existing = definitions.get(definition.name);
-	if (existing) throw new Error(`Duplicate ${sourceLabel} name "${definition.name}":\n  - ${existing.handler}\n  - ${definition.handler}`);
-	definitions.set(definition.name, definition);
-}
-function mergeDefinitions(feature, ...sources) {
-	const definitions = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		if (!source) continue;
-		for (const definition of source) {
-			const existing = definitions.get(definition.name);
-			if (existing && existing.handler !== definition.handler) throw new Error(`Duplicate ${feature} name "${definition.name}" from multiple discovery sources:\n  - ${existing.handler} (${existing.source ?? "unknown"})\n  - ${definition.handler} (${definition.source ?? "unknown"})`);
-			if (!existing) definitions.set(definition.name, definition);
-		}
-	}
-	return sortDefinitions(definitions);
-}
-function createDefinition(source, file, name) {
-	if (source.createDefinition) return source.createDefinition({
-		file,
-		name
-	});
-	return {
-		handler: file,
-		name,
-		source: source.source
-	};
-}
-function scanSuffixDefinitions(feature, source) {
-	const definitions = /* @__PURE__ */ new Map();
-	for (const root of source.roots) for (const file of listMatchingFiles(root, (name) => source.pattern.test(name), { includeHidden: source.includeHidden })) {
-		const name = source.normalizeName(root, file);
-		if (!name) continue;
-		registerDefinition(definitions, createDefinition(source, file, name), feature);
-	}
-	return sortDefinitions(definitions);
-}
-function scanDirectoryDefinitions(feature, source) {
-	const definitions = /* @__PURE__ */ new Map();
-	for (const scanDir of source.scanDirs) {
-		const directory = resolve$1(scanDir, source.subdir);
-		for (const file of listSourceFiles(directory, { includeHidden: source.includeHidden })) {
-			const name = source.normalizeName ? source.normalizeName(directory, file) : normalizePathDefinitionName(directory, file);
-			if (!name) continue;
-			registerDefinition(definitions, createDefinition(source, file, name), feature);
-		}
-	}
-	return sortDefinitions(definitions);
-}
-function discoverDefinitions(feature, sources) {
-	return mergeDefinitions(feature, ...sources.map((source) => source.kind === "suffix" ? scanSuffixDefinitions(feature, source) : scanDirectoryDefinitions(feature, source)));
-}
-function createImportExpression(registryFile, file) {
-	const importPath = relative$1(resolve$1(registryFile, ".."), file);
-	return `import(${JSON.stringify(importPath.startsWith(".") ? importPath : `./${importPath}`)})`;
-}
-function createRuntimeRegistryContents(registryFile, definitions) {
-	const needsWorkflowRuntime = definitions.some((definition) => definition.steps?.length);
-	const runtimeImport = needsWorkflowRuntime ? [`import { createWorkflowSteps } from "@vite-hub/workflow/runtime/execute"`, `import { takeInlineWorkflowDefinitionForModule } from "@vite-hub/workflow/runtime/state"`] : [];
-	const imports = definitions.map((definition) => {
-		if (!definition.steps?.length) return `  ${JSON.stringify(definition.name)}: async () => ${createImportExpression(registryFile, definition.handler)},`;
-		const workflowDirectory = /\.(?:c|m)?[jt]s$/i.test(definition.handler) ? dirname(definition.handler) : definition.handler;
-		const stepImports = definition.steps.map((step) => {
-			const stepName = relative$1(workflowDirectory, step);
-			return `{ name: ${JSON.stringify(stepName)}, run: (await ${createImportExpression(registryFile, step)}).default }`;
-		});
-		const hasIndex = /\.(?:c|m)?[jt]s$/i.test(definition.handler);
-		const indexImport = hasIndex ? `const index = await ${createImportExpression(registryFile, definition.handler)}` : "";
-		const handler = hasIndex ? `index.default?.handler ? index.default : takeInlineWorkflowDefinitionForModule(${JSON.stringify(definition.name)}, index) || { handler: index.default }` : "{ handler: async (context) => { let value = context.payload; for (const step of Object.values(context.steps || {})) value = await step(value); return value } }";
-		return [
-			`  ${JSON.stringify(definition.name)}: async () => {`,
-			`    const cached = registryEntryCache.get(${JSON.stringify(definition.name)})`,
-			"    if (cached) return cached",
-			indexImport ? `    ${indexImport}` : "",
-			`    const steps = [${stepImports.join(", ")}]`,
-			`    const definition = ${handler}`,
-			"    const entry = {",
-			"      ...definition,",
-			"      options: { ...definition.options, rootStep: false },",
-			"      handler: async (context) => {",
-			"        const workflowSteps = createWorkflowSteps(context, steps)",
-			"        return await definition.handler({ ...context, steps: workflowSteps })",
-			"      },",
-			"    }",
-			`    registryEntryCache.set(${JSON.stringify(definition.name)}, entry)`,
-			"    return entry",
-			"  },"
-		].filter(Boolean).join("\n");
-	});
-	return [
-		...runtimeImport,
-		runtimeImport.length ? "" : "",
-		...needsWorkflowRuntime ? ["const registryEntryCache = new Map()", ""] : [],
-		"const registry = {",
-		...imports,
-		"}",
-		"",
-		"export default registry",
-		""
-	].join("\n");
-}
-function createGeneratedDefinitionPath(rootDir, options) {
-	const segments = options.segments ?? generatedDirSegments(options.productName);
-	return resolve$1(...options.buildDir ? [
-		rootDir,
-		options.buildDir,
-		...segments,
-		options.fileName
-	] : [
-		rootDir,
-		...segments,
-		options.fileName
-	]);
-}
-function createNitroRuntimeFilePath(rootDir, options) {
-	return createGeneratedDefinitionPath(rootDir, options);
-}
-async function writeRuntimeRegistryFiles(options) {
-	await Promise.all([writeFileIfChanged(options.registryFile, createRuntimeRegistryContents(options.registryFile, options.definitions)), writeFileIfChanged(options.pluginFile, options.createPluginContents(options.pluginFile, options.registryFile))]);
-	return {
-		definitions: options.definitions,
-		pluginFile: options.pluginFile,
-		registryFile: options.registryFile
-	};
-}
-function applyNitroRuntimeAliases(nitro, aliases) {
-	nitro.options.alias ||= {};
-	Object.assign(nitro.options.alias, aliases);
-}
-function hookNitroRuntimeRegistryRefresh(nitro, refresh, onRefresh = () => {}) {
-	for (const hookName of ["build:before", "dev:reload"]) nitro.hooks.hook(hookName, async () => {
-		await onRefresh(await refresh(), hookName);
-	});
-}
-async function writeFileIfChanged(file, contents) {
-	if (await readFile(file, "utf8").catch(() => void 0) === contents) return;
-	await mkdir(resolve$1(file, ".."), { recursive: true });
-	await writeFile(file, contents, "utf8");
-}
-//#endregion
-//#region ../../node_modules/.pnpm/exsolve@1.0.8/node_modules/exsolve/dist/index.mjs
-const nodeBuiltins = [
-	"_http_agent",
-	"_http_client",
-	"_http_common",
-	"_http_incoming",
-	"_http_outgoing",
-	"_http_server",
-	"_stream_duplex",
-	"_stream_passthrough",
-	"_stream_readable",
-	"_stream_transform",
-	"_stream_wrap",
-	"_stream_writable",
-	"_tls_common",
-	"_tls_wrap",
-	"assert",
-	"assert/strict",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"dns/promises",
-	"domain",
-	"events",
-	"fs",
-	"fs/promises",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"inspector/promises",
-	"module",
-	"net",
-	"os",
-	"path",
-	"path/posix",
-	"path/win32",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"readline/promises",
-	"repl",
-	"stream",
-	"stream/consumers",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"sys",
-	"timers",
-	"timers/promises",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"util/types",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib"
-];
-const own$1 = {}.hasOwnProperty;
-const classRegExp = /^([A-Z][a-z\d]*)+$/;
-const kTypes = new Set([
-	"string",
-	"function",
-	"number",
-	"object",
-	"Function",
-	"Object",
-	"boolean",
-	"bigint",
-	"symbol"
-]);
-const messages = /* @__PURE__ */ new Map();
-const nodeInternalPrefix = "__node_internal_";
-let userStackTraceLimit;
-/**
-* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
-* We cannot use Intl.ListFormat because it's not available in
-* --without-intl builds.
-*
-* @param {Array<string>} array
-*   An array of strings.
-* @param {string} [type]
-*   The list type to be inserted before the last element.
-* @returns {string}
-*/
-function formatList(array, type = "and") {
-	return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array.at(-1)}`;
-}
-/**
-* Utility function for registering the error codes.
-*/
-function createError(sym, value, constructor) {
-	messages.set(sym, value);
-	return makeNodeErrorWithCode(constructor, sym);
-}
-function makeNodeErrorWithCode(Base, key) {
-	return function NodeError(...parameters) {
-		const limit = Error.stackTraceLimit;
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
-		const error = new Base();
-		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
-		const message = getMessage(key, parameters, error);
-		Object.defineProperties(error, {
-			message: {
-				value: message,
-				enumerable: false,
-				writable: true,
-				configurable: true
-			},
-			toString: {
-				value() {
-					return `${this.name} [${key}]: ${this.message}`;
-				},
-				enumerable: false,
-				writable: true,
-				configurable: true
-			}
-		});
-		captureLargerStackTrace(error);
-		error.code = key;
-		return error;
-	};
-}
-function isErrorStackTraceLimitWritable() {
-	try {
-		if (v8.startupSnapshot.isBuildingSnapshot()) return false;
-	} catch {}
-	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-	if (desc === void 0) return Object.isExtensible(Error);
-	return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
-}
-/**
-* This function removes unnecessary frames from Node.js core errors.
-*/
-function hideStackFrames(wrappedFunction) {
-	const hidden = nodeInternalPrefix + wrappedFunction.name;
-	Object.defineProperty(wrappedFunction, "name", { value: hidden });
-	return wrappedFunction;
-}
-const captureLargerStackTrace = hideStackFrames(function(error) {
-	const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-	if (stackTraceLimitIsWritable) {
-		userStackTraceLimit = Error.stackTraceLimit;
-		Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-	}
-	Error.captureStackTrace(error);
-	if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-	return error;
-});
-function getMessage(key, parameters, self) {
-	const message = messages.get(key);
-	assert.ok(message !== void 0, "expected `message` to be found");
-	if (typeof message === "function") {
-		assert.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`);
-		return Reflect.apply(message, self, parameters);
-	}
-	const regex = /%[dfijoOs]/g;
-	let expectedLength = 0;
-	while (regex.exec(message) !== null) expectedLength++;
-	assert.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`);
-	if (parameters.length === 0) return message;
-	parameters.unshift(message);
-	return Reflect.apply(format, null, parameters);
-}
-/**
-* Determine the specific type of a value for type-mismatch errors.
-*/
-function determineSpecificType(value) {
-	if (value === null || value === void 0) return String(value);
-	if (typeof value === "function" && value.name) return `function ${value.name}`;
-	if (typeof value === "object") {
-		if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
-		return `${inspect(value, { depth: -1 })}`;
-	}
-	let inspected = inspect(value, { colors: false });
-	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
-	return `type ${typeof value} (${inspected})`;
-}
-createError("ERR_INVALID_ARG_TYPE", (name, expected, actual) => {
-	assert.ok(typeof name === "string", "'name' must be a string");
-	if (!Array.isArray(expected)) expected = [expected];
-	let message = "The ";
-	if (name.endsWith(" argument")) message += `${name} `;
-	else {
-		const type = name.includes(".") ? "property" : "argument";
-		message += `"${name}" ${type} `;
-	}
-	message += "must be ";
-	const types = [];
-	const instances = [];
-	const other = [];
-	for (const value of expected) {
-		assert.ok(typeof value === "string", "All expected entries have to be of type string");
-		if (kTypes.has(value)) types.push(value.toLowerCase());
-		else if (classRegExp.exec(value) === null) {
-			assert.ok(value !== "object", "The value \"object\" should be written as \"Object\"");
-			other.push(value);
-		} else instances.push(value);
-	}
-	if (instances.length > 0) {
-		const pos = types.indexOf("object");
-		if (pos !== -1) {
-			types.slice(pos, 1);
-			instances.push("Object");
-		}
-	}
-	if (types.length > 0) {
-		message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
-		if (instances.length > 0 || other.length > 0) message += " or ";
-	}
-	if (instances.length > 0) {
-		message += `an instance of ${formatList(instances, "or")}`;
-		if (other.length > 0) message += " or ";
-	}
-	if (other.length > 0) if (other.length > 1) message += `one of ${formatList(other, "or")}`;
-	else {
-		if (other[0]?.toLowerCase() !== other[0]) message += "an ";
-		message += `${other[0]}`;
-	}
-	message += `. Received ${determineSpecificType(actual)}`;
-	return message;
-}, TypeError);
-const ERR_INVALID_MODULE_SPECIFIER = createError(
-	"ERR_INVALID_MODULE_SPECIFIER",
-	/**
-	* @param {string} request
-	* @param {string} reason
-	* @param {string} [base]
-	*/
-	(request, reason, base) => {
-		return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
-	},
-	TypeError
-);
-const ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path$1, base, message) => {
-	return `Invalid package config ${path$1}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
-}, Error);
-const ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (packagePath, key, target, isImport = false, base) => {
-	const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
-	if (key === ".") {
-		assert.ok(isImport === false);
-		return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
-	}
-	return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
-}, Error);
-const ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path$1, base, exactUrl = false) => {
-	return `Cannot find ${exactUrl ? "module" : "package"} '${path$1}' imported from ${base}`;
-}, Error);
-createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
-const ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
-	return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath || ""}package.json` : ""} imported from ${base}`;
-}, TypeError);
-const ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
-	"ERR_PACKAGE_PATH_NOT_EXPORTED",
-	/**
-	* @param {string} packagePath
-	* @param {string} subpath
-	* @param {string} [base]
-	*/
-	(packagePath, subpath, base) => {
-		if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-		return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
-	},
-	Error
-);
-const ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
-const ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", "Failed to resolve module specifier \"%s\" from \"%s\": Invalid relative URL or base scheme is not hierarchical.", TypeError);
-const ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", (extension, path$1) => {
-	return `Unknown file extension "${extension}" for ${path$1}`;
-}, TypeError);
-createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
-	let inspected = inspect(value);
-	if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
-	return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
-}, TypeError);
-const hasOwnProperty$1 = {}.hasOwnProperty;
-const cache = /* @__PURE__ */ new Map();
-function read(jsonPath, { base, specifier }) {
-	const existing = cache.get(jsonPath);
-	if (existing) return existing;
-	let string;
-	try {
-		string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
-	} catch (error) {
-		const exception = error;
-		if (exception.code !== "ENOENT") throw exception;
-	}
-	const result = {
-		exists: false,
-		pjsonPath: jsonPath,
-		main: void 0,
-		name: void 0,
-		type: "none",
-		exports: void 0,
-		imports: void 0
-	};
-	if (string !== void 0) {
-		let parsed;
-		try {
-			parsed = JSON.parse(string);
-		} catch (error_) {
-			const error = new ERR_INVALID_PACKAGE_CONFIG(jsonPath, (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier), error_.message);
-			error.cause = error_;
-			throw error;
-		}
-		result.exists = true;
-		if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") result.name = parsed.name;
-		if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") result.main = parsed.main;
-		if (hasOwnProperty$1.call(parsed, "exports")) result.exports = parsed.exports;
-		if (hasOwnProperty$1.call(parsed, "imports")) result.imports = parsed.imports;
-		if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) result.type = parsed.type;
-	}
-	cache.set(jsonPath, result);
-	return result;
-}
-function getPackageScopeConfig(resolved) {
-	let packageJSONUrl = new URL("package.json", resolved);
-	while (true) {
-		if (packageJSONUrl.pathname.endsWith("node_modules/package.json")) break;
-		const packageConfig = read(fileURLToPath(packageJSONUrl), { specifier: resolved });
-		if (packageConfig.exists) return packageConfig;
-		const lastPackageJSONUrl = packageJSONUrl;
-		packageJSONUrl = new URL("../package.json", packageJSONUrl);
-		if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) break;
-	}
-	return {
-		pjsonPath: fileURLToPath(packageJSONUrl),
-		exists: false,
-		type: "none"
-	};
-}
-const hasOwnProperty = {}.hasOwnProperty;
-const extensionFormatMap = {
-	__proto__: null,
-	".json": "json",
-	".cjs": "commonjs",
-	".cts": "commonjs",
-	".js": "module",
-	".ts": "module",
-	".mts": "module",
-	".mjs": "module"
-};
-const protocolHandlers = {
-	__proto__: null,
-	"data:": getDataProtocolModuleFormat,
-	"file:": getFileProtocolModuleFormat,
-	"node:": () => "builtin"
-};
-function mimeToFormat(mime) {
-	if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)) return "module";
-	if (mime === "application/json") return "json";
-	return null;
-}
-function getDataProtocolModuleFormat(parsed) {
-	const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [
-		null,
-		null,
-		null
-	];
-	return mimeToFormat(mime);
-}
-/**
-* Returns the file extension from a URL.
-*
-* Should give similar result to
-* `require('node:path').extname(require('node:url').fileURLToPath(url))`
-* when used with a `file:` URL.
-*
-*/
-function extname(url) {
-	const pathname = url.pathname;
-	let index = pathname.length;
-	while (index--) {
-		const code = pathname.codePointAt(index);
-		if (code === 47) return "";
-		if (code === 46) return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
-	}
-	return "";
-}
-function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
-	const ext = extname(url);
-	if (ext === ".js") {
-		const { type: packageType } = getPackageScopeConfig(url);
-		if (packageType !== "none") return packageType;
-		return "commonjs";
-	}
-	if (ext === "") {
-		const { type: packageType } = getPackageScopeConfig(url);
-		if (packageType === "none" || packageType === "commonjs") return "commonjs";
-		return "module";
-	}
-	const format$1 = extensionFormatMap[ext];
-	if (format$1) return format$1;
-	if (ignoreErrors) return;
-	throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url));
-}
-function defaultGetFormatWithoutErrors(url, context) {
-	const protocol = url.protocol;
-	if (!hasOwnProperty.call(protocolHandlers, protocol)) return null;
-	return protocolHandlers[protocol](url, context, true) || null;
-}
-const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
-const own = {}.hasOwnProperty;
-const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
-const deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
-const invalidPackageNameRegEx = /^\.|%|\\/;
-const patternRegEx = /\*/g;
-const encodedSeparatorRegEx = /%2f|%5c/i;
-const emittedPackageWarnings = /* @__PURE__ */ new Set();
-const doubleSlashRegEx = /[/\\]{2}/;
-function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
-	if (process$1.noDeprecation) return;
-	const pjsonPath = fileURLToPath(packageJsonUrl);
-	const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
-	process$1.emitWarning(`Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}.`, "DeprecationWarning", "DEP0166");
-}
-function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
-	if (process$1.noDeprecation) return;
-	if (defaultGetFormatWithoutErrors(url, { parentURL: base.href }) !== "module") return;
-	const urlPath = fileURLToPath(url.href);
-	const packagePath = fileURLToPath(new URL$1(".", packageJsonUrl));
-	const basePath = fileURLToPath(base);
-	if (!main) process$1.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
-	else if (path.resolve(packagePath, main) !== urlPath) process$1.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
-}
-function tryStatSync(path$1) {
-	try {
-		return statSync(path$1);
-	} catch {}
-}
-/**
-* Legacy CommonJS main resolution:
-* 1. let M = pkg_url + (json main field)
-* 2. TRY(M, M.js, M.json, M.node)
-* 3. TRY(M/index.js, M/index.json, M/index.node)
-* 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
-* 5. NOT_FOUND
-*/
-function fileExists(url) {
-	const stats = statSync(url, { throwIfNoEntry: false });
-	const isFile = stats ? stats.isFile() : void 0;
-	return isFile === null || isFile === void 0 ? false : isFile;
-}
-function legacyMainResolve(packageJsonUrl, packageConfig, base) {
-	let guess;
-	if (packageConfig.main !== void 0) {
-		guess = new URL$1(packageConfig.main, packageJsonUrl);
-		if (fileExists(guess)) return guess;
-		const tries$1 = [
-			`./${packageConfig.main}.js`,
-			`./${packageConfig.main}.json`,
-			`./${packageConfig.main}.node`,
-			`./${packageConfig.main}/index.js`,
-			`./${packageConfig.main}/index.json`,
-			`./${packageConfig.main}/index.node`
-		];
-		let i$1 = -1;
-		while (++i$1 < tries$1.length) {
-			guess = new URL$1(tries$1[i$1], packageJsonUrl);
-			if (fileExists(guess)) break;
-			guess = void 0;
-		}
-		if (guess) {
-			emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
-			return guess;
-		}
-	}
-	const tries = [
-		"./index.js",
-		"./index.json",
-		"./index.node"
-	];
-	let i = -1;
-	while (++i < tries.length) {
-		guess = new URL$1(tries[i], packageJsonUrl);
-		if (fileExists(guess)) break;
-		guess = void 0;
-	}
-	if (guess) {
-		emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
-		return guess;
-	}
-	throw new ERR_MODULE_NOT_FOUND(fileURLToPath(new URL$1(".", packageJsonUrl)), fileURLToPath(base));
-}
-function finalizeResolution(resolved, base, preserveSymlinks) {
-	if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, String.raw`must not include encoded "/" or "\" characters`, fileURLToPath(base));
-	let filePath;
-	try {
-		filePath = fileURLToPath(resolved);
-	} catch (error) {
-		Object.defineProperty(error, "input", { value: String(resolved) });
-		Object.defineProperty(error, "module", { value: String(base) });
-		throw error;
-	}
-	const stats = tryStatSync(filePath.endsWith("/") ? filePath.slice(-1) : filePath);
-	if (stats && stats.isDirectory()) {
-		const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath(base));
-		error.url = String(resolved);
-		throw error;
-	}
-	if (!stats || !stats.isFile()) {
-		const error = new ERR_MODULE_NOT_FOUND(filePath || resolved.pathname, base && fileURLToPath(base), true);
-		error.url = String(resolved);
-		throw error;
-	}
-	if (!preserveSymlinks) {
-		const real = realpathSync(filePath);
-		const { search, hash } = resolved;
-		resolved = pathToFileURL(real + (filePath.endsWith(path.sep) ? "/" : ""));
-		resolved.search = search;
-		resolved.hash = hash;
-	}
-	return resolved;
-}
-function importNotDefined(specifier, packageJsonUrl, base) {
-	return new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && fileURLToPath(new URL$1(".", packageJsonUrl)), fileURLToPath(base));
-}
-function exportsNotFound(subpath, packageJsonUrl, base) {
-	return new ERR_PACKAGE_PATH_NOT_EXPORTED(fileURLToPath(new URL$1(".", packageJsonUrl)), subpath, base && fileURLToPath(base));
-}
-function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
-	throw new ERR_INVALID_MODULE_SPECIFIER(request, `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJsonUrl)}`, base && fileURLToPath(base));
-}
-function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
-	target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
-	return new ERR_INVALID_PACKAGE_TARGET(fileURLToPath(new URL$1(".", packageJsonUrl)), subpath, target, internal, base && fileURLToPath(base));
-}
-function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
-	if (subpath !== "" && !pattern && target.at(-1) !== "/") throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-	if (!target.startsWith("./")) {
-		if (internal && !target.startsWith("../") && !target.startsWith("/")) {
-			let isURL = false;
-			try {
-				new URL$1(target);
-				isURL = true;
-			} catch {}
-			if (!isURL) return packageResolve(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target + subpath, packageJsonUrl, conditions);
-		}
-		throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-	}
-	if (invalidSegmentRegEx.exec(target.slice(2)) !== null) if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
-		if (!isPathMap) {
-			const request = pattern ? match.replace("*", () => subpath) : match + subpath;
-			emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, true);
-		}
-	} else throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-	const resolved = new URL$1(target, packageJsonUrl);
-	const resolvedPath = resolved.pathname;
-	const packagePath = new URL$1(".", packageJsonUrl).pathname;
-	if (!resolvedPath.startsWith(packagePath)) throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-	if (subpath === "") return resolved;
-	if (invalidSegmentRegEx.exec(subpath) !== null) {
-		const request = pattern ? match.replace("*", () => subpath) : match + subpath;
-		if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
-			if (!isPathMap) emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, false);
-		} else throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
-	}
-	if (pattern) return new URL$1(RegExpPrototypeSymbolReplace.call(patternRegEx, resolved.href, () => subpath));
-	return new URL$1(subpath, resolved);
-}
-function isArrayIndex(key) {
-	const keyNumber = Number(key);
-	if (`${keyNumber}` !== key) return false;
-	return keyNumber >= 0 && keyNumber < 4294967295;
-}
-function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
-	if (typeof target === "string") return resolvePackageTargetString(target, subpath, packageSubpath, packageJsonUrl, base, pattern, internal, isPathMap, conditions);
-	if (Array.isArray(target)) {
-		const targetList = target;
-		if (targetList.length === 0) return null;
-		let lastException;
-		let i = -1;
-		while (++i < targetList.length) {
-			const targetItem = targetList[i];
-			let resolveResult;
-			try {
-				resolveResult = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
-			} catch (error) {
-				const exception = error;
-				lastException = exception;
-				if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
-				throw error;
-			}
-			if (resolveResult === void 0) continue;
-			if (resolveResult === null) {
-				lastException = null;
-				continue;
-			}
-			return resolveResult;
-		}
-		if (lastException === void 0 || lastException === null) return null;
-		throw lastException;
-	}
-	if (typeof target === "object" && target !== null) {
-		const keys = Object.getOwnPropertyNames(target);
-		let i = -1;
-		while (++i < keys.length) {
-			const key = keys[i];
-			if (isArrayIndex(key)) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), fileURLToPath(base), "\"exports\" cannot contain numeric property keys.");
-		}
-		i = -1;
-		while (++i < keys.length) {
-			const key = keys[i];
-			if (key === "default" || conditions && conditions.has(key)) {
-				const conditionalTarget = target[key];
-				const resolveResult = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
-				if (resolveResult === void 0) continue;
-				return resolveResult;
-			}
-		}
-		return null;
-	}
-	if (target === null) return null;
-	throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
-}
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-	if (typeof exports === "string" || Array.isArray(exports)) return true;
-	if (typeof exports !== "object" || exports === null) return false;
-	const keys = Object.getOwnPropertyNames(exports);
-	let isConditionalSugar = false;
-	let i = 0;
-	let keyIndex = -1;
-	while (++keyIndex < keys.length) {
-		const key = keys[keyIndex];
-		const currentIsConditionalSugar = key === "" || key[0] !== ".";
-		if (i++ === 0) isConditionalSugar = currentIsConditionalSugar;
-		else if (isConditionalSugar !== currentIsConditionalSugar) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), fileURLToPath(base), "\"exports\" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.");
-	}
-	return isConditionalSugar;
-}
-function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-	if (process$1.noDeprecation) return;
-	const pjsonPath = fileURLToPath(pjsonUrl);
-	if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
-	emittedPackageWarnings.add(pjsonPath + "|" + match);
-	process$1.emitWarning(`Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`, "DeprecationWarning", "DEP0155");
-}
-function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-	let exports = packageConfig.exports;
-	if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) exports = { ".": exports };
-	if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-		const target = exports[packageSubpath];
-		const resolveResult = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base, false, false, false, conditions);
-		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
-		return resolveResult;
-	}
-	let bestMatch = "";
-	let bestMatchSubpath = "";
-	const keys = Object.getOwnPropertyNames(exports);
-	let i = -1;
-	while (++i < keys.length) {
-		const key = keys[i];
-		const patternIndex = key.indexOf("*");
-		if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
-			if (packageSubpath.endsWith("/")) emitTrailingSlashPatternDeprecation(packageSubpath, packageJsonUrl, base);
-			const patternTrailer = key.slice(patternIndex + 1);
-			if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
-				bestMatch = key;
-				bestMatchSubpath = packageSubpath.slice(patternIndex, packageSubpath.length - patternTrailer.length);
-			}
-		}
-	}
-	if (bestMatch) {
-		const target = exports[bestMatch];
-		const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, false, packageSubpath.endsWith("/"), conditions);
-		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
-		return resolveResult;
-	}
-	throw exportsNotFound(packageSubpath, packageJsonUrl, base);
-}
-function patternKeyCompare(a, b) {
-	const aPatternIndex = a.indexOf("*");
-	const bPatternIndex = b.indexOf("*");
-	const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
-	const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
-	if (baseLengthA > baseLengthB) return -1;
-	if (baseLengthB > baseLengthA) return 1;
-	if (aPatternIndex === -1) return 1;
-	if (bPatternIndex === -1) return -1;
-	if (a.length > b.length) return -1;
-	if (b.length > a.length) return 1;
-	return 0;
-}
-function packageImportsResolve(name, base, conditions) {
-	if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
-	let packageJsonUrl;
-	const packageConfig = getPackageScopeConfig(base);
-	if (packageConfig.exists) {
-		packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
-		const imports = packageConfig.imports;
-		if (imports) if (own.call(imports, name) && !name.includes("*")) {
-			const resolveResult = resolvePackageTarget(packageJsonUrl, imports[name], "", name, base, false, true, false, conditions);
-			if (resolveResult !== null && resolveResult !== void 0) return resolveResult;
-		} else {
-			let bestMatch = "";
-			let bestMatchSubpath = "";
-			const keys = Object.getOwnPropertyNames(imports);
-			let i = -1;
-			while (++i < keys.length) {
-				const key = keys[i];
-				const patternIndex = key.indexOf("*");
-				if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
-					const patternTrailer = key.slice(patternIndex + 1);
-					if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
-						bestMatch = key;
-						bestMatchSubpath = name.slice(patternIndex, name.length - patternTrailer.length);
-					}
-				}
-			}
-			if (bestMatch) {
-				const target = imports[bestMatch];
-				const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, true, false, conditions);
-				if (resolveResult !== null && resolveResult !== void 0) return resolveResult;
-			}
-		}
-	}
-	throw importNotDefined(name, packageJsonUrl, base);
-}
-/**
-* @param {string} specifier
-* @param {URL} base
-*/
-function parsePackageName(specifier, base) {
-	let separatorIndex = specifier.indexOf("/");
-	let validPackageName = true;
-	let isScoped = false;
-	if (specifier[0] === "@") {
-		isScoped = true;
-		if (separatorIndex === -1 || specifier.length === 0) validPackageName = false;
-		else separatorIndex = specifier.indexOf("/", separatorIndex + 1);
-	}
-	const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
-	if (invalidPackageNameRegEx.exec(packageName) !== null) validPackageName = false;
-	if (!validPackageName) throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", fileURLToPath(base));
-	return {
-		packageName,
-		packageSubpath: "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex)),
-		isScoped
-	};
-}
-function packageResolve(specifier, base, conditions) {
-	if (nodeBuiltins.includes(specifier)) return new URL$1("node:" + specifier);
-	const { packageName, packageSubpath, isScoped } = parsePackageName(specifier, base);
-	const packageConfig = getPackageScopeConfig(base);
-	if (packageConfig.exists && packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(pathToFileURL(packageConfig.pjsonPath), packageSubpath, packageConfig, base, conditions);
-	let packageJsonUrl = new URL$1("./node_modules/" + packageName + "/package.json", base);
-	let packageJsonPath = fileURLToPath(packageJsonUrl);
-	let lastPath;
-	do {
-		const stat = tryStatSync(packageJsonPath.slice(0, -13));
-		if (!stat || !stat.isDirectory()) {
-			lastPath = packageJsonPath;
-			packageJsonUrl = new URL$1((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
-			packageJsonPath = fileURLToPath(packageJsonUrl);
-			continue;
-		}
-		const packageConfig$1 = read(packageJsonPath, {
-			base,
-			specifier
-		});
-		if (packageConfig$1.exports !== void 0 && packageConfig$1.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig$1, base, conditions);
-		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig$1, base);
-		return new URL$1(packageSubpath, packageJsonUrl);
-	} while (packageJsonPath.length !== lastPath.length);
-	throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false);
-}
-function isRelativeSpecifier(specifier) {
-	if (specifier[0] === ".") {
-		if (specifier.length === 1 || specifier[1] === "/") return true;
-		if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) return true;
-	}
-	return false;
-}
-function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
-	if (specifier === "") return false;
-	if (specifier[0] === "/") return true;
-	return isRelativeSpecifier(specifier);
-}
-/**
-* The “Resolver Algorithm Specification” as detailed in the Node docs (which is
-* sync and slightly lower-level than `resolve`).
-*
-* @param {string} specifier
-*   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
-* @param {URL} base
-*   Full URL (to a file) that `specifier` is resolved relative from.
-* @param {Set<string>} [conditions]
-*   Conditions.
-* @param {boolean} [preserveSymlinks]
-*   Keep symlinks instead of resolving them.
-* @returns {URL}
-*   A URL object to the found thing.
-*/
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
-	const protocol = base.protocol;
-	const isData = protocol === "data:";
-	let resolved;
-	if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) try {
-		resolved = new URL$1(specifier, base);
-	} catch (error_) {
-		const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-		error.cause = error_;
-		throw error;
-	}
-	else if (protocol === "file:" && specifier[0] === "#") resolved = packageImportsResolve(specifier, base, conditions);
-	else try {
-		resolved = new URL$1(specifier);
-	} catch (error_) {
-		if (isData && !nodeBuiltins.includes(specifier)) {
-			const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-			error.cause = error_;
-			throw error;
-		}
-		resolved = packageResolve(specifier, base, conditions);
-	}
-	assert.ok(resolved !== void 0, "expected to be defined");
-	if (resolved.protocol !== "file:") return resolved;
-	return finalizeResolution(resolved, base, preserveSymlinks);
-}
-const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-const isWindows = process.platform === "win32";
-const globalCache = globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map();
-/**
-* Synchronously resolves a module url based on the options provided.
-*
-* @param {string} input - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
-function resolveModuleURL(input, options) {
-	const parsedInput = _parseInput(input);
-	if ("external" in parsedInput) return parsedInput.external;
-	const specifier = parsedInput.specifier;
-	let url = parsedInput.url;
-	let absolutePath = parsedInput.absolutePath;
-	let cacheKey;
-	let cacheObj;
-	if (options?.cache !== false) {
-		cacheKey = _cacheKey(absolutePath || specifier, options);
-		cacheObj = options?.cache && typeof options?.cache === "object" ? options.cache : globalCache;
-	}
-	if (cacheObj) {
-		const cached = cacheObj.get(cacheKey);
-		if (typeof cached === "string") return cached;
-		if (cached instanceof Error) {
-			if (options?.try) return;
-			throw cached;
-		}
-	}
-	if (absolutePath) try {
-		const stat = lstatSync(absolutePath);
-		if (stat.isSymbolicLink()) {
-			absolutePath = realpathSync(absolutePath);
-			url = pathToFileURL(absolutePath);
-		}
-		if (stat.isFile()) {
-			if (cacheObj) cacheObj.set(cacheKey, url.href);
-			return url.href;
-		}
-	} catch (error) {
-		if (error?.code !== "ENOENT") {
-			if (cacheObj) cacheObj.set(cacheKey, error);
-			throw error;
-		}
-	}
-	const conditionsSet = options?.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
-	const target = specifier || url.href;
-	const bases = _normalizeBases(options?.from);
-	const suffixes = options?.suffixes || [""];
-	const extensions = options?.extensions ? ["", ...options.extensions] : [""];
-	let resolved;
-	for (const base of bases) {
-		for (const suffix of suffixes) {
-			let name = _join(target, suffix);
-			if (name === ".") name += "/.";
-			for (const extension of extensions) {
-				resolved = _tryModuleResolve(name + extension, base, conditionsSet);
-				if (resolved) break;
-			}
-			if (resolved) break;
-		}
-		if (resolved) break;
-	}
-	if (!resolved) {
-		const error = /* @__PURE__ */ new Error(`Cannot resolve module "${input}" (from: ${bases.map((u) => _fmtPath(u)).join(", ")})`);
-		error.code = "ERR_MODULE_NOT_FOUND";
-		if (cacheObj) cacheObj.set(cacheKey, error);
-		if (options?.try) return;
-		throw error;
-	}
-	if (cacheObj) cacheObj.set(cacheKey, resolved.href);
-	return resolved.href;
-}
-/**
-* Synchronously resolves a module then converts it to a file path
-*
-* (throws error if reolved path is not file:// scheme)
-*
-* @param {string} id - The identifier or path of the module to resolve.
-* @param {ResolveOptions} [options] - Options to resolve the module. See {@link ResolveOptions}.
-* @returns {string} The resolved URL as a string.
-*/
-function resolveModulePath(id, options) {
-	const resolved = resolveModuleURL(id, options);
-	if (!resolved) return;
-	if (!resolved.startsWith("file://") && options?.try) return;
-	const absolutePath = fileURLToPath(resolved);
-	return isWindows ? _normalizeWinPath(absolutePath) : absolutePath;
-}
-function _tryModuleResolve(specifier, base, conditions) {
-	try {
-		return moduleResolve(specifier, base, conditions);
-	} catch {}
-}
-function _normalizeBases(inputs) {
-	const urls = (Array.isArray(inputs) ? inputs : [inputs]).flatMap((input) => _normalizeBase(input));
-	if (urls.length === 0) return [pathToFileURL("./")];
-	return urls;
-}
-function _normalizeBase(input) {
-	if (!input) return [];
-	if (_isURL(input)) return [input];
-	if (typeof input !== "string") return [];
-	if (/^(?:node|data|http|https|file):/.test(input)) return new URL(input);
-	try {
-		if (input.endsWith("/") || statSync(input).isDirectory()) return pathToFileURL(input + "/");
-		return pathToFileURL(input);
-	} catch {
-		return [pathToFileURL(input + "/"), pathToFileURL(input)];
-	}
-}
-function _fmtPath(input) {
-	try {
-		return fileURLToPath(input);
-	} catch {
-		return input;
-	}
-}
-function _cacheKey(id, opts) {
-	return JSON.stringify([
-		id,
-		(opts?.conditions || ["node", "import"]).sort(),
-		opts?.extensions,
-		opts?.from,
-		opts?.suffixes
-	]);
-}
-function _join(a, b) {
-	if (!a || !b || b === "/") return a;
-	return (a.endsWith("/") ? a : a + "/") + (b.startsWith("/") ? b.slice(1) : b);
-}
-function _normalizeWinPath(path$1) {
-	return path$1.replace(/\\/g, "/").replace(/^[a-z]:\//, (r) => r.toUpperCase());
-}
-function _isURL(input) {
-	return input instanceof URL || input?.constructor?.name === "URL";
-}
-function _parseInput(input) {
-	if (typeof input === "string") {
-		if (input.startsWith("file:")) {
-			const url = new URL(input);
-			return {
-				url,
-				absolutePath: fileURLToPath(url)
-			};
-		}
-		if (isAbsolute(input)) return {
-			url: pathToFileURL(input),
-			absolutePath: input
-		};
-		if (/^(?:node|data|http|https):/.test(input)) return { external: input };
-		if (nodeBuiltins.includes(input) && !input.includes(":")) return { external: `node:${input}` };
-		return { specifier: input };
-	}
-	if (_isURL(input)) {
-		if (input.protocol === "file:") return {
-			url: input,
-			absolutePath: fileURLToPath(input)
-		};
-		return { external: input.href };
-	}
-	throw new TypeError("id must be a `string` or `URL`");
-}
-//#endregion
-//#region ../internal/src/nitro.ts
-function resolveRuntimeEntry$1(srcRelative, packageSubpath, importMetaUrl) {
-	return resolveModulePath(srcRelative, {
-		extensions: [".ts", ".mts"],
-		from: importMetaUrl,
-		try: true
-	}) ?? resolveModulePath(packageSubpath, {
-		extensions: [".js", ".mjs"],
-		from: importMetaUrl
-	});
-}
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-async function hasNamedVitePlugin(plugin, name) {
-	if (isPromiseLike(plugin)) return hasNamedVitePlugin(await plugin, name);
-	if (Array.isArray(plugin)) {
-		for (const entry of plugin) if (await hasNamedVitePlugin(entry, name)) return true;
-		return false;
-	}
-	return typeof plugin === "object" && plugin !== null && "name" in plugin && plugin.name === name;
-}
-async function assertNoVitePlugin(vite, vitePluginName, integrationName) {
-	if (await hasNamedVitePlugin(vite?.plugins, vitePluginName)) throw new Error(`[vitehub] Do not configure ${vitePluginName} when using ${integrationName}.`);
-}
-async function assertNoVitePluginInNitro(nitro, vitePluginName, integrationName) {
-	await assertNoVitePlugin(nitro.options.vite, vitePluginName, integrationName);
-}
-function mergeNitroImportsPreset(current, preset) {
-	if (current === false) return current;
-	const existing = current || {};
-	const presets = Array.isArray(existing.presets) ? [...existing.presets] : [];
-	const found = presets.find((entry) => entry?.from === preset.from);
-	if (found && Array.isArray(found.imports)) {
-		const seen = new Set(found.imports);
-		found.imports.push(...preset.imports.filter((name) => !seen.has(name)));
-	} else if (!found) presets.push({
-		from: preset.from,
-		imports: [...preset.imports]
-	});
-	return {
-		...existing,
-		presets
-	};
-}
-//#endregion
-//#region src/discovery.ts
-const workflowSuffixPattern = /\.workflow\.(?:c|m)?[jt]s$/i;
-const sourceFilePattern = /\.(?:c|m)?[jt]s$/i;
-const declarationFilePattern = /\.d\.(?:c|m)?[jt]s$/i;
-const stepFilePattern = /^\d+[.-].*\.(?:c|m)?[jt]s$/i;
-function normalizeSuffixWorkflowName(rootDir, file) {
-	return normalizeSuffixDefinitionName(rootDir, file, workflowSuffixPattern, { stripPrefix: "src/" });
-}
-function readDirEntries(root) {
-	try {
-		return readdirSync(root, { withFileTypes: true });
-	} catch (error) {
-		if (error.code === "ENOENT") return [];
-		throw error;
-	}
-}
-function isSourceFile(file) {
-	return sourceFilePattern.test(file) && !declarationFilePattern.test(file);
-}
-function isWorkflowFolder(directory) {
-	return readDirEntries(directory).some((entry) => entry.isFile() && (entry.name.toLowerCase().startsWith("index.") || stepFilePattern.test(entry.name)) && isSourceFile(entry.name));
-}
-function findWorkflowFolders(workflowsDir) {
-	const folders = [];
-	for (const entry of readDirEntries(workflowsDir)) {
-		if (!entry.isDirectory() || entry.isSymbolicLink() || entry.name.startsWith(".")) continue;
-		const directory = resolve$1(workflowsDir, entry.name);
-		if (isWorkflowFolder(directory)) {
-			folders.push(directory);
-			continue;
-		}
-		folders.push(...findWorkflowFolders(directory));
-	}
-	return folders.sort();
-}
-function discoverWorkflowFolders(scanDirs, source) {
-	const definitions = /* @__PURE__ */ new Map();
-	for (const scanDir of scanDirs) {
-		const workflowsDir = resolve$1(scanDir, "workflows");
-		for (const directory of findWorkflowFolders(workflowsDir)) {
-			const files = readDirEntries(directory).filter((entry) => entry.isFile() && isSourceFile(entry.name)).map((entry) => resolve$1(directory, entry.name)).sort();
-			const index = files.find((file) => /\/index\.(?:c|m)?[jt]s$/i.test(normalize(file)));
-			const steps = files.filter((file) => stepFilePattern.test(file.split("/").pop()));
-			if (!index && steps.length === 0) continue;
-			const relativeName = normalize(relative(workflowsDir, directory));
-			registerDefinition(definitions, {
-				handler: index || directory,
-				name: relativeName,
-				source,
-				steps
-			}, "workflow");
-		}
-	}
-	return sortDefinitions(definitions);
-}
-function discoverFlatServerWorkflowDefinitions(scanDirs, source) {
-	return discoverDefinitions("workflow", [createDirectoryDefinitionSource("nitro-server-workflows", scanDirs, "workflows", {
-		normalizeName(directory, file) {
-			const normalizedFile = normalize(file);
-			const parent = normalize(resolve$1(file, ".."));
-			if (parent !== normalize(directory) && statSync(parent).isDirectory() && isWorkflowFolder(parent)) return;
-			const fileName = normalizedFile.split("/").pop();
-			if (fileName.toLowerCase().startsWith("index.") || stepFilePattern.test(fileName)) return;
-			return normalizePathDefinitionName(directory, file);
-		},
-		createDefinition: ({ file, name }) => ({
-			handler: file,
-			name,
-			source
-		})
-	})]);
-}
-function discoverWorkflowDefinitions(options) {
-	if (options.mode === "nitro-server-workflows") return mergeDefinitions("workflow", discoverFlatServerWorkflowDefinitions(options.scanDirs, "nitro-server-workflows"), discoverWorkflowFolders(options.scanDirs, "nitro-server-workflows"));
-	const roots = resolveDefinitionScanRoots(options.rootDir, options.scanDirs);
-	const serverScanDirs = roots.map((root) => resolve$1(root, "server"));
-	const folderDefinitions = discoverWorkflowFolders(serverScanDirs, "nitro-server-workflows");
-	return mergeDefinitions("workflow", discoverDefinitions("workflow", [createSuffixDefinitionSource("vite-suffix", roots, workflowSuffixPattern, normalizeSuffixWorkflowName, { createDefinition: ({ file, name }) => ({
-		handler: file,
-		name,
-		source: "vite-suffix"
-	}) })]), discoverFlatServerWorkflowDefinitions(serverScanDirs, "nitro-server-workflows"), folderDefinitions);
-}
-//#endregion
-//#region src/nitro/module.ts
-const WORKFLOW_NITRO_IMPORTS_PRESET = {
-	from: "@vite-hub/workflow",
-	imports: ["defineWorkflow", "getWorkflowRun"]
-};
-const WORKFLOW_VITE_PLUGIN_NAME = "@vite-hub/workflow/vite";
-function resolveRuntimeEntry(srcRelative, packageSubpath) {
-	return resolveRuntimeEntry$1(srcRelative, packageSubpath, import.meta.url);
-}
-function createNitroWorkflowRegistryPath(rootDir, buildDir) {
-	return createNitroRuntimeFilePath(rootDir, {
-		buildDir,
-		fileName: "nitro-registry.mjs",
-		segments: ["vitehub", "workflow"]
-	});
-}
-function createNitroWorkflowPluginPath(rootDir, buildDir) {
-	return createNitroRuntimeFilePath(rootDir, {
-		buildDir,
-		fileName: "nitro-plugin.ts",
-		segments: ["vitehub", "workflow"]
-	});
-}
-function resolveNitroWorkflowScanDirs(rootDir, scanDirs) {
-	return scanDirs?.length ? scanDirs : [resolve(rootDir, "server")];
-}
-function createNitroWorkflowPluginContents(file, registryFile) {
-	return [
-		"import { definePlugin as defineNitroPlugin } from \"nitro\"",
-		"import { useRuntimeConfig } from \"nitro/runtime-config\"",
-		"",
-		"import { runCloudflareWorkflow } from \"@vite-hub/workflow/runtime/cloudflare-runner\"",
-		"import { startOpenWorkflowWorker } from \"@vite-hub/workflow/runtime/openworkflow-worker\"",
-		"import { enterWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from \"@vite-hub/workflow/runtime/state\"",
-		"",
-		`import workflowRegistry from ${JSON.stringify(createImportPath(file, registryFile))}`,
-		"",
-		"function applyWorkflowRuntimeEnv(runtimeConfig, env) {",
-		"  globalThis.__vitehubApplyRuntimeEnvToRuntimeConfig?.(runtimeConfig, { env: env || {} })",
-		"}",
-		"",
-		"export async function runNitroWorkflowDefinition(name, env, event, step) {",
-		"  const runtimeConfig = useRuntimeConfig()",
-		"  applyWorkflowRuntimeEnv(runtimeConfig, env)",
-		"  return await runCloudflareWorkflow({ config: runtimeConfig.workflow, env: env || {}, event, name, registry: workflowRegistry, step })",
-		"}",
-		"",
-		"globalThis.__vitehubRunNitroWorkflowDefinition = runNitroWorkflowDefinition",
-		"",
-		"function shouldStartOpenWorkflowWorker(workflowConfig) {",
-		"  return workflowConfig?.provider === \"openworkflow\" && hasOpenWorkflowPostgresConfig(workflowConfig) && globalThis.process?.env?.OPENWORKFLOW_WORKER !== \"false\"",
-		"}",
-		"",
-		"function hasOpenWorkflowPostgresConfig(workflowConfig) {",
-		"  return Boolean(workflowConfig?.postgres?.url || globalThis.process?.env?.OPENWORKFLOW_POSTGRES_URL || globalThis.process?.env?.DATABASE_URL)",
-		"}",
-		"",
-		"const workflowNitroPlugin = defineNitroPlugin(async (nitroApp) => {",
-		"  const runtimeConfig = useRuntimeConfig()",
-		"  setWorkflowRuntimeConfig(runtimeConfig.workflow)",
-		"  setWorkflowRuntimeRegistry(workflowRegistry)",
-		"",
-		"  nitroApp.hooks.hook(\"request\", (event) => {",
-		"    enterWorkflowRuntimeEvent(event)",
-		"  })",
-		"",
-		"  if (!shouldStartOpenWorkflowWorker(runtimeConfig.workflow)) {",
-		"    return",
-		"  }",
-		"",
-		"  const worker = await startOpenWorkflowWorker({",
-		"    config: runtimeConfig.workflow,",
-		"    concurrency: Number(globalThis.process?.env?.OPENWORKFLOW_WORKER_CONCURRENCY || runtimeConfig.workflow.worker?.concurrency || 10),",
-		"    registry: workflowRegistry,",
-		"    signals: false,",
-		"  })",
-		"",
-		"  let stopped = false",
-		"  nitroApp.hooks.hook(\"close\", async () => {",
-		"    if (stopped) {",
-		"      return",
-		"    }",
-		"    stopped = true",
-		"    await worker.stop()",
-		"  })",
-		"})",
-		"",
-		"export default workflowNitroPlugin",
-		""
-	].join("\n");
-}
-function createCloudflareWorkflowClassExports(definitions) {
-	if (!definitions.length) return "";
-	return [
-		"",
-		"import { WorkflowEntrypoint as ViteHubWorkflowEntrypoint } from \"cloudflare:workers\"",
-		"",
-		...definitions.map((definition) => {
-			return [
-				`export class ${getCloudflareWorkflowClassName(definition.name)} extends ViteHubWorkflowEntrypoint {`,
-				"  async run(event, step) {",
-				`    return await globalThis.__vitehubRunNitroWorkflowDefinition(${JSON.stringify(definition.name)}, this.env || {}, event, step)`,
-				"  }",
-				"}",
-				""
-			].join("\n");
-		})
-	].flat().join("\n");
-}
-async function writeNitroWorkflowRuntimeFiles(nitro) {
-	const registryFile = createNitroWorkflowRegistryPath(nitro.options.rootDir, nitro.options.buildDir);
-	const pluginFile = createNitroWorkflowPluginPath(nitro.options.rootDir, nitro.options.buildDir);
-	const definitions = discoverWorkflowDefinitions({
-		mode: "nitro-server-workflows",
-		scanDirs: resolveNitroWorkflowScanDirs(nitro.options.rootDir, nitro.options.scanDirs)
-	});
-	const providerDefinitions = definitions;
-	return {
-		...await writeRuntimeRegistryFiles({
-			createPluginContents: createNitroWorkflowPluginContents,
-			definitions,
-			pluginFile,
-			registryFile
-		}),
-		providerDefinitions
-	};
-}
-const workflowNitroModule = {
-	name: "@vite-hub/workflow",
-	async setup(nitro) {
-		await assertNoVitePluginInNitro(nitro, WORKFLOW_VITE_PLUGIN_NAME, "@vite-hub/workflow/nitro");
-		const resolved = normalizeWorkflowOptions(nitro.options.workflow, { hosting: nitro.options.preset });
-		const runtimeConfig = nitro.options.runtimeConfig ||= {};
-		if (nitro.options.preset) runtimeConfig.hosting ||= nitro.options.preset;
-		runtimeConfig.workflow = resolved || false;
-		nitro.options.alias ||= {};
-		nitro.options.alias["@vite-hub/workflow"] = resolveRuntimeEntry("../index", "@vite-hub/workflow");
-		nitro.options.alias["@vite-hub/workflow/runtime/state"] = resolveRuntimeEntry("../runtime/state", "@vite-hub/workflow/runtime/state");
-		nitro.options.alias["@vite-hub/workflow/runtime/execute"] = resolveRuntimeEntry("../runtime/execute", "@vite-hub/workflow/runtime/execute");
-		nitro.options.alias["@vite-hub/workflow/runtime/cloudflare-runner"] = resolveRuntimeEntry("../runtime/cloudflare-runner", "@vite-hub/workflow/runtime/cloudflare-runner");
-		nitro.options.alias["@vite-hub/workflow/runtime/openworkflow"] = resolveRuntimeEntry("../runtime/openworkflow", "@vite-hub/workflow/runtime/openworkflow");
-		nitro.options.alias["@vite-hub/workflow/runtime/openworkflow-worker"] = resolveRuntimeEntry("../runtime/openworkflow-worker", "@vite-hub/workflow/runtime/openworkflow-worker");
-		let runtimeFiles = await writeNitroWorkflowRuntimeFiles(nitro);
-		applyNitroRuntimeAliases(nitro, { "#vitehub/workflow/registry": runtimeFiles.registryFile });
-		if (!(nitro.options._config?.imports === false)) nitro.options.imports = mergeNitroImportsPreset(nitro.options.imports === false ? {} : nitro.options.imports, WORKFLOW_NITRO_IMPORTS_PRESET);
-		nitro.options.plugins ||= [];
-		if (!nitro.options.plugins.includes(runtimeFiles.pluginFile)) nitro.options.plugins.push(runtimeFiles.pluginFile);
-		if (!resolved) return;
-		const workflows = resolved.provider === "cloudflare" ? createCloudflareWorkflowBindings(runtimeFiles.providerDefinitions, resolved) : void 0;
-		if (workflows && nitro.options.preset?.includes("cloudflare")) {
-			nitro.options.cloudflare ||= {};
-			nitro.options.cloudflare.wrangler ||= {};
-			nitro.options.cloudflare.wrangler.workflows ||= [];
-			for (const workflow of workflows) if (!nitro.options.cloudflare.wrangler.workflows.some((existing) => existing.binding === workflow.binding)) nitro.options.cloudflare.wrangler.workflows.push(workflow);
-		}
-		hookNitroRuntimeRegistryRefresh(nitro, () => writeNitroWorkflowRuntimeFiles(nitro), (nextRuntimeFiles) => {
-			runtimeFiles = nextRuntimeFiles;
-			applyNitroRuntimeAliases(nitro, { "#vitehub/workflow/registry": runtimeFiles.registryFile });
-		});
-		nitro.hooks.hook("compiled", async (currentNitro) => {
-			if (resolved.provider !== "cloudflare" || !currentNitro.options.preset?.includes("cloudflare")) return;
-			const classExports = createCloudflareWorkflowClassExports(runtimeFiles.providerDefinitions);
-			if (!classExports) return;
-			await appendFile(join(currentNitro.options.output.serverDir, "index.mjs"), classExports, "utf8");
-		});
-	}
-};
-//#endregion
-export { createImportPath as a, computePackageDir as i, discoverWorkflowDefinitions as n, ensureGeneratedDir as o, createRuntimeRegistryContents as r, resolveRuntimeModule as s, workflowNitroModule as t };