@unified-latex/unified-latex 1.4.2 → 1.6.0

package/README.md

@@ -24,7 +24,7 @@ import the `.js` file. To explicitly access the commonjs export, import the `.cj
 
 # Constants
 
-| Name                          | Type                                                                                         | Description                                                                                                                                   |
-| :---------------------------- | :------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- |
-| `processLatexToAstViaUnified` | `() => Processor<Ast.Root, Ast.Root, Ast.Root, void>`                                        | Use `unified()` to a string to an `Ast.Ast` and then return it. This function&#xA;will not print/pretty-print the `Ast.Ast` back to a string. |
-| `processLatexViaUnified`      | `(options?: StringCompilerPluginOptions) => Processor<Ast.Root, Ast.Root, Ast.Root, string>` | Use `unified()` to a string to an `Ast.Ast` and then pretty-print it.                                                                         |
+| Name                          | Type                                                                                                               | Description                                                                                                                                   |
+| :---------------------------- | :----------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- |
+| `processLatexToAstViaUnified` | `() => Processor<Ast.Root, Ast.Root, Ast.Root, void>`                                                              | Use `unified()` to a string to an `Ast.Ast` and then return it. This function&#xA;will not print/pretty-print the `Ast.Ast` back to a string. |
+| `processLatexViaUnified`      | `(options?: StringCompilerPluginOptions & ParserPluginOptions) => Processor<Ast.Root, Ast.Root, Ast.Root, string>` | Use `unified()` to a string to an `Ast.Ast` and then pretty-print it.                                                                         |

package/index.cjs

@@ -2302,21 +2302,26 @@ function index(value) {
   return value && typeof value === "number" ? value : 1;
 }
 
-// ../../node_modules/vfile-message/index.js
+// ../../node_modules/vfile-message/lib/index.js
 var VFileMessage = class extends Error {
   /**
    * Create a message for `reason` at `place` from `origin`.
    *
    * When an error is passed in as `reason`, the `stack` is copied.
    *
-   * @param {string|Error|VFileMessage} reason
-   *   Reason for message.
-   *   Uses the stack and message of the error if given.
-   * @param {Node|NodeLike|Position|Point} [place]
-   *   Place at which the message occurred in a file.
-   * @param {string} [origin]
-   *   Place in code the message originates from (example `'my-package:my-rule-name'`)
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   *
+   *   > 👉 **Note**: you should use markdown.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns
+   *   Instance of `VFileMessage`.
    */
+  // To do: next major: expose `undefined` everywhere instead of `null`.
   constructor(reason, place, origin) {
     const parts = [null, null];
     let position2 = {
@@ -2602,10 +2607,10 @@ function cwd() {
 }
 
 // ../../node_modules/vfile/lib/minurl.shared.js
-function isUrl(fileURLOrPath) {
-  return fileURLOrPath !== null && typeof fileURLOrPath === "object" && // @ts-expect-error: indexable.
-  fileURLOrPath.href && // @ts-expect-error: indexable.
-  fileURLOrPath.origin;
+function isUrl(fileUrlOrPath) {
+  return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable.
+  fileUrlOrPath.href && // @ts-expect-error: indexable.
+  fileUrlOrPath.origin;
 }
 
 // ../../node_modules/vfile/lib/minurl.browser.js
@@ -2657,25 +2662,30 @@ var VFile = class {
   /**
    * Create a new virtual file.
    *
-   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.
-   * If `options` is a `URL`, it’s treated as `{path: options}`.
-   * If `options` is a `VFile`, shallow copies its data over to the new file.
-   * All fields in `options` are set on the newly created `VFile`.
+   * `options` is treated as:
+   *
+   * *   `string` or `Buffer` — `{value: options}`
+   * *   `URL` — `{path: options}`
+   * *   `VFile` — shallow copies its data over to the new file
+   * *   `object` — all fields are shallow copied over to the new file
    *
    * Path related fields are set in the following order (least specific to
    * most specific): `history`, `path`, `basename`, `stem`, `extname`,
    * `dirname`.
    *
-   * It’s not possible to set either `dirname` or `extname` without setting
-   * either `history`, `path`, `basename`, or `stem` as well.
+   * You cannot set `dirname` or `extname` without setting either `history`,
+   * `path`, `basename`, or `stem` too.
    *
-   * @param {Compatible} [value]
+   * @param {Compatible | null | undefined} [value]
+   *   File value.
+   * @returns
+   *   New instance.
    */
   constructor(value) {
     let options;
     if (!value) {
       options = {};
-    } else if (typeof value === "string" || (0, import_is_buffer.default)(value)) {
+    } else if (typeof value === "string" || buffer(value)) {
       options = { value };
     } else if (isUrl(value)) {
       options = { path: value };
@@ -2693,18 +2703,20 @@ var VFile = class {
     let index2 = -1;
     while (++index2 < order.length) {
       const prop2 = order[index2];
-      if (prop2 in options && options[prop2] !== void 0) {
+      if (prop2 in options && options[prop2] !== void 0 && options[prop2] !== null) {
         this[prop2] = prop2 === "history" ? [...options[prop2]] : options[prop2];
       }
     }
     let prop;
     for (prop in options) {
-      if (!order.includes(prop))
+      if (!order.includes(prop)) {
         this[prop] = options[prop];
+      }
     }
   }
   /**
    * Get the full path (example: `'~/index.min.js'`).
+   *
    * @returns {string}
    */
   get path() {
@@ -2712,10 +2724,12 @@ var VFile = class {
   }
   /**
    * Set the full path (example: `'~/index.min.js'`).
+   *
    * Cannot be nullified.
    * You can set a file URL (a `URL` object with a `file:` protocol) which will
    * be turned into a path with `url.fileURLToPath`.
-   * @param {string|URL} path
+   *
+   * @param {string | URL} path
    */
   set path(path2) {
     if (isUrl(path2)) {
@@ -2734,6 +2748,7 @@ var VFile = class {
   }
   /**
    * Set the parent path (example: `'~'`).
+   *
    * Cannot be set if there’s no `path` yet.
    */
   set dirname(dirname2) {
@@ -2748,6 +2763,7 @@ var VFile = class {
   }
   /**
    * Set basename (including extname) (`'index.min.js'`).
+   *
    * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
    * on windows).
    * Cannot be nullified (use `file.path = file.dirname` instead).
@@ -2765,6 +2781,7 @@ var VFile = class {
   }
   /**
    * Set the extname (including dot) (example: `'.js'`).
+   *
    * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
    * on windows).
    * Cannot be set if there’s no `path` yet.
@@ -2790,6 +2807,7 @@ var VFile = class {
   }
   /**
    * Set the stem (basename w/o extname) (example: `'index.min'`).
+   *
    * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
    * on windows).
    * Cannot be nullified (use `file.path = file.dirname` instead).
@@ -2802,26 +2820,28 @@ var VFile = class {
   /**
    * Serialize the file.
    *
-   * @param {BufferEncoding} [encoding='utf8']
-   *   When `value` is a `Buffer`, `encoding` is a character encoding to
-   *   understand it as (default: `'utf8'`).
+   * @param {BufferEncoding | null | undefined} [encoding='utf8']
+   *   Character encoding to understand `value` as when it’s a `Buffer`
+   *   (default: `'utf8'`).
    * @returns {string}
    *   Serialized file.
    */
   toString(encoding) {
-    return (this.value || "").toString(encoding);
+    return (this.value || "").toString(encoding || void 0);
   }
   /**
-   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and
-   * associates it with the file by adding it to `vfile.messages` and setting
-   * `message.file` to the current filepath.
+   * Create a warning message associated with the file.
    *
-   * @param {string|Error|VFileMessage} reason
-   *   Human readable reason for the message, uses the stack and message of the error if given.
-   * @param {Node|NodeLike|Position|Point} [place]
-   *   Place where the message occurred in the file.
-   * @param {string} [origin]
-   *   Computer readable reason for the message
+   * Its `fatal` is set to `false` and `file` is set to the current file path.
+   * Its added to `file.messages`.
+   *
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
    * @returns {VFileMessage}
    *   Message.
    */
@@ -2836,15 +2856,18 @@ var VFile = class {
     return message;
   }
   /**
-   * Like `VFile#message()`, but associates an informational message where
-   * `fatal` is set to `null`.
+   * Create an info message associated with the file.
+   *
+   * Its `fatal` is set to `null` and `file` is set to the current file path.
+   * Its added to `file.messages`.
    *
