@peter.naydenov/cuts 2.0.2 → 2.0.3

package/test-e2e/node_modules/rolldown/dist/shared/error-w0u7biK-.mjs

@@ -0,0 +1,85 @@
+import { t as require_binding } from "./binding-s-V_wTpj.mjs";
+//#region src/types/sourcemap.ts
+function bindingifySourcemap(map) {
+	if (map == null) return;
+	return { inner: typeof map === "string" ? map : {
+		file: map.file ?? void 0,
+		mappings: map.mappings,
+		sourceRoot: "sourceRoot" in map ? map.sourceRoot ?? void 0 : void 0,
+		sources: map.sources?.map((s) => s ?? void 0),
+		sourcesContent: map.sourcesContent?.map((s) => s ?? void 0),
+		names: map.names,
+		x_google_ignoreList: map.x_google_ignoreList,
+		debugId: "debugId" in map ? map.debugId : void 0
+	} };
+}
+require_binding();
+function unwrapBindingResult(container) {
+	if (typeof container === "object" && container !== null && "isBindingErrors" in container && container.isBindingErrors) throw aggregateBindingErrorsIntoJsError(container.errors);
+	return container;
+}
+function normalizeBindingResult(container) {
+	if (typeof container === "object" && container !== null && "isBindingErrors" in container && container.isBindingErrors) return aggregateBindingErrorsIntoJsError(container.errors);
+	return container;
+}
+function normalizeBindingError(e) {
+	return e.type === "JsError" ? e.field0 : Object.assign(/* @__PURE__ */ new Error(), {
+		code: e.field0.kind,
+		kind: e.field0.kind,
+		message: e.field0.message,
+		id: e.field0.id,
+		exporter: e.field0.exporter,
+		loc: e.field0.loc,
+		pos: e.field0.pos,
+		stack: void 0
+	});
+}
+function aggregateBindingErrorsIntoJsError(rawErrors) {
+	const errors = rawErrors.map(normalizeBindingError);
+	let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
+	for (let i = 0; i < errors.length; i++) {
+		summary += "\n";
+		if (i >= 5) {
+			summary += "...";
+			break;
+		}
+		summary += getErrorMessage(errors[i]);
+	}
+	const wrapper = new Error(summary);
+	Object.defineProperty(wrapper, "errors", {
+		configurable: true,
+		enumerable: true,
+		get: () => errors,
+		set: (value) => Object.defineProperty(wrapper, "errors", {
+			configurable: true,
+			enumerable: true,
+			value
+		})
+	});
+	return wrapper;
+}
+function getErrorMessage(e) {
+	if (Object.hasOwn(e, "kind")) return e.message;
+	let s = "";
+	if (e.plugin) s += `[plugin ${e.plugin}]`;
+	const id = e.id ?? e.loc?.file;
+	if (id) {
+		s += " " + id;
+		if (e.loc) s += `:${e.loc.line}:${e.loc.column}`;
+	}
+	if (s) s += "\n";
+	const message = `${e.name ?? "Error"}: ${e.message}`;
+	s += message;
+	if (e.frame) s = joinNewLine(s, e.frame);
+	if (e.stack) s = joinNewLine(s, e.stack.replace(message, ""));
+	if (e.cause) {
+		s = joinNewLine(s, "Caused by:");
+		s = joinNewLine(s, getErrorMessage(e.cause).split("\n").map((line) => "  " + line).join("\n"));
+	}
+	return s;
+}
+function joinNewLine(s1, s2) {
+	return s1.replace(/\n+$/, "") + "\n" + s2.replace(/^\n+/, "");
+}
+//#endregion
+export { bindingifySourcemap as a, unwrapBindingResult as i, normalizeBindingError as n, normalizeBindingResult as r, aggregateBindingErrorsIntoJsError as t };

package/test-e2e/node_modules/rolldown/dist/shared/get-log-filter-semyr3Lj.d.mts

@@ -0,0 +1,35 @@
+import { a as RolldownLog } from "./logging-C6h4g8dA.mjs";
+
+//#region src/get-log-filter.d.ts
+/**
+* @param filters A list of log filters to apply
+* @returns A function that tests whether a log should be output
+*
+* @category Config
+*/
+type GetLogFilter = (filters: string[]) => (log: RolldownLog) => boolean;
+/**
+* A helper function to generate log filters using the same syntax as the CLI.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'rolldown';
+* import { getLogFilter } from 'rolldown/getLogFilter';
+*
+* const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
+*
+* export default defineConfig({
+* 	input: 'main.js',
+* 	onLog(level, log, handler) {
+* 		if (logFilter(log)) {
+* 			handler(level, log);
+* 		}
+* 	}
+* });
+* ```
+*
+* @category Config
+*/
+declare const getLogFilter: GetLogFilter;
+//#endregion
+export { getLogFilter as n, GetLogFilter as t };

