@unified-latex/unified-latex-util-split 1.0.1

package/README.md

@@ -0,0 +1,97 @@
+<!-- DO NOT MODIFY -->
+<!-- This file was autogenerated by build-docs.ts -->
+<!-- Edit the docstring in index.ts and regenerate -->
+<!-- rather than editing this file directly. -->
+# unified-latex-util-split
+
+## What is this?
+
+Functions to manipulate `unified-latex` Abstract Syntax Tree (AST).
+
+## When should I use this?
+
+If you want break apart or join an array of nodes based on a condition. For example,
+this is used to split on `&` characters in the `align` environment.
+
+# Functions
+
+## `arrayJoin(array, sep)`
+
+Joins an array of arrays with the item `sep`
+
+```typescript
+function arrayJoin<T>(array: T[][], sep: T | T[]): T[];
+```
+
+**Parameters**
+
+| Param | Type       |
+| :---- | :--------- |
+| array | `T[][]`    |
+| sep   | `T \| T[]` |
+
+## `splitOnCondition(nodes, splitFunc, options)`
+
+Split a list of nodes based on whether `splitFunc` returns `true`.
+If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then
+there will be at most two segments returned.
+
+```typescript
+function splitOnCondition(
+  nodes: Ast.Node[],
+  splitFunc: (node: Ast.Node) => boolean,
+  options: { onlySplitOnFirstOccurrence?: boolean }
+): { segments: Ast.Node[][]; separators: Ast.Node[] };
+```
+
+**Parameters**
+
+| Param     | Type                              |
+| :-------- | :-------------------------------- |
+| nodes     | `Ast.Node[]`                      |
+| splitFunc | `(node: Ast.Node) => boolean`     |
+| options   | <span color='gray'>Omitted</span> |
+
+## `splitOnMacro(ast, macroName)`
+
+Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`
+is returned. The original array is reconstructed as
+`segments[0] + macros[0] + segments[1] + ...`.
+
+```typescript
+function splitOnMacro(
+  ast: Ast.Node[],
+  macroName: string | string[]
+): { segments: Ast.Node[][]; macros: Ast.Macro[] };
+```
+
+**Parameters**
+
+| Param     | Type                 |
+| :-------- | :------------------- |
+| ast       | `Ast.Node[]`         |
+| macroName | `string \| string[]` |
+
+`unsplitOnMacro({
+    segments,
+    macros,
+})`
+---
+
+Does the reverse of `splitOnMacro`
+
+```typescript
+function unsplitOnMacro({
+  segments,
+  macros,
+}: {
+  segments: Ast.Node[][];
+  macros: Ast.Node[] | Ast.Node[][];
+}): Ast.Node[];
+```
+
+**Parameters**
+
+| Param                                     | Type                              |
+| :---------------------------------------- | :-------------------------------- |
+| {&#xA;    segments,&#xA;    macros,&#xA;} | <span color='gray'>Omitted</span> |

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../index.ts", "../libs/split-on-macro.ts", "../libs/split-on-condition.ts", "../libs/unsplit-on-macro.ts", "../libs/array-join.ts"],
+  "sourcesContent": ["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 */", "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 * 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\";\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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,sCAAsB;;;ACMf,0BACH,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,OAAO;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAC;AAE3D,QAAM,eAAyB,CAAC;AAChC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,EAAE,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGA,MAAI,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAC,EAAE;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,EAAE;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,KAAK;AACvD,WAAO,MAAM,MAAM,YAAY,QAAQ;AAAA,EAC3C,CAAC;AACD,WAAS,KACL,MAAM,MAAM,aAAa,aAAa,SAAS,KAAK,GAAG,MAAM,MAAM,CACvE;AAEA,SAAO,EAAE,UAAU,WAAW;AAClC;;;AD9BO,sBACH,KACA,WAC+C;AAC/C,MAAI,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC3B,UAAM,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACA,QAAM,cAAc,sCAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,eAAe,iBAAiB,KAAK,WAAW;AAClE,SAAO,EAAE,UAAU,QAAQ,WAA0B;AACzD;;;AErBO,wBAAwB;AAAA,EAC3B;AAAA,EACA;AAAA,GAID;AACC,MAAI,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO,CAAC;AAAA,EACZ;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AACvC,YAAQ,KACJ,wEACJ;AAAA,EACJ;AAEA,MAAI,MAAM,SAAS;AACnB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAGpC,UAAM,IAAI,OAAO,OAAO,EAAE,EAAE,OAAO,SAAS,IAAI,EAAE;AAAA,EACtD;AAEA,SAAO;AACX;;;AC3BO,mBAAsB,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACT,aAAO;AAAA,IACX;AACA,QAAI,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAC3B,OAAO;AACH,aAAO,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EACJ,CAAC;AACL;",
+  "names": []
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./libs/split-on-macro";
+export * from "./libs/split-on-condition";
+export * from "./libs/unsplit-on-macro";
+export * from "./libs/array-join";
+/**
+ * ## What is this?
+ *
+ * Functions to manipulate `unified-latex` Abstract Syntax Tree (AST).
+ *
+ * ## When should I use this?
+ *
+ * If you want break apart or join an array of nodes based on a condition. For example,
+ * this is used to split on `&` characters in the `align` environment.
+ */ 
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAGlC;;;;;;;;;GASG"}

package/dist/index.js

@@ -0,0 +1,82 @@
+// libs/split-on-macro.ts
+import { match } from "@unified-latex/unified-latex-util-match";
+
+// libs/split-on-condition.ts
+function splitOnCondition(nodes, splitFunc = () => false, options) {
+  if (!Array.isArray(nodes)) {
+    throw new Error(`Can only split an Array, not ${nodes}`);
+  }
+  const { onlySplitOnFirstOccurrence = false } = options || {};
+  const splitIndices = [];
+  for (let i = 0; i < nodes.length; i++) {
+    if (splitFunc(nodes[i])) {
+      splitIndices.push(i);
+      if (onlySplitOnFirstOccurrence) {
+        break;
+      }
+    }
+  }
+  if (splitIndices.length === 0) {
+    return { segments: [nodes], separators: [] };
+  }
+  let separators = splitIndices.map((i) => nodes[i]);
+  let segments = splitIndices.map((splitEnd, i) => {
+    const splitStart = i === 0 ? 0 : splitIndices[i - 1] + 1;
+    return nodes.slice(splitStart, splitEnd);
+  });
+  segments.push(nodes.slice(splitIndices[splitIndices.length - 1] + 1, nodes.length));
+  return { segments, separators };
+}
+
+// libs/split-on-macro.ts
+function splitOnMacro(ast, macroName) {
+  if (typeof macroName === "string") {
+    macroName = [macroName];
+  }
+  if (!Array.isArray(macroName)) {
+    throw new Error("Type coercion failed");
+  }
+  const isSeparator = match.createMacroMatcher(macroName);
+  const { segments, separators } = splitOnCondition(ast, isSeparator);
+  return { segments, macros: separators };
+}
+
+// libs/unsplit-on-macro.ts
+function unsplitOnMacro({
+  segments,
+  macros
+}) {
+  if (segments.length === 0) {
+    console.warn("Trying to join zero segments");
+    return [];
+  }
+  if (segments.length !== macros.length + 1) {
+    console.warn("Mismatch between lengths of macros and segments when trying to unsplit");
+  }
+  let ret = segments[0];
+  for (let i = 0; i < macros.length; i++) {
+    ret = ret.concat(macros[i]).concat(segments[i + 1]);
+  }
+  return ret;
+}
+
+// libs/array-join.ts
+function arrayJoin(array, sep) {
+  return array.flatMap((item, i) => {
+    if (i === 0) {
+      return item;
+    }
+    if (Array.isArray(sep)) {
+      return [...sep, ...item];
+    } else {
+      return [sep, ...item];
+    }
+  });
+}
+export {
+  arrayJoin,
+  splitOnCondition,
+  splitOnMacro,
+  unsplitOnMacro
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../libs/split-on-macro.ts", "../libs/split-on-condition.ts", "../libs/unsplit-on-macro.ts", "../libs/array-join.ts"],
+  "sourcesContent": ["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 * 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\";\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"],
+  "mappings": ";AACA;;;ACMO,0BACH,OACA,YAAyC,MAAM,OAC/C,SACkD;AAClD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACvB,UAAM,IAAI,MAAM,gCAAgC,OAAO;AAAA,EAC3D;AAEA,QAAM,EAAE,6BAA6B,UAAU,WAAW,CAAC;AAE3D,QAAM,eAAyB,CAAC;AAChC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,UAAU,MAAM,EAAE,GAAG;AACrB,mBAAa,KAAK,CAAC;AACnB,UAAI,4BAA4B;AAC5B;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAGA,MAAI,aAAa,WAAW,GAAG;AAC3B,WAAO,EAAE,UAAU,CAAC,KAAK,GAAG,YAAY,CAAC,EAAE;AAAA,EAC/C;AAEA,MAAI,aAAa,aAAa,IAAI,CAAC,MAAM,MAAM,EAAE;AACjD,MAAI,WAAW,aAAa,IAAI,CAAC,UAAU,MAAM;AAC7C,UAAM,aAAa,MAAM,IAAI,IAAI,aAAa,IAAI,KAAK;AACvD,WAAO,MAAM,MAAM,YAAY,QAAQ;AAAA,EAC3C,CAAC;AACD,WAAS,KACL,MAAM,MAAM,aAAa,aAAa,SAAS,KAAK,GAAG,MAAM,MAAM,CACvE;AAEA,SAAO,EAAE,UAAU,WAAW;AAClC;;;AD9BO,sBACH,KACA,WAC+C;AAC/C,MAAI,OAAO,cAAc,UAAU;AAC/B,gBAAY,CAAC,SAAS;AAAA,EAC1B;AACA,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC3B,UAAM,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AACA,QAAM,cAAc,MAAM,mBAAmB,SAAS;AACtD,QAAM,EAAE,UAAU,eAAe,iBAAiB,KAAK,WAAW;AAClE,SAAO,EAAE,UAAU,QAAQ,WAA0B;AACzD;;;AErBO,wBAAwB;AAAA,EAC3B;AAAA,EACA;AAAA,GAID;AACC,MAAI,SAAS,WAAW,GAAG;AACvB,YAAQ,KAAK,8BAA8B;AAC3C,WAAO,CAAC;AAAA,EACZ;AACA,MAAI,SAAS,WAAW,OAAO,SAAS,GAAG;AACvC,YAAQ,KACJ,wEACJ;AAAA,EACJ;AAEA,MAAI,MAAM,SAAS;AACnB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAGpC,UAAM,IAAI,OAAO,OAAO,EAAE,EAAE,OAAO,SAAS,IAAI,EAAE;AAAA,EACtD;AAEA,SAAO;AACX;;;AC3BO,mBAAsB,OAAc,KAAmB;AAC1D,SAAO,MAAM,QAAQ,CAAC,MAAM,MAAM;AAC9B,QAAI,MAAM,GAAG;AACT,aAAO;AAAA,IACX;AACA,QAAI,MAAM,QAAQ,GAAG,GAAG;AACpB,aAAO,CAAC,GAAG,KAAK,GAAG,IAAI;AAAA,IAC3B,OAAO;AACH,aAAO,CAAC,KAAK,GAAG,IAAI;AAAA,IACxB;AAAA,EACJ,CAAC;AACL;",
+  "names": []
+}

package/dist/libs/array-join.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Joins an array of arrays with the item `sep`
+ */
+export declare function arrayJoin<T>(array: T[][], sep: T | T[]): T[];
+//# sourceMappingURL=array-join.d.ts.map

package/dist/libs/array-join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-join.d.ts","sourceRoot":"","sources":["../../libs/array-join.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAW5D"}

package/dist/libs/split-on-condition.d.ts

@@ -0,0 +1,13 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+/**
+ * Split a list of nodes based on whether `splitFunc` returns `true`.
+ * If `onlySplitOnFirstOccurrence` is set to true in the `options` object, then
+ * there will be at most two segments returned.
+ */
+export declare function splitOnCondition(nodes: Ast.Node[], splitFunc?: (node: Ast.Node) => boolean, options?: {
+    onlySplitOnFirstOccurrence?: boolean;
+}): {
+    segments: Ast.Node[][];
+    separators: Ast.Node[];
+};
+//# sourceMappingURL=split-on-condition.d.ts.map

package/dist/libs/split-on-condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-on-condition.d.ts","sourceRoot":"","sources":["../../libs/split-on-condition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,EACjB,SAAS,GAAE,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,KAAK,OAAqB,EACpD,OAAO,CAAC,EAAE;IAAE,0BAA0B,CAAC,EAAE,OAAO,CAAA;CAAE,GACnD;IAAE,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,CAAA;CAAE,CAgCpD"}

package/dist/libs/split-on-macro.d.ts

@@ -0,0 +1,15 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+/**
+ * Split an array of AST nodes based on a macro. An object `{segments: [], macros: []}`
+ * is returned. The original array is reconstructed as
+ * `segments[0] + macros[0] + segments[1] + ...`.
+ *
+ * @param {[object]} ast
+ * @param {(string|[string])} macroName
+ * @returns {{segments: [object], macros: [object]}}
+ */
+export declare function splitOnMacro(ast: Ast.Node[], macroName: string | string[]): {
+    segments: Ast.Node[][];
+    macros: Ast.Macro[];
+};
+//# sourceMappingURL=split-on-macro.d.ts.map

package/dist/libs/split-on-macro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-on-macro.d.ts","sourceRoot":"","sources":["../../libs/split-on-macro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAI1D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CACxB,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,EACf,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAC7B;IAAE,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,CAAA;CAAE,CAUjD"}

package/dist/libs/unsplit-on-macro.d.ts

@@ -0,0 +1,9 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+/**
+ * Does the reverse of `splitOnMacro`
+ */
+export declare function unsplitOnMacro({ segments, macros, }: {
+    segments: Ast.Node[][];
+    macros: Ast.Node[] | Ast.Node[][];
+}): Ast.Node[];
+//# sourceMappingURL=unsplit-on-macro.d.ts.map

package/dist/libs/unsplit-on-macro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsplit-on-macro.d.ts","sourceRoot":"","sources":["../../libs/unsplit-on-macro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAE1D;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAC3B,QAAQ,EACR,MAAM,GACT,EAAE;IACC,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;IACvB,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;CACrC,cAmBA"}

package/package.json

@@ -0,0 +1,63 @@
+{
+    "name": "@unified-latex/unified-latex-util-split",
+    "version": "1.0.1",
+    "description": "Functions for modifying a unified-latex AST",
+    "main": "dist/index.js",
+    "type": "module",
+    "dependencies": {
+        "@unified-latex/unified-latex-types": "*",
+        "@unified-latex/unified-latex-util-match": "*"
+    },
+    "files": [
+        "dist/**/*.ts",
+        "dist/**/*.js",
+        "dist/**/*.map",
+        "dist/**/*.json"
+    ],
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        },
+        "./*js": "./dist/*js",
+        "./*": {
+            "import": "./dist/*.js",
+            "require": "./dist/*.cjs"
+        }
+    },
+    "scripts": {
+        "build": "npm run clean && mkdirp ./dist && npm run compile",
+        "clean": "rm -rf ./dist && rm -rf tsconfig.tsbuildinfo",
+        "compile": "tsc -b tsconfig.json & node build.js",
+        "test": "jest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/siefkenj/unified-latex.git"
+    },
+    "keywords": [
+        "pegjs",
+        "latex",
+        "parser",
+        "prettier",
+        "unified-latex",
+        "unified"
+    ],
+    "author": "Jason Siefken",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/siefkenj/unified-latex/issues"
+    },
+    "homepage": "https://github.com/siefkenj/unified-latex#readme",
+    "jest": {
+        "transformIgnorePatterns": [
+            "node_modules/(?!unified|bail|is-plain-obj|trough|vfile.*|unist.*|hast.*|property-information|html-void-elements|.*-separated-tokens|.*entities.*|ccount|rehype*|string-width|strip-ansi|ansi-regex|supports-color)"
+        ],
+        "transform": {
+            "\\.m?jsx?$": "esbuild-jest",
+            "latex.pegjs$": "<rootDir>/../../tests/pegjs-preprocessor-latex.js",
+            "\\.pegjs$": "<rootDir>/../../tests/pegjs-preprocessor.js",
+            "^.+\\.tsx?$": "ts-jest"
+        }
+    }
+}