@ohtaman/washi 0.1.1 → 0.1.2

package/dist/browser/washi.js

@@ -0,0 +1,1547 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./highs-loader-T47YOyos.js";
+//#region src/modeler/boolean-expr.ts
+var l = 0, u = class {
+	and(e) {
+		return new f("and", [this, e]);
+	}
+	or(e) {
+		return new f("or", [this, e]);
+	}
+	implies(e) {
+		return new f("implies", [this, e]);
+	}
+	xor(e) {
+		return new f("xor", [this, e]);
+	}
+	not() {
+		return new f("not", [this]);
+	}
+}, d = class extends u {
+	id;
+	name;
+	value = null;
+	constructor(e) {
+		super(), this.id = ++l, this.name = e || `p_${this.id}`;
+	}
+	toString() {
+		return this.name;
+	}
+}, f = class extends u {
+	op;
+	children;
+	constructor(e, t) {
+		super(), this.op = e, this.children = t;
+	}
+	toString() {
+		return this.op === "not" ? `not(${this.children[0].toString()})` : `(${this.children.map((e) => e.toString()).join(` ${this.op} `)})`;
+	}
+};
+function p(...e) {
+	if (e.length === 0) throw Error("and() requires at least one expression");
+	return new f("and", e);
+}
+function m(...e) {
+	if (e.length === 0) throw Error("or() requires at least one expression");
+	return new f("or", e);
+}
+function h(e) {
+	return new f("not", [e]);
+}
+function g(e, t) {
+	return new f("implies", [e, t]);
+}
+function _(...e) {
+	if (e.length === 0) throw Error("xor() requires at least one expression");
+	return new f("xor", e);
+}
+//#endregion
+//#region src/modeler/constraint.ts
+var v = 0, y = class {
+	id;
+	lhs;
+	sense;
+	rhs;
+	name;
+	slack = null;
+	dual = null;
+	constructor(e, t, n, r) {
+		this.id = ++v, this.lhs = e, this.sense = t, this.rhs = n, this.name = r || `c_${this.id}`;
+	}
+	get pi() {
+		return this.dual;
+	}
+	and(e) {
+		return new f("and", [this, e]);
+	}
+	or(e) {
+		return new f("or", [this, e]);
+	}
+	implies(e) {
+		return new f("implies", [this, e]);
+	}
+	xor(e) {
+		return new f("xor", [this, e]);
+	}
+	not() {
+		return new f("not", [this]);
+	}
+	toString() {
+		let e = this.sense === "==" ? "=" : this.sense;
+		return `${this.name}: ${this.lhs.toString()} ${e} ${this.rhs}`;
+	}
+};
+//#endregion
+//#region src/modeler/quad-expr.ts
+function b(e, t) {
+	let n = e.id, r = t.id;
+	return n <= r ? `${n}:${r}` : `${r}:${n}`;
+}
+var x = class e {
+	linearTerms;
+	quadTerms;
+	constant;
+	constructor(e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), n = 0) {
+		this.linearTerms = new Map(e), this.quadTerms = /* @__PURE__ */ new Map();
+		for (let [e, n] of t) this.quadTerms.set(e, { ...n });
+		this.constant = n;
+	}
+	clone() {
+		return new e(this.linearTerms, this.quadTerms, this.constant);
+	}
+	getQuadCoeff(e, t) {
+		let n = b(e, t), r = this.quadTerms.get(n);
+		return r ? r.coeff : 0;
+	}
+	add(t) {
+		let n = this.clone();
+		if (typeof t == "number") return n.constant += t, n;
+		if (t instanceof e) {
+			for (let [e, r] of t.quadTerms) {
+				let t = n.quadTerms.get(e), i = (t ? t.coeff : 0) + r.coeff;
+				Math.abs(i) < 1e-12 ? n.quadTerms.delete(e) : n.quadTerms.set(e, {
+					var1: r.var1,
+					var2: r.var2,
+					coeff: i
+				});
+			}
+			for (let [e, r] of t.linearTerms) {
+				let t = (n.linearTerms.get(e) || 0) + r;
+				Math.abs(t) < 1e-12 ? n.linearTerms.delete(e) : n.linearTerms.set(e, t);
+			}
+			return n.constant += t.constant, n;
+		}
+		if ("terms" in t && t.terms instanceof Map) {
+			for (let [e, r] of t.terms) {
+				let t = (n.linearTerms.get(e) || 0) + r;
+				Math.abs(t) < 1e-12 ? n.linearTerms.delete(e) : n.linearTerms.set(e, t);
+			}
+			return n.constant += t.constant, n;
+		}
+		let r = t, i = (n.linearTerms.get(r) || 0) + 1;
+		return Math.abs(i) < 1e-12 ? n.linearTerms.delete(r) : n.linearTerms.set(r, i), n;
+	}
+	sub(t) {
+		return typeof t == "number" ? this.add(-t) : t instanceof e ? this.add(t.neg()) : ("terms" in t && t.terms instanceof Map, this.add(t.mul(-1)));
+	}
+	mul(t) {
+		let n = new e(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), this.constant * t);
+		for (let [e, r] of this.linearTerms) {
+			let i = r * t;
+			Math.abs(i) >= 1e-12 && n.linearTerms.set(e, i);
+		}
+		for (let [e, r] of this.quadTerms) {
+			let i = r.coeff * t;
+			Math.abs(i) >= 1e-12 && n.quadTerms.set(e, {
+				var1: r.var1,
+				var2: r.var2,
+				coeff: i
+			});
+		}
+		return n;
+	}
+	div(e) {
+		if (Math.abs(e) < 1e-12) throw Error("Division by zero in QuadExpr.div()");
+		return this.mul(1 / e);
+	}
+	neg() {
+		return this.mul(-1);
+	}
+	get value() {
+		let e = this.constant;
+		for (let [t, n] of this.linearTerms) {
+			if (t.value === null) return null;
+			e += n * t.value;
+		}
+		for (let t of this.quadTerms.values()) {
+			if (t.var1.value === null || t.var2.value === null) return null;
+			e += t.coeff * t.var1.value * t.var2.value;
+		}
+		return e;
+	}
+	getValue() {
+		return this.value;
+	}
+	static fromProduct(t, n, r = 1) {
+		let i = new e(), a = b(t, n);
+		return i.quadTerms.set(a, {
+			var1: t.id <= n.id ? t : n,
+			var2: t.id <= n.id ? n : t,
+			coeff: r
+		}), i;
+	}
+}, S = class e {
+	terms;
+	constant;
+	constructor(e = /* @__PURE__ */ new Map(), t = 0) {
+		this.terms = new Map(e), this.constant = t;
+	}
+	clone() {
+		return new e(this.terms, this.constant);
+	}
+	add(e) {
+		if (e instanceof x) return e.add(this);
+		let t = this.clone();
+		if (typeof e == "number") t.constant += e;
+		else if ("terms" in e) {
+			for (let [n, r] of e.terms) {
+				let e = (t.terms.get(n) || 0) + r;
+				Math.abs(e) < 1e-12 ? t.terms.delete(n) : t.terms.set(n, e);
+			}
+			t.constant += e.constant;
+		} else {
+			let n = (t.terms.get(e) || 0) + 1;
+			Math.abs(n) < 1e-12 ? t.terms.delete(e) : t.terms.set(e, n);
+		}
+		return t;
+	}
+	sub(e) {
+		return e instanceof x ? e.neg().add(this) : typeof e == "number" ? this.add(-e) : ("terms" in e, this.add(e.mul(-1)));
+	}
+	mul(t) {
+		if (typeof t == "number") {
+			let n = new e(/* @__PURE__ */ new Map(), this.constant * t);
+			for (let [e, r] of this.terms) {
+				let i = r * t;
+				Math.abs(i) >= 1e-12 && n.terms.set(e, i);
+			}
+			return n;
+		}
+		let n = new x();
+		Math.abs(this.constant) >= 1e-12 && n.linearTerms.set(t, this.constant);
+		for (let [e, r] of this.terms) n = n.add(x.fromProduct(e, t, r));
+		return n;
+	}
+	div(e) {
+		if (Math.abs(e) < 1e-12) throw Error("Division by zero in LinExpr.div()");
+		return this.mul(1 / e);
+	}
+	neg() {
+		return this.mul(-1);
+	}
+	get value() {
+		let e = this.constant;
+		for (let [t, n] of this.terms) {
+			if (t.value === null) return null;
+			e += n * t.value;
+		}
+		return e;
+	}
+	getValue() {
+		return this.value;
+	}
+	le(e, t) {
+		return this.toConstraint("<=", e, t);
+	}
+	lessThanOrEqual(e, t) {
+		return this.le(e, t);
+	}
+	ge(e, t) {
+		return this.toConstraint(">=", e, t);
+	}
+	greaterThanOrEqual(e, t) {
+		return this.ge(e, t);
+	}
+	eq(e, t) {
+		return this.toConstraint("==", e, t);
+	}
+	equalTo(e, t) {
+		return this.eq(e, t);
+	}
+	toConstraint(t, n, r) {
+		let i = this.clone(), a = 0;
+		typeof n == "number" ? a = n : "terms" in n ? (i = i.sub(new e(n.terms, 0)), a = n.constant) : i = i.sub(n);
+		let o = a - i.constant;
+		return i.constant = 0, new y(i, t, o, r);
+	}
+	toString() {
+		let e = [], t = !0;
+		for (let [n, r] of this.terms) {
+			let i = r >= 0 ? t ? "" : "+ " : "- ", a = Math.abs(r), o = a === 1 ? "" : `${a} `;
+			e.push(`${i}${o}${n.name}`), t = !1;
+		}
+		if (this.constant !== 0 || e.length === 0) {
+			let n = this.constant >= 0 ? t ? "" : "+ " : "- ";
+			e.push(`${n}${Math.abs(this.constant)}`);
+		}
+		return e.join(" ") || "0";
+	}
+};
+function C(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = 0, i = 0;
+	for (let a of e) {
+		let e = t ? t(a, i++) : a;
+		if (typeof e == "number") r += e;
+		else if (e && typeof e == "object" && "terms" in e) {
+			let t = e;
+			for (let [e, r] of t.terms) {
+				let t = n.get(e) || 0;
+				n.set(e, t + r);
+			}
+			r += t.constant;
+		} else if (e) {
+			let t = e, r = n.get(t) || 0;
+			n.set(t, r + 1);
+		}
+	}
+	for (let [e, t] of n) Math.abs(t) < 1e-12 && n.delete(e);
+	return new S(n, r);
+}
+var w = C, T = C, E = 0, D = class e {
+	id;
+	name;
+	type;
+	lb;
+	ub;
+	value = null;
+	reducedCost = null;
+	constructor(e = {}) {
+		this.id = ++E, this.name = e.name || `x_${this.id}`, this.type = e.type || "Continuous", this.type === "Binary" ? (this.lb = 0, this.ub = 1) : (this.lb = e.lb === void 0 ? 0 : e.lb, this.ub = e.ub === void 0 ? Infinity : e.ub);
+	}
+	get x() {
+		return this.value;
+	}
+	get varValue() {
+		return this.value;
+	}
+	mul(t) {
+		if (typeof t == "number") return new S(/* @__PURE__ */ new Map([[this, t]]), 0);
+		if (t instanceof e) return x.fromProduct(this, t, 1);
+		let n = new x();
+		Math.abs(t.constant) >= 1e-12 && n.linearTerms.set(this, t.constant);
+		for (let [e, r] of t.terms) {
+			let t = x.fromProduct(this, e, r);
+			n = n.add(t);
+		}
+		return n;
+	}
+	add(e) {
+		return e instanceof x ? e.add(this) : new S(/* @__PURE__ */ new Map([[this, 1]]), 0).add(e);
+	}
+	sub(e) {
+		return e instanceof x ? e.neg().add(this) : new S(/* @__PURE__ */ new Map([[this, 1]]), 0).sub(e);
+	}
+	neg() {
+		return this.mul(-1);
+	}
+	le(e, t) {
+		return new S(/* @__PURE__ */ new Map([[this, 1]]), 0).le(e, t);
+	}
+	lessThanOrEqual(e, t) {
+		return this.le(e, t);
+	}
+	ge(e, t) {
+		return new S(/* @__PURE__ */ new Map([[this, 1]]), 0).ge(e, t);
+	}
+	greaterThanOrEqual(e, t) {
+		return this.ge(e, t);
+	}
+	eq(e, t) {
+		return new S(/* @__PURE__ */ new Map([[this, 1]]), 0).eq(e, t);
+	}
+	equalTo(e, t) {
+		return this.eq(e, t);
+	}
+	toString() {
+		return this.name;
+	}
+};
+//#endregion
+//#region src/modeler/parser.ts
+function ee(e) {
+	let t = [], n = 0, r = e.length;
+	for (; n < r;) {
+		let i = e[n];
+		if (/\s/.test(i)) {
+			n++;
+			continue;
+		}
+		if (i === "+") t.push({
+			type: "PLUS",
+			value: "+"
+		}), n++;
+		else if (i === "-") t.push({
+			type: "MINUS",
+			value: "-"
+		}), n++;
+		else if (i === "*") t.push({
+			type: "STAR",
+			value: "*"
+		}), n++;
+		else if (i === "/") t.push({
+			type: "SLASH",
+			value: "/"
+		}), n++;
+		else if (i === "(") t.push({
+			type: "LPAREN",
+			value: "("
+		}), n++;
+		else if (i === ")") t.push({
+			type: "RPAREN",
+			value: ")"
+		}), n++;
+		else if (i === "<" || i === ">" || i === "=") {
+			let a = i;
+			n + 1 < r && (e[n + 1] === "=" || e[n + 1] === "<" || e[n + 1] === ">") ? (a += e[n + 1], n += 2) : n++, t.push({
+				type: "COMP",
+				value: a
+			});
+		} else if (/[0-9.]/.test(i)) {
+			let i = "";
+			for (; n < r && /[0-9.]/.test(e[n]);) i += e[n], n++;
+			t.push({
+				type: "NUMBER",
+				value: i
+			});
+		} else if (/[a-zA-Z_]/.test(i)) {
+			let i = "";
+			for (; n < r && /[a-zA-Z0-9_]/.test(e[n]);) i += e[n], n++;
+			t.push({
+				type: "IDENT",
+				value: i
+			});
+		} else throw Error(`Unexpected character '${i}' at position ${n} in: "${e}"`);
+	}
+	return t;
+}
+var te = class {
+	tokens;
+	pos = 0;
+	resolver;
+	constructor(e, t) {
+		this.tokens = e, this.resolver = t;
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	consume(e) {
+		let t = this.tokens[this.pos++];
+		if (!t) throw Error("Unexpected end of input");
+		if (e && t.value !== e && t.type !== e) throw Error(`Expected '${e}', but found '${t.value}'`);
+		return t;
+	}
+	parseExpression() {
+		let e = this.parseTerm();
+		for (; this.pos < this.tokens.length;) {
+			let t = this.peek();
+			if (!t) break;
+			if (t.type === "PLUS") this.consume(), e = e.add(this.parseTerm());
+			else if (t.type === "MINUS") this.consume(), e = e.sub(this.parseTerm());
+			else break;
+		}
+		return e;
+	}
+	parseTerm() {
+		let e = this.parseFactor();
+		for (; this.pos < this.tokens.length;) {
+			let t = this.peek();
+			if (!t) break;
+			if (t.type === "STAR") {
+				this.consume();
+				let t = this.parseFactor();
+				e = this.multiplyExpressions(e, t);
+			} else if (t.type === "SLASH") {
+				this.consume();
+				let t = this.parseFactor();
+				if (t.terms.size > 0) throw Error("Cannot divide by variable in linear expression");
+				if (Math.abs(t.constant) < 1e-12) throw Error("Division by zero in expression");
+				e = e.div(t.constant);
+			} else break;
+		}
+		return e;
+	}
+	multiplyExpressions(e, t) {
+		if (e.terms.size > 0 && t.terms.size > 0) throw Error("Multiplication of two variables creates a non-linear term (not allowed in MILP/LP)");
+		return e.terms.size === 0 ? t.mul(e.constant) : e.mul(t.constant);
+	}
+	parseFactor() {
+		let e = this.peek();
+		if (!e) throw Error("Unexpected end of expression");
+		if (e.type === "PLUS") return this.consume(), this.parseFactor();
+		if (e.type === "MINUS") return this.consume(), this.parseFactor().neg();
+		if (e.type === "NUMBER") {
+			this.consume();
+			let t = parseFloat(e.value);
+			if (this.peek()?.type === "IDENT") {
+				let e = this.consume();
+				return this.resolveVariable(e.value).mul(t);
+			}
+			return new S(/* @__PURE__ */ new Map(), t);
+		}
+		if (e.type === "IDENT") {
+			this.consume();
+			let t = this.resolveVariable(e.value);
+			return new S(/* @__PURE__ */ new Map([[t, 1]]), 0);
+		}
+		if (e.type === "LPAREN") {
+			this.consume("LPAREN");
+			let e = this.parseExpression();
+			return this.consume("RPAREN"), e;
+		}
+		throw Error(`Unexpected token '${e.value}' in expression`);
+	}
+	resolveVariable(e) {
+		let t = this.resolver(e);
+		if (!t) throw Error(`Unknown variable '${e}' in expression`);
+		return t;
+	}
+};
+function O(e, t) {
+	return new te(ee(e), t).parseExpression();
+}
+function k(e, t, n) {
+	let r = e.match(/(<=|>=|==|=<|=>|=)/);
+	if (!r) throw Error(`Constraint must contain a comparison operator (<=, >=, ==, =): "${e}"`);
+	let i = r[0], a = r.index, o = e.substring(0, a).trim(), s = e.substring(a + i.length).trim(), c;
+	if (i === "<=" || i === "=<") c = "<=";
+	else if (i === ">=" || i === "=>") c = ">=";
+	else if (i === "==" || i === "=") c = "==";
+	else throw Error(`Unsupported operator "${i}"`);
+	let l = O(o, t), u = O(s, t);
+	return c === "<=" ? l.le(u, n) : c === ">=" ? l.ge(u, n) : l.eq(u, n);
+}
+function A(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = "";
+	for (let i = 0; i < e.length; i++) if (r += e[i], i < t.length) {
+		let e = t[i];
+		if (typeof e == "number") r += `(${e})`;
+		else if (e instanceof D) {
+			let t = `__v_${i}__`;
+			n.set(t, e), r += t;
+		} else if (e instanceof S) {
+			`${i}`, r += `(${e.toString()})`;
+			for (let [t] of e.terms) n.set(t.name, t);
+		}
+	}
+	return {
+		fullText: r,
+		resolver: (e) => n.get(e)
+	};
+}
+function ne(e, ...t) {
+	let { fullText: n, resolver: r } = A(e, t);
+	return k(n, r);
+}
+function re(e, ...t) {
+	let { fullText: n, resolver: r } = A(e, t);
+	return /(<=|>=|==|=<|=>|=)/.test(n) ? k(n, r) : O(n, r);
+}
+//#endregion
+//#region src/modeler/lp-writer.ts
+function j(e, t, n) {
+	let r = e.replace(/[^a-zA-Z0-9_]/g, "_");
+	return /^[0-9]/.test(r) && (r = `${t}_${r}`), (!r || r.length === 0) && (r = `${t}_${n}`), r;
+}
+function M(e) {
+	let { sense: t, objective: n, constraints: r, variables: i } = e, a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Set();
+	for (let e of i) {
+		let t = j(e.name, "x", e.id), n = t, r = 1;
+		for (; c.has(n);) n = `${t}_${r++}`;
+		c.add(n), o.set(e, n), a.set(n, e);
+	}
+	let l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map();
+	for (let e of r) {
+		let t = j(e.name, "c", e.id), n = t, r = 1;
+		for (; l.has(n);) n = `${t}_${r++}`;
+		l.add(n), u.set(e, n), s.set(n, e);
+	}
+	let d = [];
+	d.push(t === "Maximize" ? "Maximize" : "Minimize");
+	let f = [], p = !0, m = n instanceof x ? n.linearTerms : n.terms;
+	if (m) for (let [e, t] of m) {
+		if (Math.abs(t) < 1e-12) continue;
+		let n = o.get(e), r = t >= 0 ? p ? "" : "+ " : "- ", i = Math.abs(t), a = i === 1 ? "" : `${i} `;
+		f.push(`${r}${a}${n}`), p = !1;
+	}
+	if (n instanceof x && n.quadTerms.size > 0) {
+		let e = [], t = !0;
+		for (let r of n.quadTerms.values()) {
+			if (Math.abs(r.coeff) < 1e-12) continue;
+			let n = 2 * r.coeff, i = n >= 0 ? t ? "" : "+ " : "- ", a = Math.abs(n), s = a === 1 ? "" : `${a} `, c = o.get(r.var1), l = o.get(r.var2);
+			r.var1 === r.var2 ? e.push(`${i}${s}${c} ^ 2`) : e.push(`${i}${s}${c} * ${l}`), t = !1;
+		}
+		if (e.length > 0) {
+			let t = `[ ${e.join(" ")} ] / 2`;
+			f.length > 0 ? f.push("+", t) : f.push(t);
+		}
+	}
+	let h = f.length > 0 ? f.join(" ") : "0";
+	d.push(` obj: ${h}`), d.push("Subject To");
+	for (let e of r) {
+		let t = u.get(e), n = [], r = !0;
+		for (let [t, i] of e.lhs.terms) {
+			if (Math.abs(i) < 1e-12) continue;
+			let e = o.get(t), a = i >= 0 ? r ? "" : "+ " : "- ", s = Math.abs(i), c = s === 1 ? "" : `${s} `;
+			n.push(`${a}${c}${e}`), r = !1;
+		}
+		let i = n.length > 0 ? n.join(" ") : "0", a = e.sense === "==" ? "=" : e.sense;
+		d.push(` ${t}: ${i} ${a} ${e.rhs}`);
+	}
+	d.push("Bounds");
+	let g = [], _ = [];
+	for (let e of i) {
+		let t = o.get(e);
+		if (e.type === "Binary") {
+			_.push(t);
+			continue;
+		}
+		e.type === "Integer" && g.push(t);
+		let n = e.lb === -Infinity, r = e.ub === Infinity;
+		n && r ? d.push(` ${t} free`) : n && !r ? d.push(` -infinity <= ${t} <= ${e.ub}`) : !n && r ? e.lb !== 0 && d.push(` ${t} >= ${e.lb}`) : d.push(` ${e.lb} <= ${t} <= ${e.ub}`);
+	}
+	if (g.length > 0) {
+		d.push("Generals");
+		for (let e = 0; e < g.length; e += 10) d.push(" " + g.slice(e, e + 10).join(" "));
+	}
+	if (_.length > 0) {
+		d.push("Binary");
+		for (let e = 0; e < _.length; e += 10) d.push(" " + _.slice(e, e + 10).join(" "));
+	}
+	return d.push("End"), {
+		lpString: d.join("\n") + "\n",
+		nameToVar: a,
+		nameToConstraint: s
+	};
+}
+//#endregion
+//#region \0washi-browser-worker-factory
+function ie() {
+	let e = r("highs-worker.js");
+	if (new URL(e).origin === window.location.origin) return new Worker(e, { type: "module" });
+	let t = URL.createObjectURL(new Blob(["import " + JSON.stringify(e) + ";"], { type: "text/javascript" }));
+	try {
+		let e = new Worker(t, { type: "module" }), n = () => URL.revokeObjectURL(t);
+		return e.addEventListener("message", n, { once: !0 }), e.addEventListener("error", n, { once: !0 }), e;
+	} catch (e) {
+		throw URL.revokeObjectURL(t), e;
+	}
+}
+//#endregion
+//#region src/highs-worker-client.ts
+var N = null, ae = 0, P = /* @__PURE__ */ new Map();
+function oe() {
+	if (typeof window > "u" || typeof Worker > "u") return null;
+	if (!N) try {
+		N = ie();
+		let e = N;
+		N.onmessage = (e) => {
+			let { type: t, id: n, result: r, runTime: i, error: a } = e.data, o = P.get(n);
+			o && (P.delete(n), t === "SOLVE_SUCCESS" ? o.resolve({
+				result: r,
+				runTime: i
+			}) : o.reject(Error(a || "Worker solve failed")));
+		};
+		let t = (t) => {
+			if (N === e) {
+				N = null, e.terminate();
+				for (let e of P.values()) e.reject(t);
+				P.clear();
+			}
+		};
+		N.onerror = (e) => t(/* @__PURE__ */ Error(`[WaSHI] HiGHS Worker failed to load or execute. Check Worker assets, CORS and CSP. ${e.message || ""}`)), N.onmessageerror = () => t(/* @__PURE__ */ Error("[WaSHI] Could not deserialize the HiGHS Worker response."));
+	} catch (e) {
+		console.warn("Could not instantiate Web Worker, falling back to main thread:", e), N = null;
+	}
+	return N;
+}
+async function se(e, n = {}) {
+	let r = await a(n.wasmUrl), i = n.useWorker ?? typeof window < "u" ? oe() : null;
+	if (!i) return t(e, n);
+	let o = {
+		...n,
+		wasmUrl: r
+	}, s = `req_${++ae}`;
+	return new Promise((t, n) => {
+		P.set(s, {
+			resolve: t,
+			reject: n
+		});
+		try {
+			i.postMessage({
+				type: "SOLVE",
+				id: s,
+				lpString: e,
+				options: o
+			});
+		} catch (e) {
+			P.delete(s), n(e);
+		}
+	});
+}
+//#endregion
+//#region src/modeler/solvers/highs.ts
+function ce(e) {
+	if (typeof e != "string") return "Unknown";
+	let t = e.trim();
+	if (!t) return "Unknown";
+	switch (t) {
+		case "Optimal": return "Optimal";
+		case "Infeasible": return "Infeasible";
+		case "Unbounded": return "Unbounded";
+		case "Primal infeasible or unbounded": return "Unknown";
+		case "Time limit reached":
+		case "TimeLimit": return "TimeLimit";
+		case "Iteration limit reached":
+		case "IterationLimit": return "IterationLimit";
+		case "Bound on objective reached":
+		case "Target for objective reached":
+		case "Feasible": return "Feasible";
+		case "Not Set": return "NotSolved";
+		case "Load error":
+		case "Model error":
+		case "Presolve error":
+		case "Solve error":
+		case "Postsolve error":
+		case "Error": return "Error";
+		case "Empty":
+		case "Unknown": return "Unknown";
+	}
+	let n = t.toLowerCase();
+	return n.includes("infeasible") && n.includes("unbounded") ? "Unknown" : n.includes("infeasible") ? "Infeasible" : n.includes("unbounded") ? "Unbounded" : n.includes("time limit") || n.includes("timelimit") ? "TimeLimit" : n.includes("iteration limit") || n.includes("iterationlimit") ? "IterationLimit" : n.includes("error") ? "Error" : n === "optimal" ? "Optimal" : "Unknown";
+}
+var F = class e {
+	static capabilities = {
+		supportsMIP: !0,
+		supportsQP: !0
+	};
+	name = "HiGHS";
+	version = "1.15.3";
+	capabilities = e.capabilities;
+	options;
+	constructor(e = {}) {
+		this.options = e;
+	}
+	async solve(e, t, n = {}) {
+		let r = {
+			...this.options,
+			...n
+		}, { lpString: i, nameToVar: a, nameToConstraint: o } = t, { result: s, runTime: c } = await se(i, r), l = ce(s?.Status), u = s.ObjectiveValue, d = typeof u == "number" ? u + e.objective.constant : null, f = {}, p = {}, m = {}, h = {};
+		if (s.Columns) for (let [e, t] of Object.entries(s.Columns)) {
+			let n = a.get(e);
+			if (n) {
+				let e = Math.abs(t.Primal) < 1e-9 ? 0 : t.Primal;
+				f[n.name] = e, t.Dual !== void 0 && (m[n.name] = Math.abs(t.Dual) < 1e-9 ? 0 : t.Dual);
+			}
+		}
+		if (s.Rows) {
+			let e = Array.isArray(s.Rows) ? s.Rows : Object.values(s.Rows);
+			for (let t of e) {
+				let e = t.Name, n = o.get(e);
+				if (n && (t.Dual !== void 0 && (p[n.name] = Math.abs(t.Dual) < 1e-9 ? 0 : t.Dual), t.Primal !== void 0)) {
+					let e = n.rhs - t.Primal;
+					h[n.name] = Math.abs(e) < 1e-9 ? 0 : e;
+				}
+			}
+		}
+		return {
+			status: l,
+			objectiveValue: d,
+			values: f,
+			reducedCosts: m,
+			duals: p,
+			slacks: h,
+			runTime: c,
+			raw: s
+		};
+	}
+}, le = F, I = null;
+async function L() {
+	return I || (I = (async () => {
+		try {
+			let e = await import("./_washi-optional-engine-282Ug7Gw.js");
+			return await (e.default || e)();
+		} catch (e) {
+			throw Error("[WaSHI] Could not load GLPK. Install the optional glpk.js dependency before selecting this solver.", { cause: e });
+		}
+	})(), I);
+}
+//#endregion
+//#region src/modeler/solvers/glpk.ts
+var R = class e {
+	static capabilities = {
+		supportsMIP: !0,
+		supportsQP: !1
+	};
+	name = "GLPK";
+	version = "5.0.0";
+	capabilities = e.capabilities;
+	options;
+	constructor(e = {}) {
+		this.options = e;
+	}
+	async solve(e, t, n = {}) {
+		let r = {
+			...this.options,
+			...n
+		}, i = await L(), { nameToVar: a, nameToConstraint: o } = t, s = /* @__PURE__ */ new Map();
+		for (let [e, t] of a.entries()) s.set(t, e);
+		let c = /* @__PURE__ */ new Map();
+		for (let [e, t] of o.entries()) c.set(t, e);
+		let l = [], u = "linearTerms" in e.objective ? e.objective.linearTerms : e.objective.terms;
+		if (u) for (let [e, t] of u) {
+			if (Math.abs(t) < 1e-12) continue;
+			let n = s.get(e) || e.name;
+			l.push({
+				name: n,
+				coef: Number(t)
+			});
+		}
+		let d = [];
+		for (let t of e.constraints) {
+			let e = c.get(t) || t.name || `c_${d.length + 1}`, n = [];
+			for (let [e, r] of t.lhs.terms) {
+				if (Math.abs(r) < 1e-12) continue;
+				let t = s.get(e) || e.name;
+				n.push({
+					name: t,
+					coef: Number(r)
+				});
+			}
+			let r;
+			r = t.sense === "==" ? {
+				type: i.GLP_FX,
+				lb: t.rhs,
+				ub: t.rhs
+			} : t.sense === "<=" ? {
+				type: i.GLP_UP,
+				lb: -Infinity,
+				ub: t.rhs
+			} : {
+				type: i.GLP_LO,
+				lb: t.rhs,
+				ub: Infinity
+			}, d.push({
+				name: e,
+				vars: n,
+				bnds: r
+			});
+		}
+		let f = [], p = [], m = [];
+		for (let t of e.variables) {
+			let e = s.get(t) || t.name;
+			t.type === "Binary" ? f.push(e) : t.type === "Integer" && p.push(e);
+			let n = t.lb, r = t.ub, a;
+			a = n === -Infinity && r === Infinity ? i.GLP_FR : n !== -Infinity && r === Infinity ? i.GLP_LO : n === -Infinity && r !== Infinity ? i.GLP_UP : n === r ? i.GLP_FX : i.GLP_DB, m.push({
+				name: e,
+				type: a,
+				lb: n === -Infinity ? 0 : n,
+				ub: r === Infinity ? 0 : r
+			});
+		}
+		let h = {
+			name: e.name || "GLPK_Model",
+			objective: {
+				direction: e.sense === "Maximize" ? i.GLP_MAX : i.GLP_MIN,
+				name: "obj",
+				vars: l
+			},
+			subjectTo: d
+		};
+		m.length > 0 && (h.bounds = m), f.length > 0 && (h.binaries = f), p.length > 0 && (h.generals = p);
+		let g = {
+			msglev: r.verbose ? i.GLP_MSG_ALL : i.GLP_MSG_OFF,
+			presol: r.presolve !== "off"
+		};
+		typeof r.timeLimit == "number" && (g.tmlim = r.timeLimit), typeof r.mipGap == "number" && (g.mipgap = r.mipGap);
+		let _ = performance.now(), v = await i.solve(h, g), y = (performance.now() - _) / 1e3, b = v?.result?.status, x;
+		x = b === i.GLP_OPT ? "Optimal" : b === i.GLP_FEAS ? "Feasible" : b === i.GLP_INFEAS || b === i.GLP_NOFEAS ? "Infeasible" : b === i.GLP_UNBND ? "Unbounded" : "Optimal";
+		let S = v?.result?.z, C = typeof S == "number" ? S + e.objective.constant : null, w = {}, T = v?.result?.vars || {};
+		for (let [e, t] of Object.entries(T)) {
+			let n = a.get(e), r = n ? n.name : e;
+			w[r] = typeof t == "number" ? Math.abs(t) < 1e-9 ? 0 : t : 0;
+		}
+		for (let t of e.variables) w[t.name] === void 0 && (w[t.name] = 0);
+		let E = {};
+		if (v?.result?.dual) for (let [e, t] of Object.entries(v.result.dual)) {
+			let n = o.get(e), r = n ? n.name : e;
+			E[r] = Number(t);
+		}
+		return {
+			status: x,
+			objectiveValue: C,
+			values: w,
+			duals: E,
+			runTime: v?.time || y,
+			logs: [`GLPK solved in ${(v?.time || y) * 1e3} ms.`],
+			raw: v
+		};
+	}
+}, z = class {
+	name;
+	capabilities;
+	options;
+	constructor(e = {}) {
+		this.name = e.name || "MockSolver", this.capabilities = e.capabilities || {
+			supportsMIP: !0,
+			supportsQP: !0
+		}, this.options = e;
+	}
+	async solve(e, t, n = {}) {
+		let r = {
+			...this.options,
+			...n
+		};
+		return r.delayMs && r.delayMs > 0 && await new Promise((e) => setTimeout(e, r.delayMs)), {
+			status: r.status || "Optimal",
+			objectiveValue: r.objectiveValue ?? 0,
+			values: r.values || {},
+			reducedCosts: r.reducedCosts,
+			duals: r.duals,
+			slacks: r.slacks,
+			runTime: .001,
+			raw: { mock: !0 }
+		};
+	}
+}, B = /* @__PURE__ */ new Map();
+B.set("highs", (e) => new F(e)), B.set("glpk", (e) => new R(e)), B.set("mock", (e) => new z(e));
+var V = (e) => new F(e);
+function H(e, t) {
+	B.set(e.toLowerCase(), t);
+}
+function ue(e) {
+	if (typeof e == "string") {
+		let t = B.get(e.toLowerCase());
+		if (!t) throw Error(`Solver '${e}' is not registered.`);
+		V = t;
+	} else V = typeof e == "function" ? e : () => e;
+}
+function U(e, t) {
+	if (!e) return V(t);
+	if (typeof e == "string") {
+		let n = B.get(e.toLowerCase());
+		if (!n) throw Error(`Solver '${e}' not found. Available solvers: ${W().join(", ")}`);
+		return n(t);
+	}
+	return e;
+}
+function W() {
+	return Array.from(B.keys());
+}
+//#endregion
+//#region src/modeler/solvers/z3.ts
+var G = null;
+async function K() {
+	if (!G) {
+		let e = (async () => {
+			try {
+				return await (await import("./_washi-optional-engine-282Ug7Gw.js")).init();
+			} catch (e) {
+				throw Error(`[WaSHI] Failed to load z3-solver. Ensure the optional dependency is installed (npm install z3-solver) and supported in this environment. Error: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+			}
+		})();
+		e.catch(() => {
+			G === e && (G = null);
+		}), G = e;
+	}
+	return G;
+}
+var q = class {
+	name = "z3";
+	capabilities = {
+		supportsMIP: !0,
+		supportsQP: !1,
+		supportsSMT: !0,
+		supportsUnsatCore: !0
+	};
+	createContextTranslator(e) {
+		let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+		function r(n) {
+			if (!t.has(n.name)) {
+				let r = n.type === "Continuous" || n.type === "CONTINUOUS" ? e.Real.const(n.name) : e.Int.const(n.name);
+				t.set(n.name, r);
+			}
+			return t.get(n.name);
+		}
+		function i(t) {
+			if (!n.has(t.name)) {
+				let r = e.Bool.const(t.name);
+				n.set(t.name, r);
+			}
+			return n.get(t.name);
+		}
+		function a(t) {
+			return typeof e.isInt == "function" && e.isInt(t) ? e.ToReal(t) : t;
+		}
+		function o(t, n) {
+			let r = typeof e.isInt == "function" && e.isInt(t), i = typeof e.isInt == "function" && e.isInt(n);
+			return r && i ? t.add(n) : a(t).add(a(n));
+		}
+		function s(t, n) {
+			return typeof e.isInt == "function" && e.isInt(t) && Number.isInteger(n) ? t.mul(e.Int.val(n)) : a(t).mul(e.Real.val(n));
+		}
+		function c(t, n) {
+			let r = typeof e.isInt == "function" && e.isInt(t), i = typeof e.isInt == "function" && e.isInt(n);
+			return r && i ? t.mul(n) : a(t).mul(a(n));
+		}
+		function l(t, n) {
+			return n && Number.isInteger(t) ? e.Int.val(t) : e.Real.val(t);
+		}
+		function u(t, n, r) {
+			let i = typeof e.isInt == "function" && e.isInt(t) && Number.isInteger(r), o = i ? t : a(t), s = i ? e.Int.val(r) : e.Real.val(r);
+			return n === "<=" ? o.le(s) : n === ">=" ? o.ge(s) : o.eq(s);
+		}
+		function p(t) {
+			let n = null;
+			if (t && t.terms) for (let [e, i] of t.terms.entries()) {
+				let t = s(r(e), i);
+				n = n === null ? t : o(n, t);
+			}
+			let i = t && typeof t.constant == "number" ? t.constant : 0;
+			if (i !== 0 || n === null) {
+				let t = l(i, n === null || typeof e.isInt == "function" && e.isInt(n));
+				n = n === null ? t : o(n, t);
+			}
+			return n;
+		}
+		function m(t) {
+			let n = null;
+			if (t.linearTerms) for (let [e, i] of t.linearTerms.entries()) {
+				let t = s(r(e), i);
+				n = n === null ? t : o(n, t);
+			}
+			if (t.quadTerms) for (let e of t.quadTerms.values()) {
+				let t = s(c(r(e.var1), r(e.var2)), e.coeff);
+				n = n === null ? t : o(n, t);
+			}
+			let i = t && typeof t.constant == "number" ? t.constant : 0;
+			if (i !== 0 || n === null) {
+				let t = l(i, n === null || typeof e.isInt == "function" && e.isInt(n));
+				n = n === null ? t : o(n, t);
+			}
+			return n;
+		}
+		function h(e) {
+			let t = e.lhs instanceof Object && "quadTerms" in e.lhs ? m(e.lhs) : p(e.lhs), n = typeof e.rhs == "number" ? e.rhs : 0;
+			return u(t, e.sense, n);
+		}
+		function g(t) {
+			if (t instanceof d) return i(t);
+			if (t instanceof y) return h(t);
+			if (t instanceof f) switch (t.op) {
+				case "and": return e.And(...t.children.map(g));
+				case "or": return e.Or(...t.children.map(g));
+				case "not": return e.Not(g(t.children[0]));
+				case "implies": return e.Implies(g(t.children[0]), g(t.children[1]));
+				case "xor": return e.Xor(g(t.children[0]), g(t.children[1]));
+				default: throw Error(`Unsupported boolean operation: ${t.op}`);
+			}
+			throw Error(`Unknown logic element: ${String(t)}`);
+		}
+		function _(e) {
+			if (!e) return 0;
+			if (typeof e.asNumber == "function") return e.asNumber();
+			let t = e.toString();
+			if (t.startsWith("(/ ")) {
+				let e = t.slice(3, -1).trim().split(/\s+/);
+				if (e.length === 2) return Number(e[0]) / Number(e[1]);
+			}
+			return Number(t);
+		}
+		return {
+			getVarAst: r,
+			getBoolVarAst: i,
+			compareAstWithNumber: u,
+			translateLinExpr: p,
+			translateQuadExpr: m,
+			translateConstraint: h,
+			translateBoolExpr: g,
+			parseAstValue: _,
+			varAstMap: t,
+			boolVarAstMap: n
+		};
+	}
+	async check(e, t = {}) {
+		let { Context: n } = await K(), r = new n(`check_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`), i = new r.Solver(), a = this.createContextTranslator(r), o = e.variables || e.vars || [], s = e.boolVars || [], c = e.constraints || [], l = e.logicalConstraints || [];
+		for (let e of o) {
+			let t = a.getVarAst(e);
+			e.lb !== -Infinity && i.add(a.compareAstWithNumber(t, ">=", e.lb)), e.ub !== Infinity && i.add(a.compareAstWithNumber(t, "<=", e.ub)), (e.type === "Binary" || e.type === "BINARY") && (i.add(a.compareAstWithNumber(t, ">=", 0)), i.add(a.compareAstWithNumber(t, "<=", 1)));
+		}
+		for (let e of c) {
+			let t = a.translateConstraint(e), n = r.Bool.const(e.name);
+			i.addAndTrack(t, n);
+		}
+		for (let e = 0; e < l.length; e++) {
+			let t = l[e], n = t && t.name || `lc_${e + 1}`, o = t && t.expr || t, s = a.translateBoolExpr(o), c = r.Bool.const(n);
+			i.addAndTrack(s, c);
+		}
+		let u = (await i.check()).toString();
+		if (u === "sat") {
+			let e = i.model(), t = {};
+			for (let n of o) {
+				let r = a.getVarAst(n), i = e.eval(r);
+				t[n.name] = a.parseAstValue(i);
+			}
+			for (let n of s) {
+				let r = a.getBoolVarAst(n), i = e.eval(r);
+				t[n.name] = i.toString() === "true";
+			}
+			return {
+				status: "Sat",
+				values: t
+			};
+		}
+		if (u === "unsat") {
+			let e = i.unsatCore(), t = [], n = typeof e.length == "function" ? e.length() : e.length;
+			for (let r = 0; r < n; r++) t.push(e.get(r).toString());
+			return {
+				status: "Unsat",
+				values: {},
+				unsatCore: t
+			};
+		}
+		return {
+			status: "Unknown",
+			values: {}
+		};
+	}
+	async solve(e, t, n = {}) {
+		if (!(e.objective !== null && e.objective !== void 0 && ("terms" in e.objective && e.objective.terms.size > 0 || "quadTerms" in e.objective && e.objective.quadTerms.length > 0 || e.objective.offset && e.objective.offset !== 0))) {
+			let t = await this.check(e, n), r = {};
+			for (let [e, n] of Object.entries(t.values)) r[e] = typeof n == "boolean" ? +!!n : n;
+			return {
+				status: t.status === "Sat" ? "Optimal" : t.status === "Unsat" ? "Infeasible" : "Error",
+				objectiveValue: 0,
+				values: r
+			};
+		}
+		let { Context: r } = await K(), i = new r(`opt_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`), a = new i.Optimize(), o = this.createContextTranslator(i), s = e.variables || e.vars || [], c = e.boolVars || [], l = e.constraints || [], u = e.logicalConstraints || [];
+		for (let e of s) {
+			let t = o.getVarAst(e);
+			e.lb !== -Infinity && a.add(o.compareAstWithNumber(t, ">=", e.lb)), e.ub !== Infinity && a.add(o.compareAstWithNumber(t, "<=", e.ub)), (e.type === "Binary" || e.type === "BINARY") && (a.add(o.compareAstWithNumber(t, ">=", 0)), a.add(o.compareAstWithNumber(t, "<=", 1)));
+		}
+		for (let e of l) {
+			let t = o.translateConstraint(e);
+			a.add(t);
+		}
+		for (let e of u) {
+			let t = e && e.expr || e, n = o.translateBoolExpr(t);
+			a.add(n);
+		}
+		let d = e.objective instanceof Object && "quadTerms" in e.objective ? o.translateQuadExpr(e.objective) : o.translateLinExpr(e.objective);
+		(e.sense || "MINIMIZE").toUpperCase() === "MAXIMIZE" ? a.maximize(d) : a.minimize(d);
+		let f = (await a.check()).toString();
+		if (f === "sat") {
+			let e = a.model(), t = {};
+			for (let n of s) {
+				let r = o.getVarAst(n), i = e.eval(r);
+				t[n.name] = o.parseAstValue(i);
+			}
+			for (let n of c) {
+				let r = o.getBoolVarAst(n), i = e.eval(r);
+				t[n.name] = +(i.toString() === "true");
+			}
+			return {
+				status: "Optimal",
+				objectiveValue: o.parseAstValue(e.eval(d)),
+				values: t
+			};
+		}
+		return f === "unsat" ? {
+			status: "Infeasible",
+			objectiveValue: null,
+			values: {}
+		} : {
+			status: "Error",
+			objectiveValue: null,
+			values: {}
+		};
+	}
+};
+function J() {
+	H("z3", () => new q());
+}
+J();
+//#endregion
+//#region src/modeler/model.ts
+var Y = class {
+	name;
+	sense;
+	objective;
+	variables = [];
+	constraints = [];
+	boolVars = [];
+	logicalConstraints = [];
+	unsatCore = [];
+	values = /* @__PURE__ */ new Map();
+	varMapByName = /* @__PURE__ */ new Map();
+	constrMapByName = /* @__PURE__ */ new Map();
+	status = "NotSolved";
+	objectiveValue = null;
+	runTime = 0;
+	solution = null;
+	solver = null;
+	constructor(e = {}) {
+		this.name = e.name || "OptimizationModel", this.sense = e.sense || "Minimize", this.objective = new S(), e.solver && (this.solver = U(e.solver));
+	}
+	get vars() {
+		return this.variables;
+	}
+	get constrs() {
+		return this.constraints;
+	}
+	get numVars() {
+		return this.variables.length;
+	}
+	get numConstrs() {
+		return this.constraints.length;
+	}
+	addVar(e, t, n, r) {
+		let i;
+		i = typeof e == "string" ? {
+			name: e,
+			type: t,
+			lb: n,
+			ub: r
+		} : e || {};
+		let a = new D(i);
+		if (this.varMapByName.has(a.name)) throw Error(`Variable with name '${a.name}' already exists in model`);
+		return this.variables.push(a), this.varMapByName.set(a.name, a), a;
+	}
+	addVars(e, t, n) {
+		if (typeof t == "number" || Array.isArray(t)) {
+			let r = typeof e == "number" ? Array.from({ length: e }, (e, t) => t) : e, i = typeof t == "number" ? Array.from({ length: t }, (e, t) => t) : t, a = n || {}, o = a.prefix || a.name || "x", s = {};
+			for (let e of r) {
+				s[e] = {};
+				for (let t of i) s[e][t] = this.addVar({
+					...a,
+					name: `${o}_${e}_${t}`
+				});
+			}
+			return s;
+		}
+		let r = t || {}, i = r.prefix || r.name;
+		if (typeof e == "number") {
+			let t = [], n = i || "x";
+			for (let i = 0; i < e; i++) t.push(this.addVar({
+				...r,
+				name: `${n}_${i}`
+			}));
+			return t;
+		}
+		{
+			let t = {};
+			for (let n of e) {
+				let e = i ? `${i}_${n}` : `${n}`;
+				t[n] = this.addVar({
+					...r,
+					name: e
+				});
+			}
+			return t;
+		}
+	}
+	addVars2D(e, t, n) {
+		let r = {}, i = n?.name || "x";
+		for (let a of e) {
+			r[a] = {};
+			for (let e of t) r[a][e] = this.addVar({
+				...n,
+				name: `${i}_${a}_${e}`
+			});
+		}
+		return r;
+	}
+	getVarByName(e) {
+		return this.varMapByName.get(e);
+	}
+	getConstraintByName(e) {
+		return this.constrMapByName.get(e);
+	}
+	setObjective(e, t) {
+		t && (this.sense = t), this.objective = typeof e == "string" ? O(e, (e) => this.getVarByName(e)) : typeof e == "number" ? new S(/* @__PURE__ */ new Map(), e) : e instanceof x || "terms" in e ? e.clone() : new S(/* @__PURE__ */ new Map([[e, 1]]), 0);
+	}
+	maximize(e) {
+		this.setObjective(e, "Maximize");
+	}
+	minimize(e) {
+		this.setObjective(e, "Minimize");
+	}
+	addBoolVar(e) {
+		let t = new d(e);
+		return this.boolVars.push(t), t;
+	}
+	addConstraint(e, t) {
+		if (e instanceof u) {
+			let n = t || `lc_${this.logicalConstraints.length + 1}`;
+			return this.logicalConstraints.push({
+				name: n,
+				expr: e
+			}), e;
+		}
+		let n;
+		if (typeof e == "string" ? n = k(e, (e) => this.getVarByName(e), t) : (n = e, t && (n.name = t)), this.constrMapByName.has(n.name)) throw Error(`Constraint with name '${n.name}' already exists in model`);
+		return this.constraints.push(n), this.constrMapByName.set(n.name, n), n;
+	}
+	addConstr(e, t) {
+		return this.addConstraint(e, t);
+	}
+	addConstrs(e) {
+		return e.map((e) => this.addConstraint(e));
+	}
+	add(e, t) {
+		if (Array.isArray(e)) {
+			for (let t of e) this.add(t);
+			return this;
+		}
+		return e instanceof D ? (this.varMapByName.has(e.name) || (this.variables.push(e), this.varMapByName.set(e.name, e)), this) : (this.addConstraint(e, t), this);
+	}
+	addIndicator(e, t, n = {}) {
+		let r = n.activeValue === void 0 ? 1 : n.activeValue, i = n.M === void 0 ? 1e5 : n.M, a = n.name || `ind_${e.name}_${t.name}`, o = [], { lhs: s, sense: c, rhs: l } = t;
+		if (r === 1) {
+			if (c === "<=" || c === "==") {
+				let t = this.addConstraint(s.add(e.mul(i)).le(l + i), c === "==" ? `${a}_le` : a);
+				o.push(t);
+			}
+			if (c === ">=" || c === "==") {
+				let t = this.addConstraint(s.sub(e.mul(i)).ge(l - i), c === "==" ? `${a}_ge` : a);
+				o.push(t);
+			}
+		} else {
+			if (c === "<=" || c === "==") {
+				let t = this.addConstraint(s.sub(e.mul(i)).le(l), c === "==" ? `${a}_le` : a);
+				o.push(t);
+			}
+			if (c === ">=" || c === "==") {
+				let t = this.addConstraint(s.add(e.mul(i)).ge(l), c === "==" ? `${a}_ge` : a);
+				o.push(t);
+			}
+		}
+		return o;
+	}
+	toLpString() {
+		let { lpString: e } = M({
+			name: this.name,
+			sense: this.sense,
+			objective: this.objective,
+			constraints: this.constraints,
+			variables: this.variables
+		});
+		return e;
+	}
+	async optimize(e, t) {
+		let n, r;
+		if (e && typeof e == "object" && "solve" in e && typeof e.solve == "function" ? (n = e, r = t || {}) : typeof e == "function" ? (n = new e(t), r = t || {}) : typeof e == "string" ? (n = U(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = U(r.solver, r), delete r.solver) : n = this.solver || U()), this.objective instanceof x && this.objective.quadTerms.size > 0 && n.capabilities?.supportsQP === !1) throw Error(`Solver "${n.name}" does not support quadratic objectives (QP). Please use a QP-capable solver such as HiGHS or Clarabel.`);
+		let i = {
+			name: this.name,
+			sense: this.sense,
+			objective: this.objective,
+			constraints: this.constraints,
+			variables: this.variables,
+			logicalConstraints: this.logicalConstraints,
+			boolVars: this.boolVars
+		}, a = M(i), o = await n.solve(i, a, r);
+		this.runTime = o.runTime ?? 0, this.status = o.status, this.objectiveValue = o.objectiveValue ?? null;
+		let s = {}, c = {}, l = {}, u = {};
+		if (this.values.clear(), o.values) for (let [e, t] of Object.entries(o.values)) {
+			this.values.set(e, t);
+			let n = this.getVarByName(e) || a.nameToVar.get(e);
+			n && (n.value = t, s[n.name] = t);
+		}
+		if (o.reducedCosts) for (let [e, t] of Object.entries(o.reducedCosts)) {
+			let n = this.getVarByName(e) || a.nameToVar.get(e);
+			n && (n.reducedCost = t, l[n.name] = t);
+		}
+		if (o.duals) for (let [e, t] of Object.entries(o.duals)) {
+			let n = this.getConstraintByName(e) || a.nameToConstraint.get(e);
+			n && (n.dual = t, c[n.name] = t);
+		}
+		if (o.slacks) for (let [e, t] of Object.entries(o.slacks)) {
+			let n = this.getConstraintByName(e) || a.nameToConstraint.get(e);
+			n && (n.slack = t, u[n.name] = t);
+		}
+		return this.solution = {
+			status: this.status,
+			objectiveValue: this.objectiveValue,
+			values: s,
+			duals: c,
+			reducedCosts: l,
+			slacks: u,
+			runTime: this.runTime,
+			raw: o.raw
+		}, this.status;
+	}
+	async solve(e, t) {
+		return this.optimize(e, t);
+	}
+	async check(e, t) {
+		let n, r;
+		if (e && typeof e == "object" && "solve" in e && typeof e.solve == "function" ? (n = e, r = t || {}) : typeof e == "function" ? (n = new e(t), r = t || {}) : typeof e == "string" ? (n = U(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = U(r.solver, r), delete r.solver) : n = this.solver || U()), this.logicalConstraints.length > 0 && n.capabilities?.supportsSMT !== !0) throw Error(`Solver "${n.name}" does not support SMT / logical constraints (or, implies, not, xor). Please use an SMT-capable solver such as Z3.`);
+		if (typeof n.check == "function") {
+			let e = await n.check({
+				name: this.name,
+				variables: this.variables,
+				boolVars: this.boolVars,
+				constraints: this.constraints,
+				logicalConstraints: this.logicalConstraints
+			}, r);
+			if (this.status = e.status, this.runTime = e.runTime ?? 0, this.unsatCore = e.unsatCore || [], e.values) {
+				this.values.clear();
+				for (let [t, n] of Object.entries(e.values)) {
+					this.values.set(t, n);
+					let e = this.getVarByName(t);
+					e && typeof n == "number" && (e.value = n);
+				}
+			}
+			return e;
+		}
+		let i = this.objective, a = this.sense;
+		try {
+			this.objective = new S(), this.sense = "Minimize";
+			let e = await this.optimize(n, r), t = e === "Optimal" || e === "Feasible", i = e === "Infeasible", a = {};
+			for (let e of this.variables) a[e.name] = e.value ?? 0;
+			return {
+				status: t ? "Sat" : i ? "Unsat" : "Unknown",
+				values: a,
+				runTime: this.runTime
+			};
+		} finally {
+			this.objective = i, this.sense = a;
+		}
+	}
+}, X = "Minimize", de = "Maximize", fe = "Continuous", pe = "Integer", me = "Binary", he = {
+	Optimal: "Optimal",
+	Feasible: "Feasible",
+	Infeasible: "Infeasible",
+	Unbounded: "Unbounded",
+	TimeLimit: "Not Solved (Time Limit)",
+	IterationLimit: "Not Solved (Iteration Limit)",
+	Error: "Error",
+	NotSolved: "Not Solved",
+	Sat: "Sat",
+	Unsat: "Unsat",
+	Unknown: "Unknown"
+}, ge = class e extends D {
+	constructor(e, t, n, r = "Continuous") {
+		super({
+			name: e,
+			lb: t === void 0 ? 0 : t,
+			ub: n === void 0 ? Infinity : n,
+			type: r
+		});
+	}
+	static dicts(t, n, r, i, a = "Continuous") {
+		let o = {};
+		for (let s of n) {
+			let n = `${t}_${s}`;
+			o[s] = new e(n, r, i, a);
+		}
+		return o;
+	}
+};
+function _e(e) {
+	return e == null ? null : typeof e == "number" ? e : e.value;
+}
+var Z = class {
+	model;
+	constructor(e = "NoName", t = X) {
+		this.model = new Y({
+			name: e,
+			sense: t
+		});
+	}
+	get name() {
+		return this.model.name;
+	}
+	get sense() {
+		return this.model.sense;
+	}
+	set sense(e) {
+		this.model.sense = e;
+	}
+	get objective() {
+		return this.model.objective;
+	}
+	get variables() {
+		return this.model.variables;
+	}
+	get constraints() {
+		return this.model.constraints;
+	}
+	get status() {
+		return this.model.status;
+	}
+	get objectiveValue() {
+		return this.model.objectiveValue;
+	}
+	addVariable(e) {
+		return this.model.getVarByName(e.name) || (this.model.variables.push(e), this.model.varMapByName.set(e.name, e)), e;
+	}
+	setObjective(e) {
+		if (typeof e == "object" && e) {
+			if ("terms" in e) for (let [t] of e.terms) this.addVariable(t);
+			else e instanceof D && this.addVariable(e);
+		}
+		this.model.setObjective(e);
+	}
+	addConstraint(e, t) {
+		if (typeof e == "object" && e && "lhs" in e) for (let [t] of e.lhs.terms) this.addVariable(t);
+		return this.model.addConstraint(e, t);
+	}
+	add(e, t) {
+		typeof e == "string" ? /(<=|>=|==|=<|=>|=)/.test(e) ? this.addConstraint(e, t) : this.setObjective(e) : e instanceof y ? this.addConstraint(e, t) : this.setObjective(e);
+	}
+	async solve(e, t) {
+		return this.model.optimize(e, t);
+	}
+	toLpString() {
+		return this.model.toLpString();
+	}
+}, Q = "Minimize", $ = "Maximize", ve = "Binary", ye = "Integer", be = "Continuous";
+function xe(e) {
+	return {
+		expr: e,
+		sense: $
+	};
+}
+function Se(e) {
+	return {
+		expr: e,
+		sense: Q
+	};
+}
+var Ce = class extends Y {
+	constructor(e = "MipModel", t = Q) {
+		super({
+			name: e,
+			sense: t
+		});
+	}
+	add_var(e = {}) {
+		return this.addVar({
+			name: e.name,
+			type: e.var_type,
+			lb: e.lb,
+			ub: e.ub
+		});
+	}
+	set objective_spec(e) {
+		this.setObjective(e.expr, e.sense);
+	}
+	get objective_value() {
+		return this.objectiveValue;
+	}
+	add_constr(e, t) {
+		return this.addConstraint(e, t);
+	}
+};
+//#endregion
+export { ve as BINARY, u as BoolExpr, f as BoolOp, d as BoolVar, be as CONTINUOUS, y as Constraint, R as GLPKSolver, le as HiGHS, F as HighsSolver, ye as INTEGER, S as LinExpr, me as LpBinary, fe as LpContinuous, pe as LpInteger, de as LpMaximize, X as LpMinimize, Z as LpProblem, he as LpStatus, ge as LpVariable, $ as MAXIMIZE, Q as MINIMIZE, Ce as MipModel, z as MockSolver, Y as Model, c as OFFICIAL_HIGHS_CDN_WASM_URL, x as QuadExpr, D as Var, q as Z3Solver, p as and, ne as c, re as expr, M as generateLpString, L as getGlpk, i as getHighs, o as getHighsWasmUrl, U as getSolver, g as implies, n as isValidWasmHeader, W as listAvailableSolvers, T as lpSum, xe as maximize, Se as minimize, h as not, m as or, k as parseConstraint, O as parseExpr, e as probeWasmUrl, H as registerSolver, J as registerZ3Solver, a as resolveBrowserWasmUrl, ue as setDefaultSolver, s as setHighsWasmUrl, t as solveLpWithHighs, C as sum, _e as value, _ as xor, w as xsum };