@dialecte/core 0.1.6 → 0.1.8

package/dist/test/run-test-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAO/C,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAC1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAMrD,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AAID,wBAAgB,YAAY,CAC3B,eAAe,SAAS,YAAY,EACpC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;IAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,IAAI,CA0DP"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,SAAS,EACT,SAAS,EACT,SAAS,EACT,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAQhD,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAKhG;AA6GD,iBAAS,gBAAgB,CAAC,eAAe,SAAS,YAAY,EAC7D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAKN;AAED,eAAO,MAAM,YAAY;eAKb,eAAe,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEW,OAAO,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE3E,IAAI;kBACM,eAAe,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEQ,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEtE,IAAI;aACC,OAAO,gBAAgB;CAfiC,CAAA;AAElE,wBAAgB,gBAAgB,CAAC,aAAa,SAAS,iBAAiB,EACvE,cAAc,EAAE,aAAa,GAC3B;IACF,UAAU,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC3D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;QAC9E,cAAc,CAAC,EAAE,aAAa,CAAA;KAC9B,GAAG,IAAI,CAAA;IACR,aAAa,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC9D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACzE,cAAc,CAAC,EAAE,aAAa,CAAA;KAC9B,GAAG,IAAI,CAAA;IACR,OAAO,EAAE,OAAO,gBAAgB,CAAA;CAChC,CAMA"}

package/dist/test/run-test-cases.type.d.ts

@@ -1,18 +1,20 @@
 import { Document } from '../document';
 import { AnyDialecteConfig } from '../types';
 export type BaseTestCase = {
+    only?: boolean;
+};
+export type BaseXmlTestCase = BaseTestCase & {
     sourceXml: string;
     targetXml?: string;
-    only?: boolean;
     expectedQueries?: string[];
     unexpectedQueries?: string[];
 };
-export type TestCases<GenericTestCase extends BaseTestCase> = Record<string, GenericTestCase>;
+export type TestCases<GenericTestCase extends BaseXmlTestCase> = Record<string, GenericTestCase>;
 export type TestContext<GenericConfig extends AnyDialecteConfig> = {
     document: Document<GenericConfig>;
     databaseName: string;
 };
