@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/error.js

@@ -0,0 +1,27 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/error.js
+var require_error = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var util = __require("util");
+	var User = exports.User = function User(msg) {
+		var err = new Error(msg);
+		Error.captureStackTrace(err, User);
+		err.code = "EGAUGE";
+		return err;
+	};
+	exports.MissingTemplateValue = function MissingTemplateValue(item, values) {
+		var err = new User(util.format("Missing template value \"%s\"", item.type));
+		Error.captureStackTrace(err, MissingTemplateValue);
+		err.template = item;
+		err.values = values;
+		return err;
+	};
+	exports.Internal = function Internal(msg) {
+		var err = new Error(msg);
+		Error.captureStackTrace(err, Internal);
+		err.code = "EGAUGEINTERNAL";
+		return err;
+	};
+}));
+//#endregion
+export default require_error();
+export { require_error };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/has-color.js

@@ -0,0 +1,9 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_browser } from "../../../color-support@1.1.3/node_modules/color-support/browser.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/has-color.js
+var require_has_color = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_browser()().hasBasic;
+}));
+//#endregion
+export default require_has_color();
+export { require_has_color };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/index.js

@@ -0,0 +1,224 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_plumbing } from "./plumbing.js";
+import { require_has_unicode } from "../../../has-unicode@2.0.1/node_modules/has-unicode/index.js";
+import { require_has_color } from "./has-color.js";
+import { require_signal_exit } from "../../../signal-exit@3.0.7/node_modules/signal-exit/index.js";
+import { require_themes } from "./themes.js";
+import { require_set_interval } from "./set-interval.js";
+import { require_process } from "./process.js";
+import { require_set_immediate } from "./set-immediate.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/index.js
+var require_gauge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Plumbing = require_plumbing();
+	var hasUnicode = require_has_unicode();
+	var hasColor = require_has_color();
+	var onExit = require_signal_exit();
+	var defaultThemes = require_themes();
+	var setInterval = require_set_interval();
+	var process = require_process();
+	var setImmediate = require_set_immediate();
+	module.exports = Gauge;
+	function callWith(obj, method) {
+		return function() {
+			return method.call(obj);
+		};
+	}
+	function Gauge(arg1, arg2) {
+		var options, writeTo;
+		if (arg1 && arg1.write) {
+			writeTo = arg1;
+			options = arg2 || {};
+		} else if (arg2 && arg2.write) {
+			writeTo = arg2;
+			options = arg1 || {};
+		} else {
+			writeTo = process.stderr;
+			options = arg1 || arg2 || {};
+		}
+		this._status = {
+			spun: 0,
+			section: "",
+			subsection: ""
+		};
+		this._paused = false;
+		this._disabled = true;
+		this._showing = false;
+		this._onScreen = false;
+		this._needsRedraw = false;
+		this._hideCursor = options.hideCursor == null ? true : options.hideCursor;
+		this._fixedFramerate = options.fixedFramerate == null ? !/^v0\.8\./.test(process.version) : options.fixedFramerate;
+		this._lastUpdateAt = null;
+		this._updateInterval = options.updateInterval == null ? 50 : options.updateInterval;
+		this._themes = options.themes || defaultThemes;
+		this._theme = options.theme;
+		var theme = this._computeTheme(options.theme);
+		var template = options.template || [
+			{
+				type: "progressbar",
+				length: 20
+			},
+			{
+				type: "activityIndicator",
+				kerning: 1,
+				length: 1
+			},
+			{
+				type: "section",
+				kerning: 1,
+				default: ""
+			},
+			{
+				type: "subsection",
+				kerning: 1,
+				default: ""
+			}
+		];
+		this.setWriteTo(writeTo, options.tty);
+		this._gauge = new (options.Plumbing || Plumbing)(theme, template, this.getWidth());
+		this._$$doRedraw = callWith(this, this._doRedraw);
+		this._$$handleSizeChange = callWith(this, this._handleSizeChange);
+		this._cleanupOnExit = options.cleanupOnExit == null || options.cleanupOnExit;
+		this._removeOnExit = null;
+		if (options.enabled || options.enabled == null && this._tty && this._tty.isTTY) this.enable();
+		else this.disable();
+	}
+	Gauge.prototype = {};
+	Gauge.prototype.isEnabled = function() {
+		return !this._disabled;
+	};
+	Gauge.prototype.setTemplate = function(template) {
+		this._gauge.setTemplate(template);
+		if (this._showing) this._requestRedraw();
+	};
+	Gauge.prototype._computeTheme = function(theme) {
+		if (!theme) theme = {};
+		if (typeof theme === "string") theme = this._themes.getTheme(theme);
+		else if (theme && (Object.keys(theme).length === 0 || theme.hasUnicode != null || theme.hasColor != null)) {
+			var useUnicode = theme.hasUnicode == null ? hasUnicode() : theme.hasUnicode;
+			var useColor = theme.hasColor == null ? hasColor : theme.hasColor;
+			theme = this._themes.getDefault({
+				hasUnicode: useUnicode,
+				hasColor: useColor,
+				platform: theme.platform
+			});
+		}
+		return theme;
+	};
+	Gauge.prototype.setThemeset = function(themes) {
+		this._themes = themes;
+		this.setTheme(this._theme);
+	};
+	Gauge.prototype.setTheme = function(theme) {
+		this._gauge.setTheme(this._computeTheme(theme));
+		if (this._showing) this._requestRedraw();
+		this._theme = theme;
+	};
+	Gauge.prototype._requestRedraw = function() {
+		this._needsRedraw = true;
+		if (!this._fixedFramerate) this._doRedraw();
+	};
+	Gauge.prototype.getWidth = function() {
+		return (this._tty && this._tty.columns || 80) - 1;
+	};
+	Gauge.prototype.setWriteTo = function(writeTo, tty) {
+		var enabled = !this._disabled;
+		if (enabled) this.disable();
+		this._writeTo = writeTo;
+		this._tty = tty || writeTo === process.stderr && process.stdout.isTTY && process.stdout || writeTo.isTTY && writeTo || this._tty;
+		if (this._gauge) this._gauge.setWidth(this.getWidth());
+		if (enabled) this.enable();
+	};
+	Gauge.prototype.enable = function() {
+		if (!this._disabled) return;
+		this._disabled = false;
+		if (this._tty) this._enableEvents();
+		if (this._showing) this.show();
+	};
+	Gauge.prototype.disable = function() {
+		if (this._disabled) return;
+		if (this._showing) {
+			this._lastUpdateAt = null;
+			this._showing = false;
+			this._doRedraw();
+			this._showing = true;
+		}
+		this._disabled = true;
+		if (this._tty) this._disableEvents();
+	};
+	Gauge.prototype._enableEvents = function() {
+		if (this._cleanupOnExit) this._removeOnExit = onExit(callWith(this, this.disable));
+		this._tty.on("resize", this._$$handleSizeChange);
+		if (this._fixedFramerate) {
+			this.redrawTracker = setInterval(this._$$doRedraw, this._updateInterval);
+			if (this.redrawTracker.unref) this.redrawTracker.unref();
+		}
+	};
+	Gauge.prototype._disableEvents = function() {
+		this._tty.removeListener("resize", this._$$handleSizeChange);
+		if (this._fixedFramerate) clearInterval(this.redrawTracker);
+		if (this._removeOnExit) this._removeOnExit();
+	};
+	Gauge.prototype.hide = function(cb) {
+		if (this._disabled) return cb && process.nextTick(cb);
+		if (!this._showing) return cb && process.nextTick(cb);
+		this._showing = false;
+		this._doRedraw();
+		cb && setImmediate(cb);
+	};
+	Gauge.prototype.show = function(section, completed) {
+		this._showing = true;
+		if (typeof section === "string") this._status.section = section;
+		else if (typeof section === "object") {
+			var sectionKeys = Object.keys(section);
+			for (var ii = 0; ii < sectionKeys.length; ++ii) {
+				var key = sectionKeys[ii];
+				this._status[key] = section[key];
+			}
+		}
+		if (completed != null) this._status.completed = completed;
+		if (this._disabled) return;
+		this._requestRedraw();
+	};
+	Gauge.prototype.pulse = function(subsection) {
+		this._status.subsection = subsection || "";
+		this._status.spun++;
+		if (this._disabled) return;
+		if (!this._showing) return;
+		this._requestRedraw();
+	};
+	Gauge.prototype._handleSizeChange = function() {
+		this._gauge.setWidth(this._tty.columns - 1);
+		this._requestRedraw();
+	};
+	Gauge.prototype._doRedraw = function() {
+		if (this._disabled || this._paused) return;
+		if (!this._fixedFramerate) {
+			var now = Date.now();
+			if (this._lastUpdateAt && now - this._lastUpdateAt < this._updateInterval) return;
+			this._lastUpdateAt = now;
+		}
+		if (!this._showing && this._onScreen) {
+			this._onScreen = false;
+			var result = this._gauge.hide();
+			if (this._hideCursor) result += this._gauge.showCursor();
+			return this._writeTo.write(result);
+		}
+		if (!this._showing && !this._onScreen) return;
+		if (this._showing && !this._onScreen) {
+			this._onScreen = true;
+			this._needsRedraw = true;
+			if (this._hideCursor) this._writeTo.write(this._gauge.hideCursor());
+		}
+		if (!this._needsRedraw) return;
+		if (!this._writeTo.write(this._gauge.show(this._status))) {
+			this._paused = true;
+			this._writeTo.on("drain", callWith(this, function() {
+				this._paused = false;
+				this._doRedraw();
+			}));
+		}
+	};
+}));
+//#endregion
+export default require_gauge();
+export { require_gauge };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/plumbing.js

