@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js

@@ -0,0 +1,229 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_glob } from "../../../glob@7.2.3/node_modules/glob/glob.js";
+//#region node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js
+var require_rimraf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const assert = __require("assert");
+	const path = __require("path");
+	const fs = __require("fs");
+	let glob = void 0;
+	try {
+		glob = require_glob();
+	} catch (_err) {}
+	const defaultGlobOpts = {
+		nosort: true,
+		silent: true
+	};
+	let timeout = 0;
+	const isWindows = process.platform === "win32";
+	const defaults = (options) => {
+		[
+			"unlink",
+			"chmod",
+			"stat",
+			"lstat",
+			"rmdir",
+			"readdir"
+		].forEach((m) => {
+			options[m] = options[m] || fs[m];
+			m = m + "Sync";
+			options[m] = options[m] || fs[m];
+		});
+		options.maxBusyTries = options.maxBusyTries || 3;
+		options.emfileWait = options.emfileWait || 1e3;
+		if (options.glob === false) options.disableGlob = true;
+		if (options.disableGlob !== true && glob === void 0) throw Error("glob dependency not found, set `options.disableGlob = true` if intentional");
+		options.disableGlob = options.disableGlob || false;
+		options.glob = options.glob || defaultGlobOpts;
+	};
+	const rimraf = (p, options, cb) => {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		assert(p, "rimraf: missing path");
+		assert.equal(typeof p, "string", "rimraf: path should be a string");
+		assert.equal(typeof cb, "function", "rimraf: callback function required");
+		assert(options, "rimraf: invalid options argument provided");
+		assert.equal(typeof options, "object", "rimraf: options should be object");
+		defaults(options);
+		let busyTries = 0;
+		let errState = null;
+		let n = 0;
+		const next = (er) => {
+			errState = errState || er;
+			if (--n === 0) cb(errState);
+		};
+		const afterGlob = (er, results) => {
+			if (er) return cb(er);
+			n = results.length;
+			if (n === 0) return cb();
+			results.forEach((p) => {
+				const CB = (er) => {
+					if (er) {
+						if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
+							busyTries++;
+							return setTimeout(() => rimraf_(p, options, CB), busyTries * 100);
+						}
+						if (er.code === "EMFILE" && timeout < options.emfileWait) return setTimeout(() => rimraf_(p, options, CB), timeout++);
+						if (er.code === "ENOENT") er = null;
+					}
+					timeout = 0;
+					next(er);
+				};
+				rimraf_(p, options, CB);
+			});
+		};
+		if (options.disableGlob || !glob.hasMagic(p)) return afterGlob(null, [p]);
+		options.lstat(p, (er, stat) => {
+			if (!er) return afterGlob(null, [p]);
+			glob(p, options.glob, afterGlob);
+		});
+	};
+	const rimraf_ = (p, options, cb) => {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.lstat(p, (er, st) => {
+			if (er && er.code === "ENOENT") return cb(null);
+			if (er && er.code === "EPERM" && isWindows) fixWinEPERM(p, options, er, cb);
+			if (st && st.isDirectory()) return rmdir(p, options, er, cb);
+			options.unlink(p, (er) => {
+				if (er) {
+					if (er.code === "ENOENT") return cb(null);
+					if (er.code === "EPERM") return isWindows ? fixWinEPERM(p, options, er, cb) : rmdir(p, options, er, cb);
+					if (er.code === "EISDIR") return rmdir(p, options, er, cb);
+				}
+				return cb(er);
+			});
+		});
+	};
+	const fixWinEPERM = (p, options, er, cb) => {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.chmod(p, 438, (er2) => {
+			if (er2) cb(er2.code === "ENOENT" ? null : er);
+			else options.stat(p, (er3, stats) => {
+				if (er3) cb(er3.code === "ENOENT" ? null : er);
+				else if (stats.isDirectory()) rmdir(p, options, er, cb);
+				else options.unlink(p, cb);
+			});
+		});
+	};
+	const fixWinEPERMSync = (p, options, er) => {
+		assert(p);
+		assert(options);
+		try {
+			options.chmodSync(p, 438);
+		} catch (er2) {
+			if (er2.code === "ENOENT") return;
+			else throw er;
+		}
+		let stats;
+		try {
+			stats = options.statSync(p);
+		} catch (er3) {
+			if (er3.code === "ENOENT") return;
+			else throw er;
+		}
+		if (stats.isDirectory()) rmdirSync(p, options, er);
+		else options.unlinkSync(p);
+	};
+	const rmdir = (p, options, originalEr, cb) => {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.rmdir(p, (er) => {
+			if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) rmkids(p, options, cb);
+			else if (er && er.code === "ENOTDIR") cb(originalEr);
+			else cb(er);
+		});
+	};
+	const rmkids = (p, options, cb) => {
+		assert(p);
+		assert(options);
+		assert(typeof cb === "function");
+		options.readdir(p, (er, files) => {
+			if (er) return cb(er);
+			let n = files.length;
+			if (n === 0) return options.rmdir(p, cb);
+			let errState;
+			files.forEach((f) => {
+				rimraf(path.join(p, f), options, (er) => {
+					if (errState) return;
+					if (er) return cb(errState = er);
+					if (--n === 0) options.rmdir(p, cb);
+				});
+			});
+		});
+	};
+	const rimrafSync = (p, options) => {
+		options = options || {};
+		defaults(options);
+		assert(p, "rimraf: missing path");
+		assert.equal(typeof p, "string", "rimraf: path should be a string");
+		assert(options, "rimraf: missing options");
+		assert.equal(typeof options, "object", "rimraf: options should be object");
+		let results;
+		if (options.disableGlob || !glob.hasMagic(p)) results = [p];
+		else try {
+			options.lstatSync(p);
+			results = [p];
+		} catch (er) {
+			results = glob.sync(p, options.glob);
+		}
+		if (!results.length) return;
+		for (let i = 0; i < results.length; i++) {
+			const p = results[i];
+			let st;
+			try {
+				st = options.lstatSync(p);
+			} catch (er) {
+				if (er.code === "ENOENT") return;
+				if (er.code === "EPERM" && isWindows) fixWinEPERMSync(p, options, er);
+			}
+			try {
+				if (st && st.isDirectory()) rmdirSync(p, options, null);
+				else options.unlinkSync(p);
+			} catch (er) {
+				if (er.code === "ENOENT") return;
+				if (er.code === "EPERM") return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
+				if (er.code !== "EISDIR") throw er;
+				rmdirSync(p, options, er);
+			}
+		}
+	};
+	const rmdirSync = (p, options, originalEr) => {
+		assert(p);
+		assert(options);
+		try {
+			options.rmdirSync(p);
+		} catch (er) {
+			if (er.code === "ENOENT") return;
+			if (er.code === "ENOTDIR") throw originalEr;
+			if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") rmkidsSync(p, options);
+		}
+	};
+	const rmkidsSync = (p, options) => {
+		assert(p);
+		assert(options);
+		options.readdirSync(p).forEach((f) => rimrafSync(path.join(p, f), options));
+		const retries = isWindows ? 100 : 1;
+		let i = 0;
+		do {
+			let threw = true;
+			try {
+				const ret = options.rmdirSync(p, options);
+				threw = false;
+				return ret;
+			} finally {
+				if (++i < retries && threw) continue;
+			}
+		} while (true);
+	};
+	module.exports = rimraf;
+	rimraf.sync = rimrafSync;
+}));
+//#endregion
+export default require_rimraf();
+export { require_rimraf };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js

