{"version":3,"sources":["jsdelivr-header.js","/npm/@unified-latex/libs/argspec-parser.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,sECCA,SAAS,cAAc,GACnB,IAAI,EAAM,GAIH,OAHF,EAAmC,sBAC7B,GAAA,KAEJ,CACX,CAMgB,SAAA,SACZ,EACA,GAAO,GAEH,GAAgB,iBAAT,EACA,OAAA,EAGP,GAAA,MAAM,QAAQ,GAAO,CACf,MAAA,EAAW,EAAO,IAAM,GACvB,OAAA,EAAK,KAAK,GAAQ,SAAS,KAAM,KAAK,EAAQ,CAGnD,MAAA,EAAa,cAAc,GAC3B,EAAa,gBACf,eAAgB,EAAO,EAAK,gBAAa,EAE3B,kBAAd,EAAK,MAET,IAAI,EAAO,EAEX,MAAM,EAAO,EAAK,KAClB,OAAQ,GACJ,IAAK,OACD,OAAO,EAAa,IACxB,IAAK,eACD,OAAO,EAAa,IACxB,IAAK,gBACM,OAAA,EAAO,IAAM,EAAK,MAC7B,IAAK,WAQD,MANuB,MAAnB,EAAK,WAAyC,MAApB,EAAK,WACvB,GAAA,EAAK,WAAa,IAAM,KAExB,GAAA,EAAK,WAAa,IAAM,IACxB,GAAA,EAAK,UAAY,EAAK,YAE3B,EAAO,EAClB,IAAK,YAQD,MANuB,MAAnB,EAAK,WAAyC,MAApB,EAAK,WACvB,GAAA,KAEA,GAAA,EAAK,WAAa,IAAM,IACxB,GAAA,EAAK,UAAY,EAAK,YAE3B,EAAO,EAClB,IAAK,gBAED,OADQ,GAAA,EAAK,WAAa,IAAM,IAE5B,EACA,IACA,SAAS,EAAK,qBACd,IACA,EAER,IAAK,WACM,OAAA,EAAO,IAAM,EAAK,UAC7B,IAAK,QACD,OAAO,EAAO,IAAM,SAAS,EAAK,SAAW,IACjD,IAAK,QAAS,CACJ,MAAA,EAAa,SAAS,EAAK,YAC1B,OAAA,EAAW,OAAS,GAAuB,MAAlB,EAAW,GACrC,KAAK,KACL,IAAI,GAAU,CAExB,QACI,MAAM,EAAmB,EAElB,OADP,QAAQ,KAAK,sBAAsB,cAAuB,GACnD,GAEnB,CAEA,MAAM,WAAmD,CAAC,EAS1C,SAAA,MAAM,EAAM,IAExB,OADA,WAAW,GAAO,WAAW,IAAQ,iBAAU,MAAM,GAC9C,WAAW,EACtB,CAEA,SAAS,gBACL,EACA,GAEA,OAAK,GAGe,iBAAT,IACP,EAAO,CAAC,IAEP,EAGE,IAAI,EAAK,KAAK,GAAM,IAAI,OAAM,KAAK,OAF/B,IAAI,EAAK,KAAK,QANd,EASf,C","file":"/npm/@unified-latex/unified-latex-util-argspec@1.8.3/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@unified-latex/unified-latex-util-argspec@1.8.3/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","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"]}