@unified-latex/unified-latex-util-split 1.7.1 → 1.8.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/index.cjs +85 -65
  2. package/index.cjs.map +1 -1
  3. package/index.js +85 -69
  4. package/index.js.map +1 -1
  5. package/package.json +3 -3
package/index.cjs CHANGED
@@ -1,77 +1,97 @@
1
- "use strict";
2
1
  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
3
- const unifiedLatexUtilMatch = require("@unified-latex/unified-latex-util-match");
2
+ let _unified_latex_unified_latex_util_match = require("@unified-latex/unified-latex-util-match");
3
+ //#region libs/split-on-condition.ts
4
+ /**
5
+ * Split a list of nodes based on whether `splitFunc` returns `true`.
6
+ * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then
7
+ * there will be at most two segments returned.
8
+ */
4
9
  function splitOnCondition(nodes, splitFunc = () => false, options) {
5
- if (!Array.isArray(nodes)) {
6
- throw new Error(`Can only split an Array, not ${nodes}`);
7
- }
8
- const { onlySplitOnFirstOccurrence = false } = options || {};
9
- const splitIndices = [];
10
- for (let i = 0; i < nodes.length; i++) {
11
- if (splitFunc(nodes[i])) {
12
- splitIndices.push(i);
13
- if (onlySplitOnFirstOccurrence) {
14
- break;
15
- }
16
- }
17
- }
18
- if (splitIndices.length === 0) {
19
- return { segments: [nodes], separators: [] };
20
- }
21
- let separators = splitIndices.map((i) => nodes[i]);
22
- let segments = splitIndices.map((splitEnd, i) => {
23
- const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;
24
- return nodes.slice(splitStart, splitEnd);
25
- });
26
- segments.push(
27
- nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)
28
- );
29
- return { segments, separators };
10
+ if (!Array.isArray(nodes)) throw new Error(`Can only split an Array, not ${nodes}`);
11
+ const { onlySplitOnFirstOccurrence = false } = options || {};
12
+ const splitIndices = [];
13
+ for (let i = 0; i < nodes.length; i++) if (splitFunc(nodes[i])) {
14
+ splitIndices.push(i);
15
+ if (onlySplitOnFirstOccurrence) break;
16
+ }
17
+ if (splitIndices.length === 0) return {
18
+ segments: [nodes],
19
+ separators: []
20
+ };
21
+ let separators = splitIndices.map((i) => nodes[i]);
22
+ let segments = splitIndices.map((splitEnd, i) => {
23
+ const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;
24
+ return nodes.slice(splitStart, splitEnd);
25
+ });
26
+ segments.push(nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length));
27
+ return {
28
+ segments,
29
+ separators
30
+ };
30
31
  }
32
+ //#endregion
33
+ //#region libs/split-on-macro.ts
34
+ /**
35
+ * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`
36
+ * is returned. The original array is reconstructed as
37
+ * `segments[0] + macros[0] + segments[1] + ...`.
38
+ *
39
+ * @param {[object]} ast
40
+ * @param {(string|[string])} macroName
41
+ * @returns {{segments: [object], macros: [object]}}
42
+ */
31
43
  function splitOnMacro(ast, macroName) {
32
- if (typeof macroName === "string") {
33
- macroName = [macroName];
34
- }
35
- if (!Array.isArray(macroName)) {
36
- throw new Error("Type coercion failed");
37
- }
38
- const isSeparator = unifiedLatexUtilMatch.match.createMacroMatcher(macroName);
39
- const { segments, separators } = splitOnCondition(ast, isSeparator);
40
- return { segments, macros: separators };
44
+ if (typeof macroName === "string") macroName = [macroName];
45
+ if (!Array.isArray(macroName)) throw new Error("Type coercion failed");
46
+ const { segments, separators } = splitOnCondition(ast, _unified_latex_unified_latex_util_match.match.createMacroMatcher(macroName));
47
+ return {
48
+ segments,
49
+ macros: separators
50
+ };
41
51
  }
