screw-up 1.29.0 → 1.31.0

package/dist/index.mjs

@@ -1,27 +1,30 @@
 /*!
 * 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
 */
-import { i as getFetchGitMetadata, l as resolvePackageMetadata, n as generateMetadataFileContent, o as createConsoleLogger, r as writeFileIfChanged, t as ensureMetadataGitignore } from "./metadata-file-CyQ2yue9.js";
-import { i as version, n as name, t as git_commit_hash } from "./packageMetadata-DnXbVLQ5.js";
+import { i as getFetchGitMetadata, l as resolvePackageMetadata, n as generateMetadataFileContent, o as createConsoleLogger, r as writeFileIfChanged, t as ensureMetadataGitignore } from "./metadata-file-BWd04LhD.js";
+import { i as version, n as name, t as git_commit_hash } from "./packageMetadata-BsMXJpMH.js";
 import { readFile, readdir, writeFile } from "fs/promises";
 import { existsSync } from "fs";
-import { dirname, extname, join } from "path";
+import { dirname, extname, join, posix, resolve } from "path";
 import { createHash } from "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 = {
@@ -33,6 +36,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) {
@@ -67,11 +76,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 = () => {
@@ -87,15 +106,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;
@@ -171,6 +195,375 @@ var createLogicalContext = (id) => {
 };
 createLogicalContext(Symbol("[root]"));
 //#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) => 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`,
+	join(resolvedPath, "index.d.ts"),
+	join(resolvedPath, "index.d.mts"),
+	join(resolvedPath, "index.d.cts")
+];
+var resolveSpecifierSuffix = (specifier, importerPath, declarationFiles, logger) => {
+	if (!isRelativeSpecifier(specifier) || hasExplicitExtension(specifier)) return;
+	const resolvedPath = resolve(dirname(importerPath), specifier);
+	const matches = createCandidateDeclarationPaths(resolvedPath).filter((path) => declarationFiles.has(path));
+	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) => {
+			var _path$split$pop;
+			return (_path$split$pop = path.split(/[/\\]/).pop()) !== null && _path$split$pop !== void 0 ? _path$split$pop : path;
+		}).join(", ")})`);
+		return;
+	}
+	const match = matches[0];
+	const runtimeSuffix = getDeclarationRuntimeSuffix(match);
+	const indexPrefix = 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",
@@ -312,45 +705,46 @@ var cjsInteropGlobalFlagAssignmentPattern = new RegExp(`\\bglobalThis\\.${cjsInt
 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 =
-    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 {
@@ -461,7 +855,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(),
@@ -477,20 +872,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
 	};
 };
@@ -598,7 +990,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();
@@ -777,29 +1169,65 @@ var screwUp = (options = {}) => {
 			}
 		},
 		writeBundle: async (options) => {
-			if (!insertMetadataBanner || !options.dir) return;
+			if (!options.dir) return;
 			try {
 				const files = await readdir(options.dir, { recursive: true });
-				let count = 0;
+				const declarationFiles = new Set(files.filter((file) => isDeclarationFilePath(file)).map((file) => resolve(options.dir, file)));
+				const ts = fixDeclarationImportExtensions ? await loadTypeScript() : void 0;
+				let bannerCount = 0;
+				let declarationCount = 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`;
+					const isAssetTarget = assetFiltersRegex.some((filter) => filter.test(file));
+					const isDeclarationTarget = fixDeclarationImportExtensions && !!ts && isDeclarationFilePath(filePath);
+					if (!isAssetTarget && !isDeclarationTarget) continue;
+					try {
+						let content = await 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 readFile(mapPath, "utf-8"), lineOffset);
-								if (adjusted !== void 0) await writeFile(mapPath, adjusted);
-							} catch (_unused2) {}
-							count++;
+								mapContent = await 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 writeFile(filePath, content);
+						if (mapLoaded && mapContent !== void 0) await 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) {}
 		}
 	};
 };