@powerlines/plugin-env 0.15.4 → 0.15.6

package/dist/powerlines/src/lib/entry.mjs

@@ -0,0 +1,201 @@
+import { __ΩResolvedEntryTypeDefinition } from "../types/resolved.mjs";
+import { replacePathTokens } from "../plugin-utils/paths.mjs";
+import { replaceExtension, replacePath } from "@stryke/path/replace";
+import { toArray } from "@stryke/convert/to-array";
+import { isFile } from "@stryke/fs/is-file";
+import { listFiles, listFilesSync } from "@stryke/fs/list-files";
+import { appendPath } from "@stryke/path/append";
+import { joinPaths } from "@stryke/path/join-paths";
+import { isString } from "@stryke/type-checks/is-string";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import { parseTypeDefinition } from "@stryke/convert/parse-type-definition";
+import { getUniqueBy } from "@stryke/helpers/get-unique";
+import { murmurhash } from "@stryke/hash/murmurhash";
+
+//#region ../powerlines/src/lib/entry.ts
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+function resolveEntryInputFile(context, typeDefinition) {
+	return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
+}
+resolveEntryInputFile.__type = [
+	"Context",
+	"context",
+	"typeDefinition",
+	"resolveEntryInputFile",
+	"P\"w!2\"!2#&/$"
+];
+function resolveEntryInput(context, typeDefinition) {
+	return {
+		file: resolveEntryInputFile(context, typeDefinition),
+		name: typeDefinition.name
+	};
+}
+resolveEntryInput.__type = [
+	"Context",
+	"context",
+	"typeDefinition",
+	"resolveEntryInput",
+	"P\"w!2\"!2#!/$"
+];
+function resolveEntryOutput(context, typeDefinition) {
+	return replaceExtension(replacePath(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), replacePath(context.config.sourceRoot, context.config.projectRoot)));
+}
+resolveEntryOutput.__type = [
+	"Context",
+	"context",
+	"typeDefinition",
+	"resolveEntryOutput",
+	"P\"w!2\"!2#&/$"
+];
+function resolveEntry(context, typeDefinition) {
+	const input = resolveEntryInput(context, typeDefinition);
+	return {
+		...input,
+		input,
+		output: resolveEntryOutput(context, typeDefinition)
+	};
+}
+resolveEntry.__type = [
+	"Context",
+	"context",
+	"typeDefinition",
+	() => __ΩResolvedEntryTypeDefinition,
+	"resolveEntry",
+	"P\"w!2\"!2#n$/%"
+];
+/**
+* Resolves multiple type definitions into their corresponding resolved entry type definitions.
+*
+* @param context - The current context
+* @param typeDefinitions - The type definitions to resolve.
+* @returns A promise that resolves to an array of resolved entry type definitions.
+*/
+async function resolveEntries(context, typeDefinitions) {
+	return (await Promise.all(typeDefinitions.map(__assignType(async (typeDefinition) => {
+		const parsed = parseTypeDefinition(typeDefinition);
+		const filePath = appendPath(parsed.file, context.config.projectRoot);
+		if (isFile(filePath)) return resolveEntry(context, {
+			file: replacePath(filePath, context.config.projectRoot),
+			name: parsed.name
+		});
+		return (await listFiles(appendPath(parsed.file, context.config.projectRoot))).map(__assignType((file) => resolveEntry(context, {
+			file,
+			name: parsed.name
+		}), [
+			"file",
+			"",
+			"P\"2!\"/\""
+		]));
+	}, [
+		"typeDefinition",
+		"",
+		"P\"2!\"/\""
+	])))).flat().filter(Boolean);
+}
+resolveEntries.__type = [
+	"Context",
+	"context",
+	"typeDefinitions",
+	() => __ΩResolvedEntryTypeDefinition,
+	"resolveEntries",
+	"Resolves multiple type definitions into their corresponding resolved entry type definitions.",
+	"P\"w!2\"!F2#n$F`/%?&"
+];
+/**
+* Resolves multiple type definitions into their corresponding resolved entry type definitions.
+*
+* @param context - The current context
+* @param typeDefinitions - The type definitions to resolve.
+* @returns A promise that resolves to an array of resolved entry type definitions.
+*/
+function resolveEntriesSync(context, typeDefinitions) {
+	return typeDefinitions.map(__assignType((entry) => isString(entry) ? replacePathTokens(context, entry) : replacePathTokens(context, entry.file), [
+		"entry",
+		"",
+		"P\"2!\"/\""
+	])).map(__assignType((typeDefinition) => {
+		const parsed = parseTypeDefinition(typeDefinition);
+		const filePath = appendPath(parsed.file, context.config.projectRoot);
+		if (isFile(filePath)) return resolveEntry(context, {
+			file: replacePath(filePath, context.config.projectRoot),
+			name: parsed.name
+		});
+		return listFilesSync(filePath).map(__assignType((file) => resolveEntry(context, {
+			file,
+			name: parsed.name
+		}), [
+			"file",
+			"",
+			"P\"2!\"/\""
+		]));
+	}, [
+		"typeDefinition",
+		"",
+		"P\"2!\"/\""
+	])).flat().filter(Boolean);
+}
+resolveEntriesSync.__type = [
+	"Context",
+	"context",
+	"typeDefinitions",
+	() => __ΩResolvedEntryTypeDefinition,
+	"resolveEntriesSync",
+	"Resolves multiple type definitions into their corresponding resolved entry type definitions.",
+	"P\"w!2\"!F2#n$F/%?&"
+];
+/** Resolve a virtual entry point by generating a unique file path in the artifacts directory.
+*
+* @param context - The current context
+* @param typeDefinition - The type definition to resolve.
+* @returns The resolved entry type definition with a unique virtual file path.
+*/
+function resolveVirtualEntry(context, typeDefinition) {
+	const resolved = resolveEntry(context, parseTypeDefinition(typeDefinition));
+	const file = joinPaths(context.artifactsPath, `entry-${murmurhash({
+		file: resolved.file,
+		name: resolved.name
+	}, { maxLength: 24 }).replaceAll("-", "0").replaceAll("_", "1")}.ts`);
+	return {
+		file,
+		name: resolved.name,
+		input: {
+			file,
+			name: resolved.name
+		},
+		output: file
+	};
+}
+resolveVirtualEntry.__type = [
+	"Context",
+	"context",
+	"typeDefinition",
+	() => __ΩResolvedEntryTypeDefinition,
+	"resolveVirtualEntry",
+	"P\"w!2\"!2#n$/%"
+];
+/**
+* Get unique entries from the provided list.
+*
+* @param entries - The entries to process.
+* @returns An array of unique entries (by file path or content hash).
+*/
+function getUniqueEntries(entries = []) {
+	return getUniqueBy(toArray(entries), __assignType((item) => isSetString(item) ? item : murmurhash(item ?? {}, { maxLength: 24 }), [
+		"item",
+		"",
+		"P!2!\"/\""
+	]));
+}
+getUniqueEntries.__type = [
+	"entries",
+	() => [],
+	"getUniqueEntries",
+	"Get unique entries from the provided list.",
+	"PP!!FJ2!>\"!F/#?$"
+];
+
+//#endregion
+export { resolveEntryInputFile, resolveEntryOutput };