-export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseTestCase> = {
+export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseXmlTestCase> = {
     testCase: GenericTestCase;
     source: TestContext<GenericConfig>;
     target?: TestContext<GenericConfig>;

package/dist/test/run-test-cases.type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAE7F,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,YAAY,IACjC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA"}
+{"version":3,"file":"run-test-cases.type.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,eAAe,SAAS,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAEhG,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAClE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA"}

package/dist/test.js

@@ -1,88 +1,88 @@
-import { expect as l, it as x } from "vitest";
-import { x as E, D as b, i as X, o as q, e as f } from "./index-Cl4q6wr5.js";
-import { D as S, s as D, l as L, k as T } from "./standardizing-27Zk5ECm.js";
-function h(a) {
-  const e = w(a);
+import { expect as f, it as p } from "vitest";
+import { x as X, D as q, i as S, o as D, e as h } from "./index-BcfPvtox.js";
+import { DIALECTE_DEV_NAMESPACE as T, standardizeRecord as L, toTreeRecord as w, toTrackedRecord as g } from "./helpers.js";
+function v(t) {
+  const e = O(t);
   if (e.length === 0)
-    return [a];
-  const t = [];
-  for (const A of e)
-    t.push(a.slice(0, A));
-  return t.push(a), t;
+    return [t];
+  const a = [];
+  for (const B of e)
+    a.push(t.slice(0, B));
+  return a.push(t), a;
 }
-function w(a) {
+function O(t) {
   const e = [];
-  let t = 0, A = 0, B = null;
-  for (let r = 0; r < a.length; r++) {
-    const _ = a[r];
-    if (B) {
-      _ === B && (B = null);
+  let a = 0, B = 0, A = null;
+  for (let r = 0; r < t.length; r++) {
+    const _ = t[r];
+    if (A) {
+      _ === A && (A = null);
       continue;
     }
     if (_ === '"' || _ === "'") {
-      B = _;
+      A = _;
       continue;
     }
     if (_ === "[") {
-      t++;
+      a++;
       continue;
     }
     if (_ === "]") {
-      t--;
+      a--;
       continue;
     }
     if (_ === "(") {
-      A++;
+      B++;
       continue;
     }
     if (_ === ")") {
-      A--;
+      B--;
       continue;
     }
-    if (!(t > 0 || A > 0) && _ === "/") {
+    if (!(a > 0 || B > 0) && _ === "/") {
       if (r === 0) {
-        a[r + 1] === "/" && r++;
+        t[r + 1] === "/" && r++;
         continue;
       }
-      if (e.length === 0 && r === 1 && a[0] === "/")
+      if (e.length === 0 && r === 1 && t[0] === "/")
         continue;
-      e.push(r), a[r + 1] === "/" && r++;
+      e.push(r), t[r + 1] === "/" && r++;
     }
   }
   return e;
 }
-function O(a) {
-  const { namespaces: e } = a, t = g(e);
+function M(t) {
+  const { namespaces: e } = t, a = R(e);
   return {
-    assertExpectedElementQueries(A) {
-      M({ ...A, nsResolver: t });
+    assertExpectedElementQueries(B) {
+      k({ ...B, nsResolver: a });
     },
-    assertUnexpectedElementQueries(A) {
-      k({ ...A, nsResolver: t });
+    assertUnexpectedElementQueries(B) {
+      V({ ...B, nsResolver: a });
     }
   };
 }
-function M(a) {
-  const { xmlDocument: e, queries: t, nsResolver: A } = a;
-  for (const B of t)
-    R({ xmlDocument: e, xpath: B, nsResolver: A });
+function k(t) {
+  const { xmlDocument: e, queries: a, nsResolver: B } = t;
+  for (const A of a)
+    F({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function g(a) {
-  return (e) => e ? a[e]?.uri ?? null : null;
+function R(t) {
+  return (e) => e ? t[e]?.uri ?? null : null;
 }
-function k(a) {
-  const { xmlDocument: e, queries: t, nsResolver: A } = a;
-  for (const B of t)
-    V({ xmlDocument: e, xpath: B, nsResolver: A });
+function V(t) {
+  const { xmlDocument: e, queries: a, nsResolver: B } = t;
+  for (const A of a)
+    N({ xmlDocument: e, xpath: A, nsResolver: B });
 }
-function R(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: A } = a, B = h(t);
+function F(t) {
+  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
   let r = null, _ = 0;
-  for (let C = 0; C < B.length; C++) {
-    const s = B[C], c = e.evaluate(
+  for (let C = 0; C < A.length; C++) {
+    const s = A[C], c = e.evaluate(
       s,
       e,
-      A ?? null,
+      B ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
@@ -90,77 +90,77 @@ function R(a) {
       r = c, _ = C + 1;
       continue;
     }
-    const i = C === 0 ? B[0] : t.slice(B[C - 1].length), n = _ === 0 ? `[No parent matched — failed from document root]
+    const i = C === 0 ? A[0] : a.slice(A[C - 1].length), u = _ === 0 ? `[No parent matched — failed from document root]
   Document:
-${d({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${B.length}]:
-${r ? d({ xml: r.outerHTML }) : "(none)"}`;
-    l(
+${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${A.length}]:
+${r ? x({ xml: r.outerHTML }) : "(none)"}`;
+    f(
       c,
       `Element not found in XML.
-  Failed at step ${C + 1}/${B.length}: ${i.trim()}
-  Full XPath: ${t}
-  ${n}`
+  Failed at step ${C + 1}/${A.length}: ${i.trim()}
+  Full XPath: ${a}
+  ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function d(a) {
-  const { xml: e } = a;
+function x(t) {
+  const { xml: e } = t;
   try {
-    return E(e, { indentation: "  ", collapseContent: !0 });
+    return X(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
-function V(a) {
-  const { xmlDocument: e, xpath: t, nsResolver: A } = a, B = h(t);
-  if (B.length > 1) {
+function N(t) {
+  const { xmlDocument: e, xpath: a, nsResolver: B } = t, A = v(a);
+  if (A.length > 1) {
     let C = null;
-    for (let s = 0; s < B.length - 1; s++) {
-      const u = B[s], i = e.evaluate(
-        u,
+    for (let s = 0; s < A.length - 1; s++) {
+      const n = A[s], i = e.evaluate(
+        n,
         e,
-        A ?? null,
+        B ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, n = s === 0 ? B[0] : t.slice(B[s - 1].length), v = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
-${C ? d({ xml: C.outerHTML }) : "(none)"}`;
-      l(
+      ).singleNodeValue, u = s === 0 ? A[0] : a.slice(A[s - 1].length), o = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
+${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+      f(
         i,
         `Absent assertion is unreliable: ancestor step does not exist.
   The query passes but for the wrong reason — an ancestor is missing, not the target element.
-  Missing at step ${s + 1}/${B.length}: ${n.trim()}
-  Full XPath: ${t}
-  ${v}`
+  Missing at step ${s + 1}/${A.length}: ${u.trim()}
+  Full XPath: ${a}
+  ${o}`
       ).toBeTruthy(), C = i;
     }
   }
   const _ = e.evaluate(
-    t,
+    a,
     e,
-    A ?? null,
+    B ?? null,
     XPathResult.FIRST_ORDERED_NODE_TYPE,
     null
   ).singleNodeValue;
-  l(
+  f(
     _,
     `Element should NOT exist in XML but was found.
-  XPath: ${t}
+  XPath: ${a}
   Found:
-${_ ? d({ xml: _.outerHTML }) : "(none)"}`
+${_ ? x({ xml: _.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
-const p = {
+const d = {
   default: {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: S,
+  dev: T,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, ee = `xmlns="${p.default.uri}"`, te = `xmlns:${p.dev.prefix}="${p.dev.uri}"`, ae = `xmlns:${p.ext.prefix}="${p.ext.uri}"`, F = [
+}, Ae = `xmlns="${d.default.uri}"`, re = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, Ce = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, U = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const p = {
   "CC_2",
   "CC_3",
   "Root"
-], N = {
+], y = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const p = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, U = {
+}, I = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const p = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, y = {
+}, $ = {
   A: ["AAAA_1", "AAAA_2", "AAAA_3", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -319,7 +319,7 @@ const p = {
     "CC_2",
     "CC_3"
   ]
-}, I = {
+}, P = {
   A: ["Root"],
   AAAA_1: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
   AAAA_2: ["A", "AAA_1", "AAA_2", "AAA_3", "AA_1", "AA_2", "AA_3", "Root"],
@@ -351,7 +351,7 @@ const p = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, $ = "Root", P = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], Q = {
+}, Q = "Root", z = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], G = {
   A: {
     aA: "",
     bA: "",
@@ -506,7 +506,7 @@ const p = {
     "ext:root": "",
     root: ""
   }
-}, z = {
+}, H = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1508,49 +1508,49 @@ const p = {
       }
     ]
   }
-}, G = {
+}, j = {
   supportedFileExtensions: [".xml"]
-}, H = {
+}, Y = {
   tables: {
     xmlElements: {
       name: "xmlElements",
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, o = {
-  rootElementName: $,
-  singletonElements: P,
-  elements: F,
-  namespaces: p,
-  attributes: Q,
-  children: N,
-  parents: U,
-  descendants: y,
-  ancestors: I,
-  database: H,
-  io: G,
-  definition: z,
+}, l = {
+  rootElementName: Q,
+  singletonElements: z,
+  elements: U,
+  namespaces: d,
+  attributes: G,
+  children: y,
+  parents: I,
+  descendants: $,
+  ancestors: P,
+  database: Y,
+  io: j,
+  definition: H,
   hooks: {}
 };
-async function m(a) {
-  const { xmlString: e, dialecteConfig: t = o } = a, A = `test-${crypto.randomUUID()}.xml`, B = new File([e], A, { type: "text/xml" }), _ = (await X({
-    files: [B],
-    dialecteConfig: t,
+async function m(t) {
+  const { xmlString: e, dialecteConfig: a = l } = t, B = `test-${crypto.randomUUID()}.xml`, A = new File([e], B, { type: "text/xml" }), _ = (await S({
+    files: [A],
+    dialecteConfig: a,
     useCustomRecordsIds: !0
-  }))[0], C = q({
-    config: t,
+  }))[0], C = D({
+    config: a,
     storage: { type: "local", databaseName: _ }
   });
   return {
     document: C,
     databaseName: _,
     exportCurrentTest: async (c) => {
-      const { extension: i = t.io.supportedFileExtensions[0], withDatabaseIds: n = !1 } = c || {};
-      return f({
-        dialecteConfig: t,
+      const { extension: i = a.io.supportedFileExtensions[0], withDatabaseIds: u = !1 } = c || {};
+      return h({
+        dialecteConfig: a,
         databaseName: _,
         extension: i,
-        withDatabaseIds: n
+        withDatabaseIds: u
       });
     },
     cleanup: async () => {
@@ -1558,87 +1558,118 @@ async function m(a) {
     }
   };
 }
-function Be(a) {
-  const { databaseName: e, dialecteConfig: t } = a;
+function _e(t) {
+  const { databaseName: e, dialecteConfig: a } = t;
   return {
-    store: new b(e, t),
+    store: new q(e, a),
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const Y = crypto.randomUUID.bind(crypto);
-function j() {
-  let a = 0;
+const E = crypto.randomUUID.bind(crypto);
+function b() {
+  let t = 0;
   return function() {
-    return `${a++}`;
+    return `${t++}`;
   };
 }
-function Ae(a) {
+function W(t) {
   const {
     testCases: e,
-    act: t,
-    dialecteConfig: A = o
-  } = a, { assertExpectedElementQueries: B, assertUnexpectedElementQueries: r } = O({
-    namespaces: A.namespaces
+    act: a,
+    dialecteConfig: B = l
+  } = t, { assertExpectedElementQueries: A, assertUnexpectedElementQueries: r } = M({
+    namespaces: B.namespaces
   });
   for (const [_, C] of Object.entries(e))
-    (C.only ? x.only : x)(_, async () => {
-      crypto.randomUUID = Y;
-      const u = await m({
-        xmlString: C.sourceXml,
-        dialecteConfig: A
-      }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: A }) : void 0;
+    (C.only ? p.only : p)(_, async () => {
+      crypto.randomUUID = E;
+      const n = await m({ xmlString: C.sourceXml, dialecteConfig: B }), c = C.targetXml ? await m({ xmlString: C.targetXml, dialecteConfig: B }) : void 0;
       try {
-        crypto.randomUUID = j();
-        const { assertDatabaseName: i } = await t({
+        crypto.randomUUID = b();
+        const { assertDatabaseName: i, withDatabaseIds: u } = await a({
           testCase: C,
-          source: { document: u.document, databaseName: u.databaseName },
+          source: { document: n.document, databaseName: n.databaseName },
           target: c ? { document: c.document, databaseName: c.databaseName } : void 0
-        }), { xmlDocument: n } = await f({
-          dialecteConfig: A,
+        }), { xmlDocument: o } = await h({
+          dialecteConfig: B,
           databaseName: i,
-          extension: A.io.supportedFileExtensions[0],
-          withDatabaseIds: !0
+          extension: B.io.supportedFileExtensions[0],
+          withDatabaseIds: u ?? !0
+        });
+        C.expectedQueries?.length && A({ xmlDocument: o, queries: C.expectedQueries }), C.unexpectedQueries?.length && r({ xmlDocument: o, queries: C.unexpectedQueries });
+      } finally {
+        await n.cleanup(), await c?.cleanup();
+      }
+    });
+}
+function Z(t) {
+  const {
+    testCases: e,
+    act: a,
+    dialecteConfig: B = l
+  } = t;
+  for (const [A, r] of Object.entries(e))
+    (r.only ? p.only : p)(A, async () => {
+      crypto.randomUUID = E;
+      const C = await m({ xmlString: r.sourceXml, dialecteConfig: B }), s = r.targetXml ? await m({ xmlString: r.targetXml, dialecteConfig: B }) : void 0;
+      try {
+        crypto.randomUUID = b(), await a({
+          testCase: r,
+          source: { document: C.document, databaseName: C.databaseName },
+          target: s ? { document: s.document, databaseName: s.databaseName } : void 0
         });
-        C.expectedQueries?.length && B({ xmlDocument: n, queries: C.expectedQueries }), C.unexpectedQueries?.length && r({ xmlDocument: n, queries: C.unexpectedQueries });
       } finally {
-        await u.cleanup(), await c?.cleanup();
+        await C.cleanup(), await s?.cleanup();
       }
     });
 }
-function Z(a) {
-  function e(t) {
-    const { record: A, type: B = "raw" } = t, r = D({ record: A, dialecteConfig: a });
-    switch (B) {
+function J(t, e) {
+  for (const [a, B] of Object.entries(t))
+    (B.only ? p.only : p)(a, () => e(B));
+}
+const se = K(l);
+function K(t) {
+  return {
+    withExport: (e) => W({ dialecteConfig: t, ...e }),
+    withoutExport: (e) => Z({ dialecteConfig: t, ...e }),
+    generic: J
+  };
+}
+function ee(t) {
+  function e(a) {
+    const { record: B, type: A = "raw" } = a, r = L({ record: B, dialecteConfig: t });
+    switch (A) {
       case "raw":
         return r;
       case "tracked":
-        return T({ record: r });
+        return g({ record: r });
       case "tree":
-        return L({ record: r });
+        return w({ record: r });
       default:
-        throw new Error(`Unsupported record type: ${B}`);
+        throw new Error(`Unsupported record type: ${A}`);
     }
   }
   return e;
 }
-const Ce = Z(o);
+const ce = ee(l);
 export {
-  H as DATABASE_CONFIG,
-  p as DIALECTE_NAMESPACES,
-  G as IO_CONFIG,
-  o as TEST_DIALECTE_CONFIG,
-  ee as XMLNS_DEFAULT_NAMESPACE,
-  te as XMLNS_DEV_NAMESPACE,
-  ae as XMLNS_EXT_NAMESPACE,
-  M as assertExpectedElementQueries,
-  k as assertUnexpectedElementQueries,
-  j as createMockRandomUUID,
-  Be as createTestContext,
+  Y as DATABASE_CONFIG,
+  d as DIALECTE_NAMESPACES,
+  j as IO_CONFIG,
+  l as TEST_DIALECTE_CONFIG,
+  Ae as XMLNS_DEFAULT_NAMESPACE,
+  re as XMLNS_DEV_NAMESPACE,
+  Ce as XMLNS_EXT_NAMESPACE,
+  k as assertExpectedElementQueries,
+  V as assertUnexpectedElementQueries,
+  b as createMockRandomUUID,
+  _e as createTestContext,
   m as createTestDialecte,
-  Ce as createTestRecord,
-  Z as createTestRecordFactory,
-  O as createXmlAssertions,
-  Ae as runTestCases,
-  h as splitXpathIntoSteps
+  ce as createTestRecord,
+  ee as createTestRecordFactory,
+  K as createTestRunner,
+  M as createXmlAssertions,
+  se as runTestCases,
+  v as splitXpathIntoSteps
 };

package/dist/types/dialecte-config.d.ts

@@ -2,7 +2,7 @@ import { AnyDefinition } from './definition';
 import { ImportOptions, ExportOptions, IOHooks } from './io';
 import { Operation } from './operations';
 import { Namespace, RawRecord, TreeRecord } from './records';
-import { Context } from '../document';
+import { Context, CloneMapping } from '../document';
 export type RawDialecteConfig<GenericElementNames extends readonly string[], GenericRootElement extends GenericElementNames[number], GenericAttributes extends Record<string, any>, GenericChildren extends Record<string, readonly string[]>, GenericParents extends Record<string, readonly string[]>, GenericDescendants extends Record<string, readonly string[]>, GenericAncestors extends Record<string, readonly string[]>> = {
     rootElementName: GenericRootElement;
     singletonElements?: readonly GenericElementNames[number][];
@@ -51,6 +51,34 @@ export type TransactionHooks = {
         parentRecord: RawRecord<GenericConfig, GenericParentElement>;
         context: Context<GenericConfig>;
     }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called after deepClone completes all recursive cloning.
+     * Receives the full source→target mapping. Return additional operations to stage
+     */
+    afterDeepClone?: <GenericConfig extends AnyDialecteConfig>(params: {
+        mappings: CloneMapping<GenericConfig>[];
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called after a record is updated (attributes or value changed).
+     * Return additional operations to stage (e.g., update path attrs on dependent refs).
+     */
+    afterUpdated?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+        oldRecord: RawRecord<GenericConfig, GenericElement>;
+        newRecord: RawRecord<GenericConfig, GenericElement>;
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
+    /**
+     * Called before a record and its subtree are staged for deletion.
+     * Root and all descendants are still live in context at this point.
+     *
+     * Return additional operations to stage (e.g., clear or delete ref elements
+     * pointing to this record or any of its descendants).
+     */
+    beforeDelete?: <GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>>(params: {
+        record: RawRecord<GenericConfig, GenericElement>;
+        context: Context<GenericConfig>;
+    }) => Promise<Operation<GenericConfig>[]>;
 };
 export type DatabaseConfig = Readonly<{
     tables: {