@dialecte/core 0.2.8 → 0.2.10

package/dist/test/create-test-dialecte.d.ts

@@ -1,14 +1,14 @@
 import { TEST_DIALECTE_CONFIG } from './config';
 import { Project } from '../project';
-import { Document, Context } from '../document';
+import { Document, Context, ExtensionModules } from '../document';
 import { AnyDialecteConfig, TransactionHooks } from '../types';
 type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
 export type TestDocument<GenericConfig extends AnyDialecteConfig> = {
     documentId: string;
     document: Document<GenericConfig>;
 };
-export type TestProjectResult<GenericConfig extends AnyDialecteConfig> = {
-    project: Project<GenericConfig>;
+export type TestProjectResult<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
+    project: Project<GenericConfig, GenericModules>;
     source: TestDocument<GenericConfig>;
     target?: TestDocument<GenericConfig>;
 };
@@ -16,12 +16,16 @@ export type TestProjectResult<GenericConfig extends AnyDialecteConfig> = {
  * Spin up a Project with source (and optionally target) file imported.
  * Returns project + pre-opened documents. Caller owns lifecycle via project.destroy().
  */
-export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig>(params: {
+export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: {
     sourceXml: string;
     targetXml?: string;
     dialecteConfig?: GenericConfig;
+    extensions?: {
+        base?: ExtensionModules;
+        custom?: ExtensionModules;
+    };
     hooks?: TransactionHooks<GenericConfig>;
-}): Promise<TestProjectResult<GenericConfig>>;
+}): Promise<TestProjectResult<GenericConfig, GenericModules>>;
 /**
  * Create a Context directly from a databaseName for testing FP query functions.
  * Opens the store to discover existing tables.

package/dist/test/create-test-dialecte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,YAAY,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACnE,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACxE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;IACnC,MAAM,CAAC,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;CACpC,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC3D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CA4C5C;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAalC"}
+{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,YAAY,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACnE,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAC5B,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;IAC/C,MAAM,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;IACnC,MAAM,CAAC,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;CACpC,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC5D,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;KAAE,CAAA;IACnE,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;CACvC,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CA+C5D;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAalC"}

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

@@ -1,4 +1,5 @@
 import { TestRunner } from './run-test-cases.type';
+import { ExtensionModules } from '../document';
 import { AnyDialecteConfig, TransactionHooks } from '../types';
 export declare function createMockRandomUUID(): () => `${string}-${string}-${string}-${string}-${string}`;
 export declare const runTestCases: TestRunner<{
@@ -2146,6 +2147,13 @@ export declare const runTestCases: TestRunner<{
             }];
         };
     };
-}>;
-export declare function createTestRunner<GenericConfig extends AnyDialecteConfig>(dialecteConfig: GenericConfig, hooks?: TransactionHooks<GenericConfig>): TestRunner<GenericConfig>;
+}, Record<never, never>>;
+export declare function createTestRunner<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: {
+    dialecteConfig: GenericConfig;
+    hooks?: TransactionHooks<GenericConfig>;
+    extensions?: {
+        base?: ExtensionModules;
+        custom?: ExtensionModules;
+    };
+}): TestRunner<GenericConfig, GenericModules>;
 //# sourceMappingURL=run-test-cases.d.ts.map

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":"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"}
+{"version":3,"file":"run-test-cases.d.ts","sourceRoot":"","sources":["../../src/test/run-test-cases.ts"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,5 @@
-import { Document } from '../document';
+import { Document, ExtensionModules } from '../document';
+import { Project } from '../project';
 import { AnyDialecteConfig, TransactionHooks } from '../types';
 export type BaseTestCase = {
     only?: boolean;
@@ -10,8 +11,9 @@ export type BaseXmlTestCase = BaseTestCase & {
     unexpectedQueries?: string[];
 };
 export type TestCases<GenericTestCase extends BaseXmlTestCase> = Record<string, GenericTestCase>;
-export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseXmlTestCase> = {
+export type ActParams<GenericConfig extends AnyDialecteConfig, GenericTestCase extends BaseXmlTestCase, GenericModules extends ExtensionModules = Record<never, never>> = {
     testCase: GenericTestCase;
+    project: Project<GenericConfig, GenericModules>;
     source: Document<GenericConfig>;
     target?: Document<GenericConfig>;
 };
@@ -19,16 +21,16 @@ export type ActResult = {
     assertOn?: 'source' | 'target';
     withDatabaseIds?: boolean;
 };
-export type TestRunner<GenericConfig extends AnyDialecteConfig> = {
+export type TestRunner<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
     withExport<GenericTestCase extends BaseXmlTestCase>(params: {
         testCases: TestCases<GenericTestCase>;
-        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<ActResult | void>;
+        act: (params: ActParams<GenericConfig, GenericTestCase, GenericModules>) => Promise<ActResult | void>;
         dialecteConfig?: GenericConfig;
         hooks?: TransactionHooks<GenericConfig>;
     }): void;
     withoutExport<GenericTestCase extends BaseXmlTestCase>(params: {
         testCases: TestCases<GenericTestCase>;
-        act: (params: ActParams<GenericConfig, GenericTestCase>) => Promise<void>;
+        act: (params: ActParams<GenericConfig, GenericTestCase, GenericModules>) => Promise<void>;
         dialecteConfig?: GenericConfig;
         hooks?: TransactionHooks<GenericConfig>;
     }): void;

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,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,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,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,IACpC;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,UAAU,CAAC,aAAa,SAAS,iBAAiB,IAAI;IACjE,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,GAAG,IAAI,CAAC,CAAA;QACrF,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,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;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,OAAO,CAAC,eAAe,SAAS,YAAY,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAAA;CACP,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,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElE,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,SAAS,CACpB,aAAa,SAAS,iBAAiB,EACvC,eAAe,SAAS,eAAe,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH,QAAQ,EAAE,eAAe,CAAA;IACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;IAC/C,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;IAC/B,MAAM,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,UAAU,CACrB,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH,UAAU,CAAC,eAAe,SAAS,eAAe,EAAE,MAAM,EAAE;QAC3D,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;QACrC,GAAG,EAAE,CACJ,MAAM,EAAE,SAAS,CAAC,aAAa,EAAE,eAAe,EAAE,cAAc,CAAC,KAC7D,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;QAC9B,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,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,EAAE,cAAc,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACzF,cAAc,CAAC,EAAE,aAAa,CAAA;QAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,OAAO,CAAC,eAAe,SAAS,YAAY,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC1C,GAAG,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GACtC,IAAI,CAAA;CACP,CAAA"}

package/dist/test.js

@@ -1,141 +1,141 @@
 import { expect as m, it as p } from "vitest";
-import { x as D, D as w, P as L } from "./index-1D8DELEq.js";
-import { D as T, s as g, o as O, n as M } from "./merge-extensions-dj7By9gG.js";
-function v(B) {
-  const e = k(B);
+import { x as w, D as L, P as T } from "./index-1D8DELEq.js";
+import { D as g, s as O, o as M, n as k } from "./merge-extensions-dj7By9gG.js";
+function E(a) {
+  const e = R(a);
   if (e.length === 0)
-    return [B];
+    return [a];
   const t = [];
   for (const r of e)
-    t.push(B.slice(0, r));
-  return t.push(B), t;
+    t.push(a.slice(0, r));
+  return t.push(a), t;
 }
-function k(B) {
+function R(a) {
   const e = [];
-  let t = 0, r = 0, a = null;
-  for (let C = 0; C < B.length; C++) {
-    const A = B[C];
-    if (a) {
-      A === a && (a = null);
+  let t = 0, r = 0, B = null;
+  for (let A = 0; A < a.length; A++) {
+    const _ = a[A];
+    if (B) {
+      _ === B && (B = null);
       continue;
     }
-    if (A === '"' || A === "'") {
-      a = A;
+    if (_ === '"' || _ === "'") {
+      B = _;
       continue;
     }
-    if (A === "[") {
+    if (_ === "[") {
       t++;
       continue;
     }
-    if (A === "]") {
+    if (_ === "]") {
       t--;
       continue;
     }
-    if (A === "(") {
+    if (_ === "(") {
       r++;
       continue;
     }
-    if (A === ")") {
+    if (_ === ")") {
       r--;
       continue;
     }
-    if (!(t > 0 || r > 0) && A === "/") {
-      if (C === 0) {
-        B[C + 1] === "/" && C++;
+    if (!(t > 0 || r > 0) && _ === "/") {
+      if (A === 0) {
+        a[A + 1] === "/" && A++;
         continue;
       }
-      if (e.length === 0 && C === 1 && B[0] === "/")
+      if (e.length === 0 && A === 1 && a[0] === "/")
         continue;
-      e.push(C), B[C + 1] === "/" && C++;
+      e.push(A), a[A + 1] === "/" && A++;
     }
   }
   return e;
 }
-function R(B) {
-  const { namespaces: e } = B, t = F(e);
+function V(a) {
+  const { namespaces: e } = a, t = y(e);
   return {
     assertExpectedElementQueries(r) {
-      V({ ...r, nsResolver: t });
+      F({ ...r, nsResolver: t });
     },
     assertUnexpectedElementQueries(r) {
-      y({ ...r, nsResolver: t });
+      I({ ...r, nsResolver: t });
     }
   };
 }
-function V(B) {
-  const { xmlDocument: e, queries: t, nsResolver: r } = B;
-  for (const a of t)
-    I({ xmlDocument: e, xpath: a, nsResolver: r });
+function F(a) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = a;
+  for (const B of t)
+    U({ xmlDocument: e, xpath: B, nsResolver: r });
 }
-function F(B) {
-  return (e) => e ? B[e]?.uri ?? null : null;
+function y(a) {
+  return (e) => e ? a[e]?.uri ?? null : null;
 }
-function y(B) {
-  const { xmlDocument: e, queries: t, nsResolver: r } = B;
-  for (const a of t)
-    U({ xmlDocument: e, xpath: a, nsResolver: r });
+function I(a) {
+  const { xmlDocument: e, queries: t, nsResolver: r } = a;
+  for (const B of t)
+    N({ xmlDocument: e, xpath: B, nsResolver: r });
 }
-function I(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = v(t);
-  let C = null, A = 0;
-  for (let s = 0; s < a.length; s++) {
-    const _ = a[s], c = e.evaluate(
-      _,
+function U(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = a, B = E(t);
+  let A = null, _ = 0;
+  for (let C = 0; C < B.length; C++) {
+    const s = B[C], n = e.evaluate(
+      s,
       e,
       r ?? null,
       XPathResult.FIRST_ORDERED_NODE_TYPE,
       null
     ).singleNodeValue;
-    if (c) {
-      C = c, A = s + 1;
+    if (n) {
+      A = n, _ = C + 1;
       continue;
     }
-    const n = s === 0 ? a[0] : t.slice(a[s - 1].length), u = A === 0 ? `[No parent matched — failed from document root]
+    const i = C === 0 ? B[0] : t.slice(B[C - 1].length), u = _ === 0 ? `[No parent matched — failed from document root]
   Document:
-${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${A}/${a.length}]:
-${C ? x({ xml: C.outerHTML }) : "(none)"}`;
+${x({ xml: new XMLSerializer().serializeToString(e) })}` : `[Last match at step ${_}/${B.length}]:
+${A ? x({ xml: A.outerHTML }) : "(none)"}`;
     m(
-      c,
+      n,
       `Element not found in XML.
-  Failed at step ${s + 1}/${a.length}: ${n.trim()}
+  Failed at step ${C + 1}/${B.length}: ${i.trim()}
   Full XPath: ${t}
   ${u}`
     ).toBeTruthy();
     return;
   }
 }
-function x(B) {
-  const { xml: e } = B;
+function x(a) {
+  const { xml: e } = a;
   try {
-    return D(e, { indentation: "  ", collapseContent: !0 });
+    return w(e, { indentation: "  ", collapseContent: !0 });
   } catch {
     return e;
   }
 }
-function U(B) {
-  const { xmlDocument: e, xpath: t, nsResolver: r } = B, a = v(t);
-  if (a.length > 1) {
-    let s = null;
-    for (let _ = 0; _ < a.length - 1; _++) {
-      const i = a[_], n = e.evaluate(
-        i,
+function N(a) {
+  const { xmlDocument: e, xpath: t, nsResolver: r } = a, B = E(t);
+  if (B.length > 1) {
+    let C = null;
+    for (let s = 0; s < B.length - 1; s++) {
+      const c = B[s], i = e.evaluate(
+        c,
         e,
         r ?? null,
         XPathResult.FIRST_ORDERED_NODE_TYPE,
         null
-      ).singleNodeValue, u = _ === 0 ? a[0] : t.slice(a[_ - 1].length), o = _ === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${_}]:
-${s ? x({ xml: s.outerHTML }) : "(none)"}`;
+      ).singleNodeValue, u = s === 0 ? B[0] : t.slice(B[s - 1].length), l = s === 0 ? "[Document root — no parent context]" : `[Parent element found at step ${s}]:
+${C ? x({ xml: C.outerHTML }) : "(none)"}`;
       m(
-        n,
+        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 ${_ + 1}/${a.length}: ${u.trim()}
+  Missing at step ${s + 1}/${B.length}: ${u.trim()}
   Full XPath: ${t}
-  ${o}`
-      ).toBeTruthy(), s = n;
+  ${l}`
+      ).toBeTruthy(), C = i;
     }
   }
-  const A = e.evaluate(
+  const _ = e.evaluate(
     t,
     e,
     r ?? null,
@@ -143,11 +143,11 @@ ${s ? x({ xml: s.outerHTML }) : "(none)"}`;
     null
   ).singleNodeValue;
   m(
-    A,
+    _,
     `Element should NOT exist in XML but was found.
   XPath: ${t}
   Found:
-${A ? x({ xml: A.outerHTML }) : "(none)"}`
+${_ ? x({ xml: _.outerHTML }) : "(none)"}`
   ).toBeFalsy();
 }
 const d = {
@@ -155,12 +155,12 @@ const d = {
     uri: "http://dialecte.dev/XML/DEFAULT",
     prefix: ""
   },
-  dev: T,
+  dev: g,
   ext: {
     uri: "http://dialecte.dev/XML/DEV-EXT",
     prefix: "ext"
   }
-}, Ce = `xmlns="${d.default.uri}"`, _e = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, se = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, N = [
+}, _e = `xmlns="${d.default.uri}"`, se = `xmlns:${d.dev.prefix}="${d.dev.uri}"`, ce = `xmlns:${d.ext.prefix}="${d.ext.uri}"`, $ = [
   "A",
   "AAAA_1",
   "AAAA_2",
@@ -192,7 +192,7 @@ const d = {
   "CC_2",
   "CC_3",
   "Root"
-], $ = {
+], P = {
   A: ["AA_1", "AA_2", "AA_3"],
   AAAA_1: [],
   AAAA_2: [],
@@ -224,7 +224,7 @@ const d = {
   CC_2: ["CCC_1", "CCC_2", "CCC_3"],
   CC_3: ["CCC_1", "CCC_2", "CCC_3"],
   Root: ["A", "B", "C"]
-}, P = {
+}, Q = {
   A: ["Root"],
   AAAA_1: ["AAA_1", "AAA_2", "AAA_3"],
   AAAA_2: ["AAA_1", "AAA_2", "AAA_3"],
@@ -256,7 +256,7 @@ const d = {
   CC_2: ["C"],
   CC_3: ["C"],
   Root: []
-}, Q = {
+}, j = {
   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 d = {
     "CC_2",
     "CC_3"
   ]
-}, j = {
+}, z = {
   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 d = {
   CC_2: ["C", "Root"],
   CC_3: ["C", "Root"],
   Root: []
-}, z = "Root", G = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], H = {
+}, G = "Root", H = ["A", "AA_1", "B", "BB_1", "C", "CC_1", "CC_2", "Root"], Y = {
   A: {
     aA: "",
     bA: "",
@@ -508,7 +508,7 @@ const d = {
     "ext:root": "",
     root: ""
   }
-}, Y = {
+}, K = {
   A: {
     tag: "A",
     namespace: { prefix: "", uri: "http://dialecte.dev/XML/DEFAULT" },
@@ -1533,9 +1533,9 @@ const d = {
       }
     ]
   }
-}, K = {
-  supportedFileExtensions: [".xml"]
 }, W = {
+  supportedFileExtensions: [".xml"]
+}, Z = {
   recordSchema: {
     primaryKey: "id",
     indexes: ["tagName", "parent.id", "parent.tagName"],
@@ -1549,168 +1549,180 @@ const d = {
       schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
     }
   }
-}, l = {
-  rootElementName: z,
-  singletonElements: G,
-  elements: N,
+}, o = {
+  rootElementName: G,
+  singletonElements: H,
+  elements: $,
   namespaces: d,
-  attributes: H,
-  children: $,
-  parents: P,
-  descendants: Q,
-  ancestors: j,
-  database: W,
-  io: K,
-  definition: Y
+  attributes: Y,
+  children: P,
+  parents: Q,
+  descendants: j,
+  ancestors: z,
+  database: Z,
+  io: W,
+  definition: K
 };
-async function E(B) {
+async function b(a) {
   const {
     sourceXml: e,
     targetXml: t,
-    dialecteConfig: r = l,
-    hooks: a
-  } = B, C = `test-${crypto.randomUUID()}`, A = await new L({
+    dialecteConfig: r = o,
+    extensions: B,
+    hooks: A
+  } = a, _ = `test-${crypto.randomUUID()}`, C = await new T({
     configs: { default: r },
     defaultConfigKey: "default",
     storage: { type: "local" },
-    hooks: a
-  }).open(C), [s] = await A.import(
+    extensions: B,
+    hooks: A
+  }).open(_), [s] = await C.import(
     [new File([e], "source.xml", { type: "text/xml" })],
     { useCustomRecordsIds: !0 }
-  ), _ = {
+  ), c = {
     documentId: s.documentId,
-    document: A.openDocument(s.documentId)
+    document: C.openDocument(s.documentId)
   };
-  let i;
+  let n;
   if (t) {
-    const [c] = await A.import(
+    const [i] = await C.import(
       [new File([t], "target.xml", { type: "text/xml" })],
       { useCustomRecordsIds: !0 }
     );
-    i = {
-      documentId: c.documentId,
-      document: A.openDocument(c.documentId)
+    n = {
+      documentId: i.documentId,
+      document: C.openDocument(i.documentId)
     };
   }
-  return { project: A, source: _, target: i };
+  return { project: C, source: c, target: n };
 }
-async function ce(B) {
-  const { databaseName: e, dialecteConfig: t, documentId: r } = B, a = new w(e, {
+async function ie(a) {
+  const { databaseName: e, dialecteConfig: t, documentId: r } = a, B = new L(e, {
     recordSchema: t.database.recordSchema
   });
-  return await a.open(), {
+  return await B.open(), {
     dialecteConfig: t,
-    store: a,
+    store: B,
     documentId: r,
     recordCache: /* @__PURE__ */ new Map(),
     stagedOperations: []
   };
 }
