@askdkc/dsh-cli 0.11.3

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DSH Standard contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/README.md

@@ -0,0 +1,13 @@
+# @dsh-std/core
+
+English | [中文](README.zh.md)
+
+The minimal meta-protocol for protocol declarations, definition registration, and negotiation. See the [Core Meta-protocol proposal](../../docs/proposals/core.zh.md).
+
+Core understands only `apiVersion`, `kind`, participants, requirements, supports, protocol definitions, and their agreements. It does not prescribe resources, capabilities, providers, execution planes, locality, endpoints, or plugin lifecycle.
+
+A `ProtocolCatalog` belongs to an evaluator. Each protocol definition explicitly lists accepted API versions, validates requirement/support `spec` values, and owns its negotiation logic. Core neither infers compatibility from a shared major version nor treats an installed definition as a live implementation.
+
+`defineProtocolDeclaration()` validates and freezes the requirements and supports currently published by one participant. Static component bounds belong to `@dsh-std/manifest`, selection to `@dsh-std/composition`, activation and the publication barrier to `@dsh-std/lifecycle`, and cross-endpoint offers to `@dsh-std/connection`.
+
+Provider selection, multi-party merging, catalogs, invocation bindings, and UI semantics remain owned by their protocol definitions or domain packages.

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/README.zh.md

@@ -0,0 +1,13 @@
+# @dsh-std/core
+
+[English](README.md) | 中文
+
+协议声明、definition 注册与协商的最小元协议。设计见 [Core Meta-protocol](../../docs/proposals/core.zh.md)。
+
+Core 只认识 `apiVersion`、`kind`、participant、requirement、support、协议 definition 及其 agreement。它不预设 resource、capability、provider、execution plane、locality、endpoint 或插件生命周期。
+
+`ProtocolCatalog` 由评估器持有。每个协议 definition 明确列出接受的 API 版本，分别校验 requirement/support 的 `spec`，并拥有自己的协商逻辑。Core 不会从相同主版本推断兼容性，也不会把安装了一份 definition 当作已有 live implementation。
+
+`defineProtocolDeclaration()` 校验并冻结一个 participant 当前实际发布的 requirements 与 supports。静态组件上限属于 `@dsh-std/manifest`，选择属于 `@dsh-std/composition`，激活与 publication barrier 属于 `@dsh-std/lifecycle`，跨端点 offer 属于 `@dsh-std/connection`。
+
+协议专属的 provider 选择、多项合并、目录、调用绑定和 UI 语义均由相应 definition 或独立协议包定义。

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/lib/index.d.ts