42
- function unsplitOnMacro({
43
- segments,
44
- macros
45
- }) {
46
- if (segments.length === 0) {
47
- console.warn("Trying to join zero segments");
48
- return [];
49
- }
50
- if (segments.length !== macros.length + 1) {
51
- console.warn(
52
- "Mismatch between lengths of macros and segments when trying to unsplit"
53
- );
54
- }
55
- let ret = segments[0];
56
- for (let i = 0; i < macros.length; i++) {
57
- ret = ret.concat(macros[i]).concat(segments[i + 1]);
58
- }
59
- return ret;
52
+ //#endregion
53
+ //#region libs/unsplit-on-macro.ts
54
+ /**
55
+ * Does the reverse of `splitOnMacro`
56
+ */
57
+ function unsplitOnMacro({ segments, macros }) {
58
+ if (segments.length === 0) {
59
+ console.warn("Trying to join zero segments");
60
+ return [];
61
+ }
62
+ if (segments.length !== macros.length + 1) console.warn("Mismatch between lengths of macros and segments when trying to unsplit");
63
+ let ret = segments[0];
64
+ for (let i = 0; i < macros.length; i++) ret = ret.concat(macros[i]).concat(segments[i + 1]);
65
+ return ret;
60
66
  }
67
+ //#endregion
68
+ //#region libs/array-join.ts
69
+ /**
70
+ * Joins an array of arrays with the item `sep`
71
+ */
61
72
  function arrayJoin(array, sep) {
62
- return array.flatMap((item, i) => {
63
- if (i === 0) {
64
- return item;
65
- }
66
- if (Array.isArray(sep)) {
67
- return [...sep, ...item];
68
- } else {
69
- return [sep, ...item];
70
- }
71
- });
73
+ return array.flatMap((item, i) => {
74
+ if (i === 0) return item;
75
+ if (Array.isArray(sep)) return [...sep, ...item];
76
+ else return [sep, ...item];
77
+ });
72
78
  }
79
+ //#endregion
80
+ //#region index.ts
81
+ /**
82
+ * ## What is this?
83
+ *
84
+ * Functions to manipulate `unified-latex` Abstract Syntax Tree (AST).
85
+ *
86
+ * ## When should I use this?
87
+ *
88
+ * If you want break apart or join an array of nodes based on a condition. For example,
89
+ * this is used to split on `&` characters in the `align` environment.
90
+ */
91
+ //#endregion
73
92
  exports.arrayJoin = arrayJoin;
74
93
  exports.splitOnCondition = splitOnCondition;
75
94
  exports.splitOnMacro = splitOnMacro;
76
95
  exports.unsplitOnMacro = unsplitOnMacro;
77
- //# sourceMappingURL=index.cjs.map
96
+
97
+ //# sourceMappingURL=index.cjs.map
package/index.cjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.cjs","sources":["../libs/split-on-condition.ts","../libs/split-on-macro.ts","../libs/unsplit-on-macro.ts","../libs/array-join.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"],"names":["match"],"mappings":";;;AAOO,SAAS,iBACZ,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,KAAK,EAAE;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAA;AAE1D,QAAM,eAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,CAAC,CAAC,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGI,MAAA,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAG,EAAA;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,CAAC,CAAC;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,CAAC,IAAI;AAChD,WAAA,MAAM,MAAM,YAAY,QAAQ;AAAA,EAAA,CAC1C;AACQ,WAAA;AAAA,IACL,MAAM,MAAM,aAAa,aAAa,SAAS,CAAC,IAAI,GAAG,MAAM,MAAM;AAAA,EAAA;AAGhE,SAAA,EAAE,UAAU;AACvB;AC9BgB,SAAA,aACZ,KACA,WAC+C;AAC3C,MAAA,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AACrB,UAAA,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACM,QAAA,cAAcA,sBAAAA,MAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,WAAA,IAAe,iBAAiB,KAAK,WAAW;AAC3D,SAAA,EAAE,UAAU,QAAQ;AAC/B;ACrBO,SAAS,eAAe;AAAA,EAC3B;AAAA,EACA;AACJ,GAGG;AACK,MAAA,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO;EACX;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AAC/B,YAAA;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AAEI,MAAA,MAAM,SAAS,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAG9B,UAAA,IAAI,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,SAAS,IAAI,CAAC,CAAC;AAAA,EACtD;AAEO,SAAA;AACX;AC3BgB,SAAA,UAAa,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACF,aAAA;AAAA,IACX;AACI,QAAA,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAAA,OACpB;AACI,aAAA,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EAAA,CACH;AACL;;;;;"}
1
+ {"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"}
package/index.js CHANGED
@@ -1,77 +1,93 @@
1
1
  import { match } from "@unified-latex/unified-latex-util-match";
2
+ //#region libs/split-on-condition.ts
3
+ /**
4
+ * Split a list of nodes based on whether `splitFunc` returns `true`.
5
+ * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then
6
+ * there will be at most two segments returned.
7
+ */
2
8
  function splitOnCondition(nodes, splitFunc = () => false, options) {
3
- if (!Array.isArray(nodes)) {
4
- throw new Error(`Can only split an Array, not ${nodes}`);
5
- }
6
- const { onlySplitOnFirstOccurrence = false } = options || {};
7
- const splitIndices = [];
8
- for (let i = 0; i < nodes.length; i++) {
9
- if (splitFunc(nodes[i])) {
10
- splitIndices.push(i);
11
- if (onlySplitOnFirstOccurrence) {
12
- break;
13
- }
14
- }
15
- }
16
- if (splitIndices.length === 0) {
17
- return { segments: [nodes], separators: [] };
18
- }
19
- let separators = splitIndices.map((i) => nodes[i]);
20
- let segments = splitIndices.map((splitEnd, i) => {
21
- const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;
22
- return nodes.slice(splitStart, splitEnd);
23
- });
24
- segments.push(
25
- nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length)
26
- );
27
- return { segments, separators };
9
+ if (!Array.isArray(nodes)) throw new Error(`Can only split an Array, not ${nodes}`);
10
+ const { onlySplitOnFirstOccurrence = false } = options || {};
11
+ const splitIndices = [];
12
+ for (let i = 0; i < nodes.length; i++) if (splitFunc(nodes[i])) {
13
+ splitIndices.push(i);
14
+ if (onlySplitOnFirstOccurrence) break;
15
+ }
16
+ if (splitIndices.length === 0) return {
17
+ segments: [nodes],
18
+ separators: []
19
+ };
20
+ let separators = splitIndices.map((i) => nodes[i]);
21
+ let segments = splitIndices.map((splitEnd, i) => {
22
+ const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;
23
+ return nodes.slice(splitStart, splitEnd);
24
+ });
25
+ segments.push(nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length));
26
+ return {
27
+ segments,
28
+ separators
29
+ };
28
30
  }
