@weborigami/language 0.0.45 → 0.0.47

package/index.ts

@@ -1,3 +1,4 @@
+import { Packed } from "@weborigami/async-tree";
 
 export * from "./main.js";
 
@@ -17,13 +18,13 @@ export type Code = ArrayWithSource;
 export type Constructor<T> = new (...args: any[]) => T;
 
 /**
- * A function that can convert a value from some persistent form into some kind
- * of live value.
+ * A structure associating a media type and an unpack function with a given file
+ * extension.
  */
-export type FileUnpackFunction = (
-  input: any,
-  options?: any
-) => any;
+export type ExtensionHandler = {
+  mediaType?: string;
+  unpack?: UnpackFunction;
+}
 
 /**
  * A mixin is a function that takes an existing class and returns a new class.
@@ -39,9 +40,14 @@ export type Mixin<MixinMembers> = <T>(
 
 /**
  * Source code representation used by the parser.
- */
+*/
 export type Source = {
   name: string;
   text: string;
-  url: URL;
-}
+  url: URL;  
+}
+
+/**
+ * A function that converts a value from a persistent form into a live value.
+ */
+export type UnpackFunction = (input: Packed, options?: any) => any;

package/main.js

@@ -3,7 +3,7 @@ export * from "./src/runtime/internal.js";
 export * as compile from "./src/compiler/compile.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export { default as ExpressionTree } from "./src/runtime/ExpressionTree.js";
-export { default as FileLoadersTransform } from "./src/runtime/FileLoadersTransform.js";
+export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
 export { default as InheritScopeMixin } from "./src/runtime/InheritScopeMixin.js";
 export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
@@ -19,4 +19,3 @@ export * as expressionFunction from "./src/runtime/expressionFunction.js";
 export { default as extname } from "./src/runtime/extname.js";
 export { default as formatError } from "./src/runtime/formatError.js";
 export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";
-export * as symbols from "./src/runtime/symbols.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -10,9 +10,9 @@
     "typescript": "5.3.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.45",
