{"version":3,"file":"index.cjs","names":[],"sources":["../libs/argspec-parser.ts","../libs/argspec-types.ts","../index.ts"],"sourcesContent":["import { ArgSpecPegParser as PegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as ArgSpec from \"./argspec-types\";\n\n/**\n * Produce a string containing any decorators for the argspec node.\n * For example, `!` in front of a node means \"don't accept leading whitespace\"\n */\nfunction getDecorators(node: ArgSpec.Node): string {\n    let ret = \"\";\n    if ((node as ArgSpec.LeadingWhitespace).noLeadingWhitespace) {\n        ret += \"!\";\n    }\n    return ret;\n}\n\n/**\n * Print an `xparse` argument specification AST\n * to a string.\n */\nexport function printRaw(\n    node: ArgSpec.Node | string | (ArgSpec.Node | string)[],\n    root = false\n): string {\n    if (typeof node === \"string\") {\n        return node;\n    }\n\n    if (Array.isArray(node)) {\n        const sepToken = root ? \" \" : \"\";\n        return node.map((tok) => printRaw(tok)).join(sepToken);\n    }\n\n    const decorators = getDecorators(node);\n    const defaultArg = printDefaultArg(\n        \"defaultArg\" in node ? node.defaultArg : undefined,\n        // `embellishment`s are the only spec that can have multiple default args\n        node.type === \"embellishment\"\n    );\n    let spec = decorators;\n\n    const type = node.type;\n    switch (type) {\n        case \"body\":\n            return decorators + \"b\";\n        case \"optionalStar\":\n            return decorators + \"s\";\n        case \"optionalToken\":\n            return spec + \"t\" + node.token;\n        case \"optional\":\n            // [...] is the default enclosure for optional arguments\n            if (node.openBrace === \"[\" && node.closeBrace === \"]\") {\n                spec += node.defaultArg ? \"O\" : \"o\";\n            } else {\n                spec += node.defaultArg ? \"D\" : \"d\";\n                spec += node.openBrace + node.closeBrace;\n            }\n            return spec + defaultArg;\n        case \"mandatory\":\n            // {...} is the default enclosure for mandatory arguments\n            if (node.openBrace === \"{\" && node.closeBrace === \"}\") {\n                spec += \"m\";\n            } else {\n                spec += node.defaultArg ? \"R\" : \"r\";\n                spec += node.openBrace + node.closeBrace;\n            }\n            return spec + defaultArg;\n        case \"embellishment\":\n            spec += node.defaultArg ? \"E\" : \"e\";\n            return (\n                spec +\n                \"{\" +\n                printRaw(node.embellishmentTokens) +\n                \"}\" +\n                defaultArg\n            );\n        case \"verbatim\":\n            return spec + \"v\" + node.openBrace;\n        case \"group\":\n            return spec + \"{\" + printRaw(node.content) + \"}\";\n        case \"until\": {\n            const stopTokens = printRaw(node.stopTokens);\n            return stopTokens.length > 1 || stopTokens[0] === \" \"\n                ? `u{${stopTokens}}`\n                : `u${stopTokens}`;\n        }\n        default:\n            const neverType: never = type;\n            console.warn(`Unknown node type \"${neverType}\" for node`, node);\n            return \"\";\n    }\n}\n\nconst parseCache: { [argStr: string]: ArgSpec.Node[] } = {};\n\n/**\n * Parse an `xparse` argument specification string to an AST.\n * This function caches results. Don't mutate the returned AST!\n *\n * @param {string} [str=\"\"] - LaTeX string input\n * @returns - AST for LaTeX string\n */\nexport function parse(str = \"\"): ArgSpec.Node[] {\n    parseCache[str] = parseCache[str] || PegParser.parse(str);\n    return parseCache[str];\n}\n\nfunction printDefaultArg(\n    args: string | string[] | undefined,\n    multipleArgs: boolean\n): string {\n    if (!args) {\n        return \"\";\n    }\n    if (typeof args === \"string\") {\n        args = [args];\n    }\n    if (!multipleArgs) {\n        return `{${args.join(\"\")}}`;\n    }\n    return `{${args.map((a) => `{${a}}`).join(\"\")}}`;\n}\n","export type Ast = Node[] | Node;\nexport type Node = Optional | Mandatory | Verbatim | Body | Group | Until;\ntype Optional = OptionalArg | OptionalStar | OptionalToken | Embellishment;\ninterface AstNode {\n    type: string;\n}\ninterface Arg extends AstNode {\n    openBrace: string;\n    closeBrace: string;\n}\nexport interface LeadingWhitespace {\n    noLeadingWhitespace: boolean | undefined;\n}\nexport interface DefaultArgument {\n    defaultArg?: string;\n}\nexport interface DefaultArguments {\n    defaultArg?: string[];\n}\ninterface Verbatim extends Arg {\n    type: \"verbatim\";\n}\ninterface OptionalArg extends LeadingWhitespace, DefaultArgument, Arg {\n    type: \"optional\";\n}\ninterface OptionalStar extends LeadingWhitespace, AstNode {\n    type: \"optionalStar\";\n}\ninterface OptionalToken extends LeadingWhitespace, AstNode {\n    type: \"optionalToken\";\n    token: string;\n}\nexport interface Embellishment extends DefaultArguments, AstNode {\n    type: \"embellishment\";\n    embellishmentTokens: string[];\n}\ninterface Mandatory extends LeadingWhitespace, DefaultArgument, Arg {\n    type: \"mandatory\";\n}\nexport interface Group extends AstNode {\n    type: \"group\";\n    content: (Group | string)[];\n}\ninterface Body extends AstNode {\n    type: \"body\";\n}\ninterface Until extends AstNode {\n    type: \"until\";\n    stopTokens: string[];\n}\n","export * from \"./libs/argspec-parser\";\nimport * as ArgSpecAst from \"./libs/argspec-types\";\nexport { ArgSpecAst };\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Tools to deal with `xparse` argument signatures. (E.g., `\"o m\"` for optional followed by mandatory\n * argument).\n *\n * ## When should I use this?\n *\n * If you are working on the internals of `unified-latex`.\n */\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAOA,SAAS,cAAc,MAA4B;CAC/C,IAAI,MAAM;AACV,KAAK,KAAmC,oBACpC,QAAO;AAEX,QAAO;;;;;;AAOX,SAAgB,SACZ,MACA,OAAO,OACD;AACN,KAAI,OAAO,SAAS,SAChB,QAAO;AAGX,KAAI,MAAM,QAAQ,KAAK,EAAE;EACrB,MAAM,WAAW,OAAO,MAAM;AAC9B,SAAO,KAAK,KAAK,QAAQ,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS;;CAG1D,MAAM,aAAa,cAAc,KAAK;CACtC,MAAM,aAAa,gBACf,gBAAgB,OAAO,KAAK,aAAa,KAAA,GAEzC,KAAK,SAAS,gBACjB;CACD,IAAI,OAAO;CAEX,MAAM,OAAO,KAAK;AAClB,SAAQ,MAAR;EACI,KAAK,OACD,QAAO,aAAa;EACxB,KAAK,eACD,QAAO,aAAa;EACxB,KAAK,gBACD,QAAO,OAAO,MAAM,KAAK;EAC7B,KAAK;AAED,OAAI,KAAK,cAAc,OAAO,KAAK,eAAe,IAC9C,SAAQ,KAAK,aAAa,MAAM;QAC7B;AACH,YAAQ,KAAK,aAAa,MAAM;AAChC,YAAQ,KAAK,YAAY,KAAK;;AAElC,UAAO,OAAO;EAClB,KAAK;AAED,OAAI,KAAK,cAAc,OAAO,KAAK,eAAe,IAC9C,SAAQ;QACL;AACH,YAAQ,KAAK,aAAa,MAAM;AAChC,YAAQ,KAAK,YAAY,KAAK;;AAElC,UAAO,OAAO;EAClB,KAAK;AACD,WAAQ,KAAK,aAAa,MAAM;AAChC,UACI,OACA,MACA,SAAS,KAAK,oBAAoB,GAClC,MACA;EAER,KAAK,WACD,QAAO,OAAO,MAAM,KAAK;EAC7B,KAAK,QACD,QAAO,OAAO,MAAM,SAAS,KAAK,QAAQ,GAAG;EACjD,KAAK,SAAS;GACV,MAAM,aAAa,SAAS,KAAK,WAAW;AAC5C,UAAO,WAAW,SAAS,KAAK,WAAW,OAAO,MAC5C,KAAK,WAAW,KAChB,IAAI;;EAEd;AAEI,WAAQ,KAAK,sBADY,KACoB,aAAa,KAAK;AAC/D,UAAO;;;AAInB,IAAM,aAAmD,EAAE;;;;;;;;AAS3D,SAAgB,MAAM,MAAM,IAAoB;AAC5C,YAAW,OAAO,WAAW,QAAQ,wCAAA,iBAAU,MAAM,IAAI;AACzD,QAAO,WAAW;;AAGtB,SAAS,gBACL,MACA,cACM;AACN,KAAI,CAAC,KACD,QAAO;AAEX,KAAI,OAAO,SAAS,SAChB,QAAO,CAAC,KAAK;AAEjB,KAAI,CAAC,aACD,QAAO,IAAI,KAAK,KAAK,GAAG,CAAC;AAE7B,QAAO,IAAI,KAAK,KAAK,MAAM,IAAI,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC"}