{"version":3,"file":"index.cjs","names":[],"sources":["../libs/split-on-condition.ts","../libs/split-on-macro.ts","../libs/unsplit-on-macro.ts","../libs/array-join.ts","../index.ts"],"sourcesContent":["import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Split a list of nodes based on whether `splitFunc` returns `true`.\n * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then\n * there will be at most two segments returned.\n */\nexport function splitOnCondition(\n    nodes: Ast.Node[],\n    splitFunc: (node: Ast.Node) => boolean = () => false,\n    options?: { onlySplitOnFirstOccurrence?: boolean }\n): { segments: Ast.Node[][]; separators: Ast.Node[] } {\n    if (!Array.isArray(nodes)) {\n        throw new Error(`Can only split an Array, not ${nodes}`);\n    }\n\n    const { onlySplitOnFirstOccurrence = false } = options || {};\n\n    const splitIndices: number[] = [];\n    for (let i = 0; i < nodes.length; i++) {\n        if (splitFunc(nodes[i])) {\n            splitIndices.push(i);\n            if (onlySplitOnFirstOccurrence) {\n                break;\n            }\n        }\n    }\n\n    // Short circuit if there is no splitting to be done\n    if (splitIndices.length === 0) {\n        return { segments: [nodes], separators: [] };\n    }\n\n    let separators = splitIndices.map((i) => nodes[i]);\n    let segments = splitIndices.map((splitEnd, i) => {\n        const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;\n        return nodes.slice(splitStart, splitEnd);\n    });\n    segments.push(\n        nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)\n    );\n\n    return { segments, separators };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { splitOnCondition } from \"./split-on-condition\";\n\n/**\n * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`\n * is returned. The original array is reconstructed as\n * `segments[0] + macros[0] + segments[1] + ...`.\n *\n * @param {[object]} ast\n * @param {(string|[string])} macroName\n * @returns {{segments: [object], macros: [object]}}\n */\nexport function splitOnMacro(\n    ast: Ast.Node[],\n    macroName: string | string[]\n): { segments: Ast.Node[][]; macros: Ast.Macro[] } {\n    if (typeof macroName === \"string\") {\n        macroName = [macroName];\n    }\n    if (!Array.isArray(macroName)) {\n        throw new Error(\"Type coercion failed\");\n    }\n    const isSeparator = match.createMacroMatcher(macroName);\n    const { segments, separators } = splitOnCondition(ast, isSeparator);\n    return { segments, macros: separators as Ast.Macro[] };\n}\n","import * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Does the reverse of `splitOnMacro`\n */\nexport function unsplitOnMacro({\n    segments,\n    macros,\n}: {\n    segments: Ast.Node[][];\n    macros: Ast.Node[] | Ast.Node[][];\n}) {\n    if (segments.length === 0) {\n        console.warn(\"Trying to join zero segments\");\n        return [];\n    }\n    if (segments.length !== macros.length + 1) {\n        console.warn(\n            \"Mismatch between lengths of macros and segments when trying to unsplit\"\n        );\n    }\n\n    let ret = segments[0];\n    for (let i = 0; i < macros.length; i++) {\n        // Even though the type of macros[i] is node and not array,\n        // Array.concat still works\n        ret = ret.concat(macros[i]).concat(segments[i + 1]);\n    }\n\n    return ret;\n}\n","/**\n * Joins an array of arrays with the item `sep`\n */\nexport function arrayJoin<T>(array: T[][], sep: T | T[]): T[] {\n    return array.flatMap((item, i) => {\n        if (i === 0) {\n            return item;\n        }\n        if (Array.isArray(sep)) {\n            return [...sep, ...item];\n        } else {\n            return [sep, ...item];\n        }\n    });\n}\n","export * from \"./libs/split-on-macro\";\nexport * from \"./libs/split-on-condition\";\nexport * from \"./libs/unsplit-on-macro\";\nexport * from \"./libs/array-join\";\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 manipulate `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you want break apart or join an array of nodes based on a condition. For example,\n * this is used to split on `&` characters in the `align` environment.\n */\n"],"mappings":";;;;;;;;AAOA,SAAgB,iBACZ,OACA,kBAA+C,OAC/C,SACkD;AAClD,KAAI,CAAC,MAAM,QAAQ,MAAM,CACrB,OAAM,IAAI,MAAM,gCAAgC,QAAQ;CAG5D,MAAM,EAAE,6BAA6B,UAAU,WAAW,EAAE;CAE5D,MAAM,eAAyB,EAAE;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,IAC9B,KAAI,UAAU,MAAM,GAAG,EAAE;AACrB,eAAa,KAAK,EAAE;AACpB,MAAI,2BACA;;AAMZ,KAAI,aAAa,WAAW,EACxB,QAAO;EAAE,UAAU,CAAC,MAAM;EAAE,YAAY,EAAE;EAAE;CAGhD,IAAI,aAAa,aAAa,KAAK,MAAM,MAAM,GAAG;CAClD,IAAI,WAAW,aAAa,KAAK,UAAU,MAAM;EAC7C,MAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,KAAK;AACvD,SAAO,MAAM,MAAM,YAAY,SAAS;GAC1C;AACF,UAAS,KACL,MAAM,MAAM,aAAa,aAAa,SAAS,KAAK,GAAG,MAAM,OAAO,CACvE;AAED,QAAO;EAAE;EAAU;EAAY;;;;;;;;;;;;;AC7BnC,SAAgB,aACZ,KACA,WAC+C;AAC/C,KAAI,OAAO,cAAc,SACrB,aAAY,CAAC,UAAU;AAE3B,KAAI,CAAC,MAAM,QAAQ,UAAU,CACzB,OAAM,IAAI,MAAM,uBAAuB;CAG3C,MAAM,EAAE,UAAU,eAAe,iBAAiB,KAD9B,wCAAA,MAAM,mBAAmB,UAAU,CACY;AACnE,QAAO;EAAE;EAAU,QAAQ;EAA2B;;;;;;;ACpB1D,SAAgB,eAAe,EAC3B,UACA,UAID;AACC,KAAI,SAAS,WAAW,GAAG;AACvB,UAAQ,KAAK,+BAA+B;AAC5C,SAAO,EAAE;;AAEb,KAAI,SAAS,WAAW,OAAO,SAAS,EACpC,SAAQ,KACJ,yEACH;CAGL,IAAI,MAAM,SAAS;AACnB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IAG/B,OAAM,IAAI,OAAO,OAAO,GAAG,CAAC,OAAO,SAAS,IAAI,GAAG;AAGvD,QAAO;;;;;;;AC1BX,SAAgB,UAAa,OAAc,KAAmB;AAC1D,QAAO,MAAM,SAAS,MAAM,MAAM;AAC9B,MAAI,MAAM,EACN,QAAO;AAEX,MAAI,MAAM,QAAQ,IAAI,CAClB,QAAO,CAAC,GAAG,KAAK,GAAG,KAAK;MAExB,QAAO,CAAC,KAAK,GAAG,KAAK;GAE3B"}