@weborigami/origami 0.0.35

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021–2023 Jan Miksovsky and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ReadMe.md

@@ -0,0 +1,3 @@
+# Origami package
+
+This folder contains the files published as the high-level `@weborigami/origami` package. It contains common types of useful trees, the `ori` CLI, a templating system for creating text output, and more.

package/exports/PathTransform.d.ts

@@ -0,0 +1,5 @@
+import type { Mixin } from "@weborigami/language";
+
+declare const PathTransform: Mixin<{}>;
+
+export default PathTransform;

package/exports/PathTransform.js

@@ -0,0 +1,18 @@
+export default function PathTransform(Base) {
+  return class Path extends Base {
+    async get(key) {
+      let value = await super.get(key);
+      if (typeof value === "object" && value !== null) {
+        // @ts-ignore
+        const path = this[PathTransform.pathKey]
+          ? // @ts-ignore
+            `${this[PathTransform.pathKey]}/${key}`
+          : key;
+        value[PathTransform.pathKey] = path;
+      }
+      return value;
+    }
+  };
+}
+
+PathTransform.pathKey = Symbol("path");

package/exports/buildExports.js

@@ -0,0 +1,109 @@
+/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
+import { keyMapsForExtensions, map } from "@weborigami/async-tree";
+import unpackOrigamiTemplate from "../src/builtins/@loaders/orit.js";
+import { transformObject } from "../src/common/utilities.js";
+import PathTransform from "./PathTransform.js";
+
+// For builtins that should be renamed or not exported
+const specialBuiltinNames = {
+  "!": null,
+  "@false": null,
+  "@new": null,
+  "@true": null,
+  "~": "homeFiles",
+};
+
+// Top-level template for the export file
+const templateText = `// This file is generated by running buildExports.js -- do not edit by hand.
+{{ _ }}`;
+
+// Generate a top-level export file for the entire project. For each .js file in
+// the given source tree, generate an appropriate statement that includes that
+// file's export(s) in the top-level export file.
+export default async function exportFile(src) {
+  const statements = await exportStatements(src);
+  const templateFn = await unpackOrigamiTemplate(templateText);
+  const result = await templateFn(statements);
+  return result;
+}
+
+/**
+ * Given a buffer containing the code for a JavaScript file, generate an
+ * appropriate export statement for that file.
+ *
+ * @this {AsyncTree}
+ */
+async function exportStatementForCode(codeBuffer, key) {
+  const code = String(codeBuffer);
+
+  const exportsAnything = code.match(/^export /m);
+  if (!exportsAnything) {
+    // Has no exports
+    return "";
+  }
+
+  // @ts-ignore
+  const path = codeBuffer[PathTransform.pathKey] ?? "";
+  const pathParts = path.split("/");
+  pathParts.pop(); // Drop key
+
+  const exportsDefault = code.match(/^export default /m);
+  if (!exportsDefault) {
+    // Export everything.
+    return `export * from "../src/${path}";\n`;
+  }
+
+  // Export a single default export.
+
+  // We construct an identifier for the export based on the path to the file and
+  // the file name. This omits the first part of the path, which is the name of
+  // a folder that's a direct child of the `src` folder. The remaining parts are
+  // joined in camelCase to form the export name. We remove the `@` prefix from
+  // any parts that start with it. As an example, the file inside the src folder
+  // at `builtins/@tree/concat.js` will be identified as `treeConcat`.
+  let exportIdentifierParts = pathParts.slice(1);
+
+  // The file name is the last part of the path; remove the .js extension.
+  let name = key.slice(0, -3);
+
+  // Ignore certain builtins like `@true` and `@false` that would conflict with
+  // JavaScript keywords. Developers can use those JavaScript keywords directly.
+  const specialName = specialBuiltinNames[name];
+  if (specialName === null) {
+    return "";
+  }
+  if (specialName) {
+    name = specialName;
+  }
+
+  // Add the name to the parts.
+  exportIdentifierParts.push(name);
+
+  // Remove the @ prefix from any parts, if present.
+  exportIdentifierParts = exportIdentifierParts.map((part) =>
+    part.startsWith("@") ? part.slice(1) : part
+  );
+
+  // Join the parts in camelCase to form the identifier.
+  const identifier = exportIdentifierParts
+    .map((part, index) =>
+      index === 0 ? part : part[0].toUpperCase() + part.slice(1)
+    )
+    .join("");
+
+  return `export { default as ${identifier} } from "../src/${path}";\n`;
+}
+
+function exportStatements(src) {
+  // Add paths to the source tree so they can be used in the export statements.
+  const withPaths = transformObject(PathTransform, src);
+
+  // Map each source file to an export statement.
+  const mapped = map({
+    deep: true,
+    valueMap: exportStatementForCode,
+    ...keyMapsForExtensions({ sourceExtension: "js" }),
+  })(withPaths);
+
+  return mapped;
+}

