likec4 1.47.0 → 1.48.0

package/dist/_chunks/libs/@lume/kiwi.mjs

@@ -0,0 +1,1355 @@
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/maptype.js
+function createMap() {
+	return new IndexedMap();
+}
+var IndexedMap = class IndexedMap {
+	index = {};
+	array = [];
+	/**
+	* Returns the number of items in the array.
+	*/
+	size() {
+		return this.array.length;
+	}
+	/**
+	* Returns true if the array is empty.
+	*/
+	empty() {
+		return this.array.length === 0;
+	}
+	/**
+	* Returns the item at the given array index.
+	*
+	* @param index The integer index of the desired item.
+	*/
+	itemAt(index) {
+		return this.array[index];
+	}
+	/**
+	* Returns true if the key is in the array, false otherwise.
+	*
+	* @param key The key to locate in the array.
+	*/
+	contains(key) {
+		return this.index[key.id()] !== void 0;
+	}
+	/**
+	* Returns the pair associated with the given key, or undefined.
+	*
+	* @param key The key to locate in the array.
+	*/
+	find(key) {
+		const i = this.index[key.id()];
+		return i === void 0 ? void 0 : this.array[i];
+	}
+	/**
+	* Returns the pair associated with the key if it exists.
+	*
+	* If the key does not exist, a new pair will be created and
+	* inserted using the value created by the given factory.
+	*
+	* @param key The key to locate in the array.
+	* @param factory The function which creates the default value.
+	*/
+	setDefault(key, factory) {
+		const i = this.index[key.id()];
+		if (i === void 0) {
+			const pair = new Pair(key, factory());
+			this.index[key.id()] = this.array.length;
+			this.array.push(pair);
+			return pair;
+		} else return this.array[i];
+	}
+	/**
+	* Insert the pair into the array and return the pair.
+	*
+	* This will overwrite any existing entry in the array.
+	*
+	* @param key The key portion of the pair.
+	* @param value The value portion of the pair.
+	*/
+	insert(key, value) {
+		const pair = new Pair(key, value);
+		const i = this.index[key.id()];
+		if (i === void 0) {
+			this.index[key.id()] = this.array.length;
+			this.array.push(pair);
+		} else this.array[i] = pair;
+		return pair;
+	}
+	/**
+	* Removes and returns the pair for the given key, or undefined.
+	*
+	* @param key The key to remove from the map.
+	*/
+	erase(key) {
+		const i = this.index[key.id()];
+		if (i === void 0) return;
+		this.index[key.id()] = void 0;
+		const pair = this.array[i];
+		const last = this.array.pop();
+		if (pair !== last) {
+			this.array[i] = last;
+			this.index[last.first.id()] = i;
+		}
+		return pair;
+	}
+	/**
+	* Create a copy of this associative array.
+	*/
+	copy() {
+		const copy = new IndexedMap();
+		for (let i = 0; i < this.array.length; i++) {
+			const pair = this.array[i].copy();
+			copy.array[i] = pair;
+			copy.index[pair.first.id()] = i;
+		}
+		return copy;
+	}
+};
+/**
+* A class which defines a generic pair object.
+* @private
+*/
+var Pair = class Pair {
+	first;
+	second;
+	/**
+	* Construct a new Pair object.
+	*
+	* @param first The first item of the pair.
+	* @param second The second item of the pair.
+	*/
+	constructor(first, second) {
+		this.first = first;
+		this.second = second;
+	}
+	/**
+	* Create a copy of the pair.
+	*/
+	copy() {
+		return new Pair(this.first, this.second);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/variable.js
+/**
+* The primary user constraint variable.
+*
+* @class
+* @param {String} [name=""] The name to associated with the variable.
+*/
+var Variable = class {
+	constructor(name = "") {
+		this._name = name;
+	}
+	/**
+	* Returns the unique id number of the variable.
+	* @private
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the name of the variable.
+	*
+	* @return {String} name of the variable
+	*/
+	name() {
+		return this._name;
+	}
+	/**
+	* Set the name of the variable.
+	*
+	* @param {String} name Name of the variable
+	*/
+	setName(name) {
+		this._name = name;
+	}
+	/**
+	* Returns the user context object of the variable.
+	* @private
+	*/
+	context() {
+		return this._context;
+	}
+	/**
+	* Set the user context object of the variable.
+	* @private
+	*/
+	setContext(context) {
+		this._context = context;
+	}
+	/**
+	* Returns the value of the variable.
+	*
+	* @return {Number} Calculated value
+	*/
+	value() {
+		return this._value;
+	}
+	/**
+	* Set the value of the variable.
+	* @private
+	*/
+	setValue(value) {
+		this._value = value;
+	}
+	/**
+	* Creates a new Expression by adding a number, variable or expression
+	* to the variable.
+	*
+	* @param {Number|Variable|Expression} value Value to add.
+	* @return {Expression} expression
+	*/
+	plus(value) {
+		return new Expression(this, value);
+	}
+	/**
+	* Creates a new Expression by substracting a number, variable or expression
+	* from the variable.
+	*
+	* @param {Number|Variable|Expression} value Value to substract.
+	* @return {Expression} expression
+	*/
+	minus(value) {
+		return new Expression(this, typeof value === "number" ? -value : [-1, value]);
+	}
+	/**
+	* Creates a new Expression by multiplying with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to multiply with.
+	* @return {Expression} expression
+	*/
+	multiply(coefficient) {
+		return new Expression([coefficient, this]);
+	}
+	/**
+	* Creates a new Expression by dividing with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to divide by.
+	* @return {Expression} expression
+	*/
+	divide(coefficient) {
+		return new Expression([1 / coefficient, this]);
+	}
+	/**
+	* Returns the JSON representation of the variable.
+	* @private
+	*/
+	toJSON() {
+		return {
+			name: this._name,
+			value: this._value
+		};
+	}
+	toString() {
+		return this._context + "[" + this._name + ":" + this._value + "]";
+	}
+	_name;
+	_value = 0;
+	_context = null;
+	_id = VarId++;
+};
+/**
+* The internal variable id counter.
+* @private
+*/
+let VarId = 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/expression.js
+/**
+* An expression of variable terms and a constant.
+*
+* The constructor accepts an arbitrary number of parameters,
+* each of which must be one of the following types:
+*  - number
+*  - Variable
+*  - Expression
+*  - 2-tuple of [number, Variable|Expression]
+*
+* The parameters are summed. The tuples are multiplied.
+*
+* @class
+* @param {...(number|Variable|Expression|Array)} args
+*/
+var Expression = class Expression {
+	constructor() {
+		let parsed = parseArgs(arguments);
+		this._terms = parsed.terms;
+		this._constant = parsed.constant;
+	}
+	/**
+	* Returns the mapping of terms in the expression.
+	*
+	* This *must* be treated as const.
+	* @private
+	*/
+	terms() {
+		return this._terms;
+	}
+	/**
+	* Returns the constant of the expression.
+	* @private
+	*/
+	constant() {
+		return this._constant;
+	}
+	/**
+	* Returns the computed value of the expression.
+	*
+	* @private
+	* @return {Number} computed value of the expression
+	*/
+	value() {
+		let result = this._constant;
+		for (let i = 0, n = this._terms.size(); i < n; i++) {
+			let pair = this._terms.itemAt(i);
+			result += pair.first.value() * pair.second;
+		}
+		return result;
+	}
+	/**
+	* Creates a new Expression by adding a number, variable or expression
+	* to the expression.
+	*
+	* @param {Number|Variable|Expression} value Value to add.
+	* @return {Expression} expression
+	*/
+	plus(value) {
+		return new Expression(this, value);
+	}
+	/**
+	* Creates a new Expression by substracting a number, variable or expression
+	* from the expression.
+	*
+	* @param {Number|Variable|Expression} value Value to substract.
+	* @return {Expression} expression
+	*/
+	minus(value) {
+		return new Expression(this, typeof value === "number" ? -value : [-1, value]);
+	}
+	/**
+	* Creates a new Expression by multiplying with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to multiply with.
+	* @return {Expression} expression
+	*/
+	multiply(coefficient) {
+		return new Expression([coefficient, this]);
+	}
+	/**
+	* Creates a new Expression by dividing with a fixed number.
+	*
+	* @param {Number} coefficient Coefficient to divide by.
+	* @return {Expression} expression
+	*/
+	divide(coefficient) {
+		return new Expression([1 / coefficient, this]);
+	}
+	isConstant() {
+		return this._terms.size() == 0;
+	}
+	toString() {
+		let result = this._terms.array.map(function(pair) {
+			return pair.second + "*" + pair.first.toString();
+		}).join(" + ");
+		if (!this.isConstant() && this._constant !== 0) result += " + ";
+		result += this._constant;
+		return result;
+	}
+	_terms;
+	_constant;
+};
+/**
+* An internal argument parsing function.
+* @private
+*/
+function parseArgs(args) {
+	let constant = 0;
+	let factory = () => 0;
+	let terms = createMap();
+	for (let i = 0, n = args.length; i < n; ++i) {
+		let item = args[i];
+		if (typeof item === "number") constant += item;
+		else if (item instanceof Variable) terms.setDefault(item, factory).second += 1;
+		else if (item instanceof Expression) {
+			constant += item.constant();
+			let terms2 = item.terms();
+			for (let j = 0, k = terms2.size(); j < k; j++) {
+				let termPair = terms2.itemAt(j);
+				terms.setDefault(termPair.first, factory).second += termPair.second;
+			}
+		} else if (item instanceof Array) {
+			if (item.length !== 2) throw new Error("array must have length 2");
+			let value = item[0];
+			let value2 = item[1];
+			if (typeof value !== "number") throw new Error("array item 0 must be a number");
+			if (value2 instanceof Variable) terms.setDefault(value2, factory).second += value;
+			else if (value2 instanceof Expression) {
+				constant += value2.constant() * value;
+				let terms2 = value2.terms();
+				for (let j = 0, k = terms2.size(); j < k; j++) {
+					let termPair = terms2.itemAt(j);
+					terms.setDefault(termPair.first, factory).second += termPair.second * value;
+				}
+			} else throw new Error("array item 1 must be a variable or expression");
+		} else throw new Error("invalid Expression argument: " + item);
+	}
+	return {
+		terms,
+		constant
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/strength.js
+/**
+* @class Strength
+*/
+var Strength = class Strength {
+	/**
+	* Create a new symbolic strength.
+	*
+	* @param a strong
+	* @param b medium
+	* @param c weak
+	* @param [w] weight
+	* @return strength
+	*/
+	static create(a, b, c, w = 1) {
+		let result = 0;
+		result += Math.max(0, Math.min(1e3, a * w)) * 1e6;
+		result += Math.max(0, Math.min(1e3, b * w)) * 1e3;
+		result += Math.max(0, Math.min(1e3, c * w));
+		return result;
+	}
+	/**
+	* The 'required' symbolic strength.
+	*/
+	static required = Strength.create(1e3, 1e3, 1e3);
+	/**
+	* The 'strong' symbolic strength.
+	*/
+	static strong = Strength.create(1, 0, 0);
+	/**
+	* The 'medium' symbolic strength.
+	*/
+	static medium = Strength.create(0, 1, 0);
+	/**
+	* The 'weak' symbolic strength.
+	*/
+	static weak = Strength.create(0, 0, 1);
+	/**
+	* Clip a symbolic strength to the allowed min and max.
+	* @private
+	*/
+	static clip(value) {
+		return Math.max(0, Math.min(Strength.required, value));
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/constraint.js
+/**
+* An enum defining the linear constraint operators.
+*
+* |Value|Operator|Description|
+* |----|-----|-----|
+* |`Le`|<=|Less than equal|
+* |`Ge`|>=|Greater than equal|
+* |`Eq`|==|Equal|
+*
+* @enum {Number}
+*/
+var Operator;
+(function(Operator) {
+	Operator[Operator["Le"] = 0] = "Le";
+	Operator[Operator["Ge"] = 1] = "Ge";
+	Operator[Operator["Eq"] = 2] = "Eq";
+})(Operator || (Operator = {}));
+/**
+* A linear constraint equation.
+*
+* A constraint equation is composed of an expression, an operator,
+* and a strength. The RHS of the equation is implicitly zero.
+*
+* @class
+* @param {Expression} expression The constraint expression (LHS).
+* @param {Operator} operator The equation operator.
+* @param {Expression} [rhs] Right hand side of the expression.
+* @param {Number} [strength=Strength.required] The strength of the constraint.
+*/
+var Constraint = class {
+	constructor(expression, operator, rhs, strength = Strength.required) {
+		this._operator = operator;
+		this._strength = Strength.clip(strength);
+		if (rhs === void 0 && expression instanceof Expression) this._expression = expression;
+		else this._expression = expression.minus(rhs);
+	}
+	/**
+	* Returns the unique id number of the constraint.
+	* @private
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the expression of the constraint.
+	*
+	* @return {Expression} expression
+	*/
+	expression() {
+		return this._expression;
+	}
+	/**
+	* Returns the relational operator of the constraint.
+	*
+	* @return {Operator} linear constraint operator
+	*/
+	op() {
+		return this._operator;
+	}
+	/**
+	* Returns the strength of the constraint.
+	*
+	* @return {Number} strength
+	*/
+	strength() {
+		return this._strength;
+	}
+	toString() {
+		return this._expression.toString() + " " + [
+			"<=",
+			">=",
+			"="
+		][this._operator] + " 0 (" + this._strength.toString() + ")";
+	}
+	_expression;
+	_operator;
+	_strength;
+	_id = CnId++;
+};
+/**
+* The internal constraint id counter.
+* @private
+*/
+let CnId = 0;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@lume+kiwi@0.4.4/node_modules/@lume/kiwi/dist/solver.js
+/**
+* The constraint solver class.
+*
+* @class
+*/
+var Solver = class {
+	/**
+	* @type {number} - The max number of solver iterations before an error
+	* is thrown, in order to prevent infinite iteration. Default: `10,000`.
+	*/
+	maxIterations = 1e3;
+	/**
+	* Construct a new Solver.
+	*/
+	constructor() {}
+	/**
+	* Creates and add a constraint to the solver.
+	*
+	* @param {Expression|Variable} lhs Left hand side of the expression
+	* @param {Operator} operator Operator
+	* @param {Expression|Variable|Number} rhs Right hand side of the expression
+	* @param {Number} [strength=Strength.required] Strength
+	*/
+	createConstraint(lhs, operator, rhs, strength = Strength.required) {
+		let cn = new Constraint(lhs, operator, rhs, strength);
+		this.addConstraint(cn);
+		return cn;
+	}
+	/**
+	* Add a constraint to the solver.
+	*
+	* @param {Constraint} constraint Constraint to add to the solver
+	*/
+	addConstraint(constraint) {
+		if (this._cnMap.find(constraint) !== void 0) throw new Error("duplicate constraint");
+		let data = this._createRow(constraint);
+		let row = data.row;
+		let tag = data.tag;
+		let subject = this._chooseSubject(row, tag);
+		if (subject.type() === SymbolType.Invalid && row.allDummies()) if (!nearZero(row.constant())) throw new Error("unsatisfiable constraint");
+		else subject = tag.marker;
+		if (subject.type() === SymbolType.Invalid) {
+			if (!this._addWithArtificialVariable(row)) throw new Error("unsatisfiable constraint");
+		} else {
+			row.solveFor(subject);
+			this._substitute(subject, row);
+			this._rowMap.insert(subject, row);
+		}
+		this._cnMap.insert(constraint, tag);
+		this._optimize(this._objective);
+	}
+	/**
+	* Remove a constraint from the solver.
+	*
+	* @param {Constraint} constraint Constraint to remove from the solver
+	*/
+	removeConstraint(constraint) {
+		let cnPair = this._cnMap.erase(constraint);
+		if (cnPair === void 0) throw new Error("unknown constraint");
+		this._removeConstraintEffects(constraint, cnPair.second);
+		let marker = cnPair.second.marker;
+		let rowPair = this._rowMap.erase(marker);
+		if (rowPair === void 0) {
+			let leaving = this._getMarkerLeavingSymbol(marker);
+			if (leaving.type() === SymbolType.Invalid) throw new Error("failed to find leaving row");
+			rowPair = this._rowMap.erase(leaving);
+			rowPair.second.solveForEx(leaving, marker);
+			this._substitute(marker, rowPair.second);
+		}
+		this._optimize(this._objective);
+	}
+	/**
+	* Test whether the solver contains the constraint.
+	*
+	* @param {Constraint} constraint Constraint to test for
+	* @return {Bool} true or false
+	*/
+	hasConstraint(constraint) {
+		return this._cnMap.contains(constraint);
+	}
+	/**
+	* Get an array of the current constraints.
+	*
+	* @return {Constraint[]}
+	*/
+	getConstraints() {
+		return this._cnMap.array.map(({ first }) => first);
+	}
+	/**
+	* Add an edit variable to the solver.
+	*
+	* @param {Variable} variable Edit variable to add to the solver
+	* @param {Number} strength Strength, should be less than `Strength.required`
+	*/
+	addEditVariable(variable, strength) {
+		if (this._editMap.find(variable) !== void 0) throw new Error("duplicate edit variable");
+		strength = Strength.clip(strength);
+		if (strength === Strength.required) throw new Error("bad required strength");
+		let cn = new Constraint(new Expression(variable), Operator.Eq, void 0, strength);
+		this.addConstraint(cn);
+		let info = {
+			tag: this._cnMap.find(cn).second,
+			constraint: cn,
+			constant: 0
+		};
+		this._editMap.insert(variable, info);
+	}
+	/**
+	* Remove an edit variable from the solver.
+	*
+	* @param {Variable} variable Edit variable to remove from the solver
+	*/
+	removeEditVariable(variable) {
+		let editPair = this._editMap.erase(variable);
+		if (editPair === void 0) throw new Error("unknown edit variable");
+		this.removeConstraint(editPair.second.constraint);
+	}
+	/**
+	* Test whether the solver contains the edit variable.
+	*
+	* @param {Variable} variable Edit variable to test for
+	* @return {Bool} true or false
+	*/
+	hasEditVariable(variable) {
+		return this._editMap.contains(variable);
+	}
+	/**
+	* Suggest the value of an edit variable.
+	*
+	* @param {Variable} variable Edit variable to suggest a value for
+	* @param {Number} value Suggested value
+	*/
+	suggestValue(variable, value) {
+		let editPair = this._editMap.find(variable);
+		if (editPair === void 0) throw new Error("unknown edit variable");
+		let rows = this._rowMap;
+		let info = editPair.second;
+		let delta = value - info.constant;
+		info.constant = value;
+		let marker = info.tag.marker;
+		let rowPair = rows.find(marker);
+		if (rowPair !== void 0) {
+			if (rowPair.second.add(-delta) < 0) this._infeasibleRows.push(marker);
+			this._dualOptimize();
+			return;
+		}
+		let other = info.tag.other;
+		rowPair = rows.find(other);
+		if (rowPair !== void 0) {
+			if (rowPair.second.add(delta) < 0) this._infeasibleRows.push(other);
+			this._dualOptimize();
+			return;
+		}
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let rowPair = rows.itemAt(i);
+			let row = rowPair.second;
+			let coeff = row.coefficientFor(marker);
+			if (coeff !== 0 && row.add(delta * coeff) < 0 && rowPair.first.type() !== SymbolType.External) this._infeasibleRows.push(rowPair.first);
+		}
+		this._dualOptimize();
+	}
+	/**
+	* Update the values of the variables.
+	*/
+	updateVariables() {
+		let vars = this._varMap;
+		let rows = this._rowMap;
+		for (let i = 0, n = vars.size(); i < n; ++i) {
+			let pair = vars.itemAt(i);
+			let rowPair = rows.find(pair.second);
+			if (rowPair !== void 0) pair.first.setValue(rowPair.second.constant());
+			else pair.first.setValue(0);
+		}
+	}
+	/**
+	* Get the symbol for the given variable.
+	*
+	* If a symbol does not exist for the variable, one will be created.
+	* @private
+	*/
+	_getVarSymbol(variable) {
+		let factory = () => this._makeSymbol(SymbolType.External);
+		return this._varMap.setDefault(variable, factory).second;
+	}
+	/**
+	* Create a new Row object for the given constraint.
+	*
+	* The terms in the constraint will be converted to cells in the row.
+	* Any term in the constraint with a coefficient of zero is ignored.
+	* This method uses the `_getVarSymbol` method to get the symbol for
+	* the variables added to the row. If the symbol for a given cell
+	* variable is basic, the cell variable will be substituted with the
+	* basic row.
+	*
+	* The necessary slack and error variables will be added to the row.
+	* If the constant for the row is negative, the sign for the row
+	* will be inverted so the constant becomes positive.
+	*
+	* Returns the created Row and the tag for tracking the constraint.
+	* @private
+	*/
+	_createRow(constraint) {
+		let expr = constraint.expression();
+		let row = new Row(expr.constant());
+		let terms = expr.terms();
+		for (let i = 0, n = terms.size(); i < n; ++i) {
+			let termPair = terms.itemAt(i);
+			if (!nearZero(termPair.second)) {
+				let symbol = this._getVarSymbol(termPair.first);
+				let basicPair = this._rowMap.find(symbol);
+				if (basicPair !== void 0) row.insertRow(basicPair.second, termPair.second);
+				else row.insertSymbol(symbol, termPair.second);
+			}
+		}
+		let objective = this._objective;
+		let strength = constraint.strength();
+		let tag = {
+			marker: INVALID_SYMBOL,
+			other: INVALID_SYMBOL
+		};
+		switch (constraint.op()) {
+			case Operator.Le:
+			case Operator.Ge: {
+				let coeff = constraint.op() === Operator.Le ? 1 : -1;
+				let slack = this._makeSymbol(SymbolType.Slack);
+				tag.marker = slack;
+				row.insertSymbol(slack, coeff);
+				if (strength < Strength.required) {
+					let error = this._makeSymbol(SymbolType.Error);
+					tag.other = error;
+					row.insertSymbol(error, -coeff);
+					objective.insertSymbol(error, strength);
+				}
+				break;
+			}
+			case Operator.Eq:
+				if (strength < Strength.required) {
+					let errplus = this._makeSymbol(SymbolType.Error);
+					let errminus = this._makeSymbol(SymbolType.Error);
+					tag.marker = errplus;
+					tag.other = errminus;
+					row.insertSymbol(errplus, -1);
+					row.insertSymbol(errminus, 1);
+					objective.insertSymbol(errplus, strength);
+					objective.insertSymbol(errminus, strength);
+				} else {
+					let dummy = this._makeSymbol(SymbolType.Dummy);
+					tag.marker = dummy;
+					row.insertSymbol(dummy);
+				}
+				break;
+		}
+		if (row.constant() < 0) row.reverseSign();
+		return {
+			row,
+			tag
+		};
+	}
+	/**
+	* Choose the subject for solving for the row.
+	*
+	* This method will choose the best subject for using as the solve
+	* target for the row. An invalid symbol will be returned if there
+	* is no valid target.
+	*
+	* The symbols are chosen according to the following precedence:
+	*
+	* 1) The first symbol representing an external variable.
+	* 2) A negative slack or error tag variable.
+	*
+	* If a subject cannot be found, an invalid symbol will be returned.
+	*
+	* @private
+	*/
+	_chooseSubject(row, tag) {
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			if (pair.first.type() === SymbolType.External) return pair.first;
+		}
+		let type = tag.marker.type();
+		if (type === SymbolType.Slack || type === SymbolType.Error) {
+			if (row.coefficientFor(tag.marker) < 0) return tag.marker;
+		}
+		type = tag.other.type();
+		if (type === SymbolType.Slack || type === SymbolType.Error) {
+			if (row.coefficientFor(tag.other) < 0) return tag.other;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Add the row to the tableau using an artificial variable.
+	*
+	* This will return false if the constraint cannot be satisfied.
+	*
+	* @private
+	*/
+	_addWithArtificialVariable(row) {
+		let art = this._makeSymbol(SymbolType.Slack);
+		this._rowMap.insert(art, row.copy());
+		this._artificial = row.copy();
+		this._optimize(this._artificial);
+		let success = nearZero(this._artificial.constant());
+		this._artificial = null;
+		let pair = this._rowMap.erase(art);
+		if (pair !== void 0) {
+			let basicRow = pair.second;
+			if (basicRow.isConstant()) return success;
+			let entering = this._anyPivotableSymbol(basicRow);
+			if (entering.type() === SymbolType.Invalid) return false;
+			basicRow.solveForEx(art, entering);
+			this._substitute(entering, basicRow);
+			this._rowMap.insert(entering, basicRow);
+		}
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) rows.itemAt(i).second.removeSymbol(art);
+		this._objective.removeSymbol(art);
+		return success;
+	}
+	/**
+	* Substitute the parametric symbol with the given row.
+	*
+	* This method will substitute all instances of the parametric symbol
+	* in the tableau and the objective function with the given row.
+	*
+	* @private
+	*/
+	_substitute(symbol, row) {
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			pair.second.substitute(symbol, row);
+			if (pair.second.constant() < 0 && pair.first.type() !== SymbolType.External) this._infeasibleRows.push(pair.first);
+		}
+		this._objective.substitute(symbol, row);
+		if (this._artificial) this._artificial.substitute(symbol, row);
+	}
+	/**
+	* Optimize the system for the given objective function.
+	*
+	* This method performs iterations of Phase 2 of the simplex method
+	* until the objective function reaches a minimum.
+	*
+	* @private
+	*/
+	_optimize(objective) {
+		let iterations = 0;
+		while (iterations < this.maxIterations) {
+			let entering = this._getEnteringSymbol(objective);
+			if (entering.type() === SymbolType.Invalid) return;
+			let leaving = this._getLeavingSymbol(entering);
+			if (leaving.type() === SymbolType.Invalid) throw new Error("the objective is unbounded");
+			let row = this._rowMap.erase(leaving).second;
+			row.solveForEx(leaving, entering);
+			this._substitute(entering, row);
+			this._rowMap.insert(entering, row);
+			iterations++;
+		}
+		throw new Error("solver iterations exceeded");
+	}
+	/**
+	* Optimize the system using the dual of the simplex method.
+	*
+	* The current state of the system should be such that the objective
+	* function is optimal, but not feasible. This method will perform
+	* an iteration of the dual simplex method to make the solution both
+	* optimal and feasible.
+	*
+	* @private
+	*/
+	_dualOptimize() {
+		let rows = this._rowMap;
+		let infeasible = this._infeasibleRows;
+		while (infeasible.length !== 0) {
+			let leaving = infeasible.pop();
+			let pair = rows.find(leaving);
+			if (pair !== void 0 && pair.second.constant() < 0) {
+				let entering = this._getDualEnteringSymbol(pair.second);
+				if (entering.type() === SymbolType.Invalid) throw new Error("dual optimize failed");
+				let row = pair.second;
+				rows.erase(leaving);
+				row.solveForEx(leaving, entering);
+				this._substitute(entering, row);
+				rows.insert(entering, row);
+			}
+		}
+	}
+	/**
+	* Compute the entering variable for a pivot operation.
+	*
+	* This method will return first symbol in the objective function which
+	* is non-dummy and has a coefficient less than zero. If no symbol meets
+	* the criteria, it means the objective function is at a minimum, and an
+	* invalid symbol is returned.
+	*
+	* @private
+	*/
+	_getEnteringSymbol(objective) {
+		let cells = objective.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let symbol = pair.first;
+			if (pair.second < 0 && symbol.type() !== SymbolType.Dummy) return symbol;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Compute the entering symbol for the dual optimize operation.
+	*
+	* This method will return the symbol in the row which has a positive
+	* coefficient and yields the minimum ratio for its respective symbol
+	* in the objective function. The provided row *must* be infeasible.
+	* If no symbol is found which meats the criteria, an invalid symbol
+	* is returned.
+	*
+	* @private
+	*/
+	_getDualEnteringSymbol(row) {
+		let ratio = Number.MAX_VALUE;
+		let entering = INVALID_SYMBOL;
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let symbol = pair.first;
+			let c = pair.second;
+			if (c > 0 && symbol.type() !== SymbolType.Dummy) {
+				let r = this._objective.coefficientFor(symbol) / c;
+				if (r < ratio) {
+					ratio = r;
+					entering = symbol;
+				}
+			}
+		}
+		return entering;
+	}
+	/**
+	* Compute the symbol for pivot exit row.
+	*
+	* This method will return the symbol for the exit row in the row
+	* map. If no appropriate exit symbol is found, an invalid symbol
+	* will be returned. This indicates that the objective function is
+	* unbounded.
+	*
+	* @private
+	*/
+	_getLeavingSymbol(entering) {
+		let ratio = Number.MAX_VALUE;
+		let found = INVALID_SYMBOL;
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			let symbol = pair.first;
+			if (symbol.type() !== SymbolType.External) {
+				let row = pair.second;
+				let temp = row.coefficientFor(entering);
+				if (temp < 0) {
+					let temp_ratio = -row.constant() / temp;
+					if (temp_ratio < ratio) {
+						ratio = temp_ratio;
+						found = symbol;
+					}
+				}
+			}
+		}
+		return found;
+	}
+	/**
+	* Compute the leaving symbol for a marker variable.
+	*
+	* This method will return a symbol corresponding to a basic row
+	* which holds the given marker variable. The row will be chosen
+	* according to the following precedence:
+	*
+	* 1) The row with a restricted basic varible and a negative coefficient
+	*    for the marker with the smallest ratio of -constant / coefficient.
+	*
+	* 2) The row with a restricted basic variable and the smallest ratio
+	*    of constant / coefficient.
+	*
+	* 3) The last unrestricted row which contains the marker.
+	*
+	* If the marker does not exist in any row, an invalid symbol will be
+	* returned. This indicates an internal solver error since the marker
+	* *should* exist somewhere in the tableau.
+	*
+	* @private
+	*/
+	_getMarkerLeavingSymbol(marker) {
+		let dmax = Number.MAX_VALUE;
+		let r1 = dmax;
+		let r2 = dmax;
+		let invalid = INVALID_SYMBOL;
+		let first = invalid;
+		let second = invalid;
+		let third = invalid;
+		let rows = this._rowMap;
+		for (let i = 0, n = rows.size(); i < n; ++i) {
+			let pair = rows.itemAt(i);
+			let row = pair.second;
+			let c = row.coefficientFor(marker);
+			if (c === 0) continue;
+			let symbol = pair.first;
+			if (symbol.type() === SymbolType.External) third = symbol;
+			else if (c < 0) {
+				let r = -row.constant() / c;
+				if (r < r1) {
+					r1 = r;
+					first = symbol;
+				}
+			} else {
+				let r = row.constant() / c;
+				if (r < r2) {
+					r2 = r;
+					second = symbol;
+				}
+			}
+		}
+		if (first !== invalid) return first;
+		if (second !== invalid) return second;
+		return third;
+	}
+	/**
+	* Remove the effects of a constraint on the objective function.
+	*
+	* @private
+	*/
+	_removeConstraintEffects(cn, tag) {
+		if (tag.marker.type() === SymbolType.Error) this._removeMarkerEffects(tag.marker, cn.strength());
+		if (tag.other.type() === SymbolType.Error) this._removeMarkerEffects(tag.other, cn.strength());
+	}
+	/**
+	* Remove the effects of an error marker on the objective function.
+	*
+	* @private
+	*/
+	_removeMarkerEffects(marker, strength) {
+		let pair = this._rowMap.find(marker);
+		if (pair !== void 0) this._objective.insertRow(pair.second, -strength);
+		else this._objective.insertSymbol(marker, -strength);
+	}
+	/**
+	* Get the first Slack or Error symbol in the row.
+	*
+	* If no such symbol is present, an invalid symbol will be returned.
+	*
+	* @private
+	*/
+	_anyPivotableSymbol(row) {
+		let cells = row.cells();
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			let type = pair.first.type();
+			if (type === SymbolType.Slack || type === SymbolType.Error) return pair.first;
+		}
+		return INVALID_SYMBOL;
+	}
+	/**
+	* Returns a new Symbol of the given type.
+	*
+	* @private
+	*/
+	_makeSymbol(type) {
+		return new Symbol(type, this._idTick++);
+	}
+	_cnMap = createCnMap();
+	_rowMap = createRowMap();
+	_varMap = createVarMap();
+	_editMap = createEditMap();
+	_infeasibleRows = [];
+	_objective = new Row();
+	_artificial = null;
+	_idTick = 0;
+};
+/**
+* Test whether a value is approximately zero.
+* @private
+*/
+function nearZero(value) {
+	let eps = 1e-8;
+	return value < 0 ? -value < eps : value < eps;
+}
+/**
+* An internal function for creating a constraint map.
+* @private
+*/
+function createCnMap() {
+	return createMap();
+}
+/**
+* An internal function for creating a row map.
+* @private
+*/
+function createRowMap() {
+	return createMap();
+}
+/**
+* An internal function for creating a variable map.
+* @private
+*/
+function createVarMap() {
+	return createMap();
+}
+/**
+* An internal function for creating an edit map.
+* @private
+*/
+function createEditMap() {
+	return createMap();
+}
+/**
+* An enum defining the available symbol types.
+* @private
+*/
+var SymbolType;
+(function(SymbolType) {
+	SymbolType[SymbolType["Invalid"] = 0] = "Invalid";
+	SymbolType[SymbolType["External"] = 1] = "External";
+	SymbolType[SymbolType["Slack"] = 2] = "Slack";
+	SymbolType[SymbolType["Error"] = 3] = "Error";
+	SymbolType[SymbolType["Dummy"] = 4] = "Dummy";
+})(SymbolType || (SymbolType = {}));
+/**
+* An internal class representing a symbol in the solver.
+* @private
+*/
+var Symbol = class {
+	/**
+	* Construct a new Symbol
+	*
+	* @param [type] The type of the symbol.
+	* @param [id] The unique id number of the symbol.
+	*/
+	constructor(type, id) {
+		this._id = id;
+		this._type = type;
+	}
+	/**
+	* Returns the unique id number of the symbol.
+	*/
+	id() {
+		return this._id;
+	}
+	/**
+	* Returns the type of the symbol.
+	*/
+	type() {
+		return this._type;
+	}
+	_id;
+	_type;
+};
+/**
+* A static invalid symbol
+* @private
+*/
+let INVALID_SYMBOL = new Symbol(SymbolType.Invalid, -1);
+/**
+* An internal row class used by the solver.
+* @private
+*/
+var Row = class Row {
+	/**
+	* Construct a new Row.
+	*/
+	constructor(constant = 0) {
+		this._constant = constant;
+	}
+	/**
+	* Returns the mapping of symbols to coefficients.
+	*/
+	cells() {
+		return this._cellMap;
+	}
+	/**
+	* Returns the constant for the row.
+	*/
+	constant() {
+		return this._constant;
+	}
+	/**
+	* Returns true if the row is a constant value.
+	*/
+	isConstant() {
+		return this._cellMap.empty();
+	}
+	/**
+	* Returns true if the Row has all dummy symbols.
+	*/
+	allDummies() {
+		let cells = this._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) if (cells.itemAt(i).first.type() !== SymbolType.Dummy) return false;
+		return true;
+	}
+	/**
+	* Create a copy of the row.
+	*/
+	copy() {
+		let theCopy = new Row(this._constant);
+		theCopy._cellMap = this._cellMap.copy();
+		return theCopy;
+	}
+	/**
+	* Add a constant value to the row constant.
+	*
+	* Returns the new value of the constant.
+	*/
+	add(value) {
+		return this._constant += value;
+	}
+	/**
+	* Insert the symbol into the row with the given coefficient.
+	*
+	* If the symbol already exists in the row, the coefficient
+	* will be added to the existing coefficient. If the resulting
+	* coefficient is zero, the symbol will be removed from the row.
+	*/
+	insertSymbol(symbol, coefficient = 1) {
+		let pair = this._cellMap.setDefault(symbol, () => 0);
+		if (nearZero(pair.second += coefficient)) this._cellMap.erase(symbol);
+	}
+	/**
+	* Insert a row into this row with a given coefficient.
+	*
+	* The constant and the cells of the other row will be
+	* multiplied by the coefficient and added to this row. Any
+	* cell with a resulting coefficient of zero will be removed
+	* from the row.
+	*/
+	insertRow(other, coefficient = 1) {
+		this._constant += other._constant * coefficient;
+		let cells = other._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			this.insertSymbol(pair.first, pair.second * coefficient);
+		}
+	}
+	/**
+	* Remove a symbol from the row.
+	*/
+	removeSymbol(symbol) {
+		this._cellMap.erase(symbol);
+	}
+	/**
+	* Reverse the sign of the constant and cells in the row.
+	*/
+	reverseSign() {
+		this._constant = -this._constant;
+		let cells = this._cellMap;
+		for (let i = 0, n = cells.size(); i < n; ++i) {
+			let pair = cells.itemAt(i);
+			pair.second = -pair.second;
+		}
+	}
+	/**
+	* Solve the row for the given symbol.
+	*
+	* This method assumes the row is of the form
+	* a * x + b * y + c = 0 and (assuming solve for x) will modify
+	* the row to represent the right hand side of
+	* x = -b/a * y - c / a. The target symbol will be removed from
+	* the row, and the constant and other cells will be multiplied
+	* by the negative inverse of the target coefficient.
+	*
+	* The given symbol *must* exist in the row.
+	*/
+	solveFor(symbol) {
+		let cells = this._cellMap;
+		let coeff = -1 / cells.erase(symbol).second;
+		this._constant *= coeff;
+		for (let i = 0, n = cells.size(); i < n; ++i) cells.itemAt(i).second *= coeff;
+	}
+	/**
+	* Solve the row for the given symbols.
+	*
+	* This method assumes the row is of the form
+	* x = b * y + c and will solve the row such that
+	* y = x / b - c / b. The rhs symbol will be removed from the
+	* row, the lhs added, and the result divided by the negative
+	* inverse of the rhs coefficient.
+	*
+	* The lhs symbol *must not* exist in the row, and the rhs
+	* symbol must* exist in the row.
+	*/
+	solveForEx(lhs, rhs) {
+		this.insertSymbol(lhs, -1);
+		this.solveFor(rhs);
+	}
+	/**
+	* Returns the coefficient for the given symbol.
+	*/
+	coefficientFor(symbol) {
+		let pair = this._cellMap.find(symbol);
+		return pair !== void 0 ? pair.second : 0;
+	}
+	/**
+	* Substitute a symbol with the data from another row.
+	*
+	* Given a row of the form a * x + b and a substitution of the
+	* form x = 3 * y + c the row will be updated to reflect the
+	* expression 3 * a * y + a * c + b.
+	*
+	* If the symbol does not exist in the row, this is a no-op.
+	*/
+	substitute(symbol, row) {
+		let pair = this._cellMap.erase(symbol);
+		if (pair !== void 0) this.insertRow(row, pair.second);
+	}
+	_cellMap = createMap();
+	_constant;
+};
+
+//#endregion
+export { Variable as a, Strength as i, Constraint as n, Operator as r, Solver as t };