@@ -0,0 +1,79 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_debug } from "../internal/debug.js";
+import { require_re } from "../internal/re.js";
+import { require_parse_options } from "../internal/parse-options.js";
+import { require_semver } from "./semver.js";
+import { require_cmp } from "../functions/cmp.js";
+import { require_range } from "./range.js";
+//#region node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js
+var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ANY = Symbol("SemVer ANY");
+	module.exports = class Comparator {
+		static get ANY() {
+			return ANY;
+		}
+		constructor(comp, options) {
+			options = parseOptions(options);
+			if (comp instanceof Comparator) if (comp.loose === !!options.loose) return comp;
+			else comp = comp.value;
+			comp = comp.trim().split(/\s+/).join(" ");
+			debug("comparator", comp, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.parse(comp);
+			if (this.semver === ANY) this.value = "";
+			else this.value = this.operator + this.semver.version;
+			debug("comp", this);
+		}
+		parse(comp) {
+			const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+			const m = comp.match(r);
+			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+			this.operator = m[1] !== void 0 ? m[1] : "";
+			if (this.operator === "=") this.operator = "";
+			if (!m[2]) this.semver = ANY;
+			else this.semver = new SemVer(m[2], this.options.loose);
+		}
+		toString() {
+			return this.value;
+		}
+		test(version) {
+			debug("Comparator.test", version, this.options.loose);
+			if (this.semver === ANY || version === ANY) return true;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			return cmp(version, this.operator, this.semver, this.options);
+		}
+		intersects(comp, options) {
+			if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
+			if (this.operator === "") {
+				if (this.value === "") return true;
+				return new Range(comp.value, options).test(this.value);
+			} else if (comp.operator === "") {
+				if (comp.value === "") return true;
+				return new Range(this.value, options).test(comp.semver);
+			}
+			options = parseOptions(options);
+			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
+			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+			if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+			if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+			return false;
+		}
+	};
+	const parseOptions = require_parse_options();
+	const { safeRe: re, t } = require_re();
+	const cmp = require_cmp();
+	const debug = require_debug();
+	const SemVer = require_semver();
+	const Range = require_range();
+}));
+//#endregion
+export default require_comparator();
+export { require_comparator };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js

