@duxweb/dvha-naiveui 1.2.5 → 1.2.7

package/dist/esm/node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/delegate.js

@@ -0,0 +1,143 @@
+import { getEventTarget as e } from "./utils.js";
+import { trapOff as t, trapOn as n } from "./traps.js";
+//#region ../../node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/delegate.js
+function r() {
+	if (typeof window > "u") return {
+		on: () => {},
+		off: () => {}
+	};
+	let r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakMap();
+	function a() {
+		r.set(this, !0);
+	}
+	function o() {
+		r.set(this, !0), i.set(this, !0);
+	}
+	function s(e, t, n) {
+		let r = e[t];
+		return e[t] = function() {
+			return n.apply(e, arguments), r.apply(e, arguments);
+		}, e;
+	}
+	function c(e, t) {
+		e[t] = Event.prototype[t];
+	}
+	let l = /* @__PURE__ */ new WeakMap(), u = Object.getOwnPropertyDescriptor(Event.prototype, "currentTarget");
+	function d() {
+		return l.get(this) ?? null;
+	}
+	function f(e, t) {
+		u !== void 0 && Object.defineProperty(e, "currentTarget", {
+			configurable: !0,
+			enumerable: !0,
+			get: t ?? u.get
+		});
+	}
+	let p = {
+		bubble: {},
+		capture: {}
+	}, m = {};
+	function h() {
+		let t = function(t) {
+			let { type: n, eventPhase: u, bubbles: m } = t, h = e(t);
+			if (u === 2) return;
+			let g = u === 1 ? "capture" : "bubble", _ = h, v = [];
+			for (; _ === null && (_ = window), v.push(_), _ !== window;) _ = _.parentNode || null;
+			let y = p.capture[n], b = p.bubble[n];
+			if (s(t, "stopPropagation", a), s(t, "stopImmediatePropagation", o), f(t, d), g === "capture") {
+				if (y === void 0) return;
+				for (let e = v.length - 1; e >= 0 && !r.has(t); --e) {
+					let n = v[e], r = y.get(n);
+					if (r !== void 0) {
+						l.set(t, n);
+						for (let e of r) {
+							if (i.has(t)) break;
+							e(t);
+						}
+					}
+					if (e === 0 && !m && b !== void 0) {
+						let e = b.get(n);
+						if (e !== void 0) for (let n of e) {
+							if (i.has(t)) break;
+							n(t);
+						}
+					}
+				}
+			} else if (g === "bubble") {
+				if (b === void 0) return;
+				for (let e = 0; e < v.length && !r.has(t); ++e) {
+					let n = v[e], r = b.get(n);
+					if (r !== void 0) {
+						l.set(t, n);
+						for (let e of r) {
+							if (i.has(t)) break;
+							e(t);
+						}
+					}
+				}
+			}
+			c(t, "stopPropagation"), c(t, "stopImmediatePropagation"), f(t);
+		};
+		return t.displayName = "evtdUnifiedHandler", t;
+	}
+	function g() {
+		let e = function(e) {
+			let { type: t, eventPhase: n } = e;
+			if (n !== 2) return;
+			let r = m[t];
+			r !== void 0 && r.forEach((t) => t(e));
+		};
+		return e.displayName = "evtdUnifiedWindowEventHandler", e;
+	}
+	let _ = h(), v = g();
+	function y(e, t) {
+		let n = p[e];
+		return n[t] === void 0 && (n[t] = /* @__PURE__ */ new Map(), window.addEventListener(t, _, e === "capture")), n[t];
+	}
+	function b(e) {
+		return m[e] === void 0 && (m[e] = /* @__PURE__ */ new Set(), window.addEventListener(e, v)), m[e];
+	}
+	function x(e, t) {
+		let n = e.get(t);
+		return n === void 0 && e.set(t, n = /* @__PURE__ */ new Set()), n;
+	}
+	function S(e, t, n, r) {
+		let i = p[t][n];
+		if (i !== void 0) {
+			let t = i.get(e);
+			if (t !== void 0 && t.has(r)) return !0;
+		}
+		return !1;
+	}
+	function C(e, t) {
+		let n = m[e];
+		return !!(n !== void 0 && n.has(t));
+	}
+	function w(e, t, r, i) {
+		let a;
+		if (a = typeof i == "object" && i.once === !0 ? (n) => {
+			T(e, t, a, i), r(n);
+		} : r, n(e, t, a, i)) return;
+		let o = x(y(i === !0 || typeof i == "object" && i.capture === !0 ? "capture" : "bubble", e), t);
+		if (o.has(a) || o.add(a), t === window) {
+			let t = b(e);
+			t.has(a) || t.add(a);
+		}
+	}
+	function T(e, n, r, i) {
+		if (t(e, n, r, i)) return;
+		let a = i === !0 || typeof i == "object" && i.capture === !0, o = a ? "capture" : "bubble", s = y(o, e), c = x(s, n);
+		if (n === window && !S(n, a ? "bubble" : "capture", e, r) && C(e, r)) {
+			let t = m[e];
+			t.delete(r), t.size === 0 && (window.removeEventListener(e, v), m[e] = void 0);
+		}
+		c.has(r) && c.delete(r), c.size === 0 && s.delete(n), s.size === 0 && (window.removeEventListener(e, _, o === "capture"), p[o][e] = void 0);
+	}
+	return {
+		on: w,
+		off: T
+	};
+}
+var { on: i, off: a } = r();
+//#endregion
+export { a as off, i as on };

