@ttsc/factory 0.18.4 → 0.19.1

package/lib/factory/literals/createTemplateHead.js

@@ -7,9 +7,10 @@ const make_1 = require("../internal/make");
  * the leading backtick up to the first `${`.
  *
  * The `text` is the cooked content of that span. The optional `rawText` carries
- * the source spelling before escape processing; when omitted, the cooked text
- * is used. A head is not a complete expression on its own, it is one piece of a
- * larger template literal.
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A head is not a complete expression on its own, it is one piece
+ * of a larger template literal.
  *
  * The printer emits the opening backtick, the content, then the `${` that opens
  * the first substitution. With `text` of `head`, this prints:

package/lib/factory/literals/createTemplateHead.js.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateHead.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateHead.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;GAoBG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,EACF,EAAE,CAAC,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAH9C,QAAA,kBAAkB,GAAlB,kBAAkB,CAG4B"}
+{"version":3,"file":"createTemplateHead.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateHead.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,EACF,EAAE,CAAC,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAH9C,QAAA,kBAAkB,GAAlB,kBAAkB,CAG4B"}

package/lib/factory/literals/createTemplateHead.mjs

@@ -5,9 +5,10 @@ import { make } from '../internal/make.mjs';
  * the leading backtick up to the first `${`.
  *
  * The `text` is the cooked content of that span. The optional `rawText` carries
- * the source spelling before escape processing; when omitted, the cooked text
- * is used. A head is not a complete expression on its own, it is one piece of a
- * larger template literal.
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A head is not a complete expression on its own, it is one piece
+ * of a larger template literal.
  *
  * The printer emits the opening backtick, the content, then the `${` that opens
  * the first substitution. With `text` of `head`, this prints:

