@weborigami/language 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "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.1",
+    "@weborigami/async-tree": "0.6.2",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/origami.pegjs

@@ -690,6 +690,8 @@ relationalOperator
   / "<"
   / ">="
   / ">"
+  / "instanceof"
+  / "in"
 
 separator
   = __ "," __

package/src/compiler/parse.js

@@ -396,17 +396,19 @@ function peg$parse(input, options) {
   const peg$c55 = "?.";
   const peg$c56 = "<=";
   const peg$c57 = ">=";
-  const peg$c58 = "#!";
-  const peg$c59 = "<<";
-  const peg$c60 = ">>>";
-  const peg$c61 = ">>";
-  const peg$c62 = "\u2192";
-  const peg$c63 = "->";
-  const peg$c64 = "${";
-  const peg$c65 = "~";
-  const peg$c66 = "await";
-  const peg$c67 = "typeof";
-  const peg$c68 = "void";
+  const peg$c58 = "instanceof";
+  const peg$c59 = "in";
+  const peg$c60 = "#!";
+  const peg$c61 = "<<";
+  const peg$c62 = ">>>";
+  const peg$c63 = ">>";
+  const peg$c64 = "\u2192";
+  const peg$c65 = "->";
+  const peg$c66 = "${";
+  const peg$c67 = "~";
+  const peg$c68 = "await";
+  const peg$c69 = "typeof";
+  const peg$c70 = "void";
 
   const peg$r0 = /^[^\/>\t\n\r]/;
   const peg$r1 = /^[0-9]/;
@@ -515,31 +517,33 @@ function peg$parse(input, options) {
   const peg$e88 = peg$classExpectation(["/", "\n", "\r"], true, false, false);
   const peg$e89 = peg$literalExpectation("<=", false);
   const peg$e90 = peg$literalExpectation(">=", false);
-  const peg$e91 = peg$literalExpectation("#!", false);
-  const peg$e92 = peg$classExpectation(["\n", "\r"], true, false, false);
-  const peg$e93 = peg$literalExpectation("<<", false);
-  const peg$e94 = peg$literalExpectation(">>>", false);
-  const peg$e95 = peg$literalExpectation(">>", false);
-  const peg$e96 = peg$otherExpectation("lambda function");
-  const peg$e97 = peg$literalExpectation("\u2192", false);
-  const peg$e98 = peg$literalExpectation("->", false);
-  const peg$e99 = peg$otherExpectation("single quote string");
-  const peg$e100 = peg$otherExpectation("string");
-  const peg$e101 = peg$literalExpectation("${", false);
-  const peg$e102 = peg$otherExpectation("template document");
-  const peg$e103 = peg$otherExpectation("template literal");
-  const peg$e104 = peg$otherExpectation("template substitution");
-  const peg$e105 = peg$classExpectation(["!", "+"], false, false, false);
-  const peg$e106 = peg$literalExpectation("~", false);
-  const peg$e107 = peg$classExpectation(["/", ")", "]", "}"], false, false, false);
-  const peg$e108 = peg$literalExpectation("await", false);
-  const peg$e109 = peg$literalExpectation("typeof", false);
-  const peg$e110 = peg$literalExpectation("void", false);
-  const peg$e111 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false, false);
-  const peg$e112 = peg$otherExpectation("slash-separated path");
-  const peg$e113 = peg$classExpectation([["a", "z"]], false, false, false);
-  const peg$e114 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false, false);
-  const peg$e115 = peg$classExpectation([":"], false, false, false);
+  const peg$e91 = peg$literalExpectation("instanceof", false);
+  const peg$e92 = peg$literalExpectation("in", false);
+  const peg$e93 = peg$literalExpectation("#!", false);
+  const peg$e94 = peg$classExpectation(["\n", "\r"], true, false, false);
+  const peg$e95 = peg$literalExpectation("<<", false);
+  const peg$e96 = peg$literalExpectation(">>>", false);
+  const peg$e97 = peg$literalExpectation(">>", false);
+  const peg$e98 = peg$otherExpectation("lambda function");
+  const peg$e99 = peg$literalExpectation("\u2192", false);
+  const peg$e100 = peg$literalExpectation("->", false);
+  const peg$e101 = peg$otherExpectation("single quote string");
+  const peg$e102 = peg$otherExpectation("string");
+  const peg$e103 = peg$literalExpectation("${", false);
+  const peg$e104 = peg$otherExpectation("template document");
+  const peg$e105 = peg$otherExpectation("template literal");
+  const peg$e106 = peg$otherExpectation("template substitution");
+  const peg$e107 = peg$classExpectation(["!", "+"], false, false, false);
+  const peg$e108 = peg$literalExpectation("~", false);
+  const peg$e109 = peg$classExpectation(["/", ")", "]", "}"], false, false, false);
+  const peg$e110 = peg$literalExpectation("await", false);
+  const peg$e111 = peg$literalExpectation("typeof", false);
+  const peg$e112 = peg$literalExpectation("void", false);
+  const peg$e113 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false, false);
+  const peg$e114 = peg$otherExpectation("slash-separated path");
+  const peg$e115 = peg$classExpectation([["a", "z"]], false, false, false);
+  const peg$e116 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false, false);
+  const peg$e117 = peg$classExpectation([":"], false, false, false);
 
   function peg$f0() {
     return null;
@@ -5209,6 +5213,24 @@ function peg$parse(input, options) {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) { peg$fail(peg$e3); }
           }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 10) === peg$c58) {
+              s0 = peg$c58;
+              peg$currPos += 10;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$e91); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.substr(peg$currPos, 2) === peg$c59) {
+                s0 = peg$c59;
+                peg$currPos += 2;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e92); }
+              }
+            }
+          }
         }
       }
     }