-const b = crypto.randomUUID.bind(crypto);
-function X() {
-  let B = 0;
+const X = crypto.randomUUID.bind(crypto);
+function q() {
+  let a = 0;
   return function() {
-    return `${B++}`;
+    return `${a++}`;
   };
 }
-function Z(B) {
+function J(a) {
   const {
     testCases: e,
     act: t,
-    hooks: r,
-    dialecteConfig: a = l
-  } = B, { assertExpectedElementQueries: C, assertUnexpectedElementQueries: A } = R({
-    namespaces: a.namespaces
+    extensions: r,
+    hooks: B,
+    dialecteConfig: A = o
+  } = a, { assertExpectedElementQueries: _, assertUnexpectedElementQueries: C } = V({
+    namespaces: A.namespaces
   });
-  for (const [s, _] of Object.entries(e))
-    (_.only ? p.only : p)(s, async () => {
-      crypto.randomUUID = b;
-      const { project: c, source: n, target: u } = await E({
-        sourceXml: _.sourceXml,
-        targetXml: _.targetXml,
-        dialecteConfig: a,
-        hooks: r
+  for (const [s, c] of Object.entries(e))
+    (c.only ? p.only : p)(s, async () => {
+      crypto.randomUUID = X;
+      const { project: i, source: u, target: l } = await b({
+        sourceXml: c.sourceXml,
+        targetXml: c.targetXml,
+        dialecteConfig: A,
+        extensions: r,
+        hooks: B
       });
       try {
-        crypto.randomUUID = X();
-        const o = await t({ testCase: _, source: n.document, target: u?.document }), q = o?.assertOn ?? "source", S = o?.withDatabaseIds ?? !0, f = q === "target" ? u?.documentId : n.documentId;
-        if (!f) throw new Error("documentId required for export");
-        const { xmlDocument: h } = await c.export(f, { withDatabaseIds: S });
-        _.expectedQueries?.length && C({ xmlDocument: h, queries: _.expectedQueries }), _.unexpectedQueries?.length && A({ xmlDocument: h, queries: _.unexpectedQueries });
+        crypto.randomUUID = q();
+        const f = await t({
+          testCase: c,
+          project: i,
+          source: u.document,
+          target: l?.document
+        }), S = f?.assertOn ?? "source", D = f?.withDatabaseIds ?? !0, h = S === "target" ? l?.documentId : u.documentId;
+        if (!h) throw new Error("documentId required for export");
+        const { xmlDocument: v } = await i.export(h, { withDatabaseIds: D });
+        c.expectedQueries?.length && _({ xmlDocument: v, queries: c.expectedQueries }), c.unexpectedQueries?.length && C({ xmlDocument: v, queries: c.unexpectedQueries });
       } finally {
-        await c.destroy();
+        await i.destroy();
       }
     });
 }
-function J(B) {
+function ee(a) {
   const {
     testCases: e,
     act: t,
-    hooks: r,
-    dialecteConfig: a = l
-  } = B;
-  for (const [C, A] of Object.entries(e))
-    (A.only ? p.only : p)(C, async () => {
-      crypto.randomUUID = b;
-      const { project: _, source: i, target: c } = await E({
-        sourceXml: A.sourceXml,
-        targetXml: A.targetXml,
-        dialecteConfig: a,
-        hooks: r
+    extensions: r,
+    hooks: B,
+    dialecteConfig: A = o
+  } = a;
+  for (const [_, C] of Object.entries(e))
+    (C.only ? p.only : p)(_, async () => {
+      crypto.randomUUID = X;
+      const { project: c, source: n, target: i } = await b({
+        sourceXml: C.sourceXml,
+        targetXml: C.targetXml,
+        dialecteConfig: A,
+        extensions: r,
+        hooks: B
       });
       try {
-        crypto.randomUUID = X(), await t({ testCase: A, source: i.document, target: c?.document });
+        crypto.randomUUID = q(), await t({ testCase: C, project: c, source: n.document, target: i?.document });
       } finally {
-        await _.destroy();
+        await c.destroy();
       }
     });
 }
-function ee(B, e) {
-  for (const [t, r] of Object.entries(B))
+function te(a, e) {
+  for (const [t, r] of Object.entries(a))
     (r.only ? p.only : p)(t, () => e(r));
 }
-const ie = te(l);
-function te(B, e) {
+const ne = ae({ dialecteConfig: o });
+function ae(a) {
+  const { dialecteConfig: e, hooks: t, extensions: r } = a;
   return {
-    withExport: (t) => Z({ dialecteConfig: B, hooks: e, ...t }),
-    withoutExport: (t) => J({ dialecteConfig: B, hooks: e, ...t }),
-    generic: ee
+    withExport: (B) => J({ dialecteConfig: e, extensions: r, hooks: t, ...B }),
+    withoutExport: (B) => ee({ dialecteConfig: e, extensions: r, hooks: t, ...B }),
+    generic: te
   };
 }
-function Be(B) {
+function Be(a) {
   function e(t) {
-    const { record: r, type: a = "raw" } = t, C = g({ record: r, dialecteConfig: B });
-    switch (a) {
+    const { record: r, type: B = "raw" } = t, A = O({ record: r, dialecteConfig: a });
+    switch (B) {
       case "raw":
-        return C;
+        return A;
       case "tracked":
-        return M({ record: C });
+        return k({ record: A });
       case "tree":
-        return O({ record: C });
+        return M({ record: A });
       default:
-        throw new Error(`Unsupported record type: ${a}`);
+        throw new Error(`Unsupported record type: ${B}`);
     }
   }
   return e;
 }
-const ne = Be(l);
+const ue = Be(o);
 export {
-  W as DATABASE_CONFIG,
+  Z as DATABASE_CONFIG,
   d as DIALECTE_NAMESPACES,
-  K as IO_CONFIG,
-  l as TEST_DIALECTE_CONFIG,
-  Ce as XMLNS_DEFAULT_NAMESPACE,
-  _e as XMLNS_DEV_NAMESPACE,
-  se as XMLNS_EXT_NAMESPACE,
-  V as assertExpectedElementQueries,
-  y as assertUnexpectedElementQueries,
-  X as createMockRandomUUID,
-  ce as createTestContext,
-  E as createTestProject,
-  ne as createTestRecord,
+  W as IO_CONFIG,
+  o as TEST_DIALECTE_CONFIG,
+  _e as XMLNS_DEFAULT_NAMESPACE,
+  se as XMLNS_DEV_NAMESPACE,
+  ce as XMLNS_EXT_NAMESPACE,
+  F as assertExpectedElementQueries,
+  I as assertUnexpectedElementQueries,
+  q as createMockRandomUUID,
+  ie as createTestContext,
+  b as createTestProject,
+  ue as createTestRecord,
   Be as createTestRecordFactory,
-  te as createTestRunner,
-  R as createXmlAssertions,
-  ie as runTestCases,
-  v as splitXpathIntoSteps
+  ae as createTestRunner,
+  V as createXmlAssertions,
+  ne as runTestCases,
+  E as splitXpathIntoSteps
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/core",
-	"version": "0.2.8",
+	"version": "0.2.10",
 	"description": "Dialecte - Core functionality for Dialecte SDK",
 	"license": "MIT",
 	"repository": {