@depup/typebox 1.1.6-depup.0

package/build/schema/index.mjs

@@ -0,0 +1,9 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './schema.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import * as Schema from './schema.mjs';
+export default Schema;

package/build/schema/parse.d.mts

@@ -0,0 +1,13 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
+export declare class ParseError {
+    schema: Schema.XSchema;
+    value: unknown;
+    errors: TLocalizedValidationError[];
+    constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
+}
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static.XStatic<Schema>;
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static.XStatic<Schema>;

package/build/schema/parse.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Check } from './check.mjs';
+import { Errors } from './errors.mjs';
+// ------------------------------------------------------------------
+// ParseError
+// ------------------------------------------------------------------
+export class ParseError {
+    constructor(schema, value, errors) {
+        this.schema = schema;
+        this.value = value;
+        this.errors = errors;
+    }
+}
+/** Parses a value against the provided schema */
+export function Parse(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    if (!Check(context, schema, value)) {
+        const [_result, errors] = Errors(context, schema, value);
+        throw new ParseError(schema, value, errors);
+    }
+    return value;
+}

package/build/schema/pointer/index.d.mts

@@ -0,0 +1,2 @@
+export * from './pointer-get.mjs';
+export * as Pointer from './pointer.mjs';

package/build/schema/pointer/index.mjs

@@ -0,0 +1,2 @@
+export * from './pointer-get.mjs';
+export * as Pointer from './pointer.mjs';

package/build/schema/pointer/pointer-get.d.mts

@@ -0,0 +1,9 @@
+type TEscape0<Index extends string> = Index extends `${infer Left}~0${infer Right}` ? `${Left}~${TEscape<Right>}` : Index;
+type TEscape1<Index extends string> = Index extends `${infer Left}~1${infer Right}` ? `${Left}/${TEscape<Right>}` : Index;
+type TEscape<Index extends string, Escaped0 extends string = TEscape0<Index>, Escaped1 extends string = TEscape1<Escaped0>> = Escaped1;
+type IndicesReduce<Pointer extends string, Result extends string[] = []> = (Pointer extends `${infer Left extends string}/${infer Right extends string}` ? Left extends '' ? IndicesReduce<Right, Result> : IndicesReduce<Right, [...Result, TEscape<Left>]> : [...Result, TEscape<Pointer>]);
+type TIndices<Pointer extends string, Result extends string[] = Pointer extends '' ? [] : IndicesReduce<Pointer>> = Result;
+type TResolve<Value extends unknown, Indices extends string[]> = (Indices extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Value ? TResolve<Value[Left], Right> : undefined : Value);
+/** Type Level RFC 6901 Json Pointer Resolver */
+export type XPointerGet<Value extends unknown, Pointer extends string, Indices extends string[] = TIndices<Pointer>, Result extends unknown = TResolve<Value, Indices>> = Result;
+export {};

package/build/schema/pointer/pointer-get.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/pointer/pointer.d.mts

@@ -0,0 +1,10 @@
+/** Returns an array of path indices for the given pointer */
+export declare function Indices(pointer: string): string[];
+/** Returns true if a value exists at the current pointer */
+export declare function Has(value: unknown, pointer: string): unknown;
+/** Gets a value at the pointer, or undefined if not exists */
+export declare function Get(value: unknown, pointer: string): unknown;
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export declare function Delete(value: unknown, pointer: string): unknown;

package/build/schema/pointer/pointer.mjs