-   * @param {string|Error|VFileMessage} reason
-   *   Human readable reason for the message, uses the stack and message of the error if given.
-   * @param {Node|NodeLike|Position|Point} [place]
-   *   Place where the message occurred in the file.
-   * @param {string} [origin]
-   *   Computer readable reason for the message
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
    * @returns {VFileMessage}
    *   Message.
    */
@@ -2854,19 +2877,24 @@ var VFile = class {
     return message;
   }
   /**
-   * Like `VFile#message()`, but associates a fatal message where `fatal` is
-   * set to `true`, and then immediately throws it.
+   * Create a fatal error associated with the file.
+   *
+   * Its `fatal` is set to `true` and `file` is set to the current file path.
+   * Its added to `file.messages`.
    *
    * > 👉 **Note**: a fatal error means that a file is no longer processable.
    *
-   * @param {string|Error|VFileMessage} reason
-   *   Human readable reason for the message, uses the stack and message of the error if given.
-   * @param {Node|NodeLike|Position|Point} [place]
-   *   Place where the message occurred in the file.
-   * @param {string} [origin]
-   *   Computer readable reason for the message
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
    * @returns {never}
    *   Message.
+   * @throws {VFileMessage}
+   *   Message.
    */
   fail(reason, place, origin) {
     const message = this.message(reason, place, origin);
@@ -2891,6 +2919,9 @@ function assertPath2(path2, name) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
+function buffer(value) {
+  return (0, import_is_buffer.default)(value);
+}
 
 // ../../node_modules/unified/lib/index.js
 var unified = base().freeze();
@@ -3273,8 +3304,8 @@ function _printRaw(node) {
     case "argument":
       return [node.openMark, ..._printRaw(node.content), node.closeMark];
     case "comment":
-      var suffix = node.suffixParbreak ? "" : linebreak;
-      var leadingWhitespace = "";
+      let suffix = node.suffixParbreak ? "" : linebreak;
+      let leadingWhitespace = "";
       if (node.sameline && node.leadingWhitespace) {
         leadingWhitespace = " ";
       }
@@ -3290,9 +3321,9 @@ function _printRaw(node) {
     case "environment":
     case "mathenv":
     case "verbatim":
-      var env = _printRaw(node.env);
-      var envStart = [ESCAPE + "begin{", ...env, "}"];
-      var envEnd = [ESCAPE + "end{", ...env, "}"];
+      let env = _printRaw(node.env);
+      let envStart = [ESCAPE + "begin{", ...env, "}"];
+      let envEnd = [ESCAPE + "end{", ...env, "}"];
       argsString = node.args == null ? [] : _printRaw(node.args);
       return [
         ...envStart,
@@ -21340,31 +21371,14 @@ function gobbleSingleArgument(nodes, argSpec, startPos = 0) {
   const openMark = argSpec.openBrace || "";
   const closeMark = argSpec.closeBrace || "";
   const acceptGroup = (argSpec.type === "mandatory" || argSpec.type === "optional") && openMark === "{" && closeMark === "}";
-  function findBracePositions() {
-    let openMarkPos = null;
-    if (openMark) {
-      openMarkPos = nodes.findIndex(
-        (node, i) => i >= currPos && match.string(node, openMark)
-      );
-      if (openMarkPos < currPos) {
-        openMarkPos = null;
-      }
-    }
-    let closeMarkPos = null;
-    if (openMarkPos != null) {
-      closeMarkPos = nodes.findIndex(
-        (node, i) => i >= openMarkPos + 1 && match.string(node, closeMark)
-      );
-      if (closeMarkPos < openMarkPos + 1) {
-        closeMarkPos = null;
-      }
-    }
-    return [openMarkPos, closeMarkPos];
-  }
   gobbleWhitespace();
   const currNode = nodes[currPos];
   if (currNode == null || match.comment(currNode) || match.parbreak(currNode)) {
-    return { argument: argument2, nodesRemoved: 0 };
+    const ret = {
+      argument: argument2,
+      nodesRemoved: 0
+    };
+    return ret;
   }
   switch (argSpec.type) {
     case "mandatory":
@@ -21379,6 +21393,21 @@ function gobbleSingleArgument(nodes, argSpec, startPos = 0) {
         });
         currPos++;
         break;
+      } else {
+        const bracePos2 = findBracePositions(
+          nodes,
+          currPos,
+          openMark,
+          closeMark
+        );
+        if (bracePos2) {
+          argument2 = arg(nodes.slice(bracePos2[0] + 1, bracePos2[1]), {
+            openMark,
+            closeMark
+          });
+          currPos = bracePos2[1] + 1;
+          break;
+        }
       }
     case "optional":
       if (acceptGroup && match.group(currNode)) {
@@ -21389,29 +21418,34 @@ function gobbleSingleArgument(nodes, argSpec, startPos = 0) {
         currPos++;
         break;
       }
-      if (match.string(currNode, openMark)) {
-        const [openMarkPos, closeMarkPos] = findBracePositions();
-        if (openMarkPos != null && closeMarkPos != null) {
-          argument2 = arg(nodes.slice(openMarkPos + 1, closeMarkPos), {
-            openMark,
-            closeMark
-          });
-          currPos = closeMarkPos + 1;
-          break;
-        }
+      const bracePos = findBracePositions(
+        nodes,
+        currPos,
+        openMark,
+        closeMark
+      );
+      if (bracePos) {
+        argument2 = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {
+          openMark,
+          closeMark
+        });
+        currPos = bracePos[1] + 1;
+        break;
       }
       break;
     case "optionalStar":
-    case "optionalToken":
-      if (match.string(
-        currNode,
+    case "optionalToken": {
+      const bracePos2 = findBracePositions(
+        nodes,
+        currPos,
         argSpec.type === "optionalStar" ? "*" : argSpec.token
-      )) {
-        argument2 = arg([currNode], { openMark: "", closeMark: "" });
-        currPos++;
-        break;
+      );
+      if (bracePos2) {
+        argument2 = arg(currNode, { openMark: "", closeMark: "" });
+        currPos = bracePos2[0] + 1;
       }
       break;
+    }
     case "until": {
       if (argSpec.stopTokens.length > 1) {
         console.warn(
@@ -21420,30 +21454,45 @@ function gobbleSingleArgument(nodes, argSpec, startPos = 0) {
         break;
       }
       const rawToken = argSpec.stopTokens[0];
-      const stopToken = rawToken === " " ? { type: "whitespace" } : { type: "string", content: argSpec.stopTokens[0] };
-      let matchPos = scan(nodes, stopToken, {
-        startIndex: startPos,
-        allowSubstringMatches: true
-      });
-      if (matchPos != null && partialStringMatch(nodes[matchPos], stopToken)) {
-        console.warn(
-          `"until" arguments that stop at non-punctuation symbols is not yet implemented`
-        );
-        break;
-      }
-      if (matchPos == null) {
+      const stopToken = rawToken === " " ? { type: "whitespace" } : rawToken;
+      let bracePos2 = findBracePositions(
+        nodes,
+        startPos,
+        void 0,
+        stopToken
+      );
+      if (!bracePos2) {
         break;
       }
-      argument2 = arg(nodes.slice(startPos, matchPos), {
+      argument2 = arg(nodes.slice(startPos, bracePos2[1]), {
         openMark: "",
         closeMark: rawToken
       });
-      currPos = matchPos;
+      currPos = bracePos2[1];
       if (currPos < nodes.length) {
         currPos++;
       }
       break;
     }
+    case "embellishment": {
+      for (const token of argSpec.embellishmentTokens) {
+        const bracePos2 = findBracePositions(nodes, currPos, token);
+        if (!bracePos2) {
+          continue;
+        }
+        let argNode = nodes[bracePos2[0] + 1];
+        argument2 = arg(
+          match.group(argNode) ? argNode.content : argNode,
+          {
+            openMark: token,
+            closeMark: ""
+          }
+        );
+        currPos = bracePos2[1] + 1;
+        break;
+      }
+      break;
+    }
     default:
       console.warn(
         `Don't know how to find an argument of argspec type "${argSpec.type}"`
@@ -21453,8 +21502,84 @@ function gobbleSingleArgument(nodes, argSpec, startPos = 0) {
   nodes.splice(startPos, nodesRemoved);
   return { argument: argument2, nodesRemoved };
 }
-function partialStringMatch(node, token) {
-  return match.anyString(node) && match.anyString(token) && node.content.length > token.content.length;
+function cloneStringNode(node, content) {
+  return Object.assign({}, node, { content });
+}
+function findBracePositions(nodes, startPos, openMark, closeMark) {
+  const currNode = nodes[startPos];
+  let openMarkPos = startPos;
+  let closeMarkPos = startPos;
+  if (openMark) {
+    if (!match.anyString(currNode)) {
+      return;
+    }
+    const nodeContent = currNode.content;
+    if (!nodeContent.startsWith(openMark)) {
+      return;
+    }
+    openMarkPos = startPos;
+    if (currNode.content.length > openMark.length) {
+      const nodeContent2 = currNode.content;
+      currNode.content = openMark;
+      nodes.splice(
+        openMarkPos + 1,
+        0,
+        cloneStringNode(currNode, nodeContent2.slice(openMark.length))
+      );
+    }
+    closeMarkPos = openMarkPos + 1;
+  }
+  if (!closeMark) {
+    const argNode = nodes[closeMarkPos];
+    if (!argNode) {
+      return;
+    }
+    if (match.anyString(argNode) && argNode.content.length > 1) {
+      const argContent = argNode.content;
+      argNode.content = argContent[0];
+      nodes.splice(
+        closeMarkPos + 1,
+        0,
+        cloneStringNode(argNode, argContent.slice(1))
+      );
+    }
+    return [openMarkPos, closeMarkPos];
+  }
+  closeMarkPos = scan(nodes, closeMark, {
+    startIndex: closeMarkPos,
+    allowSubstringMatches: true
+  });
+  if (closeMarkPos === null) {
+    return;
+  }
+  const closingNode = nodes[closeMarkPos];
+  if (match.anyString(closingNode) && typeof closeMark === "string") {
+    const closingNodeContent = closingNode.content;
+    let closeMarkIndex = closingNodeContent.indexOf(closeMark);
+    if (closingNodeContent.length > closeMark.length) {
+      closingNode.content = closeMark;
+      const prev = closingNodeContent.slice(0, closeMarkIndex);
+      const next = closingNodeContent.slice(
+        closeMarkIndex + closeMark.length
+      );
+      if (prev) {
+        nodes.splice(
+          closeMarkPos,
+          0,
+          cloneStringNode(closingNode, prev)
+        );
+        closeMarkPos++;
+      }
+      if (next) {
+        nodes.splice(
+          closeMarkPos + 1,
+          0,
+          cloneStringNode(closingNode, next)
+        );
+      }
+    }
+  }
+  return [openMarkPos, closeMarkPos];
 }
 function gobbleArguments(nodes, argSpec, startPos = 0) {
   if (typeof argSpec === "function") {
@@ -21466,20 +21591,50 @@ function gobbleArguments(nodes, argSpec, startPos = 0) {
   const args = [];
   let nodesRemoved = 0;
   for (const spec of argSpec) {
-    const { argument: argument2, nodesRemoved: removed } = gobbleSingleArgument(
-      nodes,
-      spec,
-      startPos
-    );
-    if (argument2) {
-      args.push(argument2);
-      nodesRemoved += removed;
+    if (spec.type === "embellishment") {
+      const remainingTokens = new Set(spec.embellishmentTokens);
+      const argForToken = Object.fromEntries(
+        spec.embellishmentTokens.map((t) => [t, emptyArg()])
+      );
+      let { argument: argument2, nodesRemoved: removed } = gobbleSingleArgument(
+        nodes,
+        embellishmentSpec(remainingTokens),
+        startPos
+      );
+      while (argument2) {
+        const token = argument2.openMark;
+        remainingTokens.delete(token);
+        argForToken[token] = argument2;
+        nodesRemoved += removed;
+        const newSpec = embellishmentSpec(remainingTokens);
+        ({ argument: argument2, nodesRemoved: removed } = gobbleSingleArgument(
+          nodes,
+          newSpec,
+          startPos
+        ));
+      }
+      args.push(...spec.embellishmentTokens.map((t) => argForToken[t]));
     } else {
-      args.push(arg([], { openMark: "", closeMark: "" }));
+      const { argument: argument2, nodesRemoved: removed } = gobbleSingleArgument(
+        nodes,
+        spec,
+        startPos
+      );
+      args.push(argument2 || emptyArg());
+      nodesRemoved += removed;
     }
   }
   return { args, nodesRemoved };
 }
+function embellishmentSpec(tokens) {
+  return {
+    type: "embellishment",
+    embellishmentTokens: [...tokens]
+  };
+}
+function emptyArg() {
+  return arg([], { openMark: "", closeMark: "" });
+}
 function attachMacroArgsInArray(nodes, macros17) {
   let currIndex;
   const isRelevantMacro = match.createMacroMatcher(macros17);
@@ -21699,7 +21854,7 @@ var macros4 = {
 var environments4 = {};
 var macros5 = {
   // Special
-  "\\": { signature: "!s !o" },
+  "\\": { signature: "!s !o", renderInfo: { breakAfter: true } },
   _: { signature: "m", escapeToken: "" },
   "^": { signature: "m", escapeToken: "" },
   // \newcommand arg signature from https://www.texdev.net/2020/08/19/the-good-the-bad-and-the-ugly-creating-document-commands
@@ -22443,8 +22598,9 @@ var macros11 = {
 };
 var environments11 = {};
 (function() {
-  if (typeof globalThis === "object")
+  if (typeof globalThis === "object") {
     return;
+  }
   Object.defineProperty(Object.prototype, "__magic__", {
     get: function() {
       return this;
@@ -38496,7 +38652,7 @@ var processor = unified().use(unifiedLatexStringCompiler, { pretty: true }).free
 
 // libs/unified-latex.ts
 var processLatexViaUnified = (options) => {
-  return unified().use(unifiedLatexFromString).use(
+  return unified().use(unifiedLatexFromString, options).use(
     unifiedLatexStringCompiler,
     Object.assign({ pretty: true }, options)
   );