@samva/markup 0.3.0 → 0.5.0

package/dist/email/source-edit.js

@@ -1,8 +1,8 @@
+import { n as isObject } from "../guards-eV1qLbf2.js";
 import { buildLineMap } from "../diagnostics.js";
-import { Predicate } from "effect";
 import { parse } from "@babel/parser";
 //#region src/email/source-edit.ts
-const node = (value) => Predicate.isObject(value) && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
+const node = (value) => isObject(value) && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
 const children = (value) => Array.isArray(value) ? value.filter(node) : [];
 const walk = (value, visit, parent = null) => {
 	if (Array.isArray(value)) {

package/dist/email/stylesheets.d.ts

@@ -1,4 +1,4 @@
-import { i as Stylesheet } from "../css-ar2lU3NC.js";
+import { i as Stylesheet } from "../css-DoNc7CiC.js";
 //#region src/email/stylesheets.d.ts
 /** Called by a compiler-generated stylesheet module at import time. */
 declare const registerStylesheet: (sheet: Stylesheet) => void;

package/dist/email/text.d.ts

@@ -1,4 +1,4 @@
-import { m as EmailNode } from "../elements-DtwKlFVH.js";
+import { m as EmailNode } from "../elements-ChJULZlh.js";
 //#region src/email/text.d.ts
 /** Derive the plain-text alternative from the semantic tree in reading order. */
 declare const deriveEmailText: (node: EmailNode) => string;

package/dist/email/text.js

@@ -18,8 +18,8 @@ const block = (inner, separator) => {
 	return trimmed === "" ? "" : `${separator}${trimmed}${separator}`;
 };
 const collect = (nodes, keep, descend) => nodes.flatMap((child) => {
-	if (child._tag === "Fragment") return collect(child.children, keep, descend);
-	if (child._tag !== "Element") return [];
+	if (child.type === "Fragment") return collect(child.children, keep, descend);
+	if (child.type !== "Element") return [];
 	if (keep(child.tag)) return [child];
 	return descend(child.tag) ? collect(child.children, keep, descend) : [];
 });
@@ -30,7 +30,7 @@ const TABLE_SECTIONS = /* @__PURE__ */ new Set([
 ]);
 const childText = (node, context) => node.children.map((child) => derive(child, context)).join("");
 const derive = (node, context) => {
-	switch (node._tag) {
+	switch (node.type) {
 		case "Text": return context.preformatted ? node.value : node.value.replace(INVISIBLE, "").replace(/[^\S\n]+/g, " ");
 		case "Raw": return node.text;
 		case "Fragment": return node.children.map((child) => derive(child, context)).join("");

package/dist/emit.d.ts

@@ -1,5 +1,5 @@
-import { t as Diagnostic } from "./diagnostics-oveE-laV.js";
-import { c as UnboundTemplateSourceLocations } from "./source-locations-BCJQnIfU.js";
+import { t as Diagnostic } from "./diagnostics-CqepLcpI.js";
+import { s as UnboundTemplateSourceLocations } from "./source-locations-D6Te6Gy1.js";
 import { TemplateVariable } from "./render-template.js";
 //#region src/emit.d.ts
 /**

package/dist/emit.js

@@ -2,7 +2,7 @@ import { sameTemplateSourceLocations } from "./source-locations.js";
 import { isRootTag } from "./ast.js";
 import { createVariablesProxy } from "./variables.js";
 import { renderTemplate } from "./render-template.js";
-import { Result } from "effect";
+import { Result } from "better-result";
 //#region src/emit.ts
 /**
 * emitModule — the module-level emit boundary for the TSX authoring layer
@@ -115,7 +115,7 @@ const emitModule = (moduleExports) => {
 */
 const emitOne = (name, template) => {
 	const first = renderTemplate(template);
-	if (Result.isFailure(first)) return {
+	if (Result.isError(first)) return {
 		name,
 		ok: false,
 		source: void 0,
@@ -124,11 +124,11 @@ const emitOne = (name, template) => {
 			kind: "unavailable",
 			reason: "render-failed"
 		},
-		diagnostics: first.failure.diagnostics
+		diagnostics: first.error.diagnostics
 	};
-	const rendered = first.success;
+	const rendered = first.value;
 	const second = renderTemplate(template);
-	if (Result.isSuccess(second) && second.success.source === rendered.source && sameTemplateSourceLocations(second.success.sourceLocations, rendered.sourceLocations)) return {
+	if (Result.isOk(second) && second.value.source === rendered.source && sameTemplateSourceLocations(second.value.sourceLocations, rendered.sourceLocations)) return {
 		name,
 		ok: true,
 		source: rendered.source,

package/dist/guards-eV1qLbf2.js

@@ -0,0 +1,9 @@
+//#region src/internal/guards.ts
+/** A non-null, non-array object, narrowed for property access. */
+const isObject = (input) => typeof input === "object" && input !== null && !Array.isArray(input);
+/** True when `input` carries `property`, narrowing it for reads. */
+const hasProperty = (input, property) => typeof input === "object" && input !== null || typeof input === "function" ? property in input : false;
+//#endregion
+export { isObject as n, hasProperty as t };
+
+//# sourceMappingURL=guards-eV1qLbf2.js.map

package/dist/{input-schema-BIfzI63B.d.ts → input-schema-7dPFVvNE.d.ts}

@@ -1,5 +1,5 @@
 import { OutputUnit } from "@cfworker/json-schema";
-import { StandardJSONSchemaV1 } from "effect/StandardSchema";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 //#region src/input-schema.d.ts
 /** JSON Schema dialect accepted by template publications. */
 declare const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
@@ -20,4 +20,4 @@ declare const inputSchema: <S extends StandardJSONSchemaV1>(source: S) => InputS
 type InputIssue = OutputUnit;
 //#endregion
 export { jsonSchema as a, inputSchema as i, InputIssue as n, InputSchema as r, INPUT_SCHEMA_DIALECT as t };
-//# sourceMappingURL=input-schema-BIfzI63B.d.ts.map
+//# sourceMappingURL=input-schema-7dPFVvNE.d.ts.map

package/dist/input-schema-zjkgrXn2.js

@@ -0,0 +1,455 @@
+import { n as isObject, t as hasProperty } from "./guards-eV1qLbf2.js";
+import { Validator } from "@cfworker/json-schema";
+//#region src/json-schema/2020-12/meta/applicator.json
+var applicator_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/applicator",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/applicator": true },
+	$dynamicAnchor: "meta",
+	title: "Applicator vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"prefixItems": { "$ref": "#/$defs/schemaArray" },
+		"items": { "$dynamicRef": "#meta" },
+		"contains": { "$dynamicRef": "#meta" },
+		"additionalProperties": { "$dynamicRef": "#meta" },
+		"properties": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"default": {}
+		},
+		"patternProperties": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"propertyNames": { "format": "regex" },
+			"default": {}
+		},
+		"dependentSchemas": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"default": {}
+		},
+		"propertyNames": { "$dynamicRef": "#meta" },
+		"if": { "$dynamicRef": "#meta" },
+		"then": { "$dynamicRef": "#meta" },
+		"else": { "$dynamicRef": "#meta" },
+		"allOf": { "$ref": "#/$defs/schemaArray" },
+		"anyOf": { "$ref": "#/$defs/schemaArray" },
+		"oneOf": { "$ref": "#/$defs/schemaArray" },
+		"not": { "$dynamicRef": "#meta" }
+	},
+	$defs: { "schemaArray": {
+		"type": "array",
+		"minItems": 1,
+		"items": { "$dynamicRef": "#meta" }
+	} }
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/content.json
+var content_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/content",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/content": true },
+	$dynamicAnchor: "meta",
+	title: "Content vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"contentEncoding": { "type": "string" },
+		"contentMediaType": { "type": "string" },
+		"contentSchema": { "$dynamicRef": "#meta" }
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/core.json
+var core_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/core",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/core": true },
+	$dynamicAnchor: "meta",
+	title: "Core vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"$id": {
+			"$ref": "#/$defs/uriReferenceString",
+			"$comment": "Non-empty fragments not allowed.",
+			"pattern": "^[^#]*#?$"
+		},
+		"$schema": { "$ref": "#/$defs/uriString" },
+		"$ref": { "$ref": "#/$defs/uriReferenceString" },
+		"$anchor": { "$ref": "#/$defs/anchorString" },
+		"$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+		"$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+		"$vocabulary": {
+			"type": "object",
+			"propertyNames": { "$ref": "#/$defs/uriString" },
+			"additionalProperties": { "type": "boolean" }
+		},
+		"$comment": { "type": "string" },
+		"$defs": {
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" }
+		}
+	},
+	$defs: {
+		"anchorString": {
+			"type": "string",
+			"pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+		},
+		"uriString": {
+			"type": "string",
+			"format": "uri"
+		},
+		"uriReferenceString": {
+			"type": "string",
+			"format": "uri-reference"
+		}
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/format-annotation.json
+var format_annotation_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
+	$dynamicAnchor: "meta",
+	title: "Format vocabulary meta-schema for annotation results",
+	type: ["object", "boolean"],
+	properties: { "format": { "type": "string" } }
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/meta-data.json
+var meta_data_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
+	$dynamicAnchor: "meta",
+	title: "Meta-data vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"title": { "type": "string" },
+		"description": { "type": "string" },
+		"default": true,
+		"deprecated": {
+			"type": "boolean",
+			"default": false
+		},
+		"readOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"writeOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"examples": {
+			"type": "array",
+			"items": true
+		}
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/unevaluated.json
+var unevaluated_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
+	$dynamicAnchor: "meta",
+	title: "Unevaluated applicator vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"unevaluatedItems": { "$dynamicRef": "#meta" },
+		"unevaluatedProperties": { "$dynamicRef": "#meta" }
+	}
+};
+//#endregion
+//#region src/json-schema/2020-12/meta/validation.json
+var validation_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/validation",
+	$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/validation": true },
+	$dynamicAnchor: "meta",
+	title: "Validation vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
+			"type": "array",
+			"items": { "$ref": "#/$defs/simpleTypes" },
+			"minItems": 1,
+			"uniqueItems": true
+		}] },
+		"const": true,
+		"enum": {
+			"type": "array",
+			"items": true
+		},
+		"multipleOf": {
+			"type": "number",
+			"exclusiveMinimum": 0
+		},
+		"maximum": { "type": "number" },
+		"exclusiveMaximum": { "type": "number" },
+		"minimum": { "type": "number" },
+		"exclusiveMinimum": { "type": "number" },
+		"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"pattern": {
+			"type": "string",
+			"format": "regex"
+		},
+		"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"uniqueItems": {
+			"type": "boolean",
+			"default": false
+		},
+		"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minContains": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 1
+		},
+		"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"required": { "$ref": "#/$defs/stringArray" },
+		"dependentRequired": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/$defs/stringArray" }
+		}
+	},
+	$defs: {
+		"nonNegativeInteger": {
+			"type": "integer",
+			"minimum": 0
+		},
+		"nonNegativeIntegerDefault0": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 0
+		},
+		"simpleTypes": { "enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		"stringArray": {
+			"type": "array",
+			"items": { "type": "string" },
+			"uniqueItems": true,
+			"default": []
+		}
+	}
+};
+//#endregion
+//#region src/input-schema.ts
+const meta = new Validator({
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/schema",
+	$vocabulary: {
+		"https://json-schema.org/draft/2020-12/vocab/core": true,
+		"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+		"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+		"https://json-schema.org/draft/2020-12/vocab/validation": true,
+		"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+		"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+		"https://json-schema.org/draft/2020-12/vocab/content": true
+	},
+	$dynamicAnchor: "meta",
+	title: "Core and Validation specifications meta-schema",
+	allOf: [
+		{ "$ref": "meta/core" },
+		{ "$ref": "meta/applicator" },
+		{ "$ref": "meta/unevaluated" },
+		{ "$ref": "meta/validation" },
+		{ "$ref": "meta/meta-data" },
+		{ "$ref": "meta/format-annotation" },
+		{ "$ref": "meta/content" }
+	],
+	type: ["object", "boolean"],
+	$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+	properties: {
+		"definitions": {
+			"$comment": "\"definitions\" has been replaced by \"$defs\".",
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"deprecated": true,
+			"default": {}
+		},
+		"dependencies": {
+			"$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+			"type": "object",
+			"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
+			"deprecated": true,
+			"default": {}
+		},
+		"$recursiveAnchor": {
+			"$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+			"$ref": "meta/core#/$defs/anchorString",
+			"deprecated": true
+		},
+		"$recursiveRef": {
+			"$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+			"$ref": "meta/core#/$defs/uriReferenceString",
+			"deprecated": true
+		}
+	}
+}, "2020-12", false);
+for (const part of [
+	applicator_default,
+	content_default,
+	core_default,
+	format_annotation_default,
+	meta_data_default,
+	unevaluated_default,
+	validation_default
+]) meta.addSchema(part);
+/** JSON Schema dialect accepted by template publications. */
+const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const canonicalJson = (value) => {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (isObject(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonicalJson(item)]));
+	return value;
+};
+const annotations = /* @__PURE__ */ new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$comment"
+]);
+const scalarKeywords = /* @__PURE__ */ new Set([
+	"$schema",
+	"$ref",
+	"type",
+	"enum",
+	"const",
+	"required",
+	"minProperties",
+	"maxProperties",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf"
+]);
+const schemaMaps = /* @__PURE__ */ new Set([
+	"properties",
+	"$defs",
+	"patternProperties",
+	"dependentSchemas"
+]);
+const schemaValues = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"items",
+	"contains",
+	"not",
+	"if",
+	"then",
+	"else",
+	"propertyNames"
+]);
+const schemaArrays = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+/** Check every schema position before deriving identity; unknown keywords never disappear. */
+const canonicalSchema = (schema, path = "#") => {
+	if (typeof schema === "boolean") return schema;
+	if (!isObject(schema)) throw new TypeError(`Invalid schema at ${path}`);
+	const shape = meta.validate(schema);
+	if (!shape.valid) throw new TypeError(`Invalid JSON Schema at ${path}: ${JSON.stringify(shape.errors)}`);
+	const result = {};
+	for (const [key, value] of Object.entries(schema).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+		if (annotations.has(key)) continue;
+		if (schemaMaps.has(key)) {
+			if (!isObject(value)) throw new TypeError(`Invalid ${path}/${key}`);
+			result[key] = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, child]) => [name, canonicalSchema(child, `${path}/${key}/${name}`)]));
+		} else if (schemaValues.has(key)) result[key] = canonicalSchema(value, `${path}/${key}`);
+		else if (schemaArrays.has(key)) {
+			if (!Array.isArray(value)) throw new TypeError(`Invalid ${path}/${key}`);
+			result[key] = value.map((child, index) => canonicalSchema(child, `${path}/${key}/${index}`));
+		} else if (scalarKeywords.has(key)) {
+			if (key === "$ref" && (typeof value !== "string" || !(value === "#" || value.startsWith("#/")))) throw new TypeError(`Only local JSON Pointer references are supported at ${path}/$ref`);
+			if (key === "$schema" && value !== "https://json-schema.org/draft/2020-12/schema") throw new TypeError(`Expected JSON Schema 2020-12 at ${path}`);
+			result[key] = canonicalJson(value);
+		} else throw new TypeError(`Unsupported input schema keyword ${path}/${key}`);
+	}
+	return result;
+};
+/** Direct portable JSON Schema authoring; the caller declares its JSON input type. */
+const jsonSchema = (schema) => ({ "~standard": {
+	version: 1,
+	vendor: "samva-json-schema",
+	jsonSchema: {
+		input: () => schema,
+		output: () => schema
+	}
+} });
+/** Pinned Effect/Zod converters omit arbitrary refinements, so inspect those vendors' check metadata. */
+const rejectNonportableChecks = (source) => {
+	const vendor = source["~standard"].vendor;
+	if (vendor !== "effect" && vendor !== "zod") return;
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (value) => {
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		if (!isObject(value) || seen.has(value)) return;
+		seen.add(value);
+		if (vendor === "zod" && isObject(value._zod)) {
+			visit(value._zod.def);
+			return;
+		}
+		if (vendor === "effect" && value.encoding !== void 0) throw new TypeError("Nonportable Effect transform; use a JSON input schema without decoding transforms");
+		if (vendor === "effect" && value._tag === "Suspend") throw new TypeError("Unsupported suspended Effect converter; use local JSON Schema references");
+		if (vendor === "zod" && value.type === "lazy") throw new TypeError("Unsupported lazy Zod converter; author recursive input with local JSON Schema references");
+		if (vendor === "zod" && (value.check === "custom" || value.check === "overwrite" || [
+			"transform",
+			"default",
+			"prefault",
+			"catch"
+		].includes(String(value.type)))) throw new TypeError("Nonportable Zod refinement/transform; express constraints in JSON Schema");
+		if (vendor === "effect" && value._tag === "Filter" && (!isObject(value.annotations) || typeof value.annotations.toJsonSchema !== "function")) throw new TypeError("Nonportable Effect refinement; provide a JSON Schema constraint");
+		for (const [key, child] of Object.entries(value)) if (key !== "~standard" && key !== "annotations") visit(child);
+	};
+	if (vendor === "effect" && hasProperty(source, "ast")) visit(source.ast);
+	else visit(source);
+};
+/** Convert caller input, never validator output. Both conversion directions must be portable. */
+const inputSchema = (source) => {
+	rejectNonportableChecks(source);
+	const converter = source["~standard"].jsonSchema;
+	const schema = structuredClone(converter.input({ target: "draft-2020-12" }));
+	const canonical = canonicalSchema(schema);
+	const output = canonicalSchema(converter.output({ target: "draft-2020-12" }));
+	if (JSON.stringify(canonical) !== JSON.stringify(output)) throw new TypeError("Template schemas must preserve JSON input; input/output conversion differs");
+	const validator = new Validator(schema, "2020-12", false);
+	const validate = (value) => {
+		const result = validator.validate(value);
+		validate.errors = result.errors;
+		return result.valid;
+	};
+	validate.errors = [];
+	return {
+		schema,
+		validationIdentity: JSON.stringify(canonical),
+		validate
+	};
+};
+//#endregion
+export { inputSchema as n, jsonSchema as r, INPUT_SCHEMA_DIALECT as t };
+
+//# sourceMappingURL=input-schema-zjkgrXn2.js.map

package/dist/input-schema.d.ts

@@ -1,2 +1,2 @@
-import { a as jsonSchema, i as inputSchema, n as InputIssue, r as InputSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-BIfzI63B.js";
+import { a as jsonSchema, i as inputSchema, n as InputIssue, r as InputSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-7dPFVvNE.js";
 export { INPUT_SCHEMA_DIALECT, InputIssue, InputSchema, inputSchema, jsonSchema };