@@ -0,0 +1,96 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Asserts
+// ------------------------------------------------------------------
+function AssertNotRoot(indices) {
+    if (indices.length === 0)
+        throw Error('Cannot set root');
+}
+function AssertCanSet(value) {
+    if (!Guard.IsObject(value))
+        throw Error('Cannot set value');
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+function IsNumericIndex(index) {
+    return /^(0|[1-9]\d*)$/.test(index);
+}
+function TakeIndexRight(indices) {
+    return [
+        indices.slice(0, indices.length - 1),
+        indices.slice(indices.length - 1)[0]
+    ];
+}
+function HasIndex(index, value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
+}
+function GetIndex(index, value) {
+    return Guard.IsObject(value) ? value[index] : undefined;
+}
+function GetIndices(indices, value) {
+    return indices.reduce((value, index) => GetIndex(index, value), value);
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+/** Returns an array of path indices for the given pointer */
+export function Indices(pointer) {
+    if (Guard.IsEqual(pointer.length, 0))
+        return [];
+    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if a value exists at the current pointer */
+export function Has(value, pointer) {
+    let current = value;
+    return Indices(pointer).every(index => {
+        if (!HasIndex(index, current))
+            return false;
+        current = current[index];
+        return true;
+    });
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a value at the pointer, or undefined if not exists */
+export function Get(value, pointer) {
+    const indices = Indices(pointer);
+    return GetIndices(indices, value);
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export function Set(value, pointer, next) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    parent[index] = next;
+    return value;
+}
+// ------------------------------------------------------------------
+// Delete
+// ------------------------------------------------------------------
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export function Delete(value, pointer) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
+        parent.splice(+index, 1);
+    }
+    else {
+        delete parent[index];
+    }
+    return value;
+}

package/build/schema/resolve/index.d.mts

@@ -0,0 +1 @@
+export * as Resolve from './resolve.mjs';

package/build/schema/resolve/index.mjs

@@ -0,0 +1 @@
+export * as Resolve from './resolve.mjs';

package/build/schema/resolve/ref.d.mts

@@ -0,0 +1,2 @@
+import * as Schema from '../types/index.mjs';
+export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;

package/build/schema/resolve/ref.mjs

@@ -0,0 +1,96 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// Match: Id
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    if (schema.$id === ref.hash)
+        return schema;
+    const absoluteId = new URL(schema.$id, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Anchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteAnchor.href, absoluteRef.href))
+        return schema;
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Hash
+// ------------------------------------------------------------------
+function MatchHash(schema, base, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    return ref.hash.startsWith('#')
+        ? Pointer.Get(schema, decodeURIComponent(ref.hash.slice(1)))
+        : undefined;
+}
+// ------------------------------------------------------------------
+// Match
+// ------------------------------------------------------------------
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function FromObject(schema, base, ref) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        const match = FromValue(schema[key], base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(schema, base, ref) {
+    base = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
+    if (Schema.IsSchemaObject(schema)) {
+        const result = Match(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Guard.IsArray(schema))
+        return FromArray(schema, base, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, base, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export function Ref(schema, ref) {
+    const defaultBase = new URL('http://unknown');
+    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, defaultBase.href) : defaultBase;
+    const initialRef = new URL(ref, initialBase.href);
+    return FromValue(schema, initialBase, initialRef);
+}

package/build/schema/resolve/resolve.d.mts

@@ -0,0 +1 @@
+export * from './ref.mjs';

package/build/schema/resolve/resolve.mjs

@@ -0,0 +1 @@
+export * from './ref.mjs';

package/build/schema/schema.d.mts

@@ -0,0 +1,10 @@
+export * from './engine/index.mjs';
+export * from './pointer/index.mjs';
+export * from './resolve/index.mjs';
+export * from './static/index.mjs';
+export * from './types/index.mjs';
+export * from './build.mjs';
+export * from './compile.mjs';
+export * from './check.mjs';
+export * from './parse.mjs';
+export * from './errors.mjs';

package/build/schema/schema.mjs

@@ -0,0 +1,10 @@
+export * from './engine/index.mjs';
+export * from './pointer/index.mjs';
+export * from './resolve/index.mjs';
+export * from './static/index.mjs';
+export * from './types/index.mjs';
+export * from './build.mjs';
+export * from './compile.mjs';
+export * from './check.mjs';
+export * from './parse.mjs';
+export * from './errors.mjs';

package/build/schema/static/additionalProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAdditionalProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Stack, Root, Schema>;
+})> = Result;

package/build/schema/static/additionalProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/allOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAllOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = unknown> = (Schemas extends readonly [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAllOf<Stack, Root, Right, Result & XStaticSchema<Stack, Root, Left>> : Result);

package/build/schema/static/allOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/anyOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticAnyOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAnyOf<Stack, Root, Right, XStaticSchema<Stack, Root, Left> | Result> : Result);

package/build/schema/static/anyOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/const.d.mts

@@ -0,0 +1 @@
+export type XStaticConst<Value extends unknown> = Value;

package/build/schema/static/const.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/enum.d.mts

@@ -0,0 +1 @@
+export type XStaticEnum<Values extends unknown[], Result extends unknown = never> = (Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XStaticEnum<Right, Left | Result> : Result);

package/build/schema/static/enum.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/if.d.mts

@@ -0,0 +1,15 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XElse } from '../types/else.mjs';
+import type { XThen } from '../types/then.mjs';
+export type XStaticIf<Stack extends string[], Root extends XSchema, Schema extends XIf, IfSchema extends XSchema, If extends unknown = XStaticSchema<Stack, Root, IfSchema>, Then extends unknown = Schema extends XThen<infer ThenSchema extends XSchema> ? XStaticSchema<Stack, Root, ThenSchema> : never, Else extends unknown = Schema extends XElse<infer ElseSchema extends XSchema> ? XStaticSchema<Stack, Root, ElseSchema> : never, IsThen extends boolean = Schema extends XThen ? true : false, IsElse extends boolean = Schema extends XElse ? true : false, Result extends unknown = ([
+    IsThen,
+    IsElse
+] extends [true, true] ? (If & Then) | Exclude<Else, If> : [
+    IsThen,
+    IsElse
+] extends [true, false] ? (If & Then) : [
+    IsThen,
+    IsElse
+] extends [false, true] ? Exclude<Else, If> : unknown)> = Result;

package/build/schema/static/if.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/index.d.mts

@@ -0,0 +1 @@
+export type { XStatic } from './static.mjs';

package/build/schema/static/index.mjs

@@ -0,0 +1 @@
+export {};

package/build/schema/static/items.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XStaticElements } from './~elements.mjs';
+type XFromSized<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[]> = (XStaticElements<Stack, Root, Schema, Items>);
+type XFromUnsized<Stack extends string[], Root extends XSchema, Schema extends XSchema> = (XStaticSchema<Stack, Root, Schema>[]);
+export type XStaticItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[] | XSchema, Result extends unknown = (Items extends XSchema[] ? XFromSized<Stack, Root, Schema, [...Items]> : Items extends XSchema ? XFromUnsized<Stack, Root, Items> : never)> = Result;
+export {};