package/exports/exports.js

@@ -0,0 +1,121 @@
+// This file is generated by running buildExports.js -- do not edit by hand.
+export { default as apply } from "../src/builtins/@apply.js";
+export { default as arrows } from "../src/builtins/@arrows.js";
+export { default as builtins } from "../src/builtins/@builtins.js";
+export { default as cache } from "../src/builtins/@cache.js";
+export { default as config } from "../src/builtins/@config.js";
+export { default as copy } from "../src/builtins/@copy.js";
+export { default as crawl } from "../src/builtins/@crawl.js";
+export { default as debug } from "../src/builtins/@debug.js";
+export { default as document } from "../src/builtins/@document.js";
+export { default as equals } from "../src/builtins/@equals.js";
+export { default as explore } from "../src/builtins/@explore.js";
+export { default as files } from "../src/builtins/@files.js";
+export { default as filter } from "../src/builtins/@filter.js";
+export { default as globs } from "../src/builtins/@globs.js";
+export { default as help } from "../src/builtins/@help.js";
+export { default as http } from "../src/builtins/@http.js";
+export { default as https } from "../src/builtins/@https.js";
+export { default as if } from "../src/builtins/@if.js";
+export { default as imageFormat } from "../src/builtins/@image/format.js";
+export { default as imageResize } from "../src/builtins/@image/resize.js";
+export { default as index } from "../src/builtins/@index.js";
+export { default as inherited } from "../src/builtins/@inherited.js";
+export { default as inline } from "../src/builtins/@inline.js";
+export { default as invoke } from "../src/builtins/@invoke.js";
+export { default as js } from "../src/builtins/@js.js";
+export { default as json } from "../src/builtins/@json.js";
+export { default as loadersCss } from "../src/builtins/@loaders/css.js";
+export { default as loadersHtm } from "../src/builtins/@loaders/htm.js";
+export { default as loadersHtml } from "../src/builtins/@loaders/html.js";
+export { default as loadersJs } from "../src/builtins/@loaders/js.js";
+export { default as loadersJson } from "../src/builtins/@loaders/json.js";
+export { default as loadersMd } from "../src/builtins/@loaders/md.js";
+export { default as loadersMjs } from "../src/builtins/@loaders/mjs.js";
+export { default as loadersOri } from "../src/builtins/@loaders/ori.js";
+export { default as loadersOrit } from "../src/builtins/@loaders/orit.js";
+export { default as loadersTxt } from "../src/builtins/@loaders/txt.js";
+export { default as loadersXhtml } from "../src/builtins/@loaders/xhtml.js";
+export { default as loadersYaml } from "../src/builtins/@loaders/yaml.js";
+export { default as loadersYml } from "../src/builtins/@loaders/yml.js";
+export { default as map } from "../src/builtins/@map.js";
+export { default as match } from "../src/builtins/@match.js";
+export { default as mdHtml } from "../src/builtins/@mdHtml.js";
+export { default as node } from "../src/builtins/@node.js";
+export { default as not } from "../src/builtins/@not.js";
+export { default as or } from "../src/builtins/@or.js";
+export { default as ori } from "../src/builtins/@ori.js";
+export { default as pack } from "../src/builtins/@pack.js";
+export { default as parseJson } from "../src/builtins/@parse/json.js";
+export { default as parseYaml } from "../src/builtins/@parse/yaml.js";
+export { default as project } from "../src/builtins/@project.js";
+export { default as repeat } from "../src/builtins/@repeat.js";
+export { default as rss } from "../src/builtins/@rss.js";
+export { default as scopeExtend } from "../src/builtins/@scope/extend.js";
+export { default as scopeGet } from "../src/builtins/@scope/get.js";
+export { default as scopeInvoke } from "../src/builtins/@scope/invoke.js";
+export { default as scopeSet } from "../src/builtins/@scope/set.js";
+export { default as serve } from "../src/builtins/@serve.js";
+export { default as shell } from "../src/builtins/@shell.js";
+export { default as stdin } from "../src/builtins/@stdin.js";
+export { default as svg } from "../src/builtins/@svg.js";
+export { default as treeConcat } from "../src/builtins/@tree/concat.js";
+export { default as treeCount } from "../src/builtins/@tree/count.js";
+export { default as treeDefineds } from "../src/builtins/@tree/defineds.js";
+export { default as treeDot } from "../src/builtins/@tree/dot.js";
+export { default as treeExceptions } from "../src/builtins/@tree/exceptions.js";
+export { default as treeFirst } from "../src/builtins/@tree/first.js";
+export { default as treeFlowSvg } from "../src/builtins/@tree/flowSvg.js";
+export { default as treeFn } from "../src/builtins/@tree/fn.js";
+export { default as treeFrom } from "../src/builtins/@tree/from.js";
+export { default as treeFromJson } from "../src/builtins/@tree/fromJson.js";
+export { default as treeFromYaml } from "../src/builtins/@tree/fromYaml.js";
+export { default as treeGroupBy } from "../src/builtins/@tree/groupBy.js";
+export { default as treeInners } from "../src/builtins/@tree/inners.js";
+export { default as treeIsAsyncTree } from "../src/builtins/@tree/isAsyncTree.js";
+export { default as treeKeys } from "../src/builtins/@tree/keys.js";
+export { default as treeKeysJson } from "../src/builtins/@tree/keysJson.js";
+export { default as treeMerge } from "../src/builtins/@tree/merge.js";
+export { default as treeMergeDeep } from "../src/builtins/@tree/mergeDeep.js";
+export { default as treeNextKey } from "../src/builtins/@tree/nextKey.js";
+export { default as treeParent } from "../src/builtins/@tree/parent.js";
+export { default as treePaths } from "../src/builtins/@tree/paths.js";
+export { default as treePlain } from "../src/builtins/@tree/plain.js";
+export { default as treePreviousKey } from "../src/builtins/@tree/previousKey.js";
+export { default as treeReverse } from "../src/builtins/@tree/reverse.js";
+export { default as treeSetDeep } from "../src/builtins/@tree/setDeep.js";
+export { default as treeShuffle } from "../src/builtins/@tree/shuffle.js";
+export { default as treeSitemap } from "../src/builtins/@tree/sitemap.js";
+export { default as treeSort } from "../src/builtins/@tree/sort.js";
+export { default as treeSortBy } from "../src/builtins/@tree/sortBy.js";
+export { default as treeStatic } from "../src/builtins/@tree/static.js";
+export { default as treeTable } from "../src/builtins/@tree/table.js";
+export { default as treeTake } from "../src/builtins/@tree/take.js";
+export { default as treeValues } from "../src/builtins/@tree/values.js";
+export { default as treeValuesDeep } from "../src/builtins/@tree/valuesDeep.js";
+export { default as treeHttp } from "../src/builtins/@treeHttp.js";
+export { default as treeHttps } from "../src/builtins/@treeHttps.js";
+export { default as unpack } from "../src/builtins/@unpack.js";
+export { default as watch } from "../src/builtins/@watch.js";
+export { default as with } from "../src/builtins/@with.js";
+export { default as yaml } from "../src/builtins/@yaml.js";
+export { default as homeFiles } from "../src/builtins/~.js";
+export { default as defaultModuleExport } from "../src/cli/defaultModuleExport.js";
+export { default as showUsage } from "../src/cli/showUsage.js";
+export { default as addValueKeyToScope } from "../src/common/addValueKeyToScope.js";
+export { default as arrowFunctionsMap } from "../src/common/arrowFunctionsMap.js";
+export { default as CommandModulesTransform } from "../src/common/CommandModulesTransform.js";
+export { default as ConstantTree } from "../src/common/ConstantTree.js";
+export { default as ExplorableSiteTransform } from "../src/common/ExplorableSiteTransform.js";
+export { default as FilterTree } from "../src/common/FilterTree.js";
+export { default as GlobTree } from "../src/common/GlobTree.js";
+export { default as processUnpackedContent } from "../src/common/processUnpackedContent.js";
+export * from "../src/common/serialize.js";
+export { default as ShuffleTransform } from "../src/common/ShuffleTransform.js";
+export { default as TextDocument } from "../src/common/TextDocument.js";
+export * from "../src/common/utilities.js";
+export { default as assertScopeIsDefined } from "../src/misc/assertScopeIsDefined.js";
+export { default as OriCommandTransform } from "../src/misc/OriCommandTransform.js";
+export { default as yamlOrigamiTag } from "../src/misc/yamlOrigamiTag.js";
+export * from "../src/server/mediaTypes.js";
+export * from "../src/server/server.js";