@@ -5254,12 +5276,12 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3;
 
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c58) {
-      s1 = peg$c58;
+    if (input.substr(peg$currPos, 2) === peg$c60) {
+      s1 = peg$c60;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e91); }
+      if (peg$silentFails === 0) { peg$fail(peg$e93); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -5268,7 +5290,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e92); }
+        if (peg$silentFails === 0) { peg$fail(peg$e94); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
@@ -5277,7 +5299,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e92); }
+          if (peg$silentFails === 0) { peg$fail(peg$e94); }
         }
       }
       peg$savedPos = s0;
@@ -5359,28 +5381,28 @@ function peg$parse(input, options) {
   function peg$parseshiftOperator() {
     let s0;
 
-    if (input.substr(peg$currPos, 2) === peg$c59) {
-      s0 = peg$c59;
+    if (input.substr(peg$currPos, 2) === peg$c61) {
+      s0 = peg$c61;
       peg$currPos += 2;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e93); }
+      if (peg$silentFails === 0) { peg$fail(peg$e95); }
     }
     if (s0 === peg$FAILED) {
-      if (input.substr(peg$currPos, 3) === peg$c60) {
-        s0 = peg$c60;
+      if (input.substr(peg$currPos, 3) === peg$c62) {
+        s0 = peg$c62;
         peg$currPos += 3;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e94); }
+        if (peg$silentFails === 0) { peg$fail(peg$e96); }
       }
       if (s0 === peg$FAILED) {
-        if (input.substr(peg$currPos, 2) === peg$c61) {
-          s0 = peg$c61;
+        if (input.substr(peg$currPos, 2) === peg$c63) {
+          s0 = peg$c63;
           peg$currPos += 2;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e95); }
+          if (peg$silentFails === 0) { peg$fail(peg$e97); }
         }
       }
     }
@@ -5450,7 +5472,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e96); }
+      if (peg$silentFails === 0) { peg$fail(peg$e98); }
     }
 
     return s0;
@@ -5460,19 +5482,19 @@ function peg$parse(input, options) {
     let s0;
 
     if (input.charCodeAt(peg$currPos) === 8594) {
-      s0 = peg$c62;
+      s0 = peg$c64;
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e97); }
+      if (peg$silentFails === 0) { peg$fail(peg$e99); }
     }
     if (s0 === peg$FAILED) {
-      if (input.substr(peg$currPos, 2) === peg$c63) {
-        s0 = peg$c63;
+      if (input.substr(peg$currPos, 2) === peg$c65) {
+        s0 = peg$c65;
         peg$currPos += 2;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e98); }
+        if (peg$silentFails === 0) { peg$fail(peg$e100); }
       }
     }
 
@@ -5497,7 +5519,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e92); }
+        if (peg$silentFails === 0) { peg$fail(peg$e94); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
@@ -5506,7 +5528,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e92); }
+          if (peg$silentFails === 0) { peg$fail(peg$e94); }
         }
       }
       peg$savedPos = s0;