-    "@weborigami/types": "0.0.45",
-    "peggy": "3.0.2",
+    "@weborigami/async-tree": "0.0.47",
+    "@weborigami/types": "0.0.47",
+    "peggy": "4.0.2",
     "watcher": "2.3.0"
   },
   "scripts": {

package/src/compiler/parse.js

@@ -1,8 +1,9 @@
-// Generated by Peggy 3.0.2.
+// @generated by Peggy 4.0.2.
 //
 // https://peggyjs.org/
 
 
+
 //
 // Origami language parser
 //
@@ -406,16 +407,16 @@ function peg$parse(input, options) {
   var peg$f39 = function(assignments) {
       return annotate([ops.tree, ...(assignments ?? [])], location());
     };
-  var peg$currPos = 0;
-  var peg$savedPos = 0;
+  var peg$currPos = options.peg$currPos | 0;
+  var peg$savedPos = peg$currPos;
   var peg$posDetailsCache = [{ line: 1, column: 1 }];
-  var peg$maxFailPos = 0;
-  var peg$maxFailExpected = [];
-  var peg$silentFails = 0;
+  var peg$maxFailPos = peg$currPos;
+  var peg$maxFailExpected = options.peg$maxFailExpected || [];
+  var peg$silentFails = options.peg$silentFails | 0;
 
   var peg$result;
 
-  if ("startRule" in options) {
+  if (options.startRule) {
     if (!(options.startRule in peg$startRuleFunctions)) {
       throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
     }
@@ -490,9 +491,11 @@ function peg$parse(input, options) {
     if (details) {
       return details;
     } else {
-      p = pos - 1;
-      while (!peg$posDetailsCache[p]) {
-        p--;
+      if (pos >= peg$posDetailsCache.length) {
+        p = peg$posDetailsCache.length - 1;
+      } else {
+        p = pos;
+        while (!peg$posDetailsCache[--p]) {}
       }
 
       details = peg$posDetailsCache[p];
@@ -909,8 +912,8 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = [];
-    if (peg$r0.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
+    s2 = input.charAt(peg$currPos);
+    if (peg$r0.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
@@ -919,8 +922,8 @@ function peg$parse(input, options) {
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
         s1.push(s2);
-        if (peg$r0.test(input.charAt(peg$currPos))) {
-          s2 = input.charAt(peg$currPos);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r0.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
@@ -1311,8 +1314,8 @@ function peg$parse(input, options) {
   function peg$parseidentifierChar() {
     var s0, s1, s2, s3;
 
-    if (peg$r1.test(input.charAt(peg$currPos))) {
-      s0 = input.charAt(peg$currPos);
+    s0 = input.charAt(peg$currPos);
+    if (peg$r1.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
@@ -1444,8 +1447,8 @@ function peg$parse(input, options) {
   function peg$parseinlineSpace() {
     var s0;
 
-    if (peg$r2.test(input.charAt(peg$currPos))) {
-      s0 = input.charAt(peg$currPos);
+    s0 = input.charAt(peg$currPos);
+    if (peg$r2.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
@@ -2361,8 +2364,8 @@ function peg$parse(input, options) {
   function peg$parsesign() {
     var s0;
 
-    if (peg$r3.test(input.charAt(peg$currPos))) {
-      s0 = input.charAt(peg$currPos);
+    s0 = input.charAt(peg$currPos);
+    if (peg$r3.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
@@ -2408,8 +2411,8 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
-      if (peg$r4.test(input.charAt(peg$currPos))) {
-        s3 = input.charAt(peg$currPos);
+      s3 = input.charAt(peg$currPos);
+      if (peg$r4.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
@@ -2417,8 +2420,8 @@ function peg$parse(input, options) {
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
-        if (peg$r4.test(input.charAt(peg$currPos))) {
-          s3 = input.charAt(peg$currPos);
+        s3 = input.charAt(peg$currPos);
+        if (peg$r4.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
@@ -2442,8 +2445,8 @@ function peg$parse(input, options) {
       }
       if (s1 !== peg$FAILED) {
         s2 = [];
-        if (peg$r4.test(input.charAt(peg$currPos))) {
-          s3 = input.charAt(peg$currPos);
+        s3 = input.charAt(peg$currPos);
+        if (peg$r4.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
@@ -2451,8 +2454,8 @@ function peg$parse(input, options) {
         }
         while (s3 !== peg$FAILED) {
           s2.push(s3);
-          if (peg$r4.test(input.charAt(peg$currPos))) {
-            s3 = input.charAt(peg$currPos);
+          s3 = input.charAt(peg$currPos);
+          if (peg$r4.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
@@ -3085,6 +3088,15 @@ function peg$parse(input, options) {
 
   peg$result = peg$startRuleFunction();
 
+  if (options.peg$library) {
+    return /** @type {any} */ ({
+      peg$result,
+      peg$currPos,
+      peg$FAILED,
+      peg$maxFailExpected,
+      peg$maxFailPos
+    });
+  }
   if (peg$result !== peg$FAILED && peg$currPos === input.length) {
     return peg$result;
   } else {
@@ -3102,8 +3114,80 @@ function peg$parse(input, options) {
   }
 }
 
+const peg$allowedStartRules = [
+  "__",
+  "absoluteFilePath",
+  "args",
+  "array",
+  "assignment",
+  "assignmentOrShorthand",
+  "callTarget",
+  "closingBrace",
+  "closingBracket",
+  "closingParen",
+  "comment",
+  "digits",
+  "doubleArrow",
+  "doubleQuoteString",
+  "doubleQuoteStringChar",
+  "escapedChar",
+  "expr",
+  "expression",
+  "float",
+  "functionComposition",
+  "group",
+  "host",
+  "identifier",
+  "identifierChar",
+  "identifierList",
+  "implicitParensArgs",
+  "inlineSpace",
+  "integer",
+  "lambda",
+  "leadingSlashPath",
+  "list",
+  "multiLineComment",
+  "newLine",
+  "number",
+  "object",
+  "objectProperties",
+  "objectProperty",
+  "objectPropertyOrShorthand",
+  "parameterizedLambda",
+  "parensArgs",
+  "pipeline",
+  "path",
+  "pathKey",
+  "protocolCall",
+  "protocol",
+  "reservedProtocol",
+  "scopeReference",
+  "separator",
+  "sign",
+  "singleArrow",
+  "singleLineComment",
+  "singleQuoteString",
+  "singleQuoteStringChar",
+  "step",
+  "start",
+  "string",
+  "templateDocument",
+  "templateDocumentChar",
+  "templateDocumentContents",
+  "templateDocumentText",
+  "templateLiteral",
+  "templateLiteralChar",
+  "templateLiteralContents",
+  "templateLiteralText",
+  "templateSubstitution",
+  "textChar",
+  "tree",
+  "treeAssignments",
+  "whitespaceWithNewLine"
+];
+
 export {
+  peg$allowedStartRules as StartRules,
   peg$SyntaxError as SyntaxError,
-
   peg$parse as parse
 };

package/src/runtime/HandleExtensionsTransform.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "../../index.ts";
+
+declare const HandleExtensionsTransform: Mixin<{}>;
+
+export default HandleExtensionsTransform;

package/src/runtime/{FileLoadersTransform.js → HandleExtensionsTransform.js}

@@ -1,15 +1,15 @@
 import { isStringLike } from "@weborigami/async-tree";
 import Scope from "./Scope.js";
-import attachFileLoader from "./attachFileLoader.js";
+import handleExtension from "./handleExtension.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @typedef {import("../../index.js").FileUnpackFunction} FileUnpackFunction
+ * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @typedef {import("../../index.ts").UnpackFunction} FileUnpackFunction
  *
  * @param {AsyncTreeConstructor} Base
  */
-export default function FileLoadersTransform(Base) {
+export default function HandleExtensionsTransform(Base) {
   return class FileLoaders extends Base {
     async get(key) {
       let value = await super.get(key);
@@ -18,7 +18,7 @@ export default function FileLoadersTransform(Base) {
       // exists) that handles that extension.
       if (value && isStringLike(key)) {
         const scope = Scope.getScope(this);
-        value = await attachFileLoader(scope, String(key), value, this);
+        value = await handleExtension(scope, String(key), value, this);
       }
 
       return value;

package/src/runtime/ImportModulesMixin.js

@@ -32,17 +32,24 @@ export default function ImportModulesMixin(Base) {
           // Ignore errors.
         }
         if (stats) {
-          // Module exists, but we can't load it, probably due to a syntax error.
-          throw new SyntaxError(`Error loading ${filePath}`);
+          // Module exists, but we can't load it. This is often due to a syntax
+          // error in the target module, so we offer that as a hint.
+          const message = `Error loading ${filePath}, possibly due to a syntax error.\n${error.message}`;
+          throw new SyntaxError(message);
         }
 
         // Module doesn't exist.
         return undefined;
       }
 
-      // If the module loaded and defines a default export, return that, otherwise
-      // return the overall module.
-      return typeof obj === "object" && "default" in obj ? obj.default : obj;
+      if ("default" in obj) {
+        // Module with a default export; return that.
+        return obj.default;
+      } else {
+        // Module with multiple named exports. Cast from a module namespace
+        // object to a plain object.
+        return { ...obj };
+      }
     }
   };
 }

package/src/runtime/InvokeFunctionsTransform.js

@@ -23,5 +23,11 @@ export default function InvokeFunctionsTransform(Base) {
       }
       return value;
     }
+
+    // Need to evaluate the value before checking if it is a tree.
+    async isKeyForSubtree(key) {
+      const value = await this.get(key);
+      return Tree.isAsyncTree(value);
+    }
   };
 }

package/src/runtime/OrigamiTransform.d.ts

@@ -3,7 +3,7 @@ import { Mixin } from "../../index.ts";
 import type { AsyncTree } from "@weborigami/types";
 
 // TODO: Figure out how to import declarations from InheritScopeMixin and
-// FileLoadersTransform and apply them here.
+// HandleExtensionsTransform and apply them here.
 declare const OrigamiTransform: Mixin<{
   scope: AsyncTree|null;
 }>;

package/src/runtime/OrigamiTransform.js

@@ -1,4 +1,4 @@
-import FileLoadersTransform from "./FileLoadersTransform.js";
+import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import InheritScopeMixin from "./InheritScopeMixin.js";
 
 /**
@@ -7,5 +7,7 @@ import InheritScopeMixin from "./InheritScopeMixin.js";
  * @param {AsyncTreeConstructor} Base
  */
 export default function OrigamiTransform(Base) {
-  return class Origami extends InheritScopeMixin(FileLoadersTransform(Base)) {};
+  return class Origami extends InheritScopeMixin(
+    HandleExtensionsTransform(Base)
+  ) {};
 }

package/src/runtime/Scope.js

@@ -38,13 +38,20 @@ export default class Scope {
   static getScope(tree) {
     if (!tree) {
       return null;
-    } else if ("scope" in tree) {
-      return /** @type {any} */ (tree).scope;
-    } else if (Tree.isAsyncTree(tree)) {
-      return new Scope(tree, this.getScope(tree.parent));
-    } else {
-      return tree;
+    } else if (!Tree.isAsyncTree(tree)) {
+      throw new Error("Tried to get the scope of something that's not a tree.");
     }
+
+    if ("scope" in tree) {
+      // Ask tree for its scope, use that if defined.
+      const scope = /** @type {any} */ (tree).scope;
+      if (scope) {
+        return scope;
+      }
+    }
+
+    // Default scope is tree plus its parent scope.
+    return new Scope(tree, this.getScope(tree.parent));
   }
 
   async keys() {

package/src/runtime/concatTreeValues.js

@@ -1,8 +1,4 @@
-import {
-  Tree,
-  getRealmObjectPrototype,
-  isPlainObject,
-} from "@weborigami/async-tree";
+import { Tree, getRealmObjectPrototype } from "@weborigami/async-tree";
 
 const textDecoder = new TextDecoder();
 const TypedArray = Object.getPrototypeOf(Uint8Array);
@@ -31,16 +27,7 @@ async function getText(value, scope) {
     value = await value.call(scope);
   }
 
-  // We'd prefer to use Tree.isTreelike() here, but that counts an object with
-  // an unpack() function as a treelike object. In this case, we don't want to
-  // unpack anything that's not already treelike.
-  const isTreelike =
-    Tree.isAsyncTree(value) ||
-    value instanceof Function ||
-    value instanceof Array ||
-    value instanceof Set ||
-    isPlainObject(value);
-  if (isTreelike) {
+  if (Tree.isTreelike(value)) {
     // The mapReduce operation above only implicit casts its top-level input to
     // a tree. If we're asked for the text of a treelike value, we need to
     // explicitly recurse.

package/src/runtime/evaluate.js

@@ -1,4 +1,4 @@
-import { Tree, isPlainObject } from "@weborigami/async-tree";
+import { Tree, isPlainObject, isUnpackable } from "@weborigami/async-tree";
 import { ops } from "./internal.js";
 
 const codeSymbol = Symbol("code");
@@ -45,17 +45,14 @@ export default async function evaluate(code) {
     throw ReferenceError(`${codeFragment(code[0])} is not defined`);
   }
 
-  if (
-    !(fn instanceof Function || Tree.isAsyncTree(fn)) &&
-    typeof fn.unpack === "function"
-  ) {
+  if (isUnpackable(fn)) {
     // Unpack the object and use the result as the function or tree.
     fn = await fn.unpack();
   }
 
   if (!Tree.isTreelike(fn)) {
     throw TypeError(
-      `${codeFragment(code[0])} didn't return a function that can be called`
+      `${codeFragment(code[0])} didn't return a function or a treelike object`
     );
   }
 

package/src/runtime/functionResultsMap.js

@@ -11,7 +11,7 @@ export default function functionResultsMap(tree) {
   return map({
     description: "functionResultsMap",
 
-    valueMap: async (sourceValue, sourceKey, tree) => {
+    value: async (sourceValue, sourceKey, tree) => {
       let resultValue;
       if (typeof sourceValue === "function") {
         const scope = Scope.getScope(tree);

package/src/runtime/handleExtension.js

@@ -0,0 +1,56 @@
+import { isUnpackable, symbols } from "@weborigami/async-tree";
+import extname from "./extname.js";
+
+/**
+ * Given a value that was retrieved using the given key, search in scope for a
+ * handler for the file extension on the key (if present). If a handler is
+ * found, attach information from it to the value and return the modified value.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {AsyncTree|null} scope
+ * @param {any} key
+ * @param {any} value
+ * @param {AsyncTree|null} parent
+ */
+export default async function handleExtension(scope, key, value, parent) {
+  const extension = extname(key);
+  let result = value;
+  if (extension) {
+    const handlerName = `${extension.slice(1)}_handler`;
+    /** @type {import("../../index.ts").ExtensionHandler} */
+    let extensionHandler = await scope?.get(handlerName);
+    if (isUnpackable(extensionHandler)) {
+      // The extension handler itself needs to be unpacked. E.g., if it's a
+      // buffer containing JavaScript file, we need to unpack it to get its
+      // default export.
+      // @ts-ignore
+      extensionHandler = await extensionHandler.unpack();
+    }
+    if (extensionHandler) {
+      const input = value;
+
+      // If the result is a plain string, box it as a String so we can attach
+      // data to it.
+      if (typeof result === "string") {
+        result = new String(result);
+      }
+
+      if (extensionHandler.mediaType) {
+        result.mediaType = extensionHandler.mediaType;
+      }
+      result[symbols.parent] = parent;
+
+      const unpack = extensionHandler.unpack;
+      if (unpack) {
+        // Wrap the unpack function so its only called once per value.
+        let loaded;
+        result.unpack = async () => {
+          loaded ??= await unpack(input, { key, parent });
+          return loaded;
+        };
+      }
+    }
+  }
+  return result;
+}

package/src/runtime/ops.js

@@ -3,12 +3,12 @@
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  */
 
-import { SiteTree, Tree } from "@weborigami/async-tree";
-import FileLoadersTransform from "./FileLoadersTransform.js";
+import { ObjectTree, SiteTree, Tree } from "@weborigami/async-tree";
+import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import Scope from "./Scope.js";
-import attachFileLoader from "./attachFileLoader.js";
 import concatTreeValues from "./concatTreeValues.js";
+import handleExtension from "./handleExtension.js";
 import { OrigamiTree, evaluate, expressionFunction } from "./internal.js";
 
 // For memoizing lambda functions
@@ -75,7 +75,7 @@ async function fetchResponse(href) {
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();
   if (filename) {
-    buffer = await attachFileLoader(this, filename, buffer, null);
+    buffer = await handleExtension(this, filename, buffer, null);
   }
 
   return buffer;
@@ -163,7 +163,7 @@ export function lambda(parameters, code) {
       ambients[parameter] = args.shift();
     }
     ambients["@recurse"] = invoke;
-    const scope = new Scope(ambients, this);
+    const scope = new Scope(new ObjectTree(ambients), this);
 
     let result = await evaluate.call(scope, code);
 
@@ -252,7 +252,7 @@ tree.toString = () => "«ops.tree»";
 export function treeHttp(host, ...keys) {
   const href = constructHref("http:", host, ...keys);
   /** @type {AsyncTree} */
-  let result = new (FileLoadersTransform(SiteTree))(href);
+  let result = new (HandleExtensionsTransform(SiteTree))(href);
   result = Scope.treeWithScope(result, this);
   return result;
 }
@@ -268,7 +268,7 @@ treeHttp.toString = () => "«ops.treeHttp»";
 export function treeHttps(host, ...keys) {
   const href = constructHref("https:", host, ...keys);
   /** @type {AsyncTree} */
-  let result = new (FileLoadersTransform(SiteTree))(href);
+  let result = new (HandleExtensionsTransform(SiteTree))(href);
   result = Scope.treeWithScope(result, this);
   return result;
 }

package/test/compiler/parse.test.js

@@ -87,7 +87,7 @@ describe("Origami parser", () => {
       `
         {
           index.html = index.ori(teamData.yaml)
-          thumbnails = @map(images, { valueMap: thumbnail.js })
+          thumbnails = @map(images, { value: thumbnail.js })
         }
       `,
       [
@@ -104,7 +104,7 @@ describe("Origami parser", () => {
           [
             [ops.scope, "@map"],
             [ops.scope, "images"],
-            [ops.object, ["valueMap", [ops.scope, "thumbnail.js"]]],
+            [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
           ],
         ],
       ]

package/test/runtime/{FileLoadersTransform.test.js → HandleExtensionsTransform.test.js}

@@ -1,10 +1,10 @@
 import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import FileLoadersTransform from "../../src/runtime/FileLoadersTransform.js";
+import HandleExtensionsTransform from "../../src/runtime/HandleExtensionsTransform.js";
 import Scope from "../../src/runtime/Scope.js";
 
-describe("FileLoadersTransform", () => {
+describe("HandleExtensionsTransform", () => {
   test("invokes an appropriate loader for a .json file extension", async () => {
     const fixture = createFixture();
     const numberValue = await fixture.get("foo");
@@ -26,16 +26,16 @@ describe("FileLoadersTransform", () => {
 
 function createFixture() {
   /** @type {import("@weborigami/types").AsyncTree} */
-  let tree = new (FileLoadersTransform(ObjectTree))({
+  let tree = new (HandleExtensionsTransform(ObjectTree))({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });
   /** @type {any} */
-  const scope = {
-    "@loaders": {
-      json: (buffer) => JSON.parse(String(buffer)),
+  const scope = new ObjectTree({
+    json_handler: {
+      unpack: (buffer) => JSON.parse(String(buffer)),
     },
-  };
+  });
   tree = Scope.treeWithScope(tree, scope);
   return tree;
 }

package/test/runtime/evaluate.test.js

@@ -53,9 +53,8 @@ describe("evaluate", () => {
 
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
-    const packed = {
-      unpack: async () => fn,
-    };
+    const packed = new String();
+    /** @type {any} */ (packed).unpack = async () => fn;
     const code = [packed, "a", "b", "c"];
     const result = await evaluate.call(null, code);
     assert.equal(result, "a,b,c");

package/src/runtime/FileLoadersTransform.d.ts

@@ -1,5 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-declare const FileLoadersTransform: Mixin<{}>;
-
-export default FileLoadersTransform;

package/src/runtime/attachFileLoader.js

@@ -1,31 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import extname from "./extname.js";
-import * as symbols from "./symbols.js";
-
-export default async function attachFileLoader(scope, key, value, parent) {
-  const extension = extname(key);
-  let result = value;
-  if (extension) {
-    const loaderName = extension.slice(1);
-    const loader = await Tree.traverse(scope, "@loaders", loaderName);
-    if (loader) {
-      const input = value;
-
-      // If the result is a plain string, box it as a String so we can attach
-      // data to it.
-      if (typeof result === "string") {
-        result = new String(result);
-      }
-      result[symbols.parent] = parent;
-
-      // Wrap the loader with a function that will only be called once per
-      // value.
-      let loaded;
-      result.unpack = async () => {
-        loaded ??= await loader(input, { key, parent });
-        return loaded;
-      };
-    }
-  }
-  return result;
-}

package/src/runtime/symbols.js

@@ -1 +0,0 @@
-export const parent = Symbol("parent");