{"version":3,"file":"index.cjs","names":[],"sources":["../libs/gobble-single-argument.ts","../libs/gobble-arguments.ts","../libs/attach-arguments.ts","../libs/unified-latex-attach-macro-arguments.ts","../libs/get-args-content.ts","../index.ts"],"sourcesContent":["/* eslint-disable no-fallthrough */\nimport { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n    ArgSpecAst as ArgSpec,\n    printRaw,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { scan } from \"@unified-latex/unified-latex-util-scan\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`.\n * If an argument couldn't be found, `argument` will be `null`.\n */\nexport function gobbleSingleArgument(\n    nodes: Ast.Node[],\n    argSpec: ArgSpec.Node,\n    startPos = 0\n): {\n    argument: Ast.Argument | null;\n    nodesRemoved: number;\n} {\n    if (typeof argSpec === \"string\" || !argSpec.type) {\n        throw new Error(\n            `argSpec must be an already-parsed argument specification, not \"${JSON.stringify(\n                argSpec\n            )}\"`\n        );\n    }\n\n    let argument: Ast.Argument | null = null;\n\n    let currPos = startPos;\n\n    // Gobble whitespace from `currPos` onward, updating `currPos`.\n    // If `argSpec` specifies leading whitespace is not allowed,\n    // this function does nothing.\n    const gobbleWhitespace = (argSpec as ArgSpec.LeadingWhitespace)\n        .noLeadingWhitespace\n        ? () => {}\n        : () => {\n              while (currPos < nodes.length) {\n                  if (!match.whitespace(nodes[currPos])) {\n                      break;\n                  }\n                  currPos++;\n              }\n          };\n\n    const openMark: string = (argSpec as any).openBrace || \"\";\n    const closeMark: string = (argSpec as any).closeBrace || \"\";\n\n    // Only mandatory arguments can be wrapped in {...}.\n    // Since we already parse such things as groups, we need to\n    // check the open and closing symbols to see if we allow for\n    // groups to be accepted as arguments\n    const acceptGroup =\n        (argSpec.type === \"mandatory\" || argSpec.type === \"optional\") &&\n        openMark === \"{\" &&\n        closeMark === \"}\";\n\n    // Do the actual matching\n    gobbleWhitespace();\n    const currNode = nodes[currPos];\n    if (\n        currNode == null ||\n        match.comment(currNode) ||\n        match.parbreak(currNode)\n    ) {\n        const ret: { argument: null; nodesRemoved: number } = {\n            argument,\n            nodesRemoved: 0,\n        };\n        return ret;\n    }\n\n    switch (argSpec.type) {\n        case \"mandatory\":\n            if (acceptGroup) {\n                // We have already gobbled whitespace, so at this point, `currNode`\n                // is either an openMark or we don't have an optional argument.\n                let content: Ast.Node[] = [currNode];\n                if (match.group(currNode)) {\n                    // Unwrap a group if there is one.\n                    content = currNode.content;\n                }\n                argument = arg(content, {\n                    openMark,\n                    closeMark,\n                });\n                currPos++;\n                break;\n            } else {\n                const bracePos = findBracePositions(\n                    nodes,\n                    currPos,\n                    openMark,\n                    closeMark\n                );\n                if (bracePos) {\n                    argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n                        openMark,\n                        closeMark,\n                    });\n                    currPos = bracePos[1] + 1;\n                    break;\n                }\n            }\n        // NOTE: Fallthrough is on purpose.\n        // Matching a mandatory argument and an optional argument is the same for our purposes\n        // because we're not going to fail to parse because of a missing argument.\n        case \"optional\":\n            // It is possible that an optional argument accepts a group if its open/close braces are `{}`\n            if (acceptGroup && match.group(currNode)) {\n                argument = arg(currNode.content, {\n                    openMark,\n                    closeMark,\n                });\n                currPos++;\n                break;\n            }\n            // If we're here, we have custom braces to match\n            const bracePos = findBracePositions(\n                nodes,\n                currPos,\n                openMark,\n                closeMark\n            );\n            if (bracePos) {\n                argument = arg(nodes.slice(bracePos[0] + 1, bracePos[1]), {\n                    openMark,\n                    closeMark,\n                });\n                currPos = bracePos[1] + 1;\n                break;\n            }\n            break;\n        case \"optionalStar\":\n        case \"optionalToken\": {\n            const bracePos = findBracePositions(\n                nodes,\n                currPos,\n                argSpec.type === \"optionalStar\" ? \"*\" : argSpec.token\n            );\n            if (bracePos) {\n                argument = arg(currNode, { openMark: \"\", closeMark: \"\" });\n                // Instead of `closeMarkPos` returned from findBracePositions,\n                // one should use `openMarkPos + ` because there's no argument\n                currPos = bracePos[0] + 1;\n            }\n            break;\n        }\n        case \"until\": {\n            if (argSpec.stopTokens.length > 1) {\n                console.warn(\n                    `\"until\" matches with multi-token stop conditions are not yet implemented`\n                );\n                break;\n            }\n            const rawToken = argSpec.stopTokens[0];\n            const stopToken: string | Ast.Whitespace =\n                rawToken === \" \" ? { type: \"whitespace\" } : rawToken;\n\n            let bracePos = findBracePositions(\n                nodes,\n                startPos,\n                undefined,\n                stopToken\n            );\n            // If the corresponding token is not found, eat nothing;\n            if (!bracePos) {\n                break;\n            }\n\n            argument = arg(nodes.slice(startPos, bracePos[1]), {\n                openMark: \"\",\n                closeMark: rawToken,\n            });\n            currPos = bracePos[1];\n            if (currPos < nodes.length) {\n                currPos++;\n            }\n            break;\n        }\n        case \"embellishment\": {\n            for (const token of argSpec.embellishmentTokens) {\n                const bracePos = findBracePositions(nodes, currPos, token);\n                if (!bracePos) {\n                    continue;\n                }\n                let argNode = nodes[bracePos[0] + 1];\n                argument = arg(\n                    match.group(argNode) ? argNode.content : argNode,\n                    {\n                        openMark: token,\n                        closeMark: \"\",\n                    }\n                );\n                currPos = bracePos[1] + 1;\n                break;\n            }\n            break;\n        }\n        default:\n            console.warn(\n                `Don't know how to find an argument of argspec type \"${argSpec.type}\"`\n            );\n    }\n\n    // `currPos` is has already stepped past any whitespace. However,\n    // if we did not consume an argument, we don't want to consume the whitespace.\n    const nodesRemoved = argument ? currPos - startPos : 0;\n    nodes.splice(startPos, nodesRemoved);\n    return { argument, nodesRemoved };\n}\n\nfunction cloneStringNode(node: Ast.String, content: string): Ast.String {\n    return Object.assign({}, node, { content });\n}\n\n/**\n * Find the position of the open brace and the closing brace.\n * Returns undefined if the brace isn't found.\n * This may mutate `nodes`, if braces are not a kind of characters that are\n * always parsed as a separate token\n */\nfunction findBracePositions(\n    nodes: Ast.Node[],\n    startPos: number,\n    openMark?: string,\n    closeMark?: string | Ast.Node\n): [number, number] | undefined {\n    const currNode = nodes[startPos];\n    let openMarkPos = startPos;\n    let closeMarkPos: number | null = startPos;\n    if (openMark) {\n        if (!match.anyString(currNode)) {\n            return;\n        }\n        const nodeContent = currNode.content;\n        // The first node we encounter must contain the opening brace.\n        if (!nodeContent.startsWith(openMark)) {\n            return;\n        }\n        openMarkPos = startPos;\n        if (currNode.content.length > openMark.length) {\n            const nodeContent = currNode.content;\n            currNode.content = openMark;\n            nodes.splice(\n                openMarkPos + 1,\n                0,\n                cloneStringNode(currNode, nodeContent.slice(openMark.length))\n            );\n        }\n        closeMarkPos = openMarkPos + 1;\n    }\n    if (!closeMark) {\n        // In such a case, the token immediately preceding the opening brace\n        // will be treated as an argument. If the next token is a string node,\n        // only its first character is picked up.\n        const argNode = nodes[closeMarkPos];\n        if (!argNode) {\n            return;\n        }\n        if (match.anyString(argNode) && argNode.content.length > 1) {\n            const argContent = argNode.content;\n            argNode.content = argContent[0];\n            nodes.splice(\n                closeMarkPos + 1,\n                0,\n                cloneStringNode(argNode, argContent.slice(1))\n            );\n        }\n        return [openMarkPos, closeMarkPos];\n    }\n    // scan for closing marks\n    closeMarkPos = scan(nodes, closeMark, {\n        startIndex: closeMarkPos,\n        allowSubstringMatches: true,\n    });\n    if (closeMarkPos === null) {\n        return;\n    }\n    const closingNode = nodes[closeMarkPos];\n    if (match.anyString(closingNode) && typeof closeMark === \"string\") {\n        const closingNodeContent = closingNode.content;\n        let closeMarkIndex = closingNodeContent.indexOf(closeMark);\n        if (closingNodeContent.length > closeMark.length) {\n            closingNode.content = closeMark;\n            const prev = closingNodeContent.slice(0, closeMarkIndex);\n            const next = closingNodeContent.slice(\n                closeMarkIndex + closeMark.length\n            );\n            if (prev) {\n                nodes.splice(\n                    closeMarkPos,\n                    0,\n                    cloneStringNode(closingNode, prev)\n                );\n                closeMarkPos++;\n            }\n            if (next) {\n                nodes.splice(\n                    closeMarkPos + 1,\n                    0,\n                    cloneStringNode(closingNode, next)\n                );\n            }\n        }\n    }\n    return [openMarkPos, closeMarkPos];\n}\n","import { arg } from \"@unified-latex/unified-latex-builder\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { ArgumentParser } from \"@unified-latex/unified-latex-types\";\nimport {\n    ArgSpecAst as ArgSpec,\n    parse as parseArgspec,\n} from \"@unified-latex/unified-latex-util-argspec\";\nimport { gobbleSingleArgument } from \"./gobble-single-argument\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\n\n/**\n * Gobbles an argument of whose type is specified\n * by `argSpec` starting at the position `startPos`. If an argument couldn't be found,\n * `argument` will be `null`.\n */\nexport function gobbleArguments(\n    nodes: Ast.Node[],\n    argSpec: string | ArgSpec.Node[] | ArgumentParser,\n    startPos = 0\n): {\n    args: Ast.Argument[];\n    nodesRemoved: number;\n} {\n    if (typeof argSpec === \"function\") {\n        return argSpec(nodes, startPos);\n    }\n\n    if (typeof argSpec === \"string\") {\n        argSpec = parseArgspec(argSpec);\n    }\n\n    const args: Ast.Argument[] = [];\n    let nodesRemoved = 0;\n\n    for (const spec of argSpec) {\n        if (spec.type === \"embellishment\") {\n            // We need special behavior for embellishment argspecs.\n            // Because an embellishment argspec specifies more than one argument,\n            // we need to keep gobbling arguments until we've got them all.\n            const remainingTokens = new Set(spec.embellishmentTokens);\n            const argForToken = Object.fromEntries(\n                spec.embellishmentTokens.map((t, i) => {\n                    // For empty arguments, we also store their default.\n                    const defaultArg =\n                        \"defaultArg\" in spec ? spec.defaultArg?.[i] : undefined;\n                    return [t, emptyArg(defaultArg)];\n                })\n            );\n\n            let { argument, nodesRemoved: removed } = gobbleSingleArgument(\n                nodes,\n                embellishmentSpec(remainingTokens),\n                startPos\n            );\n            while (argument) {\n                const token = argument.openMark;\n                remainingTokens.delete(token);\n                argForToken[token] = argument;\n                nodesRemoved += removed;\n                const newSpec = embellishmentSpec(remainingTokens);\n                ({ argument, nodesRemoved: removed } = gobbleSingleArgument(\n                    nodes,\n                    newSpec,\n                    startPos\n                ));\n            }\n\n            args.push(...spec.embellishmentTokens.map((t) => argForToken[t]));\n        } else {\n            const { argument, nodesRemoved: removed } = gobbleSingleArgument(\n                nodes,\n                spec,\n                startPos\n            );\n            // For empty arguments, we also store their default.\n            const defaultArg =\n                \"defaultArg\" in spec ? spec.defaultArg : undefined;\n            args.push(argument || emptyArg(defaultArg));\n            nodesRemoved += removed;\n        }\n    }\n\n    return { args, nodesRemoved };\n}\n\n/**\n * Create an embellishment argspec from a set of tokens.\n */\nfunction embellishmentSpec(tokens: Set<string>): ArgSpec.Embellishment {\n    return {\n        type: \"embellishment\",\n        embellishmentTokens: [...tokens],\n    };\n}\n\n/**\n * Create an empty argument.\n */\nfunction emptyArg(defaultArg?: string): Ast.Argument {\n    const ret = arg([], { openMark: \"\", closeMark: \"\" });\n    if (defaultArg != null) {\n        updateRenderInfo(ret, { defaultArg });\n    }\n    return ret;\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { updateRenderInfo } from \"@unified-latex/unified-latex-util-render-info\";\nimport { gobbleArguments } from \"./gobble-arguments\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Search (in a right-associative way) through the array for instances of\n * `macros` and attach arguments to the macro. Argument signatures are\n * specified by `macros[].signature`.\n *\n * Info stored in `macros[].renderInfo` will be attached to the node\n * with attribute `_renderInfo`.\n */\nexport function attachMacroArgsInArray(\n    nodes: Ast.Node[],\n    macros: MacroInfoRecord\n): void {\n    // Some preliminaries that are only used if `ast` is an array.\n    let currIndex: number;\n\n    /**\n     * Determine whether `node` matches one of the macros in `macros`.\n     * Care is taken when matching because not all macros have\n     * `\\` as their escape token.\n     */\n    const isRelevantMacro = match.createMacroMatcher(macros);\n\n    function gobbleUntilMacro() {\n        // Step backwards until we find the required macro\n        while (currIndex >= 0 && !isRelevantMacro(nodes[currIndex])) {\n            currIndex--;\n        }\n    }\n\n    // Search for an occurrence of any of the macros `macroName` and its arguments.\n    // Some macros are right-associative, so we should start searching from\n    // the right\n    currIndex = nodes.length - 1;\n    while (currIndex >= 0) {\n        gobbleUntilMacro();\n        if (currIndex < 0) {\n            // We didn't find an occurrence of the macro\n            return;\n        }\n\n        // Store the currIndex, which is where the macro is. Start searching\n        // for its arguments at the next index.\n        const macroIndex = currIndex;\n        const macro = nodes[macroIndex] as Ast.Macro;\n        const macroName = macro.content;\n        const macroInfo = macros[macroName];\n\n        // Add `._renderInfo` if we have any\n        updateRenderInfo(macro, macroInfo.renderInfo);\n\n        const signatureOrParser =\n            macroInfo.argumentParser || macroInfo.signature;\n\n        // If the macro has no signature, it shouldn't consume any arguments. Just move along.\n        // Note: It is important that this happens *after* `updateRenderInfo` is called, since\n        // we still want to update the render info even if there are no args.\n        if (signatureOrParser == null) {\n            currIndex--;\n            continue;\n        }\n\n        // We don't want to search for macro arguments if we already\n        // found them. If the macro has arguments, we assume that\n        // they've already been attached\n        if (macro.args != null) {\n            currIndex = macroIndex - 1;\n            continue;\n        }\n\n        // `currIndex` is the position of the macro. We want to start\n        // looking for the arguments right after the macro\n        currIndex++;\n        const { args } = gobbleArguments(nodes, signatureOrParser, currIndex);\n        macro.args = args;\n        // After we've gobbled the arguments, set\n        // ourselves one space before the macro so we can continue.\n        currIndex = macroIndex - 1;\n    }\n}\n\n/**\n * Recursively search for and attach the arguments for a\n * particular macro to its AST node. `macros` should\n * contain a `signature` property which specifies the arguments\n * signature in xparse syntax.\n */\nexport function attachMacroArgs(tree: Ast.Ast, macros: MacroInfoRecord) {\n    visit(\n        tree,\n        (nodes) => {\n            attachMacroArgsInArray(nodes, macros);\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n}\n","import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { attachMacroArgsInArray } from \"./attach-arguments\";\n\ntype PluginOptions = { macros: MacroInfoRecord } | undefined;\n\n/**\n * Unified plugin to attach macro arguments to the macros specified via the `macros`\n * option.\n *\n * @param macros An object whose keys are macro names and values contains information about the macro and its argument signature.\n */\nexport const unifiedLatexAttachMacroArguments: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n    return (tree) => {\n        const { macros = {} } = options || {};\n        if (Object.keys(macros).length === 0) {\n            console.warn(\n                \"Attempting to attach macro arguments but no macros are specified.\"\n            );\n        }\n        visit(\n            tree,\n            (nodes) => {\n                attachMacroArgsInArray(nodes, macros);\n            },\n            { includeArrays: true, test: Array.isArray }\n        );\n    };\n};\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Returns the content of `args` for a macro or environment as an array. If an argument\n * was omitted (e.g., because it was an optional arg that wasn't included), then `null` is returned.\n */\nexport function getArgsContent(\n    node: Ast.Macro | Ast.Environment\n): (Ast.Node[] | null)[] {\n    if (!Array.isArray(node.args)) {\n        return [];\n    }\n\n    return node.args.map((arg) => {\n        if (arg.openMark === \"\" && arg.content.length === 0) {\n            return null;\n        }\n        return arg.content;\n    });\n}\n\n/**\n * Returns the content of `args` for a macro or environment as an object whose keys are the \"names\"\n * of each argument. These names of the arguments must be specified in the `_renderInfo` prop. If `_renderInfo`\n * does not contain a `namedArguments` array, then an empty object will be returned.\n *\n * @namedArgumentsFallback - If `_renderInfo.namedArguments` is not provided, `namedArgumentsFallback` is ued.\n */\nexport function getNamedArgsContent(\n    node: Ast.Macro | Ast.Environment,\n    namedArgumentsFallback: readonly (string | null)[] = []\n): Record<string, Ast.Node[] | null> {\n    const names = node._renderInfo?.namedArguments || namedArgumentsFallback;\n\n    if (\n        !Array.isArray(node.args) ||\n        !Array.isArray(names) ||\n        names.length === 0\n    ) {\n        return {};\n    }\n    const ret: Record<string, Ast.Node[] | null> = {};\n\n    node.args.forEach((arg, i) => {\n        const name = names[i];\n        if (name == null) {\n            // If a null name was given, it shouldn't be listed as a named argument.\n            return;\n        }\n        let val: Ast.Node[] | null = arg.content;\n        if (arg.openMark === \"\" && arg.content.length === 0) {\n            val = null;\n        }\n        ret[name] = val;\n    });\n\n    return ret;\n}\n","export { gobbleArguments } from \"./libs/gobble-arguments\";\nexport {\n    attachMacroArgs,\n    attachMacroArgsInArray,\n} from \"./libs/attach-arguments\";\nexport * from \"./libs/unified-latex-attach-macro-arguments\";\nexport * from \"./libs/get-args-content\";\nexport * from \"./libs/gobble-single-argument\";\nexport * from \"./libs/gobble-arguments\";\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions to help modify and attach arguments to macros in a `unified-latex` Abstract Syntax Tree (AST).\n *\n * By default, TeX doesn't actually have a concept of macro \"arguments\". Instead, TeX searches the\n * tokens after a macro and processes them according to the macro's rules. However, LaTeX attempts\n * to make macros look like functions that accept arguments. To attach the \"arguments\" to a macro\n * node, the `unified-latex` AST needs to be reparsed and manipulated.\n *\n * ## When should I use this?\n *\n * If you have custom macros that you want arguments attached to.\n *\n * If you know ahead of time which macros need arguments attached to them, use `unified-latex-util-parse`\n * and pass in the appropriate macro info instead.\n */\n"],"mappings":"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"}