forgepress 0.0.0 → 0.0.1

package/dist/_chunks/references.mjs

@@ -0,0 +1,53 @@
+import { isRecord, quote } from "./value.mjs";
+function entryKey(collection, id) {
+	return `${collection}/${id}`;
+}
+function localized(value, path, translated) {
+	if (!translated) return [[path, value]];
+	return isRecord(value) ? Object.entries(value).map(([locale, item]) => [[...path, locale], item]) : [];
+}
+function references(field, value, path) {
+	if (field.type === "relation" && !field.multiple) return typeof value === "string" ? [{
+		path,
+		collection: field.collection,
+		id: value
+	}] : [];
+	if (!Array.isArray(value)) return [];
+	if (field.type === "relation") return value.flatMap((id, index) => typeof id === "string" ? [{
+		path: [...path, index],
+		collection: field.collection,
+		id
+	}] : []);
+	if (field.type === "dynamic") return value.flatMap((block, index) => isRecord(block) && typeof block.id === "string" && typeof block.collection === "string" && field.collections.includes(block.collection) ? [{
+		path: [...path, index],
+		collection: block.collection,
+		id: block.id
+	}] : []);
+	return [];
+}
+function entryReferences(schema, collection, row) {
+	const translatable = (schema.locales ?? []).length > 0;
+	return Object.entries(schema.collections[collection]?.fields ?? {}).flatMap(([key, field]) => localized(row[key], [key], translatable && field.translate === true).flatMap(([path, value]) => references(field, value, path)));
+}
+function validateReferences(schema, content) {
+	const issues = [];
+	for (const [collection, entries] of Object.entries(content)) for (const [id, row] of Object.entries(entries)) for (const reference of entryReferences(schema, collection, row)) {
+		const target = content[reference.collection]?.[reference.id];
+		const name = entryKey(reference.collection, reference.id);
+		const field = quote(reference.path[0]);
+		if (!target) issues.push({
+			collection,
+			id,
+			path: reference.path,
+			message: `Field ${field} references ${name}, which doesn't exist`
+		});
+		else if (row.status === "published" && target.status !== "published") issues.push({
+			collection,
+			id,
+			path: reference.path,
+			message: `Field ${field} references ${name}, which is unpublished; publish it or remove the reference`
+		});
+	}
+	return issues;
+}
+export { entryKey, validateReferences };

package/dist/_chunks/types.d.mts

@@ -0,0 +1,25 @@
+import { OutputMeta } from "./entry.mjs";
+type LinkKind = 'relation' | 'dynamic';
+export interface OutputEntry extends OutputMeta {
+  [field: string]: unknown;
+}
+export interface OutputManifest {
+  indexed: string[];
+  links: Record<string, LinkKind>;
+  entries: OutputEntry[];
+  files: Record<string, string>;
+}
+export type OutputCollection = {
+  localized: false;
+  manifest: string;
+} | {
+  localized: true;
+  manifests: Record<string, string>;
+};
+export interface OutputIndex {
+  version: number;
+  commit: string | null;
+  dev?: true;
+  locales: string[];
+  collections: Record<string, OutputCollection>;
+}

package/dist/_chunks/types.mjs

@@ -0,0 +1,2 @@
+const OUTPUT_INDEX = "index.json";
+export { OUTPUT_INDEX };

package/dist/_chunks/validate.mjs

