correctly 0.0.0 → 0.1.0

package/dist/engine-BgWBnb1A.mjs

@@ -1,746 +0,0 @@
-import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Ajv } from "ajv";
-import picomatch from "picomatch";
-import { findNodeAtLocation, getNodePath, getNodeValue, parseTree, printParseErrorCode } from "jsonc-parser";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import addFormats from "ajv-formats";
-import { createHash, randomUUID } from "node:crypto";
-//#region src/core/config.schema.json
-var config_schema_default = {
-	$schema: "http://json-schema.org/draft-07/schema#",
-	type: "object",
-	additionalProperties: false,
-	required: ["associations"],
-	properties: {
-		"$schema": { "type": "string" },
-		"files": { "$ref": "#/definitions/patterns" },
-		"exclude": { "$ref": "#/definitions/patterns" },
-		"associations": {
-			"type": "array",
-			"items": {
-				"type": "object",
-				"additionalProperties": false,
-				"required": ["files", "schema"],
-				"properties": {
-					"name": {
-						"type": "string",
-						"minLength": 1
-					},
-					"files": { "$ref": "#/definitions/patterns" },
-					"schema": {
-						"type": ["string", "null"],
-						"minLength": 1
-					},
-					"mode": { "enum": ["json", "jsonc"] }
-				}
-			}
-		},
-		"remote": {
-			"type": "object",
-			"additionalProperties": false,
-			"properties": {
-				"offline": { "type": "boolean" },
-				"cacheDir": {
-					"type": "string",
-					"minLength": 1
-				},
-				"timeoutMs": {
-					"type": "integer",
-					"minimum": 1,
-					"maximum": 6e4
-				},
-				"maxBytes": {
-					"type": "integer",
-					"minimum": 1,
-					"maximum": 16777216
-				},
-				"maxRequests": {
-					"type": "integer",
-					"minimum": 1,
-					"maximum": 256
-				}
-			}
-		}
-	},
-	definitions: { "patterns": {
-		"type": "array",
-		"minItems": 1,
-		"items": {
-			"type": "string",
-			"minLength": 1,
-			"pattern": "^(?![/!])(?![A-Za-z]:)(?!.*(?:^|/)\\.\\.(?:/|$)).+"
-		}
-	} }
-};
-//#endregion
-//#region src/core/parse.ts
-function pointer(parts) {
-	return parts.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
-}
-function positionAt(text, offset) {
-	const end = Math.min(Math.max(0, offset), text.length);
-	let line = 0;
-	let start = 0;
-	for (let i = 0; i < end; i++) if (text[i] === "\r") {
-		if (text[i + 1] === "\n" && i + 1 < end) i++;
-		line++;
-		start = i + 1;
-	} else if (text[i] === "\n") {
-		line++;
-		start = i + 1;
-	}
-	return {
-		line,
-		character: end - start
-	};
-}
-function diagnostic(text, code, message, jsonPointer = "", offset = 0, length = 1) {
-	const start = Math.min(offset, text.length);
-	const size = Math.min(Math.max(1, length), text.length - start);
-	return {
-		code,
-		message,
-		pointer: jsonPointer,
-		offset: start,
-		length: size,
-		range: {
-			start: positionAt(text, start),
-			end: positionAt(text, start + size)
-		}
-	};
-}
-function parseDocument(text, mode) {
-	const errors = [];
-	const root = parseTree(text, errors, {
-		disallowComments: mode === "json",
-		allowTrailingComma: mode === "jsonc",
-		allowEmptyContent: false
-	});
-	const diagnostics = errors.map((e) => diagnostic(text, "syntax", printParseErrorCode(e.error), "", e.offset, e.length));
-	function visit(node) {
-		if (node.type === "object") {
-			const keys = /* @__PURE__ */ new Set();
-			for (const property of node.children ?? []) {
-				const key = property.children?.[0];
-				if (!key || typeof key.value !== "string") continue;
-				if (keys.has(key.value)) diagnostics.push(diagnostic(text, "duplicate-key", `Duplicate key ${JSON.stringify(key.value)}`, pointer([...getNodePath(node), key.value]), key.offset, key.length));
-				keys.add(key.value);
-			}
-		}
-		if (node.type === "number" && !Number.isFinite(node.value)) diagnostics.push(diagnostic(text, "syntax", "Number exceeds the supported finite range", pointer(getNodePath(node)), node.offset, node.length));
-		for (const child of node.children ?? []) visit(child);
-	}
-	if (root) visit(root);
-	function value(node) {
-		if (node.type === "object") return Object.fromEntries((node.children ?? []).flatMap((property) => {
-			const key = property.children?.[0];
-			const child = property.children?.[1];
-			return key && child ? [[String(key.value), value(child)]] : [];
-		}));
-		if (node.type === "array") return (node.children ?? []).map(value);
-		return getNodeValue(node);
-	}
-	return {
-		root,
-		value: root ? value(root) : void 0,
-		diagnostics,
-		locate: (jsonPointer, key = false) => {
-			const node = locate(root, jsonPointer, key);
-			return node ? {
-				offset: node.offset,
-				length: node.length
-			} : void 0;
-		}
-	};
-}
-function locate(root, jsonPointer, key = false) {
-	if (!root) return void 0;
-	const parts = jsonPointer === "" ? [] : jsonPointer.slice(1).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
-	let current = root;
-	for (const part of parts) {
-		const next = findNodeAtLocation(current, [current.type === "array" ? Number(part) : part]);
-		if (!next) break;
-		current = next;
-	}
-	return key && current.parent?.type === "property" ? current.parent.children?.[0] ?? current : current;
-}
-//#endregion
-//#region src/core/types.ts
-var CorrectlyError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.name = "CorrectlyError";
-		this.code = code;
-	}
-};
-function failure(error, file) {
-	return {
-		code: error instanceof CorrectlyError ? error.code : "execution",
-		message: error instanceof Error ? error.message : String(error),
-		...file === void 0 ? {} : { file }
-	};
-}
-//#endregion
-//#region src/core/config.ts
-const CONFIG_NAME = "correctly.config.json";
-const DEFAULT_EXCLUDES = [
-	"**/node_modules/**",
-	"**/.git/**",
-	"**/dist/**",
-	"**/artifacts/**",
-	"**/.correctly-cache/**"
-];
-const readText = (uri) => readFile(fileURLToPath(uri), "utf8");
-const validateConfig = new Ajv({
-	allErrors: true,
-	strict: true
-}).compile(config_schema_default);
-function contains(root, file) {
-	const relative = path.relative(root, file);
-	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
-async function discoverConfig(start, boundary, virtualFiles = /* @__PURE__ */ new Set()) {
-	let directory = path.resolve(start);
-	if (boundary && !contains(boundary, directory)) throw new CorrectlyError("config", `Path is outside workspace ${boundary}`);
-	while (true) {
-		const candidate = path.join(directory, CONFIG_NAME);
-		if (virtualFiles.has(candidate)) return candidate;
-		try {
-			if ((await stat(candidate)).isFile()) return candidate;
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-		}
-		const parent = path.dirname(directory);
-		if (directory === boundary || parent === directory) break;
-		directory = parent;
-	}
-	throw new CorrectlyError("config", `No ${CONFIG_NAME} found from ${start}${boundary ? ` within ${boundary}` : ""}`);
-}
-async function loadProject(configPath, read = readText) {
-	const resolved = path.resolve(configPath);
-	let text;
-	try {
-		text = await read(pathToFileURL(resolved).href);
-	} catch (error) {
-		throw new CorrectlyError("config", `Cannot read configuration ${resolved}: ${String(error)}`);
-	}
-	const parsed = parseDocument(text, "json");
-	if (parsed.diagnostics.length) {
-		const d = parsed.diagnostics[0];
-		throw new CorrectlyError("config", `${resolved}:${d.range.start.line + 1}:${d.range.start.character + 1}: ${d.message}`);
-	}
-	if (!validateConfig(parsed.value)) throw new CorrectlyError("config", `${resolved}: ${validateConfig.errors?.map((e) => `${e.instancePath || "/"} ${e.message}`).join("; ")}`);
-	const config = parsed.value;
-	for (const pattern of [
-		...config.files ?? [],
-		...config.exclude ?? [],
-		...config.associations.flatMap((a) => a.files)
-	]) if (pattern.includes("\\")) throw new CorrectlyError("config", `Use forward slashes in patterns: ${pattern}`);
-	return {
-		configPath: resolved,
-		root: path.dirname(resolved),
-		config
-	};
-}
-function schemaUri(value, root) {
-	if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(value) && !/^[A-Za-z]:[\\/]/.test(value)) {
-		const uri = new URL(value);
-		if (![
-			"file:",
-			"http:",
-			"https:"
-		].includes(uri.protocol)) throw new CorrectlyError("schema", `Unsupported schema protocol: ${uri.protocol}`);
-		return uri.href;
-	}
-	const hash = value.indexOf("#");
-	const filename = hash === -1 ? value : value.slice(0, hash);
-	const uri = pathToFileURL(path.resolve(root, filename));
-	if (hash !== -1) uri.hash = value.slice(hash + 1);
-	return uri.href;
-}
-function exclusions(project) {
-	const cachePath = path.resolve(project.root, project.config.remote?.cacheDir ?? ".correctly-cache");
-	const relative = path.relative(project.root, cachePath).split(path.sep).join("/");
-	return [
-		...DEFAULT_EXCLUDES,
-		...project.config.exclude ?? [],
-		...relative && contains(project.root, cachePath) ? [`${relative}/**`] : []
-	];
-}
-function isIncluded(project, file) {
-	if (!contains(project.root, file)) return false;
-	const relative = path.relative(project.root, file).split(path.sep).join("/");
-	const options = { dot: true };
-	return picomatch(project.config.files ?? ["**/*.json", "**/*.jsonc"], options)(relative) && !picomatch(exclusions(project), options)(relative);
-}
-function associationFor(project, file) {
-	const relative = path.relative(project.root, file).split(path.sep).join("/");
-	for (let index = project.config.associations.length - 1; index >= 0; index--) {
-		const rule = project.config.associations[index];
-		if (picomatch(rule.files, { dot: true })(relative)) return {
-			index,
-			name: rule.name ?? `association ${index + 1}`,
-			schema: rule.schema === null ? null : schemaUri(rule.schema, project.root),
-			mode: rule.mode ?? modeFor(file)
-		};
-	}
-	return null;
-}
-function modeFor(file) {
-	return path.extname(file).toLowerCase() === ".jsonc" ? "jsonc" : "json";
-}
-//#endregion
-//#region src/core/schemas.ts
-const DIALECTS = {
-	draft7: "http://json-schema.org/draft-07/schema#",
-	"2020-12": "https://json-schema.org/draft/2020-12/schema"
-};
-const VOCABULARIES = new Set([
-	"core",
-	"applicator",
-	"unevaluated",
-	"validation",
-	"meta-data",
-	"format-annotation",
-	"content"
-].map((name) => `https://json-schema.org/draft/2020-12/vocab/${name}`));
-const SINGLE_SCHEMAS = [
-	"additionalItems",
-	"additionalProperties",
-	"contains",
-	"propertyNames",
-	"not",
-	"if",
-	"then",
-	"else",
-	"unevaluatedProperties",
-	"unevaluatedItems",
-	"contentSchema"
-];
-const MAP_SCHEMAS = [
-	"properties",
-	"patternProperties",
-	"definitions",
-	"$defs",
-	"dependentSchemas",
-	"dependencies"
-];
-const ARRAY_SCHEMAS = [
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-];
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function dialect(value, inherited) {
-	if (value === void 0) return inherited;
-	if (typeof value !== "string") throw new CorrectlyError("schema", "Schema $schema must be a string");
-	const id = value.replace(/#$/, "");
-	if (id === "http://json-schema.org/draft-07/schema" || id === "https://json-schema.org/draft-07/schema") return "draft7";
-	if (id === DIALECTS["2020-12"]) return "2020-12";
-	throw new CorrectlyError("unsupported-dialect", `Unsupported schema dialect: ${value}; supported: draft 7, draft 2020-12`);
-}
-var SchemaStore = class {
-	options;
-	resources = /* @__PURE__ */ new Map();
-	pending = /* @__PURE__ */ new Map();
-	cacheDir;
-	offline;
-	timeoutMs;
-	maxBytes;
-	maxRequests;
-	read;
-	request;
-	requests = 0;
-	constructor(project, options = {}) {
-		this.options = options;
-		const remote = project.config.remote;
-		this.cacheDir = path.resolve(project.root, remote?.cacheDir ?? ".correctly-cache");
-		this.offline = options.offline ?? remote?.offline ?? false;
-		this.timeoutMs = remote?.timeoutMs ?? 5e3;
-		this.maxBytes = remote?.maxBytes ?? 2097152;
-		this.maxRequests = remote?.maxRequests ?? 64;
-		this.read = options.read ?? readText;
-		this.request = options.fetch ?? fetch;
-	}
-	async load(value, inherited = "draft7") {
-		this.options.signal?.throwIfAborted();
-		const url = new URL(value);
-		url.hash = "";
-		const uri = url.href;
-		const known = this.resources.get(uri);
-		if (known) return known;
-		let promise = this.pending.get(uri);
-		if (!promise) {
-			promise = this.loadResource(uri, inherited);
-			this.pending.set(uri, promise);
-		}
-		return promise;
-	}
-	async loadResource(uri, inherited) {
-		if (++this.requests > this.maxRequests) throw new CorrectlyError("schema-limit", `Schema resource limit (${this.maxRequests}) exceeded`);
-		let text;
-		const url = new URL(uri);
-		try {
-			if (url.protocol === "file:") text = await this.read(uri);
-			else if (url.protocol === "https:" || url.protocol === "http:") text = await this.remote(uri);
-			else throw new CorrectlyError("schema", `Unsupported schema protocol: ${url.protocol}`);
-		} catch (error) {
-			if (error instanceof CorrectlyError) throw error;
-			throw new CorrectlyError("schema-load", `Cannot load schema ${uri}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		this.options.signal?.throwIfAborted();
-		if (Buffer.byteLength(text) > this.maxBytes) throw new CorrectlyError("schema-limit", `Schema ${uri} exceeds ${this.maxBytes} bytes`);
-		const parsed = parseDocument(text, "json");
-		if (parsed.diagnostics.length) {
-			const d = parsed.diagnostics[0];
-			throw new CorrectlyError("schema", `Invalid schema JSON at ${uri}:${d.range.start.line + 1}:${d.range.start.character + 1}: ${d.message}`);
-		}
-		if (typeof parsed.value !== "boolean" && !isObject(parsed.value)) throw new CorrectlyError("schema", `Schema must be an object or boolean: ${uri}`);
-		const rootDialect = dialect(isObject(parsed.value) ? parsed.value.$schema : void 0, inherited);
-		const schema = parsed.value;
-		const resource = {
-			uri,
-			schema,
-			dialect: rootDialect
-		};
-		this.normalize(schema, uri, rootDialect, resource);
-		if (isObject(schema) && schema.$id === void 0) schema.$id = uri;
-		this.register(uri, resource);
-		return resource;
-	}
-	register(uri, resource) {
-		const previous = this.resources.get(uri);
-		if (previous && previous.schema !== resource.schema) throw new CorrectlyError("schema", `Duplicate schema identifier: ${uri}`);
-		this.resources.set(uri, resource);
-	}
-	normalize(schema, base, expected, root) {
-		if (!isObject(schema)) return;
-		const ownDialect = dialect(schema.$schema, expected);
-		if (ownDialect !== expected) throw new CorrectlyError("unsupported-dialect", `Mixed schema dialects at ${base} are not supported`);
-		if (schema.$schema !== void 0) schema.$schema = DIALECTS[ownDialect];
-		if (schema.$async !== void 0) throw new CorrectlyError("schema", `Asynchronous data validation is not supported: ${base}`);
-		if (schema.$vocabulary !== void 0) {
-			if (!isObject(schema.$vocabulary)) throw new CorrectlyError("schema", `$vocabulary must be an object: ${base}`);
-			for (const [vocabulary, required] of Object.entries(schema.$vocabulary)) {
-				if (typeof required !== "boolean") throw new CorrectlyError("schema", `$vocabulary values must be boolean: ${base}`);
-				if (required && !VOCABULARIES.has(vocabulary)) throw new CorrectlyError("unsupported-vocabulary", `Unsupported required vocabulary: ${vocabulary}`);
-			}
-		}
-		let scope = base;
-		if (schema.$id !== void 0) {
-			if (typeof schema.$id !== "string") throw new CorrectlyError("schema", `$id must be a string: ${base}`);
-			scope = new URL(schema.$id, base).href;
-			schema.$id = scope;
-			this.register(scope.replace(/#$/, ""), {
-				...root,
-				schema
-			});
-		}
-		for (const anchor of [schema.$anchor, schema.$dynamicAnchor]) if (typeof anchor === "string") this.register(new URL(`#${anchor}`, scope).href, {
-			...root,
-			schema
-		});
-		for (const key of SINGLE_SCHEMAS) this.normalize(schema[key], scope, expected, root);
-		for (const key of MAP_SCHEMAS) if (isObject(schema[key])) for (const child of Object.values(schema[key])) this.normalize(child, scope, expected, root);
-		for (const key of [...ARRAY_SCHEMAS, "items"]) {
-			const children = schema[key];
-			if (Array.isArray(children)) for (const child of children) this.normalize(child, scope, expected, root);
-			else if (key === "items") this.normalize(children, scope, expected, root);
-		}
-	}
-	async remote(uri) {
-		const cacheFile = path.join(this.cacheDir, `${createHash("sha256").update(uri).digest("hex")}.json`);
-		let cached;
-		try {
-			const raw = await readFile(cacheFile, "utf8");
-			const entry = JSON.parse(raw);
-			if (!isObject(entry) || entry.uri !== uri || typeof entry.text !== "string") throw new Error("invalid cache entry");
-			cached = entry;
-		} catch (error) {
-			if (error.code !== "ENOENT") throw new CorrectlyError("schema-cache", `Cannot read schema cache ${cacheFile}: ${String(error)}`);
-		}
-		if (this.offline) {
-			if (!cached) throw new CorrectlyError("offline-miss", `Schema is not cached in offline mode: ${uri}`);
-			return cached.text;
-		}
-		const timeout = AbortSignal.timeout(this.timeoutMs);
-		const signal = this.options.signal ? AbortSignal.any([this.options.signal, timeout]) : timeout;
-		const headers = {};
-		if (cached?.etag) headers["If-None-Match"] = cached.etag;
-		if (cached?.lastModified) headers["If-Modified-Since"] = cached.lastModified;
-		let current = uri;
-		for (let redirects = 0; redirects <= 5; redirects++) {
-			const response = await this.request(current, {
-				signal,
-				headers,
-				redirect: "manual"
-			});
-			if ([
-				301,
-				302,
-				303,
-				307,
-				308
-			].includes(response.status)) {
-				await response.body?.cancel();
-				const location = response.headers.get("location");
-				if (!location) throw new CorrectlyError("schema-load", `Redirect without location: ${current}`);
-				current = new URL(location, current).href;
-				if (!["http:", "https:"].includes(new URL(current).protocol)) throw new CorrectlyError("schema-load", `Unsupported redirect: ${current}`);
-				continue;
-			}
-			if (response.status === 304 && cached) {
-				await response.body?.cancel();
-				return cached.text;
-			}
-			if (!response.ok || !response.body) {
-				await response.body?.cancel();
-				throw new CorrectlyError("schema-load", `HTTP ${response.status} loading schema ${uri}`);
-			}
-			const reader = response.body.getReader();
-			const chunks = [];
-			let size = 0;
-			try {
-				while (true) {
-					const { value, done } = await reader.read();
-					if (done) break;
-					size += value.byteLength;
-					if (size > this.maxBytes) throw new CorrectlyError("schema-limit", `Schema ${uri} exceeds ${this.maxBytes} bytes`);
-					chunks.push(value);
-				}
-			} finally {
-				await reader.cancel();
-			}
-			const text = Buffer.concat(chunks).toString("utf8");
-			const entry = {
-				uri,
-				text
-			};
-			const etag = response.headers.get("etag");
-			const lastModified = response.headers.get("last-modified");
-			if (etag) entry.etag = etag;
-			if (lastModified) entry.lastModified = lastModified;
-			signal.throwIfAborted();
-			await mkdir(this.cacheDir, { recursive: true });
-			const temporary = `${cacheFile}.${randomUUID()}.tmp`;
-			await writeFile(temporary, JSON.stringify(entry));
-			await rename(temporary, cacheFile);
-			return text;
-		}
-		throw new CorrectlyError("schema-limit", `Too many redirects loading schema ${uri}`);
-	}
-};
-function localSchemaPath(uri) {
-	const url = new URL(uri);
-	return url.protocol === "file:" ? fileURLToPath(url) : void 0;
-}
-//#endregion
-//#region src/core/diagnostics.ts
-function validationContexts(errors, diagnostics) {
-	const summaries = errors.flatMap((error, index) => {
-		if (error.keyword === "anyOf" || error.keyword === "oneOf") return [{
-			index,
-			error,
-			prefix: `${error.schemaPath}/`,
-			alternative: true
-		}];
-		if (error.keyword === "if" && ["then", "else"].includes(error.params.failingKeyword)) return [{
-			index,
-			error,
-			prefix: `${error.schemaPath.slice(0, -3)}/${error.params.failingKeyword}`,
-			alternative: false
-		}];
-		return [];
-	});
-	return diagnostics.map((diagnostic, index) => {
-		const error = errors[index];
-		const parent = summaries.filter((parent) => parent.index > index && (error.instancePath === parent.error.instancePath || error.instancePath.startsWith(`${parent.error.instancePath}/`)) && (parent.error.propertyName === void 0 || error.propertyName === parent.error.propertyName) && (parent.alternative ? error.schemaPath.startsWith(parent.prefix) : error.schemaPath === parent.prefix || error.schemaPath.startsWith(`${parent.prefix}/`))).toSorted((a, b) => b.prefix.length - a.prefix.length || a.index - b.index)[0];
-		if (!parent) return diagnostic;
-		const branch = parent.alternative ? error.schemaPath.slice(parent.prefix.length).split("/")[0] : parent.error.params.failingKeyword;
-		if (parent.alternative && !/^\d+$/.test(branch)) return diagnostic;
-		return {
-			...diagnostic,
-			context: {
-				parent: parent.index,
-				label: parent.alternative ? `Alternative ${Number(branch) + 1}` : branch === "then" ? "Then branch" : "Else branch"
-			}
-		};
-	});
-}
-function diagnosticViews(diagnostics) {
-	const views = diagnostics.map((diagnostic) => ({
-		...diagnostic,
-		branches: []
-	}));
-	const roots = [];
-	for (const [index, view] of views.entries()) {
-		const context = view.context;
-		const parent = context && Number.isInteger(context.parent) && context.parent > index ? views[context.parent] : void 0;
-		if (!parent) {
-			roots.push(view);
-			continue;
-		}
-		let branch = parent.branches.find((branch) => branch.label === context.label);
-		if (!branch) {
-			branch = {
-				label: context.label,
-				diagnostics: []
-			};
-			parent.branches.push(branch);
-		}
-		branch.diagnostics.push(view);
-	}
-	return roots;
-}
-function diagnosticDetails(view) {
-	return view.branches.flatMap((branch) => branch.diagnostics.flatMap((child) => [{
-		label: branch.label,
-		diagnostic: child
-	}, ...diagnosticDetails(child).map((detail) => ({
-		...detail,
-		label: `${branch.label} / ${detail.label}`
-	}))]));
-}
-//#endregion
-//#region src/core/engine.ts
-const ANNOTATIONS = [
-	"markdownDescription",
-	"enumDescriptions",
-	"markdownEnumDescriptions",
-	"defaultSnippets",
-	"errorMessage",
-	"patternErrorMessage",
-	"deprecationMessage",
-	"suggestSortText",
-	"doNotSuggest",
-	"allowComments",
-	"allowTrailingCommas",
-	"deprecated",
-	"$vocabulary"
-];
-function registerRootAnchors(ajv, schema, uri) {
-	if (typeof schema !== "object" || schema === null) return;
-	const object = schema;
-	for (const anchor of [object.$anchor, object.$dynamicAnchor]) if (typeof anchor === "string") ajv.refs[new URL(`#${anchor}`, object.$id ?? uri).href] = object.$id ?? uri;
-}
-function validationMessage(error) {
-	if (error.keyword === "anyOf") return "must match at least one alternative; none matched";
-	if (error.keyword === "if" && ["then", "else"].includes(error.params.failingKeyword)) return `must satisfy the ${error.params.failingKeyword} branch of the conditional schema`;
-	if (error.keyword === "uniqueItems") {
-		const { i, j } = error.params;
-		if (Number.isInteger(i) && Number.isInteger(j)) return `duplicates item at ${error.instancePath}${pointer([Math.min(i, j)])}; array items must be unique`;
-	}
-	if (error.keyword === "enum" && Array.isArray(error.params.allowedValues)) return `must be one of: ${error.params.allowedValues.map((value) => JSON.stringify(value)).join(", ")}`;
-	if (error.keyword === "const" && Object.hasOwn(error.params, "allowedValue")) return `must equal ${JSON.stringify(error.params.allowedValue)}`;
-	if (error.keyword === "oneOf") {
-		if (error.params.passingSchemas === null) return "must match exactly one alternative; none matched";
-		if (Array.isArray(error.params.passingSchemas)) return `must match exactly one alternative; multiple matched (alternatives ${error.params.passingSchemas.map((index) => index + 1).join(", ")})`;
-	}
-	return error.message ?? "Schema violation";
-}
-function validationDiagnostic(text, parsed, error) {
-	let jsonPointer = error.instancePath;
-	if (error.keyword === "uniqueItems" && Number.isInteger(error.params.i) && Number.isInteger(error.params.j)) jsonPointer += pointer([Math.max(error.params.i, error.params.j)]);
-	const property = error.params.additionalProperty ?? error.params.unevaluatedProperty ?? error.params.missingProperty ?? error.params.propertyName ?? error.propertyName;
-	if (typeof property === "string") jsonPointer += pointer([property]);
-	const node = parsed.locate(jsonPointer, error.keyword === "additionalProperties" || error.keyword === "unevaluatedProperties" || error.keyword === "propertyNames" || typeof error.propertyName === "string");
-	const rangeNode = error.keyword === "required" && error.propertyName === void 0 ? parsed.locate(error.instancePath) : node;
-	const length = error.keyword === "required" && error.propertyName === void 0 ? 1 : rangeNode?.length;
-	return diagnostic(text, `schema/${error.keyword}`, `${jsonPointer || "/"}: ${validationMessage(error)}`, jsonPointer, rangeNode?.offset ?? 0, length ?? 1);
-}
-var Engine = class {
-	project;
-	store;
-	compiled = /* @__PURE__ */ new Map();
-	constructor(project, options = {}) {
-		this.project = project;
-		this.store = new SchemaStore(project, options);
-	}
-	validator(uri) {
-		let compiled = this.compiled.get(uri);
-		if (!compiled) {
-			compiled = this.compile(uri);
-			this.compiled.set(uri, compiled);
-		}
-		return compiled;
-	}
-	async compile(uri) {
-		try {
-			const resource = await this.store.load(uri);
-			const options = {
-				allErrors: true,
-				strictSchema: true,
-				strictTypes: false,
-				strictTuples: false,
-				strictRequired: false,
-				coerceTypes: false,
-				useDefaults: false,
-				removeAdditional: false,
-				validateSchema: true,
-				loadSchema: async (ref) => {
-					const loaded = await this.store.load(ref, resource.dialect);
-					if (loaded.dialect !== resource.dialect) throw new CorrectlyError("unsupported-dialect", `Mixed schema dialects: ${uri} references ${ref}`);
-					registerRootAnchors(ajv, loaded.schema, loaded.uri);
-					return loaded.schema;
-				}
-			};
-			const ajv = resource.dialect === "2020-12" ? new Ajv2020(options) : new Ajv(options);
-			addFormats(ajv);
-			for (const keyword of ANNOTATIONS) if (!ajv.RULES.keywords[keyword]) ajv.addKeyword({
-				keyword,
-				valid: true
-			});
-			if (resource.dialect === "2020-12") ajv.addKeyword({
-				keyword: "$anchor",
-				schemaType: "string",
-				valid: true
-			});
-			ajv.addSchema(resource.schema, resource.uri);
-			registerRootAnchors(ajv, resource.schema, resource.uri);
-			return await ajv.compileAsync({
-				$schema: DIALECTS[resource.dialect],
-				$ref: uri
-			});
-		} catch (error) {
-			if (error instanceof CorrectlyError) throw error;
-			throw new CorrectlyError("schema", `Cannot compile schema ${uri}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	async prepare() {
-		for (const association of this.project.config.associations) if (association.schema !== null) await this.store.load(schemaUri(association.schema, this.project.root));
-		for (const association of this.project.config.associations) if (association.schema !== null) await this.validator(schemaUri(association.schema, this.project.root));
-	}
-	async validate(file, text) {
-		const association = associationFor(this.project, file);
-		const mode = association?.mode ?? modeFor(file);
-		const result = {
-			file,
-			mode,
-			association,
-			coverage: "excluded",
-			diagnostics: [],
-			failures: []
-		};
-		if (!isIncluded(this.project, file)) return result;
-		result.coverage = association?.schema ? "schema" : "syntax-only";
-		const parsed = parseDocument(text, mode);
-		result.diagnostics.push(...parsed.diagnostics);
-		if (association?.schema) try {
-			const validate = await this.validator(association.schema);
-			if (parsed.diagnostics.length === 0 && !validate(parsed.value)) result.diagnostics.push(...validationContexts(validate.errors ?? [], (validate.errors ?? []).map((e) => validationDiagnostic(text, parsed, e))));
-		} catch (error) {
-			result.failures.push(failure(error, file));
-		}
-		return result;
-	}
-};
-//#endregion
-export { pointer as C, parseDocument as S, schemaUri as _, SchemaStore as a, diagnostic as b, DEFAULT_EXCLUDES as c, discoverConfig as d, exclusions as f, readText as g, modeFor as h, DIALECTS as i, associationFor as l, loadProject as m, diagnosticDetails as n, localSchemaPath as o, isIncluded as p, diagnosticViews as r, CONFIG_NAME as s, Engine as t, contains as u, CorrectlyError as v, positionAt as w, locate as x, failure as y };
-
-//# sourceMappingURL=engine-BgWBnb1A.mjs.map