@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/frontend/embedded_fragment_support.js

@@ -0,0 +1,106 @@
+import ts from 'typescript';
+function createExpressionSourceFile(text) {
+    return ts.createSourceFile('/virtual/macro_fragment_expression.ts', `const __sts_macro_fragment_expr = (${text});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function cloneRegexWithGlobalAndUnicode(pattern) {
+    const flags = new Set(pattern.flags.split(''));
+    flags.add('g');
+    flags.add('u');
+    return new RegExp(pattern.source, [...flags].join(''));
+}
+function shiftSpan(baseSpan, start, end) {
+    return {
+        fileName: baseSpan.fileName,
+        start,
+        end,
+    };
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+export function parseMacroHelperCallExpression(text, helperName, allowedHelpers) {
+    const sourceFile = createExpressionSourceFile(text);
+    const parseDiagnostics = sourceFile.parseDiagnostics ?? [];
+    if (parseDiagnostics.length > 0) {
+        return null;
+    }
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isVariableStatement(statement)) {
+        return null;
+    }
+    const initializer = statement.declarationList.declarations[0]?.initializer;
+    if (!initializer || !ts.isParenthesizedExpression(initializer)) {
+        return null;
+    }
+    const expression = initializer.expression;
+    if (!ts.isCallExpression(expression) || expression.arguments.length !== 1) {
+        return null;
+    }
+    if (!ts.isPropertyAccessExpression(expression.expression) ||
+        !ts.isIdentifier(expression.expression.expression) ||
+        expression.expression.expression.text !== helperName) {
+        return null;
+    }
+    const helper = expression.expression.name.text;
+    if (!allowedHelpers.includes(helper)) {
+        return null;
+    }
+    return {
+        argumentText: expression.arguments[0].getText(sourceFile),
+        helper,
+    };
+}
+export function findTemplateQuasiAtPosition(template, sourcePosition) {
+    return template.quasis.find((quasi) => sourcePosition >= quasi.span.start && sourcePosition < quasi.span.end) ?? null;
+}
+export function findWordAtSourcePosition(quasi, sourcePosition, wordPattern) {
+    for (const match of quasi.text.matchAll(cloneRegexWithGlobalAndUnicode(wordPattern))) {
+        const word = match[0];
+        const start = quasi.span.start + match.index;
+        const end = start + word.length;
+        if (sourcePosition >= start && sourcePosition < end) {
+            return {
+                span: shiftSpan(quasi.span, start, end),
+                word,
+            };
+        }
+    }
+    return null;
+}
+export function keywordTokenSpans(quasis, wordPattern, predicate, type = 'keyword') {
+    const tokens = [];
+    for (const quasi of quasis) {
+        for (const match of quasi.text.matchAll(cloneRegexWithGlobalAndUnicode(wordPattern))) {
+            const word = match[0];
+            if (!predicate(word)) {
+                continue;
+            }
+            const start = quasi.span.start + match.index;
+            tokens.push({
+                span: shiftSpan(quasi.span, start, start + word.length),
+                type,
+            });
+        }
+    }
+    return tokens;
+}
+export function formatTemplateLiteralWithInterpolationMarkers(template, options) {
+    const markers = template.expressions.map((_, index) => `${options.markerPrefix}${index}__`);
+    let combined = template.quasis[0]?.text ?? '';
+    for (let index = 0; index < template.expressions.length; index += 1) {
+        combined += markers[index];
+        combined += template.quasis[index + 1]?.text ?? '';
+    }
+    const formattedCombined = options.formatCombinedText(combined);
+    const splitPattern = new RegExp(`${escapeRegExp(options.markerPrefix)}\\d+__`, 'u');
+    const formattedQuasis = formattedCombined.split(splitPattern);
+    const parts = ['`'];
+    for (let index = 0; index < formattedQuasis.length; index += 1) {
+        parts.push(formattedQuasis[index]);
+        if (index < template.expressions.length) {
+            parts.push(`\${${options.formatExpression(options.expressionTextForIndex(index))}}`);
+        }
+    }
+    parts.push('`');
+    return parts.join('');
+}

package/project-transform/src/frontend/embedded_fragment_support.ts

@@ -0,0 +1,172 @@
+import ts from 'typescript';
+
+import type {
+  MacroSemanticToken,
+  MacroTemplateOperand,
+  MacroTemplateQuasi,
+} from './macro_api.ts';
+import type { SourceSpan } from './macro_types.ts';
+
+export interface ParsedMacroHelperCallExpression {
+  readonly argumentText: string;
+  readonly helper: string;
+}
+
+function createExpressionSourceFile(text: string): ts.SourceFile {
+  return ts.createSourceFile(
+    '/virtual/macro_fragment_expression.ts',
+    `const __sts_macro_fragment_expr = (${text});`,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+}
+
+function cloneRegexWithGlobalAndUnicode(pattern: RegExp): RegExp {
+  const flags = new Set(pattern.flags.split(''));
+  flags.add('g');
+  flags.add('u');
+  return new RegExp(pattern.source, [...flags].join(''));
+}
+
+function shiftSpan(baseSpan: SourceSpan, start: number, end: number): SourceSpan {
+  return {
+    fileName: baseSpan.fileName,
+    start,
+    end,
+  };
+}
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+
+export function parseMacroHelperCallExpression(
+  text: string,
+  helperName: string,
+  allowedHelpers: readonly string[],
+): ParsedMacroHelperCallExpression | null {
+  const sourceFile = createExpressionSourceFile(text);
+  const parseDiagnostics = (sourceFile as ts.SourceFile & {
+    parseDiagnostics?: readonly ts.Diagnostic[];
+  }).parseDiagnostics ?? [];
+  if (parseDiagnostics.length > 0) {
+    return null;
+  }
+
+  const statement = sourceFile.statements[0];
+  if (!statement || !ts.isVariableStatement(statement)) {
+    return null;
+  }
+
+  const initializer = statement.declarationList.declarations[0]?.initializer;
+  if (!initializer || !ts.isParenthesizedExpression(initializer)) {
+    return null;
+  }
+
+  const expression = initializer.expression;
+  if (!ts.isCallExpression(expression) || expression.arguments.length !== 1) {
+    return null;
+  }
+
+  if (
+    !ts.isPropertyAccessExpression(expression.expression) ||
+    !ts.isIdentifier(expression.expression.expression) ||
+    expression.expression.expression.text !== helperName
+  ) {
+    return null;
+  }
+
+  const helper = expression.expression.name.text;
+  if (!allowedHelpers.includes(helper)) {
+    return null;
+  }
+
+  return {
+    argumentText: expression.arguments[0]!.getText(sourceFile),
+    helper,
+  };
+}
+
+export function findTemplateQuasiAtPosition(
+  template: MacroTemplateOperand,
+  sourcePosition: number,
+): MacroTemplateQuasi | null {
+  return template.quasis.find((quasi) =>
+    sourcePosition >= quasi.span.start && sourcePosition < quasi.span.end
+  ) ?? null;
+}
+
+export function findWordAtSourcePosition(
+  quasi: MacroTemplateQuasi,
+  sourcePosition: number,
+  wordPattern: RegExp,
+): { readonly span: SourceSpan; readonly word: string } | null {
+  for (const match of quasi.text.matchAll(cloneRegexWithGlobalAndUnicode(wordPattern))) {
+    const word = match[0]!;
+    const start = quasi.span.start + match.index!;
+    const end = start + word.length;
+    if (sourcePosition >= start && sourcePosition < end) {
+      return {
+        span: shiftSpan(quasi.span, start, end),
+        word,
+      };
+    }
+  }
+
+  return null;
+}
+
+export function keywordTokenSpans(
+  quasis: readonly MacroTemplateQuasi[],
+  wordPattern: RegExp,
+  predicate: (word: string) => boolean,
+  type = 'keyword',
+): readonly MacroSemanticToken[] {
+  const tokens: MacroSemanticToken[] = [];
+  for (const quasi of quasis) {
+    for (const match of quasi.text.matchAll(cloneRegexWithGlobalAndUnicode(wordPattern))) {
+      const word = match[0]!;
+      if (!predicate(word)) {
+        continue;
+      }
+
+      const start = quasi.span.start + match.index!;
+      tokens.push({
+        span: shiftSpan(quasi.span, start, start + word.length),
+        type,
+      });
+    }
+  }
+  return tokens;
+}
+
+export function formatTemplateLiteralWithInterpolationMarkers(
+  template: MacroTemplateOperand,
+  options: {
+    readonly expressionTextForIndex: (index: number) => string;
+    readonly formatCombinedText: (text: string) => string;
+    readonly formatExpression: (text: string) => string;
+    readonly markerPrefix: string;
+  },
+): string {
+  const markers = template.expressions.map((_, index) => `${options.markerPrefix}${index}__`);
+  let combined = template.quasis[0]?.text ?? '';
+  for (let index = 0; index < template.expressions.length; index += 1) {
+    combined += markers[index]!;
+    combined += template.quasis[index + 1]?.text ?? '';
+  }
+
+  const formattedCombined = options.formatCombinedText(combined);
+  const splitPattern = new RegExp(`${escapeRegExp(options.markerPrefix)}\\d+__`, 'u');
+  const formattedQuasis = formattedCombined.split(splitPattern);
+  const parts = ['`'];
+  for (let index = 0; index < formattedQuasis.length; index += 1) {
+    parts.push(formattedQuasis[index]!);
+    if (index < template.expressions.length) {
+      parts.push(`\${${options.formatExpression(options.expressionTextForIndex(index))}}`);
+    }
+  }
+  parts.push('`');
+  return parts.join('');
+}

package/project-transform/src/frontend/error_normalization.js

@@ -0,0 +1,403 @@
+import ts from 'typescript';
+import { isSoundscriptSourceFile, toSourceFileName, } from './project_frontend.js';
+export const SOUNDSCRIPT_NORMALIZE_ERROR_HELPER_NAME = '__sts_normalize_error';
+function repairBuiltinMacroModuleSpecifiers(text) {
+    return text;
+}
+function isBuiltInPromiseDeclarationFile(fileName) {
+    return fileName.includes('/sound-libs/lib.') || /\/lib\..+\.d\.ts$/u.test(fileName);
+}
+function isBuiltInPromiseMethodCall(callExpression, checker, methodName) {
+    if (!ts.isPropertyAccessExpression(callExpression.expression) ||
+        callExpression.expression.name.text !== methodName) {
+        return false;
+    }
+    const signature = checker.getResolvedSignature(callExpression);
+    const declaration = signature?.getDeclaration();
+    if (!declaration || !('name' in declaration) || !declaration.name) {
+        return false;
+    }
+    if (!ts.isIdentifier(declaration.name) || declaration.name.text !== methodName) {
+        return false;
+    }
+    const parent = declaration.parent;
+    return ts.isInterfaceDeclaration(parent) &&
+        parent.name.text === 'Promise' &&
+        isBuiltInPromiseDeclarationFile(declaration.getSourceFile().fileName);
+}
+function createHelperDeclaration() {
+    const valueIdentifier = ts.factory.createIdentifier('value');
+    const detailsIdentifier = ts.factory.createIdentifier('details');
+    const messageIdentifier = ts.factory.createIdentifier('message');
+    const errorIdentifier = ts.factory.createIdentifier('error');
+    const detailsType = ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(undefined, 'message', ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+        ts.factory.createPropertySignature(undefined, 'name', ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+        ts.factory.createPropertySignature(undefined, 'stack', ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+    ]);
+    return ts.factory.createFunctionDeclaration(undefined, undefined, SOUNDSCRIPT_NORMALIZE_ERROR_HELPER_NAME, undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'value', undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword), undefined),
+    ], ts.factory.createTypeReferenceNode('Error'), ts.factory.createBlock([
+        ts.factory.createIfStatement(ts.factory.createBinaryExpression(valueIdentifier, ts.SyntaxKind.InstanceOfKeyword, ts.factory.createIdentifier('Error')), ts.factory.createBlock([ts.factory.createReturnStatement(valueIdentifier)], true)),
+        ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(detailsIdentifier, undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(ts.factory.createTypeOfExpression(valueIdentifier), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createStringLiteral('object')), ts.SyntaxKind.AmpersandAmpersandToken, ts.factory.createBinaryExpression(valueIdentifier, ts.SyntaxKind.ExclamationEqualsEqualsToken, ts.factory.createNull())), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createParenthesizedExpression(ts.factory.createAsExpression(valueIdentifier, detailsType)), ts.factory.createToken(ts.SyntaxKind.ColonToken), ts.factory.createIdentifier('undefined'))),
+        ], ts.NodeFlags.Const)),
+        ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(messageIdentifier, undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(detailsIdentifier, ts.SyntaxKind.AmpersandAmpersandToken, ts.factory.createBinaryExpression(ts.factory.createTypeOfExpression(ts.factory.createPropertyAccessExpression(detailsIdentifier, 'message')), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createStringLiteral('string'))), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createPropertyAccessExpression(detailsIdentifier, 'message'), ts.factory.createToken(ts.SyntaxKind.ColonToken), ts.factory.createStringLiteral('Non-Error thrown value.'))),
+        ], ts.NodeFlags.Const)),
+        ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(errorIdentifier, undefined, undefined, ts.factory.createNewExpression(ts.factory.createIdentifier('Error'), undefined, [
+                messageIdentifier,
+                ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment('cause', valueIdentifier),
+                ]),
+            ])),
+        ], ts.NodeFlags.Const)),
+        ts.factory.createIfStatement(ts.factory.createBinaryExpression(detailsIdentifier, ts.SyntaxKind.AmpersandAmpersandToken, ts.factory.createBinaryExpression(ts.factory.createTypeOfExpression(ts.factory.createPropertyAccessExpression(detailsIdentifier, 'name')), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createStringLiteral('string'))), ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(errorIdentifier, 'name'), ts.SyntaxKind.EqualsToken, ts.factory.createPropertyAccessExpression(detailsIdentifier, 'name'))),
+        ], true)),
+        ts.factory.createIfStatement(ts.factory.createBinaryExpression(detailsIdentifier, ts.SyntaxKind.AmpersandAmpersandToken, ts.factory.createBinaryExpression(ts.factory.createTypeOfExpression(ts.factory.createPropertyAccessExpression(detailsIdentifier, 'stack')), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createStringLiteral('string'))), ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(errorIdentifier, 'stack'), ts.SyntaxKind.EqualsToken, ts.factory.createPropertyAccessExpression(detailsIdentifier, 'stack'))),
+        ], true)),
+        ts.factory.createReturnStatement(errorIdentifier),
+    ], true));
+}
+function createInternalParameter(name) {
+    return ts.factory.createParameterDeclaration(undefined, undefined, name, undefined, undefined, undefined);
+}
+function createNormalizedBindingStatement(name, valueExpression) {
+    return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(name, undefined, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier(SOUNDSCRIPT_NORMALIZE_ERROR_HELPER_NAME), undefined, [valueExpression])),
+    ], ts.NodeFlags.Const));
+}
+function insertHelperDeclaration(sourceFile) {
+    const statements = [...sourceFile.statements];
+    let insertIndex = 0;
+    while (insertIndex < statements.length && ts.isImportDeclaration(statements[insertIndex])) {
+        insertIndex += 1;
+    }
+    return ts.factory.updateSourceFile(sourceFile, [
+        ...statements.slice(0, insertIndex),
+        createHelperDeclaration(),
+        ...statements.slice(insertIndex),
+    ]);
+}
+function splitTextLines(text) {
+    const lines = [];
+    let start = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] !== '\n') {
+            continue;
+        }
+        const end = index + 1;
+        lines.push({
+            start,
+            end,
+            matchText: createLineMatchText(text.slice(start, end)),
+            text: text.slice(start, end),
+        });
+        start = end;
+    }
+    if (start < text.length || text.length === 0) {
+        lines.push({
+            start,
+            end: text.length,
+            matchText: createLineMatchText(text.slice(start)),
+            text: text.slice(start),
+        });
+    }
+    return lines;
+}
+function createLineMatchText(text) {
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : text;
+}
+function computeAlignedLinePairs(originalLines, rewrittenLines) {
+    const dp = Array.from({ length: originalLines.length + 1 }, () => new Uint32Array(rewrittenLines.length + 1));
+    for (let originalIndex = originalLines.length - 1; originalIndex >= 0; originalIndex -= 1) {
+        for (let rewrittenIndex = rewrittenLines.length - 1; rewrittenIndex >= 0; rewrittenIndex -= 1) {
+            dp[originalIndex][rewrittenIndex] =
+                originalLines[originalIndex].matchText === rewrittenLines[rewrittenIndex].matchText
+                    ? dp[originalIndex + 1][rewrittenIndex + 1] + 1
+                    : Math.max(dp[originalIndex + 1][rewrittenIndex], dp[originalIndex][rewrittenIndex + 1]);
+        }
+    }
+    const pairs = [];
+    let originalIndex = 0;
+    let rewrittenIndex = 0;
+    while (originalIndex < originalLines.length && rewrittenIndex < rewrittenLines.length) {
+        if (originalLines[originalIndex].matchText === rewrittenLines[rewrittenIndex].matchText &&
+            dp[originalIndex][rewrittenIndex] === dp[originalIndex + 1][rewrittenIndex + 1] + 1) {
+            pairs.push({ originalIndex, rewrittenIndex });
+            originalIndex += 1;
+            rewrittenIndex += 1;
+            continue;
+        }
+        if (dp[originalIndex + 1][rewrittenIndex] >= dp[originalIndex][rewrittenIndex + 1]) {
+            originalIndex += 1;
+        }
+        else {
+            rewrittenIndex += 1;
+        }
+    }
+    return pairs;
+}
+function commonPrefixLength(left, right) {
+    const limit = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < limit && left[index] === right[index]) {
+        index += 1;
+    }
+    return index;
+}
+function commonSuffixLength(left, right) {
+    const limit = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < limit &&
+        left[left.length - 1 - index] === right[right.length - 1 - index]) {
+        index += 1;
+    }
+    return index;
+}
+function computeTrailingLineMappedSegments(originalText, rewrittenText, originalBase, rewrittenBase) {
+    const originalLines = splitTextLines(originalText);
+    const rewrittenLines = splitTextLines(rewrittenText);
+    if (originalLines.length === 0 || rewrittenLines.length === 0) {
+        return [];
+    }
+    const rewrittenLineOffset = Math.max(0, rewrittenLines.length - originalLines.length);
+    const segments = [];
+    for (let originalIndex = 0; originalIndex < originalLines.length; originalIndex += 1) {
+        const rewrittenIndex = originalIndex + rewrittenLineOffset;
+        const originalLine = originalLines[originalIndex];
+        const rewrittenLine = rewrittenLines[rewrittenIndex];
+        if (!originalLine || !rewrittenLine) {
+            continue;
+        }
+        const prefixLength = commonPrefixLength(originalLine.text, rewrittenLine.text);
+        const maxSuffixLength = Math.min(originalLine.text.length - prefixLength, rewrittenLine.text.length - prefixLength);
+        const suffixLength = Math.min(commonSuffixLength(originalLine.text.slice(prefixLength), rewrittenLine.text.slice(prefixLength)), maxSuffixLength);
+        if (prefixLength > 0) {
+            segments.push({
+                originalStart: originalBase + originalLine.start,
+                originalEnd: originalBase + originalLine.start + prefixLength,
+                rewrittenStart: rewrittenBase + rewrittenLine.start,
+                rewrittenEnd: rewrittenBase + rewrittenLine.start + prefixLength,
+            });
+        }
+        if (suffixLength > 0) {
+            segments.push({
+                originalStart: originalBase + originalLine.end - suffixLength,
+                originalEnd: originalBase + originalLine.end,
+                rewrittenStart: rewrittenBase + rewrittenLine.end - suffixLength,
+                rewrittenEnd: rewrittenBase + rewrittenLine.end,
+            });
+        }
+    }
+    return segments.filter((segment) => segment.originalStart < segment.originalEnd);
+}
+export function buildRewriteStageFromTexts(fileName, originalText, rewrittenText) {
+    if (originalText === rewrittenText) {
+        return {
+            replacements: [],
+            rewrittenText,
+        };
+    }
+    const originalLines = splitTextLines(originalText);
+    const rewrittenLines = splitTextLines(rewrittenText);
+    const alignedPairs = computeAlignedLinePairs(originalLines, rewrittenLines);
+    const lineMappings = alignedPairs.map((pair) => ({
+        originalStart: originalLines[pair.originalIndex]?.start ?? originalText.length,
+        originalEnd: originalLines[pair.originalIndex]?.end ?? originalText.length,
+        rewrittenStart: rewrittenLines[pair.rewrittenIndex]?.start ?? rewrittenText.length,
+        rewrittenEnd: rewrittenLines[pair.rewrittenIndex]?.end ?? rewrittenText.length,
+    }));
+    const replacements = [];
+    let replacementId = 1;
+    let originalIndex = 0;
+    let rewrittenIndex = 0;
+    for (const pair of [...alignedPairs, {
+            originalIndex: originalLines.length,
+            rewrittenIndex: rewrittenLines.length,
+        }]) {
+        const originalStart = originalLines[originalIndex]?.start ?? originalText.length;
+        const rewrittenStart = rewrittenLines[rewrittenIndex]?.start ?? rewrittenText.length;
+        const originalEnd = originalLines[pair.originalIndex]?.start ?? originalText.length;
+        const rewrittenEnd = rewrittenLines[pair.rewrittenIndex]?.start ?? rewrittenText.length;
+        if (originalStart !== originalEnd || rewrittenStart !== rewrittenEnd) {
+            replacements.push({
+                id: replacementId,
+                mappedSegments: computeTrailingLineMappedSegments(originalText.slice(originalStart, originalEnd), rewrittenText.slice(rewrittenStart, rewrittenEnd), originalStart, rewrittenStart),
+                originalSpan: {
+                    fileName,
+                    start: originalStart,
+                    end: originalEnd,
+                },
+                rewriteText: rewrittenText.slice(rewrittenStart, rewrittenEnd),
+                rewrittenSpan: {
+                    fileName,
+                    start: rewrittenStart,
+                    end: rewrittenEnd,
+                },
+            });
+            replacementId += 1;
+        }
+        originalIndex = pair.originalIndex + 1;
+        rewrittenIndex = pair.rewrittenIndex + 1;
+    }
+    return {
+        lineMappings,
+        replacements,
+        rewrittenText,
+    };
+}
+function normalizeSourceFile(sourceFile, checker) {
+    let changed = false;
+    let needsHelper = false;
+    let caughtCounter = 0;
+    let onRejectedCounter = 0;
+    let rejectionValueCounter = 0;
+    const transformer = (context) => {
+        function nextCaughtName() {
+            caughtCounter += 1;
+            return `__sts_caught_${caughtCounter}`;
+        }
+        function nextOnRejectedName() {
+            onRejectedCounter += 1;
+            return `__sts_onRejected_${onRejectedCounter}`;
+        }
+        function nextRejectedValueName() {
+            rejectionValueCounter += 1;
+            return `__sts_rejected_${rejectionValueCounter}`;
+        }
+        function rewriteRejectedHandler(handler) {
+            if (handler.parameters.length === 0) {
+                return handler;
+            }
+            changed = true;
+            needsHelper = true;
+            const [firstParameter, ...remainingParameters] = handler.parameters;
+            const internalName = nextCaughtName();
+            const normalizationStatement = createNormalizedBindingStatement(firstParameter.name, ts.factory.createIdentifier(internalName));
+            const parameters = [
+                createInternalParameter(internalName),
+                ...remainingParameters,
+            ];
+            if (ts.isArrowFunction(handler)) {
+                const visitedBody = ts.visitNode(handler.body, visit);
+                const block = visitedBody && ts.isBlock(visitedBody)
+                    ? ts.factory.updateBlock(visitedBody, [
+                        normalizationStatement,
+                        ...visitedBody.statements,
+                    ])
+                    : ts.factory.createBlock([
+                        normalizationStatement,
+                        ts.factory.createReturnStatement(visitedBody && ts.isExpression(visitedBody)
+                            ? visitedBody
+                            : handler.body),
+                    ], true);
+                return ts.factory.updateArrowFunction(handler, handler.modifiers, handler.typeParameters, parameters, handler.type, handler.equalsGreaterThanToken, block);
+            }
+            const visitedBody = ts.visitNode(handler.body, visit);
+            const block = visitedBody && ts.isBlock(visitedBody)
+                ? ts.factory.updateBlock(visitedBody, [
+                    normalizationStatement,
+                    ...visitedBody.statements,
+                ])
+                : ts.factory.createBlock([normalizationStatement], true);
+            return ts.factory.updateFunctionExpression(handler, handler.modifiers, handler.asteriskToken, handler.name, handler.typeParameters, parameters, handler.type, block);
+        }
+        function createRejectedHandlerAdapter(handlerExpression) {
+            changed = true;
+            needsHelper = true;
+            const capturedName = nextOnRejectedName();
+            const rejectionValueName = nextRejectedValueName();
+            const capturedIdentifier = ts.factory.createIdentifier(capturedName);
+            const rejectionValueIdentifier = ts.factory.createIdentifier(rejectionValueName);
+            return ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [createInternalParameter(capturedName)], undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(capturedIdentifier, ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createIdentifier('undefined')), ts.SyntaxKind.BarBarToken, ts.factory.createBinaryExpression(capturedIdentifier, ts.SyntaxKind.EqualsEqualsEqualsToken, ts.factory.createNull())), ts.factory.createToken(ts.SyntaxKind.QuestionToken), capturedIdentifier, ts.factory.createToken(ts.SyntaxKind.ColonToken), ts.factory.createArrowFunction(undefined, undefined, [createInternalParameter(rejectionValueName)], undefined, undefined, ts.factory.createCallExpression(capturedIdentifier, undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier(SOUNDSCRIPT_NORMALIZE_ERROR_HELPER_NAME), undefined, [rejectionValueIdentifier]),
+            ]))))), undefined, [handlerExpression]);
+        }
+        const visit = (node) => {
+            if (ts.isTryStatement(node) && node.catchClause?.variableDeclaration) {
+                const visitedTry = ts.visitEachChild(node, visit, context);
+                const visitedCatchClause = visitedTry.catchClause;
+                const originalCatchClause = node.catchClause;
+                if (!visitedCatchClause || !originalCatchClause?.variableDeclaration) {
+                    return visitedTry;
+                }
+                changed = true;
+                needsHelper = true;
+                const internalName = nextCaughtName();
+                const normalizationStatement = createNormalizedBindingStatement(originalCatchClause.variableDeclaration.name, ts.factory.createIdentifier(internalName));
+                const updatedCatchClause = ts.factory.updateCatchClause(visitedCatchClause, ts.factory.createVariableDeclaration(internalName), ts.factory.updateBlock(visitedCatchClause.block, [
+                    normalizationStatement,
+                    ...visitedCatchClause.block.statements,
+                ]));
+                return ts.factory.updateTryStatement(visitedTry, visitedTry.tryBlock, updatedCatchClause, visitedTry.finallyBlock);
+            }
+            if (ts.isCallExpression(node)) {
+                const visitedCall = ts.visitEachChild(node, visit, context);
+                if (!ts.isCallExpression(visitedCall)) {
+                    return visitedCall;
+                }
+                if (isBuiltInPromiseMethodCall(node, checker, 'catch')) {
+                    if (visitedCall.arguments.length === 0) {
+                        return visitedCall;
+                    }
+                    const [handler, ...restArguments] = visitedCall.arguments;
+                    const rewrittenHandler = ts.isArrowFunction(handler) || ts.isFunctionExpression(handler)
+                        ? rewriteRejectedHandler(handler)
+                        : createRejectedHandlerAdapter(handler);
+                    return ts.factory.updateCallExpression(visitedCall, visitedCall.expression, visitedCall.typeArguments, [rewrittenHandler, ...restArguments]);
+                }
+                if (isBuiltInPromiseMethodCall(node, checker, 'then')) {
+                    if (visitedCall.arguments.length < 2) {
+                        return visitedCall;
+                    }
+                    const [onFulfilled, onRejected, ...restArguments] = visitedCall.arguments;
+                    const rewrittenRejected = ts.isArrowFunction(onRejected) || ts.isFunctionExpression(onRejected)
+                        ? rewriteRejectedHandler(onRejected)
+                        : createRejectedHandlerAdapter(onRejected);
+                    return ts.factory.updateCallExpression(visitedCall, visitedCall.expression, visitedCall.typeArguments, [onFulfilled, rewrittenRejected, ...restArguments]);
+                }
+                return visitedCall;
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return (node) => {
+            const visited = ts.visitNode(node, visit);
+            const visitedSourceFile = visited && ts.isSourceFile(visited) ? visited : node;
+            return changed && needsHelper
+                ? insertHelperDeclaration(visitedSourceFile)
+                : visitedSourceFile;
+        };
+    };
+    const result = ts.transform(sourceFile, [transformer]);
+    const [transformed] = result.transformed;
+    result.dispose();
+    if (!changed || !transformed) {
+        return undefined;
+    }
+    const printer = ts.createPrinter();
+    const rewrittenText = repairBuiltinMacroModuleSpecifiers(printer.printFile(transformed));
+    return {
+        rewriteStage: buildRewriteStageFromTexts(sourceFile.fileName, sourceFile.text, rewrittenText),
+        sourceFile: ts.createSourceFile(sourceFile.fileName, rewrittenText, sourceFile.languageVersion, true),
+    };
+}
+export function normalizeErrorBoundariesInProgram(program) {
+    const checker = program.getTypeChecker();
+    const changedFiles = new Map();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile ||
+            !isSoundscriptSourceFile(toSourceFileName(sourceFile.fileName))) {
+            continue;
+        }
+        const normalized = normalizeSourceFile(sourceFile, checker);
+        if (normalized) {
+            changedFiles.set(sourceFile.fileName, normalized);
+        }
+    }
+    return { changedFiles };
+}