package/build/schema/static/items.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/oneOf.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticOneOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticOneOf<Stack, Root, Right, XStaticSchema<Stack, Root, Left> | Result> : Result);

package/build/schema/static/oneOf.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/patternProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPatternProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>, InferredProperties extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: XStaticSchema<Stack, Root, Properties[Key]>;
+}, EvaluatedProperties extends unknown = {
+    [key: string]: InferredProperties[keyof InferredProperties];
+}> = EvaluatedProperties;

package/build/schema/static/patternProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/prefixItems.d.mts

@@ -0,0 +1,3 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticElements } from './~elements.mjs';
+export type XStaticPrefixItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], Result extends unknown[] = XStaticElements<Stack, Root, Schema, PrefixItems>> = Result;

package/build/schema/static/prefixItems.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/properties.d.mts

@@ -0,0 +1,11 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+import type { XIsReadonly } from './~readonly.mjs';
+type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
+    readonly [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+type XOptionalProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>> = {
+    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? never : Key]?: XStaticSchema<Stack, Root, Properties[Key]>;
+};
+export type XStaticProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, ReadonlyOptional extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Properties>, Optional extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Properties>, Result extends Record<PropertyKey, unknown> = ReadonlyOptional & Optional> = Result;
+export {};

