@zntc/react-native 0.1.0

package/dist/index.js

@@ -0,0 +1,3471 @@
+var __commonJS = (cb, mod) => function __require() {
+	if (mod) return mod.exports;
+	mod = { exports: {} };
+	try { (0, cb[Object.keys(cb)[0]])(mod.exports, mod); }
+	catch (e) { mod = void 0; throw e; }
+	return mod.exports;
+};
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwn = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var keys = __getOwnPropNames(from), i = 0, key; i < keys.length; i++) {
+      key = keys[i];
+      if (!__hasOwn.call(to, key))
+        __defProp(to, key, { get: ((k) => from[k]).bind(null, key), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+import { Buffer as Buffer$1 } from "node:buffer";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+var createRequire$1 = createRequire;
+var createRequire$2 = createRequire;
+var createRequire$3 = createRequire;
+var createRequire$4 = createRequire;
+var createRequire$5 = createRequire;
+import { resolve, dirname, extname, sep, join, basename, isAbsolute, relative } from "node:path";
+var resolve$1 = resolve;
+var dirname$1 = dirname;
+var extname$1 = extname;
+var dirname$2 = dirname;
+var resolve$2 = resolve;
+var dirname$3 = dirname;
+var join$1 = join;
+var resolve$3 = resolve;
+var dirname$4 = dirname;
+var resolve$4 = resolve;
+var isAbsolute$1 = isAbsolute;
+var resolve$5 = resolve;
+var join$2 = join;
+var pathResolve = resolve;
+var join$3 = join;
+var extname$2 = extname;
+var join$4 = join;
+var dirname$5 = dirname;
+var join$5 = join;
+import { existsSync, lstatSync, readdirSync, realpathSync, readFileSync, mkdtempSync } from "node:fs";
+var readFileSync$1 = readFileSync;
+var readdirSync$1 = readdirSync;
+var existsSync$1 = existsSync;
+var existsSync$2 = existsSync;
+var readFileSync$2 = readFileSync;
+var existsSync$3 = existsSync;
+var existsSync$4 = existsSync;
+var readFileSync$3 = readFileSync;
+import { readFile } from "node:fs/promises";
+var readFile$1 = readFile;
+import { fileURLToPath } from "node:url";
+import { build, init, watch } from "@zntc/core";
+import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
+var spawn$1 = spawn;
+import { createServer } from "node:http";
+//#region index.js
+var require_jsc_safe_url_index = __commonJS({
+	"index.js"(exports, module) {
+const URI_REGEX = /^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+	function _rfc3986Parse(url) {
+		const match = url.match(URI_REGEX);
+		if (match == null) {
+			throw new Error("Unexpected error - failed to regex-match URL");
+		}
+		return { schemeAndAuthority: (match[1] || "") + (match[3] || ""), path: match[5] || "", hasQueryPart: match[6] != null, queryWithoutQuestionMark: match[7] || "", fragmentWithHash: match[8] || "" };
+	}
+	function isJscSafeUrl(url) {
+		const parsedUrl = _rfc3986Parse(url);
+		return !parsedUrl.hasQueryPart;
+	}
+	function toNormalUrl(urlToNormalize) {
+		const parsedUrl = _rfc3986Parse(urlToNormalize);
+		if (parsedUrl.path.indexOf("//&") === -1) {
+			return urlToNormalize;
+		}
+		return (parsedUrl.schemeAndAuthority + parsedUrl.path.replace("//&", "?") + (parsedUrl.queryWithoutQuestionMark.length > 0 ? "&" + parsedUrl.queryWithoutQuestionMark : "") + parsedUrl.fragmentWithHash);
+	}
+	function toJscSafeUrl(urlToConvert) {
+		if (!_rfc3986Parse(urlToConvert).hasQueryPart) {
+			return urlToConvert;
+		}
+		const parsedUrl = _rfc3986Parse(toNormalUrl(urlToConvert));
+		if (parsedUrl.queryWithoutQuestionMark.length > 0 && (parsedUrl.path === "" || parsedUrl.path === "/")) {
+			throw new Error(`The given URL "${urlToConvert}" has an empty path and cannot be converted to a JSC-safe format.`);
+		}
+		return (parsedUrl.schemeAndAuthority + parsedUrl.path + (parsedUrl.queryWithoutQuestionMark.length > 0 ? "//&" + parsedUrl.queryWithoutQuestionMark.replace(/\?/g, "%3F") : "") + parsedUrl.fragmentWithHash);
+	}
+	module.exports = { isJscSafeUrl, toNormalUrl, toJscSafeUrl };
+	
+	}
+});
+//#endregion
+//#region (disabled):url
+var require__disabled__url = __commonJS({
+	"(disabled):url"(exports, module) {
+	}
+});
+//#endregion
+//#region (optional-missing):
+var require__optional_missing__ = __commonJS({
+	"(optional-missing):"(exports, module) {
+		var e = new Error("Cannot find module \"" + "" + "\"");
+		e.code = "MODULE_NOT_FOUND";
+		throw e;
+	}
+});
+//#endregion
+//#region array-set.js
+var require_source_map_lib_array_set = __commonJS({
+	"array-set.js"(exports, module) {
+class ArraySet {
+		constructor() {
+			this._array = [];
+			this._set = new Map();
+		}
+		static fromArray(aArray,aAllowDuplicates) {
+			const set = new ArraySet();
+			for (let i = 0,len = aArray.length; i < len; i++) {
+				set.add(aArray[i], aAllowDuplicates);
+			}
+			return set;
+		}
+		size() {
+			return this._set.size;
+		}
+		add(aStr,aAllowDuplicates) {
+			const isDuplicate = this.has(aStr),idx = this._array.length;
+			if (!isDuplicate || aAllowDuplicates) {
+				this._array.push(aStr);
+			}
+			if (!isDuplicate) {
+				this._set.set(aStr, idx);
+			}
+		}
+		has(aStr) {
+			return this._set.has(aStr);
+		}
+		indexOf(aStr) {
+			const idx = this._set.get(aStr);
+			if (idx >= 0) {
+				return idx;
+			}
+			throw new Error("\"" + aStr + "\" is not in the set.");
+		}
+		at(aIdx) {
+			if (aIdx >= 0 && aIdx < this._array.length) {
+				return this._array[aIdx];
+			}
+			throw new Error("No element indexed by " + aIdx);
+		}
+		toArray() {
+			return this._array.slice();
+		}
+	}
+	exports.ArraySet = ArraySet;
+	
+	}
+});
+//#endregion
+//#region base64-vlq.js
+var require_source_map_lib_base64_vlq = __commonJS({
+	"base64-vlq.js"(exports, module) {
+const base64 = require_source_map_lib_base64(),VLQ_BASE_SHIFT = 5,VLQ_BASE = 1 << VLQ_BASE_SHIFT,VLQ_BASE_MASK = VLQ_BASE - 1,VLQ_CONTINUATION_BIT = VLQ_BASE;
+	function toVLQSigned(aValue) {
+		return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
+	}
+	exports.encode = function base64VLQ_encode(aValue) {
+		let encoded = "",digit,vlq = toVLQSigned(aValue);
+		do {
+			digit = vlq & VLQ_BASE_MASK;
+			vlq >>>= VLQ_BASE_SHIFT;
+			if (vlq > 0) {
+				digit |= VLQ_CONTINUATION_BIT;
+			}
+			encoded += base64.encode(digit);
+		} while (vlq > 0);
+		return encoded;
+	};
+	
+	}
+});
+//#endregion
+//#region base64.js
+var require_source_map_lib_base64 = __commonJS({
+	"base64.js"(exports, module) {
+const intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+	exports.encode = function(number) {
+		if (0 <= number && number < intToCharMap.length) {
+			return intToCharMap[number];
+		}
+		throw new TypeError("Must be between 0 and 63: " + number);
+	};
+	
+	}
+});
+//#endregion
+//#region binary-search.js
+var require_source_map_lib_binary_search = __commonJS({
+	"binary-search.js"(exports, module) {
+exports.GREATEST_LOWER_BOUND = 1;
+	exports.LEAST_UPPER_BOUND = 2;
+	function recursiveSearch(aLow,aHigh,aNeedle,aHaystack,aCompare,aBias) {
+		const mid = Math.floor((aHigh - aLow) / 2) + aLow,cmp = aCompare(aNeedle, aHaystack[mid], true);
+		if (cmp === 0) {
+			return mid;
+		} else if (cmp > 0) {
+			if (aHigh - mid > 1) {
+				return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+			}
+			if (aBias === exports.LEAST_UPPER_BOUND) {
+				return aHigh < aHaystack.length ? aHigh : -1;
+			}
+			return mid;
+		}
+		if (mid - aLow > 1) {
+			return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+		}
+		if (aBias == exports.LEAST_UPPER_BOUND) {
+			return mid;
+		}
+		return aLow < 0 ? -1 : aLow;
+	}
+	exports.search = function search(aNeedle,aHaystack,aCompare,aBias) {
+		if (aHaystack.length === 0) {
+			return -1;
+		}
+		let index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+		if (index < 0) {
+			return -1;
+		}
+		while (index - 1 >= 0) {
+			if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+				break;
+			}
+			--index;
+		}
+		return index;
+	};
+	
+	}
+});
+//#endregion
+//#region mapping-list.js
+var require_source_map_lib_mapping_list = __commonJS({
+	"mapping-list.js"(exports, module) {
+const util = require_source_map_lib_util();
+	function generatedPositionAfter(mappingA,mappingB) {
+		const lineA = mappingA.generatedLine,lineB = mappingB.generatedLine,columnA = mappingA.generatedColumn,columnB = mappingB.generatedColumn;
+		return (lineB > lineA || (lineB == lineA && columnB >= columnA) || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0);
+	}
+	class MappingList {
+		constructor() {
+			this._array = [];
+			this._sorted = true;
+			this._last = { generatedLine: -1, generatedColumn: 0 };
+		}
+		unsortedForEach(aCallback,aThisArg) {
+			this._array.forEach(aCallback, aThisArg);
+		}
+		add(aMapping) {
+			if (generatedPositionAfter(this._last, aMapping)) {
+				this._last = aMapping;
+				this._array.push(aMapping);
+			} else {
+				this._sorted = false;
+				this._array.push(aMapping);
+			}
+		}
+		toArray() {
+			if (!this._sorted) {
+				this._array.sort(util.compareByGeneratedPositionsInflated);
+				this._sorted = true;
+			}
+			return this._array;
+		}
+	}
+	exports.MappingList = MappingList;
+	
+	}
+});
+//#endregion
+//#region read-wasm-browser.js
+var require_source_map_lib_read_wasm_browser = __commonJS({
+	"read-wasm-browser.js"(exports, module) {
+"use strict";
+	let mappingsWasm = null;
+	module.exports = function readWasm() {
+		if (typeof mappingsWasm == "string") {
+			return fetch(mappingsWasm).then((response) => response.arrayBuffer());
+		}
+		if (mappingsWasm instanceof ArrayBuffer) {
+			return Promise.resolve(mappingsWasm);
+		}
+		throw new Error("You must provide the string URL or ArrayBuffer contents of lib/mappings.wasm by calling SourceMapConsumer.initialize({ 'lib/mappings.wasm': ... }) before using SourceMapConsumer");
+	};
+	module.exports.initialize = (input) => {
+		mappingsWasm = input;
+	};
+	
+	}
+});
+//#endregion
+//#region source-map-consumer.js
+var require_source_map_lib_source_map_consumer = __commonJS({
+	"source-map-consumer.js"(exports, module) {
+const util = require_source_map_lib_util(),binarySearch = require_source_map_lib_binary_search(),ArraySet = require_source_map_lib_array_set().ArraySet,base64VLQ = require_source_map_lib_base64_vlq(),readWasm = require_source_map_lib_read_wasm_browser(),wasm = require_source_map_lib_wasm(),INTERNAL = Symbol("smcInternal");
+	class SourceMapConsumer {
+		constructor(aSourceMap,aSourceMapURL) {
+			if (aSourceMap == INTERNAL) {
+				return Promise.resolve(this);
+			}
+			return _factory(aSourceMap, aSourceMapURL);
+		}
+		static initialize(opts) {
+			readWasm.initialize(opts["lib/mappings.wasm"]);
+		}
+		static fromSourceMap(aSourceMap,aSourceMapURL) {
+			return _factoryBSM(aSourceMap, aSourceMapURL);
+		}
+		static async with(rawSourceMap,sourceMapUrl,f) {
+			const consumer = await new SourceMapConsumer(rawSourceMap, sourceMapUrl);
+			try {
+				return await f(consumer);
+			} finally {
+				consumer.destroy();
+			}
+		}
+		eachMapping(aCallback,aContext,aOrder) {
+			throw new Error("Subclasses must implement eachMapping");
+		}
+		allGeneratedPositionsFor(aArgs) {
+			throw new Error("Subclasses must implement allGeneratedPositionsFor");
+		}
+		destroy() {
+			throw new Error("Subclasses must implement destroy");
+		}
+	}
+	SourceMapConsumer.prototype._version = 3;
+	SourceMapConsumer.GENERATED_ORDER = 1;
+	SourceMapConsumer.ORIGINAL_ORDER = 2;
+	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+	exports.SourceMapConsumer = SourceMapConsumer;
+	class BasicSourceMapConsumer extends SourceMapConsumer {
+		constructor(aSourceMap,aSourceMapURL) {
+			return super(INTERNAL).then((that) => {
+				let sourceMap = aSourceMap;
+				if (typeof aSourceMap == "string") {
+					sourceMap = util.parseSourceMapInput(aSourceMap);
+				}
+				const version = util.getArg(sourceMap, "version"),sources = util.getArg(sourceMap, "sources").map(String),names = util.getArg(sourceMap, "names", []),sourceRoot = util.getArg(sourceMap, "sourceRoot", null),sourcesContent = util.getArg(sourceMap, "sourcesContent", null),mappings = util.getArg(sourceMap, "mappings"),file = util.getArg(sourceMap, "file", null),x_google_ignoreList = util.getArg(sourceMap, "x_google_ignoreList", null);
+				if (version != that._version) {
+					throw new Error("Unsupported version: " + version);
+				}
+				that._sourceLookupCache = new Map();
+				that._names = ArraySet.fromArray(names.map(String), true);
+				that._sources = ArraySet.fromArray(sources, true);
+				that._absoluteSources = ArraySet.fromArray(that._sources.toArray().map(function(s) {
+					return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+				}), true);
+				that.sourceRoot = sourceRoot;
+				that.sourcesContent = sourcesContent;
+				that._mappings = mappings;
+				that._sourceMapURL = aSourceMapURL;
+				that.file = file;
+				that.x_google_ignoreList = x_google_ignoreList;
+				that._computedColumnSpans = false;
+				that._mappingsPtr = 0;
+				that._wasm = null;
+				return wasm().then((w) => {
+					that._wasm = w;
+					return that;
+				});
+			});
+		}
+		_findSourceIndex(aSource) {
+			const cachedIndex = this._sourceLookupCache.get(aSource);
+			if (typeof cachedIndex == "number") {
+				return cachedIndex;
+			}
+			const sourceAsMapRelative = util.computeSourceURL(null, aSource, this._sourceMapURL);
+			if (this._absoluteSources.has(sourceAsMapRelative)) {
+				const index = this._absoluteSources.indexOf(sourceAsMapRelative);
+				this._sourceLookupCache.set(aSource, index);
+				return index;
+			}
+			const sourceAsSourceRootRelative = util.computeSourceURL(this.sourceRoot, aSource, this._sourceMapURL);
+			if (this._absoluteSources.has(sourceAsSourceRootRelative)) {
+				const index = this._absoluteSources.indexOf(sourceAsSourceRootRelative);
+				this._sourceLookupCache.set(aSource, index);
+				return index;
+			}
+			return -1;
+		}
+		static fromSourceMap(aSourceMap,aSourceMapURL) {
+			return new BasicSourceMapConsumer(aSourceMap.toString());
+		}
+		get sources() {
+			return this._absoluteSources.toArray();
+		}
+		_getMappingsPtr() {
+			if (this._mappingsPtr === 0) {
+				this._parseMappings();
+			}
+			return this._mappingsPtr;
+		}
+		_parseMappings() {
+			const aStr = this._mappings,size = aStr.length,mappingsBufPtr = this._wasm.exports.allocate_mappings(size) >>> 0,mappingsBuf = new Uint8Array(this._wasm.exports.memory.buffer, mappingsBufPtr, size);
+			for (let i = 0; i < size; i++) {
+				mappingsBuf[i] = aStr.charCodeAt(i);
+			}
+			const mappingsPtr = this._wasm.exports.parse_mappings(mappingsBufPtr);
+			if (!mappingsPtr) {
+				const error = this._wasm.exports.get_last_error();
+				let msg = `Error parsing mappings (code ${error}): `;
+				switch (error) {
+					case 1:
+						msg += "the mappings contained a negative line, column, source index, or name index";
+						break;
+					case 2:
+						msg += "the mappings contained a number larger than 2**32";
+						break;
+					case 3:
+						msg += "reached EOF while in the middle of parsing a VLQ";
+						break;
+					case 4:
+						msg += "invalid base 64 character while parsing a VLQ";
+						break;
+					default:
+						msg += "unknown error code";
+						break;
+				}
+				throw new Error(msg);
+			}
+			this._mappingsPtr = mappingsPtr;
+		}
+		eachMapping(aCallback,aContext,aOrder) {
+			const context = aContext || null,order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+			this._wasm.withMappingCallback((mapping) => {
+				if (mapping.source !== null) {
+					mapping.source = this._absoluteSources.at(mapping.source);
+					if (mapping.name !== null) {
+						mapping.name = this._names.at(mapping.name);
+					}
+				}
+				if (this._computedColumnSpans && mapping.lastGeneratedColumn === null) {
+					mapping.lastGeneratedColumn = Infinity;
+				}
+				aCallback.call(context, mapping);
+			}, () => {
+				switch (order) {
+					case SourceMapConsumer.GENERATED_ORDER:
+						this._wasm.exports.by_generated_location(this._getMappingsPtr());
+						break;
+					case SourceMapConsumer.ORIGINAL_ORDER:
+						this._wasm.exports.by_original_location(this._getMappingsPtr());
+						break;
+					default:
+						throw new Error("Unknown order of iteration.");
+				}
+			});
+		}
+		allGeneratedPositionsFor(aArgs) {
+			let source = util.getArg(aArgs, "source");
+			const originalLine = util.getArg(aArgs, "line"),originalColumn = aArgs.column || 0;
+			source = this._findSourceIndex(source);
+			if (source < 0) {
+				return [];
+			}
+			if (originalLine < 1) {
+				throw new Error("Line numbers must be >= 1");
+			}
+			if (originalColumn < 0) {
+				throw new Error("Column numbers must be >= 0");
+			}
+			const mappings = [];
+			this._wasm.withMappingCallback((m) => {
+				let lastColumn = m.lastGeneratedColumn;
+				if (this._computedColumnSpans && lastColumn === null) {
+					lastColumn = Infinity;
+				}
+				mappings.push({ line: m.generatedLine, column: m.generatedColumn, lastColumn });
+			}, () => {
+				this._wasm.exports.all_generated_locations_for(this._getMappingsPtr(), source, originalLine - 1, "column" in aArgs, originalColumn);
+			});
+			return mappings;
+		}
+		destroy() {
+			if (this._mappingsPtr !== 0) {
+				this._wasm.exports.free_mappings(this._mappingsPtr);
+				this._mappingsPtr = 0;
+			}
+		}
+		computeColumnSpans() {
+			if (this._computedColumnSpans) {
+				return;
+			}
+			this._wasm.exports.compute_column_spans(this._getMappingsPtr());
+			this._computedColumnSpans = true;
+		}
+		originalPositionFor(aArgs) {
+			const needle = { generatedLine: util.getArg(aArgs, "line"), generatedColumn: util.getArg(aArgs, "column") };
+			if (needle.generatedLine < 1) {
+				throw new Error("Line numbers must be >= 1");
+			}
+			if (needle.generatedColumn < 0) {
+				throw new Error("Column numbers must be >= 0");
+			}
+			let bias = util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND);
+			if (bias == null) {
+				bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
+			}
+			let mapping;
+			this._wasm.withMappingCallback((m) => (mapping = m), () => {
+				this._wasm.exports.original_location_for(this._getMappingsPtr(), needle.generatedLine - 1, needle.generatedColumn, bias);
+			});
+			if (mapping) {
+				if (mapping.generatedLine === needle.generatedLine) {
+					let source = util.getArg(mapping, "source", null);
+					if (source !== null) {
+						source = this._absoluteSources.at(source);
+					}
+					let name = util.getArg(mapping, "name", null);
+					if (name !== null) {
+						name = this._names.at(name);
+					}
+					return { source, line: util.getArg(mapping, "originalLine", null), column: util.getArg(mapping, "originalColumn", null), name };
+				}
+			}
+			return { source: null, line: null, column: null, name: null };
+		}
+		hasContentsOfAllSources() {
+			if (!this.sourcesContent) {
+				return false;
+			}
+			return (this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
+				return sc == null;
+			}));
+		}
+		sourceContentFor(aSource,nullOnMissing) {
+			if (!this.sourcesContent) {
+				return null;
+			}
+			const index = this._findSourceIndex(aSource);
+			if (index >= 0) {
+				return this.sourcesContent[index];
+			}
+			if (nullOnMissing) {
+				return null;
+			}
+			throw new Error("\"" + aSource + "\" is not in the SourceMap.");
+		}
+		generatedPositionFor(aArgs) {
+			let source = util.getArg(aArgs, "source");
+			source = this._findSourceIndex(source);
+			if (source < 0) {
+				return { line: null, column: null, lastColumn: null };
+			}
+			const needle = { source, originalLine: util.getArg(aArgs, "line"), originalColumn: util.getArg(aArgs, "column") };
+			if (needle.originalLine < 1) {
+				throw new Error("Line numbers must be >= 1");
+			}
+			if (needle.originalColumn < 0) {
+				throw new Error("Column numbers must be >= 0");
+			}
+			let bias = util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND);
+			if (bias == null) {
+				bias = SourceMapConsumer.GREATEST_LOWER_BOUND;
+			}
+			let mapping;
+			this._wasm.withMappingCallback((m) => (mapping = m), () => {
+				this._wasm.exports.generated_location_for(this._getMappingsPtr(), needle.source, needle.originalLine - 1, needle.originalColumn, bias);
+			});
+			if (mapping) {
+				if (mapping.source === needle.source) {
+					let lastColumn = mapping.lastGeneratedColumn;
+					if (this._computedColumnSpans && lastColumn === null) {
+						lastColumn = Infinity;
+					}
+					return { line: util.getArg(mapping, "generatedLine", null), column: util.getArg(mapping, "generatedColumn", null), lastColumn };
+				}
+			}
+			return { line: null, column: null, lastColumn: null };
+		}
+	}
+	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+	class IndexedSourceMapConsumer extends SourceMapConsumer {
+		constructor(aSourceMap,aSourceMapURL) {
+			return super(INTERNAL).then((that) => {
+				let sourceMap = aSourceMap;
+				if (typeof aSourceMap == "string") {
+					sourceMap = util.parseSourceMapInput(aSourceMap);
+				}
+				const version = util.getArg(sourceMap, "version"),sections = util.getArg(sourceMap, "sections");
+				if (version != that._version) {
+					throw new Error("Unsupported version: " + version);
+				}
+				let lastOffset = { line: -1, column: 0 };
+				return Promise.all(sections.map((s) => {
+					if (s.url) {
+						throw new Error("Support for url field in sections not implemented.");
+					}
+					const offset = util.getArg(s, "offset"),offsetLine = util.getArg(offset, "line"),offsetColumn = util.getArg(offset, "column");
+					if (offsetLine < lastOffset.line || (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
+						throw new Error("Section offsets must be ordered and non-overlapping.");
+					}
+					lastOffset = offset;
+					const cons = new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL);
+					return cons.then((consumer) => {
+						return { generatedOffset: { generatedLine: offsetLine + 1, generatedColumn: offsetColumn + 1 }, consumer };
+					});
+				})).then((s) => {
+					that._sections = s;
+					return that;
+				});
+			});
+		}
+		get sources() {
+			const sources = [];
+			for (let i = 0; i < this._sections.length; i++) {
+				for (let j = 0; j < this._sections[i].consumer.sources.length; j++) {
+					sources.push(this._sections[i].consumer.sources[j]);
+				}
+			}
+			return sources;
+		}
+		originalPositionFor(aArgs) {
+			const needle = { generatedLine: util.getArg(aArgs, "line"), generatedColumn: util.getArg(aArgs, "column") },sectionIndex = binarySearch.search(needle, this._sections, function(aNeedle,section) {
+				const cmp = aNeedle.generatedLine - section.generatedOffset.generatedLine;
+				if (cmp) {
+					return cmp;
+				}
+				return (aNeedle.generatedColumn - (section.generatedOffset.generatedColumn - 1));
+			}),section = this._sections[sectionIndex];
+			if (!section) {
+				return { source: null, line: null, column: null, name: null };
+			}
+			return section.consumer.originalPositionFor({ line: needle.generatedLine - (section.generatedOffset.generatedLine - 1), column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), bias: aArgs.bias });
+		}
+		hasContentsOfAllSources() {
+			return this._sections.every(function(s) {
+				return s.consumer.hasContentsOfAllSources();
+			});
+		}
+		sourceContentFor(aSource,nullOnMissing) {
+			for (let i = 0; i < this._sections.length; i++) {
+				const section = this._sections[i],content = section.consumer.sourceContentFor(aSource, true);
+				if (content) {
+					return content;
+				}
+			}
+			if (nullOnMissing) {
+				return null;
+			}
+			throw new Error("\"" + aSource + "\" is not in the SourceMap.");
+		}
+		_findSectionIndex(source) {
+			for (let i = 0; i < this._sections.length; i++) {
+				const { consumer:consumer } = this._sections[i];
+				if (consumer._findSourceIndex(source) !== -1) {
+					return i;
+				}
+			}
+			return -1;
+		}
+		generatedPositionFor(aArgs) {
+			const index = this._findSectionIndex(util.getArg(aArgs, "source")),section = index >= 0 ? this._sections[index] : null,nextSection = index >= 0 && index + 1 < this._sections.length ? this._sections[index + 1] : null,generatedPosition = section && section.consumer.generatedPositionFor(aArgs);
+			if (generatedPosition && generatedPosition.line !== null) {
+				const lineShift = section.generatedOffset.generatedLine - 1,columnShift = section.generatedOffset.generatedColumn - 1;
+				if (generatedPosition.line === 1) {
+					generatedPosition.column += columnShift;
+					if (typeof generatedPosition.lastColumn == "number") {
+						generatedPosition.lastColumn += columnShift;
+					}
+				}
+				if (generatedPosition.lastColumn === Infinity && nextSection && generatedPosition.line === nextSection.generatedOffset.generatedLine) {
+					generatedPosition.lastColumn = nextSection.generatedOffset.generatedColumn - 2;
+				}
+				generatedPosition.line += lineShift;
+				return generatedPosition;
+			}
+			return { line: null, column: null, lastColumn: null };
+		}
+		allGeneratedPositionsFor(aArgs) {
+			const index = this._findSectionIndex(util.getArg(aArgs, "source")),section = index >= 0 ? this._sections[index] : null,nextSection = index >= 0 && index + 1 < this._sections.length ? this._sections[index + 1] : null;
+			if (!section)return [];
+			return section.consumer.allGeneratedPositionsFor(aArgs).map((generatedPosition) => {
+				const lineShift = section.generatedOffset.generatedLine - 1,columnShift = section.generatedOffset.generatedColumn - 1;
+				if (generatedPosition.line === 1) {
+					generatedPosition.column += columnShift;
+					if (typeof generatedPosition.lastColumn == "number") {
+						generatedPosition.lastColumn += columnShift;
+					}
+				}
+				if (generatedPosition.lastColumn === Infinity && nextSection && generatedPosition.line === nextSection.generatedOffset.generatedLine) {
+					generatedPosition.lastColumn = nextSection.generatedOffset.generatedColumn - 2;
+				}
+				generatedPosition.line += lineShift;
+				return generatedPosition;
+			});
+		}
+		eachMapping(aCallback,aContext,aOrder) {
+			this._sections.forEach((section, index) => {
+				const nextSection = index + 1 < this._sections.length ? this._sections[index + 1] : null,{ generatedOffset:generatedOffset } = section,lineShift = generatedOffset.generatedLine - 1,columnShift = generatedOffset.generatedColumn - 1;
+				section.consumer.eachMapping(function(mapping) {
+					if (mapping.generatedLine === 1) {
+						mapping.generatedColumn += columnShift;
+						if (typeof mapping.lastGeneratedColumn == "number") {
+							mapping.lastGeneratedColumn += columnShift;
+						}
+					}
+					if (mapping.lastGeneratedColumn === Infinity && nextSection && mapping.generatedLine === nextSection.generatedOffset.generatedLine) {
+						mapping.lastGeneratedColumn = nextSection.generatedOffset.generatedColumn - 2;
+					}
+					mapping.generatedLine += lineShift;
+					aCallback.call(this, mapping);
+				}, aContext, aOrder);
+			});
+		}
+		computeColumnSpans() {
+			for (let i = 0; i < this._sections.length; i++) {
+				this._sections[i].consumer.computeColumnSpans();
+			}
+		}
+		destroy() {
+			for (let i = 0; i < this._sections.length; i++) {
+				this._sections[i].consumer.destroy();
+			}
+		}
+	}
+	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+	function _factory(aSourceMap,aSourceMapURL) {
+		let sourceMap = aSourceMap;
+		if (typeof aSourceMap == "string") {
+			sourceMap = util.parseSourceMapInput(aSourceMap);
+		}
+		const consumer = sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+		return Promise.resolve(consumer);
+	}
+	function _factoryBSM(aSourceMap,aSourceMapURL) {
+		return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+	}
+	
+	}
+});
+//#endregion
+//#region source-map-generator.js
+var require_source_map_lib_source_map_generator = __commonJS({
+	"source-map-generator.js"(exports, module) {
+const base64VLQ = require_source_map_lib_base64_vlq(),util = require_source_map_lib_util(),ArraySet = require_source_map_lib_array_set().ArraySet,MappingList = require_source_map_lib_mapping_list().MappingList;
+	class SourceMapGenerator {
+		constructor(aArgs) {
+			if (!aArgs) {
+				aArgs = {};
+			}
+			this._file = util.getArg(aArgs, "file", null);
+			this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
+			this._skipValidation = util.getArg(aArgs, "skipValidation", false);
+			this._sources = new ArraySet();
+			this._names = new ArraySet();
+			this._mappings = new MappingList();
+			this._sourcesContents = null;
+		}
+		static fromSourceMap(aSourceMapConsumer) {
+			const sourceRoot = aSourceMapConsumer.sourceRoot,generator = new SourceMapGenerator({ file: aSourceMapConsumer.file, sourceRoot });
+			aSourceMapConsumer.eachMapping(function(mapping) {
+				const newMapping = { generated: { line: mapping.generatedLine, column: mapping.generatedColumn } };
+				if (mapping.source != null) {
+					newMapping.source = mapping.source;
+					if (sourceRoot != null) {
+						newMapping.source = util.relative(sourceRoot, newMapping.source);
+					}
+					newMapping.original = { line: mapping.originalLine, column: mapping.originalColumn };
+					if (mapping.name != null) {
+						newMapping.name = mapping.name;
+					}
+				}
+				generator.addMapping(newMapping);
+			});
+			aSourceMapConsumer.sources.forEach(function(sourceFile) {
+				let sourceRelative = sourceFile;
+				if (sourceRoot != null) {
+					sourceRelative = util.relative(sourceRoot, sourceFile);
+				}
+				if (!generator._sources.has(sourceRelative)) {
+					generator._sources.add(sourceRelative);
+				}
+				const content = aSourceMapConsumer.sourceContentFor(sourceFile);
+				if (content != null) {
+					generator.setSourceContent(sourceFile, content);
+				}
+			});
+			return generator;
+		}
+		addMapping(aArgs) {
+			const generated = util.getArg(aArgs, "generated"),original = util.getArg(aArgs, "original", null);
+			let source = util.getArg(aArgs, "source", null),name = util.getArg(aArgs, "name", null);
+			if (!this._skipValidation) {
+				this._validateMapping(generated, original, source, name);
+			}
+			if (source != null) {
+				source = String(source);
+				if (!this._sources.has(source)) {
+					this._sources.add(source);
+				}
+			}
+			if (name != null) {
+				name = String(name);
+				if (!this._names.has(name)) {
+					this._names.add(name);
+				}
+			}
+			this._mappings.add({ generatedLine: generated.line, generatedColumn: generated.column, originalLine: original && original.line, originalColumn: original && original.column, source, name });
+		}
+		setSourceContent(aSourceFile,aSourceContent) {
+			let source = aSourceFile;
+			if (this._sourceRoot != null) {
+				source = util.relative(this._sourceRoot, source);
+			}
+			if (aSourceContent != null) {
+				if (!this._sourcesContents) {
+					this._sourcesContents = Object.create(null);
+				}
+				this._sourcesContents[util.toSetString(source)] = aSourceContent;
+			} else if (this._sourcesContents) {
+				delete this._sourcesContents[util.toSetString(source)];
+				if (Object.keys(this._sourcesContents).length === 0) {
+					this._sourcesContents = null;
+				}
+			}
+		}
+		applySourceMap(aSourceMapConsumer,aSourceFile,aSourceMapPath) {
+			let sourceFile = aSourceFile;
+			if (aSourceFile == null) {
+				if (aSourceMapConsumer.file == null) {
+					throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + "or the source map's \"file\" property. Both were omitted.");
+				}
+				sourceFile = aSourceMapConsumer.file;
+			}
+			const sourceRoot = this._sourceRoot;
+			if (sourceRoot != null) {
+				sourceFile = util.relative(sourceRoot, sourceFile);
+			}
+			const newSources = this._mappings.toArray().length > 0 ? new ArraySet() : this._sources,newNames = new ArraySet();
+			this._mappings.unsortedForEach(function(mapping) {
+				if (mapping.source === sourceFile && mapping.originalLine != null) {
+					const original = aSourceMapConsumer.originalPositionFor({ line: mapping.originalLine, column: mapping.originalColumn });
+					if (original.source != null) {
+						mapping.source = original.source;
+						if (aSourceMapPath != null) {
+							mapping.source = util.join(aSourceMapPath, mapping.source);
+						}
+						if (sourceRoot != null) {
+							mapping.source = util.relative(sourceRoot, mapping.source);
+						}
+						mapping.originalLine = original.line;
+						mapping.originalColumn = original.column;
+						if (original.name != null) {
+							mapping.name = original.name;
+						}
+					}
+				}
+				const source = mapping.source;
+				if (source != null && !newSources.has(source)) {
+					newSources.add(source);
+				}
+				const name = mapping.name;
+				if (name != null && !newNames.has(name)) {
+					newNames.add(name);
+				}
+			}, this);
+			this._sources = newSources;
+			this._names = newNames;
+			aSourceMapConsumer.sources.forEach(function(srcFile) {
+				const content = aSourceMapConsumer.sourceContentFor(srcFile);
+				if (content != null) {
+					if (aSourceMapPath != null) {
+						srcFile = util.join(aSourceMapPath, srcFile);
+					}
+					if (sourceRoot != null) {
+						srcFile = util.relative(sourceRoot, srcFile);
+					}
+					this.setSourceContent(srcFile, content);
+				}
+			}, this);
+		}
+		_validateMapping(aGenerated,aOriginal,aSource,aName) {
+			if (aOriginal && typeof aOriginal.line != "number" && typeof aOriginal.column != "number") {
+				throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");
+			}
+			if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
+			} else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
+			} else {
+				throw new Error("Invalid mapping: " + JSON.stringify({ generated: aGenerated, source: aSource, original: aOriginal, name: aName }));
+			}
+		}
+		_serializeMappings() {
+			let previousGeneratedColumn = 0,previousGeneratedLine = 1,previousOriginalColumn = 0,previousOriginalLine = 0,previousName = 0,previousSource = 0,result = "",next,mapping,nameIdx,sourceIdx;
+			const mappings = this._mappings.toArray();
+			for (let i = 0,len = mappings.length; i < len; i++) {
+				mapping = mappings[i];
+				next = "";
+				if (mapping.generatedLine !== previousGeneratedLine) {
+					previousGeneratedColumn = 0;
+					while (mapping.generatedLine !== previousGeneratedLine) {
+						next += ";";
+						previousGeneratedLine++;
+					}
+				} else if (i > 0) {
+					if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+						continue;
+					}
+					next += ",";
+				}
+				next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
+				previousGeneratedColumn = mapping.generatedColumn;
+				if (mapping.source != null) {
+					sourceIdx = this._sources.indexOf(mapping.source);
+					next += base64VLQ.encode(sourceIdx - previousSource);
+					previousSource = sourceIdx;
+					next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
+					previousOriginalLine = mapping.originalLine - 1;
+					next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
+					previousOriginalColumn = mapping.originalColumn;
+					if (mapping.name != null) {
+						nameIdx = this._names.indexOf(mapping.name);
+						next += base64VLQ.encode(nameIdx - previousName);
+						previousName = nameIdx;
+					}
+				}
+				result += next;
+			}
+			return result;
+		}
+		_generateSourcesContent(aSources,aSourceRoot) {
+			return aSources.map(function(source) {
+				if (!this._sourcesContents) {
+					return null;
+				}
+				if (aSourceRoot != null) {
+					source = util.relative(aSourceRoot, source);
+				}
+				const key = util.toSetString(source);
+				return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
+			}, this);
+		}
+		toJSON() {
+			const map = { version: this._version, sources: this._sources.toArray(), names: this._names.toArray(), mappings: this._serializeMappings() };
+			if (this._file != null) {
+				map.file = this._file;
+			}
+			if (this._sourceRoot != null) {
+				map.sourceRoot = this._sourceRoot;
+			}
+			if (this._sourcesContents) {
+				map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+			}
+			return map;
+		}
+		toString() {
+			return JSON.stringify(this.toJSON());
+		}
+	}
+	SourceMapGenerator.prototype._version = 3;
+	exports.SourceMapGenerator = SourceMapGenerator;
+	
+	}
+});
+//#endregion
+//#region source-node.js
+var require_source_map_lib_source_node = __commonJS({
+	"source-node.js"(exports, module) {
+const SourceMapGenerator = require_source_map_lib_source_map_generator().SourceMapGenerator,util = require_source_map_lib_util(),REGEX_NEWLINE = /(\r?\n)/,NEWLINE_CODE = 10,isSourceNode = "$$$isSourceNode$$$";
+	class SourceNode {
+		constructor(aLine,aColumn,aSource,aChunks,aName) {
+			this.children = [];
+			this.sourceContents = {};
+			this.line = aLine == null ? null : aLine;
+			this.column = aColumn == null ? null : aColumn;
+			this.source = aSource == null ? null : aSource;
+			this.name = aName == null ? null : aName;
+			this[isSourceNode] = true;
+			if (aChunks != null)this.add(aChunks);
+		}
+		static fromStringWithSourceMap(aGeneratedCode,aSourceMapConsumer,aRelativePath) {
+			const node = new SourceNode(),remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+			let remainingLinesIndex = 0;
+			const shiftNextLine = function() {
+				const lineContents = getNextLine(),newLine = getNextLine() || "";
+				return lineContents + newLine;
+				function getNextLine() {
+					return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : undefined;
+				}
+			};
+			let lastGeneratedLine = 1,lastGeneratedColumn = 0,lastMapping = null,nextLine;
+			aSourceMapConsumer.eachMapping(function(mapping) {
+				if (lastMapping !== null) {
+					if (lastGeneratedLine < mapping.generatedLine) {
+						addMappingWithCode(lastMapping, shiftNextLine());
+						lastGeneratedLine++;
+						lastGeneratedColumn = 0;
+					} else {
+						nextLine = remainingLines[remainingLinesIndex] || "";
+						const code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
+						remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
+						lastGeneratedColumn = mapping.generatedColumn;
+						addMappingWithCode(lastMapping, code);
+						lastMapping = mapping;
+						return;
+					}
+				}
+				while (lastGeneratedLine < mapping.generatedLine) {
+					node.add(shiftNextLine());
+					lastGeneratedLine++;
+				}
+				if (lastGeneratedColumn < mapping.generatedColumn) {
+					nextLine = remainingLines[remainingLinesIndex] || "";
+					node.add(nextLine.substr(0, mapping.generatedColumn));
+					remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+					lastGeneratedColumn = mapping.generatedColumn;
+				}
+				lastMapping = mapping;
+			}, this);
+			if (remainingLinesIndex < remainingLines.length) {
+				if (lastMapping) {
+					addMappingWithCode(lastMapping, shiftNextLine());
+				}
+				node.add(remainingLines.splice(remainingLinesIndex).join(""));
+			}
+			aSourceMapConsumer.sources.forEach(function(sourceFile) {
+				const content = aSourceMapConsumer.sourceContentFor(sourceFile);
+				if (content != null) {
+					if (aRelativePath != null) {
+						sourceFile = util.join(aRelativePath, sourceFile);
+					}
+					node.setSourceContent(sourceFile, content);
+				}
+			});
+			return node;
+			function addMappingWithCode(mapping,code) {
+				if (mapping === null || mapping.source === undefined) {
+					node.add(code);
+				} else {
+					const source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
+					node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
+				}
+			}
+		}
+		add(aChunk) {
+			if (Array.isArray(aChunk)) {
+				aChunk.forEach(function(chunk) {
+					this.add(chunk);
+				}, this);
+			} else if (aChunk[isSourceNode] || typeof aChunk == "string") {
+				if (aChunk) {
+					this.children.push(aChunk);
+				}
+			} else {
+				throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
+			}
+			return this;
+		}
+		prepend(aChunk) {
+			if (Array.isArray(aChunk)) {
+				for (let i = aChunk.length - 1; i >= 0; i--) {
+					this.prepend(aChunk[i]);
+				}
+			} else if (aChunk[isSourceNode] || typeof aChunk == "string") {
+				this.children.unshift(aChunk);
+			} else {
+				throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
+			}
+			return this;
+		}
+		walk(aFn) {
+			let chunk;
+			for (let i = 0,len = this.children.length; i < len; i++) {
+				chunk = this.children[i];
+				if (chunk[isSourceNode]) {
+					chunk.walk(aFn);
+				} else if (chunk !== "") {
+					aFn(chunk, { source: this.source, line: this.line, column: this.column, name: this.name });
+				}
+			}
+		}
+		join(aSep) {
+			let newChildren,i;
+			const len = this.children.length;
+			if (len > 0) {
+				newChildren = [];
+				for (i = 0; i < len - 1; i++) {
+					newChildren.push(this.children[i]);
+					newChildren.push(aSep);
+				}
+				newChildren.push(this.children[i]);
+				this.children = newChildren;
+			}
+			return this;
+		}
+		replaceRight(aPattern,aReplacement) {
+			const lastChild = this.children[this.children.length - 1];
+			if (lastChild[isSourceNode]) {
+				lastChild.replaceRight(aPattern, aReplacement);
+			} else if (typeof lastChild == "string") {
+				this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+			} else {
+				this.children.push("".replace(aPattern, aReplacement));
+			}
+			return this;
+		}
+		setSourceContent(aSourceFile,aSourceContent) {
+			this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+		}
+		walkSourceContents(aFn) {
+			for (let i = 0,len = this.children.length; i < len; i++) {
+				if (this.children[i][isSourceNode]) {
+					this.children[i].walkSourceContents(aFn);
+				}
+			}
+			const sources = Object.keys(this.sourceContents);
+			for (let i = 0,len = sources.length; i < len; i++) {
+				aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+			}
+		}
+		toString() {
+			let str = "";
+			this.walk(function(chunk) {
+				str += chunk;
+			});
+			return str;
+		}
+		toStringWithSourceMap(aArgs) {
+			const generated = { code: "", line: 1, column: 0 },map = new SourceMapGenerator(aArgs);
+			let sourceMappingActive = false,lastOriginalSource = null,lastOriginalLine = null,lastOriginalColumn = null,lastOriginalName = null;
+			this.walk(function(chunk,original) {
+				generated.code += chunk;
+				if (original.source !== null && original.line !== null && original.column !== null) {
+					if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
+						map.addMapping({ source: original.source, original: { line: original.line, column: original.column }, generated: { line: generated.line, column: generated.column }, name: original.name });
+					}
+					lastOriginalSource = original.source;
+					lastOriginalLine = original.line;
+					lastOriginalColumn = original.column;
+					lastOriginalName = original.name;
+					sourceMappingActive = true;
+				} else if (sourceMappingActive) {
+					map.addMapping({ generated: { line: generated.line, column: generated.column } });
+					lastOriginalSource = null;
+					sourceMappingActive = false;
+				}
+				for (let idx = 0,length = chunk.length; idx < length; idx++) {
+					if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+						generated.line++;
+						generated.column = 0;
+						if (idx + 1 === length) {
+							lastOriginalSource = null;
+							sourceMappingActive = false;
+						} else if (sourceMappingActive) {
+							map.addMapping({ source: original.source, original: { line: original.line, column: original.column }, generated: { line: generated.line, column: generated.column }, name: original.name });
+						}
+					} else {
+						generated.column++;
+					}
+				}
+			});
+			this.walkSourceContents(function(sourceFile,sourceContent) {
+				map.setSourceContent(sourceFile, sourceContent);
+			});
+			return { code: generated.code, map };
+		}
+	}
+	exports.SourceNode = SourceNode;
+	
+	}
+});
+//#endregion
+//#region url.js
+var require_source_map_lib_url = __commonJS({
+	"url.js"(exports, module) {
+"use strict";
+	module.exports = typeof URL == "function" ? URL : require__disabled__url().URL;
+	
+	}
+});
+//#endregion
+//#region util.js
+var require_source_map_lib_util = __commonJS({
+	"util.js"(exports, module) {
+const URL = require_source_map_lib_url();
+	function getArg(aArgs,aName,aDefaultValue) {
+		if (aName in aArgs) {
+			return aArgs[aName];
+		} else if (arguments.length === 3) {
+			return aDefaultValue;
+		}
+		throw new Error("\"" + aName + "\" is a required argument.");
+	}
+	exports.getArg = getArg;
+	const supportsNullProto = (function() {
+		const obj = Object.create(null);
+		return !("__proto__" in obj);
+	})();
+	function identity(s) {
+		return s;
+	}
+	function toSetString(aStr) {
+		if (isProtoString(aStr)) {
+			return "$" + aStr;
+		}
+		return aStr;
+	}
+	exports.toSetString = supportsNullProto ? identity : toSetString;
+	function fromSetString(aStr) {
+		if (isProtoString(aStr)) {
+			return aStr.slice(1);
+		}
+		return aStr;
+	}
+	exports.fromSetString = supportsNullProto ? identity : fromSetString;
+	function isProtoString(s) {
+		if (!s) {
+			return false;
+		}
+		const length = s.length;
+		if (length < 9) {
+			return false;
+		}
+		if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+			return false;
+		}
+		for (let i = length - 10; i >= 0; i--) {
+			if (s.charCodeAt(i) !== 36) {
+				return false;
+			}
+		}
+		return true;
+	}
+	function strcmp(aStr1,aStr2) {
+		if (aStr1 === aStr2) {
+			return 0;
+		}
+		if (aStr1 === null) {
+			return 1;
+		}
+		if (aStr2 === null) {
+			return -1;
+		}
+		if (aStr1 > aStr2) {
+			return 1;
+		}
+		return -1;
+	}
+	function compareByGeneratedPositionsInflated(mappingA,mappingB) {
+		let cmp = mappingA.generatedLine - mappingB.generatedLine;
+		if (cmp !== 0) {
+			return cmp;
+		}
+		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+		if (cmp !== 0) {
+			return cmp;
+		}
+		cmp = strcmp(mappingA.source, mappingB.source);
+		if (cmp !== 0) {
+			return cmp;
+		}
+		cmp = mappingA.originalLine - mappingB.originalLine;
+		if (cmp !== 0) {
+			return cmp;
+		}
+		cmp = mappingA.originalColumn - mappingB.originalColumn;
+		if (cmp !== 0) {
+			return cmp;
+		}
+		return strcmp(mappingA.name, mappingB.name);
+	}
+	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+	function parseSourceMapInput(str) {
+		return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+	}
+	exports.parseSourceMapInput = parseSourceMapInput;
+	const PROTOCOL = "http:",PROTOCOL_AND_HOST = `${PROTOCOL}//host`;
+	function createSafeHandler(cb) {
+		return (input) => {
+			const type = getURLType(input),base = buildSafeBase(input),url = new URL(input, base);
+			cb(url);
+			const result = url.toString();
+			if (type === "absolute") {
+				return result;
+			} else if (type === "scheme-relative") {
+				return result.slice(PROTOCOL.length);
+			} else if (type === "path-absolute") {
+				return result.slice(PROTOCOL_AND_HOST.length);
+			}
+			return computeRelativeURL(base, result);
+		};
+	}
+	function withBase(url,base) {
+		return new URL(url, base).toString();
+	}
+	function buildUniqueSegment(prefix,str) {
+		let id = 0;
+		do {
+			const ident = prefix + id++;
+			if (str.indexOf(ident) === -1)return ident;
+		} while (true);
+	}
+	function buildSafeBase(str) {
+		const maxDotParts = str.split("..").length - 1,segment = buildUniqueSegment("p", str);
+		let base = `${PROTOCOL_AND_HOST}/`;
+		for (let i = 0; i < maxDotParts; i++) {
+			base += `${segment}/`;
+		}
+		return base;
+	}
+	const ABSOLUTE_SCHEME = /^[A-Za-z0-9\+\-\.]+:/;
+	function getURLType(url) {
+		if (url[0] === "/") {
+			if (url[1] === "/")return "scheme-relative";
+			return "path-absolute";
+		}
+		return ABSOLUTE_SCHEME.test(url) ? "absolute" : "path-relative";
+	}
+	function computeRelativeURL(rootURL,targetURL) {
+		if (typeof rootURL == "string")rootURL = new URL(rootURL);
+		if (typeof targetURL == "string")targetURL = new URL(targetURL);
+		const targetParts = targetURL.pathname.split("/"),rootParts = rootURL.pathname.split("/");
+		if (rootParts.length > 0 && !rootParts[rootParts.length - 1]) {
+			rootParts.pop();
+		}
+		while (targetParts.length > 0 && rootParts.length > 0 && targetParts[0] === rootParts[0]) {
+			targetParts.shift();
+			rootParts.shift();
+		}
+		const relativePath = rootParts.map(() => "..").concat(targetParts).join("/");
+		return relativePath + targetURL.search + targetURL.hash;
+	}
+	const ensureDirectory = createSafeHandler((url) => {
+		url.pathname = url.pathname.replace(/\/?$/, "/");
+	}),trimFilename = createSafeHandler((url) => {
+		url.href = new URL(".", url.toString()).toString();
+	}),normalize = createSafeHandler((url) => {
+	});
+	exports.normalize = normalize;
+	function join(aRoot,aPath) {
+		const pathType = getURLType(aPath),rootType = getURLType(aRoot);
+		aRoot = ensureDirectory(aRoot);
+		if (pathType === "absolute") {
+			return withBase(aPath, undefined);
+		}
+		if (rootType === "absolute") {
+			return withBase(aPath, aRoot);
+		}
+		if (pathType === "scheme-relative") {
+			return normalize(aPath);
+		}
+		if (rootType === "scheme-relative") {
+			return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(PROTOCOL.length);
+		}
+		if (pathType === "path-absolute") {
+			return normalize(aPath);
+		}
+		if (rootType === "path-absolute") {
+			return withBase(aPath, withBase(aRoot, PROTOCOL_AND_HOST)).slice(PROTOCOL_AND_HOST.length);
+		}
+		const base = buildSafeBase(aPath + aRoot),newPath = withBase(aPath, withBase(aRoot, base));
+		return computeRelativeURL(base, newPath);
+	}
+	exports.join = join;
+	function relative(rootURL,targetURL) {
+		const result = relativeIfPossible(rootURL, targetURL);
+		return typeof result == "string" ? result : normalize(targetURL);
+	}
+	exports.relative = relative;
+	function relativeIfPossible(rootURL,targetURL) {
+		const urlType = getURLType(rootURL);
+		if (urlType !== getURLType(targetURL)) {
+			return null;
+		}
+		const base = buildSafeBase(rootURL + targetURL),root = new URL(rootURL, base),target = new URL(targetURL, base);
+		try {
+			new URL("", target.toString());
+		} catch (err) {
+			return null;
+		}
+		if (target.protocol !== root.protocol || target.user !== root.user || target.password !== root.password || target.hostname !== root.hostname || target.port !== root.port) {
+			return null;
+		}
+		return computeRelativeURL(root, target);
+	}
+	function computeSourceURL(sourceRoot,sourceURL,sourceMapURL) {
+		if (sourceRoot && getURLType(sourceURL) === "path-absolute") {
+			sourceURL = sourceURL.replace(/^\//, "");
+		}
+		let url = normalize(sourceURL || "");
+		if (sourceRoot)url = join(sourceRoot, url);
+		if (sourceMapURL)url = join(trimFilename(sourceMapURL), url);
+		return url;
+	}
+	exports.computeSourceURL = computeSourceURL;
+	
+	}
+});
+//#endregion
+//#region wasm.js
+var require_source_map_lib_wasm = __commonJS({
+	"wasm.js"(exports, module) {
+const readWasm = require_source_map_lib_read_wasm_browser();
+	function Mapping() {
+		this.generatedLine = 0;
+		this.generatedColumn = 0;
+		this.lastGeneratedColumn = null;
+		this.source = null;
+		this.originalLine = null;
+		this.originalColumn = null;
+		this.name = null;
+	}
+	let cachedWasm = null;
+	module.exports = function wasm() {
+		if (cachedWasm) {
+			return cachedWasm;
+		}
+		const callbackStack = [];
+		cachedWasm = readWasm().then((buffer) => {
+			return WebAssembly.instantiate(buffer, { env: { mapping_callback(generatedLine,generatedColumn,hasLastGeneratedColumn,lastGeneratedColumn,hasOriginal,source,originalLine,originalColumn,hasName,name) {
+				const mapping = new Mapping();
+				mapping.generatedLine = generatedLine + 1;
+				mapping.generatedColumn = generatedColumn;
+				if (hasLastGeneratedColumn) {
+					mapping.lastGeneratedColumn = lastGeneratedColumn - 1;
+				}
+				if (hasOriginal) {
+					mapping.source = source;
+					mapping.originalLine = originalLine + 1;
+					mapping.originalColumn = originalColumn;
+					if (hasName) {
+						mapping.name = name;
+					}
+				}
+				callbackStack[callbackStack.length - 1](mapping);
+			}, start_all_generated_locations_for() {
+				console.time("all_generated_locations_for");
+			}, end_all_generated_locations_for() {
+				console.timeEnd("all_generated_locations_for");
+			}, start_compute_column_spans() {
+				console.time("compute_column_spans");
+			}, end_compute_column_spans() {
+				console.timeEnd("compute_column_spans");
+			}, start_generated_location_for() {
+				console.time("generated_location_for");
+			}, end_generated_location_for() {
+				console.timeEnd("generated_location_for");
+			}, start_original_location_for() {
+				console.time("original_location_for");
+			}, end_original_location_for() {
+				console.timeEnd("original_location_for");
+			}, start_parse_mappings() {
+				console.time("parse_mappings");
+			}, end_parse_mappings() {
+				console.timeEnd("parse_mappings");
+			}, start_sort_by_generated_location() {
+				console.time("sort_by_generated_location");
+			}, end_sort_by_generated_location() {
+				console.timeEnd("sort_by_generated_location");
+			}, start_sort_by_original_location() {
+				console.time("sort_by_original_location");
+			}, end_sort_by_original_location() {
+				console.timeEnd("sort_by_original_location");
+			} } });
+		}).then((Wasm) => {
+			return { exports: Wasm.instance.exports, withMappingCallback: (mappingCallback, f) => {
+				callbackStack.push(mappingCallback);
+				try {
+					f();
+				} finally {
+					callbackStack.pop();
+				}
+			} };
+		}).then(null, (e) => {
+			cachedWasm = null;
+			throw e;
+		});
+		return cachedWasm;
+	};
+	
+	}
+});
+//#endregion
+//#region source-map.js
+var require_source_map_source_map = __commonJS({
+	"source-map.js"(exports, module) {
+exports.SourceMapGenerator = require_source_map_lib_source_map_generator().SourceMapGenerator;
+	exports.SourceMapConsumer = require_source_map_lib_source_map_consumer().SourceMapConsumer;
+	exports.SourceNode = require_source_map_lib_source_node().SourceNode;
+	
+	}
+});
+//#endregion
+//#region protocol.ts
+const HMR_MSG = Object.freeze({ Connected: "connected", CssUpdate: "css-update", ClearError: "clear-error", Error: "error", FullReload: "full-reload" }),HMR_WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function normalizeHmrErrors(errors) {
+	if (!Array.isArray(errors) || errors.length === 0) {
+		return [{ file: "", message: "Unknown build error" }];
+	}
+	return errors.map((error) => {
+		const e = (error ?? {}),file = typeof e.location?.file == "string" ? e.location.file : "",message = String(e.text ?? e.message ?? error);
+		return { file, message };
+	});
+}
+const HMR_RN_MSG = Object.freeze({ UpdateStart: "hmr:update-start", Update: "hmr:update", UpdateDone: "hmr:update-done", Reload: "hmr:reload", Error: "hmr:error", Log: "log" });
+//#endregion
+//#region ws-frame.ts
+const TEXT_FRAME_FIN_OPCODE = 0x81,PAYLOAD_LEN_SHORT_MAX = 125,PAYLOAD_LEN_EXTENDED_16 = 126,PAYLOAD_LEN_EXTENDED_64 = 127,PAYLOAD_LEN_16BIT_MAX = 65535;
+function buildTextFrame(text) {
+	const payload = Buffer$1.from(text);
+	return Buffer$1.concat([buildTextHeader(payload.length), payload]);
+}
+function buildTextHeader(payloadLength) {
+	if (payloadLength <= PAYLOAD_LEN_SHORT_MAX) {
+		return Buffer$1.from([TEXT_FRAME_FIN_OPCODE, payloadLength]);
+	}
+	if (payloadLength <= PAYLOAD_LEN_16BIT_MAX) {
+		const header = Buffer$1.allocUnsafe(4);
+		header[0] = TEXT_FRAME_FIN_OPCODE;
+		header[1] = PAYLOAD_LEN_EXTENDED_16;
+		header.writeUInt16BE(payloadLength, 2);
+		return header;
+	}
+	const header = Buffer$1.allocUnsafe(10);
+	header[0] = TEXT_FRAME_FIN_OPCODE;
+	header[1] = PAYLOAD_LEN_EXTENDED_64;
+	header.writeBigUInt64BE(BigInt(payloadLength), 2);
+	return header;
+}
+function writeTextFrame(socket,text) {
+	if (socket.destroyed)return;
+	socket.write(buildTextFrame(text));
+}
+function computeAcceptKey(secWebSocketKey) {
+	return createHash("sha1").update(`${secWebSocketKey}${HMR_WS_GUID}`).digest("base64");
+}
+function buildHandshakeResponse(secWebSocketKey) {
+	return ["HTTP/1.1 101 Switching Protocols", "Upgrade: websocket", "Connection: Upgrade", `Sec-WebSocket-Accept: ${computeAcceptKey(secWebSocketKey)}`, "", ""].join("\r\n");
+}
+function parseTextFrame(buffer) {
+	if (buffer.length < 2)return null;
+	const byte0 = buffer[0],byte1 = buffer[1];
+	;
+	;
+	;
+	if (!((byte0 & 0x80) !== 0) || (byte0 & 0x0f) !== 0x1 || !((byte1 & 0x80) !== 0))return null;
+	let payloadLen = byte1 & 0x7f,offset = 2;
+	if (payloadLen === PAYLOAD_LEN_EXTENDED_16) {
+		if (buffer.length < 4)return null;
+		payloadLen = buffer.readUInt16BE(2);
+		offset = 4;
+	} else if (payloadLen === PAYLOAD_LEN_EXTENDED_64) {
+		if (buffer.length < 10)return null;
+		const big = buffer.readBigUInt64BE(2);
+		if (big > BigInt(Number.MAX_SAFE_INTEGER))return null;
+		payloadLen = Number(big);
+		offset = 10;
+	}
+	if (buffer.length < offset + 4 + payloadLen)return null;
+	const maskKey = buffer.subarray(offset, offset + 4),payload = Buffer$1.allocUnsafe(payloadLen);
+	for (let i = 0; i < payloadLen; i++) {
+		payload[i] = buffer[offset + 4 + i] ^ maskKey[i % 4];
+	}
+	return { text: payload.toString("utf-8"), consumed: offset + 4 + payloadLen };
+}
+//#endregion
+//#region hmr-channel.ts
+function extractErrorText(error) {
+	const e = (error ?? {});
+	return ((typeof e.stack == "string" && e.stack) || (typeof e.message == "string" && e.message) || String(error));
+}
+function createHmrChannel() {
+	const nodeSockets = new Set(),bunClients = new Set(),incomingHandlers = [],connectedText = JSON.stringify({ type: HMR_MSG.Connected });
+	let currentError = null,currentErrorText = null;
+	function broadcastText(text) {
+		for (const socket of nodeSockets)writeTextFrame(socket, text);
+		for (const ws of bunClients)ws.send(text);
+	}
+	function greetNode(socket) {
+		writeTextFrame(socket, connectedText);
+		if (currentErrorText)writeTextFrame(socket, currentErrorText);
+	}
+	function greetBun(ws) {
+		ws.send(connectedText);
+		if (currentErrorText)ws.send(currentErrorText);
+	}
+	return { accept(req,socket) {
+		const key = req.headers["sec-websocket-key"];
+		if (typeof key != "string") {
+			socket.destroy();
+			return;
+		}
+		socket.write(buildHandshakeResponse(key));
+		nodeSockets.add(socket);
+		let recvBuffer = Buffer.alloc(0);
+		socket.on("data", (chunk) => {
+			if (incomingHandlers.length === 0)return;
+			recvBuffer = (recvBuffer.length === 0 ? chunk : Buffer.concat([recvBuffer, chunk]));
+			while (recvBuffer.length > 0) {
+				const parsed = parseTextFrame(recvBuffer);
+				if (!parsed)break;
+				recvBuffer = recvBuffer.subarray(parsed.consumed);
+				for (const handler of incomingHandlers) {
+					try {
+						handler(parsed.text, socket);
+					} catch {
+					}
+				}
+			}
+		});
+		socket.on("close", () => nodeSockets.delete(socket));
+		socket.on("error", () => nodeSockets.delete(socket));
+		greetNode(socket);
+	}, addBunClient(ws) {
+		bunClients.add(ws);
+		greetBun(ws);
+	}, removeBunClient(ws) {
+		bunClients.delete(ws);
+	}, onIncoming(handler) {
+		incomingHandlers.push(handler);
+	}, broadcast(message) {
+		broadcastText(JSON.stringify(message));
+	}, reportError(errors) {
+		currentError = { type: HMR_MSG.Error, errors: normalizeHmrErrors(errors), timestamp: Date.now() };
+		currentErrorText = JSON.stringify(currentError);
+		broadcastText(currentErrorText);
+	}, reportThrownError(error) {
+		this.reportError([{ text: extractErrorText(error) }]);
+	}, clearError() {
+		currentError = null;
+		currentErrorText = null;
+	}, get clientCount() {
+		return nodeSockets.size + bunClients.size;
+	} };
+}
+//#endregion
+//#region metro-hmr-adapter.ts
+const ZNTC_LOCATION_RE = /([^\s]+\.[jt]sx?):(\d+):(\d+)/;
+function formatBuildError(message) {
+	const match = message.match(ZNTC_LOCATION_RE),errors = match ? [{ description: message, filename: match[1], lineNumber: Number.parseInt(match[2], 10), column: Number.parseInt(match[3], 10) }] : [{ description: message }];
+	return { type: "BuildError", message, errors };
+}
+function createMetroHmrAdapter() {
+	const channel = createHmrChannel();
+	return { channel, sendInitialGreeting() {
+		channel.broadcast({ type: HMR_RN_MSG.UpdateStart, isInitialUpdate: true });
+		channel.broadcast({ type: HMR_RN_MSG.UpdateDone });
+	}, sendUpdate(modules) {
+		channel.broadcast({ type: HMR_RN_MSG.UpdateStart });
+		channel.broadcast({ type: HMR_RN_MSG.Update, modules: [...modules] });
+		channel.broadcast({ type: HMR_RN_MSG.UpdateDone });
+	}, sendReload() {
+		channel.broadcast({ type: HMR_RN_MSG.Reload });
+	}, sendError(message) {
+		channel.broadcast({ type: HMR_RN_MSG.Error, message, body: formatBuildError(message) });
+	} };
+}
+//#endregion
+//#region logger.ts
+const colors = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", inverse: "\x1b[7m", white: "\x1b[37m", gray: "\x1b[90m", red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m", magenta: "\x1b[35m", cyan: "\x1b[36m", brightYellow: "\x1b[93m", brightRed: "\x1b[91m" };
+function logInfo(...args) {
+	console.log(`${colors.inverse}${colors.bold}${colors.cyan} INFO ${colors.reset}`, ...args);
+}
+function logWarn(...args) {
+	console.warn(`${colors.inverse}${colors.bold}${colors.yellow} WARN ${colors.reset}`, ...args);
+}
+function logError(...args) {
+	console.error(`${colors.inverse}${colors.bold}${colors.red} ERROR ${colors.reset}`, ...args);
+}
+function formatLogBadge(level) {
+	const color = level === "error" ? colors.red : level === "warn" ? colors.yellow : level === "debug" ? colors.magenta : level === "info" ? colors.cyan : colors.white;
+	return `${color}${colors.inverse}${colors.bold} ${level.toUpperCase()} ${colors.reset}`;
+}
+function logBundle(phase,platform,subject,detail) {
+	const color = phase === "done" ? colors.green : phase === "failed" ? colors.red : colors.yellow,badge = `${color}${colors.inverse}${colors.bold} BUNDLE ${colors.reset}`,tail = detail ? ` ${colors.dim}${detail}${colors.reset}` : "";
+	console.log(`${badge} ${colors.dim}[${platform}]${colors.reset} ${subject}${tail}`);
+}
+const BANNER_WIDTH = 59;
+function bannerLine(content) {
+	const visibleLen = content.replace(/\x1b\[[0-9;]*m/g, "").length,padding = Math.max(0, BANNER_WIDTH - visibleLen),left = Math.floor(padding / 2);
+	;
+	return `${colors.cyan}    ║${colors.reset}${" ".repeat(left)}${content}${" ".repeat((padding - left))}${colors.cyan}║${colors.reset}`;
+}
+const ZNTC_ASCII = ["▀▀▀▀▀▀▀▀", "▀▀▀▀▀▀▀▀▀▀▀▀", "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀", "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀", "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀"],ZNTC_GRADIENT = [colors.brightYellow, colors.brightYellow, colors.yellow, colors.brightRed, colors.brightRed];
+if (ZNTC_ASCII.length !== ZNTC_GRADIENT.length) {
+	throw new Error(`ZNTC banner: ZNTC_ASCII(${ZNTC_ASCII.length}) / ZNTC_GRADIENT(${ZNTC_GRADIENT.length}) 길이 불일치`);
+}
+function printZntcRnBanner(version) {
+	const versionText = version ? `v${version}` : "",logoLines = ZNTC_ASCII.map((line, i) => bannerLine(`${colors.bold}${ZNTC_GRADIENT[i]}${line}${colors.reset}`)),lines = ["", `${colors.cyan}    ╔${"═".repeat(BANNER_WIDTH)}╗${colors.reset}`, bannerLine(""), ...logoLines, bannerLine(""), bannerLine(`${colors.cyan}Lightning Fast React Native Bundler${colors.reset}`), bannerLine(`${colors.gray}${versionText}${colors.reset}`), bannerLine(""), `${colors.cyan}    ╚${"═".repeat(BANNER_WIDTH)}╝${colors.reset}`, ""];
+	console.log(lines.join("\n"));
+}
+//#endregion
+//#region hmr-bridge.ts
+function annotateUpdates(updates,platform) {
+	return updates.map((u) => {
+		const sourceMappingURL = `/__zntc_hmr_map/${encodeURIComponent(u.id)}?platform=${platform}`;
+		return { ...u, code: `${u.code}\n//# sourceMappingURL=${sourceMappingURL}\n` };
+	});
+}
+function buildOnRebuild(adapter,opts={}) {
+	return (state, event) => {
+		if (!event.success) {
+			const errMsg = state.buildError ?? event.error ?? "Unknown build error";
+			adapter.sendError(errMsg);
+			if (!opts.silent)logError(`Build failed [${state.platform}]: ${errMsg}`);
+			return;
+		}
+		const changedCount = event.changed?.length ?? 0,ms = event.phaseDurations?.total ?? Date.now() - state.lastRebuildTime;
+		if (event.graphChanged) {
+			adapter.sendReload();
+			if (!opts.silent) {
+				logInfo(`Graph changed ${colors.dim}[${state.platform}] (${changedCount} files, ${ms}ms)${colors.reset}, full reload`);
+			}
+			return;
+		}
+		if (event.updates && event.updates.length > 0) {
+			const annotated = annotateUpdates(event.updates, state.platform);
+			adapter.sendUpdate(annotated);
+			if (!opts.silent) {
+				logInfo(`HMR update ${colors.dim}[${state.platform}] ${event.updates.length} module(s) (${ms}ms)${colors.reset}`);
+			}
+			return;
+		}
+		if (!opts.silent && changedCount > 0) {
+			logInfo(`Rebuilt ${colors.dim}[${state.platform}] (${changedCount} files, ${ms}ms, no code change)${colors.reset}`);
+		}
+	};
+}
+function buildIncomingHandler(adapter,getLogsEnabled) {
+	return (text, socket) => {
+		let msg = null;
+		try {
+			msg = JSON.parse(text);
+		} catch {
+			return;
+		}
+		if (!msg || typeof msg.type != "string")return;
+		if (msg.type === "register-entrypoints") {
+			socket.write(buildAckFrame());
+			return;
+		}
+		if (msg.type === "log") {
+			if (!getLogsEnabled())return;
+			const level = typeof msg.level == "string" ? msg.level : "log",data = Array.isArray(msg.data) ? msg.data : [msg.data],formatted = data.map((arg) => {
+				if (typeof arg == "object" && arg !== null) {
+					try {
+						return JSON.stringify(arg, null, 2);
+					} catch {
+						return String(arg);
+					}
+				}
+				return String(arg);
+			}).join(" ");
+			console.log(`${formatLogBadge(level)} ${formatted}`);
+			;
+		}
+	};
+}
+const ACK_TEXT = JSON.stringify({ type: "bundle-registered" });
+function buildAckFrame() {
+	const payload = Buffer.from(ACK_TEXT);
+	return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);
+}
+function createHmrBridge(options) {
+	const adapter = createMetroHmrAdapter(),onRebuild = buildOnRebuild(adapter, { silent: options.silent });
+	let logsEnabled = options.forwardClientLogs !== false;
+	adapter.channel.onIncoming(buildIncomingHandler(adapter, () => logsEnabled));
+	return { adapter, callbacks: { onRebuild }, path: options.path, acceptUpgrade(req,socket) {
+		adapter.channel.accept(req, socket);
+		adapter.sendInitialGreeting();
+	}, toggleLogs() {
+		logsEnabled = !logsEnabled;
+		return logsEnabled;
+	} };
+}
+//#endregion
+//#region http-utils.ts
+function sendText(res,statusCode,text,contentType="text/plain") {
+	res.writeHead(statusCode, { "Content-Type": contentType, "Content-Length": Buffer.byteLength(text) });
+	res.end(text);
+}
+function sendJson(res,statusCode,data) {
+	const body = JSON.stringify(data);
+	res.writeHead(statusCode, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
+	res.end(body);
+}
+function parseCachedBody(cached) {
+	if (cached == null)return null;
+	if (typeof cached == "string")return JSON.parse(cached);
+	if (Buffer.isBuffer(cached))return JSON.parse(cached.toString("utf-8"));
+	if (typeof cached == "object")return cached;
+	return null;
+}
+async function readJsonBody(req) {
+	const augmented = req;
+	if (req.complete && !req.readable) {
+		return parseCachedBody(augmented.body) ?? parseCachedBody(augmented.rawBody) ?? {};
+	}
+	return new Promise((resolve, reject) => {
+		let body = "";
+		req.on("data", (chunk) => {
+			body += chunk.toString();
+		});
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(body));
+			} catch (error) {
+				reject(error);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function parseRequestUrl(req,fallbackHost,fallbackPort) {
+	const hostHeader = req.headers.host || `${fallbackHost}:${fallbackPort}`;
+	return new URL(req.url || "/", `http://${hostHeader}`);
+}
+//#endregion
+//#region dev-middleware.ts
+function createProjectRequire(projectRoot) {
+	return createRequire(`${resolve(projectRoot)}/package.json`);
+}
+function resolveDevMiddlewarePath(projectRoot) {
+	const projectRequire = createProjectRequire(projectRoot),candidates = [() => {
+		const expoPath = projectRequire.resolve("expo"),expoRequire = createRequire(expoPath),expoCliPath = expoRequire.resolve("@expo/cli"),expoCliRequire = createRequire(expoCliPath);
+		return expoCliRequire.resolve("@react-native/dev-middleware");
+	}, () => {
+		const reactNativePath = projectRequire.resolve("react-native/package.json"),rnRequire = createRequire(reactNativePath),cliPluginPath = rnRequire.resolve("@react-native/community-cli-plugin/package.json"),cliPluginRequire = createRequire(cliPluginPath);
+		return cliPluginRequire.resolve("@react-native/dev-middleware");
+	}, () => projectRequire.resolve("@react-native/dev-middleware"), () => require.resolve("@react-native/dev-middleware")];
+	for (const candidate of candidates) {
+		try {
+			return candidate();
+		} catch {
+		}
+	}
+	return null;
+}
+async function loadDevMiddleware(options) {
+	const path = resolveDevMiddlewarePath(options.projectRoot);
+	if (!path)return null;
+	try {
+		const requireFromProject = createProjectRequire(options.projectRoot),mod = requireFromProject(path);
+		return mod.createDevMiddleware({ serverBaseUrl: `http://localhost:${options.port}`, projectRoot: options.projectRoot, logger: { info: () => {
+		}, warn: () => {
+		}, error: (...args) => console.error("[zntc/rn dev-middleware]", ...args) } });
+	} catch {
+		return null;
+	}
+}
+const DEV_MIDDLEWARE_PATH_PREFIXES = ["/json", "/open-debugger", "/debugger-frontend", "/launch-js-devtools"];
+function isDevMiddlewareRoute(pathname) {
+	return DEV_MIDDLEWARE_PATH_PREFIXES.some((p) => pathname === p || pathname.startsWith(`${p}/`));
+}
+//#endregion
+//#region assets.ts
+function isAssetRoute(pathname) {
+	return pathname.startsWith("/assets/") || pathname.startsWith("/node_modules/");
+}
+const CONTENT_TYPE_MAP = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp", ".svg": "image/svg+xml", ".ico": "image/x-icon", ".json": "application/json" };
+function resolveSymlink(path,maxDepth=10) {
+	if (maxDepth <= 0)return path;
+	try {
+		if (existsSync(path)) {
+			const stats = lstatSync(path);
+			if (stats.isSymbolicLink()) {
+				return resolveSymlink(realpathSync(path), maxDepth - 1);
+			}
+		}
+	} catch {
+	}
+	return path;
+}
+function sanitizeRelativePath(input) {
+	const segments = input.split("/"),out = [];
+	for (const seg of segments) {
+		if (seg === "..") {
+			if (out.length > 0)out.pop();
+		} else if (seg !== "." && seg !== "") {
+			out.push(seg);
+		}
+	}
+	return out.join("/");
+}
+function resolveAssetPath(urlPathname,opts) {
+	let assetRelativePath;
+	if (urlPathname.startsWith("/assets/")) {
+		assetRelativePath = sanitizeRelativePath(urlPathname.slice("/assets/".length));
+	} else if (urlPathname.startsWith("/node_modules/")) {
+		assetRelativePath = `node_modules/${urlPathname.slice("/node_modules/".length)}`;
+	} else {
+		return null;
+	}
+	assetRelativePath = assetRelativePath.replace(/@\d+x\./, ".");
+	assetRelativePath = assetRelativePath.replace(/\\/g, "/");
+	const normalizedPath = assetRelativePath.replace(/\//g, sep);
+	let resolved = resolve$1(opts.projectRoot, normalizedPath);
+	if (existsSync(resolved))return resolveSymlink(resolved);
+	for (const nmPath of opts.nodeModulesPaths) {
+		const monorepoRoot = resolve$1(opts.projectRoot, nmPath),candidate = resolve$1(monorepoRoot, "..", normalizedPath);
+		if (existsSync(candidate))return resolveSymlink(candidate);
+	}
+	const nmMatch = normalizedPath.match(/node_modules[/\\](?:\.(?:pnpm|bun)[/\\]([^/\\]+)[/\\]node_modules[/\\])?([^/\\]+)[/\\](.+)$/);
+	if (!nmMatch)return null;
+	const bunPackageDir = nmMatch[1];
+	let packageNameOrPath = nmMatch[2],restPath = nmMatch[3];
+	if (!packageNameOrPath || !restPath)return null;
+	if (packageNameOrPath.startsWith("@")) {
+		const slashIdx = restPath.indexOf(sep);
+		if (slashIdx > 0) {
+			packageNameOrPath = `${packageNameOrPath}/${restPath.slice(0, slashIdx)}`;
+			restPath = restPath.slice(slashIdx + 1);
+		}
+	}
+	if (!bunPackageDir && !packageNameOrPath.includes("@")) {
+		const candidate = resolve$1(opts.projectRoot, "node_modules", packageNameOrPath, restPath);
+		if (existsSync(candidate))return resolveSymlink(candidate);
+	}
+	if (packageNameOrPath.startsWith("@")) {
+		const candidate = resolve$1(opts.projectRoot, "node_modules", packageNameOrPath, restPath);
+		if (existsSync(candidate))return resolveSymlink(candidate);
+	}
+	const pnpmDir = resolve$1(opts.projectRoot, "node_modules", ".pnpm");
+	if (existsSync(pnpmDir)) {
+		try {
+			const entries = readdirSync(pnpmDir),pnpmPkgName = packageNameOrPath.startsWith("@") ? packageNameOrPath.replace("/", "+") : packageNameOrPath;
+			for (const entry of entries) {
+				if (entry.startsWith(`${pnpmPkgName}@`) || entry === pnpmPkgName) {
+					const candidate = resolve$1(pnpmDir, entry, "node_modules", packageNameOrPath, restPath);
+					if (existsSync(candidate))return resolveSymlink(candidate);
+				}
+			}
+		} catch {
+		}
+	}
+	const bunDirCandidates = [resolve$1(opts.projectRoot, "node_modules", ".bun"), ...opts.nodeModulesPaths.map((p) => resolve$1(opts.projectRoot, p, ".bun"))];
+	for (const bunDir of bunDirCandidates) {
+		if (!existsSync(bunDir))continue;
+		try {
+			if (bunPackageDir) {
+				const dir = resolveSymlink(resolve$1(bunDir, bunPackageDir)),candidate = resolve$1(dir, "node_modules", packageNameOrPath, restPath);
+				if (existsSync(candidate))return resolveSymlink(candidate);
+			} else {
+				const bunPkgName = packageNameOrPath.startsWith("@") ? packageNameOrPath.replace("/", "+") : packageNameOrPath;
+				for (const entry of readdirSync(bunDir)) {
+					if (entry.startsWith(`${bunPkgName}@`) || entry === bunPkgName) {
+						const dir = resolveSymlink(resolve$1(bunDir, entry)),candidate = resolve$1(dir, "node_modules", packageNameOrPath, restPath);
+						if (existsSync(candidate))return resolveSymlink(candidate);
+					}
+				}
+			}
+		} catch {
+		}
+	}
+	const nonHoisted = resolve$1(opts.projectRoot, "node_modules", packageNameOrPath, "node_modules", restPath);
+	if (existsSync(nonHoisted))return resolveSymlink(nonHoisted);
+	for (const nmPath of opts.nodeModulesPaths) {
+		const candidate = resolve$1(opts.projectRoot, nmPath, packageNameOrPath, restPath);
+		if (existsSync(candidate))return resolveSymlink(candidate);
+	}
+	if (normalizedPath.startsWith("node_modules")) {
+		try {
+			const modulePath = normalizedPath.replace(/^node_modules[/\\]/, ""),packageName = modulePath.startsWith("@") ? (modulePath.match(/^(@[^/\\]+[/\\][^/\\]+)/)?.[1] ?? modulePath.split(sep)[0]) : modulePath.split(sep)[0];
+			if (!packageName)return null;
+			const packageRelativePath = modulePath.slice(packageName.length + 1);
+			let packageJsonPath;
+			try {
+				packageJsonPath = require.resolve(`${packageName}/package.json`, { paths: [opts.projectRoot, ...opts.nodeModulesPaths] });
+			} catch {
+				const candidates = [resolve$1(opts.projectRoot, "node_modules", packageName, "package.json"), ...opts.nodeModulesPaths.map((p) => resolve$1(opts.projectRoot, p, packageName, "package.json"))],found = candidates.find((c) => existsSync(c));
+				if (!found)return null;
+				packageJsonPath = found;
+			}
+			const candidate = resolve$1(dirname(packageJsonPath), packageRelativePath);
+			if (existsSync(candidate))return resolveSymlink(candidate);
+		} catch {
+		}
+	}
+	return null;
+}
+function isWithinRoot(path,root) {
+	if (path === root)return true;
+	return path.startsWith(root + sep);
+}
+function isAllowedPath(path,opts) {
+	const normalized = resolve$1(path);
+	if (isWithinRoot(normalized, resolve$1(opts.projectRoot)))return true;
+	return opts.nodeModulesPaths.some((p) => isWithinRoot(normalized, resolve$1(opts.projectRoot, p)));
+}
+async function handleAssetRequest(_req,res,url,opts) {
+	try {
+		const resolved = resolveAssetPath(url.pathname, opts);
+		if (!resolved) {
+			sendText(res, 404, "Not Found");
+			return;
+		}
+		if (!isAllowedPath(resolved, opts)) {
+			sendText(res, 403, "Forbidden");
+			return;
+		}
+		if (!existsSync(resolved)) {
+			sendText(res, 404, "Not Found");
+			return;
+		}
+		const ext = extname(resolved).toLowerCase();
+		;
+		const content = await readFile(resolved);
+		res.writeHead(200, { "Content-Type": (CONTENT_TYPE_MAP[ext] ?? "application/octet-stream"), "Cache-Control": "public, max-age=31536000", "Content-Length": content.length });
+		res.end(content);
+	} catch {
+		sendText(res, 500, "Internal Server Error");
+	}
+}
+//#endregion
+//#region runtime-loader.ts
+const RUNTIME_PATH = join(dirname$1(fileURLToPath(import.meta.url)), "..", "runtime", "zntc-hmr-client.cjs");
+const ZNTC_HMR_CLIENT_CODE = (() => {
+	try {
+		return readFileSync(RUNTIME_PATH, "utf-8");
+	} catch {
+		return "module.exports = { setup() {}, enable() {}, disable() {}, registerBundle() {}, log() {} }; module.exports.default = module.exports;";
+	}
+})(),HMR_CLIENT_SUFFIX = "/Libraries/Utilities/HMRClient.js";
+//#endregion
+//#region escape-regex.ts
+const SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
+function escapeRegex(s) {
+	return s.replace(SPECIAL_CHARS_RE, "\\$&");
+}
+//#endregion
+//#region internal.ts
+const requireFromCli = createRequire$1(import.meta.url);
+function getErrorMessage(err,max=100) {
+	const e = err;
+	if (typeof e?.message == "string")return e.message.slice(0, max);
+	return String(err).slice(0, max);
+}
+function normalizeExt(ext) {
+	return ext.startsWith(".") ? ext : `.${ext}`;
+}
+//#endregion
+//#region asset.ts
+function svgComponentName(filePath) {
+	const pascal = basename(filePath, extname$1(filePath)).split(/[^A-Za-z0-9_$]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+	return pascal ? `Svg${pascal}` : "SvgComponent";
+}
+function createSvgComponentModule(svg,filePath) {
+	const componentName = svgComponentName(filePath);
+	return [`import * as React from 'react';`, `import { SvgXml } from 'react-native-svg';`, ``, `const xml = ${JSON.stringify(svg)};`, ``, `function ${componentName}(props) {`, `  return React.createElement(SvgXml, Object.assign({ xml }, props));`, `}`, ``, `${componentName}.displayName = ${JSON.stringify(componentName)};`, ``, `export default ${componentName};`, ``].join("\n");
+}
+function createAssetPlugin(config) {
+	return { name: "zntc:react-native:runtime", setup(build) {
+		const hmrClientPattern = new RegExp(`${escapeRegex(HMR_CLIENT_SUFFIX)}$`);
+		build.onLoad({ filter: hmrClientPattern }, () => ({ contents: ZNTC_HMR_CLIENT_CODE }));
+		const hasSvgSource = config.sourceExts.some((e) => normalizeExt(e).toLowerCase() === ".svg");
+		if (hasSvgSource) {
+			build.onLoad({ filter: /\.svg$/i }, (args) => ({ contents: createSvgComponentModule(readFileSync$1(args.path, "utf8"), args.path) }));
+		}
+		if (config.babelTransformerPath) {
+			let customTransformer = null;
+			const transformerPath = config.babelTransformerPath,dev = config.dev ?? true,customExts = config.sourceExts.map((e) => normalizeExt(e).slice(1)).filter((e) => !/^(tsx?|jsx?|mjs|cjs|json|svg)$/.test(e)).join("|");
+			if (customExts) {
+				const customExtPattern = new RegExp(`\\.(${customExts})$`);
+				build.onLoad({ filter: customExtPattern }, async (args) => {
+					try {
+						if (!customTransformer) {
+							customTransformer = requireFromCli(requireFromCli.resolve(transformerPath, { paths: [config.projectRoot] }));
+						}
+						const src = readFileSync$1(args.path, "utf8"),result = await customTransformer.transform({ src, filename: args.path, options: { platform: config.rnPlatform, dev, hot: dev, projectRoot: config.projectRoot } });
+						if (result?.code)return { contents: result.code };
+						if (result?.ast) {
+							throw new Error(`${transformerPath} returned a Babel AST for ${args.path}. ZNTC custom source transformers must return code; use a ZNTC native transformer for this extension.`);
+						}
+					} catch (err) {
+						process.stderr.write(`[zntc:transformer] ${args.path.split("/").pop()}: ${getErrorMessage(err)}\n`);
+						throw err;
+					}
+					return null;
+				});
+			}
+		}
+	} };
+}
+//#endregion
+//#region metro-resolve-request.ts
+const DELEGATE_TO_DEFAULT_SENTINEL = "__ZNTC_RN_DELEGATE_TO_DEFAULT__",nodeRequire = createRequire$2(import.meta.url);
+function resolveFallbackRequest(moduleName,originModulePath) {
+	if (isAbsolute(moduleName))return moduleName;
+	const baseDir = originModulePath ? dirname$2(originModulePath) : process.cwd();
+	if (moduleName.startsWith("."))return resolve$2(baseDir, moduleName);
+	return nodeRequire.resolve(moduleName, { paths: [baseDir] });
+}
+function createMetroResolveRequestPlugin(opts) {
+	const { resolveRequest:resolveRequest, platform:platform } = opts,metroPlatform = platform === "web" ? null : platform;
+	return { name: "zntc:react-native:metro-resolve-request", setup(build) {
+		build.onResolve({ filter: /.*/ }, (args) => {
+			const fallbackResolver = (_context, moduleName) => {
+				if (moduleName !== args.path) {
+					return { type: "sourceFile", filePath: resolveFallbackRequest(moduleName, args.importer ?? "") };
+				}
+				throw new Error(DELEGATE_TO_DEFAULT_SENTINEL);
+			};
+			try {
+				const result = resolveRequest({ originModulePath: args.importer ?? "", platform: metroPlatform, resolveRequest: fallbackResolver }, args.path, metroPlatform);
+				if (result.type === "sourceFile")return { path: result.filePath };
+				if (result.type === "assetFiles")return { path: result.filePaths[0] ?? args.path };
+				if (result.type === "empty")return { disabled: true };
+			} catch (err) {
+				if (err.message === DELEGATE_TO_DEFAULT_SENTINEL)return null;
+				throw err;
+			}
+			return null;
+		});
+	} };
+}
+//#endregion
+//#region require-context.ts
+function createRequireContextPlugin() {
+	return { name: "zntc:react-native:require-context", setup(build) {
+		build.onResolveContext({ filter: /.*/ }, (args) => {
+			const { dir:dir, recursive:recursive, filter:filter, flags:flags, importer:importer } = args,absDir = resolve$3(dirname$3(importer), dir);
+			let entries;
+			try {
+				if (recursive) {
+					entries = readdirSync$1(absDir, { recursive: true, withFileTypes: true }).filter((d) => d.isFile()).map((d) => {
+						const parent = d.parentPath ?? absDir;
+						return relative(absDir, join$1(parent, d.name));
+					});
+				} else {
+					entries = readdirSync$1(absDir, { withFileTypes: true }).filter((d) => d.isFile()).map((d) => d.name);
+				}
+			} catch {
+				return { context: [] };
+			}
+			const re = filter ? new RegExp(filter, flags ?? "") : /^\.\/.*$/,matched = entries.map((f) => `./${f.replace(/\\/g, "/")}`).filter((p) => re.test(p)).sort();
+			return { context: matched };
+		});
+	} };
+}
+//#endregion
+//#region rn-constants.ts
+const requireFromCli$1 = createRequire$3(import.meta.url);
+function tryResolve(specifier,fromDir) {
+	try {
+		return requireFromCli$1.resolve(specifier, { paths: [fromDir] });
+	} catch {
+		return null;
+	}
+}
+function resolveRnPolyfills(projectRoot) {
+	;
+	for (const candidate of ["react-native/rn-get-polyfills", "@react-native/js-polyfills"]) {
+		const resolved = tryResolve(candidate, projectRoot);
+		if (resolved) {
+			try {
+				return requireFromCli$1(resolved)();
+			} catch {
+				continue;
+			}
+		}
+	}
+	console.warn("[zntc] Could not resolve RN polyfills, skipping");
+	return [];
+}
+const RN_SINGLETON_PACKAGES = ["react", "react-native", "react-native-safe-area-context"],RN_GLOBAL_IDENTIFIERS = ["Promise", "regeneratorRuntime", "XMLHttpRequest", "FormData", "fetch", "Headers", "Request", "Response", "WebSocket", "Blob", "File", "FileReader", "URL", "URLSearchParams", "AbortController", "AbortSignal", "queueMicrotask", "setImmediate", "clearImmediate", "requestIdleCallback", "cancelIdleCallback", "setTimeout", "clearTimeout", "setInterval", "clearInterval", "requestAnimationFrame", "cancelAnimationFrame", "DOMRect", "DOMRectReadOnly", "DOMRectList", "HTMLCollection", "NodeList", "Node", "Document", "CharacterData", "Text", "Element", "HTMLElement", "IntersectionObserver", "MutationObserver", "MutationRecord", "EventCounts", "Performance", "PerformanceEntry", "PerformanceEventTiming", "PerformanceLongTaskTiming", "PerformanceMark", "PerformanceMeasure", "PerformanceObserver", "PerformanceObserverEntryList", "PerformanceResourceTiming", "TaskAttributionTiming"];
+//#endregion
+//#region preset.ts
+const DEFAULT_SOURCE_EXTS = [".js", ".jsx", ".json", ".ts", ".tsx", ".mjs", ".cjs"];
+const DEFAULT_ASSET_EXTS = [".bmp", ".gif", ".jpg", ".jpeg", ".png", ".psd", ".svg", ".webp", ".tiff", ".tif", ".xml", ".avif", ".ico", ".m4v", ".mov", ".mp4", ".mpeg", ".mpg", ".webm", ".aac", ".aiff", ".caf", ".m4a", ".mp3", ".wav", ".html", ".pdf", ".yaml", ".yml", ".otf", ".ttf", ".woff", ".woff2"];
+function buildResolveExtensions(rnPlatform,sourceExts) {
+	const platformPrefix = `.${rnPlatform}`,extensions = [],seen = new Set();
+	for (const sourceExt of sourceExts) {
+		const ext = normalizeExt(sourceExt);
+		for (const candidate of [`${platformPrefix}${ext}`, `.native${ext}`, ext]) {
+			if (!seen.has(candidate)) {
+				seen.add(candidate);
+				extensions.push(candidate);
+			}
+		}
+	}
+	return extensions;
+}
+function buildAssetLoaders(assetExts) {
+	const loaders = {};
+	for (const ext of assetExts) {
+		loaders[normalizeExt(ext)] = "file";
+	}
+	return loaders;
+}
+function tryResolvePackageRoot(packageName,projectRoot) {
+	const logicalRoot = resolve$4(projectRoot, "node_modules", packageName);
+	if (existsSync$1(resolve$4(logicalRoot, "package.json")))return logicalRoot;
+	const pkgJson = tryResolve(`${packageName}/package.json`, projectRoot);
+	return pkgJson ? dirname$4(pkgJson) : null;
+}
+function tryResolvePackageFile(packageName,relativePath,projectRoot) {
+	const packageRoot = tryResolvePackageRoot(packageName, projectRoot);
+	if (packageRoot) {
+		const file = resolve$4(packageRoot, relativePath);
+		if (existsSync$1(file))return file;
+	}
+	return tryResolve(`${packageName}/${relativePath}`, projectRoot);
+}
+function buildRnSingletonAliases(projectRoot) {
+	const aliases = {};
+	for (const packageName of RN_SINGLETON_PACKAGES) {
+		const packageRoot = tryResolvePackageRoot(packageName, projectRoot);
+		if (packageRoot)aliases[packageName] = packageRoot;
+	}
+	return aliases;
+}
+const PRELUDE_RESERVED = new Set(["__BUNDLE_START_TIME__", "__DEV__", "__ZNTC_RN_GLOBAL__", "global", "process"]),RN_GLOBAL_EXPR = "(function(g,t,w,s){return g&&(typeof g==='object'||typeof g==='function')?g:t&&(typeof t==='object'||typeof t==='function')?t:w&&(typeof w==='object'||typeof w==='function')?w:s;})(typeof global!=='undefined'?global:void 0,typeof globalThis!=='undefined'?globalThis:void 0,typeof window!=='undefined'?window:void 0,this)";
+function formatExtraVars(extraVars) {
+	const out = [];
+	for (const [key, value] of Object.entries(extraVars)) {
+		if (PRELUDE_RESERVED.has(key))continue;
+		out.push(`var ${key}=${JSON.stringify(value)};`);
+	}
+	return out.join("");
+}
+function buildPrelude(input) {
+	const { dev:dev, bannerExtras:bannerExtras, extra:extra } = input,lines = [`var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now();`, `var __DEV__=${dev};`, `var __ZNTC_RN_GLOBAL__=${RN_GLOBAL_EXPR};`, `if(typeof global==='undefined')global=__ZNTC_RN_GLOBAL__;`, `if(typeof __ZNTC_RN_GLOBAL__.hasOwnProperty!=='function')try{Object.defineProperty(__ZNTC_RN_GLOBAL__,'hasOwnProperty',{value:Object.prototype.hasOwnProperty,configurable:true,writable:true});}catch(_e){try{__ZNTC_RN_GLOBAL__.hasOwnProperty=Object.prototype.hasOwnProperty;}catch(_e2){}}`, `var process=__ZNTC_RN_GLOBAL__.process||{};process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"${dev ? "development" : "production"}";`];
+	if (extra?.extraVars && Object.keys(extra.extraVars).length > 0) {
+		const formatted = formatExtraVars(extra.extraVars);
+		if (formatted)lines.push(formatted);
+	}
+	if (bannerExtras)lines.push(bannerExtras);
+	return lines.join("");
+}
+function buildFooter(dev) {
+	const parts = [`(function(g){g.__ZNTC_RN_BUNDLER__=true;})(${RN_GLOBAL_EXPR});`];
+	if (dev) {
+		parts.push(`setTimeout(function(){try{NativeModules.DevLoadingView.hide()}catch(e){}},0);`);
+	}
+	return parts.join("");
+}
+function resolveWorkletPluginVersion(projectRoot,override) {
+	if (override)return override;
+	try {
+		const pkgPath = requireFromCli.resolve("react-native-worklets/package.json", { paths: [projectRoot] }),pkg = requireFromCli(pkgPath);
+		return pkg.version;
+	} catch {
+		return undefined;
+	}
+}
+function deepMerge(base,override) {
+	const result = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		if (value === undefined)continue;
+		const existing = result[key];
+		if (existing && typeof existing == "object" && !Array.isArray(existing) && value && typeof value == "object" && !Array.isArray(value)) {
+			result[key] = deepMerge(existing, value);
+		} else {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+function buildRnBundleOptions(input) {
+	const { entry:entry, projectRoot:projectRoot, rnPlatform:rnPlatform, dev:dev, sourcemap:sourcemap, minify:minify, dropConsole:dropConsole, dropDebugger:dropDebugger, extra:extra } = input;
+	if (extra?.platforms && !extra.platforms.includes(rnPlatform)) {
+		throw new Error(`extra.platforms (${JSON.stringify(extra.platforms)}) does not include the active rnPlatform '${rnPlatform}'`);
+	}
+	const sourceExts = extra?.sourceExts ?? DEFAULT_SOURCE_EXTS,assetExts = extra?.assetExts ?? DEFAULT_ASSET_EXTS,plugins = [];
+	if (extra?.metroResolveRequest) {
+		const opts = { resolveRequest: extra.metroResolveRequest, platform: rnPlatform };
+		plugins.push(createMetroResolveRequestPlugin(opts));
+	}
+	plugins.push(createAssetPlugin({ projectRoot, assetExts, rnPlatform, dev, sourceExts, babelTransformerPath: extra?.babelTransformerPath }));
+	plugins.push(createRequireContextPlugin());
+	if (extra?.additionalPlugins) {
+		plugins.push(...extra.additionalPlugins);
+	}
+	const polyfills = [...resolveRnPolyfills(projectRoot)];
+	if (extra?.polyfills && extra.polyfills.length > 0) {
+		for (const p of extra.polyfills)polyfills.push(resolve$4(projectRoot, p));
+	}
+	const runBeforeMain = [],initCore = tryResolvePackageFile("react-native", "Libraries/Core/InitializeCore.js", projectRoot);
+	if (initCore)runBeforeMain.push(initCore);
+	if (extra?.prelude && extra.prelude.length > 0) {
+		for (const p of extra.prelude)runBeforeMain.push(resolve$4(projectRoot, p));
+	}
+	const define = { global: "__ZNTC_RN_GLOBAL__", __DEV__: String(dev), "process.env.NODE_ENV": `"${dev ? "development" : "production"}"`, "process.env.EXPO_ROUTER_APP_ROOT": JSON.stringify(resolve$4(projectRoot, "app")), "process.env.EXPO_ROUTER_IMPORT_MODE": "\"sync\"", "process.env.EXPO_OS": `"${rnPlatform}"` },baseLoader = buildAssetLoaders(assetExts),preset = { entryPoints: [resolve$4(projectRoot, entry)], platform: "react-native", sourcemap: sourcemap ?? dev, minify: minify ?? false, dropConsole: dropConsole ?? false, dropDebugger: dropDebugger ?? false, plugins, emitDiskSourcemap: !dev, target: "es5", flow: true, jsxInJs: true, configurableExports: true, strictExecutionOrder: true, inlineDynamicImports: true, workletTransform: true, codegenTransform: true, resolveExtensions: buildResolveExtensions(rnPlatform, sourceExts), mainFields: ["react-native", "browser", "main"], loader: baseLoader, alias: buildRnSingletonAliases(projectRoot), preserveSymlinks: true, resolveSymlinkSiblings: true, define, banner: buildPrelude(input), globalIdentifiers: [...RN_GLOBAL_IDENTIFIERS] };
+	if (polyfills.length > 0)preset.polyfills = polyfills;
+	if (runBeforeMain.length > 0)preset.runBeforeMain = runBeforeMain;
+	const workletVersion = resolveWorkletPluginVersion(projectRoot, input.workletPluginVersion);
+	if (workletVersion)preset.workletPluginVersion = workletVersion;
+	preset.footer = buildFooter(dev);
+	preset.jsx = dev ? "automatic-dev" : "automatic";
+	if (dev) {
+		preset.devMode = true;
+		preset.reactRefresh = true;
+		preset.collectModuleCodes = true;
+	} else if (minify !== true) {
+		preset.minifySyntax = true;
+	}
+	if (extra?.watchFolders && extra.watchFolders.length > 0) {
+		preset.watchFolders = extra.watchFolders.map((p) => resolve$4(projectRoot, p));
+	}
+	if (extra?.nodeModulesPaths && extra.nodeModulesPaths.length > 0) {
+		preset.nodePaths = extra.nodeModulesPaths.map((p) => resolve$4(projectRoot, p));
+	}
+	if (extra?.blockList && extra.blockList.length > 0) {
+		preset.blockList = extra.blockList;
+	}
+	if (extra?.fallback && Object.keys(extra.fallback).length > 0) {
+		preset.fallback = { ...extra.fallback };
+	}
+	if (extra?.inlineSourceMap === true) {
+		preset.sourcemapMode = "inline";
+	}
+	if (extra?.sourceRoot) {
+		preset.sourceRoot = extra.sourceRoot;
+	}
+	if (extra?.silentConsoleErrorPatterns && extra.silentConsoleErrorPatterns.length > 0) {
+		preset.silentConsoleErrorPatterns = [...extra.silentConsoleErrorPatterns];
+	}
+	if (extra?.disableHierarchicalLookup === true) {
+		preset.disableHierarchicalLookup = true;
+	}
+	if (input.override) {
+		return deepMerge(preset, input.override);
+	}
+	return preset;
+}
+async function bundleRn(input) {
+	init();
+	return build(buildRnBundleOptions(input));
+}
+function watchRn(input) {
+	init();
+	const opts = buildRnBundleOptions(input);
+	opts.outfile = input.outfile;
+	opts.write = true;
+	if (input.onReady)opts.onReady = input.onReady;
+	if (input.onRebuild)opts.onRebuild = input.onRebuild;
+	return watch(opts);
+}
+//#endregion
+//#region sourcemap.ts
+function stripVirtualPrefix(src) {
+	return src.replace(/^[\u0000-\u0020]+/, "");
+}
+function isVirtualSource(stripped) {
+	return /^[a-z][a-z0-9+.-]*:/i.test(stripped);
+}
+function isFrameworkSource(src) {
+	if (typeof src != "string")return false;
+	const stripped = stripVirtualPrefix(src);
+	return (stripped === "__prelude__" || stripped.includes("?ctx=") || /(?:^|[/\\])node_modules[/\\]/.test(stripped) || stripped.startsWith("zntc:"));
+}
+function postProcessSourceMap(rawJson,pathOpts) {
+	try {
+		const map = JSON.parse(rawJson);
+		if (map.version !== 3 || !map.sources)return rawJson;
+		delete map.file;
+		if (pathOpts?.sourceRoot === undefined && map.sourceRoot === "") {
+			delete map.sourceRoot;
+		}
+		const existing = new Set([...(Array.isArray(map.x_google_ignoreList) ? map.x_google_ignoreList : []), ...(Array.isArray(map.ignoreList) ? map.ignoreList : [])].filter((v) => Number.isInteger(v) && v >= 0));
+		for (let i = 0; i < map.sources.length; i++) {
+			if (isFrameworkSource(map.sources[i]))existing.add(i);
+		}
+		if (existing.size > 0) {
+			const ignoreList = [...existing].sort((a, b) => a - b);
+			map.x_google_ignoreList = ignoreList;
+		} else {
+			delete map.x_google_ignoreList;
+		}
+		delete map.ignoreList;
+		if (pathOpts) {
+			if (pathOpts.sourceRoot !== undefined) {
+				map.sourceRoot = pathOpts.sourceRoot;
+			}
+			if (pathOpts.useAbsolutePath && Array.isArray(map.sources)) {
+				const projectRoot = pathOpts.projectRoot ?? process.cwd();
+				map.sources = map.sources.map((s) => {
+					if (typeof s != "string")return s;
+					const stripped = stripVirtualPrefix(s);
+					if (isVirtualSource(stripped) || isAbsolute$1(stripped))return s;
+					return resolve$5(projectRoot, s);
+				});
+			}
+		}
+		return JSON.stringify(map);
+	} catch {
+		return rawJson;
+	}
+}
+//#endregion
+//#region platform-state.ts
+const SOURCE_MAPPING_URL_RE = /\/\/# sourceMappingURL=[^\n]*/g;
+function getCachedSourceMap(state) {
+	if (state.sourceMapCache)return state.sourceMapCache;
+	const raw = state.handle.getBundleSourceMap();
+	if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+		process.stderr.write(`[zntc:rn-dev:debug] getBundleSourceMap[${state.platform}]: ${raw ? `len=${raw.length}` : "null"}\n`);
+	}
+	if (!raw)return null;
+	state.sourceMapCache = postProcessSourceMap(raw);
+	return state.sourceMapCache;
+}
+function getBundleText(result) {
+	const jsFile = result.outputFiles.find((file) => file.path.endsWith(".js")) ?? result.outputFiles[0];
+	if (!jsFile)throw new Error("Build produced no output");
+	return jsFile.text.replace(SOURCE_MAPPING_URL_RE, "");
+}
+function getBundleSourceMapText(result) {
+	return result.outputFiles.find((file) => file.path.endsWith(".map"))?.text ?? null;
+}
+function createPlatformState(options,platform,callbacks) {
+	const outputDir = mkdtempSync(join$2(tmpdir(), `zntc-rn-${platform}-`)),outputPath = join$2(outputDir, "bundle.js"),platformBundle = { ...options.bundle, rnPlatform: platform };
+	let refreshPromise = null;
+	const state = { platform, outputDir, outputPath, handle: undefined, bundle: null, bundleStale: false, refreshBundle: () => refreshPlatformBundle(), sourceMapCache: null, buildError: null, fileCount: 1, lastRebuildTime: Date.now() };
+	function refreshPlatformBundle() {
+		if (!state.bundleStale && state.bundle !== null)return Promise.resolve();
+		if (refreshPromise)return refreshPromise;
+		refreshPromise = bundleRn(platformBundle).then((result) => {
+			state.bundle = getBundleText(result);
+			const sourceMap = getBundleSourceMapText(result);
+			state.sourceMapCache = sourceMap ? postProcessSourceMap(sourceMap) : null;
+			state.buildError = null;
+			state.bundleStale = false;
+		}).catch((err) => {
+			state.bundle = null;
+			state.buildError = err instanceof Error ? err.message : String(err);
+			state.bundleStale = false;
+		}).finally(() => {
+			refreshPromise = null;
+		});
+		return refreshPromise;
+	}
+	if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+		process.stderr.write(`[zntc:rn-dev:debug] watchRn[${platform}] sourcemap=${platformBundle.sourcemap} dev=${platformBundle.dev} outfile=${outputPath}\n`);
+	}
+	state.handle = watchRn({ ...platformBundle, outfile: outputPath, onReady(event) {
+		if (event.files)state.fileCount = event.files;
+		if (existsSync$2(outputPath)) {
+			state.bundle = readFileSync$2(outputPath, "utf-8").replace(SOURCE_MAPPING_URL_RE, "");
+			state.bundleStale = false;
+		} else {
+			state.buildError = "Build produced no output";
+		}
+		callbacks?.onReady?.(state, event);
+	}, onRebuild(event) {
+		state.lastRebuildTime = Date.now();
+		if (!event.success) {
+			state.buildError = event.error ?? "Unknown build error";
+			callbacks?.onRebuild?.(state, event);
+			return;
+		}
+		state.buildError = null;
+		state.sourceMapCache = null;
+		if (platformBundle.dev) {
+			if (event.graphChanged) {
+				state.bundleStale = true;
+				return state.refreshBundle().then(() => {
+					if (state.buildError) {
+						callbacks?.onRebuild?.(state, { ...event, success: false, error: state.buildError });
+						return;
+					}
+					callbacks?.onRebuild?.(state, event);
+				});
+			}
+			if (event.updates && event.updates.length > 0) {
+				state.bundleStale = true;
+			}
+			callbacks?.onRebuild?.(state, event);
+			return;
+		}
+		if (existsSync$2(outputPath)) {
+			state.bundle = readFileSync$2(outputPath, "utf-8").replace(SOURCE_MAPPING_URL_RE, "");
+			state.bundleStale = false;
+		}
+		callbacks?.onRebuild?.(state, event);
+	} });
+	return state;
+}
+function waitForBuild(state,pollIntervalMs=50) {
+	return new Promise((resolve) => {
+		const check = () => {
+			if (state.bundle !== null || state.buildError !== null)resolve(); else setTimeout(check, pollIntervalMs);
+		};
+		check();
+	});
+}
+function createPlatformStateRegistry(options,callbacks) {
+	const platforms = new Map();
+	return { platforms, getOrCreate(platform) {
+		let state = platforms.get(platform);
+		if (state)return state;
+		state = createPlatformState(options, platform, callbacks);
+		platforms.set(platform, state);
+		return state;
+	}, async stopAll() {
+		const handles = [...platforms.values()];
+		platforms.clear();
+		for (const s of handles) {
+			try {
+				s.handle.stop();
+			} catch {
+			}
+		}
+	} };
+}
+//#endregion
+//#region _shared.ts
+function resolvePlatform(url,registry,defaultPlatform) {
+	const param = url.searchParams.get("platform");
+	;
+	return registry.getOrCreate((param === "ios" || param === "android" ? param : defaultPlatform));
+}
+//#endregion
+//#region bundle.ts
+var jscSafeUrl = __toESM(require_jsc_safe_url_index());
+const HMR_MAP_PREFIX = "/__zntc_hmr_map/",MULTIPART_BOUNDARY = "3beqjf3apnqeu3h5jqorms4i",CRLF = "\r\n",METRO_NO_STORE_HEADERS = { "Surrogate-Control": "no-store", "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate", Pragma: "no-cache", Expires: "0" };
+function isBundleRoute(pathname) {
+	return pathname.endsWith(".bundle") || pathname.endsWith(".bundle.js");
+}
+function isMapRoute(pathname) {
+	return pathname.endsWith(".map") || pathname.endsWith(".bundle.map");
+}
+function isHmrMapRoute(pathname) {
+	return pathname.startsWith(HMR_MAP_PREFIX);
+}
+async function handleBundleRequest(req,res,url,registry,defaultPlatform,projectRoot,port) {
+	const state = resolvePlatform(url, registry, defaultPlatform);
+	if (state.bundle === null && state.buildError === null) {
+		await waitForBuild(state);
+	}
+	if (state.bundleStale && state.buildError === null) {
+		await state.refreshBundle();
+	}
+	if (state.buildError) {
+		sendText(res, 200, `throw new Error(${JSON.stringify(state.buildError)});`, "application/javascript");
+		return;
+	}
+	if (!state.bundle) {
+		sendText(res, 503, "Bundle not ready yet. Build may have failed - check server logs.");
+		return;
+	}
+	const host = req.headers.host || `localhost:${port}`,fullUrl = `http://${host}${url.pathname}${url.search}${url.hash || ""}`,bundleUrl = jscSafeUrl.toJscSafeUrl(fullUrl),mapPathname = url.pathname.replace(/\.bundle(\.js)?$/, ".map"),mapUrl = `http://${host}${mapPathname}${url.search}`,bundle = `${state.bundle}\n//# sourceMappingURL=${mapUrl}\n//# sourceURL=${bundleUrl}`;
+	if (req.headers.accept === "multipart/mixed") {
+		res.writeHead(200, { "Content-Type": `multipart/mixed; boundary="${MULTIPART_BOUNDARY}"`, ...METRO_NO_STORE_HEADERS, "X-React-Native-Project-Root": projectRoot });
+		res.write("If you are seeing this, your client does not support multipart response");
+		res.write(`${CRLF}--${MULTIPART_BOUNDARY}${CRLF}` + `Content-Type: application/json${CRLF}${CRLF}` + JSON.stringify({ done: state.fileCount, total: state.fileCount }));
+		const bundleBytes = Buffer.byteLength(bundle),revisionId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
+		res.end(`${CRLF}--${MULTIPART_BOUNDARY}${CRLF}` + `X-Metro-Files-Changed-Count: ${state.fileCount}${CRLF}` + `X-Metro-Delta-ID: ${revisionId}${CRLF}` + `Content-Type: application/javascript; charset=UTF-8${CRLF}` + `Content-Length: ${bundleBytes}${CRLF}` + `Last-Modified: ${new Date().toUTCString()}${CRLF}${CRLF}` + bundle + `${CRLF}--${MULTIPART_BOUNDARY}--${CRLF}`);
+		return;
+	}
+	res.writeHead(200, { "X-Content-Type-Options": "nosniff", ...METRO_NO_STORE_HEADERS, "Content-Type": "application/javascript; charset=UTF-8", "Content-Length": Buffer.byteLength(bundle), "X-React-Native-Project-Root": projectRoot, "Content-Location": bundleUrl });
+	res.end(bundle);
+}
+function handleMapRequest(_req,res,url,registry,defaultPlatform) {
+	const state = resolvePlatform(url, registry, defaultPlatform),json = getCachedSourceMap(state);
+	if (!json) {
+		sendText(res, 404, "Source map not available");
+		return;
+	}
+	res.writeHead(200, { "X-Content-Type-Options": "nosniff", ...METRO_NO_STORE_HEADERS, "Content-Type": "application/json", "Content-Length": Buffer.byteLength(json), "Access-Control-Allow-Origin": "devtools://devtools" });
+	res.end(json);
+}
+function handleHmrMapRequest(_req,res,url,registry,defaultPlatform) {
+	const state = resolvePlatform(url, registry, defaultPlatform),moduleId = decodeURIComponent(url.pathname.slice(HMR_MAP_PREFIX.length)),rawJson = state.handle.getHmrSourceMap(moduleId);
+	if (!rawJson) {
+		sendText(res, 404, "HMR source map not found");
+		return;
+	}
+	const json = postProcessSourceMap(rawJson);
+	res.writeHead(200, { "X-Content-Type-Options": "nosniff", ...METRO_NO_STORE_HEADERS, "Content-Type": "application/json", "Content-Length": Buffer.byteLength(json), "Access-Control-Allow-Origin": "devtools://devtools" });
+	res.end(json);
+}
+//#endregion
+//#region devmenu.ts
+function isDevMenuRoute(pathname) {
+	return pathname === "/devmenu";
+}
+function handleDevMenu(_req,res,broadcast) {
+	broadcast("devMenu");
+	sendText(res, 200, "OK");
+}
+//#endregion
+//#region index-page.ts
+function isIndexRoute(pathname) {
+	return pathname === "/" || pathname === "/index.html";
+}
+function handleIndexPage(_req,res,port) {
+	const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ZNTC RN Dev Server</title>
+<style>
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 14px; line-height: 1.6; color: #333; margin: 0; padding: 30px; background: #fafafa; }
+h1 { font-size: 28px; margin-bottom: 8px; font-weight: 600; color: #222; }
+h2 { font-size: 18px; margin: 30px 0 15px; font-weight: 600; color: #444; padding-bottom: 8px; border-bottom: 2px solid #e0e0e0; }
+p { margin: 8px 0; color: #666; }
+a { color: #007aff; text-decoration: none; }
+a:hover { text-decoration: underline; }
+ul { list-style: none; padding: 0; margin: 15px 0; }
+li { margin: 10px 0; padding: 8px 0; }
+code { background: #f0f0f0; padding: 4px 8px; border-radius: 4px; font-family: Monaco, Menlo, monospace; font-size: 13px; color: #333; border: 1px solid #e0e0e0; }
+a code { background: #e8f4fd; border-color: #007aff; color: #007aff; }
+a:hover code { background: #d0e9fc; }
+</style>
+</head>
+<body>
+<h1>ZNTC RN Dev Server</h1>
+<p>Metro-compatible React Native dev server (port ${port})</p>
+<h2>Bundles</h2>
+<ul>
+<li><a href="/index.bundle?platform=ios&dev=true"><code>/index.bundle?platform=ios&amp;dev=true</code></a></li>
+<li><a href="/index.bundle?platform=android&dev=true"><code>/index.bundle?platform=android&amp;dev=true</code></a></li>
+</ul>
+<h2>Source Maps</h2>
+<ul>
+<li><a href="/index.bundle.map?platform=ios"><code>/index.bundle.map?platform=ios</code></a></li>
+<li><a href="/index.bundle.map?platform=android"><code>/index.bundle.map?platform=android</code></a></li>
+</ul>
+<h2>HMR</h2>
+<ul>
+<li><code>ws://localhost:${port}/hot</code></li>
+</ul>
+</body>
+</html>`;
+	res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Content-Length": Buffer.byteLength(html) });
+	res.end(html);
+}
+//#endregion
+//#region open-url.ts
+function isOpenUrlRoute(pathname,method) {
+	return pathname === "/open-url" && method === "POST";
+}
+function resolveOpener(platform=process.platform) {
+	if (platform === "darwin")return { command: "open", args: (t) => [t] };
+	if (platform === "win32")return { command: "cmd", args: (t) => ["/c", "start", "", t] };
+	return { command: "xdg-open", args: (t) => [t] };
+}
+async function handleOpenUrl(req,res,spawner=spawn,platform=process.platform) {
+	let body = {};
+	try {
+		body = await readJsonBody(req);
+	} catch {
+		sendJson(res, 400, { error: "Invalid JSON body" });
+		return;
+	}
+	const target = body.url;
+	if (typeof target != "string" || target.length === 0) {
+		sendJson(res, 400, { error: "Invalid URL" });
+		return;
+	}
+	try {
+		const { command:command, args:args } = resolveOpener(platform),child = spawner(command, args(target), { detached: true, stdio: "ignore" });
+		child.unref();
+		sendJson(res, 200, { success: true });
+	} catch {
+		sendJson(res, 500, { error: "Failed to open URL" });
+	}
+}
+//#endregion
+//#region reload.ts
+function isReloadRoute(pathname) {
+	return pathname === "/reload";
+}
+function handleReload(_req,res,broadcast) {
+	broadcast("reload");
+	sendText(res, 200, "OK");
+}
+//#endregion
+//#region status.ts
+const STATUS_BODY = "packager-status:running";
+function isStatusRoute(pathname) {
+	return pathname === "/status" || pathname === "/status.txt";
+}
+function handleStatus(_req,res,projectRoot) {
+	res.setHeader("X-React-Native-Project-Root", projectRoot);
+	sendText(res, 200, STATUS_BODY);
+}
+//#endregion
+//#region symbolicate-source.ts
+async function createSourceMapConsumer(sourceMapJson) {
+	let parsed;
+	try {
+		parsed = JSON.parse(sourceMapJson);
+	} catch {
+		return null;
+	}
+	try {
+		const mod = (await Promise.resolve().then(()=>require_source_map_source_map()));
+		return await new mod.SourceMapConsumer(parsed);
+	} catch {
+		return null;
+	}
+}
+function normalizeFrame(frame) {
+	return { file: frame.file ?? null, methodName: frame.methodName ?? null, lineNumber: frame.lineNumber ?? null, column: frame.column ?? null };
+}
+function symbolicateFrame(consumer,frame,projectRoot) {
+	if (!frame.file || frame.lineNumber == null)return normalizeFrame(frame);
+	try {
+		const pos = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.column ?? 0 });
+		if (pos.source == null || pos.line == null)return normalizeFrame(frame);
+		const sourcePath = pos.source.startsWith("/") ? pos.source : pathResolve(projectRoot, pos.source);
+		return { file: sourcePath, methodName: pos.name ?? frame.methodName ?? null, lineNumber: pos.line, column: pos.column ?? 0 };
+	} catch {
+		return normalizeFrame(frame);
+	}
+}
+async function extractCodeFrame(frames) {
+	for (const frame of frames) {
+		if (!frame.file || frame.lineNumber == null)continue;
+		if (frame.file.includes(".bundle"))continue;
+		try {
+			const source = await readFile$1(frame.file, "utf-8"),lines = source.split("\n"),targetLine = frame.lineNumber - 1;
+			if (targetLine < 0 || targetLine >= lines.length)continue;
+			const startLine = Math.max(0, targetLine - 2),endLine = Math.min(lines.length - 1, targetLine + 2);
+			return { content: lines.slice(startLine, endLine + 1).join("\n"), location: { row: frame.lineNumber, column: frame.column ?? 0 }, fileName: frame.file };
+		} catch {
+		}
+	}
+	return null;
+}
+async function applyCustomizeFrame(frame,customizeFrame) {
+	if (!customizeFrame)return frame;
+	try {
+		const result = await customizeFrame(frame);
+		if (result?.collapse)return { ...frame, collapse: true };
+	} catch {
+	}
+	return frame;
+}
+//#endregion
+//#region symbolicate.ts
+function isSymbolicateRoute(pathname,method) {
+	return pathname === "/symbolicate" && method === "POST";
+}
+async function handleSymbolicateRequest(req,res,url,registry,defaultPlatform,projectRoot,customizeFrame) {
+	let body;
+	try {
+		body = await readJsonBody(req);
+	} catch {
+		sendJson(res, 400, { error: "Invalid JSON body" });
+		return;
+	}
+	const stack = body.stack ?? [],state = resolvePlatform(url, registry, defaultPlatform),sourceMap = getCachedSourceMap(state),debug = process.env.ZNTC_DEBUG_SYMBOLICATE === "1";
+	if (debug) {
+		process.stderr.write(`[zntc:rn-dev:debug] /symbolicate stack[${stack.length}] sourceMap=${sourceMap ? `len=${sourceMap.length}` : "null"}\n`);
+		for (const f of stack.slice(0, 5)) {
+			process.stderr.write(`[zntc:rn-dev:debug]   in: file=${f.file} line=${f.lineNumber} col=${f.column} method=${f.methodName}\n`);
+		}
+	}
+	const fallback = { stack: stack.map(normalizeFrame), codeFrame: null };
+	if (!sourceMap) {
+		if (debug)process.stderr.write("[zntc:rn-dev:debug]   sourceMap miss → fallback\n");
+		sendJson(res, 200, fallback);
+		return;
+	}
+	const consumer = await createSourceMapConsumer(sourceMap);
+	if (!consumer) {
+		if (debug)process.stderr.write("[zntc:rn-dev:debug]   consumer create fail → fallback\n");
+		sendJson(res, 200, fallback);
+		return;
+	}
+	try {
+		const symbolicated = await Promise.all(stack.map(async (frame) => {
+			const resolved = symbolicateFrame(consumer, frame, projectRoot);
+			return applyCustomizeFrame(resolved, customizeFrame);
+		})),codeFrame = await extractCodeFrame(symbolicated);
+		if (debug) {
+			for (const f of symbolicated.slice(0, 5)) {
+				process.stderr.write(`[zntc:rn-dev:debug]   out: file=${f.file} line=${f.lineNumber} col=${f.column} method=${f.methodName}${f.collapse ? " collapse=true" : ""}\n`);
+			}
+			process.stderr.write(`[zntc:rn-dev:debug]   codeFrame: ${codeFrame ? `${codeFrame.fileName}:${codeFrame.location.row}` : "null"}\n`);
+		}
+		sendJson(res, 200, { stack: symbolicated, codeFrame });
+	} finally {
+		consumer.destroy?.();
+	}
+}
+//#endregion
+//#region http-server.ts
+var jscSafeUrl$1 = __toESM(require_jsc_safe_url_index());
+function createBaseMiddleware(options,deps) {
+	return (req, res, next) => {
+		if (req.url) {
+			const normalized = jscSafeUrl$1.toNormalUrl(req.url),rewritten = options.rewriteRequestUrl ? options.rewriteRequestUrl(normalized) : normalized;
+			req.url = jscSafeUrl$1.toNormalUrl(rewritten);
+		}
+		const url = parseRequestUrl(req, options.host, options.port),pathname = url.pathname,method = req.method;
+		if (isIndexRoute(pathname)) {
+			handleIndexPage(req, res, options.port);
+			return;
+		}
+		if (isStatusRoute(pathname)) {
+			handleStatus(req, res, options.bundle.projectRoot);
+			return;
+		}
+		if (isReloadRoute(pathname)) {
+			handleReload(req, res, deps.broadcast);
+			return;
+		}
+		if (isDevMenuRoute(pathname)) {
+			handleDevMenu(req, res, deps.broadcast);
+			return;
+		}
+		if (isOpenUrlRoute(pathname, method)) {
+			handleOpenUrl(req, res).catch(next);
+			return;
+		}
+		if (isAssetRoute(pathname)) {
+			handleAssetRequest(req, res, url, { projectRoot: options.bundle.projectRoot, nodeModulesPaths: options.nodeModulesPaths }).catch(next);
+			return;
+		}
+		if (isBundleRoute(pathname)) {
+			handleBundleRequest(req, res, url, deps.platforms, options.bundle.rnPlatform, options.bundle.projectRoot, options.port).catch(next);
+			return;
+		}
+		if (isHmrMapRoute(pathname)) {
+			handleHmrMapRequest(req, res, url, deps.platforms, options.bundle.rnPlatform);
+			return;
+		}
+		if (isMapRoute(pathname)) {
+			handleMapRequest(req, res, url, deps.platforms, options.bundle.rnPlatform);
+			return;
+		}
+		if (isSymbolicateRoute(pathname, method)) {
+			handleSymbolicateRequest(req, res, url, deps.platforms, options.bundle.rnPlatform, options.bundle.projectRoot, options.symbolicator?.customizeFrame).catch(next);
+			return;
+		}
+		if (deps.devMiddleware && isDevMiddlewareRoute(pathname)) {
+			deps.devMiddleware.middleware(req, res, next);
+			return;
+		}
+		next();
+	};
+}
+function chainToHandler(middleware) {
+	return (req, res) => {
+		middleware(req, res, (err) => {
+			if (err) {
+				sendText(res, 500, `Internal Server Error: ${err.message ?? err}`);
+				return;
+			}
+			if (!res.headersSent && !res.writableEnded)sendText(res, 404, "Not Found");
+		});
+	};
+}
+function attachWebSocketEndpoints(server,deps,options) {
+	const hmr = deps.hmrBridge,cli = deps.cliServerApi?.websocketEndpoints,dev = deps.devMiddleware?.websocketEndpoints;
+	if (!hmr && !cli && !dev)return null;
+	const listener = (req, socket, head) => {
+		const url = parseRequestUrl(req, options.host, options.port);
+		if (hmr && (url.pathname === hmr.path || url.pathname.startsWith(`${hmr.path}?`))) {
+			hmr.acceptUpgrade(req, socket);
+			return;
+		}
+		if (cli) {
+			for (const [path, ep] of Object.entries(cli)) {
+				if (url.pathname === path || url.pathname.startsWith(`${path}?`)) {
+					ep.handleUpgrade(req, socket, head, (ws) => ep.emit("connection", ws, req));
+					return;
+				}
+			}
+		}
+		if (dev) {
+			for (const [path, ep] of Object.entries(dev)) {
+				if (url.pathname === path || url.pathname.startsWith(`${path}/`)) {
+					ep.handleUpgrade(req, socket, head, (ws) => ep.emit("connection", ws, req));
+					return;
+				}
+			}
+		}
+		socket.destroy();
+	};
+	server.on("upgrade", listener);
+	return listener;
+}
+async function createDevHttpServer(options,deps) {
+	const server = createServer(),baseMiddleware = createBaseMiddleware(options, deps),enhanced = options.enhanceMiddleware ? options.enhanceMiddleware(baseMiddleware, { httpServer: server }) : baseMiddleware,requestHandler = chainToHandler(enhanced);
+	server.on("request", requestHandler);
+	const upgradeHandler = attachWebSocketEndpoints(server, deps, options);
+	await new Promise((resolve, reject) => {
+		const onError = (err) => {
+			server.removeListener("listening", onListening);
+			reject(err);
+		},onListening = () => {
+			server.removeListener("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(options.port, options.host);
+	});
+	return { server, url: `http://${options.host}:${options.port}`, port: options.port, stop: () => new Promise((resolve, reject) => {
+		server.removeListener("request", requestHandler);
+		if (upgradeHandler)server.removeListener("upgrade", upgradeHandler);
+		server.close((err) => (err ? reject(err) : resolve()));
+	}) };
+}
+//#endregion
+//#region cli-server-api.ts
+function resolveCliServerApiPath(projectRoot) {
+	const candidates = [];
+	if (projectRoot) {
+		const projectRequire = createRequire$4(`${projectRoot}/package.json`);
+		candidates.push(() => projectRequire.resolve("@react-native-community/cli-server-api"));
+	}
+	const selfRequire = createRequire$4(import.meta.url);
+	candidates.push(() => selfRequire.resolve("@react-native-community/cli-server-api"));
+	for (const c of candidates) {
+		try {
+			return c();
+		} catch {
+		}
+	}
+	return "@react-native-community/cli-server-api";
+}
+async function loadCliServerApi(options) {
+	try {
+		const resolvedPath = resolveCliServerApiPath(options.projectRoot),mod = (await import(resolvedPath)),result = mod.createDevServerMiddleware({ port: options.port, host: options.host, watchFolders: [] });
+		return { websocketEndpoints: result.websocketEndpoints, broadcast: result.messageSocketEndpoint.broadcast };
+	} catch (err) {
+		if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+			process.stderr.write(`[zntc:rn-dev:debug] cli-server-api load failed: ${err?.message ?? err}\n`);
+		}
+		return null;
+	}
+}
+//#endregion
+//#region terminal-actions.ts
+function printDefaultShortcuts() {
+	console.log("");
+	logInfo("Available shortcuts:");
+	console.log(`     ${colors.bold}r${colors.reset} - Reload    ${colors.bold}d${colors.reset} - Dev Menu    ${colors.bold}j${colors.reset} - DevTools`);
+	console.log(`     ${colors.bold}i${colors.reset} - iOS Sim   ${colors.bold}a${colors.reset} - Android     ${colors.bold}c${colors.reset} - Clear cache`);
+	console.log(`     ${colors.bold}v${colors.reset} - Toggle console logs           ${colors.bold}?${colors.reset} - Show this help`);
+	console.log("");
+}
+function openIOSSimulator() {
+	if (process.platform !== "darwin") {
+		logWarn("iOS Simulator is only available on macOS");
+		return;
+	}
+	if (!existsSync$3("/usr/bin/xcrun")) {
+		logWarn("xcrun not found. Install Xcode Command Line Tools.");
+		return;
+	}
+	logInfo("Opening iOS Simulator...");
+	const child = spawn$1("open", ["-a", "Simulator"], { detached: true, stdio: ["ignore", "ignore", "ignore"] });
+	child.on("error", () => {
+	});
+	child.unref();
+}
+const AVD_NAME_RE = /^[a-zA-Z0-9._-]+$/;
+function openAndroidEmulator() {
+	const androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+	if (!androidHome) {
+		logWarn("ANDROID_HOME or ANDROID_SDK_ROOT not set");
+		return;
+	}
+	const emulatorPath = join$3(androidHome, "emulator", "emulator");
+	if (!existsSync$3(emulatorPath)) {
+		logWarn("Android emulator not found. Check your Android SDK installation.");
+		return;
+	}
+	const list = spawn$1(emulatorPath, ["-list-avds"], { stdio: ["ignore", "pipe", "ignore"] });
+	list.on("error", () => {
+	});
+	let buf = "";
+	list.stdout?.on("data", (chunk) => {
+		buf += chunk.toString();
+	});
+	list.on("close", () => {
+		const first = buf.split("\n").find((line) => line.trim().length > 0);
+		if (!first) {
+			logWarn("No Android AVDs found. Create an AVD first.");
+			return;
+		}
+		const avdName = first.trim();
+		if (!AVD_NAME_RE.test(avdName)) {
+			logWarn("Invalid AVD name");
+			return;
+		}
+		logInfo(`Opening Android Emulator: ${avdName}`);
+		const child = spawn$1(emulatorPath, ["@" + avdName], { detached: true, stdio: ["ignore", "ignore", "ignore"] });
+		child.on("error", () => {
+		});
+		child.unref();
+	});
+}
+function setupTerminalActions(callbacks,options={ enabled: true }) {
+	const stdin = options.stdin ?? process.stdin;
+	if (!options.enabled)return () => {
+	};
+	if (!stdin.isTTY) {
+		process.stderr.write("[zntc:rn-dev] stdin is not a TTY — keyboard shortcuts (r/d/j/i/a/c/?) disabled\n");
+		return () => {
+		};
+	}
+	const wasRaw = stdin.isRaw;
+	let rawModeOk = true;
+	if (!wasRaw) {
+		try {
+			stdin.setRawMode(true);
+		} catch (err) {
+			rawModeOk = false;
+			process.stderr.write(`[zntc:rn-dev] setRawMode failed (${err.message ?? err}) — keyboard shortcuts disabled\n`);
+			return () => {
+			};
+		}
+	}
+	if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+		process.stderr.write(`[zntc:rn-dev:debug] terminal-actions: isTTY=${stdin.isTTY} isRaw=${stdin.isRaw} rawModeOk=${rawModeOk} runtime=${process.versions.bun ? `bun-${process.versions.bun}` : `node-${process.versions.node}`}\n`);
+	}
+	stdin.resume();
+	stdin.setEncoding("utf8");
+	const printShortcuts = options.printShortcuts ?? printDefaultShortcuts,handleKey = (chunk) => {
+		const key = typeof chunk == "string" ? chunk : chunk.toString("utf8");
+		if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+			const hex = typeof chunk == "string" ? Buffer.from(chunk, "utf8").toString("hex") : chunk.toString("hex");
+			process.stderr.write(`[zntc:rn-dev:debug] key received: hex=${hex} len=${key.length} type=${typeof chunk}\n`);
+		}
+		if (stdin.isTTY && !stdin.isRaw) {
+			try {
+				stdin.setRawMode(true);
+			} catch {
+			}
+		}
+		if (key === "\u0003") {
+			cleanup();
+			process.kill(process.pid, "SIGINT");
+			return;
+		}
+		if (key === "\u0004") {
+			cleanup();
+			process.kill(process.pid, "SIGTERM");
+			return;
+		}
+		switch (key.toLowerCase()) {
+			case "r":
+				logInfo("Reloading app...");
+				callbacks.onReload();
+				break;
+			case "d":
+				logInfo("Opening Dev Menu...");
+				callbacks.onDevMenu();
+				break;
+			case "j":
+				logInfo("Opening DevTools...");
+				callbacks.onOpenDevTools();
+				break;
+			case "i":
+				openIOSSimulator();
+				break;
+			case "a":
+				openAndroidEmulator();
+				break;
+			case "c":
+				callbacks.onClearCache();
+				logInfo("Cache cleared");
+				break;
+			case "v":
+				{
+					const enabled = callbacks.onToggleLogs();
+					logInfo(`Console logs: ${enabled ? "ON" : "OFF"}`);
+					break;
+				}
+			case "?":
+				printShortcuts();
+				break;
+			default:
+				break;
+		}
+	};
+	stdin.on("data", handleKey);
+	let cleanedUp = false;
+	function cleanup() {
+		if (cleanedUp)return;
+		cleanedUp = true;
+		stdin.removeListener("data", handleKey);
+		if (!wasRaw && stdin.isTTY) {
+			try {
+				stdin.setRawMode(false);
+			} catch {
+			}
+		}
+		try {
+			stdin.pause();
+		} catch {
+		}
+	}
+	return cleanup;
+}
+//#endregion
+//#region serve.ts
+const HMR_PATH = "/hot";
+function makeNoopBroadcast() {
+	let warned = false;
+	return (method) => {
+		if (!warned) {
+			warned = true;
+			process.stderr.write(`[zntc:rn-dev] broadcast('${method}') skipped — '@react-native-community/cli-server-api' 미설치 또는 load 실패. ` + `RN runtime 의 reload/devMenu 메시지 안 감. peer dependency 설치 필요.\n`);
+		}
+	};
+}
+async function serveRn(options,extras={}) {
+	if (!extras.silent)printZntcRnBanner(extras.version);
+	const [cliServerApi, devMiddleware] = await Promise.all([loadCliServerApi({ port: options.port, host: options.host, projectRoot: options.bundle.projectRoot }), loadDevMiddleware({ port: options.port, projectRoot: options.bundle.projectRoot })]),broadcast = cliServerApi?.broadcast ?? makeNoopBroadcast();
+	if (process.env.ZNTC_DEBUG_TERMINAL === "1") {
+		process.stderr.write(`[zntc:rn-dev:debug] cli-server-api: ${cliServerApi ? "loaded" : "null (peer 미설치 또는 load 실패)"}\n`);
+		process.stderr.write(`[zntc:rn-dev:debug] dev-middleware: ${devMiddleware ? "loaded" : "null (peer 미설치)"}\n`);
+	}
+	const hmrBridge = options.hmr ? createHmrBridge({ path: HMR_PATH, silent: extras.silent, forwardClientLogs: options.bundle.extra?.forwardClientLogs }) : undefined,platforms = createPlatformStateRegistry(options, hmrBridge?.callbacks),httpHandle = await createDevHttpServer(options, { broadcast, platforms, hmrBridge, devMiddleware: devMiddleware ?? undefined, cliServerApi: cliServerApi ?? undefined }),buildStart = Date.now(),firstState = platforms.getOrCreate(options.bundle.rnPlatform);
+	await waitForBuild(firstState);
+	if (!extras.silent) {
+		if (firstState.buildError) {
+			logBundle("failed", options.bundle.rnPlatform, options.bundle.entry, firstState.buildError);
+		} else if (firstState.bundle !== null) {
+			const sizeKB = (Buffer.byteLength(firstState.bundle) / 1024).toFixed(1),buildMs = Date.now() - buildStart;
+			logBundle("done", options.bundle.rnPlatform, options.bundle.entry, `(${firstState.fileCount} files, ${sizeKB} KB, ${buildMs}ms)`);
+		}
+	}
+	const terminalCleanup = setupTerminalActions({ onReload: () => broadcast("reload"), onDevMenu: () => broadcast("devMenu"), onOpenDevTools: () => {
+		fetch(`${httpHandle.url}/open-debugger`, { method: "POST", signal: AbortSignal.timeout(5000) }).catch((err) => {
+			logError(`Failed to open DevTools: ${err.message ?? err}. ` + `'@react-native/dev-middleware' peer dependency 설치 확인.`);
+		});
+	}, onClearCache: () => {
+		for (const state of platforms.platforms.values()) {
+			state.bundle = null;
+			state.buildError = null;
+			state.sourceMapCache = null;
+		}
+	}, onToggleLogs: () => hmrBridge?.toggleLogs() ?? true }, { enabled: options.terminalActions });
+	if (!extras.silent) {
+		logInfo(`Dev server listening on ${httpHandle.url} (platform=${options.bundle.rnPlatform})`);
+		if (options.terminalActions)printDefaultShortcuts();
+	}
+	let signalCleanup = null;
+	if (extras.installSignalHandlers !== false) {
+		let shuttingDown = false;
+		const handleSignal = (signal) => {
+			if (shuttingDown)return;
+			shuttingDown = true;
+			if (!extras.silent)logInfo(`${signal} received, shutting down...`);
+			void (async () => {
+				try {
+					terminalCleanup();
+					await httpHandle.stop();
+					await platforms.stopAll();
+				} catch (err) {
+					logError(`Shutdown error: ${err.message ?? err}`);
+					process.exit(1);
+				}
+				if (!extras.silent)logInfo("Server stopped");
+				process.exit(0);
+			})();
+		};
+		process.on("SIGINT", handleSignal);
+		process.on("SIGTERM", handleSignal);
+		signalCleanup = () => {
+			process.off("SIGINT", handleSignal);
+			process.off("SIGTERM", handleSignal);
+		};
+	}
+	return { url: httpHandle.url, port: httpHandle.port, hmrBridge, platforms, async stop() {
+		signalCleanup?.();
+		terminalCleanup();
+		await httpHandle.stop();
+		await platforms.stopAll();
+	} };
+}
+//#endregion
+//#region options.ts
+function buildRnDevServerOptions(input) {
+	return { bundle: input.bundle, port: input.port ?? 8081, host: input.host ?? "localhost", nodeModulesPaths: input.nodeModulesPaths ?? [], enhanceMiddleware: input.enhanceMiddleware, rewriteRequestUrl: input.rewriteRequestUrl, symbolicator: input.symbolicator?.customizeFrame ? { customizeFrame: input.symbolicator.customizeFrame } : undefined, terminalActions: input.terminalActions ?? true, hmr: input.hmr ?? true };
+}
+//#endregion
+//#region babel.ts
+const ZNTC_NATIVE_PLUGIN_PATTERNS = ["optional-chaining", "nullish-coalescing", "class-properties", "private-methods", "private-property-in-object", "flow-strip-types", "transform-flow", "transform-typescript", "transform-react-jsx", "transform-arrow-functions", "transform-block-scoping", "transform-shorthand-properties", "transform-template-literals", "transform-modules-commonjs", "react-native-worklets", "react-native-reanimated/plugin", "react-native-reanimated", "@react-native/babel-preset"];
+function isZntcNativePlugin(name) {
+	return ZNTC_NATIVE_PLUGIN_PATTERNS.some((pattern) => name.includes(pattern));
+}
+function applyBabelPluginPrefix(name) {
+	if (name.startsWith("./") || name.startsWith("/") || name.startsWith("module:"))return name;
+	if (name.startsWith("@babel/")) {
+		const rest = name.slice("@babel/".length);
+		if (rest.startsWith("plugin-") || rest.startsWith("preset-"))return name;
+		return `@babel/plugin-${rest}`;
+	}
+	if (name.startsWith("@")) {
+		const slashIdx = name.indexOf("/");
+		if (slashIdx > 0) {
+			const scope = name.slice(0, slashIdx),rest = name.slice(slashIdx + 1);
+			if (rest.startsWith("babel-plugin-") || rest.startsWith("babel-preset-"))return name;
+			return `${scope}/babel-plugin-${rest}`;
+		}
+		return name;
+	}
+	if (name.startsWith("babel-plugin-") || name.startsWith("babel-preset-"))return name;
+	return `babel-plugin-${name}`;
+}
+function entryName(p) {
+	return typeof p == "string" ? p : Array.isArray(p) ? p[0] : "";
+}
+function hasNonNative(plugins) {
+	return plugins.some((p) => {
+		const name = entryName(p);
+		return typeof name == "string" && name !== "" && !isZntcNativePlugin(name);
+	});
+}
+function parserPluginsFor(filename) {
+	const ext = extname$2(filename);
+	if (ext === ".ts" || ext === ".tsx")return ["typescript", "jsx"];
+	if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") {
+		return ["jsx", "flow"];
+	}
+	return ["jsx"];
+}
+function isRootImportPluginName(name) {
+	const normalized = name.replace(/\\/g, "/");
+	return (normalized === "root-import" || normalized === "babel-plugin-root-import" || normalized.endsWith("/babel-plugin-root-import") || normalized.includes("/babel-plugin-root-import/"));
+}
+function injectRootImportRootOption(options,projectRoot) {
+	const next = options ? { ...options } : {},paths = next.paths;
+	if (Array.isArray(paths)) {
+		next.paths = paths.map((pathOption) => {
+			if (!pathOption || typeof pathOption != "object" || Array.isArray(pathOption)) {
+				return pathOption;
+			}
+			const record = pathOption;
+			return "root" in record ? record : { ...record, root: projectRoot };
+		});
+	} else if (paths && typeof paths == "object") {
+		const record = paths;
+		next.paths = "root" in record ? record : { ...record, root: projectRoot };
+	}
+	if (!("root" in next))next.root = projectRoot;
+	return next;
+}
+function detectCustomPlugins(projectRoot,inline) {
+	if (inline?.presets && hasNonNative(inline.presets))return true;
+	if (inline?.plugins && hasNonNative(inline.plugins))return true;
+	try {
+		const configPath = join$4(projectRoot, "babel.config.js");
+		if (!existsSync$4(configPath))return false;
+		const projectRequire = createRequire$5(`${projectRoot}/package.json`),config = projectRequire(configPath),plugins = config?.plugins ?? [];
+		return hasNonNative(plugins);
+	} catch {
+		return false;
+	}
+}
+function createBabelTransformer(projectRoot,inline) {
+	let babel = null,babelOptions = null;
+	function ensureBabel() {
+		if (babel)return;
+		const projectRequire = createRequire$5(`${projectRoot}/package.json`);
+		function resolvePluginPath(name) {
+			const prefixed = applyBabelPluginPrefix(name);
+			if (prefixed !== name) {
+				try {
+					return projectRequire.resolve(prefixed);
+				} catch {
+					try {
+						return requireFromCli.resolve(prefixed);
+					} catch {
+					}
+				}
+			}
+			try {
+				return projectRequire.resolve(name);
+			} catch {
+				return requireFromCli.resolve(name);
+			}
+		}
+		function resolveEntry(entry) {
+			if (Array.isArray(entry)) {
+				try {
+					const resolvedPath = resolvePluginPath(entry[0]),shouldInjectRoot = isRootImportPluginName(entry[0]) || isRootImportPluginName(applyBabelPluginPrefix(entry[0])) || isRootImportPluginName(resolvedPath);
+					if (shouldInjectRoot) {
+						return [resolvedPath, injectRootImportRootOption(entry[1], projectRoot), ...entry.slice(2)];
+					}
+					return [resolvedPath, ...entry.slice(1)];
+				} catch {
+					return entry;
+				}
+			}
+			try {
+				const resolvedPath = resolvePluginPath(entry),shouldInjectRoot = isRootImportPluginName(entry) || isRootImportPluginName(applyBabelPluginPrefix(entry)) || isRootImportPluginName(resolvedPath);
+				return shouldInjectRoot ? [resolvedPath, injectRootImportRootOption(undefined, projectRoot)] : resolvedPath;
+			} catch {
+				return entry;
+			}
+		}
+		babel = (() => {
+			try {
+				return projectRequire("@babel/core");
+			} catch {
+				return requireFromCli("@babel/core");
+			}
+		})();
+		const configPath = join$4(projectRoot, "babel.config.js"),fileConfig = existsSync$4(configPath) ? projectRequire(configPath) : { plugins: [] },filePlugins = fileConfig?.plugins ?? [],inlinePlugins = inline?.plugins ?? [],customPlugins = [];
+		for (const plugin of [...filePlugins, ...inlinePlugins]) {
+			const name = entryName(plugin);
+			if (typeof name == "string" && name !== "" && !isZntcNativePlugin(name)) {
+				customPlugins.push(resolveEntry(plugin));
+			}
+		}
+		const customPresets = [];
+		if (inline?.presets) {
+			for (const preset of inline.presets) {
+				const name = entryName(preset);
+				if (typeof name == "string" && name !== "" && !isZntcNativePlugin(name)) {
+					customPresets.push(resolveEntry(preset));
+				}
+			}
+		}
+		babelOptions = { presets: customPresets, plugins: customPlugins, cwd: projectRoot, root: projectRoot, babelrc: false, configFile: false, compact: false, retainLines: true, sourceMaps: false };
+		const pluginNames = customPlugins.map((p) => Array.isArray(p) ? p[0].split("/").pop() : String(p).split("/").pop());
+		process.stderr.write(`[zntc:babel] loaded: ${pluginNames.join(", ")}\n`);
+	}
+	return (code, filename) => {
+		try {
+			ensureBabel();
+			const result = babel.transformSync(code, { ...babelOptions, filename, parserOpts: { plugins: parserPluginsFor(filename) } });
+			if (result?.code && result.code !== code) {
+				process.stderr.write(`[zntc:babel] ${filename.split("/").pop()}: ${code.length} -> ${result.code.length}\n`);
+				return result.code;
+			}
+			return null;
+		} catch (err) {
+			process.stderr.write(`[zntc:babel] error: ${getErrorMessage(err)}\n`);
+			throw err;
+		}
+	};
+}
+function createBabelPlugin(config) {
+	return { name: "zntc:react-native:babel-transform", setup(build) {
+		const transformer = createBabelTransformer(config.projectRoot, config.inlineBabel),extPatterns = config.sourceExts.map((e) => normalizeExt(e).slice(1)).join("|"),sourcePattern = new RegExp(`\\.(${extPatterns})$`);
+		build.onTransform({ filter: sourcePattern }, (args) => {
+			if (args.path.includes("node_modules"))return null;
+			try {
+				const result = transformer(args.code, args.path);
+				return result ? { code: result } : null;
+			} catch {
+				return null;
+			}
+		});
+	} };
+}
+//#endregion
+//#region codegen.ts
+const CODEGEN_NATIVE_COMPONENT_MARKER = "codegenNativeComponent";
+const CODEGEN_FILENAME_PATTERN = /\.(js|ts)$/;
+function createCodegenTransformer(projectRoot) {
+	let babel = null,codegenPlugin = null,babelOptions = null;
+	function ensureBabel() {
+		if (babel)return;
+		babel = requireFromCli("@babel/core");
+		try {
+			const codegenPath = (() => {
+				try {
+					return requireFromCli.resolve("@react-native/babel-plugin-codegen", { paths: [projectRoot] });
+				} catch {
+					return requireFromCli.resolve("@react-native/babel-plugin-codegen");
+				}
+			})();
+			codegenPlugin = requireFromCli(codegenPath);
+		} catch (err) {
+			process.stderr.write(`[zntc:codegen] @react-native/babel-plugin-codegen not found (${getErrorMessage(err, 80)}) — view config inlining disabled\n`);
+			throw err;
+		}
+		babelOptions = { babelrc: false, configFile: false, compact: false, sourceMaps: false, plugins: [codegenPlugin] };
+	}
+	return (code, filename) => {
+		if (!CODEGEN_FILENAME_PATTERN.test(filename))return null;
+		if (!code.includes(CODEGEN_NATIVE_COMPONENT_MARKER))return null;
+		const parserPlugins = filename.endsWith(".ts") ? ["typescript"] : ["flow"];
+		try {
+			ensureBabel();
+			const result = babel.transformSync(code, { ...babelOptions, filename, parserOpts: { plugins: parserPlugins } });
+			if (result?.code && result.code !== code) {
+				process.stderr.write(`[zntc:codegen] ${filename.split("/").pop()}: view config inlined\n`);
+				return result.code;
+			}
+			return null;
+		} catch (err) {
+			process.stderr.write(`[zntc:codegen] ${filename.split("/").pop()} failed: ${getErrorMessage(err, 120)}\n`);
+			return null;
+		}
+	};
+}
+function createCodegenPlugin(config) {
+	return { name: "zntc:react-native:codegen-view-config", setup(build) {
+		const transformer = createCodegenTransformer(config.projectRoot);
+		build.onTransform({ filter: /\.(js|ts)$/ }, (args) => {
+			try {
+				const result = transformer(args.code, args.path);
+				return result ? { code: result } : null;
+			} catch {
+				return null;
+			}
+		});
+	} };
+}
+//#endregion
+//#region styled-components-native.ts
+const STYLED_COMPONENTS_NATIVE_PATH_RE = /(?:^|[/\\])styled-components[/\\]native[/\\]dist[/\\]styled-components\.native\.(?:cjs|esm)\.js$/;
+const DOM_PROBE_PATTERNS = [/(['"])undefined\1\s*!=\s*typeof\s+window\s*&&\s*(['"])HTMLElement\2\s*in\s+window/g, /typeof\s+window\s*!==?\s*(['"])undefined\1\s*&&\s*(['"])HTMLElement\2\s*in\s+window/g];
+function disableStyledComponentsNativeDomProbe(code) {
+	let next = code;
+	for (const pattern of DOM_PROBE_PATTERNS) {
+		next = next.replace(pattern, "false");
+	}
+	return next === code ? null : next;
+}
+function createStyledComponentsNativePlugin() {
+	return { name: "zntc:react-native:styled-components-native", setup(build) {
+		build.onTransform({ filter: STYLED_COMPONENTS_NATIVE_PATH_RE }, (args) => {
+			const code = disableStyledComponentsNativeDomProbe(args.code);
+			return code ? { code } : null;
+		});
+	} };
+}
+//#endregion
+//#region withExpo.ts
+function detectExpo(projectRoot) {
+	try {
+		const pkg = JSON.parse(readFileSync$3(join$5(projectRoot, "package.json"), "utf8")),deps = { ...pkg.dependencies, ...pkg.devDependencies };
+		if (deps.expo)return { name: "expo", version: deps.expo };
+		if (deps["expo-router"])return { name: "expo-router", version: deps["expo-router"] };
+	} catch {
+	}
+	return undefined;
+}
+const EXPO_ASSET_EXTS = [".heic", ".avif", ".db"],EXPO_BLOCK_LIST = [/\.expo[\\/]types/];
+const WINTER_POLYFILL_WARNING_PATTERN = "^Failed to set polyfill\\.\\s+\\w+\\s+is not configurable\\.?$";
+function resolveExpoModules(root) {
+	const winter = tryResolve("expo/src/winter/index.ts", root) ?? tryResolve("expo/src/winter/index", root) ?? tryResolve("expo/build/winter/index.js", root) ?? undefined,expoRouterPkg = tryResolve("expo-router/package.json", root),metroRuntimeBase = expoRouterPkg ? dirname$5(expoRouterPkg) : root,metroRuntime = tryResolve("@expo/metro-runtime", metroRuntimeBase) ?? undefined;
+	return { winter, metroRuntime };
+}
+function withExpo(config) {
+	const root = config.root ?? process.cwd(),{ winter:winter, metroRuntime:metroRuntime } = resolveExpoModules(root),expoModules = [];
+	if (winter)expoModules.push(winter);
+	if (metroRuntime)expoModules.push(metroRuntime);
+	const existingAssetExts = config.resolver?.assetExts ?? [],existingNormalized = new Set(existingAssetExts.map(normalizeExt));
+	return { ...config, resolver: { ...config.resolver, assetExts: [...existingAssetExts, ...EXPO_ASSET_EXTS.filter((ext) => !existingNormalized.has(ext))], blockList: [...(config.resolver?.blockList ?? []), ...EXPO_BLOCK_LIST] }, serializer: { ...config.serializer, prelude: [...(config.serializer?.prelude ?? []), ...expoModules] }, server: { ...config.server, silentConsoleErrorPatterns: [...(config.server?.silentConsoleErrorPatterns ?? []), WINTER_POLYFILL_WARNING_PATTERN] } };
+}
+//#endregion
+//#region index.ts
+export { HMR_RN_MSG, buildRnDevServerOptions, createBaseMiddleware, createDevHttpServer, createHmrBridge, createPlatformState, loadCliServerApi, loadDevMiddleware, createPlatformStateRegistry, getCachedSourceMap, applyCustomizeFrame, createSourceMapConsumer, extractCodeFrame, handleAssetRequest, handleBundleRequest, handleHmrMapRequest, handleIndexPage, handleMapRequest, handleSymbolicateRequest, isIndexRoute, isAssetRoute, isBundleRoute, isHmrMapRoute, isMapRoute, isSymbolicateRoute, normalizeFrame, symbolicateFrame, colors, formatLogBadge, logBundle, logError, logInfo, logWarn, postProcessSourceMap, printZntcRnBanner, resolveAssetPath, serveRn, setupTerminalActions, waitForBuild, createMetroHmrAdapter, createAssetPlugin, createBabelPlugin, createBabelTransformer, detectCustomPlugins, isZntcNativePlugin, ZNTC_NATIVE_PLUGIN_PATTERNS, CODEGEN_NATIVE_COMPONENT_MARKER, createCodegenPlugin, createCodegenTransformer, escapeRegex, createMetroResolveRequestPlugin, createRequireContextPlugin, createStyledComponentsNativePlugin, disableStyledComponentsNativeDomProbe, STYLED_COMPONENTS_NATIVE_PATH_RE, buildRnBundleOptions, bundleRn, DEFAULT_ASSET_EXTS, watchRn, resolveRnPolyfills, RN_GLOBAL_IDENTIFIERS, tryResolve, HMR_CLIENT_SUFFIX, ZNTC_HMR_CLIENT_CODE, detectExpo, WINTER_POLYFILL_WARNING_PATTERN, withExpo };
+//#endregion