package/lib/factory/literals/createTemplateHead.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateHead.mjs","sources":["../../../src/factory/literals/createTemplateHead.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,KACC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}
+{"version":3,"file":"createTemplateHead.mjs","sources":["../../../src/factory/literals/createTemplateHead.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;MACU,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,KACC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/literals/createTemplateMiddle.d.ts

@@ -3,9 +3,12 @@ import type { TemplateMiddle } from "../../ast";
  * Create a {@link TemplateMiddle}: a span of a template expression that sits
  * between two substitutions, from one `}` to the next `${`.
  *
- * The `text` is the cooked content of that span. A middle span only appears in
- * a template literal that has two or more substitutions, and it is one piece of
- * that larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A middle span only appears in a template literal that has two or
+ * more substitutions, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the preceding substitution, the content,
  * then the `${` that opens the next one. With `text` of `mid`, this prints:
@@ -16,6 +19,7 @@ import type { TemplateMiddle } from "../../ast";
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-export declare const createTemplateMiddle: (text: string) => TemplateMiddle;
+export declare const createTemplateMiddle: (text: string, rawText?: string) => TemplateMiddle;

package/lib/factory/literals/createTemplateMiddle.js

@@ -6,9 +6,12 @@ const make_1 = require("../internal/make");
  * Create a {@link TemplateMiddle}: a span of a template expression that sits
  * between two substitutions, from one `}` to the next `${`.
  *
- * The `text` is the cooked content of that span. A middle span only appears in
- * a template literal that has two or more substitutions, and it is one piece of
- * that larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A middle span only appears in a template literal that has two or
+ * more substitutions, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the preceding substitution, the content,
  * then the `${` that opens the next one. With `text` of `mid`, this prints:
@@ -19,8 +22,9 @@ const make_1 = require("../internal/make");
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-const createTemplateMiddle = (text) => (0, make_1.make)("TemplateMiddle", { text });
+const createTemplateMiddle = (text, rawText) => (0, make_1.make)("TemplateMiddle", { text, rawText });
 exports.createTemplateMiddle = createTemplateMiddle;
 //# sourceMappingURL=createTemplateMiddle.js.map

package/lib/factory/literals/createTemplateMiddle.js.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateMiddle.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAAY,EAAkB,EAAE,CACnE,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;AADtB,QAAA,oBAAoB,GAApB,oBAAoB,CACE"}
+{"version":3,"file":"createTemplateMiddle.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,MAAM,oBAAoB,GAAG,CAClC,IAAY,EACZ,OAAgB,EACA,EAAE,CAAC,IAAA,WAAI,EAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAHlD,QAAA,oBAAoB,GAApB,oBAAoB,CAG8B"}

package/lib/factory/literals/createTemplateMiddle.mjs

@@ -4,9 +4,12 @@ import { make } from '../internal/make.mjs';
  * Create a {@link TemplateMiddle}: a span of a template expression that sits
  * between two substitutions, from one `}` to the next `${`.
  *
- * The `text` is the cooked content of that span. A middle span only appears in
- * a template literal that has two or more substitutions, and it is one piece of
- * that larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A middle span only appears in a template literal that has two or
+ * more substitutions, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the preceding substitution, the content,
  * then the `${` that opens the next one. With `text` of `mid`, this prints:
@@ -17,9 +20,10 @@ import { make } from '../internal/make.mjs';
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-const createTemplateMiddle = (text) => make("TemplateMiddle", { text });
+const createTemplateMiddle = (text, rawText) => make("TemplateMiddle", { text, rawText });
 
 export { createTemplateMiddle };
 //# sourceMappingURL=createTemplateMiddle.mjs.map

package/lib/factory/literals/createTemplateMiddle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateMiddle.mjs","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAAY,KAC/C,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createTemplateMiddle.mjs","sources":["../../../src/factory/literals/createTemplateMiddle.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;MACU,oBAAoB,GAAG,CAClC,IAAY,EACZ,OAAgB,KACG,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/literals/createTemplateTail.d.ts

@@ -3,9 +3,12 @@ import type { TemplateTail } from "../../ast";
  * Create a {@link TemplateTail}: the closing span of a template expression, from
  * the last `}` to the trailing backtick.
  *
- * The `text` is the cooked content of that span. A tail closes a template
- * literal that has at least one substitution, and it is one piece of that
- * larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A tail closes a template literal that has at least one
+ * substitution, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the final substitution, the content,
  * then the trailing backtick. With `text` of `tail`, this prints:
@@ -16,6 +19,7 @@ import type { TemplateTail } from "../../ast";
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-export declare const createTemplateTail: (text: string) => TemplateTail;
+export declare const createTemplateTail: (text: string, rawText?: string) => TemplateTail;

package/lib/factory/literals/createTemplateTail.js

@@ -6,9 +6,12 @@ const make_1 = require("../internal/make");
  * Create a {@link TemplateTail}: the closing span of a template expression, from
  * the last `}` to the trailing backtick.
  *
- * The `text` is the cooked content of that span. A tail closes a template
- * literal that has at least one substitution, and it is one piece of that
- * larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A tail closes a template literal that has at least one
+ * substitution, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the final substitution, the content,
  * then the trailing backtick. With `text` of `tail`, this prints:
@@ -19,8 +22,9 @@ const make_1 = require("../internal/make");
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-const createTemplateTail = (text) => (0, make_1.make)("TemplateTail", { text });
+const createTemplateTail = (text, rawText) => (0, make_1.make)("TemplateTail", { text, rawText });
 exports.createTemplateTail = createTemplateTail;
 //# sourceMappingURL=createTemplateTail.js.map

package/lib/factory/literals/createTemplateTail.js.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateTail.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateTail.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACI,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAgB,EAAE,CAC/D,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;AADpB,QAAA,kBAAkB,GAAlB,kBAAkB,CACE"}
+{"version":3,"file":"createTemplateTail.js","sourceRoot":"","sources":["../../../src/factory/literals/createTemplateTail.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,EACF,EAAE,CAAC,IAAA,WAAI,EAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AAH9C,QAAA,kBAAkB,GAAlB,kBAAkB,CAG4B"}

package/lib/factory/literals/createTemplateTail.mjs

@@ -4,9 +4,12 @@ import { make } from '../internal/make.mjs';
  * Create a {@link TemplateTail}: the closing span of a template expression, from
  * the last `}` to the trailing backtick.
  *
- * The `text` is the cooked content of that span. A tail closes a template
- * literal that has at least one substitution, and it is one piece of that
- * larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A tail closes a template literal that has at least one
+ * substitution, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the final substitution, the content,
  * then the trailing backtick. With `text` of `tail`, this prints:
@@ -17,9 +20,10 @@ import { make } from '../internal/make.mjs';
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-const createTemplateTail = (text) => make("TemplateTail", { text });
+const createTemplateTail = (text, rawText) => make("TemplateTail", { text, rawText });
 
 export { createTemplateTail };
 //# sourceMappingURL=createTemplateTail.mjs.map

package/lib/factory/literals/createTemplateTail.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createTemplateTail.mjs","sources":["../../../src/factory/literals/createTemplateTail.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,kBAAkB,GAAG,CAAC,IAAY,KAC7C,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createTemplateTail.mjs","sources":["../../../src/factory/literals/createTemplateTail.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;MACU,kBAAkB,GAAG,CAChC,IAAY,EACZ,OAAgB,KACC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/factory",
-  "version": "0.18.4",
+  "version": "0.19.1",
   "description": "Self-contained legacy-style TypeScript AST factory and printer for source code generation, surviving the TypeScript-Go (tsgo) migration. Zero dependencies, no `typescript` import.",
   "main": "lib/index.js",
   "exports": {

package/src/TsPrinter.ts

@@ -197,13 +197,31 @@ export class TsPrinter {
       : "";
   }
 
+  /**
+   * Whether a broken parameter list / binding pattern may append a synthetic
+   * trailing comma after its last element.
+   *
+   * A trailing comma after a rest element (`...rest`) is a syntax error (TS1013
+   * / V8 `SyntaxError`), and one after a trailing elision (`OmittedExpression`)
+   * is not cosmetic: `[a, ,]` parses to one more hole than `[a, ]`, so the flat
+   * and broken layouts of the same node would disagree. Call arguments and
+   * array / object literals are unaffected — a trailing comma after a spread is
+   * legal there.
+   */
+  private listTrailingComma(nodes: readonly Node[]): boolean {
+    const last: Node | undefined = nodes[nodes.length - 1];
+    if (last === undefined) return true;
+    if (last.kind === "OmittedExpression") return false;
+    return !("dotDotDotToken" in last && last.dotDotDotToken !== undefined);
+  }
+
   private params(params: readonly Node[]): Doc {
     return this.delim(
       "(",
       params.map((p) => this.emit(p)),
       ")",
       {
-        trailingComma: true,
+        trailingComma: this.listTrailingComma(params),
       },
     );
   }
@@ -1156,13 +1174,13 @@ export class TsPrinter {
 
       /* template literals */
       case "TemplateHead":
-        return concat(["`", node.text, "${"]);
+        return concat(["`", templateText(node), "${"]);
       case "TemplateMiddle":
-        return concat(["}", node.text, "${"]);
+        return concat(["}", templateText(node), "${"]);
       case "TemplateTail":
-        return concat(["}", node.text, "`"]);
+        return concat(["}", templateText(node), "`"]);
       case "NoSubstitutionTemplateLiteral":
-        return concat(["`", node.text, "`"]);
+        return concat(["`", templateText(node), "`"]);
 
       /* template & misc expressions */
       case "TemplateExpression":
@@ -1237,14 +1255,17 @@ export class TsPrinter {
           "{",
           node.elements.map((e) => this.emit(e)),
           "}",
-          { space: true, trailingComma: true },
+          {
+            space: true,
+            trailingComma: this.listTrailingComma(node.elements),
+          },
         );
       case "ArrayBindingPattern":
         return this.delim(
           "[",
           node.elements.map((e) => this.emit(e)),
           "]",
-          { trailingComma: true },
+          { trailingComma: this.listTrailingComma(node.elements) },
         );
       case "TypeAssertion":
         return concat([
@@ -1618,13 +1639,30 @@ export class TsPrinter {
   }
 
   private newExpressionTarget(expression: Expression): Doc {
-    return expression.kind !== "CallExpression" &&
-      expression.kind !== "CallChain" &&
-      (expression.kind !== "NewExpression" ||
-        expression.arguments !== undefined) &&
-      this.isLeftHandSideExpression(expression)
-      ? this.emit(expression)
-      : this.parenthesizedExpression(expression);
+    return this.newExpressionTargetNeedsParentheses(expression)
+      ? this.parenthesizedExpression(expression)
+      : this.emit(expression);
+  }
+
+  /**
+   * Whether a `new` target must be parenthesized to keep its call arguments
+   * from re-binding to the `new` — mirroring the legacy printer's
+   * `parenthesizeExpressionOfNew`. A `new` target is grammatically a
+   * `MemberExpression`, so a call anywhere on the target's left spine (not just
+   * a direct one: `new (f().bar)()`, `new (a.b().c)()`) would otherwise
+   * re-parse with the call's arguments consumed by the `new` — a different
+   * program. Argument-less `new` on the spine is kept parenthesized for
+   * continuity with the direct case, though this printer always prints an
+   * argument list, which already disambiguates it.
+   */
+  private newExpressionTargetNeedsParentheses(expression: Expression): boolean {
+    if (!this.isLeftHandSideExpression(expression)) return true;
+    const leftmost: Expression = this.leftmostExpression(expression, true);
+    return (
+      leftmost.kind === "CallExpression" ||
+      leftmost.kind === "CallChain" ||
+      (leftmost.kind === "NewExpression" && leftmost.arguments === undefined)
+    );
   }
 
   private prefixUnaryOperand(operand: Expression, operator?: SyntaxKind): Doc {
@@ -1724,12 +1762,6 @@ export class TsPrinter {
       this.binaryOperatorPrecedence(operator);
     const operandPrecedence: ExpressionPrecedence =
       this.expressionPrecedence(operand);
-    if (
-      !isLeftSide &&
-      operand.kind === "ArrowFunction" &&
-      operatorPrecedence > ExpressionPrecedence.Assignment
-    )
-      return true;
     if (operandPrecedence < operatorPrecedence) return true;
     if (operandPrecedence > operatorPrecedence) return false;
 
@@ -1755,6 +1787,8 @@ export class TsPrinter {
         return ExpressionPrecedence.Comma;
       case "YieldExpression":
         return ExpressionPrecedence.Yield;
+      case "ArrowFunction":
+        return ExpressionPrecedence.Assignment;
       case "ConditionalExpression":
         return ExpressionPrecedence.Conditional;
       case "BinaryExpression":
@@ -1802,6 +1836,7 @@ export class TsPrinter {
       case "AwaitExpression":
       case "ConditionalExpression":
       case "YieldExpression":
+      case "ArrowFunction":
         return Associativity.Right;
       case "BinaryExpression":
         return this.binaryOperatorAssociativity(expression.operator);
@@ -1977,11 +2012,22 @@ export class TsPrinter {
     );
   }
 
-  private leftmostExpression(expression: Expression): Expression {
+  /**
+   * Walk to the expression's leftmost node — the one that starts its printed
+   * text. With `stopAtCall`, calls terminate the walk instead of being walked
+   * through, matching the legacy `getLeftmostExpression`'s
+   * `stopAtCallExpressions` mode used by the `new`-target parenthesizer.
+   */
+  private leftmostExpression(
+    expression: Expression,
+    stopAtCall: boolean = false,
+  ): Expression {
     switch (expression.kind) {
-      case "AsExpression":
       case "CallExpression":
       case "CallChain":
+        if (stopAtCall) return expression;
+        return this.leftmostExpression(expression.expression, stopAtCall);
+      case "AsExpression":
       case "ElementAccessExpression":
       case "ElementAccessChain":
       case "NonNullExpression":
@@ -1989,13 +2035,13 @@ export class TsPrinter {
       case "PropertyAccessExpression":
       case "PropertyAccessChain":
       case "SatisfiesExpression":
-        return this.leftmostExpression(expression.expression);
+        return this.leftmostExpression(expression.expression, stopAtCall);
       case "BinaryExpression":
-        return this.leftmostExpression(expression.left);
+        return this.leftmostExpression(expression.left, stopAtCall);
       case "ConditionalExpression":
-        return this.leftmostExpression(expression.condition);
+        return this.leftmostExpression(expression.condition, stopAtCall);
       case "TaggedTemplateExpression":
-        return this.leftmostExpression(expression.tag);
+        return this.leftmostExpression(expression.tag, stopAtCall);
       default:
         return expression;
     }
@@ -2153,6 +2199,31 @@ export namespace TsPrinter {
   }
 }
 
+/**
+ * Source text of a template span: `rawText` verbatim when the author provided
+ * one (raw fidelity is theirs to own, mirroring the legacy TypeScript emitter),
+ * otherwise the cooked `text` escaped for template context.
+ */
+const templateText = (node: { text: string; rawText?: string }): string =>
+  typeof node.rawText === "string"
+    ? node.rawText
+    : escapeTemplateText(node.text);
+
+/**
+ * Escape cooked text so it re-parses to the same cooked value inside a template
+ * literal: backslashes, backticks, and `${` sequences (a `$` not followed by
+ * `{` stays literal). CR and CRLF are escaped because the scanner normalizes
+ * raw template line terminators to LF; a lone LF is legal template text and
+ * stays literal.
+ */
+const escapeTemplateText = (text: string): string =>
+  text
+    .replace(/\\/g, "\\\\")
+    .replace(/`/g, "\\`")
+    .replace(/\$\{/g, "\\${")
+    .replace(/\r\n/g, "\\r\\n")
+    .replace(/\r/g, "\\r");
+
 const escapeString = (text: string, singleQuote?: boolean): string => {
   const escaped: string = text
     .replace(/\\/g, "\\\\")

package/src/ast/expressions/NoSubstitutionTemplateLiteral.ts

@@ -11,4 +11,7 @@ export interface NoSubstitutionTemplateLiteral {
 
   /** Text. */
   text: string;
+
+  /** RawText. */
+  rawText?: string;
 }

package/src/ast/expressions/TemplateMiddle.ts

@@ -11,4 +11,7 @@ export interface TemplateMiddle {
 
   /** Text. */
   text: string;
+
+  /** RawText. */
+  rawText?: string;
 }

package/src/ast/expressions/TemplateTail.ts

@@ -11,4 +11,7 @@ export interface TemplateTail {
 
   /** Text. */
   text: string;
+
+  /** RawText. */
+  rawText?: string;
 }

package/src/factory/literals/createNoSubstitutionTemplateLiteral.ts

@@ -5,9 +5,11 @@ import { make } from "../internal/make";
  * Create a {@link NoSubstitutionTemplateLiteral}: a backtick template string
  * with no `${...}` substitutions.
  *
- * The `text` is the literal content between the backticks. Because there are no
- * placeholders, the whole literal is a single span and the printer wraps the
- * content in backticks unchanged.
+ * The `text` is the cooked content between the backticks. Because there are no
+ * placeholders, the whole literal is a single span. The optional `rawText`
+ * carries the source spelling before escape processing; the printer emits it
+ * verbatim when present, and otherwise escapes the cooked `text` so it
+ * re-parses to the same value.
  *
  * With `text` of `hello`, this prints:
  *
@@ -17,9 +19,11 @@ import { make } from "../internal/make";
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
 export const createNoSubstitutionTemplateLiteral = (
   text: string,
+  rawText?: string,
 ): NoSubstitutionTemplateLiteral =>
-  make("NoSubstitutionTemplateLiteral", { text });
+  make("NoSubstitutionTemplateLiteral", { text, rawText });

package/src/factory/literals/createTemplateHead.ts

@@ -6,9 +6,10 @@ import { make } from "../internal/make";
  * the leading backtick up to the first `${`.
  *
  * The `text` is the cooked content of that span. The optional `rawText` carries
- * the source spelling before escape processing; when omitted, the cooked text
- * is used. A head is not a complete expression on its own, it is one piece of a
- * larger template literal.
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A head is not a complete expression on its own, it is one piece
+ * of a larger template literal.
  *
  * The printer emits the opening backtick, the content, then the `${` that opens
  * the first substitution. With `text` of `head`, this prints:

package/src/factory/literals/createTemplateMiddle.ts

@@ -5,9 +5,12 @@ import { make } from "../internal/make";
  * Create a {@link TemplateMiddle}: a span of a template expression that sits
  * between two substitutions, from one `}` to the next `${`.
  *
- * The `text` is the cooked content of that span. A middle span only appears in
- * a template literal that has two or more substitutions, and it is one piece of
- * that larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A middle span only appears in a template literal that has two or
+ * more substitutions, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the preceding substitution, the content,
  * then the `${` that opens the next one. With `text` of `mid`, this prints:
@@ -18,7 +21,10 @@ import { make } from "../internal/make";
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-export const createTemplateMiddle = (text: string): TemplateMiddle =>
-  make("TemplateMiddle", { text });
+export const createTemplateMiddle = (
+  text: string,
+  rawText?: string,
+): TemplateMiddle => make("TemplateMiddle", { text, rawText });

package/src/factory/literals/createTemplateTail.ts

@@ -5,9 +5,12 @@ import { make } from "../internal/make";
  * Create a {@link TemplateTail}: the closing span of a template expression, from
  * the last `}` to the trailing backtick.
  *
- * The `text` is the cooked content of that span. A tail closes a template
- * literal that has at least one substitution, and it is one piece of that
- * larger literal rather than a complete expression.
+ * The `text` is the cooked content of that span. The optional `rawText` carries
+ * the source spelling before escape processing; the printer emits it verbatim
+ * when present, and otherwise escapes the cooked `text` so it re-parses to the
+ * same value. A tail closes a template literal that has at least one
+ * substitution, and it is one piece of that larger literal rather than a
+ * complete expression.
  *
  * The printer emits the closing `}` of the final substitution, the content,
  * then the trailing backtick. With `text` of `tail`, this prints:
@@ -18,7 +21,10 @@ import { make } from "../internal/make";
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @param text The text.
+ * @param rawText The rawText.
  * @returns The created node.
  */
-export const createTemplateTail = (text: string): TemplateTail =>
-  make("TemplateTail", { text });
+export const createTemplateTail = (
+  text: string,
+  rawText?: string,
+): TemplateTail => make("TemplateTail", { text, rawText });