@@ -0,0 +1,48 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_console_control_strings } from "../../../console-control-strings@1.1.0/node_modules/console-control-strings/index.js";
+import { require_aproba } from "../../../aproba@2.1.0/node_modules/aproba/index.js";
+import { require_render_template } from "./render-template.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/plumbing.js
+var require_plumbing = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var consoleControl = require_console_control_strings();
+	var renderTemplate = require_render_template();
+	var validate = require_aproba();
+	var Plumbing = module.exports = function(theme, template, width) {
+		if (!width) width = 80;
+		validate("OAN", [
+			theme,
+			template,
+			width
+		]);
+		this.showing = false;
+		this.theme = theme;
+		this.width = width;
+		this.template = template;
+	};
+	Plumbing.prototype = {};
+	Plumbing.prototype.setTheme = function(theme) {
+		validate("O", [theme]);
+		this.theme = theme;
+	};
+	Plumbing.prototype.setTemplate = function(template) {
+		validate("A", [template]);
+		this.template = template;
+	};
+	Plumbing.prototype.setWidth = function(width) {
+		validate("N", [width]);
+		this.width = width;
+	};
+	Plumbing.prototype.hide = function() {
+		return consoleControl.gotoSOL() + consoleControl.eraseLine();
+	};
+	Plumbing.prototype.hideCursor = consoleControl.hideCursor;
+	Plumbing.prototype.showCursor = consoleControl.showCursor;
+	Plumbing.prototype.show = function(status) {
+		var values = Object.create(this.theme);
+		for (var key in status) values[key] = status[key];
+		return renderTemplate(this.width, this.template, values).trim() + consoleControl.color("reset") + consoleControl.eraseLine() + consoleControl.gotoSOL();
+	};
+}));
+//#endregion
+export default require_plumbing();
+export { require_plumbing };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/process.js

