@getodk/xpath 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,21 +1,21 @@
-import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-BRkDdCO9.js';
+import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-DpqfmhIO.js';
 
 function _mergeNamespaces(n, m) {
-	for (var i = 0; i < m.length; i++) {
-		const e = m[i];
-		if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
-			if (k !== 'default' && !(k in n)) {
-				const d = Object.getOwnPropertyDescriptor(e, k);
-				if (d) {
-					Object.defineProperty(n, k, d.get ? d : {
-						enumerable: true,
-						get: () => e[k]
-					});
-				}
-			}
-		} }
-	}
-	return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
+    for (var i = 0; i < m.length; i++) {
+        const e = m[i];
+        if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
+            if (k !== 'default' && !(k in n)) {
+                const d = Object.getOwnPropertyDescriptor(e, k);
+                if (d) {
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: () => e[k]
+                    });
+                }
+            }
+        } }
+    }
+    return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
 }
 
 const t = {};
@@ -387,13 +387,13 @@ function ParseTemporalYearMonthString(e) {
     if (void 0 !== n && "iso8601" !== n) throw new RangeError("YYYY-MM format is only valid with iso8601 calendar");
   } else {
     let t;
-    if (({
+    if ({
       year: r,
       month: o,
       calendar: n,
       day: a,
       z: t
-    } = ParseISODateTime(e)), t) throw new RangeError("Z designator not supported for PlainYearMonth");
+    } = ParseISODateTime(e), t) throw new RangeError("Z designator not supported for PlainYearMonth");
   }
   return {
     year: r,
@@ -412,13 +412,13 @@ function ParseTemporalMonthDayString(e) {
     if (void 0 !== n && "iso8601" !== n) throw new RangeError("MM-DD format is only valid with iso8601 calendar");
   } else {
     let t;
-    if (({
+    if ({
       month: r,
       day: o,
       calendar: n,
       year: a,
       z: t
-    } = ParseISODateTime(e)), t) throw new RangeError("Z designator not supported for PlainMonthDay");
+    } = ParseISODateTime(e), t) throw new RangeError("Z designator not supported for PlainMonthDay");
   }
   return {
     month: r,
@@ -799,7 +799,7 @@ function ToRelativeTemporalObject(e) {
     e.push("timeZone", "offset");
     const p = PrepareTemporalFields(t, e, []),
       f = Te(null);
-    f.overflow = "constrain", ({
+    f.overflow = "constrain", {
       year: r,
       month: o,
       day: n,
@@ -809,10 +809,10 @@ function ToRelativeTemporalObject(e) {
       millisecond: l,
       microsecond: d,
       nanosecond: m
-    } = InterpretTemporalDateTimeFields(c, p, f)), u = p.offset, void 0 === u && (T = "wall"), h = p.timeZone, void 0 !== h && (h = ToTemporalTimeZoneSlotValue(h));
+    } = InterpretTemporalDateTimeFields(c, p, f), u = p.offset, void 0 === u && (T = "wall"), h = p.timeZone, void 0 !== h && (h = ToTemporalTimeZoneSlotValue(h));
   } else {
     let e, f;
-    if (({
+    if ({
       year: r,
       month: o,
       day: n,
@@ -826,7 +826,7 @@ function ToRelativeTemporalObject(e) {
       ianaName: e,
       offset: u,
       z: f
-    } = ParseISODateTime(ToString(t))), e) h = ToTemporalTimeZoneSlotValue(e), f ? T = "exact" : u || (T = "wall"), p = !0;else if (f) throw new RangeError("Z designator not supported for PlainDate relativeTo; either remove the Z or add a bracketed time zone");
+    } = ParseISODateTime(ToString(t)), e) h = ToTemporalTimeZoneSlotValue(e), f ? T = "exact" : u || (T = "wall"), p = !0;else if (f) throw new RangeError("Z designator not supported for PlainDate relativeTo; either remove the Z or add a bracketed time zone");
     if (c || (c = "iso8601"), !IsBuiltinCalendar(c)) throw new RangeError(`invalid calendar identifier ${c}`);
     c = ASCIILowercase(c);
   }
@@ -906,14 +906,14 @@ function InterpretTemporalDateTimeFields(e, t, r) {
     T = GetSlot(u, i),
     p = GetSlot(u, s),
     f = GetSlot(u, l);
-  return ({
+  return {
     hour: o,
     minute: n,
     second: a,
     millisecond: d,
     microsecond: m,
     nanosecond: c
-  } = RegulateTime(o, n, a, d, m, c, h)), {
+  } = RegulateTime(o, n, a, d, m, c, h), {
     year: T,
     month: p,
     day: f,
@@ -946,7 +946,7 @@ function ToTemporalDateTime(e, t) {
     } = InterpretTemporalDateTimeFields(T, f, t));
   } else {
     let i;
-    if (ToTemporalOverflow(t), ({
+    if (ToTemporalOverflow(t), {
       year: r,
       month: o,
       day: n,
@@ -960,7 +960,7 @@ function ToTemporalDateTime(e, t) {
       z: i
     } = function ParseTemporalDateTimeString(e) {
       return ParseISODateTime(e);
-    }(ToString(e))), i) throw new RangeError("Z designator not supported for PlainDateTime");
+    }(ToString(e)), i) throw new RangeError("Z designator not supported for PlainDateTime");
     if (RejectDateTime(r, o, n, a, d, m, c, h, u), T || (T = "iso8601"), !IsBuiltinCalendar(T)) throw new RangeError(`invalid calendar identifier ${T}`);
     T = ASCIILowercase(T);
   }
@@ -1033,14 +1033,14 @@ function ToTemporalTime(e, t = "constrain") {
       millisecond: a,
       microsecond: i,
       nanosecond: s
-    } = ToTemporalTimeRecord(l))), ({
+    } = ToTemporalTimeRecord(l))), {
       hour: r,
       minute: o,
       second: n,
       millisecond: a,
       microsecond: i,
       nanosecond: s
-    } = RegulateTime(r, o, n, a, i, s, t));
+    } = RegulateTime(r, o, n, a, i, s, t);
   } else (({
     hour: r,
     minute: o,
@@ -1059,7 +1059,7 @@ function ToTemporalTime(e, t = "constrain") {
       if (t[8]) throw new RangeError("Z designator not supported for PlainTime");
     } else {
       let t, l;
-      if (({
+      if ({
         hasTime: l,
         hour: r,
         minute: o,
@@ -1068,7 +1068,7 @@ function ToTemporalTime(e, t = "constrain") {
         microsecond: i,
         nanosecond: s,
         z: t
-      } = ParseISODateTime(e)), !l) throw new RangeError(`time is missing in string: ${e}`);
+      } = ParseISODateTime(e), !l) throw new RangeError(`time is missing in string: ${e}`);
       if (t) throw new RangeError("Z designator not supported for PlainTime");
     }
     if (/[tT ][0-9][0-9]/.test(e)) return {
@@ -1170,7 +1170,7 @@ function ToTemporalZonedDateTime(e, t) {
     const f = CalendarFields(u, ["day", "hour", "microsecond", "millisecond", "minute", "month", "monthCode", "nanosecond", "second", "year"]);
     f.push("timeZone", "offset");
     const I = PrepareTemporalFields(e, f, ["timeZone"]);
-    c = ToTemporalTimeZoneSlotValue(I.timeZone), h = I.offset, void 0 === h && (y = "wall"), T = ToTemporalDisambiguation(t), p = ToTemporalOffset(t, "reject"), ({
+    c = ToTemporalTimeZoneSlotValue(I.timeZone), h = I.offset, void 0 === h && (y = "wall"), T = ToTemporalDisambiguation(t), p = ToTemporalOffset(t, "reject"), {
       year: r,
       month: o,
       day: n,
@@ -1180,10 +1180,10 @@ function ToTemporalZonedDateTime(e, t) {
       millisecond: l,
       microsecond: d,
       nanosecond: m
-    } = InterpretTemporalDateTimeFields(u, I, t));
+    } = InterpretTemporalDateTimeFields(u, I, t);
   } else {
     let I, S;
-    if (({
+    if ({
       year: r,
       month: o,
       day: n,
@@ -1201,7 +1201,7 @@ function ToTemporalZonedDateTime(e, t) {
       const t = ParseISODateTime(e);
       if (!t.ianaName) throw new RangeError("Temporal.ZonedDateTime requires a time zone ID in brackets");
       return t;
-    }(ToString(e))), c = ToTemporalTimeZoneSlotValue(I), S ? y = "exact" : h || (y = "wall"), u || (u = "iso8601"), !IsBuiltinCalendar(u)) throw new RangeError(`invalid calendar identifier ${u}`);
+    }(ToString(e)), c = ToTemporalTimeZoneSlotValue(I), S ? y = "exact" : h || (y = "wall"), u || (u = "iso8601"), !IsBuiltinCalendar(u)) throw new RangeError(`invalid calendar identifier ${u}`);
     u = ASCIILowercase(u), f = !0, T = ToTemporalDisambiguation(t), p = ToTemporalOffset(t, "reject"), ToTemporalOverflow(t);
   }
   let I = 0;
@@ -1593,7 +1593,7 @@ function GetPlainDateTimeFor(e, t, r) {
     microsecond: u,
     nanosecond: T
   } = GetISOPartsFromEpoch(o);
-  return ({
+  return {
     year: i,
     month: s,
     day: l,
@@ -1603,7 +1603,7 @@ function GetPlainDateTimeFor(e, t, r) {
     millisecond: h,
     microsecond: u,
     nanosecond: T
-  } = BalanceISODateTime(i, s, l, d, m, c, h, u, T + a)), CreateTemporalDateTime(i, s, l, d, m, c, h, u, T, r);
+  } = BalanceISODateTime(i, s, l, d, m, c, h, u, T + a), CreateTemporalDateTime(i, s, l, d, m, c, h, u, T, r);
 }
 function GetInstantFor(e, t, r) {
   return DisambiguatePossibleInstants(GetPossibleInstantsFor(e, t), e, t, r);
@@ -1751,13 +1751,13 @@ function TemporalDurationToString(t, r = "auto", o) {
   (({
     quotient: Y,
     remainder: I
-  } = divmod(Y, De))), ({
+  } = divmod(Y, De))), {
     quotient: Y,
     remainder: S
-  } = divmod(Y, De)), ({
+  } = divmod(Y, De), {
     quotient: F,
     remainder: g
-  } = divmod(Y, De));
+  } = divmod(Y, De);
   const P = 1e6 * ae(Number(g)) + 1e3 * ae(Number(S)) + ae(Number(I));
   let Z;
   if ("auto" === r) {
@@ -2092,10 +2092,10 @@ function BalanceISODate(e, t, r) {
     year: o,
     month: n
   } = BalanceISOYearMonth(o, n - 1))), a += ISODaysInMonth(o, n);
-  for (; a > ISODaysInMonth(o, n);) a -= ISODaysInMonth(o, n), ({
+  for (; a > ISODaysInMonth(o, n);) a -= ISODaysInMonth(o, n), {
     year: o,
     month: n
-  } = BalanceISOYearMonth(o, n + 1));
+  } = BalanceISOYearMonth(o, n + 1);
   return {
     year: o,
     month: n,
@@ -2137,25 +2137,25 @@ function BalanceTime(t, r, o, n, a, i) {
     c = BigInt(n),
     h = BigInt(a),
     u = BigInt(i);
-  return ({
+  return {
     quotient: s,
     remainder: u
-  } = NonNegativeBigIntDivmod(u, De)), h = h + s, ({
+  } = NonNegativeBigIntDivmod(u, De), h = h + s, {
     quotient: s,
     remainder: h
-  } = NonNegativeBigIntDivmod(h, De)), c = c + s, ({
+  } = NonNegativeBigIntDivmod(h, De), c = c + s, {
     quotient: s,
     remainder: c
-  } = NonNegativeBigIntDivmod(c, De)), m = m + s, ({
+  } = NonNegativeBigIntDivmod(c, De), m = m + s, {
     quotient: s,
     remainder: m
-  } = NonNegativeBigIntDivmod(m, ge)), d = d + s, ({
+  } = NonNegativeBigIntDivmod(m, ge), d = d + s, {
     quotient: s,
     remainder: d
-  } = NonNegativeBigIntDivmod(d, ge)), l = l + s, ({
+  } = NonNegativeBigIntDivmod(d, ge), l = l + s, {
     quotient: s,
     remainder: l
-  } = NonNegativeBigIntDivmod(l, we)), {
+  } = NonNegativeBigIntDivmod(l, we), {
     deltaDays: Number(s),
     hour: Number(l),
     minute: Number(d),
@@ -2188,10 +2188,10 @@ function NanosecondsToDays(t, r) {
   };
   if (!IsTemporalZonedDateTime(r)) {
     let t;
-    return ({
+    return {
       quotient: t,
       remainder: f
-    } = divmod(f, BigInt(y))), {
+    } = divmod(f, BigInt(y)), {
       days: Number(t),
       nanoseconds: f,
       dayLengthNs: y
@@ -2249,10 +2249,10 @@ function BalancePossiblyInfiniteDuration(t, r, o, a, i, s, l, d, m) {
       d = GetSlot(m, n);
     c = t - d;
   } else c = TotalDurationNanoseconds(I, r, o, a, i, s, l, 0);
-  "year" === d || "month" === d || "week" === d || "day" === d ? ({
+  "year" === d || "month" === d || "week" === d || "day" === d ? {
     days: I,
     nanoseconds: c
-  } = NanosecondsToDays(c, m)) : I = 0;
+  } = NanosecondsToDays(c, m) : I = 0;
   const w = c < Ie ? -1 : 1;
   switch (c = abs$1(c), h = u = T = f = y = Ie, d) {
     case "year":
@@ -2263,55 +2263,55 @@ function BalancePossiblyInfiniteDuration(t, r, o, a, i, s, l, d, m) {
       (({
         quotient: h,
         remainder: c
-      } = divmod(c, De))), ({
+      } = divmod(c, De))), {
         quotient: u,
         remainder: h
-      } = divmod(h, De)), ({
+      } = divmod(h, De), {
         quotient: T,
         remainder: u
-      } = divmod(u, De)), ({
+      } = divmod(u, De), {
         quotient: f,
         remainder: T
-      } = divmod(T, ge)), ({
+      } = divmod(T, ge), {
         quotient: y,
         remainder: f
-      } = divmod(f, ge));
+      } = divmod(f, ge);
       break;
     case "minute":
       (({
         quotient: h,
         remainder: c
-      } = divmod(c, De))), ({
+      } = divmod(c, De))), {
         quotient: u,
         remainder: h
-      } = divmod(h, De)), ({
+      } = divmod(h, De), {
         quotient: T,
         remainder: u
-      } = divmod(u, De)), ({
+      } = divmod(u, De), {
         quotient: f,
         remainder: T
-      } = divmod(T, ge));
+      } = divmod(T, ge);
       break;
     case "second":
       (({
         quotient: h,
         remainder: c
-      } = divmod(c, De))), ({
+      } = divmod(c, De))), {
         quotient: u,
         remainder: h
-      } = divmod(h, De)), ({
+      } = divmod(h, De), {
         quotient: T,
         remainder: u
-      } = divmod(u, De));
+      } = divmod(u, De);
       break;
     case "millisecond":
       (({
         quotient: h,
         remainder: c
-      } = divmod(c, De))), ({
+      } = divmod(c, De))), {
         quotient: u,
         remainder: h
-      } = divmod(h, De));
+      } = divmod(h, De);
       break;
     case "microsecond":
       ({
@@ -2590,7 +2590,7 @@ function DifferenceTime(e, t, r, o, n, a, i, s, l, d, m, c) {
   const I = DurationSign(0, 0, 0, 0, h, u, T, p, f, y);
   h *= I, u *= I, T *= I, p *= I, f *= I, y *= I;
   let S = 0;
-  if (({
+  if ({
     deltaDays: S,
     hour: h,
     minute: u,
@@ -2598,7 +2598,7 @@ function DifferenceTime(e, t, r, o, n, a, i, s, l, d, m, c) {
     millisecond: p,
     microsecond: f,
     nanosecond: y
-  } = BalanceTime(h, u, T, p, f, y)), 0 != S) throw new Error("assertion failure in DifferenceTime: _bt_.[[Days]] should be 0");
+  } = BalanceTime(h, u, T, p, f, y), 0 != S) throw new Error("assertion failure in DifferenceTime: _bt_.[[Days]] should be 0");
   return h *= I, u *= I, T *= I, p *= I, f *= I, y *= I, {
     hours: h,
     minutes: u,
@@ -2616,14 +2616,14 @@ function DifferenceInstant(t, r, o, n, a, i) {
     c = Number(s / De % De),
     h = Number(s / Ge % De),
     u = Number(s / ve);
-  return ({
+  return {
     hours: l,
     minutes: d,
     seconds: u,
     milliseconds: h,
     microseconds: c,
     nanoseconds: m
-  } = RoundDuration(0, 0, 0, 0, 0, 0, u, h, c, m, o, n, i)), BalanceDuration(0, l, d, u, h, c, m, a);
+  } = RoundDuration(0, 0, 0, 0, 0, 0, u, h, c, m, o, n, i), BalanceDuration(0, l, d, u, h, c, m, a);
 }
 function DifferenceISODateTime(e, t, r, o, n, a, i, s, l, d, m, c, h, u, T, p, f, y, I, S, g) {
   let w = e,
@@ -2638,18 +2638,18 @@ function DifferenceISODateTime(e, t, r, o, n, a, i, s, l, d, m, c, h, u, T, p, f
       nanoseconds: M
     } = DifferenceTime(o, n, a, i, s, l, h, u, T, p, f, y);
   const R = DurationSign(0, 0, 0, 0, v, C, O, b, E, M);
-  CompareISODate(d, m, c, w, D, G) === -R && (({
+  CompareISODate(d, m, c, w, D, G) === -R && ({
     year: w,
     month: D,
     day: G
-  } = BalanceISODate(w, D, G - R)), ({
+  } = BalanceISODate(w, D, G - R), {
     hours: v,
     minutes: C,
     seconds: O,
     milliseconds: b,
     microseconds: E,
     nanoseconds: M
-  } = BalanceDuration(-R, v, C, O, b, E, M, S)));
+  } = BalanceDuration(-R, v, C, O, b, E, M, S));
   const F = CreateTemporalDate(w, D, G, I),
     Y = CreateTemporalDate(d, m, c, I),
     P = LargerOfTwoTemporalUnits("day", S),
@@ -2661,7 +2661,7 @@ function DifferenceISODateTime(e, t, r, o, n, a, i, s, l, d, m, c, h, u, T, p, f
     weeks: j,
     days: $
   } = CalendarDateUntil(I, F, Y, Z);
-  return ({
+  return {
     days: $,
     hours: v,
     minutes: C,
@@ -2669,7 +2669,7 @@ function DifferenceISODateTime(e, t, r, o, n, a, i, s, l, d, m, c, h, u, T, p, f
     milliseconds: b,
     microseconds: E,
     nanoseconds: M
-  } = BalanceDuration($, v, C, O, b, E, M, S)), {
+  } = BalanceDuration($, v, C, O, b, E, M, S), {
     years: B,
     months: N,
     weeks: j,
@@ -2848,7 +2848,7 @@ function DifferenceTemporalPlainDateTime(e, t, r, o) {
     milliseconds: O,
     microseconds: b,
     nanoseconds: E
-  } = RoundDuration(S, g, w, D, G, v, C, O, b, E, I.roundingIncrement, I.smallestUnit, I.roundingMode, M))), ({
+  } = RoundDuration(S, g, w, D, G, v, C, O, b, E, I.roundingIncrement, I.smallestUnit, I.roundingMode, M))), {
     days: D,
     hours: G,
     minutes: v,
@@ -2856,7 +2856,7 @@ function DifferenceTemporalPlainDateTime(e, t, r, o) {
     milliseconds: O,
     microseconds: b,
     nanoseconds: E
-  } = BalanceDuration(D, G, v, C, O, b, E, I.largestUnit));
+  } = BalanceDuration(D, G, v, C, O, b, E, I.largestUnit);
   return new (GetIntrinsic("%Temporal.Duration%"))(n * S, n * g, n * w, n * D, n * G, n * v, n * C, n * O, n * b, n * E);
 }
 function DifferenceTemporalPlainTime(e, t, r, o) {
@@ -2878,14 +2878,14 @@ function DifferenceTemporalPlainTime(e, t, r, o) {
     milliseconds: f,
     microseconds: y,
     nanoseconds: I
-  } = RoundDuration(0, 0, 0, 0, s, l, p, f, y, I, i.roundingIncrement, i.smallestUnit, i.roundingMode))), ({
+  } = RoundDuration(0, 0, 0, 0, s, l, p, f, y, I, i.roundingIncrement, i.smallestUnit, i.roundingMode))), {
     hours: s,
     minutes: l,
     seconds: p,
     milliseconds: f,
     microseconds: y,
     nanoseconds: I
-  } = BalanceDuration(0, s, l, p, f, y, I, i.largestUnit));
+  } = BalanceDuration(0, s, l, p, f, y, I, i.largestUnit);
   return new (GetIntrinsic("%Temporal.Duration%"))(0, 0, 0, 0, n * s, n * l, n * p, n * f, n * y, n * I);
 }
 function DifferenceTemporalPlainYearMonth(e, t, r, o) {
@@ -2924,14 +2924,14 @@ function DifferenceTemporalZonedDateTime(e, t, r, o) {
   const m = GetSlot(t, n),
     c = GetSlot(i, n);
   let h, u, T, f, y, I, S, w, D, G;
-  if ("year" !== d.largestUnit && "month" !== d.largestUnit && "week" !== d.largestUnit && "day" !== d.largestUnit) h = 0, u = 0, T = 0, f = 0, ({
+  if ("year" !== d.largestUnit && "month" !== d.largestUnit && "week" !== d.largestUnit && "day" !== d.largestUnit) h = 0, u = 0, T = 0, f = 0, {
     hours: y,
     minutes: I,
     seconds: S,
     milliseconds: w,
     microseconds: D,
     nanoseconds: G
-  } = DifferenceInstant(m, c, d.roundingIncrement, d.smallestUnit, d.largestUnit, d.roundingMode));else {
+  } = DifferenceInstant(m, c, d.roundingIncrement, d.smallestUnit, d.largestUnit, d.roundingMode);else {
     const e = GetSlot(t, g);
     if (!TimeZoneEquals(e, GetSlot(i, g))) throw new RangeError("When calculating difference between time zones, largestUnit must be 'hours' or smaller because day lengths can vary between time zones due to DST or time zone offset changes.");
     (({
@@ -2945,7 +2945,7 @@ function DifferenceTemporalZonedDateTime(e, t, r, o) {
       milliseconds: w,
       microseconds: D,
       nanoseconds: G
-    } = DifferenceZonedDateTime(m, c, e, s, d.largestUnit, l))), ({
+    } = DifferenceZonedDateTime(m, c, e, s, d.largestUnit, l))), {
       years: h,
       months: u,
       weeks: T,
@@ -2956,7 +2956,7 @@ function DifferenceTemporalZonedDateTime(e, t, r, o) {
       milliseconds: w,
       microseconds: D,
       nanoseconds: G
-    } = RoundDuration(h, u, T, f, y, I, S, w, D, G, d.roundingIncrement, d.smallestUnit, d.roundingMode, t)), ({
+    } = RoundDuration(h, u, T, f, y, I, S, w, D, G, d.roundingIncrement, d.smallestUnit, d.roundingMode, t), {
       years: h,
       months: u,
       weeks: T,
@@ -2967,7 +2967,7 @@ function DifferenceTemporalZonedDateTime(e, t, r, o) {
       milliseconds: w,
       microseconds: D,
       nanoseconds: G
-    } = AdjustRoundedDurationDays(h, u, T, f, y, I, S, w, D, G, d.roundingIncrement, d.smallestUnit, d.roundingMode, t));
+    } = AdjustRoundedDurationDays(h, u, T, f, y, I, S, w, D, G, d.roundingIncrement, d.smallestUnit, d.roundingMode, t);
   }
   return new (GetIntrinsic("%Temporal.Duration%"))(a * h, a * u, a * T, a * f, a * y, a * I, a * S, a * w, a * D, a * G);
 }
@@ -2977,18 +2977,18 @@ function AddISODate(e, t, r, o, n, a, i, s) {
     m = r,
     c = a,
     h = i;
-  return l += o, d += n, ({
+  return l += o, d += n, {
     year: l,
     month: d
-  } = BalanceISOYearMonth(l, d)), ({
+  } = BalanceISOYearMonth(l, d), {
     year: l,
     month: d,
     day: m
-  } = RegulateISODate(l, d, m, s)), h += 7 * c, m += h, ({
+  } = RegulateISODate(l, d, m, s), h += 7 * c, m += h, {
     year: l,
     month: d,
     day: m
-  } = BalanceISODate(l, d, m)), {
+  } = BalanceISODate(l, d, m), {
     year: l,
     month: d,
     day: m
@@ -3003,7 +3003,7 @@ function AddTime(e, t, r, o, n, a, i, s, l, d, m, c) {
     y = a;
   h += i, u += s, T += l, p += d, f += m, y += c;
   let I = 0;
-  return ({
+  return {
     deltaDays: I,
     hour: h,
     minute: u,
@@ -3011,7 +3011,7 @@ function AddTime(e, t, r, o, n, a, i, s, l, d, m, c) {
     millisecond: p,
     microsecond: f,
     nanosecond: y
-  } = BalanceTime(h, u, T, p, f, y)), {
+  } = BalanceTime(h, u, T, p, f, y), {
     deltaDays: I,
     hour: h,
     minute: u,
@@ -3035,12 +3035,12 @@ function AddDuration(t, r, o, a, i, s, l, d, m, c, h, u, T, f, y, I, w, D, G, v,
         U = CalendarDateAdd(S, k, j, void 0, $),
         A = LargerOfTwoTemporalUnits("day", O),
         L = Te(null);
-      L.largestUnit = A, ({
+      L.largestUnit = A, {
         years: b,
         months: E,
         weeks: M,
         days: R
-      } = CalendarDateUntil(S, C, U, L)), ({
+      } = CalendarDateUntil(S, C, U, L), {
         days: R,
         hours: F,
         minutes: Y,
@@ -3048,21 +3048,21 @@ function AddDuration(t, r, o, a, i, s, l, d, m, c, h, u, T, f, y, I, w, D, G, v,
         milliseconds: Z,
         microseconds: B,
         nanoseconds: N
-      } = BalanceDuration(R, BigInt(i) + BigInt(y), BigInt(s) + BigInt(I), BigInt(l) + BigInt(w), BigInt(d) + BigInt(D), BigInt(m) + BigInt(G), BigInt(c) + BigInt(v), O));
+      } = BalanceDuration(R, BigInt(i) + BigInt(y), BigInt(s) + BigInt(I), BigInt(l) + BigInt(w), BigInt(d) + BigInt(D), BigInt(m) + BigInt(G), BigInt(c) + BigInt(v), O);
     } else {
       const e = GetIntrinsic("%Temporal.Instant%"),
         j = GetSlot(C, g),
         $ = GetSlot(C, p),
         k = AddZonedDateTime(GetSlot(C, S), j, $, t, r, o, a, i, s, l, d, m, c),
         U = AddZonedDateTime(new e(k), j, $, h, u, T, f, y, I, w, D, G, v);
-      "year" !== O && "month" !== O && "week" !== O && "day" !== O ? (b = 0, E = 0, M = 0, R = 0, ({
+      "year" !== O && "month" !== O && "week" !== O && "day" !== O ? (b = 0, E = 0, M = 0, R = 0, {
         hours: F,
         minutes: Y,
         seconds: P,
         milliseconds: Z,
         microseconds: B,
         nanoseconds: N
-      } = DifferenceInstant(GetSlot(C, n), U, 1, "nanosecond", O, "halfExpand"))) : ({
+      } = DifferenceInstant(GetSlot(C, n), U, 1, "nanosecond", O, "halfExpand")) : {
         years: b,
         months: E,
         weeks: M,
@@ -3073,11 +3073,11 @@ function AddDuration(t, r, o, a, i, s, l, d, m, c, h, u, T, f, y, I, w, D, G, v,
         milliseconds: Z,
         microseconds: B,
         nanoseconds: N
-      } = DifferenceZonedDateTime(GetSlot(C, n), U, j, $, O, Te(null)));
+      } = DifferenceZonedDateTime(GetSlot(C, n), U, j, $, O, Te(null));
     }
   } else {
     if ("year" === O || "month" === O || "week" === O) throw new RangeError("relativeTo is required for years, months, or weeks arithmetic");
-    b = E = M = 0, ({
+    b = E = M = 0, {
       days: R,
       hours: F,
       minutes: Y,
@@ -3085,7 +3085,7 @@ function AddDuration(t, r, o, a, i, s, l, d, m, c, h, u, T, f, y, I, w, D, G, v,
       milliseconds: Z,
       microseconds: B,
       nanoseconds: N
-    } = BalanceDuration(a + f, BigInt(i) + BigInt(y), BigInt(s) + BigInt(I), BigInt(l) + BigInt(w), BigInt(d) + BigInt(D), BigInt(m) + BigInt(G), BigInt(c) + BigInt(v), O));
+    } = BalanceDuration(a + f, BigInt(i) + BigInt(y), BigInt(s) + BigInt(I), BigInt(l) + BigInt(w), BigInt(d) + BigInt(D), BigInt(m) + BigInt(G), BigInt(c) + BigInt(v), O);
   }
   return RejectDuration(b, E, M, R, F, Y, P, Z, B, N), {
     years: b,
@@ -3477,19 +3477,19 @@ function AdjustRoundedDurationDays(t, r, o, n, a, i, s, l, d, m, c, h, u, T) {
     Y = AddZonedDateTime(GetSlot(T, S), R, F, f, y, I, w, 0, 0, 0, 0, 0, 0),
     P = AddZonedDateTime(new (GetIntrinsic("%Temporal.Instant%"))(Y), R, F, 0, 0, 0, M, 0, 0, 0, 0, 0, 0),
     Z = P - Y;
-  return (E - Z) * BigInt(M) >= Ie && (({
+  return (E - Z) * BigInt(M) >= Ie && ({
     years: f,
     months: y,
     weeks: I,
     days: w
-  } = AddDuration(f, y, I, w, 0, 0, 0, 0, 0, 0, 0, 0, 0, M, 0, 0, 0, 0, 0, 0, T)), E = RoundInstant(E - Z, c, h, u), ({
+  } = AddDuration(f, y, I, w, 0, 0, 0, 0, 0, 0, 0, 0, 0, M, 0, 0, 0, 0, 0, 0, T), E = RoundInstant(E - Z, c, h, u), {
     hours: D,
     minutes: G,
     seconds: v,
     milliseconds: C,
     microseconds: O,
     nanoseconds: b
-  } = BalanceDuration(0, 0, 0, 0, 0, 0, Number(E), "hour"))), {
+  } = BalanceDuration(0, 0, 0, 0, 0, 0, Number(E), "hour")), {
     years: f,
     months: y,
     weeks: I,
@@ -3525,11 +3525,11 @@ function RoundDuration(t, r, o, n, a, i, s, l, d, m, c, h, u, T) {
   }
   if ("year" === h || "month" === h || "week" === h || "day" === h) {
     let t, r, o;
-    C = TotalDurationNanoseconds(0, g, w, D, G, v, m, 0), E && (t = MoveRelativeZonedDateTime(E, f, y, I, S)), ({
+    C = TotalDurationNanoseconds(0, g, w, D, G, v, m, 0), E && (t = MoveRelativeZonedDateTime(E, f, y, I, S)), {
       days: r,
       nanoseconds: C,
       dayLengthNs: o
-    } = NanosecondsToDays(C, t)), M = BigInt(o), S += r, g = w = D = G = v = 0;
+    } = NanosecondsToDays(C, t), M = BigInt(o), S += r, g = w = D = G = v = 0;
   }
   switch (h) {
     case "year":
@@ -3570,13 +3570,13 @@ function RoundDuration(t, r, o, n, a, i, s, l, d, m, c, h, u, T) {
         const a = se(S),
           i = new O(0, S < 0 ? -1 : 1);
         let s;
-        for (({
+        for ({
           relativeTo: F,
           days: s
-        } = MoveRelativeDate(b, F, i, r)); ae(S) >= ae(s);) y += a, S -= s, ({
+        } = MoveRelativeDate(b, F, i, r); ae(S) >= ae(s);) y += a, S -= s, {
           relativeTo: F,
           days: s
-        } = MoveRelativeDate(b, F, i, r));
+        } = MoveRelativeDate(b, F, i, r);
         s = ae(s);
         const l = BigInt(s) * M;
         C = l * BigInt(y) + BigInt(S) * M + C;
@@ -3591,13 +3591,13 @@ function RoundDuration(t, r, o, n, a, i, s, l, d, m, c, h, u, T) {
           r = new O(0, 0, S < 0 ? -1 : 1),
           o = "string" != typeof b ? GetMethod(b, "dateAdd") : void 0;
         let n;
-        for (({
+        for ({
           relativeTo: F,
           days: n
-        } = MoveRelativeDate(b, F, r, o)); ae(S) >= ae(n);) I += t, S -= n, ({
+        } = MoveRelativeDate(b, F, r, o); ae(S) >= ae(n);) I += t, S -= n, {
           relativeTo: F,
           days: n
-        } = MoveRelativeDate(b, F, r, o));
+        } = MoveRelativeDate(b, F, r, o);
         n = ae(n);
         const a = BigInt(n) * M;
         C = a * BigInt(I) + BigInt(S) * M + C;
@@ -4423,11 +4423,11 @@ MakeIntrinsicClass(Calendar, "Temporal.Calendar"), DefineIntrinsic("Temporal.Cal
       month: i,
       day: s
     } = o;
-    return ({
+    return {
       year: a,
       month: i,
       day: s
-    } = RegulateISODate(a, i, s, n)), CreateTemporalDate(a, i, s, r);
+    } = RegulateISODate(a, i, s, n), CreateTemporalDate(a, i, s, r);
   },
   yearMonthFromFields(e, t, r) {
     let o = PrepareTemporalFields(e, ["month", "monthCode", "year"], ["year"]);
@@ -4437,7 +4437,7 @@ MakeIntrinsicClass(Calendar, "Temporal.Calendar"), DefineIntrinsic("Temporal.Cal
       year: a,
       month: i
     } = o;
-    return ({
+    return {
       year: a,
       month: i
     } = function RegulateISOYearMonth(e, t, r) {
@@ -4457,7 +4457,7 @@ MakeIntrinsicClass(Calendar, "Temporal.Calendar"), DefineIntrinsic("Temporal.Cal
         year: o,
         month: n
       };
-    }(a, i, n)), CreateTemporalYearMonth(a, i, r, 1);
+    }(a, i, n), CreateTemporalYearMonth(a, i, r, 1);
   },
   monthDayFromFields(e, t, r) {
     let o = PrepareTemporalFields(e, ["day", "month", "monthCode", "year"], ["day"]);
@@ -4470,10 +4470,10 @@ MakeIntrinsicClass(Calendar, "Temporal.Calendar"), DefineIntrinsic("Temporal.Cal
       day: s,
       year: l
     } = o;
-    return ({
+    return {
       month: i,
       day: s
-    } = RegulateISODate(a ? l : 1972, i, s, n)), CreateTemporalMonthDay(i, s, r, 1972);
+    } = RegulateISODate(a ? l : 1972, i, s, n), CreateTemporalMonthDay(i, s, r, 1972);
   },
   fields: e => e,
   fieldKeysToIgnore(e) {
@@ -4488,11 +4488,11 @@ MakeIntrinsicClass(Calendar, "Temporal.Calendar"), DefineIntrinsic("Temporal.Cal
     let m = GetSlot(e, i),
       c = GetSlot(e, s),
       h = GetSlot(e, l);
-    return ({
+    return {
       year: m,
       month: c,
       day: h
-    } = AddISODate(m, c, h, t, r, o, n, a)), CreateTemporalDate(m, c, h, d);
+    } = AddISODate(m, c, h, t, r, o, n, a), CreateTemporalDate(m, c, h, d);
   },
   dateUntil: (e, t, r) => DifferenceISODate(GetSlot(e, i), GetSlot(e, s), GetSlot(e, l), GetSlot(t, i), GetSlot(t, s), GetSlot(t, l), r),
   year: e => GetSlot(e, i),
@@ -4685,10 +4685,10 @@ class HelperBase {
       month: i,
       monthCode: s
     } = n;
-    return ({
+    return {
       month: i,
       monthCode: s
-    } = resolveNonLunisolarMonth(n, r, a)), {
+    } = resolveNonLunisolarMonth(n, r, a), {
       ...n,
       month: i,
       monthCode: s
@@ -4996,11 +4996,11 @@ class HelperBase {
         }, r),
         h = this.calendarToIsoDate(m, "constrain", r),
         u = this.isoToCalendarDate(h, r);
-      if (({
+      if ({
         year: o,
         month: n,
         day: a
-      } = h), u.monthCode === l && u.day === d) return {
+      } = h, u.monthCode === l && u.day === d) return {
         month: n,
         day: a,
         year: o
@@ -5527,10 +5527,10 @@ class GregorianBaseHelper extends HelperBase {
         const e = void 0 === o ? void 0 : this.eras.find(e => e.name === o || e.genericName === o);
         if (!e) throw new RangeError(`Era ${o} (ISO year ${r}) was not matched by any era`);
         if (r < 1 && e.reverseOf) throw new RangeError(`Years in ${o} era must be positive, not ${t}`);
-        t = e.reverseOf ? e.anchorEpoch.year - r : r + e.anchorEpoch.year - (e.hasYearZero ? 0 : 1), checkField("year", t), ({
+        t = e.reverseOf ? e.anchorEpoch.year - r : r + e.anchorEpoch.year - (e.hasYearZero ? 0 : 1), checkField("year", t), {
           eraYear: r,
           era: o
-        } = eraFromYear(t));
+        } = eraFromYear(t);
       }
     }
     return {
@@ -5840,10 +5840,10 @@ class ChineseBaseHelper extends HelperBase {
         calendarDay: s,
         calendarYearToVerify: l
       } = getCalendarDate(e, a);
-    "1" !== i && (a += 29, ({
+    "1" !== i && (a += 29, {
       calendarMonthString: i,
       calendarDay: s
-    } = getCalendarDate(e, a))), a -= s - 5;
+    } = getCalendarDate(e, a)), a -= s - 5;
     const d = {};
     let m,
       c,
@@ -6498,7 +6498,7 @@ class PlainDateTime {
       D = GetSlot(this, h),
       G = GetSlot(this, u),
       v = GetSlot(this, T);
-    return ({
+    return {
       year: f,
       month: y,
       day: I,
@@ -6508,7 +6508,7 @@ class PlainDateTime {
       millisecond: D,
       microsecond: G,
       nanosecond: v
-    } = RoundISODateTime(f, y, I, S, g, w, D, G, v, r, n, o)), CreateTemporalDateTime(f, y, I, S, g, w, D, G, v, GetSlot(this, p));
+    } = RoundISODateTime(f, y, I, S, g, w, D, G, v, r, n, o), CreateTemporalDateTime(f, y, I, S, g, w, D, G, v, GetSlot(this, p));
   }
   equals(e) {
     if (!IsTemporalDateTime(this)) throw new TypeError("invalid receiver");
@@ -6734,12 +6734,12 @@ class Duration {
       microsecond: 1e3,
       nanosecond: 1e3
     }[S];
-    return void 0 !== Y && ValidateTemporalRoundingIncrement(y, Y, !1), ({
+    return void 0 !== Y && ValidateTemporalRoundingIncrement(y, Y, !1), {
       years: r,
       months: o,
       weeks: n,
       days: a
-    } = UnbalanceDurationRelative(r, o, n, a, T, f)), ({
+    } = UnbalanceDurationRelative(r, o, n, a, T, f), {
       years: r,
       months: o,
       weeks: n,
@@ -6750,7 +6750,7 @@ class Duration {
       milliseconds: d,
       microseconds: m,
       nanoseconds: c
-    } = RoundDuration(r, o, n, a, i, s, l, d, m, c, y, S, I, f)), ({
+    } = RoundDuration(r, o, n, a, i, s, l, d, m, c, y, S, I, f), {
       years: r,
       months: o,
       weeks: n,
@@ -6761,7 +6761,7 @@ class Duration {
       milliseconds: d,
       microseconds: m,
       nanoseconds: c
-    } = AdjustRoundedDurationDays(r, o, n, a, i, s, l, d, m, c, y, S, I, f)), ({
+    } = AdjustRoundedDurationDays(r, o, n, a, i, s, l, d, m, c, y, S, I, f), {
       days: a,
       hours: i,
       minutes: s,
@@ -6769,7 +6769,7 @@ class Duration {
       milliseconds: d,
       microseconds: m,
       nanoseconds: c
-    } = BalanceDuration(a, i, s, l, d, m, c, T, f)), ({
+    } = BalanceDuration(a, i, s, l, d, m, c, T, f), {
       years: r,
       months: o,
       weeks: n,
@@ -6800,20 +6800,20 @@ class Duration {
             if (!m) throw new RangeError("a starting point is required for years balancing");
             const t = "string" != typeof m ? GetMethod(m, "dateAdd") : void 0;
             let r, o, n;
-            for (({
+            for ({
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, y, t)); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), h = h + d, c = r, ({
+            } = MoveRelativeDate(m, c, y, t); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), h = h + d, c = r, {
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, y, t));
-            for (({
+            } = MoveRelativeDate(m, c, y, t);
+            for ({
               relativeTo: r,
               days: n
-            } = MoveRelativeDate(m, c, I, t)); abs$1(f) >= BigInt(ae(n));) f = f - BigInt(n), u = u + d, c = r, ({
+            } = MoveRelativeDate(m, c, I, t); abs$1(f) >= BigInt(ae(n));) f = f - BigInt(n), u = u + d, c = r, {
               relativeTo: r,
               days: n
-            } = MoveRelativeDate(m, c, I, t));
+            } = MoveRelativeDate(m, c, I, t);
             r = CalendarDateAdd(m, c, y, void 0, t);
             const a = "string" != typeof m ? GetMethod(m, "dateUntil") : void 0,
               i = Te(null);
@@ -6832,13 +6832,13 @@ class Duration {
             if (!m) throw new RangeError("a starting point is required for months balancing");
             const t = "string" != typeof m ? GetMethod(m, "dateAdd") : void 0;
             let r, o;
-            for (({
+            for ({
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, I, t)); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), u = u + d, c = r, ({
+            } = MoveRelativeDate(m, c, I, t); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), u = u + d, c = r, {
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, I, t));
+            } = MoveRelativeDate(m, c, I, t);
             break;
           }
         case "week":
@@ -6846,13 +6846,13 @@ class Duration {
             if (!m) throw new RangeError("a starting point is required for weeks balancing");
             const t = "string" != typeof m ? GetMethod(m, "dateAdd") : void 0;
             let r, o;
-            for (({
+            for ({
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, S, t)); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), T = T + d, c = r, ({
+            } = MoveRelativeDate(m, c, S, t); abs$1(f) >= BigInt(ae(o));) f = f - BigInt(o), T = T + d, c = r, {
               relativeTo: r,
               days: o
-            } = MoveRelativeDate(m, c, S, t));
+            } = MoveRelativeDate(m, c, S, t);
             break;
           }
       }
@@ -6862,7 +6862,7 @@ class Duration {
         weeks: Number(T),
         days: Number(f)
       };
-    }(r, o, n, a, T, f)), new Duration(r, o, n, a, i, s, l, d, m, c);
+    }(r, o, n, a, T, f), new Duration(r, o, n, a, i, s, l, d, m, c);
   }
   total(e) {
     if (!IsTemporalDuration(this)) throw new TypeError("invalid receiver");
@@ -6962,11 +6962,11 @@ class Duration {
     let N = GetSlot(a, R);
     const j = CalculateOffsetShift(i, s, l, d, m),
       $ = CalculateOffsetShift(i, y, I, S, g);
-    0 === s && 0 === y && 0 === l && 0 === I && 0 === d && 0 === S || (({
+    0 === s && 0 === y && 0 === l && 0 === I && 0 === d && 0 === S || ({
       days: m
-    } = UnbalanceDurationRelative(s, l, d, m, "day", i)), ({
+    } = UnbalanceDurationRelative(s, l, d, m, "day", i), {
       days: g
-    } = UnbalanceDurationRelative(y, I, S, g, "day", i)));
+    } = UnbalanceDurationRelative(y, I, S, g, "day", i));
     const k = TotalDurationNanoseconds(m, c, h, u, T, p, f, j),
       U = TotalDurationNanoseconds(g, F, Y, P, Z, B, N, $);
     return ComparisonResult(Number(k - U));
@@ -7158,14 +7158,14 @@ class PlainTime {
       microsecond: d,
       nanosecond: m
     } = Mt(n, o);
-    return ({
+    return {
       hour: a,
       minute: i,
       second: s,
       millisecond: l,
       microsecond: d,
       nanosecond: m
-    } = RegulateTime(a, i, s, l, d, m, r)), new PlainTime(a, i, s, l, d, m);
+    } = RegulateTime(a, i, s, l, d, m, r), new PlainTime(a, i, s, l, d, m);
   }
   add(e) {
     if (!IsTemporalTime(this)) throw new TypeError("invalid receiver");
@@ -7204,14 +7204,14 @@ class PlainTime {
       l = GetSlot(this, h),
       p = GetSlot(this, u),
       f = GetSlot(this, T);
-    return ({
+    return {
       hour: a,
       minute: i,
       second: s,
       millisecond: l,
       microsecond: p,
       nanosecond: f
-    } = RoundTime(a, i, s, l, p, f, r, n, o)), new PlainTime(a, i, s, l, p, f);
+    } = RoundTime(a, i, s, l, p, f, r, n, o), new PlainTime(a, i, s, l, p, f);
   }
   equals(e) {
     if (!IsTemporalTime(this)) throw new TypeError("invalid receiver");
@@ -7952,35 +7952,6 @@ for (const e of Zt) {
   (t.configurable || t.enumerable || t.writable) && (t.configurable = !1, t.enumerable = !1, t.writable = !1, Object.defineProperty(e, "prototype", t));
 }
 
-class UnreachableError extends Error {
-  constructor(unrechable, additionalDetail) {
-    let message = `Unreachable value: ${JSON.stringify(unrechable)}`;
-    if (additionalDetail != null) {
-      message = `${message} (${additionalDetail})`;
-    }
-    super(message);
-  }
-}
-
-const identity = (value) => value;
-
-const {
-  ATTRIBUTE_NODE,
-  CDATA_SECTION_NODE,
-  COMMENT_NODE,
-  DOCUMENT_NODE,
-  DOCUMENT_FRAGMENT_NODE,
-  ELEMENT_NODE,
-  PROCESSING_INSTRUCTION_NODE,
-  TEXT_NODE
-} = Node;
-const isAttributeNode = (node) => node.nodeType === ATTRIBUTE_NODE;
-const isNamespaceAttribute = (attr) => attr.name === "xmlns" || attr.prefix === "xmlns";
-const isNamespaceNode = (node) => isAttributeNode(node) && (node.name === "xmlns" || node.prefix === "xmlns");
-const isDocumentNode = (node) => node.nodeType === DOCUMENT_NODE;
-const isElementNode = (node) => node.nodeType === ELEMENT_NODE;
-const isProcessingInstructionNode = (node) => node.nodeType === PROCESSING_INSTRUCTION_NODE;
-
 var transform = {};
 
 var exceptions = {};
@@ -21440,14 +21411,6 @@ function* toIterableIterator(iter) {
     }
   }
 }
-const map$1 = (fn) => (
-  // eslint-disable-next-line @typescript-eslint/no-shadow -- naming the function is helpful in stack traces/debugging
-  function* map2(iterable) {
-    for (const item of toIterableIterator(iterable)) {
-      yield fn(item);
-    }
-  }
-);
 const filter = (guard) => (
   // eslint-disable-next-line @typescript-eslint/no-shadow -- naming the function is helpful in stack traces/debugging
   function* filter2(iterable) {
@@ -21472,6 +21435,228 @@ const tee = (input) => {
   return transformExports.tee(input, 2);
 };
 
+const extendNodeKindGuards = (base) => {
+  const assertXPathNode = (value, message = "Invalid context node") => {
+    if (!base.isXPathNode(value)) {
+      throw new Error(message);
+    }
+  };
+  const isParentNode = (value) => {
+    const kind = base.getNodeKind(value);
+    return kind === "document" || kind === "element";
+  };
+  const extensions = {
+    assertXPathNode,
+    assertParentNode: (value, message = "Invalid parent node") => {
+      assertXPathNode(value);
+      if (!isParentNode(value)) {
+        throw new Error(message);
+      }
+    },
+    isDocument: (node) => {
+      return base.getNodeKind(node) === "document";
+    },
+    isElement: (node) => {
+      return base.getNodeKind(node) === "element";
+    },
+    isNamespaceDeclaration: (node) => {
+      return base.getNodeKind(node) === "namespace_declaration";
+    },
+    isAttribute: (node) => {
+      return base.getNodeKind(node) === "attribute";
+    },
+    isText: (node) => {
+      return base.getNodeKind(node) === "text";
+    },
+    isComment: (node) => {
+      return base.getNodeKind(node) === "comment";
+    },
+    isProcessingInstruction: (node) => {
+      return base.getNodeKind(node) === "processing_instruction";
+    },
+    isParentNode,
+    isQualifiedNamedNode: (node) => {
+      const kind = base.getNodeKind(node);
+      return kind === "element" || kind === "attribute";
+    }
+  };
+  return Object.assign(base, extensions);
+};
+const extendIterableOperations = (base) => {
+  const extensions = {
+    filterAttributes: filter(base.isAttribute),
+    filterQualifiedNamedNodes: filter(base.isQualifiedNamedNode),
+    filterComments: filter(base.isComment),
+    filterNamespaceDeclarations: filter(base.isNamespaceDeclaration),
+    filterProcessingInstructions: filter(base.isProcessingInstruction),
+    filterTextNodes: filter(base.isText),
+    sortInDocumentOrder: (nodes) => {
+      return Array.from(nodes).sort((a, b) => base.compareDocumentOrder(a, b));
+    }
+  };
+  return Object.assign(base, extensions);
+};
+const getElementByUniqueIdFactory = (adapter, getNamedAttributeValue) => {
+  const adapterImplementation = adapter.getElementByUniqueId?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  function* getElementDescendants(node) {
+    if (adapter.isElement(node)) {
+      yield node;
+    }
+    for (const element of adapter.getChildElements(node)) {
+      yield element;
+      yield* getElementDescendants(element);
+    }
+  }
+  return (node, id) => {
+    const containingDocument = adapter.getContainingDocument(node);
+    for (const element of getElementDescendants(containingDocument)) {
+      if (getNamedAttributeValue(element, "id") === id) {
+        return element;
+      }
+    }
+    return null;
+  };
+};
+const getQualifiedNamedAttributeValueFactory = (adapter) => {
+  const adapterImplementation = adapter.getQualifiedNamedAttributeValue?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, namespaceURI, localName) => {
+    const attributes = adapter.getAttributes(node);
+    for (const attribute of attributes) {
+      if (adapter.getNamespaceURI(attribute) === namespaceURI && adapter.getLocalName(attribute) === localName) {
+        return adapter.getNodeValue(attribute);
+      }
+    }
+    return null;
+  };
+};
+const getLocalNamedAttributeValueFactory = (adapter) => {
+  const adapterImplementation = adapter.getLocalNamedAttributeValue?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    const attributes = adapter.getAttributes(node);
+    for (const attribute of attributes) {
+      if (adapter.getLocalName(attribute) === localName) {
+        return adapter.getNodeValue(attribute);
+      }
+    }
+    return null;
+  };
+};
+const hasLocalNamedAttributeFactory = (adapter, lookup) => {
+  const adapterImplementation = adapter.hasLocalNamedAttribute?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    return lookup(node, localName) != null;
+  };
+};
+const getChildrenByLocalNameFactory = (adapter) => {
+  const adapterImplementation = adapter.getChildrenByLocalName?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    return Array.from(adapter.getChildElements(node)).filter((element) => {
+      return adapter.getLocalName(element) === localName;
+    });
+  };
+};
+const getFirstChildNodeFactory = (adapter) => {
+  const adapterImplementation = adapter.getFirstChildNode?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    const [childNode] = adapter.getChildNodes(node);
+    return childNode ?? null;
+  };
+};
+const getLastChildNodeFactory = (adapter) => {
+  const adapterImplementation = adapter.getLastChildNode?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    return Array.from(adapter.getChildNodes(node)).at(-1) ?? null;
+  };
+};
+const getFirstChildElementFactory = (adapter) => {
+  const adapterImplementation = adapter.getFirstChildElement?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    const [childElement] = adapter.getChildElements(node);
+    return childElement ?? null;
+  };
+};
+const getLastChildElementFactory = (adapter) => {
+  const adapterImplementation = adapter.getLastChildElement?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    return Array.from(adapter.getChildElements(node)).at(-1) ?? null;
+  };
+};
+const extendOptimizableOperations = (base) => {
+  const getLocalNamedAttributeValue = getLocalNamedAttributeValueFactory(base);
+  const extensions = {
+    getElementByUniqueId: getElementByUniqueIdFactory(base, getLocalNamedAttributeValue),
+    getQualifiedNamedAttributeValue: getQualifiedNamedAttributeValueFactory(base),
+    getLocalNamedAttributeValue,
+    hasLocalNamedAttribute: hasLocalNamedAttributeFactory(base, getLocalNamedAttributeValue),
+    getChildrenByLocalName: getChildrenByLocalNameFactory(base),
+    getFirstChildNode: getFirstChildNodeFactory(base),
+    getFirstChildElement: getFirstChildElementFactory(base),
+    getLastChildNode: getLastChildNodeFactory(base),
+    getLastChildElement: getLastChildElementFactory(base)
+  };
+  return Object.assign(base, extensions);
+};
+const DERIVED_DOM_PROVIDER = Symbol("DERIVED_DOM_PROVIDER");
+const derivedDOMProvider = (base) => {
+  return Object.assign({}, base, {
+    [DERIVED_DOM_PROVIDER]: true
+  });
+};
+const isXPathDOMProvider = (adapter) => {
+  return DERIVED_DOM_PROVIDER in adapter && adapter[DERIVED_DOM_PROVIDER] === true;
+};
+const xpathDOMProvider = (adapter) => {
+  if (isXPathDOMProvider(adapter)) {
+    console.warn(
+      "Repeat call to xpathDOMProvider: provider has already been derived from provided adapter"
+    );
+    return adapter;
+  }
+  const extendedGuards = extendNodeKindGuards(adapter);
+  const extendedIterableOperations = extendIterableOperations(extendedGuards);
+  const exended = extendOptimizableOperations(extendedIterableOperations);
+  return derivedDOMProvider(exended);
+};
+
+class UnreachableError extends Error {
+  constructor(unrechable, additionalDetail) {
+    let message = `Unreachable value: ${JSON.stringify(unrechable)}`;
+    if (additionalDetail != null) {
+      message = `${message} (${additionalDetail})`;
+    }
+    super(message);
+  }
+}
+
+const identity = (value) => value;
+
 class Reiterable {
   constructor(source) {
     this.source = source;
@@ -21691,7 +21876,7 @@ class NodeEvaluation extends ValueEvaluation {
     let { computedValues } = this;
     if (computedValues == null) {
       const { context, value: node } = this;
-      const stringValue = node.textContent ?? "";
+      const stringValue = context.domProvider.getNodeValue(node);
       const isEmpty = trimXMLXPathWhitespace(stringValue) === "";
       const booleanValue = !isEmpty;
       const numberFunction = context.functions.getDefaultImplementation("number");
@@ -21720,32 +21905,244 @@ class NodeEvaluation extends ValueEvaluation {
   }
 }
 
+function* concat$2(...iterables) {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
+}
+function* flatMapNodeSets(contextNodes, fn) {
+  for (const contextNode of contextNodes) {
+    yield* fn(contextNode);
+  }
+}
 function* toNodeEvaluations(context, nodes) {
   for (const node of nodes) {
     yield new NodeEvaluation(context, node);
   }
 }
-const filterNamespace = filter(isNamespaceAttribute);
-const filterNonNamespace = filter((attr) => !isNamespaceAttribute(attr));
-const filterNonAttribute = filter((node) => !isAttributeNode(node));
-const axisNameToMethod = {
-  ["ancestor" /* ANCESTOR */]: "ancestor",
-  ["ancestor-or-self" /* ANCESTOR_OR_SELF */]: "ancestorOrSelf",
-  ["attribute" /* ATTRIBUTE */]: "attribute",
-  ["child" /* CHILD */]: "child",
-  ["descendant" /* DESCENDANT */]: "descendant",
-  ["descendant-or-self" /* DESCENDANT_OR_SELF */]: "descendantOrSelf",
-  ["following" /* FOLLOWING */]: "following",
-  ["following-sibling" /* FOLLOWING_SIBLING */]: "followingSibling",
-  ["namespace" /* NAMESPACE */]: "namespace",
-  ["parent" /* PARENT */]: "parent",
-  ["preceding" /* PRECEDING */]: "preceding",
-  ["preceding-sibling" /* PRECEDING_SIBLING */]: "precedingSibling",
-  ["self" /* SELF */]: "self"
+const getNodeTypeFilter = (domProvider, step) => {
+  switch (step.axisType) {
+    case "attribute":
+      return domProvider.filterAttributes;
+    case "namespace":
+      return domProvider.filterNamespaceDeclarations;
+  }
+  switch (step.nodeType) {
+    case "__NAMED__":
+      return domProvider.filterQualifiedNamedNodes;
+    case "processing-instruction":
+      return domProvider.filterProcessingInstructions;
+    case "comment":
+      return domProvider.filterComments;
+    case "node":
+      return identity;
+    case "text":
+      return domProvider.filterTextNodes;
+    default:
+      throw new UnreachableError(step);
+  }
+};
+const axisEvaluationContext = (currentContext, contextNode) => {
+  const { domProvider, contextDocument, rootNode, visited } = currentContext;
+  return {
+    domProvider,
+    contextDocument,
+    rootNode,
+    contextNode,
+    visited
+  };
+};
+function* siblings(context, methodName) {
+  const method = context.domProvider[methodName];
+  let currentNode = context.contextNode;
+  while (currentNode != null) {
+    currentNode = method(currentNode);
+    if (currentNode != null) {
+      yield currentNode;
+    }
+  }
+}
+const getDocumentOrderTraversalContextNode = (domProvider, contextNode) => {
+  if (domProvider.isAttribute(contextNode) || domProvider.isNamespaceDeclaration(contextNode)) {
+    const parentElement = domProvider.getParentNode(contextNode);
+    domProvider.assertParentNode(parentElement);
+    return parentElement;
+  }
+  return contextNode;
+};
+function* filterValues(iter) {
+  for (const item of iter) {
+    if (item != null) {
+      yield item;
+    }
+  }
+}
+function* documentRootPrecedingSiblings(domAdapter, precedingContext, documentRoot, step) {
+  const documentRootContext = axisEvaluationContext(precedingContext, documentRoot);
+  const precedingSiblings = axisEvaluators["preceding-sibling"](documentRootContext, step);
+  for (const node of precedingSiblings) {
+    try {
+      if (domAdapter.getNodeKind(node) != null) {
+        yield node;
+      }
+    } catch {
+    }
+  }
+}
+const axisEvaluators = {
+  ancestor: function* ancestor(context, step) {
+    const { rootNode } = context;
+    const parentNodes = axisEvaluators.parent(context, step);
+    for (const parentNode of parentNodes) {
+      if (parentNode !== rootNode) {
+        const parentContext = axisEvaluationContext(context, parentNode);
+        yield* axisEvaluators.ancestor(parentContext, step);
+      }
+      yield parentNode;
+    }
+  },
+  "ancestor-or-self": function* ancestorOrSelf(context, step) {
+    const { contextNode } = context;
+    const isNamedStep = step.stepType !== "NodeTypeTest";
+    const currentContext = axisEvaluationContext(context, contextNode);
+    yield* axisEvaluators.ancestor(currentContext, step);
+    if (!isNamedStep || context.domProvider.isElement(contextNode)) {
+      yield contextNode;
+    }
+  },
+  attribute: (context) => {
+    return context.domProvider.getAttributes(context.contextNode);
+  },
+  child: (context, step) => {
+    const { contextNode, domProvider } = context;
+    if (step.nodeType === "__NAMED__") {
+      return domProvider.getChildElements(contextNode);
+    }
+    return domProvider.getChildNodes(contextNode);
+  },
+  descendant: function* descendant(context, step) {
+    for (const childNode of axisEvaluators.child(context, step)) {
+      yield childNode;
+      const childContext = axisEvaluationContext(context, childNode);
+      yield* axisEvaluators.descendant(childContext, step);
+    }
+  },
+  "descendant-or-self": function* descendantOrSelf(context, step) {
+    const { contextNode } = context;
+    yield contextNode;
+    const selfContext = axisEvaluationContext(context, contextNode);
+    yield* axisEvaluators.descendant(selfContext, step);
+  },
+  following: function* following(context, step) {
+    const { domProvider, contextDocument, rootNode } = context;
+    const contextNode = getDocumentOrderTraversalContextNode(domProvider, context.contextNode);
+    if (context.visited.has(contextNode)) {
+      return;
+    }
+    context.visited.add(contextNode);
+    const parentNode = domProvider.getParentNode(contextNode);
+    if (contextNode === rootNode || parentNode === contextDocument) {
+      return;
+    }
+    let firstChild;
+    let nextSibling = null;
+    if (step.nodeType === "__NAMED__") {
+      firstChild = domProvider.getFirstChildElement(contextNode);
+      nextSibling = domProvider.getNextSiblingElement(contextNode);
+    } else {
+      firstChild = domProvider.getFirstChildNode(contextNode);
+      nextSibling = domProvider.getNextSiblingNode(contextNode);
+    }
+    let currentNodes = filterValues([firstChild, nextSibling]);
+    if (parentNode != null && parentNode !== rootNode) {
+      const followingParentSiblingsContext = axisEvaluationContext(context, parentNode);
+      const followingParentSiblings = axisEvaluators["following-sibling"](
+        followingParentSiblingsContext,
+        step
+      );
+      currentNodes = concat$2(currentNodes, followingParentSiblings);
+    }
+    for (const currentNode of currentNodes) {
+      yield currentNode;
+      const currentContext = axisEvaluationContext(context, currentNode);
+      yield* axisEvaluators.following(currentContext, step);
+    }
+  },
+  "following-sibling": (context, step) => {
+    if (step.nodeType === "__NAMED__") {
+      return siblings(context, "getNextSiblingElement");
+    }
+    return siblings(context, "getNextSiblingNode");
+  },
+  namespace: (context) => {
+    return context.domProvider.getNamespaceDeclarations(context.contextNode);
+  },
+  parent: function* parent(context) {
+    const { rootNode, contextNode } = context;
+    if (contextNode === rootNode) {
+      return;
+    }
+    const parentNode = context.domProvider.getParentNode(contextNode);
+    if (parentNode != null) {
+      yield parentNode;
+    }
+  },
+  preceding: function* preceding(context, step) {
+    const { domProvider, rootNode, contextDocument, visited } = context;
+    const contextNode = getDocumentOrderTraversalContextNode(domProvider, context.contextNode);
+    if (visited.has(contextNode)) {
+      return;
+    }
+    visited.add(contextNode);
+    if (contextNode === rootNode) {
+      return;
+    }
+    const parentNode = domProvider.getParentNode(contextNode);
+    if (parentNode === contextDocument) {
+      yield* documentRootPrecedingSiblings(domProvider, context, contextNode, step);
+      return;
+    }
+    let lastChild;
+    let previousSibling;
+    if (step.nodeType === "__NAMED__") {
+      previousSibling = domProvider.getPreviousSiblingElement(contextNode);
+      lastChild = domProvider.getLastChildElement(contextNode);
+    } else {
+      previousSibling = domProvider.getPreviousSiblingNode(contextNode);
+      lastChild = domProvider.getLastChildNode(contextNode);
+    }
+    if (lastChild === contextNode) {
+      lastChild = null;
+    }
+    let currentNodes = filterValues([lastChild, previousSibling]);
+    if (contextNode !== rootNode && parentNode != null && parentNode !== rootNode) {
+      const precedingParentSiblingsContext = axisEvaluationContext(context, parentNode);
+      const precedingParentSiblings = axisEvaluators["preceding-sibling"](
+        precedingParentSiblingsContext,
+        step
+      );
+      currentNodes = concat$2(currentNodes, precedingParentSiblings);
+    }
+    for (const currentNode of currentNodes) {
+      yield currentNode;
+      const currentContext = axisEvaluationContext(context, currentNode);
+      yield* preceding(currentContext, step);
+    }
+  },
+  "preceding-sibling": (context, step) => {
+    if (step.nodeType === "__NAMED__") {
+      return siblings(context, "getPreviousSiblingElement");
+    }
+    return siblings(context, "getPreviousSiblingNode");
+  },
+  self: function* self(context) {
+    yield context.contextNode;
+  }
 };
 class LocationPathEvaluation {
   constructor(parentContext, contextNodes, options = {}) {
     this.parentContext = parentContext;
+    this.domProvider = parentContext.domProvider;
     const {
       evaluator,
       contextDocument,
@@ -21753,8 +22150,7 @@ class LocationPathEvaluation {
       functions,
       namespaceResolver,
       rootNode,
-      timeZone,
-      treeWalkers
+      timeZone
     } = parentContext;
     this.evaluator = evaluator;
     this.contextDocument = contextDocument;
@@ -21763,9 +22159,8 @@ class LocationPathEvaluation {
     this.namespaceResolver = namespaceResolver;
     this.rootNode = rootNode;
     this.timeZone = timeZone;
-    this.treeWalkers = treeWalkers;
-    const [nodes] = tee(distinct(contextNodes));
-    this.nodes = nodes;
+    const nodes = distinct(contextNodes);
+    this._nodes = nodes;
     this.nodeEvaluations = Reiterable.from(toNodeEvaluations(this, contextNodes));
     if (options.contextSize != null) {
       this.optionsContextSize = options.contextSize;
@@ -21774,6 +22169,16 @@ class LocationPathEvaluation {
     }
     this.initializedContextPosition = options.contextPosition ?? 1;
   }
+  static isInstance(context, value) {
+    return value instanceof LocationPathEvaluation && value.domProvider === context.domProvider;
+  }
+  static assertInstance = (context, value, message) => {
+    if (!this.isInstance(context, value)) {
+      throw new Error(message ?? "Expected a node-set result");
+    }
+  };
+  // --- DOM adapter/provider ---
+  domProvider;
   // --- Evaluation ---
   type = "NODE";
   nodeEvaluations;
@@ -21786,10 +22191,13 @@ class LocationPathEvaluation {
   evaluationContextNode;
   contextDocument;
   rootNode;
-  nodes;
+  _nodes;
+  get nodes() {
+    return this._nodes;
+  }
   get contextNodes() {
-    const [nodes, contextNodes] = tee(this.nodes);
-    this.nodes = nodes;
+    const [nodes, contextNodes] = tee(this._nodes);
+    this._nodes = nodes;
     return contextNodes;
   }
   computedContextSize = null;
@@ -21797,7 +22205,6 @@ class LocationPathEvaluation {
   initializedContextPosition;
   functions;
   namespaceResolver;
-  treeWalkers;
   timeZone;
   /**
    * TODO: this is a temporary accommodation for these cases which are presently
@@ -21939,257 +22346,68 @@ class LocationPathEvaluation {
   gte(operand) {
     return this.compare((lhs, rhs) => lhs.gte(rhs), operand);
   }
-  getTreeWalker(step) {
-    const { treeWalkers } = this;
-    switch (step.nodeType) {
-      case "__NAMED__":
-        return treeWalkers.ELEMENT;
-      case "comment":
-        return treeWalkers.COMMENT;
-      case "node":
-        return treeWalkers.ANY;
-      case "processing-instruction":
-        return treeWalkers.PROCESSING_INSTRUCTION;
-      case "text":
-        return treeWalkers.TEXT;
-      default:
-        throw new UnreachableError(step);
-    }
-  }
-  *ancestor(step) {
-    const { rootNode } = this;
-    const parents = this.parent(step);
-    for (const parent of parents) {
-      if (parent !== rootNode) {
-        const parentContext = new LocationPathEvaluation(this, [parent]);
-        yield* parentContext.ancestor(step);
-      }
-      yield parent;
-    }
-  }
-  *ancestorOrSelf(step) {
-    const isNamedStep = step.stepType !== "NodeTypeTest";
-    for (const self of this) {
-      yield* self.ancestor(step);
-      for (const node of self.contextNodes) {
-        if (!isNamedStep || isElementNode(node)) {
-          yield node;
-        }
-      }
-    }
-  }
-  *attribute() {
-    for (const node of this.contextNodes) {
-      yield* filterNonNamespace(node.attributes ?? []);
-    }
-  }
-  *child(step) {
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      let currentNode = node;
-      treeWalker.currentNode = currentNode;
-      treeWalker.firstChild();
-      do {
-        currentNode = treeWalker.currentNode;
-        if (currentNode.parentNode === node) {
-          yield currentNode;
-          treeWalker.currentNode = currentNode;
-        }
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *descendant(step) {
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      treeWalker.currentNode = node;
-      if (treeWalker.firstChild() == null) {
-        continue;
-      }
-      do {
-        const { currentNode } = treeWalker;
-        if (!node.contains(currentNode)) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *descendantOrSelf(step) {
-    for (const self of this) {
-      yield* self.contextNodes;
-      yield* self.descendant(step);
-    }
-  }
-  *following(step) {
-    const contextNodes = map$1((node) => node.ownerElement ?? node)(
-      this.contextNodes
-    );
-    const treeWalker = this.getTreeWalker(step);
-    const visited = /* @__PURE__ */ new WeakSet();
-    for (const node of contextNodes) {
-      const { nextSibling } = node;
-      if (nextSibling == null) {
-        continue;
-      }
-      treeWalker.currentNode = nextSibling;
-      do {
-        const { currentNode } = treeWalker;
-        if (visited.has(currentNode)) {
-          continue;
-        }
-        visited.add(currentNode);
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *followingSibling(step) {
-    const visited = /* @__PURE__ */ new WeakSet();
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      const { nextSibling } = node;
-      if (nextSibling == null) {
-        continue;
-      }
-      const { parentNode } = node;
-      treeWalker.currentNode = nextSibling;
-      do {
-        const { currentNode } = treeWalker;
-        if (visited.has(currentNode) || currentNode.parentNode !== parentNode) {
-          continue;
-        }
-        visited.add(currentNode);
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *namespace() {
-    for (const node of this.contextNodes) {
-      yield* filterNamespace(node.attributes ?? []);
-    }
-  }
-  *parent(step) {
-    const { contextNodes, rootNode } = this;
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of contextNodes) {
-      const contextNode = node.ownerElement ?? node;
-      if (contextNode === rootNode) {
-        continue;
-      }
-      if (contextNode !== node) {
-        yield contextNode;
-        continue;
-      }
-      treeWalker.currentNode = contextNode;
-      const parentNode = treeWalker.parentNode();
-      if (parentNode != null) {
-        yield parentNode;
-        treeWalker.currentNode = parentNode;
-      }
-    }
-  }
-  *preceding(step) {
-    const { rootNode } = this;
-    const { nodeType = null } = step;
-    const treeWalker = this.getTreeWalker(step);
-    treeWalker.currentNode = rootNode;
-    if (nodeType != null && nodeType !== "node") {
-      treeWalker.nextNode();
-      treeWalker.previousNode();
-    }
-    for (const node of this.contextNodes) {
-      const contextNode = node.ownerElement ?? node;
-      do {
-        const { currentNode } = treeWalker;
-        if (currentNode.contains(contextNode)) {
-          continue;
-        }
-        if (currentNode === contextNode || (contextNode.compareDocumentPosition(currentNode) & Node.DOCUMENT_POSITION_PRECEDING) === 0) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *precedingSibling(step) {
-    const { nodeType = null } = step;
-    const treeWalker = this.getTreeWalker(step);
-    let parentNode = null;
-    for (const node of filterNonAttribute(this.contextNodes)) {
-      const currentParentNode = node.parentNode;
-      if (currentParentNode == null) {
-        continue;
-      }
-      if (currentParentNode !== parentNode) {
-        parentNode = currentParentNode;
-        treeWalker.currentNode = parentNode.firstChild;
-        if (nodeType != null && nodeType !== "node") {
-          treeWalker.nextSibling();
-          treeWalker.previousSibling();
-        }
-      }
-      do {
-        const { currentNode } = treeWalker;
-        if (currentNode === node) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *self() {
-    yield* this.contextNodes;
-  }
   step(step) {
-    let nodesFilter = identity;
-    const { namespaceResolver } = this;
+    const { domProvider, namespaceResolver } = this;
+    let nodesFilter;
     switch (step.stepType) {
       case "NodeTypeTest":
+      case "UnqualifiedWildcardTest":
+        nodesFilter = getNodeTypeFilter(domProvider, step);
         break;
       case "NodeNameTest": {
         const { nodeName } = step;
         const nullNamespaceURI = namespaceResolver.lookupNamespaceURI(null);
         nodesFilter = filter((node) => {
-          const { namespaceURI } = node;
-          return node.localName === nodeName && (namespaceURI == null || namespaceURI === nullNamespaceURI);
+          if (!domProvider.isQualifiedNamedNode(node)) {
+            return false;
+          }
+          const namespaceURI = domProvider.getNamespaceURI(node);
+          return domProvider.getLocalName(node) === nodeName && (namespaceURI == null || namespaceURI === nullNamespaceURI);
         });
         break;
       }
       case "ProcessingInstructionNameTest": {
         const { processingInstructionName } = step;
         nodesFilter = filter((node) => {
-          return node.nodeName === processingInstructionName;
+          return domProvider.isProcessingInstruction(node) && domProvider.getProcessingInstructionName(node) === processingInstructionName;
         });
         break;
       }
       case "QualifiedNameTest": {
         const { prefix, localName } = step;
         const namespaceURI = namespaceResolver.lookupNamespaceURI(prefix);
-        nodesFilter = filter(
-          (node) => node.localName === localName && node.namespaceURI === namespaceURI
-        );
+        nodesFilter = filter((node) => {
+          return domProvider.isQualifiedNamedNode(node) && domProvider.getLocalName(node) === localName && domProvider.getNamespaceURI(node) === namespaceURI;
+        });
         break;
       }
       case "QualifiedWildcardTest": {
         const { prefix } = step;
         const namespaceURI = namespaceResolver.lookupNamespaceURI(prefix);
-        nodesFilter = filter(
-          (node) => node.namespaceURI === namespaceURI
-        );
+        nodesFilter = filter((node) => {
+          return domProvider.isQualifiedNamedNode(node) && domProvider.getNamespaceURI(node) === namespaceURI;
+        });
         break;
       }
-      case "UnqualifiedWildcardTest":
-        break;
       default:
         throw new UnreachableError(step);
     }
     const { axisType } = step;
-    const axisMethod = axisNameToMethod[axisType];
-    const nodes = nodesFilter(this[axisMethod](step));
+    const axisEvaluator = axisEvaluators[axisType];
+    const context = {
+      domProvider: this.domProvider,
+      rootNode: this.rootNode,
+      contextDocument: this.contextDocument,
+      visited: /* @__PURE__ */ new WeakSet()
+    };
+    let nodes = flatMapNodeSets(this.contextNodes, function* (contextNode) {
+      const currentContext = axisEvaluationContext(context, contextNode);
+      const axisNodes = axisEvaluator(currentContext, step);
+      yield* nodesFilter(axisNodes);
+    });
+    if (axisType === "preceding" || axisType === "preceding-sibling") {
+      nodes = this.domProvider.sortInDocumentOrder(nodes);
+    }
     return new LocationPathEvaluation(this, nodes);
   }
   evaluateLocationPathExpression(expression) {
@@ -22241,18 +22459,36 @@ const staticNamespaces = new StaticNamespaces("xf", XFORMS_NAMESPACE_URI, {
 });
 const namespaceURIs = new UpsertableMap();
 class NamespaceResolver {
-  constructor(rootNode, referenceNode) {
+  constructor(domProvider, rootNode, referenceNode, contextResolver) {
+    this.domProvider = domProvider;
     this.rootNode = rootNode;
     this.referenceNode = referenceNode;
-    this.contextResolver = referenceNode ?? rootNode;
+    const contextResolverNode = referenceNode ?? rootNode;
+    if (contextResolver == null) {
+      this.contextResolver = (prefix) => {
+        return domProvider.resolveNamespaceURI(contextResolverNode, prefix);
+      };
+    } else if (typeof contextResolver === "function") {
+      this.contextResolver = contextResolver;
+    } else {
+      this.contextResolver = (prefix) => contextResolver.lookupNamespaceURI(prefix);
+    }
+  }
+  static isInstance(rootNode, value) {
+    return value instanceof NamespaceResolver && value.rootNode === rootNode;
+  }
+  static from(domProvider, rootNode, referenceNode, contextResolver) {
+    if (this.isInstance(rootNode, contextResolver)) {
+      return contextResolver;
+    }
+    return new this(
+      domProvider,
+      rootNode,
+      referenceNode ?? null,
+      contextResolver
+    );
   }
   contextResolver;
-  lookupNodeNamespaceURI = (node, prefix) => {
-    return node.lookupNamespaceURI(prefix);
-  };
-  lookupStaticNamespaceURI = (prefix) => {
-    return staticNamespaces.get(prefix) ?? null;
-  };
   /**
    * Note: while it is likely consistent with the **spec** to resolve a `null`
    * prefix, it's not typical in a browser environment for the resolver to be
@@ -22263,102 +22499,33 @@ class NamespaceResolver {
    */
   lookupNamespaceURI(prefix) {
     return namespaceURIs.upsert(this.contextResolver, () => new UpsertableMap()).upsert(prefix, () => {
-      return this.contextResolver.lookupNamespaceURI(prefix) ?? staticNamespaces.get(prefix) ?? null;
+      return this.contextResolver(prefix) ?? staticNamespaces.get(prefix) ?? null;
     });
   }
 }
 
-const assertParentNode = (node) => {
-  if (node.children == null) {
-    throw "todo assertParentNode";
-  }
-};
-
-const getDocument = (node) => node.nodeType === Node.DOCUMENT_NODE ? node : node.ownerDocument;
-const getRootNode = (node) => {
-  if (isDocumentNode(node)) {
-    return node;
-  }
-  if (isElementNode(node)) {
-    const rootNode = node.getRootNode();
-    assertParentNode(rootNode);
-    return rootNode;
-  }
-  if (isAttributeNode(node)) {
-    const { ownerElement } = node;
-    if (ownerElement == null) {
-      throw "todo";
-    }
-    return getRootNode(ownerElement);
-  }
-  const { parentElement } = node;
-  if (parentElement == null) {
-    throw "todo getRootNode COMMENT | PROCESSING_INSTRUCTION | TEXT";
-  }
-  return getRootNode(parentElement);
-};
-const {
-  SHOW_ELEMENT,
-  SHOW_ATTRIBUTE,
-  SHOW_TEXT,
-  SHOW_CDATA_SECTION,
-  SHOW_PROCESSING_INSTRUCTION,
-  SHOW_COMMENT,
-  SHOW_DOCUMENT,
-  SHOW_DOCUMENT_TYPE
-} = NodeFilter;
-const SHOW_ANY = 0 | SHOW_ELEMENT | SHOW_ATTRIBUTE | SHOW_TEXT | SHOW_CDATA_SECTION | SHOW_PROCESSING_INSTRUCTION | SHOW_COMMENT | SHOW_DOCUMENT | SHOW_DOCUMENT_TYPE;
-const SHOW_ANY_TEXT = 0 | SHOW_TEXT | SHOW_CDATA_SECTION;
-const TreeWalkerFilter = {
-  ANY: SHOW_ANY,
-  ELEMENT: SHOW_ELEMENT,
-  TEXT: SHOW_ANY_TEXT,
-  COMMENT: SHOW_COMMENT,
-  PROCESSING_INSTRUCTION: SHOW_PROCESSING_INSTRUCTION
-};
-const getTreeWalker = (contextDocument, contextNode = contextDocument, filter = "ANY") => {
-  const flag = TreeWalkerFilter[filter];
-  return contextDocument.createTreeWalker(contextNode, flag);
-};
-
-class EvaluationContextTreeWalkers {
-  ANY;
-  COMMENT;
-  ELEMENT;
-  PROCESSING_INSTRUCTION;
-  TEXT;
-  constructor(contextDocument, rootNode) {
-    this.ANY = getTreeWalker(contextDocument, rootNode, "ANY");
-    this.COMMENT = getTreeWalker(contextDocument, rootNode, "COMMENT");
-    this.ELEMENT = getTreeWalker(contextDocument, rootNode, "ELEMENT");
-    this.PROCESSING_INSTRUCTION = getTreeWalker(
-      contextDocument,
-      rootNode,
-      "PROCESSING_INSTRUCTION"
-    );
-    this.TEXT = getTreeWalker(contextDocument, rootNode, "TEXT");
-  }
-}
 class EvaluationContext {
   constructor(evaluator, contextNode, options = {}) {
     this.evaluator = evaluator;
-    const {
-      rootNode = getRootNode(contextNode),
-      document = getDocument(rootNode),
-      functions = evaluator.functions,
-      namespaceResolver = new NamespaceResolver(document, contextNode),
-      treeWalkers = new EvaluationContextTreeWalkers(document, rootNode),
-      timeZone = evaluator.timeZone
-    } = options;
-    this.contextDocument = document;
+    const { domProvider } = evaluator;
+    this.domProvider = domProvider;
+    const { namespaceResolver } = options;
+    const rootNode = options.rootNode ?? domProvider.getContainingDocument(contextNode);
+    const contextDocument = domProvider.getContainingDocument(rootNode);
+    this.contextDocument = contextDocument;
     this.evaluationContextNode = contextNode;
     this.contextNodes = [contextNode];
     this.rootNode = rootNode;
-    this.functions = functions;
-    this.namespaceResolver = namespaceResolver;
-    this.treeWalkers = treeWalkers;
-    this.timeZone = timeZone;
+    this.functions = options.functions ?? evaluator.functions;
+    this.namespaceResolver = NamespaceResolver.from(
+      domProvider,
+      contextDocument,
+      contextDocument,
+      namespaceResolver
+    );
+    this.timeZone = options.timeZone ?? evaluator.timeZone;
   }
+  domProvider;
   /**
    * @see {@link Context.evaluationContextNode}
    */
@@ -22369,7 +22536,6 @@ class EvaluationContext {
   functions;
   namespaceResolver;
   timeZone;
-  treeWalkers;
   contextPosition() {
     return 1;
   }
@@ -22517,21 +22683,19 @@ class BooleanEvaluation extends ValueEvaluation {
 }
 
 class TypedFunctionImplementation extends FunctionImplementation {
-  constructor(localName, TypedResult, signature, call) {
-    super(
-      localName,
-      signature,
-      (context, args) => {
-        const runtimeResult = call(context, args);
-        return new TypedResult(context, runtimeResult);
-      }
-    );
+  constructor(localName, signature, call, resultFactory) {
+    super(localName, signature, (context, args) => {
+      const result = call(context, args);
+      return resultFactory(context, result);
+    });
   }
 }
 
 class BooleanFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, BooleanEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new BooleanEvaluation(context, value);
+    });
   }
 }
 
@@ -22556,15 +22720,19 @@ const lang = new BooleanFunction(
     if (contextNode == null) {
       return false;
     }
-    let contextElement = isElementNode(contextNode) ? contextNode : contextNode.parentElement;
-    if (contextElement == null) {
+    const { domProvider } = context;
+    let currentContextNode = domProvider.isElement(contextNode) ? contextNode : domProvider.getParentNode(contextNode);
+    if (currentContextNode == null) {
       return false;
     }
-    let langValue = contextElement.getAttributeNS(XML_NAMESPACE_URI, "lang");
+    let langValue = null;
     do {
-      langValue = contextElement?.getAttributeNS(XML_NAMESPACE_URI, "lang")?.toLowerCase() ?? null;
-      contextElement = contextElement.parentElement;
-    } while (langValue == null && contextElement != null);
+      if (currentContextNode == null || !domProvider.isElement(currentContextNode)) {
+        break;
+      }
+      langValue = domProvider.getQualifiedNamedAttributeValue(currentContextNode, XML_NAMESPACE_URI, "lang")?.toLowerCase() ?? null;
+      currentContextNode = domProvider.getParentNode(currentContextNode);
+    } while (langValue == null && currentContextNode != null);
     return langValue != null && (langValue === language || langValue.startsWith(`${language}-`));
   }
 );
@@ -22577,12 +22745,12 @@ const not = new BooleanFunction(
 );
 
 const boolean$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	boolean: boolean$1,
-	false: falseFn,
-	lang,
-	not,
-	true: trueFn
+    __proto__: null,
+    boolean: boolean$1,
+    false: falseFn,
+    lang,
+    not,
+    true: trueFn
 }, Symbol.toStringTag, { value: 'Module' }));
 
 class InvalidArgumentError extends Error {}
@@ -23591,11 +23759,7 @@ class NodeSetFunction extends FunctionImplementation {
   constructor(localName, signature, call) {
     super(localName, signature, (context, args) => {
       const nodes = call(context, args);
-      return LocationPathEvaluation.fromArbitraryNodes(
-        context,
-        nodes,
-        this
-      );
+      return LocationPathEvaluation.fromArbitraryNodes(context, nodes, this);
     });
   }
 }
@@ -23618,42 +23782,20 @@ class NumberEvaluation extends ValueEvaluation {
 
 class NumberFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, NumberEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new NumberEvaluation(context, value);
+    });
   }
 }
 
 class StringFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, StringEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new StringEvaluation(context, value);
+    });
   }
 }
 
-const { DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_PRECEDING } = Node;
-const sortDocumentOrder = (nodes) => {
-  const array = Array.from(nodes);
-  if (array.length < 2) {
-    return array;
-  }
-  return array.sort((a, b) => {
-    const compared = b.compareDocumentPosition(a);
-    if (compared === 0 && a !== b) {
-      if (a.ownerElement === b) {
-        return 1;
-      }
-      if (a === b.ownerElement) {
-        return -1;
-      }
-    }
-    if (compared & DOCUMENT_POSITION_FOLLOWING) {
-      return 1;
-    }
-    if (compared & DOCUMENT_POSITION_PRECEDING) {
-      return -1;
-    }
-    return 0;
-  });
-};
-
 const { toCount } = reduce;
 const count = new NumberFunction(
   "count",
@@ -23685,15 +23827,15 @@ const id = new NodeSetFunction(
     if (elementIds.length === 0) {
       return [];
     }
-    const { contextDocument } = context;
+    const { contextDocument, domProvider } = context;
     const elements = elementIds.flatMap((elementId) => {
-      const element = contextDocument.getElementById(elementId);
+      const element = domProvider.getElementByUniqueId(contextDocument, elementId);
       if (element == null) {
         return [];
       }
       return element;
     });
-    return sortDocumentOrder(elements);
+    return context.domProvider.sortInDocumentOrder(elements);
   }
 );
 const last = new NumberFunction("last", [], (context) => context.contextSize());
@@ -23709,11 +23851,14 @@ const localName = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.ATTRIBUTE_NODE && node.nodeType !== Node.PROCESSING_INSTRUCTION_NODE) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getLocalName(node);
+    }
+    if (domProvider.isProcessingInstruction(node)) {
+      return domProvider.getProcessingInstructionName(node);
     }
-    const name2 = isNamespaceNode(node) ? "" : isProcessingInstructionNode(node) ? node.nodeName : node.localName ?? "";
-    return name2;
+    return "";
   }
 );
 const name = new StringFunction(
@@ -23728,13 +23873,14 @@ const name = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.ATTRIBUTE_NODE && node.nodeType !== Node.PROCESSING_INSTRUCTION_NODE) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getQualifiedName(node);
     }
-    if (isNamespaceNode(node)) {
-      return "";
+    if (domProvider.isProcessingInstruction(node)) {
+      return domProvider.getProcessingInstructionName(node);
     }
-    return node.nodeName ?? "";
+    return "";
   }
 );
 const namespaceURI = new StringFunction(
@@ -23749,10 +23895,11 @@ const namespaceURI = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (isNamespaceNode(node)) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getNamespaceURI(node) ?? "";
     }
-    return node.namespaceURI ?? "";
+    return "";
   }
 );
 const position$1 = new NumberFunction(
@@ -23762,15 +23909,15 @@ const position$1 = new NumberFunction(
 );
 
 const nodeset$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	count,
-	current,
-	id,
-	last,
-	localName,
-	name,
-	namespaceURI,
-	position: position$1
+    __proto__: null,
+    count,
+    current,
+    id,
+    last,
+    localName,
+    name,
+    namespaceURI,
+    position: position$1
 }, Symbol.toStringTag, { value: 'Module' }));
 
 class FunctionAlias extends FunctionImplementation {
@@ -23869,12 +24016,12 @@ const sum$1 = new NumberFunction(
 );
 
 const number$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	ceiling,
-	floor,
-	number: number$2,
-	round: round$1,
-	sum: sum$1
+    __proto__: null,
+    ceiling,
+    floor,
+    number: number$2,
+    round: round$1,
+    sum: sum$1
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const escapeRegExp = (value) => value.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
@@ -24020,17 +24167,17 @@ const translate = new StringFunction(
 );
 
 const string$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	concat: concat$1,
-	contains,
-	normalizeSpace,
-	startsWith,
-	string: string$2,
-	stringLength,
-	substring,
-	substringAfter,
-	substringBefore,
-	translate
+    __proto__: null,
+    concat: concat$1,
+    contains,
+    normalizeSpace,
+    startsWith,
+    string: string$2,
+    stringLength,
+    substring,
+    substringAfter,
+    substringBefore,
+    translate
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const fn = new FunctionLibrary(FN_NAMESPACE_URI, [
@@ -24452,9 +24599,7 @@ class FilterPathExpressionEvaluator extends LocationPathEvaluator {
   evaluateNodes(context) {
     if (this.hasSteps) {
       const filterContextResults = this.filterExpression.evaluate(context);
-      if (!(filterContextResults instanceof LocationPathEvaluation)) {
-        throw "todo not a node-set context";
-      }
+      LocationPathEvaluation.assertInstance(context, filterContextResults);
       return super.evaluateNodes(filterContextResults);
     }
     return this.filterExpression.evaluateNodes(context);
@@ -24625,7 +24770,7 @@ class UnionExpressionEvaluator extends LocationPathExpressionEvaluator {
     if (!(rhs instanceof LocationPathEvaluation)) {
       throw "todo rhs not node-set result";
     }
-    return sortDocumentOrder(distinct(multiExports.chain(lhs.nodes, rhs.nodes)));
+    return context.domProvider.sortInDocumentOrder(distinct(multiExports.chain(lhs.nodes, rhs.nodes)));
   }
 }
 
@@ -24748,19 +24893,29 @@ class FunctionLibraryCollection {
   }
 }
 
-const ResultTypes = {
-  BOOLEAN_TYPE: XPathResult.BOOLEAN_TYPE,
-  NUMBER_TYPE: XPathResult.NUMBER_TYPE,
-  STRING_TYPE: XPathResult.STRING_TYPE,
-  UNORDERED_NODE_ITERATOR_TYPE: XPathResult.UNORDERED_NODE_ITERATOR_TYPE,
-  ORDERED_NODE_ITERATOR_TYPE: XPathResult.ORDERED_NODE_ITERATOR_TYPE,
-  UNORDERED_NODE_SNAPSHOT_TYPE: XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-  ORDERED_NODE_SNAPSHOT_TYPE: XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
-  ANY_UNORDERED_NODE_TYPE: XPathResult.ANY_UNORDERED_NODE_TYPE,
-  FIRST_ORDERED_NODE_TYPE: XPathResult.FIRST_ORDERED_NODE_TYPE
+const ANY_TYPE$2 = 0;
+const NUMBER_TYPE$2 = 1;
+const STRING_TYPE$2 = 2;
+const BOOLEAN_TYPE$2 = 3;
+const UNORDERED_NODE_ITERATOR_TYPE$2 = 4;
+const ORDERED_NODE_ITERATOR_TYPE$2 = 5;
+const UNORDERED_NODE_SNAPSHOT_TYPE$2 = 6;
+const ORDERED_NODE_SNAPSHOT_TYPE$2 = 7;
+const ANY_UNORDERED_NODE_TYPE$2 = 8;
+const FIRST_ORDERED_NODE_TYPE$2 = 9;
+const XPATH_EVALUATION_RESULT = {
+  ANY_TYPE: ANY_TYPE$2,
+  ANY_UNORDERED_NODE_TYPE: ANY_UNORDERED_NODE_TYPE$2,
+  BOOLEAN_TYPE: BOOLEAN_TYPE$2,
+  FIRST_ORDERED_NODE_TYPE: FIRST_ORDERED_NODE_TYPE$2,
+  NUMBER_TYPE: NUMBER_TYPE$2,
+  ORDERED_NODE_ITERATOR_TYPE: ORDERED_NODE_ITERATOR_TYPE$2,
+  ORDERED_NODE_SNAPSHOT_TYPE: ORDERED_NODE_SNAPSHOT_TYPE$2,
+  STRING_TYPE: STRING_TYPE$2,
+  UNORDERED_NODE_ITERATOR_TYPE: UNORDERED_NODE_ITERATOR_TYPE$2,
+  UNORDERED_NODE_SNAPSHOT_TYPE: UNORDERED_NODE_SNAPSHOT_TYPE$2
 };
 
-const NODE_SET_RESULT_TYPE = -1;
 const {
   ANY_TYPE: ANY_TYPE$1,
   NUMBER_TYPE: NUMBER_TYPE$1,
@@ -24772,7 +24927,7 @@ const {
   ORDERED_NODE_SNAPSHOT_TYPE: ORDERED_NODE_SNAPSHOT_TYPE$1,
   ANY_UNORDERED_NODE_TYPE: ANY_UNORDERED_NODE_TYPE$1,
   FIRST_ORDERED_NODE_TYPE: FIRST_ORDERED_NODE_TYPE$1
-} = XPathResult;
+} = XPATH_EVALUATION_RESULT;
 class BaseResult {
   static ANY_TYPE = ANY_TYPE$1;
   static NUMBER_TYPE = NUMBER_TYPE$1;
@@ -24794,7 +24949,6 @@ class BaseResult {
   ORDERED_NODE_SNAPSHOT_TYPE = ORDERED_NODE_SNAPSHOT_TYPE$1;
   ANY_UNORDERED_NODE_TYPE = ANY_UNORDERED_NODE_TYPE$1;
   FIRST_ORDERED_NODE_TYPE = FIRST_ORDERED_NODE_TYPE$1;
-  static NODE_SET_RESULT_TYPE = NODE_SET_RESULT_TYPE;
 }
 
 class InvalidNodeSetResultError extends Error {
@@ -24803,9 +24957,6 @@ class InvalidNodeSetResultError extends Error {
   }
 }
 class PrimitiveResult extends BaseResult {
-  get resultType() {
-    return this.type;
-  }
   get singleNodeValue() {
     throw new InvalidNodeSetResultError();
   }
@@ -24822,9 +24973,8 @@ class PrimitiveResult extends BaseResult {
 }
 
 class BooleanResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.BOOLEAN_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.BOOLEAN_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24837,13 +24987,12 @@ class BooleanResult extends PrimitiveResult {
 }
 
 class NodeSetResult extends BaseResult {
-  constructor(value) {
+  constructor(domProvider, value) {
     super();
+    this.domProvider = domProvider;
     this.value = value;
     this.nodes = value;
   }
-  isIntermediateResult = false;
-  type = BaseResult.NODE_SET_RESULT_TYPE;
   nodes;
   computedBooleanValue = null;
   computedNumberValue = null;
@@ -24864,7 +25013,12 @@ class NodeSetResult extends BaseResult {
   compute() {
     let { computedBooleanValue, computedNumberValue, computedStringValue } = this;
     if (computedBooleanValue == null || computedNumberValue == null || computedStringValue == null) {
-      computedStringValue = this.singleNodeValue?.textContent ?? "";
+      const { singleNodeValue } = this;
+      if (singleNodeValue == null) {
+        computedStringValue = "";
+      } else {
+        computedStringValue = this.domProvider.getNodeValue(singleNodeValue);
+      }
       const isBlank = computedStringValue === "";
       computedBooleanValue = !isBlank;
       computedNumberValue = isBlank ? NaN : Number(computedStringValue);
@@ -24877,9 +25031,9 @@ class NodeSetResult extends BaseResult {
   }
 }
 class NodeSetSnapshotResult extends NodeSetResult {
-  constructor(resultType, nodes) {
+  constructor(domProvider, resultType, nodes) {
     const snapshot = [...Reiterable.from(nodes)];
-    super(snapshot);
+    super(domProvider, snapshot);
     this.resultType = resultType;
     const snapshotIterator = snapshot.values();
     this.snapshot = snapshot;
@@ -24912,8 +25066,8 @@ class InvalidSnapshotError extends Error {
   }
 }
 class NodeSetIteratorResult extends NodeSetResult {
-  constructor(resultType, nodes) {
-    super(nodes);
+  constructor(domProvider, resultType, nodes) {
+    super(domProvider, nodes);
     this.resultType = resultType;
     this.nodes = Reiterable.from(nodes);
   }
@@ -24959,9 +25113,8 @@ class NodeSetIteratorResult extends NodeSetResult {
 }
 
 class NumberResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.NUMBER_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.NUMBER_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24974,9 +25127,8 @@ class NumberResult extends PrimitiveResult {
 }
 
 class StringResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.STRING_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.STRING_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24999,8 +25151,8 @@ const {
   ORDERED_NODE_SNAPSHOT_TYPE,
   ANY_UNORDERED_NODE_TYPE,
   FIRST_ORDERED_NODE_TYPE
-} = globalThis.XPathResult;
-const toXPathResult = (resultType, evaluation) => {
+} = XPATH_EVALUATION_RESULT;
+const toXPathEvaluationResult = (domProvider, resultType, evaluation) => {
   const { nodes } = evaluation;
   switch (resultType) {
     case ANY_TYPE:
@@ -25011,8 +25163,13 @@ const toXPathResult = (resultType, evaluation) => {
           return new NumberResult(evaluation);
         case "STRING":
           return new StringResult(evaluation);
-        case "NODE":
-          return new NodeSetIteratorResult(UNORDERED_NODE_ITERATOR_TYPE, evaluation.nodes);
+        case "NODE": {
+          return new NodeSetIteratorResult(
+            domProvider,
+            UNORDERED_NODE_ITERATOR_TYPE,
+            evaluation.nodes ?? []
+          );
+        }
         default:
           throw new UnreachableError(evaluation.type);
       }
@@ -25029,59 +25186,63 @@ const toXPathResult = (resultType, evaluation) => {
       if (nodes == null) {
         throw "todo not a node-set";
       }
-      return new NodeSetIteratorResult(resultType, nodes);
+      return new NodeSetIteratorResult(domProvider, resultType, nodes);
     case UNORDERED_NODE_SNAPSHOT_TYPE:
     case ORDERED_NODE_SNAPSHOT_TYPE:
       if (nodes == null) {
         throw "todo not a node-set";
       }
-      return new NodeSetSnapshotResult(resultType, nodes);
+      return new NodeSetSnapshotResult(domProvider, resultType, nodes);
     default:
       throw new UnreachableError(resultType);
   }
 };
 
 const functions$1 = new FunctionLibraryCollection([fn]);
-const isNonNullEntry = (entry) => entry[1] != null;
-const partialOmitNullish = (object) => Object.fromEntries(Object.entries(object).filter(isNonNullEntry));
 class Evaluator {
+  domProvider;
   // TODO: see notes on cache in `ExpressionParser.ts`, update or remove those
   // if this usage changes in a way that addresses concerns expressed there.
   parser;
   functions;
   parseOptions;
-  resultTypes = ResultTypes;
-  rootNodeDocument = null;
   rootNode;
-  sharedContextOptions;
   timeZone;
-  constructor(options = {}) {
-    const { parseOptions = {}, rootNode, timeZoneId } = options;
+  constructor(options) {
+    const rootNode = options.rootNode ?? null;
+    const { domAdapter, parseOptions = {}, timeZoneId } = options;
+    const domProvider = xpathDOMProvider(domAdapter);
+    if (rootNode != null) {
+      domProvider.assertParentNode(rootNode, "Invalid root node");
+    }
+    this.domProvider = domProvider;
+    this.rootNode = rootNode;
     this.functions = options.functions ?? functions$1;
     this.parseOptions = parseOptions;
     this.parser = expressionParser;
-    this.rootNode = rootNode ?? null;
-    if (rootNode != null) {
-      this.rootNodeDocument = rootNode.ownerDocument ?? rootNode;
-    }
-    this.sharedContextOptions = partialOmitNullish({
-      rootNode
-    });
     this.timeZone = new Pt.TimeZone(timeZoneId ?? Pt.Now.timeZoneId());
   }
+  /**
+   * @package - exposed for testing
+   */
+  getEvaluationContext(contextNode, namespaceResolver) {
+    const contextOptions = {
+      rootNode: this.rootNode,
+      namespaceResolver
+    };
+    this.domProvider.assertXPathNode(contextNode);
+    return new EvaluationContext(this, contextNode, contextOptions);
+  }
   evaluate(expression, contextNode, namespaceResolver, resultType) {
     const tree = this.parser.parse(expression, this.parseOptions);
-    const evaluationContextNamespaceResolver = typeof namespaceResolver === "function" ? {
-      lookupNamespaceURI: namespaceResolver
-    } : namespaceResolver;
-    const contextOptions = partialOmitNullish({
-      ...this.sharedContextOptions,
-      namespaceResolver: evaluationContextNamespaceResolver
-    });
     const expr = createExpression(tree.rootNode);
-    const context = new EvaluationContext(this, contextNode, contextOptions);
-    const results = expr.evaluate(context);
-    return toXPathResult(resultType ?? XPathResult.ANY_TYPE, results);
+    const evaluationContext = this.getEvaluationContext(contextNode, namespaceResolver);
+    const results = expr.evaluate(evaluationContext);
+    return toXPathEvaluationResult(
+      this.domProvider,
+      resultType ?? XPATH_EVALUATION_RESULT.ANY_TYPE,
+      results
+    );
   }
   getContextNode(options) {
     const contextNode = options.contextNode ?? this.rootNode;
@@ -25094,19 +25255,24 @@ class Evaluator {
   }
   evaluateBoolean(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.BOOLEAN_TYPE).booleanValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.BOOLEAN_TYPE).booleanValue;
   }
   evaluateNumber(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.NUMBER_TYPE).numberValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.NUMBER_TYPE).numberValue;
   }
   evaluateString(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.STRING_TYPE).stringValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.STRING_TYPE).stringValue;
   }
   evaluateNode(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    const node = this.evaluate(expression, contextNode, null, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    const node = this.evaluate(
+      expression,
+      contextNode,
+      null,
+      XPATH_EVALUATION_RESULT.FIRST_ORDERED_NODE_TYPE
+    ).singleNodeValue;
     if (!options.assertExists) {
       return node;
     }
@@ -25130,7 +25296,7 @@ class Evaluator {
       expression,
       contextNode,
       null,
-      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE
+      XPATH_EVALUATION_RESULT.ORDERED_NODE_SNAPSHOT_TYPE
     );
     const { snapshotLength } = snapshotResult;
     const nodes = [];
@@ -25144,6 +25310,287 @@ class Evaluator {
   }
 }
 
+class IncompatibleRuntimeEnvironmentError extends Error {
+}
+
+let didAssertNodeConstructor = false;
+const assertNodeConstructor = (NodeConstructor) => {
+  if (didAssertNodeConstructor) {
+    return;
+  }
+  const isExpectedFunctionSignature = typeof NodeConstructor === "function" && NodeConstructor.name === "Node" && NodeConstructor.length === 0;
+  if (!isExpectedFunctionSignature || !(globalThis.document instanceof NodeConstructor)) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  didAssertNodeConstructor = true;
+};
+const getNodeConstructor = () => {
+  const { Node } = globalThis;
+  assertNodeConstructor(Node);
+  return Node;
+};
+
+const DOCUMENT_NODE = 9;
+const ELEMENT_NODE = 1;
+const ATTRIBUTE_NODE = 2;
+const TEXT_NODE = 3;
+const CDATA_SECTION_NODE = 4;
+const COMMENT_NODE = 8;
+const PROCESSING_INSTRUCTION_NODE = 7;
+const DOCUMENT_TYPE_NODE = 10;
+const isUnknownWHATNode = (value) => {
+  return value instanceof getNodeConstructor();
+};
+const getOptionalNodeKind = (value) => {
+  if (!isUnknownWHATNode(value)) {
+    return null;
+  }
+  const node = value;
+  switch (node.nodeType) {
+    case DOCUMENT_NODE:
+      return "document";
+    case DOCUMENT_TYPE_NODE:
+      return "UNSPECIFIED_NON_XPATH_NODE";
+    case ELEMENT_NODE:
+      return "element";
+    case ATTRIBUTE_NODE:
+      if (node.namespaceURI === XMLNS_NAMESPACE_URI) {
+        return "namespace_declaration";
+      }
+      return "attribute";
+    case TEXT_NODE:
+    case CDATA_SECTION_NODE:
+      return "text";
+    case COMMENT_NODE:
+      return "comment";
+    case PROCESSING_INSTRUCTION_NODE:
+      return "processing_instruction";
+    default:
+      return null;
+  }
+};
+const getWHATNodeKind = (node) => {
+  const nodeKind = getOptionalNodeKind(node);
+  if (nodeKind == null) {
+    throw new Error(`Unsupported WHAT node type: ${node.nodeType}`);
+  }
+  return nodeKind;
+};
+const isWHATNode = (value) => {
+  const nodeKind = getOptionalNodeKind(value);
+  return nodeKind != null && nodeKind !== "UNSPECIFIED_NON_XPATH_NODE";
+};
+const isWHATDocument = (node) => {
+  return node.nodeType === DOCUMENT_NODE;
+};
+const isWHATElement = (node) => {
+  return node.nodeType === ELEMENT_NODE;
+};
+const isWHATNamespaceDeclaration = (node) => {
+  return node.nodeType === ATTRIBUTE_NODE && node.namespaceURI === XMLNS_NAMESPACE_URI;
+};
+const isWHATAttribute = (node) => {
+  return node.nodeType === ATTRIBUTE_NODE && node.namespaceURI !== XMLNS_NAMESPACE_URI;
+};
+const isWHATParentNode = (node) => {
+  return isWHATDocument(node) || isWHATElement(node);
+};
+
+const getWHATNamespaceURI = (node) => {
+  return node.namespaceURI;
+};
+const getWHATQualifiedName = (node) => {
+  return node.nodeName;
+};
+const getWHATLocalName = (node) => {
+  return node.localName;
+};
+const getWHATProcessingInstructionName = (node) => {
+  return node.nodeName;
+};
+const resolveWHATNamespaceURI = (node, prefix) => {
+  return node.lookupNamespaceURI(prefix);
+};
+
+const getContainingWHATDocument = (node) => {
+  if (isWHATDocument(node)) {
+    return node;
+  }
+  return node.ownerDocument;
+};
+const getOwnerWHATElement = (node) => {
+  const ownerElement = node.ownerElement ?? null;
+  return ownerElement;
+};
+const getAttrs = (node) => {
+  if (isWHATElement(node)) {
+    return Array.from(node.attributes);
+  }
+  return [];
+};
+const getWHATNamespaceDeclarations = (node) => {
+  return getAttrs(node).filter(isWHATNamespaceDeclaration);
+};
+const getWHATAttributes = (node) => {
+  return getAttrs(node).filter(isWHATAttribute);
+};
+const getWHATParentNode = (node) => {
+  let parentNode = getOwnerWHATElement(node);
+  if (parentNode == null) {
+    parentNode = node.parentNode;
+  }
+  return parentNode;
+};
+const getWHATChildNodes = (node) => {
+  if (!isWHATParentNode(node)) {
+    return [];
+  }
+  return Array.from(node.childNodes);
+};
+const getChildWHATElements = (node) => {
+  if (!isWHATParentNode(node)) {
+    return [];
+  }
+  return Array.from(node.children);
+};
+const getPreviousSiblingWHATNode = (node) => {
+  const previousSibling = node.previousSibling;
+  return previousSibling;
+};
+const getPreviousSiblingWHATElement = (node) => {
+  const previousElementSibling = node.previousElementSibling ?? null;
+  return previousElementSibling;
+};
+const getNextSiblingWHATNode = (node) => {
+  return node.nextSibling;
+};
+const getNextSiblingWHATElement = (node) => {
+  const nextElementSibling = node.nextElementSibling ?? null;
+  return nextElementSibling;
+};
+const isDescendantWHATNode = (ancestor, other) => {
+  return ancestor.contains(other);
+};
+const getWHATDocumentPositionComparableNode = (node) => {
+  return getOwnerWHATElement(node) ?? node;
+};
+const DOCUMENT_POSITION_PRECEDING = 2;
+const DOCUMENT_POSITION_FOLLOWING = 4;
+const compareWHATDocumentOrder = (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  const compared = b.compareDocumentPosition(a);
+  if (compared === 0) {
+    if (getWHATDocumentPositionComparableNode(a) === b) {
+      return 1;
+    }
+    if (a === getWHATDocumentPositionComparableNode(b)) {
+      return -1;
+    }
+  }
+  if (compared & DOCUMENT_POSITION_FOLLOWING) {
+    return 1;
+  }
+  if (compared & DOCUMENT_POSITION_PRECEDING) {
+    return -1;
+  }
+  throw new Error("Failed to compare document position");
+};
+
+const getQualifiedNamedWHATAttributeValue = (node, namespaceURI, localName) => {
+  return node.getAttributeNS(namespaceURI, localName);
+};
+const getLocalNamedWHATAttributeValue = (node, localName) => {
+  return node.getAttribute(localName);
+};
+const hasLocalNamedWHATAttribute = (node, localName) => {
+  return node.hasAttribute(localName);
+};
+const getWHATElementByUniqueId = (node, id) => {
+  const element = getContainingWHATDocument(node).getElementById(id);
+  return element;
+};
+const getWHATChildrenByLocalName = (node, localName) => {
+  return getChildWHATElements(node).filter((element) => {
+    return element.localName === localName;
+  });
+};
+const getFirstWHATChildNode = (node) => {
+  const firstChild = node.firstChild;
+  return firstChild;
+};
+const getLastWHATChildNode = (node) => {
+  const lastChild = node.lastChild;
+  return lastChild;
+};
+const getFirstChildWHATElement = (node) => {
+  const firstElementChild = node.firstElementChild ?? null;
+  return firstElementChild;
+};
+const getLastChildWHATElement = (node) => {
+  const lastElementChild = node.lastElementChild ?? null;
+  return lastElementChild;
+};
+
+const getWHATNodeValue = (node) => {
+  return node.textContent ?? "";
+};
+
+const whatDOMAdapter = {
+  // XPathNodeKindAdapter
+  getNodeKind: getWHATNodeKind,
+  isXPathNode: isWHATNode,
+  // XPathNameAdapter
+  getLocalName: getWHATLocalName,
+  getNamespaceURI: getWHATNamespaceURI,
+  getQualifiedName: getWHATQualifiedName,
+  getProcessingInstructionName: getWHATProcessingInstructionName,
+  resolveNamespaceURI: resolveWHATNamespaceURI,
+  // XPathValueAdapter
+  getNodeValue: getWHATNodeValue,
+  // XPathTraversalAdapter
+  compareDocumentOrder: compareWHATDocumentOrder,
+  getAttributes: getWHATAttributes,
+  getChildElements: getChildWHATElements,
+  getChildNodes: getWHATChildNodes,
+  getContainingDocument: getContainingWHATDocument,
+  getNamespaceDeclarations: getWHATNamespaceDeclarations,
+  getNextSiblingElement: getNextSiblingWHATElement,
+  getNextSiblingNode: getNextSiblingWHATNode,
+  getParentNode: getWHATParentNode,
+  getPreviousSiblingElement: getPreviousSiblingWHATElement,
+  getPreviousSiblingNode: getPreviousSiblingWHATNode,
+  isDescendantNode: isDescendantWHATNode,
+  // XPathDOMOptimizableOperations
+  getElementByUniqueId: getWHATElementByUniqueId,
+  getChildrenByLocalName: getWHATChildrenByLocalName,
+  getQualifiedNamedAttributeValue: getQualifiedNamedWHATAttributeValue,
+  getLocalNamedAttributeValue: getLocalNamedWHATAttributeValue,
+  hasLocalNamedAttribute: hasLocalNamedWHATAttribute,
+  getFirstChildElement: getFirstChildWHATElement,
+  getFirstChildNode: getFirstWHATChildNode,
+  getLastChildElement: getLastChildWHATElement,
+  getLastChildNode: getLastWHATChildNode
+};
+
+const DEFAULT_DOM_ADAPTER = whatDOMAdapter;
+const DEFAULT_DOM_PROVIDER = xpathDOMProvider(DEFAULT_DOM_ADAPTER);
+
+const XPathNodeKindKey = Symbol("XPathNodeKindKey");
+
+class DefaultEvaluator extends Evaluator {
+  constructor(options) {
+    super({
+      ...options,
+      domAdapter: DEFAULT_DOM_ADAPTER
+    });
+  }
+}
+
+const XFORMS_LOCAL_NAME = Symbol("XFORMS_LOCAL_NAME");
+const XFORMS_KNOWN_ATTRIBUTE = Symbol("XFORMS_KNOWN_ATTRIBUTE");
+
 const DAY_MILLISECONDS = 1e3 * 60 * 60 * 24;
 const MILLISECOND_NANOSECONDS = BigInt(1e6);
 const ISO_DATE_LIKE_SUBPATTERN = "\\d{4}-\\d{2}-\\d{2}";
@@ -25452,7 +25899,7 @@ const date = new FunctionImplementation(
           return new StringEvaluation(context, string);
         }
         if (!DATE_OR_DATE_TIME_PATTERN.test(string)) {
-          const unpaddedMatches = string.match(UNPADDED_MONTH_DAY_PATTERN);
+          const unpaddedMatches = UNPADDED_MONTH_DAY_PATTERN.exec(string);
           if (unpaddedMatches == null) {
             return new DateTimeLikeEvaluation(context, null);
           }
@@ -25510,14 +25957,14 @@ const decimalTime = new NumberFunction(
 );
 
 const datetime = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	date,
-	decimalDateTime,
-	decimalTime,
-	formatDate,
-	formatDateTime,
-	today,
-	xfNow
+    __proto__: null,
+    date,
+    decimalDateTime,
+    decimalTime,
+    formatDate,
+    formatDateTime,
+    today,
+    xfNow
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
@@ -25525,209 +25972,18 @@ const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
   new FunctionAlias("format-date", formatDateTime)
 ]);
 
-class UpsertableWeakMap extends WeakMap {
-  upsert(key, produce) {
-    if (this.has(key)) {
-      return this.get(key);
-    }
-    const value = produce(key);
-    this.set(key, value);
-    return value;
-  }
-}
-
-const SUPPORTS_SCOPE_CHILD_SELECTOR = (() => {
-  const parent = document.createElement("parent");
-  const child1 = document.createElement("child1");
-  const child2 = document.createElement("child2");
-  child2.append(child1);
-  parent.append(child2);
-  return parent.querySelector(":scope > child1") === child1 && parent.querySelector(":scope > child2") !== child2;
-})();
-const getScopedElement = (() => {
-  if (SUPPORTS_SCOPE_CHILD_SELECTOR) {
-    return (lookup, contextNode) => {
-      return contextNode.querySelector(lookup.scopedSelector);
-    };
-  }
-  return (lookup, contextNode) => {
-    const { unscopedSelector } = lookup;
-    for (const child of contextNode.children) {
-      if (child.matches(unscopedSelector)) {
-        return child;
-      }
-    }
-    return null;
-  };
-})();
-const getScopedElements = (() => {
-  if (SUPPORTS_SCOPE_CHILD_SELECTOR) {
-    return (lookup, contextNode) => {
-      return contextNode.querySelectorAll(lookup.scopedSelector);
-    };
-  }
-  return (lookup, contextNode) => {
-    const { unscopedSelector } = lookup;
-    return Array.from(contextNode.children).filter((child) => {
-      return child.matches(unscopedSelector);
-    });
-  };
-})();
-class ScopedElementLookup {
-  constructor(scopedSelector, unscopedSelector) {
-    this.scopedSelector = scopedSelector;
-    this.unscopedSelector = unscopedSelector;
-  }
-  /**
-   * WARNING: `T` is unchecked at runtime, use with caution!
-   */
-  getElement(contextNode) {
-    return getScopedElement(this, contextNode);
-  }
-  /**
-   * WARNING: `T` is unchecked at runtime, use with caution!
-   */
-  getElements(contextNode) {
-    return getScopedElements(this, contextNode);
-  }
-}
-
-const itextRootLookup = new ScopedElementLookup(":scope > itext", "itext");
-const getItextRoot = (modelElement) => {
-  return itextRootLookup.getElement(modelElement);
-};
-const translationLookup = new ScopedElementLookup(
-  ":scope > translation[lang]",
-  "translation[lang]"
-);
-const translationElementsCache = new UpsertableWeakMap();
-const getTranslationElementMap = (modelElement) => {
-  return translationElementsCache.upsert(modelElement, () => {
-    const itextRoot = getItextRoot(modelElement);
-    if (itextRoot == null) {
-      return /* @__PURE__ */ new Map();
-    }
-    const translationElements = Array.from(
-      translationLookup.getElements(itextRoot)
-    );
-    return new Map(
-      translationElements.map((element) => {
-        return [element.getAttribute("lang"), element];
-      })
-    );
-  });
-};
-const getTranslationElement = (modelElement, translationLanguage) => {
-  const translationElementMap = getTranslationElementMap(modelElement);
-  return translationElementMap.get(translationLanguage) ?? null;
-};
-const translationTextLookup = new ScopedElementLookup(":scope > text[id]", "text[id]");
-const translationsCache = new UpsertableWeakMap();
-const getTranslationTextByLanguage = (modelElement, language, itextID) => {
-  const translationElement = getTranslationElement(modelElement, language);
-  if (translationElement == null) {
-    return null;
-  }
-  const textMaps = translationsCache.upsert(modelElement, () => {
-    return new UpsertableWeakMap();
-  });
-  const textMap = textMaps.upsert(translationElement, () => {
-    const textElements = Array.from(
-      translationTextLookup.getElements(translationElement)
-    );
-    return new Map(
-      textElements.map((element) => {
-        return [element.getAttribute("id"), element];
-      })
-    );
-  });
-  return textMap.get(itextID) ?? null;
-};
-const defaultTextValueLookup = new ScopedElementLookup(
-  ":scope > value:not([form])",
-  "value:not([form])"
-);
-const getDefaultTextValueElement = (textElement) => {
-  return defaultTextValueLookup.getElement(textElement);
-};
-const getTranslationMetadata = (modelElement) => {
-  const languages = [];
-  let defaultLanguage = null;
-  if (modelElement == null) {
-    return {
-      defaultLanguage,
-      languages
-    };
-  }
-  const translationElementMap = getTranslationElementMap(modelElement);
-  for (const [language, element] of translationElementMap) {
-    if (defaultLanguage == null && element.hasAttribute("default")) {
-      defaultLanguage = language;
-      languages.unshift(language);
-    } else {
-      languages.push(language);
-    }
-  }
-  if (defaultLanguage == null) {
-    defaultLanguage = languages[0] ?? null;
-  }
-  return {
-    defaultLanguage,
-    languages
-  };
-};
-class XFormsItextTranslations {
-  constructor(evaluator) {
-    this.evaluator = evaluator;
-    const { defaultLanguage, languages } = getTranslationMetadata(evaluator.modelElement);
-    this.defaultLanguage = defaultLanguage;
-    this.activeLanguage = defaultLanguage;
-    this.languages = languages;
-  }
-  defaultLanguage;
-  languages;
-  activeLanguage;
-  getLanguages() {
-    return this.languages;
-  }
-  getActiveLanguage() {
-    return this.activeLanguage;
-  }
-  setActiveLanguage(language) {
-    this.activeLanguage = language ?? this.defaultLanguage;
-    return this.activeLanguage;
-  }
-}
-
 const itext = new StringFunction(
   "itext",
   [{ arityType: "required", typeHint: "string" }],
   (context, [itextIDExpression]) => {
-    const { evaluator } = context;
-    if (!(evaluator instanceof XFormsXPathEvaluator)) {
-      throw new Error("itext not available");
-    }
-    const { modelElement } = evaluator;
-    if (modelElement == null) {
-      return "";
-    }
-    const activeLanguage = evaluator.translations.getActiveLanguage();
-    if (activeLanguage == null) {
-      return "";
-    }
     const itextID = itextIDExpression.evaluate(context).toString();
-    const textElement = getTranslationTextByLanguage(modelElement, activeLanguage, itextID);
-    if (textElement == null) {
-      return "";
-    }
-    const defaultTextValue = getDefaultTextValueElement(textElement);
-    return defaultTextValue?.textContent ?? "";
+    return XFormsXPathEvaluator.getDefaultTranslationText(context, itextID);
   }
 );
 
 const string$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	itext
+    __proto__: null,
+    itext
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const jr = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(string$1)]);
@@ -25823,11 +26079,11 @@ const xfIf = new FunctionImplementation(
 );
 
 const boolean = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	booleanFromString,
-	checklist,
-	weightedChecklist,
-	xfIf
+    __proto__: null,
+    booleanFromString,
+    checklist,
+    weightedChecklist,
+    xfIf
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const DEGREES_MAX = {
@@ -25977,9 +26233,9 @@ const distance = new NumberFunction(
 );
 
 const geo = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	area,
-	distance
+    __proto__: null,
+    area,
+    distance
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const MAX_INT_32 = 2147483647;
@@ -26051,23 +26307,18 @@ const assertArgument = (index, arg) => {
     throw new Error(`Argument ${index + 1} expected`);
   }
 };
-const assertIsLocationPathEvaluation = (evaluation) => {
-  if (!(evaluation instanceof LocationPathEvaluation)) {
-    throw new Error("Expected a node-set result");
-  }
-};
 const evaluateArgumentToFilterableNodes = (context, arg) => {
   const evaluation = arg.evaluate(context);
-  assertIsLocationPathEvaluation(evaluation);
+  LocationPathEvaluation.assertInstance(context, evaluation);
   return Array.from(evaluation.contextNodes);
 };
-const compareContainmentDepth = ({ repeats: a }, { repeats: b }) => {
+const compareContainmentDepth = (domProvider, { repeats: a }, { repeats: b }) => {
   for (const repeatA of a) {
     for (const repeatB of b) {
-      if (repeatA.contains(repeatB)) {
+      if (domProvider.isDescendantNode(repeatA, repeatB)) {
         return -1;
       }
-      if (repeatB.contains(repeatA)) {
+      if (domProvider.isDescendantNode(repeatB, repeatA)) {
         return 1;
       }
     }
@@ -26118,14 +26369,15 @@ const indexedRepeat = new NodeSetFunction(
         position: position2
       });
     }
-    pairs = pairs.sort(compareContainmentDepth);
+    const { domProvider } = context;
+    pairs = pairs.sort((pairA, pairB) => compareContainmentDepth(domProvider, pairA, pairB));
     let repeatContextNode;
     for (const [index, pair] of pairs.entries()) {
       const { position: position2 } = pair;
       let { repeats } = pair;
       if (index > 0) {
         repeats = pair.repeats.filter((repeat) => {
-          return repeatContextNode.contains(repeat);
+          return domProvider.isDescendantNode(repeatContextNode, repeat);
         });
       }
       const positionedRepeat = repeats[position2 - 1];
@@ -26136,40 +26388,20 @@ const indexedRepeat = new NodeSetFunction(
     }
     const targetNodes = evaluateArgumentToFilterableNodes(context, target);
     return targetNodes.filter((targetNode) => {
-      return repeatContextNode.contains(targetNode);
+      return domProvider.isDescendantNode(repeatContextNode, targetNode);
     });
   }
 );
-const identifiedInstanceLookup = new ScopedElementLookup(":scope > instance[id]", "instance[id]");
-const instancesCache = new UpsertableWeakMap();
-const getInstanceElementByID = (modelElement, id) => {
-  const instances = instancesCache.upsert(modelElement, () => {
-    const instanceElements = Array.from(
-      identifiedInstanceLookup.getElements(modelElement)
-    );
-    return new Map(
-      instanceElements.map((element) => {
-        return [element.getAttribute("id"), element];
-      })
-    );
-  });
-  return instances.get(id) ?? null;
-};
 const instance = new NodeSetFunction(
   "instance",
   [{ arityType: "required" }],
   (context, [idExpression]) => {
     const id = idExpression.evaluate(context).toString();
-    const { evaluator } = context;
-    if (!(evaluator instanceof XFormsXPathEvaluator)) {
-      throw new Error("itext not available");
-    }
-    const { modelElement } = evaluator;
-    if (modelElement == null) {
+    const instanceElement = XFormsXPathEvaluator.getSecondaryInstance(context, id);
+    if (instanceElement == null) {
       return [];
     }
-    const instanceElement = getInstanceElementByID(modelElement, id);
-    return instanceElement == null ? [] : [instanceElement];
+    return [instanceElement];
   }
 );
 const once = new StringFunction(
@@ -26180,13 +26412,17 @@ const once = new StringFunction(
     if (contextNode == null) {
       throw "todo once no context";
     }
-    const string = contextNode.textContent ?? "";
+    const string = context.domProvider.getNodeValue(contextNode);
     if (string === "") {
       return expression.evaluate(context).toString();
     }
     return string;
   }
 );
+const isLikelyRepeatRangeEvaluationContextCommentMarkerNode = (context, node) => {
+  const { evaluationContextNode } = context;
+  return context.domProvider.isComment(node) && node === evaluationContextNode;
+};
 const position = new NumberFunction(
   "position",
   [{ arityType: "optional" }],
@@ -26195,9 +26431,7 @@ const position = new NumberFunction(
       return context.contextPosition();
     }
     const results = expression.evaluate(context);
-    if (!(results instanceof LocationPathEvaluation)) {
-      throw "todo not a node-set";
-    }
+    LocationPathEvaluation.assertInstance(context, results);
     const [first, next] = results.values();
     if (first == null) {
       return NaN;
@@ -26205,15 +26439,27 @@ const position = new NumberFunction(
     if (next != null) {
       throw "todo enforce single node(?)";
     }
+    const { domProvider } = context;
     const { value } = first;
-    const { nodeName } = value;
-    let currentNode = value;
-    let result = 1;
-    while ((currentNode = currentNode.previousSibling) != null) {
-      if (currentNode.nodeName === nodeName) {
-        result += 1;
+    if (!domProvider.isQualifiedNamedNode(value)) {
+      if (isLikelyRepeatRangeEvaluationContextCommentMarkerNode(context, value)) {
+        return context.contextPosition();
       }
+      throw new Error(
+        "Cannot get position among contiguous nodes with same name: not a named node."
+      );
     }
+    const nodeName = domProvider.getQualifiedName(value);
+    let currentNode = value;
+    let result = 0;
+    do {
+      result += 1;
+      const previousNode = domProvider.getPreviousSiblingElement(currentNode);
+      if (previousNode == null) {
+        break;
+      }
+      currentNode = previousNode;
+    } while (domProvider.getQualifiedName(currentNode) === nodeName);
     return result;
   }
 );
@@ -26225,9 +26471,7 @@ const randomize = new NodeSetFunction(
   ],
   (context, [expression, seedExpression]) => {
     const results = expression.evaluate(context);
-    if (!(results instanceof LocationPathEvaluation)) {
-      throw "todo (not a node-set)";
-    }
+    LocationPathEvaluation.assertInstance(context, results);
     const nodeResults = Array.from(results.values());
     const nodes = nodeResults.map(({ value }) => value);
     const seed = seedExpression?.evaluate(context).toNumber();
@@ -26236,13 +26480,13 @@ const randomize = new NodeSetFunction(
 );
 
 const nodeset = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	countNonEmpty,
-	indexedRepeat,
-	instance,
-	once,
-	position,
-	randomize
+    __proto__: null,
+    countNonEmpty,
+    indexedRepeat,
+    instance,
+    once,
+    position,
+    randomize
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const abs = mathAlias("abs");
@@ -26327,28 +26571,28 @@ const sqrt = mathAlias("sqrt");
 const tan = mathAlias("tan");
 
 const number$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	abs,
-	acos,
-	asin,
-	atan,
-	atan2,
-	cos,
-	exp,
-	exp10,
-	int,
-	log,
-	log10,
-	max,
-	min,
-	number,
-	pi,
-	pow,
-	random,
-	round,
-	sin,
-	sqrt,
-	tan
+    __proto__: null,
+    abs,
+    acos,
+    asin,
+    atan,
+    atan2,
+    cos,
+    exp,
+    exp10,
+    int,
+    log,
+    log10,
+    max,
+    min,
+    number,
+    pi,
+    pow,
+    random,
+    round,
+    sin,
+    sqrt,
+    tan
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const countSelected = new NumberFunction(
@@ -26385,10 +26629,10 @@ const selectedAt = new StringFunction(
 );
 
 const select = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	countSelected,
-	selected,
-	selectedAt
+    __proto__: null,
+    countSelected,
+    selected,
+    selectedAt
 }, Symbol.toStringTag, { value: 'Module' }));
 
 var cryptoJs = {exports: {}};
@@ -26402,8 +26646,8 @@ var core = {exports: {}};
 const __viteBrowserExternal = {};
 
 const __viteBrowserExternal$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	default: __viteBrowserExternal
+    __proto__: null,
+    default: __viteBrowserExternal
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const require$$0 = /*@__PURE__*/getAugmentedNamespace(__viteBrowserExternal$1);
@@ -27675,131 +27919,132 @@ function requireEncUtf16 () {
 
 var encBase64$1 = {exports: {}};
 
-var hasRequiredEncBase64;
-
-function requireEncBase64 () {
-	if (hasRequiredEncBase64) return encBase64$1.exports;
-	hasRequiredEncBase64 = 1;
-	(function (module, exports) {
-		(function (root, factory) {
-		  {
-		    // CommonJS
-		    module.exports = factory(requireCore());
-		  }
-		})(commonjsGlobal, function (CryptoJS) {
-		  (function () {
-		    // Shortcuts
-		    var C = CryptoJS;
-		    var C_lib = C.lib;
-		    var WordArray = C_lib.WordArray;
-		    var C_enc = C.enc;
-
-		    /**
-		     * Base64 encoding strategy.
-		     */
-		    C_enc.Base64 = {
-		      /**
-		       * Converts a word array to a Base64 string.
-		       *
-		       * @param {WordArray} wordArray The word array.
-		       *
-		       * @return {string} The Base64 string.
-		       *
-		       * @static
-		       *
-		       * @example
-		       *
-		       *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
-		       */
-		      stringify: function (wordArray) {
-		        // Shortcuts
-		        var words = wordArray.words;
-		        var sigBytes = wordArray.sigBytes;
-		        var map = this._map;
+(function (module, exports) {
+	(function (root, factory) {
+	  {
+	    // CommonJS
+	    module.exports = factory(requireCore());
+	  }
+	})(commonjsGlobal, function (CryptoJS) {
+	  (function () {
+	    // Shortcuts
+	    var C = CryptoJS;
+	    var C_lib = C.lib;
+	    var WordArray = C_lib.WordArray;
+	    var C_enc = C.enc;
+
+	    /**
+	     * Base64 encoding strategy.
+	     */
+	    C_enc.Base64 = {
+	      /**
+	       * Converts a word array to a Base64 string.
+	       *
+	       * @param {WordArray} wordArray The word array.
+	       *
+	       * @return {string} The Base64 string.
+	       *
+	       * @static
+	       *
+	       * @example
+	       *
+	       *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+	       */
+	      stringify: function (wordArray) {
+	        // Shortcuts
+	        var words = wordArray.words;
+	        var sigBytes = wordArray.sigBytes;
+	        var map = this._map;
+
+	        // Clamp excess bits
+	        wordArray.clamp();
+
+	        // Convert
+	        var base64Chars = [];
+	        for (var i = 0; i < sigBytes; i += 3) {
+	          var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
+	          var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 0xff;
+	          var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 0xff;
+	          var triplet = byte1 << 16 | byte2 << 8 | byte3;
+	          for (var j = 0; j < 4 && i + j * 0.75 < sigBytes; j++) {
+	            base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 0x3f));
+	          }
+	        }
 
-		        // Clamp excess bits
-		        wordArray.clamp();
+	        // Add padding
+	        var paddingChar = map.charAt(64);
+	        if (paddingChar) {
+	          while (base64Chars.length % 4) {
+	            base64Chars.push(paddingChar);
+	          }
+	        }
+	        return base64Chars.join('');
+	      },
+	      /**
+	       * Converts a Base64 string to a word array.
+	       *
+	       * @param {string} base64Str The Base64 string.
+	       *
+	       * @return {WordArray} The word array.
+	       *
+	       * @static
+	       *
+	       * @example
+	       *
+	       *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+	       */
+	      parse: function (base64Str) {
+	        // Shortcuts
+	        var base64StrLength = base64Str.length;
+	        var map = this._map;
+	        var reverseMap = this._reverseMap;
+	        if (!reverseMap) {
+	          reverseMap = this._reverseMap = [];
+	          for (var j = 0; j < map.length; j++) {
+	            reverseMap[map.charCodeAt(j)] = j;
+	          }
+	        }
 
-		        // Convert
-		        var base64Chars = [];
-		        for (var i = 0; i < sigBytes; i += 3) {
-		          var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;
-		          var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 0xff;
-		          var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 0xff;
-		          var triplet = byte1 << 16 | byte2 << 8 | byte3;
-		          for (var j = 0; j < 4 && i + j * 0.75 < sigBytes; j++) {
-		            base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 0x3f));
-		          }
-		        }
+	        // Ignore padding
+	        var paddingChar = map.charAt(64);
+	        if (paddingChar) {
+	          var paddingIndex = base64Str.indexOf(paddingChar);
+	          if (paddingIndex !== -1) {
+	            base64StrLength = paddingIndex;
+	          }
+	        }
 
-		        // Add padding
-		        var paddingChar = map.charAt(64);
-		        if (paddingChar) {
-		          while (base64Chars.length % 4) {
-		            base64Chars.push(paddingChar);
-		          }
-		        }
-		        return base64Chars.join('');
-		      },
-		      /**
-		       * Converts a Base64 string to a word array.
-		       *
-		       * @param {string} base64Str The Base64 string.
-		       *
-		       * @return {WordArray} The word array.
-		       *
-		       * @static
-		       *
-		       * @example
-		       *
-		       *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
-		       */
-		      parse: function (base64Str) {
-		        // Shortcuts
-		        var base64StrLength = base64Str.length;
-		        var map = this._map;
-		        var reverseMap = this._reverseMap;
-		        if (!reverseMap) {
-		          reverseMap = this._reverseMap = [];
-		          for (var j = 0; j < map.length; j++) {
-		            reverseMap[map.charCodeAt(j)] = j;
-		          }
-		        }
+	        // Convert
+	        return parseLoop(base64Str, base64StrLength, reverseMap);
+	      },
+	      _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+	    };
+	    function parseLoop(base64Str, base64StrLength, reverseMap) {
+	      var words = [];
+	      var nBytes = 0;
+	      for (var i = 0; i < base64StrLength; i++) {
+	        if (i % 4) {
+	          var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
+	          var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+	          var bitsCombined = bits1 | bits2;
+	          words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+	          nBytes++;
+	        }
+	      }
+	      return WordArray.create(words, nBytes);
+	    }
+	  })();
+	  return CryptoJS.enc.Base64;
+	}); 
+} (encBase64$1));
 
-		        // Ignore padding
-		        var paddingChar = map.charAt(64);
-		        if (paddingChar) {
-		          var paddingIndex = base64Str.indexOf(paddingChar);
-		          if (paddingIndex !== -1) {
-		            base64StrLength = paddingIndex;
-		          }
-		        }
+var encBase64Exports = encBase64$1.exports;
+const encBase64 = /*@__PURE__*/getDefaultExportFromCjs(encBase64Exports);
 
-		        // Convert
-		        return parseLoop(base64Str, base64StrLength, reverseMap);
-		      },
-		      _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
-		    };
-		    function parseLoop(base64Str, base64StrLength, reverseMap) {
-		      var words = [];
-		      var nBytes = 0;
-		      for (var i = 0; i < base64StrLength; i++) {
-		        if (i % 4) {
-		          var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
-		          var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
-		          var bitsCombined = bits1 | bits2;
-		          words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
-		          nBytes++;
-		        }
-		      }
-		      return WordArray.create(words, nBytes);
-		    }
-		  })();
-		  return CryptoJS.enc.Base64;
-		}); 
-	} (encBase64$1));
-	return encBase64$1.exports;
-}
+const base64 = /*#__PURE__*/_mergeNamespaces({
+    __proto__: null,
+    default: encBase64
+}, [encBase64Exports]);
 
 var encBase64url = {exports: {}};
 
@@ -31306,7 +31551,7 @@ function requireAes () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -31530,7 +31775,7 @@ function requireTripledes () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -32268,7 +32513,7 @@ function requireRc4 () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -32399,7 +32644,7 @@ function requireRabbit () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -32574,7 +32819,7 @@ function requireRabbitLegacy () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -32748,7 +32993,7 @@ function requireBlowfish () {
 		(function (root, factory, undef) {
 		  {
 		    // CommonJS
-		    module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+		    module.exports = factory(requireCore(), encBase64Exports, requireMd5(), requireEvpkdf(), requireCipherCore());
 		  }
 		})(commonjsGlobal, function (CryptoJS) {
 		  (function () {
@@ -32920,7 +33165,7 @@ function requireBlowfish () {
 	(function (root, factory, undef) {
 	  {
 	    // CommonJS
-	    module.exports = factory(requireCore(), requireX64Core(), requireLibTypedarrays(), requireEncUtf16(), requireEncBase64(), requireEncBase64url(), requireMd5(), requireSha1(), requireSha256(), requireSha224(), requireSha512(), requireSha384(), requireSha3(), requireRipemd160(), requireHmac(), requirePbkdf2(), requireEvpkdf(), requireCipherCore(), requireModeCfb(), requireModeCtr(), requireModeCtrGladman(), requireModeOfb(), requireModeEcb(), requirePadAnsix923(), requirePadIso10126(), requirePadIso97971(), requirePadZeropadding(), requirePadNopadding(), requireFormatHex(), requireAes(), requireTripledes(), requireRc4(), requireRabbit(), requireRabbitLegacy(), requireBlowfish());
+	    module.exports = factory(requireCore(), requireX64Core(), requireLibTypedarrays(), requireEncUtf16(), encBase64Exports, requireEncBase64url(), requireMd5(), requireSha1(), requireSha256(), requireSha224(), requireSha512(), requireSha384(), requireSha3(), requireRipemd160(), requireHmac(), requirePbkdf2(), requireEvpkdf(), requireCipherCore(), requireModeCfb(), requireModeCtr(), requireModeCtrGladman(), requireModeOfb(), requireModeEcb(), requirePadAnsix923(), requirePadIso10126(), requirePadIso97971(), requirePadZeropadding(), requirePadNopadding(), requireFormatHex(), requireAes(), requireTripledes(), requireRc4(), requireRabbit(), requireRabbitLegacy(), requireBlowfish());
 	  }
 	})(commonjsGlobal, function (CryptoJS) {
 	  return CryptoJS;
@@ -32929,14 +33174,6 @@ function requireBlowfish () {
 
 var cryptoJsExports = cryptoJs.exports;
 
-var encBase64Exports = requireEncBase64();
-const encBase64 = /*@__PURE__*/getDefaultExportFromCjs(encBase64Exports);
-
-const base64 = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	default: encBase64
-}, [encBase64Exports]);
-
 var encHex$1 = {exports: {}};
 
 (function (module, exports) {
@@ -32954,8 +33191,8 @@ var encHexExports = encHex$1.exports;
 const encHex = /*@__PURE__*/getDefaultExportFromCjs(encHexExports);
 
 const hex = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	default: encHex
+    __proto__: null,
+    default: encHex
 }, [encHexExports]);
 
 const toStrings = (context, expressions) => {
@@ -32986,11 +33223,11 @@ const coalesce = new StringFunction(
 const concat = new StringFunction(
   "concat",
   [{ arityType: "variadic", typeHint: "string" }],
-  (context, expressions) => {
-    if (expressions.length === 0) {
+  (context, args) => {
+    if (args.length === 0) {
       return "";
     }
-    return expressions.flatMap((expression) => {
+    return args.flatMap((expression) => {
       const results = expression.evaluate(context);
       return Array.from(results).map((result) => result.toString());
     }).join("");
@@ -33096,10 +33333,29 @@ const substr = new StringFunction(
     return start <= end ? string.substring(start, end) : "";
   }
 );
+let didAssertCrypto = false;
+const assertCrypto = (crypto) => {
+  if (didAssertCrypto) {
+    return;
+  }
+  if (typeof crypto !== "object" || crypto == null) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  if (typeof crypto.randomUUID !== "function" || crypto.randomUUID.length !== 0) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  didAssertCrypto = true;
+};
+const getGlobalCrypto = () => {
+  const { crypto } = globalThis;
+  assertCrypto(crypto);
+  return crypto;
+};
 const uuid = new StringFunction(
   "uuid",
   [{ arityType: "optional", typeHint: "number" }],
   (context, [lengthExpression]) => {
+    const crypto = getGlobalCrypto();
     let result = crypto.randomUUID();
     if (lengthExpression == null) {
       return result;
@@ -33116,15 +33372,15 @@ const uuid = new StringFunction(
 );
 
 const string = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	coalesce,
-	concat,
-	digest,
-	endsWith,
-	join,
-	regex,
-	substr,
-	uuid
+    __proto__: null,
+    coalesce,
+    concat,
+    digest,
+    endsWith,
+    join,
+    regex,
+    substr,
+    uuid
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const xf = new FunctionLibrary(XFORMS_NAMESPACE_URI, [
@@ -33137,29 +33393,197 @@ const xf = new FunctionLibrary(XFORMS_NAMESPACE_URI, [
   ...Object.values(string)
 ]);
 
+class UpsertableWeakMap extends WeakMap {
+  upsert(key, produce) {
+    if (this.has(key)) {
+      return this.get(key);
+    }
+    const value = produce(key);
+    this.set(key, value);
+    return value;
+  }
+}
+
+class XFormsItextTranslations {
+  constructor(domProvider, translationElementMap) {
+    this.domProvider = domProvider;
+    this.translationElementMap = translationElementMap;
+    this.domProvider = domProvider;
+    this.translationElementMap = translationElementMap;
+    const { defaultLanguage, languages } = this.getTranslationMetadata(
+      domProvider,
+      translationElementMap
+    );
+    this.defaultLanguage = defaultLanguage;
+    this.activeLanguage = defaultLanguage;
+    this.languages = languages;
+  }
+  defaultLanguage = null;
+  languages = [];
+  activeLanguage = null;
+  translationsCache = new UpsertableWeakMap();
+  getTranslationMetadata(domProvider, translationElementMap) {
+    const languages = [];
+    let defaultLanguage = null;
+    for (const [language, element] of translationElementMap) {
+      if (defaultLanguage == null && domProvider.hasLocalNamedAttribute(element, "default")) {
+        defaultLanguage = language;
+        languages.unshift(language);
+      } else {
+        languages.push(language);
+      }
+    }
+    if (defaultLanguage == null) {
+      defaultLanguage = languages[0] ?? null;
+    }
+    return {
+      defaultLanguage,
+      languages
+    };
+  }
+  getTranslationTextElement(itextID) {
+    const activeLanguage = this.getActiveLanguage();
+    if (activeLanguage == null) {
+      return null;
+    }
+    const { domProvider, translationElementMap, translationsCache } = this;
+    const translationElement = translationElementMap.get(activeLanguage);
+    if (translationElement == null) {
+      return null;
+    }
+    const textMap = translationsCache.upsert(translationElement, () => {
+      const textElements = Array.from(
+        domProvider.getChildrenByLocalName(translationElement, "text")
+      );
+      return new Map(
+        textElements.flatMap((element) => {
+          const id = domProvider.getLocalNamedAttributeValue(element, "id");
+          if (id == null) {
+            return [];
+          }
+          return [[id, element]];
+        })
+      );
+    });
+    return textMap.get(itextID) ?? null;
+  }
+  /**
+   * @package
+   *
+   * Here, "default" is meant as more precise language than "regular" as
+   * {@link https://getodk.github.io/xforms-spec/#languages | specified by ODK XForms}. In other words, this is equivalent to the following hypothetical XPath pseudo-code (whitespace added to improve structural clarity):
+   *
+   * ```xpath
+   * string(
+   *   imaginary:itext-translation(
+   *     xpath3-fn:environment-variable('activeLanguage')
+   *   )
+   *     /text[@id = $itextID]
+   *       /value[not(@form)]
+   * )
+   * ```
+   *
+   * Or alternately:
+   *
+   * ```xpath
+   * string(
+   *   imaginary:itext-root()
+   *     /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
+   *       /text[@id = $itextID]
+   *         /value[not(@form)]
+   * )
+   * ```
+   *
+   * @todo The above really feels like it adds some helpful clarity to how `jr:itext()` is designed to work, and the kinds of structures, state and input involved. Since there's already some discomfort around that API as specified, it's worth considering
+   */
+  getDefaultTranslationText(itextID) {
+    const textElement = this.getTranslationTextElement(itextID);
+    if (textElement == null) {
+      return "";
+    }
+    const { domProvider } = this;
+    for (const valueElement of domProvider.getChildrenByLocalName(textElement, "value")) {
+      if (!domProvider.hasLocalNamedAttribute(valueElement, "form")) {
+        return domProvider.getNodeValue(valueElement);
+      }
+    }
+    return "";
+  }
+  getLanguages() {
+    return this.languages;
+  }
+  getActiveLanguage() {
+    return this.activeLanguage;
+  }
+  setActiveLanguage(language) {
+    this.activeLanguage = language ?? this.defaultLanguage;
+    return this.activeLanguage;
+  }
+}
+
 const functions = new FunctionLibraryCollection([enk, xf, fn, jr], {
   defaultNamespaceURIs: [enk.namespaceURI, xf.namespaceURI, fn.namespaceURI]
 });
+const assertInternalXFormsXPathEvaluatorContext = (context) => {
+  const { evaluator } = context;
+  if (evaluator instanceof XFormsXPathEvaluator && /**
+   * This check ensures that we apply consistent DOM adapter access where an
+   * (ODK XForms) XPath expression crosses tree boundaries (e.g. any two of
+   * primary instance, secondary instance, itext translations).
+   *
+   * It's not totally clear whether this check is strictly necessary! Even if
+   * not, it should be cheap enough not to bother finding out.
+   */
+  evaluator.domProvider === context.domProvider) {
+    return;
+  }
+  throw new Error("Expected evaluation context initiated by XFormsXPathEvaluator");
+};
 class XFormsXPathEvaluator extends Evaluator {
+  static getSecondaryInstance(context, id) {
+    assertInternalXFormsXPathEvaluatorContext(context);
+    return context.evaluator.secondaryInstancesById.get(id) ?? null;
+  }
+  static getDefaultTranslationText(context, itextID) {
+    assertInternalXFormsXPathEvaluatorContext(context);
+    return context.evaluator.itextTranslations.getDefaultTranslationText(itextID);
+  }
   rootNode;
-  rootNodeDocument;
-  modelElement;
-  translations;
+  /**
+   * @package
+   * @see {@link InternalXFormsXPathEvaluator}
+   */
+  itextTranslations;
+  /**
+   * @package
+   * @see {@link InternalXFormsXPathEvaluator}
+   */
+  secondaryInstancesById;
   constructor(options) {
     super({
       functions,
       ...options
     });
-    const { rootNode } = options;
-    const rootNodeDocument = rootNode.ownerDocument ?? rootNode;
-    this.modelElement = this.evaluateNode("./h:html/h:head/xf:model", {
-      contextNode: rootNodeDocument
-    });
+    this.secondaryInstancesById = options.secondaryInstancesById;
     this.rootNode = options.rootNode;
-    this.rootNodeDocument = rootNodeDocument;
-    this.translations = new XFormsItextTranslations(this);
+    this.itextTranslations = new XFormsItextTranslations(
+      this.domProvider,
+      options.itextTranslationsByLanguage
+    );
+  }
+  getLanguages() {
+    return this.itextTranslations.getLanguages();
+  }
+  getActiveLanguage() {
+    return this.itextTranslations.getActiveLanguage();
+  }
+  setActiveLanguage(language) {
+    return this.itextTranslations.setActiveLanguage(language);
+  }
+  getSecondaryInstance(id) {
+    return this.secondaryInstancesById.get(id);
   }
 }
 
-export { Evaluator, XFormsXPathEvaluator };
+export { DEFAULT_DOM_ADAPTER, DEFAULT_DOM_PROVIDER, DefaultEvaluator, Evaluator, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XFormsXPathEvaluator, XPathNodeKindKey };
 //# sourceMappingURL=index.js.map