@weborigami/origami 0.0.73 → 0.2.0

package/src/{builtins/@pack.js → origami/pack.js}

@@ -1,4 +1,4 @@
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -8,6 +8,6 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @returns
  */
 export default function pack(obj) {
-  assertTreeIsDefined(this, "pack");
+  assertTreeIsDefined(this, "origami:pack");
   return obj?.pack?.();
 }

package/src/{builtins/@project.js → origami/project.js}

@@ -1,9 +1,8 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { Tree } from "@weborigami/async-tree";
 import { OrigamiFiles } from "@weborigami/language";
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
-import builtins from "./@builtins.js";
-import fileTypeOrigami from "./ori.handler.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import { builtinsTree, oriHandler } from "../internal.js";
 
 const configFileName = "config.ori";
 
@@ -23,11 +22,11 @@ const configFileName = "config.ori";
  * @param {any} [key]
  */
 export default async function project(key) {
-  assertTreeIsDefined(this, "project");
+  assertTreeIsDefined(this, "origami:project");
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
-  currentTree.parent = builtins;
+  currentTree.parent = builtinsTree;
 
   // Search up the tree for the configuration file or package.json to determine
   // the project root.
@@ -47,7 +46,7 @@ export default async function project(key) {
       projectRoot = configContainer;
     } else {
       // Load Origami configuration file
-      const config = await fileTypeOrigami.unpack(buffer, {
+      const config = await oriHandler.unpack(buffer, {
         key: configFileName,
         parent: configContainer,
       });
@@ -66,7 +65,7 @@ export default async function project(key) {
       projectRoot = new OrigamiFiles(configContainer.path);
       projectRoot.parent = configTree;
       configTree.parent = configContainer;
-      configContainer.parent = builtins;
+      configContainer.parent = builtinsTree;
     }
   }
 
@@ -83,7 +82,7 @@ async function findAncestorFile(start, fileName) {
       // Found the desired file; its container is the project root. Set the
       // parent to the builtins; in the context of this project, there's nothing
       // higher up.
-      current.parent = builtins;
+      current.parent = builtinsTree;
       return current;
     }
     // Not found; try the parent.
@@ -98,6 +97,3 @@ async function findAncestorFile(start, fileName) {
   }
   return undefined;
 }
-
-project.usage = `@project\tThe root of the current Origami project`;
-project.documentation = "https://weborigami.org/language/@project.html";

package/src/{builtins/@regexMatch.js → origami/regexMatch.js}

@@ -1,4 +1,4 @@
-import regexMatchFn from "./@regexMatchFn.js";
+import regexMatchFn from "./regexMatchFn.js";
 
 export default function regexMatch(text, regex) {
   return regexMatchFn(regex)(text);

package/src/origami/repeat.js

@@ -0,0 +1,5 @@
+export default async function repeat(count, content) {
+  const array = new Array(count);
+  array.fill(content);
+  return array;
+}

package/src/{builtins/@shell.js → origami/shell.js}

@@ -11,6 +11,3 @@ export default async function shell(command) {
     return undefined;
   }
 }
-
-shell.usage = `@shell <command>\tExecutes the shell command and returns the output`;
-shell.documentation = "https://weborigami.org/language/@shell.html";

package/src/{builtins/@stdin.js → origami/stdin.js}

@@ -27,6 +27,3 @@ function readAll(readable) {
     });
   });
 }
-
-stdin.usage = `@stdin\tReturns the contents of the standard input stream`;
-stdin.documentation = "https://weborigami.org/language/@stdin.html";

package/src/{builtins/@string.js → origami/string.js}

@@ -1,5 +1,5 @@
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import { toString } from "../common/utilities.js";
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Convert an object to a string.
@@ -9,6 +9,6 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @param {any} object
  */
 export default function stringBuiltin(object) {
-  assertTreeIsDefined(this, "string");
+  assertTreeIsDefined(this, "origami:string");
   return toString(object);
 }

package/src/{builtins/@unpack.js → origami/unpack.js}

@@ -1,4 +1,4 @@
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
@@ -9,6 +9,6 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @param {any} obj
  */
 export default function unpack(obj) {
-  assertTreeIsDefined(this, "unpack");
+  assertTreeIsDefined(this, "origami:unpack");
   return obj?.unpack?.() ?? obj;
 }

package/src/{builtins/@yaml.js → origami/yaml.js}

