@weborigami/language 0.3.3-jse.3 → 0.3.4-jse.4

package/src/compiler/origami.pegjs

@@ -15,16 +15,14 @@ import * as ops from "../runtime/ops.js";
 import {
   annotate,
   applyMacro,
-  downgradeReference,
   makeArray,
   makeBinaryOperation,
   makeCall,
   makeDeferredArguments,
   makeDocument,
-  makeJsPropertyAccess,
   makeObject,
+  makePath,
   makePipeline,
-  makeProperty,
   makeTemplate,
   makeUnaryOperation,
   makeYamlObject,
@@ -41,58 +39,51 @@ __
   }
 
 additiveExpression
-  = head:multiplicativeExpression tail:(whitespaceShell @additiveOperator whitespaceShell @multiplicativeExpression)* {
+  = head:multiplicativeExpression tail:(whitespace @additiveOperator whitespace @multiplicativeExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
 additiveOperator
   = "+"
-  / "-"
+  / minus
 
 angleBracketLiteral
-  = "<" __ protocol:angleBracketProtocol "//"? path:angleBracketPath __ ">" {
-    return annotate([protocol, ...path], location());
+  = "<" scheme:uriScheme "//"? path:angleBracketPath ">" {
+    return annotate([scheme, ...path], location());
     }
-  / "<" __ "/" path:angleBracketPath __ ">" {
-      const root = annotate([ops.rootDirectory], location());
-      return path.length > 0 ? annotate([root, ...path], location()) : root;
+  / "</" path:angleBracketPath ">" {
+      const external = annotate([markers.external, "/"], location());
+      return annotate([markers.traverse, external, ...path], location());
     }
-  / "<" __ "~" "/"? path:angleBracketPath __ ">" {
-      const home = annotate([ops.homeDirectory], location());
-      return path.length > 0 ? annotate([home, ...path], location()) : home;
-    }
-  / "<" __ path:angleBracketPath __ ">" {
-      // Angle bracket paths always reference scope
-      const scope = annotate([ops.scope], location());
-      return annotate([scope, ...path], location());
+  / "<" path:angleBracketPath ">" {
+      const [head, ...tail] = path;
+      const external = annotate([markers.external, head[1]], location());
+      return annotate([markers.traverse, external, ...tail], location());
     }
 
 angleBracketPath
-  = @angleBracketPathKey|0.., "/"| "/"?
+  = @angleBracketKey|0.., "/"| "/"?
 
-angleBracketPathKey
+// Single key in an angle bracket path, possibly with a trailing slash
+angleBracketKey
   = chars:angleBracketPathChar+ slashFollows:slashFollows? {
       // Append a trailing slash if one follows (but don't consume it)
       const key = chars.join("") + (slashFollows ? "/" : "");
       return annotate([ops.literal, key], location());
     }
 
-// A single character in a slash-separated path segment
+// A single character in an angle bracket key
 angleBracketPathChar
-  = [^/:<>] // Much more permissive than an identifier
+  // Accept anything that doesn't end the angle bracket key or path
+  = [^/>\t\n\r]
   / escapedChar
 
-angleBracketProtocol
-  = protocol:jsIdentifier ":" {
-      return annotate([markers.global, `${protocol[1]}:`], location());
-    }
-
 arguments "function arguments"
   = parenthesesArguments
-  / shellMode @pathArguments
-  / jsPropertyAccess
+  / pathArguments
+  / propertyAccess
   / computedPropertyAccess
-  / optionalChaining
+  // / optionalChaining
   / templateLiteral
 
 arrayLiteral "array"
@@ -125,7 +116,7 @@ arrowFunction
   / conditionalExpression
 
 bitwiseAndExpression
-  = head:equalityExpression tail:(__ @bitwiseAndOperator __ @equalityExpression)* {
+  = head:equalityExpression tail:(whitespace @bitwiseAndOperator whitespace @equalityExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -133,7 +124,7 @@ bitwiseAndOperator
   = @"&" !"&"
 
 bitwiseOrExpression
-  = head:bitwiseXorExpression tail:(__ @bitwiseOrOperator __ @bitwiseXorExpression)* {
+  = head:bitwiseXorExpression tail:(whitespace @bitwiseOrOperator whitespace @bitwiseXorExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -141,7 +132,7 @@ bitwiseOrOperator
   = @"|" !"|"
 
 bitwiseXorExpression
-  = head:bitwiseAndExpression tail:(__ @bitwiseXorOperator __ @bitwiseAndExpression)* {
+  = head:bitwiseAndExpression tail:(whitespace @bitwiseXorOperator whitespace @bitwiseAndExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -151,8 +142,11 @@ bitwiseXorOperator
 // A function call: `fn(arg)`, possibly part of a chain of function calls, like
 // `fn(arg1)(arg2)(arg3)`.
 callExpression "function call"
-  = head:protocolExpression tail:arguments* {
-      return tail.reduce((target, args) => makeCall(target, args, options.mode), head);
+  = head:uriExpression tail:arguments* {
+      return tail.reduce(
+        (target, args) => makeCall(target, args, location()),
+        head
+      );
     }
 
 // A comma-separated list of expressions: `x, y, z`
@@ -171,7 +165,7 @@ comment "comment"
 
 computedPropertyAccess
   = __ "[" expression:expression expectClosingBracket {
-      return annotate([markers.traverse, expression], location());
+      return annotate([markers.property, expression], location());
     }
 
 conditionalExpression
@@ -185,9 +179,9 @@ conditionalExpression
       const deferred = makeDeferredArguments(tail);
       return annotate([
         ops.conditional,
-        downgradeReference(condition),
-        downgradeReference(deferred[0]),
-        downgradeReference(deferred[1])
+        condition,
+        deferred[0],
+        deferred[1]
       ], location());
     }
   
@@ -289,7 +283,7 @@ expectPipelineExpression
     }
 
 exponentiationExpression
-  = left:unaryExpression right:(__ "**" __ @exponentiationExpression)? {
+  = left:unaryExpression right:(whitespace "**" whitespace @exponentiationExpression)? {
       return right ? annotate([ops.exponentiation, left, right], location()) : left;
     }
 
@@ -326,7 +320,7 @@ frontMatterYaml "YAML front matter"
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
   = "(" expression:expression expectClosingParenthesis {
-    return annotate(downgradeReference(expression), location());
+    return annotate(expression, location());
   }
 
 guillemetString "guillemet string"
@@ -337,34 +331,47 @@ guillemetString "guillemet string"
 guillemetStringChar
   = !('»' / newLine) @textChar
 
-// The user's home directory: `~`
-homeDirectory
-  = "~" {
-      return annotate([ops.homeDirectory], location());
-    }
-
 // 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"
-  = identifier:identifier port:(":" @integerLiteral)? slashFollows:slashFollows? {
-    const portText = port ? `:${port[1]}` : "";
-    const slashText = slashFollows ? "/" : "";
-    const hostText = identifier + portText + slashText;
-    return annotate([ops.literal, hostText], location());
+  = name:hostname port:(":" @integerLiteral)? slashFollows:slashFollows? {
+      const portText = port ? `:${port[1]}` : "";
+      const slashText = slashFollows ? "/" : "";
+      const host = name + portText + slashText;
+      return annotate([ops.literal, host], location());
+    }
+
+hostname
+  = key {
+    return text();
   }
 
-identifier "identifier"
-  = chars:identifierChar+ { return chars.join(""); }
+// JavaScript-compatible identifier
+identifier
+  = id:$( identifierStart identifierPart* ) {
+    return id;
+  }
 
-identifierChar
-  = [^(){}\[\]<>\?!\|\-=,/:\`"'«»\\→⇒… \t\n\r] // No unescaped whitespace or special chars
-  / @'-' !'>' // Accept a hyphen but not in a single arrow combination
-  / escapedChar
+// Identifier as a literal
+identifierLiteral
+  = id:identifier {
+      return annotate([ops.literal, id], location());
+    }
+
+// Continuation of a JavaScript identifier
+// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierPart
+identifierPart "JavaScript identifier continuation"
+  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
+
+// Start of a JavaScript identifier
+// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierStart
+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, options.mode) : head;
+      return args ? makeCall(head, args, location()) : head;
     }
     
 // A separated list of values for an implicit parens call. This differs from
@@ -382,33 +389,32 @@ integerLiteral "integer"
       return annotate([ops.literal, parseInt(text())], location());
     }
 
-jseMode
-  = &{ return options.mode === "jse" }
-
-jsIdentifier
-  = id:$( jsIdentifierStart jsIdentifierPart* ) {
-    return annotate([ops.literal, id], location());
+// A key in a path or an expression that looks like one
+key
+  = keyCharStart keyChar* {
+    return text();
   }
 
-// Continuation of a JavaScript identifier
-// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierPart
-jsIdentifierPart "JavaScript identifier continuation"
-  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
-
-// Start of a JavaScript identifier
-// https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-IdentifierStart
-jsIdentifierStart "JavaScript identifier start"
-  = char:. &{ return char.match(/[$_\p{ID_Start}]/u) }
-
-jsPropertyAccess
-  = __ "." __ property:jsIdentifier {
-    return annotate([markers.traverse, property], location());
-  }
+// Character after the first in a key
+keyChar
+  = keyCharStart
+  // Also allow some math operators (not slash)
+  / "!"
+  / "+"
+  / minus
+  / "*"
+  / "%"
+  / "&"
+  / "|"
+  / "^"
 
-jsReference "identifier reference"
-  = id:jsIdentifier {
-      return annotate([markers.reference, id], location());
-    }
+// First character in a key
+keyCharStart
+  // All JS identifier characters
+  = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
+  / "."
+  / "~"
+  / "@"
 
 // A separated list of values
 list "list"
@@ -421,7 +427,7 @@ logicalAndExpression
       return tail.length === 0
         ? head
         : annotate(
-          [ops.logicalAnd, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.logicalAnd, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
@@ -431,16 +437,22 @@ logicalOrExpression
       return tail.length === 0
         ? head
         : annotate(
-          [ops.logicalOr, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.logicalOr, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
 
+// Unary or binary minus operator
+minus
+  // Don't match a front matter delimiter or pipeline operator. For some reason,
+  // the negative lookahead !"--\n" doesn't work.
+  = @"-" !"-\n" !">"
+
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
 multiplicativeExpression
-  = head:exponentiationExpression tail:(whitespaceShell @multiplicativeOperator whitespaceShell @exponentiationExpression)* {
+  = head:exponentiationExpression tail:(whitespace @multiplicativeOperator whitespace @exponentiationExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -449,19 +461,13 @@ multiplicativeOperator
   / "/"
   / "%"
 
-// A namespace reference is a string of letters only, followed by a colon.
-namespace
-  = chars:[A-Za-z]+ ":" {
-    return annotate([markers.global, chars.join("") + ":"], location());
-  }
-
 // A new expression: `new Foo()`
 newExpression
-  = "new" __ head:jsReference tail:parenthesesArguments {
+  = "new" __ head:pathLiteral tail:parenthesesArguments? {
       const args = tail?.[0] !== undefined ? tail : [];
       return annotate([ops.construct, head, ...args], location());
     }
-  / "new:" head:jsReference tail:parenthesesArguments {
+  / "new:" head:pathLiteral tail:parenthesesArguments {
       const args = tail?.[0] !== undefined ? tail : [];
       return annotate([ops.construct, head, ...args], location());
     }
@@ -481,7 +487,7 @@ nullishCoalescingExpression
       return tail.length === 0
         ? head
         : annotate(
-          [ops.nullishCoalescing, downgradeReference(head), ...makeDeferredArguments(tail)],
+          [ops.nullishCoalescing, head, ...makeDeferredArguments(tail)],
           location()
         );
     }
@@ -507,10 +513,8 @@ objectEntry
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
   = key:objectKey __ "=" __ pipeline:expectPipelineExpression {
-      return annotate(
-        makeProperty(key, annotate([ops.getter, pipeline], location())),
-        location()
-      );
+      const getter = annotate([ops.getter, pipeline], location());
+      return annotate([key, getter], location());
     }
 
 objectHiddenKey
@@ -523,16 +527,17 @@ objectKey "object key"
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
   = key:objectKey __ ":" __ pipeline:expectPipelineExpression {
-      return annotate(makeProperty(key, pipeline), location());
+      return annotate([key, pipeline], location());
     }
 
 // A shorthand reference inside an object literal: `foo`
 objectShorthandProperty "object identifier"
   = key:objectPublicKey {
       const reference = annotate([markers.reference, key], location());
-      return annotate([key, reference], location());
+      const traverse = annotate([markers.traverse, reference], location());
+      return annotate([key, traverse], location());
     }
-  / jseMode path:angleBracketLiteral {
+  / path:angleBracketLiteral {
     let lastKey = path.at(-1);
     if (lastKey instanceof Array) {
       lastKey = lastKey[1]; // get scope identifier or literal
@@ -541,23 +546,23 @@ objectShorthandProperty "object identifier"
   }
 
 objectPublicKey
-  = identifier:identifier slash:"/"? {
-      return identifier + (slash ?? "");
-    }
+  = key:key slash:"/"? {
+    return text();
+  }
   / string:stringLiteral {
       // Remove `ops.literal` from the string code
       return string[1];
     }
 
 optionalChaining
-  = __ "?." __ property:jsIdentifier {
+  = __ "?." __ property:identifier {
     return annotate([ops.optionalTraverse, property], location());
   }
-  
+
+// Name of a unction parameter
 parameter
-  = jseMode @jsIdentifier
-  / shellMode identifier:identifier {
-      return annotate([ops.literal, identifier], location());
+  = key:key {
+      return annotate([ops.literal, key], location());
     }
 
 parameterList
@@ -567,11 +572,8 @@ parameterList
 
 // A list with a single identifier
 parameterSingleton
-  = identifier:identifier {
-      return annotate(
-        [annotate([ops.literal, identifier], location())],
-        location()
-      );
+  = param:parameter {
+      return annotate([param], location());
     }
 
 // Function arguments in parentheses
@@ -580,90 +582,66 @@ parenthesesArguments "function arguments in parentheses"
       return annotate(list ?? [undefined], location());
     }
 
-// A slash-separated path of keys: `a/b/c`
-path "slash-separated path"
-  // Path with at least a tail
-  = segments:pathSegment|1..| {
-      // Drop empty segments that represent consecutive or final slashes
-      segments = segments.filter(segment => segment);
-      return annotate(segments, location());
-    }
-
-// A slash-separated path of keys that follows a call target
+// A slash-separated path of keys that follows a call target, such as the path
+// after the slash in `(x)/y/z`
 pathArguments
-  = path:path {
-      return annotate([markers.traverse, ...path], location());
+  = "/" keys:pathKeys? {
+      const args = keys ?? [];
+      return annotate([markers.traverse, ...args], location());
     }
 
-// A single key in a slash-separated path: `/a`
-pathKey
-  = chars:pathSegmentChar+ slashFollows:slashFollows? {
-    // Append a trailing slash if one follows (but don't consume it)
-    const key = chars.join("") + (slashFollows ? "/" : "");
-    return annotate([ops.literal, key], location());
-  }
+// Sequence of keys that may each have trailing slashes
+pathKeys
+  = pathSegment|1..|
+  
+// A path without angle brackets
+pathLiteral
+  = keys:pathKeys {
+      return makePath(keys);
+    }
 
+// A path key with an optional trailing slash
 pathSegment
-  = "/" @pathKey?
-
-// A single character in a slash-separated path segment
-pathSegmentChar
-  // This is more permissive than an identifier. It allows some characters like
-  // brackets or quotes that are not allowed in identifiers.
-  = [^(){}\[\],:/\\ \t\n\r]
-  / escapedChar
+  = key:key "/"? {
+      return annotate([ops.literal, text()], location());
+    }
+  // A single slash is a path key
+  / "/" {
+      return annotate([ops.literal, text()], location());
+    }
 
 // A pipeline that starts with a value and optionally applies a series of
 // functions to it.
 pipelineExpression
   = head:shorthandFunction tail:(__ singleArrow __ @shorthandFunction)* {
       return annotate(
-        tail.reduce((arg, fn) => makePipeline(arg, fn, options.mode), downgradeReference(head)),
+        tail.reduce((arg, fn) => makePipeline(arg, fn, location()), head),
         location()
       );
     }
 
 primary
-  = numericLiteral
-  / stringLiteral
+  // The following start with distinct characters
+  = stringLiteral
   / arrayLiteral
   / objectLiteral
   / group
-  / templateLiteral
-  / shellMode @primaryShell
-  / jseMode @primaryJse
-
-// Primary allowed in JSE mode
-primaryJse
-  = angleBracketLiteral
-  / jsReference
+  / angleBracketLiteral
   / regexLiteral
+  / templateLiteral
 
-primaryShell
-  = rootDirectory
-  / homeDirectory
-  / qualifiedReference
-  / namespace
-  / scopeReference
+  // These are more ambiguous
+  / @numericLiteral !keyChar // numbers + chars would be a key
+  / pathLiteral
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
 program "Origami program"
   = shebang? @expression
 
-// Protocol with double-slash path: `https://example.com/index.html`
-protocolExpression
-  = fn:namespace "//" host:(host / slash) path:path? {
-      const keys = annotate([host, ...(path ?? [])], location());
-      return makeCall(fn, keys, options.mode);
-    }
-  / newExpression
-  / primary
-
-// A namespace followed by a key: `foo:x`
-qualifiedReference
-  = fn:namespace reference:scopeReference {
-      return makeCall(fn, [reference[1]], options.mode);
-    }
+propertyAccess
+  = __ "." __ property:identifierLiteral {
+    return annotate([markers.property, property], location());
+  }
 
 regexFlags
   = flags:[gimuy]* {
@@ -695,19 +673,6 @@ relationalOperator
   / ">="
   / ">"
 
-// The root folder: `/`
-rootDirectory
-  = &("/" !"/") {
-      return annotate([ops.rootDirectory], location());
-    }
-
-scopeReference "scope reference"
-  = identifier:identifier slashFollows:slashFollows? {
-      const id = identifier + (slashFollows ? "/" : "");
-      const idCode = annotate([ops.literal, identifier], location());
-      return annotate([markers.reference, idCode], location());
-    }
-
 separator
   = __ "," __
   / @whitespaceWithNewLine
@@ -761,6 +726,12 @@ slash
     return annotate([ops.literal, "/"], location());
   }
 
+// One or more consecutive slashes
+slashes
+  = "/"+ {
+      return annotate([ops.literal, "/"], location());
+    }
+
 // Check whether next character is a slash without consuming input
 slashFollows
   // This expression returned `undefined` if successful; we convert to `true`
@@ -796,13 +767,16 @@ templateBodyText "template text"
 
 templateDocument "template document"
   = front:frontMatterExpression __ body:templateBody {
-      const macroName = options.mode === "jse" ? "_template" : "@template";
+      const macroName = text().includes("@template") ? "@template" : "_template";
       return annotate(applyMacro(front, macroName, body), location());
     }
   / front:frontMatterYaml body:templateBody {
-      return makeDocument(options.mode, front, body, location());
+      return makeDocument(front, body, location());
     }
   / body:templateBody {
+      if (options.front) {
+        return makeDocument(options.front, body, location());
+      }
       const lambdaParameters = annotate(
         [annotate([ops.literal, "_"], location())],
         location()
@@ -813,8 +787,7 @@ templateDocument "template document"
 // A backtick-quoted template literal
 templateLiteral "template literal"
   = "`" head:templateLiteralText tail:(templateSubstitution templateLiteralText)* expectBacktick {
-      const op = options.mode === "jse" ? ops.templateStandard : ops.templateTree;
-      return makeTemplate(op, head, tail, location());
+      return makeTemplate(ops.templateTree, head, tail, location());
     }
 
 templateLiteralChar
@@ -838,29 +811,69 @@ textChar
 
 // A unary prefix operator: `!x`
 unaryExpression
-  = operator:unaryOperator __ expression:unaryExpression {
+  = operator:unaryOperator __ expression:expectExpression {
       return makeUnaryOperation(operator, expression, location());
     }
   / callExpression
 
+// URI
+uri
+  // Double slashes after colon: `https://example.com/index.html`
+  = scheme:uriScheme "//" host:host path:("/" uriPath)? {
+      const rest = path ? path[1] : [];
+      const keys = annotate([host, ...rest], location());
+      return makeCall(scheme, keys, location());
+    }
+  // No slashes after colon: `files:assets`
+  / scheme:uriScheme keys:pathKeys {
+      return makeCall(scheme, keys, location());
+    }
+
+// URI expression
+uriExpression
+  = uri
+  / newExpression
+  / primary
+
+// A single key in a path, possibly with trailing slash: `a/`, `b`
+uriKey
+  = chars:uriKeyChar+ "/"? {
+      return annotate([ops.literal, text()], location());
+    }
+  / "/" {
+    // A single slash is a path key
+    return annotate([ops.literal, ""], location());
+    }
+
+// A single character in a URI key
+uriKeyChar
+  // Accept anything that doesn't end the URI key or path
+  = [^/,\)\]\}\s]
+  / escapedChar
+
+// A slash-separated path of keys: `a/b/c`
+uriPath "slash-separated path"
+  = keys:uriKey|1..| {
+      return annotate(keys, location());
+    }
+
+// URI scheme, commonly called a protocol
+// See https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+uriScheme
+  = [a-z][a-z0-9+-.]*[:] {
+      return annotate([markers.global, text()], location());
+    }
+
 unaryOperator
   = "!"
   / "+"
-  // Don't match a front matter delimiter. For some reason, the negative
-  // lookahead !"--\n" doesn't work.
-  / @"-" !"-\n"
-  // Don't match a path that starts with a tilde: ~/foo
-  / @"~" !"/"
+  / @"~" ![\/\)\]\}]  // don't match `~/` or end of term
+  / minus
 
 whitespace
   = inlineSpace
   / newLine
   / comment
 
-// Whitespace required in shell mode, optional in JSE mode
-whitespaceShell
-  = shellMode whitespace
-  / jseMode __
-
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __