@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/aproba@2.1.0/node_modules/aproba/index.js

@@ -0,0 +1,119 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/aproba@2.1.0/node_modules/aproba/index.js
+var require_aproba = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = validate;
+	function isArguments(thingy) {
+		return thingy != null && typeof thingy === "object" && thingy.hasOwnProperty("callee");
+	}
+	const types = {
+		"*": {
+			label: "any",
+			check: () => true
+		},
+		A: {
+			label: "array",
+			check: (_) => Array.isArray(_) || isArguments(_)
+		},
+		S: {
+			label: "string",
+			check: (_) => typeof _ === "string"
+		},
+		N: {
+			label: "number",
+			check: (_) => typeof _ === "number"
+		},
+		F: {
+			label: "function",
+			check: (_) => typeof _ === "function"
+		},
+		O: {
+			label: "object",
+			check: (_) => typeof _ === "object" && _ != null && !types.A.check(_) && !types.E.check(_)
+		},
+		B: {
+			label: "boolean",
+			check: (_) => typeof _ === "boolean"
+		},
+		E: {
+			label: "error",
+			check: (_) => _ instanceof Error
+		},
+		Z: {
+			label: "null",
+			check: (_) => _ == null
+		}
+	};
+	function addSchema(schema, arity) {
+		const group = arity[schema.length] = arity[schema.length] || [];
+		if (group.indexOf(schema) === -1) group.push(schema);
+	}
+	function validate(rawSchemas, args) {
+		if (arguments.length !== 2) throw wrongNumberOfArgs(["SA"], arguments.length);
+		if (!rawSchemas) throw missingRequiredArg(0, "rawSchemas");
+		if (!args) throw missingRequiredArg(1, "args");
+		if (!types.S.check(rawSchemas)) throw invalidType(0, ["string"], rawSchemas);
+		if (!types.A.check(args)) throw invalidType(1, ["array"], args);
+		const schemas = rawSchemas.split("|");
+		const arity = {};
+		schemas.forEach((schema) => {
+			for (let ii = 0; ii < schema.length; ++ii) {
+				const type = schema[ii];
+				if (!types[type]) throw unknownType(ii, type);
+			}
+			if (/E.*E/.test(schema)) throw moreThanOneError(schema);
+			addSchema(schema, arity);
+			if (/E/.test(schema)) {
+				addSchema(schema.replace(/E.*$/, "E"), arity);
+				addSchema(schema.replace(/E/, "Z"), arity);
+				if (schema.length === 1) addSchema("", arity);
+			}
+		});
+		let matching = arity[args.length];
+		if (!matching) throw wrongNumberOfArgs(Object.keys(arity), args.length);
+		for (let ii = 0; ii < args.length; ++ii) {
+			let newMatching = matching.filter((schema) => {
+				const typeCheck = types[schema[ii]].check;
+				return typeCheck(args[ii]);
+			});
+			if (!newMatching.length) {
+				const labels = matching.map((_) => types[_[ii]].label).filter((_) => _ != null);
+				throw invalidType(ii, labels, args[ii]);
+			}
+			matching = newMatching;
+		}
+	}
+	function missingRequiredArg(num) {
+		return newException("EMISSINGARG", "Missing required argument #" + (num + 1));
+	}
+	function unknownType(num, type) {
+		return newException("EUNKNOWNTYPE", "Unknown type " + type + " in argument #" + (num + 1));
+	}
+	function invalidType(num, expectedTypes, value) {
+		let valueType;
+		Object.keys(types).forEach((typeCode) => {
+			if (types[typeCode].check(value)) valueType = types[typeCode].label;
+		});
+		return newException("EINVALIDTYPE", "Argument #" + (num + 1) + ": Expected " + englishList(expectedTypes) + " but got " + valueType);
+	}
+	function englishList(list) {
+		return list.join(", ").replace(/, ([^,]+)$/, " or $1");
+	}
+	function wrongNumberOfArgs(expected, got) {
+		const english = englishList(expected);
+		const args = expected.every((ex) => ex.length === 1) ? "argument" : "arguments";
+		return newException("EWRONGARGCOUNT", "Expected " + english + " " + args + " but got " + got);
+	}
+	function moreThanOneError(schema) {
+		return newException("ETOOMANYERRORTYPES", "Only one error type per argument signature is allowed, more than one found in \"" + schema + "\"");
+	}
+	function newException(code, msg) {
+		const err = new TypeError(msg);
+		err.code = code;
+		/* istanbul ignore else */
+		if (Error.captureStackTrace) Error.captureStackTrace(err, validate);
+		return err;
+	}
+}));
+//#endregion
+export default require_aproba();
+export { require_aproba };

package/dist/node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/index.js

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_tracker } from "./tracker.js";
+import { require_tracker_stream } from "./tracker-stream.js";
+import { require_tracker_group } from "./tracker-group.js";
+//#region node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.TrackerGroup = require_tracker_group();
+	exports.Tracker = require_tracker();
+	exports.TrackerStream = require_tracker_stream();
+}));
+//#endregion
+export default require_lib();
+export { require_lib };

package/dist/node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-base.js

@@ -0,0 +1,16 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-base.js
+var require_tracker_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var EventEmitter = __require("events").EventEmitter;
+	var util = __require("util");
+	var trackerId = 0;
+	var TrackerBase = module.exports = function(name) {
+		EventEmitter.call(this);
+		this.id = ++trackerId;
+		this.name = name;
+	};
+	util.inherits(TrackerBase, EventEmitter);
+}));
+//#endregion
+export default require_tracker_base();
+export { require_tracker_base };

package/dist/node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-group.js

@@ -0,0 +1,98 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_tracker_base } from "./tracker-base.js";
+import { require_tracker } from "./tracker.js";
+import { require_tracker_stream } from "./tracker-stream.js";
+//#region node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-group.js
+var require_tracker_group = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util = __require("util");
+	var TrackerBase = require_tracker_base();
+	var Tracker = require_tracker();
+	var TrackerStream = require_tracker_stream();
+	var TrackerGroup = module.exports = function(name) {
+		TrackerBase.call(this, name);
+		this.parentGroup = null;
+		this.trackers = [];
+		this.completion = {};
+		this.weight = {};
+		this.totalWeight = 0;
+		this.finished = false;
+		this.bubbleChange = bubbleChange(this);
+	};
+	util.inherits(TrackerGroup, TrackerBase);
+	function bubbleChange(trackerGroup) {
+		return function(name, completed, tracker) {
+			trackerGroup.completion[tracker.id] = completed;
+			if (trackerGroup.finished) return;
+			trackerGroup.emit("change", name || trackerGroup.name, trackerGroup.completed(), trackerGroup);
+		};
+	}
+	TrackerGroup.prototype.nameInTree = function() {
+		var names = [];
+		var from = this;
+		while (from) {
+			names.unshift(from.name);
+			from = from.parentGroup;
+		}
+		return names.join("/");
+	};
+	TrackerGroup.prototype.addUnit = function(unit, weight) {
+		if (unit.addUnit) {
+			var toTest = this;
+			while (toTest) {
+				if (unit === toTest) throw new Error("Attempted to add tracker group " + unit.name + " to tree that already includes it " + this.nameInTree(this));
+				toTest = toTest.parentGroup;
+			}
+			unit.parentGroup = this;
+		}
+		this.weight[unit.id] = weight || 1;
+		this.totalWeight += this.weight[unit.id];
+		this.trackers.push(unit);
+		this.completion[unit.id] = unit.completed();
+		unit.on("change", this.bubbleChange);
+		if (!this.finished) this.emit("change", unit.name, this.completion[unit.id], unit);
+		return unit;
+	};
+	TrackerGroup.prototype.completed = function() {
+		if (this.trackers.length === 0) return 0;
+		var valPerWeight = 1 / this.totalWeight;
+		var completed = 0;
+		for (var ii = 0; ii < this.trackers.length; ii++) {
+			var trackerId = this.trackers[ii].id;
+			completed += valPerWeight * this.weight[trackerId] * this.completion[trackerId];
+		}
+		return completed;
+	};
+	TrackerGroup.prototype.newGroup = function(name, weight) {
+		return this.addUnit(new TrackerGroup(name), weight);
+	};
+	TrackerGroup.prototype.newItem = function(name, todo, weight) {
+		return this.addUnit(new Tracker(name, todo), weight);
+	};
+	TrackerGroup.prototype.newStream = function(name, todo, weight) {
+		return this.addUnit(new TrackerStream(name, todo), weight);
+	};
+	TrackerGroup.prototype.finish = function() {
+		this.finished = true;
+		if (!this.trackers.length) this.addUnit(new Tracker(), 1, true);
+		for (var ii = 0; ii < this.trackers.length; ii++) {
+			var tracker = this.trackers[ii];
+			tracker.finish();
+			tracker.removeListener("change", this.bubbleChange);
+		}
+		this.emit("change", this.name, 1, this);
+	};
+	var buffer = "                                  ";
+	TrackerGroup.prototype.debug = function(depth) {
+		depth = depth || 0;
+		var indent = depth ? buffer.substr(0, depth) : "";
+		var output = indent + (this.name || "top") + ": " + this.completed() + "\n";
+		this.trackers.forEach(function(tracker) {
+			if (tracker instanceof TrackerGroup) output += tracker.debug(depth + 1);
+			else output += indent + " " + tracker.name + ": " + tracker.completed() + "\n";
+		});
+		return output;
+	};
+}));
+//#endregion
+export default require_tracker_group();
+export { require_tracker_group };

package/dist/node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-stream.js

@@ -0,0 +1,37 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_tracker } from "./tracker.js";
+import { require_readable_browser } from "../../../../readable-stream@3.6.2/node_modules/readable-stream/readable-browser.js";
+import { require_delegates } from "../../../../delegates@1.0.0/node_modules/delegates/index.js";
+//#region node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker-stream.js
+var require_tracker_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util = __require("util");
+	var stream = require_readable_browser();
+	var delegate = require_delegates();
+	var Tracker = require_tracker();
+	var TrackerStream = module.exports = function(name, size, options) {
+		stream.Transform.call(this, options);
+		this.tracker = new Tracker(name, size);
+		this.name = name;
+		this.id = this.tracker.id;
+		this.tracker.on("change", delegateChange(this));
+	};
+	util.inherits(TrackerStream, stream.Transform);
+	function delegateChange(trackerStream) {
+		return function(name, completion, tracker) {
+			trackerStream.emit("change", name, completion, trackerStream);
+		};
+	}
+	TrackerStream.prototype._transform = function(data, encoding, cb) {
+		this.tracker.completeWork(data.length ? data.length : 1);
+		this.push(data);
+		cb();
+	};
+	TrackerStream.prototype._flush = function(cb) {
+		this.tracker.finish();
+		cb();
+	};
+	delegate(TrackerStream.prototype, "tracker").method("completed").method("addWork").method("finish");
+}));
+//#endregion
+export default require_tracker_stream();
+export { require_tracker_stream };

package/dist/node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker.js

@@ -0,0 +1,32 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_tracker_base } from "./tracker-base.js";
+//#region node_modules/.pnpm/are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/tracker.js
+var require_tracker = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var util = __require("util");
+	var TrackerBase = require_tracker_base();
+	var Tracker = module.exports = function(name, todo) {
+		TrackerBase.call(this, name);
+		this.workDone = 0;
+		this.workTodo = todo || 0;
+	};
+	util.inherits(Tracker, TrackerBase);
+	Tracker.prototype.completed = function() {
+		return this.workTodo === 0 ? 0 : this.workDone / this.workTodo;
+	};
+	Tracker.prototype.addWork = function(work) {
+		this.workTodo += work;
+		this.emit("change", this.name, this.completed(), this);
+	};
+	Tracker.prototype.completeWork = function(work) {
+		this.workDone += work;
+		if (this.workDone > this.workTodo) this.workDone = this.workTodo;
+		this.emit("change", this.name, this.completed(), this);
+	};
+	Tracker.prototype.finish = function() {
+		this.workTodo = this.workDone = 1;
+		this.emit("change", this.name, 1, this);
+	};
+}));
+//#endregion
+export default require_tracker();
+export { require_tracker };

package/dist/node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js

@@ -0,0 +1,53 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = balanced;
+	function balanced(a, b, str) {
+		if (a instanceof RegExp) a = maybeMatch(a, str);
+		if (b instanceof RegExp) b = maybeMatch(b, str);
+		var r = range(a, b, str);
+		return r && {
+			start: r[0],
+			end: r[1],
+			pre: str.slice(0, r[0]),
+			body: str.slice(r[0] + a.length, r[1]),
+			post: str.slice(r[1] + b.length)
+		};
+	}
+	function maybeMatch(reg, str) {
+		var m = str.match(reg);
+		return m ? m[0] : null;
+	}
+	balanced.range = range;
+	function range(a, b, str) {
+		var begs, beg, left, right, result;
+		var ai = str.indexOf(a);
+		var bi = str.indexOf(b, ai + 1);
+		var i = ai;
+		if (ai >= 0 && bi > 0) {
+			if (a === b) return [ai, bi];
+			begs = [];
+			left = str.length;
+			while (i >= 0 && !result) {
+				if (i == ai) {
+					begs.push(i);
+					ai = str.indexOf(a, i + 1);
+				} else if (begs.length == 1) result = [begs.pop(), bi];
+				else {
+					beg = begs.pop();
+					if (beg < left) {
+						left = beg;
+						right = bi;
+					}
+					bi = str.indexOf(b, i + 1);
+				}
+				i = ai < bi && ai >= 0 ? ai : bi;
+			}
+			if (begs.length) result = [left, right];
+		}
+		return result;
+	}
+}));
+//#endregion
+export default require_balanced_match();
+export { require_balanced_match };

package/dist/node_modules/.pnpm/brace-expansion@1.1.12/node_modules/brace-expansion/index.js

@@ -0,0 +1,132 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_concat_map } from "../../../concat-map@0.0.1/node_modules/concat-map/index.js";
+import { require_balanced_match } from "../../../balanced-match@1.0.2/node_modules/balanced-match/index.js";
+//#region node_modules/.pnpm/brace-expansion@1.1.12/node_modules/brace-expansion/index.js
+var require_brace_expansion = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var concatMap = require_concat_map();
+	var balanced = require_balanced_match();
+	module.exports = expandTop;
+	var escSlash = "\0SLASH" + Math.random() + "\0";
+	var escOpen = "\0OPEN" + Math.random() + "\0";
+	var escClose = "\0CLOSE" + Math.random() + "\0";
+	var escComma = "\0COMMA" + Math.random() + "\0";
+	var escPeriod = "\0PERIOD" + Math.random() + "\0";
+	function numeric(str) {
+		return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+	}
+	function escapeBraces(str) {
+		return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+	}
+	function unescapeBraces(str) {
+		return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+	}
+	function parseCommaParts(str) {
+		if (!str) return [""];
+		var parts = [];
+		var m = balanced("{", "}", str);
+		if (!m) return str.split(",");
+		var pre = m.pre;
+		var body = m.body;
+		var post = m.post;
+		var p = pre.split(",");
+		p[p.length - 1] += "{" + body + "}";
+		var postParts = parseCommaParts(post);
+		if (post.length) {
+			p[p.length - 1] += postParts.shift();
+			p.push.apply(p, postParts);
+		}
+		parts.push.apply(parts, p);
+		return parts;
+	}
+	function expandTop(str) {
+		if (!str) return [];
+		if (str.substr(0, 2) === "{}") str = "\\{\\}" + str.substr(2);
+		return expand(escapeBraces(str), true).map(unescapeBraces);
+	}
+	function embrace(str) {
+		return "{" + str + "}";
+	}
+	function isPadded(el) {
+		return /^-?0\d/.test(el);
+	}
+	function lte(i, y) {
+		return i <= y;
+	}
+	function gte(i, y) {
+		return i >= y;
+	}
+	function expand(str, isTop) {
+		var expansions = [];
+		var m = balanced("{", "}", str);
+		if (!m || /\$$/.test(m.pre)) return [str];
+		var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+		var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+		var isSequence = isNumericSequence || isAlphaSequence;
+		var isOptions = m.body.indexOf(",") >= 0;
+		if (!isSequence && !isOptions) {
+			if (m.post.match(/,(?!,).*\}/)) {
+				str = m.pre + "{" + m.body + escClose + m.post;
+				return expand(str);
+			}
+			return [str];
+		}
+		var n;
+		if (isSequence) n = m.body.split(/\.\./);
+		else {
+			n = parseCommaParts(m.body);
+			if (n.length === 1) {
+				n = expand(n[0], false).map(embrace);
+				if (n.length === 1) {
+					var post = m.post.length ? expand(m.post, false) : [""];
+					return post.map(function(p) {
+						return m.pre + n[0] + p;
+					});
+				}
+			}
+		}
+		var pre = m.pre;
+		var post = m.post.length ? expand(m.post, false) : [""];
+		var N;
+		if (isSequence) {
+			var x = numeric(n[0]);
+			var y = numeric(n[1]);
+			var width = Math.max(n[0].length, n[1].length);
+			var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+			var test = lte;
+			if (y < x) {
+				incr *= -1;
+				test = gte;
+			}
+			var pad = n.some(isPadded);
+			N = [];
+			for (var i = x; test(i, y); i += incr) {
+				var c;
+				if (isAlphaSequence) {
+					c = String.fromCharCode(i);
+					if (c === "\\") c = "";
+				} else {
+					c = String(i);
+					if (pad) {
+						var need = width - c.length;
+						if (need > 0) {
+							var z = new Array(need + 1).join("0");
+							if (i < 0) c = "-" + z + c.slice(1);
+							else c = z + c;
+						}
+					}
+				}
+				N.push(c);
+			}
+		} else N = concatMap(n, function(el) {
+			return expand(el, false);
+		});
+		for (var j = 0; j < N.length; j++) for (var k = 0; k < post.length; k++) {
+			var expansion = pre + N[j] + post[k];
+			if (!isTop || isSequence || expansion) expansions.push(expansion);
+		}
+		return expansions;
+	}
+}));
+//#endregion
+export default require_brace_expansion();
+export { require_brace_expansion };