package/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Tree Origami is a JavaScript project, but we use TypeScript as an internal
+ * tool to confirm our code is type safe.
+ */
+
+import { Treelike, Unpackable } from "@weborigami/async-tree";
+import { AsyncTree } from "@weborigami/types";
+
+/**
+ * A class constructor is an object with a `new` method that returns an
+ * instance of the indicated type.
+ */
+export type Constructor<T> = new (...args: any[]) => T;
+
+export type Invocable = Function | Unpackable<Function|Treelike> | Treelike;
+
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+
+export type JsonValue = boolean | number | string | Date | JsonObject | JsonValue[] | null;
+
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+
+export type TreelikeTransform = (value: Treelike) => AsyncTree;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@weborigami/origami",
+  "version": "0.0.35",
+  "description": "Graph Origami language, CLI, framework, and server",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/graphorigami/origami.git"
+  },
+  "bin": {
+    "ori": "src/cli/cli.js"
+  },
+  "main": "./exports/exports.js",
+  "types": "./index.ts",
+  "devDependencies": {
+    "@types/chai": "4.3.9",
+    "@types/mocha": "10.0.3",
+    "@types/node": "20.8.10",
+    "typescript": "5.2.2"
+  },
+  "dependencies": {
+    "@weborigami/async-tree": "https://gitpkg.now.sh/GraphOrigami/origami/async-tree?main",
+    "@weborigami/language": "https://gitpkg.now.sh/GraphOrigami/origami/language?main",
+    "@weborigami/types": "0.0.35",
+    "graphviz-wasm": "3.0.1",
+    "highlight.js": "11.9.0",
+    "marked": "9.1.5",
+    "marked-gfm-heading-id": "3.1.0",
+    "marked-highlight": "2.0.6",
+    "marked-smartypants": "1.1.3",
+    "sharp": "0.32.6",
+    "yaml": "2.3.3"
+  },
+  "scripts": {
+    "build": "ori exports/buildExports.js src > exports/exports.js",
+    "prepublishOnly": "npm run build",
+    "test": "node --test --test-reporter=spec test/*/*.test.js test/*/*/*.test.js",
+    "typecheck": "node node_modules/typescript/bin/tsc"
+  }
+}