@@ -0,0 +1,8 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/process.js
+var require_process = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = process;
+}));
+//#endregion
+export default require_process();
+export { require_process };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/progress-bar.js

@@ -0,0 +1,46 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_string_width } from "../../../string-width@4.2.3/node_modules/string-width/index.js";
+import { require_aproba } from "../../../aproba@2.1.0/node_modules/aproba/index.js";
+import { require_wide_truncate } from "./wide-truncate.js";
+import { require_render_template } from "./render-template.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/progress-bar.js
+var require_progress_bar = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var validate = require_aproba();
+	var renderTemplate = require_render_template();
+	var wideTruncate = require_wide_truncate();
+	var stringWidth = require_string_width();
+	module.exports = function(theme, width, completed) {
+		validate("ONN", [
+			theme,
+			width,
+			completed
+		]);
+		if (completed < 0) completed = 0;
+		if (completed > 1) completed = 1;
+		if (width <= 0) return "";
+		var sofar = Math.round(width * completed);
+		var rest = width - sofar;
+		return renderTemplate(width, [{
+			type: "complete",
+			value: repeat(theme.complete, sofar),
+			length: sofar
+		}, {
+			type: "remaining",
+			value: repeat(theme.remaining, rest),
+			length: rest
+		}], theme);
+	};
+	function repeat(string, width) {
+		var result = "";
+		var n = width;
+		do {
+			if (n % 2) result += string;
+			n = Math.floor(n / 2);
+			string += string;
+		} while (n && stringWidth(result) < width);
+		return wideTruncate(result, width);
+	}
+}));
+//#endregion
+export default require_progress_bar();
+export { require_progress_bar };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/render-template.js

