@hot-updater/plugin-core 1.0.0-rc.0 → 1.0.0-rc.14

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.cjs

@@ -0,0 +1,167 @@
+const require_comparison_DenM3wCn = require("./comparison-DenM3wCn.cjs");
+const require_set_CC5YeoYX = require("./set-CC5YeoYX.cjs");
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.js
+const BUILD_STRIP = new RegExp(require_comparison_DenM3wCn.C, "g");
+const BUILD_SAFE = require_comparison_DenM3wCn.F(require_comparison_DenM3wCn.C);
+const STRICT_HYPHEN = require_comparison_DenM3wCn.F(String.raw`^\s*(${require_comparison_DenM3wCn.N})\s+-\s+(${require_comparison_DenM3wCn.N})\s*$`);
+const LOOSE_HYPHEN = require_comparison_DenM3wCn.F(String.raw`^\s*(${require_comparison_DenM3wCn.P})\s+-\s+(${require_comparison_DenM3wCn.P})\s*$`);
+const COMPARATOR_TRIM = require_comparison_DenM3wCn.F(String.raw`(\s*)${require_comparison_DenM3wCn.D}\s*(${require_comparison_DenM3wCn.A}|${require_comparison_DenM3wCn.N})`, "g");
+const TILDE_TRIM = require_comparison_DenM3wCn.F(String.raw`(\s*)${require_comparison_DenM3wCn.k}\s+`, "g");
+const CARET_TRIM = require_comparison_DenM3wCn.F(String.raw`(\s*)${require_comparison_DenM3wCn.O}\s+`, "g");
+const STRICT_TILDE = require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.k}${require_comparison_DenM3wCn.N}$`);
+const LOOSE_TILDE = require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.k}${require_comparison_DenM3wCn.P}$`);
+const STRICT_CARET = require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.O}${require_comparison_DenM3wCn.N}$`);
+const LOOSE_CARET = require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.O}${require_comparison_DenM3wCn.P}$`);
+const STRICT_XRANGE = require_comparison_DenM3wCn.F(String.raw`^${require_comparison_DenM3wCn.D}\s*${require_comparison_DenM3wCn.N}$`);
+const LOOSE_XRANGE = require_comparison_DenM3wCn.F(String.raw`^${require_comparison_DenM3wCn.D}\s*${require_comparison_DenM3wCn.P}$`);
+const STAR = require_comparison_DenM3wCn.F(String.raw`(<|>)?=?\s*\*`);
+const GTE_ZERO = /^\s*>=\s*0\.0\.0\s*$/;
+const GTE_ZERO_PRERELEASE = /^\s*>=\s*0\.0\.0-0\s*$/;
+const LOOSE_COMPARATOR = require_comparison_DenM3wCn.F(String.raw`^${require_comparison_DenM3wCn.D}\s*(${require_comparison_DenM3wCn.A})$|^$`);
+function isWildcard(value) {
+	return !value || String(value).toLowerCase() === "x" || String(value) === "*";
+}
+function hasInvalidWildcardOrder(major, minor, patch) {
+	return isWildcard(major) && !isWildcard(minor) || isWildcard(minor) && Boolean(patch) && !isWildcard(patch);
+}
+function replaceTilde(comparator, options) {
+	const expression = options.loose ? LOOSE_TILDE : STRICT_TILDE;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return prerelease ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+	});
+}
+function replaceTildes(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceTilde(part, options)).join(" ");
+}
+function replaceCaret(comparator, options) {
+	const expression = options.loose ? LOOSE_CARET : STRICT_CARET;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return major === "0" ? `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (prerelease) return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch}-${prerelease} <${Number(major) + 1}.0.0-0`;
+		return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+	});
+}
+function replaceCarets(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceCaret(part, options)).join(" ");
+}
+function replaceXRange(comparator, options) {
+	const expression = options.loose ? LOOSE_XRANGE : STRICT_XRANGE;
+	return comparator.trim().replace(expression, (match, rawOperator, rawMajor, rawMinor, rawPatch) => {
+		let operator = rawOperator;
+		let major = rawMajor;
+		let minor = rawMinor;
+		let patch = rawPatch;
+		if (hasInvalidWildcardOrder(String(major), minor === void 0 ? void 0 : String(minor), patch === void 0 ? void 0 : String(patch))) return comparator;
+		const wildcardMajor = isWildcard(major);
+		const wildcardMinor = wildcardMajor || isWildcard(minor);
+		const wildcardPatch = wildcardMinor || isWildcard(patch);
+		if (operator === "=" && wildcardPatch) operator = "";
+		if (wildcardMajor) return operator === ">" || operator === "<" ? "<0.0.0-0" : "*";
+		let prerelease = options.includePrerelease ? "-0" : "";
+		if (operator && wildcardPatch) {
+			if (wildcardMinor) minor = 0;
+			patch = 0;
+			if (operator === ">") {
+				operator = ">=";
+				if (wildcardMinor) {
+					major = Number(major) + 1;
+					minor = 0;
+				} else minor = Number(minor) + 1;
+			} else if (operator === "<=") {
+				operator = "<";
+				if (wildcardMinor) major = Number(major) + 1;
+				else minor = Number(minor) + 1;
+			}
+			if (operator === "<") prerelease = "-0";
+			return `${operator}${major}.${minor}.${patch}${prerelease}`;
+		}
+		if (wildcardMinor) return `>=${major}.0.0${prerelease} <${Number(major) + 1}.0.0-0`;
+		if (wildcardPatch) return `>=${major}.${minor}.0${prerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return match;
+	});
+}
+function replaceXRanges(comparator, options) {
+	return comparator.split(/\s+/).map((part) => replaceXRange(part, options)).join(" ");
+}
+function replaceHyphenRange(range, options) {
+	const expression = options.loose ? LOOSE_HYPHEN : STRICT_HYPHEN;
+	return range.replace(expression, (_match, rawFrom, fromMajor, fromMinor, fromPatch, fromPrerelease, _fromBuild, rawTo, toMajor, toMinor, toPatch, toPrerelease) => {
+		let from = rawFrom;
+		let to = rawTo;
+		if (isWildcard(fromMajor)) from = "";
+		else if (isWildcard(fromMinor)) from = `>=${fromMajor}.0.0${options.includePrerelease ? "-0" : ""}`;
+		else if (isWildcard(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0${options.includePrerelease ? "-0" : ""}`;
+		else if (fromPrerelease) from = `>=${from}`;
+		else from = `>=${from}${options.includePrerelease ? "-0" : ""}`;
+		if (isWildcard(toMajor)) to = "";
+		else if (isWildcard(toMinor)) to = `<${Number(toMajor) + 1}.0.0-0`;
+		else if (isWildcard(toPatch)) to = `<${toMajor}.${Number(toMinor) + 1}.0-0`;
+		else if (toPrerelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPrerelease}`;
+		else if (options.includePrerelease) to = `<${toMajor}.${toMinor}.${Number(toPatch) + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function expandComparator(comparator, options) {
+	return replaceXRanges(replaceTildes(replaceCarets(comparator.replace(BUILD_SAFE, ""), options), options), options).trim().replace(STAR, "");
+}
+function parseSimpleRange(input, options) {
+	let parts = replaceHyphenRange(input.replace(BUILD_STRIP, ""), options).replace(COMPARATOR_TRIM, "$1$2$3").replace(TILDE_TRIM, "$1~").replace(CARET_TRIM, "$1^").split(" ").map((part) => expandComparator(part, options)).join(" ").split(/\s+/).map((part) => part.trim().replace(options.includePrerelease ? GTE_ZERO_PRERELEASE : GTE_ZERO, ""));
+	if (options.loose) parts = parts.filter((part) => LOOSE_COMPARATOR.test(part));
+	const unique = /* @__PURE__ */ new Map();
+	for (const comparator of parts.map((part) => require_set_CC5YeoYX.s(part, options))) {
+		if (comparator.value === "<0.0.0-0") return [comparator];
+		unique.set(comparator.value, comparator);
+	}
+	if (unique.size > 1) unique.delete("");
+	return [...unique.values()];
+}
+function parseRange(range, options = {}) {
+	if (typeof range !== "string") return range;
+	const parsedOptions = { ...options };
+	const normalizedRange = range.trim().replaceAll(/\s+/g, " ");
+	let sets = normalizedRange.split("||").map((part) => parseSimpleRange(part.trim(), parsedOptions)).filter((set) => set.length);
+	if (!sets.length) throw new TypeError(`Range contains no valid comparator sets: ${normalizedRange}`);
+	if (sets.length > 1) {
+		const first = sets[0];
+		sets = sets.filter((set) => set[0]?.value !== "<0.0.0-0");
+		if (!sets.length) sets = [first];
+		else if (sets.length > 1) {
+			const any = sets.find((set) => set.length === 1 && set[0]?.value === "");
+			if (any) sets = [any];
+		}
+	}
+	return {
+		options: parsedOptions,
+		sets
+	};
+}
+function tryParseRange(range, options = {}) {
+	try {
+		return parseRange(range, options);
+	} catch {
+		return null;
+	}
+}
+function testParsedRange(range, version) {
+	return range.sets.some((set) => require_set_CC5YeoYX.r(set, version, range.options));
+}
+function testRangeVersion(range, version) {
+	const parsed = require_comparison_DenM3wCn.S(version, range.options);
+	return parsed ? testParsedRange(range, parsed) : false;
+}
+function satisfies(version, range, options = {}) {
+	const parsed = tryParseRange(range, options);
+	return parsed ? testRangeVersion(parsed, version) : false;
+}
+//#endregion
+exports.f = satisfies;
+exports.h = tryParseRange;
+exports.m = parseRange;

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.mjs

@@ -0,0 +1,165 @@
+import { A as LOOSE_PLAIN, C as BUILD, D as GREATER_LESS_THAN, F as safeRegex, N as XRANGE_PLAIN, O as LONE_CARET, P as XRANGE_PLAIN_LOOSE, S as tryParse, k as LONE_TILDE } from "./comparison-DenM3wCn.mjs";
+import { r as testComparatorSet, s as parseComparator } from "./set-CC5YeoYX.mjs";
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.js
+const BUILD_STRIP = new RegExp(BUILD, "g");
+const BUILD_SAFE = safeRegex(BUILD);
+const STRICT_HYPHEN = safeRegex(String.raw`^\s*(${XRANGE_PLAIN})\s+-\s+(${XRANGE_PLAIN})\s*$`);
+const LOOSE_HYPHEN = safeRegex(String.raw`^\s*(${XRANGE_PLAIN_LOOSE})\s+-\s+(${XRANGE_PLAIN_LOOSE})\s*$`);
+const COMPARATOR_TRIM = safeRegex(String.raw`(\s*)${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN}|${XRANGE_PLAIN})`, "g");
+const TILDE_TRIM = safeRegex(String.raw`(\s*)${LONE_TILDE}\s+`, "g");
+const CARET_TRIM = safeRegex(String.raw`(\s*)${LONE_CARET}\s+`, "g");
+const STRICT_TILDE = safeRegex(`^${LONE_TILDE}${XRANGE_PLAIN}$`);
+const LOOSE_TILDE = safeRegex(`^${LONE_TILDE}${XRANGE_PLAIN_LOOSE}$`);
+const STRICT_CARET = safeRegex(`^${LONE_CARET}${XRANGE_PLAIN}$`);
+const LOOSE_CARET = safeRegex(`^${LONE_CARET}${XRANGE_PLAIN_LOOSE}$`);
+const STRICT_XRANGE = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*${XRANGE_PLAIN}$`);
+const LOOSE_XRANGE = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*${XRANGE_PLAIN_LOOSE}$`);
+const STAR = safeRegex(String.raw`(<|>)?=?\s*\*`);
+const GTE_ZERO = /^\s*>=\s*0\.0\.0\s*$/;
+const GTE_ZERO_PRERELEASE = /^\s*>=\s*0\.0\.0-0\s*$/;
+const LOOSE_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN})$|^$`);
+function isWildcard(value) {
+	return !value || String(value).toLowerCase() === "x" || String(value) === "*";
+}
+function hasInvalidWildcardOrder(major, minor, patch) {
+	return isWildcard(major) && !isWildcard(minor) || isWildcard(minor) && Boolean(patch) && !isWildcard(patch);
+}
+function replaceTilde(comparator, options) {
+	const expression = options.loose ? LOOSE_TILDE : STRICT_TILDE;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return prerelease ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+	});
+}
+function replaceTildes(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceTilde(part, options)).join(" ");
+}
+function replaceCaret(comparator, options) {
+	const expression = options.loose ? LOOSE_CARET : STRICT_CARET;
+	const lowerPrerelease = options.includePrerelease ? "-0" : "";
+	return comparator.replace(expression, (_match, major, minor, patch, prerelease) => {
+		if (isWildcard(major)) return "";
+		if (isWildcard(minor)) return `>=${major}.0.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (isWildcard(patch)) return major === "0" ? `>=${major}.${minor}.0${lowerPrerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.0${lowerPrerelease} <${Number(major) + 1}.0.0-0`;
+		if (prerelease) return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch}-${prerelease} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch}-${prerelease} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch}-${prerelease} <${Number(major) + 1}.0.0-0`;
+		return major === "0" ? minor === "0" ? `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0` : `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0` : `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+	});
+}
+function replaceCarets(comparator, options) {
+	return comparator.trim().split(/\s+/).map((part) => replaceCaret(part, options)).join(" ");
+}
+function replaceXRange(comparator, options) {
+	const expression = options.loose ? LOOSE_XRANGE : STRICT_XRANGE;
+	return comparator.trim().replace(expression, (match, rawOperator, rawMajor, rawMinor, rawPatch) => {
+		let operator = rawOperator;
+		let major = rawMajor;
+		let minor = rawMinor;
+		let patch = rawPatch;
+		if (hasInvalidWildcardOrder(String(major), minor === void 0 ? void 0 : String(minor), patch === void 0 ? void 0 : String(patch))) return comparator;
+		const wildcardMajor = isWildcard(major);
+		const wildcardMinor = wildcardMajor || isWildcard(minor);
+		const wildcardPatch = wildcardMinor || isWildcard(patch);
+		if (operator === "=" && wildcardPatch) operator = "";
+		if (wildcardMajor) return operator === ">" || operator === "<" ? "<0.0.0-0" : "*";
+		let prerelease = options.includePrerelease ? "-0" : "";
+		if (operator && wildcardPatch) {
+			if (wildcardMinor) minor = 0;
+			patch = 0;
+			if (operator === ">") {
+				operator = ">=";
+				if (wildcardMinor) {
+					major = Number(major) + 1;
+					minor = 0;
+				} else minor = Number(minor) + 1;
+			} else if (operator === "<=") {
+				operator = "<";
+				if (wildcardMinor) major = Number(major) + 1;
+				else minor = Number(minor) + 1;
+			}
+			if (operator === "<") prerelease = "-0";
+			return `${operator}${major}.${minor}.${patch}${prerelease}`;
+		}
+		if (wildcardMinor) return `>=${major}.0.0${prerelease} <${Number(major) + 1}.0.0-0`;
+		if (wildcardPatch) return `>=${major}.${minor}.0${prerelease} <${major}.${Number(minor) + 1}.0-0`;
+		return match;
+	});
+}
+function replaceXRanges(comparator, options) {
+	return comparator.split(/\s+/).map((part) => replaceXRange(part, options)).join(" ");
+}
+function replaceHyphenRange(range, options) {
+	const expression = options.loose ? LOOSE_HYPHEN : STRICT_HYPHEN;
+	return range.replace(expression, (_match, rawFrom, fromMajor, fromMinor, fromPatch, fromPrerelease, _fromBuild, rawTo, toMajor, toMinor, toPatch, toPrerelease) => {
+		let from = rawFrom;
+		let to = rawTo;
+		if (isWildcard(fromMajor)) from = "";
+		else if (isWildcard(fromMinor)) from = `>=${fromMajor}.0.0${options.includePrerelease ? "-0" : ""}`;
+		else if (isWildcard(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0${options.includePrerelease ? "-0" : ""}`;
+		else if (fromPrerelease) from = `>=${from}`;
+		else from = `>=${from}${options.includePrerelease ? "-0" : ""}`;
+		if (isWildcard(toMajor)) to = "";
+		else if (isWildcard(toMinor)) to = `<${Number(toMajor) + 1}.0.0-0`;
+		else if (isWildcard(toPatch)) to = `<${toMajor}.${Number(toMinor) + 1}.0-0`;
+		else if (toPrerelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPrerelease}`;
+		else if (options.includePrerelease) to = `<${toMajor}.${toMinor}.${Number(toPatch) + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function expandComparator(comparator, options) {
+	return replaceXRanges(replaceTildes(replaceCarets(comparator.replace(BUILD_SAFE, ""), options), options), options).trim().replace(STAR, "");
+}
+function parseSimpleRange(input, options) {
+	let parts = replaceHyphenRange(input.replace(BUILD_STRIP, ""), options).replace(COMPARATOR_TRIM, "$1$2$3").replace(TILDE_TRIM, "$1~").replace(CARET_TRIM, "$1^").split(" ").map((part) => expandComparator(part, options)).join(" ").split(/\s+/).map((part) => part.trim().replace(options.includePrerelease ? GTE_ZERO_PRERELEASE : GTE_ZERO, ""));
+	if (options.loose) parts = parts.filter((part) => LOOSE_COMPARATOR.test(part));
+	const unique = /* @__PURE__ */ new Map();
+	for (const comparator of parts.map((part) => parseComparator(part, options))) {
+		if (comparator.value === "<0.0.0-0") return [comparator];
+		unique.set(comparator.value, comparator);
+	}
+	if (unique.size > 1) unique.delete("");
+	return [...unique.values()];
+}
+function parseRange(range, options = {}) {
+	if (typeof range !== "string") return range;
+	const parsedOptions = { ...options };
+	const normalizedRange = range.trim().replaceAll(/\s+/g, " ");
+	let sets = normalizedRange.split("||").map((part) => parseSimpleRange(part.trim(), parsedOptions)).filter((set) => set.length);
+	if (!sets.length) throw new TypeError(`Range contains no valid comparator sets: ${normalizedRange}`);
+	if (sets.length > 1) {
+		const first = sets[0];
+		sets = sets.filter((set) => set[0]?.value !== "<0.0.0-0");
+		if (!sets.length) sets = [first];
+		else if (sets.length > 1) {
+			const any = sets.find((set) => set.length === 1 && set[0]?.value === "");
+			if (any) sets = [any];
+		}
+	}
+	return {
+		options: parsedOptions,
+		sets
+	};
+}
+function tryParseRange(range, options = {}) {
+	try {
+		return parseRange(range, options);
+	} catch {
+		return null;
+	}
+}
+function testParsedRange(range, version) {
+	return range.sets.some((set) => testComparatorSet(set, version, range.options));
+}
+function testRangeVersion(range, version) {
+	const parsed = tryParse(version, range.options);
+	return parsed ? testParsedRange(range, parsed) : false;
+}
+function satisfies(version, range, options = {}) {
+	const parsed = tryParseRange(range, options);
+	return parsed ? testRangeVersion(parsed, version) : false;
+}
+//#endregion
+export { satisfies as f, tryParseRange as h, parseRange as m };

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/set-CC5YeoYX.cjs

@@ -0,0 +1,42 @@
+const require_comparison_DenM3wCn = require("./comparison-DenM3wCn.cjs");
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/set-CC5YeoYX.js
+const STRICT_COMPARATOR = require_comparison_DenM3wCn.F(String.raw`^${require_comparison_DenM3wCn.D}\s*(${require_comparison_DenM3wCn.E})$|^$`);
+const LOOSE_COMPARATOR = require_comparison_DenM3wCn.F(String.raw`^${require_comparison_DenM3wCn.D}\s*(${require_comparison_DenM3wCn.A})$|^$`);
+function parseComparator(comparator, options = {}) {
+	if (typeof comparator !== "string") return comparator;
+	const normalized = comparator.trim().replaceAll(/\s+/g, " ");
+	const match = normalized.match(options.loose ? LOOSE_COMPARATOR : STRICT_COMPARATOR);
+	if (!match) throw new TypeError(`Invalid comparator: ${normalized}`);
+	const operator = match[1] === "=" ? "" : match[1] || "";
+	const version = match[2] ? require_comparison_DenM3wCn.x(match[2], options) : null;
+	return {
+		operator,
+		options,
+		value: version ? `${operator}${require_comparison_DenM3wCn.y(version)}` : "",
+		version
+	};
+}
+function testParsedComparator(comparator, version) {
+	if (!comparator.version) return true;
+	const comparison = require_comparison_DenM3wCn.a(version, comparator.version);
+	switch (comparator.operator) {
+		case "": return comparison === 0;
+		case ">": return comparison > 0;
+		case ">=": return comparison >= 0;
+		case "<": return comparison < 0;
+		case "<=": return comparison <= 0;
+	}
+}
+function comparatorAllowsPrerelease(comparator, version) {
+	const allowed = comparator.version;
+	return allowed !== null && !!allowed.prerelease?.length && allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch;
+}
+function testComparatorSet(set, version, options) {
+	if (set.some((comparator) => !testParsedComparator(comparator, version))) return false;
+	return !version.prerelease?.length || !!options.includePrerelease || set.some((comparator) => comparatorAllowsPrerelease(comparator, version));
+}
+//#endregion
+exports.a = testParsedComparator;
+exports.r = testComparatorSet;
+exports.s = parseComparator;
+exports.t = comparatorAllowsPrerelease;

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/set-CC5YeoYX.mjs

@@ -0,0 +1,39 @@
+import { A as LOOSE_PLAIN, D as GREATER_LESS_THAN, E as FULL_PLAIN, F as safeRegex, a as compareParsed, x as parse, y as formatComparableVersion } from "./comparison-DenM3wCn.mjs";
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/set-CC5YeoYX.js
+const STRICT_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${FULL_PLAIN})$|^$`);
+const LOOSE_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${LOOSE_PLAIN})$|^$`);
+function parseComparator(comparator, options = {}) {
+	if (typeof comparator !== "string") return comparator;
+	const normalized = comparator.trim().replaceAll(/\s+/g, " ");
+	const match = normalized.match(options.loose ? LOOSE_COMPARATOR : STRICT_COMPARATOR);
+	if (!match) throw new TypeError(`Invalid comparator: ${normalized}`);
+	const operator = match[1] === "=" ? "" : match[1] || "";
+	const version = match[2] ? parse(match[2], options) : null;
+	return {
+		operator,
+		options,
+		value: version ? `${operator}${formatComparableVersion(version)}` : "",
+		version
+	};
+}
+function testParsedComparator(comparator, version) {
+	if (!comparator.version) return true;
+	const comparison = compareParsed(version, comparator.version);
+	switch (comparator.operator) {
+		case "": return comparison === 0;
+		case ">": return comparison > 0;
+		case ">=": return comparison >= 0;
+		case "<": return comparison < 0;
+		case "<=": return comparison <= 0;
+	}
+}
+function comparatorAllowsPrerelease(comparator, version) {
+	const allowed = comparator.version;
+	return allowed !== null && !!allowed.prerelease?.length && allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch;
+}
+function testComparatorSet(set, version, options) {
+	if (set.some((comparator) => !testParsedComparator(comparator, version))) return false;
+	return !version.prerelease?.length || !!options.includePrerelease || set.some((comparator) => comparatorAllowsPrerelease(comparator, version));
+}
+//#endregion
+export { testParsedComparator as a, testComparatorSet as r, parseComparator as s, comparatorAllowsPrerelease as t };

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.cjs

@@ -0,0 +1,39 @@
+const require_comparison_DenM3wCn = require("./comparison-DenM3wCn.cjs");
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.js
+const COERCE_EXACT = require_comparison_DenM3wCn.F(require_comparison_DenM3wCn.w);
+const COERCE_FULL_EXACT = require_comparison_DenM3wCn.F(require_comparison_DenM3wCn.T);
+require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.j}$`);
+require_comparison_DenM3wCn.F(`^${require_comparison_DenM3wCn.M}$`);
+function normalizeFull(version, options = {}) {
+	const parsed = require_comparison_DenM3wCn.S(version, options);
+	return parsed ? require_comparison_DenM3wCn.b(parsed) : null;
+}
+function normalize(version, options = {}) {
+	const parsed = require_comparison_DenM3wCn.S(version, options);
+	return parsed ? require_comparison_DenM3wCn.y(parsed) : null;
+}
+function coerce(value, options = {}) {
+	if (typeof value === "object") return value;
+	const input = typeof value === "number" ? String(value) : value;
+	let match = null;
+	if (options.rtl) {
+		const source = options.includePrerelease ? require_comparison_DenM3wCn.T : require_comparison_DenM3wCn.w;
+		const expression = require_comparison_DenM3wCn.F(source, "g");
+		let next;
+		while ((next = expression.exec(input)) && (!match || match.index + match[0].length !== input.length)) {
+			if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+			expression.lastIndex = next.index + next[1].length + next[2].length;
+		}
+	} else match = (options.includePrerelease ? COERCE_FULL_EXACT : COERCE_EXACT).exec(input);
+	if (!match) return null;
+	const major = match[2];
+	const minor = match[3] || "0";
+	const patch = match[4] || "0";
+	const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+	const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+	return require_comparison_DenM3wCn.S(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+}
+//#endregion
+exports.m = normalizeFull;
+exports.n = coerce;
+exports.p = normalize;

package/dist/node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.mjs

@@ -0,0 +1,37 @@
+import { F as safeRegex, M as PRERELEASE_LOOSE, S as tryParse, T as COERCE_FULL, b as formatFullVersion, j as PRERELEASE, w as COERCE, y as formatComparableVersion } from "./comparison-DenM3wCn.mjs";
+//#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.js
+const COERCE_EXACT = safeRegex(COERCE);
+const COERCE_FULL_EXACT = safeRegex(COERCE_FULL);
+safeRegex(`^${PRERELEASE}$`);
+safeRegex(`^${PRERELEASE_LOOSE}$`);
+function normalizeFull(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatFullVersion(parsed) : null;
+}
+function normalize(version, options = {}) {
+	const parsed = tryParse(version, options);
+	return parsed ? formatComparableVersion(parsed) : null;
+}
+function coerce(value, options = {}) {
+	if (typeof value === "object") return value;
+	const input = typeof value === "number" ? String(value) : value;
+	let match = null;
+	if (options.rtl) {
+		const source = options.includePrerelease ? COERCE_FULL : COERCE;
+		const expression = safeRegex(source, "g");
+		let next;
+		while ((next = expression.exec(input)) && (!match || match.index + match[0].length !== input.length)) {
+			if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+			expression.lastIndex = next.index + next[1].length + next[2].length;
+		}
+	} else match = (options.includePrerelease ? COERCE_FULL_EXACT : COERCE_EXACT).exec(input);
+	if (!match) return null;
+	const major = match[2];
+	const minor = match[3] || "0";
+	const patch = match[4] || "0";
+	const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+	const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+	return tryParse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+}
+//#endregion
+export { normalizeFull as m, coerce as n, normalize as p };

package/dist/paginateBundles.d.cts

@@ -1,15 +1,8 @@
 import { DatabaseBundleCursor, DatabaseBundleQueryOrder, Paginated } from "./types/index.cjs";
-
 //#region src/paginateBundles.d.ts
 declare function paginateBundles<TBundle extends {
   readonly id: string;
-}>({
-  bundles,
-  limit,
-  offset,
-  cursor,
-  orderBy
-}: {
+}>({ bundles, limit, offset, cursor, orderBy }: {
   bundles: readonly TBundle[];
   limit: number;
   offset?: number;

package/dist/paginateBundles.d.mts

@@ -1,15 +1,8 @@
 import { DatabaseBundleCursor, DatabaseBundleQueryOrder, Paginated } from "./types/index.mjs";
-
 //#region src/paginateBundles.d.ts
 declare function paginateBundles<TBundle extends {
   readonly id: string;
-}>({
-  bundles,
-  limit,
-  offset,
-  cursor,
-  orderBy
-}: {
+}>({ bundles, limit, offset, cursor, orderBy }: {
   bundles: readonly TBundle[];
   limit: number;
   offset?: number;

package/dist/parseStorageUri.d.cts

@@ -13,11 +13,7 @@ interface CreateStorageUriInput {
  * Creates a hierarchical storage identifier in the form
  * `protocol://bucket/slash-separated-encoded-key`.
  */
-declare const createStorageUri: ({
-  protocol,
-  bucket,
-  key
-}: CreateStorageUriInput) => string;
+declare const createStorageUri: ({ protocol, bucket, key }: CreateStorageUriInput) => string;
 /**
  * Parses a hierarchical storage identifier and decodes each key segment.
  *

package/dist/parseStorageUri.d.mts

@@ -13,11 +13,7 @@ interface CreateStorageUriInput {
  * Creates a hierarchical storage identifier in the form
  * `protocol://bucket/slash-separated-encoded-key`.
  */
-declare const createStorageUri: ({
-  protocol,
-  bucket,
-  key
-}: CreateStorageUriInput) => string;
+declare const createStorageUri: ({ protocol, bucket, key }: CreateStorageUriInput) => string;
 /**
  * Parses a hierarchical storage identifier and decodes each key segment.
  *

package/dist/queryBundles.d.cts

@@ -1,5 +1,4 @@
 import { Bundle, DatabaseBundleIdFilter, DatabaseBundleQueryOrder, DatabaseBundleQueryWhere } from "./types/index.cjs";
-
 //#region src/queryBundles.d.ts
 declare function bundleIdMatchesFilter(id: string, filter: DatabaseBundleIdFilter | undefined): boolean;
 declare function bundleMatchesQueryWhere(bundle: Bundle, where: DatabaseBundleQueryWhere | undefined): boolean;

package/dist/queryBundles.d.mts

@@ -1,5 +1,4 @@
 import { Bundle, DatabaseBundleIdFilter, DatabaseBundleQueryOrder, DatabaseBundleQueryWhere } from "./types/index.mjs";
-
 //#region src/queryBundles.d.ts
 declare function bundleIdMatchesFilter(id: string, filter: DatabaseBundleIdFilter | undefined): boolean;
 declare function bundleMatchesQueryWhere(bundle: Bundle, where: DatabaseBundleQueryWhere | undefined): boolean;

package/dist/releaseCatalogCompiler.cjs

@@ -1,5 +1,6 @@
-require("./_virtual/_rolldown/runtime.cjs");
-const require_index = require("./node_modules/.pnpm/verkit@0.3.2/node_modules/verkit/dist/index.cjs");
+const require_comparison_DenM3wCn = require("./node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/comparison-DenM3wCn.cjs");
+const require_range_DvX_Y6iv = require("./node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.cjs");
+const require_version_CQ98ZBpL = require("./node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/version-CQ98ZBpL.cjs");
 let _hot_updater_core = require("@hot-updater/core");
 //#region src/releaseCatalogCompiler.ts
 var ReleaseCatalogCompilationError = class extends Error {
@@ -11,7 +12,7 @@ var ReleaseCatalogCompilationError = class extends Error {
 	}
 };
 function compareBounds(left, right) {
-	return require_index.compare(left, right);
+	return require_comparison_DenM3wCn.t(left, right);
 }
 function strongerLower(current, candidate) {
 	if (current === null) return candidate;
@@ -34,7 +35,7 @@ function strongerUpper(current, candidate) {
 	};
 }
 function comparatorVersion(comparator) {
-	const version = comparator.version && require_index.normalize(comparator.version);
+	const version = comparator.version && require_version_CQ98ZBpL.p(comparator.version);
 	if (version === null) throw new ReleaseCatalogCompilationError("INVALID_TARGET_RANGE", `Invalid comparator: ${comparator.value}`);
 	return version;
 }
@@ -81,7 +82,7 @@ function comparatorSetToInterval(comparators) {
 }
 function rangeToIntervals(range) {
 	try {
-		return require_index.parseRange(range).sets.flatMap((comparators) => {
+		return require_range_DvX_Y6iv.m(range).sets.flatMap((comparators) => {
 			const interval = comparatorSetToInterval(comparators);
 			return interval === null ? [] : [interval];
 		});
@@ -278,15 +279,16 @@ function compileAppVersion(releases) {
 	const retainedIds = new Set(segmentReleases.flatMap(({ retainedIds, rollbackIds }) => [...retainedIds, ...rollbackIds]));
 	const retainedReleases = releases.filter((release) => retainedIds.has(release.id));
 	const descriptorIndex = new Map(retainedReleases.map((release, index) => [release.id, index]));
+	const segments = mergeSegments(segmentReleases.map(({ segment, retainedIds, rollbackIds }) => ({
+		...segment,
+		releaseIndexes: releases.filter((release) => retainedIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0),
+		rollbackReleaseIndexes: releases.filter((release) => rollbackIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0)
+	})).filter((segment) => segment.releaseIndexes.length > 0 || segment.rollbackReleaseIndexes.length > 0));
 	return {
 		envelope: {
 			fallbackPolicy: _hot_updater_core.RELEASE_CATALOG_FALLBACK_POLICY,
 			schemaVersion: _hot_updater_core.RELEASE_CATALOG_SCHEMA_VERSION,
-			segments: mergeSegments(segmentReleases.map(({ segment, retainedIds, rollbackIds }) => ({
-				...segment,
-				releaseIndexes: releases.filter((release) => retainedIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0),
-				rollbackReleaseIndexes: releases.filter((release) => rollbackIds.has(release.id)).map((release) => descriptorIndex.get(release.id)).filter((index) => index !== void 0)
-			})).filter((segment) => segment.releaseIndexes.length > 0 || segment.rollbackReleaseIndexes.length > 0)),
+			segments,
 			strategy: "APP_VERSION"
 		},
 		retainedReleases
@@ -354,7 +356,8 @@ function versionInSegment(version, segment) {
 	return true;
 }
 function canonicalizeAppVersion(appVersion) {
-	return require_index.coerce(appVersion);
+	const version = require_version_CQ98ZBpL.n(appVersion);
+	return version ? require_version_CQ98ZBpL.m(version) : null;
 }
 function projectCompiledCatalog(catalog, appVersion) {
 	let indexes;
@@ -380,7 +383,7 @@ function projectCompiledRollbackCatalog(catalog, appVersion) {
 function referenceCompatibleReleases(releases, appVersion) {
 	const canonicalVersion = canonicalizeAppVersion(appVersion);
 	if (!canonicalVersion) return [];
-	return releases.filter((release) => release.enabled && release.targetAppVersion !== null && require_index.satisfies(canonicalVersion, release.targetAppVersion));
+	return releases.filter((release) => release.enabled && release.targetAppVersion !== null && require_range_DvX_Y6iv.f(canonicalVersion, release.targetAppVersion));
 }
 //#endregion
 exports.ReleaseCatalogCompilationError = ReleaseCatalogCompilationError;

package/dist/releaseCatalogCompiler.d.cts

@@ -1,5 +1,4 @@
 import { RELEASE_CATALOG_FALLBACK_POLICY, RELEASE_CATALOG_SCHEMA_VERSION, Release, ReleaseCatalogDescriptor, ReleaseStrategy } from "@hot-updater/core";
-
 //#region src/releaseCatalogCompiler.d.ts
 interface CatalogVersionBound {
   readonly version: string;