@zntc/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1608 @@
+"use strict";
+//#region platforms.ts
+const PLATFORMS = [{ name: "linux-x64-gnu", npmOs: "linux", npmCpu: "x64", npmLibc: "glibc", zigTarget: "x86_64-linux-gnu", ghaRunner: "ubuntu-latest" }, { name: "linux-arm64-gnu", npmOs: "linux", npmCpu: "arm64", npmLibc: "glibc", zigTarget: "aarch64-linux-gnu", ghaRunner: "ubuntu-24.04-arm" }, { name: "linux-x64-musl", npmOs: "linux", npmCpu: "x64", npmLibc: "musl", zigTarget: "x86_64-linux-musl", ghaRunner: "ubuntu-latest" }, { name: "linux-arm64-musl", npmOs: "linux", npmCpu: "arm64", npmLibc: "musl", zigTarget: "aarch64-linux-musl", ghaRunner: "ubuntu-24.04-arm" }, { name: "darwin-x64", npmOs: "darwin", npmCpu: "x64", zigTarget: "x86_64-macos", ghaRunner: "macos-15-intel" }, { name: "darwin-arm64", npmOs: "darwin", npmCpu: "arm64", zigTarget: "aarch64-macos", ghaRunner: "macos-latest" }, { name: "win32-x64-msvc", npmOs: "win32", npmCpu: "x64", zigTarget: "x86_64-windows-msvc", ghaRunner: "windows-latest" }, { name: "win32-arm64-msvc", npmOs: "win32", npmCpu: "arm64", zigTarget: "aarch64-windows-msvc", ghaRunner: "windows-11-arm" }, { name: "win32-ia32-msvc", npmOs: "win32", npmCpu: "ia32", zigTarget: "x86-windows-msvc", ghaRunner: "windows-latest" }];
+function subPackageName(platform) {
+	return `@zntc/core-${platform.name}`;
+}
+function formatSupportedPlatforms() {
+	const groups = new Map();
+	for (const p of PLATFORMS) {
+		const key = `${p.npmOs}-${p.npmCpu}`;
+		if (!groups.has(key))groups.set(key, []);
+		if (p.npmLibc)groups.get(key).push(p.npmLibc);
+	}
+	return Array.from(groups, ([key, libcs]) => libcs.length > 0 ? `${key} (${libcs.join("/")})` : key).join(", ");
+}
+//#endregion
+//#region compat-engines.ts
+const FEATURES = ["arrow", "class", "template_literal", "destructuring", "for_of", "spread", "object_extensions", "default_params", "block_scoping", "generator", "new_target", "exponentiation", "async_await", "object_spread", "optional_catch_binding", "nullish_coalescing", "optional_chaining", "logical_assignment", "class_static_block", "class_private_method", "class_private_field", "top_level_await", "hashbang", "using", "regex_sticky", "regex_dotall", "regex_named_groups", "unicode_brace_escape"],SUPPORT = { arrow: { chrome: [45, 0], firefox: [22, 0], safari: [10, 0], edge: [12, 0], node: [4, 0], deno: [1, 0], ios: [10, 0] }, class: { chrome: [49, 0], firefox: [45, 0], safari: [10, 1], edge: [13, 0], node: [6, 0], deno: [1, 0], ios: [10, 3] }, template_literal: { chrome: [41, 0], firefox: [34, 0], safari: [9, 0], edge: [12, 0], node: [4, 0], deno: [1, 0], ios: [9, 0] }, destructuring: { chrome: [49, 0], firefox: [41, 0], safari: [8, 0], edge: [14, 0], node: [6, 0], deno: [1, 0], ios: [8, 0] }, for_of: { chrome: [38, 0], firefox: [13, 0], safari: [7, 0], edge: [12, 0], node: [0, 12], deno: [1, 0], ios: [7, 0], hermes: [0, 7] }, spread: { chrome: [46, 0], firefox: [27, 0], safari: [10, 0], edge: [13, 0], node: [5, 0], deno: [1, 0], ios: [10, 0], hermes: [0, 7] }, object_extensions: { chrome: [43, 0], firefox: [34, 0], safari: [9, 0], edge: [12, 0], node: [4, 0], deno: [1, 0], ios: [9, 0], hermes: [0, 7] }, default_params: { chrome: [49, 0], firefox: [15, 0], safari: [10, 0], edge: [14, 0], node: [6, 0], deno: [1, 0], ios: [10, 0] }, block_scoping: { chrome: [49, 0], firefox: [51, 0], safari: [11, 0], edge: [14, 0], node: [6, 0], deno: [1, 0], ios: [11, 0] }, generator: { chrome: [50, 0], firefox: [53, 0], safari: [10, 0], edge: [13, 0], node: [6, 0], deno: [1, 0], ios: [10, 0] }, new_target: { chrome: [46, 0], firefox: [41, 0], safari: [10, 0], edge: [14, 0], node: [5, 0], deno: [1, 0], ios: [10, 0] }, exponentiation: { chrome: [52, 0], firefox: [52, 0], safari: [10, 1], edge: [14, 0], node: [7, 0], deno: [1, 0], ios: [10, 3], hermes: [0, 7] }, async_await: { chrome: [55, 0], firefox: [52, 0], safari: [11, 0], edge: [15, 0], node: [7, 6], deno: [1, 0], ios: [11, 0] }, object_spread: { chrome: [60, 0], firefox: [55, 0], safari: [11, 1], edge: [79, 0], node: [8, 3], deno: [1, 0], ios: [11, 3], hermes: [0, 7] }, optional_catch_binding: { chrome: [66, 0], firefox: [58, 0], safari: [11, 1], edge: [79, 0], node: [10, 0], deno: [1, 0], ios: [11, 3], hermes: [0, 12] }, nullish_coalescing: { chrome: [80, 0], firefox: [72, 0], safari: [13, 1], edge: [80, 0], node: [14, 0], deno: [1, 0], ios: [13, 4], hermes: [0, 7] }, optional_chaining: { chrome: [91, 0], firefox: [74, 0], safari: [13, 1], edge: [91, 0], node: [16, 9], deno: [1, 9], ios: [13, 4], hermes: [0, 12] }, logical_assignment: { chrome: [85, 0], firefox: [79, 0], safari: [14, 0], edge: [85, 0], node: [15, 0], deno: [1, 2], ios: [14, 0], hermes: [0, 7] }, class_static_block: { chrome: [94, 0], firefox: [93, 0], safari: [16, 4], edge: [94, 0], node: [16, 11], deno: [1, 14], ios: [16, 4] }, class_private_method: { chrome: [84, 0], firefox: [90, 0], safari: [15, 0], edge: [84, 0], node: [14, 6], deno: [1, 0], ios: [15, 0] }, class_private_field: { chrome: [74, 0], firefox: [90, 0], safari: [14, 1], edge: [79, 0], node: [12, 0], deno: [1, 0], ios: [14, 5] }, hashbang: { chrome: [74, 0], firefox: [67, 0], safari: [13, 1], edge: [79, 0], node: [12, 0], deno: [1, 0], ios: [13, 4], hermes: [0, 7] }, using: {} };
+function verGte(a,b) {
+	if (a[0] !== b[0])return a[0] > b[0];
+	return a[1] >= b[1];
+}
+function isSupported(feature,engine,ver) {
+	const min = SUPPORT[feature]?.[engine];
+	if (!min)return false;
+	return verGte(ver, min);
+}
+function computeUnsupportedFromEngines(engines) {
+	let bits = 0;
+	for (let i = 0; i < FEATURES.length; i++) {
+		const feature = FEATURES[i];
+		let anyUnsupported = false;
+		for (const ev of engines) {
+			if (!isSupported(feature, ev.engine, [ev.major, ev.minor])) {
+				anyUnsupported = true;
+				break;
+			}
+		}
+		if (anyUnsupported)bits |= 1 << i;
+	}
+	return bits;
+}
+//#endregion
+//#region index.ts
+const ES_TARGET_BITS = { es5: 0x0fffffff, es2015: 0x06fff800, es2016: 0x06fff000, es2017: 0x06ffe000, es2018: 0x00ffc000, es2019: 0x00ff8000, es2020: 0x00fe0000, es2021: 0x00fc0000, es2022: 0x00c00000, es2023: 0x00800000, es2024: 0x00800000, es2025: 0x0, esnext: 0x0 };
+function isPlainObject(value) {
+	return value !== null && typeof value == "object" && !Array.isArray(value);
+}
+function validateTsConfigRaw(raw) {
+	if (raw === undefined)return;
+	let config;
+	try {
+		config = JSON.parse(raw);
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(`failed to parse --tsconfig-raw: ${reason}`);
+	}
+	if (!isPlainObject(config)) {
+		throw new Error("failed to parse --tsconfig-raw: expected a JSON object");
+	}
+}
+function buildOptionsJson(opts={},unsupportedOverride) {
+	const payload = {};
+	if (opts.target)payload.target = opts.target;
+	if (unsupportedOverride !== undefined && unsupportedOverride !== 0)payload.unsupported = unsupportedOverride;
+	if (opts.flow)payload.flow = true;
+	if (opts.jsxInJs)payload.jsxInJs = true;
+	if (opts.reactRefresh)payload.reactRefresh = true;
+	if (opts.reactRefreshHookSignatures)payload.reactRefreshHookSignatures = true;
+	if (opts.jsx !== undefined) {
+		payload.jsx = opts.jsx === "automatic-dev" ? "automatic_dev" : opts.jsx;
+	}
+	if (opts.jsxFactory)payload.jsxFactory = opts.jsxFactory;
+	if (opts.jsxFragment)payload.jsxFragment = opts.jsxFragment;
+	if (opts.jsxImportSource)payload.jsxImportSource = opts.jsxImportSource;
+	if (opts.dropConsole)payload.dropConsole = true;
+	if (opts.dropDebugger)payload.dropDebugger = true;
+	if (opts.asciiOnly)payload.asciiOnly = true;
+	if (opts.charsetUtf8)payload.charsetUtf8 = true;
+	if (opts.experimentalDecorators)payload.experimentalDecorators = true;
+	if (opts.emitDecoratorMetadata)payload.emitDecoratorMetadata = true;
+	if (opts.useDefineForClassFields === false)payload.useDefineForClassFields = false;
+	if (opts.verbatimModuleSyntax !== undefined)payload.verbatimModuleSyntax = opts.verbatimModuleSyntax;
+	if (opts.tsconfigPath)payload.tsconfigPath = opts.tsconfigPath;
+	if (opts.tsconfigRaw)payload.tsconfigRaw = opts.tsconfigRaw;
+	if (opts.format)payload.format = opts.format;
+	if (opts.quotes)payload.quotes = opts.quotes;
+	if (opts.platform === "react-native")payload.platform = "react_native"; else if (opts.platform)payload.platform = opts.platform;
+	if (opts.minifyWhitespace || opts.minify)payload.minifyWhitespace = true;
+	if (opts.minifyIdentifiers || opts.minify)payload.minifyIdentifiers = true;
+	if (opts.minifySyntax || opts.minify)payload.minifySyntax = true;
+	if (opts.sourcemap)payload.sourcemap = true;
+	if (opts.sourcemapDebugIds)payload.sourcemapDebugIds = true;
+	if (opts.sourcesContent === false)payload.sourcesContent = false;
+	if (opts.sourceRoot)payload.sourceRoot = opts.sourceRoot;
+	if (opts.define && opts.define.length > 0)payload.define = opts.define;
+	if (opts.stopAfter)payload.stopAfter = opts.stopAfter;
+	return JSON.stringify(payload);
+}
+function parseBrowserslistEntry(entry) {
+	const m = entry.trim().match(/^(\S+)\s+([\d.]+)(?:-[\d.]+)?$/);
+	if (!m)return null;
+	const name = m[1].toLowerCase();
+	;
+	const [majStr, minStr="0"] = (m[2]).split("."),major = parseInt(majStr, 10),minor = parseInt(minStr, 10);
+	if (Number.isNaN(major))return null;
+	;
+	const engine = { chrome: "chrome", and_chr: "chrome", firefox: "firefox", and_ff: "firefox", safari: "safari", ios_saf: "ios", edge: "edge", node: "node", deno: "deno", opera: "opera", op_mob: "opera", hermes: "hermes" }[name];
+	if (!engine)return null;
+	return { engine, major, minor };
+}
+function browserslistToUnsupported(entries) {
+	const engines = [];
+	for (const e of entries) {
+		const parsed = parseBrowserslistEntry(e);
+		if (parsed)engines.push(parsed);
+	}
+	if (engines.length === 0)return 0;
+	return computeUnsupportedFromEngines(engines);
+}
+//#endregion
+//#region runtime-polyfills.ts
+var readFileSync = require("node:fs").readFileSync;
+var createRequire = require("node:module").createRequire;
+var dirname = require("node:path").dirname;
+var resolve = require("node:path").resolve;
+let runtimeRequireOverride = null;
+function getRuntimeRequire() {
+	return runtimeRequireOverride ?? createRequire(require("url").pathToFileURL(__filename).href);
+}
+const ES_TARGETS = new Set(["es5", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020", "es2021", "es2022", "es2023", "es2024", "es2025", "esnext"]),DEVICE_TARGET_RE = /\b(?:iphone|ipad|ipod|galaxy|pixel|nexus|oneplus|xiaomi|redmi|huawei|motorola|moto)\b/i,RUNTIME_POLYFILL_FEATURE_MODULES = [{ feature: "aggregate_error", module: "es.aggregate-error" }, { feature: "aggregate_error", module: "es.aggregate-error.cause" }, { feature: "array_buffer", module: "es.array-buffer.constructor" }, { feature: "array_buffer_detached", module: "es.array-buffer.detached" }, { feature: "array_buffer_is_view", module: "es.array-buffer.is-view" }, { feature: "array_buffer_slice", module: "es.array-buffer.slice" }, { feature: "array_buffer_transfer", module: "es.array-buffer.transfer" }, { feature: "array_buffer_transfer_to_fixed_length", module: "es.array-buffer.transfer-to-fixed-length" }, { feature: "array_at", module: "es.array.at" }, { feature: "array_concat", module: "es.array.concat" }, { feature: "array_copy_within", module: "es.array.copy-within" }, { feature: "array_every", module: "es.array.every" }, { feature: "array_fill", module: "es.array.fill" }, { feature: "array_filter", module: "es.array.filter" }, { feature: "array_find", module: "es.array.find" }, { feature: "array_find_index", module: "es.array.find-index" }, { feature: "array_find_last", module: "es.array.find-last" }, { feature: "array_find_last_index", module: "es.array.find-last-index" }, { feature: "array_flat", module: "es.array.flat" }, { feature: "array_flat_map", module: "es.array.flat-map" }, { feature: "array_for_each", module: "es.array.for-each" }, { feature: "array_from", module: "es.array.from" }, { feature: "array_from_async", module: "es.array.from-async" }, { feature: "array_includes", module: "es.array.includes" }, { feature: "array_index_of", module: "es.array.index-of" }, { feature: "array_is_array", module: "es.array.is-array" }, { feature: "array_join", module: "es.array.join" }, { feature: "array_last_index_of", module: "es.array.last-index-of" }, { feature: "array_map", module: "es.array.map" }, { feature: "array_of", module: "es.array.of" }, { feature: "array_push", module: "es.array.push" }, { feature: "array_reduce", module: "es.array.reduce" }, { feature: "array_reduce_right", module: "es.array.reduce-right" }, { feature: "array_reverse", module: "es.array.reverse" }, { feature: "array_slice", module: "es.array.slice" }, { feature: "array_some", module: "es.array.some" }, { feature: "array_sort", module: "es.array.sort" }, { feature: "array_splice", module: "es.array.splice" }, { feature: "array_to_reversed", module: "es.array.to-reversed" }, { feature: "array_to_sorted", module: "es.array.to-sorted" }, { feature: "array_to_spliced", module: "es.array.to-spliced" }, { feature: "array_unshift", module: "es.array.unshift" }, { feature: "array_with", module: "es.array.with" }, { feature: "async_disposable_stack", module: "es.async-disposable-stack.constructor" }, { feature: "data_view", module: "es.data-view" }, { feature: "data_view_get_float16", module: "es.data-view.get-float16" }, { feature: "data_view_set_float16", module: "es.data-view.set-float16" }, { feature: "date_now", module: "es.date.now" }, { feature: "date_to_iso_string", module: "es.date.to-iso-string" }, { feature: "disposable_stack", module: "es.disposable-stack.constructor" }, { feature: "error_is_error", module: "es.error.is-error" }, { feature: "escape", module: "es.escape" }, { feature: "function_bind", module: "es.function.bind" }, { feature: "global_this", module: "es.global-this" }, { feature: "iterator", module: "es.iterator.constructor" }, { feature: "iterator_drop", module: "es.iterator.drop" }, { feature: "iterator_every", module: "es.iterator.every" }, { feature: "iterator_filter", module: "es.iterator.filter" }, { feature: "iterator_find", module: "es.iterator.find" }, { feature: "iterator_flat_map", module: "es.iterator.flat-map" }, { feature: "iterator_for_each", module: "es.iterator.for-each" }, { feature: "iterator_from", module: "es.iterator.from" }, { feature: "iterator_map", module: "es.iterator.map" }, { feature: "iterator_reduce", module: "es.iterator.reduce" }, { feature: "iterator_some", module: "es.iterator.some" }, { feature: "iterator_take", module: "es.iterator.take" }, { feature: "iterator_to_array", module: "es.iterator.to-array" }, { feature: "json_is_raw_json", module: "es.json.is-raw-json" }, { feature: "json_parse", module: "es.json.parse" }, { feature: "json_raw_json", module: "es.json.raw-json" }, { feature: "json_stringify", module: "es.json.stringify" }, { feature: "map", module: "es.map" }, { feature: "map_get_or_insert", module: "es.map.get-or-insert" }, { feature: "map_get_or_insert_computed", module: "es.map.get-or-insert-computed" }, { feature: "map_group_by", module: "es.map.group-by" }, { feature: "math_acosh", module: "es.math.acosh" }, { feature: "math_asinh", module: "es.math.asinh" }, { feature: "math_atanh", module: "es.math.atanh" }, { feature: "math_cbrt", module: "es.math.cbrt" }, { feature: "math_clz32", module: "es.math.clz32" }, { feature: "math_cosh", module: "es.math.cosh" }, { feature: "math_expm1", module: "es.math.expm1" }, { feature: "math_f16round", module: "es.math.f16round" }, { feature: "math_fround", module: "es.math.fround" }, { feature: "math_hypot", module: "es.math.hypot" }, { feature: "math_imul", module: "es.math.imul" }, { feature: "math_log10", module: "es.math.log10" }, { feature: "math_log1p", module: "es.math.log1p" }, { feature: "math_log2", module: "es.math.log2" }, { feature: "math_sign", module: "es.math.sign" }, { feature: "math_sinh", module: "es.math.sinh" }, { feature: "math_sum_precise", module: "es.math.sum-precise" }, { feature: "math_tanh", module: "es.math.tanh" }, { feature: "math_trunc", module: "es.math.trunc" }, { feature: "number_constructor", module: "es.number.constructor" }, { feature: "number_epsilon", module: "es.number.epsilon" }, { feature: "number_is_finite", module: "es.number.is-finite" }, { feature: "number_is_integer", module: "es.number.is-integer" }, { feature: "number_is_nan", module: "es.number.is-nan" }, { feature: "number_is_safe_integer", module: "es.number.is-safe-integer" }, { feature: "number_max_safe_integer", module: "es.number.max-safe-integer" }, { feature: "number_min_safe_integer", module: "es.number.min-safe-integer" }, { feature: "number_parse_float", module: "es.number.parse-float" }, { feature: "number_parse_int", module: "es.number.parse-int" }, { feature: "number_to_exponential", module: "es.number.to-exponential" }, { feature: "number_to_fixed", module: "es.number.to-fixed" }, { feature: "number_to_precision", module: "es.number.to-precision" }, { feature: "object_assign", module: "es.object.assign" }, { feature: "object_create", module: "es.object.create" }, { feature: "object_define_getter", module: "es.object.define-getter" }, { feature: "object_define_properties", module: "es.object.define-properties" }, { feature: "object_define_property", module: "es.object.define-property" }, { feature: "object_define_setter", module: "es.object.define-setter" }, { feature: "object_entries", module: "es.object.entries" }, { feature: "object_freeze", module: "es.object.freeze" }, { feature: "object_from_entries", module: "es.object.from-entries" }, { feature: "object_get_own_property_descriptor", module: "es.object.get-own-property-descriptor" }, { feature: "object_get_own_property_descriptors", module: "es.object.get-own-property-descriptors" }, { feature: "object_get_own_property_names", module: "es.object.get-own-property-names" }, { feature: "object_get_prototype_of", module: "es.object.get-prototype-of" }, { feature: "object_group_by", module: "es.object.group-by" }, { feature: "object_has_own", module: "es.object.has-own" }, { feature: "object_is", module: "es.object.is" }, { feature: "object_is_extensible", module: "es.object.is-extensible" }, { feature: "object_is_frozen", module: "es.object.is-frozen" }, { feature: "object_is_sealed", module: "es.object.is-sealed" }, { feature: "object_keys", module: "es.object.keys" }, { feature: "object_lookup_getter", module: "es.object.lookup-getter" }, { feature: "object_lookup_setter", module: "es.object.lookup-setter" }, { feature: "object_prevent_extensions", module: "es.object.prevent-extensions" }, { feature: "object_proto", module: "es.object.proto" }, { feature: "object_seal", module: "es.object.seal" }, { feature: "object_set_prototype_of", module: "es.object.set-prototype-of" }, { feature: "object_values", module: "es.object.values" }, { feature: "parse_float", module: "es.parse-float" }, { feature: "parse_int", module: "es.parse-int" }, { feature: "set", module: "es.set" }, { feature: "set_difference", module: "es.set.difference.v2" }, { feature: "set_intersection", module: "es.set.intersection.v2" }, { feature: "set_is_disjoint_from", module: "es.set.is-disjoint-from.v2" }, { feature: "set_is_subset_of", module: "es.set.is-subset-of.v2" }, { feature: "set_is_superset_of", module: "es.set.is-superset-of.v2" }, { feature: "set_symmetric_difference", module: "es.set.symmetric-difference.v2" }, { feature: "set_union", module: "es.set.union.v2" }, { feature: "promise", module: "es.promise" }, { feature: "promise_all_settled", module: "es.promise.all-settled" }, { feature: "promise_any", module: "es.promise.any" }, { feature: "promise_finally", module: "es.promise.finally" }, { feature: "promise_try", module: "es.promise.try" }, { feature: "promise_with_resolvers", module: "es.promise.with-resolvers" }, { feature: "reflect_apply", module: "es.reflect.apply" }, { feature: "reflect_construct", module: "es.reflect.construct" }, { feature: "reflect_define_property", module: "es.reflect.define-property" }, { feature: "reflect_delete_property", module: "es.reflect.delete-property" }, { feature: "reflect_get", module: "es.reflect.get" }, { feature: "reflect_get_own_property_descriptor", module: "es.reflect.get-own-property-descriptor" }, { feature: "reflect_get_prototype_of", module: "es.reflect.get-prototype-of" }, { feature: "reflect_has", module: "es.reflect.has" }, { feature: "reflect_is_extensible", module: "es.reflect.is-extensible" }, { feature: "reflect_own_keys", module: "es.reflect.own-keys" }, { feature: "reflect_prevent_extensions", module: "es.reflect.prevent-extensions" }, { feature: "reflect_set", module: "es.reflect.set" }, { feature: "reflect_set_prototype_of", module: "es.reflect.set-prototype-of" }, { feature: "regexp_escape", module: "es.regexp.escape" }, { feature: "regexp_flags", module: "es.regexp.flags" }, { feature: "regexp_sticky", module: "es.regexp.sticky" }, { feature: "regexp_dot_all", module: "es.regexp.dot-all" }, { feature: "structured_clone", module: "web.structured-clone" }, { feature: "string_anchor", module: "es.string.anchor" }, { feature: "string_big", module: "es.string.big" }, { feature: "string_blink", module: "es.string.blink" }, { feature: "string_bold", module: "es.string.bold" }, { feature: "string_code_point_at", module: "es.string.code-point-at" }, { feature: "string_ends_with", module: "es.string.ends-with" }, { feature: "string_fixed", module: "es.string.fixed" }, { feature: "string_fontcolor", module: "es.string.fontcolor" }, { feature: "string_fontsize", module: "es.string.fontsize" }, { feature: "string_from_code_point", module: "es.string.from-code-point" }, { feature: "string_includes", module: "es.string.includes" }, { feature: "string_is_well_formed", module: "es.string.is-well-formed" }, { feature: "string_italics", module: "es.string.italics" }, { feature: "string_link", module: "es.string.link" }, { feature: "string_match_all", module: "es.string.match-all" }, { feature: "string_pad_end", module: "es.string.pad-end" }, { feature: "string_pad_start", module: "es.string.pad-start" }, { feature: "string_raw", module: "es.string.raw" }, { feature: "string_repeat", module: "es.string.repeat" }, { feature: "string_replace_all", module: "es.string.replace-all" }, { feature: "string_small", module: "es.string.small" }, { feature: "string_starts_with", module: "es.string.starts-with" }, { feature: "string_strike", module: "es.string.strike" }, { feature: "string_sub", module: "es.string.sub" }, { feature: "string_substr", module: "es.string.substr" }, { feature: "string_sup", module: "es.string.sup" }, { feature: "string_to_well_formed", module: "es.string.to-well-formed" }, { feature: "string_trim", module: "es.string.trim" }, { feature: "string_trim_end", module: "es.string.trim-end" }, { feature: "string_trim_start", module: "es.string.trim-start" }, { feature: "suppressed_error", module: "es.suppressed-error.constructor" }, { feature: "symbol", module: "es.symbol" }, { feature: "symbol_async_dispose", module: "es.symbol.async-dispose" }, { feature: "symbol_async_iterator", module: "es.symbol.async-iterator" }, { feature: "symbol_description", module: "es.symbol.description" }, { feature: "symbol_dispose", module: "es.symbol.dispose" }, { feature: "symbol_has_instance", module: "es.symbol.has-instance" }, { feature: "symbol_is_concat_spreadable", module: "es.symbol.is-concat-spreadable" }, { feature: "symbol_iterator", module: "es.symbol.iterator" }, { feature: "symbol_match", module: "es.symbol.match" }, { feature: "symbol_match_all", module: "es.symbol.match-all" }, { feature: "symbol_replace", module: "es.symbol.replace" }, { feature: "symbol_search", module: "es.symbol.search" }, { feature: "symbol_species", module: "es.symbol.species" }, { feature: "symbol_split", module: "es.symbol.split" }, { feature: "symbol_to_primitive", module: "es.symbol.to-primitive" }, { feature: "symbol_to_string_tag", module: "es.symbol.to-string-tag" }, { feature: "symbol_unscopables", module: "es.symbol.unscopables" }, { feature: "typed_array_float32", module: "es.typed-array.float32-array" }, { feature: "typed_array_float64", module: "es.typed-array.float64-array" }, { feature: "typed_array_int8", module: "es.typed-array.int8-array" }, { feature: "typed_array_int16", module: "es.typed-array.int16-array" }, { feature: "typed_array_int32", module: "es.typed-array.int32-array" }, { feature: "typed_array_uint8", module: "es.typed-array.uint8-array" }, { feature: "typed_array_uint8_clamped", module: "es.typed-array.uint8-clamped-array" }, { feature: "typed_array_uint16", module: "es.typed-array.uint16-array" }, { feature: "typed_array_uint32", module: "es.typed-array.uint32-array" }, { feature: "typed_array_at", module: "es.typed-array.at" }, { feature: "typed_array_copy_within", module: "es.typed-array.copy-within" }, { feature: "typed_array_every", module: "es.typed-array.every" }, { feature: "typed_array_fill", module: "es.typed-array.fill" }, { feature: "typed_array_filter", module: "es.typed-array.filter" }, { feature: "typed_array_find", module: "es.typed-array.find" }, { feature: "typed_array_find_index", module: "es.typed-array.find-index" }, { feature: "typed_array_find_last", module: "es.typed-array.find-last" }, { feature: "typed_array_find_last_index", module: "es.typed-array.find-last-index" }, { feature: "typed_array_for_each", module: "es.typed-array.for-each" }, { feature: "typed_array_from", module: "es.typed-array.from" }, { feature: "typed_array_includes", module: "es.typed-array.includes" }, { feature: "typed_array_index_of", module: "es.typed-array.index-of" }, { feature: "typed_array_join", module: "es.typed-array.join" }, { feature: "typed_array_last_index_of", module: "es.typed-array.last-index-of" }, { feature: "typed_array_map", module: "es.typed-array.map" }, { feature: "typed_array_of", module: "es.typed-array.of" }, { feature: "typed_array_reduce", module: "es.typed-array.reduce" }, { feature: "typed_array_reduce_right", module: "es.typed-array.reduce-right" }, { feature: "typed_array_reverse", module: "es.typed-array.reverse" }, { feature: "typed_array_set", module: "es.typed-array.set" }, { feature: "typed_array_slice", module: "es.typed-array.slice" }, { feature: "typed_array_some", module: "es.typed-array.some" }, { feature: "typed_array_sort", module: "es.typed-array.sort" }, { feature: "typed_array_subarray", module: "es.typed-array.subarray" }, { feature: "typed_array_to_reversed", module: "es.typed-array.to-reversed" }, { feature: "typed_array_to_sorted", module: "es.typed-array.to-sorted" }, { feature: "typed_array_with", module: "es.typed-array.with" }, { feature: "uint8_array_from_base64", module: "es.uint8-array.from-base64" }, { feature: "uint8_array_from_hex", module: "es.uint8-array.from-hex" }, { feature: "uint8_array_set_from_base64", module: "es.uint8-array.set-from-base64" }, { feature: "uint8_array_set_from_hex", module: "es.uint8-array.set-from-hex" }, { feature: "uint8_array_to_base64", module: "es.uint8-array.to-base64" }, { feature: "uint8_array_to_hex", module: "es.uint8-array.to-hex" }, { feature: "unescape", module: "es.unescape" }, { feature: "weak_map", module: "es.weak-map" }, { feature: "weak_map_get_or_insert", module: "es.weak-map.get-or-insert" }, { feature: "weak_map_get_or_insert_computed", module: "es.weak-map.get-or-insert-computed" }, { feature: "weak_set", module: "es.weak-set" }, { feature: "web_atob", module: "web.atob" }, { feature: "web_btoa", module: "web.btoa" }, { feature: "web_dom_collections_for_each", module: "web.dom-collections.for-each" }, { feature: "web_dom_collections_iterator", module: "web.dom-collections.iterator" }, { feature: "web_dom_exception", module: "web.dom-exception.constructor" }, { feature: "web_immediate", module: "web.immediate" }, { feature: "web_queue_microtask", module: "web.queue-microtask" }, { feature: "web_self", module: "web.self" }, { feature: "web_timers", module: "web.timers" }, { feature: "web_url", module: "web.url" }, { feature: "web_url_can_parse", module: "web.url.can-parse" }, { feature: "web_url_parse", module: "web.url.parse" }, { feature: "web_url_to_json", module: "web.url.to-json" }, { feature: "web_url_search_params", module: "web.url-search-params" }, { feature: "web_url_search_params_delete", module: "web.url-search-params.delete" }, { feature: "web_url_search_params_has", module: "web.url-search-params.has" }, { feature: "web_url_search_params_size", module: "web.url-search-params.size" }],RUNTIME_POLYFILL_CANDIDATE_MODULES = RUNTIME_POLYFILL_FEATURE_MODULES.map((item) => item.module);
+let coreJsCompatCache,coreJsVersionCache;
+function isEsTarget(target) {
+	return target !== undefined && ES_TARGETS.has(target);
+}
+function loadCoreJsCompat() {
+	if (coreJsCompatCache !== undefined) {
+		if (coreJsCompatCache)return coreJsCompatCache;
+		throwCoreJsCompatMissing();
+	}
+	try {
+		const req = getRuntimeRequire();
+		coreJsCompatCache = req("core-js-compat");
+		return coreJsCompatCache;
+	} catch {
+		coreJsCompatCache = null;
+		throwCoreJsCompatMissing();
+	}
+}
+function throwCoreJsCompatMissing() {
+	throw new Error("@zntc/core: runtimePolyfills requires the optional 'core-js-compat' package. Install it with `bun add core-js core-js-compat`.");
+}
+function readInstalledCoreJsVersion() {
+	if (coreJsVersionCache !== undefined)return coreJsVersionCache ?? undefined;
+	try {
+		const req = getRuntimeRequire(),pkgPath = req.resolve("core-js/package.json"),pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		coreJsVersionCache = pkg.version ?? null;
+	} catch {
+		coreJsVersionCache = null;
+	}
+	return coreJsVersionCache ?? undefined;
+}
+function assertNotPhysicalDeviceTarget(raw) {
+	if (!DEVICE_TARGET_RE.test(raw))return;
+	throw new Error(`@zntc/core: unsupported runtime target '${raw}'. Physical device names are not supported; use Browserslist targets such as 'ios_saf 12', 'chrome >= 85', or 'node 18'.`);
+}
+function assertNotCompactRuntimeTarget(raw) {
+	const compact = raw.match(/^(ios_saf|ios|safari|chrome|android|samsung|hermes|node)v?\d+(?:\.\d+)*$/i);
+	if (!compact)return;
+	throw new Error(`@zntc/core: unsupported runtime target '${raw}'. Compact runtime target shorthands are not supported; use Browserslist targets such as 'ios_saf 12', 'chrome >= 85', or 'node 18'.`);
+}
+function assertBrowserslistRuntimeTarget(raw) {
+	if (!/^(?:hermes|react-native|reactnative)\b/i.test(raw))return;
+	throw new Error(`@zntc/core: unsupported runtime target '${raw}'. runtimePolyfills.targets follows Rspack/SWC env.targets and accepts Browserslist queries; use platform: 'react-native' for the default Hermes runtime target.`);
+}
+function normalizeRuntimeTargetString(raw) {
+	const value = raw.trim();
+	assertNotPhysicalDeviceTarget(value);
+	assertNotCompactRuntimeTarget(value);
+	assertBrowserslistRuntimeTarget(value);
+	return value;
+}
+function normalizeRuntimeTargets(targets) {
+	if (Array.isArray(targets))return targets.map(normalizeRuntimeTargetString);
+	return normalizeRuntimeTargetString(targets);
+}
+function normalizeBuildTargetForRuntime(target) {
+	if (!target || isEsTarget(target))return undefined;
+	const nodeTarget = target.match(/^node(\d+(?:\.\d+)*)$/i);
+	if (nodeTarget)return { node: nodeTarget[1] };
+	const hermesTarget = target.match(/^hermes(\d+(?:\.\d+)*)$/i);
+	if (hermesTarget)return { hermes: hermesTarget[1] };
+	return normalizeRuntimeTargets(target);
+}
+function defaultRuntimeTargets(options) {
+	if (options.platform === "node") {
+		const [major, minor="0"] = process.versions.node.split(".");
+		return { node: `${major}.${minor}` };
+	}
+	if (options.platform === "react-native")return { hermes: "0.7" };
+	return "defaults";
+}
+function chooseRuntimeTargets(options,runtime) {
+	const raw = runtime.targets ?? (options.browserslist ? options.browserslist : undefined);
+	if (raw !== undefined)return normalizeRuntimeTargets(raw);
+	const target = normalizeBuildTargetForRuntime(options.target);
+	if (target !== undefined)return target;
+	return defaultRuntimeTargets(options);
+}
+function normalizeCoreJsModuleName(raw) {
+	let value = raw.trim();
+	if (value.startsWith("core-js/modules/"))value = value.slice("core-js/modules/".length);
+	if (value.endsWith(".js"))value = value.slice(0, -3);
+	if (!/^(?:es|web)\.[a-z0-9.-]+$/i.test(value)) {
+		throw new Error(`@zntc/core: invalid core-js module '${raw}'. Expected e.g. 'es.string.replace-all'.`);
+	}
+	return value;
+}
+function normalizeRuntimePolyfillOptions(options) {
+	const raw = options.runtimePolyfills;
+	if (raw === undefined || raw === "off")return null;
+	const runtime = typeof raw == "string" ? { mode: raw } : { ...raw },mode = runtime.mode ?? "auto";
+	if (mode !== "auto" && mode !== "usage" && mode !== "entry") {
+		throw new Error("@zntc/core: runtimePolyfills.mode must be 'auto', 'usage', or 'entry'.");
+	}
+	const provider = runtime.provider ?? "core-js";
+	if (provider !== "core-js") {
+		throw new Error("@zntc/core: runtimePolyfills.provider currently supports only 'core-js'.");
+	}
+	return { mode, provider, targets: chooseRuntimeTargets(options, runtime), include: (runtime.include ?? []).map(normalizeCoreJsModuleName), exclude: (runtime.exclude ?? []).map(normalizeCoreJsModuleName), proposals: runtime.proposals === true, coreJsVersion: runtime.coreJs ?? options.coreJs ?? readInstalledCoreJsVersion() };
+}
+function computeCoreJsCompatModules(targets,modules,options={}) {
+	const compat = loadCoreJsCompat(),result = compat({ targets, modules, version: options.version, proposals: options.proposals });
+	return result.list.map(normalizeCoreJsModuleName).sort();
+}
+function buildCoreJsResolver(entryPoints) {
+	const override = runtimeRequireOverride,requires = [];
+	if (override) {
+		requires.push(override);
+	} else {
+		const entry = entryPoints[0];
+		if (entry)requires.push(createRequire(resolve(dirname(resolve(entry)), "package.json")));
+		requires.push(createRequire(require("url").pathToFileURL(__filename).href));
+	}
+	return (moduleName) => {
+		const specifier = `core-js/modules/${moduleName}.js`;
+		let firstError;
+		for (const req of requires) {
+			try {
+				return req.resolve(specifier);
+			} catch (err) {
+				firstError ??= err instanceof Error ? err.message : String(err);
+			}
+		}
+		throw new Error(`@zntc/core: runtimePolyfills could not resolve '${specifier}'. Install core-js with \`bun add core-js\`.\n${firstError ?? ""}`);
+	};
+}
+function uniqueSorted(values) {
+	return [...new Set(values)].sort();
+}
+function resolveRuntimeModules(modules,resolveCoreJs) {
+	return uniqueSorted(modules).map((moduleName) => ({ module: moduleName, path: resolveCoreJs(moduleName) }));
+}
+function applyRuntimePolyfillsToNapiOptions(napiOptions,options) {
+	delete napiOptions.runtimePolyfills;
+	delete napiOptions.coreJs;
+	if (options.target && !isEsTarget(options.target))delete napiOptions.target;
+	const runtime = normalizeRuntimePolyfillOptions(options);
+	if (!runtime)return { cleanup: () => {
+	}, modules: [] };
+	const exclude = new Set(runtime.exclude),includeModules = runtime.include.filter((moduleName) => !exclude.has(moduleName)),resolveCoreJs = buildCoreJsResolver(options.entryPoints),includeResolved = resolveRuntimeModules(includeModules, resolveCoreJs);
+	if (runtime.mode === "entry") {
+		const entryModules = computeCoreJsCompatModules(runtime.targets, /^(?:es|web)\./, { version: runtime.coreJsVersion, proposals: runtime.proposals }).filter((moduleName) => !exclude.has(moduleName)),entryResolved = resolveRuntimeModules(entryModules, resolveCoreJs);
+		if (entryResolved.length === 0 && includeResolved.length === 0) {
+			return { cleanup: () => {
+			}, modules: [] };
+		}
+		napiOptions.runtimePolyfillPlan = { mode: "entry", entry: entryResolved, include: includeResolved, exclude: runtime.exclude };
+		return { cleanup: () => {
+		}, modules: uniqueSorted([...entryResolved, ...includeResolved].map((item) => item.module)) };
+	}
+	const targetCandidateSet = new Set(computeCoreJsCompatModules(runtime.targets, RUNTIME_POLYFILL_CANDIDATE_MODULES, { version: runtime.coreJsVersion, proposals: runtime.proposals }).filter((moduleName) => !exclude.has(moduleName))),candidates = [];
+	for (const item of RUNTIME_POLYFILL_FEATURE_MODULES) {
+		if (!targetCandidateSet.has(item.module))continue;
+		candidates.push({ feature: item.feature, module: item.module, path: resolveCoreJs(item.module) });
+	}
+	if (candidates.length === 0 && includeResolved.length === 0) {
+		return { cleanup: () => {
+		}, modules: [] };
+	}
+	napiOptions.runtimePolyfillPlan = { mode: "usage", candidates, include: includeResolved, exclude: runtime.exclude };
+	return { cleanup: () => {
+	}, modules: uniqueSorted([...candidates, ...includeResolved].map((item) => item.module)) };
+}
+//#endregion
+//#region config-loader.ts
+var randomBytes = require("node:crypto").randomBytes;
+var existsSync = require("node:fs").existsSync;
+var readFileSync$1 = require("node:fs").readFileSync;
+var unlinkSync = require("node:fs").unlinkSync;
+var writeFileSync = require("node:fs").writeFileSync;
+var dirname$1 = require("node:path").dirname;
+var extname = require("node:path").extname;
+var join = require("node:path").join;
+var pathResolve = require("node:path").resolve;
+var pathToFileURL = require("node:url").pathToFileURL;
+var CONFIG_EXT_PRIORITY = [".ts", ".mts", ".cts", ".mjs", ".js", ".cjs", ".json"];
+var TS_EXTS = new Set(CONFIG_EXT_PRIORITY.slice(0, 3)),JS_EXTS = new Set(CONFIG_EXT_PRIORITY.slice(3, 6));
+async function loadConfig(filePath,env) {
+	const absPath = pathResolve(filePath);
+	return loadConfigWithExtends(absPath, env, new Set());
+}
+async function loadConfigWithExtends(absPath,env,visited) {
+	if (visited.has(absPath)) {
+		throw new Error(`@zntc/core: circular extends detected at ${absPath} (chain: ${[...visited, absPath].join(" → ")})`);
+	}
+	visited.add(absPath);
+	const raw = await loadModuleDefault(absPath, "config"),resolved = await resolveConfigValue(raw, env, absPath),extendsField = resolved.extends;
+	if (extendsField === undefined)return resolved;
+	const extendsPaths = Array.isArray(extendsField) ? extendsField : [extendsField],baseDir = dirname$1(absPath);
+	let merged = {};
+	for (const extPath of extendsPaths) {
+		const resolvedExt = pathResolve(baseDir, extPath),base = await loadConfigWithExtends(resolvedExt, env, new Set(visited));
+		merged = mergeUserConfigs(merged, base);
+	}
+	const { extends:_extends, ...currentWithoutExtends } = resolved;
+	return mergeUserConfigs(merged, currentWithoutExtends);
+}
+function defaultConfigEnv() {
+	return { command: "bundle", mode: "production", env: process.env };
+}
+async function resolveConfigValue(raw,env,absPath) {
+	if (typeof raw != "function") {
+		return raw;
+	}
+	const result = await raw(env ?? defaultConfigEnv());
+	if (!isPlainObject(result)) {
+		const got = Array.isArray(result) ? "array" : typeof result;
+		throw new Error(`@zntc/core: functional config must return an object (got ${got}) from ${absPath}`);
+	}
+	return result;
+}
+async function loadModuleDefault(absPath,kind,options) {
+	const allowArray = options?.allowArray === true,ext = extname(absPath).toLowerCase();
+	if (ext === ".json") {
+		const raw = readFileOrThrowNotFound(absPath);
+		try {
+			return JSON.parse(raw);
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			throw new Error(`@zntc/core: failed to parse JSON ${kind} ${absPath}: ${reason}`);
+		}
+	}
+	if (TS_EXTS.has(ext)) {
+		return (await loadTsModule(absPath, kind, allowArray));
+	}
+	if (JS_EXTS.has(ext)) {
+		try {
+			return await importAndResolveDefault(absPath, { allowArray });
+		} catch (err) {
+			if (err instanceof Error) {
+				err.message = err.message.replace("module not found", `${kind} file not found`).replace(/module must be an object or function/, `${kind} must export an object or function`);
+			}
+			throw err;
+		}
+	}
+	throw new Error(`@zntc/core: unsupported ${kind} extension "${ext}" for ${absPath}. Supported: .ts/.mts/.cts/.mjs/.js/.cjs/.json`);
+}
+async function loadTsModule(absPath,kind,allowArray) {
+	init();
+	const source = readFileOrThrowNotFound(absPath),parseFilename = absPath.endsWith(".cts") ? absPath.slice(0, -4) + ".ts" : absPath,result = transpile(source, { filename: parseFilename, format: "esm" });
+	if (result.errors) {
+		throw new Error(`@zntc/core: ${kind} compile failed in ${absPath}\n${result.errors}`);
+	}
+	const tmpName = `.zntc-${kind}.bundled-${randomBytes(6).toString("hex")}.mjs`,tmpPath = join(dirname$1(absPath), tmpName);
+	writeFileSync(tmpPath, result.code, "utf8");
+	try {
+		return await importAndResolveDefault(tmpPath, { allowArray });
+	} finally {
+		try {
+			unlinkSync(tmpPath);
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			console.warn(`@zntc/core: failed to remove tmp ${kind} ${tmpPath}: ${reason}`);
+		}
+	}
+}
+async function importAndResolveDefault(absPath,options) {
+	const allowArray = options?.allowArray === true;
+	;
+	let mod;
+	try {
+		mod = await import(url);
+	} catch (err) {
+		const code = err?.code;
+		if (code === "ERR_MODULE_NOT_FOUND" || code === "ENOENT") {
+			throw new Error(`@zntc/core: module not found: ${absPath}`);
+		}
+		throw err;
+	}
+	const value = mod.default ?? mod,valueType = typeof value,isArray = Array.isArray(value);
+	;
+	if (valueType !== "function" && !(valueType === "object" && value !== null && (allowArray || !isArray))) {
+		;
+		throw new Error(`@zntc/core: module must be an object or function (got ${(value === null ? "null" : isArray ? "array" : valueType)}) from ${absPath}`);
+	}
+	return value;
+}
+function readFileOrThrowNotFound(absPath) {
+	try {
+		return readFileSync$1(absPath, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			throw new Error(`@zntc/core: config file not found: ${absPath}`);
+		}
+		throw err;
+	}
+}
+function readFileIfExists(absPath) {
+	try {
+		return readFileSync$1(absPath, "utf8");
+	} catch (err) {
+		const code = err.code;
+		if (code === "ENOENT" || code === "ENOTDIR")return null;
+		throw err;
+	}
+}
+function findConfigPath(cwd) {
+	for (const ext of CONFIG_EXT_PRIORITY) {
+		const candidate = join(cwd, `zntc.config${ext}`);
+		if (existsSync(candidate))return candidate;
+	}
+	return null;
+}
+function findModeConfigPath(cwd,mode) {
+	if (!mode)return null;
+	for (const ext of CONFIG_EXT_PRIORITY) {
+		const candidate = join(cwd, `zntc.config.${mode}${ext}`);
+		if (existsSync(candidate))return candidate;
+	}
+	return null;
+}
+function mergeUserConfigs(base,mode) {
+	const merged = { ...base };
+	for (const key of Object.keys(mode)) {
+		const modeVal = mode[key];
+		if (modeVal === undefined)continue;
+		if (key === "plugins" && Array.isArray(modeVal) && Array.isArray(merged.plugins)) {
+			merged.plugins = [...merged.plugins, ...modeVal];
+			continue;
+		}
+		const baseVal = base[key];
+		if (typeof baseVal == "object" && baseVal !== null && !Array.isArray(baseVal) && typeof modeVal == "object" && modeVal !== null && !Array.isArray(modeVal)) {
+			merged[key] = { ...baseVal, ...modeVal };
+			continue;
+		}
+		merged[key] = modeVal;
+	}
+	return merged;
+}
+//#endregion
+//#region load-env.ts
+var pathResolve$1 = require("node:path").resolve;
+function parseDotenvLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#"))return null;
+	const eqIdx = trimmed.indexOf("=");
+	if (eqIdx <= 0)return null;
+	const key = trimmed.slice(0, eqIdx).trim();
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))return null;
+	let value = trimmed.slice(eqIdx + 1).trim();
+	const quoted = (value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"));
+	if (quoted) {
+		value = value.slice(1, -1);
+	} else {
+		value = value.replace(/\s+#.*$/, "");
+	}
+	return [key, value];
+}
+function parseDotenvFile(filePath) {
+	const content = readFileIfExists(filePath);
+	if (content === null)return {};
+	const out = {};
+	for (const line of content.split(/\r?\n/)) {
+		const parsed = parseDotenvLine(line);
+		if (parsed)out[parsed[0]] = parsed[1];
+	}
+	return out;
+}
+function loadEnv(mode,envDir,prefixes=["VITE_", "ZNTC_"]) {
+	const prefixList = Array.isArray(prefixes) ? prefixes : [prefixes],dir = pathResolve$1(envDir),files = [`.env`, `.env.local`, `.env.${mode}`, `.env.${mode}.local`],merged = {};
+	for (const file of files) {
+		Object.assign(merged, parseDotenvFile(`${dir}/${file}`));
+	}
+	const filtered = {};
+	for (const [key, value] of Object.entries(merged)) {
+		if (prefixList.some((p) => key.startsWith(p))) {
+			filtered[key] = value;
+		}
+	}
+	return filtered;
+}
+function envToDefine(env,mode,baseUrl="/") {
+	const envObject = { MODE: mode, PROD: mode === "production", DEV: mode !== "production", SSR: false, BASE_URL: baseUrl };
+	for (const [key, value] of Object.entries(env))envObject[key] = value;
+	const define = { "import.meta.env": JSON.stringify(envObject) };
+	for (const [key, value] of Object.entries(envObject)) {
+		define[`import.meta.env.${key}`] = JSON.stringify(value);
+	}
+	return define;
+}
+//#endregion
+//#region typo-suggest.ts
+function levenshtein(a,b) {
+	if (a.length === 0)return b.length;
+	if (b.length === 0)return a.length;
+	const [s, l] = a.length <= b.length ? [a, b] : [b, a];
+	let prev = Array.from({ length: s.length + 1 }),curr = Array.from({ length: s.length + 1 });
+	for (let i = 0; i <= s.length; i++)prev[i] = i;
+	for (let i = 1; i <= l.length; i++) {
+		curr[0] = i;
+		for (let j = 1; j <= s.length; j++) {
+			const cost = l.charCodeAt(i - 1) === s.charCodeAt(j - 1) ? 0 : 1;
+			curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+		}
+		[prev, curr] = [curr, prev];
+	}
+	return prev[s.length];
+}
+function suggestKey(unknown,known,threshold=2) {
+	if (!unknown || known.length === 0)return null;
+	const adjusted = Math.min(threshold, Math.max(1, Math.ceil(unknown.length / 3)));
+	let best = null,bestDist = adjusted + 1;
+	for (const candidate of known) {
+		const d = levenshtein(unknown, candidate);
+		if (d > adjusted)continue;
+		if (d < bestDist || (d === bestDist && best !== null && candidate < best)) {
+			best = candidate;
+			bestDist = d;
+		}
+	}
+	return best;
+}
+function warnUnknownKeys(config,known,options={}) {
+	const result = [],knownSet = new Set(known);
+	for (const key of Object.keys(config)) {
+		if (knownSet.has(key))continue;
+		const suggestion = suggestKey(key, known);
+		result.push({ unknown: key, suggestion });
+		if (!options.silent) {
+			const where = options.sourceLabel ? ` (${options.sourceLabel})` : "",hint = suggestion ? ` — did you mean '${suggestion}'?` : "";
+			console.warn(`@zntc/core: unknown config key '${key}'${where}${hint}`);
+		}
+	}
+	return result;
+}
+const KNOWN_CONFIG_KEYS = ["entryPoints", "outdir", "outfile", "outbase", "format", "platform", "target", "browserslist", "runtimePolyfills", "coreJs", "jsx", "jsxDev", "jsxFactory", "jsxFragment", "jsxImportSource", "jsxInJs", "jsxSideEffects", "minify", "minifyWhitespace", "minifyIdentifiers", "minifySyntax", "sourcemap", "sourcemapMode", "sourcemapDebugIds", "sourcesContent", "sourceRoot", "external", "alias", "define", "server", "loader", "conditions", "nodePaths", "moduleSpecifierMap", "resolveExtensions", "mainFields", "packagesExternal", "preserveSymlinks", "resolveSymlinkSiblings", "disableHierarchicalLookup", "splitting", "outputExports", "preserveModules", "preserveModulesRoot", "inlineDynamicImports", "manualChunks", "minChunkSize", "metafile", "treeShaking", "shimMissingExports", "keepNames", "drop", "dropConsole", "dropDebugger", "dropLabels", "banner", "footer", "intro", "outro", "inject", "pure", "legalComments", "entryNames", "chunkNames", "assetNames", "experimentalDecorators", "emitDecoratorMetadata", "useDefineForClassFields", "verbatimModuleSyntax", "tsconfigPath", "tsconfigRaw", "globalName", "globals", "publicPath", "charsetUtf8", "asciiOnly", "quotes", "compiler", "mf", "flow", "plugins", "logLevel", "logLimit", "lineLimit", "profile", "profileFormat", "profileLevel", "tokenizeFormat", "stopAfter", "ignoreAnnotations", "watchDelay", "jobs", "codegenTransform", "extends", "root", "projectRoot", "entry", "dev", "outDir", "bundler", "resolver", "transformer", "serializer", "symbolicator", "watchFolders"];
+//#endregion
+//#region workspace.ts
+var existsSync$1 = require("node:fs").existsSync;
+var readdirSync = require("node:fs").readdirSync;
+var readFileSync$2 = require("node:fs").readFileSync;
+var basename = require("node:path").basename;
+var join$1 = require("node:path").join;
+var pathResolve$2 = require("node:path").resolve;
+var CONFIG_EXT_PRIORITY_LOCAL = [".ts", ".mts", ".cts", ".mjs", ".js", ".cjs", ".json"];
+function defineWorkspace(input) {
+	return input;
+}
+var WORKSPACE_EXT_PRIORITY = CONFIG_EXT_PRIORITY_LOCAL;
+function findWorkspacePath(cwd) {
+	for (const ext of WORKSPACE_EXT_PRIORITY) {
+		const p = join$1(cwd, `zntc.workspace${ext}`);
+		if (existsSync$1(p))return p;
+	}
+	return null;
+}
+async function loadWorkspace(filePath,env) {
+	const absPath = pathResolve$2(filePath),raw = await loadModuleDefault(absPath, "workspace", { allowArray: true }),entries = typeof raw == "function" ? await raw(env ?? defaultConfigEnv()) : raw;
+	if (!Array.isArray(entries)) {
+		;
+		throw new Error(`@zntc/core: workspace must export an array (got ${(entries === null ? "null" : typeof entries)}) from ${absPath}`);
+	}
+	for (let i = 0; i < entries.length; i += 1) {
+		const e = entries[i];
+		if (typeof e == "string") {
+			if (!e.length) {
+				throw new Error(`@zntc/core: workspace[${i}] is empty string in ${absPath}`);
+			}
+			continue;
+		}
+		if (!isPlainObject(e)) {
+			throw new Error(`@zntc/core: workspace[${i}] must be a string or object (got ${Array.isArray(e) ? "array" : e === null ? "null" : typeof e}) in ${absPath}`);
+		}
+		const name = e.name;
+		if (typeof name != "string" || !name) {
+			throw new Error(`@zntc/core: workspace[${i}] inline entry requires non-empty 'name' in ${absPath}`);
+		}
+	}
+	return entries;
+}
+function identifyWorkspaceEntries(entries,rootDir) {
+	const seen = new Set(),out = [],push = (w) => {
+		if (seen.has(w.cwd))return;
+		seen.add(w.cwd);
+		out.push(w);
+	};
+	for (const entry of entries) {
+		if (typeof entry == "string") {
+			if (entry.includes("*")) {
+				for (const dir of expandGlob(entry, rootDir)) {
+					push({ name: detectPackageName(dir), cwd: dir, source: "glob", inlineConfig: null });
+				}
+			} else {
+				const abs = pathResolve$2(rootDir, entry);
+				push({ name: detectPackageName(abs), cwd: abs, source: "path", inlineConfig: null });
+			}
+			continue;
+		}
+		const { name:name, ...rest } = entry;
+		push({ name, cwd: rootDir, source: "inline", inlineConfig: rest });
+	}
+	return out;
+}
+async function loadIdentifiedConfig(w,env) {
+	if (w.inlineConfig)return w.inlineConfig;
+	const configPath = findConfigPath(w.cwd);
+	return configPath ? await loadConfig(configPath, env) : {};
+}
+function expandGlob(pattern,rootDir) {
+	if (pattern.includes("**")) {
+		throw new Error(`@zntc/core: workspace glob '**' is not supported (got '${pattern}'). Use single-level '*' patterns.`);
+	}
+	const lastSep = pattern.lastIndexOf("/");
+	if (lastSep === -1) {
+		return enumerateDirs(rootDir, pattern);
+	}
+	const dirPart = pattern.slice(0, lastSep),namePart = pattern.slice(lastSep + 1);
+	if (dirPart.includes("*")) {
+		throw new Error(`@zntc/core: workspace glob with '*' in directory part is not supported (got '${pattern}'). Use trailing-only '*'.`);
+	}
+	if (!namePart.includes("*")) {
+		return [pathResolve$2(rootDir, pattern)];
+	}
+	const baseDir = pathResolve$2(rootDir, dirPart);
+	return enumerateDirs(baseDir, namePart);
+}
+function enumerateDirs(baseDir,namePattern) {
+	if (!existsSync$1(baseDir))return [];
+	const matcher = makeStarMatcher(namePattern),out = [];
+	for (const d of readdirSync(baseDir, { withFileTypes: true })) {
+		if (!d.isDirectory())continue;
+		if (d.name.startsWith("."))continue;
+		if (d.name === "node_modules")continue;
+		if (matcher(d.name))out.push(join$1(baseDir, d.name));
+	}
+	out.sort();
+	return out;
+}
+function makeStarMatcher(pattern) {
+	if (pattern === "*")return () => true;
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*"),re = new RegExp("^" + escaped + "$");
+	return (s) => re.test(s);
+}
+function detectPackageName(absDir) {
+	const pkgPath = join$1(absDir, "package.json");
+	if (existsSync$1(pkgPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync$2(pkgPath, "utf8"));
+			if (typeof pkg.name == "string" && pkg.name)return pkg.name;
+		} catch {
+		}
+	}
+	return basename(absDir);
+}
+function filterWorkspaces(workspaces,filter) {
+	if (!filter)return workspaces;
+	const filtered = workspaces.filter((w) => w.name === filter);
+	if (filtered.length === 0) {
+		const available = workspaces.map((w) => w.name).join(", ");
+		throw new Error(`@zntc/core: --workspace='${filter}' matched 0 entries (available: ${available || "<none>"})`);
+	}
+	return filtered;
+}
+//#endregion
+//#region index.ts
+var createRequire$1 = require("module").createRequire;
+var existsSync$2 = require("fs").existsSync;
+var mkdirSync = require("fs").mkdirSync;
+var writeFileSync$1 = require("fs").writeFileSync;
+var join$2 = require("path").join;
+var dirname$2 = require("path").dirname;
+var resolve$1 = require("path").resolve;
+var fileURLToPath = require("url").fileURLToPath;
+var UTF8_DECODER = new TextDecoder("utf-8");
+function attachTextGetter(file) {
+	let cachedContents,cachedText;
+	Object.defineProperty(file, "text", { get() {
+		if (cachedContents !== file.contents) {
+			cachedContents = file.contents;
+			cachedText = UTF8_DECODER.decode(cachedContents);
+		}
+		return cachedText;
+	}, enumerable: false, configurable: true });
+	return file;
+}
+function wrapOutputFiles(result) {
+	for (const file of result.outputFiles)attachTextGetter(file);
+	return result;
+}
+var native = null;
+function detectLinuxLibc() {
+	if (process.platform !== "linux")return undefined;
+	try {
+		const report = process.report?.getReport();
+		if (report?.header?.glibcVersionRuntime)return "glibc";
+	} catch {
+	}
+	return "musl";
+}
+function getPlatformPackage() {
+	const { platform:platform, arch:arch } = process,libc = detectLinuxLibc(),match = PLATFORMS.find((p) => p.npmOs === platform && p.npmCpu === arch && p.npmLibc === libc);
+	return match ? subPackageName(match) : null;
+}
+function findAddon() {
+	const __dirname = dirname$2(fileURLToPath(require("url").pathToFileURL(__filename).href)),platformPkg = getPlatformPackage(),zigOut = join$2(__dirname, "../../zig-out/lib/zntc.node");
+	if (existsSync$2(zigOut))return zigOut;
+	const zigOut2 = join$2(__dirname, "../../../zig-out/lib/zntc.node");
+	if (existsSync$2(zigOut2))return zigOut2;
+	if (platformPkg) {
+		try {
+			const nodeRequire = createRequire$1(require("url").pathToFileURL(__filename).href);
+			return nodeRequire.resolve(platformPkg);
+		} catch {
+		}
+	}
+	const local = join$2(__dirname, "zntc.node");
+	if (existsSync$2(local))return local;
+	const parent = join$2(__dirname, "../zntc.node");
+	if (existsSync$2(parent))return parent;
+	const expected = platformPkg ? ` (expected sub-package: ${platformPkg})` : "";
+	throw new Error(`@zntc/core: native binary not found for ${process.platform}-${process.arch}${expected}. ` + `Supported: ${formatSupportedPlatforms()}. ` + "For development run `zig build napi`. " + "If your platform should be supported, please open an issue.");
+}
+function defineConfig(config) {
+	return config;
+}
+function init(addonPath) {
+	if (native)return;
+	const path = addonPath ?? findAddon(),nodeRequire = createRequire$1(require("url").pathToFileURL(__filename).href);
+	native = nodeRequire(path);
+}
+function ensureNative() {
+	init();
+	return native;
+}
+var _browserslist = null,_browserslistResolved = false;
+function loadBrowserslist() {
+	if (_browserslistResolved)return _browserslist;
+	_browserslistResolved = true;
+	try {
+		const req = createRequire$1(require("url").pathToFileURL(__filename).href);
+		;
+		_browserslist = req("browserslist");
+	} catch {
+		_browserslist = null;
+	}
+	return _browserslist;
+}
+function resolveUnsupported(options) {
+	if (options.browserslist) {
+		const bl = loadBrowserslist();
+		if (!bl) {
+			throw new Error("@zntc/core: 'browserslist' option requires the 'browserslist' package. Install it: bun add browserslist");
+		}
+		return browserslistToUnsupported(bl(options.browserslist));
+	}
+	return options.target ? (ES_TARGET_BITS[options.target] ?? 0) : 0;
+}
+var TsconfigCache = class {
+	_handle;
+	constructor() {
+		this._handle = ensureNative().createTsconfigCache();
+	}
+	clear() {
+		this._handle.clear();
+	}
+	get size() {
+		return this._handle.size();
+	}
+	[Symbol.dispose]() {
+		this._handle.clear();
+	}
+	static _unwrap(c) {
+		return c._handle;
+	}
+};
+function transpile(source,options={}) {
+	if (!source)throw new Error("@zntc/core: empty source");
+	validateTsConfigRaw(options.tsconfigRaw);
+	const optionsJson = buildOptionsJson(options, resolveUnsupported(options));
+	return ensureNative().transpile(source, options.filename ?? "input.js", optionsJson, options.cache ? TsconfigCache._unwrap(options.cache) : undefined);
+}
+function tokenize(source,options={}) {
+	if (!source)throw new Error("@zntc/core: empty source");
+	return ensureNative().tokenize(source, options.filename ?? "input.js");
+}
+function configureProfile(profile,level) {
+	ensureNative().configureProfile(profile, level);
+}
+function profileReport(format="table") {
+	return ensureNative().profileReport(format);
+}
+function normalizePluginFailure(pluginName,hookName,thrown,fallbackFile) {
+	let message = "Plugin hook failed",file = fallbackFile ?? undefined,line,column;
+	if (typeof thrown == "string") {
+		message = thrown;
+	} else if (thrown && typeof thrown == "object") {
+		const err = thrown;
+		if (typeof err.message == "string")message = err.message; else if (typeof err.text == "string")message = err.text; else message = String(thrown);
+		const loc = err.loc,fileCandidate = loc?.file ?? err.id ?? err.file ?? err.fileName;
+		if (typeof fileCandidate == "string" && fileCandidate.length > 0)file = fileCandidate;
+		const lineCandidate = loc?.line ?? err.line ?? err.lineNumber,columnCandidate = loc?.column ?? err.column ?? err.columnNumber;
+		if (typeof lineCandidate == "number" && Number.isFinite(lineCandidate))line = lineCandidate;
+		if (typeof columnCandidate == "number" && Number.isFinite(columnCandidate)) {
+			column = columnCandidate;
+		}
+	} else if (thrown != null) {
+		message = String(thrown);
+	}
+	return { __zntcPluginFailure: true, pluginName, hookName, message, ...(file ? { file } : {}), ...(line !== undefined ? { line } : {}), ...(column !== undefined ? { column } : {}) };
+}
+function pluginFailureText(failure) {
+	const location = failure.file && failure.line !== undefined ? ` (${failure.file}:${failure.line}:${failure.column ?? 0})` : failure.file ? ` (${failure.file})` : "";
+	return `Plugin "${failure.pluginName}" failed in ${failure.hookName}: ${failure.message}${location}`;
+}
+function pluginFailureToDiagnostic(failure) {
+	return { code: "plugin_error", text: pluginFailureText(failure), ...(failure.file ? { location: { file: failure.file, line: failure.line, column: failure.column } } : {}) };
+}
+function serializePluginSourceMap(map) {
+	if (map == null)return null;
+	if (typeof map == "string") {
+		try {
+			JSON.parse(map);
+		} catch (err) {
+			throw new Error(`Invalid sourcemap: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return map;
+	}
+	if (typeof map != "object") {
+		throw new Error(`Invalid sourcemap: expected object, string, null, or undefined`);
+	}
+	try {
+		return JSON.stringify(map);
+	} catch (err) {
+		throw new Error(`Invalid sourcemap: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function isPromiseLike(value) {
+	return (value != null && (typeof value == "object" || typeof value == "function") && typeof value.then == "function");
+}
+function silenceUnsupportedSyncPromise(value) {
+	Promise.resolve(value).catch(() => {
+	});
+}
+function syncPluginPromiseFailure(pluginName,hookName,file) {
+	return normalizePluginFailure(pluginName, hookName, new Error("buildSync() does not support async plugin hooks. Return a synchronous value or use build() instead."), file);
+}
+function isPluginFailureResult(value) {
+	return Boolean(value && typeof value == "object" && value.__zntcPluginFailure === true);
+}
+function safeSerializeSourceMap(map) {
+	try {
+		return { ok: true, map: serializePluginSourceMap(map) };
+	} catch (err) {
+		return { ok: false, err };
+	}
+}
+function mapMaybePromise(value,mapper) {
+	if (isPromiseLike(value))return Promise.resolve(value).then(mapper);
+	return mapper(value);
+}
+function collectPluginRegistry(plugins) {
+	const registry = { hooks: { resolveId: [], load: [], transform: [], renderChunk: [], resolveContext: [] }, generateBundleCallbacks: [], buildStartCallbacks: [], buildEndCallbacks: [], closeBundleCallbacks: [], astFunctionHooks: [], lifecycleFailures: [] };
+	for (const plugin of plugins) {
+		const build = { onResolve(opts,cb) {
+			registry.hooks.resolveId.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		}, onLoad(opts,cb) {
+			registry.hooks.load.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		}, onTransform(opts,cb) {
+			registry.hooks.transform.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		}, onRenderChunk(opts,cb) {
+			registry.hooks.renderChunk.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		}, onGenerateBundle(cb) {
+			registry.generateBundleCallbacks.push({ pluginName: plugin.name, callback: cb });
+		}, onBuildStart(cb) {
+			registry.buildStartCallbacks.push({ pluginName: plugin.name, callback: cb });
+		}, onBuildEnd(cb) {
+			registry.buildEndCallbacks.push({ pluginName: plugin.name, callback: cb });
+		}, onCloseBundle(cb) {
+			registry.closeBundleCallbacks.push({ pluginName: plugin.name, callback: cb });
+		}, onAstFunction(opts,cb) {
+			registry.astFunctionHooks.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		}, onResolveContext(opts,cb) {
+			registry.hooks.resolveContext.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+		} };
+		plugin.setup(build);
+	}
+	return registry;
+}
+var pluginArgBuilders = { resolveId: (arg1, arg2) => [arg1, { path: arg1, importer: arg2 }], load: (arg1, _) => [arg1, { path: arg1 }], renderChunk: (arg1, arg2) => [arg2 ?? "", { code: arg1, chunk: arg2 }] };
+function lifecycleHookSpec(reg,hookName,arg1) {
+	switch (hookName) {
+		case "generateBundle":
+			{
+				const outputs = arg1;
+				for (const file of outputs)attachTextGetter(file);
+				return { callbacks: reg.generateBundleCallbacks, arg: outputs, surfaceFailures: false };
+			}
+		case "buildStart":
+			return { callbacks: reg.buildStartCallbacks, arg: undefined, surfaceFailures: false };
+		case "buildEnd":
+			{
+				const msg = arg1;
+				return { callbacks: reg.buildEndCallbacks, arg: msg && msg.length > 0 ? new Error(msg) : undefined, surfaceFailures: true };
+			}
+		case "closeBundle":
+			return { callbacks: reg.closeBundleCallbacks, arg: undefined, surfaceFailures: true };
+		default:
+			return null;
+	}
+}
+function* dispatchHook(reg,hookName,arg1,arg2) {
+	if (hookName === "astFunction") {
+		if (reg.astFunctionHooks.length === 0)return null;
+		let info;
+		try {
+			info = JSON.parse(arg1);
+		} catch {
+			return null;
+		}
+		for (const h of reg.astFunctionHooks) {
+			if (!h.filter.test(info.sourcePath))continue;
+			const result = yield { callback: () => h.callback(info), pluginName: h.pluginName, hookName: "astFunction", fallbackFile: info.sourcePath };
+			if (isPluginFailureResult(result))return result;
+			if (result != null)return result;
+		}
+		return null;
+	}
+	if (hookName === "resolveContext") {
+		if (reg.hooks.resolveContext.length === 0)return null;
+		let args;
+		try {
+			args = JSON.parse(arg1);
+		} catch {
+			return null;
+		}
+		for (const h of reg.hooks.resolveContext) {
+			if (!h.filter.test(args.dir))continue;
+			const result = yield { callback: () => h.callback(args), pluginName: h.pluginName, hookName: "resolveContext", fallbackFile: args.importer };
+			if (isPluginFailureResult(result))return result;
+			if (result != null)return result;
+		}
+		return null;
+	}
+	{
+		const spec = lifecycleHookSpec(reg, hookName, arg1);
+		if (spec) {
+			let firstFailure = null;
+			for (const { pluginName:pluginName, callback:callback } of spec.callbacks) {
+				const result = yield { callback: () => callback(spec.arg), pluginName, hookName };
+				if (isPluginFailureResult(result) && firstFailure == null)firstFailure = result;
+			}
+			if (spec.surfaceFailures) {
+				if (firstFailure)reg.lifecycleFailures.push(firstFailure);
+				return null;
+			}
+			return firstFailure;
+		}
+	}
+	if (hookName === "transform" || hookName === "renderChunk") {
+		const hookList = reg.hooks[hookName];
+		if (!hookList)return null;
+		let currentCode = arg1,changed = false;
+		const sourceMaps = [];
+		for (const h of hookList) {
+			if (!h.filter.test(arg2 ?? ""))continue;
+			const cbArgs = hookName === "transform" ? { code: currentCode, path: arg2 } : { code: currentCode, chunk: arg2 },result = yield { callback: () => h.callback(cbArgs), pluginName: h.pluginName, hookName, fallbackFile: arg2 };
+			if (isPluginFailureResult(result))return result;
+			if (result != null) {
+				const obj = result,newCode = typeof result == "string" ? result : obj.code;
+				if (typeof newCode == "string") {
+					currentCode = newCode;
+					changed = true;
+				}
+				if (hookName === "transform" && typeof result == "object" && "map" in obj) {
+					const r = safeSerializeSourceMap(obj.map);
+					if (!r.ok)return normalizePluginFailure(h.pluginName, hookName, r.err, arg2);
+					if (r.map != null)sourceMaps.push(r.map);
+				}
+			}
+		}
+		return changed ? { code: currentCode, ...(sourceMaps.length > 0 ? { maps: sourceMaps } : {}) } : null;
+	}
+	const hookList = reg.hooks[hookName];
+	if (!hookList)return null;
+	const buildArgs = pluginArgBuilders[hookName];
+	if (!buildArgs)return null;
+	const [filterTarget, cbArgs] = buildArgs(arg1, arg2);
+	for (const h of hookList) {
+		if (!h.filter.test(filterTarget))continue;
+		const fallbackFile = hookName === "resolveId" ? arg2 : filterTarget,result = yield { callback: () => h.callback(cbArgs), pluginName: h.pluginName, hookName, fallbackFile };
+		if (isPluginFailureResult(result))return result;
+		if (result != null) {
+			if (hookName === "load" && typeof result == "object" && "map" in result) {
+				const r = safeSerializeSourceMap(result.map);
+				if (!r.ok)return normalizePluginFailure(h.pluginName, hookName, r.err, fallbackFile);
+				return { ...result, ...(r.map != null ? { map: r.map } : { map: undefined }) };
+			}
+			return result;
+		}
+	}
+	return null;
+}
+async function driveDispatchAsync(gen) {
+	let r = gen.next();
+	while (!r.done) {
+		const call = r.value;
+		let value;
+		try {
+			value = await call.callback();
+		} catch (err) {
+			value = normalizePluginFailure(call.pluginName, call.hookName, err, call.fallbackFile);
+		}
+		r = gen.next(value);
+	}
+	return r.value;
+}
+function driveDispatchSync(gen) {
+	let r = gen.next();
+	while (!r.done) {
+		const call = r.value;
+		let value;
+		try {
+			const raw = call.callback();
+			if (isPromiseLike(raw)) {
+				silenceUnsupportedSyncPromise(raw);
+				value = syncPluginPromiseFailure(call.pluginName, call.hookName, call.fallbackFile);
+			} else {
+				value = raw;
+			}
+		} catch (err) {
+			value = normalizePluginFailure(call.pluginName, call.hookName, err, call.fallbackFile);
+		}
+		r = gen.next(value);
+	}
+	return r.value;
+}
+function createPluginDispatcher(plugins) {
+	const reg = collectPluginRegistry(plugins),dispatcher = function dispatcher(hookName,arg1,arg2) {
+		return driveDispatchAsync(dispatchHook(reg, hookName, arg1, arg2));
+	};
+	dispatcher.takeLifecycleFailures = () => reg.lifecycleFailures.splice(0);
+	return dispatcher;
+}
+function createSyncPluginDispatcher(plugins) {
+	const reg = collectPluginRegistry(plugins),dispatcher = function dispatcher(hookName,arg1,arg2) {
+		return driveDispatchSync(dispatchHook(reg, hookName, arg1, arg2));
+	};
+	dispatcher.takeLifecycleFailures = () => reg.lifecycleFailures.splice(0);
+	return dispatcher;
+}
+function arrayAliasToPlugin(aliasArray) {
+	return { name: "zntc:array-alias", setup(build) {
+		build.onResolve({ filter: /.*/ }, (args) => {
+			for (const { find:find, replacement:replacement } of aliasArray) {
+				if (find instanceof RegExp) {
+					if (args.path.search(find) !== -1) {
+						return { path: args.path.replace(find, replacement) };
+					}
+				} else if (args.path === find || args.path.startsWith(find + "/")) {
+					return { path: args.path.replace(find, replacement) };
+				}
+			}
+			return null;
+		});
+	} };
+}
+function resolveDispatcher(options,mode="async") {
+	const arrayAlias = Array.isArray(options.alias) ? options.alias : null,userPlugins = options.plugins ?? [],allPlugins = arrayAlias ? [arrayAliasToPlugin(arrayAlias), ...userPlugins] : userPlugins;
+	if (allPlugins.length === 0)return null;
+	return mode === "sync" ? createSyncPluginDispatcher(allPlugins) : createPluginDispatcher(allPlugins);
+}
+function isBrowserLikeBuildPlatform(platform) {
+	return platform === undefined || platform === "browser" || platform === "react-native";
+}
+function withDefaultBuildDefines(options) {
+	const define = { ...options.define },browserLike = isBrowserLikeBuildPlatform(options.platform) || options.minifySyntax === true;
+	if (browserLike && define["process.env.NODE_ENV"] === undefined) {
+		define["process.env.NODE_ENV"] = options.devMode ? "\"development\"" : "\"production\"";
+	}
+	if (options.platform === "react-native" && define.__DEV__ === undefined) {
+		define.__DEV__ = options.devMode ? "true" : "false";
+	}
+	return Object.keys(define).length > 0 ? define : undefined;
+}
+function withDefaultAppBuildDefines(options) {
+	const define = { ...options.define };
+	if (define["process.env.NODE_ENV"] === undefined) {
+		define["process.env.NODE_ENV"] = (options.mode ?? "production") === "production" ? "\"production\"" : "\"development\"";
+	}
+	return define;
+}
+function prepareNapiOptions(options) {
+	const napiOptions = { ...options },define = withDefaultBuildDefines(options);
+	if (define)napiOptions.define = define;
+	delete napiOptions.write;
+	delete napiOptions.outdir;
+	delete napiOptions.plugins;
+	delete napiOptions.allowOverwrite;
+	if (Array.isArray(napiOptions.alias))delete napiOptions.alias;
+	delete napiOptions.manualChunks;
+	if (options.manualChunks) {
+		napiOptions._manualChunks = options.manualChunks;
+	}
+	delete napiOptions.mf;
+	if (options.mf) {
+		napiOptions.mfRaw = JSON.stringify(options.mf);
+	}
+	if (options.blockList) {
+		napiOptions.blockList = options.blockList.map((p) => {
+			if (p instanceof RegExp)return p.source;
+			if (typeof p == "string")return p;
+			throw new TypeError(`blockList entries must be RegExp or string, got ${typeof p}`);
+		});
+	}
+	if (options.browserslist) {
+		napiOptions.unsupported = resolveUnsupported({ browserslist: options.browserslist });
+		delete napiOptions.browserslist;
+	}
+	if (options.target && !isEsTarget(options.target)) {
+		delete napiOptions.target;
+	}
+	delete napiOptions.compiler;
+	const sc = options.compiler?.styledComponents;
+	if (sc !== undefined && sc !== false) {
+		napiOptions.styledComponents = true;
+		if (typeof sc == "object") {
+			if (sc.ssr === false)napiOptions.styledComponentsSsr = false;
+			if (sc.minify === true)napiOptions.styledComponentsMinify = true;
+			if (sc.fileName === false)napiOptions.styledComponentsFileName = false;
+			if (sc.pure === true)napiOptions.styledComponentsPure = true;
+			if (typeof sc.namespace == "string" && sc.namespace.length > 0) {
+				napiOptions.styledComponentsNamespace = sc.namespace;
+			}
+			if (Array.isArray(sc.meaninglessFileNames)) {
+				napiOptions.styledComponentsMeaninglessFileNames = sc.meaninglessFileNames;
+			}
+			if (Array.isArray(sc.topLevelImportPaths)) {
+				napiOptions.styledComponentsTopLevelImportPaths = sc.topLevelImportPaths;
+			}
+			if (sc.cssProp === true)napiOptions.styledComponentsCssProp = true;
+		}
+	}
+	const em = options.compiler?.emotion;
+	if (em !== undefined && em !== false) {
+		napiOptions.emotion = true;
+		if (typeof em == "object") {
+			if (em.autoLabel === false) {
+				napiOptions.emotionAutoLabel = "never";
+			} else if (em.autoLabel === true) {
+				napiOptions.emotionAutoLabel = "always";
+			} else if (typeof em.autoLabel == "string") {
+				napiOptions.emotionAutoLabel = em.autoLabel;
+			}
+			if (em.sourceMap === true)napiOptions.emotionSourceMap = true;
+			if (typeof em.labelFormat == "string" && em.labelFormat.length > 0) {
+				napiOptions.emotionLabelFormat = em.labelFormat;
+			}
+			const extras = collectEmotionImportMapExtras(em.importMap);
+			if (extras.css.length > 0)napiOptions.emotionExtraCssSources = extras.css;
+			if (extras.styled.length > 0)napiOptions.emotionExtraStyledSources = extras.styled;
+		}
+	}
+	const runtimePolyfills = applyRuntimePolyfillsToNapiOptions(napiOptions, { entryPoints: options.entryPoints, platform: options.platform, target: options.target, browserslist: options.browserslist, runtimePolyfills: options.runtimePolyfills, coreJs: options.coreJs, runBeforeMain: options.runBeforeMain, resolveExtensions: options.resolveExtensions });
+	return { napiOptions, cleanup: runtimePolyfills.cleanup };
+}
+var EMOTION_CSS_CANONICAL_SOURCES = new Set(["@emotion/react", "@emotion/css", "@emotion/core", "@emotion/native", "@emotion/primitives", "@emotion/primitives-core"]);
+function collectEmotionImportMapExtras(importMap) {
+	const css = new Set(),styled = new Set();
+	if (!importMap)return { css: [], styled: [] };
+	for (const [source, locals] of Object.entries(importMap)) {
+		for (const spec of Object.values(locals)) {
+			const [pkg, exportName] = spec.canonicalImport;
+			if (pkg === "@emotion/styled" && exportName === "default") {
+				styled.add(source);
+			} else if (EMOTION_CSS_CANONICAL_SOURCES.has(pkg)) {
+				css.add(source);
+			}
+		}
+	}
+	return { css: [...css], styled: [...styled] };
+}
+function postProcessCssOutputs(result,options) {
+	if (!options.minify)return;
+	let lcss;
+	try {
+		lcss = require("lightningcss");
+	} catch {
+		return;
+	}
+	for (const file of result.outputFiles) {
+		if (!file.path.endsWith(".css"))continue;
+		try {
+			const transformed = lcss.transform({ code: file.contents, minify: true, filename: file.path });
+			file.contents = transformed.code;
+		} catch {
+		}
+	}
+}
+function writeOutputFiles(result,options) {
+	const shouldWrite = options.write ?? (options.outdir != null || options.outfile != null);
+	if (!shouldWrite)return;
+	if (!options.allowOverwrite && options.outfile) {
+		const outResolved = resolve$1(options.outfile);
+		for (const entry of options.entryPoints) {
+			if (resolve$1(entry) === outResolved) {
+				throw new Error(`@zntc/core: output file '${options.outfile}' would overwrite input file (set allowOverwrite: true to permit)`);
+			}
+		}
+	}
+	const createdDirs = new Set(),outfileResolved = options.outfile ? resolve$1(options.outfile) : null;
+	for (const file of result.outputFiles) {
+		let outPath;
+		if (outfileResolved && file.path === "bundle.js") {
+			outPath = outfileResolved;
+		} else if (outfileResolved && file.path.endsWith(".map")) {
+			outPath = outfileResolved + ".map";
+		} else if (options.outdir) {
+			outPath = join$2(resolve$1(options.outdir), file.path);
+		} else {
+			outPath = resolve$1(file.path);
+		}
+		const dir = dirname$2(outPath);
+		if (!createdDirs.has(dir)) {
+			mkdirSync(dir, { recursive: true });
+			createdDirs.add(dir);
+		}
+		writeFileSync$1(outPath, file.contents);
+	}
+}
+async function build(options) {
+	const n = ensureNative();
+	if (!options.entryPoints?.length)throw new Error("@zntc/core: entryPoints is required");
+	validateTsConfigRaw(options.tsconfigRaw);
+	if (options.output && options.output.length >= 2) {
+		return buildMultiFormat(options);
+	}
+	const { napiOptions:napiOptions, cleanup:cleanup } = prepareNapiOptions(options),dispatcher = resolveDispatcher(options);
+	if (dispatcher)napiOptions._pluginDispatcher = dispatcher;
+	try {
+		const result = wrapOutputFiles(await n.build(napiOptions));
+		if (dispatcher) {
+			for (const failure of dispatcher.takeLifecycleFailures()) {
+				result.errors.push(pluginFailureToDiagnostic(failure));
+			}
+		}
+		postProcessCssOutputs(result, options);
+		writeOutputFiles(result, options);
+		if (dispatcher) {
+			await dispatcher("closeBundle", undefined, null);
+			for (const failure of dispatcher.takeLifecycleFailures()) {
+				result.errors.push(pluginFailureToDiagnostic(failure));
+			}
+		}
+		return result;
+	} finally {
+		cleanup();
+	}
+}
+function buildSync(options) {
+	const n = ensureNative();
+	if (!options.entryPoints?.length)throw new Error("@zntc/core: entryPoints is required");
+	validateTsConfigRaw(options.tsconfigRaw);
+	const { napiOptions:napiOptions, cleanup:cleanup } = prepareNapiOptions(options),dispatcher = resolveDispatcher(options, "sync");
+	if (dispatcher)napiOptions._pluginDispatcherSync = dispatcher;
+	try {
+		const result = wrapOutputFiles(n.buildSync(napiOptions));
+		if (dispatcher) {
+			for (const failure of dispatcher.takeLifecycleFailures()) {
+				result.errors.push(pluginFailureToDiagnostic(failure));
+			}
+		}
+		postProcessCssOutputs(result, options);
+		writeOutputFiles(result, options);
+		if (dispatcher) {
+			dispatcher("closeBundle", undefined, null);
+			for (const failure of dispatcher.takeLifecycleFailures()) {
+				result.errors.push(pluginFailureToDiagnostic(failure));
+			}
+		}
+		return result;
+	} finally {
+		cleanup();
+	}
+}
+var BuildInstance = class {
+	#base;
+	#closed = false;
+	constructor(base) {
+		this.#base = base;
+	}
+	get closed() {
+		return this.#closed;
+	}
+	async write(output={}) {
+		this.#assertOpen();
+		return build(mergeOutput(this.#base, output));
+	}
+	async generate(output={}) {
+		this.#assertOpen();
+		return build({ ...mergeOutput(this.#base, output), write: false });
+	}
+	async close() {
+		this.#closed = true;
+	}
+	#assertOpen() {
+		if (this.#closed)throw new Error("@zntc/core: BuildInstance is closed");
+	}
+};
+function mergeOutput(base,out) {
+	const merged = { ...base };
+	if (out.format !== undefined)merged.format = out.format;
+	if (out.dir !== undefined)merged.outdir = out.dir;
+	if (out.file !== undefined)merged.outfile = out.file;
+	if (out.globals !== undefined)merged.globals = out.globals;
+	return merged;
+}
+async function zntc(options) {
+	if (!options.entryPoints?.length)throw new Error("@zntc/core: entryPoints is required");
+	validateTsConfigRaw(options.tsconfigRaw);
+	return new BuildInstance(options);
+}
+async function buildMultiFormat(options) {
+	const outputs = options.output,{ output:_omit, ...baseOpts } = options,aggregated = { outputFiles: [], errors: [], warnings: [], outputsByFormat: [] };
+	for (const cfg of outputs) {
+		const r = await build(mergeOutput(baseOpts, cfg));
+		aggregated.errors.push(...r.errors);
+		aggregated.warnings.push(...r.warnings);
+		aggregated.outputsByFormat.push({ format: cfg.format ?? "esm", outputFiles: r.outputFiles });
+	}
+	if (aggregated.outputsByFormat.length > 0) {
+		aggregated.outputFiles = aggregated.outputsByFormat[0].outputFiles;
+	}
+	return aggregated;
+}
+function buildAppSync(options={}) {
+	const n = ensureNative(),{ publicDir:publicDir, compiler:compiler, ...rest } = options;
+	return wrapOutputFiles(n.buildAppSync({ ...rest, define: withDefaultAppBuildDefines(options), ...(publicDir === false ? { disablePublicDir: true } : publicDir !== undefined ? { publicDir } : {}), ...buildCompilerNapiFields(compiler) }));
+}
+function buildCompilerNapiFields(compiler) {
+	const out = {},sc = compiler?.styledComponents;
+	if (sc !== undefined && sc !== false)out.styledComponents = true;
+	if (typeof sc == "object") {
+		if (sc.ssr === false)out.styledComponentsSsr = false;
+		if (sc.minify === true)out.styledComponentsMinify = true;
+		if (sc.fileName === false)out.styledComponentsFileName = false;
+		if (sc.pure === true)out.styledComponentsPure = true;
+		if (typeof sc.namespace == "string" && sc.namespace.length > 0) {
+			out.styledComponentsNamespace = sc.namespace;
+		}
+		if (Array.isArray(sc.meaninglessFileNames)) {
+			out.styledComponentsMeaninglessFileNames = sc.meaninglessFileNames;
+		}
+		if (Array.isArray(sc.topLevelImportPaths)) {
+			out.styledComponentsTopLevelImportPaths = sc.topLevelImportPaths;
+		}
+		if (sc.cssProp === true)out.styledComponentsCssProp = true;
+	}
+	const em = compiler?.emotion;
+	if (em !== undefined && em !== false)out.emotion = true;
+	if (typeof em == "object") {
+		if (em.autoLabel === false)out.emotionAutoLabel = "never"; else if (em.autoLabel === true)out.emotionAutoLabel = "always"; else if (typeof em.autoLabel == "string")out.emotionAutoLabel = em.autoLabel;
+		if (em.sourceMap === true)out.emotionSourceMap = true;
+		if (typeof em.labelFormat == "string" && em.labelFormat.length > 0) {
+			out.emotionLabelFormat = em.labelFormat;
+		}
+		const extras = collectEmotionImportMapExtras(em.importMap);
+		if (extras.css.length > 0)out.emotionExtraCssSources = extras.css;
+		if (extras.styled.length > 0)out.emotionExtraStyledSources = extras.styled;
+	}
+	return out;
+}
+function prepareAppDevSync(options={}) {
+	const n = ensureNative(),{ publicDir:publicDir, ...rest } = options;
+	return n.prepareAppDevSync({ ...rest, ...(publicDir === false ? { disablePublicDir: true } : publicDir !== undefined ? { publicDir } : {}) });
+}
+function close() {
+	native = null;
+}
+function benchmark(options) {
+	if (!options.source && !options.file) {
+		throw new Error("@zntc/core.benchmark: 'source' or 'file' is required");
+	}
+	if (!Array.isArray(options.phases) || options.phases.length === 0) {
+		throw new Error("@zntc/core.benchmark: 'phases' must be a non-empty string array");
+	}
+	return ensureNative().benchmark({ source: options.source, file: options.file, filename: options.filename ?? "input.js", phases: options.phases, iterations: options.iterations ?? 100, warmup: options.warmup ?? 10 });
+}
+function extractHandler(hook) {
+	if (hook == null)return undefined;
+	if (typeof hook == "function")return hook;
+	if (typeof hook == "object" && typeof hook.handler == "function") {
+		return hook.handler;
+	}
+	return undefined;
+}
+function normalizeVitePluginSourceMap(map,onDrop) {
+	if (map == null)return undefined;
+	if (typeof map == "object") {
+		const obj = map,ver = typeof obj.version == "string" ? Number(obj.version) : obj.version;
+		if (ver !== 3) {
+			onDrop(`version=${String(obj.version)} (expected 3)`);
+			return undefined;
+		}
+		if (!Array.isArray(obj.sources)) {
+			onDrop(`missing sources array`);
+			return undefined;
+		}
+		if (typeof obj.mappings != "string") {
+			onDrop(`missing mappings string`);
+			return undefined;
+		}
+	}
+	try {
+		return serializePluginSourceMap(map) ?? undefined;
+	} catch (err) {
+		onDrop(err instanceof Error ? err.message : String(err));
+		return undefined;
+	}
+}
+function createRollupPluginContext(pluginName) {
+	return { error(error) {
+		throw error;
+	}, warn(message) {
+		console.warn(`@zntc/core [${pluginName}]: ${typeof message == "string" ? message : String(message)}`);
+	}, addWatchFile(_id) {
+	}, resolve(_source,_importer,_options) {
+		throw new Error(`@zntc/core [${pluginName}]: this.resolve() is not supported by vitePlugin() adapter yet ` + `(graph mutation surface missing). Use alias config or another plugin's resolveId hook.`);
+	}, emitFile(_file) {
+		throw new Error(`@zntc/core [${pluginName}]: this.emitFile() is not supported by vitePlugin() adapter yet.`);
+	} };
+}
+function createDropWarner(context) {
+	const seen = new Set();
+	return (reason) => {
+		if (seen.has(reason))return;
+		seen.add(reason);
+		context.warn(`sourcemap dropped: ${reason}`);
+	};
+}
+function vitePlugin(rollupPlugin) {
+	return { name: rollupPlugin.name, setup(build) {
+		const context = createRollupPluginContext(rollupPlugin.name),onDropSourceMap = createDropWarner(context),resolveId = extractHandler(rollupPlugin.resolveId);
+		if (resolveId) {
+			build.onResolve({ filter: /.*/ }, (args) => {
+				const result = resolveId.call(context, args.path, args.importer);
+				return mapMaybePromise(result, (result) => {
+					if (result == null)return null;
+					if (typeof result == "string")return { path: result };
+					if (typeof result == "object" && "id" in result) {
+						return { path: result.id, external: result.external };
+					}
+					return null;
+				});
+			});
+		}
+		const load = extractHandler(rollupPlugin.load);
+		if (load) {
+			build.onLoad({ filter: /.*/ }, (args) => {
+				const result = load.call(context, args.path);
+				return mapMaybePromise(result, (result) => {
+					if (result == null)return null;
+					if (typeof result == "string")return { contents: result };
+					if (typeof result == "object" && "code" in result) {
+						return { contents: result.code, map: normalizeVitePluginSourceMap(result.map, onDropSourceMap) };
+					}
+					return null;
+				});
+			});
+		}
+		const transform = extractHandler(rollupPlugin.transform);
+		if (transform) {
+			build.onTransform({ filter: /.*/ }, (args) => {
+				const result = transform.call(context, args.code, args.path);
+				return mapMaybePromise(result, (result) => {
+					if (result == null)return null;
+					if (typeof result == "string")return { code: result };
+					if (typeof result == "object" && "code" in result) {
+						return { code: result.code, map: normalizeVitePluginSourceMap(result.map, onDropSourceMap) };
+					}
+					return null;
+				});
+			});
+		}
+		const renderChunk = extractHandler(rollupPlugin.renderChunk);
+		if (renderChunk) {
+			build.onRenderChunk({ filter: /.*/ }, (args) => {
+				const result = renderChunk.call(context, args.code, args.chunk);
+				return mapMaybePromise(result, (result) => {
+					if (result == null)return null;
+					if (typeof result == "string")return { code: result };
+					if (typeof result == "object" && "code" in result) {
+						return { code: result.code };
+					}
+					return null;
+				});
+			});
+		}
+		const generateBundle = extractHandler(rollupPlugin.generateBundle);
+		if (generateBundle) {
+			build.onGenerateBundle((outputs) => generateBundle.call(context, outputs));
+		}
+		const buildStart = extractHandler(rollupPlugin.buildStart);
+		if (buildStart) {
+			build.onBuildStart(() => buildStart.call(context));
+		}
+		const buildEnd = extractHandler(rollupPlugin.buildEnd);
+		if (buildEnd) {
+			build.onBuildEnd((err) => buildEnd.call(context, err));
+		}
+		const closeBundle = extractHandler(rollupPlugin.closeBundle);
+		if (closeBundle) {
+			build.onCloseBundle(() => closeBundle.call(context));
+		}
+	} };
+}
+function watch(options) {
+	const n = ensureNative(),{ napiOptions:nativeOpts, cleanup:cleanup } = prepareNapiOptions(options),dispatcher = resolveDispatcher(options);
+	if (dispatcher) {
+		nativeOpts._pluginDispatcher = dispatcher;
+		const dispatchCloseBundle = () => {
+			void dispatcher("closeBundle", undefined, null).catch(() => {
+			});
+		},wrapWatchCallback = (callback) => (event) => {
+			void Promise.resolve().then(() => callback?.(event)).finally(dispatchCloseBundle).catch(() => {
+			});
+		};
+		nativeOpts.onReady = wrapWatchCallback(options.onReady);
+		nativeOpts.onRebuild = wrapWatchCallback(options.onRebuild);
+	}
+	let handle;
+	try {
+		handle = n.watch(nativeOpts);
+	} catch (err) {
+		cleanup();
+		throw err;
+	}
+	return { stop() {
+		try {
+			handle.stop();
+		} finally {
+			cleanup();
+		}
+	}, getBundleSourceMap() {
+		return handle.getBundleSourceMap();
+	}, getHmrSourceMap(moduleId) {
+		return handle.getHmrSourceMap(moduleId);
+	} };
+}
+exports.isPlainObject = isPlainObject;
+exports.validateTsConfigRaw = validateTsConfigRaw;
+exports.defineConfig = defineConfig;
+exports.defaultConfigEnv = defaultConfigEnv;
+exports.findConfigPath = findConfigPath;
+exports.findModeConfigPath = findModeConfigPath;
+exports.importAndResolveDefault = importAndResolveDefault;
+exports.loadConfig = loadConfig;
+exports.loadModuleDefault = loadModuleDefault;
+exports.mergeUserConfigs = mergeUserConfigs;
+exports.envToDefine = envToDefine;
+exports.loadEnv = loadEnv;
+exports.KNOWN_CONFIG_KEYS = KNOWN_CONFIG_KEYS;
+exports.suggestKey = suggestKey;
+exports.warnUnknownKeys = warnUnknownKeys;
+exports.defineWorkspace = defineWorkspace;
+exports.filterWorkspaces = filterWorkspaces;
+exports.findWorkspacePath = findWorkspacePath;
+exports.identifyWorkspaceEntries = identifyWorkspaceEntries;
+exports.loadIdentifiedConfig = loadIdentifiedConfig;
+exports.loadWorkspace = loadWorkspace;
+exports.WORKSPACE_EXT_PRIORITY = WORKSPACE_EXT_PRIORITY;
+exports.init = init;
+exports.TsconfigCache = TsconfigCache;
+exports.transpile = transpile;
+exports.tokenize = tokenize;
+exports.configureProfile = configureProfile;
+exports.profileReport = profileReport;
+exports.build = build;
+exports.buildSync = buildSync;
+exports.BuildInstance = BuildInstance;
+exports.zntc = zntc;
+exports.buildAppSync = buildAppSync;
+exports.prepareAppDevSync = prepareAppDevSync;
+exports.close = close;
+exports.benchmark = benchmark;
+exports.vitePlugin = vitePlugin;
+exports.watch = watch;
+//#endregion