@@ -0,0 +1,155 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_align } from "../../../wide-align@1.1.5/node_modules/wide-align/align.js";
+import { require_aproba } from "../../../aproba@2.1.0/node_modules/aproba/index.js";
+import { require_wide_truncate } from "./wide-truncate.js";
+import { require_error } from "./error.js";
+import { require_template_item } from "./template-item.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/render-template.js
+var require_render_template = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var align = require_align();
+	var validate = require_aproba();
+	var wideTruncate = require_wide_truncate();
+	var error = require_error();
+	var TemplateItem = require_template_item();
+	function renderValueWithValues(values) {
+		return function(item) {
+			return renderValue(item, values);
+		};
+	}
+	var renderTemplate = module.exports = function(width, template, values) {
+		var rendered = prepareItems(width, template, values).map(renderValueWithValues(values)).join("");
+		return align.left(wideTruncate(rendered, width), width);
+	};
+	function preType(item) {
+		return "pre" + (item.type[0].toUpperCase() + item.type.slice(1));
+	}
+	function postType(item) {
+		return "post" + (item.type[0].toUpperCase() + item.type.slice(1));
+	}
+	function hasPreOrPost(item, values) {
+		if (!item.type) return;
+		return values[preType(item)] || values[postType(item)];
+	}
+	function generatePreAndPost(baseItem, parentValues) {
+		var item = Object.assign({}, baseItem);
+		var values = Object.create(parentValues);
+		var template = [];
+		var pre = preType(item);
+		var post = postType(item);
+		if (values[pre]) {
+			template.push({ value: values[pre] });
+			values[pre] = null;
+		}
+		item.minLength = null;
+		item.length = null;
+		item.maxLength = null;
+		template.push(item);
+		values[item.type] = values[item.type];
+		if (values[post]) {
+			template.push({ value: values[post] });
+			values[post] = null;
+		}
+		return function($1, $2, length) {
+			return renderTemplate(length, template, values);
+		};
+	}
+	function prepareItems(width, template, values) {
+		function cloneAndObjectify(item, index, arr) {
+			var cloned = new TemplateItem(item, width);
+			var type = cloned.type;
+			if (cloned.value == null) if (!(type in values)) if (cloned.default == null) throw new error.MissingTemplateValue(cloned, values);
+			else cloned.value = cloned.default;
+			else cloned.value = values[type];
+			if (cloned.value == null || cloned.value === "") return null;
+			cloned.index = index;
+			cloned.first = index === 0;
+			cloned.last = index === arr.length - 1;
+			if (hasPreOrPost(cloned, values)) cloned.value = generatePreAndPost(cloned, values);
+			return cloned;
+		}
+		var output = template.map(cloneAndObjectify).filter(function(item) {
+			return item != null;
+		});
+		var remainingSpace = width;
+		var variableCount = output.length;
+		function consumeSpace(length) {
+			if (length > remainingSpace) length = remainingSpace;
+			remainingSpace -= length;
+		}
+		function finishSizing(item, length) {
+			if (item.finished) throw new error.Internal("Tried to finish template item that was already finished");
+			if (length === Infinity) throw new error.Internal("Length of template item cannot be infinity");
+			if (length != null) item.length = length;
+			item.minLength = null;
+			item.maxLength = null;
+			--variableCount;
+			item.finished = true;
+			if (item.length == null) item.length = item.getBaseLength();
+			if (item.length == null) throw new error.Internal("Finished template items must have a length");
+			consumeSpace(item.getLength());
+		}
+		output.forEach(function(item) {
+			if (!item.kerning) return;
+			var prevPadRight = item.first ? 0 : output[item.index - 1].padRight;
+			if (!item.first && prevPadRight < item.kerning) item.padLeft = item.kerning - prevPadRight;
+			if (!item.last) item.padRight = item.kerning;
+		});
+		output.forEach(function(item) {
+			if (item.getBaseLength() == null) return;
+			finishSizing(item);
+		});
+		var resized = 0;
+		var resizing;
+		var hunkSize;
+		do {
+			resizing = false;
+			hunkSize = Math.round(remainingSpace / variableCount);
+			output.forEach(function(item) {
+				if (item.finished) return;
+				if (!item.maxLength) return;
+				if (item.getMaxLength() < hunkSize) {
+					finishSizing(item, item.maxLength);
+					resizing = true;
+				}
+			});
+		} while (resizing && resized++ < output.length);
+		if (resizing) throw new error.Internal("Resize loop iterated too many times while determining maxLength");
+		resized = 0;
+		do {
+			resizing = false;
+			hunkSize = Math.round(remainingSpace / variableCount);
+			output.forEach(function(item) {
+				if (item.finished) return;
+				if (!item.minLength) return;
+				if (item.getMinLength() >= hunkSize) {
+					finishSizing(item, item.minLength);
+					resizing = true;
+				}
+			});
+		} while (resizing && resized++ < output.length);
+		if (resizing) throw new error.Internal("Resize loop iterated too many times while determining minLength");
+		hunkSize = Math.round(remainingSpace / variableCount);
+		output.forEach(function(item) {
+			if (item.finished) return;
+			finishSizing(item, hunkSize);
+		});
+		return output;
+	}
+	function renderFunction(item, values, length) {
+		validate("OON", arguments);
+		if (item.type) return item.value(values, values[item.type + "Theme"] || {}, length);
+		else return item.value(values, {}, length);
+	}
+	function renderValue(item, values) {
+		var length = item.getBaseLength();
+		var value = typeof item.value === "function" ? renderFunction(item, values, length) : item.value;
+		if (value == null || value === "") return "";
+		var alignWith = align[item.align] || align.left;
+		var leftPadding = item.padLeft ? align.left("", item.padLeft) : "";
+		var rightPadding = item.padRight ? align.right("", item.padRight) : "";
+		return leftPadding + alignWith(wideTruncate(String(value), length), length) + rightPadding;
+	}
+}));
+//#endregion
+export default require_render_template();
+export { require_render_template };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/set-immediate.js

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_process } from "./process.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/set-immediate.js
+var require_set_immediate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var process = require_process();
+	try {
+		module.exports = setImmediate;
+	} catch (ex) {
+		module.exports = process.nextTick;
+	}
+}));
+//#endregion
+export default require_set_immediate();
+export { require_set_immediate };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/set-interval.js

