@weborigami/language 0.2.2 → 0.2.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Miksovsky and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/main.js

@@ -13,5 +13,6 @@ export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctio
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
 export * as symbols from "./src/runtime/symbols.js";
 export { default as taggedTemplate } from "./src/runtime/taggedTemplate.js";
+export { default as taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@weborigami/language",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.7.4",
-    "peggy": "4.0.3",
-    "typescript": "5.6.2",
-    "yaml": "2.5.1"
+    "@types/node": "22.10.2",
+    "peggy": "4.2.0.",
+    "typescript": "5.7.2",
+    "yaml": "2.6.1"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.2",
-    "@weborigami/types": "0.2.2",
+    "@weborigami/async-tree": "0.2.3",
+    "@weborigami/types": "0.2.3",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -5,7 +5,7 @@ import { parse } from "./parse.js";
 import { annotate, undetermined } from "./parserHelpers.js";
 
 function compile(source, options) {
-  const { startRule } = options;
+  const { macros, startRule } = options;
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
@@ -15,7 +15,7 @@ function compile(source, options) {
     startRule,
   });
   const cache = {};
-  const modified = transformScopeReferences(code, cache, enableCaching);
+  const modified = transformReferences(code, cache, enableCaching, macros);
   const fn = createExpressionFunction(modified);
   return fn;
 }
@@ -27,14 +27,34 @@ export function expression(source, options = {}) {
   });
 }
 
