@power-plant/schema 0.0.25 → 0.0.26

package/dist/helpers-reqtcaa8.mjs

@@ -0,0 +1,921 @@
+import { a as SCHEMA_ARRAY_CONCAT_KEYWORDS, n as JSON_SCHEMA_PRIMITIVE_TYPES, o as SCHEMA_RECORD_KEYWORDS, r as JSON_SCHEMA_TYPES, s as SCHEMA_SINGLE_KEYWORDS, t as JSON_SCHEMA_METADATA_KEYS } from "./constants-COGt3eeW.mjs";
+import { isSetObject } from "@stryke/type-checks/is-set-object";
+import { isSetString } from "@stryke/type-checks/is-set-string";
+import { isBoolean, isFunction, isSetObject as isSetObject$1, isSetString as isSetString$1, isString } from "@stryke/type-checks";
+import { findFileExtensionSafe } from "@stryke/path/find";
+import { VALID_OBJECT_SOURCE_EXTENSIONS } from "@stryke/resolve/constants";
+import { getUnique } from "@stryke/helpers/get-unique";
+import defu from "defu";
+
+//#region src/metadata.ts
+/**
+* Applies Powerlines schema metadata onto a JSON Schema fragment.
+*
+* @param schema - The JSON Schema fragment to apply metadata to.
+* @param metadata - The Powerlines schema metadata to apply.
+* @returns A new JSON Schema fragment with the metadata applied.
+*/
+function applyJsonSchemaMetadata(schema, metadata) {
+	if (!metadata || !isSetObject(schema)) return schema;
+	const result = { ...schema };
+	const mutableResult = result;
+	for (const key of JSON_SCHEMA_METADATA_KEYS) {
+		const value = metadata[key];
+		if (value !== void 0 && value !== null) mutableResult[key] = value;
+	}
+	return result;
+}
+/**
+* Normalizes the JSON Schema `type` keyword to a string array.
+*
+* @remarks
+* This function ensures that the `type` keyword of a JSON Schema fragment is always represented as an array of strings, even if it was originally defined as a single string. This normalization simplifies type checking and processing of JSON Schemas by providing a consistent format for the `type` information.
+*
+* @param schema - The JSON Schema fragment to read types from.
+* @returns An array of JSON Schema primitive type names defined in the `type` keyword, or an empty array if no valid types are found.
+*/
+function readSchemaTypes(schema) {
+	if (!isSetObject(schema)) return [];
+	const objectSchema = schema;
+	if (Array.isArray(objectSchema.type)) return objectSchema.type.filter((type) => isSetString(type));
+	if (isSetString(objectSchema.type) && objectSchema.type !== "object" && objectSchema.type !== "array") return [objectSchema.type];
+	return [];
+}
+/**
+* Returns the primary non-null JSON Schema type name for a fragment.
+*
+* @param schema - The JSON Schema fragment to check.
+* @returns The primary non-null JSON Schema type name, or `undefined` if none is found.
+*/
+function getPrimarySchemaType(schema) {
+	if (!isSetObject(schema)) return;
+	return readSchemaTypes(schema).find((type) => type !== "null");
+}
+
+//#endregion
+//#region src/type-checks.ts
+/**
+* Checks if the provided entry is a file reference.
+*
+* @param entry - The entry to check.
+* @returns True if the entry is a file reference, false otherwise.
+*/
+function isFileReference(entry) {
+	return !isString(entry) && entry.file !== void 0;
+}
+const isSetNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isSchemaLikeValue = (value) => isSetObject$1(value) || isBoolean(value);
+const isRecordOfSchemaLike = (value) => isSetObject$1(value) && Object.values(value).every((item) => isSchemaLikeValue(item));
+const isVocabularyMap = (value) => isSetObject$1(value) && Object.values(value).every((item) => isBoolean(item));
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => isSetString$1(item));
+const isRecordOfStringArrays = (value) => isSetObject$1(value) && Object.values(value).every((item) => isStringArray(item));
+const JSON_SCHEMA_PRIMITIVE_TYPE_SET = new Set(JSON_SCHEMA_PRIMITIVE_TYPES);
+const JSON_SCHEMA_TYPE_SET = new Set(JSON_SCHEMA_TYPES);
+/**
+* A helper type guard to check if a value is a JSON Schema primitive type.
+*
+* @param value - The value to check.
+* @returns True if the value is a JSON Schema primitive type, false otherwise.
+*/
+function isJsonSchemaPrimitiveType(value) {
+	return isSetString$1(value) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(value);
+}
+/**
+* A helper type guard to check if a value is a JSON Schema type.
+*
+* @param value - The value to check.
+* @returns True if the value is a JSON Schema type, false otherwise.
+*/
+function isJsonSchemaType(value) {
+	return isSetString$1(value) && JSON_SCHEMA_TYPE_SET.has(value);
+}
+const DATE_FORMAT_SET = /* @__PURE__ */ new Set([
+	"date",
+	"time",
+	"date-time",
+	"iso-time",
+	"iso-date-time",
+	"unix-time"
+]);
+const isSetBigint = (value) => typeof value === "bigint";
+const UNTYPED_TYPE_NAME_SET = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"bigint",
+	"boolean",
+	"symbol",
+	"function",
+	"object",
+	"any",
+	"array"
+]);
+const isUntypedJSType = (value) => isSetString$1(value) && UNTYPED_TYPE_NAME_SET.has(value);
+const isUntypedTypeDescriptor = (value) => {
+	if (!isSetObject$1(value)) return false;
+	const descriptor = value;
+	if (descriptor.type !== void 0 && !(isSetString$1(descriptor.type) && isUntypedJSType(descriptor.type) || Array.isArray(descriptor.type) && descriptor.type.every((item) => isUntypedJSType(item)))) return false;
+	if (descriptor.tsType !== void 0 && !isSetString$1(descriptor.tsType)) return false;
+	if (descriptor.markdownType !== void 0 && !isSetString$1(descriptor.markdownType)) return false;
+	if (descriptor.items !== void 0 && !(isUntypedTypeDescriptor(descriptor.items) || Array.isArray(descriptor.items) && descriptor.items.every((item) => isUntypedTypeDescriptor(item)))) return false;
+	return true;
+};
+const isUntypedFunctionArg = (value) => {
+	if (!isUntypedTypeDescriptor(value)) return false;
+	const arg = value;
+	if (arg.name !== void 0 && !isSetString$1(arg.name)) return false;
+	return arg.optional === void 0 || typeof arg.optional === "boolean";
+};
+const isRecordOfUntypedSchema = (value) => isSetObject$1(value) && Object.values(value).every((item) => isUntypedSchema(item));
+const isArrayOf = (value, predicate) => Array.isArray(value) && value.every((item) => predicate(item));
+const isTupleOfTwo = (value, aPredicate, bPredicate) => Array.isArray(value) && value.length === 2 && aPredicate(value[0]) && bPredicate(value[1]);
+const isOptionalString = (value, allowEmpty = false) => value === void 0 || isString(value) && (allowEmpty || value.length > 0);
+const isOptionalBoolean = (value) => value === void 0 || isBoolean(value);
+const isOptionalNumber = (value) => value === void 0 || isSetNumber(value);
+const isOptionalBigint = (value) => value === void 0 || isSetBigint(value);
+const isOptionalJsonSchema = (value) => value === void 0 || isJsonSchema(value);
+const isOptionalJsonSchemaArray = (value) => value === void 0 || isArrayOf(value, isJsonSchema);
+const isOptionalPrimitiveTypeArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => isSetString$1(item) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(item));
+const isOptionalJsonSchemaTypeArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => isSetString$1(item) && JSON_SCHEMA_TYPE_SET.has(item));
+const hasValidJsonSchemaKeywords = (schema) => {
+	if (!isOptionalString(schema.$id)) return false;
+	if (!isOptionalString(schema.$schema)) return false;
+	if (schema.$vocabulary !== void 0 && !isVocabularyMap(schema.$vocabulary)) return false;
+	if (!isOptionalString(schema.$comment, true)) return false;
+	if (!isOptionalString(schema.$anchor)) return false;
+	if (schema.$defs !== void 0 && !isRecordOfSchemaLike(schema.$defs)) return false;
+	if (!isOptionalString(schema.$dynamicRef)) return false;
+	if (!isOptionalString(schema.$dynamicAnchor)) return false;
+	if (!isOptionalString(schema.name)) return false;
+	if (!isOptionalString(schema.title, true)) return false;
+	if (!isOptionalString(schema.description, true)) return false;
+	if (!isOptionalString(schema.docs, true)) return false;
+	if (schema.examples !== void 0 && !Array.isArray(schema.examples)) return false;
+	if (schema.alias !== void 0 && !isStringArray(schema.alias)) return false;
+	if (schema.tags !== void 0 && !isStringArray(schema.tags)) return false;
+	if (!isOptionalBoolean(schema.deprecated)) return false;
+	if (!isOptionalBoolean(schema.hidden)) return false;
+	if (!isOptionalBoolean(schema.ignore)) return false;
+	if (!isOptionalBoolean(schema.internal)) return false;
+	if (!isOptionalBoolean(schema.runtime)) return false;
+	if (!isOptionalBoolean(schema.readOnly)) return false;
+	if (!isOptionalBoolean(schema.writeOnly)) return false;
+	if (!isOptionalJsonSchemaArray(schema.allOf)) return false;
+	if (!isOptionalJsonSchemaArray(schema.anyOf)) return false;
+	if (!isOptionalJsonSchemaArray(schema.oneOf)) return false;
+	if (!isOptionalJsonSchema(schema.not)) return false;
+	if (!isOptionalJsonSchema(schema.if)) return false;
+	if (!isOptionalJsonSchema(schema.then)) return false;
+	if (!isOptionalJsonSchema(schema.else)) return false;
+	return true;
+};
+/**
+* Type guard for shared JSON Schema keyword groups.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema keyword group, false otherwise.
+*/
+function isJsonSchemaKeywords(input) {
+	if (!isSetObject$1(input)) return false;
+	return hasValidJsonSchemaKeywords(input);
+}
+/**
+* Type guard for generic JSON Schema objects with optional `$ref`.
+*
+* @param input - The value to check.
+* @returns True if the input is a generic JSON Schema object, false otherwise.
+*/
+function isJsonSchemaAny(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref) && (!schema.type || Array.isArray(schema.type) && schema.type.every((t) => JSON_SCHEMA_PRIMITIVE_TYPES.includes(t)));
+}
+/**
+* Type guard for JSON Schema array types.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema array schema, false otherwise.
+*/
+function isJsonSchemaArray(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "array") return false;
+	return isOptionalJsonSchemaArray(schema.prefixItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalBoolean(schema.uniqueItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for bigint-backed integer schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a bigint-backed integer schema, false otherwise.
+*/
+function isJsonSchemaBigint(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "integer" || schema.format !== "int64") return false;
+	return isOptionalBigint(schema.minimum) && isOptionalBigint(schema.exclusiveMinimum) && isOptionalBigint(schema.maximum) && isOptionalBigint(schema.exclusiveMaximum) && isOptionalBigint(schema.multipleOf) && isOptionalBigint(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetBigint));
+}
+/**
+* Type guard for boolean schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a boolean schema, false otherwise.
+*/
+function isJsonSchemaBoolean(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "boolean" && isOptionalBoolean(schema.default);
+}
+/**
+* Type guard for date/time schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a date or time schema, false otherwise.
+*/
+function isJsonSchemaDate(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	if (schema.anyOf !== void 0) return isArrayOf(schema.anyOf, isJsonSchemaDate);
+	if (schema.type !== "integer" && schema.type !== "string") return false;
+	if (!isSetString$1(schema.format) || !DATE_FORMAT_SET.has(schema.format)) return false;
+	return isOptionalNumber(schema.minimum) && isOptionalNumber(schema.maximum) && (schema.default === void 0 || isSetString$1(schema.default) || isSetNumber(schema.default));
+}
+/**
+* Type guard for enum-constrained schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an enum-constrained schema, false otherwise.
+*/
+function isJsonSchemaEnum(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !isSetString$1(schema.type) || !JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type) || !Array.isArray(schema.enum)) return false;
+	const typeName = schema.type;
+	const enumValues = schema.enum;
+	const defaultValue = schema.default;
+	if (typeName === "string") return enumValues.every((value) => isSetString$1(value)) && (defaultValue === void 0 || isSetString$1(defaultValue));
+	if (typeName === "number" || typeName === "integer") return enumValues.every((value) => isSetNumber(value)) && (defaultValue === void 0 || isSetNumber(defaultValue));
+	if (typeName === "boolean") return enumValues.every((value) => isBoolean(value)) && (defaultValue === void 0 || isBoolean(defaultValue));
+	return typeName === "null" && enumValues.every((value) => value === null) && (defaultValue === void 0 || defaultValue === null);
+}
+/**
+* Type guard for `allOf` composition schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an `allOf` schema, false otherwise.
+*/
+function isJsonSchemaAllOf(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !isArrayOf(schema.allOf, isJsonSchema)) return false;
+	return schema.unevaluatedProperties === void 0 || isBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties);
+}
+/**
+* Type guard for literal-value schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a literal-value schema, false otherwise.
+*/
+function isJsonSchemaLiteral(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !("const" in schema)) return false;
+	return schema.type === void 0 || isSetString$1(schema.type) && isJsonSchemaType(schema.type) || isOptionalJsonSchemaTypeArray(schema.type);
+}
+/**
+* Type guard for map tuple-array schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a map tuple-array schema, false otherwise.
+*/
+function isJsonSchemaMap(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "array" || schema.maxItems !== 125 || !isSetObject$1(schema.items)) return false;
+	const items = schema.items;
+	return items.type === "array" && isTupleOfTwo(items.prefixItems, isJsonSchema, isJsonSchema) && (items.items === void 0 || items.items === false) && items.minItems === 2 && items.maxItems === 2;
+}
+/**
+* Type guard for native enum schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a native enum schema, false otherwise.
+*/
+function isJsonSchemaNativeEnum(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	const isValidType = schema.type === "string" || schema.type === "number" || Array.isArray(schema.type) && schema.type.length === 2 && schema.type[0] === "string" && schema.type[1] === "number";
+	return hasValidJsonSchemaKeywords(schema) && isValidType && Array.isArray(schema.enum) && schema.enum.every((value) => isSetString$1(value) || isSetNumber(value));
+}
+/**
+* Type guard for impossible/never schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a never schema, false otherwise.
+*/
+function isJsonSchemaNever(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isJsonSchemaAny(schema.not);
+}
+/**
+* Type guard for `null` schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a null schema, false otherwise.
+*/
+function isJsonSchemaNull(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "null" && (schema.const === void 0 || schema.const === null) && (schema.enum === void 0 || Array.isArray(schema.enum) && schema.enum.every((v) => v === null)) && (schema.default === void 0 || schema.default === null);
+}
+/**
+* Type guard for nullable schema unions.
+*
+* @param input - The value to check.
+* @returns True if the input is a nullable schema union, false otherwise.
+*/
+function isJsonSchemaNullable(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	const anyOfBranch = schema.anyOf !== void 0 && Array.isArray(schema.anyOf) && schema.anyOf.length === 2 && isJsonSchema(schema.anyOf[0]) && isJsonSchemaNull(schema.anyOf[1]);
+	const typeBranch = Array.isArray(schema.type) && schema.type.length === 2 && (schema.type[0] === "null" && isSetString$1(schema.type[1]) && schema.type[1] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[1]) || schema.type[1] === "null" && isSetString$1(schema.type[0]) && schema.type[0] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[0]));
+	return anyOfBranch || typeBranch;
+}
+/**
+* Type guard for numeric schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a numeric schema, false otherwise.
+*/
+function isJsonSchemaNumber(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "number" && schema.type !== "integer") return false;
+	return isOptionalString(schema.format) && isOptionalNumber(schema.minimum) && isOptionalNumber(schema.exclusiveMinimum) && isOptionalNumber(schema.maximum) && isOptionalNumber(schema.exclusiveMaximum) && isOptionalNumber(schema.multipleOf) && isOptionalNumber(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetNumber));
+}
+/**
+* Type guard for integer schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an integer schema, false otherwise.
+*/
+function isJsonSchemaInteger(input) {
+	return isJsonSchemaNumber(input) && input.type === "integer";
+}
+/**
+* Type guard for decimal schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a decimal schema, false otherwise.
+*/
+function isJsonSchemaDecimal(input) {
+	return isJsonSchemaNumber(input) && input.type === "number";
+}
+/**
+* Type guard for object schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an object schema, false otherwise.
+*/
+function isJsonSchemaObject(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "object" && (schema.properties === void 0 || isRecordOfSchemaLike(schema.properties)) && (schema.patternProperties === void 0 || isRecordOfSchemaLike(schema.patternProperties)) && (schema.additionalProperties === void 0 || isBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && (schema.required === void 0 || isStringArray(schema.required)) && (schema.unevaluatedProperties === void 0 || isBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties)) && (schema.dependencies === void 0 || isSetObject$1(schema.dependencies) && Object.values(schema.dependencies).every((item) => isStringArray(item) || isJsonSchema(item))) && (schema.dependentRequired === void 0 || isRecordOfStringArrays(schema.dependentRequired)) && (schema.dependentSchemas === void 0 || isRecordOfSchemaLike(schema.dependentSchemas)) && isOptionalNumber(schema.minProperties) && isOptionalNumber(schema.maxProperties) && (schema.primaryKey === void 0 || isStringArray(schema.primaryKey)) && isOptionalString(schema.databaseSchema);
+}
+/**
+* Type guard for string schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a string schema, false otherwise.
+*/
+function isJsonSchemaString(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "string" && isOptionalNumber(schema.minLength) && isOptionalNumber(schema.maxLength) && isOptionalString(schema.pattern) && isOptionalString(schema.format) && isOptionalString(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetString$1)) && isOptionalString(schema.contentMediaType) && isOptionalString(schema.contentEncoding) && isOptionalString(schema.contentSchema);
+}
+/**
+* Type guard for set-like array schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a set-like array schema, false otherwise.
+*/
+function isJsonSchemaSet(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "array" && schema.uniqueItems === true && isOptionalJsonSchemaArray(schema.prefixItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for record schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a record schema, false otherwise.
+*/
+function isJsonSchemaRecord(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "object" && (schema.patternProperties === void 0 || isRecordOfSchemaLike(schema.patternProperties)) && (schema.additionalProperties === void 0 || isBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && isOptionalJsonSchema(schema.propertyNames);
+}
+/**
+* Type guard for tuple schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a tuple schema, false otherwise.
+*/
+function isJsonSchemaTuple(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "array" && isArrayOf(schema.prefixItems, isJsonSchema) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalBoolean(schema.uniqueItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for undefined-representing schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an undefined-representing schema, false otherwise.
+*/
+function isJsonSchemaUndefined(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isJsonSchemaAny(schema.not) && (schema.default === void 0 || schema.default === void 0);
+}
+/**
+* Type guard for primitive-union schema variants.
+*
+* @param input - The value to check.
+* @returns True if the input is a primitive-union schema variant, false otherwise.
+*/
+function isJsonSchemaPrimitiveUnion(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	if (isSetString$1(schema.type) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type)) {
+		if (schema.enum === void 0) return true;
+		if (!Array.isArray(schema.enum)) return false;
+		if (schema.type === "string") return schema.enum.every((value) => isSetString$1(value)) && (schema.default === void 0 || isSetString$1(schema.default));
+		if (schema.type === "number") return schema.enum.every((value) => isSetNumber(value)) && (schema.default === void 0 || isSetNumber(schema.default));
+		if (schema.type === "boolean") return schema.enum.every((value) => isBoolean(value)) && (schema.default === void 0 || isBoolean(schema.default));
+		if (schema.type === "integer") {
+			if (schema.format !== "int64") return false;
+			return schema.enum.every((value) => isSetBigint(value)) && (schema.default === void 0 || isSetBigint(schema.default));
+		}
+		return schema.type === "null" && schema.enum.every((value) => value === null) && (schema.default === void 0 || schema.default === null);
+	}
+	return isOptionalPrimitiveTypeArray(schema.type) && schema.type !== void 0;
+}
+/**
+* Type guard for union schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a union schema, false otherwise.
+*/
+function isJsonSchemaUnion(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && (isJsonSchemaPrimitiveUnion(schema) || isJsonSchemaAnyOf(schema));
+}
+/**
+* Type guard for permissive unknown schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a permissive unknown schema, false otherwise.
+*/
+function isJsonSchemaUnknown(input) {
+	return isJsonSchemaAny(input);
+}
+/**
+* Type guard for `anyOf` composition schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an `anyOf` schema, false otherwise.
+*/
+function isJsonSchemaAnyOf(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isArrayOf(schema.anyOf, isJsonSchema);
+}
+/**
+* Type guard for reference schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a reference schema, false otherwise.
+*/
+function isJsonSchemaRef(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isSetString$1(schema.$ref);
+}
+/**
+* Type guard for Standard Schema V1 objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Standard Schema V1 object, false otherwise.
+*/
+function isStandardSchema(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!isSetObject$1(schema["~standard"])) return false;
+	const standard = schema["~standard"];
+	return standard.version === 1 && isFunction(standard.validate);
+}
+/**
+* Type guard for Valibot BaseSchema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Valibot BaseSchema, false otherwise.
+*/
+function isValibotSchema(input) {
+	if (!isSetObject$1(input) || !isStandardSchema(input)) return false;
+	const schema = input;
+	return schema.kind === "schema" && isSetString$1(schema.type) && isBoolean(schema.async) && isFunction(schema.reference) && isSetString$1(schema.expects) && isFunction(schema["~run"]);
+}
+/**
+* Type guard for JSON Schema types.
+*
+* @remarks
+* This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema type, false otherwise.
+*/
+function isJsonSchema(input) {
+	return isJsonSchemaString(input) || isJsonSchemaInteger(input) || isJsonSchemaDecimal(input) || isJsonSchemaBigint(input) || isJsonSchemaBoolean(input) || isJsonSchemaDate(input) || isJsonSchemaEnum(input) || isJsonSchemaLiteral(input) || isJsonSchemaNativeEnum(input) || isJsonSchemaNull(input) || isJsonSchemaArray(input) || isJsonSchemaObject(input) || isJsonSchemaRecord(input) || isJsonSchemaTuple(input) || isJsonSchemaUnion(input) || isJsonSchemaUndefined(input) || isJsonSchemaRef(input) || isJsonSchemaNever(input) || isJsonSchemaMap(input) || isJsonSchemaAny(input) || isJsonSchemaNullable(input) || isJsonSchemaAllOf(input) || isJsonSchemaUnknown(input) || isJsonSchemaSet(input);
+}
+/**
+* Type guard for JSON Schemas that only accept `null`.
+*
+* @remarks
+* This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to "null". This is useful for identifying schemas that are specifically designed to allow only `null` values.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
+*/
+function isNullOnlyJsonSchema(input) {
+	return isJsonSchemaNull(input);
+}
+/**
+* Type guard for untyped schema objects.
+*
+* @remarks
+* This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped schema object, false otherwise.
+*/
+function isUntypedSchema(input) {
+	if (!isSetObject$1(input)) return false;
+	const schema = input;
+	if (!isUntypedTypeDescriptor(schema)) return false;
+	if ("id" in schema && !isSetString$1(schema.id)) return false;
+	if ("resolve" in schema && !isFunction(schema.resolve)) return false;
+	if ("properties" in schema && !isRecordOfUntypedSchema(schema.properties)) return false;
+	if ("required" in schema && !isStringArray(schema.required)) return false;
+	if ("title" in schema && !isSetString$1(schema.title)) return false;
+	if ("description" in schema && !isSetString$1(schema.description)) return false;
+	if ("$schema" in schema && !isSetString$1(schema.$schema)) return false;
+	if ("tags" in schema && !isStringArray(schema.tags)) return false;
+	if ("args" in schema && (!Array.isArray(schema.args) || !schema.args.every((item) => isUntypedFunctionArg(item)))) return false;
+	if ("returns" in schema && !isUntypedTypeDescriptor(schema.returns)) return false;
+	return true;
+}
+/**
+* Strict type guard for untyped schema objects.
+*
+* @remarks
+* This guard narrows values to the Untyped schema model while explicitly
+* rejecting values that are also valid JSON Schema instances.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped schema and not a JSON Schema.
+*/
+function isUntypedSchemaStrict(input) {
+	return isUntypedSchema(input) && !isJsonSchema(input);
+}
+/**
+* Type guard for untyped input objects.
+*
+* @remarks
+* This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped input object, false otherwise.
+*/
+function isUntypedConfig(input) {
+	if (!isSetObject$1(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && !isUntypedSchema(inputObject.$schema)) return false;
+	if ("$resolve" in inputObject && !isFunction(inputObject.$resolve)) return false;
+	return true;
+}
+/**
+* Strict type guard for untyped input objects.
+*
+* @remarks
+* This guard narrows values to the Untyped input-object model while
+* explicitly rejecting values that are valid JSON Schema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped input object and not JSON Schema.
+*/
+function isUntypedConfigStrict(input) {
+	if (!isUntypedConfig(input) || isJsonSchema(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && inputObject.$schema !== void 0 && !isUntypedSchemaStrict(inputObject.$schema)) return false;
+	return true;
+}
+/**
+* Type guard for Powerlines Schema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object, false otherwise.
+*/
+function isSchema(input) {
+	return isSetObject$1(input) && "schema" in input && isJsonSchema(input.schema) && "variant" in input && isSetString$1(input.variant) && "hash" in input && isSetString$1(input.hash);
+}
+/**
+* Type guard for Powerlines Schema objects with a specific type specification.
+*
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object with the specified type specification, false otherwise.
+*/
+function isSchemaOf(input) {
+	return isSchema(input);
+}
+/**
+* Type guard for extracted schema objects that include source information.
+*
+* @param input - The value to check.
+* @returns True if the input is a SchemaWithSource object, false otherwise.
+*/
+function isSchemaWithSource(input) {
+	return isSchema(input) && "source" in input && isSetObject$1(input.source) && "schema" in input.source && "variant" in input.source && isSetString$1(input.source.variant);
+}
+/**
+* Type guard for Powerlines Schemas that are in Object form.
+*
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object in Object form, false otherwise.
+*/
+function isSchemaObject(input) {
+	return isSchema(input) && isJsonSchemaObject(input.schema);
+}
+
+//#endregion
+//#region src/helpers.ts
+/**
+* Retrieves the JSON Schema from a Schema wrapper or returns the input if it's already a JSON Schema.
+*
+* @remarks
+* This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+*
+* @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+* @returns The JSON Schema object.
+* @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+*/
+function getJsonSchema(input) {
+	const schema = isSchema(input) ? input.schema : input;
+	if (!isJsonSchema(schema)) throw new TypeError(`The provided input is not a valid JSON Schema`);
+	return schema;
+}
+/**
+* Retrieves the JSON Schema in Object form from a Schema wrapper or returns the input if it's already a JSON Schema.
+*
+* @remarks
+* This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema object, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+*
+* @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+* @returns The JSON Schema object.
+* @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+*/
+function getJsonSchemaObject(input) {
+	const schema = getJsonSchema(input);
+	if (!isJsonSchemaObject(schema)) throw new TypeError(`The provided input is not a valid JSON Schema object`);
+	return schema;
+}
+/**
+* Extracts object properties from a JSON Schema object form.
+*
+* @remarks
+* This function returns an empty object if the schema is not an object form or if it has no properties.
+*
+* @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+* @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+*/
+function getProperties(obj) {
+	const schema = getJsonSchemaObject(obj);
+	if (!isSetObject$1(schema.properties)) return {};
+	return Object.entries(schema.properties).reduce((ret, [key, value]) => {
+		value.name = key;
+		value.required = !isPropertyOptional(schema, key);
+		value.default = schema.default?.[key] ?? value.default;
+		ret[key] = value;
+		return ret;
+	}, {});
+}
+/**
+* Returns object properties as an array.
+*
+* @remarks
+* This is a convenience function that extracts properties using `getProperties` and returns them as an array.
+*
+* @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+* @returns An array of JSON Schema fragments representing the properties, each including metadata.
+*/
+function getPropertiesList(obj) {
+	return Object.values(getProperties(obj));
+}
+/**
+* Extracts object properties from a JSON Schema object form.
+*
+* @remarks
+* This function returns an empty object if the schema is not an object form or if it has no properties.
+*
+* @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+* @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+*/
+function getProperty(obj, name) {
+	const schema = getJsonSchemaObject(obj);
+	if (!isSetObject$1(schema.properties)) throw new TypeError(`The provided schema does not have any properties`);
+	const property = schema.properties[name];
+	if (!property) throw new TypeError(`The provided schema does not have a property named "${name}"`);
+	return {
+		...property,
+		name,
+		required: !isPropertyOptional(schema, name),
+		default: schema.default?.[name] ?? property?.default
+	};
+}
+/**
+* Adds a property to a JSON Schema object form.
+*
+* @remarks
+* This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
+*
+* @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
+* @param name - The name of the property to add.
+* @param property - The JSON Schema fragment representing the property's schema, including metadata.
+* @throws Will throw an error if the provided schema is not an object form.
+*/
+function addProperty(obj, name, property) {
+	const schema = getJsonSchemaObject(obj);
+	schema.properties ??= {};
+	schema.required ??= [];
+	property.name = name;
+	schema.properties[name] = property;
+	if (!schema.required.includes(name)) schema.required.push(name);
+	if (schema.required.length === 0) delete schema.required;
+}
+/**
+* Recursively merges two JSON Schema fragments. `override` wins for any scalar
+* key that both schemas define, while structured keywords are handled
+* specially:
+*
+* - `properties`, `patternProperties`, `$defs`, `definitions`,
+*   `dependentSchemas` — each matching child schema is merged recursively.
+* - `allOf`, `anyOf`, `oneOf` — arrays are concatenated.
+* - `if`, `then`, `else`, `not`, `contains`, `items`,
+*   `additionalProperties`, `unevaluatedProperties`, `propertyNames`,
+*   `unevaluatedItems` — merged recursively when both sides are schemas.
+* - `required` — arrays are union'ed and deduplicated.
+*/
+function mergeTwo(base, override) {
+	const result = { ...base };
+	for (const [key, overrideValue] of Object.entries(override)) {
+		const baseValue = result[key];
+		if (key === "required") result[key] = getUnique([...Array.isArray(baseValue) ? baseValue : [], ...Array.isArray(overrideValue) ? overrideValue : []]);
+		else if (SCHEMA_RECORD_KEYWORDS.has(key) && isSetObject$1(baseValue) && isSetObject$1(overrideValue)) {
+			const merged = { ...baseValue };
+			for (const [childKey, childOverride] of Object.entries(overrideValue)) {
+				const childBase = merged[childKey];
+				merged[childKey] = isJsonSchema(childBase) && isJsonSchema(childOverride) ? mergeTwo(childBase, childOverride) : childOverride;
+			}
+			result[key] = merged;
+		} else if (SCHEMA_ARRAY_CONCAT_KEYWORDS.has(key) && Array.isArray(baseValue) && Array.isArray(overrideValue)) result[key] = [...baseValue, ...overrideValue];
+		else if (SCHEMA_SINGLE_KEYWORDS.has(key) && isJsonSchema(baseValue) && isJsonSchema(overrideValue)) result[key] = mergeTwo(baseValue, overrideValue);
+		else result[key] = overrideValue;
+	}
+	return result;
+}
+/**
+* Merges multiple JSON Schemas into one.
+*
+* @remarks
+* This function takes multiple JSON Schemas or Schema wrappers and merges them
+* into a single JSON Schema object. Later schemas in the argument list take
+* precedence over earlier ones for scalar conflicts.
+*
+* Structured keywords are merged recursively:
+* - Named child schemas (`properties`, `$defs`, etc.) are merged
+*   per-property via recursive calls to `merge`.
+* - Composition arrays (`allOf`, `anyOf`, `oneOf`) are concatenated.
+* - Single-schema keywords (`if`, `then`, `else`, `not`, `items`, etc.)
+*   are merged recursively when both sides define them.
+* - `required` arrays are union'ed and deduplicated.
+*
+* @param schemas - An array of JSON Schemas or Schema wrappers to merge.
+* @returns A new JSON Schema that is the result of merging all input schemas.
+*/
+function merge(...schemas) {
+	const jsonSchemas = schemas.map((s) => getJsonSchema(s));
+	if (jsonSchemas.length === 0) return {};
+	return jsonSchemas.reduce((acc, schema) => {
+		const accType = acc.type;
+		const schemaType = schema.type;
+		if (accType && schemaType && accType !== schemaType) return schema;
+		return mergeTwo(acc, schema);
+	});
+}
+/**
+* Merges metadata into a JSON Schema fragment.
+*
+* @remarks
+* This function takes a JSON Schema fragment and a metadata object, and merges the metadata into the schema. Only the keys defined in {@link JSON_SCHEMA_METADATA_KEYS} are considered for merging. The resulting schema will include the original schema properties along with the provided metadata.
+*
+* @param schema - The JSON Schema fragment to merge metadata into.
+* @param metadata - The metadata to merge into the schema.
+* @returns A new JSON Schema fragment that includes the merged metadata.
+*/
+function mergeMetadata(schema, metadata) {
+	return defu(schema, Object.fromEntries(JSON_SCHEMA_METADATA_KEYS.filter((key) => metadata[key] !== void 0).map((key) => [key, metadata[key]])));
+}
+/**
+* Returns whether a JSON Schema fragment accepts `null`.
+*
+* @remarks
+* This is true if the schema has `nullable: true` or if its `type` includes `"null"`.
+*
+* @param schema - The JSON Schema fragment to check.
+* @returns `true` if the schema accepts `null`, otherwise `false`.
+*/
+function isSchemaNullable(schema) {
+	if (!isSetObject$1(schema)) return false;
+	if (schema.nullable === true) return true;
+	return readSchemaTypes(schema).includes("null");
+}
+/**
+* Returns whether an object property is optional (not listed in `required`).
+*
+* @remarks
+* In JSON Schema, object properties are optional by default unless they are listed in the `required` array of the parent schema. This function checks whether a given property name is not included in the `required` array of its parent schema, indicating that it is optional.
+*
+* @param parent - The parent JSON Schema object containing the property.
+* @param propertyName - The name of the property to check for optionality.
+* @returns `true` if the property is optional, otherwise `false`.
+*/
+function isPropertyOptional(parent, propertyName) {
+	if (!parent.properties?.[propertyName]) throw new Error(`The property "${propertyName}" does not exist in the parent schema.`);
+	return !(parent.required ?? []).includes(propertyName);
+}
+/**
+* Checks if a given file name has a valid schema input file extension.
+*
+* @param fileName - The file name to check for a valid schema input extension.
+* @returns `true` if the file name has a valid schema input extension, otherwise `false`.
+*/
+function isValidSchemaConfigFile(fileName) {
+	return VALID_OBJECT_SOURCE_EXTENSIONS.includes(findFileExtensionSafe(fileName));
+}
+/**
+* Traverses a JSON Schema and applies a callback function to each schema fragment.
+*
+* @remarks
+* This function recursively traverses a JSON Schema, including nested schemas in properties, composition keywords (`allOf`, `anyOf`, `oneOf`), and other schema keywords. The provided callback function is invoked for each schema fragment encountered during the traversal. The results of the callback are collected and returned as an array.
+*
+* @param schema - The JSON Schema to traverse.
+* @param callback - The callback function to apply to each schema fragment.
+* @returns An array of results returned by the callback function.
+*/
+function traverseSchema(schema, callback) {
+	const results = [];
+	function traverse(schema) {
+		const result = callback(schema);
+		if (result !== void 0) results.push(result);
+		if (isJsonSchemaObject(schema)) for (const propSchema of Object.values(schema.properties ?? {})) traverse(propSchema);
+		for (const keyword of [
+			"allOf",
+			"anyOf",
+			"oneOf",
+			"not",
+			"if",
+			"then",
+			"else",
+			"$ref",
+			"items",
+			"additionalProperties",
+			"unevaluatedProperties",
+			"propertyNames",
+			"unevaluatedItems",
+			"contains"
+		]) {
+			const value = schema[keyword];
+			if (Array.isArray(value)) {
+				for (const subSchema of value) if (isJsonSchema(subSchema)) traverse(subSchema);
+			} else if (isJsonSchema(value)) traverse(value);
+		}
+	}
+	traverse(schema);
+	return results;
+}
+
+//#endregion
+export { isUntypedSchema as $, isJsonSchemaNull as A, isJsonSchemaTuple as B, isJsonSchemaEnum as C, isJsonSchemaMap as D, isJsonSchemaLiteral as E, isJsonSchemaPrimitiveUnion as F, isNullOnlyJsonSchema as G, isJsonSchemaUndefined as H, isJsonSchemaRecord as I, isSchemaOf as J, isSchema as K, isJsonSchemaRef as L, isJsonSchemaNumber as M, isJsonSchemaObject as N, isJsonSchemaNativeEnum as O, isJsonSchemaPrimitiveType as P, isUntypedConfigStrict as Q, isJsonSchemaSet as R, isJsonSchemaDecimal as S, isJsonSchemaKeywords as T, isJsonSchemaUnion as U, isJsonSchemaType as V, isJsonSchemaUnknown as W, isStandardSchema as X, isSchemaWithSource as Y, isUntypedConfig as Z, isJsonSchemaAnyOf as _, getPropertiesList as a, isJsonSchemaBoolean as b, isSchemaNullable as c, mergeMetadata as d, isUntypedSchemaStrict as et, traverseSchema as f, isJsonSchemaAny as g, isJsonSchemaAllOf as h, getProperties as i, readSchemaTypes as it, isJsonSchemaNullable as j, isJsonSchemaNever as k, isValidSchemaConfigFile as l, isJsonSchema as m, getJsonSchema as n, applyJsonSchemaMetadata as nt, getProperty as o, isFileReference as p, isSchemaObject as q, getJsonSchemaObject as r, getPrimarySchemaType as rt, isPropertyOptional as s, addProperty as t, isValibotSchema as tt, merge as u, isJsonSchemaArray as v, isJsonSchemaInteger as w, isJsonSchemaDate as x, isJsonSchemaBigint as y, isJsonSchemaString as z };
+//# sourceMappingURL=helpers-reqtcaa8.mjs.map