@ohtaman/washi 0.1.2 → 0.2.0

package/dist/lib/async-mutex-Duo4jwzn.js

@@ -0,0 +1,195 @@
+//#region node_modules/async-mutex/index.mjs
+var e = /* @__PURE__ */ Error("timeout while waiting for mutex to become available"), t = /* @__PURE__ */ Error("mutex already locked"), n = /* @__PURE__ */ Error("request for lock canceled"), r = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, i = class {
+	constructor(e, t = n) {
+		if (this._maxConcurrency = e, this._cancelError = t, this._queue = [], this._waiters = [], e <= 0) throw Error("semaphore must be initialized to a positive value");
+		this._value = e;
+	}
+	acquire() {
+		let e = this.isLocked(), t = new Promise((e, t) => this._queue.push({
+			resolve: e,
+			reject: t
+		}));
+		return e || this._dispatch(), t;
+	}
+	runExclusive(e) {
+		return r(this, void 0, void 0, function* () {
+			let [t, n] = yield this.acquire();
+			try {
+				return yield e(t);
+			} finally {
+				n();
+			}
+		});
+	}
+	waitForUnlock() {
+		return r(this, void 0, void 0, function* () {
+			return this.isLocked() ? new Promise((e) => this._waiters.push({ resolve: e })) : Promise.resolve();
+		});
+	}
+	isLocked() {
+		return this._value <= 0;
+	}
+	release() {
+		if (this._maxConcurrency > 1) throw Error("this method is unavailable on semaphores with concurrency > 1; use the scoped release returned by acquire instead");
+		if (this._currentReleaser) {
+			let e = this._currentReleaser;
+			this._currentReleaser = void 0, e();
+		}
+	}
+	cancel() {
+		this._queue.forEach((e) => e.reject(this._cancelError)), this._queue = [];
+	}
+	_dispatch() {
+		let e = this._queue.shift();
+		if (!e) return;
+		let t = !1;
+		this._currentReleaser = () => {
+			t || (t = !0, this._value++, this._resolveWaiters(), this._dispatch());
+		}, e.resolve([this._value--, this._currentReleaser]);
+	}
+	_resolveWaiters() {
+		this._waiters.forEach((e) => e.resolve()), this._waiters = [];
+	}
+}, a = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, o = class {
+	constructor(e) {
+		this._semaphore = new i(1, e);
+	}
+	acquire() {
+		return a(this, void 0, void 0, function* () {
+			let [, e] = yield this._semaphore.acquire();
+			return e;
+		});
+	}
+	runExclusive(e) {
+		return this._semaphore.runExclusive(() => e());
+	}
+	isLocked() {
+		return this._semaphore.isLocked();
+	}
+	waitForUnlock() {
+		return this._semaphore.waitForUnlock();
+	}
+	release() {
+		this._semaphore.release();
+	}
+	cancel() {
+		return this._semaphore.cancel();
+	}
+}, s = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+};
+function c(t, n, r = e) {
+	return {
+		acquire: () => new Promise((e, i) => s(this, void 0, void 0, function* () {
+			let a = !1, o = setTimeout(() => {
+				a = !0, i(r);
+			}, n);
+			try {
+				let n = yield t.acquire();
+				a ? (Array.isArray(n) ? n[1] : n)() : (clearTimeout(o), e(n));
+			} catch (e) {
+				a || (clearTimeout(o), i(e));
+			}
+		})),
+		runExclusive(e) {
+			return s(this, void 0, void 0, function* () {
+				let t = () => void 0;
+				try {
+					let n = yield this.acquire();
+					return Array.isArray(n) ? (t = n[1], yield e(n[0])) : (t = n, yield e());
+				} finally {
+					t();
+				}
+			});
+		},
+		release() {
+			t.release();
+		},
+		cancel() {
+			return t.cancel();
+		},
+		waitForUnlock: () => t.waitForUnlock(),
+		isLocked: () => t.isLocked()
+	};
+}
+function l(e, n = t) {
+	return c(e, 0, n);
+}
+//#endregion
+export { t as E_ALREADY_LOCKED, n as E_CANCELED, e as E_TIMEOUT, o as Mutex, i as Semaphore, l as tryAcquire, c as withTimeout };