-// Transform any remaining undetermined references to scope references. At the
-// same time, transform those or explicit ops.scope calls to ops.external calls
-// unless they refer to local variables (variables defined by object literals or
-// lambda parameters).
-export function transformScopeReferences(
+export function program(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "program",
+  });
+}
+
+export function templateDocument(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "templateDocument",
+  });
+}
+
+/**
+ * Transform any remaining undetermined references to scope references.
+ *
+ * At the same time, transform those or explicit ops.scope calls to ops.external
+ * calls unless they refer to local variables (variables defined by object
+ * literals or lambda parameters).
+ *
+ * Also apply any macros to the code.
+ */
+export function transformReferences(
   code,
   cache,
   enableCaching,
+  macros,
   locals = {}
 ) {
   const [fn, ...args] = code;
@@ -45,7 +65,20 @@ export function transformScopeReferences(
     case ops.scope:
       const key = args[0];
       const normalizedKey = trailingSlash.remove(key);
-      if (enableCaching && !locals[normalizedKey]) {
+      if (macros?.[normalizedKey]) {
+        // Apply macro
+        const macroBody = macros[normalizedKey];
+        const modified = transformReferences(
+          macroBody,
+          cache,
+          enableCaching,
+          macros,
+          locals
+        );
+        // @ts-ignore
+        annotate(modified, code.location);
+        return modified;
+      } else if (enableCaching && !locals[normalizedKey]) {
         // Upgrade to cached external reference
         const modified = [ops.external, key, cache];
         // @ts-ignore
@@ -87,10 +120,11 @@ export function transformScopeReferences(
       // be preferable to only descend into instructions. This would require
       // surrounding ops.lambda parameters with ops.literal, and ops.object
       // entries with ops.array.
-      return transformScopeReferences(
+      return transformReferences(
         child,
         cache,
         enableCaching,
+        macros,
         updatedLocals
       );
     } else {
@@ -103,17 +137,3 @@ export function transformScopeReferences(
   }
   return modified;
 }
-
-export function program(source, options = {}) {
-  return compile(source, {
-    ...options,
-    startRule: "program",
-  });
-}
-
-export function templateDocument(source, options = {}) {
-  return compile(source, {
-    ...options,
-    startRule: "templateDocument",
-  });
-}

package/src/compiler/origami.pegjs

@@ -571,20 +571,17 @@ stringLiteral "string"
 // A top-level document defining a template. This is the same as a template
 // literal, but can contain backticks at the top level.
 templateDocument "template"
-  = contents:templateDocumentContents {
-      return annotate([ops.lambda, ["_"], contents], location());
+  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
+      return annotate(
+        [ops.lambda, ["_"], makeTemplate(ops.templateIndent, head, tail)],
+        location()
+      );
     }
 
 // Template documents can contain backticks at the top level.
 templateDocumentChar
   = !("${") @textChar
 
-// The contents of a template document containing plain text and substitutions
-templateDocumentContents
-  = head:templateDocumentText tail:(templateSubstitution templateDocumentText)* {
-      return annotate(makeTemplate(ops.template, head, tail), location());
-    }
-
 templateDocumentText "template text"
   = chars:templateDocumentChar* {
       return chars.join("");
@@ -592,17 +589,13 @@ templateDocumentText "template text"
 
 // A backtick-quoted template literal
 templateLiteral "template literal"
-  = "`" contents:templateLiteralContents "`" {
-      return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
+  = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* "`" {
+      return annotate(makeTemplate(ops.template, head, tail), location());
     }
 
 templateLiteralChar
   = !("`" / "${") @textChar
 
-// The contents of a template literal containing plain text and substitutions
-templateLiteralContents
-  = head:templateLiteralText tail:(templateSubstitution templateLiteralText)*
-
 // Plain text in a template literal
 templateLiteralText
   = chars:templateLiteralChar* {

package/src/compiler/parse.js

@@ -202,7 +202,7 @@ function peg$parse(input, options) {
   var peg$FAILED = {};
   var peg$source = options.grammarSource;
 
-  var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, bitwiseAndExpression: peg$parsebitwiseAndExpression, bitwiseAndOperator: peg$parsebitwiseAndOperator, bitwiseOrExpression: peg$parsebitwiseOrExpression, bitwiseOrOperator: peg$parsebitwiseOrOperator, bitwiseXorExpression: peg$parsebitwiseXorExpression, bitwiseXorOperator: peg$parsebitwiseXorOperator, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentContents: peg$parsetemplateDocumentContents, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralContents: peg$parsetemplateLiteralContents, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
+  var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, arguments: peg$parsearguments, arrayLiteral: peg$parsearrayLiteral, arrayEntries: peg$parsearrayEntries, arrayEntry: peg$parsearrayEntry, arrowFunction: peg$parsearrowFunction, bitwiseAndExpression: peg$parsebitwiseAndExpression, bitwiseAndOperator: peg$parsebitwiseAndOperator, bitwiseOrExpression: peg$parsebitwiseOrExpression, bitwiseOrOperator: peg$parsebitwiseOrOperator, bitwiseXorExpression: peg$parsebitwiseXorExpression, bitwiseXorOperator: peg$parsebitwiseXorOperator, callExpression: peg$parsecallExpression, closingBrace: peg$parseclosingBrace, closingBracket: peg$parseclosingBracket, closingParenthesis: peg$parseclosingParenthesis, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, conditionalExpression: peg$parseconditionalExpression, digits: peg$parsedigits, doubleArrow: peg$parsedoubleArrow, doubleQuoteString: peg$parsedoubleQuoteString, doubleQuoteStringChar: peg$parsedoubleQuoteStringChar, ellipsis: peg$parseellipsis, equalityExpression: peg$parseequalityExpression, equalityOperator: peg$parseequalityOperator, escapedChar: peg$parseescapedChar, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, homeDirectory: peg$parsehomeDirectory, host: peg$parsehost, identifier: peg$parseidentifier, identifierChar: peg$parseidentifierChar, identifierList: peg$parseidentifierList, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, list: peg$parselist, literal: peg$parseliteral, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, namespace: peg$parsenamespace, newLine: peg$parsenewLine, numericLiteral: peg$parsenumericLiteral, nullishCoalescingExpression: peg$parsenullishCoalescingExpression, objectLiteral: peg$parseobjectLiteral, objectEntries: peg$parseobjectEntries, objectEntry: peg$parseobjectEntry, objectGetter: peg$parseobjectGetter, objectHiddenKey: peg$parseobjectHiddenKey, objectKey: peg$parseobjectKey, objectProperty: peg$parseobjectProperty, objectShorthandProperty: peg$parseobjectShorthandProperty, objectPublicKey: peg$parseobjectPublicKey, parenthesesArguments: peg$parseparenthesesArguments, path: peg$parsepath, pathArguments: peg$parsepathArguments, pathKey: peg$parsepathKey, pathSegment: peg$parsepathSegment, pathSegmentChar: peg$parsepathSegmentChar, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, protocolExpression: peg$parseprotocolExpression, qualifiedReference: peg$parsequalifiedReference, reference: peg$parsereference, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, rootDirectory: peg$parserootDirectory, scopeReference: peg$parsescopeReference, separator: peg$parseseparator, slashFollows: peg$parseslashFollows, shebang: peg$parseshebang, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateDocument: peg$parsetemplateDocument, templateDocumentChar: peg$parsetemplateDocumentChar, templateDocumentText: peg$parsetemplateDocumentText, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, unaryOperator: peg$parseunaryOperator, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
   var peg$startRuleFunction = peg$parse__;
 
   var peg$c0 = "[";
@@ -603,25 +603,25 @@ function peg$parse(input, options) {
   var peg$f68 = function(value) {
       return annotate([ops.spread, value], location());
     };
-  var peg$f69 = function(contents) {
-      return annotate([ops.lambda, ["_"], contents], location());
-    };
-  var peg$f70 = function(head, tail) {
-      return annotate(makeTemplate(ops.template, head, tail), location());
+  var peg$f69 = function(head, tail) {
+      return annotate(
+        [ops.lambda, ["_"], makeTemplate(ops.templateIndent, head, tail)],
+        location()
+      );
     };
-  var peg$f71 = function(chars) {
+  var peg$f70 = function(chars) {
       return chars.join("");
     };
-  var peg$f72 = function(contents) {
-      return annotate(makeTemplate(ops.template, contents[0], contents[1]), location());
+  var peg$f71 = function(head, tail) {
+      return annotate(makeTemplate(ops.template, head, tail), location());
     };
-  var peg$f73 = function(chars) {
+  var peg$f72 = function(chars) {
       return chars.join("");
     };
-  var peg$f74 = function(expression) {
+  var peg$f73 = function(expression) {
       return annotate(expression, location());
     };
-  var peg$f75 = function(operator, expression) {
+  var peg$f74 = function(operator, expression) {
       return annotate(makeUnaryOperation(operator, expression), location());
     };
   var peg$currPos = options.peg$currPos | 0;
@@ -4358,14 +4358,37 @@ function peg$parse(input, options) {
   }
 
   function peg$parsetemplateDocument() {
-    var s0, s1;
+    var s0, s1, s2, s3, s4, s5;
 
     peg$silentFails++;
     s0 = peg$currPos;
-    s1 = peg$parsetemplateDocumentContents();
+    s1 = peg$parsetemplateDocumentText();
+    s2 = [];
+    s3 = peg$currPos;
+    s4 = peg$parsetemplateSubstitution();
+    if (s4 !== peg$FAILED) {
+      s5 = peg$parsetemplateDocumentText();
+      s4 = [s4, s5];
+      s3 = s4;
+    } else {
+      peg$currPos = s3;
+      s3 = peg$FAILED;
+    }
+    while (s3 !== peg$FAILED) {
+      s2.push(s3);
+      s3 = peg$currPos;
+      s4 = peg$parsetemplateSubstitution();
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parsetemplateDocumentText();
+        s4 = [s4, s5];
+        s3 = s4;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+    }
     peg$savedPos = s0;
-    s1 = peg$f69(s1);
-    s0 = s1;
+    s0 = peg$f69(s1, s2);
     peg$silentFails--;
     s1 = peg$FAILED;
     if (peg$silentFails === 0) { peg$fail(peg$e94); }
@@ -4409,41 +4432,6 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parsetemplateDocumentContents() {
-    var s0, s1, s2, s3, s4, s5;
-
-    s0 = peg$currPos;
-    s1 = peg$parsetemplateDocumentText();
-    s2 = [];
-    s3 = peg$currPos;
-    s4 = peg$parsetemplateSubstitution();
-    if (s4 !== peg$FAILED) {
-      s5 = peg$parsetemplateDocumentText();
-      s4 = [s4, s5];
-      s3 = s4;
-    } else {
-      peg$currPos = s3;
-      s3 = peg$FAILED;
-    }
-    while (s3 !== peg$FAILED) {
-      s2.push(s3);
-      s3 = peg$currPos;
-      s4 = peg$parsetemplateSubstitution();
-      if (s4 !== peg$FAILED) {
-        s5 = peg$parsetemplateDocumentText();
-        s4 = [s4, s5];
-        s3 = s4;
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-    }
-    peg$savedPos = s0;
-    s0 = peg$f70(s1, s2);
-
-    return s0;
-  }
-
   function peg$parsetemplateDocumentText() {
     var s0, s1, s2;
 
@@ -4456,7 +4444,7 @@ function peg$parse(input, options) {
       s2 = peg$parsetemplateDocumentChar();
     }
     peg$savedPos = s0;
-    s1 = peg$f71(s1);
+    s1 = peg$f70(s1);
     s0 = s1;
     peg$silentFails--;
     s1 = peg$FAILED;
@@ -4466,7 +4454,7 @@ function peg$parse(input, options) {
   }
 
   function peg$parsetemplateLiteral() {
-    var s0, s1, s2, s3;
+    var s0, s1, s2, s3, s4, s5, s6;
 
     peg$silentFails++;
     s0 = peg$currPos;
@@ -4478,17 +4466,41 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e98); }
     }
     if (s1 !== peg$FAILED) {
-      s2 = peg$parsetemplateLiteralContents();
+      s2 = peg$parsetemplateLiteralText();
+      s3 = [];
+      s4 = peg$currPos;
+      s5 = peg$parsetemplateSubstitution();
+      if (s5 !== peg$FAILED) {
+        s6 = peg$parsetemplateLiteralText();
+        s5 = [s5, s6];
+        s4 = s5;
+      } else {
+        peg$currPos = s4;
+        s4 = peg$FAILED;
+      }
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = peg$currPos;
+        s5 = peg$parsetemplateSubstitution();
+        if (s5 !== peg$FAILED) {
+          s6 = peg$parsetemplateLiteralText();
+          s5 = [s5, s6];
+          s4 = s5;
+        } else {
+          peg$currPos = s4;
+          s4 = peg$FAILED;
+        }
+      }
       if (input.charCodeAt(peg$currPos) === 96) {
-        s3 = peg$c59;
+        s4 = peg$c59;
         peg$currPos++;
       } else {
-        s3 = peg$FAILED;
+        s4 = peg$FAILED;
         if (peg$silentFails === 0) { peg$fail(peg$e98); }
       }
-      if (s3 !== peg$FAILED) {
+      if (s4 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f72(s2);
+        s0 = peg$f71(s2, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -4551,41 +4563,6 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function peg$parsetemplateLiteralContents() {
-    var s0, s1, s2, s3, s4, s5;
-
-    s0 = peg$currPos;
-    s1 = peg$parsetemplateLiteralText();
-    s2 = [];
-    s3 = peg$currPos;
-    s4 = peg$parsetemplateSubstitution();
-    if (s4 !== peg$FAILED) {
-      s5 = peg$parsetemplateLiteralText();
-      s4 = [s4, s5];
-      s3 = s4;
-    } else {
-      peg$currPos = s3;
-      s3 = peg$FAILED;
-    }
-    while (s3 !== peg$FAILED) {
-      s2.push(s3);
-      s3 = peg$currPos;
-      s4 = peg$parsetemplateSubstitution();
-      if (s4 !== peg$FAILED) {
-        s5 = peg$parsetemplateLiteralText();
-        s4 = [s4, s5];
-        s3 = s4;
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-    }
-    s1 = [s1, s2];
-    s0 = s1;
-
-    return s0;
-  }
-
   function peg$parsetemplateLiteralText() {
     var s0, s1, s2;
 
@@ -4597,7 +4574,7 @@ function peg$parse(input, options) {
       s2 = peg$parsetemplateLiteralChar();
     }
     peg$savedPos = s0;
-    s1 = peg$f73(s1);
+    s1 = peg$f72(s1);
     s0 = s1;
 
     return s0;
@@ -4627,7 +4604,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f74(s2);
+          s0 = peg$f73(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -4676,7 +4653,7 @@ function peg$parse(input, options) {
       s3 = peg$parseunaryExpression();
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f75(s1, s3);
+        s0 = peg$f74(s1, s3);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -4856,11 +4833,9 @@ const peg$allowedStartRules = [
   "stringLiteral",
   "templateDocument",
   "templateDocumentChar",
-  "templateDocumentContents",
   "templateDocumentText",
   "templateLiteral",
   "templateLiteralChar",
-  "templateLiteralContents",
   "templateLiteralText",
   "templateSubstitution",
   "textChar",

package/src/compiler/parserHelpers.js

@@ -76,22 +76,6 @@ export function downgradeReference(code) {
   }
 }
 
-// Return true if the code will generate an async object.
-function isCodeForAsyncObject(code) {
-  if (!(code instanceof Array)) {
-    return false;
-  }
-  if (code[0] !== ops.object) {
-    return false;
-  }
-  // Are any of the properties getters?
-  const entries = code.slice(1);
-  const hasGetter = entries.some(([key, value]) => {
-    return value instanceof Array && value[0] === ops.getter;
-  });
-  return hasGetter;
-}
-
 export function makeArray(entries) {
   let currentEntries = [];
   const spreads = [];
@@ -260,17 +244,24 @@ export function makeObject(entries, op) {
       continue;
     }
 
-    if (
-      value instanceof Array &&
-      value[0] === ops.getter &&
-      value[1] instanceof Array &&
-      value[1][0] === ops.literal
-    ) {
-      // Simplify a getter for a primitive value to a regular property
-      value = value[1];
-    } else if (isCodeForAsyncObject(value)) {
-      // Add a trailing slash to key to indicate value is a subtree
-      key = key + "/";
+    if (value instanceof Array) {
+      if (
+        value[0] === ops.getter &&
+        value[1] instanceof Array &&
+        value[1][0] === ops.literal
+      ) {
+        // Optimize a getter for a primitive value to a regular property
+        value = value[1];
+      }
+      // else if (
+      //   value[0] === ops.object ||
+      //   (value[0] === ops.getter &&
+      //     value[1] instanceof Array &&
+      //     (value[1][0] === ops.object || value[1][0] === ops.merge))
+      // ) {
+      //   // Add a trailing slash to key to indicate value is a subtree
+      //   key = trailingSlash.add(key);
+      // }
     }
 
     currentEntries.push([key, value]);

package/src/runtime/expressionObject.js

@@ -1,4 +1,10 @@
-import { extension, ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import {
+  extension,
+  ObjectTree,
+  symbols,
+  trailingSlash,
+  Tree,
+} from "@weborigami/async-tree";
 import { handleExtension } from "./handlers.js";
 import { evaluate, ops } from "./internal.js";
 
@@ -11,8 +17,8 @@ import { evaluate, ops } from "./internal.js";
  *
  * 1. A primitive value (string, etc.). This will be defined directly as an
  *    object property.
- * 1. An immediate code entry. This will be evaluated during this call and its
- *    result defined as an object property.
+ * 1. An eager (as opposed to lazy) code entry. This will be evaluated during
+ *    this call and its result defined as an object property.
  * 1. A code entry that starts with ops.getter. This will be defined as a
  *    property getter on the object.
  *
@@ -25,15 +31,9 @@ export default async function expressionObject(entries, parent) {
   if (parent !== null && !Tree.isAsyncTree(parent)) {
     throw new TypeError(`Parent must be an AsyncTree or null`);
   }
-  Object.defineProperty(object, symbols.parent, {
-    configurable: true,
-    enumerable: false,
-    value: parent,
-    writable: true,
-  });
 
   let tree;
-  const immediateProperties = [];
+  const eagerProperties = [];
   for (let [key, value] of entries) {
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
@@ -61,7 +61,6 @@ export default async function expressionObject(entries, parent) {
 
     if (defineProperty) {
       // Define simple property
-      // object[key] = value;
       Object.defineProperty(object, key, {
         configurable: true,
         enumerable,
@@ -74,7 +73,7 @@ export default async function expressionObject(entries, parent) {
       if (value[0] === ops.getter) {
         code = value[1];
       } else {
-        immediateProperties.push(key);
+        eagerProperties.push(key);
         code = value;
       }
 
@@ -102,9 +101,25 @@ export default async function expressionObject(entries, parent) {
     }
   }
 
+  // Attach a keys method
+  Object.defineProperty(object, symbols.keys, {
+    configurable: true,
+    enumerable: false,
+    value: () => keys(object, eagerProperties, entries),
+    writable: true,
+  });
+
+  // Attach the parent
+  Object.defineProperty(object, symbols.parent, {
+    configurable: true,
+    enumerable: false,
+    value: parent,
+    writable: true,
+  });
+
   // Evaluate any properties that were declared as immediate: get their value
   // and overwrite the property getter with the actual value.
-  for (const key of immediateProperties) {
+  for (const key of eagerProperties) {
     const value = await object[key];
     // @ts-ignore Unclear why TS thinks `object` might be undefined here
     const enumerable = Object.getOwnPropertyDescriptor(object, key).enumerable;
@@ -118,3 +133,31 @@ export default async function expressionObject(entries, parent) {
 
   return object;
 }
+
+function entryKey(object, eagerProperties, entry) {
+  const [key, value] = entry;
+
+  const hasExplicitSlash = trailingSlash.has(key);
+  if (hasExplicitSlash) {
+    // Return key as is
+    return key;
+  }
+
+  // If eager property value is treelike, add slash to the key
+  if (eagerProperties.includes(key) && Tree.isTreelike(object[key])) {
+    return trailingSlash.add(key);
+  }
+
+  // If entry will definitely create a subtree, add a trailing slash
+  const entryCreatesSubtree =
+    value instanceof Array &&
+    (value[0] === ops.object ||
+      (value[0] === ops.getter &&
+        value[1] instanceof Array &&
+        (value[1][0] === ops.object || value[1][0] === ops.merge)));
+  return trailingSlash.toggle(key, entryCreatesSubtree);
+}
+
+function keys(object, eagerProperties, entries) {
+  return entries.map((entry) => entryKey(object, eagerProperties, entry));
+}

package/src/runtime/ops.js

@@ -12,6 +12,7 @@ import {
   concat as treeConcat,
 } from "@weborigami/async-tree";
 import os from "node:os";
+import taggedTemplateIndent from "../../src/runtime/taggedTemplateIndent.js";
 import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 import expressionObject from "./expressionObject.js";
 import { evaluate } from "./internal.js";
@@ -447,10 +448,18 @@ addOpLabel(subtraction, "«ops.subtraction»");
  * Apply the default tagged template function.
  */
 export function template(strings, ...values) {
-  return taggedTemplate(strings, values);
+  return taggedTemplate(strings, ...values);
 }
 addOpLabel(template, "«ops.template»");
 
+/**
+ * Apply the tagged template indent function.
+ */
+export function templateIndent(strings, ...values) {
+  return taggedTemplateIndent(strings, ...values);
+}
+addOpLabel(templateIndent, "«ops.templateIndent");
+
 /**
  * Traverse a path of keys through a tree.
  */

package/src/runtime/taggedTemplate.js

@@ -1,6 +1,6 @@
 // Default JavaScript tagged template function splices strings and values
 // together.
-export default function defaultTemplateJoin(strings, values) {
+export default function taggedTemplate(strings, ...values) {
   let result = strings[0];
   for (let i = 0; i < values.length; i++) {
     result += values[i] + strings[i + 1];

package/src/runtime/taggedTemplateIndent.js

@@ -0,0 +1,115 @@
+const lastLineWhitespaceRegex = /\n(?<indent>[ \t]*)$/;
+
+const mapStringsToModifications = new Map();
+
+/**
+ * Normalize indentation in a tagged template string.
+ *
+ * @param {TemplateStringsArray} strings
+ * @param  {...any} values
+ * @returns {string}
+ */
+export default function indent(strings, ...values) {
+  let modified = mapStringsToModifications.get(strings);
+  if (!modified) {
+    modified = modifyStrings(strings);
+    mapStringsToModifications.set(strings, modified);
+  }
+  const { blockIndentations, strings: modifiedStrings } = modified;
+  return joinBlocks(modifiedStrings, values, blockIndentations);
+}
+
+// Join strings and values, applying the given block indentation to the lines of
+// values for block placholders.
+function joinBlocks(strings, values, blockIndentations) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    let text = values[i];
+    if (text) {
+      const blockIndentation = blockIndentations[i];
+      if (blockIndentation) {
+        const lines = text.split("\n");
+        text = "";
+        if (lines.at(-1) === "") {
+          // Drop empty last line
+          lines.pop();
+        }
+        for (let line of lines) {
+          text += blockIndentation + line + "\n";
+        }
+      }
+      result += text;
+    }
+    result += strings[i + 1];
+  }
+  return result;
+}
+
+// Given an array of template boilerplate strings, return an object { modified,
+// blockIndentations } where `strings` is the array of strings with indentation
+// removed, and `blockIndentations` is an array of indentation strings for each
+// block placeholder.
+function modifyStrings(strings) {
+  // Phase one: Identify the indentation based on the first real line of the
+  // first string (skipping the initial newline), and remove this indentation
+  // from all lines of all strings.
+  let indent;
+  if (strings.length > 0 && strings[0].startsWith("\n")) {
+    // Look for indenttation
+    const firstLineWhitespaceRegex = /^\n(?<indent>[ \t]*)/;
+    const match = strings[0].match(firstLineWhitespaceRegex);
+    indent = match?.groups.indent;
+  }
+
+  // Determine the modified strings. If this invoked as a JS tagged template
+  // literal, the `strings` argument will be an odd array-ish object that we'll
+  // want to convert to a real array.
+  let modified;
+  if (indent) {
+    // De-indent the strings.
+    const indentationRegex = new RegExp(`\n${indent}`, "g");
+    // The `replaceAll` also converts strings to a real array.
+    modified = strings.map((string) =>
+      string.replaceAll(indentationRegex, "\n")
+    );
+    // Remove indentation from last line of last string
+    modified[modified.length - 1] = modified
+      .at(-1)
+      .replace(lastLineWhitespaceRegex, "\n");
+  } else {
+    // No indentation; just copy the strings so we have a real array
+    modified = strings.slice();
+  }
+
+  // Phase two: Identify any block placholders, identify and remove their
+  // preceding indentation, and remove the following newline. Work backward from
+  // the end towards the start because we're modifying the strings in place and
+  // our pattern matching won't work going forward from start to end.
+  let blockIndentations = [];
+  for (let i = modified.length - 2; i >= 0; i--) {
+    // Get the modified before and after substitution with index `i`
+    const beforeString = modified[i];
+    const afterString = modified[i + 1];
+    const match = beforeString.match(lastLineWhitespaceRegex);
+    if (match && afterString.startsWith("\n")) {
+      // The substitution between these strings is a block substitution
+      let blockIndentation = match.groups.indent;
+      blockIndentations[i] = blockIndentation;
+      // Trim the before and after strings
+      if (blockIndentation) {
+        modified[i] = beforeString.slice(0, -blockIndentation.length);
+      }
+      modified[i + 1] = afterString.slice(1);
+    }
+  }
+
+  // Remove newline from start of first string *after* removing indentation.
+  if (modified[0].startsWith("\n")) {
+    modified[0] = modified[0].slice(1);
+  }
+
+  return {
+    blockIndentations,
+    strings: modified,
+  };
+}

package/test/compiler/compile.test.js

@@ -10,7 +10,7 @@ const shared = new ObjectTree({
   name: "Alice",
 });
 
-describe.only("compile", () => {
+describe("compile", () => {
   test("array", async () => {
     await assertCompile("[]", []);
     await assertCompile("[ 1, 2, 3, ]", [1, 2, 3]);
@@ -46,12 +46,14 @@ describe.only("compile", () => {
   test("async object", async () => {
     const fn = compile.expression("{ a: { b = name }}");
     const object = await fn.call(shared);
-    assert.deepEqual(await object["a/"].b, "Alice");
+    assert.deepEqual(await object.a.b, "Alice");
   });
 
   test("templateDocument", async () => {
-    const fn = compile.templateDocument("Documents can contain ` backticks");
-    const templateFn = await fn.call(shared);
+    const defineTemplateFn = compile.templateDocument(
+      "Documents can contain ` backticks"
+    );
+    const templateFn = await defineTemplateFn.call(null);
     const value = await templateFn.call(null);
     assert.deepEqual(value, "Documents can contain ` backticks");
   });
@@ -85,7 +87,7 @@ describe.only("compile", () => {
     assert.equal(bob, "Hello, Bob!");
   });
 
-  test.only("converts non-local ops.scope calls to ops.external", async () => {
+  test("converts non-local ops.scope calls to ops.external", async () => {
     const expression = `
       (name) => {
         a: 1
@@ -108,6 +110,18 @@ describe.only("compile", () => {
       ],
     ]);
   });
+
+  test("can apply a macro", async () => {
+    const literal = [ops.literal, 1];
+    const expression = `{ a: literal }`;
+    const fn = compile.expression(expression, {
+      macros: {
+        literal,
+      },
+    });
+    const code = fn.code;
+    assert.deepEqual(stripCodeLocations(code), [ops.object, ["a", literal]]);
+  });
 });
 
 async function assertCompile(text, expected) {

package/test/compiler/parse.test.js

@@ -667,7 +667,7 @@ describe("Origami parser", () => {
     assertParse("objectLiteral", "{ a: { b = fn() } }", [
       ops.object,
       [
-        "a/",
+        "a",
         [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
       ],
     ]);
@@ -970,7 +970,7 @@ describe("Origami parser", () => {
       ops.lambda,
       ["_"],
       [
-        ops.template,
+        ops.templateIndent,
         [ops.literal, ["hello", "world"]],
         [ops.concat, [ops.scope, "foo"]],
       ],
@@ -978,7 +978,10 @@ describe("Origami parser", () => {
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
       ["_"],
-      [ops.template, [ops.literal, ["Documents can contain ` backticks"]]],
+      [
+        ops.templateIndent,
+        [ops.literal, ["Documents can contain ` backticks"]],
+      ],
     ]);
   });
 

package/test/runtime/expressionObject.test.js

@@ -5,7 +5,7 @@ import { describe, test } from "node:test";
 import expressionObject from "../../src/runtime/expressionObject.js";
 import { ops } from "../../src/runtime/internal.js";
 
-describe("expressionObject", () => {
+describe.only("expressionObject", () => {
   test("can instantiate an object", async () => {
     const scope = new ObjectTree({
       upper: (s) => s.toUpperCase(),
@@ -73,4 +73,22 @@ describe("expressionObject", () => {
     assert.deepEqual(Object.keys(object), ["visible"]);
     assert.equal(object["hidden"], "shh");
   });
+
+  test.only("provides a symbols.keys method", async () => {
+    const entries = [
+      // Will return a tree, should have a slash
+      ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
+      ["hasSlash/", "This isn't really a tree but says it is"],
+      ["message", "Hello"],
+      // Immediate treelike value, should have a slash
+      ["object", [ops.object, ["b", [ops.literal, 2]]]],
+    ];
+    const object = await expressionObject(entries, null);
+    assert.deepEqual(object[symbols.keys](), [
+      "getter/",
+      "hasSlash/",
+      "message",
+      "object/",
+    ]);
+  });
 });

package/test/runtime/taggedTemplateIndent.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import indent from "../../src/runtime/taggedTemplateIndent.js";
+
+describe("taggedTemplateIndent", () => {
+  test("joins strings and values together if template isn't a block template", () => {
+    const result = indent`a ${"b"} c`;
+    assert.equal(result, "a b c");
+  });
+
+  test("removes first and last lines if template is a block template", () => {
+    const actual = indent`
+    <p>
+      Hello, ${"Alice"}!
+    </p>
+    `;
+    const expected = `
+<p>
+  Hello, Alice!
+</p>
+`.trimStart();
+    assert.equal(actual, expected);
+  });
+
+  test("indents all lines in a block substitution", () => {
+    const lines = `
+Line 1
+Line 2
+Line 3`.trimStart();
+    const actual = indent`
+    <main>
+      ${lines}
+    </main>
+    `;
+    const expected = `
+<main>
+  Line 1
+  Line 2
+  Line 3
+</main>
+`.trimStart();
+    assert.equal(actual, expected);
+  });
+});