@ohtaman/washi 0.1.1 → 0.2.0

package/dist/browser/washi.js

@@ -0,0 +1,1213 @@
+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 "./loader-CVt4CloI.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 ee = 0, v = class {
+	id;
+	lhs;
+	sense;
+	rhs;
+	name;
+	slack = null;
+	dual = null;
+	constructor(e, t, n, r) {
+		this.id = ++ee, 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 y(e, t) {
+	let n = e.id, r = t.id;
+	return n <= r ? `${n}:${r}` : `${r}:${n}`;
+}
+var b = 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 = y(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 = y(t, n);
+		return i.quadTerms.set(a, {
+			var1: t.id <= n.id ? t : n,
+			var2: t.id <= n.id ? n : t,
+			coeff: r
+		}), i;
+	}
+}, x = 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 b) 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 b ? 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 b();
+		Math.abs(this.constant) >= 1e-12 && n.linearTerms.set(t, this.constant);
+		for (let [e, r] of this.terms) n = n.add(b.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 v(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 S(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 x(n, r);
+}
+var C = S, w = S, T = 0, E = class e {
+	id;
+	name;
+	type;
+	lb;
+	ub;
+	value = null;
+	reducedCost = null;
+	constructor(e = {}) {
+		this.id = ++T, 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 x(/* @__PURE__ */ new Map([[this, t]]), 0);
+		if (t instanceof e) return b.fromProduct(this, t, 1);
+		let n = new b();
+		Math.abs(t.constant) >= 1e-12 && n.linearTerms.set(this, t.constant);
+		for (let [e, r] of t.terms) {
+			let t = b.fromProduct(this, e, r);
+			n = n.add(t);
+		}
+		return n;
+	}
+	add(e) {
+		return e instanceof b ? e.add(this) : new x(/* @__PURE__ */ new Map([[this, 1]]), 0).add(e);
+	}
+	sub(e) {
+		return e instanceof b ? e.neg().add(this) : new x(/* @__PURE__ */ new Map([[this, 1]]), 0).sub(e);
+	}
+	neg() {
+		return this.mul(-1);
+	}
+	le(e, t) {
+		return new x(/* @__PURE__ */ new Map([[this, 1]]), 0).le(e, t);
+	}
+	lessThanOrEqual(e, t) {
+		return this.le(e, t);
+	}
+	ge(e, t) {
+		return new x(/* @__PURE__ */ new Map([[this, 1]]), 0).ge(e, t);
+	}
+	greaterThanOrEqual(e, t) {
+		return this.ge(e, t);
+	}
+	eq(e, t) {
+		return new x(/* @__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 te(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 ne = 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 x(/* @__PURE__ */ new Map(), t);
+		}
+		if (e.type === "IDENT") {
+			this.consume();
+			let t = this.resolveVariable(e.value);
+			return new x(/* @__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 D(e, t) {
+	return new ne(te(e), t).parseExpression();
+}
+function O(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 = D(o, t), u = D(s, t);
+	return c === "<=" ? l.le(u, n) : c === ">=" ? l.ge(u, n) : l.eq(u, n);
+}
+function k(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 E) {
+			let t = `__v_${i}__`;
+			n.set(t, e), r += t;
+		} else if (e instanceof x) {
+			`${i}`, r += `(${e.toString()})`;
+			for (let [t] of e.terms) n.set(t.name, t);
+		}
+	}
+	return {
+		fullText: r,
+		resolver: (e) => n.get(e)
+	};
+}
+function re(e, ...t) {
+	let { fullText: n, resolver: r } = k(e, t);
+	return O(n, r);
+}
+function ie(e, ...t) {
+	let { fullText: n, resolver: r } = k(e, t);
+	return /(<=|>=|==|=<|=>|=)/.test(n) ? O(n, r) : D(n, r);
+}
+//#endregion
+//#region src/modeler/lp-writer.ts
+function A(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 j(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 = A(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 = A(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 b ? 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 b && 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 src/modeler/solvers/registry.ts
+var M = Symbol.for("washi.solverRegistry"), N = Symbol.for("washi.defaultSolverFactory"), P = globalThis;
+P[M] || (P[M] = /* @__PURE__ */ new Map());
+var F = P[M];
+function I(e, t) {
+	F.set(e.toLowerCase(), t);
+}
+function L(e) {
+	if (typeof e == "string") {
+		let t = F.get(e.toLowerCase());
+		if (!t) throw Error(`Solver '${e}' is not registered.`);
+		P[N] = t;
+	} else P[N] = typeof e == "function" ? e : () => e;
+}
+function R(e, t) {
+	if (!e) {
+		let e = P[N] || F.get("highs");
+		if (!e) throw Error(`No default solver available. Available solvers: ${z().join(", ")}`);
+		return e(t);
+	}
+	if (typeof e == "string") {
+		let n = e.toLowerCase(), r = F.get(n);
+		if (!r) throw Error(n === "glpk" ? `Solver 'glpk' not found. Available solvers: ${z().join(", ")}. Please import '@ohtaman/washi/solvers/glpk' before selecting this solver.` : n === "z3" ? `Solver 'z3' not found. Available solvers: ${z().join(", ")}. Please import '@ohtaman/washi/solvers/z3' before selecting this solver.` : `Solver '${e}' not found. Available solvers: ${z().join(", ")}`);
+		return r(t);
+	}
+	return e;
+}
+function z() {
+	return Array.from(F.keys());
+}
+//#endregion
+//#region \0washi-browser-worker-factory
+function ae() {
+	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/modeler/solvers/highs/worker-client.ts
+var B = null, V = 0, H = /* @__PURE__ */ new Map();
+function U() {
+	if (typeof window > "u" || typeof Worker > "u") return null;
+	if (!B) try {
+		B = ae();
+		let e = B;
+		B.onmessage = (e) => {
+			let { type: t, id: n, result: r, runTime: i, error: a } = e.data, o = H.get(n);
+			o && (H.delete(n), t === "SOLVE_SUCCESS" ? o.resolve({
+				result: r,
+				runTime: i
+			}) : o.reject(Error(a || "Worker solve failed")));
+		};
+		let t = (t) => {
+			if (B === e) {
+				B = null, e.terminate();
+				for (let e of H.values()) e.reject(t);
+				H.clear();
+			}
+		};
+		B.onerror = (e) => t(/* @__PURE__ */ Error(`[WaSHI] HiGHS Worker failed to load or execute. Check Worker assets, CORS and CSP. ${e?.message || ""}`)), B.onmessageerror = () => t(/* @__PURE__ */ Error("[WaSHI] Could not deserialize the HiGHS Worker response."));
+	} catch {
+		B = null;
+	}
+	return B;
+}
+async function W(e, n = {}) {
+	let r = await a(n.wasmUrl), i = n.useWorker ?? typeof window < "u" ? U() : null;
+	if (!i) return t(e, n);
+	let o = {
+		...n,
+		wasmUrl: r
+	}, s = `req_${++V}`;
+	return new Promise((t, n) => {
+		H.set(s, {
+			resolve: t,
+			reject: n
+		});
+		try {
+			i.postMessage({
+				type: "SOLVE",
+				id: s,
+				lpString: e,
+				options: o
+			});
+		} catch (e) {
+			H.delete(s), n(e);
+		}
+	});
+}
+//#endregion
+//#region src/modeler/solvers/highs/solver.ts
+function G(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 K = 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 W(i, r), l = G(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
+		};
+	}
+}, q = K;
+function oe() {
+	I("highs", (e) => new K(e)), L((e) => new K(e));
+}
+oe();
+//#endregion
+//#region src/modeler/solvers/mock.ts
+var J = 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 }
+		};
+	}
+};
+function se() {
+	I("mock", (e) => new J(e));
+}
+se();
+//#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 = {}, t) {
+		let n;
+		n = typeof e == "string" ? {
+			...t,
+			name: e
+		} : e, this.name = n.name || "OptimizationModel", this.sense = n.sense || "Minimize", this.objective = new x(), n.solver && (this.solver = R(n.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 E(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" ? D(e, (e) => this.getVarByName(e)) : typeof e == "number" ? new x(/* @__PURE__ */ new Map(), e) : e instanceof b || "terms" in e ? e.clone() : new x(/* @__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 = O(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 E ? (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 } = j({
+			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 = R(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = R(r.solver, r), delete r.solver) : n = this.solver || R()), this.objective instanceof b && 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 = j(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 = R(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = R(r.solver, r), delete r.solver) : n = this.solver || R()), 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 x(), 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", ce = "Maximize", le = "Continuous", ue = "Integer", de = "Binary", Z = {
+	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"
+}, fe = class e extends E {
+	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 pe(e) {
+	return e == null ? null : typeof e == "number" ? e : e.value;
+}
+var me = 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 E && 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 v ? 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", he = "Binary", ge = "Integer", _e = "Continuous";
+function ve(e) {
+	return {
+		expr: e,
+		sense: $
+	};
+}
+function ye(e) {
+	return {
+		expr: e,
+		sense: Q
+	};
+}
+var be = 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 { he as BINARY, u as BoolExpr, f as BoolOp, d as BoolVar, _e as CONTINUOUS, v as Constraint, q as HiGHS, K as HighsSolver, ge as INTEGER, x as LinExpr, de as LpBinary, le as LpContinuous, ue as LpInteger, ce as LpMaximize, X as LpMinimize, me as LpProblem, Z as LpStatus, fe as LpVariable, $ as MAXIMIZE, Q as MINIMIZE, be as MipModel, J as MockSolver, Y as Model, c as OFFICIAL_HIGHS_CDN_WASM_URL, b as QuadExpr, E as Var, p as and, re as c, ie as expr, j as generateLpString, i as getHighs, o as getHighsWasmUrl, R as getSolver, g as implies, n as isValidWasmHeader, z as listAvailableSolvers, w as lpSum, ve as maximize, ye as minimize, h as not, m as or, O as parseConstraint, D as parseExpr, e as probeWasmUrl, I as registerSolver, a as resolveBrowserWasmUrl, L as setDefaultSolver, s as setHighsWasmUrl, t as solveLpWithHighs, S as sum, pe as value, _ as xor, C as xsum };