rolldown 1.0.0-beta.1-commit.1d4a330 → 1.0.0-beta.1-commit.2fe52d4

package/dist/shared/binding-BMSG-hw7.mjs

@@ -0,0 +1,530 @@
+import { createRequire } from "module";
+
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), 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));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#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 + ELLIPSIS.length, 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 - ELLIPSIS.length)}${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;
+}
+function getLocator(source, options = {}) {
+	const { offsetLine = 0, offsetColumn = 0 } = options;
+	let start = 0;
+	const ranges = source.split("\n").map((line, i$1) => {
+		const end = start + line.length + 1;
+		/** @type {import('./types').Range} */
+		const range = {
+			start,
+			end,
+			line: i$1
+		};
+		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 undefined;
+		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;
+}
+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", MULTIPLY_NOTIFY_OPTION = "MULTIPLY_NOTIFY_OPTION", MINIFY_WARNING = "MINIFY_WARNING", PARSE_ERROR = "PARSE_ERROR";
+function logParseError(message) {
+	return {
+		code: PARSE_ERROR,
+		message
+	};
+}
+function logMinifyWarning() {
+	return {
+		code: MINIFY_WARNING,
+		message: "The built-in minifier is still under development. Setting \"minify: true\" is not recommended for production use."
+	};
+}
+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 logMultiplyNotifyOption() {
+	return {
+		code: MULTIPLY_NOTIFY_OPTION,
+		message: `Found multiply notify option at watch options, using first one to start notify watcher.`
+	};
+}
+function logPluginError(error$1, plugin, { hook, id } = {}) {
+	const code = error$1.code;
+	if (!error$1.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error$1.pluginCode = code;
+	error$1.code = PLUGIN_ERROR;
+	error$1.plugin = plugin;
+	if (hook) error$1.hook = hook;
+	if (id) error$1.id = id;
+	return error$1;
+}
+function error(base) {
+	if (!(base instanceof Error)) {
+		base = Object.assign(new Error(base.message), base);
+		Object.defineProperty(base, "name", {
+			value: "RollupError",
+			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 === undefined) {
+		const { line, column } = properties.loc;
+		properties.frame = getCodeFrame(source, line, column);
+	}
+}
+
+//#endregion
+//#region src/binding.js
+var require_binding = __commonJS({ "src/binding.js"(exports, module) {
+	const { createRequire: createRequire$1 } = __require("node:module");
+	const { readFileSync } = __require("node:fs");
+	let nativeBinding = null;
+	const loadErrors = [];
+	const isMusl = () => {
+		let musl = false;
+		if (process.platform === "linux") {
+			musl = isMuslFromFilesystem();
+			if (musl === null) musl = isMuslFromReport();
+			if (musl === null) musl = isMuslFromChildProcess();
+		}
+		return musl;
+	};
+	const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+	const isMuslFromFilesystem = () => {
+		try {
+			return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+		} catch {
+			return null;
+		}
+	};
+	const isMuslFromReport = () => {
+		const report = typeof process.report.getReport === "function" ? process.report.getReport() : null;
+		if (!report) return null;
+		if (report.header && report.header.glibcVersionRuntime) return false;
+		if (Array.isArray(report.sharedObjects)) {
+			if (report.sharedObjects.some(isFileMusl)) return true;
+		}
+		return false;
+	};
+	const isMuslFromChildProcess = () => {
+		try {
+			return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+		} catch (e) {
+			return false;
+		}
+	};
+	function requireNative() {
+		if (process.platform === "android") if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.android-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-android-arm64");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return __require("./rolldown-binding.android-arm-eabi.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-android-arm-eabi");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+		else if (process.platform === "win32") if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.win32-x64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-win32-x64-msvc");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "ia32") {
+			try {
+				return __require("./rolldown-binding.win32-ia32-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-win32-ia32-msvc");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.win32-arm64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-win32-arm64-msvc");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+		else if (process.platform === "darwin") {
+			try {
+				return __require("./rolldown-binding.darwin-universal.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-darwin-universal");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			if (process.arch === "x64") {
+				try {
+					return __require("./rolldown-binding.darwin-x64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					return __require("@rolldown/binding-darwin-x64");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else if (process.arch === "arm64") {
+				try {
+					return __require("./rolldown-binding.darwin-arm64.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					return __require("@rolldown/binding-darwin-arm64");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+		} else if (process.platform === "freebsd") if (process.arch === "x64") {
+			try {
+				return __require("./rolldown-binding.freebsd-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-freebsd-x64");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return __require("./rolldown-binding.freebsd-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-freebsd-arm64");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+		else if (process.platform === "linux") if (process.arch === "x64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-x64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-x64-musl");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-x64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-x64-gnu");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-arm64-musl");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-arm64-gnu");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "arm") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-arm-musleabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-arm-musleabihf");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-arm-gnueabihf.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-arm-gnueabihf");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "riscv64") if (isMusl()) {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-musl.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-riscv64-musl");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			try {
+				return __require("./rolldown-binding.linux-riscv64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-riscv64-gnu");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		}
+		else if (process.arch === "ppc64") {
+			try {
+				return __require("./rolldown-binding.linux-ppc64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-ppc64-gnu");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "s390x") {
+			try {
+				return __require("./rolldown-binding.linux-s390x-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				return __require("@rolldown/binding-linux-s390x-gnu");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+		else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+	}
+	nativeBinding = requireNative();
+	if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+		try {
+			nativeBinding = __require("./rolldown-binding.wasi.cjs");
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) loadErrors.push(err);
+		}
+		if (!nativeBinding) try {
+			nativeBinding = __require("@rolldown/binding-wasm32-wasi");
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) loadErrors.push(err);
+		}
+	}
+	if (!nativeBinding) {
+		if (loadErrors.length > 0) throw new Error("Failed to load native binding", { cause: loadErrors });
+		throw new Error(`Failed to load native binding`);
+	}
+	module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData;
+	module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin;
+	module.exports.BindingError = nativeBinding.BindingError;
+	module.exports.BindingLog = nativeBinding.BindingLog;
+	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
+	module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions;
+	module.exports.BindingOutputAsset = nativeBinding.BindingOutputAsset;
+	module.exports.BindingOutputChunk = nativeBinding.BindingOutputChunk;
+	module.exports.BindingOutputs = nativeBinding.BindingOutputs;
+	module.exports.BindingPluginContext = nativeBinding.BindingPluginContext;
+	module.exports.BindingRenderedModule = nativeBinding.BindingRenderedModule;
+	module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext;
+	module.exports.BindingWatcher = nativeBinding.BindingWatcher;
+	module.exports.BindingWatcherChangeData = nativeBinding.BindingWatcherChangeData;
+	module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent;
+	module.exports.Bundler = nativeBinding.Bundler;
+	module.exports.MagicString = nativeBinding.MagicString;
+	module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry;
+	module.exports.ParseResult = nativeBinding.ParseResult;
+	module.exports.RenderedChunk = nativeBinding.RenderedChunk;
+	module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName;
+	module.exports.BindingHookSideEffects = nativeBinding.BindingHookSideEffects;
+	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
+	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
+	module.exports.ExportExportNameKind = nativeBinding.ExportExportNameKind;
+	module.exports.ExportImportNameKind = nativeBinding.ExportImportNameKind;
+	module.exports.ExportLocalNameKind = nativeBinding.ExportLocalNameKind;
+	module.exports.HelperMode = nativeBinding.HelperMode;
+	module.exports.ImportNameKind = nativeBinding.ImportNameKind;
+	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
+	module.exports.parseAsync = nativeBinding.parseAsync;
+	module.exports.parseSync = nativeBinding.parseSync;
+	module.exports.parseWithoutReturn = nativeBinding.parseWithoutReturn;
+	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.Severity = nativeBinding.Severity;
+	module.exports.transform = nativeBinding.transform;
+} });
+
+//#endregion
+export { __toESM, augmentCodeLocation, error, getCodeFrame, locate, logCycleLoading, logInputHookInOutputPlugin, logInvalidLogPosition, logMinifyWarning, logMultiplyNotifyOption, logParseError, logPluginError, require_binding };