package/dist/esm/node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/traps.js

@@ -0,0 +1,57 @@
+import { getEventTarget as e } from "./utils.js";
+import { off as t, on as n } from "./delegate.js";
+//#region ../../node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/traps.js
+var r = {
+	mousemoveoutside: /* @__PURE__ */ new WeakMap(),
+	clickoutside: /* @__PURE__ */ new WeakMap()
+};
+function i(t, n, r) {
+	if (t === "mousemoveoutside") {
+		let t = (t) => {
+			n.contains(e(t)) || r(t);
+		};
+		return {
+			mousemove: t,
+			touchstart: t
+		};
+	} else if (t === "clickoutside") {
+		let t = !1, i = (r) => {
+			t = !n.contains(e(r));
+		}, a = (i) => {
+			t && (n.contains(e(i)) || r(i));
+		};
+		return {
+			mousedown: i,
+			mouseup: a,
+			touchstart: i,
+			touchend: a
+		};
+	}
+	return console.error(`[evtd/create-trap-handler]: name \`${t}\` is invalid. This could be a bug of evtd.`), {};
+}
+function a(e, t, n) {
+	let a = r[e], o = a.get(t);
+	o === void 0 && a.set(t, o = /* @__PURE__ */ new WeakMap());
+	let s = o.get(n);
+	return s === void 0 && o.set(n, s = i(e, t, n)), s;
+}
+function o(e, t, r, i) {
+	if (e === "mousemoveoutside" || e === "clickoutside") {
+		let o = a(e, t, r);
+		return Object.keys(o).forEach((e) => {
+			n(e, document, o[e], i);
+		}), !0;
+	}
+	return !1;
+}
+function s(e, n, r, i) {
+	if (e === "mousemoveoutside" || e === "clickoutside") {
+		let o = a(e, n, r);
+		return Object.keys(o).forEach((e) => {
+			t(e, document, o[e], i);
+		}), !0;
+	}
+	return !1;
+}
+//#endregion
+export { s as trapOff, o as trapOn };

package/dist/esm/node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/utils.js

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/evtd@0.2.4/node_modules/evtd/es/utils.js
+function e(e) {
+	return e.composedPath()[0];
+}
+//#endregion
+export { e as getEventTarget };

package/dist/esm/node_modules/.pnpm/jsep@1.4.0/node_modules/jsep/dist/jsep.js