package/dist/lib/constraint-XWdn0ID9.js

@@ -0,0 +1,93 @@
+//#region src/modeler/boolean-expr.ts
+var e = 0, t = class {
+	and(e) {
+		return new r("and", [this, e]);
+	}
+	or(e) {
+		return new r("or", [this, e]);
+	}
+	implies(e) {
+		return new r("implies", [this, e]);
+	}
+	xor(e) {
+		return new r("xor", [this, e]);
+	}
+	not() {
+		return new r("not", [this]);
+	}
+}, n = class extends t {
+	id;
+	name;
+	value = null;
+	constructor(t) {
+		super(), this.id = ++e, this.name = t || `p_${this.id}`;
+	}
+	toString() {
+		return this.name;
+	}
+}, r = class extends t {
+	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 i(...e) {
+	if (e.length === 0) throw Error("and() requires at least one expression");
+	return new r("and", e);
+}
+function a(...e) {
+	if (e.length === 0) throw Error("or() requires at least one expression");
+	return new r("or", e);
+}
+function o(e) {
+	return new r("not", [e]);
+}
+function s(e, t) {
+	return new r("implies", [e, t]);
+}
+function c(...e) {
+	if (e.length === 0) throw Error("xor() requires at least one expression");
+	return new r("xor", e);
+}
+//#endregion
+//#region src/modeler/constraint.ts
+var l = 0, u = class {
+	id;
+	lhs;
+	sense;
+	rhs;
+	name;
+	slack = null;
+	dual = null;
+	constructor(e, t, n, r) {
+		this.id = ++l, this.lhs = e, this.sense = t, this.rhs = n, this.name = r || `c_${this.id}`;
+	}
+	get pi() {
+		return this.dual;
+	}
+	and(e) {
+		return new r("and", [this, e]);
+	}
+	or(e) {
+		return new r("or", [this, e]);
+	}
+	implies(e) {
+		return new r("implies", [this, e]);
+	}
+	xor(e) {
+		return new r("xor", [this, e]);
+	}
+	not() {
+		return new r("not", [this]);
+	}
+	toString() {
+		let e = this.sense === "==" ? "=" : this.sense;
+		return `${this.name}: ${this.lhs.toString()} ${e} ${this.rhs}`;
+	}
+};
+//#endregion
+export { i as a, a as c, n as i, c as l, t as n, s as o, r, o as s, u as t };

package/dist/lib/highs-worker.js

@@ -1,5 +1,5 @@
-import { c as e } from "./highs-loader-Blb99785.js";
-//#region src/highs-worker.ts
+import { c as e } from "./loader-Dti0v9yC.js";
+//#region src/modeler/solvers/highs/worker.ts
 self.onmessage = async (t) => {
 	let { type: n, id: r, lpString: i, options: a } = t.data;
 	if (n === "SOLVE") try {

package/dist/lib/{highs-loader-Blb99785.js → loader-Dti0v9yC.js}

@@ -1,6 +1,6 @@
 import { getBundledWasmUrl as e } from "./highs-assets.js";
 import { loadNodeHighs as t } from "./highs-node-runtime.js";
-//#region src/highs-loader.ts
+//#region src/modeler/solvers/highs/loader.ts
 var n = "https://cdn.jsdelivr.net/npm/highs@1.15.3/build/highs.wasm", r = null, i = null, a = null;
 function o(e) {
 	a = e, r = null, i = null;

package/dist/lib/registry-DksqCSjI.js

@@ -0,0 +1,32 @@
+//#region src/modeler/solvers/registry.ts
+var e = Symbol.for("washi.solverRegistry"), t = Symbol.for("washi.defaultSolverFactory"), n = globalThis;
+n[e] || (n[e] = /* @__PURE__ */ new Map());
+var r = n[e];
+function i(e, t) {
+	r.set(e.toLowerCase(), t);
+}
+function a(e) {
+	if (typeof e == "string") {
+		let i = r.get(e.toLowerCase());
+		if (!i) throw Error(`Solver '${e}' is not registered.`);
+		n[t] = i;
+	} else n[t] = typeof e == "function" ? e : () => e;
+}
+function o(e, i) {
+	if (!e) {
+		let e = n[t] || r.get("highs");
+		if (!e) throw Error(`No default solver available. Available solvers: ${s().join(", ")}`);
+		return e(i);
+	}
+	if (typeof e == "string") {
+		let t = e.toLowerCase(), n = r.get(t);
+		if (!n) throw Error(t === "glpk" ? `Solver 'glpk' not found. Available solvers: ${s().join(", ")}. Please import '@ohtaman/washi/solvers/glpk' before selecting this solver.` : t === "z3" ? `Solver 'z3' not found. Available solvers: ${s().join(", ")}. Please import '@ohtaman/washi/solvers/z3' before selecting this solver.` : `Solver '${e}' not found. Available solvers: ${s().join(", ")}`);
+		return n(i);
+	}
+	return e;
+}
+function s() {
+	return Array.from(r.keys());
+}
+//#endregion
+export { a as i, s as n, i as r, o as t };

package/dist/lib/solvers/glpk.js

@@ -1,2 +1,153 @@
-import { t as e } from "../glpk-5cUpjyb9.js";
-export { e as GLPKSolver };
+import { r as e } from "../registry-DksqCSjI.js";
+//#region src/modeler/solvers/glpk/loader.ts
+var t = null, n = null;
+async function r() {
+	if (t) return t;
+	let e = (async () => {
+		let e = typeof process < "u" && process.versions && process.versions.node && process.type !== "renderer";
+		try {
+			if (e) {
+				let e = await import(
+					/* webpackIgnore: true */
+					/* @vite-ignore */
+					"glpk.js/node"
+), t = await (e.default || e)();
+				return n = t, t;
+			}
+			let t = await import("glpk.js"), r = await (t.default || t)();
+			return n = r, r;
+		} catch (e) {
+			throw Error("[WaSHI] Could not load GLPK. Install the optional glpk.js dependency before selecting this solver.", { cause: e });
+		}
+	})();
+	return e.catch(() => {
+		t === e && (t = null, n = null);
+	}), t = e, e;
+}
+function i() {
+	if (n && typeof n.terminate == "function") try {
+		n.terminate();
+	} catch {}
+	n = null, t = null;
+}
+function a() {
+	i();
+}
+//#endregion
+//#region src/modeler/solvers/glpk/solver.ts
+var o = 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 i = {
+			...this.options,
+			...n
+		}, a = await r(), { nameToVar: o, nameToConstraint: s } = t, c = /* @__PURE__ */ new Map();
+		for (let [e, t] of o.entries()) c.set(t, e);
+		let l = /* @__PURE__ */ new Map();
+		for (let [e, t] of s.entries()) l.set(t, e);
+		let u = [], d = "linearTerms" in e.objective ? e.objective.linearTerms : e.objective.terms;
+		if (d) for (let [e, t] of d) {
+			if (Math.abs(t) < 1e-12) continue;
+			let n = c.get(e) || e.name;
+			u.push({
+				name: n,
+				coef: Number(t)
+			});
+		}
+		let f = [];
+		for (let t of e.constraints) {
+			let e = l.get(t) || t.name || `c_${f.length + 1}`, n = [];
+			for (let [e, r] of t.lhs.terms) {
+				if (Math.abs(r) < 1e-12) continue;
+				let t = c.get(e) || e.name;
+				n.push({
+					name: t,
+					coef: Number(r)
+				});
+			}
+			let r;
+			r = t.sense === "==" ? {
+				type: a.GLP_FX,
+				lb: t.rhs,
+				ub: t.rhs
+			} : t.sense === "<=" ? {
+				type: a.GLP_UP,
+				lb: -Infinity,
+				ub: t.rhs
+			} : {
+				type: a.GLP_LO,
+				lb: t.rhs,
+				ub: Infinity
+			}, f.push({
+				name: e,
+				vars: n,
+				bnds: r
+			});
+		}
+		let p = [], m = [], h = [];
+		for (let t of e.variables) {
+			let e = c.get(t) || t.name;
+			t.type === "Binary" ? p.push(e) : t.type === "Integer" && m.push(e);
+			let n = t.lb, r = t.ub, i;
+			i = n === -Infinity && r === Infinity ? a.GLP_FR : n !== -Infinity && r === Infinity ? a.GLP_LO : n === -Infinity && r !== Infinity ? a.GLP_UP : n === r ? a.GLP_FX : a.GLP_DB, h.push({
+				name: e,
+				type: i,
+				lb: n === -Infinity ? 0 : n,
+				ub: r === Infinity ? 0 : r
+			});
+		}
+		let g = {
+			name: e.name || "GLPK_Model",
+			objective: {
+				direction: e.sense === "Maximize" ? a.GLP_MAX : a.GLP_MIN,
+				name: "obj",
+				vars: u
+			},
+			subjectTo: f
+		};
+		h.length > 0 && (g.bounds = h), p.length > 0 && (g.binaries = p), m.length > 0 && (g.generals = m);
+		let _ = {
+			msglev: i.verbose ? a.GLP_MSG_ALL : a.GLP_MSG_OFF,
+			presol: i.presolve !== "off"
+		};
+		typeof i.timeLimit == "number" && (_.tmlim = i.timeLimit), typeof i.mipGap == "number" && (_.mipgap = i.mipGap);
+		let v = performance.now(), y = await a.solve(g, _), b = (performance.now() - v) / 1e3, x = y?.result?.status, S;
+		S = x === a.GLP_OPT ? "Optimal" : x === a.GLP_FEAS ? "Feasible" : x === a.GLP_INFEAS || x === a.GLP_NOFEAS ? "Infeasible" : x === a.GLP_UNBND ? "Unbounded" : "Optimal";
+		let C = y?.result?.z, w = typeof C == "number" ? C + e.objective.constant : null, T = {}, E = y?.result?.vars || {};
+		for (let [e, t] of Object.entries(E)) {
+			let n = o.get(e), r = n ? n.name : e;
+			T[r] = typeof t == "number" ? Math.abs(t) < 1e-9 ? 0 : t : 0;
+		}
+		for (let t of e.variables) T[t.name] === void 0 && (T[t.name] = 0);
+		let D = {};
+		if (y?.result?.dual) for (let [e, t] of Object.entries(y.result.dual)) {
+			let n = s.get(e), r = n ? n.name : e;
+			D[r] = Number(t);
+		}
+		return {
+			status: S,
+			objectiveValue: w,
+			values: T,
+			duals: D,
+			runTime: y?.time || b,
+			logs: [`GLPK solved in ${(y?.time || b) * 1e3} ms.`],
+			raw: y
+		};
+	}
+};
+function s() {
+	e("glpk", (e) => new o(e));
+}
+s();
+//#endregion
+export { o as GLPKSolver, r as getGlpk, s as registerGLPKSolver, a as resetGlpkCache, i as terminateGlpk };

package/dist/lib/solvers/z3-assets.js

@@ -0,0 +1 @@
+export function getBundledZ3AssetUrls() { return { jsUrl: new URL("./z3-built.js", import.meta.url).href, wasmUrl: new URL("./z3-built.wasm", import.meta.url).href }; }