@@ -5553,7 +5575,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e99); }
+      if (peg$silentFails === 0) { peg$fail(peg$e101); }
     }
 
     return s0;
@@ -5726,7 +5748,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e100); }
+      if (peg$silentFails === 0) { peg$fail(peg$e102); }
     }
 
     return s0;
@@ -5775,12 +5797,12 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = peg$currPos;
     peg$silentFails++;
-    if (input.substr(peg$currPos, 2) === peg$c64) {
-      s2 = peg$c64;
+    if (input.substr(peg$currPos, 2) === peg$c66) {
+      s2 = peg$c66;
       peg$currPos += 2;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e101); }
+      if (peg$silentFails === 0) { peg$fail(peg$e103); }
     }
     peg$silentFails--;
     if (s2 === peg$FAILED) {
@@ -5861,7 +5883,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e102); }
+      if (peg$silentFails === 0) { peg$fail(peg$e104); }
     }
 
     return s0;
@@ -5920,7 +5942,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e103); }
+      if (peg$silentFails === 0) { peg$fail(peg$e105); }
     }
 
     return s0;
@@ -5940,12 +5962,12 @@ function peg$parse(input, options) {
       if (peg$silentFails === 0) { peg$fail(peg$e42); }
     }
     if (s2 === peg$FAILED) {
-      if (input.substr(peg$currPos, 2) === peg$c64) {
-        s2 = peg$c64;
+      if (input.substr(peg$currPos, 2) === peg$c66) {
+        s2 = peg$c66;
         peg$currPos += 2;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e101); }
+        if (peg$silentFails === 0) { peg$fail(peg$e103); }
       }
     }
     peg$silentFails--;
@@ -5993,12 +6015,12 @@ function peg$parse(input, options) {
 
     peg$silentFails++;
     s0 = peg$currPos;
-    if (input.substr(peg$currPos, 2) === peg$c64) {
-      s1 = peg$c64;
+    if (input.substr(peg$currPos, 2) === peg$c66) {
+      s1 = peg$c66;
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e101); }
+      if (peg$silentFails === 0) { peg$fail(peg$e103); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parseexpectExpression();
@@ -6028,7 +6050,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e104); }
+      if (peg$silentFails === 0) { peg$fail(peg$e106); }
     }
 
     return s0;
@@ -6085,16 +6107,16 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e105); }
+      if (peg$silentFails === 0) { peg$fail(peg$e107); }
     }
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
       if (input.charCodeAt(peg$currPos) === 126) {
-        s1 = peg$c65;
+        s1 = peg$c67;
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e106); }
+        if (peg$silentFails === 0) { peg$fail(peg$e108); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
@@ -6104,7 +6126,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e107); }
+          if (peg$silentFails === 0) { peg$fail(peg$e109); }
         }
         peg$silentFails--;
         if (s3 === peg$FAILED) {
@@ -6127,12 +6149,12 @@ function peg$parse(input, options) {
         s0 = peg$parseminus();
         if (s0 === peg$FAILED) {
           s0 = peg$currPos;
-          if (input.substr(peg$currPos, 5) === peg$c66) {
-            s1 = peg$c66;
+          if (input.substr(peg$currPos, 5) === peg$c68) {
+            s1 = peg$c68;
             peg$currPos += 5;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e108); }
+            if (peg$silentFails === 0) { peg$fail(peg$e110); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -6157,12 +6179,12 @@ function peg$parse(input, options) {
           }
           if (s0 === peg$FAILED) {
             s0 = peg$currPos;
-            if (input.substr(peg$currPos, 6) === peg$c67) {
-              s1 = peg$c67;
+            if (input.substr(peg$currPos, 6) === peg$c69) {
+              s1 = peg$c69;
               peg$currPos += 6;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e109); }
+              if (peg$silentFails === 0) { peg$fail(peg$e111); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -6187,12 +6209,12 @@ function peg$parse(input, options) {
             }
             if (s0 === peg$FAILED) {
               s0 = peg$currPos;
-              if (input.substr(peg$currPos, 4) === peg$c68) {
-                s1 = peg$c68;
+              if (input.substr(peg$currPos, 4) === peg$c70) {
+                s1 = peg$c70;
                 peg$currPos += 4;
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e110); }
+                if (peg$silentFails === 0) { peg$fail(peg$e112); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -6372,7 +6394,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e111); }
+      if (peg$silentFails === 0) { peg$fail(peg$e113); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -6435,7 +6457,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e112); }
+      if (peg$silentFails === 0) { peg$fail(peg$e114); }
     }
 
     return s0;
@@ -6450,7 +6472,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e113); }
+      if (peg$silentFails === 0) { peg$fail(peg$e115); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
@@ -6459,7 +6481,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e114); }
+        if (peg$silentFails === 0) { peg$fail(peg$e116); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
@@ -6468,7 +6490,7 @@ function peg$parse(input, options) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e114); }
+          if (peg$silentFails === 0) { peg$fail(peg$e116); }
         }
       }
       s3 = input.charAt(peg$currPos);