package/dist/powerlines/src/lib/logger.cjs

@@ -0,0 +1,108 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let __storm_software_config_tools_types = require("@storm-software/config-tools/types");
+let chalk = require("chalk");
+chalk = require_rolldown_runtime.__toESM(chalk);
+let __storm_software_config_tools_logger = require("@storm-software/config-tools/logger");
+let __storm_software_config_tools_utilities_colors = require("@storm-software/config-tools/utilities/colors");
+let __stryke_helpers_noop = require("@stryke/helpers/noop");
+let __stryke_string_format_kebab_case = require("@stryke/string-format/kebab-case");
+let __stryke_string_format_title_case = require("@stryke/string-format/title-case");
+
+//#region ../powerlines/src/lib/logger.ts
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+const __ΩCreateLogOptions = [
+	"name",
+	"LogLevelLabel",
+	"logLevel",
+	"LogFn",
+	"customLogger",
+	"WorkspaceConfig",
+	"colors",
+	"colors",
+	"CreateLogOptions",
+	"P&4!8P\"w\",J4#8\"w$4%8\"w&.'f4(8Mw)y"
+];
+/**
+* Create a logging function with a specific name and options.
+*
+* @param name - The name of the logging function.
+* @param options - The options to configure the logging function.
+* @returns A logging function.
+*/
+const createLog = __assignType((name, options = {}) => {
+	const logLevel = options.logLevel === null ? __storm_software_config_tools_types.LogLevelLabel.SILENT : options.logLevel || __storm_software_config_tools_types.LogLevelLabel.INFO;
+	if (logLevel === __storm_software_config_tools_types.LogLevelLabel.SILENT) return __stryke_helpers_noop.noop;
+	if (options.customLogger) return options.customLogger;
+	return __assignType((type, ...args) => (0, __storm_software_config_tools_logger.getLogFn)((0, __storm_software_config_tools_logger.getLogLevel)(type), {
+		...options,
+		logLevel
+	})(`${chalk.default.bold.hex((0, __storm_software_config_tools_utilities_colors.getColor)("brand", options))(`${name ? (0, __stryke_string_format_kebab_case.kebabCase)(name) : ""}${options.name ? `${name ? chalk.default.gray(" > ") : ""}${(0, __stryke_string_format_kebab_case.kebabCase)(options.name)}` : ""}${chalk.default.gray(" > ")}`)}${args.join(" ")} `.trim()), [
+		"LogLevelLabel",
+		"type",
+		"args",
+		"",
+		"P\"w!2\"&@2#\"/$"
+	]);
+}, [
+	"name",
+	() => __ΩCreateLogOptions,
+	"options",
+	() => ({}),
+	"LogFn",
+	"",
+	"PP&,J2!n\"2#>$\"w%/&"
+]);
+const BADGE_COLORS = [
+	"#00A0DD",
+	"#6FCE4E",
+	"#FBBF24",
+	"#F43F5E",
+	"#3B82F6",
+	"#A855F7",
+	"#469592",
+	"#288EDF",
+	"#D8B4FE",
+	"#10B981",
+	"#EF4444",
+	"#F0EC56",
+	"#F472B6",
+	"#22D3EE",
+	"#EAB308",
+	"#84CC16",
+	"#F87171",
+	"#0EA5E9",
+	"#D946EF",
+	"#FACC15",
+	"#34D399",
+	"#8B5CF6"
+];
+const extendLog = __assignType((logFn, name) => {
+	return __assignType((type, ...args) => logFn(type, ` ${chalk.default.inverse.hex(BADGE_COLORS[name.split("").map(__assignType((char) => char.charCodeAt(0), [
+		"char",
+		"",
+		"P\"2!\"/\""
+	])).reduce(__assignType((ret, charCode) => ret + charCode, [
+		"ret",
+		"charCode",
+		"",
+		"P\"2!\"2\"\"/#"
+	]), 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${(0, __stryke_string_format_title_case.titleCase)(name)} `)}  ${args.join(" ")} `), [
+		"LogLevelLabel",
+		"type",
+		"args",
+		"",
+		"P\"w!2\"&@2#\"/$"
+	]);
+}, [
+	"LogFn",
+	"logFn",
+	"name",
+	"",
+	"P\"w!2\"&2#\"w!/$"
+]);
+
+//#endregion
+exports.extendLog = extendLog;

package/dist/powerlines/src/lib/logger.mjs

@@ -0,0 +1,106 @@
+import { LogLevelLabel } from "@storm-software/config-tools/types";
+import chalk from "chalk";
+import { getLogFn, getLogLevel } from "@storm-software/config-tools/logger";
+import { getColor } from "@storm-software/config-tools/utilities/colors";
+import { noop } from "@stryke/helpers/noop";
+import { kebabCase } from "@stryke/string-format/kebab-case";
+import { titleCase } from "@stryke/string-format/title-case";
+
+//#region ../powerlines/src/lib/logger.ts
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+const __ΩCreateLogOptions = [
+	"name",
+	"LogLevelLabel",
+	"logLevel",
+	"LogFn",
+	"customLogger",
+	"WorkspaceConfig",
+	"colors",
+	"colors",
+	"CreateLogOptions",
+	"P&4!8P\"w\",J4#8\"w$4%8\"w&.'f4(8Mw)y"
+];
+/**
+* Create a logging function with a specific name and options.
+*
+* @param name - The name of the logging function.
+* @param options - The options to configure the logging function.
+* @returns A logging function.
+*/
+const createLog = __assignType((name, options = {}) => {
+	const logLevel = options.logLevel === null ? LogLevelLabel.SILENT : options.logLevel || LogLevelLabel.INFO;
+	if (logLevel === LogLevelLabel.SILENT) return noop;
+	if (options.customLogger) return options.customLogger;
+	return __assignType((type, ...args) => getLogFn(getLogLevel(type), {
+		...options,
+		logLevel
+	})(`${chalk.bold.hex(getColor("brand", options))(`${name ? kebabCase(name) : ""}${options.name ? `${name ? chalk.gray(" > ") : ""}${kebabCase(options.name)}` : ""}${chalk.gray(" > ")}`)}${args.join(" ")} `.trim()), [
+		"LogLevelLabel",
+		"type",
+		"args",
+		"",
+		"P\"w!2\"&@2#\"/$"
+	]);
+}, [
+	"name",
+	() => __ΩCreateLogOptions,
+	"options",
+	() => ({}),
+	"LogFn",
+	"",
+	"PP&,J2!n\"2#>$\"w%/&"
+]);
+const BADGE_COLORS = [
+	"#00A0DD",
+	"#6FCE4E",
+	"#FBBF24",
+	"#F43F5E",
+	"#3B82F6",
+	"#A855F7",
+	"#469592",
+	"#288EDF",
+	"#D8B4FE",
+	"#10B981",
+	"#EF4444",
+	"#F0EC56",
+	"#F472B6",
+	"#22D3EE",
+	"#EAB308",
+	"#84CC16",
+	"#F87171",
+	"#0EA5E9",
+	"#D946EF",
+	"#FACC15",
+	"#34D399",
+	"#8B5CF6"
+];
+const extendLog = __assignType((logFn, name) => {
+	return __assignType((type, ...args) => logFn(type, ` ${chalk.inverse.hex(BADGE_COLORS[name.split("").map(__assignType((char) => char.charCodeAt(0), [
+		"char",
+		"",
+		"P\"2!\"/\""
+	])).reduce(__assignType((ret, charCode) => ret + charCode, [
+		"ret",
+		"charCode",
+		"",
+		"P\"2!\"2\"\"/#"
+	]), 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `), [
+		"LogLevelLabel",
+		"type",
+		"args",
+		"",
+		"P\"w!2\"&@2#\"/$"
+	]);
+}, [
+	"LogFn",
+	"logFn",
+	"name",
+	"",
+	"P\"w!2\"&2#\"w!/$"
+]);
+
+//#endregion
+export { extendLog };

package/dist/powerlines/src/lib/utilities/bundle.cjs

@@ -0,0 +1,67 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_context = require('../../types/context.cjs');
+const require_build = require('../../types/build.cjs');
+const require_esbuild = require('../build/esbuild.cjs');
+let __storm_software_config_tools_types = require("@storm-software/config-tools/types");
+let esbuild = require("esbuild");
+
+//#region ../powerlines/src/lib/utilities/bundle.ts
+const __ΩPartial = [
+	"T",
+	"Partial",
+	"l+e#!e\"!fRb!Pde\"!gN#\"w\"y"
+];
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Bundle a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param file - The file path to bundle.
+* @param overrides - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the bundled module.
+*/
+async function bundle(context, file, overrides = {}) {
+	const path = await context.fs.resolve(file);
+	if (!path || !context.fs.existsSync(path)) throw new Error(`Module not found: "${file}". Please check the path and try again.`);
+	const result = await (0, esbuild.build)({
+		...require_esbuild.extractESBuildConfig(context),
+		entryPoints: [path],
+		write: false,
+		sourcemap: false,
+		splitting: false,
+		treeShaking: false,
+		bundle: true,
+		...overrides
+	});
+	if (result.errors.length > 0) throw new Error(`Failed to transpile ${file}: ${result.errors.map(__assignType((error) => error.text, [
+		"error",
+		"",
+		"P\"2!\"/\""
+	])).join(", ")}`);
+	if (result.warnings.length > 0) context.log(__storm_software_config_tools_types.LogLevelLabel.WARN, `Warnings while transpiling ${file}: ${result.warnings.map(__assignType((warning) => warning.text, [
+		"warning",
+		"",
+		"P\"2!\"/\""
+	])).join(", ")}`);
+	if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	return result.outputFiles.filter(Boolean)[0];
+}
+bundle.__type = [
+	() => require_context.__ΩContext,
+	"context",
+	"file",
+	() => __ΩPartial,
+	() => require_build.__ΩESBuildResolvedBuildConfig,
+	"overrides",
+	() => ({}),
+	"OutputFile",
+	"bundle",
+	"Bundle a type definition to a module.",
+	"Pn!2\"&2#n%o$\"2&>'\"w(`/)?*"
+];
+
+//#endregion
+exports.bundle = bundle;

package/dist/powerlines/src/lib/utilities/bundle.mjs

@@ -0,0 +1,66 @@
+import { __ΩContext } from "../../types/context.mjs";
+import { __ΩESBuildResolvedBuildConfig } from "../../types/build.mjs";
+import { extractESBuildConfig } from "../build/esbuild.mjs";
+import { LogLevelLabel } from "@storm-software/config-tools/types";
+import { build } from "esbuild";
+
+//#region ../powerlines/src/lib/utilities/bundle.ts
+const __ΩPartial = [
+	"T",
+	"Partial",
+	"l+e#!e\"!fRb!Pde\"!gN#\"w\"y"
+];
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Bundle a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param file - The file path to bundle.
+* @param overrides - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the bundled module.
+*/
+async function bundle(context, file, overrides = {}) {
+	const path = await context.fs.resolve(file);
+	if (!path || !context.fs.existsSync(path)) throw new Error(`Module not found: "${file}". Please check the path and try again.`);
+	const result = await build({
+		...extractESBuildConfig(context),
+		entryPoints: [path],
+		write: false,
+		sourcemap: false,
+		splitting: false,
+		treeShaking: false,
+		bundle: true,
+		...overrides
+	});
+	if (result.errors.length > 0) throw new Error(`Failed to transpile ${file}: ${result.errors.map(__assignType((error) => error.text, [
+		"error",
+		"",
+		"P\"2!\"/\""
+	])).join(", ")}`);
+	if (result.warnings.length > 0) context.log(LogLevelLabel.WARN, `Warnings while transpiling ${file}: ${result.warnings.map(__assignType((warning) => warning.text, [
+		"warning",
+		"",
+		"P\"2!\"/\""
+	])).join(", ")}`);
+	if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	return result.outputFiles.filter(Boolean)[0];
+}
+bundle.__type = [
+	() => __ΩContext,
+	"context",
+	"file",
+	() => __ΩPartial,
+	() => __ΩESBuildResolvedBuildConfig,
+	"overrides",
+	() => ({}),
+	"OutputFile",
+	"bundle",
+	"Bundle a type definition to a module.",
+	"Pn!2\"&2#n%o$\"2&>'\"w(`/)?*"
+];
+
+//#endregion
+export { bundle };

package/dist/powerlines/src/lib/utilities/resolve.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_context = require('../../types/context.cjs');
+const require_build = require('../../types/build.cjs');
+const require_bundle = require('./bundle.cjs');
+let __stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let __stryke_convert_parse_type_definition = require("@stryke/convert/parse-type-definition");
+
+//#region ../powerlines/src/lib/utilities/resolve.ts
+const __ΩPartial = [
+	"T",
+	"Partial",
+	"l+e#!e\"!fRb!Pde\"!gN#\"w\"y"
+];
+/**
+* Compiles a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param type - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.
+* @param overrides - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the compiled module.
+*/
+async function resolve(context, type, overrides = {}) {
+	let typeDefinition;
+	if ((0, __stryke_type_checks_is_set_string.isSetString)(type)) typeDefinition = (0, __stryke_convert_parse_type_definition.parseTypeDefinition)(type);
+	else typeDefinition = type;
+	const result = await require_bundle.bundle(context, typeDefinition.file, overrides);
+	const resolved = await context.resolver.evalModule(result.text, {
+		filename: result.path,
+		forceTranspile: true
+	});
+	let exportName = typeDefinition.name;
+	if (!exportName) exportName = "default";
+	return resolved[exportName] ?? resolved[`__Ω${exportName}`];
+}
+resolve.__type = [
+	() => require_context.__ΩContext,
+	"context",
+	"type",
+	() => __ΩPartial,
+	() => require_build.__ΩESBuildResolvedBuildConfig,
+	"overrides",
+	() => ({}),
+	"resolve",
+	"Compiles a type definition to a module.",
+	"Pn!2\"!2#n%o$\"2&>'\"`/(?)"
+];
+
+//#endregion
+exports.resolve = resolve;

package/dist/powerlines/src/lib/utilities/resolve.mjs

@@ -0,0 +1,48 @@
+import { __ΩContext } from "../../types/context.mjs";
+import { __ΩESBuildResolvedBuildConfig } from "../../types/build.mjs";
+import { bundle } from "./bundle.mjs";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import { parseTypeDefinition } from "@stryke/convert/parse-type-definition";
+
+//#region ../powerlines/src/lib/utilities/resolve.ts
+const __ΩPartial = [
+	"T",
+	"Partial",
+	"l+e#!e\"!fRb!Pde\"!gN#\"w\"y"
+];
+/**
+* Compiles a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param type - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.
+* @param overrides - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the compiled module.
+*/
+async function resolve(context, type, overrides = {}) {
+	let typeDefinition;
+	if (isSetString(type)) typeDefinition = parseTypeDefinition(type);
+	else typeDefinition = type;
+	const result = await bundle(context, typeDefinition.file, overrides);
+	const resolved = await context.resolver.evalModule(result.text, {
+		filename: result.path,
+		forceTranspile: true
+	});
+	let exportName = typeDefinition.name;
+	if (!exportName) exportName = "default";
+	return resolved[exportName] ?? resolved[`__Ω${exportName}`];
+}
+resolve.__type = [
+	() => __ΩContext,
+	"context",
+	"type",
+	() => __ΩPartial,
+	() => __ΩESBuildResolvedBuildConfig,
+	"overrides",
+	() => ({}),
+	"resolve",
+	"Compiles a type definition to a module.",
+	"Pn!2\"!2#n%o$\"2&>'\"`/(?)"
+];
+
+//#endregion
+export { resolve };