package/test-e2e/node_modules/rolldown/dist/shared/load-config-pmbgQdFU.mjs

@@ -0,0 +1,120 @@
+import { t as rolldown } from "./rolldown-BLMDGLfI.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { cwd } from "node:process";
+import { pathToFileURL } from "node:url";
+//#region src/utils/load-config.ts
+async function bundleTsConfig(configFile, isEsm) {
+	const dirnameVarName = "injected_original_dirname";
+	const filenameVarName = "injected_original_filename";
+	const importMetaUrlVarName = "injected_original_import_meta_url";
+	const bundle = await rolldown({
+		input: configFile,
+		platform: "node",
+		resolve: { mainFields: ["main"] },
+		transform: { define: {
+			__dirname: dirnameVarName,
+			__filename: filenameVarName,
+			"import.meta.url": importMetaUrlVarName,
+			"import.meta.dirname": dirnameVarName,
+			"import.meta.filename": filenameVarName
+		} },
+		treeshake: false,
+		external: [/^[\w@][^:]/],
+		plugins: [{
+			name: "inject-file-scope-variables",
+			transform: {
+				filter: { id: /\.[cm]?[jt]s$/ },
+				async handler(code, id) {
+					return {
+						code: `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};` + code,
+						map: null
+					};
+				}
+			}
+		}]
+	});
+	const outputDir = path.dirname(configFile);
+	const fileName = (await bundle.write({
+		dir: outputDir,
+		format: isEsm ? "esm" : "cjs",
+		sourcemap: "inline",
+		entryFileNames: `rolldown.config.[hash]${path.extname(configFile).replace("ts", "js")}`
+	})).output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName;
+	return path.join(outputDir, fileName);
+}
+const SUPPORTED_JS_CONFIG_FORMATS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+const SUPPORTED_TS_CONFIG_FORMATS = [
+	".ts",
+	".mts",
+	".cts"
+];
+const SUPPORTED_CONFIG_FORMATS = [...SUPPORTED_JS_CONFIG_FORMATS, ...SUPPORTED_TS_CONFIG_FORMATS];
+const DEFAULT_CONFIG_BASE = "rolldown.config";
+async function findConfigFileNameInCwd() {
+	const filesInWorkingDirectory = new Set(await readdir(cwd()));
+	for (const extension of SUPPORTED_CONFIG_FORMATS) {
+		const fileName = `${DEFAULT_CONFIG_BASE}${extension}`;
+		if (filesInWorkingDirectory.has(fileName)) return fileName;
+	}
+	throw new Error("No `rolldown.config` configuration file found.");
+}
+async function loadTsConfig(configFile) {
+	const file = await bundleTsConfig(configFile, isFilePathESM(configFile));
+	try {
+		return (await import(pathToFileURL(file).href)).default;
+	} finally {
+		fs.unlink(file, () => {});
+	}
+}
+function isFilePathESM(filePath) {
+	if (/\.m[jt]s$/.test(filePath)) return true;
+	else if (/\.c[jt]s$/.test(filePath)) return false;
+	else {
+		const pkg = findNearestPackageData(path.dirname(filePath));
+		if (pkg) return pkg.type === "module";
+		return false;
+	}
+}
+function findNearestPackageData(basedir) {
+	while (basedir) {
+		const pkgPath = path.join(basedir, "package.json");
+		if (tryStatSync(pkgPath)?.isFile()) try {
+			return JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		} catch {}
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+function tryStatSync(file) {
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+/**
+* Load config from a file in a way that Rolldown does.
+*
+* @param configPath The path to the config file. If empty, it will look for `rolldown.config` with supported extensions in the current working directory.
+* @returns The loaded config export
+*
+* @category Config
+*/
+async function loadConfig(configPath) {
+	const ext = path.extname(configPath = configPath || await findConfigFileNameInCwd());
+	try {
+		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext) || process.env.NODE_OPTIONS?.includes("--import=tsx") && SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return (await import(pathToFileURL(configPath).href)).default;
+		else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return await loadTsConfig(path.resolve(configPath));
+		else throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(",")}\` but got \`${ext}\``);
+	} catch (err) {
+		throw new Error("Error happened while loading config.", { cause: err });
+	}
+}
+//#endregion
+export { loadConfig as t };

