@graffiticode/parser 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/parse.js

@@ -174,6 +174,49 @@ export const parse = (function () {
   const TK_STRSUFFIX = 0xB4;
   const TK_DOTDOT = 0xB5;
 
+  // Process escape sequences in a string lexeme
+  function processEscapeSequences(str) {
+    // The string still has backslash escape sequences
+    // Process them to get the actual string value
+    let result = "";
+    let i = 0;
+    while (i < str.length) {
+      if (str[i] === '\\' && i + 1 < str.length) {
+        // Handle escape sequence
+        const nextChar = str[i + 1];
+        switch (nextChar) {
+          case '\\':
+          case '"':
+          case "'":
+          case '`':
+            result += nextChar;
+            break;
+          case 'n':
+            result += '\n';
+            break;
+          case 't':
+            result += '\t';
+            break;
+          case 'r':
+            result += '\r';
+            break;
+          case '$':
+            result += '$';
+            break;
+          default:
+            // Unknown escape, keep the backslash and character
+            result += '\\' + nextChar;
+            break;
+        }
+        i += 2;
+      } else {
+        result += str[i];
+        i++;
+      }
+    }
+    return result;
+  }
+
   function tokenToLexeme(tk) {
     switch (tk) {
       case TK_EQUAL: return "a '=' symbol";
@@ -300,20 +343,24 @@ export const parse = (function () {
   function str(ctx, cc) {
     if (match(ctx, TK_STR)) {
       eat(ctx, TK_STR);
-      Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
+      // Process escape sequences in the lexeme
+      const processedStr = processEscapeSequences(lexeme);
+      Ast.string(ctx, processedStr, getCoord(ctx)); // strip quotes;
       cc.cls = "string";
       return cc;
     } else if (match(ctx, TK_STRPREFIX)) {
       ctx.state.inStr++;
       eat(ctx, TK_STRPREFIX);
       startCounter(ctx);
-      Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
+      const processedPrefix = processEscapeSequences(lexeme);
+      Ast.string(ctx, processedPrefix, getCoord(ctx)); // strip quotes;
       countCounter(ctx);
       const ret = function (ctx) {
         return strSuffix(ctx, function (ctx) {
           ctx.state.inStr--;
           eat(ctx, TK_STRSUFFIX);
-          Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
+          const processedSuffix = processEscapeSequences(lexeme);
+          Ast.string(ctx, processedSuffix, getCoord(ctx)); // strip quotes;
           countCounter(ctx);
           Ast.list(ctx, ctx.state.exprc);
           stopCounter(ctx);
@@ -337,7 +384,8 @@ export const parse = (function () {
       if (match(ctx, TK_STRMIDDLE)) {
         // Not done yet.
         eat(ctx, TK_STRMIDDLE);
-        Ast.string(ctx, lexeme, getCoord(ctx)); // strip quotes;
+        const processedMiddle = processEscapeSequences(lexeme);
+        Ast.string(ctx, processedMiddle, getCoord(ctx)); // strip quotes;
         countCounter(ctx);
         ret = function (ctx) {
           return strSuffix(ctx, resume);
@@ -1199,24 +1247,44 @@ export const parse = (function () {
       lexeme += String.fromCharCode(c);
       c = nextCC();
       const inTemplateLiteral = quoteChar === CC_BACKTICK;
+      let escaped = false;
+
       if (inTemplateLiteral) {
         while (
-          c !== quoteChar &&
+          (c !== quoteChar || escaped) &&
           c !== 0 &&
-          !(c === CC_DOLLAR && peekCC() === CC_LEFTBRACE)) {
-          lexeme += String.fromCharCode(c);
+          !(c === CC_DOLLAR && peekCC() === CC_LEFTBRACE && !escaped)) {
+          if (escaped) {
+            // Handle escaped characters
+            lexeme += String.fromCharCode(c);
+            escaped = false;
+          } else if (c === 92) { // backslash
+            lexeme += String.fromCharCode(c);
+            escaped = true;
+          } else {
+            lexeme += String.fromCharCode(c);
+          }
           c = nextCC();
         }
       } else {
-        while (c !== quoteChar && c !== 0) {
-          lexeme += String.fromCharCode(c);
+        while ((c !== quoteChar || escaped) && c !== 0) {
+          if (escaped) {
+            // Handle escaped characters
+            lexeme += String.fromCharCode(c);
+            escaped = false;
+          } else if (c === 92) { // backslash
+            lexeme += String.fromCharCode(c);
+            escaped = true;
+          } else {
+            lexeme += String.fromCharCode(c);
+          }
           c = nextCC();
         }
       }
       const coord = { from: getPos(ctx) - lexeme.length, to: getPos(ctx) };
       assertErr(ctx, c !== 0, `Unterminated string: ${lexeme}`, coord);
       if (quoteChar === CC_BACKTICK && c === CC_DOLLAR &&
-          peekCC() === CC_LEFTBRACE) {
+          peekCC() === CC_LEFTBRACE && !escaped) {
         nextCC(); // Eat CC_LEFTBRACE
         lexeme = lexeme.substring(1); // Strip off punct.
         return TK_STRPREFIX;
@@ -1234,21 +1302,41 @@ export const parse = (function () {
       const quoteChar = quoteCharStack[quoteCharStack.length - 1];
       c = nextCC();
       const inTemplateLiteral = quoteChar === CC_BACKTICK;
+      let escaped = false;
+
       if (inTemplateLiteral) {
-        while (c !== quoteChar && c !== 0 &&
+        while ((c !== quoteChar || escaped) && c !== 0 &&
              !(c === CC_DOLLAR &&
-               peekCC() === CC_LEFTBRACE)) {
-          lexeme += String.fromCharCode(c);
+               peekCC() === CC_LEFTBRACE && !escaped)) {
+          if (escaped) {
+            // Handle escaped characters
+            lexeme += String.fromCharCode(c);
+            escaped = false;
+          } else if (c === 92) { // backslash
+            lexeme += String.fromCharCode(c);
+            escaped = true;
+          } else {
+            lexeme += String.fromCharCode(c);
+          }
           c = nextCC();
         }
       } else {
-        while (c !== quoteChar && c !== 0) {
-          lexeme += String.fromCharCode(c);
+        while ((c !== quoteChar || escaped) && c !== 0) {
+          if (escaped) {
+            // Handle escaped characters
+            lexeme += String.fromCharCode(c);
+            escaped = false;
+          } else if (c === 92) { // backslash
+            lexeme += String.fromCharCode(c);
+            escaped = true;
+          } else {
+            lexeme += String.fromCharCode(c);
+          }
           c = nextCC();
         }
       }
       if (quoteChar === CC_BACKTICK && c === CC_DOLLAR &&
-          peekCC() === CC_LEFTBRACE) {
+          peekCC() === CC_LEFTBRACE && !escaped) {
         nextCC(); // Eat brace.
         lexeme = lexeme.substring(1); // Strip off leading brace and trailing brace.
         return TK_STRMIDDLE;

package/src/parser.spec.js

@@ -425,4 +425,149 @@ describe("parser integration tests", () => {
     expect(found123).toBe(false);
     expect(found456).toBe(false);
   });
+
+  // Tests for escaped quotes
+  it("should parse strings with escaped double quotes", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, '"He said \\"Hello\\""..', basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === 'He said "Hello"') {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe('He said "Hello"');
+  });
+
+  it("should parse strings with escaped single quotes", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, "'It\\'s working!'..", basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === "It's working!") {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe("It's working!");
+  });
+
+  it("should parse strings with escaped backticks", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, "`This has a \\` backtick`..", basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === "This has a ` backtick") {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe("This has a ` backtick");
+  });
+
+  it("should parse strings with escaped backslashes", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, '"Path: C:\\\\Users\\\\Test"..', basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === "Path: C:\\Users\\Test") {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe("Path: C:\\Users\\Test");
+  });
+
+  it("should parse template literals with escaped interpolation", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, "`Price: \\${amount}`..", basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === "Price: ${amount}") {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe("Price: ${amount}");
+  });
+
+  it("should parse strings with mixed escape sequences", async () => {
+    // Arrange & Act
+    const result = await parser.parse(0, '"Line 1\\nTab\\t\\"Quote\\""..', basisLexicon);
+
+    // Assert
+    expect(result).toHaveProperty("root");
+
+    // Find the STR node
+    let strNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "STR" && node.elts[0] === 'Line 1\nTab\t"Quote"') {
+          strNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(strNode).not.toBeNull();
+    expect(strNode.tag).toBe("STR");
+    expect(strNode.elts[0]).toBe('Line 1\nTab\t"Quote"');
+  });
 });

package/src/unparse-l0166.spec.js

@@ -117,6 +117,13 @@ describe("unparse with L0166 lexicon", () => {
       "length": 2,
       "arity": 2,
     },
+    "row": {
+      "tk": 1,
+      "name": "ROW",
+      "cls": "function",
+      "length": 2,
+      "arity": 2,
+    },
     "column": {
       "tk": 1,
       "name": "COLUMN",

package/src/unparse.js

@@ -28,272 +28,273 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
 
   // Handle AST nodes
   switch (node.tag) {
-    case "PROG":
-      // Program is a list of expressions ending with ".."
-      if (node.elts && node.elts.length > 0) {
-        const exprs = unparseNode(node.elts[0], lexicon, indent, opts);
-        return exprs + "..";
-      }
-      return "..";
+  case "PROG":
+    // Program is a list of expressions ending with ".."
+    if (node.elts && node.elts.length > 0) {
+      const exprs = unparseNode(node.elts[0], lexicon, indent, opts);
+      return exprs + "..";
+    }
+    return "..";
 
-    case "EXPRS":
-      // Multiple expressions
-      if (!node.elts || node.elts.length === 0) {
-        return "";
-      }
-      // Check if this looks like a function application that wasn't folded
-      // e.g., sub followed by arguments as separate expressions
-      if (node.elts.length >= 3) {
-        const first = node.elts[0];
-        // Check if first element is an identifier that could be a function
-        if (first && first.tag && first.elts && first.elts.length === 0) {
-          // This might be a function name followed by arguments
-          const funcName = first.tag;
-          // Check if this matches a lexicon function
-          if (lexicon && lexicon[funcName]) {
-            const arity = lexicon[funcName].arity || 0;
-            if (arity > 0 && node.elts.length === arity + 1) {
-              // Treat this as a function application
-              const args = node.elts.slice(1).map(elt => unparseNode(elt, lexicon, indent, opts)).join(" ");
-              return `${funcName} ${args}`;
-            }
+  case "EXPRS":
+    // Multiple expressions
+    if (!node.elts || node.elts.length === 0) {
+      return "";
+    }
+    // Check if this looks like a function application that wasn't folded
+    // e.g., sub followed by arguments as separate expressions
+    if (node.elts.length >= 3) {
+      const first = node.elts[0];
+      // Check if first element is an identifier that could be a function
+      if (first && first.tag && first.elts && first.elts.length === 0) {
+        // This might be a function name followed by arguments
+        const funcName = first.tag;
+        // Check if this matches a lexicon function
+        if (lexicon && lexicon[funcName]) {
+          const arity = lexicon[funcName].arity || 0;
+          if (arity > 0 && node.elts.length === arity + 1) {
+            // Treat this as a function application
+            const args = node.elts.slice(1).map(elt => unparseNode(elt, lexicon, indent, opts)).join(" ");
+            return `${funcName} ${args}`;
           }
         }
       }
+    }
 
-      // For single expression, return as is
-      if (node.elts.length === 1) {
-        return unparseNode(node.elts[0], lexicon, indent, opts);
-      }
+    // For single expression, return as is
+    if (node.elts.length === 1) {
+      return unparseNode(node.elts[0], lexicon, indent, opts);
+    }
 
-      // For multiple expressions, put each on its own line
-      return node.elts.map(elt => unparseNode(elt, lexicon, indent, opts)).join("\n");
+    // For multiple expressions, put each on its own line
+    return node.elts.map(elt => unparseNode(elt, lexicon, indent, opts)).join("\n");
 
-    case "NUM":
-      return node.elts[0];
+  case "NUM":
+    return node.elts[0];
 
-    case "STR": {
-      // Escape quotes and backslashes in the string
-      const str = node.elts[0];
-      const escaped = str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-      return `'${escaped}'`;
-    }
+  case "STR": {
+    // Escape quotes and backslashes in the string
+    const str = node.elts[0];
+    const escaped = str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `"${escaped}"`;
+  }
 
-    case "BOOL":
-      return node.elts[0] ? "true" : "false";
+  case "BOOL":
+    return node.elts[0] ? "true" : "false";
 
-    case "NULL":
-      return "null";
+  case "NULL":
+    return "null";
 
-    case "IDENT":
-      return node.elts[0];
+  case "IDENT":
+    return node.elts[0];
 
-    case "LIST": {
-      // Array literal [a, b, c]
-      if (!node.elts || node.elts.length === 0) {
-        return "[]";
-      }
+  case "LIST": {
+    console.log("LIST");
+    // Array literal [a, b, c]
+    if (!node.elts || node.elts.length === 0) {
+      return "[]";
+    }
 
-      if (opts.compact) {
-        // Compact mode: inline list
-        const items = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts));
-        return "[" + items.join(", ") + "]";
-      } else {
-        // Pretty print with each element on a new line
-        const innerIndent = indent + opts.indentSize;
-        const indentStr = " ".repeat(innerIndent);
-        const items = node.elts.map(elt =>
-          indentStr + unparseNode(elt, lexicon, innerIndent, opts)
-        );
-        return "[\n" + items.join("\n") + "\n" + " ".repeat(indent) + "]";
-      }
+    if (opts.compact) {
+      // Compact mode: inline list
+      const items = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts));
+      return "[" + items.join(", ") + "]";
+    } else {
+      // Pretty print with each element on a new line
+      const innerIndent = indent + opts.indentSize;
+      const indentStr = " ".repeat(innerIndent);
+      const items = node.elts.map(elt =>
+        indentStr + unparseNode(elt, lexicon, innerIndent, opts)
+      );
+      return "[\n" + items.join("\n") + "\n" + " ".repeat(indent) + "]";
     }
+  }
 
-    case "RECORD": {
-      // Object literal {a: 1, b: 2}
-      if (!node.elts || node.elts.length === 0) {
-        return "{}";
-      }
+  case "RECORD": {
+    // Object literal {a: 1, b: 2}
+    if (!node.elts || node.elts.length === 0) {
+      return "{}";
+    }
 
-      if (opts.compact) {
-        // Compact mode: inline record
-        const bindings = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts));
-        return "{" + bindings.join(", ") + "}";
-      } else {
-        // Pretty print with each binding on a new line
-        const innerIndent = indent + opts.indentSize;
-        const indentStr = " ".repeat(innerIndent);
-        const bindings = node.elts.map(elt =>
-          indentStr + unparseNode(elt, lexicon, innerIndent, opts)
-        );
-        return "{\n" + bindings.join("\n") + "\n" + " ".repeat(indent) + "}";
-      }
+    if (opts.compact) {
+      // Compact mode: inline record
+      const bindings = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts));
+      return "{" + bindings.join(", ") + "}";
+    } else {
+      // Pretty print with each binding on a new line
+      const innerIndent = indent + opts.indentSize;
+      const indentStr = " ".repeat(innerIndent);
+      const bindings = node.elts.map(elt =>
+        indentStr + unparseNode(elt, lexicon, innerIndent, opts)
+      );
+      return "{\n" + bindings.join("\n") + "\n" + " ".repeat(indent) + "}";
     }
+  }
 
-    case "BINDING": {
-      // Key-value pair in a record
-      if (node.elts && node.elts.length >= 2) {
-        // If the key is a string node, unparse it without quotes for object keys
-        let key;
-        if (node.elts[0] && node.elts[0].tag === "STR") {
-          key = node.elts[0].elts[0]; // Get the raw string without quotes
-        } else {
-          key = unparseNode(node.elts[0], lexicon, indent);
-        }
-        const value = unparseNode(node.elts[1], lexicon, indent, opts);
-        return `${key}: ${value}`;
+  case "BINDING": {
+    // Key-value pair in a record
+    if (node.elts && node.elts.length >= 2) {
+      // If the key is a string node, unparse it without quotes for object keys
+      let key;
+      if (node.elts[0] && node.elts[0].tag === "STR") {
+        key = node.elts[0].elts[0]; // Get the raw string without quotes
+      } else {
+        key = unparseNode(node.elts[0], lexicon, indent);
       }
-      return "";
+      const value = unparseNode(node.elts[1], lexicon, indent, opts);
+      return `${key}: ${value}`;
     }
+    return "";
+  }
 
-    case "PAREN":
-      // Parenthesized expression
-      if (node.elts && node.elts.length > 0) {
-        return "(" + unparseNode(node.elts[0], lexicon, indent, opts) + ")";
-      }
-      return "()";
-
-    case "APPLY":
-      // Function application
-      if (node.elts && node.elts.length >= 2) {
-        const func = unparseNode(node.elts[0], lexicon, indent, opts);
-        const args = unparseNode(node.elts[1], lexicon, indent, opts);
-        return func + " " + args;
-      }
-      return "";
+  case "PAREN":
+    // Parenthesized expression
+    if (node.elts && node.elts.length > 0) {
+      return "(" + unparseNode(node.elts[0], lexicon, indent, opts) + ")";
+    }
+    return "()";
+
+  case "APPLY":
+    // Function application
+    if (node.elts && node.elts.length >= 2) {
+      const func = unparseNode(node.elts[0], lexicon, indent, opts);
+      const args = unparseNode(node.elts[1], lexicon, indent, opts);
+      return func + " " + args;
+    }
+    return "";
 
-    case "LAMBDA":
-      // Lambda function
-      if (node.elts && node.elts.length >= 3) {
-        const params = node.elts[1];
-        const body = node.elts[2];
+  case "LAMBDA":
+    // Lambda function
+    if (node.elts && node.elts.length >= 3) {
+      const params = node.elts[1];
+      const body = node.elts[2];
 
-        // Extract parameter names
-        let paramStr = "";
-        if (params && params.elts) {
-          paramStr = params.elts.map(p => unparseNode(p, lexicon, indent, opts)).join(" ");
-        }
+      // Extract parameter names
+      let paramStr = "";
+      if (params && params.elts) {
+        paramStr = params.elts.map(p => unparseNode(p, lexicon, indent, opts)).join(" ");
+      }
 
-        // Unparse body
-        const bodyStr = unparseNode(body, lexicon, indent, opts);
+      // Unparse body
+      const bodyStr = unparseNode(body, lexicon, indent, opts);
 
-        if (paramStr) {
-          return `\\${paramStr} . ${bodyStr}`;
-        } else {
-          return `\\. ${bodyStr}`;
-        }
+      if (paramStr) {
+        return `\\${paramStr} . ${bodyStr}`;
+      } else {
+        return `\\. ${bodyStr}`;
       }
-      return "";
-
-    case "LET":
-      // Let binding
-      if (node.elts && node.elts.length >= 2) {
-        const bindings = node.elts[0];
-        const body = node.elts[1];
-
-        let bindingStr = "";
-        if (bindings && bindings.elts) {
-          bindingStr = bindings.elts.map(b => {
-            if (b.elts && b.elts.length >= 2) {
-              const name = unparseNode(b.elts[0], lexicon, indent, opts);
-              const value = unparseNode(b.elts[1], lexicon, indent, opts);
-              return `${name} = ${value}`;
-            }
-            return "";
-          }).filter(s => s).join(", ");
-        }
+    }
+    return "";
 
-        const bodyStr = unparseNode(body, lexicon, indent, opts);
-        return `let ${bindingStr} in ${bodyStr}`;
+  case "LET":
+    // Let binding
+    if (node.elts && node.elts.length >= 2) {
+      const bindings = node.elts[0];
+      const body = node.elts[1];
+
+      let bindingStr = "";
+      if (bindings && bindings.elts) {
+        bindingStr = bindings.elts.map(b => {
+          if (b.elts && b.elts.length >= 2) {
+            const name = unparseNode(b.elts[0], lexicon, indent, opts);
+            const value = unparseNode(b.elts[1], lexicon, indent, opts);
+            return `${name} = ${value}`;
+          }
+          return "";
+        }).filter(s => s).join(", ");
       }
-      return "";
 
-    case "IF":
-      // If-then-else
-      if (node.elts && node.elts.length >= 2) {
-        const cond = unparseNode(node.elts[0], lexicon, indent, opts);
-        const thenExpr = unparseNode(node.elts[1], lexicon, indent, opts);
+      const bodyStr = unparseNode(body, lexicon, indent, opts);
+      return `let ${bindingStr} in ${bodyStr}`;
+    }
+    return "";
 
-        if (node.elts.length >= 3) {
-          const elseExpr = unparseNode(node.elts[2], lexicon, indent, opts);
-          return `if ${cond} then ${thenExpr} else ${elseExpr}`;
-        } else {
-          return `if ${cond} then ${thenExpr}`;
-        }
-      }
-      return "";
+  case "IF":
+    // If-then-else
+    if (node.elts && node.elts.length >= 2) {
+      const cond = unparseNode(node.elts[0], lexicon, indent, opts);
+      const thenExpr = unparseNode(node.elts[1], lexicon, indent, opts);
 
-    case "CASE":
-      // Case expression
-      if (node.elts && node.elts.length > 0) {
-        const expr = unparseNode(node.elts[0], lexicon, indent, opts);
-        const cases = node.elts.slice(1).map(c => unparseNode(c, lexicon, indent, opts));
-        return `case ${expr} of ${cases.join(" | ")}`;
+      if (node.elts.length >= 3) {
+        const elseExpr = unparseNode(node.elts[2], lexicon, indent, opts);
+        return `if ${cond} then ${thenExpr} else ${elseExpr}`;
+      } else {
+        return `if ${cond} then ${thenExpr}`;
       }
-      return "";
+    }
+    return "";
 
-    case "OF":
-      // Case branch
-      if (node.elts && node.elts.length >= 2) {
-        const pattern = unparseNode(node.elts[0], lexicon, indent, opts);
-        const expr = unparseNode(node.elts[1], lexicon, indent, opts);
-        return `${pattern} => ${expr}`;
-      }
-      return "";
+  case "CASE":
+    // Case expression
+    if (node.elts && node.elts.length > 0) {
+      const expr = unparseNode(node.elts[0], lexicon, indent, opts);
+      const cases = node.elts.slice(1).map(c => unparseNode(c, lexicon, indent, opts));
+      return `case ${expr} of ${cases.join(" | ")}`;
+    }
+    return "";
+
+  case "OF":
+    // Case branch
+    if (node.elts && node.elts.length >= 2) {
+      const pattern = unparseNode(node.elts[0], lexicon, indent, opts);
+      const expr = unparseNode(node.elts[1], lexicon, indent, opts);
+      return `${pattern} => ${expr}`;
+    }
+    return "";
 
     // Unary operator - negative
-    case "NEG":
-      if (node.elts && node.elts.length >= 1) {
-        const expr = unparseNode(node.elts[0], lexicon, indent, opts);
-        return `-${expr}`;
-      }
-      return "";
+  case "NEG":
+    if (node.elts && node.elts.length >= 1) {
+      const expr = unparseNode(node.elts[0], lexicon, indent, opts);
+      return `-${expr}`;
+    }
+    return "";
 
-    case "ERROR":
-      // Error nodes - include as comments
-      if (node.elts && node.elts.length > 0) {
-        // The first element might be a node reference or a string
-        const firstElt = node.elts[0];
-        if (typeof firstElt === "object" && firstElt.elts) {
-          // It's a node, unparse it
-          return `/* ERROR: ${unparseNode(firstElt, lexicon, indent, opts)} */`;
-        }
-        return `/* ERROR: ${firstElt} */`;
+  case "ERROR":
+    // Error nodes - include as comments
+    if (node.elts && node.elts.length > 0) {
+      // The first element might be a node reference or a string
+      const firstElt = node.elts[0];
+      if (typeof firstElt === "object" && firstElt.elts) {
+        // It's a node, unparse it
+        return `/* ERROR: ${unparseNode(firstElt, lexicon, indent, opts)} */`;
       }
-      return "/* ERROR */";
-
-    default: {
-      // Check if this is a lexicon-defined function
-      // First, find the source name for this tag in the lexicon
-      let sourceName = null;
-      if (lexicon) {
-        for (const [key, value] of Object.entries(lexicon)) {
-          if (value && value.name === node.tag) {
-            sourceName = key;
-            break;
-          }
-        }
-      }
-
-      if (sourceName) {
-        // This is a known lexicon function - unparse in prefix notation
-        if (node.elts && node.elts.length > 0) {
-          const args = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts)).join(" ");
-          return `${sourceName} ${args}`;
+      return `/* ERROR: ${firstElt} */`;
+    }
+    return "/* ERROR */";
+
+  default: {
+    // Check if this is a lexicon-defined function
+    // First, find the source name for this tag in the lexicon
+    let sourceName = null;
+    if (lexicon) {
+      for (const [key, value] of Object.entries(lexicon)) {
+        if (value && value.name === node.tag) {
+          sourceName = key;
+          break;
         }
-        return sourceName;
       }
+    }
 
-      // Handle identifiers that aren't in the lexicon (like lowercase "sub")
-      if (node.elts && node.elts.length === 0) {
-        // This is likely an identifier
-        return node.tag;
+    if (sourceName) {
+      // This is a known lexicon function - unparse in prefix notation
+      if (node.elts && node.elts.length > 0) {
+        const args = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts)).join(" ");
+        return `${sourceName} ${args}`;
       }
+      return sourceName;
+    }
 
-      // Fallback for unknown nodes
-      console.warn(`Unknown node tag: ${node.tag}`);
-      return `/* ${node.tag} */`;
+    // Handle identifiers that aren't in the lexicon (like lowercase "sub")
+    if (node.elts && node.elts.length === 0) {
+      // This is likely an identifier
+      return node.tag;
     }
+
+    // Fallback for unknown nodes
+    console.warn(`Unknown node tag: ${node.tag}`);
+    return `/* ${node.tag} */`;
+  }
   }
 }
 
@@ -343,34 +344,34 @@ function reconstructNode(pool, nodeId) {
 
   // Handle different node types
   switch (node.tag) {
-    case "NUM":
-    case "STR":
-    case "IDENT":
-    case "BOOL":
-      // These nodes have primitive values in elts[0]
-      result.elts = [node.elts[0]];
-      break;
-
-    case "NULL":
-      // NULL nodes have no elements
-      result.elts = [];
-      break;
-
-    default:
-      // For all other nodes, recursively reconstruct child nodes
-      if (node.elts && Array.isArray(node.elts)) {
-        result.elts = node.elts.map(eltId => {
-          // Check if this is a node ID (number or string number)
-          if (typeof eltId === "number" || (typeof eltId === "string" && /^\d+$/.test(eltId))) {
-            // This is a reference to another node in the pool
-            return reconstructNode(pool, eltId);
-          } else {
-            // This is a primitive value
-            return eltId;
-          }
-        });
-      }
-      break;
+  case "NUM":
+  case "STR":
+  case "IDENT":
+  case "BOOL":
+    // These nodes have primitive values in elts[0]
+    result.elts = [node.elts[0]];
+    break;
+
+  case "NULL":
+    // NULL nodes have no elements
+    result.elts = [];
+    break;
+
+  default:
+    // For all other nodes, recursively reconstruct child nodes
+    if (node.elts && Array.isArray(node.elts)) {
+      result.elts = node.elts.map(eltId => {
+        // Check if this is a node ID (number or string number)
+        if (typeof eltId === "number" || (typeof eltId === "string" && /^\d+$/.test(eltId))) {
+          // This is a reference to another node in the pool
+          return reconstructNode(pool, eltId);
+        } else {
+          // This is a primitive value
+          return eltId;
+        }
+      });
+    }
+    break;
   }
 
   return result;