package/src/builtins/!.js

@@ -0,0 +1,21 @@
+/**
+ * The `!` built-in returns `undefined`, and is intended for force function
+ * invocation in the shell without requiring the use of parentheses. Parentheses
+ * can't be used in the shell without quoting them, which is inconvenient.
+ *
+ * This parentheses form:
+ *
+ * ```
+ * $ ori "fn1.js(fn2.js())"
+ * ```
+ *
+ * Can be written as:
+ *
+ * ```
+ * $ ori fn1.js fn2.js !
+ * ```
+ *
+ * This forces the invocation of `fn2.js`, passing `undefined` as the argument.
+ * The result of that invocation is then passed to `fn1.js`.
+ */
+export default undefined;

package/src/builtins/@apply.js

@@ -0,0 +1,6 @@
+/**
+ * @this {import("@weborigami/types").AsyncTree|null}
+ */
+export default async function apply(target, fn) {
+  return fn.call(this, target);
+}

package/src/builtins/@arrows.js

@@ -0,0 +1,34 @@
+import { Tree } from "@weborigami/async-tree";
+import { Scope, functionResultsMap } from "@weborigami/language";
+import builtins from "../../src/builtins/@builtins.js";
+import arrowFunctionsMap from "../common/arrowFunctionsMap.js";
+import { keySymbol } from "../common/utilities.js";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+
+/**
+ * Interpret arrow keys in the tree as function calls.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @this {AsyncTree|null}
+ * @param {Treelike} [treelike]
+ */
+export default async function arrows(treelike) {
+  assertScopeIsDefined(this);
+  treelike = treelike ?? (await this?.get("@current"));
+  if (treelike === undefined) {
+    throw TypeError(
+      "@arrows requires a treelike argument, but received undefined"
+    );
+  }
+  /** @type {AsyncTree} */
+  const tree = Tree.from(treelike);
+  const mapped = functionResultsMap(arrowFunctionsMap()(tree));
+  const scope = this ?? builtins;
+  const scoped = Scope.treeWithScope(mapped, scope);
+  scoped[keySymbol] = "@arrows";
+  return scoped;
+}
+
+arrows.usage = `@arrows <obj>\tInterpret arrow keys in the tree as function calls`;
+arrows.documentation = "https://graphorigami.org/language/@arrows.html";

package/src/builtins/@builtins.js