package/test-e2e/node_modules/rolldown/dist/shared/logging-C6h4g8dA.d.mts

@@ -0,0 +1,50 @@
+//#region src/log/logging.d.ts
+/** @inline */
+type LogLevel = "info" | "debug" | "warn";
+/** @inline */
+type LogLevelOption = LogLevel | "silent";
+/** @inline */
+type LogLevelWithError = LogLevel | "error";
+interface RolldownLog {
+  binding?: string;
+  cause?: unknown;
+  /**
+  * The log code for this log object.
+  * @example 'PLUGIN_ERROR'
+  */
+  code?: string;
+  exporter?: string;
+  frame?: string;
+  hook?: string;
+  id?: string;
+  ids?: string[];
+  loc?: {
+    column: number;
+    file?: string;
+    line: number;
+  };
+  /**
+  * The message for this log object.
+  * @example 'The "transform" hook used by the output plugin "rolldown-plugin-foo" is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.'
+  */
+  message: string;
+  meta?: any;
+  names?: string[];
+  plugin?: string;
+  pluginCode?: unknown;
+  pos?: number;
+  reexporter?: string;
+  stack?: string;
+  url?: string;
+}
+/** @inline */
+type RolldownLogWithString = RolldownLog | string;
+/** @category Plugin APIs */
+interface RolldownError extends RolldownLog {
+  name?: string;
+  stack?: string;
+  watchFiles?: string[];
+}
+type LogOrStringHandler = (level: LogLevelWithError, log: RolldownLogWithString) => void;
+//#endregion
+export { RolldownLog as a, RolldownError as i, LogLevelOption as n, RolldownLogWithString as o, LogOrStringHandler as r, LogLevel as t };

package/test-e2e/node_modules/rolldown/dist/shared/logs-D80CXhvg.mjs

