@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/testing.js

@@ -0,0 +1,725 @@
+import { Fi as e, So as t, _ as n, c as r, co as i, d as a, f as o, g as s, h as c, l, m as u, n as d, nt as f, o as ee, p as te, u as ne, x as p, y as m } from "./actions-DK1yfiI8.js";
+import { t as re } from "./routes-DvPNPlQP.js";
+import { AGGREGATION_LIMITS as ie, AggregationDatePart as h, AggregationDateUnit as g, AggregationExpressionOperator as _, AggregationExpressionType as v, AggregationFunction as y, AggregationGroupType as b, AggregationMetricType as x, ComparisonOperator as S, DEFAULT_PAGINATION as ae, DateDiffUnit as C, DeletionState as w, DerivedExpressionType as T, FilterOperator as E, HavingExpressionType as D, SearchMode as oe, SortDirection as O, StringComparison as se, TimeUnit as k } from "@ahoo-wang/wow-client";
+import ce from "dayjs";
+import { Query as le, find as A } from "mingo";
+//#region src/testing/values.ts
+function j(e, t) {
+	return t.split(".").reduce((e, t) => typeof e == "object" && e ? e[t] : void 0, e);
+}
+function M(e) {
+	if (typeof e == "number") return Number.isFinite(e) ? e : null;
+	if (typeof e != "string") return null;
+	let t = ce(e).valueOf();
+	return Number.isFinite(t) ? t : null;
+}
+function N(e) {
+	return Array.isArray(e) ? e.length === 1 ? N(e[0]) : null : typeof e == "number" && Number.isFinite(e) ? e : null;
+}
+function ue(e) {
+	return e == null ? 0 : typeof e == "number" ? 1 : typeof e == "string" ? 2 : Array.isArray(e) ? 4 : typeof e == "object" ? 3 : 5;
+}
+function P(e, t) {
+	let n = ue(e) - ue(t);
+	if (n !== 0) return n;
+	let [r, i] = typeof e == "number" || typeof e == "string" || typeof e == "boolean" ? [e, t] : [JSON.stringify(e), JSON.stringify(t)];
+	return r < i ? -1 : +(r > i);
+}
+function F(e, t) {
+	return (e % t + t) % t;
+}
+//#endregion
+//#region src/testing/calendar.ts
+var I = 36e5, L = 24 * I, de = {
+	[g.HOUR]: I,
+	[g.MINUTE]: 6e4,
+	[g.SECOND]: 1e3
+}, R = /* @__PURE__ */ new Map();
+function z(e, t) {
+	let n = `${e}|${t}`, r = R.get(n);
+	return r || (r = fe(e, t), R.set(n, r)), r;
+}
+function fe(e, t) {
+	if (!Object.values(g).includes(e)) throw Error(`The memory source does not bucket by ${e}.`);
+	let n = V(t), r = /* @__PURE__ */ new Map(), i = (t) => {
+		let i = r.get(Math.floor(t / L))?.find((e) => e.start <= t && t < e.end);
+		if (i) return i;
+		let a = me(t, e, n), o = Math.floor((a.end - 1) / L);
+		for (let e = Math.floor(a.start / L); e <= o; e++) {
+			let t = r.get(e);
+			t ? t.push(a) : r.set(e, [a]);
+		}
+		return a;
+	}, a = de[e];
+	return a === void 0 ? (e) => i(e).bucket : (e) => {
+		let t = i(e);
+		return t.regular ? t.start + Math.floor((e - t.start) / a) * a : e - F(n.wall(e), L) % a;
+	};
+}
+var B = /* @__PURE__ */ new Map();
+function V(e) {
+	let t = B.get(e);
+	if (t) return t;
+	let n = new Intl.DateTimeFormat("en-US", {
+		timeZone: e,
+		hourCycle: "h23",
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric",
+		era: "short"
+	}), r = (e) => {
+		let t = {};
+		for (let { type: r, value: i } of n.formatToParts(e)) t[r] = i;
+		let r = t.era === "BC" ? 1 - Number(t.year) : Number(t.year), i = /* @__PURE__ */ new Date(0);
+		return i.setUTCFullYear(r, Number(t.month) - 1, Number(t.day)), i.setUTCHours(Number(t.hour), Number(t.minute), Number(t.second), F(e, 1e3)), i.getTime();
+	};
+	return t = {
+		wall: r,
+		instant: (e) => pe(e, r)
+	}, B.set(e, t), t;
+}
+function pe(e, t) {
+	let n = t(e - L) - (e - L), r = t(e + L) - (e + L);
+	return [e - n, e - r].filter((n) => t(n) === e).sort((e, t) => e - t)[0] ?? e - n;
+}
+function me(e, t, n) {
+	let r = n.wall(e) - F(n.wall(e), L), i = n.instant(r), a = n.instant(r + L);
+	return {
+		start: i,
+		end: a,
+		regular: a - i === L && n.wall(i) - i === n.wall(a - 1) - (a - 1),
+		bucket: he(r, i, t, n)
+	};
+}
+function he(e, t, n, r) {
+	let i = new Date(e), a = i.getUTCFullYear(), o = i.getUTCMonth(), s = (e) => {
+		let t = /* @__PURE__ */ new Date(0);
+		return t.setUTCFullYear(a, e, 1), r.instant(t.getTime());
+	};
+	switch (n) {
+		case g.WEEK: return r.instant(e - (i.getUTCDay() + 6) % 7 * L);
+		case g.MONTH: return s(o);
+		case g.QUARTER: return s(o - o % 3);
+		case g.YEAR: return s(0);
+		default: return t;
+	}
+}
+function H(e) {
+	return e.timeZone ?? "UTC";
+}
+var ge = {
+	[h.DAY_OF_WEEK]: [1, 7],
+	[h.HOUR_OF_DAY]: [0, 23],
+	[h.DAY_OF_MONTH]: [1, 31],
+	[h.MONTH_OF_YEAR]: [1, 12]
+};
+function _e(e, t) {
+	if (!Object.values(h).includes(e)) throw Error(`The memory source does not read the date part ${e}.`);
+	let n = V(t);
+	return (t) => {
+		let r = new Date(n.wall(t));
+		switch (e) {
+			case h.DAY_OF_WEEK: return r.getUTCDay() === 0 ? 7 : r.getUTCDay();
+			case h.HOUR_OF_DAY: return r.getUTCHours();
+			case h.DAY_OF_MONTH: return r.getUTCDate();
+			case h.MONTH_OF_YEAR: return r.getUTCMonth() + 1;
+		}
+	};
+}
+var U = 1e5, ve = {
+	[g.SECOND]: [1e3, 1e3],
+	[g.MINUTE]: [6e4, 6e4],
+	[g.HOUR]: [9e5, 9e5],
+	[g.DAY]: [22 * I, I],
+	[g.WEEK]: [166 * I, I],
+	[g.MONTH]: [27 * L, I],
+	[g.QUARTER]: [88 * L, I],
+	[g.YEAR]: [364 * L, I]
+};
+function ye(e, t) {
+	if (e.length === 0) return [];
+	let n = [...e].sort((e, t) => e - t), r = n[n.length - 1], i = z(t.unit, H(t)), [a, o] = ve[t.unit], s = [];
+	for (let e = n[0];;) {
+		if (s.push(e), s.length > U) throw Error(`The memory source fills at most ${U} dense buckets.`);
+		if (e >= r) break;
+		let t = e + a;
+		for (; i(t) <= e;) t += o;
+		e = i(t);
+	}
+	return s;
+}
+//#endregion
+//#region src/testing/expression.ts
+var be = {
+	[C.SECOND]: 1e3,
+	[C.MINUTE]: 6e4,
+	[C.HOUR]: 36e5,
+	[C.DAY]: 864e5
+};
+function W(e, t, n) {
+	switch (e) {
+		case _.ADD: return t + n;
+		case _.SUBTRACT: return t - n;
+		case _.MULTIPLY: return t * n;
+		case _.DIVIDE: return n === 0 ? null : t / n;
+		default: throw Error(`The memory source does not compute ${String(e)}.`);
+	}
+}
+function G(e, t) {
+	let n = (e) => e !== null && Number.isFinite(e) ? e : null;
+	switch (e.type) {
+		case v.FIELD: return N(j(t, e.field));
+		case v.CONSTANT: return n(e.value);
+		case v.BINARY: {
+			let r = G(e.left, t), i = G(e.right, t);
+			return r === null || i === null ? null : n(W(e.operator, r, i));
+		}
+		case v.DATE_DIFF: {
+			let n = be[e.unit];
+			if (n === void 0) throw Error(`The memory source does not measure in ${e.unit}.`);
+			let r = M(j(t, e.from)), i = M(j(t, e.to));
+			return r === null || i === null ? null : (i - r) / n;
+		}
+		default: throw Error(`The memory source does not compute the expression ${e.type}.`);
+	}
+}
+//#endregion
+//#region src/testing/filter.ts
+function xe(e, t, n = {}) {
+	return new le(K(q(t, n.now))).test(e);
+}
+function Se(e, t, n) {
+	switch (e) {
+		case S.EQ: return t === n;
+		case S.NE: return t !== n;
+		case S.GT: return t > n;
+		case S.GTE: return t >= n;
+		case S.LT: return t < n;
+		case S.LTE: return t <= n;
+		default: throw Error(`The memory source does not compare with ${String(e)}.`);
+	}
+}
+function Ce(e) {
+	return we(e) ? K(e) : { $and: [K(e), { deleted: { $ne: !0 } }] };
+}
+function we(e) {
+	switch (e.op) {
+		case E.DELETION: return !0;
+		case E.AND:
+		case E.OR:
+		case E.NOR: return e.operands.some(we);
+		default: return !1;
+	}
+}
+var Te = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function K(e) {
+	switch (e.op) {
+		case E.MATCH_ALL: return {};
+		case E.MATCH_NONE: return { $nor: [{}] };
+		case E.EXPRESSION: {
+			let { expression: t, comparison: n, value: r } = e;
+			return { $where: function() {
+				let e = G(t, this);
+				return e !== null && Se(n, e, r);
+			} };
+		}
+		case E.AND:
+		case E.OR:
+		case E.NOR: return { [`$${e.op.toLowerCase()}`]: e.operands.map(K) };
+		case E.EQ:
+		case E.NE:
+		case E.GT:
+		case E.GTE:
+		case E.LT:
+		case E.LTE: return { [e.field]: { [`$${e.op.toLowerCase()}`]: e.value } };
+		case E.BETWEEN: return { [e.field]: {
+			$gte: e.lowerBound,
+			$lte: e.upperBound
+		} };
+		case E.IN: return { [e.field]: { $in: e.values } };
+		case E.NOT_IN: return { [e.field]: { $nin: e.values } };
+		case E.CONTAINS_ALL: return { [e.field]: { $all: e.values } };
+		case E.AGGREGATE_ID: return { aggregateId: { $eq: e.value } };
+		case E.AGGREGATE_IDS: return { aggregateId: { $in: e.values } };
+		case E.OWNER_ID: return { ownerId: { $eq: e.value } };
+		case E.CONTAINS:
+		case E.STARTS_WITH:
+		case E.ENDS_WITH: {
+			let t = Te(e.value), n = e.op === E.STARTS_WITH ? `^${t}` : e.op === E.ENDS_WITH ? `${t}$` : t, r = e.stringComparison === se.CASE_INSENSITIVE ? "i" : "";
+			return { [e.field]: new RegExp(n, r) };
+		}
+		case E.IS_EMPTY: return { [e.field]: { $size: 0 } };
+		case E.IS_NULL: return { [e.field]: { $eq: null } };
+		case E.IS_NOT_NULL: return { [e.field]: { $ne: null } };
+		case E.IS_EMPTY_STRING: return { [e.field]: { $eq: "" } };
+		case E.IS_NOT_EMPTY_STRING: return { $and: [{ [e.field]: { $ne: null } }, { [e.field]: { $ne: "" } }] };
+		case E.EXISTS: return { [e.field]: { $exists: !0 } };
+		case E.NOT_EXISTS: return { [e.field]: { $exists: !1 } };
+		case E.DELETION: return e.state === w.ALL ? {} : { deleted: { $eq: e.state === w.DELETED } };
+		case E.SEARCH: {
+			if (!e.fields?.length) throw Error("The memory source searches named fields only.");
+			let t = e.mode === oe.PHRASE ? [e.query.trim()] : e.query.trim().split(/\s+/);
+			return { $or: e.fields.flatMap((e) => t.map((t) => ({ [String(e)]: new RegExp(Te(t), "i") }))) };
+		}
+		case E.ELEMENT_MATCH: return { [e.field]: { $elemMatch: K(e.predicate) } };
+		default: throw Error(`The memory source does not evaluate ${e.op}.`);
+	}
+}
+function q(e, t = Date.now) {
+	let n, r = (e) => {
+		if (Array.isArray(e)) return e.map(r);
+		if (typeof e != "object" || !e || e instanceof RegExp) return e;
+		let i = e.op;
+		return i === E.BEFORE_NOW || i === E.AFTER_NOW ? (n ??= t(), De(e, n)) : Object.fromEntries(Object.entries(e).map(([e, t]) => [e, r(t)]));
+	};
+	return r(e);
+}
+var Ee = {
+	[k.NANOSECONDS]: 1e6,
+	[k.MICROSECONDS]: 1e3,
+	[k.MILLISECONDS]: 1,
+	[k.SECONDS]: 1 / 1e3,
+	[k.MINUTES]: 1 / 6e4,
+	[k.HOURS]: 1 / 36e5,
+	[k.DAYS]: 1 / 864e5
+};
+function De(e, t) {
+	if (e.datePattern !== void 0) throw Error("The memory source keeps times as epoch numbers, not as formatted text.");
+	let n = t + ke(e.offset ?? "PT0S"), r = e.timeUnit ?? k.MILLISECONDS;
+	return {
+		op: e.op === E.BEFORE_NOW ? E.LT : E.GT,
+		field: e.field,
+		value: Math.trunc(n * Ee[r])
+	};
+}
+var Oe = /^([-+]?)P(?:([-+]?\d+)D)?(?:T(?=[-+]?\d)(?:([-+]?\d+)H)?(?:([-+]?\d+)M)?(?:([-+]?\d+)(?:[.,](\d{0,9}))?S)?)?$/i;
+function ke(e) {
+	let t = Oe.exec(e);
+	if (!t || t.slice(2, 6).every((e) => e === void 0)) throw Error(`The memory source does not read the duration ${e}.`);
+	let [, n, r, i, a, o, s] = t, c = Number(`0.${s ?? "0"}`) * 1e3 * (o?.startsWith("-") ? -1 : 1), l = Number(r ?? 0) * 864e5 + Number(i ?? 0) * 36e5 + Number(a ?? 0) * 6e4 + Number(o ?? 0) * 1e3 + c;
+	return n === "-" ? -l : l;
+}
+//#endregion
+//#region src/testing/aggregate.ts
+function Ae(e, t) {
+	let n = je(e, t), r = t.groupBy ?? [], i = Me(r), a = t.metrics.filter((e) => e.type !== x.DERIVED), o = a.map((e) => {
+		let t = "filter" in e ? e.filter : void 0;
+		return t ? new le(K(t)) : void 0;
+	}), s = r.map(Ne), c = /* @__PURE__ */ new Map();
+	r.length === 0 && c.set("[]", {
+		keys: [],
+		units: []
+	});
+	let l = i ? r.indexOf(i) : -1;
+	for (let e of n) {
+		let t = s.map((t) => t(e));
+		if (l >= 0 && t[l] === null) continue;
+		let n = JSON.stringify(t), r = c.get(n);
+		r || c.set(n, r = {
+			keys: t,
+			units: []
+		}), r.units.push(e);
+	}
+	let u = [...c.values()].map(({ keys: e, units: t }) => Pe(r, e, a, o, t));
+	return i && (u = Be(u, i, a)), u = u.map((e) => Ve(e, t.metrics)), t.having && (u = u.filter((e) => Y(t.having, e))), u = He(u, t.sort ?? [], r), u.slice(0, t.limit ?? ie.DEFAULT_LIMIT);
+}
+function je(e, t) {
+	let n = [...e];
+	for (let e of t.elements ?? []) n = n.flatMap((t) => {
+		let n = j(t, e.path);
+		return Array.isArray(n) ? n.filter((e) => typeof e == "object" && !!e && !Array.isArray(e)) : [];
+	}), e.filter && (n = A(n, K(e.filter)).all());
+	return n;
+}
+function Me(e) {
+	let t = e.find((e) => (e.type === b.DATE_HISTOGRAM || e.type === b.DATE_PART) && e.dense === !0);
+	if (t && e.length > 1) throw Error(`The memory source fills a dense ${t.type} only when it is the only group.`);
+	return t;
+}
+function Ne(e) {
+	switch (e.type) {
+		case b.TERMS: {
+			let { field: t, expression: n, missingKey: r } = e;
+			return (e) => (t === void 0 ? G(n, e) : j(e, t)) ?? r ?? null;
+		}
+		case b.HISTOGRAM: {
+			let { field: t, expression: n, interval: r } = e;
+			return (e) => {
+				let i = t === void 0 ? G(n, e) : j(e, t);
+				return typeof i == "number" && Number.isFinite(i) ? Math.floor(i / r) * r : null;
+			};
+		}
+		case b.DATE_HISTOGRAM: {
+			let t = z(e.unit, H(e));
+			return (n) => {
+				let r = M(j(n, e.field));
+				return r === null ? null : t(r);
+			};
+		}
+		case b.DATE_PART: {
+			let t = _e(e.part, H(e));
+			return (n) => {
+				let r = M(j(n, e.field));
+				return r === null ? null : t(r);
+			};
+		}
+		default: throw Error(`The memory source does not group by ${e.type}.`);
+	}
+}
+function Pe(e, t, n, r, i) {
+	let a = {};
+	return e.forEach((e, n) => a[e.alias] = t[n]), n.forEach((e, t) => {
+		let n = r[t];
+		a[e.alias] = Fe(e, n ? i.filter((e) => n.test(e)) : i);
+	}), a;
+}
+function Fe(e, t) {
+	switch (e.type) {
+		case x.COUNT: return t.length;
+		case x.NUMERIC:
+		case x.PERCENTILE: {
+			if (e.type === x.NUMERIC && (e.function === y.MIN || e.function === y.MAX) && e.expression.type === v.FIELD) return Ie(t, e.expression.field, e.function === y.MAX);
+			let n = t.map((t) => G(e.expression, t)).filter((e) => e !== null);
+			return n.length === 0 ? null : e.type === x.PERCENTILE ? Re(n, e.percentile) : Le(n, e.function);
+		}
+		case x.DISTINCT_COUNT: {
+			let { expression: n } = e, r = /* @__PURE__ */ new Set();
+			for (let e of t) {
+				let t = n.type === v.FIELD ? j(e, n.field) : G(n, e);
+				for (let e of Array.isArray(t) ? t : [t]) e != null && r.add(JSON.stringify(e));
+			}
+			return r.size;
+		}
+		case x.ANY: {
+			let n = null;
+			for (let r of t) {
+				let t = j(r, e.field);
+				t != null && (n === null || P(t, n) > 0) && (n = t);
+			}
+			return n;
+		}
+		case x.FIRST:
+		case x.LAST: {
+			let n = e.type === x.FIRST, r;
+			for (let i of t) {
+				let t = M(j(i, e.orderBy ?? "eventTime")), a = j(i, e.field);
+				t !== null && a != null && (!r || (n ? t < r.at : t > r.at)) && (r = {
+					at: t,
+					value: a
+				});
+			}
+			return r ? r.value : null;
+		}
+		default: throw Error(`The memory source does not compute ${e.alias}.`);
+	}
+}
+function Ie(e, t, n) {
+	let r = null;
+	for (let i of e) {
+		let e = j(i, t), a = typeof e == "string" ? e : N(e);
+		if (a === null) continue;
+		let o = r === null ? 1 : P(a, r);
+		(n ? o > 0 : o < 0 || r === null) && (r = a);
+	}
+	return r;
+}
+function Le(e, t) {
+	let n = e.reduce((e, t) => e + t, 0), r = n / e.length, i;
+	switch (t) {
+		case y.SUM:
+			i = n;
+			break;
+		case y.AVG:
+			i = r;
+			break;
+		case y.MIN:
+			i = Math.min(...e);
+			break;
+		case y.MAX:
+			i = Math.max(...e);
+			break;
+		case y.STDDEV:
+		case y.VARIANCE: {
+			let n = e.reduce((e, t) => e + (t - r) ** 2, 0) / e.length;
+			i = t === y.VARIANCE ? n : Math.sqrt(n);
+			break;
+		}
+		default: throw Error(`The memory source does not compute ${String(t)}.`);
+	}
+	return Number.isFinite(i) ? i : null;
+}
+function Re(e, t) {
+	let n = [...e].sort((e, t) => e - t), r = (n.length - 1) * t / 100, i = Math.floor(r), a = Math.min(i + 1, n.length - 1);
+	return n[i] + (r - i) * (n[a] - n[i]);
+}
+function ze(e) {
+	return Object.fromEntries(e.map((e) => [e.alias, Fe(e, [])]));
+}
+function Be(e, t, n) {
+	let r = new Map(e.map((e) => [e[t.alias], e])), i;
+	if (t.type === b.DATE_PART) {
+		let [e, n] = ge[t.part];
+		i = Array.from({ length: n - e + 1 }, (t, n) => e + n);
+	} else i = ye([...r.keys()], t);
+	return i.map((e) => r.get(e) ?? {
+		[t.alias]: e,
+		...ze(n)
+	});
+}
+function Ve(e, t) {
+	let n = { ...e };
+	for (let e of t) e.type === x.DERIVED && (n[e.alias] = J(e.expression, n));
+	return n;
+}
+function J(e, t) {
+	switch (e.type) {
+		case T.CONSTANT: return e.value;
+		case T.METRIC_REF: {
+			let n = t[e.metric];
+			return typeof n == "number" && Number.isFinite(n) ? n : null;
+		}
+		case T.BINARY: {
+			let n = J(e.left, t), r = J(e.right, t);
+			if (n === null || r === null) return null;
+			let i = W(e.operator, n, r);
+			return i !== null && Number.isFinite(i) ? i : null;
+		}
+		default: throw Error(`The memory source does not derive ${e.type}.`);
+	}
+}
+function Y(e, t) {
+	let n = (e) => {
+		let n = t[e];
+		return typeof n == "number" && Number.isFinite(n) ? n : null;
+	};
+	switch (e.type) {
+		case D.AND: return e.operands.every((e) => Y(e, t));
+		case D.OR: return e.operands.some((e) => Y(e, t));
+		case D.CONDITION: {
+			let t = n(e.metric);
+			return t !== null && Se(e.operator, t, e.value);
+		}
+		case D.BETWEEN: {
+			let t = n(e.metric);
+			return t !== null && t >= e.lower && t <= e.upper;
+		}
+		case D.IN: {
+			let t = n(e.metric);
+			return t !== null && e.values.includes(t);
+		}
+		case D.IS_NULL: return n(e.metric) === null != (e.negated === !0);
+		default: throw Error(`The memory source does not evaluate ${e.type}.`);
+	}
+}
+function He(e, t, n) {
+	let r = new Set(t.map(({ field: e }) => e)), i = [...t.map(({ field: e, direction: t }) => ({
+		field: e,
+		sign: t === O.DESC ? -1 : 1
+	})), ...n.filter(({ alias: e }) => !r.has(e)).map(({ alias: e }) => ({
+		field: e,
+		sign: 1
+	}))];
+	return i.length === 0 ? [...e] : [...e].sort((e, t) => {
+		for (let { field: n, sign: r } of i) {
+			let i = P(e[n], t[n]);
+			if (i !== 0) return i * r;
+		}
+		return 0;
+	});
+}
+//#endregion
+//#region src/testing/source.ts
+var Ue = 512;
+function We(e, t = {}) {
+	let n = Ke(e, t.timeField), r = /* @__PURE__ */ new Map(), i = t.now;
+	return {
+		paged: (e) => X(() => {
+			let t = q(e, i), r = Z(n, t.filter, t.sort), { index: a, size: o } = t.pagination ?? ae, s = (a - 1) * o;
+			return {
+				total: r.length,
+				list: r.slice(s, s + o).map(Je(t))
+			};
+		}),
+		cursor: (e) => X(() => {
+			let t = q(e, i), r = Z(n, t.filter, t.sort), a = Number(t.cursor ?? 0), o = a + (t.size ?? r.length);
+			return {
+				list: r.slice(a, o).map(Je(t)),
+				nextCursor: o < r.length ? String(o) : null
+			};
+		}),
+		aggregate: (e) => X(() => {
+			let a = q(e, i);
+			if (!t.remember) return Ge(n, a);
+			let o = JSON.stringify(a), s = r.get(o);
+			return s || (s = Ge(n, a), r.size >= Ue && r.clear(), r.set(o, s)), structuredClone(s);
+		})
+	};
+}
+function X(e) {
+	return new Promise((t) => t(e()));
+}
+function Ge(e, t) {
+	return Ae(Z(e, t.filter ?? { op: E.MATCH_ALL }), t);
+}
+function Ke(e, t) {
+	if (t === void 0) return { documents: [...e] };
+	let n = e.map((e) => {
+		let n = j(e, t);
+		if (typeof n != "number" || !Number.isFinite(n)) throw Error(`The memory source keeps ${t} as epoch milliseconds; a document holds ${String(n)}.`);
+		return {
+			document: e,
+			at: n
+		};
+	});
+	return n.sort((e, t) => e.at - t.at), {
+		documents: n.map(({ document: e }) => e),
+		timeField: t,
+		times: Float64Array.from(n, ({ at: e }) => e)
+	};
+}
+function Z(e, t, n = []) {
+	let r = A(Ye(e, t), Ce(t));
+	return (n.length > 0 ? r.sort(qe(n)) : r).all();
+}
+function qe(e) {
+	return Object.fromEntries(e.map(({ field: e, direction: t }) => [e, t === O.DESC ? -1 : 1]));
+}
+function Je(e) {
+	let t = e.projection?.include;
+	if (!t || t.length === 0) return (e) => e;
+	let n = Object.fromEntries(t.map((e) => [e, 1]));
+	return (e) => A([e], {}, n).all()[0] ?? {};
+}
+function Ye(e, t) {
+	let { documents: n, timeField: r, times: i } = e;
+	if (r === void 0 || !i) return n;
+	let a = 0, o = n.length;
+	for (let e of Q(t)) if ("field" in e && e.field === r) switch (e.op) {
+		case E.GT:
+		case E.GTE:
+		case E.LT:
+		case E.LTE:
+		case E.EQ: {
+			let { op: t, value: n } = e;
+			if (typeof n != "number" || !Number.isFinite(n)) break;
+			t !== E.LT && t !== E.LTE && (a = Math.max(a, $(i, n, t === E.GT))), t !== E.GT && t !== E.GTE && (o = Math.min(o, $(i, n, t !== E.LT)));
+			break;
+		}
+		case E.BETWEEN: {
+			let { lowerBound: t, upperBound: n } = e;
+			typeof t == "number" && Number.isFinite(t) && (a = Math.max(a, $(i, t, !1))), typeof n == "number" && Number.isFinite(n) && (o = Math.min(o, $(i, n, !0)));
+			break;
+		}
+	}
+	return a === 0 && o === n.length ? n : a < o ? n.slice(a, o) : [];
+}
+function Q(e) {
+	return e.op === E.AND ? e.operands.flatMap(Q) : [e];
+}
+function $(e, t, n) {
+	let r = 0, i = e.length;
+	for (; r < i;) {
+		let a = r + i >>> 1;
+		(n ? e[a] <= t : e[a] < t) ? r = a + 1 : i = a;
+	}
+	return r;
+}
+//#endregion
+//#region src/runtime/admission.ts
+function Xe(n, r, a = {}) {
+	let o = a.kinds ?? e, s = {
+		...t,
+		...a.limits
+	}, c = (e) => a.text?.(e), l = n.map((e) => m("definition" in e ? e.definition : e, c)), u = /* @__PURE__ */ new Map(), d = new Map(l.map(({ definition: e }) => [e.id, e]));
+	for (let { definition: e, findings: t } of l) {
+		if (u.set(e.id, [...t]), e.kind !== "data") continue;
+		let n = r[e.source];
+		if (!n) {
+			u.get(e.id)?.push(i("definition.descriptor.missing", ["source"], { source: e.source }, "warning"));
+			continue;
+		}
+		u.get(e.id)?.push(...f(e, n, o).findings);
+	}
+	return l.flatMap(({ definition: e }) => [...u.get(e.id) ?? [], ...p(e, o, {
+		limits: s,
+		definitions: (e) => d.get(e)
+	})].map((t) => ({
+		...t,
+		definition: e.id
+	})));
+}
+//#endregion
+//#region src/testing/actions.ts
+function Ze(e, t, { now: i = Date.now() } = {}) {
+	let d = new Map(t.map((e) => [e.key, e])), f = (t) => {
+		let n = e.find((e) => e.id === t);
+		if (!n) throw Error(`No action "${t}".`);
+		return n;
+	}, p = (e, t = {}) => ({
+		...a(e),
+		...t
+	}), m = (e) => {
+		let t = d.get(e);
+		if (!t) throw Error(`No record "${String(e)}".`);
+		return t;
+	};
+	return {
+		ids: e.map((e) => e.id),
+		at: (t) => u(e, t).map((e) => e.id),
+		state: (e, t, n) => {
+			let r = f(e);
+			return ee(r, m(t), n ? {
+				now: i,
+				input: p(r, n)
+			} : { now: i });
+		},
+		bulk(e, r = t.map((e) => e.key), a) {
+			let o = f(e), s = n(o, r, (e) => d.get(e), a ? {
+				now: i,
+				input: p(o, a)
+			} : { now: i });
+			return {
+				...s,
+				reasons: c(s.refused).map(({ reason: e, keys: t }) => ({
+					reason: e,
+					count: t.length,
+					keys: t
+				}))
+			};
+		},
+		asks(e, t, n) {
+			let i = f(e), a = p(i, n);
+			return {
+				asks: r(i, t, a),
+				confirm: ne(i, a)
+			};
+		},
+		form(e) {
+			let t = f(e).form;
+			return t ? Object.entries(t).map(([e, t]) => ({
+				name: e,
+				label: t.label,
+				input: t.options ? "select" : t.input ?? "text",
+				options: t.options ?? null,
+				required: t.required !== !1
+			})) : null;
+		},
+		choice: (e) => l(f(e))?.options ?? null,
+		missing: (e, t) => {
+			let n = f(e);
+			return o(n, p(n, t));
+		},
+		changesAt: (n) => te(e, n === void 0 ? t : [m(n)], i),
+		run: (e, t, n) => {
+			let r = f(e);
+			return s(r, d.get(t), p(r, n), i);
+		}
+	};
+}
+//#endregion
+export { d as ActionRefusedError, Ze as actionHarness, Xe as admit, xe as matches, We as memorySource, re as resolveNavigation };
+
+//# sourceMappingURL=testing.js.map