@@ -0,0 +1,8 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/set-interval.js
+var require_set_interval = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = setInterval;
+}));
+//#endregion
+export default require_set_interval();
+export { require_set_interval };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/spin.js

@@ -0,0 +1,10 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/spin.js
+var require_spin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function spin(spinstr, spun) {
+		return spinstr[spun % spinstr.length];
+	};
+}));
+//#endregion
+export default require_spin();
+export { require_spin };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/template-item.js

@@ -0,0 +1,58 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_string_width } from "../../../string-width@4.2.3/node_modules/string-width/index.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/template-item.js
+var require_template_item = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var stringWidth = require_string_width();
+	module.exports = TemplateItem;
+	function isPercent(num) {
+		if (typeof num !== "string") return false;
+		return num.slice(-1) === "%";
+	}
+	function percent(num) {
+		return Number(num.slice(0, -1)) / 100;
+	}
+	function TemplateItem(values, outputLength) {
+		this.overallOutputLength = outputLength;
+		this.finished = false;
+		this.type = null;
+		this.value = null;
+		this.length = null;
+		this.maxLength = null;
+		this.minLength = null;
+		this.kerning = null;
+		this.align = "left";
+		this.padLeft = 0;
+		this.padRight = 0;
+		this.index = null;
+		this.first = null;
+		this.last = null;
+		if (typeof values === "string") this.value = values;
+		else for (var prop in values) this[prop] = values[prop];
+		if (isPercent(this.length)) this.length = Math.round(this.overallOutputLength * percent(this.length));
+		if (isPercent(this.minLength)) this.minLength = Math.round(this.overallOutputLength * percent(this.minLength));
+		if (isPercent(this.maxLength)) this.maxLength = Math.round(this.overallOutputLength * percent(this.maxLength));
+		return this;
+	}
+	TemplateItem.prototype = {};
+	TemplateItem.prototype.getBaseLength = function() {
+		var length = this.length;
+		if (length == null && typeof this.value === "string" && this.maxLength == null && this.minLength == null) length = stringWidth(this.value);
+		return length;
+	};
+	TemplateItem.prototype.getLength = function() {
+		var length = this.getBaseLength();
+		if (length == null) return null;
+		return length + this.padLeft + this.padRight;
+	};
+	TemplateItem.prototype.getMaxLength = function() {
+		if (this.maxLength == null) return null;
+		return this.maxLength + this.padLeft + this.padRight;
+	};
+	TemplateItem.prototype.getMinLength = function() {
+		if (this.minLength == null) return null;
+		return this.minLength + this.padLeft + this.padRight;
+	};
+}));
+//#endregion
+export default require_template_item();
+export { require_template_item };