package/build/schema/static/properties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/ref.d.mts

@@ -0,0 +1,8 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XPointerGet } from '../pointer/pointer-get.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XCyclicCheck<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : XCyclicCheck<Right, MaxLength, [...Buffer, Left]> : true);
+type XCyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? XCyclicCheck<Stack, 2> : true);
+type XNormal<Pointer extends string, Result extends string = (Pointer extends `#${infer Rest extends string}` ? Rest : Pointer)> = Result;
+export type XStaticRef<Stack extends string[], Root extends XSchema, Ref extends string, Normal extends string = XNormal<Ref>, Target extends unknown = XPointerGet<Root, Normal>, Schema extends XSchema = Target extends XSchema ? Target : {}, Result extends unknown = (XCyclicGuard<Stack, Ref> extends true ? XStaticSchema<[...Stack, Ref], Root, Schema> : any)> = Result;
+export {};

package/build/schema/static/ref.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/required.d.mts

@@ -0,0 +1,13 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { XIsReadonly } from './~readonly.mjs';
+import type { XStaticSchema } from './schema.mjs';
+type XResolveProperties<Schema extends XSchema, Result extends Record<PropertyKey, XSchema> = (Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? Properties : {})> = Result;
+type XFromKey<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Key extends string, Readonly extends boolean = Key extends keyof Properties ? XIsReadonly<Properties[Key]> : false, Value extends unknown = Key extends keyof Properties ? XStaticSchema<Stack, Root, Properties[Key]> : unknown, Result extends Record<PropertyKey, unknown> = (Readonly extends true ? {
+    readonly [_ in Key]: Value;
+} : {
+    [_ in Key]: Value;
+})> = Result;
+type XFromKeys<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema>, Keys extends string[], Result extends Record<PropertyKey, unknown> = {}> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? XFromKeys<Stack, Root, Properties, Right, Result & XFromKey<Stack, Root, Properties, Left>> : Result);
+export type XStaticRequired<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keys extends string[], Properties extends Record<PropertyKey, XSchema> = XResolveProperties<Schema>, Result extends Record<PropertyKey, unknown> = XFromKeys<Stack, Root, Properties, Keys>> = Result;
+export {};

package/build/schema/static/required.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/schema.d.mts

@@ -0,0 +1,55 @@
+import type { XAdditionalProperties } from '../types/additionalProperties.mjs';
+import type { XAnyOf } from '../types/anyOf.mjs';
+import type { XAllOf } from '../types/allOf.mjs';
+import type { XConst } from '../types/const.mjs';
+import type { XEnum } from '../types/enum.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XItems } from '../types/items.mjs';
+import type { XOneOf } from '../types/oneOf.mjs';
+import type { XPatternProperties } from '../types/patternProperties.mjs';
+import type { XPrefixItems } from '../types/prefixItems.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { XRef } from '../types/ref.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XSchema } from '../types/schema.mjs';
+import type { XType } from '../types/type.mjs';
+import type { XUnevaluatedProperties } from '../types/unevaluatedProperties.mjs';
+import type { XStaticAdditionalProperties } from './additionalProperties.mjs';
+import type { XStaticAllOf } from './allOf.mjs';
+import type { XStaticAnyOf } from './anyOf.mjs';
+import type { XStaticConst } from './const.mjs';
+import type { XStaticEnum } from './enum.mjs';
+import type { XStaticIf } from './if.mjs';
+import type { XStaticItems } from './items.mjs';
+import type { XStaticOneOf } from './oneOf.mjs';
+import type { XStaticPatternProperties } from './patternProperties.mjs';
+import type { XStaticPrefixItems } from './prefixItems.mjs';
+import type { XStaticProperties } from './properties.mjs';
+import type { XStaticRef } from './ref.mjs';
+import type { XStaticRequired } from './required.mjs';
+import type { XStaticType } from './type.mjs';
+import type { XStaticUnevaluatedProperties } from './unevaluatedProperties.mjs';
+type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown[] = [
+    Schema extends XAdditionalProperties<infer Type extends XSchema> ? XStaticAdditionalProperties<Stack, Root, Type> : unknown,
+    Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
+    Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
+    Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
+    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
+    Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
+    Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Properties> : unknown,
+    Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
+    Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
+    Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,
+    Schema extends XUnevaluatedProperties<infer Type extends XSchema> ? XStaticUnevaluatedProperties<Stack, Root, Type> : unknown
+]> = Result;
+type XKeywordsIntersected<Schemas extends unknown[], Result extends unknown = unknown> = (Schemas extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XKeywordsIntersected<Right, Result & Left> : Result);
+type XKeywordsEvaluated<Schema extends unknown, Result extends unknown = Schema extends object ? {
+    [Key in keyof Schema]: Schema[Key];
+} : Schema> = Result;
+export type XStaticObject<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keywords extends unknown[] = XFromKeywords<Stack, Root, Schema>, Intersected extends unknown = XKeywordsIntersected<Keywords>, Evaluated extends unknown = XKeywordsEvaluated<Intersected>> = Evaluated;
+export type XStaticBoolean<Schema extends boolean, Result extends unknown = Schema extends false ? never : unknown> = Result;
+export type XStaticSchema<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown = Schema extends boolean ? XStaticBoolean<Schema> : XStaticObject<Stack, Root, Schema>> = Result;
+export {};