package/dist/node_modules/.pnpm/color-support@1.1.3/node_modules/color-support/browser.js

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/color-support@1.1.3/node_modules/color-support/browser.js
+var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = colorSupport({ alwaysReturn: true }, colorSupport);
+	function colorSupport(options, obj) {
+		obj = obj || {};
+		options = options || {};
+		obj.level = 0;
+		obj.hasBasic = false;
+		obj.has256 = false;
+		obj.has16m = false;
+		if (!options.alwaysReturn) return false;
+		return obj;
+	}
+}));
+//#endregion
+export default require_browser();
+export { require_browser };

package/dist/node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
+var require_concat_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(xs, fn) {
+		var res = [];
+		for (var i = 0; i < xs.length; i++) {
+			var x = fn(xs[i], i);
+			if (isArray(x)) res.push.apply(res, x);
+			else res.push(x);
+		}
+		return res;
+	};
+	var isArray = Array.isArray || function(xs) {
+		return Object.prototype.toString.call(xs) === "[object Array]";
+	};
+}));
+//#endregion
+export default require_concat_map();
+export { require_concat_map };

package/dist/node_modules/.pnpm/console-control-strings@1.1.0/node_modules/console-control-strings/index.js

@@ -0,0 +1,104 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/console-control-strings@1.1.0/node_modules/console-control-strings/index.js
+var require_console_control_strings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var prefix = "\x1B[";
+	exports.up = function up(num) {
+		return prefix + (num || "") + "A";
+	};
+	exports.down = function down(num) {
+		return prefix + (num || "") + "B";
+	};
+	exports.forward = function forward(num) {
+		return prefix + (num || "") + "C";
+	};
+	exports.back = function back(num) {
+		return prefix + (num || "") + "D";
+	};
+	exports.nextLine = function nextLine(num) {
+		return prefix + (num || "") + "E";
+	};
+	exports.previousLine = function previousLine(num) {
+		return prefix + (num || "") + "F";
+	};
+	exports.horizontalAbsolute = function horizontalAbsolute(num) {
+		if (num == null) throw new Error("horizontalAboslute requires a column to position to");
+		return prefix + num + "G";
+	};
+	exports.eraseData = function eraseData() {
+		return prefix + "J";
+	};
+	exports.eraseLine = function eraseLine() {
+		return prefix + "K";
+	};
+	exports.goto = function(x, y) {
+		return prefix + y + ";" + x + "H";
+	};
+	exports.gotoSOL = function() {
+		return "\r";
+	};
+	exports.beep = function() {
+		return "\x07";
+	};
+	exports.hideCursor = function hideCursor() {
+		return prefix + "?25l";
+	};
+	exports.showCursor = function showCursor() {
+		return prefix + "?25h";
+	};
+	var colors = {
+		reset: 0,
+		bold: 1,
+		italic: 3,
+		underline: 4,
+		inverse: 7,
+		stopBold: 22,
+		stopItalic: 23,
+		stopUnderline: 24,
+		stopInverse: 27,
+		white: 37,
+		black: 30,
+		blue: 34,
+		cyan: 36,
+		green: 32,
+		magenta: 35,
+		red: 31,
+		yellow: 33,
+		bgWhite: 47,
+		bgBlack: 40,
+		bgBlue: 44,
+		bgCyan: 46,
+		bgGreen: 42,
+		bgMagenta: 45,
+		bgRed: 41,
+		bgYellow: 43,
+		grey: 90,
+		brightBlack: 90,
+		brightRed: 91,
+		brightGreen: 92,
+		brightYellow: 93,
+		brightBlue: 94,
+		brightMagenta: 95,
+		brightCyan: 96,
+		brightWhite: 97,
+		bgGrey: 100,
+		bgBrightBlack: 100,
+		bgBrightRed: 101,
+		bgBrightGreen: 102,
+		bgBrightYellow: 103,
+		bgBrightBlue: 104,
+		bgBrightMagenta: 105,
+		bgBrightCyan: 106,
+		bgBrightWhite: 107
+	};
+	exports.color = function color(colorWith) {
+		if (arguments.length !== 1 || !Array.isArray(colorWith)) colorWith = Array.prototype.slice.call(arguments);
+		return prefix + colorWith.map(colorNameToCode).join(";") + "m";
+	};
+	function colorNameToCode(color) {
+		if (colors[color] != null) return colors[color];
+		throw new Error("Unknown color or style name: " + color);
+	}
+}));
+//#endregion
+export default require_console_control_strings();
+export { require_console_control_strings };