@@ -6476,7 +6498,7 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e115); }
+        if (peg$silentFails === 0) { peg$fail(peg$e117); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;

package/src/compiler/parserHelpers.js

@@ -142,6 +142,8 @@ export function makeBinaryOperation(left, [operatorToken, right]) {
     ">>>": ops.shiftRightUnsigned,
     "^": ops.bitwiseXor,
     "|": ops.bitwiseOr,
+    instanceof: ops.instanceOf,
+    in: ops.inOperator,
   };
   const op = operators[operatorToken];
 

package/src/handlers/yaml_handler.js

@@ -3,11 +3,11 @@ import {
   isUnpackable,
   symbols,
   toString,
+  Tree,
 } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 import * as compile from "../compiler/compile.js";
 import projectGlobals from "../project/projectGlobals.js";
-import * as expressionFunction from "../runtime/expressionFunction.js";
 import getSource from "./getSource.js";
 
 // The "yaml" package doesn't seem to provide a default export that the browser can
@@ -15,6 +15,17 @@ import getSource from "./getSource.js";
 // @ts-ignore
 const YAML = YAMLModule.default ?? YAMLModule.YAML;
 
+// True if we encountered !ori or !ori.call tags while parsing
+let hasOriTags = false;
+
+// When processing the !ori tag, the YAML parser will convert our compiler
+// errors into YAML syntax errors. We track the last compiler error so we can
+// re-throw it.
+let lastCompilerError = null;
+
+// The source of the last Origami line parsed in a YAML file, used for errors
+let source;
+
 /**
  * A YAML file
  *
@@ -31,72 +42,145 @@ export default {
       throw new Error("Tried to parse something as YAML but it wasn't text.");
     }
     const parent = getParent(packed, options);
-    const oriCallTag = await oriCallTagForParent(parent, options);
-    const oriTag = await oriTagForParent(parent, options);
+    const oriCallTag = await oriCallTagForParent(parent, options, yaml);
+    const oriTag = await oriTagForParent(parent, options, yaml);
+    hasOriTags = false; // Haven't seen any yet
+
+    let data;
     // YAML parser is sync, but top-level !ori or !ori.call tags will return a
     // promise.
-    // @ts-ignore TypeScript complains customTags isn't valid here but it is.
-    const data = await YAML.parse(yaml, {
-      customTags: [oriCallTag, oriTag],
-    });
+    try {
+      // @ts-ignore TypeScript complains customTags isn't valid here but it is.
+      data = YAML.parse(yaml, {
+        customTags: [oriCallTag, oriTag],
+      });
+    } catch (/** @type {any} */ error) {
+      if (error.name === "SyntaxError") {
+        // One of our compiler errors, probably thrown by !ori.call tag
+        throw error;
+      }
+      const errorText = yaml.slice(error.pos[0], error.pos[1]);
+      const isOriError = errorText === "!ori" || errorText === "!ori.call";
+      if (isOriError && lastCompilerError) {
+        // Error is in an Origami tag, probably throw by !ori tag. Find the
+        // position of the Origami source in the YAML text.
+        let offset = error.pos[0] + errorText.length;
+        while (/\s/.test(yaml[offset])) {
+          offset++;
+        }
+        lastCompilerError.location.source.offset = offset;
+        throw lastCompilerError;
+      } else {
+        // Some other YAML parsing error
+        throw error;
+      }
+    }
+
+    if (data instanceof Promise) {
+      // Top-level !ori or !ori.call tag returned a promise
+      data = await data;
+    }
+
+    if (hasOriTags) {
+      // Resolve any promises in the data.
+      data = await Tree.plain(data);
+    }
+
     if (data && typeof data === "object" && Object.isExtensible(data)) {
       Object.defineProperty(data, symbols.deep, {
         enumerable: false,
         value: true,
       });
     }