@@ -0,0 +1,180 @@
+//#region src/utils/code-frame.ts
+function spaces(index) {
+	let result = "";
+	while (index--) result += " ";
+	return result;
+}
+function tabsToSpaces(value) {
+	return value.replace(/^\t+/, (match) => match.split("	").join("  "));
+}
+const LINE_TRUNCATE_LENGTH = 120;
+const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
+const ELLIPSIS = "...";
+function getCodeFrame(source, line, column) {
+	let lines = source.split("\n");
+	if (line > lines.length) return "";
+	const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length + MIN_CHARACTERS_SHOWN_AFTER_LOCATION + 3, LINE_TRUNCATE_LENGTH);
+	const frameStart = Math.max(0, line - 3);
+	let frameEnd = Math.min(line + 2, lines.length);
+	lines = lines.slice(frameStart, frameEnd);
+	while (!/\S/.test(lines[lines.length - 1])) {
+		lines.pop();
+		frameEnd -= 1;
+	}
+	const digits = String(frameEnd).length;
+	return lines.map((sourceLine, index) => {
+		const isErrorLine = frameStart + index + 1 === line;
+		let lineNumber = String(index + frameStart + 1);
+		while (lineNumber.length < digits) lineNumber = ` ${lineNumber}`;
+		let displayedLine = tabsToSpaces(sourceLine);
+		if (displayedLine.length > maxLineLength) displayedLine = `${displayedLine.slice(0, maxLineLength - 3)}${ELLIPSIS}`;
+		if (isErrorLine) {
+			const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + "^";
+			return `${lineNumber}: ${displayedLine}\n${indicator}`;
+		}
+		return `${lineNumber}: ${displayedLine}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/log/locate-character/index.js
+/** @typedef {import('./types').Location} Location */
+/**
+* @param {import('./types').Range} range
+* @param {number} index
+*/
+function rangeContains(range, index) {
+	return range.start <= index && index < range.end;
+}
+/**
+* @param {string} source
+* @param {import('./types').Options} [options]
+*/
+function getLocator(source, options = {}) {
+	const { offsetLine = 0, offsetColumn = 0 } = options;
+	let start = 0;
+	const ranges = source.split("\n").map((line, i) => {
+		const end = start + line.length + 1;
+		/** @type {import('./types').Range} */
+		const range = {
+			start,
+			end,
+			line: i
+		};
+		start = end;
+		return range;
+	});
+	let i = 0;
+	/**
+	* @param {string | number} search
+	* @param {number} [index]
+	* @returns {Location | undefined}
+	*/
+	function locator(search, index) {
+		if (typeof search === "string") search = source.indexOf(search, index ?? 0);
+		if (search === -1) return void 0;
+		let range = ranges[i];
+		const d = search >= range.end ? 1 : -1;
+		while (range) {
+			if (rangeContains(range, search)) return {
+				line: offsetLine + range.line,
+				column: offsetColumn + search - range.start,
+				character: search
+			};
+			i += d;
+			range = ranges[i];
+		}
+	}
+	return locator;
+}
+/**
+* @param {string} source
+* @param {string | number} search
+* @param {import('./types').Options} [options]
+* @returns {Location | undefined}
+*/
+function locate(source, search, options) {
+	return getLocator(source, options)(search, options && options.startIndex);
+}
+//#endregion
+//#region src/log/logs.ts
+const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING", MULTIPLE_WATCHER_OPTION = "MULTIPLE_WATCHER_OPTION", PARSE_ERROR = "PARSE_ERROR";
+function logParseError(message, id, pos) {
+	return {
+		code: PARSE_ERROR,
+		id,
+		message,
+		pos
+	};
+}
+function logInvalidLogPosition(pluginName) {
+	return {
+		code: INVALID_LOG_POSITION,
+		message: `Plugin "${pluginName}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
+	};
+}
+function logInputHookInOutputPlugin(pluginName, hookName) {
+	return {
+		code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
+		message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
+	};
+}
+function logCycleLoading(pluginName, moduleId) {
+	return {
+		code: CYCLE_LOADING,
+		message: `Found the module "${moduleId}" cycle loading at ${pluginName} plugin, it maybe blocking fetching modules.`
+	};
+}
+function logMultipleWatcherOption() {
+	return {
+		code: MULTIPLE_WATCHER_OPTION,
+		message: `Found multiple watcher options at watch options, using first one to start watcher.`
+	};
+}
+function logPluginError(error, plugin, { hook, id } = {}) {
+	try {
+		const code = error.code;
+		if (!error.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error.pluginCode = code;
+		error.code = PLUGIN_ERROR;
+		error.plugin = plugin;
+		if (hook) error.hook = hook;
+		if (id) error.id = id;
+	} catch (_) {} finally {
+		return error;
+	}
+}
+function error(base) {
+	if (!(base instanceof Error)) {
+		base = Object.assign(new Error(base.message), base);
+		Object.defineProperty(base, "name", {
+			value: "RolldownError",
+			writable: true
+		});
+	}
+	throw base;
+}
+function augmentCodeLocation(properties, pos, source, id) {
+	if (typeof pos === "object") {
+		const { line, column } = pos;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	} else {
+		properties.pos = pos;
+		const location = locate(source, pos, { offsetLine: 1 });
+		if (!location) return;
+		const { line, column } = location;
+		properties.loc = {
+			column,
+			file: id,
+			line
+		};
+	}
+	if (properties.frame === void 0) {
+		const { line, column } = properties.loc;
+		properties.frame = getCodeFrame(source, line, column);
+	}
+}
+//#endregion
+export { logInvalidLogPosition as a, logPluginError as c, logInputHookInOutputPlugin as i, locate as l, error as n, logMultipleWatcherOption as o, logCycleLoading as r, logParseError as s, augmentCodeLocation as t, getCodeFrame as u };

package/test-e2e/node_modules/rolldown/dist/shared/misc-DJYbNKZX.mjs

@@ -0,0 +1,21 @@
+//#region src/utils/misc.ts
+function arraify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function isPromiseLike(value) {
+	return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function unimplemented(info) {
+	if (info) throw new Error(`unimplemented: ${info}`);
+	throw new Error("unimplemented");
+}
+function unreachable(info) {
+	if (info) throw new Error(`unreachable: ${info}`);
+	throw new Error("unreachable");
+}
+function unsupported(info) {
+	throw new Error(`UNSUPPORTED: ${info}`);
+}
+function noop(..._args) {}
+//#endregion
+export { unreachable as a, unimplemented as i, isPromiseLike as n, unsupported as o, noop as r, arraify as t };

package/test-e2e/node_modules/rolldown/dist/shared/normalize-string-or-regex-CVvpepxa.mjs

@@ -0,0 +1,66 @@
+import { n as __toESM, t as require_binding } from "./binding-s-V_wTpj.mjs";
+import { c as logPluginError, n as error } from "./logs-D80CXhvg.mjs";
+//#region src/builtin-plugin/utils.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+var BuiltinPlugin = class {
+	/** Vite-specific option to control plugin ordering */
+	enforce;
+	constructor(name, _options) {
+		this.name = name;
+		this._options = _options;
+	}
+};
+function makeBuiltinPluginCallable(plugin) {
+	let callablePlugin = new import_binding.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	const wrappedPlugin = plugin;
+	for (const key in callablePlugin) {
+		const wrappedHook = async function(...args) {
+			try {
+				return await callablePlugin[key](...args);
+			} catch (e) {
+				if (e instanceof Error && !e.stack?.includes("at ")) Error.captureStackTrace(e, wrappedPlugin[key]);
+				return error(logPluginError(e, plugin.name, {
+					hook: key,
+					id: key === "transform" ? args[2] : void 0
+				}));
+			}
+		};
+		const order = callablePlugin.getOrder(key);
+		if (order == void 0) wrappedPlugin[key] = wrappedHook;
+		else wrappedPlugin[key] = {
+			handler: wrappedHook,
+			order
+		};
+	}
+	return wrappedPlugin;
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		__name: plugin.name,
+		options: plugin._options
+	};
+}
+function bindingifyManifestPlugin(plugin, pluginContextData) {
+	const { isOutputOptionsForLegacyChunks, ...options } = plugin._options;
+	return {
+		__name: plugin.name,
+		options: {
+			...options,
+			isLegacy: isOutputOptionsForLegacyChunks ? (opts) => {
+				return isOutputOptionsForLegacyChunks(pluginContextData.getOutputOptions(opts));
+			} : void 0
+		}
+	};
+}
+//#endregion
+//#region src/utils/normalize-string-or-regex.ts
+function normalizedStringOrRegex(pattern) {
+	if (!pattern) return;
+	if (!isReadonlyArray(pattern)) return [pattern];
+	return pattern;
+}
+function isReadonlyArray(input) {
+	return Array.isArray(input);
+}
+//#endregion
+export { makeBuiltinPluginCallable as a, bindingifyManifestPlugin as i, BuiltinPlugin as n, bindingifyBuiltInPlugin as r, normalizedStringOrRegex as t };