package/build/schema/static/schema.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/static.d.mts

@@ -0,0 +1,4 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XNonReadonly } from './~non-readonly.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, NonReadonly extends XSchema = XNonReadonly<Schema>, Result extends unknown = XStaticSchema<[], NonReadonly, NonReadonly>> = Result;

package/build/schema/static/static.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/type.d.mts

@@ -0,0 +1,4 @@
+type XFromTypeNames<TypeNames extends string[], Result extends unknown = never> = (TypeNames extends readonly [infer Left extends string, ...infer Right extends string[]] ? XFromTypeNames<Right, Result | XFromTypeName<Left>> : Result);
+type XFromTypeName<TypeName extends string> = (TypeName extends 'object' ? object : TypeName extends 'array' ? {} : TypeName extends 'boolean' ? boolean : TypeName extends 'integer' ? number : TypeName extends 'number' ? number : TypeName extends 'null' ? null : TypeName extends 'string' ? string : TypeName extends 'bigint' ? bigint : TypeName extends 'symbol' ? symbol : TypeName extends 'undefined' ? undefined : TypeName extends 'void' ? void : TypeName extends 'asyncIterator' ? {} : TypeName extends 'constructor' ? {} : TypeName extends 'function' ? {} : TypeName extends 'iterator' ? {} : unknown);
+export type XStaticType<TypeName extends string[] | string> = (TypeName extends string[] ? XFromTypeNames<TypeName> : TypeName extends string ? XFromTypeName<TypeName> : unknown);
+export {};

package/build/schema/static/type.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/unevaluatedProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticUnevaluatedProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Stack, Root, Schema>;
+})> = Result;

package/build/schema/static/unevaluatedProperties.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/~comparer.d.mts

@@ -0,0 +1,6 @@
+type XBuildTuple<Size extends number, Tuple extends unknown[] = []> = (Tuple['length'] extends Size ? Tuple : XBuildTuple<Size, [...Tuple, unknown]>);
+export type XLessThan<Left extends number, Right extends number> = Left extends Right ? false : XBuildTuple<Left> extends [...XBuildTuple<Right>, ...infer _Rest] ? false : true;
+export type XLessThanEqual<Left extends number, Right extends number> = (Left extends Right ? true : XLessThan<Left, Right>);
+export type XGreaterThan<Left extends number, Right extends number> = (XLessThan<Right, Left>);
+export type XGreaterThanEqual<Left extends number, Right extends number> = (XLessThanEqual<Right, Left>);
+export {};

package/build/schema/static/~comparer.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};