@@ -0,0 +1,18 @@
+import { FileTree } from "@weborigami/async-tree";
+import { ImportModulesMixin } from "@weborigami/language";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import CommandModulesTransform from "../common/CommandModulesTransform.js";
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const commandsFolder = path.resolve(dirname, "../builtins");
+
+/** @type {any} */
+const builtins = new (CommandModulesTransform(ImportModulesMixin(FileTree)))(
+  commandsFolder
+);
+
+builtins.usage = `@builtins\tThe Tree Origami built-in functions`;
+builtins.documentation = "https://graphorigami.org/language/@builtins.html";
+
+export default builtins;

package/src/builtins/@cache.js

@@ -0,0 +1,36 @@
+import { cache, Tree } from "@weborigami/async-tree";
+import { Scope } from "@weborigami/language";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+
+/**
+ * Caches tree values in a storable cache.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef  {import("@weborigami/types").AsyncMutableTree} AsyncMutableTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @param {Treelike} sourceTreelike
+ * @param {Treelike} [cacheTreelike]
+ * @param {Treelike} [filterTreelike]
+ * @this {AsyncTree|null}
+ */
+export default async function cacheBuiltin(
+  sourceTreelike,
+  cacheTreelike,
+  filterTreelike
+) {
+  assertScopeIsDefined(this);
+
+  const sourceTree = Tree.from(sourceTreelike);
+  /** @type {any} */
+  const cacheTree = cacheTreelike ? Tree.from(cacheTreelike) : undefined;
+  const filterTree = filterTreelike ? Tree.from(filterTreelike) : undefined;
+
+  /** @type {AsyncTree} */
+  let result = cache(sourceTree, cacheTree, filterTree);
+  result = Scope.treeWithScope(result, this);
+  return result;
+}
+
+cacheBuiltin.usage = `@cache/tree tree, [cache], [filter]\tCaches tree values`;
+cacheBuiltin.documentation =
+  "https://graphorigami.org/cli/builtins.html#@cache";

package/src/builtins/@config.js

@@ -0,0 +1,25 @@
+import project from "./@project.js";
+
+/**
+ * Return the configuration for the current project.
+ *
+ * If the project's root defines an ori.config.js file, the configuration is
+ * the default export of that file. Otherwise, the configuration is the set of
+ * built-in functions.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {any} [key]
+ */
+export default async function config(key) {
+  const projectTree = await project.call(this);
+  const scope = projectTree?.parent;
+  if (!scope) {
+    return undefined;
+  }
+  return key === undefined ? scope : scope.get(key);
+}
+
+config.usage = `@config\tThe current project's configuration tree`;
+config.documentation = "https://graphorigami.org/language/@config.html";

package/src/builtins/@copy.js

@@ -0,0 +1,71 @@
+import { Tree } from "@weborigami/async-tree";
+import process, { stdout } from "node:process";
+import { transformObject } from "../common/utilities.js";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import setDeep from "./@tree/setDeep.js";
+
+/**
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {AsyncTree|null}
+ * @param {Treelike} source
+ * @param {Treelike} target
+ */
+export default async function copy(source, target) {
+  assertScopeIsDefined(this);
+  // const start = performance.now();
+  const sourceTree = Tree.from(source);
+  /** @type {any} */ let targetTree = Tree.from(target);
+
+  if (stdout.isTTY) {
+    targetTree = transformObject(ProgressTransform, targetTree);
+    copyRoot = targetTree;
+    countFiles = 0;
+    countCopied = 0;
+  }
+
+  await setDeep(targetTree, sourceTree);
+
+  if (stdout.isTTY) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    copyRoot = null;
+    countFiles = null;
+    countCopied = null;
+  }
+
+  // const end = performance.now();
+  // console.log(`copy time in ms: ${end - start}`);
+}
+
+let countFiles;
+let countCopied;
+let copyRoot;
+
+function ProgressTransform(Base) {
+  return class Progress extends Base {
+    async set(...args) {
+      countFiles++;
+      copyRoot.showProgress();
+      let result;
+      try {
+        result = await super.set(...args);
+        countCopied++;
+      } catch (e) {
+        console.error(e);
+      }
+      copyRoot.showProgress();
+      return result;
+    }
+
+    showProgress() {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+      process.stdout.write(`Copied ${countCopied} of ${countFiles}`);
+    }
+  };
+}
+
+copy.usage = `@copy <source>, <target>\tCopies the source tree to the target`;
+copy.documentation = "https://graphorigami.org/language/@copy.html";