@unified-latex/unified-latex-builder 1.0.0

package/README.md

@@ -0,0 +1,153 @@
+<!-- DO NOT MODIFY -->
+<!-- This file was autogenerated by build-docs.ts -->
+<!-- Edit the docstring in index.ts and regenerate -->
+<!-- rather than editing this file directly. -->
+# unified-latex-builder
+
+## What is this?
+
+Functions to help build a `unified-latex` Abstract Syntax Tree (AST)
+with [hyperscript](https://github.com/dominictarr/hyperscript)-like syntax.
+
+## When should I use this?
+
+If you want to programmatically create `Ast.Node` nodes.
+
+# Functions
+
+## `arg(args, special)`
+
+Create an Argument. `special.braces` can optionally specify
+the signature of the open/close marks that each argument uses. For example
+
+    arg("a", { braces: "[]" });
+
+will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, and `(`.
+
+```typescript
+function arg(
+  args: CoercibleArgument | Ast.Node[],
+  special: ArgumentSpecialOptions
+): Ast.Argument;
+```
+
+**Parameters**
+
+| Param   | Type                              |
+| :------ | :-------------------------------- |
+| args    | <span color='gray'>Omitted</span> |
+| special | `ArgumentSpecialOptions`          |
+
+where
+
+```typescript
+type ArgumentSpecialOptions = {
+  braces?: string;
+  openMark?: string;
+  closeMark?: string;
+};
+```
+
+## `args(args, special)`
+
+Create an Argument list. `special.braces` can optionally specify
+the signature of the open/close marks that each argument uses. For example
+
+    args(["a", "b"], { braces: "[]{}" });
+
+will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, and `(`.
+
+```typescript
+function args(
+  args: CoercibleArgument | CoercibleArgument[],
+  special: ArgumentsSpecialOptions
+): Ast.Argument[];
+```
+
+**Parameters**
+
+| Param   | Type                              |
+| :------ | :-------------------------------- |
+| args    | <span color='gray'>Omitted</span> |
+| special | `ArgumentsSpecialOptions`         |
+
+where
+
+```typescript
+type ArgumentsSpecialOptions = {
+  braces?: string;
+  defaultOpenMark?: string;
+  defaultCloseMark?: string;
+};
+```
+
+## `env(name, body, envArgs, special)`
+
+Create an Environment node.
+
+```typescript
+function env(
+  name: String,
+  body: CoercibleNode | CoercibleNode[],
+  envArgs: CoercibleArgument | CoercibleArgument[],
+  special: {}
+): Ast.Environment;
+```
+
+**Parameters**
+
+| Param   | Type                              |
+| :------ | :-------------------------------- |
+| name    | `String`                          |
+| body    | <span color='gray'>Omitted</span> |
+| envArgs | <span color='gray'>Omitted</span> |
+| special | `{}`                              |
+
+## `m(name, marcoArgs, special)`
+
+Create a Macro with the given `name`. The macro
+may be followed by any number of arguments.
+
+```typescript
+function m(
+  name: String,
+  marcoArgs: CoercibleArgument | CoercibleArgument[],
+  special: MacroSpecialOptions
+): Ast.Macro;
+```
+
+**Parameters**
+
+| Param     | Type                              |
+| :-------- | :-------------------------------- |
+| name      | `String`                          |
+| marcoArgs | <span color='gray'>Omitted</span> |
+| special   | `MacroSpecialOptions`             |
+
+where
+
+```typescript
+type MacroSpecialOptions = {
+  escapeToken?: string;
+};
+```
+
+## `s(value)`
+
+Create a String node from `value`
+
+```typescript
+function s(value: string | Ast.String): Ast.String;
+```
+
+**Parameters**
+
+| Param | Type                   |
+| :---- | :--------------------- |
+| value | `string \| Ast.String` |
+
+# Constants
+
+| Name | Type             | Description      |
+| :--- | :--------------- | :--------------- |
+| `SP` | `Ast.Whitespace` | Whitespace node. |

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./libs/builders";
+/**
+ * ## What is this?
+ *
+ * Functions to help build a `unified-latex` Abstract Syntax Tree (AST)
+ * with [hyperscript](https://github.com/dominictarr/hyperscript)-like syntax.
+ *
+ * ## When should I use this?
+ *
+ * If you want to programmatically create `Ast.Node` nodes.
+ *
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAGhC;;;;;;;;;;GAUG"}

package/dist/index.js

@@ -0,0 +1,132 @@
+// libs/builders.ts
+function normalizeNode(node) {
+  if (typeof node === "string") {
+    return s(node);
+  }
+  return node;
+}
+function normalizeArgument(arg2, openMark = "{", closeMark = "}") {
+  if (typeof arg2 === "string") {
+    return {
+      type: "argument",
+      openMark,
+      closeMark,
+      content: [s(arg2)]
+    };
+  }
+  if (arg2.type === "argument") {
+    return arg2;
+  }
+  return { type: "argument", openMark, closeMark, content: [arg2] };
+}
+function normalizeArgumentsList(args2, openMark = "{", closeMark = "}") {
+  if (args2 == null) {
+    return [];
+  }
+  if (Array.isArray(args2)) {
+    return args2.map((arg2) => normalizeArgument(arg2, openMark, closeMark));
+  }
+  return [normalizeArgument(args2, openMark, closeMark)];
+}
+var BRACES_MAP = {
+  "*": { openMark: "", closeMark: "" },
+  "{": { openMark: "{", closeMark: "}" },
+  "[": { openMark: "[", closeMark: "]" },
+  "(": { openMark: "(", closeMark: ")" }
+};
+var CLOSE_BRACES = new Set(Object.values(BRACES_MAP).map((x) => x.closeMark).filter((x) => x));
+function bracesToOpenAndCloseMarks(braces) {
+  const ret = [];
+  for (const char of braces.split("")) {
+    if (CLOSE_BRACES.has(char)) {
+      continue;
+    }
+    const braces2 = BRACES_MAP[char];
+    if (braces2 == null) {
+      throw new Error(`Unknown open/close mark type "${char}"`);
+    }
+    braces2;
+    ret.push(braces2);
+  }
+  return ret;
+}
+function args(args2, special) {
+  var _a, _b;
+  if (!Array.isArray(args2)) {
+    args2 = [args2];
+  }
+  if (special == null ? void 0 : special.braces) {
+    const braces = bracesToOpenAndCloseMarks(special.braces);
+    if (braces.length !== args2.length) {
+      throw new Error(`There is a difference between the number of supplied braces and the number of supplied arguments. ${args2.length} supplied with braces signature ${special.braces}`);
+    }
+    return args2.map((arg2, i) => normalizeArgument(arg2, braces[i].openMark, braces[i].closeMark));
+  }
+  const openMark = (_a = special == null ? void 0 : special.defaultOpenMark) != null ? _a : "{";
+  const closeMark = (_b = special == null ? void 0 : special.defaultCloseMark) != null ? _b : "}";
+  return normalizeArgumentsList(args2, openMark, closeMark);
+}
+function arg(args2, special) {
+  var _a, _b;
+  if (typeof args2 === "string") {
+    args2 = s(args2);
+  }
+  if (!Array.isArray(args2) && args2.type === "argument") {
+    return args2;
+  }
+  let openMark = (_a = special == null ? void 0 : special.openMark) != null ? _a : "{";
+  let closeMark = (_b = special == null ? void 0 : special.closeMark) != null ? _b : "}";
+  if (special == null ? void 0 : special.braces) {
+    const braces = bracesToOpenAndCloseMarks(special.braces);
+    if (braces[0]) {
+      openMark = braces[0].openMark;
+      closeMark = braces[0].closeMark;
+    }
+  }
+  if (!Array.isArray(args2)) {
+    args2 = [args2];
+  }
+  return { type: "argument", content: args2, openMark, closeMark };
+}
+function m(name, marcoArgs, special) {
+  const args2 = normalizeArgumentsList(marcoArgs);
+  const escapeToken = special == null ? void 0 : special.escapeToken;
+  const ret = { type: "macro", content: name };
+  if (args2.length > 0) {
+    ret.args = args2;
+  }
+  if (escapeToken != null) {
+    ret.escapeToken = escapeToken;
+  }
+  return ret;
+}
+function s(value) {
+  if (typeof value === "string") {
+    return { type: "string", content: value };
+  }
+  return value;
+}
+function env(name, body, envArgs, special) {
+  if (!Array.isArray(body)) {
+    body = [body];
+  }
+  const args2 = normalizeArgumentsList(envArgs, "[", "]");
+  const ret = {
+    type: "environment",
+    env: name,
+    content: body.map(normalizeNode)
+  };
+  if (args2.length > 0) {
+    ret.args = args2;
+  }
+  return ret;
+}
+var SP = { type: "whitespace" };
+export {
+  SP,
+  arg,
+  args,
+  env,
+  m,
+  s
+};

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../libs/builders.ts"],
+  "sourcesContent": ["import type * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype CoercibleNode = string | Ast.Node;\ntype CoercibleArgument = CoercibleNode | Ast.Argument;\ntype MacroSpecialOptions = {\n    escapeToken?: string;\n};\ntype ArgumentsSpecialOptions = {\n    braces?: string;\n    defaultOpenMark?: string;\n    defaultCloseMark?: string;\n};\ntype ArgumentSpecialOptions = {\n    braces?: string;\n    openMark?: string;\n    closeMark?: string;\n};\n\nfunction normalizeNode(node: CoercibleNode): Ast.Node {\n    if (typeof node === \"string\") {\n        return s(node);\n    }\n    return node;\n}\n\nfunction normalizeArgument(\n    arg: CoercibleArgument,\n    openMark = \"{\",\n    closeMark = \"}\"\n): Ast.Argument {\n    if (typeof arg === \"string\") {\n        return {\n            type: \"argument\",\n            openMark,\n            closeMark,\n            content: [s(arg)],\n        };\n    }\n    if (arg.type === \"argument\") {\n        return arg;\n    }\n    return { type: \"argument\", openMark, closeMark, content: [arg] };\n}\n\nfunction normalizeArgumentsList(\n    args?: CoercibleArgument | CoercibleArgument[],\n    openMark = \"{\",\n    closeMark = \"}\"\n): Ast.Argument[] {\n    if (args == null) {\n        return [];\n    }\n    if (Array.isArray(args)) {\n        return args.map((arg) => normalizeArgument(arg, openMark, closeMark));\n    }\n    return [normalizeArgument(args, openMark, closeMark)];\n}\n\ntype BracesPair = { openMark: string; closeMark: string };\nconst BRACES_MAP: Record<string, BracesPair> = {\n    \"*\": { openMark: \"\", closeMark: \"\" },\n    \"{\": { openMark: \"{\", closeMark: \"}\" },\n    \"[\": { openMark: \"[\", closeMark: \"]\" },\n    \"(\": { openMark: \"(\", closeMark: \")\" },\n};\nconst CLOSE_BRACES = new Set(\n    Object.values(BRACES_MAP)\n        .map((x) => x.closeMark)\n        .filter((x) => x)\n);\n\n/**\n * Turn a braces signature into an array of braces.\n */\nfunction bracesToOpenAndCloseMarks(braces: string): BracesPair[] {\n    const ret: BracesPair[] = [];\n\n    for (const char of braces.split(\"\")) {\n        if (CLOSE_BRACES.has(char)) {\n            continue;\n        }\n        const braces = BRACES_MAP[char];\n        if (braces == null) {\n            throw new Error(`Unknown open/close mark type \"${char}\"`);\n        }\n        braces;\n        ret.push(braces);\n    }\n\n    return ret;\n}\n\n/**\n * Create an Argument list. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * args([\"a\", \"b\"], { braces: \"[]{}\" });\n * ```\n * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, and `(`.\n */\nexport function args(\n    args: CoercibleArgument | CoercibleArgument[],\n    special?: ArgumentsSpecialOptions\n): Ast.Argument[] {\n    if (!Array.isArray(args)) {\n        args = [args];\n    }\n    if (special?.braces) {\n        const braces = bracesToOpenAndCloseMarks(special.braces);\n        if (braces.length !== args.length) {\n            throw new Error(\n                `There is a difference between the number of supplied braces and the number of supplied arguments. ${args.length} supplied with braces signature ${special.braces}`\n            );\n        }\n        return args.map((arg, i) =>\n            normalizeArgument(arg, braces[i].openMark, braces[i].closeMark)\n        );\n    }\n\n    const openMark = special?.defaultOpenMark ?? \"{\";\n    const closeMark = special?.defaultCloseMark ?? \"}\";\n    return normalizeArgumentsList(args, openMark, closeMark);\n}\n\n/**\n * Create an Argument. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * arg(\"a\", { braces: \"[]\" });\n * ```\n * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, and `(`.\n */\nexport function arg(\n    args: CoercibleArgument | Ast.Node[],\n    special?: ArgumentSpecialOptions\n): Ast.Argument {\n    if (typeof args === \"string\") {\n        args = s(args);\n    }\n    if (!Array.isArray(args) && args.type === \"argument\") {\n        return args;\n    }\n\n    let openMark = special?.openMark ?? \"{\";\n    let closeMark = special?.closeMark ?? \"}\";\n    if (special?.braces) {\n        const braces = bracesToOpenAndCloseMarks(special.braces);\n        if (braces[0]) {\n            openMark = braces[0].openMark;\n            closeMark = braces[0].closeMark;\n        }\n    }\n\n    if (!Array.isArray(args)) {\n        args = [args];\n    }\n\n    return { type: \"argument\", content: args, openMark, closeMark };\n}\n\n/**\n * Create a Macro with the given `name`. The macro\n * may be followed by any number of arguments.\n */\nexport function m(\n    name: string,\n    marcoArgs?: CoercibleArgument | CoercibleArgument[],\n    special?: MacroSpecialOptions\n): Ast.Macro {\n    const args = normalizeArgumentsList(marcoArgs);\n    const escapeToken = special?.escapeToken;\n    const ret: Ast.Macro = { type: \"macro\", content: name };\n\n    if (args.length > 0) {\n        ret.args = args;\n    }\n    if (escapeToken != null) {\n        ret.escapeToken = escapeToken;\n    }\n\n    return ret;\n}\n\n/**\n * Create a String node from `value`\n */\nexport function s(value: string | Ast.String): Ast.String {\n    if (typeof value === \"string\") {\n        return { type: \"string\", content: value };\n    }\n    return value;\n}\n\n/**\n * Create an Environment node.\n */\nexport function env(\n    name: string,\n    body: CoercibleNode | CoercibleNode[],\n    envArgs?: CoercibleArgument | CoercibleArgument[],\n    special?: unknown\n): Ast.Environment {\n    if (!Array.isArray(body)) {\n        body = [body];\n    }\n    const args = normalizeArgumentsList(envArgs, \"[\", \"]\");\n    const ret: Ast.Environment = {\n        type: \"environment\",\n        env: name,\n        content: body.map(normalizeNode),\n    };\n    if (args.length > 0) {\n        ret.args = args;\n    }\n\n    return ret;\n}\n\n/**\n * Whitespace node.\n */\nexport const SP: Ast.Whitespace = { type: \"whitespace\" };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/libs/builders.d.ts

@@ -0,0 +1,53 @@
+import type * as Ast from "@unified-latex/unified-latex-types";
+declare type CoercibleNode = string | Ast.Node;
+declare type CoercibleArgument = CoercibleNode | Ast.Argument;
+declare type MacroSpecialOptions = {
+    escapeToken?: string;
+};
+declare type ArgumentsSpecialOptions = {
+    braces?: string;
+    defaultOpenMark?: string;
+    defaultCloseMark?: string;
+};
+declare type ArgumentSpecialOptions = {
+    braces?: string;
+    openMark?: string;
+    closeMark?: string;
+};
+/**
+ * Create an Argument list. `special.braces` can optionally specify
+ * the signature of the open/close marks that each argument uses. For example
+ * ```
+ * args(["a", "b"], { braces: "[]{}" });
+ * ```
+ * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, and `(`.
+ */
+export declare function args(args: CoercibleArgument | CoercibleArgument[], special?: ArgumentsSpecialOptions): Ast.Argument[];
+/**
+ * Create an Argument. `special.braces` can optionally specify
+ * the signature of the open/close marks that each argument uses. For example
+ * ```
+ * arg("a", { braces: "[]" });
+ * ```
+ * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, and `(`.
+ */
+export declare function arg(args: CoercibleArgument | Ast.Node[], special?: ArgumentSpecialOptions): Ast.Argument;
+/**
+ * Create a Macro with the given `name`. The macro
+ * may be followed by any number of arguments.
+ */
+export declare function m(name: string, marcoArgs?: CoercibleArgument | CoercibleArgument[], special?: MacroSpecialOptions): Ast.Macro;
+/**
+ * Create a String node from `value`
+ */
+export declare function s(value: string | Ast.String): Ast.String;
+/**
+ * Create an Environment node.
+ */
+export declare function env(name: string, body: CoercibleNode | CoercibleNode[], envArgs?: CoercibleArgument | CoercibleArgument[], special?: unknown): Ast.Environment;
+/**
+ * Whitespace node.
+ */
+export declare const SP: Ast.Whitespace;
+export {};
+//# sourceMappingURL=builders.d.ts.map

package/dist/libs/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../libs/builders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAE/D,aAAK,aAAa,GAAG,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC;AACvC,aAAK,iBAAiB,GAAG,aAAa,GAAG,GAAG,CAAC,QAAQ,CAAC;AACtD,aAAK,mBAAmB,GAAG;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,aAAK,uBAAuB,GAAG;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AACF,aAAK,sBAAsB,GAAG;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AA4EF;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAChB,IAAI,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,EAC7C,OAAO,CAAC,EAAE,uBAAuB,GAClC,GAAG,CAAC,QAAQ,EAAE,CAmBhB;AAED;;;;;;;GAOG;AACH,wBAAgB,GAAG,CACf,IAAI,EAAE,iBAAiB,GAAG,GAAG,CAAC,IAAI,EAAE,EACpC,OAAO,CAAC,EAAE,sBAAsB,GACjC,GAAG,CAAC,QAAQ,CAuBd;AAED;;;GAGG;AACH,wBAAgB,CAAC,CACb,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,EACnD,OAAO,CAAC,EAAE,mBAAmB,GAC9B,GAAG,CAAC,KAAK,CAaX;AAED;;GAEG;AACH,wBAAgB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAKxD;AAED;;GAEG;AACH,wBAAgB,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,aAAa,GAAG,aAAa,EAAE,EACrC,OAAO,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,EACjD,OAAO,CAAC,EAAE,OAAO,GAClB,GAAG,CAAC,WAAW,CAejB;AAED;;GAEG;AACH,eAAO,MAAM,EAAE,EAAE,GAAG,CAAC,UAAmC,CAAC"}

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@unified-latex/unified-latex-builder",
+    "version": "1.0.0",
+    "description": "Tools for constructing unified-latex ASTs",
+    "main": "dist/index.js",
+    "type": "module",
+    "dependencies": {
+        "@unified-latex/unified-latex-types": "^1.0.0"
+    },
+    "files": [
+        "dist/**/*.ts",
+        "dist/**/*.js",
+        "dist/**/*.map",
+        "dist/**/*.json"
+    ],
+    "exports": {
+        ".": "./dist/index.js",
+        "./*js": "./dist/*js",
+        "./*": "./dist/*.js"
+    },
+    "typesVersions": {
+        "*": {
+            "*": [
+                "dist/*"
+            ]
+        }
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build": "npm run clean && npm run compile",
+        "clean": "rm -rf ./dist && rm -rf tsconfig.tsbuildinfo",
+        "compile": "tsc -b tsconfig.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/siefkenj/unified-latex.git"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "BSD",
+    "bugs": {
+        "url": "https://github.com/siefkenj/unified-latex/issues"
+    },
+    "homepage": "https://github.com/siefkenj/unified-latex#readme"
+}