screw-up 1.25.0 → 1.27.0

package/dist/index.mjs

@@ -1,397 +1,318 @@
 /*!
- * name: screw-up
- * version: 1.25.0
- * description: Simply package metadata inserter on Vite plugin
- * author: Kouji Matsui (@kekyo@mi.kekyo.net)
- * license: MIT
- * repository.url: https://github.com/kekyo/screw-up.git
- * git.commit.hash: 8275b6db6558235b0fe73f99368acf3f9a6e1b29
- */
-
+* name: screw-up
+* version: 1.27.0
+* description: Simply package metadata inserter on Vite plugin
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/screw-up.git
+* git.commit.hash: eb1634007fc12b0ddd13928d7688758bdfe32624
+*/
+import { i as getFetchGitMetadata, l as resolvePackageMetadata, n as generateMetadataFileContent, o as createConsoleLogger, r as writeFileIfChanged, t as ensureMetadataGitignore } from "./metadata-file-Djz8vanJ.js";
+import { i as version, n as name, t as git_commit_hash } from "./packageMetadata-B3dAY9Pw.js";
 import { readFile, readdir, writeFile } from "fs/promises";
 import { existsSync } from "fs";
-import { dirname, join, extname } from "path";
-import { c as createConsoleLogger, n as name, g as getFetchGitMetadata, v as version, a as git_commit_hash, r as resolvePackageMetadata, b as generateMetadataFileContent, w as writeFileIfChanged, e as ensureMetadataGitignore } from "./metadata-file-CV4Jy39y.js";
+import { dirname, extname, join } from "path";
 import { createHash } from "crypto";