@@ -0,0 +1,600 @@
+import { isRecord, quote } from "./value.mjs";
+import { isCollectionName } from "./output.mjs";
+function formatIssue(issue) {
+	return `${issue.file}:${issue.line}:${issue.column} ${issue.message}`;
+}
+var ContentError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.map((issue) => `[forgepress] ${formatIssue(issue)}`).join("\n"));
+		this.name = "ContentError";
+		this.issues = issues;
+	}
+};
+const ID_START = /[$_\p{ID_Start}]/u;
+const ID_CONTINUE = /[$\u200C\u200D\p{ID_Continue}]/u;
+const SPACE = /\s/;
+const DECIMAL = /\d/;
+const HEX = /[\da-f]/i;
+const OCTAL = /[0-7]/;
+const BINARY = /[01]/;
+const HEX_DIGITS = /^[\da-f]+$/i;
+const RADIX = /[box]/i;
+const BREAKS = /* @__PURE__ */ new Set([
+	"\n",
+	"\r",
+	"\u2028",
+	"\u2029"
+]);
+const TYPE_IMPORT = "Only type imports are allowed, e.g. `import type { ForgePressEntry } from 'forgepress'`";
+const ESCAPES = /* @__PURE__ */ new Map([
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["b", "\b"],
+	["f", "\f"],
+	["v", "\v"]
+]);
+function locationAt(text, offset) {
+	let line = 1;
+	let start = 0;
+	for (let position = 0; position < offset; position += 1) {
+		const char = text[position];
+		if (BREAKS.has(char) && !(char === "\r" && text[position + 1] === "\n")) {
+			line += 1;
+			start = position + 1;
+		}
+	}
+	return {
+		line,
+		column: offset - start + 1
+	};
+}
+function pathKey(path) {
+	return JSON.stringify(path);
+}
+function parseModule(text, file) {
+	const offsets = /* @__PURE__ */ new Map();
+	let index = text.startsWith("") ? 1 : 0;
+	function fail(message, at = index) {
+		throw new ContentError([{
+			file,
+			...locationAt(text, at),
+			message
+		}]);
+	}
+	function char(offset = 0) {
+		return text[index + offset] ?? "";
+	}
+	function skip() {
+		while (index < text.length) if (SPACE.test(char())) index += 1;
+		else if (text.startsWith("//", index)) while (index < text.length && !BREAKS.has(char())) index += 1;
+		else if (text.startsWith("/*", index)) {
+			const end = text.indexOf("*/", index + 2);
+			if (end === -1) fail("Unterminated comment");
+			index = end + 2;
+		} else return;
+	}
+	function width(pattern) {
+		const point = text.codePointAt(index);
+		if (point === void 0 || !pattern.test(String.fromCodePoint(point))) return 0;
+		return point > 65535 ? 2 : 1;
+	}
+	function identifier() {
+		const start = index;
+		for (let step = width(ID_START); step > 0; step = width(ID_CONTINUE)) index += step;
+		return index > start ? text.slice(start, index) : void 0;
+	}
+	function word(expected) {
+		skip();
+		const start = index;
+		if (identifier() === expected) return true;
+		index = start;
+		return false;
+	}
+	function expectWord(expected, message) {
+		if (!word(expected)) fail(message);
+	}
+	function name(message) {
+		skip();
+		return identifier() ?? fail(message);
+	}
+	function list(close, item) {
+		index += 1;
+		for (skip(); char() !== close; skip()) {
+			item();
+			skip();
+			if (char() === ",") index += 1;
+			else if (char() !== close) fail(index < text.length ? `Expected \`,\` or \`${close}\`` : "Unexpected end of file");
+		}
+		index += 1;
+	}
+	function hex(count, start) {
+		const digits = text.slice(index, index + count);
+		if (digits.length < count || !HEX_DIGITS.test(digits)) fail("Invalid escape sequence", start);
+		index += count;
+		return Number.parseInt(digits, 16);
+	}
+	function unicode(start) {
+		if (char() !== "{") return String.fromCharCode(hex(4, start));
+		const end = text.indexOf("}", index);
+		const digits = end === -1 ? "" : text.slice(index + 1, end);
+		if (!HEX_DIGITS.test(digits) || Number.parseInt(digits, 16) > 1114111) fail("Invalid escape sequence", start);
+		index = end + 1;
+		return String.fromCodePoint(Number.parseInt(digits, 16));
+	}
+	function escape(unterminated, opening) {
+		const start = index - 1;
+		const current = char();
+		if (current === "") fail(unterminated, opening);
+		index += 1;
+		const simple = ESCAPES.get(current);
+		if (simple !== void 0) return simple;
+		if (current === "\r" && char() === "\n") index += 1;
+		if (BREAKS.has(current)) return "";
+		if (current === "x") return String.fromCharCode(hex(2, start));
+		if (current === "u") return unicode(start);
+		if (DECIMAL.test(current) && (current !== "0" || DECIMAL.test(char()))) fail(`\`\\${current}\` is not a valid escape sequence`, start);
+		if (current === "0") return "\0";
+		const point = text.codePointAt(start + 1);
+		index = start + 1 + (point > 65535 ? 2 : 1);
+		return String.fromCodePoint(point);
+	}
+	function string(quote) {
+		const start = index;
+		let result = "";
+		let run = index + 1;
+		index = run;
+		while (char() !== quote) {
+			const current = char();
+			if (current === "" || current === "\n" || current === "\r") fail("Unterminated string", start);
+			if (current === "\\") {
+				result += text.slice(run, index);
+				index += 1;
+				result += escape("Unterminated string", start);
+				run = index;
+			} else index += 1;
+		}
+		result += text.slice(run, index);
+		index += 1;
+		return result;
+	}
+	function template() {
+		const start = index;
+		let result = "";
+		let run = index + 1;
+		index = run;
+		while (char() !== "`") {
+			const current = char();
+			if (current === "") fail("Unterminated template literal", start);
+			if (current === "$" && char(1) === "{") fail("Template literals cannot contain substitutions");
+			if (current === "\\" || current === "\r") {
+				result += text.slice(run, index);
+				index += 1;
+				if (current === "\\") result += escape("Unterminated template literal", start);
+				else {
+					result += "\n";
+					if (char() === "\n") index += 1;
+				}
+				run = index;
+			} else index += 1;
+		}
+		result += text.slice(run, index);
+		index += 1;
+		return result;
+	}
+	function digits(pattern, start) {
+		const from = index;
+		while (pattern.test(char()) || char() === "_") {
+			if (char() === "_" && (index === from || !pattern.test(char(1)))) fail("Invalid numeric separator", start);
+			index += 1;
+		}
+		if (index === from) fail("Invalid number", start);
+		return text.slice(from, index).replaceAll("_", "");
+	}
+	function numberStart() {
+		return DECIMAL.test(char()) || char() === "." && DECIMAL.test(char(1));
+	}
+	function number() {
+		const start = index;
+		let source = "";
+		if (char() === "0" && RADIX.test(char(1))) {
+			const radix = char(1).toLowerCase();
+			index += 2;
+			source = `0${radix}${digits(radix === "x" ? HEX : radix === "o" ? OCTAL : BINARY, start)}`;
+		} else {
+			if (char() === "0" && (DECIMAL.test(char(1)) || char(1) === "_")) fail("Numbers cannot start with a leading zero", start);
+			if (char() !== ".") source = digits(DECIMAL, start);
+			if (char() === ".") {
+				index += 1;
+				source += `.${DECIMAL.test(char()) ? digits(DECIMAL, start) : ""}`;
+			}
+			if (char() === "e" || char() === "E") {
+				index += 1;
+				const sign = char() === "+" || char() === "-" ? char() : "";
+				index += sign.length;
+				source += `e${sign}${digits(DECIMAL, start)}`;
+			}
+		}
+		if (char() === "n") fail("BigInt values are not allowed", start);
+		if (DECIMAL.test(char()) || width(ID_START) > 0) fail("Invalid number", start);
+		const value = Number(source);
+		if (!Number.isFinite(value)) fail("Number is out of range", start);
+		return value;
+	}
+	function propertyKey() {
+		const start = index;
+		const current = char();
+		if (current === "[") fail("Computed keys are not allowed");
+		if (text.startsWith("...", index)) fail("Spread syntax is not allowed");
+		const key = current === "'" || current === "\"" ? string(current) : numberStart() ? String(number()) : identifier();
+		if (key === void 0) fail(index < text.length ? "Expected a property name" : "Unexpected end of file");
+		if (key === "__proto__") fail("`__proto__` cannot be used as a key", start);
+		return key;
+	}
+	function object(path) {
+		const result = {};
+		list("}", () => {
+			const start = index;
+			const key = propertyKey();
+			skip();
+			if (char() === "," || char() === "}") fail(`Shorthand properties are not allowed; write \`${key}: value\``, start);
+			if (char() === "(") fail("Methods are not allowed");
+			if (char() !== ":") fail(index < text.length ? `Expected \`:\` after \`${key}\`` : "Unexpected end of file");
+			index += 1;
+			if (Object.hasOwn(result, key)) fail(`Duplicate key \`${key}\``, start);
+			const child = [...path, key];
+			offsets.set(pathKey(child), start);
+			result[key] = literal(child);
+		});
+		return result;
+	}
+	function array(path) {
+		const result = [];
+		list("]", () => {
+			if (char() === ",") fail("Empty array slots are not allowed");
+			const child = [...path, result.length];
+			offsets.set(pathKey(child), index);
+			result.push(literal(child));
+		});
+		return result;
+	}
+	function literal(path) {
+		skip();
+		const start = index;
+		const current = char();
+		if (current === "{") return object(path);
+		if (current === "[") return array(path);
+		if (current === "'" || current === "\"") return string(current);
+		if (current === "`") return template();
+		if (current === "-" || current === "+") {
+			index += 1;
+			skip();
+			if (!numberStart()) fail(`Expected a number after \`${current}\``);
+			return current === "-" ? -number() : number();
+		}
+		if (numberStart()) return number();
+		if (text.startsWith("...", index)) fail("Spread syntax is not allowed");
+		const found = identifier();
+		if (found === "true" || found === "false") return found === "true";
+		if (found === "null" || found === "undefined") fail(`\`${found}\` is not supported; leave the value out instead`, start);
+		if (found === "NaN" || found === "Infinity") fail(`\`${found}\` cannot be stored`, start);
+		if (found !== void 0) fail(`\`${found}\` is not a literal value; variables, calls and expressions are not allowed`, start);
+		return fail(index < text.length ? "Expected a literal value" : "Unexpected end of file");
+	}
+	function typeReference() {
+		word("typeof");
+		name("Expected a type");
+		skip();
+		while (char() === ".") {
+			index += 1;
+			name("Expected a type");
+			skip();
+		}
+		if (char() === "<") list(">", () => {
+			const quote = char();
+			if (quote === "'" || quote === "\"") string(quote);
+			else typeReference();
+		});
+	}
+	function importDeclaration(start) {
+		if (!word("type")) fail(TYPE_IMPORT, start);
+		skip();
+		if (char() === "{") list("}", () => {
+			name("Expected an import name");
+			if (word("as")) name("Expected an import name");
+		});
+		else if (char() === "*") {
+			index += 1;
+			expectWord("as", "Expected `as`");
+			name("Expected an import name");
+		} else if (name("Expected an import clause") === "from") {
+			skip();
+			if (char() === "'" || char() === "\"") fail(TYPE_IMPORT, start);
+		}
+		expectWord("from", "Expected `from`");
+		skip();
+		if (char() !== "'" && char() !== "\"") fail("Expected a module name");
+		string(char());
+	}
+	function exportDefault() {
+		expectWord("default", "Only `export default` is allowed");
+		skip();
+		offsets.set(pathKey([]), index);
+		const value = literal([]);
+		if (word("as")) expectWord("const", "Only `as const` is allowed; use `satisfies` to type the value");
+		if (word("satisfies")) typeReference();
+		return value;
+	}
+	function statements() {
+		let exported = false;
+		let value;
+		for (skip(); index < text.length; skip()) {
+			const start = index;
+			if (char() === ";") {
+				index += 1;
+				continue;
+			}
+			if (exported) fail("Nothing may follow `export default`");
+			const keyword = identifier();
+			if (keyword === "import") importDeclaration(start);
+			else if (keyword === "export") {
+				value = exportDefault();
+				exported = true;
+			} else fail("Only `import type` and `export default` are allowed", start);
+		}
+		if (!exported) fail("Missing `export default`");
+		return value;
+	}
+	return {
+		value: statements(),
+		locate(path) {
+			for (let depth = path.length; depth >= 0; depth -= 1) {
+				const offset = offsets.get(pathKey(path.slice(0, depth)));
+				if (offset !== void 0) return locationAt(text, offset);
+			}
+			return locationAt(text, 0);
+		}
+	};
+}
+const META_KEYS = [
+	"id",
+	"status",
+	"createdAt",
+	"updatedAt"
+];
+const dynamic = {
+	type: "dynamic",
+	label: "Dynamic",
+	options: { collections: {
+		label: "Collections",
+		type: "collections",
+		required: true
+	} }
+};
+const image = {
+	type: "image",
+	label: "Image",
+	options: { multiple: {
+		label: "Multiple",
+		type: "boolean"
+	} }
+};
+const number = {
+	type: "number",
+	label: "Number",
+	options: {
+		min: {
+			label: "Minimum",
+			type: "number"
+		},
+		max: {
+			label: "Maximum",
+			type: "number"
+		},
+		step: {
+			label: "Step",
+			type: "number"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+const relation = {
+	type: "relation",
+	label: "Relation",
+	options: {
+		collection: {
+			label: "Collection",
+			type: "collection",
+			required: true
+		},
+		multiple: {
+			label: "Multiple",
+			type: "boolean"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+const richtext = {
+	type: "richtext",
+	label: "Rich Text",
+	options: {}
+};
+const text = {
+	type: "text",
+	label: "Text",
+	options: {
+		validation: {
+			label: "Validation Pattern",
+			type: "text"
+		},
+		index: {
+			label: "Indexed",
+			type: "boolean",
+			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
+		}
+	}
+};
+function compilePattern(validation) {
+	try {
+		return new RegExp(validation, "u");
+	} catch (error) {
+		return error;
+	}
+}
+const fieldTypes = {
+	text,
+	richtext,
+	number,
+	image,
+	video: {
+		type: "video",
+		label: "Video",
+		options: { multiple: {
+			label: "Multiple",
+			type: "boolean"
+		} }
+	},
+	relation,
+	dynamic
+};
+const fieldTypeNames = Object.keys(fieldTypes);
+const LOCALE_CODE = /^[a-z][\w-]*$/i;
+const RESERVED_FIELDS = META_KEYS;
+const SCHEMA_KEYS = /* @__PURE__ */ new Set(["collections", "locales"]);
+const COLLECTION_KEYS = /* @__PURE__ */ new Set([
+	"label",
+	"description",
+	"fields"
+]);
+const BASE_OPTIONS = {
+	label: "text",
+	description: "text",
+	optional: "boolean",
+	translate: "boolean"
+};
+const INDEXABLE = fieldTypeNames.filter((type) => "index" in fieldTypes[type].options);
+const KINDS = {
+	text: "a string",
+	number: "a number",
+	boolean: "true or false",
+	collection: "a collection name",
+	collections: "a list of collection names"
+};
+function isFieldType(type) {
+	return typeof type === "string" && fieldTypeNames.includes(type);
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function fits(kind, value) {
+	if (kind === "number") return finite(value);
+	if (kind === "boolean") return typeof value === "boolean";
+	if (kind === "collections") return Array.isArray(value) && value.every((item) => typeof item === "string");
+	return typeof value === "string";
+}
+function optionKinds(type) {
+	const options = Object.entries(fieldTypes[type].options).map(([option, spec]) => [option, spec.type]);
+	return {
+		...BASE_OPTIONS,
+		...Object.fromEntries(options)
+	};
+}
+function checkLocales(report, locales) {
+	if (locales === void 0) return [];
+	if (!Array.isArray(locales)) {
+		report(["locales"], "\"locales\" has to be a list of locale codes");
+		return [];
+	}
+	locales.forEach((locale, index) => {
+		if (typeof locale !== "string" || !LOCALE_CODE.test(locale)) report(["locales", index], `${quote(locale)} is not a locale code`);
+		else if (locales.indexOf(locale) < index) report(["locales", index], `Locale ${quote(locale)} is listed twice`);
+	});
+	return locales;
+}
+function checkReferences(context, path, label, targets, listed) {
+	targets.forEach((target, index) => {
+		const at = listed ? [...path, index] : path;
+		if (!context.collections.has(target)) context.report(at, `Field ${quote(label)} references unknown collection ${quote(target)}`);
+		else if (targets.indexOf(target) < index) context.report(at, `Field ${quote(label)} lists collection ${quote(target)} twice`);
+	});
+}
+function checkOption(context, path, label, option, kind, value) {
+	if (!fits(kind, value)) context.report(path, `${quote(option)} of field ${quote(label)} has to be ${KINDS[kind]}`);
+	else if (kind === "collection" || kind === "collections") checkReferences(context, path, label, kind === "collection" ? [value] : value, kind === "collections");
+}
+function checkConstraints(report, path, label, field) {
+	if (field.type === "text" && typeof field.validation === "string") {
+		const pattern = compilePattern(field.validation);
+		if (pattern instanceof SyntaxError) report([...path, "validation"], `"validation" of field ${quote(label)} is not a valid regular expression: ${pattern.message.replace(/^Invalid regular expression: /, "")}`);
+	}
+	if (field.type !== "number") return;
+	if (finite(field.step) && field.step <= 0) report([...path, "step"], `"step" of field ${quote(label)} has to be greater than 0`);
+	if (finite(field.min) && finite(field.max) && field.min > field.max) report([...path, "min"], `"min" of field ${quote(label)} can't be greater than "max"`);
+}
+function checkField(context, path, collection, key, field) {
+	const { report } = context;
+	const label = `${collection}.${key}`;
+	if (RESERVED_FIELDS.includes(key)) report(path, `Field ${quote(label)} uses ${quote(key)}, which is reserved for entry metadata`);
+	if (!isRecord(field)) return report(path, `Field ${quote(label)} has to be an object`);
+	if (field.type === void 0) return report(path, `Field ${quote(label)} needs a type`);
+	if (!isFieldType(field.type)) return report([...path, "type"], `Field ${quote(label)} has unknown type ${quote(field.type)}; use one of ${fieldTypeNames.join(", ")}`);
+	const kinds = optionKinds(field.type);
+	for (const [option, value] of Object.entries(field)) {
+		const kind = kinds[option];
+		if (option === "type") continue;
+		if (kind) checkOption(context, [...path, option], label, option, kind, value);
+		else if (option === "index") report([...path, option], `Field ${quote(label)} can't be indexed; only ${INDEXABLE.slice(0, -1).join(", ")} and ${INDEXABLE.at(-1)} fields can`);
+		else report([...path, option], `Field ${quote(label)} has no option ${quote(option)}`);
+	}
+	for (const [option, spec] of Object.entries(fieldTypes[field.type].options)) if ("required" in spec && field[option] === void 0) report(path, `Field ${quote(label)} needs ${quote(option)}`);
+	checkConstraints(report, path, label, field);
+	if (field.translate === true && context.locales.length === 0) report([...path, "translate"], `Field ${quote(label)} is translated, but the schema has no locales`);
+}
+function checkCollection(context, name, collection) {
+	const { report } = context;
+	const path = ["collections", name];
+	if (!isCollectionName(name)) report(path, `Collection ${quote(name)} has to start with a lowercase letter and contain only letters and digits`);
+	if (!isRecord(collection)) return report(path, `Collection ${quote(name)} has to be an object`);
+	for (const [key, value] of Object.entries(collection)) if (!COLLECTION_KEYS.has(key)) report([...path, key], `Collection ${quote(name)} has no option ${quote(key)}`);
+	else if (key !== "fields" && typeof value !== "string") report([...path, key], `${quote(key)} of collection ${quote(name)} has to be a string`);
+	if (!isRecord(collection.fields)) return report(collection.fields === void 0 ? path : [...path, "fields"], `Collection ${quote(name)} needs "fields" as an object`);
+	for (const [key, field] of Object.entries(collection.fields)) checkField(context, [
+		...path,
+		"fields",
+		key
+	], name, key, field);
+}
+function validateSchema(schema) {
+	const issues = [];
+	const report = (path, message) => issues.push({
+		path,
+		message
+	});
+	if (!isRecord(schema)) {
+		report([], "The schema has to be an object");
+		return issues;
+	}
+	for (const key of Object.keys(schema)) if (!SCHEMA_KEYS.has(key)) report([key], `The schema has no option ${quote(key)}`);
+	const locales = checkLocales(report, schema.locales);
+	if (!isRecord(schema.collections)) {
+		report(schema.collections === void 0 ? [] : ["collections"], "The schema needs \"collections\" as an object");
+		return issues;
+	}
+	const context = {
+		report,
+		collections: new Set(Object.keys(schema.collections)),
+		locales
+	};
+	for (const [name, collection] of Object.entries(schema.collections)) checkCollection(context, name, collection);
+	return issues;
+}
+export { ContentError, META_KEYS, compilePattern, formatIssue, parseModule, validateSchema };

package/dist/_chunks/value.mjs

@@ -0,0 +1,17 @@
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plain(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function same(left, right) {
+	return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function defined(value) {
+	if (!value) return {};
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function quote(value) {
+	return JSON.stringify(value) ?? String(value);
+}
+export { defined, isRecord, plain, quote, same };