screw-up 1.29.0 → 1.31.0

package/dist/index.cjs

@@ -1,11 +1,11 @@
 /*!
 * name: screw-up
-* version: 1.29.0
+* version: 1.31.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: 3833f6ef842d9e5a0b4f7277ca3b118f26fd4a6b
+* git.commit.hash: ebb41ebf06ebe1bec39a3770c70a62cb95b4b7d6
 */
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -41,12 +41,15 @@ let crypto$1 = require("crypto");
 //#region node_modules/async-primitives/dist/index.mjs
 /*!
 * name: async-primitives
-* version: 1.5.0
+* version: 1.7.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
+* git.commit.hash: 9472fbd5310b92690d84aaafb897429a04c013c5
+*/
+/**
+* A no-op Releasable object that does nothing when released or disposed
 */
 var __NOOP_HANDLER = () => {};
 var __NOOP_RELEASABLE = {
@@ -58,6 +61,12 @@ var toAbortError = (reason) => {
 	if (typeof reason === "string") return new Error(reason);
 	return /* @__PURE__ */ new Error("Operation aborted");
 };
+/**
+* Hooks up an abort handler to an AbortSignal and returns a handle for early cleanup
+* @param signal - The AbortSignal to hook up to
+* @param callback - The callback to call when the signal is aborted
+* @returns A Releasable handle that can be used to remove the abort listener early
+*/
 var onAbort = (signal, callback) => {
 	if (!signal) return __NOOP_RELEASABLE;
 	if (signal.aborted) {
@@ -92,11 +101,21 @@ var onAbort = (signal, callback) => {
 		[Symbol.dispose]: release
 	};
 };
+var runtimeGlobal$1 = globalThis;
 var defer = (fn) => {
-	if (typeof setImmediate === "function") setImmediate(fn);
-	else setTimeout(fn, 0);
+	const setImmediateHandler = runtimeGlobal$1.setImmediate;
+	if (typeof setImmediateHandler === "function") {
+		setImmediateHandler(fn);
+		return;
+	}
+	globalThis.setTimeout(fn, 0);
 };
 var ABORTED_ERROR$2 = () => /* @__PURE__ */ new Error("Lock acquisition was aborted");
+/**
+* Creates a new LockHandle instance
+* @param releaseCallback Callback function to release the lock
+* @returns A LockHandle object with release and dispose functionality
+*/
 var createLockHandle = (releaseCallback) => {
 	let isActive = true;
 	const release = () => {
@@ -112,15 +131,20 @@ var createLockHandle = (releaseCallback) => {
 		[Symbol.dispose]: release
 	};
 };
+/**
+* Creates a new Mutex instance
+* @param maxConsecutiveCalls - The maximum number of consecutive calls to the lockAsync method before yielding control to the next item in the queue
+* @returns A new Mutex for promise-based mutex operations
+*/
 var createMutex = (maxConsecutiveCalls = 20) => {
 	let isLocked = false;
 	const queue = [];
 	let count = 0;
 	const processQueue = () => {
-		var _a;
+		var _item$signal;
 		if (isLocked || queue.length === 0) return;
 		const item = queue.shift();
-		if ((_a = item.signal) == null ? void 0 : _a.aborted) {
+		if ((_item$signal = item.signal) === null || _item$signal === void 0 ? void 0 : _item$signal.aborted) {
 			item.reject(ABORTED_ERROR$2());
 			scheduleNextProcess();
 			return;
@@ -198,8 +222,8 @@ createLogicalContext(Symbol("[root]"));
 //#endregion
 //#region src/generated/packageMetadata.ts
 var name = "screw-up";
-var version = "1.29.0";
-var git_commit_hash = "3833f6ef842d9e5a0b4f7277ca3b118f26fd4a6b";
+var version = "1.31.0";
+var git_commit_hash = "ebb41ebf06ebe1bec39a3770c70a62cb95b4b7d6";
 //#endregion
 //#region node_modules/json5/dist/index.js
 var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -1662,10 +1686,10 @@ var require_dayjs_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region src/internal.ts
 var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
 var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
-var JSON5 = __resolveDefaultExport$2(import_dist.default, false);
-var dayjs$1 = __resolveDefaultExport$2(import_dayjs_min.default, false);
+var JSON5 = __resolveDefaultExport$3(import_dist.default, false);
+var dayjs$1 = __resolveDefaultExport$3(import_dayjs_min.default, false);
 globalThis.__screwUpIsInCJS_db7919f73ec9 = true;
-function __resolveDefaultExport$2(module, isESM) {
+function __resolveDefaultExport$3(module, isESM) {
 	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_db7919f73ec9 === true;
 	const maybe = module;
 	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
@@ -1826,6 +1850,60 @@ var resolvePackageMetadata = async (projectRoot, fetchGitMetadata, alwaysOverrid
 	};
 };
 //#endregion
+//#region src/git-ref-utils.ts
+var git$1 = __resolveDefaultExport$2(isomorphic_git.default, false);
+globalThis.__screwUpIsInCJS_89cc61422477 = true;
+function __resolveDefaultExport$2(module, isESM) {
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_89cc61422477 === true;
+	const maybe = module;
+	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+	const unwrapNamespaceDefault = (value) => {
+		if (!value || typeof value !== "object") return value;
+		const inner = value;
+		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
+		return value;
+	};
+	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+	if (__isInCJS) return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
+	if (isESM) {
+		if (hasDefault) return resolvedDefault;
+		throw new Error("Default export not found.");
+	}
+	return hasDefault ? resolvedDefault !== null && resolvedDefault !== void 0 ? resolvedDefault : module : module;
+}
+/**
+* Resolve the actual Git directory for repositories, worktrees, and submodules.
+* @param repoPath - Repository path
+* @returns The resolved Git directory path
+*/
+var getActualGitDir = async (repoPath) => {
+	const gitDir = (0, path.join)(repoPath, ".git");
+	const gitStat = await (0, fs_promises.stat)(gitDir).catch(() => null);
+	if (!(gitStat === null || gitStat === void 0 ? void 0 : gitStat.isFile())) return gitDir;
+	const match = (await (0, fs_promises.readFile)(gitDir, "utf-8")).match(/^gitdir:\s*(.+)$/m);
+	if (!match) return gitDir;
+	return (0, path.isAbsolute)(match[1]) ? match[1] : (0, path.join)(repoPath, match[1]);
+};
+/**
+* Resolve a tag object OID to the commit OID it ultimately points to.
+* Lightweight tags are returned unchanged.
+* @param repoPath - Repository path
+* @param tagOid - Tag or commit OID
+* @returns Commit hash this tag points to
+*/
+var resolveTagOidToCommit = async (repoPath, tagOid) => {
+	try {
+		var _tagObject$tag;
+		const tagObject = await git$1.readTag({
+			fs: fs_promises.default,
+			dir: repoPath,
+			oid: tagOid
+		});
+		if (tagObject === null || tagObject === void 0 || (_tagObject$tag = tagObject.tag) === null || _tagObject$tag === void 0 ? void 0 : _tagObject$tag.object) return tagObject.tag.object;
+	} catch (_unused) {}
+	return tagOid;
+};
+//#endregion
 //#region src/fast-tags.ts
 /**
 * Fast tag listing implementation that reads tags directly from filesystem
@@ -1876,13 +1954,7 @@ var readLooseTags = async (refsTagsPath) => {
 * @returns Array of all tag names
 */
 var listTagsFast = async (repoPath) => {
-	const gitDir = (0, path.join)(repoPath, ".git");
-	const gitStat = await (0, fs_promises.stat)(gitDir).catch(() => null);
-	let actualGitDir = gitDir;
-	if (gitStat === null || gitStat === void 0 ? void 0 : gitStat.isFile()) {
-		const match = (await (0, fs_promises.readFile)(gitDir, "utf-8")).match(/^gitdir:\s*(.+)$/m);
-		if (match) actualGitDir = (0, path.isAbsolute)(match[1]) ? match[1] : (0, path.join)(repoPath, match[1]);
-	}
+	const actualGitDir = await getActualGitDir(repoPath);
 	const [packedTags, looseTags] = await Promise.all([parsePackedRefs((0, path.join)(actualGitDir, "packed-refs")), readLooseTags((0, path.join)(actualGitDir, "refs", "tags"))]);
 	const allTags = new Set([...packedTags, ...looseTags]);
 	return Array.from(allTags).sort();
@@ -1895,14 +1967,8 @@ var listTagsFast = async (repoPath) => {
 */
 var resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
 	const startTime = Date.now();
-	const gitDir = (0, path.join)(repoPath, ".git");
 	const result = /* @__PURE__ */ new Map();
-	const gitStat = await (0, fs_promises.stat)(gitDir).catch(() => null);
-	let actualGitDir = gitDir;
-	if (gitStat === null || gitStat === void 0 ? void 0 : gitStat.isFile()) {
-		const match = (await (0, fs_promises.readFile)(gitDir, "utf-8")).match(/^gitdir:\s*(.+)$/m);
-		if (match) actualGitDir = (0, path.isAbsolute)(match[1]) ? match[1] : (0, path.join)(repoPath, match[1]);
-	}
+	const actualGitDir = await getActualGitDir(repoPath);
 	const tagSet = new Set(tagNames);
 	const packedRefsStart = Date.now();
 	try {
@@ -1933,16 +1999,7 @@ var resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
 			const looseRefPath = (0, path.join)(actualGitDir, "refs", "tags", tagName);
 			try {
 				const oid = (await (0, fs_promises.readFile)(looseRefPath, "utf-8")).trim();
-				let commitOid = oid;
-				try {
-					const { execSync } = require("child_process");
-					if (execSync(`git -C "${repoPath}" cat-file -t ${oid}`, { encoding: "utf-8" }).trim() === "tag") {
-						const objectMatch = execSync(`git -C "${repoPath}" cat-file -p ${oid}`, { encoding: "utf-8" }).match(/^object ([0-9a-f]{40})$/m);
-						if (objectMatch) commitOid = objectMatch[1];
-					}
-				} catch (error) {
-					logger.debug(`[fast-tags] Could not determine object type for ${tagName}: ${error}`);
-				}
+				const commitOid = await resolveTagOidToCommit(repoPath, oid);
 				result.set(tagName, {
 					oid,
 					commitOid
@@ -2458,6 +2515,375 @@ var getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) => {
 	};
 };
 //#endregion
+//#region node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt[reader.next()];
+		value |= (integer & 31) << shift;
+		shift += 5;
+	} while (integer & 32);
+	const shouldNegate = value & 1;
+	value >>>= 1;
+	if (shouldNegate) value = -2147483648 | -value;
+	return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+	let delta = num - relative;
+	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+	do {
+		let clamped = delta & 31;
+		delta >>>= 5;
+		if (delta > 0) clamped |= 32;
+		builder.write(intToChar[clamped]);
+	} while (delta > 0);
+	return num;
+}
+function hasMoreVlq(reader, max) {
+	if (reader.pos >= max) return false;
+	return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+var StringReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.buffer = buffer;
+	}
+	next() {
+		return this.buffer.charCodeAt(this.pos++);
+	}
+	peek() {
+		return this.buffer.charCodeAt(this.pos);
+	}
+	indexOf(char) {
+		const { buffer, pos } = this;
+		const idx = buffer.indexOf(char, pos);
+		return idx === -1 ? buffer.length : idx;
+	}
+};
+function decode(mappings) {
+	const { length } = mappings;
+	const reader = new StringReader(mappings);
+	const decoded = [];
+	let genColumn = 0;
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	do {
+		const semi = reader.indexOf(";");
+		const line = [];
+		let sorted = true;
+		let lastCol = 0;
+		genColumn = 0;
+		while (reader.pos < semi) {
+			let seg;
+			genColumn = decodeInteger(reader, genColumn);
+			if (genColumn < lastCol) sorted = false;
+			lastCol = genColumn;
+			if (hasMoreVlq(reader, semi)) {
+				sourcesIndex = decodeInteger(reader, sourcesIndex);
+				sourceLine = decodeInteger(reader, sourceLine);
+				sourceColumn = decodeInteger(reader, sourceColumn);
+				if (hasMoreVlq(reader, semi)) {
+					namesIndex = decodeInteger(reader, namesIndex);
+					seg = [
+						genColumn,
+						sourcesIndex,
+						sourceLine,
+						sourceColumn,
+						namesIndex
+					];
+				} else seg = [
+					genColumn,
+					sourcesIndex,
+					sourceLine,
+					sourceColumn
+				];
+			} else seg = [genColumn];
+			line.push(seg);
+			reader.pos++;
+		}
+		if (!sorted) sort(line);
+		decoded.push(line);
+		reader.pos = semi + 1;
+	} while (reader.pos <= length);
+	return decoded;
+}
+function sort(line) {
+	line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+	return a[0] - b[0];
+}
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			genColumn = encodeInteger(writer, segment[0], genColumn);
+			if (segment.length === 1) continue;
+			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+			sourceLine = encodeInteger(writer, segment[2], sourceLine);
+			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+			if (segment.length === 4) continue;
+			namesIndex = encodeInteger(writer, segment[4], namesIndex);
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region src/text-edits.ts
+var readNewlineAt = (value, index) => {
+	if (index < 0 || index >= value.length) return;
+	if (value.startsWith("\r\n", index)) return "\r\n";
+	const char = value[index];
+	if (char === "\n" || char === "\r") return char;
+};
+var findFirstNewline = (value) => {
+	for (let index = 0; index < value.length; index++) {
+		const newline = readNewlineAt(value, index);
+		if (newline) return newline;
+	}
+};
+var findPreviousNewline = (value, index) => {
+	for (let current = index - 1; current >= 0; current--) {
+		if (value[current] === "\n") return current > 0 && value[current - 1] === "\r" ? "\r\n" : "\n";
+		if (value[current] === "\r") return "\r";
+	}
+};
+var applyTextEdits = (value, edits) => {
+	if (edits.length === 0) return value;
+	const sorted = [...edits].sort((lhs, rhs) => rhs.start - lhs.start);
+	let result = value;
+	let previousStart = value.length;
+	for (const edit of sorted) {
+		if (edit.start > edit.end) throw new Error(`Invalid text edit range: ${edit.start} > ${edit.end}`);
+		if (edit.end > previousStart) throw new Error("Overlapping text edits are not supported");
+		result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+		previousStart = edit.start;
+	}
+	return result;
+};
+var detectPreferredNewline = (value, start, end) => {
+	var _findFirstNewline;
+	const within = findFirstNewline(value.slice(start, end));
+	if (within) return within;
+	const adjacent = readNewlineAt(value, end);
+	if (adjacent) return adjacent;
+	const after = findFirstNewline(value.slice(end));
+	if (after) return after;
+	const before = findPreviousNewline(value, start);
+	if (before) return before;
+	return (_findFirstNewline = findFirstNewline(value)) !== null && _findFirstNewline !== void 0 ? _findFirstNewline : "\n";
+};
+var collectLineStarts = (value) => {
+	const starts = [0];
+	for (let index = 0; index < value.length; index++) {
+		const char = value[index];
+		if (char === "\r") {
+			if (value[index + 1] === "\n") index += 1;
+			starts.push(index + 1);
+			continue;
+		}
+		if (char === "\n") starts.push(index + 1);
+	}
+	return starts;
+};
+var getLineColumnOffset = (lineStarts, offset) => {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const lineStart = lineStarts[middle];
+		const nextStart = middle + 1 < lineStarts.length ? lineStarts[middle + 1] : Number.MAX_SAFE_INTEGER;
+		if (offset < lineStart) {
+			high = middle - 1;
+			continue;
+		}
+		if (offset >= nextStart) {
+			low = middle + 1;
+			continue;
+		}
+		return {
+			line: middle,
+			column: offset - lineStart
+		};
+	}
+	const lastLine = Math.max(0, lineStarts.length - 1);
+	return {
+		line: lastLine,
+		column: offset - lineStarts[lastLine]
+	};
+};
+//#endregion
+//#region src/declaration-import-fix.ts
+var declarationFilePattern = /\.d\.(?:cts|mts|ts)$/;
+var isRelativeSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../");
+var hasExplicitExtension = (specifier) => path.posix.extname(specifier) !== "";
+var getDeclarationRuntimeSuffix = (declarationPath) => {
+	if (declarationPath.endsWith(".d.mts")) return ".mjs";
+	if (declarationPath.endsWith(".d.cts")) return ".cjs";
+	return ".js";
+};
+var createCandidateDeclarationPaths = (resolvedPath) => [
+	`${resolvedPath}.d.ts`,
+	`${resolvedPath}.d.mts`,
+	`${resolvedPath}.d.cts`,
+	(0, path.join)(resolvedPath, "index.d.ts"),
+	(0, path.join)(resolvedPath, "index.d.mts"),
+	(0, path.join)(resolvedPath, "index.d.cts")
+];
+var resolveSpecifierSuffix = (specifier, importerPath, declarationFiles, logger) => {
+	if (!isRelativeSpecifier(specifier) || hasExplicitExtension(specifier)) return;
+	const resolvedPath = (0, path.resolve)((0, path.dirname)(importerPath), specifier);
+	const matches = createCandidateDeclarationPaths(resolvedPath).filter((path$1) => declarationFiles.has(path$1));
+	if (matches.length === 0) return;
+	if (matches.length >= 2) {
+		logger === null || logger === void 0 || logger.warn(`[fixDeclarationImports] Skipped ambiguous declaration import: ${specifier} (${matches.map((path$2) => {
+			var _path$split$pop;
+			return (_path$split$pop = path$2.split(/[/\\]/).pop()) !== null && _path$split$pop !== void 0 ? _path$split$pop : path$2;
+		}).join(", ")})`);
+		return;
+	}
+	const match = matches[0];
+	const runtimeSuffix = getDeclarationRuntimeSuffix(match);
+	const indexPrefix = (0, path.join)(resolvedPath, "index.");
+	return match.startsWith(indexPrefix) ? `/index${runtimeSuffix}` : runtimeSuffix;
+};
+var collectModuleSpecifierEdits = (ts, sourceFile, importerPath, declarationFiles, logger) => {
+	const edits = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pushSpecifierEdit = (literal) => {
+		const suffix = resolveSpecifierSuffix(literal.text, importerPath, declarationFiles, logger);
+		if (!suffix) return;
+		const insertionPoint = literal.getEnd() - 1;
+		if (seen.has(insertionPoint)) return;
+		seen.add(insertionPoint);
+		edits.push({
+			start: insertionPoint,
+			end: insertionPoint,
+			text: suffix
+		});
+	};
+	const visit = (node) => {
+		if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+			if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) pushSpecifierEdit(node.moduleSpecifier);
+		} else if (ts.isImportTypeNode(node)) {
+			const argument = node.argument;
+			if (ts.isLiteralTypeNode(argument) && ts.isStringLiteralLike(argument.literal)) pushSpecifierEdit(argument.literal);
+		}
+		node.forEachChild(visit);
+	};
+	sourceFile.forEachChild(visit);
+	return edits;
+};
+var isDeclarationFilePath = (filePath) => declarationFilePattern.test(filePath);
+var fixDeclarationImportSpecifiers = (ts, code, filePath, declarationFiles, logger) => {
+	const edits = collectModuleSpecifierEdits(ts, ts.createSourceFile(filePath, code, ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS), filePath, declarationFiles, logger);
+	if (edits.length === 0) return {
+		changed: false,
+		code,
+		edits
+	};
+	return {
+		changed: true,
+		code: applyTextEdits(code, edits),
+		edits
+	};
+};
+var adjustSourceMapForDeclarationEdits = (source, originalCode, edits) => {
+	if (edits.length === 0) return;
+	const original = typeof source === "string" ? source : Buffer.from(source).toString("utf-8");
+	let map;
+	try {
+		map = JSON.parse(original);
+	} catch (_unused) {
+		return;
+	}
+	if (!map || typeof map.mappings !== "string") return;
+	const lineStarts = collectLineStarts(originalCode);
+	const lineDeltas = /* @__PURE__ */ new Map();
+	for (const edit of edits) {
+		var _lineDeltas$get;
+		if (edit.start !== edit.end) return;
+		if (edit.text.includes("\n") || edit.text.includes("\r")) return;
+		const position = getLineColumnOffset(lineStarts, edit.start);
+		const entries = (_lineDeltas$get = lineDeltas.get(position.line)) !== null && _lineDeltas$get !== void 0 ? _lineDeltas$get : [];
+		entries.push({
+			column: position.column,
+			delta: edit.text.length
+		});
+		lineDeltas.set(position.line, entries);
+	}
+	if (lineDeltas.size === 0) return;
+	const decodedMappings = decode(map.mappings);
+	for (const [line, entries] of lineDeltas.entries()) {
+		const segments = decodedMappings[line];
+		if (!segments || segments.length === 0) continue;
+		const sortedEntries = [...entries].sort((lhs, rhs) => lhs.column - rhs.column);
+		let entryIndex = 0;
+		let cumulativeDelta = 0;
+		for (const segment of segments) {
+			while (entryIndex < sortedEntries.length && sortedEntries[entryIndex].column <= segment[0]) {
+				cumulativeDelta += sortedEntries[entryIndex].delta;
+				entryIndex += 1;
+			}
+			segment[0] += cumulativeDelta;
+		}
+	}
+	map.mappings = encode(decodedMappings);
+	const serialized = JSON.stringify(map);
+	return original.endsWith("\n") ? `${serialized}\n` : serialized;
+};
+//#endregion
 //#region src/default-import-fix.ts
 var importConditions = [
 	"import",
@@ -2599,45 +3025,46 @@ var cjsInteropGlobalFlagAssignmentPattern = new RegExp(`\\bglobalThis\\.${cjsInt
 var createCjsInteropHelperId = (seed) => {
 	return (0, crypto$1.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 =
-    typeof globalThis !== 'undefined' &&
-    (globalThis as any).${cjsInteropGlobalFlagPrefix}${helperId} === true;
-  const maybe = module as { default?: T };
-  const hasDefault = !!(maybe && typeof maybe === 'object' && 'default' in maybe);
-  const unwrapNamespaceDefault = (value: unknown): unknown => {
-    if (!value || typeof value !== 'object') {
-      return value;
-    }
-    const inner = value as any;
-    const isModule =
-      inner.__esModule === true ||
-      (typeof Symbol !== 'undefined' &&
-        (inner as any)[Symbol.toStringTag] === 'Module');
-    if (isModule && 'default' in inner) {
-      return inner.default;
-    }
-    return value;
-  };
-  const resolvedDefault = hasDefault
-    ? unwrapNamespaceDefault((maybe as any).default)
-    : undefined;
-
-  if (__isInCJS) {
-    return hasDefault ? ((resolvedDefault as T) ?? (module as T)) : (module as T);
-  }
-
-  if (isESM) {
-    if (hasDefault) {
-      return resolvedDefault as T;
-    }
-    throw new Error('Default export not found.');
-  }
-
-  return hasDefault ? ((resolvedDefault as T) ?? (module as T)) : (module as T);
-}`;
+var buildHelperFunctionSource = (helperId, newline) => [
+	`globalThis.${cjsInteropGlobalFlagPrefix}${helperId} = false;`,
+	"function __resolveDefaultExport<T>(module: T | { default?: T }, isESM: boolean): T {",
+	"  const __isInCJS =",
+	"    typeof globalThis !== 'undefined' &&",
+	`    (globalThis as any).${cjsInteropGlobalFlagPrefix}${helperId} === true;`,
+	"  const maybe = module as { default?: T };",
+	"  const hasDefault = !!(maybe && typeof maybe === 'object' && 'default' in maybe);",
+	"  const unwrapNamespaceDefault = (value: unknown): unknown => {",
+	"    if (!value || typeof value !== 'object') {",
+	"      return value;",
+	"    }",
+	"    const inner = value as any;",
+	"    const isModule =",
+	"      inner.__esModule === true ||",
+	"      (typeof Symbol !== 'undefined' &&",
+	"        (inner as any)[Symbol.toStringTag] === 'Module');",
+	"    if (isModule && 'default' in inner) {",
+	"      return inner.default;",
+	"    }",
+	"    return value;",
+	"  };",
+	"  const resolvedDefault = hasDefault",
+	"    ? unwrapNamespaceDefault((maybe as any).default)",
+	"    : undefined;",
+	"",
+	"  if (__isInCJS) {",
+	"    return hasDefault ? ((resolvedDefault as T) ?? (module as T)) : (module as T);",
+	"  }",
+	"",
+	"  if (isESM) {",
+	"    if (hasDefault) {",
+	"      return resolvedDefault as T;",
+	"    }",
+	"    throw new Error('Default export not found.');",
+	"  }",
+	"",
+	"  return hasDefault ? ((resolvedDefault as T) ?? (module as T)) : (module as T);",
+	"}"
+].join(newline);
 var injectCjsInteropFlag = (code) => {
 	let changed = false;
 	return {
@@ -2748,7 +3175,8 @@ var transformDefaultImports = async (ts, code, id, resolveModuleKind) => {
 			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});`;
+		const newline = detectPreferredNewline(code, statement.getStart(sourceFile), statement.getEnd());
+		const replacement = `${replacementImports.join(newline)}${newline}const ${defaultName} = __resolveDefaultExport(${interopSource}, ${isESM});`;
 		edits.push({
 			start: statement.getStart(sourceFile),
 			end: statement.getEnd(),
@@ -2764,20 +3192,17 @@ var transformDefaultImports = async (ts, code, id, resolveModuleKind) => {
 		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 newline = detectPreferredNewline(code, lastImport.getStart(sourceFile), lastImport.getEnd());
 			const helperId = createCjsInteropHelperId(normalizedId);
 			edits.push({
 				start: lastImport.getEnd(),
 				end: lastImport.getEnd(),
-				text: `${newline}${buildHelperFunctionSource(helperId)}${newline}`
+				text: `${newline}${buildHelperFunctionSource(helperId, newline)}${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,
+		code: applyTextEdits(code, edits),
 		changed: true
 	};
 };
@@ -2949,7 +3374,7 @@ var screwUp = (options = {}) => {
 		"license",
 		"repository.url",
 		"git.commit.hash"
-	], checkWorkingDirectoryStatus = true, alwaysOverrideVersionFromGit = true, insertMetadataBanner = true } = options;
+	], checkWorkingDirectoryStatus = true, alwaysOverrideVersionFromGit = true, insertMetadataBanner = true, fixDeclarationImportExtensions = true } = options;
 	const assetFiltersRegex = assetFilters.map((filter) => new RegExp(filter));
 	const generateMetadataSourceLocker = createMutex();
 	const resolveModuleKind = createNodeModuleKindResolver();
@@ -3128,29 +3553,65 @@ var screwUp = (options = {}) => {
 			}
 		},
 		writeBundle: async (options) => {
-			if (!insertMetadataBanner || !options.dir) return;
+			if (!options.dir) return;
 			try {
 				const files = await (0, fs_promises.readdir)(options.dir, { recursive: true });
-				let count = 0;
+				const declarationFiles = new Set(files.filter((file) => isDeclarationFilePath(file)).map((file) => (0, path.resolve)(options.dir, file)));
+				const ts = fixDeclarationImportExtensions ? await loadTypeScript() : void 0;
+				let bannerCount = 0;
+				let declarationCount = 0;
 				for (const file of files) {
 					const filePath = (0, path.join)(options.dir, file);
-					if (assetFiltersRegex.some((filter) => filter.test(file))) try {
-						const content = await (0, fs_promises.readFile)(filePath, "utf-8");
-						if (!content.includes(banner)) {
-							const bannerBlock = `${banner}\n`;
-							await (0, fs_promises.writeFile)(filePath, insertBannerHeader(content, bannerBlock));
-							const lineOffset = countInsertedLines(bannerBlock);
-							const mapPath = `${filePath}.map`;
+					const isAssetTarget = assetFiltersRegex.some((filter) => filter.test(file));
+					const isDeclarationTarget = fixDeclarationImportExtensions && !!ts && isDeclarationFilePath(filePath);
+					if (!isAssetTarget && !isDeclarationTarget) continue;
+					try {
+						let content = await (0, fs_promises.readFile)(filePath, "utf-8");
+						let contentChanged = false;
+						let mapLoaded = false;
+						let mapContent;
+						const mapPath = `${filePath}.map`;
+						const loadMapContent = async () => {
+							if (mapLoaded) return mapContent;
+							mapLoaded = true;
 							try {
-								const adjusted = applyLineOffsetToSourceMap(await (0, fs_promises.readFile)(mapPath, "utf-8"), lineOffset);
-								if (adjusted !== void 0) await (0, fs_promises.writeFile)(mapPath, adjusted);
-							} catch (_unused2) {}
-							count++;
+								mapContent = await (0, fs_promises.readFile)(mapPath, "utf-8");
+							} catch (_unused2) {
+								mapContent = void 0;
+							}
+							return mapContent;
+						};
+						if (insertMetadataBanner && isAssetTarget && !content.includes(banner)) {
+							const bannerBlock = `${banner}\n`;
+							content = insertBannerHeader(content, bannerBlock);
+							contentChanged = true;
+							const currentMapContent = await loadMapContent();
+							if (currentMapContent !== void 0) {
+								const adjusted = applyLineOffsetToSourceMap(currentMapContent, countInsertedLines(bannerBlock));
+								if (adjusted !== void 0) mapContent = adjusted;
+							}
+							bannerCount++;
+						}
+						if (isDeclarationTarget) {
+							const declarationResult = fixDeclarationImportSpecifiers(ts, content, filePath, declarationFiles, logger);
+							if (declarationResult.changed) {
+								const currentMapContent = await loadMapContent();
+								if (currentMapContent !== void 0) {
+									const adjusted = adjustSourceMapForDeclarationEdits(currentMapContent, content, declarationResult.edits);
+									if (adjusted !== void 0) mapContent = adjusted;
+								}
+								content = declarationResult.code;
+								contentChanged = true;
+								declarationCount++;
+							}
 						}
-					} catch (error) {}
+						if (contentChanged) await (0, fs_promises.writeFile)(filePath, content);
+						if (mapLoaded && mapContent !== void 0) await (0, fs_promises.writeFile)(mapPath, mapContent);
+					} catch (_unused3) {}
 				}
-				if (count >= 1) logger.debug(`writeBundle: Banner header inserted: ${count} file(s)`);
-			} catch (error) {}
+				if (bannerCount >= 1) logger.debug(`writeBundle: Banner header inserted: ${bannerCount} file(s)`);
+				if (declarationCount >= 1) logger.debug(`writeBundle: Declaration imports fixed: ${declarationCount} file(s)`);
+			} catch (_unused4) {}
 		}
 	};
 };