-const __NOOP_HANDLER = () => {
-};
-const __NOOP_RELEASABLE = {
-  release: __NOOP_HANDLER,
-  [Symbol.dispose]: __NOOP_HANDLER
-};
-const toAbortError = (reason) => {
-  if (reason instanceof Error) {
-    return reason;
-  }
-  if (typeof reason === "string") {
-    return new Error(reason);
-  }
-  return new Error("Operation aborted");
-};
-const onAbort = (signal, callback) => {
-  if (!signal) {
-    return __NOOP_RELEASABLE;
-  }
-  if (signal.aborted) {
-    try {
-      callback(toAbortError(signal.reason));
-    } catch (error) {
-      console.warn("AbortHook callback error: ", error);
-    }
-    return __NOOP_RELEASABLE;
-  }
-  let abortHandler;
-  abortHandler = () => {
-    if (abortHandler) {
-      const reason = signal.reason;
-      signal.removeEventListener("abort", abortHandler);
-      abortHandler = void 0;
-      try {
-        callback(toAbortError(reason));
-      } catch (error) {
-        console.warn("AbortHook callback error: ", error);
-      }
-    }
-  };
-  const release = () => {
-    if (abortHandler) {
-      signal.removeEventListener("abort", abortHandler);
-      abortHandler = void 0;
-    }
-  };
-  signal.addEventListener("abort", abortHandler, { once: true });
-  const handle = {
-    release,
-    [Symbol.dispose]: release
-  };
-  return handle;
-};
-const defer = (fn) => {
-  if (typeof setImmediate === "function") {
-    setImmediate(fn);
-  } else {
-    setTimeout(fn, 0);
-  }
-};
-const ABORTED_ERROR$2 = () => new Error("Lock acquisition was aborted");
-const createLockHandle = (releaseCallback) => {
-  let isActive = true;
-  const release = () => {
-    if (!isActive) {
-      return;
-    }
-    isActive = false;
-    releaseCallback();
-  };
-  return {
-    get isActive() {
-      return isActive;
-    },
-    release,
-    [Symbol.dispose]: release
-  };
-};
-const createMutex = (maxConsecutiveCalls = 20) => {
-  let isLocked = false;
-  const queue = [];
-  let count = 0;
-  const processQueue = () => {
-    var _a;
-    if (isLocked || queue.length === 0) {
-      return;
-    }
-    const item = queue.shift();
-    if ((_a = item.signal) == null ? void 0 : _a.aborted) {
-      item.reject(ABORTED_ERROR$2());
-      scheduleNextProcess();
-      return;
-    }
-    isLocked = true;
-    const lockHandle = createLockHandle(releaseLock);
-    item.resolve(lockHandle);
-  };
-  const scheduleNextProcess = () => {
-    count++;
-    if (count >= maxConsecutiveCalls) {
-      count = 0;
-      defer(processQueue);
-    } else {
-      processQueue();
-    }
-  };
-  const releaseLock = () => {
-    if (!isLocked) {
-      return;
-    }
-    isLocked = false;
-    scheduleNextProcess();
-  };
-  const removeFromQueue = (item) => {
-    const index = queue.indexOf(item);
-    if (index !== -1) {
-      queue.splice(index, 1);
-    }
-  };
-  const lock = async (signal) => {
-    if (signal) {
-      if (signal.aborted) {
-        throw ABORTED_ERROR$2();
-      }
-      return new Promise((resolve, reject) => {
-        const queueItem = {
-          resolve: void 0,
-          reject: void 0,
-          signal
-        };
-        const abortHandle = onAbort(signal, () => {
-          removeFromQueue(queueItem);
-          reject(ABORTED_ERROR$2());
-        });
-        queueItem.resolve = (handle) => {
-          abortHandle.release();
-          resolve(handle);
-        };
-        queueItem.reject = (error) => {
-          abortHandle.release();
-          reject(error);
-        };
-        queue.push(queueItem);
-        processQueue();
-      });
-    } else {
-      return new Promise((resolve, reject) => {
-        queue.push({
-          resolve,
-          reject
-        });
-        processQueue();
-      });
-    }
-  };
-  const result = {
-    lock,
-    waiter: {
-      wait: lock
-    },
-    get isLocked() {
-      return isLocked;
-    },
-    get pendingCount() {
-      return queue.length;
-    }
-  };
-  return result;
-};
-const importConditions = ["import", "node", "default"];
-const stripQuery = (id) => {
-  const queryIndex = id.indexOf("?");
-  return queryIndex === -1 ? id : id.slice(0, queryIndex);
-};
-const isBareSpecifier = (specifier) => {
-  if (!specifier) {
-    return false;
-  }
-  if (specifier.startsWith(".")) {
-    return false;
-  }
-  if (specifier.startsWith("/") || specifier.startsWith("\\")) {
-    return false;
-  }
-  if (specifier.startsWith("node:")) {
-    return false;
-  }
-  if (specifier.includes(":")) {
-    return false;
-  }
-  return true;
-};
-const parsePackageName = (specifier) => {
-  if (specifier.startsWith("@")) {
-    const parts = specifier.split("/");
-    if (parts.length >= 2) {
-      return {
-        packageName: `${parts[0]}/${parts[1]}`,
-        subpath: parts.slice(2).join("/")
-      };
-    }
-  }
-  const [packageName, ...rest] = specifier.split("/");
-  return { packageName, subpath: rest.join("/") };
-};
-const findPackageJsonPath = (packageName, importerDir) => {
-  let current = importerDir;
-  while (true) {
-    const candidate = join(
-      current,
-      "node_modules",
-      packageName,
-      "package.json"
-    );
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return void 0;
-    }
-    current = parent;
-  }
-};
-const readPackageJson = async (packageJsonPath) => {
-  try {
-    const raw = await readFile(packageJsonPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") {
-      return parsed;
-    }
-  } catch (e) {
-    return void 0;
-  }
-  return void 0;
-};
-const resolveExportTarget = (target, subpath, conditions) => {
-  if (typeof target === "string") {
-    if (subpath && subpath !== ".") {
-      return void 0;
-    }
-    return target;
-  }
-  if (Array.isArray(target)) {
-    for (const entry of target) {
-      const resolved = resolveExportTarget(entry, subpath, conditions);
-      if (resolved) {
-        return resolved;
-      }
-    }
-    return void 0;
-  }
-  if (!target || typeof target !== "object") {
-    return void 0;
-  }
-  const record = target;
-  const keys = Object.keys(record);
-  const hasSubpathMap = keys.some((key) => key.startsWith("."));
-  if (hasSubpathMap) {
-    const subpathKey = subpath === "" || subpath === "." ? "." : subpath.startsWith("./") ? subpath : `./${subpath}`;
-    if (!(subpathKey in record)) {
-      return void 0;
-    }
-    return resolveExportTarget(record[subpathKey], ".", conditions);
-  }
-  for (const condition of conditions) {
-    if (condition in record) {
-      const resolved = resolveExportTarget(
-        record[condition],
-        subpath,
-        conditions
-      );
-      if (resolved) {
-        return resolved;
-      }
-    }
-  }
-  return void 0;
-};
-const inferModuleKindFromPath = (targetPath, packageType) => {
-  const ext = extname(targetPath);
-  if (ext === ".mjs") {
-    return "esm";
-  }
-  if (ext === ".cjs") {
-    return "cjs";
-  }
-  if (ext === ".js" || ext === "") {
-    return packageType === "module" ? "esm" : "cjs";
-  }
-  return packageType === "module" ? "esm" : "cjs";
-};
-const resolveModuleKindFromPackage = (packageJson, subpath) => {
-  const packageType = typeof packageJson.type === "string" ? packageJson.type : void 0;
-  if (packageJson.exports !== void 0) {
-    const resolved = resolveExportTarget(
-      packageJson.exports,
-      subpath,
-      importConditions
-    );
-    if (!resolved) {
-      return "unresolvable";
-    }
-    return inferModuleKindFromPath(resolved, packageType);
-  }
-  if (subpath) {
-    return inferModuleKindFromPath(subpath, packageType);
-  }
-  const main = typeof packageJson.main === "string" ? packageJson.main : "index.js";
-  return inferModuleKindFromPath(main, packageType);
-};
-const createNodeModuleKindResolver = () => {
-  const packageJsonCache = /* @__PURE__ */ new Map();
-  const resolveCache = /* @__PURE__ */ new Map();
-  return async (specifier, importer) => {
-    var _a;
-    if (!isBareSpecifier(specifier)) {
-      return "unknown";
-    }
-    const importerPath = stripQuery(importer);
-    const importerDir = dirname(importerPath);
-    const { packageName, subpath } = parsePackageName(specifier);
-    const packageJsonPath = findPackageJsonPath(packageName, importerDir);
-    if (!packageJsonPath) {
-      return "unknown";
-    }
-    const cacheKey = `${packageJsonPath}:${subpath}`;
-    const cached = resolveCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    let packageJson = packageJsonCache.get(packageJsonPath);
-    if (packageJson === void 0) {
-      packageJson = (_a = await readPackageJson(packageJsonPath)) != null ? _a : null;
-      packageJsonCache.set(packageJsonPath, packageJson);
-    }
-    if (!packageJson) {
-      resolveCache.set(cacheKey, "unknown");
-      return "unknown";
-    }
-    const resolved = resolveModuleKindFromPackage(packageJson, subpath);
-    resolveCache.set(cacheKey, resolved);
-    return resolved;
-  };
-};
-const scanHasDefaultImport = (ts, code) => {
-  const scanner = ts.createScanner(
-    ts.ScriptTarget.ESNext,
-    true,
-    ts.LanguageVariant.Standard,
-    code
-  );
-  let token = scanner.scan();
-  while (token !== ts.SyntaxKind.EndOfFileToken) {
-    if (token === ts.SyntaxKind.ImportKeyword) {
-      const next = scanner.scan();
-      if (next === ts.SyntaxKind.OpenParenToken) {
-        token = scanner.scan();
-        continue;
-      }
-      if (next === ts.SyntaxKind.Identifier || next === ts.SyntaxKind.TypeKeyword) {
-        return true;
-      }
-    }
-    token = scanner.scan();
-  }
-  return false;
-};
-const cjsInteropGlobalFlagPrefix = "__screwUpIsInCJS_";
-const cjsInteropIdLength = 12;
-const cjsInteropGlobalFlagAssignmentPattern = new RegExp(
-  `\\bglobalThis\\.${cjsInteropGlobalFlagPrefix}[0-9a-f]+\\s*=\\s*false\\b`,
-  "g"
-);
-const createCjsInteropHelperId = (seed) => {
-  const hash = createHash("sha256").update(seed).digest("hex");
-  return hash.slice(0, cjsInteropIdLength);
-};
-const buildHelperFunctionSource = (helperId) => `
+//#region node_modules/async-primitives/dist/index.mjs
+/*!
+* name: async-primitives
+* version: 1.5.0
+* description: A collection of primitive functions for asynchronous operations
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/async-primitives.git
+* git.commit.hash: cd35465b7e9b9945049186e7eaeecc0bfba65766
+*/
+var __NOOP_HANDLER = () => {};
+var __NOOP_RELEASABLE = {
+	release: __NOOP_HANDLER,
+	[Symbol.dispose]: __NOOP_HANDLER
+};
+var toAbortError = (reason) => {
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new Error(reason);
+	return /* @__PURE__ */ new Error("Operation aborted");
+};
+var onAbort = (signal, callback) => {
+	if (!signal) return __NOOP_RELEASABLE;
+	if (signal.aborted) {
+		try {
+			callback(toAbortError(signal.reason));
+		} catch (error) {
+			console.warn("AbortHook callback error: ", error);
+		}
+		return __NOOP_RELEASABLE;
+	}
+	let abortHandler = () => {
+		if (abortHandler) {
+			const reason = signal.reason;
+			signal.removeEventListener("abort", abortHandler);
+			abortHandler = void 0;
+			try {
+				callback(toAbortError(reason));
+			} catch (error) {
+				console.warn("AbortHook callback error: ", error);
+			}
+		}
+	};
+	const release = () => {
+		if (abortHandler) {
+			signal.removeEventListener("abort", abortHandler);
+			abortHandler = void 0;
+		}
+	};
+	signal.addEventListener("abort", abortHandler, { once: true });
+	return {
+		release,
+		[Symbol.dispose]: release
+	};
+};
+var defer = (fn) => {
+	if (typeof setImmediate === "function") setImmediate(fn);
+	else setTimeout(fn, 0);
+};
+var ABORTED_ERROR$2 = () => /* @__PURE__ */ new Error("Lock acquisition was aborted");
+var createLockHandle = (releaseCallback) => {
+	let isActive = true;
+	const release = () => {
+		if (!isActive) return;
+		isActive = false;
+		releaseCallback();
+	};
+	return {
+		get isActive() {
+			return isActive;
+		},
+		release,
+		[Symbol.dispose]: release
+	};
+};
+var createMutex = (maxConsecutiveCalls = 20) => {
+	let isLocked = false;
+	const queue = [];
+	let count = 0;
+	const processQueue = () => {
+		var _a;
+		if (isLocked || queue.length === 0) return;
+		const item = queue.shift();
+		if ((_a = item.signal) == null ? void 0 : _a.aborted) {
+			item.reject(ABORTED_ERROR$2());
+			scheduleNextProcess();
+			return;
+		}
+		isLocked = true;
+		const lockHandle = createLockHandle(releaseLock);
+		item.resolve(lockHandle);
+	};
+	const scheduleNextProcess = () => {
+		count++;
+		if (count >= maxConsecutiveCalls) {
+			count = 0;
+			defer(processQueue);
+		} else processQueue();
+	};
+	const releaseLock = () => {
+		if (!isLocked) return;
+		isLocked = false;
+		scheduleNextProcess();
+	};
+	const removeFromQueue = (item) => {
+		const index = queue.indexOf(item);
+		if (index !== -1) queue.splice(index, 1);
+	};
+	const lock = async (signal) => {
+		if (signal) {
+			if (signal.aborted) throw ABORTED_ERROR$2();
+			return new Promise((resolve, reject) => {
+				const queueItem = {
+					resolve: void 0,
+					reject: void 0,
+					signal
+				};
+				const abortHandle = onAbort(signal, () => {
+					removeFromQueue(queueItem);
+					reject(ABORTED_ERROR$2());
+				});
+				queueItem.resolve = (handle) => {
+					abortHandle.release();
+					resolve(handle);
+				};
+				queueItem.reject = (error) => {
+					abortHandle.release();
+					reject(error);
+				};
+				queue.push(queueItem);
+				processQueue();
+			});
+		} else return new Promise((resolve, reject) => {
+			queue.push({
+				resolve,
+				reject
+			});
+			processQueue();
+		});
+	};
+	return {
+		lock,
+		waiter: { wait: lock },
+		get isLocked() {
+			return isLocked;
+		},
+		get pendingCount() {
+			return queue.length;
+		}
+	};
+};
+var createLogicalContext = (id) => {
+	return {
+		id,
+		data: /* @__PURE__ */ new Map()
+	};
+};
+createLogicalContext(Symbol("[root]"));
+//#endregion
+//#region src/default-import-fix.ts
+var importConditions = [
+	"import",
+	"node",
+	"default"
+];
+var stripQuery = (id) => {
+	const queryIndex = id.indexOf("?");
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+};
+var isBareSpecifier = (specifier) => {
+	if (!specifier) return false;
+	if (specifier.startsWith(".")) return false;
+	if (specifier.startsWith("/") || specifier.startsWith("\\")) return false;
+	if (specifier.startsWith("node:")) return false;
+	if (specifier.includes(":")) return false;
+	return true;
+};
+var parsePackageName = (specifier) => {
+	if (specifier.startsWith("@")) {
+		const parts = specifier.split("/");
+		if (parts.length >= 2) return {
+			packageName: `${parts[0]}/${parts[1]}`,
+			subpath: parts.slice(2).join("/")
+		};
+	}
+	const [packageName, ...rest] = specifier.split("/");
+	return {
+		packageName,
+		subpath: rest.join("/")
+	};
+};
+var findPackageJsonPath = (packageName, importerDir) => {
+	let current = importerDir;
+	while (true) {
+		const candidate = join(current, "node_modules", packageName, "package.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+};
+var readPackageJson = async (packageJsonPath) => {
+	try {
+		const raw = await readFile(packageJsonPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object") return parsed;
+	} catch (_unused) {
+		return;
+	}
+};
+var resolveExportTarget = (target, subpath, conditions) => {
+	if (typeof target === "string") {
+		if (subpath && subpath !== ".") return;
+		return target;
+	}
+	if (Array.isArray(target)) {
+		for (const entry of target) {
+			const resolved = resolveExportTarget(entry, subpath, conditions);
+			if (resolved) return resolved;
+		}
+		return;
+	}
+	if (!target || typeof target !== "object") return;
+	const record = target;
+	if (Object.keys(record).some((key) => key.startsWith("."))) {
+		const subpathKey = subpath === "" || subpath === "." ? "." : subpath.startsWith("./") ? subpath : `./${subpath}`;
+		if (!(subpathKey in record)) return;
+		return resolveExportTarget(record[subpathKey], ".", conditions);
+	}
+	for (const condition of conditions) if (condition in record) {
+		const resolved = resolveExportTarget(record[condition], subpath, conditions);
+		if (resolved) return resolved;
+	}
+};
+var inferModuleKindFromPath = (targetPath, packageType) => {
+	const ext = extname(targetPath);
+	if (ext === ".mjs") return "esm";
+	if (ext === ".cjs") return "cjs";
+	if (ext === ".js" || ext === "") return packageType === "module" ? "esm" : "cjs";
+	return packageType === "module" ? "esm" : "cjs";
+};
+var resolveModuleKindFromPackage = (packageJson, subpath) => {
+	const packageType = typeof packageJson.type === "string" ? packageJson.type : void 0;
+	if (packageJson.exports !== void 0) {
+		const resolved = resolveExportTarget(packageJson.exports, subpath, importConditions);
+		if (!resolved) return "unresolvable";
+		return inferModuleKindFromPath(resolved, packageType);
+	}
+	if (subpath) return inferModuleKindFromPath(subpath, packageType);
+	return inferModuleKindFromPath(typeof packageJson.main === "string" ? packageJson.main : "index.js", packageType);
+};
+var createNodeModuleKindResolver = () => {
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	const resolveCache = /* @__PURE__ */ new Map();
+	return async (specifier, importer) => {
+		if (!isBareSpecifier(specifier)) return "unknown";
+		const importerDir = dirname(stripQuery(importer));
+		const { packageName, subpath } = parsePackageName(specifier);
+		const packageJsonPath = findPackageJsonPath(packageName, importerDir);
+		if (!packageJsonPath) return "unknown";
+		const cacheKey = `${packageJsonPath}:${subpath}`;
+		const cached = resolveCache.get(cacheKey);
+		if (cached) return cached;
+		let packageJson = packageJsonCache.get(packageJsonPath);
+		if (packageJson === void 0) {
+			var _await$readPackageJso;
+			packageJson = (_await$readPackageJso = await readPackageJson(packageJsonPath)) !== null && _await$readPackageJso !== void 0 ? _await$readPackageJso : null;
+			packageJsonCache.set(packageJsonPath, packageJson);
+		}
+		if (!packageJson) {
+			resolveCache.set(cacheKey, "unknown");
+			return "unknown";
+		}
+		const resolved = resolveModuleKindFromPackage(packageJson, subpath);
+		resolveCache.set(cacheKey, resolved);
+		return resolved;
+	};
+};
+var scanHasDefaultImport = (ts, code) => {
+	const scanner = ts.createScanner(ts.ScriptTarget.ESNext, true, ts.LanguageVariant.Standard, code);
+	let token = scanner.scan();
+	while (token !== ts.SyntaxKind.EndOfFileToken) {
+		if (token === ts.SyntaxKind.ImportKeyword) {
+			const next = scanner.scan();
+			if (next === ts.SyntaxKind.OpenParenToken) {
+				token = scanner.scan();
+				continue;
+			}
+			if (next === ts.SyntaxKind.Identifier || next === ts.SyntaxKind.TypeKeyword) return true;
+		}
+		token = scanner.scan();
+	}
+	return false;
+};
+var cjsInteropGlobalFlagPrefix = "__screwUpIsInCJS_";
+var cjsInteropIdLength = 12;
+var cjsInteropGlobalFlagAssignmentPattern = new RegExp(`\\bglobalThis\\.${cjsInteropGlobalFlagPrefix}[0-9a-f]+\\s*=\\s*false\\b`, "g");
+var createCjsInteropHelperId = (seed) => {
+	return createHash("sha256").update(seed).digest("hex").slice(0, cjsInteropIdLength);
+};
+var buildHelperFunctionSource = (helperId) => `
 globalThis.${cjsInteropGlobalFlagPrefix}${helperId} = false;
 function __resolveDefaultExport<T>(module: T | { default?: T }, isESM: boolean): T {
   const __isInCJS =
@@ -430,713 +351,462 @@ function __resolveDefaultExport<T>(module: T | { default?: T }, isESM: boolean):
 
   return hasDefault ? ((resolvedDefault as T) ?? (module as T)) : (module as T);
 }`;
-const injectCjsInteropFlag = (code) => {
-  let changed = false;
-  const nextCode = code.replace(
-    cjsInteropGlobalFlagAssignmentPattern,
-    (match) => {
-      changed = true;
-      return match.replace(/\bfalse\b/, "true ");
-    }
-  );
-  return { code: nextCode, changed };
-};
-const hasResolveDefaultExport = (ts, sourceFile) => {
-  return sourceFile.statements.some((statement) => {
-    var _a, _b;
-    if (ts.isFunctionDeclaration(statement)) {
-      return ((_a = statement.name) == null ? void 0 : _a.text) === "__resolveDefaultExport";
-    }
-    if (ts.isVariableStatement(statement)) {
-      return statement.declarationList.declarations.some((declaration) => {
-        return ts.isIdentifier(declaration.name) && declaration.name.text === "__resolveDefaultExport";
-      });
-    }
-    if (ts.isImportDeclaration(statement)) {
-      const importClause = statement.importClause;
-      if (!importClause) {
-        return false;
-      }
-      if (((_b = importClause.name) == null ? void 0 : _b.text) === "__resolveDefaultExport") {
-        return true;
-      }
-      if (importClause.namedBindings) {
-        if (ts.isNamespaceImport(importClause.namedBindings)) {
-          return importClause.namedBindings.name.text === "__resolveDefaultExport";
-        }
-        if (ts.isNamedImports(importClause.namedBindings)) {
-          return importClause.namedBindings.elements.some(
-            (element) => {
-              var _a2;
-              return element.name.text === "__resolveDefaultExport" || ((_a2 = element.propertyName) == null ? void 0 : _a2.text) === "__resolveDefaultExport";
-            }
-          );
-        }
-      }
-    }
-    return false;
-  });
-};
-const isTypeOnlyImportClause = (ts, importClause) => {
-  const phaseModifier = importClause.phaseModifier;
-  if (phaseModifier !== void 0) {
-    return phaseModifier === ts.SyntaxKind.TypeKeyword;
-  }
-  return Boolean(importClause.isTypeOnly);
-};
-const getScriptKind = (ts, id) => {
-  if (id.endsWith(".tsx")) {
-    return ts.ScriptKind.TSX;
-  }
-  if (id.endsWith(".jsx")) {
-    return ts.ScriptKind.JSX;
-  }
-  if (id.endsWith(".mts")) {
-    const mts = ts.ScriptKind["MTS"];
-    return mts != null ? mts : ts.ScriptKind.TS;
-  }
-  if (id.endsWith(".cts")) {
-    const cts = ts.ScriptKind["CTS"];
-    return cts != null ? cts : ts.ScriptKind.TS;
-  }
-  if (id.endsWith(".ts")) {
-    return ts.ScriptKind.TS;
-  }
-  if (id.endsWith(".mjs")) {
-    return ts.ScriptKind.JS;
-  }
-  if (id.endsWith(".cjs")) {
-    return ts.ScriptKind.JS;
-  }
-  return ts.ScriptKind.JS;
-};
-const formatModuleSpecifier = (specifier) => {
-  const escaped = specifier.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  return `'${escaped}'`;
-};
-const buildNamedImport = (moduleName, namedBindings) => {
-  const elements = namedBindings.elements.map((specifier) => {
-    const alias = specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
-    return specifier.isTypeOnly ? `type ${alias}` : alias;
-  }).join(", ");
-  return `import { ${elements} } from ${formatModuleSpecifier(moduleName)};`;
-};
-const transformDefaultImports = async (ts, code, id, resolveModuleKind) => {
-  const normalizedId = stripQuery(id);
-  const sourceFile = ts.createSourceFile(
-    normalizedId,
-    code,
-    ts.ScriptTarget.ESNext,
-    false,
-    getScriptKind(ts, normalizedId)
-  );
-  const edits = [];
-  let needsHelper = false;
-  const helperPresent = hasResolveDefaultExport(ts, sourceFile);
-  let namespaceIndex = 0;
-  const usedNamespace = (base) => {
-    let candidate = `${base}${namespaceIndex}`;
-    while (code.includes(candidate)) {
-      namespaceIndex += 1;
-      candidate = `${base}${namespaceIndex}`;
-    }
-    namespaceIndex += 1;
-    return candidate;
-  };
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement)) {
-      continue;
-    }
-    const importClause = statement.importClause;
-    if (!importClause || !importClause.name) {
-      continue;
-    }
-    if (isTypeOnlyImportClause(ts, importClause)) {
-      continue;
-    }
-    if (!ts.isStringLiteral(statement.moduleSpecifier)) {
-      continue;
-    }
-    const moduleName = statement.moduleSpecifier.text;
-    const moduleKind = await resolveModuleKind(moduleName, normalizedId);
-    if (moduleKind === "unknown" || moduleKind === "unresolvable") {
-      continue;
-    }
-    const isESM = moduleKind === "esm";
-    const defaultName = importClause.name.text;
-    const replacementImports = [];
-    let namespaceName;
-    if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
-      namespaceName = importClause.namedBindings.name.text;
-      replacementImports.push(
-        `import * as ${namespaceName} from ${formatModuleSpecifier(moduleName)};`
-      );
-    } else {
-      namespaceName = usedNamespace("__screwUpDefaultImportModule");
-      replacementImports.push(
-        `import * as ${namespaceName} from ${formatModuleSpecifier(moduleName)};`
-      );
-      if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-        replacementImports.push(
-          buildNamedImport(moduleName, importClause.namedBindings)
-        );
-      }
-    }
-    const replacement = `${replacementImports.join("\n")}
-const ${defaultName} = __resolveDefaultExport(${namespaceName}, ${isESM});`;
-    edits.push({
-      start: statement.getStart(sourceFile),
-      end: statement.getEnd(),
-      text: replacement
-    });
-    needsHelper = true;
-  }
-  if (edits.length === 0) {
-    return { code, changed: false };
-  }
-  if (needsHelper && !helperPresent) {
-    const importStatements = sourceFile.statements.filter(
-      ts.isImportDeclaration
-    );
-    const lastImport = importStatements[importStatements.length - 1];
-    if (lastImport) {
-      const newline = code.includes("\r\n") ? "\r\n" : "\n";
-      const helperId = createCjsInteropHelperId(normalizedId);
-      edits.push({
-        start: lastImport.getEnd(),
-        end: lastImport.getEnd(),
-        text: `${newline}${buildHelperFunctionSource(helperId)}${newline}`
-      });
-    }
-  }
-  edits.sort((a, b) => b.start - a.start);
-  let nextCode = code;
-  for (const edit of edits) {
-    nextCode = nextCode.slice(0, edit.start) + edit.text + nextCode.slice(edit.end);
-  }
-  return { code: nextCode, changed: true };
-};
-const generateBanner = (metadata, outputKeys) => {
-  const parts = [];
-  for (const key of outputKeys) {
-    const value = metadata[key];
-    if (value) {
-      parts.push(`${key}: ${value}`);
-    }
-  }
-  return parts.length > 0 ? `/*!
- * ${parts.join("\n * ")}
- */` : "";
-};
-const insertBannerHeader = (content, banner) => {
-  const lines = content.split("\n");
-  if (lines.length > 0 && lines[0].startsWith("#!")) {
-    return lines[0] + "\n" + banner + "\n" + lines.slice(1).join("\n");
-  } else {
-    return banner + "\n" + content;
-  }
-};
-const splitShebang = (content) => {
-  if (!content.startsWith("#!")) {
-    return { shebang: "", rest: content };
-  }
-  const newlineIndex = content.indexOf("\n");
-  if (newlineIndex === -1) {
-    return { shebang: `${content}
-`, rest: "" };
-  }
-  return {
-    shebang: content.slice(0, newlineIndex + 1),
-    rest: content.slice(newlineIndex + 1)
-  };
-};
-const ensureTrailingNewline = (value, newline) => value.endsWith(newline) ? value : value + newline;
-const mergeBanners = (currentBanner, existingBanner) => {
-  if (!currentBanner) {
-    return existingBanner;
-  }
-  if (!existingBanner) {
-    return currentBanner;
-  }
-  if (existingBanner.includes(currentBanner)) {
-    return existingBanner;
-  }
-  const shebangMatch = existingBanner.match(/^(#![^\r\n]*)(\r?\n)?([\s\S]*)$/);
-  if (shebangMatch) {
-    const [, shebangLine, newlineSeq2 = "\n", rest = ""] = shebangMatch;
-    if (rest.startsWith(currentBanner)) {
-      return existingBanner;
-    }
-    const currentWithNewline2 = ensureTrailingNewline(currentBanner, newlineSeq2);
-    if (rest.length === 0) {
-      return `${shebangLine}${newlineSeq2}${currentWithNewline2}`;
-    }
-    return `${shebangLine}${newlineSeq2}${currentWithNewline2}${rest}`;
-  }
-  const newlineSeq = existingBanner.includes("\r\n") ? "\r\n" : "\n";
-  const currentWithNewline = ensureTrailingNewline(currentBanner, newlineSeq);
-  return `${currentWithNewline}${existingBanner}`;
-};
-const countInsertedLines = (bannerWithTrailingNewline) => {
-  return bannerWithTrailingNewline.split("\n").length - 1;
-};
-const stringifyAssetSource = (source) => typeof source === "string" ? source : Buffer.from(source).toString("utf-8");
-const applyLineOffsetToSourceMap = (source, lineOffset) => {
-  if (lineOffset <= 0) {
-    return void 0;
-  }
-  const original = stringifyAssetSource(source);
-  let map;
-  try {
-    map = JSON.parse(original);
-  } catch (e) {
-    return void 0;
-  }
-  if (!map || typeof map.mappings !== "string") {
-    return void 0;
-  }
-  const prefix = ";".repeat(lineOffset);
-  if (map.mappings.startsWith(prefix)) {
-    return void 0;
-  }
-  map.mappings = prefix + map.mappings;
-  const serialized = JSON.stringify(map);
-  return original.endsWith("\n") ? `${serialized}
-` : serialized;
-};
-const applyLineOffsetToSourceMapObject = (map, lineOffset) => {
-  if (!map || lineOffset <= 0 || typeof map.mappings !== "string") {
-    return;
-  }
-  const prefix = ";".repeat(lineOffset);
-  if (map.mappings.startsWith(prefix)) {
-    return;
-  }
-  map.mappings = prefix + map.mappings;
-};
-const screwUp = (options = {}) => {
-  const {
-    fixDefaultImport = true,
-    outputKeys = [
-      "name",
-      "version",
-      "description",
-      "author",
-      "license",
-      "repository.url",
-      "git.commit.hash"
-    ],
-    assetFilters = ["\\.d\\.ts$"],
-    outputMetadataFile = false,
-    outputMetadataFilePath = "src/generated/packageMetadata.ts",
-    outputMetadataKeys = [
-      "name",
-      "version",
-      "description",
-      "author",
-      "license",
-      "repository.url",
-      "git.commit.hash"
-    ],
-    checkWorkingDirectoryStatus = true,
-    alwaysOverrideVersionFromGit = true,
-    insertMetadataBanner = true
-  } = options;
-  const assetFiltersRegex = assetFilters.map((filter) => new RegExp(filter));
-  const generateMetadataSourceLocker = createMutex();
-  const resolveModuleKind = createNodeModuleKindResolver();
-  let typescriptPromise;
-  const loggerPrefix = `${name}-vite`;
-  let logger = createConsoleLogger(loggerPrefix);
-  let banner = "";
-  let metadata;
-  let projectRoot;
-  let fetchGitMetadata = () => Promise.resolve({});
-  const loadTypeScript = async () => {
-    if (!typescriptPromise) {
-      typescriptPromise = import("typescript").catch(() => void 0);
-    }
-    return typescriptPromise;
-  };
-  const resolveOutputBanner = async (outputOptions, chunk) => {
-    var _a, _b;
-    const outputBanner = outputOptions.banner;
-    if (typeof outputBanner === "function") {
-      const resolved = await outputBanner(chunk);
-      return (_a = resolved != null ? resolved : banner) != null ? _a : "";
-    }
-    return (_b = outputBanner != null ? outputBanner : banner) != null ? _b : "";
-  };
-  const generateMetadataSourceFiles = async () => {
-    const result = await resolvePackageMetadata(
-      projectRoot,
-      fetchGitMetadata,
-      alwaysOverrideVersionFromGit,
-      logger
-    );
-    metadata = result.metadata;
-    banner = generateBanner(metadata, outputKeys);
-    if (outputMetadataFile) {
-      const metadataSourceContent = generateMetadataFileContent(
-        metadata,
-        outputMetadataKeys
-      );
-      const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
-      const metadataWritten = await writeFileIfChanged(
-        metadataSourcePath,
-        metadataSourceContent,
-        "metadata source file",
-        logger
-      );
-      if (existsSync(metadataSourcePath)) {
-        const gitignoreWritten = await ensureMetadataGitignore(
-          metadataSourcePath,
-          logger
-        );
-        if (gitignoreWritten) {
-          logger.info(
-            `generateMetadataSourceFile: .gitignore is generated: ${join(
-              dirname(outputMetadataFilePath),
-              ".gitignore"
-            )}`
-          );
-        }
-      }
-      return metadataWritten;
-    }
-    return false;
-  };
-  const generateMetadataFileFromKeys = async (keys) => {
-    if (outputMetadataFile) {
-      const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
-      if (!existsSync(metadataSourcePath)) {
-        const dummyMetadata = {};
-        keys.forEach((key) => {
-          dummyMetadata[key] = "[Require first build]";
-        });
-        const dummyContent = generateMetadataFileContent(dummyMetadata, keys);
-        return await writeFileIfChanged(
-          metadataSourcePath,
-          dummyContent,
-          "dummy metadata source file",
-          logger
-        );
-      }
-    }
-    return false;
-  };
-  return {
-    name: "screw-up",
-    // Ensure screw-up runs before other plugins
-    // (especially vite-plugin-dts, avoid packageMetadata.ts is not found)
-    enforce: "pre",
-    // Plugin starting
-    applyToEnvironment: async (penv) => {
-      logger.info(`${version}-${git_commit_hash}: Started.`);
-      projectRoot = penv.config.root;
-      if (projectRoot && await generateMetadataFileFromKeys(outputMetadataKeys)) {
-        logger.info(
-          `applyToEnvironment: Dummy metadata source file is generated: ${outputMetadataFilePath}`
-        );
-      }
-      return true;
-    },
-    // Build configuration phase
-    config: (config) => {
-      var _a, _b, _c;
-      if (!insertMetadataBanner) {
-        return;
-      }
-      (_a = config.build) != null ? _a : config.build = {};
-      const rollupOptions = (_c = (_b = config.build).rollupOptions) != null ? _c : _b.rollupOptions = {};
-      const ensureOutputs = () => {
-        if (Array.isArray(rollupOptions.output)) {
-          const outputs2 = rollupOptions.output;
-          if (outputs2.length === 0) {
-            const output2 = {};
-            outputs2.push(output2);
-            return outputs2;
-          }
-          outputs2.forEach((output2, index) => {
-            if (!output2) {
-              outputs2[index] = {};
-            }
-          });
-          return outputs2;
-        }
-        if (rollupOptions.output) {
-          return [rollupOptions.output];
-        }
-        const output = {};
-        rollupOptions.output = output;
-        return [output];
-      };
-      const outputs = ensureOutputs();
-      outputs.forEach((output) => {
-        const previousBanner = output.banner;
-        const resolvePreviousBanner = async (chunk) => {
-          if (typeof previousBanner === "function") {
-            const resolved = await previousBanner(chunk);
-            return resolved != null ? resolved : "";
-          }
-          return previousBanner != null ? previousBanner : "";
-        };
-        output.banner = async (chunk) => {
-          const existingBanner = await resolvePreviousBanner(chunk);
-          const currentBanner = banner != null ? banner : "";
-          return mergeBanners(currentBanner, existingBanner);
-        };
-      });
-    },
-    transform: async (code, id) => {
-      if (!fixDefaultImport || !id || id.includes("\0")) {
-        return;
-      }
-      const cleanId = id.split("?")[0];
-      if (cleanId.includes("node_modules")) {
-        return;
-      }
-      if (cleanId.endsWith(".d.ts") || cleanId.endsWith(".d.mts") || cleanId.endsWith(".d.cts")) {
-        return;
-      }
-      if (!/\.(?:[cm]?[jt]sx?|[cm]js)$/.test(cleanId)) {
-        return;
-      }
-      const ts = await loadTypeScript();
-      if (!ts) {
-        return;
-      }
-      const hasDefaultImport = scanHasDefaultImport(ts, code);
-      if (cleanId.includes("/src/") || cleanId.includes("\\src\\")) {
-        logger.debug(
-          `[fixDefaultImport] scan ${cleanId}: ${hasDefaultImport ? "hit" : "miss"}`
-        );
-      }
-      if (!hasDefaultImport) {
-        return;
-      }
-      const result = await transformDefaultImports(
-        ts,
-        code,
-        cleanId,
-        resolveModuleKind
-      );
-      if (result.changed) {
-        return {
-          code: result.code,
-          map: null
-        };
-      }
-    },
-    // Configuration resolved phase
-    configResolved: async (config) => {
-      const l = await generateMetadataSourceLocker.lock();
-      try {
-        const tempEnableLogging = true;
-        projectRoot = config.root;
-        if (tempEnableLogging || (config == null ? void 0 : config.logger)) {
-          logger = createConsoleLogger(loggerPrefix, config.logger);
-        }
-        logger.debug(`configResolved: Started.`);
-        fetchGitMetadata = getFetchGitMetadata(
-          projectRoot,
-          checkWorkingDirectoryStatus,
-          logger
-        );
-        if (await generateMetadataSourceFiles()) {
-          logger.info(
-            `configResolved: Metadata source file is generated: ${outputMetadataFilePath}`
-          );
-        }
-      } finally {
-        logger.debug(`configResolved: Exited.`);
-        l.release();
-      }
-    },
-    // Server hook
-    configureServer: async (server) => {
-      const l = await generateMetadataSourceLocker.lock();
-      try {
-        logger.debug(`configureServer: Started.`);
-        if (outputMetadataFile && server.watcher) {
-          const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
-          server.watcher.unwatch(metadataSourcePath);
-          logger.debug(
-            `configureServer: Excluded from watcher: ${outputMetadataFilePath}`
-          );
-        }
-        if (await generateMetadataSourceFiles()) {
-          logger.info(
-            `configureServer: Metadata source file is generated: ${outputMetadataFilePath}`
-          );
-        }
-      } finally {
-        logger.debug(`configureServer: Exited.`);
-        l.release();
-      }
-    },
-    // Build start phase
-    buildStart: async () => {
-      const l = await generateMetadataSourceLocker.lock();
-      try {
-        logger.debug(`buildStart: Started.`);
-        if (await generateMetadataSourceFiles()) {
-          logger.info(
-            `buildStart: Metadata source file is generated: ${outputMetadataFilePath}`
-          );
-        }
-      } finally {
-        logger.debug(`buildStart: Exited.`);
-        l.release();
-      }
-    },
-    renderChunk: (code, chunk, outputOptions) => {
-      if (!fixDefaultImport || outputOptions.format !== "cjs") {
-        return null;
-      }
-      const result = injectCjsInteropFlag(code);
-      if (!result.changed) {
-        return null;
-      }
-      return { code: result.code, map: null };
-    },
-    // Generate bundle phase
-    generateBundle: {
-      order: "post",
-      handler: async (outputOptions, bundle) => {
-        if (insertMetadataBanner) {
-          let chunkCount = 0;
-          for (const fileName in bundle) {
-            const output = bundle[fileName];
-            if (output.type === "chunk") {
-              const chunk = output;
-              const resolvedBanner = await resolveOutputBanner(
-                outputOptions,
-                chunk
-              );
-              if (!resolvedBanner) {
-                continue;
-              }
-              const { shebang: bannerShebang, rest: bannerRest } = splitShebang(resolvedBanner);
-              const bannerCore = bannerRest.trimEnd();
-              if (!bannerCore || chunk.code.includes(bannerCore)) {
-                continue;
-              }
-              const originalCode = chunk.code;
-              let nextCode = originalCode;
-              if (bannerShebang && !nextCode.startsWith("#!")) {
-                nextCode = `${bannerShebang}${nextCode}`;
-              }
-              const bannerBlock = ensureTrailingNewline(bannerCore, "\n");
-              nextCode = insertBannerHeader(nextCode, bannerBlock);
-              if (nextCode === originalCode) {
-                continue;
-              }
-              const lineOffset = nextCode.split("\n").length - originalCode.split("\n").length;
-              chunk.code = nextCode;
-              if (lineOffset > 0 && chunk.map) {
-                applyLineOffsetToSourceMapObject(chunk.map, lineOffset);
-              }
-              const mapFileName = `${fileName}.map`;
-              const mapAsset = bundle[mapFileName];
-              if (lineOffset > 0 && mapAsset && mapAsset.type === "asset" && mapAsset.source !== void 0) {
-                const adjusted = applyLineOffsetToSourceMap(
-                  mapAsset.source,
-                  lineOffset
-                );
-                if (adjusted !== void 0) {
-                  mapAsset.source = adjusted;
-                }
-              }
-              chunkCount++;
-            }
-          }
-          if (chunkCount >= 1) {
-            logger.debug(
-              `generateBundle: Banner header reinserted: ${chunkCount} file(s)`
-            );
-          }
-          let assetCount = 0;
-          for (const fileName in bundle) {
-            const chunk = bundle[fileName];
-            if (
-              // Only treat assets that match filters; JS chunks already handled via rollup banner
-              chunk.type === "asset" && assetFiltersRegex.some((filter) => filter.test(fileName))
-            ) {
-              if (typeof chunk.source === "string") {
-                const bannerBlock = `${banner}
-`;
-                chunk.source = insertBannerHeader(chunk.source, bannerBlock);
-                const lineOffset = countInsertedLines(bannerBlock);
-                const mapFileName = `${fileName}.map`;
-                const mapAsset = bundle[mapFileName];
-                if (mapAsset && mapAsset.type === "asset" && mapAsset.source !== void 0) {
-                  const adjusted = applyLineOffsetToSourceMap(
-                    mapAsset.source,
-                    lineOffset
-                  );
-                  if (adjusted !== void 0) {
-                    mapAsset.source = adjusted;
-                  }
-                }
-                assetCount++;
-              }
-            }
-          }
-          if (assetCount >= 1) {
-            logger.debug(
-              `generateBundle: Banner header inserted: ${assetCount} file(s)`
-            );
-          }
-        }
-      }
-    },
-    // Write bundle phase
-    writeBundle: async (options2) => {
-      if (!insertMetadataBanner || !options2.dir) return;
-      try {
-        const files = await readdir(options2.dir, { recursive: true });
-        let count = 0;
-        for (const file of files) {
-          const filePath = join(options2.dir, file);
-          if (assetFiltersRegex.some((filter) => filter.test(file))) {
-            try {
-              const content = await readFile(filePath, "utf-8");
-              if (!content.includes(banner)) {
-                const bannerBlock = `${banner}
-`;
-                await writeFile(
-                  filePath,
-                  insertBannerHeader(content, bannerBlock)
-                );
-                const lineOffset = countInsertedLines(bannerBlock);
-                const mapPath = `${filePath}.map`;
-                try {
-                  const mapContent = await readFile(mapPath, "utf-8");
-                  const adjusted = applyLineOffsetToSourceMap(
-                    mapContent,
-                    lineOffset
-                  );
-                  if (adjusted !== void 0) {
-                    await writeFile(mapPath, adjusted);
-                  }
-                } catch (e) {
-                }
-                count++;
-              }
-            } catch (error) {
-            }
-          }
-        }
-        if (count >= 1) {
-          logger.debug(`writeBundle: Banner header inserted: ${count} file(s)`);
-        }
-      } catch (error) {
-      }
-    }
-  };
-};
-export {
-  screwUp as default
-};
-//# sourceMappingURL=index.mjs.map
+var injectCjsInteropFlag = (code) => {
+	let changed = false;
+	return {
+		code: code.replace(cjsInteropGlobalFlagAssignmentPattern, (match) => {
+			changed = true;
+			return match.replace(/\bfalse\b/, "true ");
+		}),
+		changed
+	};
+};
+var hasResolveDefaultExport = (ts, sourceFile) => {
+	return sourceFile.statements.some((statement) => {
+		if (ts.isFunctionDeclaration(statement)) {
+			var _statement$name;
+			return ((_statement$name = statement.name) === null || _statement$name === void 0 ? void 0 : _statement$name.text) === "__resolveDefaultExport";
+		}
+		if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => {
+			return ts.isIdentifier(declaration.name) && declaration.name.text === "__resolveDefaultExport";
+		});
+		if (ts.isImportDeclaration(statement)) {
+			var _importClause$name;
+			const importClause = statement.importClause;
+			if (!importClause) return false;
+			if (((_importClause$name = importClause.name) === null || _importClause$name === void 0 ? void 0 : _importClause$name.text) === "__resolveDefaultExport") return true;
+			if (importClause.namedBindings) {
+				if (ts.isNamespaceImport(importClause.namedBindings)) return importClause.namedBindings.name.text === "__resolveDefaultExport";
+				if (ts.isNamedImports(importClause.namedBindings)) return importClause.namedBindings.elements.some((element) => {
+					var _element$propertyName;
+					return element.name.text === "__resolveDefaultExport" || ((_element$propertyName = element.propertyName) === null || _element$propertyName === void 0 ? void 0 : _element$propertyName.text) === "__resolveDefaultExport";
+				});
+			}
+		}
+		return false;
+	});
+};
+var isTypeOnlyImportClause = (ts, importClause) => {
+	const phaseModifier = importClause.phaseModifier;
+	if (phaseModifier !== void 0) return phaseModifier === ts.SyntaxKind.TypeKeyword;
+	return Boolean(importClause.isTypeOnly);
+};
+var getScriptKind = (ts, id) => {
+	if (id.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (id.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (id.endsWith(".mts")) {
+		const mts = ts.ScriptKind["MTS"];
+		return mts !== null && mts !== void 0 ? mts : ts.ScriptKind.TS;
+	}
+	if (id.endsWith(".cts")) {
+		const cts = ts.ScriptKind["CTS"];
+		return cts !== null && cts !== void 0 ? cts : ts.ScriptKind.TS;
+	}
+	if (id.endsWith(".ts")) return ts.ScriptKind.TS;
+	if (id.endsWith(".mjs")) return ts.ScriptKind.JS;
+	if (id.endsWith(".cjs")) return ts.ScriptKind.JS;
+	return ts.ScriptKind.JS;
+};
+var formatModuleSpecifier = (specifier) => {
+	return `'${specifier.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+};
+var buildNamedImport = (moduleName, namedBindings) => {
+	return `import { ${namedBindings.elements.map((specifier) => {
+		const alias = specifier.propertyName ? `${specifier.propertyName.text} as ${specifier.name.text}` : specifier.name.text;
+		return specifier.isTypeOnly ? `type ${alias}` : alias;
+	}).join(", ")} } from ${formatModuleSpecifier(moduleName)};`;
+};
+var transformDefaultImports = async (ts, code, id, resolveModuleKind) => {
+	const normalizedId = stripQuery(id);
+	const sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.ESNext, false, getScriptKind(ts, normalizedId));
+	const edits = [];
+	let needsHelper = false;
+	const helperPresent = hasResolveDefaultExport(ts, sourceFile);
+	let namespaceIndex = 0;
+	const usedNamespace = (base) => {
+		let candidate = `${base}${namespaceIndex}`;
+		while (code.includes(candidate)) {
+			namespaceIndex += 1;
+			candidate = `${base}${namespaceIndex}`;
+		}
+		namespaceIndex += 1;
+		return candidate;
+	};
+	for (const statement of sourceFile.statements) {
+		var _namespaceName;
+		if (!ts.isImportDeclaration(statement)) continue;
+		const importClause = statement.importClause;
+		if (!importClause || !importClause.name) continue;
+		if (isTypeOnlyImportClause(ts, importClause)) continue;
+		if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const moduleName = statement.moduleSpecifier.text;
+		const moduleKind = await resolveModuleKind(moduleName, normalizedId);
+		if (moduleKind === "unknown" || moduleKind === "unresolvable") continue;
+		const isESM = moduleKind === "esm";
+		const isCJS = moduleKind === "cjs";
+		const defaultName = importClause.name.text;
+		const replacementImports = [];
+		let namespaceName;
+		let defaultImportName;
+		if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
+			namespaceName = importClause.namedBindings.name.text;
+			replacementImports.push(`import * as ${namespaceName} from ${formatModuleSpecifier(moduleName)};`);
+		} else if (isCJS) {
+			defaultImportName = usedNamespace("__screwUpDefaultImportModule");
+			replacementImports.push(`import ${defaultImportName} from ${formatModuleSpecifier(moduleName)};`);
+			if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) replacementImports.push(buildNamedImport(moduleName, importClause.namedBindings));
+		} else {
+			namespaceName = usedNamespace("__screwUpDefaultImportModule");
+			replacementImports.push(`import * as ${namespaceName} from ${formatModuleSpecifier(moduleName)};`);
+			if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) replacementImports.push(buildNamedImport(moduleName, importClause.namedBindings));
+		}
+		const interopSource = (_namespaceName = namespaceName) !== null && _namespaceName !== void 0 ? _namespaceName : defaultImportName;
+		const replacement = `${replacementImports.join("\n")}\nconst ${defaultName} = __resolveDefaultExport(${interopSource}, ${isESM});`;
+		edits.push({
+			start: statement.getStart(sourceFile),
+			end: statement.getEnd(),
+			text: replacement
+		});
+		needsHelper = true;
+	}
+	if (edits.length === 0) return {
+		code,
+		changed: false
+	};
+	if (needsHelper && !helperPresent) {
+		const importStatements = sourceFile.statements.filter(ts.isImportDeclaration);
+		const lastImport = importStatements[importStatements.length - 1];
+		if (lastImport) {
+			const newline = code.includes("\r\n") ? "\r\n" : "\n";
+			const helperId = createCjsInteropHelperId(normalizedId);
+			edits.push({
+				start: lastImport.getEnd(),
+				end: lastImport.getEnd(),
+				text: `${newline}${buildHelperFunctionSource(helperId)}${newline}`
+			});
+		}
+	}
+	edits.sort((a, b) => b.start - a.start);
+	let nextCode = code;
+	for (const edit of edits) nextCode = nextCode.slice(0, edit.start) + edit.text + nextCode.slice(edit.end);
+	return {
+		code: nextCode,
+		changed: true
+	};
+};
+//#endregion
+//#region src/vite-plugin.ts
+/**
+* Generate banner string from package.json metadata
+* @param metadata - Package metadata
+* @param outputKeys - Array of keys to output in specified order
+* @returns Banner string
+*/
+var generateBanner = (metadata, outputKeys) => {
+	const parts = [];
+	for (const key of outputKeys) {
+		const value = metadata[key];
+		if (value) parts.push(`${key}: ${value}`);
+	}
+	return parts.length > 0 ? `/*!\n * ${parts.join("\n * ")}\n */` : "";
+};
+/**
+* Insert banner header at appropriate position considering shebang
+* @param content - The content to insert banner into
+* @param banner - The banner header to insert
+* @returns Content with banner header inserted
+*/
+var insertBannerHeader = (content, banner) => {
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[0].startsWith("#!")) return lines[0] + "\n" + banner + "\n" + lines.slice(1).join("\n");
+	else return banner + "\n" + content;
+};
+/**
+* Adds a trailing newline to the banner text when needed so subsequent
+* concatenations do not collapse onto the last line.
+*/
+var ensureTrailingNewline = (value, newline) => value.endsWith(newline) ? value : value + newline;
+/**
+* Merge screw-up's metadata banner with an existing Rollup banner, keeping any
+* shebang line at the very top and preventing duplicate metadata blocks.
+*/
+var mergeBanners = (currentBanner, existingBanner) => {
+	if (!currentBanner) return existingBanner;
+	if (!existingBanner) return currentBanner;
+	if (existingBanner.includes(currentBanner)) return existingBanner;
+	const shebangMatch = existingBanner.match(/^(#![^\r\n]*)(\r?\n)?([\s\S]*)$/);
+	if (shebangMatch) {
+		const [, shebangLine, newlineSeq = "\n", rest = ""] = shebangMatch;
+		if (rest.startsWith(currentBanner)) return existingBanner;
+		const currentWithNewline = ensureTrailingNewline(currentBanner, newlineSeq);
+		if (rest.length === 0) return `${shebangLine}${newlineSeq}${currentWithNewline}`;
+		return `${shebangLine}${newlineSeq}${currentWithNewline}${rest}`;
+	}
+	return `${ensureTrailingNewline(currentBanner, existingBanner.includes("\r\n") ? "\r\n" : "\n")}${existingBanner}`;
+};
+/**
+* Count how many newline characters exist in the banner block.
+* The result equals the line delta that needs to be applied to sourcemaps.
+*/
+var countInsertedLines = (bannerWithTrailingNewline) => {
+	return bannerWithTrailingNewline.split("\n").length - 1;
+};
+/**
+* Convert asset payloads to UTF-8 strings to simplify sourcemap adjustments.
+*/
+var stringifyAssetSource = (source) => typeof source === "string" ? source : Buffer.from(source).toString("utf-8");
+/**
+* Prepend the specified number of empty lines to a sourcemap by adding semicolons
+* at the beginning of the VLQ mappings string.
+* @returns Updated sourcemap JSON string, or undefined if no change is needed.
+*/
+var applyLineOffsetToSourceMap = (source, lineOffset) => {
+	if (lineOffset <= 0) return;
+	const original = stringifyAssetSource(source);
+	let map;
+	try {
+		map = JSON.parse(original);
+	} catch (_unused) {
+		return;
+	}
+	if (!map || typeof map.mappings !== "string") return;
+	const prefix = ";".repeat(lineOffset);
+	if (map.mappings.startsWith(prefix)) return;
+	map.mappings = prefix + map.mappings;
+	const serialized = JSON.stringify(map);
+	return original.endsWith("\n") ? `${serialized}\n` : serialized;
+};
+/**
+* Vite plugin that adds banner to the bundled code
+* @param options - Plugin options
+* @returns Vite plugin
+*/
+var screwUp = (options = {}) => {
+	const { fixDefaultImport = true, outputKeys = [
+		"name",
+		"version",
+		"description",
+		"author",
+		"license",
+		"repository.url",
+		"git.commit.hash"
+	], assetFilters = ["\\.d\\.ts$"], outputMetadataFile = false, outputMetadataFilePath = "src/generated/packageMetadata.ts", outputMetadataKeys = [
+		"name",
+		"version",
+		"description",
+		"author",
+		"license",
+		"repository.url",
+		"git.commit.hash"
+	], checkWorkingDirectoryStatus = true, alwaysOverrideVersionFromGit = true, insertMetadataBanner = true } = options;
+	const assetFiltersRegex = assetFilters.map((filter) => new RegExp(filter));
+	const generateMetadataSourceLocker = createMutex();
+	const resolveModuleKind = createNodeModuleKindResolver();
+	let typescriptPromise;
+	const loggerPrefix = `${name}-vite`;
+	let logger = createConsoleLogger(loggerPrefix);
+	let banner = "";
+	let metadata;
+	let projectRoot;
+	let fetchGitMetadata = () => Promise.resolve({});
+	const loadTypeScript = async () => {
+		if (!typescriptPromise) typescriptPromise = import("typescript").catch(() => void 0);
+		return typescriptPromise;
+	};
+	const generateMetadataSourceFiles = async () => {
+		metadata = (await resolvePackageMetadata(projectRoot, fetchGitMetadata, alwaysOverrideVersionFromGit, logger)).metadata;
+		banner = generateBanner(metadata, outputKeys);
+		if (outputMetadataFile) {
+			const metadataSourceContent = generateMetadataFileContent(metadata, outputMetadataKeys);
+			const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
+			const metadataWritten = await writeFileIfChanged(metadataSourcePath, metadataSourceContent, "metadata source file", logger);
+			if (existsSync(metadataSourcePath)) {
+				if (await ensureMetadataGitignore(metadataSourcePath, logger)) logger.info(`generateMetadataSourceFile: .gitignore is generated: ${join(dirname(outputMetadataFilePath), ".gitignore")}`);
+			}
+			return metadataWritten;
+		}
+		return false;
+	};
+	const generateMetadataFileFromKeys = async (keys) => {
+		if (outputMetadataFile) {
+			const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
+			if (!existsSync(metadataSourcePath)) {
+				const dummyMetadata = {};
+				keys.forEach((key) => {
+					dummyMetadata[key] = "[Require first build]";
+				});
+				return await writeFileIfChanged(metadataSourcePath, generateMetadataFileContent(dummyMetadata, keys), "dummy metadata source file", logger);
+			}
+		}
+		return false;
+	};
+	return {
+		name: "screw-up",
+		enforce: "pre",
+		applyToEnvironment: async (penv) => {
+			logger.info(`${version}-${git_commit_hash}: Started.`);
+			projectRoot = penv.config.root;
+			if (projectRoot && await generateMetadataFileFromKeys(outputMetadataKeys)) logger.info(`applyToEnvironment: Dummy metadata source file is generated: ${outputMetadataFilePath}`);
+			return true;
+		},
+		config: (config) => {
+			var _config$build, _config$build2, _config$build2$rolldo;
+			if (!insertMetadataBanner) return;
+			(_config$build = config.build) !== null && _config$build !== void 0 || (config.build = {});
+			const rolldownOptions = (_config$build2$rolldo = (_config$build2 = config.build).rolldownOptions) !== null && _config$build2$rolldo !== void 0 ? _config$build2$rolldo : _config$build2.rolldownOptions = {};
+			const ensureOutputs = () => {
+				if (Array.isArray(rolldownOptions.output)) {
+					const outputs = rolldownOptions.output;
+					if (outputs.length === 0) {
+						outputs.push({});
+						return outputs;
+					}
+					outputs.forEach((output, index) => {
+						if (!output) outputs[index] = {};
+					});
+					return outputs;
+				}
+				if (rolldownOptions.output) return [rolldownOptions.output];
+				const output = {};
+				rolldownOptions.output = output;
+				return [output];
+			};
+			ensureOutputs().forEach((output) => {
+				const previousBanner = output.banner;
+				const resolvePreviousBanner = async (chunk) => {
+					if (typeof previousBanner === "function") {
+						const resolved = await previousBanner(chunk);
+						return resolved !== null && resolved !== void 0 ? resolved : "";
+					}
+					return previousBanner !== null && previousBanner !== void 0 ? previousBanner : "";
+				};
+				output.banner = async (chunk) => {
+					var _banner;
+					const existingBanner = await resolvePreviousBanner(chunk);
+					return mergeBanners((_banner = banner) !== null && _banner !== void 0 ? _banner : "", existingBanner);
+				};
+			});
+		},
+		transform: async (code, id) => {
+			if (!fixDefaultImport || !id || id.includes("\0")) return;
+			const cleanId = id.split("?")[0];
+			if (cleanId.includes("node_modules")) return;
+			if (cleanId.endsWith(".d.ts") || cleanId.endsWith(".d.mts") || cleanId.endsWith(".d.cts")) return;
+			if (!/\.(?:[cm]?[jt]sx?|[cm]js)$/.test(cleanId)) return;
+			const ts = await loadTypeScript();
+			if (!ts) return;
+			const hasDefaultImport = scanHasDefaultImport(ts, code);
+			if (cleanId.includes("/src/") || cleanId.includes("\\src\\")) logger.debug(`[fixDefaultImport] scan ${cleanId}: ${hasDefaultImport ? "hit" : "miss"}`);
+			if (!hasDefaultImport) return;
+			const result = await transformDefaultImports(ts, code, cleanId, resolveModuleKind);
+			if (result.changed) return {
+				code: result.code,
+				map: null
+			};
+		},
+		configResolved: async (config) => {
+			const l = await generateMetadataSourceLocker.lock();
+			try {
+				projectRoot = config.root;
+				logger = createConsoleLogger(loggerPrefix, config.logger);
+				logger.debug(`configResolved: Started.`);
+				fetchGitMetadata = getFetchGitMetadata(projectRoot, checkWorkingDirectoryStatus, logger);
+				if (await generateMetadataSourceFiles()) logger.info(`configResolved: Metadata source file is generated: ${outputMetadataFilePath}`);
+			} finally {
+				logger.debug(`configResolved: Exited.`);
+				l.release();
+			}
+		},
+		configureServer: async (server) => {
+			const l = await generateMetadataSourceLocker.lock();
+			try {
+				logger.debug(`configureServer: Started.`);
+				if (outputMetadataFile && server.watcher) {
+					const metadataSourcePath = join(projectRoot, outputMetadataFilePath);
+					server.watcher.unwatch(metadataSourcePath);
+					logger.debug(`configureServer: Excluded from watcher: ${outputMetadataFilePath}`);
+				}
+				if (await generateMetadataSourceFiles()) logger.info(`configureServer: Metadata source file is generated: ${outputMetadataFilePath}`);
+			} finally {
+				logger.debug(`configureServer: Exited.`);
+				l.release();
+			}
+		},
+		buildStart: async () => {
+			const l = await generateMetadataSourceLocker.lock();
+			try {
+				logger.debug(`buildStart: Started.`);
+				if (await generateMetadataSourceFiles()) logger.info(`buildStart: Metadata source file is generated: ${outputMetadataFilePath}`);
+			} finally {
+				logger.debug(`buildStart: Exited.`);
+				l.release();
+			}
+		},
+		renderChunk: (code, chunk, outputOptions) => {
+			if (!fixDefaultImport || outputOptions.format !== "cjs") return null;
+			const result = injectCjsInteropFlag(code);
+			if (!result.changed) return null;
+			return {
+				code: result.code,
+				map: null
+			};
+		},
+		generateBundle: {
+			order: "post",
+			handler: async (_outputOptions, bundle) => {
+				if (insertMetadataBanner) {
+					let assetCount = 0;
+					for (const fileName in bundle) {
+						const chunk = bundle[fileName];
+						if (chunk.type === "asset" && assetFiltersRegex.some((filter) => filter.test(fileName))) {
+							if (typeof chunk.source === "string") {
+								const bannerBlock = `${banner}\n`;
+								chunk.source = insertBannerHeader(chunk.source, bannerBlock);
+								const lineOffset = countInsertedLines(bannerBlock);
+								const mapAsset = bundle[`${fileName}.map`];
+								if (mapAsset && mapAsset.type === "asset" && mapAsset.source !== void 0) {
+									const adjusted = applyLineOffsetToSourceMap(mapAsset.source, lineOffset);
+									if (adjusted !== void 0) mapAsset.source = adjusted;
+								}
+								assetCount++;
+							}
+						}
+					}
+					if (assetCount >= 1) logger.debug(`generateBundle: Banner header inserted: ${assetCount} file(s)`);
+				}
+			}
+		},
+		writeBundle: async (options) => {
+			if (!insertMetadataBanner || !options.dir) return;
+			try {
+				const files = await readdir(options.dir, { recursive: true });
+				let count = 0;
+				for (const file of files) {
+					const filePath = join(options.dir, file);
+					if (assetFiltersRegex.some((filter) => filter.test(file))) try {
+						const content = await readFile(filePath, "utf-8");
+						if (!content.includes(banner)) {
+							const bannerBlock = `${banner}\n`;
+							await writeFile(filePath, insertBannerHeader(content, bannerBlock));
+							const lineOffset = countInsertedLines(bannerBlock);
+							const mapPath = `${filePath}.map`;
+							try {
+								const adjusted = applyLineOffsetToSourceMap(await readFile(mapPath, "utf-8"), lineOffset);
+								if (adjusted !== void 0) await writeFile(mapPath, adjusted);
+							} catch (_unused2) {}
+							count++;
+						}
+					} catch (error) {}
+				}
+				if (count >= 1) logger.debug(`writeBundle: Banner header inserted: ${count} file(s)`);
+			} catch (error) {}
+		}
+	};
+};
+//#endregion
+//#region src/index.ts
+var src_default = screwUp;
+//#endregion
+export { src_default as default };
+
+//# sourceMappingURL=index.mjs.map