31
+ //#endregion
32
+ //#region libs/split-on-macro.ts
33
+ /**
34
+ * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`
35
+ * is returned. The original array is reconstructed as
36
+ * `segments[0] + macros[0] + segments[1] + ...`.
37
+ *
38
+ * @param {[object]} ast
39
+ * @param {(string|[string])} macroName
40
+ * @returns {{segments: [object], macros: [object]}}
41
+ */
29
42
  function splitOnMacro(ast, macroName) {
30
- if (typeof macroName === "string") {
31
- macroName = [macroName];
32
- }
33
- if (!Array.isArray(macroName)) {
34
- throw new Error("Type coercion failed");
35
- }
36
- const isSeparator = match.createMacroMatcher(macroName);
37
- const { segments, separators } = splitOnCondition(ast, isSeparator);
38
- return { segments, macros: separators };
43
+ if (typeof macroName === "string") macroName = [macroName];
44
+ if (!Array.isArray(macroName)) throw new Error("Type coercion failed");
45
+ const { segments, separators } = splitOnCondition(ast, match.createMacroMatcher(macroName));
46
+ return {
47
+ segments,
48
+ macros: separators
49
+ };
39
50
  }
40
- function unsplitOnMacro({
41
- segments,
42
- macros
43
- }) {
44
- if (segments.length === 0) {
45
- console.warn("Trying to join zero segments");
46
- return [];
47
- }
48
- if (segments.length !== macros.length + 1) {
49
- console.warn(
50
- "Mismatch between lengths of macros and segments when trying to unsplit"
51
- );
52
- }
53
- let ret = segments[0];
54
- for (let i = 0; i < macros.length; i++) {
55
- ret = ret.concat(macros[i]).concat(segments[i + 1]);
56
- }
57
- return ret;
51
+ //#endregion
52
+ //#region libs/unsplit-on-macro.ts
53
+ /**
54
+ * Does the reverse of `splitOnMacro`
55
+ */
56
+ function unsplitOnMacro({ segments, macros }) {
57
+ if (segments.length === 0) {
58
+ console.warn("Trying to join zero segments");
59
+ return [];
60
+ }
61
+ if (segments.length !== macros.length + 1) console.warn("Mismatch between lengths of macros and segments when trying to unsplit");
62
+ let ret = segments[0];
63
+ for (let i = 0; i < macros.length; i++) ret = ret.concat(macros[i]).concat(segments[i + 1]);
64
+ return ret;
58
65
  }
66
+ //#endregion
67
+ //#region libs/array-join.ts
68
+ /**
69
+ * Joins an array of arrays with the item `sep`
70
+ */
59
71
  function arrayJoin(array, sep) {
60
- return array.flatMap((item, i) => {
61
- if (i === 0) {
62
- return item;
63
- }
64
- if (Array.isArray(sep)) {
65
- return [...sep, ...item];
66
- } else {
67
- return [sep, ...item];
68
- }
69
- });
72
+ return array.flatMap((item, i) => {
73
+ if (i === 0) return item;
74
+ if (Array.isArray(sep)) return [...sep, ...item];
75
+ else return [sep, ...item];
76
+ });
70
77
  }
71
- export {
72
- arrayJoin,
73
- splitOnCondition,
74
- splitOnMacro,
75
- unsplitOnMacro
76
- };
77
- //# sourceMappingURL=index.js.map
78
+ //#endregion
79
+ //#region index.ts
80
+ /**
81
+ * ## What is this?
82
+ *
83
+ * Functions to manipulate `unified-latex` Abstract Syntax Tree (AST).
84
+ *
85
+ * ## When should I use this?
86
+ *
87
+ * If you want break apart or join an array of nodes based on a condition. For example,
88
+ * this is used to split on `&` characters in the `align` environment.
89
+ */
90
+ //#endregion
91
+ export { arrayJoin, splitOnCondition, splitOnMacro, unsplitOnMacro };
92
+
93
+ //# sourceMappingURL=index.js.map
package/index.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.js","sources":["../libs/split-on-condition.ts","../libs/split-on-macro.ts","../libs/unsplit-on-macro.ts","../libs/array-join.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"],"names":[],"mappings":";AAOO,SAAS,iBACZ,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,KAAK,EAAE;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAA;AAE1D,QAAM,eAAyB,CAAA;AAC/B,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,CAAC,CAAC,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGI,MAAA,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAG,EAAA;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,CAAC,CAAC;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,CAAC,IAAI;AAChD,WAAA,MAAM,MAAM,YAAY,QAAQ;AAAA,EAAA,CAC1C;AACQ,WAAA;AAAA,IACL,MAAM,MAAM,aAAa,aAAa,SAAS,CAAC,IAAI,GAAG,MAAM,MAAM;AAAA,EAAA;AAGhE,SAAA,EAAE,UAAU;AACvB;AC9BgB,SAAA,aACZ,KACA,WAC+C;AAC3C,MAAA,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AACrB,UAAA,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACM,QAAA,cAAc,MAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,WAAA,IAAe,iBAAiB,KAAK,WAAW;AAC3D,SAAA,EAAE,UAAU,QAAQ;AAC/B;ACrBO,SAAS,eAAe;AAAA,EAC3B;AAAA,EACA;AACJ,GAGG;AACK,MAAA,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO;EACX;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AAC/B,YAAA;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AAEI,MAAA,MAAM,SAAS,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAG9B,UAAA,IAAI,OAAO,OAAO,CAAC,CAAC,EAAE,OAAO,SAAS,IAAI,CAAC,CAAC;AAAA,EACtD;AAEO,SAAA;AACX;AC3BgB,SAAA,UAAa,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACF,aAAA;AAAA,IACX;AACI,QAAA,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAAA,OACpB;AACI,aAAA,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EAAA,CACH;AACL;"}
1
+ {"version":3,"file":"index.js","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,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"}
package/package.json CHANGED
@@ -1,12 +1,12 @@
1
1
  {
2
2
  "name": "@unified-latex/unified-latex-util-split",
3
- "version": "1.7.1",
3
+ "version": "1.8.4",
4
4
  "description": "Functions for modifying a unified-latex AST",
5
5
  "main": "index.js",
6
6
  "type": "module",
7
7
  "dependencies": {
8
- "@unified-latex/unified-latex-types": "^1.7.1",
9
- "@unified-latex/unified-latex-util-match": "^1.7.1"
8
+ "@unified-latex/unified-latex-types": "^1.8.4",
9
+ "@unified-latex/unified-latex-util-match": "^1.8.4"
10
10
  },
11
11
  "repository": {
12
12
  "type": "git",