@ohtaman/washi 0.0.0-stage → 0.1.1

package/dist/lib/washi.js

@@ -0,0 +1,908 @@
+import { C as e, E as t, S as n, T as r, _ as i, a, b as o, c as s, d as c, f as l, g as u, h as d, i as f, l as p, m, n as h, o as g, p as _, r as v, s as ee, t as y, u as b, v as x, w as S, x as C, y as w } from "./z3-C8g-PtmP.js";
+import { n as T, t as E } from "./glpk-BC32ZaPG.js";
+//#region src/modeler/quad-expr.ts
+function D(e, t) {
+	let n = e.id, r = t.id;
+	return n <= r ? `${n}:${r}` : `${r}:${n}`;
+}
+var O = 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 = D(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 = D(t, n);
+		return i.quadTerms.set(a, {
+			var1: t.id <= n.id ? t : n,
+			var2: t.id <= n.id ? n : t,
+			coeff: r
+		}), i;
+	}
+}, k = 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 O) 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 O ? 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 O();
+		Math.abs(this.constant) >= 1e-12 && n.linearTerms.set(t, this.constant);
+		for (let [e, r] of this.terms) n = n.add(O.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 x(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 A(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 k(n, r);
+}
+var j = A, M = A, N = 0, P = class e {
+	id;
+	name;
+	type;
+	lb;
+	ub;
+	value = null;
+	reducedCost = null;
+	constructor(e = {}) {
+		this.id = ++N, 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 k(/* @__PURE__ */ new Map([[this, t]]), 0);
+		if (t instanceof e) return O.fromProduct(this, t, 1);
+		let n = new O();
+		Math.abs(t.constant) >= 1e-12 && n.linearTerms.set(this, t.constant);
+		for (let [e, r] of t.terms) {
+			let t = O.fromProduct(this, e, r);
+			n = n.add(t);
+		}
+		return n;
+	}
+	add(e) {
+		return e instanceof O ? e.add(this) : new k(/* @__PURE__ */ new Map([[this, 1]]), 0).add(e);
+	}
+	sub(e) {
+		return e instanceof O ? e.neg().add(this) : new k(/* @__PURE__ */ new Map([[this, 1]]), 0).sub(e);
+	}
+	neg() {
+		return this.mul(-1);
+	}
+	le(e, t) {
+		return new k(/* @__PURE__ */ new Map([[this, 1]]), 0).le(e, t);
+	}
+	lessThanOrEqual(e, t) {
+		return this.le(e, t);
+	}
+	ge(e, t) {
+		return new k(/* @__PURE__ */ new Map([[this, 1]]), 0).ge(e, t);
+	}
+	greaterThanOrEqual(e, t) {
+		return this.ge(e, t);
+	}
+	eq(e, t) {
+		return new k(/* @__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 F(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 k(/* @__PURE__ */ new Map(), t);
+		}
+		if (e.type === "IDENT") {
+			this.consume();
+			let t = this.resolveVariable(e.value);
+			return new k(/* @__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 I(e, t) {
+	return new te(F(e), t).parseExpression();
+}
+function L(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 = I(o, t), u = I(s, t);
+	return c === "<=" ? l.le(u, n) : c === ">=" ? l.ge(u, n) : l.eq(u, n);
+}
+function R(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 P) {
+			let t = `__v_${i}__`;
+			n.set(t, e), r += t;
+		} else if (e instanceof k) {
+			`${i}`, r += `(${e.toString()})`;
+			for (let [t] of e.terms) n.set(t.name, t);
+		}
+	}
+	return {
+		fullText: r,
+		resolver: (e) => n.get(e)
+	};
+}
+function z(e, ...t) {
+	let { fullText: n, resolver: r } = R(e, t);
+	return L(n, r);
+}
+function B(e, ...t) {
+	let { fullText: n, resolver: r } = R(e, t);
+	return /(<=|>=|==|=<|=>|=)/.test(n) ? L(n, r) : I(n, r);
+}
+//#endregion
+//#region src/modeler/lp-writer.ts
+function V(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 H(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 = V(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 = V(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 O ? 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 O && 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/model.ts
+var U = 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 k(), e.solver && (this.solver = v(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 P(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" ? I(e, (e) => this.getVarByName(e)) : typeof e == "number" ? new k(/* @__PURE__ */ new Map(), e) : e instanceof O || "terms" in e ? e.clone() : new k(/* @__PURE__ */ new Map([[e, 1]]), 0);
+	}
+	maximize(e) {
+		this.setObjective(e, "Maximize");
+	}
+	minimize(e) {
+		this.setObjective(e, "Minimize");
+	}
+	addBoolVar(e) {
+		let t = new C(e);
+		return this.boolVars.push(t), t;
+	}
+	addConstraint(e, t) {
+		if (e instanceof w) {
+			let n = t || `lc_${this.logicalConstraints.length + 1}`;
+			return this.logicalConstraints.push({
+				name: n,
+				expr: e
+			}), e;
+		}
+		let n;
+		if (typeof e == "string" ? n = L(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 P ? (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 } = H({
+			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 = v(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = v(r.solver, r), delete r.solver) : n = this.solver || v()), this.objective instanceof O && 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 = H(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 = v(e, t), r = t || {}) : (r = { ...e }, r.solver ? (n = v(r.solver, r), delete r.solver) : n = this.solver || v()), 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 k(), 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;
+		}
+	}
+}, W = "Minimize", G = "Maximize", K = "Continuous", q = "Integer", J = "Binary", Y = {
+	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"
+}, X = class e extends P {
+	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 Z(e) {
+	return e == null ? null : typeof e == "number" ? e : e.value;
+}
+var ne = class {
+	model;
+	constructor(e = "NoName", t = W) {
+		this.model = new U({
+			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 P && 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 x ? 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", re = "Binary", ie = "Integer", ae = "Continuous";
+function oe(e) {
+	return {
+		expr: e,
+		sense: $
+	};
+}
+function se(e) {
+	return {
+		expr: e,
+		sense: Q
+	};
+}
+var ce = class extends U {
+	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 { re as BINARY, w as BoolExpr, o as BoolOp, C as BoolVar, ae as CONTINUOUS, x as Constraint, E as GLPKSolver, s as HiGHS, p as HighsSolver, ie as INTEGER, k as LinExpr, J as LpBinary, K as LpContinuous, q as LpInteger, G as LpMaximize, W as LpMinimize, ne as LpProblem, Y as LpStatus, X as LpVariable, $ as MAXIMIZE, Q as MINIMIZE, ce as MipModel, ee as MockSolver, U as Model, b as OFFICIAL_HIGHS_CDN_WASM_URL, O as QuadExpr, P as Var, y as Z3Solver, n as and, z as c, B as expr, H as generateLpString, T as getGlpk, c as getHighs, l as getHighsWasmUrl, v as getSolver, e as implies, _ as isValidWasmHeader, f as listAvailableSolvers, M as lpSum, oe as maximize, se as minimize, S as not, r as or, L as parseConstraint, I as parseExpr, m as probeWasmUrl, a as registerSolver, h as registerZ3Solver, d as resolveBrowserWasmUrl, g as setDefaultSolver, u as setHighsWasmUrl, i as solveLpWithHighs, A as sum, Z as value, t as xor, j as xsum };