end-of-semester-report/node_modules/@unified-latex/unified-latex-util-parse/index.cjs.map

{"version":3,"file":"index.cjs","sources":["../libs/compiler-ast.ts","../../../node_modules/bail/index.js","../../../node_modules/is-buffer/index.js","../../../node_modules/extend/index.js","../node_modules/is-plain-obj/index.js","../../../node_modules/trough/lib/index.js","../node_modules/unist-util-stringify-position/lib/index.js","../node_modules/vfile-message/lib/index.js","../node_modules/vfile/lib/minpath.browser.js","../node_modules/vfile/lib/minproc.browser.js","../node_modules/vfile/lib/minurl.shared.js","../node_modules/vfile/lib/minurl.browser.js","../node_modules/vfile/lib/index.js","../node_modules/unified/lib/index.js","../libs/parse-minimal.ts","../libs/plugin-from-string-minimal.ts","../libs/reparse-math.ts","../libs/process-macros-and-environments.ts","../libs/process-at-letter-and-expl-macros.ts","../libs/plugin-from-string.ts","../libs/parse.ts","../libs/parse-math.ts"],"sourcesContent":["import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin<void[], Ast.Root, Ast.Root> =\n    function unifiedLatexAstComplier() {\n        Object.assign(this, { Compiler: (x: Ast.Root) => x });\n    };\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   Pipeline.\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error | null | undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result && result.then && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   *\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason` at `place` from `origin`.\n   *\n   * When an error is passed in as `reason`, the `stack` is copied.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   *\n   *   > 👉 **Note**: you should use markdown.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // To do: next major: expose `undefined` everywhere instead of `null`.\n  constructor(reason, place, origin) {\n    /** @type {[string | null, string | null]} */\n    const parts = [null, null]\n    /** @type {Position} */\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {line: null, column: null},\n      // @ts-expect-error: \"\n      end: {line: null, column: null}\n    }\n\n    super()\n\n    if (typeof place === 'string') {\n      origin = place\n      place = undefined\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        parts[1] = origin\n      } else {\n        parts[0] = origin.slice(0, index)\n        parts[1] = origin.slice(index + 1)\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          // To do: next major: deep clone.\n          // @ts-expect-error: looks like a position.\n          position = place.position\n        }\n      }\n      // Position.\n      else if ('start' in place || 'end' in place) {\n        // @ts-expect-error: looks like a position.\n        // To do: next major: deep clone.\n        position = place\n      }\n      // Point.\n      else if ('line' in place || 'column' in place) {\n        // To do: next major: deep clone.\n        position.start = place\n      }\n    }\n\n    // Fields from `Error`.\n    /**\n     * Serialized positional info of error.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(place) || '1:1'\n\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = typeof reason === 'object' ? reason.message : reason\n\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack = ''\n\n    if (typeof reason === 'object' && reason.stack) {\n      this.stack = reason.stack\n    }\n\n    /**\n     * Reason for message.\n     *\n     * > 👉 **Note**: you should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * State of problem.\n     *\n     * * `true` — marks associated file as no longer processable (error)\n     * * `false` — necessitates a (potential) change (warning)\n     * * `null | undefined` — for things that might not need changing (info)\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | null}\n     */\n    this.line = position.start.line\n\n    /**\n     * Starting column of error.\n     *\n     * @type {number | null}\n     */\n    this.column = position.start.column\n\n    /**\n     * Full unist position.\n     *\n     * @type {Position | null}\n     */\n    this.position = position\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | null}\n     */\n    this.source = parts[0]\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | null}\n     */\n    this.ruleId = parts[1]\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | null}\n     */\n    this.file\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | null}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | null}\n     */\n    this.expected\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | null}\n     */\n    this.url\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | null}\n     */\n    this.note\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | undefined} [ext]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string | undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number | undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * Check if `fileUrlOrPath` looks like a URL.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileUrlOrPath) {\n  return (\n    fileUrlOrPath !== null &&\n    typeof fileUrlOrPath === 'object' &&\n    // @ts-expect-error: indexable.\n    fileUrlOrPath.href &&\n    // @ts-expect-error: indexable.\n    fileUrlOrPath.origin\n  )\n}\n","/// <reference lib=\"dom\" />\n\nimport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string | URL} path\n *   File URL.\n * @returns {string}\n *   File URL.\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.charCodeAt(index) === 37 /* `%` */ &&\n      pathname.charCodeAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.charCodeAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n */\n\n/**\n * @typedef {Record<string, unknown> & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *\n *   This is a copy of the types from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Options | URL | Value | VFile} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n *   Set multiple values.\n * @property {Value | null | undefined} [value]\n *   Set `value`.\n * @property {string | null | undefined} [cwd]\n *   Set `cwd`.\n * @property {Array<string> | null | undefined} [history]\n *   Set `history`.\n * @property {URL | string | null | undefined} [path]\n *   Set `path`.\n * @property {string | null | undefined} [basename]\n *   Set `basename`.\n * @property {string | null | undefined} [stem]\n *   Set `stem`.\n * @property {string | null | undefined} [extname]\n *   Set `extname`.\n * @property {string | null | undefined} [dirname]\n *   Set `dirname`.\n * @property {Data | null | undefined} [data]\n *   Set `data`.\n *\n * @typedef Map\n *   Raw source map.\n *\n *   See:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n *   Which version of the source map spec this map is following.\n * @property {Array<string>} sources\n *   An array of URLs to the original source files.\n * @property {Array<string>} names\n *   An array of identifiers which can be referenced by individual mappings.\n * @property {string | undefined} [sourceRoot]\n *   The URL root from which all sources are relative.\n * @property {Array<string> | undefined} [sourcesContent]\n *   An array of contents of the original source files.\n * @property {string} mappings\n *   A string of base64 VLQs which contain the actual mappings.\n * @property {string} file\n *   The generated file this source map is associated with.\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration.\n *\n *   A bunch of keys that will be shallow copied over to the new file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n *   Configuration for reporters.\n */\n\n/**\n * @template {ReporterSettings} Settings\n *   Options type.\n * @callback Reporter\n *   Type for a reporter.\n * @param {Array<VFile>} files\n *   Files to report.\n * @param {Settings} options\n *   Configuration.\n * @returns {string}\n *   Report.\n */\n\nimport bufferLike from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n *\n * @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>}\n */\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Buffer` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (typeof value === 'string' || buffer(value)) {\n      options = {value}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else {\n      options = value\n    }\n\n    /**\n     * Place to store custom information (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * List of filepaths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    this.cwd = proc.cwd()\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        prop in options &&\n        options[prop] !== undefined &&\n        options[prop] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) {\n        // @ts-expect-error: fine to set other things.\n        this[prop] = options[prop]\n      }\n    }\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {string | URL} path\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   */\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = path.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = path.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.charCodeAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = path.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? path.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Buffer`\n   *   (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    return (this.value || '').toString(encoding || undefined)\n  }\n\n  /**\n   * Create a warning message associated with the file.\n   *\n   * Its `fatal` is set to `false` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin)\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Create an info message associated with the file.\n   *\n   * Its `fatal` is set to `null` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = null\n\n    return message\n  }\n\n  /**\n   * Create a fatal error associated with the file.\n   *\n   * Its `fatal` is set to `true` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Message.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {void}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is a buffer.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Buffer}\n *   Whether `value` is a Node.js buffer.\n */\nfunction buffer(value) {\n  return bufferLike(value)\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n  const transformers = trough()\n  /** @type {Processor['attachers']} */\n  const attachers = []\n  /** @type {Record<string, unknown>} */\n  let namespace = {}\n  /** @type {boolean|undefined} */\n  let frozen\n  let freezeIndex = -1\n\n  // Data management.\n  // @ts-expect-error: overloads are handled.\n  processor.data = data\n  processor.Parser = undefined\n  processor.Compiler = undefined\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  // @ts-expect-error: overloads are handled.\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  // @ts-expect-error: overloads are handled.\n  processor.run = run\n  processor.runSync = runSync\n  // @ts-expect-error: overloads are handled.\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  /** @type {Processor} */\n  function processor() {\n    const destination = base()\n    let index = -1\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  /** @type {Processor['freeze']} */\n  function freeze() {\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      /** @type {Transformer|void} */\n      const transformer = attacher.call(processor, ...options)\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Number.POSITIVE_INFINITY\n\n    return processor\n  }\n\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n  function use(value, ...options) {\n    /** @type {Record<string, unknown>|undefined} */\n    let settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...options] = value\n          addPlugin(plugin, ...options)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {void}\n     */\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {...unknown} [value]\n     * @returns {void}\n     */\n    function addPlugin(plugin, value) {\n      let index = -1\n      /** @type {Processor['attachers'][number]|undefined} */\n      let entry\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index]\n          break\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments])\n      }\n    }\n  }\n\n  /** @type {Processor['parse']} */\n  function parse(doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /** @type {Processor['stringify']} */\n  function stringify(node, doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n  function run(node, doc, callback) {\n    assertNode(node)\n    processor.freeze()\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc\n      doc = undefined\n    }\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done)\n\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['runSync']} */\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    // @ts-expect-error: we either bailed on an error or have a tree.\n    return result\n\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n    function done(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n  function process(doc, callback) {\n    processor.freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      const file = vfile(doc)\n\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error)\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file)\n\n          if (result === undefined || result === null) {\n            // Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result\n          } else {\n            file.result = result\n          }\n\n          done(error, file)\n        }\n      })\n\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n      function done(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['processSync']} */\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n\n    const file = vfile(doc)\n\n    processor.process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    // type-coverage:ignore-next-line\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\nfunction keys(value) {\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value)\n}\n","import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n    return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n    return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n","import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n    /**\n     * Whether the text will be parsed assuming math mode or not.\n     */\n    mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n    PluginOptions[],\n    string,\n    Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n    const parser: Parser<Ast.Root> = (str) => {\n        if (options?.mode === \"math\") {\n            return {\n                type: \"root\",\n                content: parseMathMinimal(str),\n                _renderInfo: { inMathMode: true },\n            };\n        }\n        return parseMinimal(str);\n    };\n\n    Object.assign(this, { Parser: parser });\n};\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n    | {\n          /**\n           * List of environments whose body should be parsed in math mode\n           */\n          mathEnvs: string[];\n          /**\n           * List of macros whose bodies should be parsed in math mode\n           */\n          mathMacros: string[];\n      }\n    | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexReparseMath(options) {\n    const { mathEnvs = [], mathMacros = [] } = options || {};\n\n    return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n    mathEnvs,\n    mathMacros,\n}: {\n    mathEnvs: string[];\n    mathMacros: string[];\n}) {\n    const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n    const isMathMacro = match.createMacroMatcher(mathMacros);\n\n    return (tree: Ast.Root) => {\n        visit(\n            tree,\n            (node) => {\n                if (match.anyMacro(node)) {\n                    for (const arg of node.args || []) {\n                        if (\n                            arg.content.length > 0 &&\n                            !wasParsedInMathMode(arg.content)\n                        ) {\n                            arg.content = parseMathMinimal(\n                                printRaw(arg.content)\n                            );\n                        }\n                    }\n                }\n                if (match.anyEnvironment(node)) {\n                    if (!wasParsedInMathMode(node.content)) {\n                        node.content = parseMathMinimal(printRaw(node.content));\n                    }\n                }\n            },\n            {\n                test: (node) => isMathEnvironment(node) || isMathMacro(node),\n            }\n        );\n    };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n    return !nodes.some(\n        (node) =>\n            // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n            // that we were not parsed in math mode.\n            (match.anyString(node) && node.content.length > 1) ||\n            match.string(node, \"^\") ||\n            match.string(node, \"_\")\n    );\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n    EnvInfoRecord,\n    MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexReparseMathConstructPlugin } from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n    | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n    | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n    const { environments = {}, macros = {} } = options || {};\n\n    const mathMacros = Object.fromEntries(\n        Object.entries(macros).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n    const mathEnvs = Object.fromEntries(\n        Object.entries(environments).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n\n    const mathReparser = unifiedLatexReparseMathConstructPlugin({\n        mathEnvs: Object.keys(mathEnvs),\n        mathMacros: Object.keys(mathMacros),\n    });\n\n    const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n    const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n    return (tree) => {\n        // First we attach all arguments/process all nodes/environments that have math content\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, mathMacros);\n                },\n                leave: (node) => {\n                    if (!isRelevantMathEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n\n        // Next we reparse macros/envs that may not have been parsed in math mode\n        mathReparser(tree);\n\n        // Now we attach all arguments/process all environment bodies\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, macros);\n                },\n                leave: (node) => {\n                    if (!isRelevantEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n    };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n    hasReparsableMacroNames,\n    reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n    | {\n          /**\n           * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n           * If this option is true, it disables autodetect.\n           */\n          atLetter?: boolean;\n          /**\n           * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n           * If this option is true, it disables autodetect.\n           */\n          expl3?: boolean;\n          /**\n           * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n           * Defaults to `true`.\n           */\n          autodetectExpl3AndAtLetter?: boolean;\n      }\n    | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n    let {\n        atLetter = false,\n        expl3 = false,\n        autodetectExpl3AndAtLetter = false,\n    } = options || {};\n\n    return (tree) => {\n        // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n        reparseExpl3AndAtLetterRegions(tree);\n        if (atLetter || expl3) {\n            autodetectExpl3AndAtLetter = false;\n        }\n        if (autodetectExpl3AndAtLetter) {\n            atLetter = hasReparsableMacroNames(tree, \"@\");\n            // We don't check for the `:` here because it could be prone to misidentification.\n            expl3 = hasReparsableMacroNames(tree, \"_\");\n        }\n        const charSet: Set<string> = new Set();\n        if (atLetter) {\n            charSet.add(\"@\");\n        }\n        if (expl3) {\n            charSet.add(\":\");\n            charSet.add(\"_\");\n        }\n\n        if (charSet.size > 0) {\n            reparseMacroNames(tree, charSet);\n        }\n    };\n};\n","import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n    EnvInfoRecord,\n    MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n    unifiedLatexTrimEnvironmentContents,\n    unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n    | {\n          mode?: \"math\" | \"regular\";\n          macros?: MacroInfoRecord;\n          environments?: EnvInfoRecord;\n          flags?: {\n              /**\n               * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n               */\n              atLetter?: boolean;\n              /**\n               * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n               */\n              expl3?: boolean;\n              /**\n               * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n               * Defaults to `false`.\n               */\n              autodetectExpl3AndAtLetter?: boolean;\n          };\n      }\n    | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin<PluginOptions[], string, Ast.Root> =\n    function unifiedLatexFromString(options) {\n        const {\n            mode = \"regular\",\n            macros = {},\n            environments = {},\n            flags: {\n                atLetter = false,\n                expl3 = false,\n                autodetectExpl3AndAtLetter = false,\n            } = {},\n        } = options || {};\n\n        // Build up a parsing plugin with only unified components\n        const allMacroInfo: MacroInfoRecord = Object.assign(\n            {},\n            ...Object.values(macroInfo),\n            macros\n        );\n        const allEnvInfo: EnvInfoRecord = Object.assign(\n            {},\n            ...Object.values(environmentInfo),\n            environments\n        );\n\n        // Build up a parser that will perform all the needed steps\n        const fullParser = unified()\n            .use(unifiedLatexFromStringMinimal, { mode })\n            .use(unifiedLatexProcessAtLetterAndExplMacros, {\n                atLetter,\n                expl3,\n                autodetectExpl3AndAtLetter,\n            })\n            // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n            // so do a minimal pass first with just those environments.\n            .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n                macros: allMacroInfo,\n                environments: allEnvInfo,\n            })\n            .use(unifiedLatexTrimEnvironmentContents)\n            .use(unifiedLatexTrimRoot)\n            .use(unifiedLatexAstComplier);\n\n        const parser: Parser<Ast.Root> = (str) => {\n            const file = fullParser.processSync({ value: str });\n            return file.result;\n        };\n\n        Object.assign(this, { Parser: parser });\n    };\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { type FrozenProcessor, unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\nimport type { PluginOptions } from \"./plugin-from-string\";\n\nlet parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n    return parser.parse(str);\n}\n\n/**\n * Returns the default `unified-latex` parser, or create a new one with the\n * provided `unifiedLatexFromString` options\n * @param options Plugin options of `unifiedLatexFromString` plugin.\n * @returns The default `unified-latex` parser if `options` is `undefined`, or a\n * newly created `unified-latex` parser with the provided `options`.\n */\nexport function getParser(\n    options?: PluginOptions\n): FrozenProcessor<Ast.Root, Ast.Root, Ast.Root, void> {\n    return options\n        ? unified().use(unifiedLatexFromString, options).freeze()\n        : parser;\n}\n","import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n    if (typeof str !== \"string\") {\n        str = printRaw(str);\n    }\n    const file = unified()\n        .use(unifiedLatexFromString, { mode: \"math\" })\n        .use(unifiedLatexAstComplier)\n        .processSync({ value: str });\n    return (file.result as Ast.Root).content;\n}\n"],"names":["unifiedLatexAstComplier","isBuffer","isArray","isPlainObject","setProperty","getProperty","extend","index","point","position","path","assertPath","prop","dirname","basename","extname","bufferLike","parse","value","options","isPlainObj","file","LatexPegParser","unifiedLatexFromStringMinimal","parser","unifiedLatexReparseMath","match","visit","printRaw","unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse","attachMacroArgsInArray","processEnvironment","unifiedLatexProcessAtLetterAndExplMacros","reparseExpl3AndAtLetterRegions","hasReparsableMacroNames","reparseMacroNames","unifiedLatexFromString","macroInfo","environmentInfo","unifiedLatexTrimEnvironmentContents","unifiedLatexTrimRoot"],"mappings":"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","x_google_ignoreList":[1,2,3,4,5,6,7,8,9,10,11,12,13]}