@tanstack/router-generator 1.166.29 → 1.166.31

package/dist/esm/transform/transform.js

@@ -1,298 +1,313 @@
-import { mergeImportDeclarations } from "../utils.js";
-import { ensureStringArgument } from "./utils.js";
+import MagicString from "magic-string";
+import * as t from "@babel/types";
 import { parseAst } from "@tanstack/router-utils";
-import { parse, print, types, visit } from "recast";
-import { SourceMapConsumer } from "source-map";
 //#region src/transform/transform.ts
-var b = types.builders;
-async function transform({ ctx, source, node }) {
-	let appliedChanges = false;
+var routeConstructors = ["createFileRoute", "createLazyFileRoute"];
+function transform({ ctx, source, node }) {
 	let ast;
 	try {
-		ast = parse(source, {
-			sourceFileName: "output.ts",
-			parser: { parse(code) {
-				return parseAst({
-					code,
-					tokens: true
-				});
-			} }
-		});
-	} catch (e) {
-		console.error("Error parsing code", ctx.routeId, source, e);
+		ast = parseAst({ code: source });
+	} catch (error) {
 		return {
 			result: "error",
-			error: e
+			error
 		};
 	}
-	const preferredQuote = detectPreferredQuoteStyle(ast);
-	let routeExportHandled = false;
-	function onExportFound(decl) {
-		if (decl.init?.type === "CallExpression") {
-			const callExpression = decl.init;
-			const firstArgument = callExpression.arguments[0];
-			if (firstArgument) {
-				if (firstArgument.type === "ObjectExpression") {
-					const staticProperties = firstArgument.properties.flatMap((p) => {
-						if (p.type === "ObjectProperty" && p.key.type === "Identifier") return p.key.name;
-						return [];
-					});
-					node.createFileRouteProps = new Set(staticProperties);
-				}
-			}
-			let identifier;
-			if (callExpression.callee.type === "Identifier") {
-				identifier = callExpression.callee;
-				if (ctx.verboseFileRoutes) {
-					callExpression.callee = b.callExpression(identifier, [b.stringLiteral(ctx.routeId)]);
-					appliedChanges = true;
-				}
-			} else if (callExpression.callee.type === "CallExpression" && callExpression.callee.callee.type === "Identifier") {
-				identifier = callExpression.callee.callee;
-				if (!ctx.verboseFileRoutes) {
-					callExpression.callee = identifier;
-					appliedChanges = true;
-				} else appliedChanges = ensureStringArgument(callExpression.callee, ctx.routeId, ctx.preferredQuote);
-			}
-			if (identifier === void 0) throw new Error(`expected identifier to be present in ${ctx.routeId} for export "Route"`);
-			if (identifier.name === "createFileRoute" && ctx.lazy) {
-				identifier.name = "createLazyFileRoute";
-				appliedChanges = true;
-			} else if (identifier.name === "createLazyFileRoute" && !ctx.lazy) {
-				identifier.name = "createFileRoute";
-				appliedChanges = true;
-			}
-		} else throw new Error(`expected "Route" export to be initialized by a CallExpression`);
-		routeExportHandled = true;
+	const exportedRouteNames = getExportedRouteNames(ast.program.body);
+	if (exportedRouteNames.size === 0) return { result: "no-route-export" };
+	const { calls: routeCalls, hasUnsupportedRouteId, hasMalformedRouteCall } = findExportedRouteCalls(ast.program.body, exportedRouteNames);
+	if (routeCalls.length === 0 && hasMalformedRouteCall) return {
+		result: "error",
+		error: /* @__PURE__ */ new Error(`expected Route export in ${ctx.routeId} to use createFileRoute('/path')({...}) or createLazyFileRoute('/path')({...})`)
+	};
+	if (routeCalls.length === 0 && hasUnsupportedRouteId) return {
+		result: "error",
+		error: /* @__PURE__ */ new Error(`expected route id to be a string literal or plain template literal in ${ctx.routeId}`)
+	};
+	if (routeCalls.length === 0) return { result: "not-modified" };
+	if (routeCalls.length > 1) return {
+		result: "error",
+		error: /* @__PURE__ */ new Error(`expected exactly one createFileRoute/createLazyFileRoute call in ${ctx.routeId}`)
+	};
+	const routeCall = routeCalls[0];
+	const routeIdQuote = getRouteIdQuote(source, routeCall.routeIdArg);
+	const createFileRouteProps = getCreateFileRouteProps(routeCall.optionsArg);
+	if (createFileRouteProps) node.createFileRouteProps = createFileRouteProps;
+	const expectedCallee = getExpectedRouteConstructor(ctx.lazy);
+	const expectedRouteId = `${routeIdQuote}${ctx.routeId}${routeIdQuote}`;
+	const currentRouteId = source.slice(routeCall.routeIdArg.start, routeCall.routeIdArg.end);
+	const targetModule = `@tanstack/${ctx.target}-router`;
+	const imports = parseTargetImports(ast.program.body, source, targetModule);
+	const s = new MagicString(source);
+	let modified = false;
+	if (routeCall.callee.name !== expectedCallee) {
+		s.update(routeCall.callee.start, routeCall.callee.end, expectedCallee);
+		modified = true;
 	}
-	const program = ast.program;
-	for (const n of program.body) {
-		if (n.type === "ExportNamedDeclaration") {
-			if (n.declaration?.type === "VariableDeclaration") {
-				const decl = n.declaration.declarations[0];
-				if (decl && decl.type === "VariableDeclarator" && decl.id.type === "Identifier") {
-					if (decl.id.name === "Route") onExportFound(decl);
-				}
-			} else if (n.declaration === null && n.specifiers) {
-				for (const spec of n.specifiers) if (typeof spec.exported.name === "string") {
-					if (spec.exported.name === "Route") {
-						const variableName = spec.local?.name || spec.exported.name;
-						for (const decl of program.body) if (decl.type === "VariableDeclaration" && decl.declarations[0]) {
-							const variable = decl.declarations[0];
-							if (variable.type === "VariableDeclarator" && variable.id.type === "Identifier" && variable.id.name === variableName) {
-								onExportFound(variable);
-								break;
-							}
-						}
-					}
-				}
-			}
-		}
-		if (routeExportHandled) break;
+	if (currentRouteId !== expectedRouteId) {
+		s.update(routeCall.routeIdArg.start, routeCall.routeIdArg.end, expectedRouteId);
+		modified = true;
 	}
-	if (!routeExportHandled) return { result: "no-route-export" };
-	const imports = {
-		required: [],
-		banned: []
+	if (updateRouteImports({
+		imports,
+		source,
+		s,
+		targetModule,
+		required: expectedCallee,
+		lineEnding: getLineEnding(source)
+	})) modified = true;
+	if (!modified) return { result: "not-modified" };
+	return {
+		result: "modified",
+		output: s.toString()
 	};
-	const targetModule = `@tanstack/${ctx.target}-router`;
-	if (ctx.verboseFileRoutes === false) imports.banned = [{
-		source: targetModule,
-		specifiers: [{ imported: "createLazyFileRoute" }, { imported: "createFileRoute" }]
-	}];
-	else if (ctx.lazy) {
-		imports.required = [{
-			source: targetModule,
-			specifiers: [{ imported: "createLazyFileRoute" }]
-		}];
-		imports.banned = [{
-			source: targetModule,
-			specifiers: [{ imported: "createFileRoute" }]
-		}];
-	} else {
-		imports.required = [{
-			source: targetModule,
-			specifiers: [{ imported: "createFileRoute" }]
-		}];
-		imports.banned = [{
-			source: targetModule,
-			specifiers: [{ imported: "createLazyFileRoute" }]
-		}];
+}
+function getExportedRouteNames(body) {
+	const exportedRouteNames = /* @__PURE__ */ new Set();
+	for (const statement of body) {
+		if (!t.isExportNamedDeclaration(statement) || statement.source) continue;
+		if (t.isVariableDeclaration(statement.declaration)) {
+			for (const declarator of statement.declaration.declarations) if (t.isIdentifier(declarator.id) && declarator.id.name === "Route") exportedRouteNames.add("Route");
+		}
+		for (const specifier of statement.specifiers) {
+			if (!t.isExportSpecifier(specifier) || getExportedName(specifier.exported) !== "Route") continue;
+			const localName = getLocalBindingName(specifier.local);
+			if (localName) exportedRouteNames.add(localName);
+		}
 	}
-	imports.required = mergeImportDeclarations(imports.required);
-	imports.banned = mergeImportDeclarations(imports.banned);
-	const importStatementCandidates = [];
-	const importDeclarationsToRemove = [];
-	for (const n of program.body) {
-		const findImport = (opts) => (i) => {
-			if (i.source === opts.source) {
-				const importKind = i.importKind || "value";
-				return (opts.importKind || "value") === importKind;
+	return exportedRouteNames;
+}
+function findExportedRouteCalls(body, exportedRouteNames) {
+	const calls = [];
+	let hasUnsupportedRouteId = false;
+	let hasMalformedRouteCall = false;
+	for (const statement of body) {
+		const declaration = getVariableDeclaration(statement);
+		if (!declaration) continue;
+		for (const declarator of declaration.declarations) {
+			if (!t.isIdentifier(declarator.id) || !exportedRouteNames.has(declarator.id.name)) continue;
+			const init = getRouteConstructorInit(declarator.init);
+			if (!init) {
+				if (isDirectRouteConstructorCall(declarator.init)) hasMalformedRouteCall = true;
+				continue;
 			}
-			return false;
-		};
-		if (n.type === "ImportDeclaration" && typeof n.source.value === "string") {
-			const filterImport = findImport({
-				source: n.source.value,
-				importKind: n.importKind
+			const routeIdArg = init.innerCall.arguments[0];
+			if (isSupportedRouteId(routeIdArg)) calls.push({
+				callee: init.callee,
+				routeIdArg,
+				optionsArg: init.outerCall.arguments[0]
 			});
-			let requiredImports = imports.required.filter(filterImport)[0];
-			const bannedImports = imports.banned.filter(filterImport)[0];
-			if (!requiredImports && !bannedImports) continue;
-			const importSpecifiersToRemove = [];
-			if (n.specifiers) {
-				for (const spec of n.specifiers) {
-					if (!requiredImports && !bannedImports) break;
-					if (spec.type === "ImportSpecifier" && typeof spec.imported.name === "string") {
-						if (requiredImports) {
-							const requiredImportIndex = requiredImports.specifiers.findIndex((imp) => imp.imported === spec.imported.name);
-							if (requiredImportIndex !== -1) {
-								requiredImports.specifiers.splice(requiredImportIndex, 1);
-								if (requiredImports.specifiers.length === 0) {
-									imports.required = imports.required.splice(imports.required.indexOf(requiredImports), 1);
-									requiredImports = void 0;
-								}
-							} else importStatementCandidates.push(n);
-						}
-						if (bannedImports) {
-							if (bannedImports.specifiers.findIndex((imp) => imp.imported === spec.imported.name) !== -1) importSpecifiersToRemove.push(spec);
-						}
-					}
-				}
-				if (importSpecifiersToRemove.length > 0) {
-					appliedChanges = true;
-					n.specifiers = n.specifiers.filter((spec) => !importSpecifiersToRemove.includes(spec));
-					if (n.specifiers.length === 0) importDeclarationsToRemove.push(n);
-				}
-			}
+			else hasUnsupportedRouteId = true;
 		}
 	}
-	imports.required.forEach((requiredImport) => {
-		if (requiredImport.specifiers.length > 0) {
-			appliedChanges = true;
-			if (importStatementCandidates.length > 0) {
-				const importStatement = importStatementCandidates.find((importStatement) => {
-					if (importStatement.source.value === requiredImport.source) return (importStatement.importKind || "value") === (requiredImport.importKind || "value");
-					return false;
-				});
-				if (importStatement) {
-					if (importStatement.specifiers === void 0) importStatement.specifiers = [];
-					const importSpecifiersToAdd = requiredImport.specifiers.map((spec) => b.importSpecifier(b.identifier(spec.imported), b.identifier(spec.imported)));
-					importStatement.specifiers = [...importStatement.specifiers, ...importSpecifiersToAdd];
-					return;
-				}
-			}
-			const importStatement = b.importDeclaration(requiredImport.specifiers.map((spec) => b.importSpecifier(b.identifier(spec.imported), spec.local ? b.identifier(spec.local) : null)), b.stringLiteral(requiredImport.source));
-			program.body.unshift(importStatement);
+	return {
+		calls,
+		hasUnsupportedRouteId,
+		hasMalformedRouteCall
+	};
+}
+function getVariableDeclaration(statement) {
+	const declaration = t.isExportNamedDeclaration(statement) ? statement.declaration : statement;
+	return t.isVariableDeclaration(declaration) ? declaration : null;
+}
+function getExportedName(node) {
+	return t.isIdentifier(node) ? node.name : node.value;
+}
+function getLocalBindingName(node) {
+	return t.isIdentifier(node) ? node.name : null;
+}
+function getRouteConstructorInit(expression) {
+	if (!expression || !t.isCallExpression(expression)) return null;
+	if (!t.isCallExpression(expression.callee)) return null;
+	const innerCall = expression.callee;
+	if (!t.isIdentifier(innerCall.callee) || !isRouteConstructor(innerCall.callee)) return null;
+	return {
+		callee: innerCall.callee,
+		outerCall: expression,
+		innerCall
+	};
+}
+function isDirectRouteConstructorCall(expression) {
+	return !!expression && t.isCallExpression(expression) && t.isIdentifier(expression.callee) && isRouteConstructor(expression.callee);
+}
+function isRouteConstructor(callee) {
+	return routeConstructors.includes(callee.name);
+}
+function isSupportedRouteId(arg) {
+	return !!arg && (t.isStringLiteral(arg) || t.isTemplateLiteral(arg) && arg.expressions.length === 0);
+}
+function getRouteIdQuote(source, arg) {
+	const raw = source.slice(arg.start, arg.end);
+	if (raw.startsWith("'")) return "'";
+	if (raw.startsWith("\"")) return "\"";
+	return "`";
+}
+function getCreateFileRouteProps(arg) {
+	if (!arg || !t.isObjectExpression(arg)) return;
+	const props = /* @__PURE__ */ new Set();
+	for (const property of arg.properties) {
+		if (!t.isObjectProperty(property) || property.computed) continue;
+		if (t.isIdentifier(property.key)) {
+			props.add(property.key.name);
+			continue;
 		}
+		if (t.isStringLiteral(property.key)) props.add(property.key.value);
+	}
+	return props;
+}
+function parseTargetImports(body, source, targetModule) {
+	const imports = [];
+	for (const statement of body) {
+		if (!t.isImportDeclaration(statement) || statement.importKind === "type" || statement.source.value !== targetModule) continue;
+		const rawSource = source.slice(statement.source.start, statement.source.end);
+		const importStatement = source.slice(statement.start, statement.end);
+		imports.push({
+			declaration: statement,
+			defaultImport: statement.specifiers.find((specifier) => t.isImportDefaultSpecifier(specifier))?.local.name,
+			namespace: statement.specifiers.find((specifier) => t.isImportNamespaceSpecifier(specifier))?.local.name,
+			named: statement.specifiers.filter((specifier) => t.isImportSpecifier(specifier)).map((specifier) => ({
+				imported: t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value,
+				local: specifier.local.name,
+				importKind: specifier.importKind ?? void 0
+			})),
+			moduleName: statement.source.value,
+			quote: rawSource[0],
+			semicolon: importStatement.trimEnd().endsWith(";")
+		});
+	}
+	return imports;
+}
+function updateRouteImports({ imports, source, s, targetModule, required, lineEnding }) {
+	const analysis = analyzeRouteImports(imports, required);
+	if (analysis.kind === "ok") return false;
+	if (analysis.kind === "rename") {
+		s.update(analysis.imported.start, analysis.imported.end, analysis.next);
+		s.update(analysis.local.start, analysis.local.end, analysis.next);
+		return true;
+	}
+	return normalizeRouteImports({
+		imports,
+		source,
+		s,
+		targetModule,
+		required,
+		lineEnding
 	});
-	if (importDeclarationsToRemove.length > 0) {
-		appliedChanges = true;
-		for (const importDeclaration of importDeclarationsToRemove) if (importDeclaration.specifiers?.length === 0) {
-			const index = program.body.indexOf(importDeclaration);
-			if (index !== -1) program.body.splice(index, 1);
+}
+function analyzeRouteImports(imports, required) {
+	const opposite = getOtherRouteConstructor(required);
+	let requiredCount = 0;
+	let oppositeCount = 0;
+	let renameCandidate;
+	for (const declaration of imports) for (const specifier of declaration.declaration.specifiers) {
+		if (!t.isImportSpecifier(specifier)) continue;
+		const imported = specifier.imported;
+		if (!t.isIdentifier(imported)) return { kind: "normalize" };
+		if (!isRouteConstructorName(imported.name)) continue;
+		if (specifier.local.name !== imported.name) return { kind: "normalize" };
+		if (imported.name === required) {
+			requiredCount++;
+			continue;
+		}
+		if (imported.name === opposite) {
+			oppositeCount++;
+			renameCandidate = {
+				imported,
+				local: specifier.local,
+				next: required
+			};
 		}
 	}
-	if (!appliedChanges) return { result: "not-modified" };
-	const printResult = print(ast, {
-		reuseWhitespace: true,
-		sourceMapName: "output.map"
-	});
-	let transformedCode = printResult.code;
-	if (printResult.map) transformedCode = await fixTransformedOutputText({
-		originalCode: source,
-		transformedCode,
-		sourceMap: printResult.map,
-		preferredQuote
-	});
-	return {
-		result: "modified",
-		output: transformedCode
+	if (requiredCount === 1 && oppositeCount === 0) return { kind: "ok" };
+	if (requiredCount === 0 && oppositeCount === 1 && renameCandidate) return {
+		kind: "rename",
+		...renameCandidate
 	};
+	return { kind: "normalize" };
 }
-async function fixTransformedOutputText({ originalCode, transformedCode, sourceMap, preferredQuote }) {
-	const originalLines = originalCode.split("\n");
-	const transformedLines = transformedCode.split("\n");
-	const defaultUsesSemicolons = detectSemicolonUsage(originalCode);
-	const consumer = await new SourceMapConsumer(sourceMap);
-	return transformedLines.map((line, i) => {
-		const transformedLineNum = i + 1;
-		let origLineText = void 0;
-		for (let col = 0; col < line.length; col++) {
-			const mapped = consumer.originalPositionFor({
-				line: transformedLineNum,
-				column: col
-			});
-			if (mapped.line != null && mapped.line > 0) {
-				origLineText = originalLines[mapped.line - 1];
-				break;
-			}
-		}
-		if (origLineText !== void 0) {
-			if (origLineText === line) return origLineText;
-			return fixLine(line, {
-				originalLine: origLineText,
-				useOriginalSemicolon: true,
-				useOriginalQuotes: true,
-				fallbackQuote: preferredQuote
-			});
-		} else return fixLine(line, {
-			originalLine: null,
-			useOriginalSemicolon: false,
-			useOriginalQuotes: false,
-			fallbackQuote: preferredQuote,
-			fallbackSemicolon: defaultUsesSemicolons
+function normalizeRouteImports({ imports, source, s, targetModule, required, lineEnding }) {
+	const owner = imports.find((declaration) => hasNamedImport(declaration.named, required)) ?? imports.find((declaration) => !declaration.namespace);
+	let modified = false;
+	for (const declaration of imports) {
+		const named = normalizeNamedImports({
+			named: declaration.named,
+			required,
+			isOwner: declaration === owner
 		});
-	}).join("\n");
+		if (sameNamedImports(declaration.named, named)) continue;
+		const replacement = renderImportDeclaration({
+			...declaration,
+			named
+		});
+		if (replacement === null) {
+			s.remove(declaration.declaration.start, getRemovalEnd(source, declaration.declaration.end));
+			modified = true;
+			continue;
+		}
+		s.update(declaration.declaration.start, declaration.declaration.end, replacement);
+		modified = true;
+	}
+	if (!owner) {
+		const quote = imports[0]?.quote ?? "'";
+		const semicolon = imports[0]?.semicolon ?? false;
+		s.prepend(`import { ${required} } from ${quote}${targetModule}${quote}${semicolon ? ";" : ""}${lineEnding}`);
+		modified = true;
+	}
+	return modified;
 }
-function fixLine(line, { originalLine, useOriginalSemicolon, useOriginalQuotes, fallbackQuote, fallbackSemicolon = true }) {
-	let result = line;
-	if (useOriginalQuotes && originalLine) result = fixQuotes(result, originalLine, fallbackQuote);
-	else if (!useOriginalQuotes && fallbackQuote) result = fixQuotesToPreferred(result, fallbackQuote);
-	if (useOriginalSemicolon && originalLine) {
-		const hadSemicolon = originalLine.trimEnd().endsWith(";");
-		const hasSemicolon = result.trimEnd().endsWith(";");
-		if (hadSemicolon && !hasSemicolon) result += ";";
-		if (!hadSemicolon && hasSemicolon) result = result.replace(/;\s*$/, "");
-	} else if (!useOriginalSemicolon) {
-		const hasSemicolon = result.trimEnd().endsWith(";");
-		if (!fallbackSemicolon && hasSemicolon) result = result.replace(/;\s*$/, "");
-		if (fallbackSemicolon && !hasSemicolon && result.trim()) result += ";";
+function normalizeNamedImports({ named, required, isOwner }) {
+	const banned = getOtherRouteConstructor(required);
+	const nextNamed = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const specifier of named) {
+		if (specifier.imported === banned) continue;
+		if (specifier.local === required && (specifier.imported !== required || !isOwner)) continue;
+		const key = `${specifier.importKind ?? "value"}:${specifier.imported}:${specifier.local}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		nextNamed.push(specifier);
 	}
-	return result;
+	if (isOwner && !hasNamedImport(nextNamed, required)) nextNamed.push({
+		imported: required,
+		local: required
+	});
+	return nextNamed;
 }
-function fixQuotes(line, originalLine, fallbackQuote) {
-	let originalQuote = detectQuoteFromLine(originalLine);
-	if (!originalQuote) originalQuote = fallbackQuote;
-	return fixQuotesToPreferred(line, originalQuote);
+function getExpectedRouteConstructor(lazy) {
+	return lazy ? "createLazyFileRoute" : "createFileRoute";
 }
-function fixQuotesToPreferred(line, quote) {
-	return line.replace(/(['"`])([^'"`\\]*(?:\\.[^'"`\\]*)*)\1/g, (_, q, content) => {
-		return `${quote}${content.replaceAll(quote, `\\${quote}`)}${quote}`;
-	});
+function getOtherRouteConstructor(constructor) {
+	return constructor === "createFileRoute" ? "createLazyFileRoute" : "createFileRoute";
 }
-function detectQuoteFromLine(line) {
-	const match = line.match(/(['"`])(?:\\.|[^\\])*?\1/);
-	return match ? match[1] : null;
+function hasNamedImport(named, required) {
+	return named.some((specifier) => specifier.imported === required && specifier.local === required && specifier.importKind !== "type");
 }
-function detectSemicolonUsage(code) {
-	const lines = code.split("\n").map((l) => l.trim());
-	const total = lines.length;
-	return lines.filter((l) => l.endsWith(";")).length > total / 2;
+function sameNamedImports(left, right) {
+	return left.length === right.length && left.every((specifier, index) => specifier.imported === right[index].imported && specifier.local === right[index].local && specifier.importKind === right[index].importKind);
 }
-function detectPreferredQuoteStyle(ast) {
-	let single = 0;
-	let double = 0;
-	visit(ast, { visitStringLiteral(path) {
-		if (path.parent.node.type !== "JSXAttribute") {
-			const raw = path.node.extra?.raw;
-			if (raw?.startsWith("'")) single++;
-			else if (raw?.startsWith("\"")) double++;
-		}
-		return false;
-	} });
-	if (single >= double) return "'";
-	return "\"";
+function isRouteConstructorName(value) {
+	return routeConstructors.includes(value);
+}
+function renderImportDeclaration(importDeclaration) {
+	const parts = [];
+	if (importDeclaration.defaultImport) parts.push(importDeclaration.defaultImport);
+	if (importDeclaration.namespace) parts.push(`* as ${importDeclaration.namespace}`);
+	if (importDeclaration.named.length > 0) parts.push(`{ ${importDeclaration.named.map((specifier) => `${specifier.importKind === "type" ? "type " : ""}${specifier.imported === specifier.local ? specifier.imported : `${specifier.imported} as ${specifier.local}`}`).join(", ")} }`);
+	if (parts.length === 0) return null;
+	return `import ${parts.join(", ")} from ${importDeclaration.quote}${importDeclaration.moduleName}${importDeclaration.quote}${importDeclaration.semicolon ? ";" : ""}`;
+}
+function getLineEnding(source) {
+	if (source.includes("\r\n")) return "\r\n";
+	if (source.includes("\n")) return "\n";
+	if (source.includes("\r")) return "\r";
+	return "\n";
+}
+function getRemovalEnd(source, end) {
+	let pos = end;
+	while (pos < source.length && (source[pos] === " " || source[pos] === "	")) pos++;
+	if (source[pos] === "\r" && source[pos + 1] === "\n") return pos + 2;
+	if (source[pos] === "\n" || source[pos] === "\r") return pos + 1;
+	return end;
 }
 //#endregion
 export { transform };