screw-up 1.28.0 → 1.30.0

package/dist/index.cjs

@@ -1,11 +1,11 @@
 /*!
 * name: screw-up
-* version: 1.28.0
+* version: 1.30.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: 4bc8c338f32ab8ed9bbf0b9ad0ba4166d584be65
+* git.commit.hash: ac6785ada0880218ecbaef699721d3a169362e76
 */
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -198,8 +198,8 @@ createLogicalContext(Symbol("[root]"));
 //#endregion
 //#region src/generated/packageMetadata.ts
 var name = "screw-up";
-var version = "1.28.0";
-var git_commit_hash = "4bc8c338f32ab8ed9bbf0b9ad0ba4166d584be65";
+var version = "1.30.0";
+var git_commit_hash = "ac6785ada0880218ecbaef699721d3a169362e76";
 //#endregion
 //#region node_modules/json5/dist/index.js
 var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -2237,12 +2237,81 @@ var getRelatedBranches = async (repositoryPath, commitHash) => {
 * @param repositoryPath - Local Git repository directory
 * @returns Modified files
 */
+var isModifiedFile = ([, head, workdir, stage]) => {
+	return workdir === 2 || stage === 2 || stage === 3 || head === 1 && workdir === 0 || head === 0 && workdir === 1;
+};
+var getStatusRow = async (filepath, entries) => {
+	const [head, workdir, stage] = entries;
+	const [headType, workdirType, stageType] = await Promise.all([
+		head ? head.type() : void 0,
+		workdir ? workdir.type() : void 0,
+		stage ? stage.type() : void 0
+	]);
+	const isBlob = [
+		headType,
+		workdirType,
+		stageType
+	].includes("blob");
+	if ((headType === "tree" || headType === "special") && !isBlob) return;
+	if (headType === "commit") return;
+	if ((workdirType === "tree" || workdirType === "special") && !isBlob) return;
+	if (stageType === "commit") return;
+	if ((stageType === "tree" || stageType === "special") && !isBlob) return;
+	const headOid = headType === "blob" ? await head.oid() : void 0;
+	const stageOid = stageType === "blob" ? await stage.oid() : void 0;
+	let workdirOid;
+	if (headType !== "blob" && workdirType === "blob" && stageType !== "blob") workdirOid = "42";
+	else if (workdirType === "blob") workdirOid = await workdir.oid();
+	const entry = [
+		void 0,
+		headOid,
+		workdirOid,
+		stageOid
+	];
+	const statusValues = entry.map((value) => entry.indexOf(value));
+	return [
+		filepath,
+		statusValues[1],
+		statusValues[2],
+		statusValues[3]
+	];
+};
+var reduceModifiedFiles = async (parent, children) => {
+	const modifiedFiles = parent ? [parent] : [];
+	for (const child of children) modifiedFiles.push(...child);
+	return modifiedFiles;
+};
+var iterateSequentially = async (walk, children) => {
+	const results = [];
+	for (const child of children) results.push(await walk(child));
+	return results;
+};
 var getModifiedFiles = async (repositoryPath) => {
 	try {
-		return (await isomorphic_git.statusMatrix({
+		return await isomorphic_git.walk({
 			fs: fs_promises.default,
-			dir: repositoryPath
-		})).filter(([, head, workdir, stage]) => workdir === 2 || stage === 2 || stage === 3 || head === 1 && workdir === 0 || head === 0 && workdir === 1);
+			dir: repositoryPath,
+			trees: [
+				isomorphic_git.TREE({ ref: "HEAD" }),
+				isomorphic_git.WORKDIR(),
+				isomorphic_git.STAGE()
+			],
+			map: async (filepath, entries) => {
+				const [head, workdir, stage] = entries;
+				if (!head && !stage && workdir) {
+					if (await isomorphic_git.isIgnored({
+						fs: fs_promises.default,
+						dir: repositoryPath,
+						filepath
+					})) return null;
+				}
+				const statusRow = await getStatusRow(filepath, entries);
+				if (!statusRow || !isModifiedFile(statusRow)) return;
+				return statusRow;
+			},
+			reduce: reduceModifiedFiles,
+			iterate: iterateSequentially
+		});
 	} catch (_unused5) {
 		return [];
 	}
@@ -2389,6 +2458,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",
@@ -2530,45 +2968,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 {
@@ -2679,7 +3118,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(),
@@ -2695,20 +3135,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
 	};
 };
@@ -2880,7 +3317,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();
@@ -3059,29 +3496,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) {}
 		}
 	};
 };