vite-plugin-simple-macro 0.0.9

package/dist/index.mjs

@@ -0,0 +1,5062 @@
+import { parseAsync, traverse, types } from "@babel/core";
+import * as _t from "@babel/types";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __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));
+//#endregion
+//#region node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+		case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+		case "id": {
+			if (id === void 0) throw new Error("`id` is required for `id` expression");
+			let idToMatch = id;
+			if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch);
+			return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch);
+		}
+		case "importerId": {
+			if (importerId === void 0) return false;
+			let importerIdToMatch = importerId;
+			if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch);
+			return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch);
+		}
+		case "moduleType":
+			if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType === expr.pattern;
+		case "code":
+			if (code === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code);
+		case "query": {
+			if (id === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+//#endregion
+//#region node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = /* @__PURE__ */ new Uint8Array(64);
+var charToInt = /* @__PURE__ */ new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+	let delta = num - relative;
+	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+	do {
+		let clamped = delta & 31;
+		delta >>>= 5;
+		if (delta > 0) clamped |= 32;
+		builder.write(intToChar[clamped]);
+	} while (delta > 0);
+	return num;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+	return a[0] - b[0];
+}
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			genColumn = encodeInteger(writer, segment[0], genColumn);
+			if (segment.length === 1) continue;
+			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+			sourceLine = encodeInteger(writer, segment[2], sourceLine);
+			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			if (segment.length === 4) continue;
+			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+var import_resolve_uri_umd = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.resolveURI = factory());
+	})(exports, (function() {
+		"use strict";
+		const schemeRegex = /^[\w+.-]+:\/\//;
+		/**
+		* Matches the parts of a URL:
+		* 1. Scheme, including ":", guaranteed.
+		* 2. User/password, including "@", optional.
+		* 3. Host, guaranteed.
+		* 4. Port, including ":", optional.
+		* 5. Path, including "/", optional.
+		* 6. Query, including "?", optional.
+		* 7. Hash, including "#", optional.
+		*/
+		const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+		/**
+		* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+		* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+		*
+		* 1. Host, optional.
+		* 2. Path, which may include "/", guaranteed.
+		* 3. Query, including "?", optional.
+		* 4. Hash, including "#", optional.
+		*/
+		const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+		function isAbsoluteUrl(input) {
+			return schemeRegex.test(input);
+		}
+		function isSchemeRelativeUrl(input) {
+			return input.startsWith("//");
+		}
+		function isAbsolutePath(input) {
+			return input.startsWith("/");
+		}
+		function isFileUrl(input) {
+			return input.startsWith("file:");
+		}
+		function isRelative(input) {
+			return /^[.?#]/.test(input);
+		}
+		function parseAbsoluteUrl(input) {
+			const match = urlRegex.exec(input);
+			return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+		}
+		function parseFileUrl(input) {
+			const match = fileRegex.exec(input);
+			const path = match[2];
+			return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+		}
+		function makeUrl(scheme, user, host, port, path, query, hash) {
+			return {
+				scheme,
+				user,
+				host,
+				port,
+				path,
+				query,
+				hash,
+				type: 7
+			};
+		}
+		function parseUrl(input) {
+			if (isSchemeRelativeUrl(input)) {
+				const url = parseAbsoluteUrl("http:" + input);
+				url.scheme = "";
+				url.type = 6;
+				return url;
+			}
+			if (isAbsolutePath(input)) {
+				const url = parseAbsoluteUrl("http://foo.com" + input);
+				url.scheme = "";
+				url.host = "";
+				url.type = 5;
+				return url;
+			}
+			if (isFileUrl(input)) return parseFileUrl(input);
+			if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+			const url = parseAbsoluteUrl("http://foo.com/" + input);
+			url.scheme = "";
+			url.host = "";
+			url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+			return url;
+		}
+		function stripPathFilename(path) {
+			if (path.endsWith("/..")) return path;
+			const index = path.lastIndexOf("/");
+			return path.slice(0, index + 1);
+		}
+		function mergePaths(url, base) {
+			normalizePath(base, base.type);
+			if (url.path === "/") url.path = base.path;
+			else url.path = stripPathFilename(base.path) + url.path;
+		}
+		/**
+		* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+		* "foo/.". We need to normalize to a standard representation.
+		*/
+		function normalizePath(url, type) {
+			const rel = type <= 4;
+			const pieces = url.path.split("/");
+			let pointer = 1;
+			let positive = 0;
+			let addTrailingSlash = false;
+			for (let i = 1; i < pieces.length; i++) {
+				const piece = pieces[i];
+				if (!piece) {
+					addTrailingSlash = true;
+					continue;
+				}
+				addTrailingSlash = false;
+				if (piece === ".") continue;
+				if (piece === "..") {
+					if (positive) {
+						addTrailingSlash = true;
+						positive--;
+						pointer--;
+					} else if (rel) pieces[pointer++] = piece;
+					continue;
+				}
+				pieces[pointer++] = piece;
+				positive++;
+			}
+			let path = "";
+			for (let i = 1; i < pointer; i++) path += "/" + pieces[i];
+			if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+			url.path = path;
+		}
+		/**
+		* Attempts to resolve `input` URL/path relative to `base`.
+		*/
+		function resolve(input, base) {
+			if (!input && !base) return "";
+			const url = parseUrl(input);
+			let inputType = url.type;
+			if (base && inputType !== 7) {
+				const baseUrl = parseUrl(base);
+				const baseType = baseUrl.type;
+				switch (inputType) {
+					case 1: url.hash = baseUrl.hash;
+					case 2: url.query = baseUrl.query;
+					case 3:
+					case 4: mergePaths(url, baseUrl);
+					case 5:
+						url.user = baseUrl.user;
+						url.host = baseUrl.host;
+						url.port = baseUrl.port;
+					case 6: url.scheme = baseUrl.scheme;
+				}
+				if (baseType > inputType) inputType = baseType;
+			}
+			normalizePath(url, inputType);
+			const queryHash = url.query + url.hash;
+			switch (inputType) {
+				case 2:
+				case 3: return queryHash;
+				case 4: {
+					const path = url.path.slice(1);
+					if (!path) return queryHash || ".";
+					if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+					return path + queryHash;
+				}
+				case 5: return url.path + queryHash;
+				default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+			}
+		}
+		return resolve;
+	}));
+})))(), 1);
+function stripFilename(path) {
+	if (!path) return "";
+	const index = path.lastIndexOf("/");
+	return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+	const from = stripFilename(mapUrl);
+	const prefix = sourceRoot ? sourceRoot + "/" : "";
+	return (source) => (0, import_resolve_uri_umd.default)(prefix + (source || ""), from);
+}
+var COLUMN$1 = 0;
+var SOURCES_INDEX$1 = 1;
+var SOURCE_LINE$1 = 2;
+var SOURCE_COLUMN$1 = 3;
+var NAMES_INDEX$1 = 4;
+function maybeSort(mappings, owned) {
+	const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+	if (unsortedIndex === mappings.length) return mappings;
+	if (!owned) mappings = mappings.slice();
+	for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) mappings[i] = sortSegments(mappings[i], owned);
+	return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+	for (let i = start; i < mappings.length; i++) if (!isSorted(mappings[i])) return i;
+	return mappings.length;
+}
+function isSorted(line) {
+	for (let j = 1; j < line.length; j++) if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) return false;
+	return true;
+}
+function sortSegments(line, owned) {
+	if (!owned) line = line.slice();
+	return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[COLUMN$1] - b[COLUMN$1];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+	while (low <= high) {
+		const mid = low + (high - low >> 1);
+		const cmp = haystack[mid][COLUMN$1] - needle;
+		if (cmp === 0) {
+			found = true;
+			return mid;
+		}
+		if (cmp < 0) low = mid + 1;
+		else high = mid - 1;
+	}
+	found = false;
+	return low - 1;
+}
+function upperBound(haystack, needle, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN$1] !== needle) break;
+	return index;
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+	const { lastKey, lastNeedle, lastIndex } = state;
+	let low = 0;
+	let high = haystack.length - 1;
+	if (key === lastKey) {
+		if (needle === lastNeedle) {
+			found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
+			return lastIndex;
+		}
+		if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
+		else high = lastIndex;
+	}
+	state.lastKey = key;
+	state.lastNeedle = needle;
+	return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+	return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var TraceMap = class {
+	constructor(map, mapUrl) {
+		const isString = typeof map === "string";
+		if (!isString && map._decodedMemo) return map;
+		const parsed = parse(map);
+		const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+		this.version = version;
+		this.file = file;
+		this.names = names || [];
+		this.sourceRoot = sourceRoot;
+		this.sources = sources;
+		this.sourcesContent = sourcesContent;
+		this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+		const resolve = resolver(mapUrl, sourceRoot);
+		this.resolvedSources = sources.map(resolve);
+		const { mappings } = parsed;
+		if (typeof mappings === "string") {
+			this._encoded = mappings;
+			this._decoded = void 0;
+		} else if (Array.isArray(mappings)) {
+			this._encoded = void 0;
+			this._decoded = maybeSort(mappings, isString);
+		} else if (parsed.sections) throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+		else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+		this._decodedMemo = memoizedState();
+		this._bySources = void 0;
+		this._bySourceMemos = void 0;
+	}
+};
+function cast$1(map) {
+	return map;
+}
+function decodedMappings(map) {
+	var _a;
+	return (_a = cast$1(map))._decoded || (_a._decoded = decode(cast$1(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+	let { line, column, bias } = needle;
+	line--;
+	if (line < 0) throw new Error(LINE_GTR_ZERO);
+	if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+	const decoded = decodedMappings(map);
+	if (line >= decoded.length) return OMapping(null, null, null, null);
+	const segments = decoded[line];
+	const index = traceSegmentInternal(segments, cast$1(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	if (segment.length === 1) return OMapping(null, null, null, null);
+	const { names, resolvedSources } = map;
+	return OMapping(resolvedSources[segment[SOURCES_INDEX$1]], segment[SOURCE_LINE$1] + 1, segment[SOURCE_COLUMN$1], segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null);
+}
+function OMapping(source, line, column, name) {
+	return {
+		source,
+		line,
+		column,
+		name
+	};
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+	let index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === -1 ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === -1) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+//#endregion
+//#region node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+var SetArray = class {
+	constructor() {
+		this._indexes = { __proto__: null };
+		this.array = [];
+	}
+};
+function cast(set) {
+	return set;
+}
+function get(setarr, key) {
+	return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+	const index = get(setarr, key);
+	if (index !== void 0) return index;
+	const { array, _indexes: indexes } = cast(setarr);
+	return indexes[key] = array.push(key) - 1;
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var NO_NAME = -1;
+var GenMapping = class {
+	constructor({ file, sourceRoot } = {}) {
+		this._names = new SetArray();
+		this._sources = new SetArray();
+		this._sourcesContent = [];
+		this._mappings = [];
+		this.file = file;
+		this.sourceRoot = sourceRoot;
+		this._ignoreList = new SetArray();
+	}
+};
+function cast2(map) {
+	return map;
+}
+var maybeAddMapping = (map, mapping) => {
+	return addMappingInternal(true, map, mapping);
+};
+function setSourceContent(map, source, content) {
+	const { _sources: sources, _sourcesContent: sourcesContent } = cast2(map);
+	const index = put(sources, source);
+	sourcesContent[index] = content;
+}
+function toDecodedMap(map) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList } = cast2(map);
+	removeEmptyFinalLines(mappings);
+	return {
+		version: 3,
+		file: map.file || void 0,
+		names: names.array,
+		sourceRoot: map.sourceRoot || void 0,
+		sources: sources.array,
+		sourcesContent,
+		mappings,
+		ignoreList: ignoreList.array
+	};
+}
+function toEncodedMap(map) {
+	const decoded = toDecodedMap(map);
+	return Object.assign({}, decoded, { mappings: encode(decoded.mappings) });
+}
+function allMappings(map) {
+	const out = [];
+	const { _mappings: mappings, _sources: sources, _names: names } = cast2(map);
+	for (let i = 0; i < mappings.length; i++) {
+		const line = mappings[i];
+		for (let j = 0; j < line.length; j++) {
+			const seg = line[j];
+			const generated = {
+				line: i + 1,
+				column: seg[COLUMN]
+			};
+			let source = void 0;
+			let original = void 0;
+			let name = void 0;
+			if (seg.length !== 1) {
+				source = sources.array[seg[SOURCES_INDEX]];
+				original = {
+					line: seg[SOURCE_LINE] + 1,
+					column: seg[SOURCE_COLUMN]
+				};
+				if (seg.length === 5) name = names.array[seg[NAMES_INDEX]];
+			}
+			out.push({
+				generated,
+				source,
+				original,
+				name
+			});
+		}
+	}
+	return out;
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+	const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names } = cast2(map);
+	const line = getIndex(mappings, genLine);
+	const index = getColumnIndex(line, genColumn);
+	if (!source) {
+		if (skipable && skipSourceless(line, index)) return;
+		return insert(line, index, [genColumn]);
+	}
+	const sourcesIndex = put(sources, source);
+	const namesIndex = name ? put(names, name) : NO_NAME;
+	if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+	if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) return;
+	return insert(line, index, name ? [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn,
+		namesIndex
+	] : [
+		genColumn,
+		sourcesIndex,
+		sourceLine,
+		sourceColumn
+	]);
+}
+function getIndex(arr, index) {
+	for (let i = arr.length; i <= index; i++) arr[i] = [];
+	return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+	let index = line.length;
+	for (let i = index - 1; i >= 0; index = i--) if (genColumn >= line[i][COLUMN]) break;
+	return index;
+}
+function insert(array, index, value) {
+	for (let i = array.length; i > index; i--) array[i] = array[i - 1];
+	array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+	const { length } = mappings;
+	let len = length;
+	for (let i = len - 1; i >= 0; len = i, i--) if (mappings[i].length > 0) break;
+	if (len < length) mappings.length = len;
+}
+function skipSourceless(line, index) {
+	if (index === 0) return true;
+	return line[index - 1].length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+	if (index === 0) return false;
+	const prev = line[index - 1];
+	if (prev.length === 1) return false;
+	return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+function addMappingInternal(skipable, map, mapping) {
+	const { generated, source, original, name, content } = mapping;
+	if (!source) return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
+	return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
+}
+//#endregion
+//#region node_modules/@babel/generator/lib/index.js
+var import_jsesc = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var forOwn = (object, callback) => {
+		for (const key in object) if (hasOwnProperty.call(object, key)) callback(key, object[key]);
+	};
+	var extend = (destination, source) => {
+		if (!source) return destination;
+		forOwn(source, (key, value) => {
+			destination[key] = value;
+		});
+		return destination;
+	};
+	var forEach = (array, callback) => {
+		const length = array.length;
+		let index = -1;
+		while (++index < length) callback(array[index]);
+	};
+	var fourHexEscape = (hex) => {
+		return "\\u" + ("0000" + hex).slice(-4);
+	};
+	var hexadecimal = (code, lowercase) => {
+		let hexadecimal = code.toString(16);
+		if (lowercase) return hexadecimal;
+		return hexadecimal.toUpperCase();
+	};
+	var toString = object.toString;
+	var isArray = Array.isArray;
+	var isBuffer = (value) => {
+		return typeof Buffer === "function" && Buffer.isBuffer(value);
+	};
+	var isObject = (value) => {
+		return toString.call(value) == "[object Object]";
+	};
+	var isString = (value) => {
+		return typeof value == "string" || toString.call(value) == "[object String]";
+	};
+	var isNumber = (value) => {
+		return typeof value == "number" || toString.call(value) == "[object Number]";
+	};
+	var isBigInt = (value) => {
+		return typeof value == "bigint";
+	};
+	var isFunction = (value) => {
+		return typeof value == "function";
+	};
+	var isMap = (value) => {
+		return toString.call(value) == "[object Map]";
+	};
+	var isSet = (value) => {
+		return toString.call(value) == "[object Set]";
+	};
+	var singleEscapes = {
+		"\\": "\\\\",
+		"\b": "\\b",
+		"\f": "\\f",
+		"\n": "\\n",
+		"\r": "\\r",
+		"	": "\\t"
+	};
+	var regexSingleEscape = /[\\\b\f\n\r\t]/;
+	var regexDigit = /[0-9]/;
+	var regexWhitespace = /[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
+	var escapeEverythingRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^]/g;
+	var escapeNonAsciiRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^ !#-&\(-\[\]-_a-~]/g;
+	var jsesc = (argument, options) => {
+		const increaseIndentation = () => {
+			oldIndent = indent;
+			++options.indentLevel;
+			indent = options.indent.repeat(options.indentLevel);
+		};
+		const defaults = {
+			"escapeEverything": false,
+			"minimal": false,
+			"isScriptContext": false,
+			"quotes": "single",
+			"wrap": false,
+			"es6": false,
+			"json": false,
+			"compact": true,
+			"lowercaseHex": false,
+			"numbers": "decimal",
+			"indent": "	",
+			"indentLevel": 0,
+			"__inline1__": false,
+			"__inline2__": false
+		};
+		const json = options && options.json;
+		if (json) {
+			defaults.quotes = "double";
+			defaults.wrap = true;
+		}
+		options = extend(defaults, options);
+		if (options.quotes != "single" && options.quotes != "double" && options.quotes != "backtick") options.quotes = "single";
+		const quote = options.quotes == "double" ? "\"" : options.quotes == "backtick" ? "`" : "'";
+		const compact = options.compact;
+		const lowercaseHex = options.lowercaseHex;
+		let indent = options.indent.repeat(options.indentLevel);
+		let oldIndent = "";
+		const inline1 = options.__inline1__;
+		const inline2 = options.__inline2__;
+		const newLine = compact ? "" : "\n";
+		let result;
+		let isEmpty = true;
+		const useBinNumbers = options.numbers == "binary";
+		const useOctNumbers = options.numbers == "octal";
+		const useDecNumbers = options.numbers == "decimal";
+		const useHexNumbers = options.numbers == "hexadecimal";
+		if (json && argument && isFunction(argument.toJSON)) argument = argument.toJSON();
+		if (!isString(argument)) {
+			if (isMap(argument)) {
+				if (argument.size == 0) return "new Map()";
+				if (!compact) {
+					options.__inline1__ = true;
+					options.__inline2__ = false;
+				}
+				return "new Map(" + jsesc(Array.from(argument), options) + ")";
+			}
+			if (isSet(argument)) {
+				if (argument.size == 0) return "new Set()";
+				return "new Set(" + jsesc(Array.from(argument), options) + ")";
+			}
+			if (isBuffer(argument)) {
+				if (argument.length == 0) return "Buffer.from([])";
+				return "Buffer.from(" + jsesc(Array.from(argument), options) + ")";
+			}
+			if (isArray(argument)) {
+				result = [];
+				options.wrap = true;
+				if (inline1) {
+					options.__inline1__ = false;
+					options.__inline2__ = true;
+				}
+				if (!inline2) increaseIndentation();
+				forEach(argument, (value) => {
+					isEmpty = false;
+					if (inline2) options.__inline2__ = false;
+					result.push((compact || inline2 ? "" : indent) + jsesc(value, options));
+				});
+				if (isEmpty) return "[]";
+				if (inline2) return "[" + result.join(", ") + "]";
+				return "[" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "]";
+			} else if (isNumber(argument) || isBigInt(argument)) {
+				if (json) return JSON.stringify(Number(argument));
+				let result;
+				if (useDecNumbers) result = String(argument);
+				else if (useHexNumbers) {
+					let hexadecimal = argument.toString(16);
+					if (!lowercaseHex) hexadecimal = hexadecimal.toUpperCase();
+					result = "0x" + hexadecimal;
+				} else if (useBinNumbers) result = "0b" + argument.toString(2);
+				else if (useOctNumbers) result = "0o" + argument.toString(8);
+				if (isBigInt(argument)) return result + "n";
+				return result;
+			} else if (isBigInt(argument)) {
+				if (json) return JSON.stringify(Number(argument));
+				return argument + "n";
+			} else if (!isObject(argument)) {
+				if (json) return JSON.stringify(argument) || "null";
+				return String(argument);
+			} else {
+				result = [];
+				options.wrap = true;
+				increaseIndentation();
+				forOwn(argument, (key, value) => {
+					isEmpty = false;
+					result.push((compact ? "" : indent) + jsesc(key, options) + ":" + (compact ? "" : " ") + jsesc(value, options));
+				});
+				if (isEmpty) return "{}";
+				return "{" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "}";
+			}
+		}
+		const regex = options.escapeEverything ? escapeEverythingRegex : escapeNonAsciiRegex;
+		result = argument.replace(regex, (char, pair, lone, quoteChar, index, string) => {
+			if (pair) {
+				if (options.minimal) return pair;
+				const first = pair.charCodeAt(0);
+				const second = pair.charCodeAt(1);
+				if (options.es6) return "\\u{" + hexadecimal((first - 55296) * 1024 + second - 56320 + 65536, lowercaseHex) + "}";
+				return fourHexEscape(hexadecimal(first, lowercaseHex)) + fourHexEscape(hexadecimal(second, lowercaseHex));
+			}
+			if (lone) return fourHexEscape(hexadecimal(lone.charCodeAt(0), lowercaseHex));
+			if (char == "\0" && !json && !regexDigit.test(string.charAt(index + 1))) return "\\0";
+			if (quoteChar) {
+				if (quoteChar == quote || options.escapeEverything) return "\\" + quoteChar;
+				return quoteChar;
+			}
+			if (regexSingleEscape.test(char)) return singleEscapes[char];
+			if (options.minimal && !regexWhitespace.test(char)) return char;
+			const hex = hexadecimal(char.charCodeAt(0), lowercaseHex);
+			if (json || hex.length > 2) return fourHexEscape(hex);
+			return "\\x" + ("00" + hex).slice(-2);
+		});
+		if (quote == "`") result = result.replace(/\$\{/g, "\\${");
+		if (options.isScriptContext) result = result.replace(/<\/(script|style)/gi, "<\\/$1").replace(/<!--/g, json ? "\\u003C!--" : "\\x3C!--");
+		if (options.wrap) result = quote + result + quote;
+		return result;
+	};
+	jsesc.version = "3.0.2";
+	module.exports = jsesc;
+})))(), 1);
+var SourceMap = class {
+	_map;
+	_rawMappings;
+	_sourceFileName;
+	_lastGenLine = 0;
+	_lastSourceLine = 0;
+	_lastSourceColumn = 0;
+	_inputMap = null;
+	constructor(opts, code) {
+		const map = this._map = new GenMapping({ sourceRoot: opts.sourceRoot });
+		this._sourceFileName = opts.sourceFileName?.replace(/\\/g, "/");
+		this._rawMappings = void 0;
+		if (opts.inputSourceMap) {
+			this._inputMap = new TraceMap(opts.inputSourceMap);
+			const resolvedSources = this._inputMap.resolvedSources;
+			if (resolvedSources.length) for (let i = 0; i < resolvedSources.length; i++) setSourceContent(map, resolvedSources[i], this._inputMap.sourcesContent?.[i]);
+		}
+		if (typeof code === "string" && !opts.inputSourceMap) setSourceContent(map, this._sourceFileName, code);
+		else if (typeof code === "object") for (const sourceFileName of Object.keys(code)) setSourceContent(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
+	}
+	get() {
+		return toEncodedMap(this._map);
+	}
+	getDecoded() {
+		return toDecodedMap(this._map);
+	}
+	getRawMappings() {
+		return this._rawMappings ||= allMappings(this._map);
+	}
+	mark(generated, generatedIdentifierName, line, column, identifierName, identifierNamePos, filename) {
+		this._rawMappings = void 0;
+		let originalMapping;
+		if (line != null) if (this._inputMap) {
+			originalMapping = originalPositionFor(this._inputMap, {
+				line,
+				column
+			});
+			if (originalMapping.name && (identifierNamePos || identifierName != null && originalMapping.column === column)) identifierName = originalMapping.name;
+			else if (identifierNamePos) {
+				const originalIdentifierMapping = originalPositionFor(this._inputMap, identifierNamePos);
+				if (originalIdentifierMapping.name) identifierName = originalIdentifierMapping.name;
+			}
+		} else originalMapping = {
+			name: null,
+			source: filename?.replace(/\\/g, "/") || this._sourceFileName,
+			line,
+			column
+		};
+		if (identifierName != null && identifierName === generatedIdentifierName) identifierName = null;
+		maybeAddMapping(this._map, {
+			name: identifierName,
+			generated,
+			source: originalMapping?.source,
+			original: originalMapping
+		});
+	}
+};
+var spaceIndents = [];
+for (let i = 0; i < 32; i++) spaceIndents.push(" ".repeat(i * 2));
+var Buffer$1 = class {
+	constructor(map, indentChar) {
+		this._map = map;
+		this._indentChar = indentChar;
+	}
+	_map = null;
+	_buf = "";
+	_str = "";
+	_appendCount = 0;
+	_last = 0;
+	_canMarkIdName = true;
+	_indentChar = "";
+	_queuedChar = 0;
+	_position = {
+		line: 1,
+		column: 0
+	};
+	_sourcePosition = {
+		identifierName: void 0,
+		identifierNamePos: void 0,
+		line: void 0,
+		column: void 0,
+		filename: void 0
+	};
+	get() {
+		const { _map, _last } = this;
+		if (this._queuedChar !== 32) this._flush();
+		const code = _last === 10 ? (this._buf + this._str).trimRight() : this._buf + this._str;
+		if (_map === null) return {
+			code,
+			decodedMap: void 0,
+			map: null,
+			rawMappings: void 0
+		};
+		const result = {
+			code,
+			decodedMap: _map.getDecoded(),
+			get map() {
+				const resultMap = _map.get();
+				result.map = resultMap;
+				return resultMap;
+			},
+			set map(value) {
+				Object.defineProperty(result, "map", {
+					value,
+					writable: true
+				});
+			},
+			get rawMappings() {
+				const mappings = _map.getRawMappings();
+				result.rawMappings = mappings;
+				return mappings;
+			},
+			set rawMappings(value) {
+				Object.defineProperty(result, "rawMappings", {
+					value,
+					writable: true
+				});
+			}
+		};
+		return result;
+	}
+	append(str, maybeNewline, ignoreMapping = false) {
+		this._flush();
+		this._append(str, maybeNewline, ignoreMapping);
+	}
+	appendChar(char) {
+		this._flush();
+		this._appendChar(char, 1, true);
+	}
+	queue(char) {
+		this._flush();
+		this._queuedChar = char;
+	}
+	_flush() {
+		const queuedChar = this._queuedChar;
+		if (queuedChar !== 0) {
+			this._appendChar(queuedChar, 1, true);
+			this._queuedChar = 0;
+		}
+	}
+	_appendChar(char, repeat, useSourcePos) {
+		this._last = char;
+		if (char === -1) {
+			const indent = repeat >= 64 ? this._indentChar.repeat(repeat) : spaceIndents[repeat / 2];
+			this._str += indent;
+		} else this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
+		const isSpace = char === 32;
+		const position = this._position;
+		if (char !== 10) {
+			if (this._map) {
+				const sourcePos = this._sourcePosition;
+				if (useSourcePos && sourcePos) {
+					this._map.mark(position, null, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
+					if (!isSpace && this._canMarkIdName) {
+						sourcePos.identifierName = void 0;
+						sourcePos.identifierNamePos = void 0;
+					}
+				} else this._map.mark(position, null);
+			}
+			position.column += repeat;
+		} else {
+			position.line++;
+			position.column = 0;
+		}
+	}
+	_append(str, maybeNewline, ignoreMapping) {
+		const len = str.length;
+		const position = this._position;
+		const sourcePos = this._sourcePosition;
+		this._last = -1;
+		if (++this._appendCount > 4096) {
+			+this._str;
+			this._buf += this._str;
+			this._str = str;
+			this._appendCount = 0;
+		} else this._str += str;
+		const hasMap = !ignoreMapping && this._map !== null;
+		if (!maybeNewline && !hasMap) {
+			position.column += len;
+			return;
+		}
+		const { column, identifierName, identifierNamePos, filename } = sourcePos;
+		let line = sourcePos.line;
+		if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) {
+			sourcePos.identifierName = void 0;
+			sourcePos.identifierNamePos = void 0;
+		}
+		let i = str.indexOf("\n");
+		let last = 0;
+		if (hasMap && i !== 0) this._map.mark(position, str, line, column, identifierName, identifierNamePos, filename);
+		while (i !== -1) {
+			position.line++;
+			position.column = 0;
+			last = i + 1;
+			if (last < len && line !== void 0) {
+				line++;
+				if (hasMap) this._map.mark(position, str, line, 0, void 0, void 0, filename);
+			}
+			i = str.indexOf("\n", last);
+		}
+		position.column += len - last;
+	}
+	removeLastSemicolon() {
+		if (this._queuedChar === 59) this._queuedChar = 0;
+	}
+	getLastChar(checkQueue) {
+		if (!checkQueue) return this._last;
+		const queuedChar = this._queuedChar;
+		return queuedChar !== 0 ? queuedChar : this._last;
+	}
+	getNewlineCount() {
+		return this._queuedChar === 0 && this._last === 10 ? 1 : 0;
+	}
+	hasContent() {
+		return this._last !== 0;
+	}
+	exactSource(loc, cb) {
+		if (!this._map) {
+			cb();
+			return;
+		}
+		this.source("start", loc);
+		const identifierName = loc.identifierName;
+		const sourcePos = this._sourcePosition;
+		if (identifierName != null) {
+			this._canMarkIdName = false;
+			sourcePos.identifierName = identifierName;
+		}
+		cb();
+		if (identifierName != null) {
+			this._canMarkIdName = true;
+			sourcePos.identifierName = void 0;
+			sourcePos.identifierNamePos = void 0;
+		}
+		this.source("end", loc);
+	}
+	source(prop, loc) {
+		if (!this._map) return;
+		this._normalizePosition(prop, loc, 0);
+	}
+	sourceWithOffset(prop, loc, columnOffset) {
+		if (!this._map) return;
+		this._normalizePosition(prop, loc, columnOffset);
+	}
+	_normalizePosition(prop, loc, columnOffset) {
+		this._flush();
+		const pos = loc[prop];
+		if (pos) {
+			this.setSourcePosition(pos.line, Math.max(pos.column + columnOffset, 0));
+			this._sourcePosition.filename = loc.filename;
+		}
+	}
+	setSourcePosition(line, column) {
+		const target = this._sourcePosition;
+		target.line = line;
+		target.column = column;
+	}
+	getCurrentColumn() {
+		return this._position.column + (this._queuedChar ? 1 : 0);
+	}
+	getCurrentLine() {
+		return this._position.line;
+	}
+};
+var { isMemberExpression: isMemberExpression$1, isOptionalMemberExpression, isYieldExpression, isStatement: isStatement$4 } = _t;
+var PRECEDENCE = /* @__PURE__ */ new Map([
+	["||", 0],
+	["??", 1],
+	["&&", 2],
+	["|", 3],
+	["^", 4],
+	["&", 5],
+	["==", 6],
+	["===", 6],
+	["!=", 6],
+	["!==", 6],
+	["<", 7],
+	[">", 7],
+	["<=", 7],
+	[">=", 7],
+	["in", 7],
+	["instanceof", 7],
+	[">>", 8],
+	["<<", 8],
+	[">>>", 8],
+	["+", 9],
+	["-", 9],
+	["*", 10],
+	["/", 10],
+	["%", 10],
+	["**", 11]
+]);
+function isTSTypeExpression(nodeId) {
+	return nodeId === 154 || nodeId === 199 || nodeId === 207;
+}
+var isClassExtendsClause = (node, parent, parentId) => {
+	return (parentId === 22 || parentId === 23) && parent.superClass === node;
+};
+var hasPostfixPart = (node, parent, parentId) => {
+	switch (parentId) {
+		case 109:
+		case 133: return parent.object === node;
+		case 18:
+		case 131:
+		case 113: return parent.callee === node;
+		case 220: return parent.tag === node;
+		case 189: return true;
+	}
+	return false;
+};
+function NullableTypeAnnotation$1(node, parent, parentId) {
+	return parentId === 4;
+}
+function FunctionTypeAnnotation$1(node, parent, parentId, tokenContext) {
+	return parentId === 237 || parentId === 91 || parentId === 4 || (tokenContext & 8) > 0;
+}
+function UpdateExpression$1(node, parent, parentId) {
+	return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
+}
+function needsParenBeforeExpressionBrace(tokenContext) {
+	return (tokenContext & 3) > 0;
+}
+function ObjectExpression$1(node, parent, parentId, tokenContext) {
+	return needsParenBeforeExpressionBrace(tokenContext);
+}
+function DoExpression$1(node, parent, parentId, tokenContext) {
+	return (tokenContext & 1) > 0 && !node.async;
+}
+function BinaryLike(node, parent, parentId, nodeType) {
+	if (isClassExtendsClause(node, parent, parentId)) return true;
+	if (hasPostfixPart(node, parent, parentId) || parentId === 236 || parentId === 143 || parentId === 8) return true;
+	let parentPos;
+	switch (parentId) {
+		case 11:
+		case 108:
+			parentPos = PRECEDENCE.get(parent.operator);
+			break;
+		case 154:
+		case 199: parentPos = 7;
+	}
+	if (parentPos !== void 0) {
+		const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
+		if (parentPos > nodePos) return true;
+		if (parentPos === nodePos && parentId === 11 && (nodePos === 11 ? parent.left === node : parent.right === node)) return true;
+		if (nodeType === 1 && parentId === 108 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) return true;
+	}
+	return false;
+}
+function UnionTypeAnnotation$1(node, parent, parentId) {
+	switch (parentId) {
+		case 4:
+		case 116:
+		case 91:
+		case 237: return true;
+	}
+	return false;
+}
+function OptionalIndexedAccessType$1(node, parent, parentId) {
+	return parentId === 85 && parent.objectType === node;
+}
+function TSAsExpression$1(node, parent, parentId) {
+	if ((parentId === 6 || parentId === 7) && parent.left === node) return true;
+	if (parentId === 11 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) return true;
+	return BinaryLike(node, parent, parentId, 2);
+}
+function TSConditionalType$1(node, parent, parentId) {
+	switch (parentId) {
+		case 153:
+		case 193:
+		case 209:
+		case 210:
+		case 179:
+		case 217: return true;
+		case 173: return parent.objectType === node;
+		case 159: return parent.checkType === node || parent.extendsType === node;
+	}
+	return false;
+}
+function TSUnionType$1(node, parent, parentId) {
+	switch (parentId) {
+		case 179:
+		case 209:
+		case 153:
+		case 193: return true;
+		case 173: return parent.objectType === node;
+	}
+	return false;
+}
+function TSIntersectionType$1(node, parent, parentId) {
+	return parentId === 209 || TSTypeOperator$1(node, parent, parentId);
+}
+function TSInferType$1(node, parent, parentId) {
+	if (TSTypeOperator$1(node, parent, parentId)) return true;
+	if ((parentId === 179 || parentId === 217) && node.typeParameter.constraint != null) return true;
+	return false;
+}
+function TSTypeOperator$1(node, parent, parentId) {
+	switch (parentId) {
+		case 153:
+		case 193: return true;
+		case 173: if (parent.objectType === node) return true;
+	}
+	return false;
+}
+function TSInstantiationExpression$1(node, parent, parentId) {
+	switch (parentId) {
+		case 18:
+		case 131:
+		case 113:
+		case 175: return parent.typeArguments != null;
+	}
+	return false;
+}
+function TSFunctionType$1(node, parent, parentId) {
+	if (TSUnionType$1(node, parent, parentId)) return true;
+	return parentId === 217 || parentId === 159 && (parent.checkType === node || parent.extendsType === node);
+}
+function BinaryExpression$1(node, parent, parentId, tokenContext) {
+	if (BinaryLike(node, parent, parentId, 0)) return true;
+	return (tokenContext & 128) > 0 && node.operator === "in";
+}
+function LogicalExpression(node, parent, parentId) {
+	return BinaryLike(node, parent, parentId, 1);
+}
+function SequenceExpression$1(node, parent, parentId) {
+	if (parentId === 142 || parentId === 134 || parentId === 109 && parent.property === node || parentId === 133 && parent.property === node || parentId === 222) return false;
+	if (parentId === 22) return true;
+	if (parentId === 69) return parent.right === node;
+	if (parentId === 61) return true;
+	return !isStatement$4(parent);
+}
+function YieldExpression$1(node, parent, parentId) {
+	return parentId === 11 || parentId === 108 || parentId === 236 || parentId === 143 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 29 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
+}
+function ClassExpression(node, parent, parentId, tokenContext) {
+	return (tokenContext & 5) > 0;
+}
+function UnaryLike(node, parent, parentId) {
+	return hasPostfixPart(node, parent, parentId) || parentId === 11 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
+}
+function FunctionExpression$1(node, parent, parentId, tokenContext) {
+	return (tokenContext & 5) > 0;
+}
+function ConditionalExpression$1(node, parent, parentId) {
+	switch (parentId) {
+		case 236:
+		case 143:
+		case 11:
+		case 108:
+		case 8: return true;
+		case 29: if (parent.test === node) return true;
+	}
+	if (isTSTypeExpression(parentId)) return true;
+	return UnaryLike(node, parent, parentId);
+}
+function OptionalMemberExpression$1(node, parent, parentId) {
+	switch (parentId) {
+		case 18: return parent.callee === node;
+		case 109: return parent.object === node;
+	}
+	return false;
+}
+function AssignmentExpression$1(node, parent, parentId, tokenContext) {
+	if (needsParenBeforeExpressionBrace(tokenContext) && node.left.type === "ObjectPattern") return true;
+	return ConditionalExpression$1(node, parent, parentId);
+}
+function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
+	if (getRawIdentifier && getRawIdentifier(node) !== node.name) return false;
+	if (parentId === 6 && node.extra?.parenthesized && parent.left === node) {
+		const rightType = parent.right.type;
+		if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) return true;
+	}
+	if (tokenContext & 64 || (parentId === 109 || parentId === 133) && tokenContext & 49) {
+		if (node.name === "let") {
+			if ((isMemberExpression$1(parent, {
+				object: node,
+				computed: true
+			}) || isOptionalMemberExpression(parent, {
+				object: node,
+				computed: true,
+				optional: false
+			})) && tokenContext & 49) return true;
+			return (tokenContext & 64) > 0;
+		}
+	}
+	return parentId === 69 && parent.left === node && node.name === "async" && !parent.await;
+}
+var parens = /*#__PURE__*/ Object.defineProperty({
+	__proto__: null,
+	ArrowFunctionExpression: ConditionalExpression$1,
+	AssignmentExpression: AssignmentExpression$1,
+	AwaitExpression: YieldExpression$1,
+	BinaryExpression: BinaryExpression$1,
+	ClassExpression,
+	ConditionalExpression: ConditionalExpression$1,
+	DoExpression: DoExpression$1,
+	FunctionExpression: FunctionExpression$1,
+	FunctionTypeAnnotation: FunctionTypeAnnotation$1,
+	Identifier: Identifier$1,
+	IntersectionTypeAnnotation: UnionTypeAnnotation$1,
+	LogicalExpression,
+	NullableTypeAnnotation: NullableTypeAnnotation$1,
+	ObjectExpression: ObjectExpression$1,
+	OptionalCallExpression: OptionalMemberExpression$1,
+	OptionalIndexedAccessType: OptionalIndexedAccessType$1,
+	OptionalMemberExpression: OptionalMemberExpression$1,
+	SequenceExpression: SequenceExpression$1,
+	SpreadElement: UnaryLike,
+	TSAsExpression: TSAsExpression$1,
+	TSConditionalType: TSConditionalType$1,
+	TSConstructorType: TSFunctionType$1,
+	TSFunctionType: TSFunctionType$1,
+	TSInferType: TSInferType$1,
+	TSInstantiationExpression: TSInstantiationExpression$1,
+	TSIntersectionType: TSIntersectionType$1,
+	TSSatisfiesExpression: TSAsExpression$1,
+	TSTypeAssertion: UnaryLike,
+	TSTypeOperator: TSTypeOperator$1,
+	TSUnionType: TSUnionType$1,
+	UnaryExpression: UnaryLike,
+	UnionTypeAnnotation: UnionTypeAnnotation$1,
+	UpdateExpression: UpdateExpression$1,
+	YieldExpression: YieldExpression$1
+}, Symbol.toStringTag, { value: "Module" });
+function TaggedTemplateExpression(node) {
+	this.print(node.tag);
+	this.print(node.typeArguments);
+	this.print(node.quasi);
+}
+function TemplateElement() {
+	throw new Error("TemplateElement printing is handled in TemplateLiteral");
+}
+function _printTemplate(node, substitutions) {
+	const quasis = node.quasis;
+	let partRaw = "`";
+	for (let i = 0; i < quasis.length - 1; i++) {
+		partRaw += quasis[i].value.raw;
+		this.token(partRaw + "${", true);
+		this.print(substitutions[i]);
+		partRaw = "}";
+	}
+	partRaw += quasis[quasis.length - 1].value.raw;
+	this.token(partRaw + "`", true);
+}
+function TemplateLiteral(node) {
+	_printTemplate.call(this, node, node.expressions);
+}
+var { isCallExpression, isLiteral, isMemberExpression, isNewExpression, isPattern } = _t;
+function UnaryExpression(node) {
+	const { operator } = node;
+	const firstChar = operator.charCodeAt(0);
+	if (firstChar >= 97 && firstChar <= 122) {
+		this.word(operator);
+		this.space();
+	} else this.tokenChar(firstChar);
+	this.print(node.argument);
+}
+function DoExpression(node) {
+	if (node.async) {
+		this.word("async", true);
+		this.space();
+	}
+	this.word("do");
+	this.space();
+	this.print(node.body);
+}
+function ParenthesizedExpression(node) {
+	this.tokenChar(40);
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	this.print(node.expression, void 0, true);
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	this.rightParens(node);
+}
+function UpdateExpression(node) {
+	if (node.prefix) {
+		this.token(node.operator, false, 0, true);
+		this.print(node.argument);
+	} else {
+		this.print(node.argument, true);
+		this.token(node.operator, false, 0, true);
+	}
+}
+function ConditionalExpression(node) {
+	this.print(node.test);
+	this.space();
+	this.tokenChar(63);
+	this.space();
+	this.print(node.consequent);
+	this.space();
+	this.tokenChar(58);
+	this.space();
+	this.print(node.alternate);
+}
+function _printExpressionArguments(node) {
+	this.tokenChar(40);
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	this.printList(node.arguments, this.shouldPrintTrailingComma(")"), void 0, void 0, void 0, true);
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	this.rightParens(node);
+}
+function NewExpression(node, parent) {
+	this.word("new");
+	this.space();
+	this.print(node.callee);
+	if (this.format.minified && node.arguments.length === 0 && !isCallExpression(parent, { callee: node }) && !isMemberExpression(parent) && !isNewExpression(parent)) return;
+	this.print(node.typeArguments);
+	if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ")")) return;
+	_printExpressionArguments.call(this, node);
+}
+function SequenceExpression(node) {
+	this.printList(node.expressions);
+}
+function ThisExpression() {
+	this.word("this");
+}
+function Super() {
+	this.word("super");
+}
+function _shouldPrintDecoratorsBeforeExport(node) {
+	return typeof node.start === "number" && node.start === node.declaration.start;
+}
+function Decorator(node) {
+	this.tokenChar(64);
+	const { expression } = node;
+	this.print(expression);
+	this.newline();
+}
+function OptionalMemberExpression(node) {
+	let { computed } = node;
+	const { optional, property } = node;
+	this.print(node.object);
+	if (!computed && isMemberExpression(property)) throw new TypeError("Got a MemberExpression for MemberExpression property");
+	if (isLiteral(property) && typeof property.value === "number") computed = true;
+	if (optional) this.token("?.");
+	if (computed) {
+		this.tokenChar(91);
+		this.print(property);
+		this.tokenChar(93);
+	} else {
+		if (!optional) this.tokenChar(46);
+		this.print(property);
+	}
+}
+function OptionalCallExpression(node) {
+	this.print(node.callee);
+	if (node.optional) this.token("?.");
+	this.print(node.typeArguments);
+	_printExpressionArguments.call(this, node);
+}
+function CallExpression(node) {
+	this.print(node.callee);
+	this.print(node.typeArguments);
+	_printExpressionArguments.call(this, node);
+}
+function Import() {
+	this.word("import");
+}
+function AwaitExpression(node) {
+	this.word("await");
+	this.space();
+	this.print(node.argument);
+}
+function YieldExpression(node) {
+	if (node.delegate) {
+		this.word("yield", true);
+		this.tokenChar(42);
+		if (node.argument) {
+			this.space();
+			this.print(node.argument);
+		}
+	} else if (node.argument) {
+		this.word("yield", true);
+		this.space();
+		this.print(node.argument);
+	} else this.word("yield");
+}
+function EmptyStatement() {
+	this.semicolon(true);
+}
+function ExpressionStatement(node) {
+	this.tokenContext |= 1;
+	this.print(node.expression);
+	this.semicolon();
+}
+function AssignmentPattern(node) {
+	this.print(node.left);
+	if (node.left.type === "Identifier" || isPattern(node.left)) {
+		if (node.left.optional) this.tokenChar(63);
+		this.print(node.left.typeAnnotation);
+	}
+	this.space();
+	this.tokenChar(61);
+	this.space();
+	this.print(node.right);
+}
+function AssignmentExpression(node) {
+	this.print(node.left);
+	this.space();
+	this.token(node.operator, false, 0, true);
+	this.space();
+	this.print(node.right);
+}
+function BinaryExpression(node) {
+	this.print(node.left);
+	this.space();
+	const { operator } = node;
+	if (operator.charCodeAt(0) === 105) this.word(operator);
+	else {
+		this.token(operator, false, 0, true);
+		this.setLastChar(operator.charCodeAt(operator.length - 1));
+	}
+	this.space();
+	this.print(node.right);
+}
+function BindExpression(node) {
+	this.print(node.object);
+	this.token("::");
+	this.print(node.callee);
+}
+function MemberExpression(node) {
+	this.print(node.object);
+	if (!node.computed && isMemberExpression(node.property)) throw new TypeError("Got a MemberExpression for MemberExpression property");
+	let computed = node.computed;
+	if (isLiteral(node.property) && typeof node.property.value === "number") computed = true;
+	if (computed) {
+		const oldNoLineTerminatorAfterNode = this.enterDelimited();
+		this.tokenChar(91);
+		this.print(node.property, void 0, true);
+		this.tokenChar(93);
+		this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	} else {
+		this.tokenChar(46);
+		this.print(node.property);
+	}
+}
+function MetaProperty(node) {
+	this.print(node.meta);
+	this.tokenChar(46);
+	this.print(node.property);
+}
+function PrivateName(node) {
+	this.tokenChar(35);
+	this.print(node.id);
+}
+function V8IntrinsicIdentifier(node) {
+	this.tokenChar(37);
+	this.word(node.name);
+}
+function ModuleExpression(node) {
+	this.word("module", true);
+	this.space();
+	this.tokenChar(123);
+	this.indent();
+	const { body } = node;
+	if (body.body.length || body.directives.length) this.newline();
+	this.print(body);
+	this.dedent();
+	this.rightBrace(node);
+}
+var { isFor, isIfStatement, isStatement: isStatement$3, isVoidPattern } = _t;
+function WithStatement(node) {
+	this.word("with");
+	this.space();
+	this.tokenChar(40);
+	this.print(node.object);
+	this.tokenChar(41);
+	this.printBlock(node.body);
+}
+function IfStatement(node) {
+	this.word("if");
+	this.space();
+	this.tokenChar(40);
+	this.print(node.test);
+	this.tokenChar(41);
+	this.space();
+	const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent));
+	if (needsBlock) {
+		this.tokenChar(123);
+		this.newline();
+		this.indent();
+	}
+	this.printAndIndentOnComments(node.consequent);
+	if (needsBlock) {
+		this.dedent();
+		this.newline();
+		this.tokenChar(125);
+	}
+	if (node.alternate) {
+		if (this.endsWith(125)) this.space();
+		this.word("else");
+		this.space();
+		this.printAndIndentOnComments(node.alternate);
+	}
+}
+function getLastStatement(statement) {
+	const { body } = statement;
+	if (isStatement$3(body) === false) return statement;
+	return getLastStatement(body);
+}
+function ForStatement(node) {
+	this.word("for");
+	this.space();
+	this.tokenChar(40);
+	this.tokenContext |= 144;
+	this.print(node.init);
+	this.tokenContext = 0;
+	this.tokenChar(59);
+	if (node.test) {
+		this.space();
+		this.print(node.test);
+	}
+	this.tokenChar(59, 1);
+	if (node.update) {
+		this.space();
+		this.print(node.update);
+	}
+	this.tokenChar(41);
+	this.printBlock(node.body);
+}
+function WhileStatement(node) {
+	this.word("while");
+	this.space();
+	this.tokenChar(40);
+	this.print(node.test);
+	this.tokenChar(41);
+	this.printBlock(node.body);
+}
+function ForInStatement(node) {
+	this.word("for");
+	this.space();
+	this.noIndentInnerCommentsHere();
+	this.tokenChar(40);
+	this.tokenContext |= 160;
+	this.print(node.left);
+	this.tokenContext = 0;
+	this.space();
+	this.word("in");
+	this.space();
+	this.print(node.right);
+	this.tokenChar(41);
+	this.printBlock(node.body);
+}
+function ForOfStatement(node) {
+	this.word("for");
+	this.space();
+	if (node.await) {
+		this.word("await");
+		this.space();
+	}
+	this.noIndentInnerCommentsHere();
+	this.tokenChar(40);
+	this.tokenContext |= 64;
+	this.print(node.left);
+	this.space();
+	this.word("of");
+	this.space();
+	this.print(node.right);
+	this.tokenChar(41);
+	this.printBlock(node.body);
+}
+function DoWhileStatement(node) {
+	this.word("do");
+	this.space();
+	this.print(node.body);
+	this.space();
+	this.word("while");
+	this.space();
+	this.tokenChar(40);
+	this.print(node.test);
+	this.tokenChar(41);
+	this.semicolon();
+}
+function printStatementAfterKeyword(printer, node) {
+	if (node) {
+		printer.space();
+		printer.printTerminatorless(node);
+	}
+	printer.semicolon();
+}
+function BreakStatement(node) {
+	this.word("break");
+	printStatementAfterKeyword(this, node.label);
+}
+function ContinueStatement(node) {
+	this.word("continue");
+	printStatementAfterKeyword(this, node.label);
+}
+function ReturnStatement(node) {
+	this.word("return");
+	printStatementAfterKeyword(this, node.argument);
+}
+function ThrowStatement(node) {
+	this.word("throw");
+	printStatementAfterKeyword(this, node.argument);
+}
+function LabeledStatement(node) {
+	this.print(node.label);
+	this.tokenChar(58);
+	this.space();
+	this.print(node.body);
+}
+function TryStatement(node) {
+	this.word("try");
+	this.space();
+	this.print(node.block);
+	this.space();
+	if (node.handlers) this.print(node.handlers[0]);
+	else this.print(node.handler);
+	if (node.finalizer) {
+		this.space();
+		this.word("finally");
+		this.space();
+		this.print(node.finalizer);
+	}
+}
+function CatchClause(node) {
+	this.word("catch");
+	this.space();
+	if (node.param) {
+		this.tokenChar(40);
+		this.print(node.param);
+		this.print(node.param.typeAnnotation);
+		this.tokenChar(41);
+		this.space();
+	}
+	this.print(node.body);
+}
+function SwitchStatement(node) {
+	this.word("switch");
+	this.space();
+	this.tokenChar(40);
+	this.print(node.discriminant);
+	this.tokenChar(41);
+	this.space();
+	this.tokenChar(123);
+	this.printSequence(node.cases, true);
+	this.rightBrace(node);
+}
+function SwitchCase(node) {
+	if (node.test) {
+		this.word("case");
+		this.space();
+		this.print(node.test);
+		this.tokenChar(58);
+	} else {
+		this.word("default");
+		this.tokenChar(58);
+	}
+	if (node.consequent.length) {
+		this.newline();
+		this.printSequence(node.consequent, true);
+	}
+}
+function DebuggerStatement() {
+	this.word("debugger");
+	this.semicolon();
+}
+function commaSeparatorWithNewline(occurrenceCount) {
+	this.tokenChar(44, occurrenceCount);
+	this.newline();
+}
+function VariableDeclaration(node, parent) {
+	if (node.declare) {
+		this.word("declare");
+		this.space();
+	}
+	const { kind } = node;
+	switch (kind) {
+		case "await using":
+			this.word("await");
+			this.space();
+		case "using":
+			this.word("using", true);
+			break;
+		default: this.word(kind);
+	}
+	this.space();
+	let hasInits = false;
+	if (!isFor(parent)) {
+		for (const declar of node.declarations) if (declar.init) {
+			hasInits = true;
+			break;
+		}
+	}
+	this.printList(node.declarations, void 0, void 0, node.declarations.length > 1, hasInits ? commaSeparatorWithNewline : void 0);
+	if (parent != null) switch (parent.type) {
+		case "ForStatement":
+			if (parent.init === node) return;
+			break;
+		case "ForInStatement":
+		case "ForOfStatement": if (parent.left === node) return;
+	}
+	this.semicolon();
+}
+function VariableDeclarator(node) {
+	this.print(node.id);
+	if (node.definite) this.tokenChar(33);
+	if (!isVoidPattern(node.id)) this.print(node.id.typeAnnotation);
+	if (node.init) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.init);
+	}
+}
+var { isIdentifier: isIdentifier$1 } = _t;
+function _params(node, noLineTerminator, idNode, parentNode) {
+	this.print(node.typeParameters);
+	if (idNode !== void 0 || parentNode !== void 0) {
+		const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
+		if (nameInfo) this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
+	}
+	this.tokenChar(40);
+	_parameters.call(this, node.params, 41);
+	this.print(node.returnType, noLineTerminator);
+	this._noLineTerminator = noLineTerminator;
+}
+function _parameters(parameters, endToken) {
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	const trailingComma = this.shouldPrintTrailingComma(endToken);
+	const paramLength = parameters.length;
+	for (let i = 0; i < paramLength; i++) {
+		_param.call(this, parameters[i]);
+		if (trailingComma || i < paramLength - 1) {
+			this.tokenChar(44, i);
+			this.space();
+		}
+	}
+	this.tokenChar(endToken);
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+}
+function _param(parameter) {
+	this.printJoin(parameter.decorators, void 0, void 0, void 0, void 0, true);
+	this.print(parameter, void 0, true);
+	if (parameter.optional) this.tokenChar(63);
+	this.print(parameter.typeAnnotation, void 0, true);
+}
+function _methodHead(node) {
+	const kind = node.kind;
+	const key = node.key;
+	if (kind === "get" || kind === "set") {
+		this.word(kind);
+		this.space();
+	}
+	if (node.async) {
+		this.word("async", true);
+		this.space();
+	}
+	if (kind === "method" || kind === "init") {
+		if (node.generator) this.tokenChar(42);
+	}
+	if (node.computed) {
+		this.tokenChar(91);
+		this.print(key);
+		this.tokenChar(93);
+	} else this.print(key);
+	if (node.optional) this.tokenChar(63);
+	if (this._buf._map) _params.call(this, node, false, node.computed && node.key.type !== "StringLiteral" ? void 0 : node.key);
+	else _params.call(this, node, false);
+}
+function _predicate(node, noLineTerminatorAfter) {
+	if (node.predicate) {
+		if (!node.returnType) this.tokenChar(58);
+		this.space();
+		this.print(node.predicate, noLineTerminatorAfter);
+	}
+}
+function _functionHead(node, parent, hasPredicate) {
+	if (node.async) {
+		this.word("async");
+		if (!this.format.preserveFormat) this._innerCommentsState = 0;
+		this.space();
+	}
+	this.word("function");
+	if (node.generator) {
+		if (!this.format.preserveFormat) this._innerCommentsState = 0;
+		this.tokenChar(42);
+	}
+	this.space();
+	if (node.id) this.print(node.id);
+	if (this._buf._map) _params.call(this, node, false, node.id, parent);
+	else _params.call(this, node, false);
+	if (hasPredicate) _predicate.call(this, node);
+}
+function FunctionExpression(node, parent) {
+	_functionHead.call(this, node, parent, true);
+	this.space();
+	this.print(node.body);
+}
+function ArrowFunctionExpression(node, parent) {
+	if (node.async) {
+		this.word("async", true);
+		this.space();
+	}
+	if (_shouldPrintArrowParamsParens.call(this, node)) _params.call(this, node, true, void 0, this._buf._map ? parent : void 0);
+	else this.print(node.params[0], true);
+	_predicate.call(this, node, true);
+	this.space();
+	this.printInnerComments();
+	this.token("=>");
+	this.space();
+	this.tokenContext |= 2;
+	this.print(node.body);
+}
+function _shouldPrintArrowParamsParens(node) {
+	if (node.params.length !== 1) return true;
+	if (node.typeParameters || node.returnType || node.predicate) return true;
+	const firstParam = node.params[0];
+	if (!isIdentifier$1(firstParam) || firstParam.typeAnnotation || firstParam.optional || firstParam.leadingComments?.length || firstParam.trailingComments?.length) return true;
+	if (this.tokenMap) {
+		if (node.loc == null) return true;
+		if (this.tokenMap.findMatching(node, "(") !== null) return true;
+		const arrowToken = this.tokenMap.findMatching(node, "=>");
+		if (arrowToken?.loc == null) return true;
+		return arrowToken.loc.start.line !== node.loc.start.line;
+	}
+	if (this.format.retainLines) return true;
+	return false;
+}
+function isRenamedIdentifier(id) {
+	return !!id.loc?.identifierName && id.loc.identifierName !== id.name;
+}
+function _getFuncIdName(idNode, parent) {
+	let id = idNode;
+	if (!id && parent) {
+		const parentType = parent.type;
+		if (parentType === "VariableDeclarator") id = parent.id;
+		else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") id = parent.left;
+		else if (parentType === "ObjectProperty" || parentType === "ClassProperty") {
+			if (!parent.computed || parent.key.type === "StringLiteral") id = parent.key;
+		} else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") id = parent.key;
+	}
+	if (!id?.loc) return;
+	let nameInfo;
+	if (id.type === "Identifier") {
+		if (!isRenamedIdentifier(id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: id.loc.identifierName
+		};
+	} else if (id.type === "PrivateName") {
+		if (!isRenamedIdentifier(id.id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: "#" + id.id.loc.identifierName
+		};
+	} else if (id.type === "StringLiteral") nameInfo = {
+		pos: id.loc.start,
+		name: id.value
+	};
+	return nameInfo;
+}
+function TSTypeAnnotation(node, parent) {
+	this.token((parent.type === "TSFunctionType" || parent.type === "TSConstructorType") && parent.returnType === node ? "=>" : ":");
+	this.space();
+	if (node.optional) this.tokenChar(63);
+	this.print(node.typeAnnotation);
+}
+function TSTypeParameterInstantiation(node, parent) {
+	this.tokenChar(60);
+	let printTrailingSeparator = parent.type === "ArrowFunctionExpression" && node.params.length === 1;
+	if (this.tokenMap && node.start != null && node.end != null) {
+		printTrailingSeparator &&= !!this.tokenMap.find(node, (t) => this.tokenMap.matchesOriginal(t, ","));
+		printTrailingSeparator ||= this.shouldPrintTrailingComma(">");
+	}
+	this.printList(node.params, printTrailingSeparator);
+	this.tokenChar(62);
+}
+function TSTypeParameter(node) {
+	if (node.const) {
+		this.word("const");
+		this.space();
+	}
+	if (node.in) {
+		this.word("in");
+		this.space();
+	}
+	if (node.out) {
+		this.word("out");
+		this.space();
+	}
+	this.word(node.name.name);
+	if (node.constraint) {
+		this.space();
+		this.word("extends");
+		this.space();
+		this.print(node.constraint);
+	}
+	if (node.default) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.default);
+	}
+}
+function TSParameterProperty(node) {
+	if (node.accessibility) {
+		this.word(node.accessibility);
+		this.space();
+	}
+	if (node.readonly) {
+		this.word("readonly");
+		this.space();
+	}
+	_param.call(this, node.parameter);
+}
+function TSDeclareFunction(node, parent) {
+	if (node.declare) {
+		this.word("declare");
+		this.space();
+	}
+	_functionHead.call(this, node, parent, false);
+	this.semicolon();
+}
+function TSDeclareMethod(node) {
+	_classMethodHead.call(this, node, false);
+	this.semicolon();
+}
+function TSQualifiedName(node) {
+	this.print(node.left);
+	this.tokenChar(46);
+	this.print(node.right);
+}
+function TSCallSignatureDeclaration(node) {
+	tsPrintSignatureDeclarationBase.call(this, node);
+	maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function maybePrintTrailingCommaOrSemicolon(printer, node) {
+	if (!printer.tokenMap || !node.start || !node.end) {
+		printer.semicolon();
+		return;
+	}
+	if (printer.tokenMap.endMatches(node, ",")) printer.token(",");
+	else if (printer.tokenMap.endMatches(node, ";")) printer.semicolon();
+}
+function TSConstructSignatureDeclaration(node) {
+	this.word("new");
+	this.space();
+	tsPrintSignatureDeclarationBase.call(this, node);
+	maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSPropertySignature(node) {
+	const { readonly } = node;
+	if (readonly) {
+		this.word("readonly");
+		this.space();
+	}
+	tsPrintPropertyOrMethodName.call(this, node);
+	this.print(node.typeAnnotation);
+	maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function tsPrintPropertyOrMethodName(node) {
+	if (node.computed) this.tokenChar(91);
+	this.print(node.key);
+	if (node.computed) this.tokenChar(93);
+	if (node.optional) this.tokenChar(63);
+}
+function TSMethodSignature(node) {
+	const { kind } = node;
+	if (kind === "set" || kind === "get") {
+		this.word(kind);
+		this.space();
+	}
+	tsPrintPropertyOrMethodName.call(this, node);
+	tsPrintSignatureDeclarationBase.call(this, node);
+	maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSIndexSignature(node) {
+	const { readonly, static: isStatic } = node;
+	if (isStatic) {
+		this.word("static");
+		this.space();
+	}
+	if (readonly) {
+		this.word("readonly");
+		this.space();
+	}
+	this.tokenChar(91);
+	_parameters.call(this, node.parameters, 93);
+	this.print(node.typeAnnotation);
+	maybePrintTrailingCommaOrSemicolon(this, node);
+}
+function TSAnyKeyword() {
+	this.word("any");
+}
+function TSBigIntKeyword() {
+	this.word("bigint");
+}
+function TSUnknownKeyword() {
+	this.word("unknown");
+}
+function TSNumberKeyword() {
+	this.word("number");
+}
+function TSObjectKeyword() {
+	this.word("object");
+}
+function TSBooleanKeyword() {
+	this.word("boolean");
+}
+function TSStringKeyword() {
+	this.word("string");
+}
+function TSSymbolKeyword() {
+	this.word("symbol");
+}
+function TSVoidKeyword() {
+	this.word("void");
+}
+function TSUndefinedKeyword() {
+	this.word("undefined");
+}
+function TSNullKeyword() {
+	this.word("null");
+}
+function TSNeverKeyword() {
+	this.word("never");
+}
+function TSIntrinsicKeyword() {
+	this.word("intrinsic");
+}
+function TSThisType() {
+	this.word("this");
+}
+function TSFunctionType(node) {
+	tsPrintFunctionOrConstructorType.call(this, node);
+}
+function TSConstructorType(node) {
+	if (node.abstract) {
+		this.word("abstract");
+		this.space();
+	}
+	this.word("new");
+	this.space();
+	tsPrintFunctionOrConstructorType.call(this, node);
+}
+function tsPrintFunctionOrConstructorType(node) {
+	const { typeParameters } = node;
+	const parameters = node.params;
+	this.print(typeParameters);
+	this.tokenChar(40);
+	_parameters.call(this, parameters, 41);
+	this.space();
+	const returnType = node.returnType;
+	this.print(returnType);
+}
+function TSTypeReference(node) {
+	const typeArguments = node.typeArguments;
+	this.print(node.typeName, !!typeArguments);
+	this.print(typeArguments);
+}
+function TSTypePredicate(node) {
+	if (node.asserts) {
+		this.word("asserts");
+		this.space();
+	}
+	this.print(node.parameterName);
+	if (node.typeAnnotation) {
+		this.space();
+		this.word("is");
+		this.space();
+		this.print(node.typeAnnotation.typeAnnotation);
+	}
+}
+function TSTypeQuery(node) {
+	this.word("typeof");
+	this.space();
+	this.print(node.exprName);
+	const typeArguments = node.typeArguments;
+	if (typeArguments) this.print(typeArguments);
+}
+function TSTypeLiteral(node) {
+	printBraced(this, node, () => this.printJoin(node.members, true, true, void 0, void 0, true));
+}
+function TSArrayType(node) {
+	this.print(node.elementType, true);
+	this.tokenChar(91);
+	this.tokenChar(93);
+}
+function TSTupleType(node) {
+	this.tokenChar(91);
+	this.printList(node.elementTypes, this.shouldPrintTrailingComma("]"));
+	this.tokenChar(93);
+}
+function TSOptionalType(node) {
+	this.print(node.typeAnnotation);
+	this.tokenChar(63);
+}
+function TSRestType(node) {
+	this.token("...");
+	this.print(node.typeAnnotation);
+}
+function TSNamedTupleMember(node) {
+	this.print(node.label);
+	if (node.optional) this.tokenChar(63);
+	this.tokenChar(58);
+	this.space();
+	this.print(node.elementType);
+}
+function TSUnionType(node) {
+	tsPrintUnionOrIntersectionType(this, node, "|");
+}
+function TSIntersectionType(node) {
+	tsPrintUnionOrIntersectionType(this, node, "&");
+}
+function tsPrintUnionOrIntersectionType(printer, node, sep) {
+	let hasLeadingToken = 0;
+	if (printer.tokenMap?.startMatches(node, sep)) {
+		hasLeadingToken = 1;
+		printer.token(sep);
+	}
+	printer.printJoin(node.types, void 0, void 0, function(i) {
+		this.space();
+		this.token(sep, void 0, i + hasLeadingToken);
+		this.space();
+	});
+}
+function TSConditionalType(node) {
+	this.print(node.checkType);
+	this.space();
+	this.word("extends");
+	this.space();
+	this.print(node.extendsType);
+	this.space();
+	this.tokenChar(63);
+	this.space();
+	this.print(node.trueType);
+	this.space();
+	this.tokenChar(58);
+	this.space();
+	this.print(node.falseType);
+}
+function TSInferType(node) {
+	this.word("infer");
+	this.print(node.typeParameter);
+}
+function TSParenthesizedType(node) {
+	this.tokenChar(40);
+	this.print(node.typeAnnotation);
+	this.tokenChar(41);
+}
+function TSTypeOperator(node) {
+	this.word(node.operator);
+	this.space();
+	this.print(node.typeAnnotation);
+}
+function TSIndexedAccessType(node) {
+	this.print(node.objectType, true);
+	this.tokenChar(91);
+	this.print(node.indexType);
+	this.tokenChar(93);
+}
+function TSMappedType(node) {
+	const { nameType, optional, readonly, typeAnnotation } = node;
+	this.tokenChar(123);
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	this.space();
+	if (readonly) {
+		tokenIfPlusMinus(this, readonly);
+		this.word("readonly");
+		this.space();
+	}
+	this.tokenChar(91);
+	this.word(node.key.name);
+	this.space();
+	this.word("in");
+	this.space();
+	this.print(node.constraint);
+	if (nameType) {
+		this.space();
+		this.word("as");
+		this.space();
+		this.print(nameType, void 0, true);
+	}
+	this.tokenChar(93);
+	if (optional) {
+		tokenIfPlusMinus(this, optional);
+		this.tokenChar(63);
+	}
+	if (typeAnnotation) {
+		this.tokenChar(58);
+		this.space();
+		this.print(typeAnnotation, void 0, true);
+	}
+	this.space();
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	this.tokenChar(125);
+}
+function tokenIfPlusMinus(self, tok) {
+	if (tok !== true) self.token(tok);
+}
+function TSTemplateLiteralType(node) {
+	_printTemplate.call(this, node, node.types);
+}
+function TSLiteralType(node) {
+	this.print(node.literal);
+}
+function TSClassImplements(node) {
+	this.print(node.expression);
+	this.print(node.typeArguments);
+}
+function TSInterfaceDeclaration(node) {
+	const { declare, id, typeParameters, extends: extendz, body } = node;
+	if (declare) {
+		this.word("declare");
+		this.space();
+	}
+	this.word("interface");
+	this.space();
+	this.print(id);
+	this.print(typeParameters);
+	if (extendz?.length) {
+		this.space();
+		this.word("extends");
+		this.space();
+		this.printList(extendz);
+	}
+	this.space();
+	this.print(body);
+}
+function TSInterfaceBody(node) {
+	printBraced(this, node, () => this.printJoin(node.body, true, true, void 0, void 0, true));
+}
+function TSTypeAliasDeclaration(node) {
+	const { declare, id, typeParameters, typeAnnotation } = node;
+	if (declare) {
+		this.word("declare");
+		this.space();
+	}
+	this.word("type");
+	this.space();
+	this.print(id);
+	this.print(typeParameters);
+	this.space();
+	this.tokenChar(61);
+	this.space();
+	this.print(typeAnnotation);
+	this.semicolon();
+}
+function TSAsExpression(node) {
+	const { expression, typeAnnotation } = node;
+	this.print(expression, true);
+	this.space();
+	this.word("as");
+	this.space();
+	this.print(typeAnnotation);
+}
+function TSSatisfiesExpression(node) {
+	const { expression, typeAnnotation } = node;
+	this.print(expression, true);
+	this.space();
+	this.word("satisfies");
+	this.space();
+	this.print(typeAnnotation);
+}
+function TSTypeAssertion(node) {
+	const { typeAnnotation, expression } = node;
+	this.tokenChar(60);
+	this.print(typeAnnotation);
+	this.tokenChar(62);
+	this.space();
+	this.print(expression);
+}
+function TSInstantiationExpression(node) {
+	this.print(node.expression);
+	this.print(node.typeArguments);
+}
+function TSEnumDeclaration(node) {
+	const { declare, const: isConst, id } = node;
+	if (declare) {
+		this.word("declare");
+		this.space();
+	}
+	if (isConst) {
+		this.word("const");
+		this.space();
+	}
+	this.word("enum");
+	this.space();
+	this.print(id);
+	this.space();
+	this.print(node.body);
+}
+function TSEnumBody(node) {
+	printBraced(this, node, () => this.printList(node.members, this.shouldPrintTrailingComma("}") ?? false, true, true, void 0, true));
+}
+function TSEnumMember(node) {
+	const { id, initializer } = node;
+	this.print(id);
+	if (initializer) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(initializer);
+	}
+}
+function TSModuleDeclaration(node) {
+	const { declare, kind } = node;
+	if (declare) {
+		this.word("declare");
+		this.space();
+	}
+	if (kind !== "global") {
+		this.word(kind);
+		this.space();
+	}
+	this.print(node.id);
+	if (!node.body) {
+		this.semicolon();
+		return;
+	}
+	this.space();
+	this.print(node.body);
+}
+function TSModuleBlock(node) {
+	printBraced(this, node, () => this.printSequence(node.body, true, true));
+}
+function TSImportType(node) {
+	const { qualifier, options } = node;
+	this.word("import");
+	this.tokenChar(40);
+	this.print(node.source);
+	if (options) {
+		this.tokenChar(44);
+		this.print(options);
+	}
+	this.tokenChar(41);
+	if (qualifier) {
+		this.tokenChar(46);
+		this.print(qualifier);
+	}
+	const typeArguments = node.typeArguments;
+	if (typeArguments) this.print(typeArguments);
+}
+function TSImportEqualsDeclaration(node) {
+	const { id, moduleReference } = node;
+	this.word("import");
+	this.space();
+	this.print(id);
+	this.space();
+	this.tokenChar(61);
+	this.space();
+	this.print(moduleReference);
+	this.semicolon();
+}
+function TSExternalModuleReference(node) {
+	this.token("require(");
+	this.print(node.expression);
+	this.tokenChar(41);
+}
+function TSNonNullExpression(node) {
+	this.print(node.expression);
+	this.tokenChar(33);
+	this.setLastChar(33);
+}
+function TSExportAssignment(node) {
+	this.word("export");
+	this.space();
+	this.tokenChar(61);
+	this.space();
+	this.print(node.expression);
+	this.semicolon();
+}
+function TSNamespaceExportDeclaration(node) {
+	this.word("export");
+	this.space();
+	this.word("as");
+	this.space();
+	this.word("namespace");
+	this.space();
+	this.print(node.id);
+	this.semicolon();
+}
+function tsPrintSignatureDeclarationBase(node) {
+	const { typeParameters } = node;
+	const parameters = node.params;
+	this.print(typeParameters);
+	this.tokenChar(40);
+	_parameters.call(this, parameters, 41);
+	this.print(node.returnType);
+}
+function _tsPrintClassMemberModifiers(node) {
+	const isPrivateField = node.type === "ClassPrivateProperty";
+	const isPublicField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
+	printModifiersList(this, node, [isPublicField && node.declare && "declare", !isPrivateField && node.accessibility]);
+	if (node.static) {
+		this.word("static");
+		this.space();
+	}
+	printModifiersList(this, node, [
+		!isPrivateField && node.abstract && "abstract",
+		!isPrivateField && node.override && "override",
+		(isPublicField || isPrivateField) && node.readonly && "readonly"
+	]);
+}
+function printBraced(printer, node, cb) {
+	printer.token("{");
+	const oldNoLineTerminatorAfterNode = printer.enterDelimited();
+	cb();
+	printer._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	printer.rightBrace(node);
+}
+function printModifiersList(printer, node, modifiers) {
+	const modifiersSet = /* @__PURE__ */ new Set();
+	for (const modifier of modifiers) if (modifier) modifiersSet.add(modifier);
+	printer.tokenMap?.find(node, (tok) => {
+		if (modifiersSet.has(tok.value)) {
+			printer.token(tok.value);
+			printer.space();
+			modifiersSet.delete(tok.value);
+			return modifiersSet.size === 0;
+		}
+		return false;
+	});
+	for (const modifier of modifiersSet) {
+		printer.word(modifier);
+		printer.space();
+	}
+}
+var { isClassDeclaration, isExportDefaultSpecifier, isExportNamespaceSpecifier, isImportDefaultSpecifier, isImportNamespaceSpecifier, isStatement: isStatement$2 } = _t;
+function ImportSpecifier(node) {
+	if (node.importKind === "type" || node.importKind === "typeof") {
+		this.word(node.importKind);
+		this.space();
+	}
+	this.print(node.imported);
+	if (node.local && node.local.name !== node.imported.name) {
+		this.space();
+		this.word("as");
+		this.space();
+		this.print(node.local);
+	}
+}
+function ImportDefaultSpecifier(node) {
+	this.print(node.local);
+}
+function ExportDefaultSpecifier(node) {
+	this.print(node.exported);
+}
+function ExportSpecifier(node) {
+	if (node.exportKind === "type") {
+		this.word("type");
+		this.space();
+	}
+	this.print(node.local);
+	if (node.exported && node.local.name !== node.exported.name) {
+		this.space();
+		this.word("as");
+		this.space();
+		this.print(node.exported);
+	}
+}
+function ExportNamespaceSpecifier(node) {
+	this.tokenChar(42);
+	this.space();
+	this.word("as");
+	this.space();
+	this.print(node.exported);
+}
+function _printAttributes(node, hasPreviousBrace) {
+	const { attributes } = node;
+	this.word("with");
+	this.space();
+	const occurrenceCount = hasPreviousBrace ? 1 : 0;
+	this.token("{", void 0, occurrenceCount);
+	this.space();
+	this.printList(attributes, this.shouldPrintTrailingComma("}"));
+	this.space();
+	this.token("}", void 0, occurrenceCount);
+}
+function ExportAllDeclaration(node) {
+	this.word("export");
+	this.space();
+	if (node.exportKind === "type") {
+		this.word("type");
+		this.space();
+	}
+	this.tokenChar(42);
+	this.space();
+	this.word("from");
+	this.space();
+	if (node.attributes?.length) {
+		this.print(node.source, true);
+		this.space();
+		_printAttributes.call(this, node, false);
+	} else this.print(node.source);
+	this.semicolon();
+}
+function maybePrintDecoratorsBeforeExport(printer, node) {
+	if (isClassDeclaration(node.declaration) && _shouldPrintDecoratorsBeforeExport.call(printer, node)) printer.printJoin(node.declaration.decorators);
+}
+function ExportNamedDeclaration(node) {
+	maybePrintDecoratorsBeforeExport(this, node);
+	this.word("export");
+	this.space();
+	if (node.declaration) {
+		const declar = node.declaration;
+		this.print(declar);
+		if (!isStatement$2(declar)) this.semicolon();
+	} else {
+		if (node.exportKind === "type") {
+			this.word("type");
+			this.space();
+		}
+		const specifiers = node.specifiers.slice(0);
+		let hasSpecial = false;
+		for (;;) {
+			const first = specifiers[0];
+			if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
+				hasSpecial = true;
+				this.print(specifiers.shift());
+				if (specifiers.length) {
+					this.tokenChar(44);
+					this.space();
+				}
+			} else break;
+		}
+		let hasBrace = false;
+		if (specifiers.length || !specifiers.length && !hasSpecial) {
+			hasBrace = true;
+			this.tokenChar(123);
+			if (specifiers.length) {
+				this.space();
+				this.printList(specifiers, this.shouldPrintTrailingComma("}"));
+				this.space();
+			}
+			this.tokenChar(125);
+		}
+		if (node.source) {
+			this.space();
+			this.word("from");
+			this.space();
+			if (node.attributes?.length) {
+				this.print(node.source, true);
+				this.space();
+				_printAttributes.call(this, node, hasBrace);
+			} else this.print(node.source);
+		}
+		this.semicolon();
+	}
+}
+function ExportDefaultDeclaration(node) {
+	maybePrintDecoratorsBeforeExport(this, node);
+	this.word("export");
+	this.noIndentInnerCommentsHere();
+	this.space();
+	this.word("default");
+	this.space();
+	this.tokenContext |= 4;
+	const declar = node.declaration;
+	this.print(declar);
+	if (!isStatement$2(declar)) this.semicolon();
+}
+function ImportDeclaration(node) {
+	this.word("import");
+	this.space();
+	const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
+	if (isTypeKind) {
+		this.noIndentInnerCommentsHere();
+		this.word(node.importKind);
+		this.space();
+	} else if (node.module) {
+		this.noIndentInnerCommentsHere();
+		this.word("module");
+		this.space();
+	} else if (node.phase) {
+		this.noIndentInnerCommentsHere();
+		this.word(node.phase);
+		this.space();
+	}
+	const specifiers = node.specifiers.slice(0);
+	const hasSpecifiers = !!specifiers.length;
+	while (hasSpecifiers) {
+		const first = specifiers[0];
+		if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
+			this.print(specifiers.shift());
+			if (specifiers.length) {
+				this.tokenChar(44);
+				this.space();
+			}
+		} else break;
+	}
+	let hasBrace = false;
+	if (specifiers.length) {
+		hasBrace = true;
+		this.tokenChar(123);
+		this.space();
+		this.printList(specifiers, this.shouldPrintTrailingComma("}"));
+		this.space();
+		this.tokenChar(125);
+	} else if (isTypeKind && !hasSpecifiers) {
+		hasBrace = true;
+		this.tokenChar(123);
+		this.tokenChar(125);
+	}
+	if (hasSpecifiers || isTypeKind) {
+		this.space();
+		this.word("from");
+		this.space();
+	}
+	if (node.attributes?.length) {
+		this.print(node.source, true);
+		this.space();
+		_printAttributes.call(this, node, hasBrace);
+	} else this.print(node.source);
+	this.semicolon();
+}
+function ImportAttribute(node) {
+	this.print(node.key);
+	this.tokenChar(58);
+	this.space();
+	this.print(node.value);
+}
+function ImportNamespaceSpecifier(node) {
+	this.tokenChar(42);
+	this.space();
+	this.word("as");
+	this.space();
+	this.print(node.local);
+}
+function ImportExpression(node) {
+	this.word("import");
+	if (node.phase) {
+		this.tokenChar(46);
+		this.word(node.phase);
+	}
+	this.tokenChar(40);
+	const shouldPrintTrailingComma = this.shouldPrintTrailingComma(")");
+	this.print(node.source);
+	if (node.options != null) {
+		this.tokenChar(44);
+		this.space();
+		this.print(node.options);
+	}
+	if (shouldPrintTrailingComma) this.tokenChar(44);
+	this.rightParens(node);
+}
+var { isAssignmentPattern, isIdentifier } = _t;
+var lastRawIdentResult = "";
+function _getRawIdentifier(node) {
+	const { name } = node;
+	const token = this.tokenMap.find(node, (tok) => tok.value === name);
+	if (token) {
+		lastRawIdentResult = this._originalCode.slice(token.start, token.end);
+		return lastRawIdentResult;
+	}
+	return lastRawIdentResult = node.name;
+}
+function Identifier(node) {
+	if (this._buf._map && node.loc?.identifierName && node.loc.identifierName !== node.name) this.sourceIdentifierName(node.loc.identifierName);
+	this.word(this.tokenMap ? lastRawIdentResult : node.name);
+}
+function ArgumentPlaceholder() {
+	this.tokenChar(63);
+}
+function RestElement(node) {
+	this.token("...");
+	this.print(node.argument);
+}
+function ObjectExpression(node) {
+	const props = node.properties;
+	this.tokenChar(123);
+	if (props.length) {
+		const oldNoLineTerminatorAfterNode = this.enterDelimited();
+		this.space();
+		this.printList(props, this.shouldPrintTrailingComma("}"), true, true, void 0, true);
+		this.space();
+		this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	}
+	this.rightBrace(node);
+}
+function ObjectMethod(node) {
+	this.printJoin(node.decorators);
+	_methodHead.call(this, node);
+	this.space();
+	this.print(node.body);
+}
+function ObjectProperty(node) {
+	this.printJoin(node.decorators);
+	if (node.computed) {
+		this.tokenChar(91);
+		this.print(node.key);
+		this.tokenChar(93);
+	} else {
+		if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) {
+			this.print(node.value);
+			return;
+		}
+		this.print(node.key);
+		if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) return;
+	}
+	this.tokenChar(58);
+	this.space();
+	this.print(node.value);
+}
+function ArrayExpression(node) {
+	const elems = node.elements;
+	const len = elems.length;
+	this.tokenChar(91);
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	for (let i = 0; i < elems.length; i++) {
+		const elem = elems[i];
+		if (elem) {
+			if (i > 0) this.space();
+			this.print(elem, void 0, true);
+			if (i < len - 1 || this.shouldPrintTrailingComma("]")) this.tokenChar(44, i);
+		} else this.tokenChar(44, i);
+	}
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	this.tokenChar(93);
+}
+function RegExpLiteral(node) {
+	this.word(`/${node.pattern}/${node.flags}`, false);
+}
+function BooleanLiteral(node) {
+	this.word(node.value ? "true" : "false");
+}
+function NullLiteral() {
+	this.word("null");
+}
+function NumericLiteral(node) {
+	const raw = this.getPossibleRaw(node);
+	const opts = this.format.jsescOption;
+	const value = node.value;
+	const str = value + "";
+	if (opts.numbers) this.number((0, import_jsesc.default)(value, opts), value);
+	else if (raw == null) this.number(str, value);
+	else if (this.format.minified) this.number(raw.length < str.length ? raw : str, value);
+	else this.number(raw, value);
+}
+function StringLiteral(node) {
+	const raw = this.getPossibleRaw(node);
+	if (!this.format.minified && raw !== void 0) {
+		this.token(raw);
+		return;
+	}
+	const val = (0, import_jsesc.default)(node.value, this.format.jsescOption);
+	this.token(val);
+}
+function BigIntLiteral(node) {
+	const raw = this.getPossibleRaw(node);
+	if (!this.format.minified && raw !== void 0) {
+		this.word(raw);
+		return;
+	}
+	this.word(node.value + "n");
+}
+var validTopicTokenSet = /* @__PURE__ */ new Set([
+	"^^",
+	"@@",
+	"^",
+	"%",
+	"#"
+]);
+function TopicReference() {
+	const { topicToken } = this.format;
+	if (validTopicTokenSet.has(topicToken)) this.token(topicToken);
+	else {
+		const givenTopicTokenJSON = JSON.stringify(topicToken);
+		const validTopics = Array.from(validTopicTokenSet, (v) => JSON.stringify(v));
+		throw new Error(`The "topicToken" generator option must be one of ${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
+	}
+}
+function VoidPattern() {
+	this.word("void");
+}
+var { isDeclareExportDeclaration, isStatement: isStatement$1 } = _t;
+function AnyTypeAnnotation() {
+	this.word("any");
+}
+function ArrayTypeAnnotation(node) {
+	this.print(node.elementType, true);
+	this.tokenChar(91);
+	this.tokenChar(93);
+}
+function BooleanTypeAnnotation() {
+	this.word("boolean");
+}
+function BooleanLiteralTypeAnnotation(node) {
+	this.word(node.value ? "true" : "false");
+}
+function NullLiteralTypeAnnotation() {
+	this.word("null");
+}
+function DeclareClass(node, parent) {
+	if (!isDeclareExportDeclaration(parent)) {
+		this.word("declare");
+		this.space();
+	}
+	this.word("class");
+	this.space();
+	_interfaceish.call(this, node);
+}
+function DeclareFunction(node, parent) {
+	if (!isDeclareExportDeclaration(parent)) {
+		this.word("declare");
+		this.space();
+	}
+	this.word("function");
+	this.space();
+	this.print(node.id);
+	this.print(node.id.typeAnnotation?.typeAnnotation);
+	if (node.predicate) {
+		this.space();
+		this.print(node.predicate);
+	}
+	this.semicolon();
+}
+function InferredPredicate() {
+	this.tokenChar(37);
+	this.word("checks");
+}
+function DeclaredPredicate(node) {
+	this.tokenChar(37);
+	this.word("checks");
+	this.tokenChar(40);
+	this.print(node.value);
+	this.tokenChar(41);
+}
+function DeclareInterface(node) {
+	this.word("declare");
+	this.space();
+	InterfaceDeclaration.call(this, node);
+}
+function DeclareModule(node) {
+	this.word("declare");
+	this.space();
+	this.word("module");
+	this.space();
+	this.print(node.id);
+	this.space();
+	this.print(node.body);
+}
+function DeclareModuleExports(node) {
+	this.word("declare");
+	this.space();
+	this.word("module");
+	this.tokenChar(46);
+	this.word("exports");
+	this.print(node.typeAnnotation);
+}
+function DeclareTypeAlias(node) {
+	this.word("declare");
+	this.space();
+	TypeAlias.call(this, node);
+}
+function DeclareOpaqueType(node, parent) {
+	if (!isDeclareExportDeclaration(parent)) {
+		this.word("declare");
+		this.space();
+	}
+	OpaqueType.call(this, node);
+}
+function DeclareVariable(node, parent) {
+	if (!isDeclareExportDeclaration(parent)) {
+		this.word("declare");
+		this.space();
+	}
+	this.word("var");
+	this.space();
+	this.print(node.id);
+	this.print(node.id.typeAnnotation);
+	this.semicolon();
+}
+function DeclareExportDeclaration(node) {
+	this.word("declare");
+	this.space();
+	this.word("export");
+	this.space();
+	if (node.default) {
+		this.word("default");
+		this.space();
+	}
+	FlowExportDeclaration.call(this, node);
+}
+function DeclareExportAllDeclaration(node) {
+	this.word("declare");
+	this.space();
+	ExportAllDeclaration.call(this, node);
+}
+function EnumDeclaration(node) {
+	const { id, body } = node;
+	this.word("enum");
+	this.space();
+	this.print(id);
+	this.print(body);
+}
+function enumExplicitType(context, name, hasExplicitType) {
+	if (hasExplicitType) {
+		context.space();
+		context.word("of");
+		context.space();
+		context.word(name);
+	}
+	context.space();
+}
+function enumBody(context, node) {
+	const { members } = node;
+	context.token("{");
+	context.indent();
+	context.newline();
+	for (const member of members) {
+		context.print(member);
+		context.newline();
+	}
+	if (node.hasUnknownMembers) {
+		context.token("...");
+		context.newline();
+	}
+	context.dedent();
+	context.token("}");
+}
+function EnumBooleanBody(node) {
+	const { explicitType } = node;
+	enumExplicitType(this, "boolean", explicitType);
+	enumBody(this, node);
+}
+function EnumNumberBody(node) {
+	const { explicitType } = node;
+	enumExplicitType(this, "number", explicitType);
+	enumBody(this, node);
+}
+function EnumStringBody(node) {
+	const { explicitType } = node;
+	enumExplicitType(this, "string", explicitType);
+	enumBody(this, node);
+}
+function EnumSymbolBody(node) {
+	enumExplicitType(this, "symbol", true);
+	enumBody(this, node);
+}
+function EnumDefaultedMember(node) {
+	const { id } = node;
+	this.print(id);
+	this.tokenChar(44);
+}
+function enumInitializedMember(context, node) {
+	context.print(node.id);
+	context.space();
+	context.token("=");
+	context.space();
+	context.print(node.init);
+	context.token(",");
+}
+function EnumBooleanMember(node) {
+	enumInitializedMember(this, node);
+}
+function EnumNumberMember(node) {
+	enumInitializedMember(this, node);
+}
+function EnumStringMember(node) {
+	enumInitializedMember(this, node);
+}
+function FlowExportDeclaration(node) {
+	if (node.declaration) {
+		const declar = node.declaration;
+		this.print(declar);
+		if (!isStatement$1(declar)) this.semicolon();
+	} else {
+		this.tokenChar(123);
+		if (node.specifiers.length) {
+			this.space();
+			this.printList(node.specifiers);
+			this.space();
+		}
+		this.tokenChar(125);
+		if (node.source) {
+			this.space();
+			this.word("from");
+			this.space();
+			this.print(node.source);
+		}
+		this.semicolon();
+	}
+}
+function ExistsTypeAnnotation() {
+	this.tokenChar(42);
+}
+function FunctionTypeAnnotation(node, parent) {
+	this.print(node.typeParameters);
+	this.tokenChar(40);
+	if (node.this) {
+		this.word("this");
+		this.tokenChar(58);
+		this.space();
+		this.print(node.this.typeAnnotation);
+		if (node.params.length || node.rest) {
+			this.tokenChar(44);
+			this.space();
+		}
+	}
+	this.printList(node.params);
+	if (node.rest) {
+		if (node.params.length) {
+			this.tokenChar(44);
+			this.space();
+		}
+		this.token("...");
+		this.print(node.rest);
+	}
+	this.tokenChar(41);
+	const type = parent?.type;
+	if (type != null && (type === "ObjectTypeCallProperty" || type === "ObjectTypeInternalSlot" || type === "DeclareFunction" || type === "ObjectTypeProperty" && parent.method)) this.tokenChar(58);
+	else {
+		this.space();
+		this.token("=>");
+	}
+	this.space();
+	this.print(node.returnType);
+}
+function FunctionTypeParam(node) {
+	this.print(node.name);
+	if (node.optional) this.tokenChar(63);
+	if (node.name) {
+		this.tokenChar(58);
+		this.space();
+	}
+	this.print(node.typeAnnotation);
+}
+function InterfaceExtends(node) {
+	this.print(node.id);
+	this.print(node.typeParameters, true);
+}
+function _interfaceish(node) {
+	this.print(node.id);
+	this.print(node.typeParameters);
+	if (node.extends?.length) {
+		this.space();
+		this.word("extends");
+		this.space();
+		this.printList(node.extends);
+	}
+	if (node.type === "DeclareClass") {
+		if (node.mixins?.length) {
+			this.space();
+			this.word("mixins");
+			this.space();
+			this.printList(node.mixins);
+		}
+		if (node.implements?.length) {
+			this.space();
+			this.word("implements");
+			this.space();
+			this.printList(node.implements);
+		}
+	}
+	this.space();
+	this.print(node.body);
+}
+function _variance(node) {
+	const kind = node.variance?.kind;
+	if (kind != null) {
+		if (kind === "plus") this.tokenChar(43);
+		else if (kind === "minus") this.tokenChar(45);
+	}
+}
+function InterfaceDeclaration(node) {
+	this.word("interface");
+	this.space();
+	_interfaceish.call(this, node);
+}
+function andSeparator(occurrenceCount) {
+	this.space();
+	this.token("&", false, occurrenceCount);
+	this.space();
+}
+function InterfaceTypeAnnotation(node) {
+	this.word("interface");
+	if (node.extends?.length) {
+		this.space();
+		this.word("extends");
+		this.space();
+		this.printList(node.extends);
+	}
+	this.space();
+	this.print(node.body);
+}
+function IntersectionTypeAnnotation(node) {
+	this.printJoin(node.types, void 0, void 0, andSeparator);
+}
+function MixedTypeAnnotation() {
+	this.word("mixed");
+}
+function EmptyTypeAnnotation() {
+	this.word("empty");
+}
+function NullableTypeAnnotation(node) {
+	this.tokenChar(63);
+	this.print(node.typeAnnotation);
+}
+function NumberTypeAnnotation() {
+	this.word("number");
+}
+function StringTypeAnnotation() {
+	this.word("string");
+}
+function ThisTypeAnnotation() {
+	this.word("this");
+}
+function TupleTypeAnnotation(node) {
+	this.tokenChar(91);
+	this.printList(node.types);
+	this.tokenChar(93);
+}
+function TypeofTypeAnnotation(node) {
+	this.word("typeof");
+	this.space();
+	this.print(node.argument);
+}
+function TypeAlias(node) {
+	this.word("type");
+	this.space();
+	this.print(node.id);
+	this.print(node.typeParameters);
+	this.space();
+	this.tokenChar(61);
+	this.space();
+	this.print(node.right);
+	this.semicolon();
+}
+function TypeAnnotation(node, parent) {
+	this.tokenChar(58);
+	this.space();
+	if (parent.type === "ArrowFunctionExpression") this.tokenContext |= 8;
+	else if (node.optional) this.tokenChar(63);
+	this.print(node.typeAnnotation);
+}
+function TypeParameterInstantiation(node) {
+	this.tokenChar(60);
+	this.printList(node.params);
+	this.tokenChar(62);
+}
+function TypeParameter(node) {
+	_variance.call(this, node);
+	this.word(node.name);
+	if (node.bound) this.print(node.bound);
+	if (node.default) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.default);
+	}
+}
+function OpaqueType(node) {
+	this.word("opaque");
+	this.space();
+	this.word("type");
+	this.space();
+	this.print(node.id);
+	this.print(node.typeParameters);
+	if (node.supertype) {
+		this.tokenChar(58);
+		this.space();
+		this.print(node.supertype);
+	}
+	if (node.impltype) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.impltype);
+	}
+	this.semicolon();
+}
+function ObjectTypeAnnotation(node) {
+	if (node.exact) this.token("{|");
+	else this.tokenChar(123);
+	const props = [
+		...node.properties,
+		...node.callProperties || [],
+		...node.indexers || [],
+		...node.internalSlots || []
+	];
+	if (props.length) {
+		this.newline();
+		this.space();
+		this.printJoin(props, true, true, () => {
+			if (props.length !== 1 || node.inexact) {
+				this.tokenChar(44);
+				this.space();
+			}
+		}, true);
+		this.space();
+	}
+	if (node.inexact) {
+		this.indent();
+		this.token("...");
+		if (props.length) this.newline();
+		this.dedent();
+	}
+	if (node.exact) this.token("|}");
+	else this.tokenChar(125);
+}
+function ObjectTypeInternalSlot(node) {
+	if (node.static) {
+		this.word("static");
+		this.space();
+	}
+	this.tokenChar(91);
+	this.tokenChar(91);
+	this.print(node.id);
+	this.tokenChar(93);
+	this.tokenChar(93);
+	if (node.optional) this.tokenChar(63);
+	if (!node.method) {
+		this.tokenChar(58);
+		this.space();
+	}
+	this.print(node.value);
+}
+function ObjectTypeCallProperty(node) {
+	if (node.static) {
+		this.word("static");
+		this.space();
+	}
+	this.print(node.value);
+}
+function ObjectTypeIndexer(node) {
+	if (node.static) {
+		this.word("static");
+		this.space();
+	}
+	_variance.call(this, node);
+	this.tokenChar(91);
+	if (node.id) {
+		this.print(node.id);
+		this.tokenChar(58);
+		this.space();
+	}
+	this.print(node.key);
+	this.tokenChar(93);
+	this.tokenChar(58);
+	this.space();
+	this.print(node.value);
+}
+function ObjectTypeProperty(node) {
+	if (node.proto) {
+		this.word("proto");
+		this.space();
+	}
+	if (node.static) {
+		this.word("static");
+		this.space();
+	}
+	if (node.kind === "get" || node.kind === "set") {
+		this.word(node.kind);
+		this.space();
+	}
+	_variance.call(this, node);
+	this.print(node.key);
+	if (node.optional) this.tokenChar(63);
+	if (!node.method) {
+		this.tokenChar(58);
+		this.space();
+	}
+	this.print(node.value);
+}
+function ObjectTypeSpreadProperty(node) {
+	this.token("...");
+	this.print(node.argument);
+}
+function QualifiedTypeIdentifier(node) {
+	this.print(node.qualification);
+	this.tokenChar(46);
+	this.print(node.id);
+}
+function SymbolTypeAnnotation() {
+	this.word("symbol");
+}
+function orSeparator(occurrenceCount) {
+	this.space();
+	this.token("|", false, occurrenceCount);
+	this.space();
+}
+function UnionTypeAnnotation(node) {
+	this.printJoin(node.types, void 0, void 0, orSeparator);
+}
+function TypeCastExpression(node) {
+	this.tokenChar(40);
+	this.print(node.expression);
+	this.print(node.typeAnnotation);
+	this.tokenChar(41);
+}
+function Variance(node) {
+	if (node.kind === "plus") this.tokenChar(43);
+	else this.tokenChar(45);
+}
+function VoidTypeAnnotation() {
+	this.word("void");
+}
+function IndexedAccessType(node) {
+	this.print(node.objectType, true);
+	this.tokenChar(91);
+	this.print(node.indexType);
+	this.tokenChar(93);
+}
+function OptionalIndexedAccessType(node) {
+	this.print(node.objectType);
+	if (node.optional) this.token("?.");
+	this.tokenChar(91);
+	this.print(node.indexType);
+	this.tokenChar(93);
+}
+var { isExportDefaultDeclaration, isExportNamedDeclaration } = _t;
+function ClassDeclaration(node, parent) {
+	if (!(isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent)) || !_shouldPrintDecoratorsBeforeExport.call(this, parent)) this.printJoin(node.decorators);
+	if (node.declare) {
+		this.word("declare");
+		this.space();
+	}
+	if (node.abstract) {
+		this.word("abstract");
+		this.space();
+	}
+	this.word("class");
+	if (node.id) {
+		this.space();
+		this.print(node.id);
+	}
+	this.print(node.typeParameters);
+	if (node.superClass) {
+		this.space();
+		this.word("extends");
+		this.space();
+		this.print(node.superClass);
+		this.print(node.superTypeArguments);
+	}
+	if (node.implements) {
+		this.space();
+		this.word("implements");
+		this.space();
+		this.printList(node.implements);
+	}
+	this.space();
+	this.print(node.body);
+}
+function ClassBody(node) {
+	this.tokenChar(123);
+	if (node.body.length === 0) this.tokenChar(125);
+	else {
+		const separator = classBodyEmptySemicolonsPrinter(this, node);
+		separator?.(-1);
+		const oldNoLineTerminatorAfterNode = this.enterDelimited();
+		this.printJoin(node.body, true, true, separator, true, true);
+		this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+		if (!this.endsWith(10)) this.newline();
+		this.rightBrace(node);
+	}
+}
+function classBodyEmptySemicolonsPrinter(printer, node) {
+	if (!printer.tokenMap || node.start == null || node.end == null) return null;
+	const indexes = printer.tokenMap.getIndexes(node);
+	if (!indexes) return null;
+	let k = 1;
+	let occurrenceCount = 0;
+	let nextLocIndex = 0;
+	const advanceNextLocIndex = () => {
+		while (nextLocIndex < node.body.length && node.body[nextLocIndex].start == null) nextLocIndex++;
+	};
+	advanceNextLocIndex();
+	return (i) => {
+		if (nextLocIndex <= i) {
+			nextLocIndex = i + 1;
+			advanceNextLocIndex();
+		}
+		const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start;
+		let tok;
+		while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) {
+			printer.tokenChar(59, occurrenceCount++);
+			k++;
+		}
+	};
+}
+function ClassProperty(node) {
+	this.printJoin(node.decorators);
+	if (!node.static && !this.format.preserveFormat) {
+		const endLine = node.key.loc?.end?.line;
+		if (endLine) this.catchUp(endLine);
+	}
+	_tsPrintClassMemberModifiers.call(this, node);
+	if (node.computed) {
+		this.tokenChar(91);
+		this.print(node.key);
+		this.tokenChar(93);
+	} else {
+		_variance.call(this, node);
+		this.print(node.key);
+	}
+	if (node.optional) this.tokenChar(63);
+	if (node.definite) this.tokenChar(33);
+	this.print(node.typeAnnotation);
+	if (node.value) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.value);
+	}
+	this.semicolon();
+}
+function ClassAccessorProperty(node) {
+	this.printJoin(node.decorators);
+	const endLine = node.key.loc?.end?.line;
+	if (endLine) this.catchUp(endLine);
+	_tsPrintClassMemberModifiers.call(this, node);
+	this.word("accessor", true);
+	this.space();
+	if (node.computed) {
+		this.tokenChar(91);
+		this.print(node.key);
+		this.tokenChar(93);
+	} else {
+		_variance.call(this, node);
+		this.print(node.key);
+	}
+	if (node.optional) this.tokenChar(63);
+	if (node.definite) this.tokenChar(33);
+	this.print(node.typeAnnotation);
+	if (node.value) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.value);
+	}
+	this.semicolon();
+}
+function ClassPrivateProperty(node) {
+	this.printJoin(node.decorators);
+	_tsPrintClassMemberModifiers.call(this, node);
+	this.print(node.key);
+	if (node.optional) this.tokenChar(63);
+	if (node.definite) this.tokenChar(33);
+	this.print(node.typeAnnotation);
+	if (node.value) {
+		this.space();
+		this.tokenChar(61);
+		this.space();
+		this.print(node.value);
+	}
+	this.semicolon();
+}
+function ClassMethod(node) {
+	_classMethodHead.call(this, node);
+	this.space();
+	this.print(node.body);
+}
+function ClassPrivateMethod(node) {
+	_classMethodHead.call(this, node);
+	this.space();
+	this.print(node.body);
+}
+function _classMethodHead(node, allowDecorators = true) {
+	if (allowDecorators) this.printJoin(node.decorators);
+	if (!this.format.preserveFormat) {
+		const endLine = node.key.loc?.end?.line;
+		if (endLine) this.catchUp(endLine);
+	}
+	_tsPrintClassMemberModifiers.call(this, node);
+	_methodHead.call(this, node);
+}
+function StaticBlock(node) {
+	this.word("static");
+	this.space();
+	this.tokenChar(123);
+	if (node.body.length === 0) this.tokenChar(125);
+	else {
+		this.newline();
+		this.printSequence(node.body, true);
+		this.rightBrace(node);
+	}
+}
+function File(node) {
+	if (node.program) this.print(node.program.interpreter);
+	this.print(node.program);
+}
+function Program(node) {
+	this.printInnerComments(false);
+	const directivesLen = node.directives?.length;
+	if (directivesLen) {
+		const newline = node.body.length ? 2 : 1;
+		this.printSequence(node.directives, void 0, void 0, newline);
+		if (!node.directives[directivesLen - 1].trailingComments?.length) this.newline(newline);
+	}
+	this.printSequence(node.body);
+}
+function BlockStatement(node) {
+	this.tokenChar(123);
+	const oldNoLineTerminatorAfterNode = this.enterDelimited();
+	const directivesLen = node.directives?.length;
+	if (directivesLen) {
+		const newline = node.body.length ? 2 : 1;
+		this.printSequence(node.directives, true, true, newline);
+		if (!node.directives[directivesLen - 1].trailingComments?.length) this.newline(newline);
+	}
+	this.printSequence(node.body, true, true);
+	this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+	this.rightBrace(node);
+}
+function Directive(node) {
+	this.print(node.value);
+	this.semicolon();
+}
+var unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
+var unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
+function DirectiveLiteral(node) {
+	const raw = this.getPossibleRaw(node);
+	if (!this.format.minified && raw !== void 0) {
+		this.token(raw);
+		return;
+	}
+	const { value } = node;
+	if (!unescapedDoubleQuoteRE.test(value)) this.token(`"${value}"`);
+	else if (!unescapedSingleQuoteRE.test(value)) this.token(`'${value}'`);
+	else throw new Error("Malformed AST: it is not possible to print a directive containing both unescaped single and double quotes.");
+}
+function InterpreterDirective(node) {
+	this.token(`#!${node.value}`);
+	this._newline();
+}
+function Placeholder(node) {
+	this.token("%%");
+	this.print(node.name);
+	this.token("%%");
+	if (node.expectedNode === "Statement") this.semicolon();
+}
+function JSXAttribute(node) {
+	this.print(node.name);
+	if (node.value) {
+		this.tokenChar(61);
+		this.print(node.value);
+	}
+}
+function JSXIdentifier(node) {
+	this.word(node.name);
+}
+function JSXNamespacedName(node) {
+	this.print(node.namespace);
+	this.tokenChar(58);
+	this.print(node.name);
+}
+function JSXMemberExpression(node) {
+	this.print(node.object);
+	this.tokenChar(46);
+	this.print(node.property);
+}
+function JSXSpreadAttribute(node) {
+	this.tokenChar(123);
+	this.token("...");
+	this.print(node.argument);
+	this.rightBrace(node);
+}
+function JSXExpressionContainer(node) {
+	this.tokenChar(123);
+	this.print(node.expression);
+	this.rightBrace(node);
+}
+function JSXSpreadChild(node) {
+	this.tokenChar(123);
+	this.token("...");
+	this.print(node.expression);
+	this.rightBrace(node);
+}
+function JSXText(node) {
+	const raw = this.getPossibleRaw(node);
+	if (raw !== void 0) this.token(raw, true);
+	else this.token(node.value, true);
+}
+function JSXElement(node) {
+	const open = node.openingElement;
+	this.print(open);
+	if (open.selfClosing) return;
+	this.indent();
+	for (const child of node.children) this.print(child);
+	this.dedent();
+	this.print(node.closingElement);
+}
+function spaceSeparator() {
+	this.space();
+}
+function JSXOpeningElement(node) {
+	this.tokenChar(60);
+	this.print(node.name);
+	this.print(node.typeArguments);
+	if (node.attributes.length > 0) {
+		this.space();
+		this.printJoin(node.attributes, void 0, void 0, spaceSeparator);
+	}
+	if (node.selfClosing) {
+		this.space();
+		this.tokenChar(47);
+	}
+	this.tokenChar(62);
+}
+function JSXClosingElement(node) {
+	this.tokenChar(60);
+	this.tokenChar(47);
+	this.print(node.name);
+	this.tokenChar(62);
+}
+function JSXEmptyExpression() {
+	this.printInnerComments();
+}
+function JSXFragment(node) {
+	this.print(node.openingFragment);
+	this.indent();
+	for (const child of node.children) this.print(child);
+	this.dedent();
+	this.print(node.closingFragment);
+}
+function JSXOpeningFragment() {
+	this.tokenChar(60);
+	this.tokenChar(62);
+}
+function JSXClosingFragment() {
+	this.token("</");
+	this.tokenChar(62);
+}
+var generatorFunctions = /*#__PURE__*/ Object.defineProperty({
+	__proto__: null,
+	AnyTypeAnnotation,
+	ArgumentPlaceholder,
+	ArrayExpression,
+	ArrayPattern: ArrayExpression,
+	ArrayTypeAnnotation,
+	ArrowFunctionExpression,
+	AssignmentExpression,
+	AssignmentPattern,
+	AwaitExpression,
+	BigIntLiteral,
+	BigIntLiteralTypeAnnotation: BigIntLiteral,
+	BinaryExpression,
+	BindExpression,
+	BlockStatement,
+	BooleanLiteral,
+	BooleanLiteralTypeAnnotation,
+	BooleanTypeAnnotation,
+	BreakStatement,
+	CallExpression,
+	CatchClause,
+	ClassAccessorProperty,
+	ClassBody,
+	ClassDeclaration,
+	ClassExpression: ClassDeclaration,
+	ClassImplements: InterfaceExtends,
+	ClassMethod,
+	ClassPrivateMethod,
+	ClassPrivateProperty,
+	ClassProperty,
+	ConditionalExpression,
+	ContinueStatement,
+	DebuggerStatement,
+	DeclareClass,
+	DeclareExportAllDeclaration,
+	DeclareExportDeclaration,
+	DeclareFunction,
+	DeclareInterface,
+	DeclareModule,
+	DeclareModuleExports,
+	DeclareOpaqueType,
+	DeclareTypeAlias,
+	DeclareVariable,
+	DeclaredPredicate,
+	Decorator,
+	Directive,
+	DirectiveLiteral,
+	DoExpression,
+	DoWhileStatement,
+	EmptyStatement,
+	EmptyTypeAnnotation,
+	EnumBooleanBody,
+	EnumBooleanMember,
+	EnumDeclaration,
+	EnumDefaultedMember,
+	EnumNumberBody,
+	EnumNumberMember,
+	EnumStringBody,
+	EnumStringMember,
+	EnumSymbolBody,
+	ExistsTypeAnnotation,
+	ExportAllDeclaration,
+	ExportDefaultDeclaration,
+	ExportDefaultSpecifier,
+	ExportNamedDeclaration,
+	ExportNamespaceSpecifier,
+	ExportSpecifier,
+	ExpressionStatement,
+	File,
+	ForInStatement,
+	ForOfStatement,
+	ForStatement,
+	FunctionDeclaration: FunctionExpression,
+	FunctionExpression,
+	FunctionTypeAnnotation,
+	FunctionTypeParam,
+	GenericTypeAnnotation: InterfaceExtends,
+	Identifier,
+	IfStatement,
+	Import,
+	ImportAttribute,
+	ImportDeclaration,
+	ImportDefaultSpecifier,
+	ImportExpression,
+	ImportNamespaceSpecifier,
+	ImportSpecifier,
+	IndexedAccessType,
+	InferredPredicate,
+	InterfaceDeclaration,
+	InterfaceExtends,
+	InterfaceTypeAnnotation,
+	InterpreterDirective,
+	IntersectionTypeAnnotation,
+	JSXAttribute,
+	JSXClosingElement,
+	JSXClosingFragment,
+	JSXElement,
+	JSXEmptyExpression,
+	JSXExpressionContainer,
+	JSXFragment,
+	JSXIdentifier,
+	JSXMemberExpression,
+	JSXNamespacedName,
+	JSXOpeningElement,
+	JSXOpeningFragment,
+	JSXSpreadAttribute,
+	JSXSpreadChild,
+	JSXText,
+	LabeledStatement,
+	LogicalExpression: AssignmentExpression,
+	MemberExpression,
+	MetaProperty,
+	MixedTypeAnnotation,
+	ModuleExpression,
+	NewExpression,
+	NullLiteral,
+	NullLiteralTypeAnnotation,
+	NullableTypeAnnotation,
+	NumberLiteralTypeAnnotation: NumericLiteral,
+	NumberTypeAnnotation,
+	NumericLiteral,
+	ObjectExpression,
+	ObjectMethod,
+	ObjectPattern: ObjectExpression,
+	ObjectProperty,
+	ObjectTypeAnnotation,
+	ObjectTypeCallProperty,
+	ObjectTypeIndexer,
+	ObjectTypeInternalSlot,
+	ObjectTypeProperty,
+	ObjectTypeSpreadProperty,
+	OpaqueType,
+	OptionalCallExpression,
+	OptionalIndexedAccessType,
+	OptionalMemberExpression,
+	ParenthesizedExpression,
+	Placeholder,
+	PrivateName,
+	Program,
+	QualifiedTypeIdentifier,
+	RegExpLiteral,
+	RestElement,
+	ReturnStatement,
+	SequenceExpression,
+	SpreadElement: RestElement,
+	StaticBlock,
+	StringLiteral,
+	StringLiteralTypeAnnotation: StringLiteral,
+	StringTypeAnnotation,
+	Super,
+	SwitchCase,
+	SwitchStatement,
+	SymbolTypeAnnotation,
+	TSAnyKeyword,
+	TSArrayType,
+	TSAsExpression,
+	TSBigIntKeyword,
+	TSBooleanKeyword,
+	TSCallSignatureDeclaration,
+	TSClassImplements,
+	TSConditionalType,
+	TSConstructSignatureDeclaration,
+	TSConstructorType,
+	TSDeclareFunction,
+	TSDeclareMethod,
+	TSEnumBody,
+	TSEnumDeclaration,
+	TSEnumMember,
+	TSExportAssignment,
+	TSExternalModuleReference,
+	TSFunctionType,
+	TSImportEqualsDeclaration,
+	TSImportType,
+	TSIndexSignature,
+	TSIndexedAccessType,
+	TSInferType,
+	TSInstantiationExpression,
+	TSInterfaceBody,
+	TSInterfaceDeclaration,
+	TSInterfaceHeritage: TSClassImplements,
+	TSIntersectionType,
+	TSIntrinsicKeyword,
+	TSLiteralType,
+	TSMappedType,
+	TSMethodSignature,
+	TSModuleBlock,
+	TSModuleDeclaration,
+	TSNamedTupleMember,
+	TSNamespaceExportDeclaration,
+	TSNeverKeyword,
+	TSNonNullExpression,
+	TSNullKeyword,
+	TSNumberKeyword,
+	TSObjectKeyword,
+	TSOptionalType,
+	TSParameterProperty,
+	TSParenthesizedType,
+	TSPropertySignature,
+	TSQualifiedName,
+	TSRestType,
+	TSSatisfiesExpression,
+	TSStringKeyword,
+	TSSymbolKeyword,
+	TSTemplateLiteralType,
+	TSThisType,
+	TSTupleType,
+	TSTypeAliasDeclaration,
+	TSTypeAnnotation,
+	TSTypeAssertion,
+	TSTypeLiteral,
+	TSTypeOperator,
+	TSTypeParameter,
+	TSTypeParameterDeclaration: TSTypeParameterInstantiation,
+	TSTypeParameterInstantiation,
+	TSTypePredicate,
+	TSTypeQuery,
+	TSTypeReference,
+	TSUndefinedKeyword,
+	TSUnionType,
+	TSUnknownKeyword,
+	TSVoidKeyword,
+	TaggedTemplateExpression,
+	TemplateElement,
+	TemplateLiteral,
+	ThisExpression,
+	ThisTypeAnnotation,
+	ThrowStatement,
+	TopicReference,
+	TryStatement,
+	TupleTypeAnnotation,
+	TypeAlias,
+	TypeAnnotation,
+	TypeCastExpression,
+	TypeParameter,
+	TypeParameterDeclaration: TypeParameterInstantiation,
+	TypeParameterInstantiation,
+	TypeofTypeAnnotation,
+	UnaryExpression,
+	UnionTypeAnnotation,
+	UpdateExpression,
+	V8IntrinsicIdentifier,
+	VariableDeclaration,
+	VariableDeclarator,
+	Variance,
+	VoidPattern,
+	VoidTypeAnnotation,
+	WhileStatement,
+	WithStatement,
+	YieldExpression,
+	_classMethodHead,
+	_functionHead,
+	_getRawIdentifier,
+	_interfaceish,
+	_methodHead,
+	_param,
+	_parameters,
+	_params,
+	_predicate,
+	_printAttributes,
+	_printTemplate,
+	_shouldPrintArrowParamsParens,
+	_shouldPrintDecoratorsBeforeExport,
+	_tsPrintClassMemberModifiers,
+	_variance
+}, Symbol.toStringTag, { value: "Module" });
+var generatorInfosMap = /* @__PURE__ */ new Map();
+var index = 0;
+for (const key of Object.keys(generatorFunctions).sort()) {
+	if (key.startsWith("_")) continue;
+	generatorInfosMap.set(key, [
+		generatorFunctions[key],
+		index++,
+		void 0
+	]);
+}
+var { VISITOR_KEYS: VISITOR_KEYS$1 } = _t;
+for (const type of Object.keys(parens)) {
+	const func = parens[type];
+	if (generatorInfosMap.has(type)) generatorInfosMap.get(type)[2] = func;
+}
+function newCalleeNeedsParens(node) {
+	let current = node;
+	while (true) switch (current.type) {
+		case "CallExpression":
+		case "ImportExpression":
+		case "OptionalCallExpression":
+		case "OptionalMemberExpression": return true;
+		case "MemberExpression":
+			current = current.object;
+			break;
+		case "TaggedTemplateExpression":
+			current = current.tag;
+			break;
+		case "TSNonNullExpression":
+			current = current.expression;
+			break;
+		default: return false;
+	}
+}
+function parentNeedsParens(node, parent, parentId) {
+	switch (parentId) {
+		case 113:
+			if (parent.callee === node) return newCalleeNeedsParens(node);
+			break;
+		case 43: return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
+	}
+	return false;
+}
+function isDecoratorMemberExpression(node) {
+	switch (node.type) {
+		case "Identifier": return true;
+		case "MemberExpression": return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
+		default: return false;
+	}
+}
+function isLastChild(parent, child) {
+	const visitorKeys = VISITOR_KEYS$1[parent.type];
+	for (let i = visitorKeys.length - 1; i >= 0; i--) {
+		const val = parent[visitorKeys[i]];
+		if (val === child) return true;
+		else if (Array.isArray(val)) {
+			let j = val.length - 1;
+			while (j >= 0 && val[j] === null) j--;
+			return j >= 0 && val[j] === child;
+		} else if (val) return false;
+	}
+	return false;
+}
+var { traverseFast, VISITOR_KEYS } = _t;
+var TokenMap = class {
+	_tokens;
+	_source;
+	_nodesToTokenIndexes = /* @__PURE__ */ new Map();
+	_nodesOccurrencesCountCache = /* @__PURE__ */ new Map();
+	_tokensCache = /* @__PURE__ */ new Map();
+	constructor(ast, tokens, source) {
+		this._tokens = tokens;
+		this._source = source;
+		traverseFast(ast, (node) => {
+			const indexes = this._getTokensIndexesOfNode(node);
+			if (indexes.length > 0) this._nodesToTokenIndexes.set(node, indexes);
+		});
+		this._tokensCache.clear();
+	}
+	has(node) {
+		return this._nodesToTokenIndexes.has(node);
+	}
+	getIndexes(node) {
+		return this._nodesToTokenIndexes.get(node);
+	}
+	find(node, condition) {
+		const indexes = this._nodesToTokenIndexes.get(node);
+		if (indexes) for (let k = 0; k < indexes.length; k++) {
+			const index = indexes[k];
+			const tok = this._tokens[index];
+			if (condition(tok, index)) return tok;
+		}
+		return null;
+	}
+	findLastIndex(node, condition) {
+		const indexes = this._nodesToTokenIndexes.get(node);
+		if (indexes) for (let k = indexes.length - 1; k >= 0; k--) {
+			const index = indexes[k];
+			const tok = this._tokens[index];
+			if (condition(tok, index)) return index;
+		}
+		return -1;
+	}
+	findMatching(node, test, occurrenceCount = 0) {
+		const indexes = this._nodesToTokenIndexes.get(node);
+		if (indexes) {
+			if (typeof test === "number") test = String.fromCharCode(test);
+			let i = 0;
+			const count = occurrenceCount;
+			if (count > 1) {
+				const cache = this._nodesOccurrencesCountCache.get(node);
+				if (cache?.test === test && cache.count < count) {
+					i = cache.i + 1;
+					occurrenceCount -= cache.count + 1;
+				}
+			}
+			for (; i < indexes.length; i++) {
+				const tok = this._tokens[indexes[i]];
+				if (this.matchesOriginal(tok, test)) {
+					if (occurrenceCount === 0) {
+						if (count > 0) this._nodesOccurrencesCountCache.set(node, {
+							test,
+							count,
+							i
+						});
+						return tok;
+					}
+					occurrenceCount--;
+				}
+			}
+		}
+		return null;
+	}
+	matchesOriginal(token, test) {
+		if (token.end - token.start !== test.length) return false;
+		if (token.value != null) return token.value === test;
+		return this._source.startsWith(test, token.start);
+	}
+	startMatches(node, test) {
+		const indexes = this._nodesToTokenIndexes.get(node);
+		if (!indexes) return false;
+		const tok = this._tokens[indexes[0]];
+		if (tok.start !== node.start) return false;
+		return this.matchesOriginal(tok, test);
+	}
+	endMatches(node, test) {
+		const indexes = this._nodesToTokenIndexes.get(node);
+		if (!indexes) return false;
+		const tok = this._tokens[indexes[indexes.length - 1]];
+		if (tok.end !== node.end) return false;
+		return this.matchesOriginal(tok, test);
+	}
+	_getTokensIndexesOfNode(node) {
+		if (node.start == null || node.end == null) return [];
+		const { first, last } = this._findTokensOfNode(node, 0, this._tokens.length - 1);
+		let low = first;
+		const children = childrenIterator(node);
+		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && node.declaration?.type === "ClassDeclaration") children.next();
+		const indexes = [];
+		for (const child of children) {
+			if (child == null) continue;
+			if (child.start == null || child.end == null) continue;
+			const childTok = this._findTokensOfNode(child, low, last);
+			const high = childTok.first;
+			for (let k = low; k < high; k++) indexes.push(k);
+			low = childTok.last + 1;
+		}
+		for (let k = low; k <= last; k++) indexes.push(k);
+		return indexes;
+	}
+	_findTokensOfNode(node, low, high) {
+		const cached = this._tokensCache.get(node);
+		if (cached) return cached;
+		const first = this._findFirstTokenOfNode(node.start, low, high);
+		const last = this._findLastTokenOfNode(node.end, first, high);
+		this._tokensCache.set(node, {
+			first,
+			last
+		});
+		return {
+			first,
+			last
+		};
+	}
+	_findFirstTokenOfNode(start, low, high) {
+		while (low <= high) {
+			const mid = high + low >> 1;
+			if (start < this._tokens[mid].start) high = mid - 1;
+			else if (start > this._tokens[mid].start) low = mid + 1;
+			else return mid;
+		}
+		return low;
+	}
+	_findLastTokenOfNode(end, low, high) {
+		while (low <= high) {
+			const mid = high + low >> 1;
+			if (end < this._tokens[mid].end) high = mid - 1;
+			else if (end > this._tokens[mid].end) low = mid + 1;
+			else return mid;
+		}
+		return high;
+	}
+};
+function* childrenIterator(node) {
+	if (node.type === "TemplateLiteral") {
+		yield node.quasis[0];
+		for (let i = 1; i < node.quasis.length; i++) {
+			yield node.expressions[i - 1];
+			yield node.quasis[i];
+		}
+		return;
+	}
+	const keys = VISITOR_KEYS[node.type];
+	for (const key of keys) {
+		const child = node[key];
+		if (!child) continue;
+		if (Array.isArray(child)) yield* child;
+		else yield child;
+	}
+}
+var { isExpression, isFunction, isStatement, isClassBody, isTSInterfaceBody, isTSEnumMember } = _t;
+var SCIENTIFIC_NOTATION = /e/i;
+var ZERO_DECIMAL_INTEGER = /\.0+$/;
+var HAS_NEWLINE = /[\n\r\u2028\u2029]/;
+var HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
+function commentIsNewline(c) {
+	return c.type === "CommentLine" || HAS_NEWLINE.test(c.value);
+}
+var Printer = class {
+	constructor(format, map, tokens = null, originalCode = null) {
+		this.format = format;
+		this._tokens = tokens;
+		this._originalCode = originalCode;
+		this._indentRepeat = format.indent.style.length;
+		this._inputMap = map?._inputMap || null;
+		this._buf = new Buffer$1(map, format.indent.style[0]);
+		const { preserveFormat, compact, concise, retainLines, retainFunctionParens } = format;
+		if (preserveFormat) this._flags |= 1;
+		if (compact) this._flags |= 2;
+		if (concise) this._flags |= 4;
+		if (retainLines) this._flags |= 8;
+		if (retainFunctionParens) this._flags |= 16;
+		if (format.auxiliaryCommentBefore || format.auxiliaryCommentAfter) this._flags |= 32;
+	}
+	enterDelimited() {
+		const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+		if (oldNoLineTerminatorAfterNode !== null) this._noLineTerminatorAfterNode = null;
+		return oldNoLineTerminatorAfterNode;
+	}
+	tokenContext = 0;
+	_tokens = null;
+	_originalCode = null;
+	_currentNode = null;
+	_currentTypeId = null;
+	_indent = 0;
+	_indentRepeat = 0;
+	_insideAux = false;
+	_noLineTerminator = false;
+	_noLineTerminatorAfterNode = null;
+	_printAuxAfterOnNextUserNode = false;
+	_printedComments = /* @__PURE__ */ new Set();
+	_lastCommentLine = 0;
+	_innerCommentsState = 0;
+	_flags = 0;
+	tokenMap = null;
+	_boundGetRawIdentifier = null;
+	generate(ast) {
+		if (this.format.preserveFormat) {
+			this.tokenMap = new TokenMap(ast, this._tokens, this._originalCode);
+			this._boundGetRawIdentifier = _getRawIdentifier.bind(this);
+		}
+		this.print(ast);
+		this._maybeAddAuxComment();
+		return this._buf.get();
+	}
+	indent(flags = this._flags) {
+		if (flags & 7) return;
+		this._indent += this._indentRepeat;
+	}
+	dedent(flags = this._flags) {
+		if (flags & 7) return;
+		this._indent -= this._indentRepeat;
+	}
+	_printSemicolonBeforeNextNode = -1;
+	_printSemicolonBeforeNextToken = -1;
+	semicolon(force = false) {
+		const flags = this._flags;
+		if (flags & 32) this._maybeAddAuxComment();
+		if (flags & 1) {
+			const node = this._currentNode;
+			if (node.start != null && node.end != null) {
+				if (!this.tokenMap.endMatches(node, ";")) {
+					this._printSemicolonBeforeNextNode = this._buf.getCurrentLine();
+					return;
+				}
+				const indexes = this.tokenMap.getIndexes(this._currentNode);
+				this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);
+			}
+		}
+		if (force) this._appendChar(59);
+		else this._queue(59);
+		this._noLineTerminator = false;
+	}
+	rightBrace(node) {
+		if (this.format.minified) this._buf.removeLastSemicolon();
+		this.sourceWithOffset("end", node.loc, -1);
+		this.tokenChar(125);
+	}
+	rightParens(node) {
+		this.sourceWithOffset("end", node.loc, -1);
+		this.tokenChar(41);
+	}
+	space(force = false) {
+		if (this._flags & 3) return;
+		if (force) this._space();
+		else {
+			const lastCp = this.getLastChar(true);
+			if (lastCp !== 0 && lastCp !== 32 && lastCp !== 10) this._space();
+		}
+	}
+	word(str, noLineTerminatorAfter = false) {
+		this.tokenContext &= 128;
+		this._maybePrintInnerComments(str);
+		const flags = this._flags;
+		if (flags & 32) this._maybeAddAuxComment();
+		if (flags & 1) this._catchUpToCurrentToken(str);
+		const lastChar = this.getLastChar();
+		if (lastChar === -2 || lastChar === -3 || lastChar === 47 && str.charCodeAt(0) === 47) this._space();
+		this._append(str, false);
+		this.setLastChar(-3);
+		this._noLineTerminator = noLineTerminatorAfter;
+	}
+	number(str, number) {
+		function isNonDecimalLiteral(str) {
+			if (str.length > 2 && str.charCodeAt(0) === 48) {
+				const secondChar = str.charCodeAt(1);
+				return secondChar === 98 || secondChar === 111 || secondChar === 120;
+			}
+			return false;
+		}
+		this.word(str);
+		if (Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46) this.setLastChar(-2);
+	}
+	token(str, maybeNewline = false, occurrenceCount = 0, mayNeedSpace = false) {
+		this.tokenContext &= 128;
+		this._maybePrintInnerComments(str, occurrenceCount);
+		const flags = this._flags;
+		if (flags & 32) this._maybeAddAuxComment();
+		if (flags & 1) this._catchUpToCurrentToken(str, occurrenceCount);
+		if (mayNeedSpace) {
+			const strFirst = str.charCodeAt(0);
+			if ((strFirst === 45 && str === "--" || strFirst === 61) && this.getLastChar() === 33 || strFirst === 43 && this.getLastChar() === 43 || strFirst === 45 && this.getLastChar() === 45 || strFirst === 46 && this.getLastChar() === -2) this._space();
+		}
+		this._append(str, maybeNewline);
+		this._noLineTerminator = false;
+	}
+	tokenChar(char, occurrenceCount = 0) {
+		this.tokenContext &= 128;
+		this._maybePrintInnerComments(char, occurrenceCount);
+		const flags = this._flags;
+		if (flags & 32) this._maybeAddAuxComment();
+		if (flags & 1) this._catchUpToCurrentToken(char, occurrenceCount);
+		if (char === 43 && this.getLastChar() === 43 || char === 45 && this.getLastChar() === 45 || char === 46 && this.getLastChar() === -2) this._space();
+		this._appendChar(char);
+		this._noLineTerminator = false;
+	}
+	newline(i = 1, flags = this._flags) {
+		if (i <= 0) return;
+		if (flags & 10) return;
+		if (flags & 4) {
+			this.space();
+			return;
+		}
+		if (i > 2) i = 2;
+		i -= this._buf.getNewlineCount();
+		for (let j = 0; j < i; j++) this._newline();
+	}
+	endsWith(char) {
+		return this.getLastChar(true) === char;
+	}
+	getLastChar(checkQueue) {
+		return this._buf.getLastChar(checkQueue);
+	}
+	setLastChar(char) {
+		this._buf._last = char;
+	}
+	exactSource(loc, cb) {
+		if (!loc) {
+			cb();
+			return;
+		}
+		this._catchUp("start", loc);
+		this._buf.exactSource(loc, cb);
+	}
+	source(prop, loc) {
+		if (!loc) return;
+		this._catchUp(prop, loc);
+		this._buf.source(prop, loc);
+	}
+	sourceWithOffset(prop, loc, columnOffset) {
+		if (!loc || this.format.preserveFormat) return;
+		this._catchUp(prop, loc);
+		this._buf.sourceWithOffset(prop, loc, columnOffset);
+	}
+	sourceIdentifierName(identifierName, pos) {
+		if (!this._buf._canMarkIdName) return;
+		const sourcePosition = this._buf._sourcePosition;
+		sourcePosition.identifierNamePos = pos;
+		sourcePosition.identifierName = identifierName;
+	}
+	_space() {
+		this._queue(32);
+	}
+	_newline() {
+		if (this._buf._queuedChar === 32) this._buf._queuedChar = 0;
+		this._appendChar(10, true);
+	}
+	_catchUpToCurrentToken(str, occurrenceCount = 0) {
+		const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount);
+		if (token) this._catchUpTo(token.loc.start);
+		if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) this._appendChar(59, true);
+		this._printSemicolonBeforeNextToken = -1;
+		this._printSemicolonBeforeNextNode = -1;
+	}
+	_append(str, maybeNewline) {
+		this._maybeIndent();
+		this._buf.append(str, maybeNewline);
+	}
+	_appendChar(char, noIndent) {
+		if (!noIndent) this._maybeIndent();
+		this._buf.appendChar(char);
+	}
+	_queue(char) {
+		this._buf.queue(char);
+		this.setLastChar(-1);
+	}
+	_maybeIndent() {
+		const indent = this._shouldIndent();
+		if (indent > 0) this._buf._appendChar(-1, indent, false);
+	}
+	_shouldIndent() {
+		return this.endsWith(10) ? this._indent : 0;
+	}
+	catchUp(line) {
+		if (!this.format.retainLines) return;
+		const count = line - this._buf.getCurrentLine();
+		for (let i = 0; i < count; i++) this._newline();
+	}
+	_catchUp(prop, loc) {
+		const flags = this._flags;
+		if ((flags & 1) === 0) {
+			if (flags & 8 && loc?.[prop]) this.catchUp(loc[prop].line);
+			return;
+		}
+		const pos = loc?.[prop];
+		if (pos != null) this._catchUpTo(pos);
+	}
+	_catchUpTo({ line, column, index }) {
+		const count = line - this._buf.getCurrentLine();
+		if (count > 0 && this._noLineTerminator) return;
+		for (let i = 0; i < count; i++) this._newline();
+		const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn();
+		if (spacesCount > 0) {
+			const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\v\f\uFEFF\p{Space_Separator}]/gu, " ") : " ".repeat(spacesCount);
+			this._buf.append(spaces, false, true);
+			this._buf.setSourcePosition(line, column);
+			this.setLastChar(32);
+		}
+	}
+	printTerminatorless(node) {
+		this._noLineTerminator = true;
+		this.print(node);
+	}
+	print(node, noLineTerminatorAfter = false, resetTokenContext = false, trailingCommentsLineOffset) {
+		if (!node) return;
+		this._innerCommentsState = 0;
+		const { type, loc, extra } = node;
+		const flags = this._flags;
+		let changedFlags = false;
+		if (node._compact) {
+			this._flags |= 4;
+			changedFlags = true;
+		}
+		const nodeInfo = generatorInfosMap.get(type);
+		if (nodeInfo === void 0) throw new ReferenceError(`unknown node of type ${JSON.stringify(type)} with constructor ${JSON.stringify(node.constructor.name)}`);
+		const [printMethod, nodeId, needsParens] = nodeInfo;
+		const parent = this._currentNode;
+		const parentId = this._currentTypeId;
+		this._currentNode = node;
+		this._currentTypeId = nodeId;
+		if (flags & 1) this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode;
+		let oldInAux;
+		if (flags & 32) {
+			oldInAux = this._insideAux;
+			this._insideAux = loc == null;
+			this._maybeAddAuxComment(this._insideAux && !oldInAux);
+		}
+		let oldTokenContext = 0;
+		if (resetTokenContext) {
+			oldTokenContext = this.tokenContext;
+			if (oldTokenContext & 128) this.tokenContext = 0;
+			else oldTokenContext = 0;
+		}
+		const parenthesized = extra != null && extra.parenthesized;
+		let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 72 || parent && (parentNeedsParens(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : void 0));
+		if (!shouldPrintParens && parenthesized && node.leadingComments?.length && node.leadingComments[0].type === "CommentBlock") switch (parentId) {
+			case 66:
+			case 241:
+			case 6:
+			case 141: break;
+			case 18:
+			case 131:
+			case 113: if (parent.callee !== node) break;
+			default: shouldPrintParens = true;
+		}
+		let indentParenthesized = false;
+		if (!shouldPrintParens && this._noLineTerminator && (node.leadingComments?.some(commentIsNewline) || flags & 8 && loc && loc.start.line > this._buf.getCurrentLine())) {
+			shouldPrintParens = true;
+			indentParenthesized = true;
+		}
+		let oldNoLineTerminatorAfterNode;
+		if (!shouldPrintParens) {
+			noLineTerminatorAfter ||= !!parent && this._noLineTerminatorAfterNode === parent && isLastChild(parent, node);
+			if (noLineTerminatorAfter) if (node.trailingComments?.some(commentIsNewline)) {
+				if (isExpression(node)) shouldPrintParens = true;
+			} else {
+				oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+				this._noLineTerminatorAfterNode = node;
+			}
+		}
+		if (shouldPrintParens) {
+			this.tokenChar(40);
+			if (indentParenthesized) this.indent();
+			this._innerCommentsState = 0;
+			if (!resetTokenContext) oldTokenContext = this.tokenContext;
+			if (oldTokenContext & 128) this.tokenContext = 0;
+			oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
+			this._noLineTerminatorAfterNode = null;
+		}
+		this._printLeadingComments(node, parent);
+		this.exactSource(nodeId === 137 || nodeId === 67 ? null : loc, printMethod.bind(this, node, parent));
+		if (shouldPrintParens) {
+			this._printTrailingComments(node, parent);
+			if (indentParenthesized) {
+				this.dedent();
+				this.newline();
+			}
+			this.tokenChar(41);
+			this._noLineTerminator = noLineTerminatorAfter;
+		} else if (noLineTerminatorAfter && !this._noLineTerminator) {
+			this._noLineTerminator = true;
+			this._printTrailingComments(node, parent);
+		} else this._printTrailingComments(node, parent, trailingCommentsLineOffset);
+		if (oldTokenContext) this.tokenContext = oldTokenContext;
+		this._currentNode = parent;
+		this._currentTypeId = parentId;
+		if (changedFlags) this._flags = flags;
+		if (flags & 32) this._insideAux = oldInAux;
+		if (oldNoLineTerminatorAfterNode != null) this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
+		this._innerCommentsState = 0;
+	}
+	_maybeAddAuxComment(enteredPositionlessNode) {
+		if (enteredPositionlessNode) this._printAuxBeforeComment();
+		if (!this._insideAux) this._printAuxAfterComment();
+	}
+	_printAuxBeforeComment() {
+		if (this._printAuxAfterOnNextUserNode) return;
+		this._printAuxAfterOnNextUserNode = true;
+		const comment = this.format.auxiliaryCommentBefore;
+		if (comment) this._printComment({
+			type: "CommentBlock",
+			value: comment
+		}, 0);
+	}
+	_printAuxAfterComment() {
+		if (!this._printAuxAfterOnNextUserNode) return;
+		this._printAuxAfterOnNextUserNode = false;
+		const comment = this.format.auxiliaryCommentAfter;
+		if (comment) this._printComment({
+			type: "CommentBlock",
+			value: comment
+		}, 0);
+	}
+	getPossibleRaw(node) {
+		const extra = node.extra;
+		if (extra?.raw != null && extra.rawValue != null && node.value === extra.rawValue) return extra.raw;
+	}
+	printJoin(nodes, statement, indent, separator, printTrailingSeparator, resetTokenContext, trailingCommentsLineOffset) {
+		if (!nodes?.length) return;
+		const flags = this._flags;
+		if (indent == null && flags & 8) {
+			const startLine = nodes[0].loc?.start.line;
+			if (startLine != null && startLine !== this._buf.getCurrentLine()) indent = true;
+		}
+		if (indent) this.indent(flags);
+		const len = nodes.length;
+		for (let i = 0; i < len; i++) {
+			const node = nodes[i];
+			if (!node) continue;
+			if (statement && i === 0 && this._buf.hasContent()) this.newline(1, flags);
+			this.print(node, false, resetTokenContext, trailingCommentsLineOffset || 0);
+			if (separator != null) {
+				if (i < len - 1) separator.call(this, i, false);
+				else if (printTrailingSeparator) separator.call(this, i, true);
+			}
+			if (statement) if (i + 1 === len) this.newline(1, flags);
+			else {
+				const lastCommentLine = this._lastCommentLine;
+				if (lastCommentLine > 0) {
+					const offset = (nodes[i + 1].loc?.start.line || 0) - lastCommentLine;
+					if (offset >= 0) {
+						this.newline(offset || 1, flags);
+						continue;
+					}
+				}
+				this.newline(1, flags);
+			}
+		}
+		if (indent) this.dedent(flags);
+	}
+	printAndIndentOnComments(node) {
+		const indent = node.leadingComments && node.leadingComments.length > 0;
+		if (indent) this.indent();
+		this.print(node);
+		if (indent) this.dedent();
+	}
+	printBlock(body) {
+		if (body.type !== "EmptyStatement") this.space();
+		this.print(body);
+	}
+	_printTrailingComments(node, parent, lineOffset) {
+		const { innerComments, trailingComments } = node;
+		if (innerComments?.length) this._printComments(2, innerComments, node, parent, lineOffset);
+		if (trailingComments?.length) this._printComments(2, trailingComments, node, parent, lineOffset);
+		else this._lastCommentLine = 0;
+	}
+	_printLeadingComments(node, parent) {
+		const comments = node.leadingComments;
+		if (!comments?.length) return;
+		this._printComments(0, comments, node, parent);
+	}
+	_maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) {
+		const state = this._innerCommentsState;
+		switch (state & 3) {
+			case 0:
+				this._innerCommentsState = 5;
+				return;
+			case 1: this.printInnerComments((state & 4) > 0, this.tokenMap?.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
+		}
+	}
+	printInnerComments(indent = true, nextToken) {
+		const node = this._currentNode;
+		const comments = node.innerComments;
+		if (!comments?.length) {
+			this._innerCommentsState = 2;
+			return;
+		}
+		const hasSpace = this.endsWith(32);
+		if (indent) this.indent();
+		switch (this._printComments(1, comments, node, void 0, void 0, nextToken)) {
+			case 2: this._innerCommentsState = 2;
+			case 1: if (hasSpace) this.space();
+		}
+		if (indent) this.dedent();
+	}
+	noIndentInnerCommentsHere() {
+		this._innerCommentsState &= -5;
+	}
+	printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
+		this.printJoin(nodes, true, indent ?? false, void 0, void 0, resetTokenContext, trailingCommentsLineOffset);
+	}
+	printList(items, printTrailingSeparator, statement, indent, separator, resetTokenContext) {
+		this.printJoin(items, statement, indent, separator ?? commaSeparator, printTrailingSeparator, resetTokenContext);
+	}
+	shouldPrintTrailingComma(listEnd) {
+		if (!this.tokenMap) return null;
+		const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, (token) => this.tokenMap.matchesOriginal(token, typeof listEnd === "number" ? String.fromCharCode(listEnd) : listEnd));
+		if (listEndIndex <= 0) return null;
+		return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ",");
+	}
+	_shouldPrintComment(comment, nextToken) {
+		if (comment.ignore) return 0;
+		if (this._printedComments.has(comment)) return 0;
+		if (this._noLineTerminator && HAS_NEWLINE_OR_BlOCK_COMMENT_END.test(comment.value)) return 2;
+		if (nextToken && this.tokenMap) {
+			const commentTok = this.tokenMap.find(this._currentNode, (token) => token.value === comment.value);
+			if (commentTok && commentTok.start > nextToken.start) return 2;
+		}
+		this._printedComments.add(comment);
+		if (!this.format.shouldPrintComment(comment.value)) return 0;
+		return 1;
+	}
+	_printComment(comment, skipNewLines) {
+		const noLineTerminator = this._noLineTerminator;
+		const isBlockComment = comment.type === "CommentBlock";
+		const printNewLines = isBlockComment && skipNewLines !== 1 && !noLineTerminator;
+		if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) this.newline(1);
+		switch (this.getLastChar(true)) {
+			case 47: this._space();
+			case 91:
+			case 123:
+			case 40: break;
+			default: this.space();
+		}
+		let val;
+		if (isBlockComment) {
+			val = `/*${comment.value}*/`;
+			if (this.format.indent.adjustMultilineComment) {
+				const offset = comment.loc?.start.column;
+				if (offset) {
+					const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
+					val = val.replace(newlineRegex, "\n");
+				}
+				if (this._flags & 4) val = val.replace(/\n(?!$)/g, `\n`);
+				else {
+					let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
+					if (this._shouldIndent() || this.format.retainLines) indentSize += this._indent;
+					val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
+				}
+			}
+		} else if (!noLineTerminator) val = `//${comment.value}`;
+		else val = `/*${comment.value}*/`;
+		this.source("start", comment.loc);
+		this._append(val, isBlockComment);
+		if (!isBlockComment && !noLineTerminator) this._newline();
+		if (printNewLines && skipNewLines !== 3) this.newline(1);
+	}
+	_printComments(type, comments, node, parent, lineOffset = 0, nextToken) {
+		const nodeLoc = node.loc;
+		const len = comments.length;
+		let hasLoc = !!nodeLoc;
+		const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
+		const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
+		let lastLine = 0;
+		let leadingCommentNewline = 0;
+		const { _noLineTerminator, _flags } = this;
+		for (let i = 0; i < len; i++) {
+			const comment = comments[i];
+			const shouldPrint = this._shouldPrintComment(comment, nextToken);
+			if (shouldPrint === 2) return i === 0 ? 0 : 1;
+			if (hasLoc && comment.loc && shouldPrint === 1) {
+				const commentStartLine = comment.loc.start.line;
+				const commentEndLine = comment.loc.end.line;
+				if (type === 0) {
+					let offset = 0;
+					if (i === 0) {
+						if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine !== commentEndLine)) offset = leadingCommentNewline = 1;
+					} else offset = commentStartLine - lastLine;
+					lastLine = commentEndLine;
+					if (offset > 0 && !_noLineTerminator) this.newline(offset, _flags);
+					this._printComment(comment, 1);
+					if (i + 1 === len) {
+						const count = Math.max(nodeStartLine - lastLine, leadingCommentNewline);
+						if (count > 0 && !_noLineTerminator) this.newline(count, _flags);
+						lastLine = nodeStartLine;
+					}
+				} else if (type === 1) {
+					const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
+					lastLine = commentEndLine;
+					if (offset > 0 && !_noLineTerminator) this.newline(offset, _flags);
+					this._printComment(comment, 1);
+					if (i + 1 === len) {
+						const count = Math.min(1, nodeEndLine - lastLine);
+						if (count > 0 && !_noLineTerminator) this.newline(count, _flags);
+						lastLine = nodeEndLine;
+					}
+				} else {
+					const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
+					lastLine = commentEndLine;
+					if (offset > 0 && !_noLineTerminator) this.newline(offset, _flags);
+					this._printComment(comment, 1);
+				}
+			} else {
+				hasLoc = false;
+				if (shouldPrint !== 1) continue;
+				if (len === 1) {
+					const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
+					const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumMember(node);
+					if (type === 0) this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent) && parent.body === node ? 1 : 0);
+					else if (shouldSkipNewline && type === 2) this._printComment(comment, 1);
+					else this._printComment(comment, 0);
+				} else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody" && node.type !== "TSInterfaceBody") this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0);
+				else this._printComment(comment, 0);
+			}
+		}
+		if (type === 2 && hasLoc && lastLine) this._lastCommentLine = lastLine;
+		return 2;
+	}
+};
+function commaSeparator(occurrenceCount, last) {
+	this.tokenChar(44, occurrenceCount);
+	if (!last) this.space();
+}
+function normalizeOptions(code, opts, ast) {
+	if (opts.experimental_preserveFormat) {
+		if (typeof code !== "string") throw new Error("`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string");
+		if (!opts.retainLines) throw new Error("`experimental_preserveFormat` requires `retainLines` to be set to `true`");
+		if (opts.compact && opts.compact !== "auto") throw new Error("`experimental_preserveFormat` is not compatible with the `compact` option");
+		if (opts.minified) throw new Error("`experimental_preserveFormat` is not compatible with the `minified` option");
+		if (opts.jsescOption) throw new Error("`experimental_preserveFormat` is not compatible with the `jsescOption` option");
+		if (!Array.isArray(ast.tokens)) throw new Error("`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option.");
+	}
+	const format = {
+		auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+		auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+		shouldPrintComment: opts.shouldPrintComment,
+		preserveFormat: opts.experimental_preserveFormat,
+		retainLines: opts.retainLines,
+		retainFunctionParens: opts.retainFunctionParens,
+		comments: opts.comments == null || opts.comments,
+		compact: opts.compact,
+		minified: opts.minified,
+		concise: opts.concise,
+		indent: {
+			adjustMultilineComment: true,
+			style: "  "
+		},
+		jsescOption: {
+			quotes: "double",
+			wrap: true,
+			minimal: true,
+			...opts.jsescOption
+		},
+		topicToken: opts.topicToken
+	};
+	if (format.minified) {
+		format.compact = true;
+		format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
+	} else format.shouldPrintComment = format.shouldPrintComment || ((value) => format.comments || value.includes("@license") || value.includes("@preserve"));
+	if (format.compact === "auto") {
+		format.compact = typeof code === "string" && code.length > 5e5;
+		if (format.compact) console.error(`[BABEL] Note: The code generator has deoptimised the styling of ${opts.filename} as it exceeds the max of 500KB.`);
+	}
+	if (format.compact || format.preserveFormat) format.indent.adjustMultilineComment = false;
+	const { auxiliaryCommentBefore, auxiliaryCommentAfter, shouldPrintComment } = format;
+	if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) format.auxiliaryCommentBefore = void 0;
+	if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) format.auxiliaryCommentAfter = void 0;
+	return format;
+}
+function generate(ast, opts = {}, code) {
+	return new Printer(normalizeOptions(code, opts, ast), opts.sourceMaps ? new SourceMap(opts, code) : null, ast.tokens, typeof code === "string" ? code : null).generate(ast);
+}
+//#endregion
+//#region src/index.ts
+var PREREQUISITE = id(makeIdFiltersToMatchWithQuery(/\.[mc]?[tj]sx?$/));
+var VISITOR = { CallExpression(path, ctx) {
+	for (const macro of ctx.macro) {
+		if (!macro.transform.call(ctx, path, ctx, types)) continue;
+		ctx.changed++;
+		break;
+	}
+} };
+function macroPlugin(opts) {
+	const { filter, macro } = opts;
+	const inner = filter ? and(PREREQUISITE, filter) : PREREQUISITE;
+	return {
+		name: "vite-plugin-simple-macro",
+		transform: {
+			order: "pre",
+			filter: [include(addSpecificFilter(macro, inner))],
+			async handler(code, id, info) {
+				if (!exprInterpreter(inner, code, id, info.moduleType)) return;
+				const filtered = macro.filter(({ filter }) => !filter || exprInterpreter(filter, code, id, info.moduleType));
+				if (!filtered.length) return;
+				const ast = await parseAsync(code, {
+					filename: id,
+					plugins: [["@babel/plugin-syntax-typescript", { isTSX: true }]]
+				});
+				const ctx = {
+					id,
+					macro: filtered,
+					changed: 0,
+					...info
+				};
+				traverse(ast, VISITOR, void 0, ctx);
+				if (!ctx.changed) return;
+				const out = generate(ast, {
+					sourceMaps: true,
+					sourceFileName: id
+				});
+				return {
+					code: out.code,
+					map: out.map
+				};
+			}
+		}
+	};
+}
+function addSpecificFilter(macro, inner) {
+	const out = [];
+	for (const { filter } of macro) if (filter) out.push(filter);
+	else return inner;
+	return and(inner, or(...out));
+}
+//#endregion
+export { macroPlugin as default };