+
     return data;
   },
 };
 
-async function oriCallTagForParent(parent, options) {
+async function oriCallTagForParent(parent, options, yaml) {
   const globals = await projectGlobals();
   return {
     collection: "seq",
 
     tag: "!ori.call",
 
-    identify: (value) => false,
-
-    async resolve(value) {
+    resolve(value) {
+      hasOriTags = true;
       /** @type {any[]} */
       const args = typeof value?.toJSON === "function" ? value.toJSON() : value;
 
       // First arg is Origami source
       const text = args.shift();
-      const source = getSource(text, options);
-
-      const codeFn = compile.expression(source, {
-        globals,
-        parent,
-      });
+      source = getSource(text, options);
 
-      // Evaluate the code to get a function
-      let fn = await codeFn.call(parent);
+      // Offset the source position to account for its location in YAML text
+      source.context = yaml;
+      const firstItem = value.items[0];
+      source.offset = firstItem.range[0];
+      if (
+        firstItem.type === "QUOTE_DOUBLE" ||
+        firstItem.type === "QUOTE_SINGLE"
+      ) {
+        // Account for opening quote
+        source.offset += 1;
+      }
 
-      // Call the function with the rest of the args
-      if (isUnpackable(fn)) {
-        fn = await fn.unpack();
+      lastCompilerError = null;
+      let codeFn;
+      try {
+        codeFn = compile.expression(source, {
+          globals,
+          parent,
+        });
+      } catch (error) {
+        lastCompilerError = error;
+        throw error;
       }
 
-      return fn.call(null, ...args);
+      // Return a promise for the code's evaluation. If we instead define
+      // resolve() as async, the catch block in unpack() won't catch Origami
+      // parse errors.
+      return new Promise(async (resolve) => {
+        // Evaluate the code to get a function
+        let fn = await codeFn.call(parent);
+
+        // Call the function with the rest of the args
+        if (isUnpackable(fn)) {
+          fn = await fn.unpack();
+        }
+
+        // Resolve any promise args
+        const resolvedArgs = await Promise.all(args);
+
+        const result = await fn.call(null, ...resolvedArgs);
+        resolve(result);
+      });
     },
   };
 }
 
 // Define the !ori tag for YAML parsing. This will run in the context of the
 // supplied parent.
-async function oriTagForParent(parent, options) {
+async function oriTagForParent(parent, options, yaml) {
   const globals = await projectGlobals();
   return {
-    identify: expressionFunction.isExpressionFunction,
-
     resolve(text) {
-      const source = getSource(text, options);
-      const fn = compile.expression(source, {
-        globals,
-        parent,
-      });
+      hasOriTags = true;
+      source = getSource(text, options);
+      source.context = yaml;
+
+      lastCompilerError = null;
+      let fn;
+      try {
+        fn = compile.expression(source, {
+          globals,
+          parent,
+        });
+      } catch (error) {
+        lastCompilerError = error;
+        throw error;
+      }
+
       return fn.call(parent);
     },
 

package/src/project/jsGlobals.js

@@ -12,7 +12,7 @@ import path from "node:path";
  * Fetch API
  * URL API
  */
-const globals = bindStaticMethodsForGlobals({
+const globals = {
   AbortController,
   AbortSignal,
   AggregateError,
@@ -152,7 +152,7 @@ const globals = bindStaticMethodsForGlobals({
   // Special cases
   fetch: fetchWrapper,
   import: importWrapper,
-});
+};
 
 // Give access to our own custom globals as `globalThis`
 Object.defineProperty(globals, "globalThis", {
@@ -190,64 +190,4 @@ async function importWrapper(modulePath) {
 }
 importWrapper.containerAsTarget = true;
 
-/**
- * Some JavaScript globals like Promise have static methods like Promise.all
- * verify that the call target is the class. This creates an issue because the
- * Origami evaluate() function calls all functions with the evaluation context
- * -- the tree in which the code is running -- as the call target.
- *
- * This function works around the problem. If the indicated object has no static
- * methods, it's returned as is. If it does have static methods, this returns an
- * extension of the object that overrides the static methods with ones that are
- * bound to the object.
- */
-function bindStaticMethods(obj) {
-  if (typeof obj !== "function" && (typeof obj !== "object" || obj === null)) {
-    // Something like `NaN` or `null`
-    return obj;
-  }
-
-  const staticMethodDescriptors = Object.entries(
-    Object.getOwnPropertyDescriptors(obj)
-  )
-    .filter(([key, descriptor]) => descriptor.value instanceof Function)
-    .map(([key, descriptor]) => [
-      key,
-      {
-        ...descriptor,
-        value: descriptor.value.bind(obj),
-      },
-    ]);
-  if (staticMethodDescriptors.length === 0) {
-    // No static methods
-    return obj;
-  }
-
-  let extended;
-  if (typeof obj === "object" || !obj.prototype) {
-    // A regular object or an oddball like Proxy with no prototype
-    extended = Object.create(obj);
-  } else {
-    // A function, possibly a constructor called with or without `new`
-    /** @this {any} */
-    extended = function (...args) {
-      const calledWithNew = this instanceof extended;
-      return calledWithNew ? new obj(...args) : obj(...args);
-    };
-  }
-
-  Object.defineProperties(
-    extended,
-    Object.fromEntries(staticMethodDescriptors)
-  );
-
-  return extended;
-}
-
-function bindStaticMethodsForGlobals(objects) {
-  const entries = Object.entries(objects);
-  const bound = entries.map(([key, value]) => [key, bindStaticMethods(value)]);
-  return Object.fromEntries(bound);
-}
-
 export default globals;

package/src/protocols/constructHref.js

@@ -9,6 +9,9 @@ import { pathFromKeys } from "@weborigami/async-tree";
  */
 export default function constructHref(protocol, host, ...keys) {
   const path = pathFromKeys(keys);
+  if (host.endsWith("/")) {
+    host = host.slice(0, -1);
+  }
   let href = [host, path].join("/");
   if (!href.startsWith(protocol)) {
     if (!href.startsWith("//")) {

package/src/protocols/explorehttp.js

@@ -0,0 +1,13 @@
+import { ExplorableSiteMap } from "@weborigami/async-tree";
+import constructSiteTree from "./constructSiteTree.js";
+
+/**
+ * A site tree with JSON Keys via HTTP.
+ *
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function explorehttp(host, ...keys) {
+  return constructSiteTree("http:", ExplorableSiteMap, host, ...keys);
+}

package/src/protocols/protocolGlobals.js

@@ -2,6 +2,7 @@ import * as protocols from "./protocols.js";
 
 export default {
   "explore:": protocols.explore,
+  "explorehttp:": protocols.explorehttp,
   "files:": protocols.files,
   "http:": protocols.http,
   "https:": protocols.https,

package/src/protocols/protocols.js

@@ -1,4 +1,5 @@
 export { default as explore } from "./explore.js";
+export { default as explorehttp } from "./explorehttp.js";
 export { default as files } from "./files.js";
 export { default as http } from "./http.js";
 export { default as https } from "./https.js";

package/src/runtime/errors.js

@@ -144,9 +144,22 @@ export function maybeOrigamiSourceCode(text) {
 // 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);
+
+  let line;
+  let column;
+  if (source.offset && source.context) {
+    // Account for source code that was offset within a larger document
+    const offset = source.offset + start.offset;
+    // Calculate line and column from offset
+    const textUpToOffset = source.context.slice(0, offset);
+    const lines = textUpToOffset.split("\n");
+    line = lines.length;
+    column = lines[lines.length - 1].length + 1;
+  } else {
+    // Use indicated start location as is
+    line = start.line;
+    column = start.column;
+  }
 
   if (typeof source === "object" && source.url) {
     const { url } = source;
@@ -162,10 +175,10 @@ function lineInfo(location) {
       // Not a file: URL, use as is
       fileRef = url.href;
     }
-    return `\n    at ${fileRef}:${line}:${start.column}`;
+    return `\n    at ${fileRef}:${line}:${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}`;
+    return `\n    at line ${line}, column ${column}`;
   } else {
     return "";
   }

package/src/runtime/ops.js

@@ -181,6 +181,11 @@ export async function homeDirectory(...keys) {
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
+export function inOperator(a, b) {
+  return a in b;
+}
+addOpLabel(inOperator, "«ops.inOperator»");
+
 /**
  * Given the tree currently be using as the context for the runtime, walk up the
  * parent chain `depth` levels and return that tree.
@@ -203,6 +208,11 @@ export async function inherited(depth, state) {
 addOpLabel(inherited, "«ops.inherited»");
 inherited.needsState = true;
 
+export function instanceOf(a, b) {
+  return a instanceof b;
+}
+addOpLabel(instanceOf, "«ops.instanceOf»");
+
 /**
  * Return a function that will invoke the given code.
  *

package/test/handlers/yaml_handler.test.js

@@ -1,4 +1,3 @@
-import { Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import yaml_handler from "../../src/handlers/yaml_handler.js";
@@ -22,8 +21,7 @@ message: Hello
 answer: !ori 1 + 1
 `;
     const data = await yaml_handler.unpack(text);
-    const plain = await Tree.plain(data);
-    assert.deepEqual(plain, {
+    assert.deepEqual(data, {
       message: "Hello",
       answer: 2,
     });
@@ -38,8 +36,7 @@ answer: !ori.call
   - 3
 `;
     const data = await yaml_handler.unpack(text);
-    const plain = await Tree.plain(data);
-    assert.deepEqual(plain, {
+    assert.deepEqual(data, {
       message: "Hello",
       answer: 5,
     });

package/test/project/jsGlobals.test.js

@@ -3,19 +3,25 @@ import { describe, test } from "node:test";
 import jsGlobals from "../../src/project/jsGlobals.js";
 
 describe("jsGlobals", () => {
-  test("can invoke static methods", async () => {
-    const { Promise } = jsGlobals;
-    const { all } = Promise;
-    const result = (
-      await all(["fruit", "computer", "park"].map((item) => `Apple ${item}`))
-    ).join(", ");
-    assert.equal(result, "Apple fruit, Apple computer, Apple park");
+  test("can invoke finicky methods like Promise.all that check their receiver", async () => {
+    const value = await jsGlobals.Promise.all([Promise.resolve("hi")]);
+    assert.equal(value, "hi");
   });
 
-  test("can invoke a method on a static method", () => {
+  test("can invoke a static method on a global", () => {
     const { Math } = jsGlobals;
     const a = [1, 3, 2];
     const b = Math.max.apply(null, a);
     assert.equal(b, 3);
   });
+
+  test("can invoke a global constructor", async () => {
+    const { Number: fixture } = jsGlobals;
+    // Without `new`
+    const instance1 = fixture(5);
+    assert.equal(instance1, 5);
+    // With `new`
+    const instance = new fixture();
+    assert(instance instanceof Number);
+  });
 });

package/test/runtime/ops.test.js

@@ -155,6 +155,14 @@ describe("ops", () => {
     assert(ops.greaterThanOrEqual("ab", "aa"));
   });
 
+  test("ops.inOperator returns true if a is in object b", () => {
+    assert.strictEqual(ops.inOperator("a", { a: 1, b: 2 }), true);
+    assert.strictEqual(ops.inOperator("c", { a: 1, b: 2 }), false);
+    const arr = [0, 0, 0];
+    assert.strictEqual(ops.inOperator(1, arr), true);
+    assert.strictEqual(ops.inOperator(3, arr), false);
+  });
+
   test("ops.inherited walks up the object parent chain", async () => {
     const tree = new ObjectMap(
       {
@@ -168,6 +176,16 @@ describe("ops", () => {
     assert.equal(await ops.inherited(2, { object: b }), tree);
   });
 
+  test("ops.instanceOf checks prototype chain", () => {
+    class Parent {}
+    class Child extends Parent {}
+    const child = new Child();
+    assert.strictEqual(ops.instanceOf(child, Child), true);
+    assert.strictEqual(ops.instanceOf(child, Parent), true);
+    assert.strictEqual(ops.instanceOf(child, Object), true);
+    assert.strictEqual(ops.instanceOf(child, Array), false);
+  });
+
   test("ops.lambda defines a function with no inputs", async () => {
     const code = createCode([ops.lambda, [], [ops.literal, "result"]]);
     const fn = await evaluate(code);

package/test/runtime/jsGlobals.test.js

@@ -1,21 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import jsGlobals from "../../src/project/jsGlobals.js";
-
-describe("jsGlobals", () => {
-  test("wraps static methods to bind them to defining object", async () => {
-    const all = jsGlobals.Promise.all;
-    const value = await all([Promise.resolve("hi")]);
-    assert.equal(value, "hi");
-  });
-
-  test("can invoke a global constructor", async () => {
-    const { Number: fixture } = jsGlobals;
-    // Without `new`
-    const instance1 = fixture(5);
-    assert.equal(instance1, 5);
-    // With `new`
-    const instance = new fixture();
-    assert(instance instanceof Number);
-  });
-});