@rotorjs/jpl 0.0.0

package/dist/main.js

@@ -0,0 +1,3644 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, n) => {
+	let r = {};
+	for (var i in e) t(r, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return n || t(r, Symbol.toStringTag, { value: "Module" }), r;
+}, c = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, l = (n, r, a) => (a = n == null ? {} : e(i(n)), c(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n));
+//#endregion
+//#region node_modules/@jplorg/jpl/src/createSingleton.js
+function u(e) {
+	let t;
+	return () => (t ??= e(), t);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/applyDefaults.js
+function d(e, t, ...n) {
+	let r = (e, t, n) => {
+		if (Array.isArray(e)) return e;
+		if (typeof e == "object") {
+			if (e === null || Array.isArray(t) || typeof t != "object" || !t) return e;
+			let i = { ...e }, a = n.some((e) => e.length === 0);
+			return Object.keys({
+				...e,
+				...t
+			}).forEach((e) => {
+				a ? Object.hasOwn(i, e) || (i[e] = t[e]) : i[e] = r(i[e], t[e], n.filter((t) => t[0] === e).map((e) => e.slice(1))), i[e] === void 0 && delete i[e];
+			}), i;
+		}
+		return e === void 0 ? t : e;
+	};
+	return r(e, t, n.map((e) => typeof e == "string" ? e.split(".") : e));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/apply.js
+function f(e, t) {
+	let n = e, r = !0;
+	return t.forEach((e) => {
+		let [t, i] = e;
+		if (e.length === 1) {
+			if (!Object.hasOwn(n, t)) return;
+			if (r) {
+				let e;
+				({[t]: e, ...n} = n), r = !1;
+			} else delete n[t];
+			return;
+		}
+		Object.hasOwn(n, t) && n[t] === i || (r ? (n = {
+			...n,
+			[t]: i
+		}, r = !1) : n[t] = i);
+	}), n;
+}
+function p(e, t, n = null) {
+	let r = e, i = !0;
+	return t.forEach((e) => {
+		let [t, a] = e, o = t >= 0 ? t : r.length + t;
+		if (!(o >= 0 && o < r.length && r[o] === a)) {
+			if (t >= 0) {
+				let e = o + 1 - r.length;
+				e > 0 && (r = [...r, ...Array(e).fill(n)], i = !1);
+			} else {
+				let e = -o;
+				e > 0 && (r = [...Array(e).fill(n), ...r], i = !1, o = 0);
+			}
+			i &&= (r = [...r], !1), r[o] = a;
+		}
+	}), r;
+}
+function m(e, t) {
+	let n = t.length, r = 1, i = t.map((e) => {
+		let t = e.length;
+		return r *= t, [
+			t,
+			0,
+			e
+		];
+	});
+	if (r === 0) return [];
+	let a = e, o = e.length;
+	o !== n && (a = o > n ? a.slice(0, n) : [...a, ...Array(n - o)]);
+	let s = Array(r), c = 0;
+	for (;;) {
+		let e = a, t = !0;
+		if (i.forEach(([, n, r], i) => {
+			let a = r[n];
+			e[i] !== a && (t &&= (e = [...e], !1), e[i] = a);
+		}), s[c] = e, c += 1, c >= r) break;
+		for (let e = n - 1; e >= 0; --e) {
+			let t = i[e], [n, r] = t, a = r + 1;
+			if (a < n) {
+				t[1] = a;
+				break;
+			}
+			t[1] = 0;
+		}
+	}
+	return s;
+}
+var h = "1.0", g = class extends Error {
+	static is(e) {
+		return e instanceof this;
+	}
+	constructor(e, t = "JPLError") {
+		super(e), this.name = t;
+	}
+}, _ = class extends g {
+	constructor(e, t = "JPLExecutionError") {
+		super(e, t), this.value = typeof e == "string" && e ? e : null;
+	}
+};
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/errors/adaptErrors.js
+function ee(e) {
+	try {
+		return e();
+	} catch (e) {
+		throw v(e);
+	}
+}
+async function te(e) {
+	try {
+		return await e();
+	} catch (e) {
+		throw v(e);
+	}
+}
+function v(e) {
+	return g.is(e) ? e : new _(e.message);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/errors/enclosure.js
+var y = class extends g {
+	constructor(e) {
+		super(e, "JPLErrorEnclosure"), this.inner = e;
+	}
+}, b = class extends g {
+	constructor(e) {
+		super(e, "JPLFatalError");
+	}
+}, x = class {
+	static is(e) {
+		return e instanceof this;
+	}
+	constructor(e) {
+		this._v = ne(e);
+	}
+	get value() {
+		return this._v;
+	}
+	get json() {
+		return this._v;
+	}
+	async alter(e) {
+		return S(await e(this.value));
+	}
+	toJSON() {
+		try {
+			return this.json;
+		} catch (e) {
+			throw v(e);
+		}
+	}
+};
+function ne(e) {
+	return x.is(e) ? e.value : S(e);
+}
+function S(e) {
+	return O(e, void 0, oe);
+}
+function C(e) {
+	return x.is(e) ? ee(() => e.value) : e;
+}
+var re = [
+	"null",
+	"function",
+	"boolean",
+	"number",
+	"string",
+	"array",
+	"object"
+];
+function ie(e) {
+	let t = C(e);
+	if (t === null) return "null";
+	if (Array.isArray(t)) return "array";
+	let n = typeof t;
+	switch (n) {
+		case "function":
+		case "boolean":
+		case "number":
+		case "string":
+		case "object": return n;
+		default: throw new b(`invalid type ${n} (${e})`);
+	}
+}
+function w(e, t) {
+	if (x.is(e)) throw new b(E("unexpected type: JPLTypes (%*<100v) are not allowed here", e));
+	let n = ie(e);
+	if (n !== t) throw new b(E("unexpected type: %s (%*<100v) cannot be used as %s", n, e, t));
+	return e;
+}
+function T(e, t, n) {
+	let r = n ? O(e, (e, t) => typeof C(t) == "function" ? "<function>" : t) : O(e);
+	return t && typeof r == "string" ? r : JSON.stringify(r);
+}
+function E(e, ...t) {
+	let n = 0;
+	return D(e).replace(/%([*\-<]+)?([1-9][0-9]*)?(.)/g, (e, r, i, a) => {
+		switch (a) {
+			case "%": return "%";
+			default:
+		}
+		let o = t[n] ?? null;
+		n += 1;
+		let s;
+		switch (a) {
+			case "s":
+				s = D(o);
+				break;
+			case "v":
+				s = ae(o);
+				break;
+			default: throw new b(`format ${e} has unknown verb ${a}`);
+		}
+		let c = !0, l = !1, u = !1;
+		[...r ?? []].forEach((t) => {
+			switch (t) {
+				case "*":
+					c = !1;
+					break;
+				case "-":
+					l = !0;
+					break;
+				case "<":
+					u = !0;
+					break;
+				default: throw new b(`format ${e} has unknown flag ${t}`);
+			}
+		});
+		let d = +(i ?? 0);
+		if (d > 0) {
+			let e = [...s].length;
+			if (c && e < d) {
+				let t = " ".repeat(d - e);
+				s = l ? `${s}${t}` : `${t}${s}`;
+			} else u && e > d && (s = `${s.substring(0, d - 1)}…`);
+		}
+		return s;
+	});
+}
+function D(e) {
+	return T(e, !0, !0);
+}
+function ae(e) {
+	return T(e, !1, !0);
+}
+function O(e, t, n = ce) {
+	let r = (e, i) => {
+		let a = i;
+		return t && (a = t(e ?? "", a)), n(e, a, r);
+	};
+	return r(null, e);
+}
+function oe(e, t, n) {
+	return x.is(t) || typeof t == "function" ? t : k(e, t, n);
+}
+function se(e, t, n) {
+	let r = t;
+	return x.is(r) && (r = r.toJSON()), typeof r == "function" ? r : k(e, r, n);
+}
+function ce(e, t, n) {
+	let r = t;
+	return x.is(r) && (r = r.toJSON()), k(e, r, n);
+}
+function le(e, t, n) {
+	let r = t;
+	return typeof r?.toJSON == "function" && (r = r.toJSON()), k(e, r, n);
+}
+function k(e, t, n) {
+	let r = e == null, i = typeof t;
+	switch (i) {
+		case "string":
+		case "boolean": return t;
+		case "number": return Number.isFinite(t) ? t : null;
+		case "undefined":
+		case "function": return r ? null : void 0;
+		case "object": return t === null ? null : Array.isArray(t) ? p(t, Array.from(Array(t.length), (e, r) => [r, n(`${r}`, t[r]) ?? null])) : f(t, Object.entries(t).map(([e, t]) => {
+			let r = n(e, t);
+			return r === void 0 ? [e] : [e, r];
+		}));
+		default: throw new b(`unexpected ${i}`);
+	}
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/errors/runtime.js
+function A(e, t) {
+	return t.length > 0 ? E(e, ...t) : D(e);
+}
+var j = class extends _ {
+	constructor(e, ...t) {
+		let n = A(e, t);
+		super(n, "JPLRuntimeError"), this.value = t.length > 0 ? n : S(e);
+	}
+}, M = class extends j {
+	constructor(e, ...t) {
+		super(`TypeError - ${A(e, t)}`);
+	}
+}, ue = class extends j {
+	constructor(e, ...t) {
+		super(`ReferenceError - ${A(e, t)}`);
+	}
+}, de = class extends j {
+	constructor(e, ...t) {
+		super(`ZeroDivisionError - ${A(e, t)}`);
+	}
+}, fe = class extends j {
+	constructor(e, ...t) {
+		super(`TypeConversionError - ${A(e, t)}`);
+	}
+}, pe = class extends g {
+	constructor(e, t = "", n = 0) {
+		super(e, "JPLSyntaxError"), this.src = t, this.at = n;
+	}
+}, me = class e {
+	constructor(e) {
+		this._parent = e, this._exited = !1, this._subscriptions = {}, this._nextSubscriptionKey = 0;
+	}
+	get parent() {
+		return this._parent;
+	}
+	get exited() {
+		return this._exited ||= this.parent?.exited ?? !1, this._exited;
+	}
+	checkHealth() {
+		if (this.exited) throw new b("execution aborted");
+	}
+	exit = () => {
+		this.exited || (this._exited = !0, Object.values(this._subscriptions).forEach((e) => {
+			e();
+		}), this._subscriptions = {});
+	};
+	subscribe = (e) => {
+		if (this.exited) return setTimeout(e), () => {};
+		let t = this._nextSubscriptionKey;
+		this._nextSubscriptionKey += 1, this._subscriptions[t] = e;
+		let n = (this.parent?.subscribe ?? (() => () => {}))(e);
+		return () => {
+			delete this._subscriptions[t], n();
+		};
+	};
+	next = () => new e(this);
+}, he = class e {
+	constructor(e = {}) {
+		this._state = {
+			signal: e.signal ?? new me(),
+			vars: e.vars ?? {}
+		};
+	}
+	get signal() {
+		return this._state.signal;
+	}
+	get vars() {
+		return this._state.vars;
+	}
+	next(t) {
+		return new e({
+			signal: t.signal ?? this.signal,
+			vars: f(this.vars, Object.entries(t.vars ?? {}))
+		});
+	}
+};
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/functions.js
+function ge(e, t, n, r, ...i) {
+	let { argNames: a, pipe: o, scope: s } = this;
+	return e.executeInstructions(o, [r], s.next({
+		signal: t,
+		vars: Object.fromEntries(a.map((e, t) => [e, i[t] ?? null]))
+	}), n);
+}
+function _e(e, t, n) {
+	return ge.bind({
+		argNames: e,
+		pipe: t,
+		scope: n
+	});
+}
+function ve(e, t, n) {
+	return _e(e, t, new he(n));
+}
+function ye(e) {
+	return async (t, n, r, i, ...a) => {
+		let o = await e(t, i, ...a);
+		return t.muxAll([o], r);
+	};
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/mux.js
+function be(e, t) {
+	let n = e.length;
+	if (n === 1) {
+		e[0].forEach((e) => t(e));
+		return;
+	}
+	let r = 1, i = e.map((e) => {
+		let t = e?.length ?? 0;
+		return r *= t, [
+			t,
+			0,
+			e
+		];
+	});
+	if (r === 0) return;
+	let a = e.map(([e]) => e), o = 0;
+	for (; t(...a), o += 1, !(o >= r);) for (let e = n - 1; e >= 0; --e) {
+		let t = i[e], [n, r, o] = t, s = r + 1;
+		if (s < n) {
+			t[1] = s, a[e] = o[s];
+			break;
+		}
+		t[1] = 0, [a[e]] = o;
+	}
+}
+function N(e, t) {
+	let n = e.length;
+	if (n === 1) return e[0].map((e) => t(e));
+	let r = 1, i = e.map((e) => {
+		let t = e?.length ?? 0;
+		return r *= t, [
+			t,
+			0,
+			e
+		];
+	});
+	if (r === 0) return [];
+	let a = Array(r), o = e.map(([e]) => e), s = 0;
+	for (; a[s] = t(...o), s += 1, !(s >= r);) for (let e = n - 1; e >= 0; --e) {
+		let t = i[e], [n, r, a] = t, s = r + 1;
+		if (s < n) {
+			t[1] = s, o[e] = a[s];
+			break;
+		}
+		t[1] = 0, [o[e]] = a;
+	}
+	return a;
+}
+function P(e, t) {
+	return Promise.all(N(e, t));
+}
+async function xe(e, t) {
+	return Se(await P(e, t));
+}
+function Se(e) {
+	return e.length === 0 ? e : e.length === 1 ? e[0] : e.flat(1);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/library/index.js
+var Ce = /* @__PURE__ */ s({
+	DEFINITION_VERSION: () => h,
+	DEFINITION_VERSION_MAJOR: () => 1,
+	DEFINITION_VERSION_MINOR: () => 0,
+	JPLError: () => g,
+	JPLErrorEnclosure: () => y,
+	JPLExecutionError: () => _,
+	JPLFatalError: () => b,
+	JPLReferenceError: () => ue,
+	JPLRuntimeError: () => j,
+	JPLRuntimeScope: () => he,
+	JPLSyntaxError: () => pe,
+	JPLType: () => x,
+	JPLTypeConversionError: () => fe,
+	JPLTypeError: () => M,
+	JPLZeroDivisionError: () => de,
+	OPA_FIELD: () => "$.$",
+	OPA_FUNCTION: () => "$()",
+	OPA_ITER: () => "$[]",
+	OPA_SLICE: () => "[:]",
+	OPC_EQUAL: () => "==",
+	OPC_GREATER: () => ">",
+	OPC_GREATEREQUAL: () => ">=",
+	OPC_LESS: () => "<",
+	OPC_LESSEQUAL: () => "<=",
+	OPC_UNEQUAL: () => "!=",
+	OPM_ADDITION: () => "+",
+	OPM_DIVISION: () => "/",
+	OPM_MULTIPLICATION: () => "*",
+	OPM_REMAINDER: () => "%",
+	OPM_SUBTRACTION: () => "-",
+	OPU_ADDITION: () => "+=",
+	OPU_DIVISION: () => "/=",
+	OPU_MULTIPLICATION: () => "*=",
+	OPU_NULL_COALESCENCE: () => "?=",
+	OPU_REMAINDER: () => "%=",
+	OPU_SET: () => "=",
+	OPU_SUBTRACTION: () => "-=",
+	OPU_UPDATE: () => "|=",
+	OP_ACCESS: () => "$.",
+	OP_AND: () => "and",
+	OP_ARRAY_CONSTRUCTOR: () => "[]",
+	OP_ASSIGNMENT: () => "$=",
+	OP_CALCULATION: () => "clc",
+	OP_COMPARISON: () => "cmp",
+	OP_CONSTANT: () => "cnt",
+	OP_CONSTANT_FALSE: () => "fls",
+	OP_CONSTANT_NULL: () => "nul",
+	OP_CONSTANT_TRUE: () => "tru",
+	OP_FUNCTION_DEFINITION: () => "fun",
+	OP_IF: () => "if",
+	OP_INTERPOLATED_STRING: () => "\"$\"",
+	OP_NEGATION: () => "neg",
+	OP_NOT: () => "not",
+	OP_NULL_COALESCENCE: () => "??",
+	OP_NUMBER: () => "nbr",
+	OP_OBJECT_CONSTRUCTOR: () => "{}",
+	OP_OR: () => "or",
+	OP_OUTPUT_CONCAT: () => ",",
+	OP_STRING: () => "\"\"",
+	OP_TRY: () => "try",
+	OP_VARIABLE: () => "var",
+	OP_VARIABLE_DEFINITION: () => "va=",
+	OP_VOID: () => "vod",
+	adaptError: () => v,
+	adaptErrors: () => ee,
+	adaptErrorsAsync: () => te,
+	applyArray: () => p,
+	applyCombinations: () => m,
+	applyObject: () => f,
+	assertType: () => w,
+	displayValue: () => D,
+	jplJSONStripper: () => ce,
+	jplStripper: () => se,
+	jplTypedStripper: () => oe,
+	jsonStripper: () => le,
+	mux: () => be,
+	muxAll: () => xe,
+	muxAsync: () => P,
+	muxOne: () => N,
+	nativeFunction: () => ye,
+	normalize: () => S,
+	orphanFunction: () => ve,
+	rawStripper: () => k,
+	scopedFunction: () => _e,
+	strictDisplayValue: () => ae,
+	stringify: () => T,
+	strip: () => O,
+	template: () => E,
+	typeOf: () => ie,
+	typeOrder: () => re,
+	unwrap: () => C
+}), we = { vars: {} };
+function F(e = {}, t = {}) {
+	return d(e, t, "vars");
+}
+var Te = class {
+	constructor(e, t) {
+		this._options = F(t?.runtime, we), this._program = e;
+	}
+	get options() {
+		return this._options;
+	}
+	get program() {
+		return this._program;
+	}
+	createScope = (e) => new he(e);
+	execute = async (e) => {
+		let t = this.createScope({ vars: Object.fromEntries(this.muxOne([Object.entries(this.options.vars)], ([e, t]) => [e, this.normalizeValue(t)])) });
+		try {
+			return await this.executeInstructions(this.program.definition.instructions ?? [], e, t, this.options.adjustResult);
+		} finally {
+			t.signal.exit();
+		}
+	};
+	executeInstructions = (e, t, n, r = (e) => [e]) => {
+		let i = async (t, n, a) => {
+			if (await void 0, a.signal.checkHealth(), t >= e.length) return r(n, a);
+			let { op: o, params: s } = e[t], c = this.program.ops[o];
+			if (!c) throw new b(`invalid OP '${o}'`);
+			return c.op(this, n, s ?? {}, a, (e, n) => i(t + 1, e, n));
+		};
+		return this.muxAll([t], (e) => i(0, e, n));
+	};
+	op(e, t, n, r, i = (e) => [e]) {
+		let a = this.program.ops[e];
+		if (!a) throw new b(`invalid OP '${e}'`);
+		let o = a.map(this, t);
+		return this.muxAll([n], (e) => a.op(this, e, o ?? {}, r, i));
+	}
+	normalizeValue = S;
+	normalizeValues = (e = [], t = "values") => {
+		if (!Array.isArray(e)) throw new b(`expected ${t} to be an array`);
+		return this.normalizeValue(e);
+	};
+	unwrapValue = C;
+	unwrapValues = (e = [], t = "values") => {
+		if (!Array.isArray(e)) throw new b(`expected ${t} to be an array`);
+		return this.muxOne([e], (e) => this.unwrapValue(e));
+	};
+	stripValue = (e) => O(e, (e, t) => this.unwrapValue(t));
+	stripValues = (e = [], t = "values") => {
+		if (!Array.isArray(e)) throw new b(`expected ${t} to be an array`);
+		return this.muxOne([e], (e) => this.stripValue(e));
+	};
+	alterValue = async (e, t) => x.is(e) ? te(() => e.alter(t)) : this.normalizeValue(await t(e));
+	type = ie;
+	assertType = w;
+	truthy = (e) => {
+		let t = this.unwrapValue(e);
+		return t !== null && t !== !1;
+	};
+	compare = Ee.bind(this);
+	compareStrings = (e, t) => {
+		let n = this.type(e);
+		if (n !== "string") throw new b(`unexpected type ${n}`);
+		let r = this.type(t);
+		if (r !== "string") throw new b(`unexpected type ${r}`);
+		return I(this.unwrapValue(e), this.unwrapValue(t));
+	};
+	compareArrays = (e, t) => {
+		let n = this.type(e);
+		if (n !== "array") throw new b(`unexpected type ${n}`);
+		let r = this.type(t);
+		if (r !== "array") throw new b(`unexpected type ${r}`);
+		return De.call(this, this.unwrapValue(e), this.unwrapValue(t));
+	};
+	compareObjects = (e, t) => {
+		let n = this.type(e);
+		if (n !== "object") throw new b(`unexpected type ${n}`);
+		let r = this.type(t);
+		if (r !== "object") throw new b(`unexpected type ${r}`);
+		return Oe.call(this, this.unwrapValue(e), this.unwrapValue(t));
+	};
+	equals = (e, t) => this.compare(e, t) === 0;
+	merge = async (e, t) => (await void 0, this.type(e) !== "object" || this.type(t) !== "object" ? t : this.alterValue(e, async (e) => f(e, await Promise.all(Object.entries(this.unwrapValue(t)).map(async ([t, n]) => [t, await this.merge(e[t] ?? null, n)])))));
+	stringifyJSON = (e, t) => T(e, t);
+	stripJSON = (e) => O(e);
+	mux = be;
+	muxOne = N;
+	muxAsync = P;
+	muxAll = xe;
+};
+function Ee(e, t) {
+	let n = this.type(e), r = this.type(t);
+	if (n !== r) return re.indexOf(n) - re.indexOf(r);
+	let i = this.unwrapValue(e), a = this.unwrapValue(t);
+	switch (n) {
+		case "null":
+		case "function": return 0;
+		case "boolean":
+		case "number": return i - +a;
+		case "string": return I(i, a);
+		case "array": return De.call(this, i, a);
+		case "object": return Oe.call(this, i, a);
+		default: throw new b(`unexpected type ${n}`);
+	}
+}
+function I(e, t) {
+	let n = Math.min(e.length, t.length), r = 0;
+	for (let i of e) {
+		if (r >= n) break;
+		let i = e.codePointAt(r), a = i - t.codePointAt(r);
+		if (a !== 0) return a;
+		r += 1, i > 65535 && (r += 1);
+	}
+	return e.length - t.length;
+}
+function De(e, t) {
+	let n = Math.min(e.length, t.length);
+	for (let r = 0; r < n; r += 1) {
+		let n = Ee.call(this, e[r], t[r]);
+		if (n !== 0) return n;
+	}
+	return e.length - t.length;
+}
+function Oe(e, t) {
+	let n = Object.keys(e).sort(I), r = Object.keys(t).sort(I), i = De.call(this, n, r);
+	if (i !== 0) return i;
+	for (let r of n) if (i = Ee.call(this, e[r], t[r]), i !== 0) return i;
+	return 0;
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/program/ops/utils.js
+function L(e) {
+	return [{
+		op: "cnt",
+		params: { value: e ?? null }
+	}];
+}
+function R(e) {
+	return [{
+		op: "$.",
+		params: {
+			pipe: L(w(e, "function")),
+			selectors: [{
+				op: "$()",
+				params: {
+					args: [],
+					bound: !1,
+					optional: !1
+				}
+			}]
+		}
+	}];
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/program/ops/opAccess/opaField.js
+var ke = {
+	op(e, t, n, r, i, a) {
+		let o = e.unwrapValue(n), s = e.type(o);
+		return e.executeInstructions(r.pipe ?? [], [t], i, (t) => {
+			let n = e.unwrapValue(t), i = e.type(n);
+			switch (s) {
+				case "null":
+					if (["string", "number"].includes(i)) return a(null);
+					break;
+				case "object":
+					if (i === "string") return a(o[n] ?? null);
+					break;
+				case "array":
+					if (i === "number") {
+						let e = Math.trunc(n);
+						return a(o[e >= 0 ? e : o.length + e] ?? null);
+					}
+					break;
+				case "string":
+					if (i === "number") {
+						let e = Math.trunc(n), t = [...o];
+						return a(t[e >= 0 ? e : t.length + e] ?? null);
+					}
+					break;
+				default:
+			}
+			if (r.optional) return [];
+			throw new M("cannot access field of %s (%*<100v) with %s (%*<100v)", s, o, i, n);
+		});
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			optional: e.assertType(t.optional, "boolean")
+		};
+	}
+}, Ae = {
+	async op(e, t, n, r, i, a) {
+		let o = e.unwrapValue(n), s = e.type(o);
+		switch (s) {
+			case "function": {
+				let n = await e.muxAsync([r.args ?? []], (n) => e.executeInstructions(n ?? [], [t], i));
+				return e.muxAll(n, async (...n) => {
+					try {
+						let s = async (e) => {
+							try {
+								return await a(e);
+							} catch (e) {
+								throw new y(e);
+							}
+						};
+						return r.bound ? await o(e, i.signal, s, n[0] ?? null, ...n.slice(1)) : await o(e, i.signal, s, t, ...n);
+					} catch (e) {
+						throw y.is(e) ? e.inner : v(e);
+					}
+				});
+			}
+			default:
+		}
+		if (r.optional) return [];
+		throw new M("cannot execute %s (%*<100v)", s, o);
+	},
+	map(e, t) {
+		return {
+			args: e.muxOne([t.args], (e) => R(e)),
+			bound: e.assertType(t.bound, "boolean"),
+			optional: e.assertType(t.optional, "boolean")
+		};
+	}
+}, je = {
+	op(e, t, n, r, i, a) {
+		let o = e.unwrapValue(n), s = e.type(o);
+		switch (s) {
+			case "null": return [];
+			case "object": return e.muxAll([Object.values(o)], a);
+			case "array": return e.muxAll([o], a);
+			case "string": return e.muxAll([[...o]], a);
+			default:
+		}
+		if (r.optional) return [];
+		throw new M("cannot iterate over %s (%*<100v)", s, o);
+	},
+	map(e, t) {
+		return { optional: e.assertType(t.optional, "boolean") };
+	}
+}, Me = {
+	async op(e, t, n, r, i, a) {
+		let o = e.unwrapValue(n), s = e.type(o), [c, l] = await Promise.all([e.executeInstructions(r.from ?? [], [t], i), e.executeInstructions(r.to ?? [], [t], i)]);
+		return e.muxAll([e.unwrapValues(c), e.unwrapValues(l)], (t, n) => {
+			let i = e.type(t), c = e.type(n);
+			switch (s) {
+				case "null": return a(null);
+				case "array":
+					if (["number", "null"].includes(i) && ["number", "null"].includes(c)) return a(o.slice(Math.trunc(t ?? 0), Math.trunc(n ?? o.length)));
+					break;
+				case "string":
+					if (["number", "null"].includes(i) && ["number", "null"].includes(c)) {
+						let e = [...o];
+						return a(e.slice(Math.trunc(t ?? 0), Math.trunc(n ?? e.length)).join(""));
+					}
+					break;
+				default:
+			}
+			if (r.optional) return [];
+			throw new M("cannot slice %s (%*<100v) with %s (%*<100v) and %s (%*<100v)", s, o, i, t, c, n);
+		});
+	},
+	map(e, t) {
+		return {
+			from: R(t.from),
+			to: R(t.to),
+			optional: e.assertType(t.optional, "boolean")
+		};
+	}
+}, Ne = {
+	op(e, t, n, r, i) {
+		let a = async (o, s) => {
+			if (await void 0, r.signal.checkHealth(), o >= (n.selectors?.length ?? 0)) return i(s, r);
+			let { op: c, params: l } = n.selectors[o], u = Pe[c];
+			if (!u) throw new b(`invalid OPA '${c}'`);
+			return u.op(e, t, s, l ?? {}, r, (e) => a(o + 1, e));
+		};
+		return e.executeInstructions(n.pipe ?? [], [t], r, (e) => a(0, e));
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			selectors: e.muxOne([t.selectors], ({ op: t, params: n }) => {
+				let r = Pe[t];
+				if (!r) throw new b(`invalid OPA '${t}'`);
+				return {
+					op: e.assertType(t, "string"),
+					params: r.map(e, n)
+				};
+			})
+		};
+	}
+}, Pe = {
+	"$.$": ke,
+	"$()": Ae,
+	"$[]": je,
+	"[:]": Me
+}, Fe = {
+	op(e, t, n, r, i) {
+		let a = async (o) => {
+			if (await void 0, r.signal.checkHealth(), o >= (n.pipes?.length ?? 0)) return i(!0, r);
+			let s = n.pipes[o];
+			return e.executeInstructions(s ?? [], [t], r, (t) => e.truthy(t) ? a(o + 1) : i(!1, r));
+		};
+		return a(0);
+	},
+	map(e, t) {
+		return { pipes: e.muxOne([t.pipes], (e) => R(e)) };
+	}
+}, Ie = {
+	async op(e, t, n, r, i) {
+		return i(await e.executeInstructions(n.pipe ?? [], [t], r), r);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Le = {
+	async op(e, t, n, r, i, a) {
+		let o, s = e.unwrapValue(n), c = e.type(n);
+		switch (c) {
+			case "null":
+			case "object":
+			case "array":
+				o = s;
+				break;
+			case "string":
+				o = [...s];
+				break;
+			default:
+				if (r.optional) return [void 0];
+				throw new M("cannot access fields of %s (%*<100v) (assignment)", c, s);
+		}
+		let l = await e.executeInstructions(r.pipe ?? [], [t], i, (e) => [e]), u = async (t, n) => {
+			if (await void 0, i.signal.checkHealth(), t >= l.length) return [n];
+			let o = c === "string" ? c : e.type(n), s = e.unwrapValue(l[t]), d = e.type(s);
+			switch (o) {
+				case "null":
+					switch (d) {
+						case "string": return e.muxAll([await a(null)], (e) => e === void 0 ? u(t + 1, n) : u(t + 1, { [s]: e }));
+						case "number": {
+							let r = Math.trunc(s);
+							return e.muxAll([await a(null)], (e) => e === void 0 ? u(t + 1, n) : u(t + 1, p([], [[r, e]])));
+						}
+						default:
+					}
+					break;
+				case "object":
+					if (d === "string") {
+						let r = n[s];
+						return e.muxAll([await a(r ?? null)], (e) => e === void 0 ? u(t + 1, n) : u(t + 1, f(n, [[s, e]])));
+					}
+					break;
+				case "array":
+					if (d === "number") {
+						let r = Math.trunc(s), i = n[r >= 0 ? r : n.length + r];
+						return e.muxAll([await a(i ?? null)], (e) => e === void 0 ? u(t + 1, n) : u(t + 1, p(n, [[r, e]])));
+					}
+					break;
+				case "string":
+					if (d === "number") {
+						let r = Math.trunc(s), i = n[r >= 0 ? r : n.length + r];
+						return e.muxAll([await a(i ?? null)], (i) => {
+							if (i === void 0) return u(t + 1, n);
+							let a = e.unwrapValue(i), o = e.type(a);
+							switch (o) {
+								case "null":
+								case "string": return u(t + 1, p(n, [[r, i ?? " "]], " "));
+								default:
+							}
+							throw new M("cannot assign %s (%*<100v) to string (%*<100v)", o, a, n.join(""));
+						});
+					}
+					break;
+				default:
+			}
+			if (r.optional) return u(t + 1, n);
+			throw new M("cannot access field of %s (%*<100v) with %s (%*<100v) (assignment)", o, o === "string" ? n.join("") : n, d, s);
+		};
+		return e.muxAsync([await u(0, o)], (t) => {
+			if (o === t) return n;
+			switch (c === "string" ? c : e.type(t)) {
+				case "null": return;
+				case "object":
+				case "array": return e.alterValue(n, () => t);
+				case "string": return e.alterValue(n, () => t.join(""));
+				default:
+			}
+		});
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			optional: e.assertType(t.optional, "boolean")
+		};
+	}
+}, Re = {
+	async op(e, t, n, r, i, a) {
+		let o = e.unwrapValue(n), s = e.type(o);
+		switch (s) {
+			case "null": return [void 0];
+			case "object": {
+				let t = Object.entries(o), r = await e.muxAsync([t], async (t) => e.muxAsync([await a(t[1] ?? null)], (e) => e === void 0 ? t : [t[0], e]));
+				return e.muxAsync([m(t, r)], (r) => t === r ? n : e.alterValue(n, () => Object.fromEntries(r)));
+			}
+			case "array": {
+				let t = o, r = await e.muxAsync([t], async (t) => e.muxAsync([await a(t ?? null)], (e) => e === void 0 ? t : e));
+				return e.muxAsync([m(t, r)], (r) => t === r ? n : e.alterValue(n, () => r));
+			}
+			case "string": {
+				let t = [...o], r = await e.muxAsync([t], async (t) => e.muxAsync([await a(t)], (n) => {
+					if (n === void 0) return t;
+					let r = e.unwrapValue(n), i = e.type(r);
+					switch (i) {
+						case "null":
+						case "string": return r ?? " ";
+						default:
+					}
+					throw new M("cannot assign %s (%*<100v) to string (%*<100v)", i, r, o);
+				}));
+				return e.muxAsync([m(t, r)], (r) => t === r ? n : e.alterValue(n, () => r.join("")));
+			}
+			default:
+		}
+		if (r.optional) return [void 0];
+		throw new M("cannot iterate over %s (%*<100v) (assignment)", s, o);
+	},
+	map(e, t) {
+		return { optional: e.assertType(t.optional, "boolean") };
+	}
+};
+//#endregion
+//#region node_modules/@jplorg/jpl/src/program/ops/opAssignment/opaAssignSlice.js
+function ze(e, t) {
+	return e.length === t.length ? e.every((e, n) => e === t[n]) : !1;
+}
+var Be = {
+	async op(e, t, n, r, i, a) {
+		let [o, s] = await Promise.all([e.executeInstructions(r.from ?? [], [t], i), e.executeInstructions(r.to ?? [], [t], i)]), c = e.muxOne([e.unwrapValues(o), e.unwrapValues(s)], (e, t) => [e, t]), l = async (t, n) => {
+			if (await void 0, i.signal.checkHealth(), t >= c.length) return [n];
+			let o = e.unwrapValue(n), s = e.type(n), [u, d] = c[t], f = e.type(u), p = e.type(d);
+			switch (s) {
+				case "null": return l(t + 1, n);
+				case "array":
+					if (["number", "null"].includes(f) && ["number", "null"].includes(p)) return e.muxAll([await a(o.slice(Math.trunc(u ?? 0), Math.trunc(d ?? o.length)))], async (r) => r === void 0 ? l(t + 1, n) : l(t + 1, await e.alterValue(n, (t) => {
+						let n = e.unwrapValue(r), i = e.type(n);
+						switch (i) {
+							case "null":
+							case "array": {
+								let e = Math.trunc(u ?? 0), r = Math.trunc(d ?? t.length);
+								if (e = e >= 0 ? Math.min(t.length, e) : Math.max(0, t.length + e), r = Math.max(e, r >= 0 ? Math.min(t.length, r) : Math.max(0, t.length + r)), ze(t.slice(e, r), n ?? [])) return t;
+								let i = [...t];
+								return i.splice(e, r - e, ...n ?? []), i;
+							}
+							default:
+						}
+						throw new M("cannot assign %s (%*<100v) to slice of %s (%*<100v)", i, n, s, t);
+					})));
+					break;
+				case "string":
+					if (["number", "null"].includes(f) && ["number", "null"].includes(p)) {
+						let r = [...o];
+						return e.muxAll([await a(r.slice(Math.trunc(u ?? 0), Math.trunc(d ?? r.length)).join(""))], async (r) => r === void 0 ? l(t + 1, n) : l(t + 1, await e.alterValue(n, (t) => {
+							let n = e.unwrapValue(r), i = e.type(n);
+							switch (i) {
+								case "null":
+								case "string": {
+									let e = [...t], r = Math.trunc(u ?? 0), i = Math.trunc(d ?? e.length);
+									return r = r >= 0 ? Math.min(e.length, r) : Math.max(0, e.length + r), i = Math.max(r, i >= 0 ? Math.min(e.length, i) : Math.max(0, e.length + i)), ze(e.slice(r, i), n ?? []) ? t : (e.splice(r, i - r, ...n ?? []), e.join(""));
+								}
+								default:
+							}
+							throw new M("cannot assign %s (%*<100v) to slice of %s (%*<100v)", i, n, s, t);
+						})));
+					}
+					break;
+				default:
+			}
+			if (r.optional) return l(t + 1, n);
+			throw new M("cannot slice %s (%*<100v) with %s (%*<100v) and %s (%*<100v) (assignment)", s, o, f, u, p, d);
+		};
+		return e.muxOne([await l(0, n)], (t) => e.type(t) === "null" ? void 0 : t);
+	},
+	map(e, t) {
+		return {
+			from: R(t.from),
+			to: R(t.to),
+			optional: e.assertType(t.optional, "boolean")
+		};
+	}
+}, Ve = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "clc",
+			params: {
+				pipe: L(n),
+				operations: [{
+					op: "+",
+					params: { by: r.pipe ?? [] }
+				}]
+			}
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, He = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "clc",
+			params: {
+				pipe: L(n),
+				operations: [{
+					op: "/",
+					params: { by: r.pipe ?? [] }
+				}]
+			}
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Ue = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "clc",
+			params: {
+				pipe: L(n),
+				operations: [{
+					op: "*",
+					params: { by: r.pipe ?? [] }
+				}]
+			}
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, We = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "??",
+			params: { pipes: [L(n), r.pipe ?? []] }
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Ge = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "clc",
+			params: {
+				pipe: L(n),
+				operations: [{
+					op: "%",
+					params: { by: r.pipe ?? [] }
+				}]
+			}
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Ke = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.pipe ?? [], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, qe = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions([{
+			op: "clc",
+			params: {
+				pipe: L(n),
+				operations: [{
+					op: "-",
+					params: { by: r.pipe ?? [] }
+				}]
+			}
+		}], [t], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Je = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.pipe ?? [], [n], i, a);
+	},
+	map(e, t) {
+		return { pipe: R(t.pipe) };
+	}
+}, Ye = {
+	op(e, t, n, r, i) {
+		let a = async (i, o) => {
+			if (await void 0, r.signal.checkHealth(), i >= (n.selectors?.length ?? 0)) {
+				let { op: i, params: a } = n.assignment ?? {}, s = Ze[i];
+				if (!s) throw new b(`invalid OPU '${i}'`);
+				return s.op(e, t, o, a ?? {}, r, (e) => [e]);
+			}
+			let { op: s, params: c } = n.selectors[i], l = Xe[s];
+			if (!l) throw new b(`invalid OPA '${s}' (assignment)`);
+			return l.op(e, t, o, c ?? {}, r, (e) => a(i + 1, e));
+		};
+		return e.executeInstructions(n.pipe ?? [], [t], r, async (t) => e.muxAll([await a(0, t)], (e) => i(e === void 0 ? t : e, r)));
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			selectors: e.muxOne([t.selectors], ({ op: t, params: n }) => {
+				let r = Xe[t];
+				if (!r) throw new b(`invalid OPA '${t}' (assignment)`);
+				return {
+					op: e.assertType(t, "string"),
+					params: r.map(e, n)
+				};
+			}),
+			assignment: (({ op: t, params: n }) => {
+				let r = Ze[t];
+				if (!r) throw new b(`invalid OPU '${t}'`);
+				return {
+					op: e.assertType(t, "string"),
+					params: r.map(e, n)
+				};
+			})(t.assignment)
+		};
+	}
+}, Xe = {
+	"$.$": Le,
+	"$[]": Re,
+	"[:]": Be
+}, Ze = {
+	"+=": Ve,
+	"/=": He,
+	"*=": Ue,
+	"?=": We,
+	"%=": Ge,
+	"=": Ke,
+	"-=": qe,
+	"|=": Je
+}, Qe = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, async (t) => a(await e.alterValue(n, (n) => {
+			let r = e.unwrapValue(t), i = e.type(n), a = e.type(r);
+			if (i === "null" || a === "null") return i === "null" ? a === "null" ? null : r : n;
+			switch (i) {
+				case "number":
+					if (a === "number") return n + r;
+					break;
+				case "array":
+					if (a === "array") return r.length === 0 ? n : n.length === 0 ? r : [...n, ...r];
+					break;
+				case "string":
+					if (a === "string") return n + r;
+					break;
+				case "object":
+					if (a === "object") return f(n, Object.entries(r));
+					break;
+				default:
+			}
+			throw new M("%s (%*<100v) and %s (%*<100v) cannot be added together", i, n, a, r);
+		})));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, $e = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, async (t) => a(await e.alterValue(n, (n) => {
+			let r = e.unwrapValue(t), i = e.type(n), a = e.type(r);
+			switch (i) {
+				case "number":
+					if (a === "number") {
+						if (r === 0) throw new de("%s (%*<100v) cannot be divided by zero", i, n);
+						return n / r;
+					}
+					break;
+				case "string":
+					if (a === "string") return r === "" ? [...n] : n.split(r);
+					break;
+				default:
+			}
+			throw new M("%s (%*<100v) cannot be divided by %s (%*<100v)", i, n, a, r);
+		})));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, et = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, async (t) => a(await e.alterValue(n, (n) => {
+			let r = e.unwrapValue(t), i = e.type(n), a = e.type(r);
+			switch (i) {
+				case "number":
+					if (a === "number") return n * r;
+					break;
+				case "string":
+					if (a === "number") return r < 1 ? null : n.repeat(r);
+					break;
+				case "object":
+					if (a === "object") return e.merge(n, r);
+					break;
+				default:
+			}
+			throw new M("%s (%*<100v) and %s (%*<100v) cannot be multiplied together", i, n, a, r);
+		})));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, tt = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, async (t) => a(await e.alterValue(n, (n) => {
+			let r = e.unwrapValue(t), i = e.type(n), a = e.type(r);
+			switch (i) {
+				case "number":
+					if (a === "number") {
+						if (r === 0) throw new de("%s (%*<100v) cannot be divided by zero (remainder)", i, n);
+						return n % r;
+					}
+					break;
+				default:
+			}
+			throw new M("%s (%*<100v) cannot be divided by %s (%*<100v) (remainder)", i, n, a, r);
+		})));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, nt = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, async (t) => a(await e.alterValue(n, (n) => {
+			let r = e.unwrapValue(t), i = e.type(n), a = e.type(r);
+			switch (i) {
+				case "number":
+					if (a === "number") return n - r;
+					break;
+				case "array":
+					if (a === "array") {
+						if (n.length === 0 || r.length === 0) return n;
+						let t = n.filter((t) => !r.some((n) => e.equals(t, n)));
+						return n.length === t.length ? n : t;
+					}
+					break;
+				case "string":
+					if (a === "string") return n.replaceAll(r, "");
+					break;
+				case "object":
+					switch (a) {
+						case "array": return r.length === 0 ? n : f(n, Object.entries(n).filter(([, t]) => r.some((n) => e.equals(t, n))).map(([e]) => [e]));
+						case "string": return f(n, [[r]]);
+						default:
+					}
+					break;
+				default:
+			}
+			throw new M("%s (%*<100v) and %s (%*<100v) cannot be subtracted", i, n, a, r);
+		})));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, rt = {
+	op(e, t, n, r, i) {
+		let a = async (o, s) => {
+			if (await void 0, r.signal.checkHealth(), o >= (n.operations?.length ?? 0)) return i(s, r);
+			let { op: c, params: l } = n.operations[o], u = it[c];
+			if (!u) throw new b(`invalid OPM '${c}'`);
+			return u.op(e, t, s, l ?? {}, r, (e) => a(o + 1, e));
+		};
+		return e.executeInstructions(n.pipe ?? [], [t], r, (e) => a(0, e));
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			operations: e.muxOne([t.operations], ({ op: t, params: n }) => {
+				let r = it[t];
+				if (!r) throw new b(`invalid OPM '${t}'`);
+				return {
+					op: e.assertType(t, "string"),
+					params: r.map(e, n)
+				};
+			})
+		};
+	}
+}, it = {
+	"+": Qe,
+	"/": $e,
+	"*": et,
+	"%": tt,
+	"-": nt
+}, at = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(e.equals(n, t)));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, ot = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(e.compare(n, t) > 0));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, st = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(e.compare(n, t) >= 0));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, ct = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(e.compare(n, t) < 0));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, lt = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(e.compare(n, t) <= 0));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, ut = {
+	op(e, t, n, r, i, a) {
+		return e.executeInstructions(r.by ?? [], [t], i, (t) => a(!e.equals(n, t)));
+	},
+	map(e, t) {
+		return { by: R(t.by) };
+	}
+}, dt = {
+	op(e, t, n, r, i) {
+		let a = async (o, s) => {
+			if (await void 0, r.signal.checkHealth(), o >= (n.comparisons?.length ?? 0)) return i(s, r);
+			let { op: c, params: l } = n.comparisons[o], u = ft[c];
+			if (!u) throw new b(`invalid OPC '${c}'`);
+			return u.op(e, t, s, l ?? {}, r, (e) => a(o + 1, e));
+		};
+		return e.executeInstructions(n.pipe ?? [], [t], r, (e) => a(0, e));
+	},
+	map(e, t) {
+		return {
+			pipe: R(t.pipe),
+			comparisons: e.muxOne([t.comparisons], ({ op: t, params: n }) => {
+				let r = ft[t];
+				if (!r) throw new b(`invalid OPC '${t}'`);
+				return {
+					op: e.assertType(t, "string"),
+					params: r.map(e, n)
+				};
+			})
+		};
+	}
+}, ft = {
+	"==": at,
+	">": ot,
+	">=": st,
+	"<": ct,
+	"<=": lt,
+	"!=": ut
+}, pt = {
+	"$.": Ne,
+	and: Fe,
+	"[]": Ie,
+	"$=": Ye,
+	clc: rt,
+	cmp: dt,
+	cnt: {
+		op(e, t, n, r, i) {
+			return i(n.value ?? null, r);
+		},
+		map(e, t) {
+			return { value: e.normalizeValue(t.value) };
+		}
+	},
+	fls: {
+		op(e, t, n, r, i) {
+			return i(!1, r);
+		},
+		map() {
+			return {};
+		}
+	},
+	nul: {
+		op(e, t, n, r, i) {
+			return i(null, r);
+		},
+		map() {
+			return {};
+		}
+	},
+	tru: {
+		op(e, t, n, r, i) {
+			return i(!0, r);
+		},
+		map() {
+			return {};
+		}
+	},
+	fun: {
+		op(e, t, n, r, i) {
+			return i(_e(n.argNames ?? [], n.pipe ?? [], r), r);
+		},
+		map(e, t) {
+			return {
+				argNames: e.muxOne([t.argNames], (t) => e.assertType(t, "string")),
+				pipe: R(t.pipe)
+			};
+		}
+	},
+	if: {
+		op(e, t, n, r, i) {
+			let a = async (o) => {
+				if (await void 0, r.signal.checkHealth(), o >= (n.ifs?.length ?? 0)) return e.executeInstructions(n.else ?? [], [t], r, (e) => i(e, r));
+				let s = n.ifs[o];
+				return e.executeInstructions(s.if ?? [], [t], r, (n) => e.truthy(n) ? e.executeInstructions(s.then ?? [], [t], r, (e) => i(e, r)) : a(o + 1));
+			};
+			return a(0);
+		},
+		map(e, t) {
+			return {
+				ifs: e.muxOne([t.ifs], (e) => ({
+					if: R(e.if),
+					then: R(e.then)
+				})),
+				else: R(t.else)
+			};
+		}
+	},
+	"\"$\"": {
+		async op(e, t, n, r, i) {
+			let a = await e.muxAsync([n.interpolations ?? []], (n) => e.executeInstructions(n.pipe ?? [], [t], r, (t) => [(n.before ?? "") + e.stringifyJSON(t, !0)]));
+			return e.muxAll(a, (...e) => i(e.join("") + (n.after ?? ""), r));
+		},
+		map(e, t) {
+			return {
+				interpolations: e.muxOne([t.interpolations], (t) => ({
+					before: e.assertType(t.before, "string"),
+					pipe: R(t.pipe)
+				})),
+				after: e.assertType(t.after, "string")
+			};
+		}
+	},
+	neg: {
+		async op(e, t, n, r, i) {
+			return i(await e.alterValue(t, (t) => {
+				let n = e.type(t);
+				switch (n) {
+					case "number": return -t;
+					default:
+				}
+				throw new M("%s (%*<100v) cannot be negated", n, t);
+			}), r);
+		},
+		map() {
+			return {};
+		}
+	},
+	not: {
+		op(e, t, n, r, i) {
+			return i(!e.truthy(t), r);
+		},
+		map() {
+			return {};
+		}
+	},
+	"??": {
+		op(e, t, n, r, i) {
+			let a = async (o) => {
+				if (await void 0, r.signal.checkHealth(), o >= (n.pipes?.length ?? 0)) return i(null, r);
+				let s = n.pipes[o];
+				return e.executeInstructions(s ?? [], [t], r, (t) => {
+					switch (e.type(t)) {
+						case "null": return a(o + 1);
+						default: return i(t, r);
+					}
+				});
+			};
+			return a(0);
+		},
+		map(e, t) {
+			return { pipes: e.muxOne([t.pipes], (e) => R(e)) };
+		}
+	},
+	nbr: {
+		op(e, t, n, r, i) {
+			return i(n.number ?? 0, r);
+		},
+		map(e, t) {
+			return { number: e.assertType(t.number, "number") };
+		}
+	},
+	"{}": {
+		async op(e, t, n, r, i) {
+			let a = await e.muxAsync([n.fields ?? []], async (n) => {
+				let [i, a] = await Promise.all([e.executeInstructions(n.key ?? [], [t], r), e.executeInstructions(n.value ?? [], [t], r)]);
+				return e.muxAll([e.unwrapValues(i), a], (t, r) => {
+					let i = e.type(t);
+					switch (i) {
+						case "string": return [[t, r]];
+						default:
+					}
+					if (n.optional) return [];
+					throw new M("cannot use %s (%*<100v) as object key", i, t);
+				});
+			});
+			return e.muxAll(a, (...e) => i(Object.fromEntries(e), r));
+		},
+		map(e, t) {
+			return { fields: e.muxOne([t.fields], (t) => ({
+				key: R(t.key),
+				value: R(t.value),
+				optional: e.assertType(t.optional, "boolean")
+			})) };
+		}
+	},
+	or: {
+		op(e, t, n, r, i) {
+			let a = async (o) => {
+				if (await void 0, r.signal.checkHealth(), o >= (n.pipes?.length ?? 0)) return i(!1, r);
+				let s = n.pipes[o];
+				return e.executeInstructions(s ?? [], [t], r, (t) => e.truthy(t) ? i(!0, r) : a(o + 1));
+			};
+			return a(0);
+		},
+		map(e, t) {
+			return { pipes: e.muxOne([t.pipes], (e) => R(e)) };
+		}
+	},
+	",": {
+		op(e, t, n, r, i) {
+			return e.muxAll([n.pipes ?? []], (n) => e.executeInstructions(n ?? [], [t], r, (e) => i(e, r)));
+		},
+		map(e, t) {
+			return { pipes: e.muxOne([t.pipes], (e) => R(e)) };
+		}
+	},
+	"\"\"": {
+		op(e, t, n, r, i) {
+			return i(n.string ?? "", r);
+		},
+		map(e, t) {
+			return { string: e.assertType(t.string, "string") };
+		}
+	},
+	try: {
+		async op(e, t, n, r, i) {
+			let a = r.next({ signal: r.signal.next() });
+			try {
+				return await e.executeInstructions(n.try ?? [], [t], a, async (e) => {
+					try {
+						return await i(e, r);
+					} catch (e) {
+						throw new y(e);
+					}
+				});
+			} catch (t) {
+				if (y.is(t)) throw t.inner;
+				if (!_.is(t)) throw t;
+				return a.signal.exit(), e.executeInstructions(n.catch ?? [], [t.value], r, (e) => i(e, r));
+			}
+		},
+		map(e, t) {
+			return {
+				try: R(t.try),
+				catch: R(t.catch)
+			};
+		}
+	},
+	var: {
+		op(e, t, n, r, i) {
+			if (!Object.hasOwn(r.vars, n.name ?? "")) throw new ue("%s is not defined", n.name ?? "");
+			return i(r.vars[n.name ?? ""], r);
+		},
+		map(e, t) {
+			return { name: e.assertType(t.name, "string") };
+		}
+	},
+	"va=": {
+		op(e, t, n, r, i) {
+			return e.executeInstructions(n.pipe ?? [], [t], r, (e) => i(t, r.next({ vars: { [n.name ?? ""]: e } })));
+		},
+		map(e, t) {
+			return {
+				name: e.assertType(t.name, "string"),
+				pipe: R(t.pipe)
+			};
+		}
+	},
+	vod: {
+		op() {
+			return [];
+		},
+		map() {
+			return {};
+		}
+	}
+}, mt = {};
+function ht(e = {}, t = {}) {
+	return d(e, t);
+}
+function gt(e) {
+	let t = e?.version, [, n, r] = typeof t == "string" ? /^(\d+)\.(\d+)?$/g.exec(t) ?? [] : [];
+	if (!n || !r || !Array.isArray(e.instructions)) throw new b("invalid program definition");
+	if (+n != 1 || +r > 0) throw new b(`unsupported program definition v${n}.${r} - this version of JPL only supports v1 (up to v${h})`);
+}
+var _t = class e {
+	constructor(e, t) {
+		gt(e), this._options = ht(t?.program, mt), this._runtimeOptions = t?.runtime, this._definition = e, this._ops = pt;
+	}
+	get options() {
+		return this._options;
+	}
+	get definition() {
+		return this._definition;
+	}
+	get ops() {
+		return this._ops;
+	}
+	run = async (e, t) => {
+		let n = new Te(this, { runtime: F(t?.runtime, this._runtimeOptions) }), r = n.normalizeValues(e, "program inputs"), i = await n.execute(r);
+		return n.stripJSON(i);
+	};
+	prepend = (t) => (gt(t), new e({
+		version: h,
+		instructions: [...t.instructions, ...this.definition.instructions]
+	}, {
+		program: this._options,
+		runtime: this._runtimeOptions
+	}));
+	append = (t) => (gt(t), new e({
+		version: h,
+		instructions: [...this.definition.instructions, ...t.instructions]
+	}, {
+		program: this._options,
+		runtime: this._runtimeOptions
+	}));
+}, vt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", yt = "0123456789", bt = `${vt}_$`, xt = `${bt}${yt}`, St = xt, Ct = " \xA0\r\n	", wt = `${yt}abcdefABCDEF`;
+function z(e, t, n) {
+	let r = t, i = !1;
+	for (;;) {
+		let t = B(e, r, n, { phrase: "#" });
+		if (t.is) {
+			for ({i: r} = t;;) {
+				let t = H(e, r, n, { set: "\r\n" });
+				if (t.is) {
+					({i: r} = t);
+					break;
+				}
+				let i = W(e, r, n);
+				if (i.is) {
+					({i: r} = i);
+					break;
+				}
+				r += 1;
+			}
+			i = !0;
+			continue;
+		}
+		if (t = B(e, r, n, { phrase: "/*" }), t.is) {
+			for ({i: r} = t;;) {
+				if (t = B(e, r, n, { phrase: "*/" }), t.is) {
+					({i: r} = t);
+					break;
+				}
+				let i = W(e, r, n);
+				if (i.is) return {i: r} = i, G(e, r, n, {
+					operator: "comment",
+					message: "incomplete comment"
+				});
+				r += 1;
+			}
+			i = !0;
+			continue;
+		}
+		let a = H(e, r, n, { set: Ct });
+		if ({i: r} = a, !a.is) break;
+		i = !0;
+	}
+	return {
+		i: r,
+		is: i
+	};
+}
+function B(e, t, n, { phrase: r, notBeforeSet: i, spaceBefore: a, spaceAfter: o }) {
+	let s = t;
+	if (a && t > 0 && !H(e, s - 1, n, {
+		set: St,
+		exclusive: !0
+	}).is) return {
+		i: s,
+		is: !1
+	};
+	for (let t = 0; t < r.length; t += 1, s += 1) {
+		let i = W(e, s, n);
+		if (i.is || e[s] !== r[t]) return {
+			i: i.i,
+			is: !1
+		};
+	}
+	return !W(e, s, n).is && (i && H(e, s, n, { set: i }).is || o && !H(e, s, n, {
+		set: St,
+		exclusive: !0
+	}).is) ? {
+		i: s,
+		is: !1
+	} : {
+		i: s,
+		is: !0
+	};
+}
+function V(e, t, n, { phrase: r, notBeforeSet: i, spaceBefore: a, spaceAfter: o }) {
+	let s = t, c = B(e, s, n, {
+		phrase: r,
+		notBeforeSet: i,
+		spaceBefore: a,
+		spaceAfter: o
+	});
+	return c.is ? ({i: s} = c, {i: s} = z(e, s, n), {
+		i: s,
+		is: !0
+	}) : {
+		i: c.i,
+		is: !1
+	};
+}
+function Tt(e, t, n) {
+	return H(e, t, n, { set: wt });
+}
+function H(e, t, n, { set: r, exclusive: i }) {
+	let a = W(e, t, n);
+	if (a.is) return {
+		i: a.i,
+		is: !1
+	};
+	let o = e[t];
+	return r.includes(o) === !i ? {
+		i: t + 1,
+		is: !0,
+		value: o
+	} : {
+		i: t,
+		is: !1,
+		value: ""
+	};
+}
+function Et(e, t, n) {
+	let r = t, i = !1, a = "";
+	for (;;) {
+		let t = H(e, r, n, { set: i ? xt : bt });
+		if ({i: r} = t, !t.is) break;
+		i = !0, a += t.value;
+	}
+	return i && ({i: r} = z(e, r, n)), {
+		i: r,
+		is: i,
+		value: a
+	};
+}
+function U(e, t, n) {
+	let r = Et(e, t, n);
+	if (!r.is) return r;
+	switch (r.value) {
+		case "and":
+		case "catch":
+		case "func":
+		case "elif":
+		case "else":
+		case "end":
+		case "false":
+		case "if":
+		case "not":
+		case "null":
+		case "or":
+		case "then":
+		case "true":
+		case "try": return {
+			i: t,
+			is: !1,
+			value: r.value,
+			reserved: !0
+		};
+		default: return r;
+	}
+}
+function W(e, t) {
+	return t >= e.length ? {
+		i: e.length,
+		is: !0
+	} : {
+		i: t,
+		is: !1
+	};
+}
+function Dt(e, t) {
+	let n = e.substring(0, t).split(/\r?\n|\r/), r = n[n.length - 1];
+	return {
+		i: t,
+		line: n.length - 1,
+		column: r.length
+	};
+}
+function Ot(e, t, n, { area: r = 25 } = {}) {
+	let i = Math.max(Math.min(t, e.length - 1 - r), r) - r, a = Math.min(i + r + 1 + r, e.length), o = e.substring(i, a).replaceAll(/\r?\n|\r/g, "⏎").replaceAll("	", "→"), s = " > ";
+	i > 0 && (s += "…");
+	let c = "";
+	return a < e.length && (c = "…"), {
+		i: t,
+		value: `${s}${o}${c}\n${" ".repeat(s.length + (t - i))}^ here`
+	};
+}
+function G(e, t, n, { operator: r, message: i } = {}) {
+	let a;
+	if (W(e, t, n).is) a = "unexpected EOT";
+	else {
+		let { line: r, column: i } = Dt(e, t, n);
+		a = `unexpected token '${e[t]}' at line ${r + 1}, column ${i + 1}`;
+	}
+	throw r && (a += ` while parsing ${r}`), i && (a += `: ${i}`), a += `\n${Ot(e, t, n).value}`, new pe(a, e, t);
+}
+function kt(e, t, n, { operator: r, message: i } = {}) {
+	let a = "error";
+	throw r && (a += ` while parsing ${r}`), i && (a += `: ${i}`), a += `\n${Ot(e, t, n).value}`, new pe(a, e, t);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/interpreter/parse.js
+async function At(e, t, n) {
+	let r = t, i = await jt(e, r, n);
+	return {i: r} = i, W(e, r, n).is ? i : G(e, r, n, {
+		operator: "program",
+		message: "expected EOT"
+	});
+}
+function jt(e, t, n) {
+	let r = t;
+	return {i: r} = z(e, r, n), K(e, r, n);
+}
+function Mt(e, t, n) {
+	let r = t, i = V(e, r, n, { phrase: "(" });
+	if ({i: r} = i, !i.is) return G(e, r, n, {
+		operator: "function definition",
+		message: "expected '('"
+	});
+	let a = [];
+	if (i = V(e, r, n, { phrase: ")" }), i.is) ({i: r} = i);
+	else for (;;) {
+		let t = U(e, r, n);
+		if (!t.is) return G(e, r, n, {
+			operator: "function definition",
+			message: "expected argument name"
+		});
+		let o;
+		if ({i: r, value: o} = t, a.push(o), i = V(e, r, n, { phrase: ")" }), i.is) {
+			({i: r} = i);
+			break;
+		}
+		if (i = V(e, r, n, { phrase: "," }), {i: r} = i, !i.is) return G(e, r, n, {
+			operator: "function definition",
+			message: "expected ',' or ')'"
+		});
+	}
+	return i = V(e, r, n, { phrase: ":" }), {i: r} = i, i.is ? {
+		i: r,
+		argNames: a
+	} : G(e, r, n, {
+		operator: "function definition",
+		message: "expected ':'"
+	});
+}
+async function Nt(e, t, n, { identity: r } = {}) {
+	let i = t, a = [], o = !0;
+	for (;;) {
+		let t = V(e, i, n, { phrase: "." });
+		if (!(r && a.length === 0) && t.is) {
+			({i: i} = t);
+			let r = U(e, i, n);
+			if (!r.is) return G(e, i, n, {
+				operator: "field access operator",
+				message: "expected field name"
+			});
+			let o;
+			({i: i, value: o} = r);
+			let s;
+			t = V(e, i, n, {
+				phrase: "?",
+				notBeforeSet: "?="
+			}), t.is && ({i: i, is: s} = t), a.push({
+				op: "$.$",
+				params: {
+					pipe: [{
+						op: "\"\"",
+						params: { string: o }
+					}],
+					optional: s
+				}
+			});
+			continue;
+		}
+		if (t = V(e, i, n, { phrase: "[" }), t.is) {
+			if ({i: i} = t, t = V(e, i, n, { phrase: "]" }), t.is) {
+				({i: i} = t);
+				let r;
+				t = V(e, i, n, {
+					phrase: "?",
+					notBeforeSet: "?="
+				}), t.is && ({i: i, is: r} = t), a.push({
+					op: "$[]",
+					params: { optional: r }
+				});
+				continue;
+			}
+			if (t = V(e, i, n, { phrase: ":" }), t.is) {
+				if ({i: i} = t, t = V(e, i, n, { phrase: "]" }), t.is) {
+					({i: i} = t);
+					let r;
+					t = V(e, i, n, {
+						phrase: "?",
+						notBeforeSet: "?="
+					}), t.is && ({i: i, is: r} = t), a.push({
+						op: "[:]",
+						params: {
+							from: [{ op: "nul" }],
+							to: [{ op: "nul" }],
+							optional: r
+						}
+					});
+					continue;
+				}
+				let r;
+				if ({i: i, ops: r} = await K(e, i, n), t = V(e, i, n, { phrase: "]" }), {i: i} = t, !t.is) return G(e, i, n, {
+					operator: "array slice operator",
+					message: "expected ']'"
+				});
+				let o;
+				t = V(e, i, n, {
+					phrase: "?",
+					notBeforeSet: "?="
+				}), t.is && ({i: i, is: o} = t), a.push({
+					op: "[:]",
+					params: {
+						from: [{ op: "nul" }],
+						to: r,
+						optional: o
+					}
+				});
+				continue;
+			}
+			let r;
+			if ({i: i, ops: r} = await K(e, i, n), t = V(e, i, n, { phrase: "]" }), t.is) {
+				({i: i} = t);
+				let o;
+				t = V(e, i, n, {
+					phrase: "?",
+					notBeforeSet: "?="
+				}), t.is && ({i: i, is: o} = t), a.push({
+					op: "$.$",
+					params: {
+						pipe: r,
+						optional: o
+					}
+				});
+				continue;
+			}
+			if (t = V(e, i, n, { phrase: ":" }), !t.is) return G(e, i, n, {
+				operator: "variable access operator",
+				message: "expected ':' or ']'"
+			});
+			if ({i: i} = t, t = V(e, i, n, { phrase: "]" }), t.is) {
+				({i: i} = t);
+				let o;
+				t = V(e, i, n, {
+					phrase: "?",
+					notBeforeSet: "?="
+				}), t.is && ({i: i, is: o} = t), a.push({
+					op: "[:]",
+					params: {
+						from: r,
+						to: [{ op: "nul" }],
+						optional: o
+					}
+				});
+				continue;
+			}
+			let o;
+			if ({i: i, ops: o} = await K(e, i, n), t = V(e, i, n, { phrase: "]" }), {i: i} = t, !t.is) return G(e, i, n, {
+				operator: "array slice operator",
+				message: "expected ']'"
+			});
+			let s;
+			t = V(e, i, n, {
+				phrase: "?",
+				notBeforeSet: "?="
+			}), t.is && ({i: i, is: s} = t), a.push({
+				op: "[:]",
+				params: {
+					from: r,
+					to: o,
+					optional: s
+				}
+			});
+			continue;
+		}
+		let s;
+		if (t = V(e, i, n, { phrase: "->" }), t.is && ({i: i, is: s} = t), t = V(e, i, n, { phrase: "(" }), !t.is && s) return G(e, i, n, {
+			operator: "bound function call",
+			message: "expected '('"
+		});
+		if (t.is) {
+			({i: i} = t);
+			let r = [];
+			if (t = V(e, i, n, { phrase: ")" }), t.is) ({i: i} = t);
+			else for (;;) {
+				let a;
+				if ({i: i, ops: a} = await q(e, i, n), r.push(a), t = V(e, i, n, { phrase: ")" }), t.is) {
+					({i: i} = t);
+					break;
+				}
+				if (t = V(e, i, n, { phrase: "," }), {i: i} = t, !t.is) return G(e, i, n, {
+					operator: "function call",
+					message: "expected ',' or ')'"
+				});
+			}
+			let c;
+			t = V(e, i, n, {
+				phrase: "?",
+				notBeforeSet: "?="
+			}), t.is && ({i: i, is: c} = t), a.push({
+				op: "$()",
+				params: {
+					args: r,
+					bound: s,
+					optional: c
+				}
+			}), o = !1;
+			continue;
+		}
+		break;
+	}
+	return {
+		i,
+		is: a.length > 0,
+		selectors: a,
+		canAssign: o
+	};
+}
+async function Pt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "=",
+		notBeforeSet: "="
+	});
+	if (i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "|=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "|=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "+=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "+=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "-=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "-=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "*=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "*=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "/=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "/=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "%=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "%=",
+				params: { pipe: t }
+			}
+		};
+	}
+	if (i = V(e, r, n, { phrase: "?=" }), i.is) {
+		({i: r} = i);
+		let t;
+		return {i: r, ops: t} = await J(e, r, n), {
+			i: r,
+			is: !0,
+			assignment: {
+				op: "?=",
+				params: { pipe: t }
+			}
+		};
+	}
+	return {
+		i: r,
+		is: !1
+	};
+}
+function Ft(e, t, n) {
+	let r = t, i = !1, a = "";
+	for (;;) {
+		let t = H(e, r, n, { set: "0123456789" });
+		if (!t.is) break;
+		({i: r} = t), i = !0, a += t.value;
+	}
+	if (!i) return {
+		i: r,
+		is: !1
+	};
+	let o = B(e, r, n, { phrase: "." });
+	if (o.is) for ({i: r} = o, a += ".";;) {
+		let t = H(e, r, n, { set: "0123456789" });
+		if (!t.is) break;
+		({i: r} = t), a += t.value;
+	}
+	let s = H(e, r, n, { set: "eE" });
+	if (s.is) {
+		({i: r} = s), a += s.value, s = H(e, r, n, { set: "+-" }), s.is && ({i: r} = s, a += s.value);
+		let t;
+		for (; s = H(e, r, n, { set: "0123456789" }), s.is;) ({i: r} = s), t = !0, a += s.value;
+		if (!t) return G(e, r, n, {
+			operator: "number",
+			message: "expected digit"
+		});
+	}
+	let c = +a;
+	return Number.isFinite(c) ? ({i: r} = z(e, r, n), {
+		i: r,
+		is: !0,
+		ops: [{
+			op: "nbr",
+			params: { number: c }
+		}]
+	}) : kt(e, r, n, {
+		operator: "number",
+		message: `invalid number ${c}`
+	});
+}
+async function It(e, t, n) {
+	let r = t, i = "", a = H(e, r, n, { set: "\"'`" });
+	if (!a.is) return {
+		i: r,
+		is: !1
+	};
+	let o;
+	({i: r, value: o} = a);
+	let s = o === "`", c = [];
+	for (;;) {
+		let t = B(e, r, n, { phrase: o });
+		if (t.is) {
+			({i: r} = t);
+			break;
+		}
+		let a = W(e, r, n);
+		if (a.is) return {i: r} = a, G(e, r, n, {
+			operator: "string",
+			message: "incomplete string literal"
+		});
+		if (t = B(e, r, n, { phrase: "\\" }), t.is) {
+			if ({i: r} = t, t = V(e, r, n, { phrase: "(" }), t.is) {
+				({i: r} = t);
+				let a;
+				if ({i: r, ops: a} = await K(e, r, n), t = B(e, r, n, { phrase: ")" }), {i: r} = t, !t.is) return G(e, r, n, {
+					operator: "string interpolation",
+					message: "expected ')'"
+				});
+				c.push({
+					before: i,
+					pipe: a
+				}), i = "";
+				continue;
+			}
+			if (s) switch (e[r]) {
+				case "\n":
+					r += 1;
+					continue;
+				case "\r":
+					r += 1, !W(e, r, n).is && e[r] === "\n" && (r += 1);
+					continue;
+				default:
+			}
+			switch (e[r]) {
+				case "\"":
+					i += "\"", r += 1;
+					continue;
+				case "'":
+					i += "'", r += 1;
+					continue;
+				case "`":
+					i += "`", r += 1;
+					continue;
+				case "\\":
+					i += "\\", r += 1;
+					continue;
+				case "/":
+					i += "/", r += 1;
+					continue;
+				case "b":
+					i += "\b", r += 1;
+					continue;
+				case "f":
+					i += "\f", r += 1;
+					continue;
+				case "n":
+					i += "\n", r += 1;
+					continue;
+				case "r":
+					i += "\r", r += 1;
+					continue;
+				case "t":
+					i += "	", r += 1;
+					continue;
+				case "u": {
+					r += 1;
+					let a = "";
+					for (let i = 0; i < 4; i += 1) {
+						if (t = Tt(e, r, n), {i: r} = t, !t.is) return G(e, r, n, {
+							operator: "string",
+							message: "incomplete unicode escape sequence: expected hex digit"
+						});
+						a += t.value;
+					}
+					i += String.fromCodePoint(parseInt(a, 16));
+					continue;
+				}
+				default: return G(e, r, n, {
+					operator: "string",
+					message: "invalid escape sequence"
+				});
+			}
+		}
+		if (s) switch (e[r]) {
+			case "\n":
+			case "\r":
+			case "	":
+				i += e[r], r += 1;
+				continue;
+			default:
+		}
+		if (e.charCodeAt(r) < 32) return G(e, r, n, { operator: "string" });
+		i += e[r], r += 1;
+	}
+	return {i: r} = z(e, r, n), c.length === 0 ? {
+		i: r,
+		is: !0,
+		ops: [{
+			op: "\"\"",
+			params: { string: i }
+		}]
+	} : {
+		i: r,
+		is: !0,
+		ops: [{
+			op: "\"$\"",
+			params: {
+				interpolations: c,
+				after: i
+			}
+		}]
+	};
+}
+async function K(e, t, n) {
+	await void 0;
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Lt(e, r, n)), i.push(...t);
+		let a = V(e, r, n, {
+			phrase: "|",
+			notBeforeSet: "="
+		});
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return {
+		i: r,
+		ops: i
+	};
+}
+async function q(e, t, n) {
+	await void 0;
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Rt(e, r, n)), i.push(...t);
+		let a = V(e, r, n, {
+			phrase: "|",
+			notBeforeSet: "="
+		});
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return {
+		i: r,
+		ops: i
+	};
+}
+async function J(e, t, n) {
+	return await void 0, Rt(e, t, n);
+}
+async function Lt(e, t, n) {
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Rt(e, r, n)), i.push(t);
+		let a = V(e, r, n, { phrase: "," });
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return i.length === 1 ? {
+		i: r,
+		ops: i[0]
+	} : {
+		i: r,
+		ops: [{
+			op: ",",
+			params: { pipes: i }
+		}]
+	};
+}
+async function Rt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "try",
+		spaceAfter: !0
+	});
+	if (!i.is) return zt(e, r, n);
+	({i: r} = i);
+	let a;
+	({i: r, ops: a} = await zt(e, r, n));
+	let o;
+	return i = V(e, r, n, {
+		spaceBefore: !0,
+		phrase: "catch",
+		spaceAfter: !0
+	}), i.is ? ({i: r} = i, {i: r, ops: o} = await zt(e, r, n)) : o = [{ op: "vod" }], {
+		i: r,
+		ops: [{
+			op: "try",
+			params: {
+				try: a,
+				catch: o
+			}
+		}]
+	};
+}
+async function zt(e, t, n) {
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Bt(e, r, n)), i.push(t);
+		let a = V(e, r, n, {
+			spaceBefore: !0,
+			phrase: "or",
+			spaceAfter: !0
+		});
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return i.length === 1 ? {
+		i: r,
+		ops: i[0]
+	} : {
+		i: r,
+		ops: [{
+			op: "or",
+			params: { pipes: i }
+		}]
+	};
+}
+async function Bt(e, t, n) {
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Vt(e, r, n)), i.push(t);
+		let a = V(e, r, n, {
+			spaceBefore: !0,
+			phrase: "and",
+			spaceAfter: !0
+		});
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return i.length === 1 ? {
+		i: r,
+		ops: i[0]
+	} : {
+		i: r,
+		ops: [{
+			op: "and",
+			params: { pipes: i }
+		}]
+	};
+}
+async function Vt(e, t, n) {
+	let r = t, i;
+	({i: r, ops: i} = await Ht(e, r, n));
+	let a = [];
+	for (;;) {
+		let t = V(e, r, n, { phrase: "==" });
+		if (t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Ht(e, r, n)), a.push({
+				op: "==",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, { phrase: "!=" }), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Ht(e, r, n)), a.push({
+				op: "!=",
+				params: { by: i }
+			});
+			continue;
+		}
+		break;
+	}
+	return a.length === 0 ? {
+		i: r,
+		ops: i
+	} : {
+		i: r,
+		ops: [{
+			op: "cmp",
+			params: {
+				pipe: i,
+				comparisons: a
+			}
+		}]
+	};
+}
+async function Ht(e, t, n) {
+	let r = t, i;
+	({i: r, ops: i} = await Y(e, r, n));
+	let a = [];
+	for (;;) {
+		let t = V(e, r, n, { phrase: "<=" });
+		if (t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Y(e, r, n)), a.push({
+				op: "<=",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, { phrase: "<" }), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Y(e, r, n)), a.push({
+				op: "<",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, { phrase: ">=" }), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Y(e, r, n)), a.push({
+				op: ">=",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, { phrase: ">" }), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Y(e, r, n)), a.push({
+				op: ">",
+				params: { by: i }
+			});
+			continue;
+		}
+		break;
+	}
+	return a.length === 0 ? {
+		i: r,
+		ops: i
+	} : {
+		i: r,
+		ops: [{
+			op: "cmp",
+			params: {
+				pipe: i,
+				comparisons: a
+			}
+		}]
+	};
+}
+async function Y(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "not",
+		spaceAfter: !0
+	});
+	if (!i.is) return Ut(e, r, n);
+	({i: r} = i);
+	let a;
+	return {i: r, ops: a} = await Ut(e, r, n), {
+		i: r,
+		ops: [...a, { op: "not" }]
+	};
+}
+async function Ut(e, t, n) {
+	let r = t, i = await Wt(e, r, n);
+	({i: r} = i);
+	let a = V(e, r, n, {
+		phrase: "?",
+		notBeforeSet: "?="
+	});
+	return a.is ? ({i: r} = a, {
+		i: r,
+		ops: [{
+			op: "try",
+			params: {
+				try: i.ops,
+				catch: [{ op: "vod" }]
+			}
+		}]
+	}) : i;
+}
+async function Wt(e, t, n) {
+	let r = t, i;
+	({i: r, ops: i} = await X(e, r, n));
+	let a = [];
+	for (;;) {
+		let t = V(e, r, n, {
+			phrase: "+",
+			notBeforeSet: "="
+		});
+		if (t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await X(e, r, n)), a.push({
+				op: "+",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, {
+			phrase: "-",
+			notBeforeSet: "=>"
+		}), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await X(e, r, n)), a.push({
+				op: "-",
+				params: { by: i }
+			});
+			continue;
+		}
+		break;
+	}
+	return a.length === 0 ? {
+		i: r,
+		ops: i
+	} : {
+		i: r,
+		ops: [{
+			op: "clc",
+			params: {
+				pipe: i,
+				operations: a
+			}
+		}]
+	};
+}
+async function X(e, t, n) {
+	let r = t, i;
+	({i: r, ops: i} = await Z(e, r, n));
+	let a = [];
+	for (;;) {
+		let t = V(e, r, n, {
+			phrase: "*",
+			notBeforeSet: "="
+		});
+		if (t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Z(e, r, n)), a.push({
+				op: "*",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, {
+			phrase: "/",
+			notBeforeSet: "="
+		}), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Z(e, r, n)), a.push({
+				op: "/",
+				params: { by: i }
+			});
+			continue;
+		}
+		if (t = V(e, r, n, {
+			phrase: "%",
+			notBeforeSet: "="
+		}), t.is) {
+			({i: r} = t);
+			let i;
+			({i: r, ops: i} = await Z(e, r, n)), a.push({
+				op: "%",
+				params: { by: i }
+			});
+			continue;
+		}
+		break;
+	}
+	return a.length === 0 ? {
+		i: r,
+		ops: i
+	} : {
+		i: r,
+		ops: [{
+			op: "clc",
+			params: {
+				pipe: i,
+				operations: a
+			}
+		}]
+	};
+}
+async function Z(e, t, n) {
+	let r = t, i = [];
+	for (;;) {
+		let t;
+		({i: r, ops: t} = await Gt(e, r, n)), i.push(t);
+		let a = V(e, r, n, { phrase: "??" });
+		if (!a.is) break;
+		({i: r} = a);
+	}
+	return i.length === 1 ? {
+		i: r,
+		ops: i[0]
+	} : {
+		i: r,
+		ops: [{
+			op: "??",
+			params: { pipes: i }
+		}]
+	};
+}
+async function Gt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "-",
+		notBeforeSet: "=>"
+	});
+	if (!i.is) return Kt(e, r, n);
+	({i: r} = i);
+	let a;
+	return {i: r, ops: a} = await Kt(e, r, n), {
+		i: r,
+		ops: [...a, { op: "neg" }]
+	};
+}
+async function Kt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "if",
+		spaceAfter: !0
+	});
+	if (!i.is) return qt(e, r, n);
+	({i: r} = i);
+	let a = [];
+	for (;;) {
+		let t;
+		if ({i: r, ops: t} = await K(e, r, n), i = V(e, r, n, {
+			spaceBefore: !0,
+			phrase: "then",
+			spaceAfter: !0
+		}), {i: r} = i, !i.is) return G(e, r, n, {
+			operator: "if statement",
+			message: "expected 'then'"
+		});
+		let o;
+		if ({i: r, ops: o} = await K(e, r, n), a.push({
+			if: t,
+			then: o
+		}), i = V(e, r, n, {
+			spaceBefore: !0,
+			phrase: "elif",
+			spaceAfter: !0
+		}), !i.is) break;
+		({i: r} = i);
+	}
+	let o;
+	return i = V(e, r, n, {
+		spaceBefore: !0,
+		phrase: "else",
+		spaceAfter: !0
+	}), i.is ? ({i: r} = i, {i: r, ops: o} = await K(e, r, n)) : o = [], i = V(e, r, n, {
+		spaceBefore: !0,
+		phrase: "end"
+	}), {i: r} = i, i.is ? {
+		i: r,
+		ops: [{
+			op: "if",
+			params: {
+				ifs: a,
+				else: o
+			}
+		}]
+	} : G(e, r, n, {
+		operator: "if statement",
+		message: "expected 'end'"
+	});
+}
+function qt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "true",
+		spaceAfter: !0
+	});
+	return i.is ? ({i: r} = i, {
+		i: r,
+		ops: [{ op: "tru" }]
+	}) : (i = V(e, r, n, {
+		phrase: "false",
+		spaceAfter: !0
+	}), i.is ? ({i: r} = i, {
+		i: r,
+		ops: [{ op: "fls" }]
+	}) : (i = V(e, r, n, {
+		phrase: "null",
+		spaceAfter: !0
+	}), i.is ? ({i: r} = i, {
+		i: r,
+		ops: [{ op: "nul" }]
+	}) : Jt(e, r, n)));
+}
+async function Jt(e, t, n) {
+	let r = t, i = await Ft(e, r, n);
+	return i.is ? ({i: r} = i, {
+		i: r,
+		ops: i.ops
+	}) : Yt(e, r, n);
+}
+async function Yt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "func",
+		spaceAfter: !0
+	});
+	if (!i.is) return Xt(e, r, n);
+	({i: r} = i);
+	let a = U(e, r, n);
+	if (!a.is) return Xt(e, t, n);
+	let o;
+	({i: r, value: o} = a);
+	let s;
+	({i: r, argNames: s} = await Mt(e, r, n));
+	let c;
+	return {i: r, ops: c} = await J(e, r, n), {
+		i: r,
+		ops: [{
+			op: "va=",
+			params: {
+				name: o,
+				pipe: [{
+					op: "fun",
+					params: {
+						argNames: s,
+						pipe: c
+					}
+				}]
+			}
+		}]
+	};
+}
+async function Xt(e, t, n) {
+	let r = t, i = V(e, r, n, {
+		phrase: "func",
+		spaceAfter: !0
+	});
+	if (!i.is) return Zt(e, r, n);
+	({i: r} = i);
+	let a;
+	({i: r, argNames: a} = await Mt(e, r, n));
+	let o;
+	return {i: r, ops: o} = await J(e, r, n), {
+		i: r,
+		ops: [{
+			op: "fun",
+			params: {
+				argNames: a,
+				pipe: o
+			}
+		}]
+	};
+}
+async function Zt(e, t, n) {
+	let r = t, i = U(e, r, n);
+	if (!i.is) return Qt(e, r, n);
+	let a;
+	({i: r, value: a} = i);
+	let o, s, c = await Nt(e, r, n);
+	if (c.is ? {i: r, selectors: o, canAssign: s} = c : (o = [], s = !0), !s) {
+		let e = [{
+			op: "var",
+			params: { name: a }
+		}];
+		return o.length === 0 ? {
+			i: r,
+			ops: e
+		} : {
+			i: r,
+			ops: [{
+				op: "$.",
+				params: {
+					pipe: e,
+					selectors: o
+				}
+			}]
+		};
+	}
+	let l = await Pt(e, r, n);
+	if (!l.is) {
+		let e = [{
+			op: "var",
+			params: { name: a }
+		}];
+		return o.length === 0 ? {
+			i: r,
+			ops: e
+		} : {
+			i: r,
+			ops: [{
+				op: "$.",
+				params: {
+					pipe: e,
+					selectors: o
+				}
+			}]
+		};
+	}
+	let u;
+	return {i: r, assignment: u} = l, o.length === 0 && u.op === "=" ? {
+		i: r,
+		ops: [{
+			op: "va=",
+			params: {
+				name: a,
+				pipe: u.params.pipe
+			}
+		}]
+	} : {
+		i: r,
+		ops: [{
+			op: "va=",
+			params: {
+				name: a,
+				pipe: [{
+					op: "$=",
+					params: {
+						pipe: [{
+							op: "var",
+							params: { name: a }
+						}],
+						selectors: o,
+						assignment: u
+					}
+				}]
+			}
+		}]
+	};
+}
+async function Qt(e, t, n) {
+	let r = t, i = [], a, o = V(e, r, n, { phrase: "." });
+	if (!o.is) ({i: r, ops: a} = await $t(e, r, n));
+	else {
+		({i: r} = o), a = [];
+		let t = U(e, r, n);
+		if (t.is) {
+			let a;
+			({i: r, value: a} = t);
+			let s;
+			o = V(e, r, n, {
+				phrase: "?",
+				notBeforeSet: "?="
+			}), o.is && ({i: r, is: s} = o), i.push({
+				op: "$.$",
+				params: {
+					pipe: [{
+						op: "\"\"",
+						params: { string: a }
+					}],
+					optional: s
+				}
+			});
+		}
+	}
+	let s = await Nt(e, r, n, { identity: a.length === 0 && i.length === 0 }), c;
+	if (s.is ? ({i: r, canAssign: c} = s, i.push(...s.selectors)) : c = i.length > 0, i.length === 0) return {
+		i: r,
+		ops: a
+	};
+	if (!c) return {
+		i: r,
+		ops: [{
+			op: "$.",
+			params: {
+				pipe: a,
+				selectors: i
+			}
+		}]
+	};
+	let l = await Pt(e, r, n);
+	if (!l.is) return {
+		i: r,
+		ops: [{
+			op: "$.",
+			params: {
+				pipe: a,
+				selectors: i
+			}
+		}]
+	};
+	let u;
+	return {i: r, assignment: u} = l, {
+		i: r,
+		ops: [{
+			op: "$=",
+			params: {
+				pipe: a,
+				selectors: i,
+				assignment: u
+			}
+		}]
+	};
+}
+async function $t(e, t, n) {
+	let r = t, i = V(e, r, n, { phrase: "{" });
+	if (!i.is) return en(e, r, n);
+	({i: r} = i);
+	let a = [];
+	if (i = V(e, r, n, { phrase: "}" }), i.is) ({i: r} = i);
+	else for (;;) {
+		if (i = V(e, r, n, { phrase: "(" }), i.is) {
+			({i: r} = i);
+			let t;
+			if ({i: r, ops: t} = await K(e, r, n), i = V(e, r, n, { phrase: ")" }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ')'"
+			});
+			let o;
+			if ({i: r, is: o} = V(e, r, n, { phrase: "?" }), i = V(e, r, n, { phrase: ":" }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ':'"
+			});
+			let s;
+			if ({i: r, ops: s} = await q(e, r, n), a.push({
+				key: t,
+				value: s,
+				optional: o
+			}), i = V(e, r, n, { phrase: "}" }), i.is) {
+				({i: r} = i);
+				break;
+			}
+			if (i = V(e, r, n, { phrase: "," }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ',' or '}'"
+			});
+			continue;
+		}
+		let t = await It(e, r, n);
+		if (t.is) {
+			let o;
+			if ({i: r, ops: o} = t, i = V(e, r, n, { phrase: ":" }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ':'"
+			});
+			let s;
+			if ({i: r, ops: s} = await q(e, r, n), a.push({
+				key: o,
+				value: s,
+				optional: !1
+			}), i = V(e, r, n, { phrase: "}" }), i.is) {
+				({i: r} = i);
+				break;
+			}
+			if (i = V(e, r, n, { phrase: "," }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ',' or '}'"
+			});
+			continue;
+		}
+		let o = U(e, r, n);
+		if (o.is) {
+			let t;
+			({i: r, value: t} = o);
+			let s;
+			if (i = V(e, r, n, { phrase: ":" }), i.is) ({i: r} = i), {i: r, ops: s} = await q(e, r, n);
+			else {
+				let i;
+				({i: r, is: i} = V(e, r, n, { phrase: "?" })), s = i ? [{
+					op: "try",
+					params: {
+						try: [{
+							op: "var",
+							params: { name: t }
+						}],
+						catch: [{ op: "vod" }]
+					}
+				}] : [{
+					op: "var",
+					params: { name: t }
+				}];
+			}
+			if (a.push({
+				key: [{
+					op: "\"\"",
+					params: { string: t }
+				}],
+				value: s,
+				optional: !1
+			}), i = V(e, r, n, { phrase: "}" }), i.is) {
+				({i: r} = i);
+				break;
+			}
+			if (i = V(e, r, n, { phrase: "," }), {i: r} = i, !i.is) return G(e, r, n, {
+				operator: "object",
+				message: "expected ',' or '}'"
+			});
+			continue;
+		}
+		return G(e, r, n, {
+			operator: "object",
+			message: "expected field declaration"
+		});
+	}
+	return {
+		i: r,
+		ops: [{
+			op: "{}",
+			params: { fields: a }
+		}]
+	};
+}
+async function en(e, t, n) {
+	let r = t, i = V(e, r, n, { phrase: "[" });
+	if ({i: r} = i, !i.is) return tn(e, r, n);
+	let a;
+	if (i = V(e, r, n, { phrase: "]" }), i.is) ({i: r} = i), a = [{ op: "vod" }];
+	else if ({i: r, ops: a} = await K(e, r, n), i = V(e, r, n, { phrase: "]" }), {i: r} = i, !i.is) return G(e, r, n, {
+		operator: "array",
+		message: "expected ']'"
+	});
+	return {
+		i: r,
+		ops: [{
+			op: "[]",
+			params: { pipe: a }
+		}]
+	};
+}
+async function tn(e, t, n) {
+	let r = t, i = await It(e, r, n);
+	return i.is ? ({i: r} = i, {
+		i: r,
+		ops: i.ops
+	}) : nn(e, r, n);
+}
+async function nn(e, t, n) {
+	let r = t, i = V(e, r, n, { phrase: "(" });
+	if ({i: r} = i, !i.is) return G(e, r, n);
+	let a;
+	return {i: r, ops: a} = await K(e, r, n), i = V(e, r, n, { phrase: ")" }), {i: r} = i, i.is ? {
+		i: r,
+		ops: a
+	} : G(e, r, n, {
+		operator: "group",
+		message: "expected ')'"
+	});
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/interpreter/index.js
+var rn = {};
+function an(e = {}, t = {}) {
+	return d(e, t);
+}
+var on = class {
+	constructor(e) {
+		this._options = an(e?.interpreter, rn), this._programOptions = e?.program, this._runtimeOptions = e?.runtime;
+	}
+	get options() {
+		return this._options;
+	}
+	parse = async (e, t) => new _t({
+		version: h,
+		instructions: await this.parseInstructions(e)
+	}, {
+		program: ht(t?.program, this._programOptions),
+		runtime: F(t?.runtime, this._runtimeOptions)
+	});
+	parseInstructions = async (e) => {
+		let { ops: t } = await At(e, 0, { interpreter: this });
+		return t;
+	};
+}, sn = new on(), cn = /* @__PURE__ */ s({ sortEntries: () => ln }), ln = ye(async (e, t) => [await e.alterValue(t, (t) => [...t].sort((t, n) => e.compareArrays(e.unwrapValue(t)[0], e.unwrapValue(n)[0])))]);
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcContains.js
+function un(e, t, n, r, i) {
+	let a = e.unwrapValue(r), o = e.type(a), s = e.unwrapValue(i ?? null), c = e.type(s);
+	switch (o) {
+		case "array": return n(a.some((t) => e.equals(t, s)));
+		case "string":
+			if (c === "string") return n(a.includes(s));
+			break;
+		case "object": return n(Object.values(a).some((t) => e.equals(t, s)));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot contain %s (%*<100v)", o, a, c, s);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcEndsWith.js
+function dn(e, t, n, r, i) {
+	let a = e.unwrapValue(r), o = e.type(a), s = e.unwrapValue(i ?? null), c = e.type(s);
+	switch (o) {
+		case "string":
+			if (c === "string") return n(a.endsWith(s));
+			break;
+		default:
+	}
+	throw new M("%s (%*<100v) cannot end with %s (%*<100v)", o, a, c, s);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcError.js
+function fn(e, t, n, r) {
+	throw new j(r);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcFromJSON.js
+function pn(e, t, n, r) {
+	let i = e.unwrapValue(r), a = e.type(i);
+	switch (a) {
+		case "string": {
+			let e;
+			try {
+				e = JSON.parse(i);
+			} catch (e) {
+				throw new j(e.message);
+			}
+			return n(e);
+		}
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be parsed as JSON", a, i);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcHas.js
+function mn(e, t, n, r, i) {
+	let a = e.unwrapValue(r), o = e.type(a), s = e.unwrapValue(i ?? null), c = e.type(s);
+	switch (o) {
+		case "array":
+			if (c === "number") return n(s >= 0 && s < a.length);
+			break;
+		case "object":
+			if (c === "string") return n(Object.hasOwn(a, s));
+			break;
+		default:
+	}
+	throw new M("%s (%*<100v) cannot have %s (%*<100v) as key", o, a, c, s);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcIn.js
+function hn(e, t, n, r, i) {
+	let a = e.unwrapValue(r), o = e.type(a), s = e.unwrapValue(i ?? null), c = e.type(s);
+	switch (c) {
+		case "array":
+			if (o === "number") return n(a >= 0 && a < s.length);
+			break;
+		case "object":
+			if (o === "string") return n(Object.hasOwn(s, a));
+			break;
+		default:
+	}
+	throw new M("%s (%*<100v) cannot have %s (%*<100v) as key", c, s, o, a);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcKeys.js
+function gn(e, t, n, r) {
+	let i = e.unwrapValue(r), a = e.type(i);
+	switch (a) {
+		case "array": return n(i.map((e, t) => t));
+		case "object": return n(Object.keys(i));
+		default:
+	}
+	throw new M("%s (%*<100v) has no keys", a, i);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcLength.js
+function _n(e, t, n, r) {
+	let i = e.unwrapValue(r), a = e.type(i);
+	switch (a) {
+		case "null": return n(0);
+		case "array": return n(i.length);
+		case "string": return n([...i].length);
+		case "object": return n(Object.keys(i).length);
+		default:
+	}
+	throw new M("%s (%*<100v) has no length", a, i);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcNow.js
+function vn(e, t, n) {
+	return n(Date.now());
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcStartsWith.js
+function yn(e, t, n, r, i) {
+	let a = e.unwrapValue(r), o = e.type(a), s = e.unwrapValue(i ?? null), c = e.type(s);
+	switch (o) {
+		case "string":
+			if (c === "string") return n(a.startsWith(s));
+			break;
+		default:
+	}
+	throw new M("%s (%*<100v) cannot start with %s (%*<100v)", o, a, c, s);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcToJSON.js
+function bn(e, t, n, r) {
+	return n(e.stringifyJSON(r, !1));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcToLowerCase.js
+async function xn(e, t, n, r) {
+	let i = e.type(r);
+	switch (i) {
+		case "string": return n(await e.alterValue(r, (e) => e.toLowerCase()));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be converted to lower case", i, e.unwrapValue(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcToNumber.js
+function Sn(e, t, n, r) {
+	let i = e.unwrapValue(r), a = e.type(i);
+	switch (a) {
+		case "number": return n(i);
+		case "string": {
+			let t = e.normalizeValue(+i);
+			if (i === "" || e.type(t) !== "number") throw new fe("%s (%*<100v) does not contain a valid number", a, i);
+			return n(t);
+		}
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be parsed as a number", a, i);
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcToString.js
+function Cn(e, t, n, r) {
+	return n(e.stringifyJSON(r, !0));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcToUpperCase.js
+async function wn(e, t, n, r) {
+	let i = e.type(r);
+	switch (i) {
+		case "string": return n(await e.alterValue(r, (e) => e.toUpperCase()));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be converted to upper case", i, e.unwrapValue(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcTrim.js
+async function Tn(e, t, n, r) {
+	let i = e.type(r);
+	switch (i) {
+		case "string": return n(await e.alterValue(r, (e) => e.trim()));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be trimmed", i, e.unwrapValue(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcTrimEnd.js
+async function En(e, t, n, r) {
+	let i = e.type(r);
+	switch (i) {
+		case "string": return n(await e.alterValue(r, (e) => e.trimEnd()));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be trimmed", i, e.unwrapValue(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcTrimStart.js
+async function Dn(e, t, n, r) {
+	let i = e.type(r);
+	switch (i) {
+		case "string": return n(await e.alterValue(r, (e) => e.trimStart()));
+		default:
+	}
+	throw new M("%s (%*<100v) cannot be trimmed", i, e.unwrapValue(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcType.js
+function On(e, t, n, r) {
+	return n(e.type(r));
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/funcVoid.js
+function kn() {
+	return [];
+}
+//#endregion
+//#region node_modules/@jplorg/jpl/src/builtins/math.js
+function An(e, t) {
+	let n = e.type(t), r = e.unwrapValue(t);
+	if (n !== "number") throw new M("%s (%*<100v) cannot be used for mathematical operations", n, r);
+	return r;
+}
+function Q(e) {
+	return async function(t, n, r, i, ...a) {
+		let o = t.type(i);
+		if (o !== "number") throw new M("%s (%*<100v) cannot be used for mathematical operations", o, t.unwrapValue(i));
+		return r(await t.alterValue(i, (n) => e(t, n, ...a)));
+	};
+}
+var jn = Q((e, t, n) => t ** An(e, n ?? null)), Mn = Q((e, t) => Math.sqrt(t)), Nn = Q((e, t) => Math.exp(t)), Pn = Q((e, t) => Math.log(t)), Fn = Q((e, t) => Math.log10(t)), In = Q((e, t) => Math.sin(t)), Ln = Q((e, t) => Math.cos(t)), Rn = Q((e, t) => Math.tan(t)), zn = Q((e, t) => Math.asin(t)), Bn = Q((e, t) => Math.acos(t)), Vn = Q((e, t) => Math.atan(t)), Hn = Q((e, t) => Math.ceil(t)), Un = Q((e, t) => Math.floor(t)), Wn = Q((e, t) => Math.round(t)), Gn = Q((e, t) => Math.trunc(t)), Kn = Q((e, t) => Math.abs(t)), qn = /* @__PURE__ */ s({
+	abs: () => Kn,
+	acos: () => Bn,
+	asin: () => zn,
+	atan: () => Vn,
+	ceil: () => Hn,
+	contains: () => un,
+	cos: () => Ln,
+	endsWith: () => dn,
+	error: () => fn,
+	exp: () => Nn,
+	floor: () => Un,
+	fromJSON: () => pn,
+	has: () => mn,
+	in: () => hn,
+	keys: () => gn,
+	length: () => _n,
+	log: () => Pn,
+	log10: () => Fn,
+	now: () => vn,
+	pow: () => jn,
+	round: () => Wn,
+	sin: () => In,
+	sqrt: () => Mn,
+	startsWith: () => yn,
+	tan: () => Rn,
+	toJSON: () => bn,
+	toLowerCase: () => xn,
+	toNumber: () => Sn,
+	toString: () => Cn,
+	toUpperCase: () => wn,
+	trim: () => Tn,
+	trimEnd: () => En,
+	trimStart: () => Dn,
+	trunc: () => Gn,
+	type: () => On,
+	void: () => kn
+}), Jn = "\n# There are additional builtins that are implemented directly in the corresponding languages.\n# Also the functions in the \"internals\" namespace are not exposed to the public and are only to be used by the builtins below.\n\nfunc map(f): ([.[] | f()])\n| func mapValues(f): (.[] |= f())\n| func select(f): (if f() then . else void() end)\n| func reduce(f, s): (\n  l = length()\n  | func i(i, n, c): (if n < l then i(i, n + 1, f->(.[n], c, n)) else c end)\n  | i(i, 0, s)\n)\n| func while(cond, f): (\n  func i(i): (if cond() then ., i->(f(), i) else void() end)\n  | i(i)\n)\n| func until(cond, f): (\n  func i(i): (if cond() then . else i->(f(), i) end)\n  | i(i)\n)\n| func range(from, to, step): (\n  t = type->(from) | if t != \"number\" then error->(\"cannot use \\(t) as a number\") end\n  | t = type->(to) | if t != \"number\" then error->(\"cannot use \\(t) as a number\") end\n  | s = (step | if . != 0 and . != null then abs() else 1 end)\n  | while->(\n    from,\n    if from <= to then func (): (. < to) else func (): (. > to) end,\n    if from <= to then func (): (. + s) else func (): (. - s) end\n  )\n)\n\n\n# type selectors:\n| func isArray(): (type() == \"array\")\n| func arrays(): (select(isArray))\n| func isObject(): (type() == \"object\")\n| func objects(): (select(isObject))\n| func isIterable(): (contains->([\"array\", \"object\"], type()))\n| func iterables(): (select(isIterable))\n| func isScalar(): (not contains->([\"array\", \"object\"], type()))\n| func scalars(): (select(isScalar))\n| func isBoolean(): (type() == \"boolean\")\n| func booleans(): (select(isBoolean))\n| func isNumber(): (type() == \"number\")\n| func numbers(): (select(isNumber))\n| func isString(): (type() == \"string\")\n| func strings(): (select(isString))\n| func isNull(): (type() == \"null\")\n| func nulls(): (select(isNull))\n| func isFunction(): (type() == \"function\")\n| func functions(): (select(isFunction))\n| func isNullLike(): (contains->([\"null\", \"function\"], type()))\n| func nullLikes(): (select(isNullLike))\n| func isValue(): (not contains->([\"null\", \"function\"], type()))\n| func values(): (select(isValue))\n| func isContent(): (isValue() and not contains->([[], {}, \"\"], .))\n| func contents(): (select(isContent))\n\n\n| func toEntries(): (o = . | keys() | map(func (): ({ key: ., value: o[.] })))\n| func fromEntries(): (\n  reduce(\n    func (s): (s + { (.key ?? .Key ?? .name ?? .Name): if has(\"value\") then .value else .Value end }),\n    {}\n  )\n)\n| func withEntries(f): (toEntries() | map(f) | fromEntries())\n\n| func add(): (reduce(func (sum): (sum + .)))\n| func join(sep): (\n  reduce(\n    func (sum): (\n      if sum == null then \"\" else sum + sep end\n      + (. | toString())\n    )\n  ) ?? \"\"\n)\n| func sortBy(f): ([.[] | [[f()], .]] | internals.sortEntries() | [.[][1]])\n| func sort(): (sortBy(func (): (.)))\n| func groupBy(f): (\n  key = 0 | value = 1\n  | [.[] | [[f()], [.]]] | internals.sortEntries()\n  | if . == []\n  then .\n  else\n    reduce->(\n      .[1:],\n      func (sum): (if sum[-1][key] == .[key] then (sum)[-1][value] += .[value] else sum + [.] end),\n      .[:1]\n    )\n    | [.[][value]]\n  end\n)\n| func group(): (groupBy(func (): (.)))\n| func uniqueBy(f): (groupBy(f) | map(func (): (.[0])))\n| func unique(): (group() | map(func (): (.[0])))\n| func recurseBy(f, cond): (\n  c = cond ?? func (): (. != null)\n  | func r(r): (., (f() | select(c) | r(r)))\n  | r(r)\n)\n| func recurse(cond): (recurseBy(func (): ((arrays(), objects()) | .[]), cond))\n| func reverse(): ([.[length() - 1 - range(0, length())]])\n| func minBy(f): (\n  key = 0 | value = 1\n  | [.[] | [[f()], .]]\n  | reduce->(.[1:], func (sum): (if .[key] < sum[key] then . else sum end), .[0])\n  | .[value]\n)\n| func min(): (reduce->(.[1:], func (sum): (if . < sum then . else sum end), .[0]))\n| func maxBy(f): (\n  key = 0 | value = 1\n  | [.[] | [[f()], .]]\n  | reduce->(.[1:], func (sum): (if .[key] > sum[key] then . else sum end), .[0])\n  | .[value]\n)\n| func max(): (reduce->(.[1:], func (sum): (if . > sum then . else sum end), .[0]))\n| func first(f): ([f()][0])\n| func nth(which, f): (\n  [f()]\n  | .[if which | type() == \"number\" then which else length() | which() end]\n)\n| func last(f): ([f()][-1])\n| func isEmpty(f): (first(func (): ((f() | false), true)))\n| func allBy(f, cond): (isEmpty(func (): (f() | cond() and void())))\n| func all(cond): (allBy(func (): (.[]), cond))\n| func anyBy(f, cond): (not isEmpty(func (): (f() | cond() or void())))\n| func any(cond): (anyBy(func (): (.[]), cond))\n\n| func getPath(path): (\n  fields = (path | if type() == 'string' then . / '.' end)\n  | reduce->(fields, func (sum): sum[if type->(sum) == 'array' then toNumber() else toString() end], .)\n)\n| func updatePath(path, update): (\n  fields = (path | if type() == 'string' then (. / '.')[] |= (v = . | try toNumber() catch v) end)\n  | reduce->(\n    reverse->(fields),\n    func (sum): (\n      field = .\n      | func (): (\n        if type() == 'array'\n        then (\n          input = .\n          | try toNumber->(field) catch toString->(field)\n          | if type() == 'number'\n          then input[.] |= sum()\n          else {}[.] |= sum()\n          end\n        ) elif type() == 'object'\n        then (\n          .[toString->(field)] |= sum()\n        ) elif type->(field) == 'number'\n        then (\n          [][field] |= sum()\n        ) else (\n          {}[toString->(field)] |= sum()\n        )\n        end\n      )\n    ),\n    update\n  )->(.)\n)\n| func setPath(path, value): (\n  updatePath(path, func (): value)\n)\n", Yn = u(async () => {
+	await void 0;
+	let e = { ...qn };
+	return await (await sn.parse(Jn, { runtime: {
+		vars: {
+			internals: cn,
+			...qn
+		},
+		adjustResult: (t, n) => {
+			let { internals: r, ...i } = n.vars;
+			return e = f(e, Object.entries(i)), [];
+		}
+	} })).run([null]), e;
+}), Xn = u(async () => ({
+	interpreter: {},
+	program: {},
+	runtime: { vars: { ...await Yn() } }
+})), Zn = async (e, t) => {
+	let n = await Xn();
+	return new on({
+		interpreter: an(t?.interpreter, n.interpreter),
+		program: ht(t?.program, n.program),
+		runtime: F(t?.runtime, n.runtime)
+	}).parse(e);
+};
+({ ...Ce });
+//#endregion
+//#region node_modules/@rotorjs/dashboards/dist/main.js
+var Qn = [];
+for (let e = 0; e < 256; ++e) Qn.push((e + 256).toString(16).slice(1));
+var $n = class {
+	#e;
+	#t;
+	#n;
+	#r = {};
+	#i = !1;
+	#a;
+	#o = new AbortController();
+	constructor(e, t, n, r) {
+		this.#e = e, this.#t = Promise.resolve(t), this.#n = n, this.#a = r?.debounce;
+		let i = this.signal;
+		this.#e.addEventListener("interest", (e) => {
+			Object.hasOwn(this.#r, e.interest) && this.update();
+		}, { signal: i }), this.#n(t);
+	}
+	get engine() {
+		return this.#e;
+	}
+	get signal() {
+		return AbortSignal.any([this.#o.signal, this.engine.signal]);
+	}
+	addInterest(e) {
+		this.#r[e] = !0;
+	}
+	removeInterest(e) {
+		delete this.#r[e];
+	}
+	getInterests() {
+		return Object.keys(this.#r);
+	}
+	clearInterests() {
+		this.#r = {};
+	}
+	update() {
+		this.#i || (this.#i = !0, this.#t = this.#t.then(async (e) => {
+			if (await new Promise((e) => {
+				setTimeout(e, this.#a);
+			}), this.#i = !1, this.signal.aborted) return e;
+			let t;
+			try {
+				t = await this.reduce(e);
+			} catch (n) {
+				t = this.recover(e, n);
+			}
+			return this.signal.aborted ? e : (t !== e && this.#n(t), t);
+		}));
+	}
+	stop() {
+		this.#o.abort();
+	}
+}, $ = [];
+for (let e = 0; e < 256; ++e) $.push((e + 256).toString(16).slice(1));
+function er(e, t = 0) {
+	return ($[e[t + 0]] + $[e[t + 1]] + $[e[t + 2]] + $[e[t + 3]] + "-" + $[e[t + 4]] + $[e[t + 5]] + "-" + $[e[t + 6]] + $[e[t + 7]] + "-" + $[e[t + 8]] + $[e[t + 9]] + "-" + $[e[t + 10]] + $[e[t + 11]] + $[e[t + 12]] + $[e[t + 13]] + $[e[t + 14]] + $[e[t + 15]]).toLowerCase();
+}
+var tr = new Uint8Array(16);
+function nr() {
+	return crypto.getRandomValues(tr);
+}
+var rr = {};
+function ir(e, t, n) {
+	let r;
+	if (e) r = or(e.random ?? e.rng?.() ?? nr(), e.msecs, e.seq, t, n);
+	else {
+		let e = Date.now(), i = nr();
+		ar(rr, e, i), r = or(i, rr.msecs, rr.seq, t, n);
+	}
+	return t ?? er(r);
+}
+function ar(e, t, n) {
+	return e.msecs ??= -Infinity, e.seq ??= 0, t > e.msecs ? (e.seq = n[6] << 23 | n[7] << 16 | n[8] << 8 | n[9], e.msecs = t) : (e.seq = e.seq + 1 | 0, e.seq === 0 && e.msecs++), e;
+}
+function or(e, t, n, r, i = 0) {
+	if (e.length < 16) throw Error("Random bytes length must be >= 16");
+	if (!r) r = new Uint8Array(16), i = 0;
+	else if (i < 0 || i + 16 > r.length) throw RangeError(`UUID byte range ${i}:${i + 15} is out of buffer bounds`);
+	return t ??= Date.now(), n ??= e[6] * 127 << 24 | e[7] << 16 | e[8] << 8 | e[9], r[i++] = t / 1099511627776 & 255, r[i++] = t / 4294967296 & 255, r[i++] = t / 16777216 & 255, r[i++] = t / 65536 & 255, r[i++] = t / 256 & 255, r[i++] = t & 255, r[i++] = 112 | n >>> 28 & 15, r[i++] = n >>> 20 & 255, r[i++] = 128 | n >>> 14 & 63, r[i++] = n >>> 6 & 255, r[i++] = n << 2 & 255 | e[10] & 3, r[i++] = e[11], r[i++] = e[12], r[i++] = e[13], r[i++] = e[14], r[i++] = e[15], r;
+}
+var sr = class extends $n {
+	recover(e, t) {
+		return [{
+			type: "error",
+			id: ir(),
+			error: t
+		}];
+	}
+}, cr = /* @__PURE__ */ l((/* @__PURE__ */ o(((e, t) => {
+	t.exports = function e(t, n) {
+		if (t === n) return !0;
+		if (t && n && typeof t == "object" && typeof n == "object") {
+			if (t.constructor !== n.constructor) return !1;
+			var r, i, a;
+			if (Array.isArray(t)) {
+				if (r = t.length, r != n.length) return !1;
+				for (i = r; i-- !== 0;) if (!e(t[i], n[i])) return !1;
+				return !0;
+			}
+			if (t.constructor === RegExp) return t.source === n.source && t.flags === n.flags;
+			if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === n.valueOf();
+			if (t.toString !== Object.prototype.toString) return t.toString() === n.toString();
+			if (a = Object.keys(t), r = a.length, r !== Object.keys(n).length) return !1;
+			for (i = r; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(n, a[i])) return !1;
+			for (i = r; i-- !== 0;) {
+				var o = a[i];
+				if (!e(t[o], n[o])) return !1;
+			}
+			return !0;
+		}
+		return t !== t && n !== n;
+	};
+})))(), 1), lr = class extends sr {
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor(e, t, n, r) {
+		super(e, r?.initialState ?? [], n), this.#e = t, this.#n = r?.vars ?? {}, this.#r = r?.compare ?? cr.default, this.update();
+	}
+	async getProgram() {
+		if (this.#t) throw this.#t;
+		if (typeof this.#e == "string") try {
+			this.#e = await Zn(this.#e);
+		} catch (e) {
+			throw this.#t = e, e;
+		}
+		return this.#e;
+	}
+	async reduce(e) {
+		let t = await this.getProgram(), n = Object.fromEntries(Object.entries(this.#n).map(([e, t]) => [e, typeof t == "function" ? t(this) : t])), r = await t.run([null], { runtime: { vars: n } });
+		return this.#r(e, r) ? e : r;
+	}
+};
+//#endregion
+//#region lib/createJPLDashboardReducer.ts
+function ur(e) {
+	return (t, n, r) => new lr(t, n.src ?? "", r, e);
+}
+//#endregion
+export { lr as JPLDashboardReducer, ur as createJPLDashboardReducer };