@@ -0,0 +1,112 @@
+//#region src/protocol.d.ts
+/** Domain-neutral protocol identities and live participant declarations. */
+interface ApiReference {
+  readonly apiVersion: string;
+  readonly kind: string;
+}
+interface ParticipantIdentity {
+  /** Unique within the negotiation scope that carries this declaration. */
+  readonly id: string;
+}
+interface ProtocolRequirement<Spec = unknown> extends ApiReference {
+  readonly optional?: boolean;
+  readonly spec?: Spec;
+}
+interface ProtocolSupport<Spec = unknown> extends ApiReference {
+  readonly spec?: Spec;
+}
+interface ProtocolDeclaration {
+  readonly participant: ParticipantIdentity;
+  readonly requires?: readonly ProtocolRequirement[];
+  readonly supports?: readonly ProtocolSupport[];
+}
+interface ParsedApiVersion {
+  readonly group: string;
+  readonly major: number;
+  readonly stability: 'alpha' | 'beta' | 'stable';
+  readonly revision: number;
+}
+declare function protocolKey(reference: ApiReference): string;
+/** A grouping key only. It does not claim that versions in the family interoperate. */
+declare function protocolFamilyKey(reference: ApiReference): string;
+declare function sameProtocol(left: ApiReference, right: ApiReference): boolean;
+declare function parseApiVersion(value: string): ParsedApiVersion;
+declare function validateApiReference(value: unknown, label?: string): asserts value is ApiReference;
+declare function validateProtocolDeclaration(value: unknown): asserts value is ProtocolDeclaration;
+declare function defineProtocolDeclaration<const T extends ProtocolDeclaration>(declaration: T): T;
+//#endregion
+//#region src/negotiation.d.ts
+interface EvaluatorIdentity {
+  readonly name: string;
+  readonly version: string;
+}
+interface ProtocolRequirementEntry<Spec = unknown> {
+  readonly participant: string;
+  readonly requirement: ProtocolRequirement<Spec>;
+}
+interface ProtocolSupportEntry<Spec = unknown> {
+  readonly participant: string;
+  readonly support: ProtocolSupport<Spec>;
+}
+interface ProtocolIssue {
+  readonly code: string;
+  readonly severity: 'error' | 'warning';
+  readonly participant?: string;
+  readonly path?: string;
+  readonly message: string;
+}
+interface ProtocolNegotiationInput<RequirementSpec = unknown, SupportSpec = unknown, Policy = unknown> {
+  readonly requirements: readonly ProtocolRequirementEntry<RequirementSpec>[];
+  readonly supports: readonly ProtocolSupportEntry<SupportSpec>[];
+  readonly policy?: Policy;
+}
+interface ProtocolNegotiationOutcome<Agreement = unknown> {
+  readonly agreement?: Agreement;
+  readonly issues?: readonly ProtocolIssue[];
+}
+interface ProtocolDefinition<RequirementSpec = unknown, SupportSpec = unknown, Agreement = unknown, Policy = unknown> extends ApiReference {
+  /** Every accepted wire/static API version. No compatibility is inferred by core. */
+  readonly accepts?: readonly string[];
+  validateRequirement(spec: unknown): RequirementSpec;
+  validateSupport(spec: unknown): SupportSpec;
+  negotiate(input: ProtocolNegotiationInput<RequirementSpec, SupportSpec, Policy>): ProtocolNegotiationOutcome<Agreement>;
+}
+interface NegotiatedProtocol<Agreement = unknown> extends ApiReference {
+  readonly participants: readonly string[];
+  readonly agreement?: Agreement;
+  readonly issues: readonly ProtocolIssue[];
+}
+interface NegotiationReport {
+  readonly apiVersion: 'core.dsh/report/v1alpha1';
+  readonly evaluator: EvaluatorIdentity;
+  readonly compatible: boolean;
+  readonly protocols: readonly NegotiatedProtocol[];
+  readonly issues: readonly ProtocolIssue[];
+}
+declare class ProtocolCatalog {
+  readonly evaluator: EvaluatorIdentity;
+  private readonly definitions;
+  constructor(evaluator: EvaluatorIdentity);
+  register(definition: ProtocolDefinition): () => void;
+  list(): readonly ProtocolDefinition[];
+  resolve(reference: ApiReference): ProtocolDefinition | undefined;
+  understands(reference: ApiReference): boolean;
+  negotiate(declarations: readonly ProtocolDeclaration[], policy?: unknown): NegotiationReport;
+}
+//#endregion
+//#region src/version.d.ts
+interface SemanticVersion {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+  readonly prerelease: readonly (string | number)[];
+  readonly build: readonly string[];
+}
+type VersionRange = string | readonly string[];
+declare function parseSemanticVersion(value: string): SemanticVersion;
+declare function compareSemanticVersions(leftValue: string | SemanticVersion, rightValue: string | SemanticVersion): number;
+declare function assertVersionRange(range: VersionRange): void;
+declare function satisfiesVersionRange(versionValue: string, range: VersionRange): boolean;
+//#endregion
+export { ApiReference, EvaluatorIdentity, NegotiatedProtocol, NegotiationReport, ParsedApiVersion, ParticipantIdentity, ProtocolCatalog, ProtocolDeclaration, ProtocolDefinition, ProtocolIssue, ProtocolNegotiationInput, ProtocolNegotiationOutcome, ProtocolRequirement, ProtocolRequirementEntry, ProtocolSupport, ProtocolSupportEntry, SemanticVersion, VersionRange, assertVersionRange, compareSemanticVersions, defineProtocolDeclaration, parseApiVersion, parseSemanticVersion, protocolFamilyKey, protocolKey, sameProtocol, satisfiesVersionRange, validateApiReference, validateProtocolDeclaration };
+//# sourceMappingURL=index.d.ts.map

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/protocol.ts","../src/negotiation.ts","../src/version.ts"],"mappings":";;UAEiB;WACN;WACA;;UAGM;;WAEN;;UAGM,oBAAoB,wBAAwB;WAClD;WACA,OAAO;;UAGD,gBAAgB,wBAAwB;WAC9C,OAAO;;UAGD;WACN,aAAa;WACb,oBAAoB;WACpB,oBAAoB;;UAGd;WACN;WACA;WACA;WACA;;iBAGK,YAAY,WAAW;;iBAKvB,kBAAkB,WAAW;iBAK7B,aAAa,MAAM,cAAc,OAAO;iBAIxC,gBAAgB,gBAAgB;iBAWhC,qBAAqB,gBAAgB,yBAAuC,SAAS;iBASrF,4BAA4B,yBAAyB,SAAS;iBAU9D,gCAAgC,UAAU,qBAAqB,aAAa,IAAI;;;UCpE/E;WACN;WACA;;UAGM,yBAAyB;WAC/B;WACA,aAAa,oBAAoB;;UAG3B,qBAAqB;WAC3B;WACA,SAAS,gBAAgB;;UAGnB;WACN;WACA;WACA;WACA;WACA;;UAGM,yBAAyB,2BAA2B,uBAAuB;WACjF,uBAAuB,yBAAyB;WAChD,mBAAmB,qBAAqB;WACxC,SAAS;;UAGH,2BAA2B;WACjC,YAAY;WACZ,kBAAkB;;UAGZ,mBAAmB,2BAA2B,uBAAuB,qBAAqB,0BACjG;;WAEC;EACT,oBAAoB,gBAAgB;EACpC,gBAAgB,gBAAgB;EAChC,UACE,OAAO,yBAAyB,iBAAiB,aAAa,UAC7D,2BAA2B;;UAGf,mBAAmB,6BAA6B;WACtD;WACA,YAAY;WACZ,iBAAiB;;UAGX;WACN;WACA,WAAW;WACX;WACA,oBAAoB;WACpB,iBAAiB;;cAQf;WAGU,WAAW;mBAFf;EAEI,YAAA,WAAW;EAKhC,SAAS,YAAY;EAmBrB,iBAAiB;EAIjB,QAAQ,WAAW,eAAe;EAKlC,YAAY,WAAW;EAIvB,UAAU,uBAAuB,uBAAuB,mBAAmB;;;;UClH5D;WACN;WACA;WACA;WACA;WACA;;KAGC;iBAEI,qBAAqB,gBAAgB;iBAerC,wBAAwB,oBAAoB,iBAAiB,qBAAqB;iBASlF,mBAAmB,OAAO;iBAI1B,sBAAsB,sBAAsB,OAAO"}

