@weborigami/language 0.3.4-jse.7 → 0.3.4-jse.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.3.4-jse.7",
+  "version": "0.3.4-jse.9",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.3.4-jse.7",
-    "@weborigami/types": "0.3.4-jse.7",
+    "@weborigami/async-tree": "0.3.4-jse.9",
+    "@weborigami/types": "0.3.4-jse.9",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/optimize.js

@@ -37,8 +37,8 @@ export default function optimize(code, options = {}) {
   const [op, ...args] = code;
   switch (op) {
     case markers.global:
-      // Replace global op with the globals
-      return annotate([globals, args[0]], code.location);
+      // Replace with the indicated global
+      return globals[args[0]];
 
     case markers.traverse:
       return resolvePath(code, globals, locals, cache);
@@ -56,7 +56,7 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const keys = entries.map(entryKey);
+      const keys = entries.map((entry) => entryKey(entry));
       locals.push(keys);
       break;
   }
@@ -70,13 +70,16 @@ export default function optimize(code, options = {}) {
       } else if (op === ops.object && index > 0) {
         const [key, value] = child;
         const adjustedLocals = avoidLocalRecursion(locals, key);
-        return [
-          key,
-          optimize(/** @type {AnnotatedCode} */ (value), {
-            ...options,
-            locals: adjustedLocals,
-          }),
-        ];
+        return annotate(
+          [
+            key,
+            optimize(/** @type {AnnotatedCode} */ (value), {
+              ...options,
+              locals: adjustedLocals,
+            }),
+          ],
+          child.location
+        );
       } else if (Array.isArray(child) && "location" in child) {
         // Review: Aside from ops.object (above), what non-instruction arrays
         // does this descend into?
@@ -140,7 +143,7 @@ function compoundReference(key, globals, locals, location) {
   const type = referenceType(head, globals, locals);
   let result;
   if (type === REFERENCE_GLOBAL) {
-    result = globalReference(head, globals, location);
+    result = globalReference(head, globals);
   } else if (type === REFERENCE_LOCAL) {
     result = localReference(head, locals, location);
   } else {
@@ -177,9 +180,9 @@ function getLocalReferenceDepth(locals, key) {
   return depth;
 }
 
-function globalReference(key, globals, location) {
+function globalReference(key, globals) {
   const normalized = trailingSlash.remove(key);
-  return annotate([globals, normalized], location);
+  return globals[normalized];
 }
 
 function inlineLiteral(code) {
@@ -191,6 +194,7 @@ function inlineLiteral(code) {
 function localReference(key, locals, location) {
   const normalized = trailingSlash.remove(key);
   const depth = getLocalReferenceDepth(locals, normalized);
+  /** @type {any[]} */
   const context = [ops.context];
   if (depth > 0) {
     context.push(depth);
@@ -249,24 +253,29 @@ function reference(code, globals, locals) {
 
   // See if the whole key is a global or local variable
   let type = referenceType(key, globals, locals);
-  let result;
   if (type === REFERENCE_GLOBAL) {
-    result = globalReference(key, globals, location);
+    return {
+      type,
+      result: globalReference(key, globals),
+    };
   } else if (type === REFERENCE_LOCAL) {
-    result = localReference(key, locals, location);
-  } else {
-    // Try key as a compound reference x.y.z
-    const compound = compoundReference(key, globals, locals, location);
-    result = compound?.result;
-    type = compound?.type;
+    return {
+      type,
+      result: localReference(key, locals, location),
+    };
   }
 
-  if (!result) {
-    // If none of the above worked, it must be an external reference
-    result = externalReference(key, locals, location);
+  // Try key as a compound reference x.y.z
+  const compound = compoundReference(key, globals, locals, location);
+  if (compound.type !== REFERENCE_EXTERNAL) {
+    return compound;
   }
 
-  return { type, result };
+  // Not a compound reference, must be external
+  return {
+    type: REFERENCE_EXTERNAL,
+    result: externalReference(key, locals, location),
+  };
 }
 
 function referenceType(key, globals, locals) {
@@ -287,7 +296,13 @@ function resolvePath(code, globals, locals, cache) {
 
   let { type, result } = reference(head, globals, locals);
 
-  result.push(...tail);
+  if (tail.length > 0) {
+    if (result instanceof Array) {
+      result.push(...tail);
+    } else {
+      result = annotate([result, ...tail], code.location);
+    }
+  }
 
   if (type === REFERENCE_EXTERNAL && cache !== null) {
     // Cache external path
@@ -299,6 +314,7 @@ function resolvePath(code, globals, locals, cache) {
 
 function scopeCall(locals, location) {
   const depth = locals.length;
+  /** @type {any[]} */
   const code = [ops.scope];
   if (depth > 0) {
     // Add context for appropriate depth to scope call

package/src/compiler/origami.pegjs

@@ -164,10 +164,17 @@ comment "comment"
   / singleLineComment
 
 computedPropertyAccess
-  = __ "[" expression:expectExpression expectClosingBracket {
+  = computedPropertySpace "[" expression:expectExpression expectClosingBracket {
       return annotate([markers.property, expression], location());
     }
 
+// A space before a computed property access. This is allowed when in not in
+// shell mode, but not in shell mode. In shell mode `foo [bar]` should parse as
+// a function call with a single argument of an array, not as a property access.
+computedPropertySpace
+  = shellMode
+  / !shellMode __
+
 conditionalExpression
   = condition:logicalOrExpression tail:(__
     "?" __ @shorthandFunction __
@@ -773,7 +780,12 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
+      // TODO: Deprecate @template
       const macroName = text().includes("@template") ? "@template" : "_template";
+      if (macroName === "@template") {
+        // If the front matter is a macro, apply it to the body
+        console.warn("Warning: the @template() macro is deprecated. Use _template() instead.");
+      }
       return annotate(applyMacro(front, macroName, body), location());
     }
   / front:frontMatterYaml body:templateBody {
@@ -854,7 +866,8 @@ uriKey
 // A single character in a URI key
 uriKeyChar
   // Accept anything that doesn't end the URI key or path
-  = [^/,\)\]\}\s]
+  // Reject whitespace; see notes for `whitespace` term
+  = char:[^/,\)\]\}] !&{ return /\s/.test(char); } { return char; }
   / escapedChar
 
 // A slash-separated path of keys: `a/b/c`
@@ -877,8 +890,9 @@ unaryOperator
   / minus
 
 whitespace
-  = inlineSpace
-  / newLine
+  // JavaScript considers a large number of characters whitespace so we use the
+  // `/s` definition to avoid missing any.
+  = char:. &{ return /\s/.test(char); } { return char; }
   / comment
 
 whitespaceWithNewLine

package/src/compiler/parse.js

@@ -205,7 +205,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, angleBracketLiteral: peg$parseangleBracketLiteral, angleBracketPath: peg$parseangleBracketPath, angleBracketKey: peg$parseangleBracketKey, angleBracketPathChar: peg$parseangleBracketPathChar, 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, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, computedPropertyAccess: peg$parsecomputedPropertyAccess, 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, expectBacktick: peg$parseexpectBacktick, expectClosingBrace: peg$parseexpectClosingBrace, expectClosingBracket: peg$parseexpectClosingBracket, expectClosingParenthesis: peg$parseexpectClosingParenthesis, expectDoubleQuote: peg$parseexpectDoubleQuote, expectExpression: peg$parseexpectExpression, expectFrontDelimiter: peg$parseexpectFrontDelimiter, expectGuillemet: peg$parseexpectGuillemet, expectSingleQuote: peg$parseexpectSingleQuote, expectPipelineExpression: peg$parseexpectPipelineExpression, expectUnaryExpression: peg$parseexpectUnaryExpression, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, frontDelimiter: peg$parsefrontDelimiter, frontMatterExpression: peg$parsefrontMatterExpression, frontMatterText: peg$parsefrontMatterText, frontMatterYaml: peg$parsefrontMatterYaml, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, host: peg$parsehost, hostname: peg$parsehostname, identifier: peg$parseidentifier, identifierLiteral: peg$parseidentifierLiteral, identifierPart: peg$parseidentifierPart, identifierStart: peg$parseidentifierStart, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, key: peg$parsekey, keyChar: peg$parsekeyChar, keyCharStart: peg$parsekeyCharStart, list: peg$parselist, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, minus: peg$parseminus, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, newExpression: peg$parsenewExpression, 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, optionalChaining: peg$parseoptionalChaining, parameter: peg$parseparameter, parameterList: peg$parseparameterList, parameterSingleton: peg$parseparameterSingleton, parenthesesArguments: peg$parseparenthesesArguments, pathArguments: peg$parsepathArguments, pathKeys: peg$parsepathKeys, pathLiteral: peg$parsepathLiteral, pathSegment: peg$parsepathSegment, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, propertyAccess: peg$parsepropertyAccess, regexFlags: peg$parseregexFlags, regexLiteral: peg$parseregexLiteral, regexLiteralChar: peg$parseregexLiteralChar, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, separator: peg$parseseparator, shebang: peg$parseshebang, shellMode: peg$parseshellMode, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, slash: peg$parseslash, slashes: peg$parseslashes, slashFollows: peg$parseslashFollows, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateBody: peg$parsetemplateBody, templateBodyChar: peg$parsetemplateBodyChar, templateBodyText: peg$parsetemplateBodyText, templateDocument: peg$parsetemplateDocument, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, uri: peg$parseuri, uriExpression: peg$parseuriExpression, uriKey: peg$parseuriKey, uriKeyChar: peg$parseuriKeyChar, uriPath: peg$parseuriPath, uriScheme: peg$parseuriScheme, unaryOperator: peg$parseunaryOperator, whitespace: peg$parsewhitespace, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
+  var peg$startRuleFunctions = { __: peg$parse__, additiveExpression: peg$parseadditiveExpression, additiveOperator: peg$parseadditiveOperator, angleBracketLiteral: peg$parseangleBracketLiteral, angleBracketPath: peg$parseangleBracketPath, angleBracketKey: peg$parseangleBracketKey, angleBracketPathChar: peg$parseangleBracketPathChar, 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, commaExpression: peg$parsecommaExpression, comment: peg$parsecomment, computedPropertyAccess: peg$parsecomputedPropertyAccess, computedPropertySpace: peg$parsecomputedPropertySpace, 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, expectBacktick: peg$parseexpectBacktick, expectClosingBrace: peg$parseexpectClosingBrace, expectClosingBracket: peg$parseexpectClosingBracket, expectClosingParenthesis: peg$parseexpectClosingParenthesis, expectDoubleQuote: peg$parseexpectDoubleQuote, expectExpression: peg$parseexpectExpression, expectFrontDelimiter: peg$parseexpectFrontDelimiter, expectGuillemet: peg$parseexpectGuillemet, expectSingleQuote: peg$parseexpectSingleQuote, expectPipelineExpression: peg$parseexpectPipelineExpression, expectUnaryExpression: peg$parseexpectUnaryExpression, exponentiationExpression: peg$parseexponentiationExpression, expression: peg$parseexpression, floatLiteral: peg$parsefloatLiteral, frontDelimiter: peg$parsefrontDelimiter, frontMatterExpression: peg$parsefrontMatterExpression, frontMatterText: peg$parsefrontMatterText, frontMatterYaml: peg$parsefrontMatterYaml, group: peg$parsegroup, guillemetString: peg$parseguillemetString, guillemetStringChar: peg$parseguillemetStringChar, host: peg$parsehost, hostname: peg$parsehostname, identifier: peg$parseidentifier, identifierLiteral: peg$parseidentifierLiteral, identifierPart: peg$parseidentifierPart, identifierStart: peg$parseidentifierStart, implicitParenthesesCallExpression: peg$parseimplicitParenthesesCallExpression, implicitParensthesesArguments: peg$parseimplicitParensthesesArguments, inlineSpace: peg$parseinlineSpace, integerLiteral: peg$parseintegerLiteral, key: peg$parsekey, keyChar: peg$parsekeyChar, keyCharStart: peg$parsekeyCharStart, list: peg$parselist, logicalAndExpression: peg$parselogicalAndExpression, logicalOrExpression: peg$parselogicalOrExpression, minus: peg$parseminus, multiLineComment: peg$parsemultiLineComment, multiplicativeExpression: peg$parsemultiplicativeExpression, multiplicativeOperator: peg$parsemultiplicativeOperator, newExpression: peg$parsenewExpression, 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, optionalChaining: peg$parseoptionalChaining, parameter: peg$parseparameter, parameterList: peg$parseparameterList, parameterSingleton: peg$parseparameterSingleton, parenthesesArguments: peg$parseparenthesesArguments, pathArguments: peg$parsepathArguments, pathKeys: peg$parsepathKeys, pathLiteral: peg$parsepathLiteral, pathSegment: peg$parsepathSegment, pipelineExpression: peg$parsepipelineExpression, primary: peg$parseprimary, program: peg$parseprogram, propertyAccess: peg$parsepropertyAccess, regexFlags: peg$parseregexFlags, regexLiteral: peg$parseregexLiteral, regexLiteralChar: peg$parseregexLiteralChar, relationalExpression: peg$parserelationalExpression, relationalOperator: peg$parserelationalOperator, separator: peg$parseseparator, shebang: peg$parseshebang, shellMode: peg$parseshellMode, shiftExpression: peg$parseshiftExpression, shiftOperator: peg$parseshiftOperator, shorthandFunction: peg$parseshorthandFunction, singleArrow: peg$parsesingleArrow, singleLineComment: peg$parsesingleLineComment, singleQuoteString: peg$parsesingleQuoteString, singleQuoteStringChar: peg$parsesingleQuoteStringChar, slash: peg$parseslash, slashes: peg$parseslashes, slashFollows: peg$parseslashFollows, spreadElement: peg$parsespreadElement, stringLiteral: peg$parsestringLiteral, templateBody: peg$parsetemplateBody, templateBodyChar: peg$parsetemplateBodyChar, templateBodyText: peg$parsetemplateBodyText, templateDocument: peg$parsetemplateDocument, templateLiteral: peg$parsetemplateLiteral, templateLiteralChar: peg$parsetemplateLiteralChar, templateLiteralText: peg$parsetemplateLiteralText, templateSubstitution: peg$parsetemplateSubstitution, textChar: peg$parsetextChar, unaryExpression: peg$parseunaryExpression, uri: peg$parseuri, uriExpression: peg$parseuriExpression, uriKey: peg$parseuriKey, uriKeyChar: peg$parseuriKeyChar, uriPath: peg$parseuriPath, uriScheme: peg$parseuriScheme, unaryOperator: peg$parseunaryOperator, whitespace: peg$parsewhitespace, whitespaceWithNewLine: peg$parsewhitespaceWithNewLine };
   var peg$startRuleFunction = peg$parse__;
 
   var peg$c0 = "+";
@@ -285,7 +285,7 @@ function peg$parse(input, options) {
   var peg$r7 = /^[gimuy]/;
   var peg$r8 = /^[^\/\n\r]/;
   var peg$r9 = /^[^\n\r]/;
-  var peg$r10 = /^[^\/,)\]}s]/;
+  var peg$r10 = /^[^\/,)\]}]/;
   var peg$r11 = /^[a-z]/;
   var peg$r12 = /^[a-z0-9+-.]/;
   var peg$r13 = /^[:]/;
@@ -399,7 +399,7 @@ function peg$parse(input, options) {
   var peg$e105 = peg$otherExpectation("template document");
   var peg$e106 = peg$otherExpectation("template literal");
   var peg$e107 = peg$otherExpectation("template substitution");
-  var peg$e108 = peg$classExpectation(["/", ",", ")", "]", "}", "s"], true, false);
+  var peg$e108 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false);
   var peg$e109 = peg$otherExpectation("slash-separated path");
   var peg$e110 = peg$classExpectation([["a", "z"]], false, false);
   var peg$e111 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false);
@@ -732,7 +732,12 @@ function peg$parse(input, options) {
       return annotate([ops.literal, chars.join("")], location());
     };
   var peg$f99 = function(front, body) {
+      // TODO: Deprecate @template
       const macroName = text().includes("@template") ? "@template" : "_template";
+      if (macroName === "@template") {
+        // If the front matter is a macro, apply it to the body
+        console.warn("Warning: the @template() macro is deprecated. Use _template() instead.");
+      }
       return annotate(applyMacro(front, macroName, body), location());
     };
   var peg$f100 = function(front, body) {
@@ -775,12 +780,16 @@ function peg$parse(input, options) {
     // A single slash is a path key
     return annotate([ops.literal, ""], location());
     };
-  var peg$f110 = function(keys) {
+  var peg$f110 = function(char) { return /\s/.test(char); };
+  var peg$f111 = function(char) { return char; };
+  var peg$f112 = function(keys) {
       return annotate(keys, location());
     };
-  var peg$f111 = function() {
+  var peg$f113 = function() {
       return annotate([markers.global, text()], location());
     };
+  var peg$f114 = function(char) { return /\s/.test(char); };
+  var peg$f115 = function(char) { return char; };
   var peg$currPos = options.peg$currPos | 0;
   var peg$savedPos = peg$currPos;
   var peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -1896,21 +1905,26 @@ function peg$parse(input, options) {
     var s0, s1, s2, s3, s4;
 
     s0 = peg$currPos;
-    s1 = peg$parse__();
-    if (input.charCodeAt(peg$currPos) === 91) {
-      s2 = peg$c6;
-      peg$currPos++;
-    } else {
-      s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e9); }
-    }
-    if (s2 !== peg$FAILED) {
-      s3 = peg$parseexpectExpression();
-      if (s3 !== peg$FAILED) {
-        s4 = peg$parseexpectClosingBracket();
-        if (s4 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s0 = peg$f16(s3);
+    s1 = peg$parsecomputedPropertySpace();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s2 = peg$c6;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$e9); }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseexpectExpression();
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseexpectClosingBracket();
+          if (s4 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f16(s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1927,6 +1941,35 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parsecomputedPropertySpace() {
+    var s0, s1, s2;
+
+    s0 = peg$parseshellMode();
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      peg$silentFails++;
+      s2 = peg$parseshellMode();
+      peg$silentFails--;
+      if (s2 === peg$FAILED) {
+        s1 = undefined;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
   function peg$parseconditionalExpression() {
     var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
 
@@ -6009,15 +6052,44 @@ function peg$parse(input, options) {
   }
 
   function peg$parseuriKeyChar() {
-    var s0;
+    var s0, s1, s2, s3;
 
-    s0 = input.charAt(peg$currPos);
-    if (peg$r10.test(s0)) {
+    s0 = peg$currPos;
+    s1 = input.charAt(peg$currPos);
+    if (peg$r10.test(s1)) {
       peg$currPos++;
     } else {
-      s0 = peg$FAILED;
+      s1 = peg$FAILED;
       if (peg$silentFails === 0) { peg$fail(peg$e108); }
     }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      peg$silentFails++;
+      peg$savedPos = peg$currPos;
+      s3 = peg$f110(s1);
+      if (s3) {
+        s3 = undefined;
+      } else {
+        s3 = peg$FAILED;
+      }
+      peg$silentFails--;
+      if (s3 === peg$FAILED) {
+        s2 = undefined;
+      } else {
+        peg$currPos = s2;
+        s2 = peg$FAILED;
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f111(s1);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
     if (s0 === peg$FAILED) {
       s0 = peg$parseescapedChar();
     }
@@ -6045,7 +6117,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = s0;
-      s1 = peg$f110(s1);
+      s1 = peg$f112(s1);
     }
     s0 = s1;
     peg$silentFails--;
@@ -6096,7 +6168,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f111();
+        s0 = peg$f113();
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -6164,14 +6236,37 @@ function peg$parse(input, options) {
   }
 
   function peg$parsewhitespace() {
-    var s0;
+    var s0, s1, s2;
 
-    s0 = peg$parseinlineSpace();
-    if (s0 === peg$FAILED) {
-      s0 = peg$parsenewLine();
-      if (s0 === peg$FAILED) {
-        s0 = peg$parsecomment();
+    s0 = peg$currPos;
+    if (input.length > peg$currPos) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e41); }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = peg$currPos;
+      s2 = peg$f114(s1);
+      if (s2) {
+        s2 = undefined;
+      } else {
+        s2 = peg$FAILED;
       }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f115(s1);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsecomment();
     }
 
     return s0;
@@ -6255,6 +6350,7 @@ const peg$allowedStartRules = [
   "commaExpression",
   "comment",
   "computedPropertyAccess",
+  "computedPropertySpace",
   "conditionalExpression",
   "digits",
   "doubleArrow",

package/src/compiler/parserHelpers.js

@@ -28,7 +28,7 @@ export const markers = {
  * If a parse result is an object that will be evaluated at runtime, attach the
  * location of the source code that produced it for debugging and error messages.
  *
- * @param {Code[]} code
+ * @param {any[]} code
  * @param {CodeLocation} location
  */
 export function annotate(code, location) {
@@ -375,11 +375,12 @@ export function makePath(keys) {
   const reference = annotate([markers.reference, headKey], head.location);
 
   let code = [markers.traverse, reference, ...tail];
-  code.location = spanLocations(code);
+  const location = spanLocations(code);
+  code = annotate(code, location);
 
   // Last key has trailing slash implies unpack operation
   if (trailingSlash.has(args.at(-1)[1])) {
-    code = annotate([ops.unpack, code], code.location);
+    code = annotate([ops.unpack, code], location);
   }
 
   return code;

package/src/runtime/errors.js

@@ -1,6 +1,7 @@
 // Text we look for in an error stack to guess whether a given line represents a
 
 import {
+  box,
   scope as scopeFn,
   trailingSlash,
   TraverseError,
@@ -8,6 +9,7 @@ import {
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import codeFragment from "./codeFragment.js";
+import * as symbols from "./symbols.js";
 import { typos } from "./typos.js";
 
 // function in the Origami source code.
@@ -18,6 +20,19 @@ const origamiSourceSignals = [
   "at Scope.evaluate",
 ];
 
+const displayedWarnings = new Set();
+
+export function attachWarning(value, message) {
+  if (typeof value === "object" && value?.[symbols.warningSymbol]) {
+    // Already has a warning, don't overwrite it
+    return value;
+  }
+
+  const boxed = box(value);
+  boxed[symbols.warningSymbol] = message;
+  return boxed;
+}
+
 export async function builtinReferenceError(tree, builtins, key) {
   // See if the key is in scope (but not as a builtin)
   const scope = scopeFn(tree);
@@ -40,6 +55,16 @@ export async function builtinReferenceError(tree, builtins, key) {
   return new ReferenceError(message);
 }
 
+// Display a warning message in the console, but only once for each unique
+// message and location.
+export function displayWarning(message, location) {
+  const warning = "Warning: " + message + lineInfo(location);
+  if (!displayedWarnings.has(warning)) {
+    displayedWarnings.add(warning);
+    console.warn(warning);
+  }
+}
+
 /**
  * Format an error for display in the console.
  *
@@ -80,33 +105,10 @@ export function formatError(error) {
 
   // Add location
   if (location) {
-    let { source, start } = location;
-    // Adjust line number with offset if present (for example, if the code is in
-    // an Origami template document with front matter that was stripped)
-    let line = start.line + (source.offset ?? 0);
     if (!fragmentInMessage) {
       message += `\nevaluating: ${fragment}`;
     }
-
-    if (typeof source === "object" && source.url) {
-      const { url } = source;
-      let fileRef;
-      // If URL is a file: URL, change to a relative path
-      if (url.protocol === "file:") {
-        fileRef = fileURLToPath(url);
-        const relativePath = path.relative(process.cwd(), fileRef);
-        if (!relativePath.startsWith("..")) {
-          fileRef = relativePath;
-        }
-      } else {
-        // Not a file: URL, use as is
-        fileRef = url.href;
-      }
-      message += `\n    at ${fileRef}:${line}:${start.column}`;
-    } else if (source.text.includes("\n")) {
-      // Don't know the URL, but has multiple lines so add line number
-      message += `\n    at line ${line}, column ${start.column}`;
-    }
+    message += lineInfo(location);
   }
 
   return message;
@@ -128,6 +130,36 @@ export function maybeOrigamiSourceCode(text) {
   return origamiSourceSignals.some((signal) => text.includes(signal));
 }
 
+// Return user-friendly line information for the error location
+function lineInfo(location) {
+  let { source, start } = location;
+  // Adjust line number with offset if present (for example, if the code is in
+  // an Origami template document with front matter that was stripped)
+  let line = start.line + (source.offset ?? 0);
+
+  if (typeof source === "object" && source.url) {
+    const { url } = source;
+    let fileRef;
+    // If URL is a file: URL, change to a relative path
+    if (url.protocol === "file:") {
+      fileRef = fileURLToPath(url);
+      const relativePath = path.relative(process.cwd(), fileRef);
+      if (!relativePath.startsWith("..")) {
+        fileRef = relativePath;
+      }
+    } else {
+      // Not a file: URL, use as is
+      fileRef = url.href;
+    }
+    return `\n    at ${fileRef}:${line}:${start.column}`;
+  } else if (source.text.includes("\n")) {
+    // Don't know the URL, but has multiple lines so add line number
+    return `\n    at line ${line}, column ${start.column}`;
+  } else {
+    return "";
+  }
+}
+
 export async function scopeReferenceError(scope, key) {
   const messages = [
     `"${key}" is not in scope or is undefined.`,

package/src/runtime/evaluate.js

@@ -1,4 +1,5 @@
 import { Tree, isUnpackable } from "@weborigami/async-tree";
+import { displayWarning, symbols } from "@weborigami/language";
 import codeFragment from "./codeFragment.js";
 
 /**
@@ -66,33 +67,10 @@ export default async function evaluate(code) {
     throw error;
   }
 
-  // To aid debugging, add the code to the result.
-  // if (Object.isExtensible(result)) {
-  //   try {
-  //     if (code.location && !result[sourceSymbol]) {
-  //       Object.defineProperty(result, sourceSymbol, {
-  //         value: codeFragment(code.location),
-  //         enumerable: false,
-  //       });
-  //     }
-  //     if (!result[codeSymbol]) {
-  //       Object.defineProperty(result, codeSymbol, {
-  //         value: code,
-  //         enumerable: false,
-  //       });
-  //     }
-  //     if (!result[scopeSymbol]) {
-  //       Object.defineProperty(result, scopeSymbol, {
-  //         get() {
-  //           return scope(this).trees;
-  //         },
-  //         enumerable: false,
-  //       });
-  //     }
-  //   } catch (/** @type {any} */ error) {
-  //     // Ignore errors.
-  //   }
-  // }
+  if (result?.[symbols.warningSymbol]) {
+    displayWarning(result[symbols.warningSymbol], code.location);
+    delete result[symbols.warningSymbol];
+  }
 
   return result;
 }

package/src/runtime/getHandlers.js

@@ -6,5 +6,5 @@ export default function getHandlers(tree) {
     return null;
   }
   const root = Tree.root(tree);
-  return root.handlers;
+  return /** @type {any} */ (root).handlers;
 }

package/src/runtime/ops.js

@@ -204,7 +204,7 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
 export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
   // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
+  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
@@ -424,7 +424,7 @@ addOpLabel(remainder, "«ops.remainder»");
 export async function rootDirectory(...keys) {
   const tree = new OrigamiFiles("/");
   // Use the same handlers as the current tree
-  tree.handlers = getHandlers(this);
+  /** @type {any} */ (tree).handlers = getHandlers(this);
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");

package/src/runtime/symbols.js

@@ -2,3 +2,4 @@ export const codeSymbol = Symbol("code");
 export const configSymbol = Symbol("config");
 export const scopeSymbol = Symbol("scope");
 export const sourceSymbol = Symbol("source");
+export const warningSymbol = Symbol("warning");

package/test/compiler/codeHelpers.js

@@ -7,6 +7,15 @@ export function assertCodeEqual(actual, expected) {
   assert.deepStrictEqual(actualStripped, expectedStripped);
 }
 
+export function assertCodeLocations(code) {
+  assert(code.location, "no location");
+  for (const item of code) {
+    if (Array.isArray(item)) {
+      assertCodeLocations(item);
+    }
+  }
+}
+
 /**
  * Adds a fake source to code.
  *

package/test/compiler/optimize.test.js

@@ -4,7 +4,11 @@ import * as compile from "../../src/compiler/compile.js";
 import optimize from "../../src/compiler/optimize.js";
 import { markers } from "../../src/compiler/parserHelpers.js";
 import { ops } from "../../src/runtime/internal.js";
-import { assertCodeEqual, createCode } from "./codeHelpers.js";
+import {
+  assertCodeEqual,
+  assertCodeLocations,
+  createCode,
+} from "./codeHelpers.js";
 
 describe("optimize", () => {
   test("change local references to context references", () => {
@@ -155,8 +159,8 @@ describe("optimize", () => {
     test("global reference", () => {
       // Compilation of `Math` where Math is a global variable
       const code = createCode([markers.traverse, [markers.reference, "Math"]]);
-      const globals = { Math: null }; // value doesn't matter
-      const expected = [globals, "Math"];
+      const globals = { Math: {} }; // value doesn't matter
+      const expected = globals.Math;
       assertCodeEqual(optimize(code, { globals }), expected);
     });
 
@@ -167,7 +171,7 @@ describe("optimize", () => {
         [markers.reference, "Math.PI"],
       ]);
       const globals = { Math: { PI: null } }; // value doesn't matter
-      const expected = [[globals, "Math"], "PI"];
+      const expected = [globals.Math, "PI"];
       assertCodeEqual(optimize(code, { globals }), expected);
     });
 
@@ -277,5 +281,6 @@ function assertCompile(expression, expected, mode = "shell") {
   const globals = new ObjectTree({});
   const fn = compile.expression(expression, { globals, mode, parent });
   const actual = fn.code;
+  assertCodeLocations(actual);
   assertCodeEqual(actual, expected);
 }

package/test/compiler/parse.test.js

@@ -3,7 +3,7 @@ import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
 import { markers } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
-import { assertCodeEqual } from "./codeHelpers.js";
+import { assertCodeEqual, assertCodeLocations } from "./codeHelpers.js";
 
 describe("Origami parser", () => {
   test("additiveExpression", () => {
@@ -1596,16 +1596,8 @@ function assertParse(
   assertCodeEqual(code, expected);
 }
 
-function assertCodeLocations(code) {
-  assert(code.location, "no location");
-  for (const item of code) {
-    if (Array.isArray(item)) {
-      assertCodeLocations(item);
-    }
-  }
-}
-
 function assertThrows(startRule, source, message, position, mode = "shell") {
+  // @ts-ignore We declare this so we can inspect it in debugger
   let code;
   try {
     code = parse(source, {

package/test/runtime/expressionObject.test.js

@@ -54,7 +54,7 @@ describe("expressionObject", () => {
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
     const parent = new ObjectTree({});
-    parent.handlers = {
+    /** @type {any} */ (parent).handlers = {
       "json.handler": {
         unpack: JSON.parse,
       },

package/test/runtime/ops.test.js

@@ -358,7 +358,7 @@ describe("ops", () => {
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope.call(b);
-      assert.equal(await scope.get("c"), 1);
+      assert.equal(await scope?.get("c"), 1);
     });
 
     test("accepts an optional context", async () => {
@@ -372,7 +372,7 @@ describe("ops", () => {
       const a = await tree.get("a");
       const b = await a.get("b");
       const scope = await ops.scope.call(b, tree);
-      assert.equal(await scope.get("c"), 1);
+      assert.equal(await scope?.get("c"), 1);
     });
   });