@@ -0,0 +1,436 @@
+//#region ../../node_modules/.pnpm/jsep@1.4.0/node_modules/jsep/dist/jsep.js
+var e = class {
+	add(e, t, n) {
+		if (typeof arguments[0] != "string") for (let e in arguments[0]) this.add(e, arguments[0][e], arguments[1]);
+		else (Array.isArray(e) ? e : [e]).forEach(function(e) {
+			this[e] = this[e] || [], t && this[e][n ? "unshift" : "push"](t);
+		}, this);
+	}
+	run(e, t) {
+		this[e] = this[e] || [], this[e].forEach(function(e) {
+			e.call(t && t.context ? t.context : t, t);
+		});
+	}
+}, t = class {
+	constructor(e) {
+		this.jsep = e, this.registered = {};
+	}
+	register(...e) {
+		e.forEach((e) => {
+			if (typeof e != "object" || !e.name || !e.init) throw Error("Invalid JSEP plugin format");
+			this.registered[e.name] || (e.init(this.jsep), this.registered[e.name] = e);
+		});
+	}
+}, n = class e {
+	static get version() {
+		return "1.4.0";
+	}
+	static toString() {
+		return "JavaScript Expression Parser (JSEP) v" + e.version;
+	}
+	static addUnaryOp(t) {
+		return e.max_unop_len = Math.max(t.length, e.max_unop_len), e.unary_ops[t] = 1, e;
+	}
+	static addBinaryOp(t, n, r) {
+		return e.max_binop_len = Math.max(t.length, e.max_binop_len), e.binary_ops[t] = n, r ? e.right_associative.add(t) : e.right_associative.delete(t), e;
+	}
+	static addIdentifierChar(t) {
+		return e.additional_identifier_chars.add(t), e;
+	}
+	static addLiteral(t, n) {
+		return e.literals[t] = n, e;
+	}
+	static removeUnaryOp(t) {
+		return delete e.unary_ops[t], t.length === e.max_unop_len && (e.max_unop_len = e.getMaxKeyLen(e.unary_ops)), e;
+	}
+	static removeAllUnaryOps() {
+		return e.unary_ops = {}, e.max_unop_len = 0, e;
+	}
+	static removeIdentifierChar(t) {
+		return e.additional_identifier_chars.delete(t), e;
+	}
+	static removeBinaryOp(t) {
+		return delete e.binary_ops[t], t.length === e.max_binop_len && (e.max_binop_len = e.getMaxKeyLen(e.binary_ops)), e.right_associative.delete(t), e;
+	}
+	static removeAllBinaryOps() {
+		return e.binary_ops = {}, e.max_binop_len = 0, e;
+	}
+	static removeLiteral(t) {
+		return delete e.literals[t], e;
+	}
+	static removeAllLiterals() {
+		return e.literals = {}, e;
+	}
+	get char() {
+		return this.expr.charAt(this.index);
+	}
+	get code() {
+		return this.expr.charCodeAt(this.index);
+	}
+	constructor(e) {
+		this.expr = e, this.index = 0;
+	}
+	static parse(t) {
+		return new e(t).parse();
+	}
+	static getMaxKeyLen(e) {
+		return Math.max(0, ...Object.keys(e).map((e) => e.length));
+	}
+	static isDecimalDigit(e) {
+		return e >= 48 && e <= 57;
+	}
+	static binaryPrecedence(t) {
+		return e.binary_ops[t] || 0;
+	}
+	static isIdentifierStart(t) {
+		return t >= 65 && t <= 90 || t >= 97 && t <= 122 || t >= 128 && !e.binary_ops[String.fromCharCode(t)] || e.additional_identifier_chars.has(String.fromCharCode(t));
+	}
+	static isIdentifierPart(t) {
+		return e.isIdentifierStart(t) || e.isDecimalDigit(t);
+	}
+	throwError(e) {
+		let t = /* @__PURE__ */ Error(e + " at character " + this.index);
+		throw t.index = this.index, t.description = e, t;
+	}
+	runHook(t, n) {
+		if (e.hooks[t]) {
+			let r = {
+				context: this,
+				node: n
+			};
+			return e.hooks.run(t, r), r.node;
+		}
+		return n;
+	}
+	searchHook(t) {
+		if (e.hooks[t]) {
+			let n = { context: this };
+			return e.hooks[t].find(function(e) {
+				return e.call(n.context, n), n.node;
+			}), n.node;
+		}
+	}
+	gobbleSpaces() {
+		let t = this.code;
+		for (; t === e.SPACE_CODE || t === e.TAB_CODE || t === e.LF_CODE || t === e.CR_CODE;) t = this.expr.charCodeAt(++this.index);
+		this.runHook("gobble-spaces");
+	}
+	parse() {
+		this.runHook("before-all");
+		let t = this.gobbleExpressions(), n = t.length === 1 ? t[0] : {
+			type: e.COMPOUND,
+			body: t
+		};
+		return this.runHook("after-all", n);
+	}
+	gobbleExpressions(t) {
+		let n = [], r, i;
+		for (; this.index < this.expr.length;) if (r = this.code, r === e.SEMCOL_CODE || r === e.COMMA_CODE) this.index++;
+		else if (i = this.gobbleExpression()) n.push(i);
+		else if (this.index < this.expr.length) {
+			if (r === t) break;
+			this.throwError("Unexpected \"" + this.char + "\"");
+		}
+		return n;
+	}
+	gobbleExpression() {
+		let e = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+		return this.gobbleSpaces(), this.runHook("after-expression", e);
+	}
+	gobbleBinaryOp() {
+		this.gobbleSpaces();
+		let t = this.expr.substr(this.index, e.max_binop_len), n = t.length;
+		for (; n > 0;) {
+			if (e.binary_ops.hasOwnProperty(t) && (!e.isIdentifierStart(this.code) || this.index + t.length < this.expr.length && !e.isIdentifierPart(this.expr.charCodeAt(this.index + t.length)))) return this.index += n, t;
+			t = t.substr(0, --n);
+		}
+		return !1;
+	}
+	gobbleBinaryExpression() {
+		let t, n, r, i, a, o, s, c, l;
+		if (o = this.gobbleToken(), !o || (n = this.gobbleBinaryOp(), !n)) return o;
+		for (a = {
+			value: n,
+			prec: e.binaryPrecedence(n),
+			right_a: e.right_associative.has(n)
+		}, s = this.gobbleToken(), s || this.throwError("Expected expression after " + n), i = [
+			o,
+			a,
+			s
+		]; n = this.gobbleBinaryOp();) {
+			if (r = e.binaryPrecedence(n), r === 0) {
+				this.index -= n.length;
+				break;
+			}
+			a = {
+				value: n,
+				prec: r,
+				right_a: e.right_associative.has(n)
+			}, l = n;
+			let c = (e) => a.right_a && e.right_a ? r > e.prec : r <= e.prec;
+			for (; i.length > 2 && c(i[i.length - 2]);) s = i.pop(), n = i.pop().value, o = i.pop(), t = {
+				type: e.BINARY_EXP,
+				operator: n,
+				left: o,
+				right: s
+			}, i.push(t);
+			t = this.gobbleToken(), t || this.throwError("Expected expression after " + l), i.push(a, t);
+		}
+		for (c = i.length - 1, t = i[c]; c > 1;) t = {
+			type: e.BINARY_EXP,
+			operator: i[c - 1].value,
+			left: i[c - 2],
+			right: t
+		}, c -= 2;
+		return t;
+	}
+	gobbleToken() {
+		let t, n, r, i;
+		if (this.gobbleSpaces(), i = this.searchHook("gobble-token"), i) return this.runHook("after-token", i);
+		if (t = this.code, e.isDecimalDigit(t) || t === e.PERIOD_CODE) return this.gobbleNumericLiteral();
+		if (t === e.SQUOTE_CODE || t === e.DQUOTE_CODE) i = this.gobbleStringLiteral();
+		else if (t === e.OBRACK_CODE) i = this.gobbleArray();
+		else {
+			for (n = this.expr.substr(this.index, e.max_unop_len), r = n.length; r > 0;) {
+				if (e.unary_ops.hasOwnProperty(n) && (!e.isIdentifierStart(this.code) || this.index + n.length < this.expr.length && !e.isIdentifierPart(this.expr.charCodeAt(this.index + n.length)))) {
+					this.index += r;
+					let t = this.gobbleToken();
+					return t || this.throwError("missing unaryOp argument"), this.runHook("after-token", {
+						type: e.UNARY_EXP,
+						operator: n,
+						argument: t,
+						prefix: !0
+					});
+				}
+				n = n.substr(0, --r);
+			}
+			e.isIdentifierStart(t) ? (i = this.gobbleIdentifier(), e.literals.hasOwnProperty(i.name) ? i = {
+				type: e.LITERAL,
+				value: e.literals[i.name],
+				raw: i.name
+			} : i.name === e.this_str && (i = { type: e.THIS_EXP })) : t === e.OPAREN_CODE && (i = this.gobbleGroup());
+		}
+		return i ? (i = this.gobbleTokenProperty(i), this.runHook("after-token", i)) : this.runHook("after-token", !1);
+	}
+	gobbleTokenProperty(t) {
+		this.gobbleSpaces();
+		let n = this.code;
+		for (; n === e.PERIOD_CODE || n === e.OBRACK_CODE || n === e.OPAREN_CODE || n === e.QUMARK_CODE;) {
+			let r;
+			if (n === e.QUMARK_CODE) {
+				if (this.expr.charCodeAt(this.index + 1) !== e.PERIOD_CODE) break;
+				r = !0, this.index += 2, this.gobbleSpaces(), n = this.code;
+			}
+			this.index++, n === e.OBRACK_CODE ? (t = {
+				type: e.MEMBER_EXP,
+				computed: !0,
+				object: t,
+				property: this.gobbleExpression()
+			}, t.property || this.throwError("Unexpected \"" + this.char + "\""), this.gobbleSpaces(), n = this.code, n !== e.CBRACK_CODE && this.throwError("Unclosed ["), this.index++) : n === e.OPAREN_CODE ? t = {
+				type: e.CALL_EXP,
+				arguments: this.gobbleArguments(e.CPAREN_CODE),
+				callee: t
+			} : (n === e.PERIOD_CODE || r) && (r && this.index--, this.gobbleSpaces(), t = {
+				type: e.MEMBER_EXP,
+				computed: !1,
+				object: t,
+				property: this.gobbleIdentifier()
+			}), r && (t.optional = !0), this.gobbleSpaces(), n = this.code;
+		}
+		return t;
+	}
+	gobbleNumericLiteral() {
+		let t = "", n, r;
+		for (; e.isDecimalDigit(this.code);) t += this.expr.charAt(this.index++);
+		if (this.code === e.PERIOD_CODE) for (t += this.expr.charAt(this.index++); e.isDecimalDigit(this.code);) t += this.expr.charAt(this.index++);
+		if (n = this.char, n === "e" || n === "E") {
+			for (t += this.expr.charAt(this.index++), n = this.char, (n === "+" || n === "-") && (t += this.expr.charAt(this.index++)); e.isDecimalDigit(this.code);) t += this.expr.charAt(this.index++);
+			e.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) || this.throwError("Expected exponent (" + t + this.char + ")");
+		}
+		return r = this.code, e.isIdentifierStart(r) ? this.throwError("Variable names cannot start with a number (" + t + this.char + ")") : (r === e.PERIOD_CODE || t.length === 1 && t.charCodeAt(0) === e.PERIOD_CODE) && this.throwError("Unexpected period"), {
+			type: e.LITERAL,
+			value: parseFloat(t),
+			raw: t
+		};
+	}
+	gobbleStringLiteral() {
+		let t = "", n = this.index, r = this.expr.charAt(this.index++), i = !1;
+		for (; this.index < this.expr.length;) {
+			let e = this.expr.charAt(this.index++);
+			if (e === r) {
+				i = !0;
+				break;
+			} else if (e === "\\") switch (e = this.expr.charAt(this.index++), e) {
+				case "n":
+					t += "\n";
+					break;
+				case "r":
+					t += "\r";
+					break;
+				case "t":
+					t += "	";
+					break;
+				case "b":
+					t += "\b";
+					break;
+				case "f":
+					t += "\f";
+					break;
+				case "v":
+					t += "\v";
+					break;
+				default: t += e;
+			}
+			else t += e;
+		}
+		return i || this.throwError("Unclosed quote after \"" + t + "\""), {
+			type: e.LITERAL,
+			value: t,
+			raw: this.expr.substring(n, this.index)
+		};
+	}
+	gobbleIdentifier() {
+		let t = this.code, n = this.index;
+		for (e.isIdentifierStart(t) ? this.index++ : this.throwError("Unexpected " + this.char); this.index < this.expr.length && (t = this.code, e.isIdentifierPart(t));) this.index++;
+		return {
+			type: e.IDENTIFIER,
+			name: this.expr.slice(n, this.index)
+		};
+	}
+	gobbleArguments(t) {
+		let n = [], r = !1, i = 0;
+		for (; this.index < this.expr.length;) {
+			this.gobbleSpaces();
+			let a = this.code;
+			if (a === t) {
+				r = !0, this.index++, t === e.CPAREN_CODE && i && i >= n.length && this.throwError("Unexpected token " + String.fromCharCode(t));
+				break;
+			} else if (a === e.COMMA_CODE) {
+				if (this.index++, i++, i !== n.length) {
+					if (t === e.CPAREN_CODE) this.throwError("Unexpected token ,");
+					else if (t === e.CBRACK_CODE) for (let e = n.length; e < i; e++) n.push(null);
+				}
+			} else if (n.length !== i && i !== 0) this.throwError("Expected comma");
+			else {
+				let t = this.gobbleExpression();
+				(!t || t.type === e.COMPOUND) && this.throwError("Expected comma"), n.push(t);
+			}
+		}
+		return r || this.throwError("Expected " + String.fromCharCode(t)), n;
+	}
+	gobbleGroup() {
+		this.index++;
+		let t = this.gobbleExpressions(e.CPAREN_CODE);
+		if (this.code === e.CPAREN_CODE) return this.index++, t.length === 1 ? t[0] : t.length ? {
+			type: e.SEQUENCE_EXP,
+			expressions: t
+		} : !1;
+		this.throwError("Unclosed (");
+	}
+	gobbleArray() {
+		return this.index++, {
+			type: e.ARRAY_EXP,
+			elements: this.gobbleArguments(e.CBRACK_CODE)
+		};
+	}
+}, r = new e();
+Object.assign(n, {
+	hooks: r,
+	plugins: new t(n),
+	COMPOUND: "Compound",
+	SEQUENCE_EXP: "SequenceExpression",
+	IDENTIFIER: "Identifier",
+	MEMBER_EXP: "MemberExpression",
+	LITERAL: "Literal",
+	THIS_EXP: "ThisExpression",
+	CALL_EXP: "CallExpression",
+	UNARY_EXP: "UnaryExpression",
+	BINARY_EXP: "BinaryExpression",
+	ARRAY_EXP: "ArrayExpression",
+	TAB_CODE: 9,
+	LF_CODE: 10,
+	CR_CODE: 13,
+	SPACE_CODE: 32,
+	PERIOD_CODE: 46,
+	COMMA_CODE: 44,
+	SQUOTE_CODE: 39,
+	DQUOTE_CODE: 34,
+	OPAREN_CODE: 40,
+	CPAREN_CODE: 41,
+	OBRACK_CODE: 91,
+	CBRACK_CODE: 93,
+	QUMARK_CODE: 63,
+	SEMCOL_CODE: 59,
+	COLON_CODE: 58,
+	unary_ops: {
+		"-": 1,
+		"!": 1,
+		"~": 1,
+		"+": 1
+	},
+	binary_ops: {
+		"||": 1,
+		"??": 1,
+		"&&": 2,
+		"|": 3,
+		"^": 4,
+		"&": 5,
+		"==": 6,
+		"!=": 6,
+		"===": 6,
+		"!==": 6,
+		"<": 7,
+		">": 7,
+		"<=": 7,
+		">=": 7,
+		"<<": 8,
+		">>": 8,
+		">>>": 8,
+		"+": 9,
+		"-": 9,
+		"*": 10,
+		"/": 10,
+		"%": 10,
+		"**": 11
+	},
+	right_associative: new Set(["**"]),
+	additional_identifier_chars: new Set(["$", "_"]),
+	literals: {
+		true: !0,
+		false: !1,
+		null: null
+	},
+	this_str: "this"
+}), n.max_unop_len = n.getMaxKeyLen(n.unary_ops), n.max_binop_len = n.getMaxKeyLen(n.binary_ops);
+var i = (e) => new n(e).parse(), a = Object.getOwnPropertyNames(class {});
+Object.getOwnPropertyNames(n).filter((e) => !a.includes(e) && i[e] === void 0).forEach((e) => {
+	i[e] = n[e];
+}), i.Jsep = n;
+var o = "ConditionalExpression";
+i.plugins.register({
+	name: "ternary",
+	init(e) {
+		e.hooks.add("after-expression", function(t) {
+			if (t.node && this.code === e.QUMARK_CODE) {
+				this.index++;
+				let n = t.node, r = this.gobbleExpression();
+				if (r || this.throwError("Expected expression"), this.gobbleSpaces(), this.code === e.COLON_CODE) {
+					this.index++;
+					let i = this.gobbleExpression();
+					if (i || this.throwError("Expected expression"), t.node = {
+						type: o,
+						test: n,
+						consequent: r,
+						alternate: i
+					}, n.operator && e.binary_ops[n.operator] <= .9) {
+						let r = n;
+						for (; r.right.operator && e.binary_ops[r.right.operator] <= .9;) r = r.right;
+						t.node.test = r.right, r.right = t.node, t.node = n;
+					}
+				} else this.throwError("Expected :");
+			}
+		});
+	}
+});
+//#endregion
+export { i as jsep };