package/vendor/dsh-std/packages/messages/node_modules/@dsh-std/core/lib/index.js

@@ -0,0 +1,424 @@
+//#region src/protocol.ts
+function protocolKey(reference) {
+	return `${reference.apiVersion}\0${reference.kind}`;
+}
+/** A grouping key only. It does not claim that versions in the family interoperate. */
+function protocolFamilyKey(reference) {
+	const version = parseApiVersion(reference.apiVersion);
+	return `${version.group}/v${version.major}\0${reference.kind}`;
+}
+function sameProtocol(left, right) {
+	return left.apiVersion === right.apiVersion && left.kind === right.kind;
+}
+function parseApiVersion(value) {
+	const match = /^([a-z][a-z0-9.-]*)\/v([1-9][0-9]*)(?:(alpha|beta)([1-9][0-9]*))?$/u.exec(value);
+	if (match === null) throw new TypeError(`invalid apiVersion ${JSON.stringify(value)}`);
+	return Object.freeze({
+		group: match[1],
+		major: Number(match[2]),
+		stability: match[3] ?? "stable",
+		revision: match[4] === void 0 ? 0 : Number(match[4])
+	});
+}
+function validateApiReference(value, label = "protocol reference") {
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	if (typeof value.apiVersion !== "string") throw new TypeError(`${label}.apiVersion must be a string`);
+	parseApiVersion(value.apiVersion);
+	if (typeof value.kind !== "string" || !/^[A-Z][A-Za-z0-9]*$/u.test(value.kind)) throw new TypeError(`${label}.kind is invalid`);
+}
+function validateProtocolDeclaration(value) {
+	if (!record(value)) throw new TypeError("protocol declaration must be an object");
+	exact(value, [
+		"participant",
+		"requires",
+		"supports"
+	], "protocol declaration");
+	if (!record(value.participant)) throw new TypeError("protocol declaration participant must be an object");
+	exact(value.participant, ["id"], "participant identity");
+	nonEmpty$1(value.participant.id, "participant identity.id");
+	validateRows(value.requires, true);
+	validateRows(value.supports, false);
+}
+function defineProtocolDeclaration(declaration) {
+	validateProtocolDeclaration(declaration);
+	return deepFreeze(structuredClone(declaration));
+}
+function validateRows(value, requirement) {
+	if (value === void 0) return;
+	const label = requirement ? "protocol requirements" : "protocol supports";
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, rowValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		validateApiReference(rowValue, rowLabel);
+		const row = rowValue;
+		exact(row, requirement ? [
+			"apiVersion",
+			"kind",
+			"optional",
+			"spec"
+		] : [
+			"apiVersion",
+			"kind",
+			"spec"
+		], rowLabel);
+		if (requirement && row.optional !== void 0 && typeof row.optional !== "boolean") throw new TypeError(`${rowLabel}.optional must be boolean`);
+		const key = protocolKey(row);
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function nonEmpty$1(value, label) {
+	if (typeof value !== "string" || value.trim() === "") throw new TypeError(`${label} must be a non-empty string`);
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exact(value, allowed, label) {
+	const unknown = Object.keys(value).filter((key) => !allowed.includes(key) && !key.startsWith("x-"));
+	if (unknown.length > 0) throw new TypeError(`${label} contains unknown field ${JSON.stringify(unknown[0])}`);
+}
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	Object.freeze(value);
+	for (const child of Object.values(value)) deepFreeze(child);
+	return value;
+}
+//#endregion
+//#region src/negotiation.ts
+var ProtocolCatalog = class {
+	evaluator;
+	definitions = /* @__PURE__ */ new Map();
+	constructor(evaluator) {
+		this.evaluator = evaluator;
+		nonEmpty(evaluator.name, "evaluator.name");
+		nonEmpty(evaluator.version, "evaluator.version");
+	}
+	register(definition) {
+		validateDefinition(definition);
+		const accepted = /* @__PURE__ */ new Set([definition.apiVersion, ...definition.accepts ?? []]);
+		for (const version of accepted) {
+			const key = protocolKey({
+				apiVersion: version,
+				kind: definition.kind
+			});
+			if (this.definitions.has(key)) throw new Error(`protocol definition for ${version} ${definition.kind} is already registered`);
+		}
+		const stored = Object.freeze({
+			definition: freezeDefinition(definition),
+			accepted: new Set(accepted)
+		});
+		for (const version of accepted) this.definitions.set(protocolKey({
+			apiVersion: version,
+			kind: definition.kind
+		}), stored);
+		return () => {
+			for (const version of accepted) {
+				const key = protocolKey({
+					apiVersion: version,
+					kind: definition.kind
+				});
+				if (this.definitions.get(key) === stored) this.definitions.delete(key);
+			}
+		};
+	}
+	list() {
+		return Object.freeze([...new Set([...this.definitions.values()].map((row) => row.definition))]);
+	}
+	resolve(reference) {
+		validateApiReference(reference);
+		return this.definitions.get(protocolKey(reference))?.definition;
+	}
+	understands(reference) {
+		return this.resolve(reference) !== void 0;
+	}
+	negotiate(declarations, policy) {
+		const participantIds = /* @__PURE__ */ new Set();
+		for (const declaration of declarations) {
+			validateProtocolDeclaration(declaration);
+			if (participantIds.has(declaration.participant.id)) throw new TypeError(`duplicate participant identity ${JSON.stringify(declaration.participant.id)}`);
+			participantIds.add(declaration.participant.id);
+		}
+		const groups = /* @__PURE__ */ new Map();
+		const issues = [];
+		for (const [declarationIndex, declaration] of declarations.entries()) {
+			for (const [index, requirement] of (declaration.requires ?? []).entries()) {
+				const stored = this.definitions.get(protocolKey(requirement));
+				if (stored === void 0) {
+					issues.push(freezeIssue({
+						code: "definition-unavailable",
+						severity: requirement.optional === true ? "warning" : "error",
+						participant: declaration.participant.id,
+						path: `/declarations/${declarationIndex}/requires/${index}`,
+						message: `no definition recognizes ${requirement.apiVersion} ${requirement.kind}`
+					}));
+					continue;
+				}
+				const group = groups.get(stored) ?? {
+					requirements: [],
+					supports: []
+				};
+				try {
+					group.requirements.push(Object.freeze({
+						participant: declaration.participant.id,
+						requirement: Object.freeze({
+							...requirement,
+							...Object.hasOwn(requirement, "spec") ? { spec: stored.definition.validateRequirement(requirement.spec) } : { spec: stored.definition.validateRequirement(void 0) }
+						})
+					}));
+				} catch (error) {
+					issues.push(freezeIssue({
+						code: "invalid-requirement",
+						severity: "error",
+						participant: declaration.participant.id,
+						path: `/declarations/${declarationIndex}/requires/${index}/spec`,
+						message: errorMessage(error)
+					}));
+				}
+				groups.set(stored, group);
+			}
+			for (const [index, support] of (declaration.supports ?? []).entries()) {
+				const stored = this.definitions.get(protocolKey(support));
+				if (stored === void 0) {
+					issues.push(freezeIssue({
+						code: "definition-unavailable",
+						severity: "warning",
+						participant: declaration.participant.id,
+						path: `/declarations/${declarationIndex}/supports/${index}`,
+						message: `no definition recognizes ${support.apiVersion} ${support.kind}`
+					}));
+					continue;
+				}
+				const group = groups.get(stored) ?? {
+					requirements: [],
+					supports: []
+				};
+				try {
+					group.supports.push(Object.freeze({
+						participant: declaration.participant.id,
+						support: Object.freeze({
+							...support,
+							...Object.hasOwn(support, "spec") ? { spec: stored.definition.validateSupport(support.spec) } : { spec: stored.definition.validateSupport(void 0) }
+						})
+					}));
+				} catch (error) {
+					issues.push(freezeIssue({
+						code: "invalid-support",
+						severity: "error",
+						participant: declaration.participant.id,
+						path: `/declarations/${declarationIndex}/supports/${index}/spec`,
+						message: errorMessage(error)
+					}));
+				}
+				groups.set(stored, group);
+			}
+		}
+		const protocols = [];
+		for (const stored of [...groups.keys()].sort((left, right) => protocolKey(left.definition).localeCompare(protocolKey(right.definition)))) {
+			const group = groups.get(stored);
+			let outcome;
+			try {
+				outcome = stored.definition.negotiate(Object.freeze({
+					requirements: Object.freeze([...group.requirements]),
+					supports: Object.freeze([...group.supports]),
+					...policy === void 0 ? {} : { policy }
+				}));
+			} catch (error) {
+				outcome = { issues: [{
+					code: "definition-failed",
+					severity: "error",
+					message: errorMessage(error)
+				}] };
+			}
+			const protocolIssues = Object.freeze((outcome.issues ?? []).map(freezeIssue));
+			issues.push(...protocolIssues);
+			protocols.push(Object.freeze({
+				apiVersion: stored.definition.apiVersion,
+				kind: stored.definition.kind,
+				participants: Object.freeze([.../* @__PURE__ */ new Set([...group.requirements.map((row) => row.participant), ...group.supports.map((row) => row.participant)])].sort()),
+				...Object.hasOwn(outcome, "agreement") ? { agreement: outcome.agreement } : {},
+				issues: protocolIssues
+			}));
+		}
+		return Object.freeze({
+			apiVersion: "core.dsh/report/v1alpha1",
+			evaluator: Object.freeze({ ...this.evaluator }),
+			compatible: !issues.some((issue) => issue.severity === "error"),
+			protocols: Object.freeze(protocols),
+			issues: Object.freeze(issues)
+		});
+	}
+};
+function validateDefinition(definition) {
+	validateApiReference(definition, "protocol definition");
+	if (typeof definition.validateRequirement !== "function" || typeof definition.validateSupport !== "function" || typeof definition.negotiate !== "function") throw new TypeError("protocol definition must provide validators and negotiate");
+	const versions = [definition.apiVersion, ...definition.accepts ?? []];
+	if (new Set(versions).size !== versions.length) throw new TypeError("protocol definition accepts duplicate versions");
+	for (const version of versions) validateApiReference({
+		apiVersion: version,
+		kind: definition.kind
+	});
+}
+function freezeDefinition(definition) {
+	return Object.freeze({
+		...definition,
+		...definition.accepts === void 0 ? {} : { accepts: Object.freeze([...definition.accepts]) }
+	});
+}
+function freezeIssue(issue) {
+	if (issue.severity !== "error" && issue.severity !== "warning") throw new TypeError("protocol issue severity is invalid");
+	nonEmpty(issue.code, "protocol issue.code");
+	nonEmpty(issue.message, "protocol issue.message");
+	return Object.freeze({ ...issue });
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim() === "") throw new TypeError(`${label} must be a non-empty string`);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/version.ts
+function parseSemanticVersion(value) {
+	const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u.exec(value);
+	if (match === null) throw new TypeError(`invalid semantic version ${JSON.stringify(value)}`);
+	const prerelease = match[4] === void 0 ? [] : match[4].split(".").map((identifier) => {
+		if (!/^\d+$/u.test(identifier)) return identifier;
+		if (identifier.length > 1 && identifier.startsWith("0")) throw new TypeError(`invalid semantic version ${JSON.stringify(value)}`);
+		return Number(identifier);
+	});
+	return Object.freeze({
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: Object.freeze(prerelease),
+		build: Object.freeze(match[5] === void 0 ? [] : match[5].split("."))
+	});
+}
+function compareSemanticVersions(leftValue, rightValue) {
+	const left = typeof leftValue === "string" ? parseSemanticVersion(leftValue) : leftValue;
+	const right = typeof rightValue === "string" ? parseSemanticVersion(rightValue) : rightValue;
+	return left.major - right.major || left.minor - right.minor || left.patch - right.patch || comparePrerelease(left.prerelease, right.prerelease);
+}
+function assertVersionRange(range) {
+	compileRange(range);
+}
+function satisfiesVersionRange(versionValue, range) {
+	const version = parseSemanticVersion(versionValue);
+	return compileRange(range).some((group) => {
+		if (version.prerelease.length > 0 && !group.explicitPrereleases.has(coreKey(version))) return false;
+		return group.predicates.every((predicate) => predicate(version));
+	});
+}
+function compileRange(range) {
+	const values = typeof range === "string" ? [range] : range;
+	if (!Array.isArray(values) || values.length === 0) throw new TypeError("version range must be a string or non-empty array");
+	return Object.freeze(values.flatMap((value) => {
+		if (typeof value !== "string" || value.trim() === "") throw new TypeError("version range must not be empty");
+		return value.split("||").map((part) => compileGroup(part.trim()));
+	}));
+}
+function compileGroup(value) {
+	if (value === "") throw new TypeError("version range contains an empty alternative");
+	if (value === "*" || /^x$/iu.test(value)) return {
+		predicates: [],
+		explicitPrereleases: /* @__PURE__ */ new Set()
+	};
+	const predicates = [];
+	const explicitPrereleases = /* @__PURE__ */ new Set();
+	for (const token of value.split(/\s+/u)) {
+		const parsed = compileComparator(token);
+		predicates.push(...parsed.predicates);
+		if (parsed.explicitPrerelease !== void 0) explicitPrereleases.add(parsed.explicitPrerelease);
+	}
+	return Object.freeze({
+		predicates: Object.freeze(predicates),
+		explicitPrereleases
+	});
+}
+function compileComparator(token) {
+	const match = /^(<=|>=|<|>|=|\^|~)?(.+)$/u.exec(token);
+	if (match === null) throw new TypeError(`invalid version comparator ${JSON.stringify(token)}`);
+	const operator = match[1] ?? "=";
+	const body = match[2];
+	const partial = /^(0|[1-9]\d*|[xX*])(?:\.(0|[1-9]\d*|[xX*]))?(?:\.(0|[1-9]\d*|[xX*]))?$/u.exec(body);
+	if (partial !== null && (partial[2] === void 0 || partial[3] === void 0 || [
+		partial[1],
+		partial[2],
+		partial[3]
+	].some(wild))) {
+		if (operator !== "=") {
+			if ((operator === "~" || operator === "^") && ![partial[1], partial[2]].some(wild)) {
+				const lower = version(Number(partial[1]), Number(partial[2]), partial[3] === void 0 || wild(partial[3]) ? 0 : Number(partial[3]));
+				return bounded(lower, operator === "~" ? version(lower.major, lower.minor + 1, 0) : caretUpper(lower));
+			}
+			throw new TypeError(`partial version cannot use ${JSON.stringify(operator)}`);
+		}
+		return wildcardRange(partial);
+	}
+	const target = parseSemanticVersion(body);
+	const explicitPrerelease = target.prerelease.length === 0 ? void 0 : coreKey(target);
+	if (operator === "^") return {
+		...bounded(target, caretUpper(target)),
+		...explicitPrerelease === void 0 ? {} : { explicitPrerelease }
+	};
+	if (operator === "~") return {
+		...bounded(target, version(target.major, target.minor + 1, 0)),
+		...explicitPrerelease === void 0 ? {} : { explicitPrerelease }
+	};
+	const comparison = (candidate) => compareSemanticVersions(candidate, target);
+	return {
+		predicates: [operator === "=" ? (candidate) => comparison(candidate) === 0 : operator === "<" ? (candidate) => comparison(candidate) < 0 : operator === "<=" ? (candidate) => comparison(candidate) <= 0 : operator === ">" ? (candidate) => comparison(candidate) > 0 : (candidate) => comparison(candidate) >= 0],
+		...explicitPrerelease === void 0 ? {} : { explicitPrerelease }
+	};
+}
+function wildcardRange(match) {
+	if (wild(match[1])) return { predicates: [] };
+	const major = Number(match[1]);
+	if (match[2] === void 0 || wild(match[2])) return bounded(version(major, 0, 0), version(major + 1, 0, 0));
+	const minor = Number(match[2]);
+	if (match[3] === void 0 || wild(match[3])) return bounded(version(major, minor, 0), version(major, minor + 1, 0));
+	throw new TypeError("unreachable complete version range");
+}
+function bounded(lower, upper) {
+	return { predicates: [(candidate) => compareSemanticVersions(candidate, lower) >= 0, (candidate) => compareSemanticVersions(candidate, upper) < 0] };
+}
+function caretUpper(lower) {
+	if (lower.major > 0) return version(lower.major + 1, 0, 0);
+	if (lower.minor > 0) return version(0, lower.minor + 1, 0);
+	return version(0, 0, lower.patch + 1);
+}
+function version(major, minor, patch) {
+	return {
+		major,
+		minor,
+		patch,
+		prerelease: [],
+		build: []
+	};
+}
+function wild(value) {
+	return value === "*" || /^x$/iu.test(value ?? "");
+}
+function coreKey(value) {
+	return `${value.major}.${value.minor}.${value.patch}`;
+}
+function comparePrerelease(left, right) {
+	if (left.length === 0) return right.length === 0 ? 0 : 1;
+	if (right.length === 0) return -1;
+	for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+		const leftPart = left[index];
+		const rightPart = right[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		if (leftPart === rightPart) continue;
+		if (typeof leftPart === "number" && typeof rightPart === "string") return -1;
+		if (typeof leftPart === "string" && typeof rightPart === "number") return 1;
+		return leftPart < rightPart ? -1 : 1;
+	}
+	return 0;
+}
+//#endregion
+export { ProtocolCatalog, assertVersionRange, compareSemanticVersions, defineProtocolDeclaration, parseApiVersion, parseSemanticVersion, protocolFamilyKey, protocolKey, sameProtocol, satisfiesVersionRange, validateApiReference, validateProtocolDeclaration };
+
+//# sourceMappingURL=index.js.map