@@ -0,0 +1,282 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_constants } from "../internal/constants.js";
+import { require_debug } from "../internal/debug.js";
+import { require_re } from "../internal/re.js";
+import { require_parse_options } from "../internal/parse-options.js";
+import { require_semver } from "./semver.js";
+import { require_lrucache } from "../internal/lrucache.js";
+import { require_comparator } from "./comparator.js";
+//#region node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js
+var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SPACE_CHARACTERS = /\s+/g;
+	module.exports = class Range {
+		constructor(range, options) {
+			options = parseOptions(options);
+			if (range instanceof Range) if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+			else return new Range(range.raw, options);
+			if (range instanceof Comparator) {
+				this.raw = range.value;
+				this.set = [[range]];
+				this.formatted = void 0;
+				return this;
+			}
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+			this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+			if (this.set.length > 1) {
+				const first = this.set[0];
+				this.set = this.set.filter((c) => !isNullSet(c[0]));
+				if (this.set.length === 0) this.set = [first];
+				else if (this.set.length > 1) {
+					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
+						this.set = [c];
+						break;
+					}
+				}
+			}
+			this.formatted = void 0;
+		}
+		get range() {
+			if (this.formatted === void 0) {
+				this.formatted = "";
+				for (let i = 0; i < this.set.length; i++) {
+					if (i > 0) this.formatted += "||";
+					const comps = this.set[i];
+					for (let k = 0; k < comps.length; k++) {
+						if (k > 0) this.formatted += " ";
+						this.formatted += comps[k].toString().trim();
+					}
+				}
+			}
+			return this.formatted;
+		}
+		format() {
+			return this.range;
+		}
+		toString() {
+			return this.range;
+		}
+		parseRange(range) {
+			const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
+			const cached = cache.get(memoKey);
+			if (cached) return cached;
+			const loose = this.options.loose;
+			const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+			debug("hyphen replace", range);
+			range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+			debug("comparator trim", range);
+			range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+			debug("tilde trim", range);
+			range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+			debug("caret trim", range);
+			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+			if (loose) rangeList = rangeList.filter((comp) => {
+				debug("loose invalid filter", comp, this.options);
+				return !!comp.match(re[t.COMPARATORLOOSE]);
+			});
+			debug("range list", rangeList);
+			const rangeMap = /* @__PURE__ */ new Map();
+			const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+			for (const comp of comparators) {
+				if (isNullSet(comp)) return [comp];
+				rangeMap.set(comp.value, comp);
+			}
+			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+			const result = [...rangeMap.values()];
+			cache.set(memoKey, result);
+			return result;
+		}
+		intersects(range, options) {
+			if (!(range instanceof Range)) throw new TypeError("a Range is required");
+			return this.set.some((thisComparators) => {
+				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+						return rangeComparators.every((rangeComparator) => {
+							return thisComparator.intersects(rangeComparator, options);
+						});
+					});
+				});
+			});
+		}
+		test(version) {
+			if (!version) return false;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
+			return false;
+		}
+	};
+	const cache = new (require_lrucache())();
+	const parseOptions = require_parse_options();
+	const Comparator = require_comparator();
+	const debug = require_debug();
+	const SemVer = require_semver();
+	const { safeRe: re, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+	const isNullSet = (c) => c.value === "<0.0.0-0";
+	const isAny = (c) => c.value === "";
+	const isSatisfiable = (comparators, options) => {
+		let result = true;
+		const remainingComparators = comparators.slice();
+		let testComparator = remainingComparators.pop();
+		while (result && remainingComparators.length) {
+			result = remainingComparators.every((otherComparator) => {
+				return testComparator.intersects(otherComparator, options);
+			});
+			testComparator = remainingComparators.pop();
+		}
+		return result;
+	};
+	const parseComparator = (comp, options) => {
+		comp = comp.replace(re[t.BUILD], "");
+		debug("comp", comp, options);
+		comp = replaceCarets(comp, options);
+		debug("caret", comp);
+		comp = replaceTildes(comp, options);
+		debug("tildes", comp);
+		comp = replaceXRanges(comp, options);
+		debug("xrange", comp);
+		comp = replaceStars(comp, options);
+		debug("stars", comp);
+		return comp;
+	};
+	const isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+	const replaceTildes = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+	};
+	const replaceTilde = (comp, options) => {
+		const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("tilde", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+			else if (isX(p)) ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+			else if (pr) {
+				debug("replaceTilde pr", pr);
+				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+			debug("tilde return", ret);
+			return ret;
+		});
+	};
+	const replaceCarets = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+	};
+	const replaceCaret = (comp, options) => {
+		debug("caret", comp, options);
+		const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+		const z = options.includePrerelease ? "-0" : "";
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("caret", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+			else if (isX(p)) if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+			else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+			else if (pr) {
+				debug("replaceCaret pr", pr);
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+			} else {
+				debug("no pr");
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+			}
+			debug("caret return", ret);
+			return ret;
+		});
+	};
+	const replaceXRanges = (comp, options) => {
+		debug("replaceXRanges", comp, options);
+		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+	};
+	const replaceXRange = (comp, options) => {
+		comp = comp.trim();
+		const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+		return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+			debug("xRange", comp, ret, gtlt, M, m, p, pr);
+			const xM = isX(M);
+			const xm = xM || isX(m);
+			const xp = xm || isX(p);
+			const anyX = xp;
+			if (gtlt === "=" && anyX) gtlt = "";
+			pr = options.includePrerelease ? "-0" : "";
+			if (xM) if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+			else ret = "*";
+			else if (gtlt && anyX) {
+				if (xm) m = 0;
+				p = 0;
+				if (gtlt === ">") {
+					gtlt = ">=";
+					if (xm) {
+						M = +M + 1;
+						m = 0;
+						p = 0;
+					} else {
+						m = +m + 1;
+						p = 0;
+					}
+				} else if (gtlt === "<=") {
+					gtlt = "<";
+					if (xm) M = +M + 1;
+					else m = +m + 1;
+				}
+				if (gtlt === "<") pr = "-0";
+				ret = `${gtlt + M}.${m}.${p}${pr}`;
+			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+			debug("xRange return", ret);
+			return ret;
+		});
+	};
+	const replaceStars = (comp, options) => {
+		debug("replaceStars", comp, options);
+		return comp.trim().replace(re[t.STAR], "");
+	};
+	const replaceGTE0 = (comp, options) => {
+		debug("replaceGTE0", comp, options);
+		return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+	};
+	const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+		if (isX(fM)) from = "";
+		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+		else if (fpr) from = `>=${from}`;
+		else from = `>=${from}${incPr ? "-0" : ""}`;
+		if (isX(tM)) to = "";
+		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
+		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
+		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
+		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	};
+	const testSet = (set, version, options) => {
+		for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
+		if (version.prerelease.length && !options.includePrerelease) {
+			for (let i = 0; i < set.length; i++) {
+				debug(set[i].semver);
+				if (set[i].semver === Comparator.ANY) continue;
+				if (set[i].semver.prerelease.length > 0) {
+					const allowed = set[i].semver;
+					if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+				}
+			}
+			return false;
+		}
+		return true;
+	};
+}));
+//#endregion
+export default require_range();
+export { require_range };