clanka 0.2.28 → 0.2.29

package/dist/ScriptPreprocessing.js

@@ -1,3 +1,8 @@
+const callTemplateTargets = ["applyPatch", "taskComplete"];
+const objectPropertyTargets = [
+    { functionName: "writeFile", propertyName: "content" },
+    { functionName: "updateTask", propertyName: "description" },
+];
 const isIdentifierChar = (char) => char !== undefined && /[A-Za-z0-9_$]/.test(char);
 const isIdentifierStartChar = (char) => char !== undefined && /[A-Za-z_$]/.test(char);
 const hasIdentifierBoundary = (text, index, length) => !isIdentifierChar(text[index - 1]) && !isIdentifierChar(text[index + length]);
@@ -12,11 +17,11 @@ const findNextIdentifier = (text, identifier, from) => {
     return -1;
 };
 const skipWhitespace = (text, start) => {
-    let i = start;
-    while (i < text.length && /\s/.test(text[i])) {
-        i++;
+    let index = start;
+    while (index < text.length && /\s/.test(text[index])) {
+        index++;
     }
-    return i;
+    return index;
 };
 const parseIdentifier = (text, start) => {
     if (!isIdentifierStartChar(text[start])) {
@@ -32,28 +37,125 @@ const parseIdentifier = (text, start) => {
     };
 };
 const findPreviousNonWhitespace = (text, from) => {
-    let i = from;
-    while (i >= 0 && /\s/.test(text[i])) {
-        i--;
+    let index = from;
+    while (index >= 0 && /\s/.test(text[index])) {
+        index--;
     }
-    return i;
+    return index;
 };
 const findNextNonWhitespace = (text, from) => {
-    let i = from;
-    while (i < text.length && /\s/.test(text[i])) {
-        i++;
+    let index = from;
+    while (index < text.length && /\s/.test(text[index])) {
+        index++;
+    }
+    return index;
+};
+const isEscaped = (text, index) => {
+    let slashCount = 0;
+    let cursor = index - 1;
+    while (cursor >= 0 && text[cursor] === "\\") {
+        slashCount++;
+        cursor--;
+    }
+    return slashCount % 2 === 1;
+};
+const needsTemplateEscaping = (text) => {
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === "`" && !isEscaped(text, index)) {
+            return true;
+        }
+        if (char === "$" && text[index + 1] === "{" && !isEscaped(text, index)) {
+            return true;
+        }
+    }
+    return false;
+};
+const findTemplateEnd = (text, start, isTerminator) => {
+    let end = -1;
+    for (let index = start + 1; index < text.length; index++) {
+        if (text[index] !== "`" || isEscaped(text, index)) {
+            continue;
+        }
+        if (isTerminator(text[index + 1])) {
+            end = index;
+            continue;
+        }
+        const next = skipWhitespace(text, index + 1);
+        if (isTerminator(text[next])) {
+            end = index;
+        }
+    }
+    return end;
+};
+const findTypeAnnotationAssignment = (text, start) => {
+    let index = start;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === "=") {
+            return index;
+        }
+        if (char === "\n" || char === ";") {
+            return -1;
+        }
+        index++;
     }
-    return i;
+    return -1;
+};
+const findClosingParen = (text, openParen) => {
+    let depth = 1;
+    for (let index = openParen + 1; index < text.length; index++) {
+        const char = text[index];
+        if (char === "(") {
+            depth++;
+            continue;
+        }
+        if (char === ")") {
+            depth--;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
+};
+const findClosingBrace = (text, openBrace) => {
+    let depth = 1;
+    let stringDelimiter;
+    for (let index = openBrace + 1; index < text.length; index++) {
+        const char = text[index];
+        if (stringDelimiter !== undefined) {
+            if (char === stringDelimiter && !isEscaped(text, index)) {
+                stringDelimiter = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            stringDelimiter = char;
+            continue;
+        }
+        if (char === "{") {
+            depth++;
+            continue;
+        }
+        if (char === "}") {
+            depth--;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
 };
 const findObjectValueTerminator = (text, start) => {
     let parenDepth = 0;
     let bracketDepth = 0;
     let braceDepth = 0;
     let stringDelimiter;
-    for (let i = start; i < text.length; i++) {
-        const char = text[i];
+    for (let index = start; index < text.length; index++) {
+        const char = text[index];
         if (stringDelimiter !== undefined) {
-            if (char === stringDelimiter && !isEscaped(text, i)) {
+            if (char === stringDelimiter && !isEscaped(text, index)) {
                 stringDelimiter = undefined;
             }
             continue;
@@ -88,7 +190,7 @@ const findObjectValueTerminator = (text, start) => {
         }
         if (char === "}") {
             if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
-                return i;
+                return index;
             }
             if (braceDepth > 0) {
                 braceDepth--;
@@ -99,13 +201,13 @@ const findObjectValueTerminator = (text, start) => {
             parenDepth === 0 &&
             bracketDepth === 0 &&
             braceDepth === 0) {
-            return i;
+            return index;
         }
     }
     return -1;
 };
 const collectExpressionIdentifiers = (text, start, end) => {
-    const out = new Set();
+    const identifiers = new Set();
     let cursor = start;
     while (cursor < end) {
         const identifier = parseIdentifier(text, cursor);
@@ -113,37 +215,14 @@ const collectExpressionIdentifiers = (text, start, end) => {
             cursor++;
             continue;
         }
-        const previousNonWhitespace = findPreviousNonWhitespace(text, cursor - 1);
-        const nextNonWhitespace = findNextNonWhitespace(text, identifier.end);
-        if (text[previousNonWhitespace] !== "." &&
-            text[nextNonWhitespace] !== "." &&
-            text[nextNonWhitespace] !== "(") {
-            out.add(identifier.name);
+        const previous = findPreviousNonWhitespace(text, cursor - 1);
+        const next = findNextNonWhitespace(text, identifier.end);
+        if (text[previous] !== "." && text[next] !== "." && text[next] !== "(") {
+            identifiers.add(identifier.name);
         }
         cursor = identifier.end;
     }
-    return out;
-};
-const isEscaped = (text, index) => {
-    let slashCount = 0;
-    let i = index - 1;
-    while (i >= 0 && text[i] === "\\") {
-        slashCount++;
-        i--;
-    }
-    return slashCount % 2 === 1;
-};
-const needsTemplateEscaping = (text) => {
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        if (char === "`" && !isEscaped(text, i)) {
-            return true;
-        }
-        if (char === "$" && text[i + 1] === "{" && !isEscaped(text, i)) {
-            return true;
-        }
-    }
-    return false;
+    return identifiers;
 };
 const normalizePatchEscapedQuotes = (text) => text.includes("*** Begin Patch")
     ? text.replace(/\\"([A-Za-z0-9_$.-]+)\\"/g, (match, content, index) => {
@@ -166,35 +245,36 @@ const normalizeNonPatchEscapedTemplateMarkers = (text) => text
     .replace(/\\{2,}(?=`|\$\{)/g, "\\")
     .replace(/(^|\s)\\+(?=\.[A-Za-z0-9_-]+\/)/g, "$1");
 const escapeTemplateLiteralContent = (text) => {
-    const normalizedPatchQuotes = normalizePatchEscapedQuotes(text);
-    const isPatchContent = normalizedPatchQuotes.includes("*** Begin Patch");
+    const patchNormalized = normalizePatchEscapedQuotes(text);
+    const isPatchContent = patchNormalized.includes("*** Begin Patch");
     const normalized = isPatchContent
-        ? normalizedPatchQuotes
-        : normalizeNonPatchEscapedTemplateMarkers(normalizedPatchQuotes);
+        ? patchNormalized
+        : normalizeNonPatchEscapedTemplateMarkers(patchNormalized);
     if (!needsTemplateEscaping(normalized) &&
-        !(isPatchContent && normalized.includes("\\"))) {
+        !(isPatchContent && normalized.includes('\\"'))) {
         return normalized;
     }
     let out = "";
-    for (let i = 0; i < normalized.length; i++) {
-        const char = normalized[i];
+    for (let index = 0; index < normalized.length; index++) {
+        const char = normalized[index];
         if (char === "\\") {
-            if (!isPatchContent &&
-                (normalized[i + 1] === "`" ||
-                    (normalized[i + 1] === "$" && normalized[i + 2] === "{"))) {
+            if ((normalized[index + 1] === "`" && isEscaped(normalized, index + 1)) ||
+                (normalized[index + 1] === "$" &&
+                    normalized[index + 2] === "{" &&
+                    isEscaped(normalized, index + 1))) {
                 out += "\\";
                 continue;
             }
             out += "\\\\";
             continue;
         }
-        if (char === "`" && !isEscaped(normalized, i)) {
+        if (char === "`" && !isEscaped(normalized, index)) {
             out += "\\`";
             continue;
         }
         if (char === "$" &&
-            normalized[i + 1] === "{" &&
-            !isEscaped(normalized, i)) {
+            normalized[index + 1] === "{" &&
+            !isEscaped(normalized, index)) {
             out += "\\$";
             continue;
         }
@@ -202,230 +282,122 @@ const escapeTemplateLiteralContent = (text) => {
     }
     return out;
 };
-const findTemplateEnd = (text, start, isTerminator) => {
-    let end = -1;
-    for (let i = start + 1; i < text.length; i++) {
-        if (text[i] !== "`" || isEscaped(text, i)) {
-            continue;
-        }
-        if (isTerminator(text[i + 1])) {
-            end = i;
-            continue;
-        }
-        const next = skipWhitespace(text, i + 1);
-        if (isTerminator(text[next])) {
-            end = i;
-        }
-    }
-    return end;
-};
-const findTypeAnnotationAssignment = (text, start) => {
-    let i = start;
-    while (i < text.length) {
-        const char = text[i];
-        if (char === "=") {
-            return i;
-        }
-        if (char === "\n" || char === ";") {
-            return -1;
-        }
-        i++;
-    }
-    return -1;
-};
-const findClosingParen = (text, openParen) => {
-    let depth = 1;
-    for (let i = openParen + 1; i < text.length; i++) {
-        const char = text[i];
-        if (char === "(") {
-            depth++;
-            continue;
-        }
-        if (char === ")") {
-            depth--;
-            if (depth === 0) {
-                return i;
-            }
-        }
-    }
-    return -1;
-};
-const findClosingBrace = (text, openBrace) => {
-    let depth = 1;
-    let stringDelimiter;
-    for (let i = openBrace + 1; i < text.length; i++) {
-        const char = text[i];
-        if (stringDelimiter !== undefined) {
-            if (char === stringDelimiter && !isEscaped(text, i)) {
-                stringDelimiter = undefined;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            stringDelimiter = char;
-            continue;
-        }
-        if (char === "{") {
-            depth++;
-            continue;
-        }
-        if (char === "}") {
-            depth--;
-            if (depth === 0) {
-                return i;
-            }
-        }
-    }
-    return -1;
-};
-const fixObjectLiteralTemplateValues = (text) => text.replace(/\\{2,}(?=`|\$\{)/g, "\\");
-const fixAssignedObjectTemplateValues = (script, variableName) => {
+const normalizeObjectLiteralTemplateMarkers = (text) => text.replace(/\\{2,}(?=`|\$\{)/g, "\\");
+const replaceSlice = (text, start, end, replacement) => `${text.slice(0, start)}${replacement}${text.slice(end)}`;
+const rewriteTemplateContents = (script, findNext, rewrite) => {
     let out = script;
     let cursor = 0;
     while (cursor < out.length) {
-        const variableStart = findNextIdentifier(out, variableName, cursor);
-        if (variableStart === -1) {
+        const range = findNext(out, cursor);
+        if (range === undefined) {
             break;
         }
-        let assignmentStart = skipWhitespace(out, variableStart + variableName.length);
-        if (out[assignmentStart] === ":") {
-            assignmentStart = findTypeAnnotationAssignment(out, assignmentStart + 1);
-            if (assignmentStart === -1) {
-                cursor = variableStart + variableName.length;
-                continue;
-            }
-        }
-        if (out[assignmentStart] !== "=" ||
-            out[assignmentStart + 1] === "=" ||
-            out[assignmentStart + 1] === ">") {
-            cursor = variableStart + variableName.length;
-            continue;
-        }
-        const objectStart = skipWhitespace(out, assignmentStart + 1);
-        if (out[objectStart] !== "{") {
-            cursor = objectStart + 1;
-            continue;
-        }
-        const objectEnd = findClosingBrace(out, objectStart);
-        if (objectEnd === -1) {
-            cursor = objectStart + 1;
-            continue;
-        }
-        const original = out.slice(objectStart, objectEnd + 1);
-        const escaped = fixObjectLiteralTemplateValues(original);
-        if (escaped !== original) {
-            out = `${out.slice(0, objectStart)}${escaped}${out.slice(objectEnd + 1)}`;
-            cursor = objectEnd + (escaped.length - original.length) + 1;
+        const original = out.slice(range.contentStart, range.contentEnd);
+        const updated = rewrite(original);
+        if (updated !== original) {
+            out = replaceSlice(out, range.contentStart, range.contentEnd, updated);
+            cursor = range.nextCursor + (updated.length - original.length);
             continue;
         }
-        cursor = objectEnd + 1;
-    }
-    return out;
-};
-const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
-const collectObjectEntryMapSources = (script, valueIdentifier) => {
-    const out = new Set();
-    const pattern = new RegExp(`Object\\.entries\\(\\s*([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\)\\s*\\.map\\(\\s*(?:async\\s*)?\\(\\s*\\[\\s*[A-Za-z_$][A-Za-z0-9_$]*\\s*,\\s*${escapeRegExp(valueIdentifier)}\\s*\\]\\s*\\)\\s*=>`, "g");
-    for (const match of script.matchAll(pattern)) {
-        const sourceIdentifier = match[1];
-        if (sourceIdentifier !== undefined) {
-            out.add(sourceIdentifier);
-        }
+        cursor = range.nextCursor;
     }
     return out;
 };
-const findCallTemplateEnd = (text, templateStart, openParen) => {
-    const closeParen = findClosingParen(text, openParen);
-    if (closeParen === -1) {
-        return -1;
-    }
-    for (let i = closeParen - 1; i > templateStart; i--) {
-        if (text[i] === "`" && !isEscaped(text, i)) {
-            return i;
-        }
-    }
-    return -1;
-};
-const fixCallTemplateArgument = (script, functionName) => {
-    let out = script;
-    let cursor = 0;
-    while (cursor < out.length) {
-        const callStart = findNextIdentifier(out, functionName, cursor);
+const findDirectCallTemplate = (text, functionName, from) => {
+    let cursor = from;
+    while (cursor < text.length) {
+        const callStart = findNextIdentifier(text, functionName, cursor);
         if (callStart === -1) {
-            break;
+            return undefined;
         }
-        const openParen = skipWhitespace(out, callStart + functionName.length);
-        if (out[openParen] !== "(") {
+        const openParen = skipWhitespace(text, callStart + functionName.length);
+        if (text[openParen] !== "(") {
             cursor = callStart + functionName.length;
             continue;
         }
-        const templateStart = skipWhitespace(out, openParen + 1);
-        if (out[templateStart] !== "`") {
+        const templateStart = skipWhitespace(text, openParen + 1);
+        if (text[templateStart] !== "`") {
             cursor = openParen + 1;
             continue;
         }
-        const templateEnd = findCallTemplateEnd(out, templateStart, openParen);
+        const closeParen = findClosingParen(text, openParen);
+        let templateEnd = -1;
+        if (closeParen !== -1) {
+            for (let index = closeParen - 1; index > templateStart; index--) {
+                if (text[index] === "`" && !isEscaped(text, index)) {
+                    templateEnd = index;
+                    break;
+                }
+            }
+        }
+        else {
+            const patchEnd = text.indexOf("*** End Patch", templateStart);
+            const searchStart = patchEnd === -1 ? templateStart + 1 : patchEnd + 1;
+            for (let index = searchStart; index < text.length; index++) {
+                if (text[index] !== "`" || isEscaped(text, index)) {
+                    continue;
+                }
+                const candidate = skipWhitespace(text, index + 1);
+                if (text[candidate] === ")") {
+                    templateEnd = index;
+                    break;
+                }
+            }
+        }
         if (templateEnd === -1) {
             cursor = templateStart + 1;
             continue;
         }
-        const original = out.slice(templateStart + 1, templateEnd);
-        const escaped = escapeTemplateLiteralContent(original);
-        if (escaped !== original) {
-            out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`;
-            cursor = templateEnd + (escaped.length - original.length) + 1;
-            continue;
-        }
-        cursor = templateEnd + 1;
+        return {
+            contentStart: templateStart + 1,
+            contentEnd: templateEnd,
+            nextCursor: templateEnd + 1,
+        };
     }
-    return out;
+    return undefined;
 };
-const fixCallObjectPropertyTemplate = (script, functionName, propertyName) => {
-    let out = script;
-    let cursor = 0;
-    while (cursor < out.length) {
-        const callStart = findNextIdentifier(out, functionName, cursor);
+const findObjectPropertyTemplate = (text, target, from) => {
+    let cursor = from;
+    while (cursor < text.length) {
+        const callStart = findNextIdentifier(text, target.functionName, cursor);
         if (callStart === -1) {
-            break;
+            return undefined;
         }
-        const openParen = skipWhitespace(out, callStart + functionName.length);
-        if (out[openParen] !== "(") {
-            cursor = callStart + functionName.length;
+        const openParen = skipWhitespace(text, callStart + target.functionName.length);
+        if (text[openParen] !== "(") {
+            cursor = callStart + target.functionName.length;
             continue;
         }
-        const propertyKey = findNextIdentifier(out, propertyName, openParen + 1);
+        const propertyKey = findNextIdentifier(text, target.propertyName, openParen + 1);
         if (propertyKey === -1) {
             cursor = openParen + 1;
             continue;
         }
-        const colon = skipWhitespace(out, propertyKey + propertyName.length);
-        if (out[colon] !== ":") {
-            cursor = propertyKey + propertyName.length;
+        const colon = skipWhitespace(text, propertyKey + target.propertyName.length);
+        if (text[colon] !== ":") {
+            cursor = propertyKey + target.propertyName.length;
             continue;
         }
-        const templateStart = skipWhitespace(out, colon + 1);
-        if (out[templateStart] !== "`") {
+        const templateStart = skipWhitespace(text, colon + 1);
+        if (text[templateStart] !== "`") {
             cursor = templateStart + 1;
             continue;
         }
-        const templateEnd = findTemplateEnd(out, templateStart, (char) => char === "}" || char === ",");
+        const templateEnd = findTemplateEnd(text, templateStart, (char) => char === "}" || char === ",");
         if (templateEnd === -1) {
             cursor = templateStart + 1;
             continue;
         }
-        const original = out.slice(templateStart + 1, templateEnd);
-        const escaped = escapeTemplateLiteralContent(original);
-        if (escaped !== original) {
-            out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`;
-            cursor = templateEnd + (escaped.length - original.length) + 1;
-            continue;
-        }
-        cursor = templateEnd + 1;
+        return {
+            contentStart: templateStart + 1,
+            contentEnd: templateEnd,
+            nextCursor: templateEnd + 1,
+        };
     }
-    return out;
+    return undefined;
 };
 const collectCallArgumentIdentifiers = (script, functionName) => {
-    const out = new Set();
+    const identifiers = new Set();
     let cursor = 0;
     while (cursor < script.length) {
         const callStart = findNextIdentifier(script, functionName, cursor);
@@ -445,57 +417,98 @@ const collectCallArgumentIdentifiers = (script, functionName) => {
         }
         const argumentEnd = skipWhitespace(script, identifier.end);
         if (script[argumentEnd] === ")" || script[argumentEnd] === ",") {
-            out.add(identifier.name);
+            identifiers.add(identifier.name);
         }
         cursor = identifier.end;
     }
-    return out;
+    return identifiers;
 };
-const collectCallObjectPropertyIdentifiers = (script, functionName, propertyName) => {
-    const out = new Set();
+const collectObjectPropertyIdentifiers = (script, target) => {
+    const identifiers = new Set();
     let cursor = 0;
     while (cursor < script.length) {
-        const callStart = findNextIdentifier(script, functionName, cursor);
+        const callStart = findNextIdentifier(script, target.functionName, cursor);
         if (callStart === -1) {
             break;
         }
-        const openParen = skipWhitespace(script, callStart + functionName.length);
+        const openParen = skipWhitespace(script, callStart + target.functionName.length);
         if (script[openParen] !== "(") {
-            cursor = callStart + functionName.length;
+            cursor = callStart + target.functionName.length;
             continue;
         }
-        const propertyKey = findNextIdentifier(script, propertyName, openParen + 1);
+        const propertyKey = findNextIdentifier(script, target.propertyName, openParen + 1);
         if (propertyKey === -1) {
             cursor = openParen + 1;
             continue;
         }
-        const afterProperty = skipWhitespace(script, propertyKey + propertyName.length);
+        const afterProperty = skipWhitespace(script, propertyKey + target.propertyName.length);
         if (script[afterProperty] === ":") {
             const valueStart = skipWhitespace(script, afterProperty + 1);
             const valueEnd = findObjectValueTerminator(script, valueStart);
             if (valueEnd !== -1) {
                 for (const identifier of collectExpressionIdentifiers(script, valueStart, valueEnd)) {
-                    out.add(identifier);
+                    identifiers.add(identifier);
                 }
             }
             cursor = valueStart + 1;
             continue;
         }
         if (script[afterProperty] === "}" || script[afterProperty] === ",") {
-            out.add(propertyName);
+            identifiers.add(target.propertyName);
             cursor = afterProperty + 1;
             continue;
         }
         cursor = afterProperty + 1;
     }
-    return out;
+    return identifiers;
 };
-const callObjectPropertyTargets = [
-    ["writeFile", "content"],
-    ["updateTask", "description"],
-];
-const fixTargetCallObjectPropertyTemplates = (script) => callObjectPropertyTargets.reduce((current, [functionName, propertyName]) => fixCallObjectPropertyTemplate(current, functionName, propertyName), script);
-const fixAssignedTemplate = (script, variableName) => {
+const rewriteAssignedTemplate = (script, variableName) => rewriteTemplateContents(script, (text, from) => {
+    let cursor = from;
+    while (cursor < text.length) {
+        const variableStart = findNextIdentifier(text, variableName, cursor);
+        if (variableStart === -1) {
+            return undefined;
+        }
+        let assignmentStart = skipWhitespace(text, variableStart + variableName.length);
+        if (text[assignmentStart] === ":") {
+            assignmentStart = findTypeAnnotationAssignment(text, assignmentStart + 1);
+            if (assignmentStart === -1) {
+                cursor = variableStart + variableName.length;
+                continue;
+            }
+        }
+        if (text[assignmentStart] !== "=" ||
+            text[assignmentStart + 1] === "=" ||
+            text[assignmentStart + 1] === ">") {
+            cursor = variableStart + variableName.length;
+            continue;
+        }
+        const templateStart = skipWhitespace(text, assignmentStart + 1);
+        if (text[templateStart] !== "`") {
+            cursor = templateStart + 1;
+            continue;
+        }
+        const templateEnd = findTemplateEnd(text, templateStart, (char) => char === undefined ||
+            char === "\n" ||
+            char === "\r" ||
+            char === ";" ||
+            char === "," ||
+            char === ")" ||
+            char === "}" ||
+            char === "]");
+        if (templateEnd === -1) {
+            cursor = templateStart + 1;
+            continue;
+        }
+        return {
+            contentStart: templateStart + 1,
+            contentEnd: templateEnd,
+            nextCursor: templateEnd + 1,
+        };
+    }
+    return undefined;
+}, escapeTemplateLiteralContent);
+const rewriteAssignedObjectLiteral = (script, variableName) => {
     let out = script;
     let cursor = 0;
     while (cursor < out.length) {
@@ -517,63 +530,84 @@ const fixAssignedTemplate = (script, variableName) => {
             cursor = variableStart + variableName.length;
             continue;
         }
-        const templateStart = skipWhitespace(out, assignmentStart + 1);
-        if (out[templateStart] !== "`") {
-            cursor = templateStart + 1;
+        const objectStart = skipWhitespace(out, assignmentStart + 1);
+        if (out[objectStart] !== "{") {
+            cursor = objectStart + 1;
             continue;
         }
-        const templateEnd = findTemplateEnd(out, templateStart, (char) => char === undefined ||
-            char === "\n" ||
-            char === "\r" ||
-            char === ";" ||
-            char === "," ||
-            char === ")" ||
-            char === "}" ||
-            char === "]");
-        if (templateEnd === -1) {
-            cursor = templateStart + 1;
+        const objectEnd = findClosingBrace(out, objectStart);
+        if (objectEnd === -1) {
+            cursor = objectStart + 1;
             continue;
         }
-        const original = out.slice(templateStart + 1, templateEnd);
-        const escaped = escapeTemplateLiteralContent(original);
-        if (escaped !== original) {
-            out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`;
-            cursor = templateEnd + (escaped.length - original.length) + 1;
+        const original = out.slice(objectStart, objectEnd + 1);
+        const updated = normalizeObjectLiteralTemplateMarkers(original);
+        if (updated !== original) {
+            out = replaceSlice(out, objectStart, objectEnd + 1, updated);
+            cursor = objectEnd + 1 + (updated.length - original.length);
             continue;
         }
-        cursor = templateEnd + 1;
+        cursor = objectEnd + 1;
     }
     return out;
 };
-const fixAssignedTemplatesForToolCalls = (script) => {
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+const collectObjectEntryMapSources = (script, valueIdentifier) => {
     const identifiers = new Set();
-    for (const functionName of ["applyPatch", "taskComplete"]) {
+    const pattern = new RegExp(`Object\\.entries\\(\\s*([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\)\\s*\\.map\\(\\s*(?:async\\s*)?\\(\\s*\\[\\s*[A-Za-z_$][A-Za-z0-9_$]*\\s*,\\s*${escapeRegExp(valueIdentifier)}\\s*\\]\\s*\\)\\s*=>`, "g");
+    for (const match of script.matchAll(pattern)) {
+        if (match[1] !== undefined) {
+            identifiers.add(match[1]);
+        }
+    }
+    return identifiers;
+};
+const rewriteDirectTemplates = (script) => {
+    let out = script;
+    for (const target of objectPropertyTargets) {
+        out = rewriteTemplateContents(out, (text, from) => findObjectPropertyTemplate(text, target, from), escapeTemplateLiteralContent);
+    }
+    for (const functionName of callTemplateTargets) {
+        out = rewriteTemplateContents(out, (text, from) => findDirectCallTemplate(text, functionName, from), escapeTemplateLiteralContent);
+    }
+    return out;
+};
+const collectReferencedTemplateIdentifiers = (script) => {
+    const templateIdentifiers = new Set();
+    for (const functionName of callTemplateTargets) {
         for (const identifier of collectCallArgumentIdentifiers(script, functionName)) {
-            identifiers.add(identifier);
+            templateIdentifiers.add(identifier);
         }
     }
-    for (const [functionName, propertyName] of callObjectPropertyTargets) {
-        for (const identifier of collectCallObjectPropertyIdentifiers(script, functionName, propertyName)) {
-            identifiers.add(identifier);
+    for (const target of objectPropertyTargets) {
+        for (const identifier of collectObjectPropertyIdentifiers(script, target)) {
+            templateIdentifiers.add(identifier);
         }
     }
     if (script.includes("*** Begin Patch")) {
-        identifiers.add("patch");
+        templateIdentifiers.add("patch");
     }
-    const objectTemplateIdentifiers = new Set();
-    for (const identifier of identifiers) {
-        for (const sourceIdentifier of collectObjectEntryMapSources(script, identifier)) {
-            objectTemplateIdentifiers.add(sourceIdentifier);
+    const objectIdentifiers = new Set();
+    for (const identifier of templateIdentifiers) {
+        for (const source of collectObjectEntryMapSources(script, identifier)) {
+            objectIdentifiers.add(source);
         }
     }
+    return {
+        templateIdentifiers,
+        objectIdentifiers,
+    };
+};
+const rewriteAssignedTargets = (script) => {
+    const { templateIdentifiers, objectIdentifiers } = collectReferencedTemplateIdentifiers(script);
     let out = script;
-    for (const identifier of identifiers) {
-        out = fixAssignedTemplate(out, identifier);
+    for (const identifier of templateIdentifiers) {
+        out = rewriteAssignedTemplate(out, identifier);
     }
-    for (const identifier of objectTemplateIdentifiers) {
-        out = fixAssignedObjectTemplateValues(out, identifier);
+    for (const identifier of objectIdentifiers) {
+        out = rewriteAssignedObjectLiteral(out, identifier);
     }
     return out;
 };
-export const preprocessScript = (script) => fixAssignedTemplatesForToolCalls(["applyPatch", "taskComplete"].reduce((current, functionName) => fixCallTemplateArgument(current, functionName), fixTargetCallObjectPropertyTemplates(script)));
+export const preprocessScript = (script) => rewriteAssignedTargets(rewriteDirectTemplates(script));
 //# sourceMappingURL=ScriptPreprocessing.js.map