@weborigami/language 0.6.3 → 0.6.5

package/main.js

@@ -12,6 +12,7 @@ export { formatError, highlightError } from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
+export { default as expressionObject } from "./src/runtime/expressionObject.js";
 export * from "./src/runtime/handleExtension.js";
 export { default as handleExtension } from "./src/runtime/handleExtension.js";
 export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.3",
+    "@weborigami/async-tree": "0.6.5",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -47,9 +47,9 @@ export default function optimize(code, options = {}) {
       return resolvePath(code, globals, parent, locals, cache);
 
     case ops.lambda:
-      const parameters = args[0];
+      const parameters = args[1];
       if (parameters.length > 0) {
-        const paramNames = parameters.map((param) => param[1]);
+        const paramNames = parameters.map((param) => param[0]);
         locals.push({
           type: REFERENCE_PARAM,
           names: paramNames,
@@ -62,7 +62,10 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const propertyNames = entries.map((entry) => entryKey(entry));
+      // Filter out computed property keys when determining local variables
+      const propertyNames = entries
+        .map((entry) => entryKey(entry))
+        .filter((key) => key !== null);
       locals.push({
         type: REFERENCE_INHERITED,
         names: propertyNames,
@@ -73,22 +76,21 @@ export default function optimize(code, options = {}) {
   // Optimize children
   const optimized = annotate(
     code.map((child, index) => {
-      // Don't optimize lambda parameter names
-      if (op === ops.lambda && index === 1) {
-        return child;
-      } else if (op === ops.object && index > 0) {
+      if (op === ops.object && index > 0) {
         const [key, value] = child;
         const adjustedLocals = avoidLocalRecursion(locals, key);
-        return annotate(
-          [
-            key,
-            optimize(/** @type {AnnotatedCode} */ (value), {
-              ...options,
-              locals: adjustedLocals,
-            }),
-          ],
-          child.location
-        );
+        const optimizedKey =
+          typeof key === "string"
+            ? key
+            : optimize(/** @type {AnnotatedCode} */ (key), {
+                ...options,
+                locals: adjustedLocals,
+              });
+        const optimizedValue = optimize(/** @type {AnnotatedCode} */ (value), {
+          ...options,
+          locals: adjustedLocals,
+        });
+        return annotate([optimizedKey, optimizedValue], child.location);
       } else if (Array.isArray(child) && "location" in child) {
         // Review: Aside from ops.object (above), what non-instruction arrays
         // does this descend into?

package/src/compiler/origami.pegjs

@@ -18,8 +18,10 @@ import {
   makeArray,
   makeBinaryOperation,
   makeCall,
+  makeCallChain,
   makeDeferredArguments,
   makeDocument,
+  makeLambda,
   makeObject,
   makePath,
   makePipeline,
@@ -83,7 +85,7 @@ arguments "function arguments"
   / pathArguments
   / propertyAccess
   / computedPropertyAccess
-  // / optionalChaining
+  / optional
   / templateLiteral
 
 arrayLiteral "array"
@@ -100,18 +102,18 @@ arrayEntries
 arrayEntry
   = spreadElement
   / pipelineExpression
-  // JavaScript treats a missing value as `undefined`
-  / __ !"]" {
+  / &separator {
+      // Missing value is allowed
       return annotate([ops.literal, undefined], location());
     }
 
 arrowFunction
-  = ("async" __)? "(" __ parameters:parameterList? __ ")" __ doubleArrow __ pipeline:expectPipelineExpression {
-      const lambdaParameters = parameters ?? annotate([], location());
-      return annotate([ops.lambda, lambdaParameters, pipeline], location());
+  = ("async" __)? "(" __ parameters:paramList? __ ")" __ doubleArrow __ body:expectPipelineExpression {
+      parameters ??= annotate([], location());
+      return makeLambda(parameters, body, location());
     }
-  / parameter:parameterSingleton __ doubleArrow __ pipeline:expectPipelineExpression {
-      return annotate([ops.lambda, parameter, pipeline], location());
+  / parameters:paramSingleton __ doubleArrow __ body:expectPipelineExpression {
+      return makeLambda(parameters, body, location());
     }
   / conditionalExpression
 
@@ -143,10 +145,7 @@ bitwiseXorOperator
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
   = head:uriExpression tail:arguments* {
-      return tail.reduce(
-        (target, args) => makeCall(target, args, location()),
-        head
-      );
+      return makeCallChain(head, tail, location());
     }
 
 // A comma-separated list of expressions: `x, y, z`
@@ -168,9 +167,9 @@ computedPropertyAccess
       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.
+// A space before a computed property access. This is allowed when 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 __
@@ -191,9 +190,6 @@ conditionalExpression
         deferred[1]
       ], location());
     }
-  
-digits
-  = @[0-9]+
 
 doubleArrow = "⇒" / "=>"
 
@@ -271,7 +267,13 @@ expectFrontDelimiter
       error("Expected \"---\"");
     }
 
-expectGuillemet
+expectLeftGuillemet
+  = '«'
+  / .? {
+      error("Expected closing guillemet");
+    }
+
+expectRightGuillemet
   = '»'
   / .? {
       error("Expected closing guillemet");
@@ -305,11 +307,6 @@ exponentiationExpression
 expression
   = __ @commaExpression __
 
-floatLiteral "floating-point number"
-  = digits? "." digits {
-      return annotate([ops.literal, parseFloat(text())], location());
-    }
-
 // Marker for the beginning or end of front matter
 frontDelimiter
   = "---\n"
@@ -338,19 +335,22 @@ group "parenthetical group"
   }
 
 guillemetString "guillemet string"
-  = '«' chars:guillemetStringChar* expectGuillemet {
-    return annotate([ops.literal, chars.join("")], location());
-  }
+  = "«" chars:guillemetStringChar* expectRightGuillemet {
+      return annotate([ops.literal, chars.join("")], location());
+    }
+  / "»" chars:guillemetStringChar* expectLeftGuillemet {
+      return annotate([ops.literal, chars.join("")], location());
+    }
 
 guillemetStringChar
-  = !('»' / newLine) @textChar
+  = !("«" / "»" / newLine) @textChar
 
 // A host identifier that may include a colon and port number: `example.com:80`.
 // This is used as a special case at the head of a path, where we want to
 // interpret a colon as part of a text identifier.
 host "HTTP/HTTPS host"
-  = name:hostname port:(":" @integerLiteral)? slashFollows:slashFollows? {
-      const portText = port ? `:${port[1]}` : "";
+  = name:hostname port:port? slashFollows:slashFollows? {
+      const portText = port ?? "";
       const slashText = slashFollows ? "/" : "";
       const host = name + portText + slashText;
       return annotate([ops.literal, host], location());
@@ -383,26 +383,32 @@ identifierPart "JavaScript identifier continuation"
 identifierStart "JavaScript identifier start"
   = char:. &{ return char.match(/[$_\p{ID_Start}]/u) }
 
-implicitParenthesesCallExpression "function call with implicit parentheses"
-  = head:arrowFunction args:(inlineSpace+ @implicitParensthesesArguments)? {
-      return args ? makeCall(head, args, location()) : head;
+// A single argument for an implicit parens call. This differs from
+// `parenthesesArgument` in that the term can't be a pipeline.
+implicitParenthesesArgument
+  = "..." arg:shorthandFunction {
+      return annotate([markers.spread, arg], location());
+    }
+  / shorthandFunction
+
+// A separated list of arguments for an implicit parens call.
+implicitParenthesesArgumentList "list"
+  = args:implicitParenthesesArgument|1.., separator| separator? {
+      return annotate(args, location());
     }
     
-// A separated list of values for an implicit parens call. This differs from
-// `list` in that the value term can't be a pipeline.
-implicitParensthesesArguments
-  = shellMode values:shorthandFunction|1.., separator| separator? {
-      return annotate(values, location());
+// A separated list of values for an implicit parens call. 
+implicitParenthesesArguments
+  = shellMode inlineSpace+ @implicitParenthesesArgumentList
+
+implicitParenthesesCallExpression "function call with implicit parentheses"
+  = head:arrowFunction args:implicitParenthesesArguments? {
+      return args ? makeCall(head, args, location()) : head;
     }
 
 inlineSpace
   = [ \t]
 
-integerLiteral "integer"
-  = digits {
-      return annotate([ops.literal, parseInt(text())], location());
-    }
-
 // A key in a path or an expression that looks like one
 key
   = keyCharStart keyChar* {
@@ -426,16 +432,10 @@ keyChar
 keyCharStart
   // All JS identifier characters
   = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
-  / "."
+  / "." !".." // a dot, but not a spread/rest operator
   / "@"
   / "~"
 
-// A separated list of values
-list "list"
-  = values:pipelineExpression|1.., separator| separator? {
-      return annotate(values, location());
-    }
-
 logicalAndExpression
   = head:bitwiseOrExpression tail:(__ "&&" __ @bitwiseOrExpression)* {
       return tail.length === 0
@@ -491,10 +491,52 @@ newLine
   / "\r\n"
   / "\r"
 
+number
+  = numberBigInt
+  / numberStandard {
+      const stripped = text().replace("_", ""); // remove underscores
+      return Number(stripped);
+    }
+
+numberBigInt
+  = digits:numberDecimalDigits "n"  {
+      const stripped = digits.replace("_", ""); // remove underscores
+      return BigInt(stripped);
+    }
+
+numberBinary
+  = "0" [bB] digits:[01_]+
+
+numberDecimal
+  = numberDecimalDigits? "." numberDecimalDigits numberExponent?
+  / numberDecimalDigits numberExponent?
+
+numberDecimalDigits
+  = [0-9]([_]*[0-9])* {
+    return text();
+  }
+
+numberExponent
+  = [eE] [+\-]? digits:numberDecimalDigits
+
+numberHex
+  = "0" [xX] digits:[0-9a-fA-F_]+
+
 // A number
-numericLiteral "number"
-  = floatLiteral
-  / integerLiteral
+numberLiteral "number"
+  = number:number {
+      return annotate([ops.literal, number], location());
+    }
+
+numberOctal
+  = "0" [oO] digits:[0-7]+
+
+// Any number that can be parsed with Number(); i.e., not a bigint
+numberStandard
+  = numberBinary
+  / numberOctal
+  / numberHex
+  / numberDecimal
 
 nullishCoalescingExpression
   = head:logicalAndExpression tail:(__ "??" __ @logicalAndExpression)* {
@@ -561,7 +603,8 @@ objectShorthandProperty "object identifier"
     }
 
 objectPublicKey
-  = key:key slash:"/"? {
+  = "[" __ @pipelineExpression __ expectClosingBracket
+  / key:key slash:"/"? {
       return text();
     }
   / string:stringLiteral {
@@ -569,31 +612,144 @@ objectPublicKey
       return string[1];
     }
 
-optionalChaining
-  = __ "?." __ property:identifier {
-      return annotate([ops.optionalTraverse, property], location());
+// Optional chaining
+optional
+  = __ "?." args:parenthesesArguments {
+      return annotate([ops.optional, args], location());
+    }
+  / __ "?." access:computedPropertyAccess {
+      return annotate([ops.optional, access], location());
+    }
+  / __ "?." whitespaceOptionalForProgram property:identifierLiteral {
+      const propertyAccess = annotate([markers.property, property], location());
+      return annotate([ops.optional, propertyAccess], location());
+    }
+
+paramArray
+  = "[" __ entries:paramArrayEntries __ "]" {
+      return annotate([markers.paramArray, ...entries], location());
+    }
+
+// A list of parameters inside array destructuring: `a, b` in `([a, b]) => a + b`
+// Different than top-level parameters because elements can be elided: `a, , b`
+paramArrayEntries
+  = entries:paramArrayEntry|1.., separator| rest:(separator @paramRest?)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
     }
 
-// Name of a unction parameter
-parameter
+// Single parameter in a function's parameter list
+param
+  = paramNameWithInitilializer
+  / pattern:paramBindingPattern initializer:paramInitializer? {
+      return initializer
+        ? annotate([markers.paramInitializer, pattern, initializer], location())
+        : pattern;
+    }
+
+paramArrayEntry
+  = param
+  / &separator {
+      // Missing value is allowed
+      return undefined;
+    }
+
+paramBindingPattern
+  = paramArray
+  / paramObject
+
+paramInitializer
+  = __ "=" __ @pipelineExpression
+
+// A list of lambda parameters inside the parentheses: `a, b` in `(a, b) => a + b`
+paramList
+  = entries:param|1.., separator| rest:(separator @paramRest?)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
+    }
+
+// A single name in a parameter list: `a` in `a, b`
+paramName
   = key:key {
-      return annotate([ops.literal, key], location());
+      return annotate([markers.paramName, key], location());
+    }
+
+paramNameWithInitilializer
+  = name:paramName initializer:paramInitializer? {
+      return initializer
+        ? annotate([markers.paramInitializer, name, initializer], location())
+        : name;
+    }
+
+// Object binding pattern in function parameter: `{ a, b: c }`
+paramObject
+  = "{" __ entries:paramObjectEntries? __ "}" {
+      return annotate([markers.paramObject, ...(entries ?? [])], location());
     }
 
-parameterList
-  = list:parameter|1.., separator| separator? {
-      return annotate(list, location());
+// A separated list of parameter object entries inside the curly braces
+paramObjectEntries
+  = entries:paramObjectEntry|1.., separator| rest:(separator @paramRest)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
     }
 
-// A list with a single identifier
-parameterSingleton
-  = param:parameter {
+// An entry in a parameter object: `a: b` in `{ a: b }`
+paramObjectEntry
+  = key:objectPublicKey __ ":" __ param:param {
+      return annotate([key, param], location());
+    }
+  / name:paramName initializer:paramInitializer? {
+      const binding = initializer
+        ? annotate([markers.paramInitializer, name, initializer], location())
+        : name;
+      return annotate([name[1], binding], location());
+    }
+
+// Optional rest parameter for param array or object
+paramRest
+  = "..." __ param:param {
+    return annotate([markers.paramRest, param], location());
+    }
+
+// A lambda parameter list with a single identifier with no parentheses:
+// `x` in `x => x + 1`
+paramSingleton
+  = param:paramName {
       return annotate([param], location());
     }
 
+// A single argument inside parentheses
+parenthesesArgument
+  = "..." arg:pipelineExpression {
+      return annotate([markers.spread, arg], location());
+    }
+  / pipelineExpression
+
+// A separated list of arguments inside parentheses
+parenthesesArgumentList "list"
+  = args:parenthesesArgument|1.., separator| separator? {
+      return annotate(args, location());
+    }
+
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
-  = "(" __ list:list? __ expectClosingParenthesis {
+  = inlineSpace* "(" __ list:parenthesesArgumentList? __ expectClosingParenthesis {
       return annotate(list ?? [undefined], location());
     }
 
@@ -635,6 +791,11 @@ pipelineExpression
       );
     }
 
+port
+  = ":" [0-9]+ {
+    return text();
+  }
+
 primary
   // The following start with distinct characters
   = stringLiteral
@@ -646,7 +807,7 @@ primary
   / templateLiteral
 
   // These are more ambiguous
-  / @numericLiteral !keyChar // numbers + chars would be a key
+  / @numberLiteral !keyChar // numbers + chars would be a key
   / pathLiteral
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
@@ -716,15 +877,13 @@ shiftOperator
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
-  = (shellMode / programMode) "=" !"=" __ definition:implicitParenthesesCallExpression {
+  = (shellMode / programMode) "=" !"=" __ body:implicitParenthesesCallExpression {
       if (options.mode === "program") {
         throw new Error("Parse error: shorthand function syntax isn't allowed in Origami programs. Use arrow syntax instead.");
       }
-      const lambdaParameters = annotate(
-        [annotate([ops.literal, "_"], location())],
-        location()
-      );
-      return annotate([ops.lambda, lambdaParameters, definition], location());
+      const underscore = annotate([markers.paramName, "_"], location());
+      const parameters = annotate([underscore], location());
+      return makeLambda(parameters, body, location());
     }
   / implicitParenthesesCallExpression
 
@@ -764,7 +923,7 @@ slashFollows
 
 spreadElement
   = ellipsis __ value:expectPipelineExpression {
-      return annotate([ops.spread, value], location());
+      return annotate([markers.spread, value], location());
     }
 
 stringLiteral "string"
@@ -799,11 +958,9 @@ templateDocument "template document"
       if (options.front) {
         return makeDocument(options.front, body, location());
       }
-      const lambdaParameters = annotate(
-        [annotate([ops.literal, "_"], location())],
-        location()
-      );
-      return annotate([ops.lambda, lambdaParameters, body], location());
+      const underscore = annotate([markers.paramName, "_"], location());
+      const parameters = annotate([underscore], location());
+      return makeLambda(parameters, body, location());
     }
 
 // A backtick-quoted template literal