{"version":3,"file":"index.cjs","names":[],"sources":["../libs/builders.ts","../index.ts"],"sourcesContent":["import type * as Ast from \"@unified-latex/unified-latex-types\";\n\ntype CoercibleNode = string | Ast.Node;\ntype CoercibleArgument = null | CoercibleNode | Ast.Argument;\ntype MacroSpecialOptions = {\n    escapeToken?: string;\n};\ntype ArgumentsSpecialOptions = {\n    braces?: string;\n    defaultOpenMark?: string;\n    defaultCloseMark?: string;\n};\ntype ArgumentSpecialOptions = {\n    braces?: string;\n    openMark?: string;\n    closeMark?: string;\n};\n\nfunction normalizeNode(node: CoercibleNode): Ast.Node {\n    if (typeof node === \"string\") {\n        return s(node);\n    }\n    return node;\n}\n\nfunction normalizeArgument(\n    arg: CoercibleArgument,\n    openMark = \"{\",\n    closeMark = \"}\"\n): Ast.Argument {\n    if (arg == null) {\n        return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n    }\n    if (typeof arg === \"string\") {\n        return {\n            type: \"argument\",\n            openMark,\n            closeMark,\n            content: [s(arg)],\n        };\n    }\n    if (arg.type === \"argument\") {\n        return arg;\n    }\n    return { type: \"argument\", openMark, closeMark, content: [arg] };\n}\n\nfunction normalizeArgumentsList(\n    args?: CoercibleArgument | CoercibleArgument[],\n    openMark = \"{\",\n    closeMark = \"}\"\n): Ast.Argument[] {\n    if (args == null) {\n        return [];\n    }\n    if (Array.isArray(args)) {\n        return args.map((arg) => normalizeArgument(arg, openMark, closeMark));\n    }\n    return [normalizeArgument(args, openMark, closeMark)];\n}\n\ntype BracesPair = { openMark: string; closeMark: string };\nconst BRACES_MAP: Record<string, BracesPair> = {\n    \"*\": { openMark: \"\", closeMark: \"\" },\n    \"{\": { openMark: \"{\", closeMark: \"}\" },\n    \"[\": { openMark: \"[\", closeMark: \"]\" },\n    \"(\": { openMark: \"(\", closeMark: \")\" },\n    \"<\": { openMark: \"<\", closeMark: \">\" },\n};\nconst CLOSE_BRACES = new Set(\n    Object.values(BRACES_MAP)\n        .map((x) => x.closeMark)\n        .filter((x) => x)\n);\n\n/**\n * Turn a braces signature into an array of braces.\n */\nfunction bracesToOpenAndCloseMarks(braces: string): BracesPair[] {\n    const ret: BracesPair[] = [];\n\n    for (const char of braces.split(\"\")) {\n        if (CLOSE_BRACES.has(char)) {\n            continue;\n        }\n        const braces = BRACES_MAP[char];\n        if (braces == null) {\n            throw new Error(`Unknown open/close mark type \"${char}\"`);\n        }\n        braces;\n        ret.push(braces);\n    }\n\n    return ret;\n}\n\n/**\n * Create an Argument list. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * args([\"a\", \"b\"], { braces: \"[]{}\" });\n * ```\n * will result in arguments `[a]{b}`. Valid braces are `*`, `[`, `{`, `(`, and `<`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function args(\n    args: CoercibleArgument | CoercibleArgument[],\n    special?: ArgumentsSpecialOptions\n): Ast.Argument[] {\n    if (!Array.isArray(args)) {\n        args = [args];\n    }\n    if (special?.braces) {\n        const braces = bracesToOpenAndCloseMarks(special.braces);\n        if (braces.length !== args.length) {\n            throw new Error(\n                `There is a difference between the number of supplied braces and the number of supplied arguments. ${args.length} supplied with braces signature ${special.braces}`\n            );\n        }\n        return args.map((arg, i) =>\n            normalizeArgument(arg, braces[i].openMark, braces[i].closeMark)\n        );\n    }\n\n    const openMark = special?.defaultOpenMark ?? \"{\";\n    const closeMark = special?.defaultCloseMark ?? \"}\";\n    return normalizeArgumentsList(args, openMark, closeMark);\n}\n\n/**\n * Create an Argument. `special.braces` can optionally specify\n * the signature of the open/close marks that each argument uses. For example\n * ```\n * arg(\"a\", { braces: \"[]\" });\n * ```\n * will result in arguments `[a]`. Valid braces are `*`, `[`, `{`, `<`, and `(`.\n *\n * `null` may be passed as the value of an empty optional argument. If `null` is passed,\n * the `openBrace` and `closeBrace` of the argument will be set to empty strings and the\n * contents will be set to an empty array. For example,\n * ```\n * args([null, \"b\"], { braces: \"[]{}\" });\n * ```\n * will produce the same structure as if the the first \"optional argument\" were omitted in regular parsing.\n */\nexport function arg(\n    args: CoercibleArgument | Ast.Node[],\n    special?: ArgumentSpecialOptions\n): Ast.Argument {\n    if (args == null) {\n        return { type: \"argument\", content: [], openMark: \"\", closeMark: \"\" };\n    }\n    if (typeof args === \"string\") {\n        args = s(args);\n    }\n    if (!Array.isArray(args) && args.type === \"argument\") {\n        return args;\n    }\n\n    let openMark = special?.openMark ?? \"{\";\n    let closeMark = special?.closeMark ?? \"}\";\n    if (special?.braces) {\n        const braces = bracesToOpenAndCloseMarks(special.braces);\n        if (braces[0]) {\n            openMark = braces[0].openMark;\n            closeMark = braces[0].closeMark;\n        }\n    }\n\n    if (!Array.isArray(args)) {\n        args = [args];\n    }\n\n    return { type: \"argument\", content: args, openMark, closeMark };\n}\n\n/**\n * Create a Macro with the given `name`. The macro\n * may be followed by any number of arguments.\n */\nexport function m(\n    name: string,\n    marcoArgs?: CoercibleArgument | CoercibleArgument[],\n    special?: MacroSpecialOptions\n): Ast.Macro {\n    const args = normalizeArgumentsList(marcoArgs);\n    const escapeToken = special?.escapeToken;\n    const ret: Ast.Macro = { type: \"macro\", content: name };\n\n    if (args.length > 0) {\n        ret.args = args;\n    }\n    if (escapeToken != null) {\n        ret.escapeToken = escapeToken;\n    }\n\n    return ret;\n}\n\n/**\n * Create a String node from `value`\n */\nexport function s(value: string | Ast.String): Ast.String {\n    if (typeof value === \"string\") {\n        return { type: \"string\", content: value };\n    }\n    return value;\n}\n\n/**\n * Create an Environment node.\n */\nexport function env(\n    name: string,\n    body: CoercibleNode | CoercibleNode[],\n    envArgs?: CoercibleArgument | CoercibleArgument[],\n    special?: unknown\n): Ast.Environment {\n    if (!Array.isArray(body)) {\n        body = [body];\n    }\n    const args = normalizeArgumentsList(envArgs, \"[\", \"]\");\n    const ret: Ast.Environment = {\n        type: \"environment\",\n        env: name,\n        content: body.map(normalizeNode),\n    };\n    if (args.length > 0) {\n        ret.args = args;\n    }\n\n    return ret;\n}\n\n/**\n * Whitespace node.\n */\nexport const SP: Ast.Whitespace = { type: \"whitespace\" };\n","export * from \"./libs/builders\";\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 build a `unified-latex` Abstract Syntax Tree (AST)\n * with [hyperscript](https://github.com/dominictarr/hyperscript)-like syntax.\n *\n * ## When should I use this?\n *\n * If you want to programmatically create `Ast.Node` nodes.\n *\n */\n"],"mappings":"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"}