package/test-e2e/node_modules/rolldown/dist/shared/parse-BywQARUG.mjs

@@ -0,0 +1,74 @@
+import { n as __toESM, t as require_binding } from "./binding-s-V_wTpj.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.124.0_@emnapi+core@1.9.2_@emnapi+runtime@1.9.2/node_modules/oxc-parser/src-js/wrap.js
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
+function wrap(result) {
+	let program, module, comments, errors;
+	return {
+		get program() {
+			if (!program) program = jsonParseAst(result.program);
+			return program;
+		},
+		get module() {
+			if (!module) module = result.module;
+			return module;
+		},
+		get comments() {
+			if (!comments) comments = result.comments;
+			return comments;
+		},
+		get errors() {
+			if (!errors) errors = result.errors;
+			return errors;
+		}
+	};
+}
+function jsonParseAst(programJson) {
+	const { node: program, fixes } = JSON.parse(programJson);
+	for (const fixPath of fixes) applyFix(program, fixPath);
+	return program;
+}
+function applyFix(program, fixPath) {
+	let node = program;
+	for (const key of fixPath) node = node[key];
+	if (node.bigint) node.value = BigInt(node.bigint);
+	else try {
+		node.value = RegExp(node.regex.pattern, node.regex.flags);
+	} catch {}
+}
+//#endregion
+//#region src/utils/parse.ts
+/**
+* Parse JS/TS source asynchronously on a separate thread.
+*
+* Note that not all of the workload can happen on a separate thread.
+* Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
+* has to happen on current thread. This synchronous deserialization work typically outweighs
+* the asynchronous parsing by a factor of between 3 and 20.
+*
+* i.e. the majority of the workload cannot be parallelized by using this method.
+*
+* Generally {@linkcode parseSync} is preferable to use as it does not have the overhead of spawning a thread.
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads.
+*
+* @category Utilities
+*/
+async function parse(filename, sourceText, options) {
+	return wrap(await (0, import_binding.parse)(filename, sourceText, options));
+}
+/**
+* Parse JS/TS source synchronously on current thread.
+*
+* This is generally preferable over {@linkcode parse} (async) as it does not have the overhead
+* of spawning a thread, and the majority of the workload cannot be parallelized anyway
+* (see {@linkcode parse} documentation for details).
+*
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads
+* with {@linkcode parseSync} rather than using {@linkcode parse}.
+*
+* @category Utilities
+*/
+function parseSync(filename, sourceText, options) {
+	return wrap((0, import_binding.parseSync)(filename, sourceText, options));
+}
+//#endregion
+export { parseSync as n, parse as t };