package/dist/esm/node_modules/.pnpm/json-2-csv@5.5.10/node_modules/json-2-csv/lib/constants.js

@@ -0,0 +1,53 @@
+import { __commonJSMin as e } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/json-2-csv@5.5.10/node_modules/json-2-csv/lib/constants.js
+var t = /* @__PURE__ */ e(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.excelBOM = e.defaultCsv2JsonOptions = e.defaultJson2CsvOptions = e.errors = void 0, e.errors = {
+		optionsRequired: "Options were not passed and are required.",
+		json2csv: {
+			cannotCallOn: "Cannot call json2csv on",
+			dataCheckFailure: "Data provided was not an array of documents.",
+			notSameSchema: "Not all documents have the same schema."
+		},
+		csv2json: {
+			cannotCallOn: "Cannot call csv2json on",
+			dataCheckFailure: "CSV is not a string."
+		}
+	}, e.defaultJson2CsvOptions = {
+		arrayIndexesAsKeys: !1,
+		checkSchemaDifferences: !1,
+		delimiter: {
+			field: ",",
+			wrap: "\"",
+			eol: "\n"
+		},
+		emptyFieldValue: void 0,
+		escapeHeaderNestedDots: !0,
+		excelBOM: !1,
+		excludeKeys: [],
+		expandNestedObjects: !0,
+		expandArrayObjects: !1,
+		prependHeader: !0,
+		preventCsvInjection: !1,
+		sortHeader: !1,
+		trimFieldValues: !1,
+		trimHeaderFields: !1,
+		unwindArrays: !1,
+		useDateIso8601Format: !1,
+		useLocaleFormat: !1,
+		wrapBooleans: !1,
+		fieldTitleMap: Object.create({})
+	}, e.defaultCsv2JsonOptions = {
+		delimiter: {
+			field: ",",
+			wrap: "\"",
+			eol: "\n"
+		},
+		excelBOM: !1,
+		preventCsvInjection: !1,
+		trimFieldValues: !1,
+		trimHeaderFields: !1
+	}, e.excelBOM = "";
+}));
+//#endregion
+export default t();
+export { t as require_constants };