@@ -1,7 +1,7 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * Render the object as text in YAML format.
@@ -10,7 +10,7 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @param {any} [obj]
  */
 export default async function toYaml(obj) {
-  assertTreeIsDefined(this, "yaml");
+  assertTreeIsDefined(this, "origami:yaml");
   // A fragment of the logic from getTreeArgument.js
   if (arguments.length > 0 && obj === undefined) {
     throw new Error(
@@ -27,6 +27,3 @@ export default async function toYaml(obj) {
   const value = await toPlainValue(obj);
   return YAML.stringify(value);
 }
-
-toYaml.usage = `@yaml <obj>\tRender the object as text in YAML format`;
-toYaml.documentation = "https://weborigami.org/language/@yaml.html";

package/src/{builtins/@yamlParse.js → origami/yamlParse.js}

@@ -5,6 +5,3 @@ export default async function yamlParse(input) {
   const text = toString(input);
   return text ? serialize.parseYaml(text) : undefined;
 }
-
-yamlParse.usage = `@yamlParse <text>\tParse text as YAML`;
-yamlParse.documentation = "https://weborigami.org/builtins/@yamlParse.html";

package/src/protocols/explore.js

@@ -0,0 +1,19 @@
+import { ExplorableSiteTree } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import constructSiteTree from "../common/constructSiteTree.js";
+
+/**
+ * A site tree with JSON Keys via HTTPS.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("../../index.ts").Invocable} Invocable
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function explore(host, ...keys) {
+  assertTreeIsDefined(this, "explore:");
+  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
+}

package/src/{builtins/@files.js → protocols/files.js}

@@ -2,7 +2,7 @@ import { OrigamiFiles } from "@weborigami/language";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -11,7 +11,7 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @param {string[]} keys
  */
 export default async function files(...keys) {
-  assertTreeIsDefined(this, "files");
+  assertTreeIsDefined(this, "files:");
 
   // If path begins with `~`, treat it relative to the home directory.
   // Otherwise, treat it relative to the current working directory.
@@ -28,6 +28,3 @@ export default async function files(...keys) {
   const result = new OrigamiFiles(resolved);
   return result;
 }
-
-files.usage = `@files [path]\tTree of files at the given path`;
-files.documentation = "https://weborigami.org/language/@files.html";

package/src/protocols/http.js

@@ -0,0 +1,18 @@
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import constructHref from "../common/constructHref.js";
+import fetchAndHandleExtension from "../common/fetchAndHandleExtension.js";
+
+/**
+ * Retrieve the indicated web resource via HTTP.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default async function http(host, ...keys) {
+  assertTreeIsDefined(this, "http:");
+  const href = constructHref("http:", host, ...keys);
+  return fetchAndHandleExtension.call(this, href);
+}

package/src/protocols/https.js

@@ -0,0 +1,18 @@
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import constructHref from "../common/constructHref.js";
+import fetchAndHandleExtension from "../common/fetchAndHandleExtension.js";
+
+/**
+ * Retrieve the indicated web resource via HTTPS.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default async function https(host, ...keys) {
+  assertTreeIsDefined(this, "https:");
+  const href = constructHref("https:", host, ...keys);
+  return fetchAndHandleExtension.call(this, href);
+}

package/src/protocols/httpstree.js

@@ -0,0 +1,19 @@
+import { SiteTree } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import constructSiteTree from "../common/constructSiteTree.js";
+
+/**
+ * Return a website tree via HTTPS.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("../../index.ts").Invocable} Invocable
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function httpstree(host, ...keys) {
+  assertTreeIsDefined(this, "treehttps:");
+  return constructSiteTree("https:", SiteTree, this, host, ...keys);
+}

package/src/protocols/httptree.js

@@ -0,0 +1,19 @@
+import { SiteTree } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import constructSiteTree from "../common/constructSiteTree.js";
+
+/**
+ * Return a website tree via HTTP.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("../../index.ts").Invocable} Invocable
+ *
+ * @this {AsyncTree|null}
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function httptree(host, ...keys) {
+  assertTreeIsDefined(this, "httptree:");
+  return constructSiteTree("http:", SiteTree, this, host, ...keys);
+}

package/src/protocols/inherited.js

@@ -0,0 +1,18 @@
+import { Tree } from "@weborigami/async-tree";
+import { ops } from "@weborigami/language";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+
+/**
+ * Return the inherited value (if any) for the indicated key.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {string[]} keys
+ */
+export default async function inherited(...keys) {
+  assertTreeIsDefined(this, "inherited:");
+  const key = keys.shift();
+  const value = await ops.inherited.call(this, key);
+  return keys.length > 0 ? await Tree.traverse(value, ...keys) : value;
+}

package/src/protocols/new.js

@@ -0,0 +1,42 @@
+import { isUnpackable, scope as scopeFn, Tree } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+
+/**
+ * Find the indicated class constructor in scope, then return a function which
+ * invokes it with `new`.
+ *
+ * This can also take a single argument that is a class.
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param  {...any} keys
+ */
+export default async function instantiate(...keys) {
+  assertTreeIsDefined(this, "new:");
+  let constructor;
+  const scope = this ? scopeFn(this) : null;
+  if (
+    keys.length === 1 &&
+    (typeof keys[0] === "object" || typeof keys[0] === "function")
+  ) {
+    constructor = keys[0];
+  } else if (scope) {
+    constructor = await Tree.traverseOrThrow(scope, ...keys);
+  } else {
+    throw new TypeError(`new: The scope isn't defined.`);
+  }
+  if (isUnpackable(constructor)) {
+    constructor = await constructor.unpack();
+  }
+  // Origami may pass `undefined` as the first argument to the constructor. We
+  // don't pass that along, because constructors like `Date` don't like it.
+  return (...args) => {
+    const object =
+      args.length === 1 && args[0] === undefined
+        ? new constructor()
+        : new constructor(...args);
+    if (Tree.isAsyncTree(object)) {
+      object.parent = scope;
+    }
+    return object;
+  };
+}

package/src/{builtins/@package.js → protocols/package.js}

@@ -1,28 +1,45 @@
 import { Tree, keysFromPath, scope } from "@weborigami/async-tree";
-import project from "./@project.js";
+import project from "../origami/project.js";
 
 /**
  * @this {import("@weborigami/types").AsyncTree|null}
  * @param {string[]} keys
  */
-export default async function packageBuiltin(...keys) {
+export default async function packageNamespace(...keys) {
   const parent = this ?? (await project.call(null));
-  const parentScope = scope(parent);
 
-  const packageKeys = [keys.shift()];
-  if (packageKeys[0]?.startsWith("@")) {
-    // First key is an npm organization, get the next key too.
-    packageKeys.push(keys.shift());
+  let name = keys.shift();
+  let organization;
+  if (name?.startsWith("@")) {
+    // First key is an npm organization
+    organization = name;
+    if (keys.length === 0) {
+      // Return a function that will process the next key
+      return async (name, ...keys) =>
+        getPackage(parent, organization, name, keys);
+    }
+    name = keys.shift();
+  }
+
+  return getPackage(parent, organization, name, keys);
+}
+
+async function getPackage(parent, organization, name, keys) {
+  const packagePath = ["node_modules"];
+  if (organization) {
+    packagePath.push(organization);
   }
+  packagePath.push(name);
 
+  const parentScope = scope(parent);
   const packageRoot = await Tree.traverse(
     // @ts-ignore
     parentScope,
-    "node_modules",
-    ...packageKeys
+    ...packagePath
   );
+
   if (!packageRoot) {
-    throw new Error(`Can't find node_modules/${packageKeys.join("/")}`);
+    throw new Error(`Can't find ${packagePath.join("/")}`);
   }
 
   const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
@@ -44,5 +61,10 @@ export default async function packageBuiltin(...keys) {
     keys.length > 0
       ? await Tree.traverse(packageExports, ...keys)
       : packageExports;
+
+  if (Tree.isAsyncTree(result)) {
+    result.parent = parent;
+  }
+
   return result;
 }

package/src/protocols/scope.js

@@ -0,0 +1,24 @@
+import { Tree } from "@weborigami/async-tree";
+import { ops } from "@weborigami/language";
+
+/**
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {string[]} keys
+ */
+export default async function scope(...keys) {
+  const key = keys.shift();
+  let value;
+  try {
+    // Look up key in scope but don't throw if it's undefined
+    value = await ops.scope.call(this, key);
+  } catch (error) {
+    if (error instanceof ReferenceError) {
+      value = undefined;
+    } else {
+      throw error;
+    }
+  }
+  return keys.length > 0 ? await Tree.traverse(value, ...keys) : value;
+}

package/src/server/constructResponse.js

@@ -1,11 +1,11 @@
 import {
-  SiteTree,
-  Tree,
+  extension,
   isPacked,
   isPlainObject,
   isStringLike,
+  SiteTree,
+  Tree,
 } from "@weborigami/async-tree";
-import { extname } from "@weborigami/language";
 import * as serialize from "../common/serialize.js";
 import { toString } from "../common/utilities.js";
 import { mediaTypeForExtension } from "./mediaTypes.js";
@@ -51,8 +51,8 @@ export default async function constructResponse(request, resource) {
     mediaType = resource.mediaType;
   } else {
     // Infer expected media type from file extension on request URL.
-    const extension = extname(url.pathname).toLowerCase();
-    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+    const ext = extension.extname(url.pathname).toLowerCase();
+    mediaType = ext ? mediaTypeForExtension[ext] : undefined;
   }
 
   if (

package/src/{builtins/@siteAudit.js → site/audit.js}

@@ -1,13 +1,13 @@
 import { Tree } from "@weborigami/async-tree";
-import getTreeArgument from "../misc/getTreeArgument.js";
-import crawl from "./@crawl.js";
+import getTreeArgument from "../common/getTreeArgument.js";
+import crawl from "./crawler/crawl.js";
 
 /**
  * @this {import("@weborigami/types").AsyncTree|null}
  * @param {import("@weborigami/async-tree").Treelike} treelike
  */
-export default async function siteAudit(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "@siteAudit");
+export default async function audit(treelike) {
+  const tree = await getTreeArgument(this, arguments, treelike, "site:audit");
   const crawled = await crawl.call(this, tree);
   let crawlErrorsJson = await crawled.get("crawl-errors.json");
   if (!crawlErrorsJson) {

package/src/{builtins/@crawl.js → site/crawler/crawl.js}

@@ -7,8 +7,8 @@ import {
   trailingSlash,
 } from "@weborigami/async-tree";
 import { InvokeFunctionsTransform } from "@weborigami/language";
-import crawlResources from "../crawler/crawlResources.js";
-import getTreeArgument from "../misc/getTreeArgument.js";
+import getTreeArgument from "../../common/getTreeArgument.js";
+import crawlResources from "./crawlResources.js";
 
 /**
  * Crawl a tree, starting its root index.html page, and following links to
@@ -26,7 +26,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  * @returns {Promise<AsyncTree>}
  */
 export default async function crawlBuiltin(treelike, baseHref) {
-  const tree = await getTreeArgument(this, arguments, treelike, "@crawl");
+  const tree = await getTreeArgument(this, arguments, treelike, "site:crawl");
 
   if (baseHref === undefined) {
     // Ask tree or original treelike if it has an `href` property we can use as
@@ -124,6 +124,3 @@ function addValueToObject(object, keys, value) {
     }
   }
 }
-
-crawlBuiltin.usage = `@crawl <tree>\tCrawl a tree`;
-crawlBuiltin.documentation = "https://weborigami.org/language/@crawl.html";

package/src/{crawler → site/crawler}/findPaths.js

@@ -1,5 +1,4 @@
-import { toString } from "@weborigami/async-tree";
-import { extname } from "@weborigami/language";
+import { extension, toString } from "@weborigami/async-tree";
 import { isCrawlableHref, normalizeHref } from "./utilities.js";
 
 // Filter the paths to those that are local to the site.
@@ -42,7 +41,7 @@ export default function findPaths(value, key, baseUrl, localPath) {
 
   // We guess the value is HTML is if its key has an .html extension or
   // doesn't have an extension, or the value starts with `<`.
-  const ext = key ? extname(key).toLowerCase() : "";
+  const ext = key ? extension.extname(key).toLowerCase() : "";
   let foundPaths;
   if (ext === ".html" || ext === ".htm" || ext === ".xhtml") {
     foundPaths = findPathsInHtml(text);

package/src/{crawler → site/crawler}/utilities.js

@@ -1,5 +1,4 @@
-import { trailingSlash } from "@weborigami/async-tree";
-import { extname } from "@weborigami/language";
+import { extension, trailingSlash } from "@weborigami/async-tree";
 
 // A fake base URL used to handle cases where an href is relative and must be
 // treated relative to some base URL.
@@ -13,7 +12,7 @@ export function isCrawlableHref(href) {
   if (lastKey === "robots.txt" || lastKey === "sitemap.xml") {
     return true;
   }
-  const ext = extname(lastKey);
+  const ext = extension.extname(lastKey);
   // We assume an empty extension is HTML.
   const crawlableExtensions = [".html", ".css", ".js", ".map", ".xhtml", ""];
   return crawlableExtensions.includes(ext);

package/src/{builtins/@index.js → site/index.js}

@@ -1,5 +1,5 @@
-import { keySymbol } from "../common/utilities.js";
-import getTreeArgument from "../misc/getTreeArgument.js";
+import getTreeArgument from "../common/getTreeArgument.js";
+import { getDescriptor } from "../common/utilities.js";
 
 /**
  * Return a default index.html page for the current tree.
@@ -10,7 +10,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  * @param {Treelike} [treelike]
  */
 export default async function index(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "@index");
+  const tree = await getTreeArgument(this, arguments, treelike, "site:index");
   const keys = Array.from(await tree.keys());
 
   // Skip system-ish files that start with a period. Also skip `index.html`.
@@ -26,7 +26,7 @@ export default async function index(treelike) {
     links.push(link);
   }
 
-  const heading = tree[keySymbol] ?? "Index";
+  const heading = getDescriptor(tree) ?? "Index";
   const list = `    <ul>\n${links.join("\n")}\n    </ul>`;
 
   const html = `<!DOCTYPE html>
@@ -59,6 +59,3 @@ ${list}
   result.unpack = () => tree;
   return result;
 }
-
-index.usage = `@index\tReturn a default index.html page for the current tree`;
-index.documentation = "https://weborigami.org/language/@index.html";

package/src/{builtins/@jsonKeys.js → site/jsonKeys.js}

@@ -1,6 +1,6 @@
 import { Tree, jsonKeys } from "@weborigami/async-tree";
+import getTreeArgument from "../common/getTreeArgument.js";
 import { transformObject } from "../common/utilities.js";
-import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
  * Expose .keys.json for a tree.
@@ -15,13 +15,13 @@ export default async function jsonKeysBuiltin(treelike) {
     this,
     arguments,
     treelike,
-    "@keysJson",
+    "site:jsonKeys",
     true
   );
-  return transformObject(KeysJsonTransform, tree);
+  return transformObject(JsonKeysTransform, tree);
 }
 
-function KeysJsonTransform(Base) {
+function JsonKeysTransform(Base) {
   return class Static extends Base {
     async get(key) {
       let value = await super.get(key);
@@ -29,7 +29,7 @@ function KeysJsonTransform(Base) {
         value = await jsonKeys.stringify(this);
       } else if (Tree.isTreelike(value)) {
         const tree = Tree.from(value, { deep: true, parent: this });
-        value = transformObject(KeysJsonTransform, tree);
+        value = transformObject(JsonKeysTransform, tree);
       }
       return value;
     }

package/src/{builtins/@rss.js → site/rss.js}

@@ -1,5 +1,5 @@
 import { Tree } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 const months = [
@@ -25,7 +25,7 @@ const months = [
  * @param {any} options
  */
 export default async function rss(jsonFeedTree, options = {}) {
-  assertTreeIsDefined(this, "rss");
+  assertTreeIsDefined(this, "site:rss");
   const jsonFeed = await Tree.plain(jsonFeedTree);
   const { description, home_page_url, items, title } = jsonFeed;
 
@@ -114,6 +114,3 @@ function toRFC822Date(date) {
   const seconds = date.getUTCSeconds().toString().padStart(2, "0");
   return `${day}, ${dayOfMonth} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
 }
-
-rss.usage = `@rss <feed>\tTransforms a JSON Feed tree to RSS XML`;
-rss.documentation = "https://weborigami.org/language/@rss.html";

package/src/site/site.js

@@ -0,0 +1,9 @@
+export { default as audit } from "./audit.js";
+export { default as crawl } from "./crawler/crawl.js";
+export { default as index } from "./index.js";
+export { default as jsonKeys } from "./jsonKeys.js";
+export { default as redirect } from "./redirect.js";
+export { default as rss } from "./rss.js";
+export { default as sitemap } from "./sitemap.js";
+export { default as slug } from "./slug.js";
+export { default as staticBuiltin } from "./static.js";