zeed 1.2.4 → 1.3.1

package/dist/common/schema/schema.d.cts

@@ -1,213 +1,2 @@
-/**
- * Metadata interface for type descriptions and additional properties
- */
-interface TypeMeta {
-    desc?: string;
-}
-/**
- * Core Type class for schema validation and type inference
- * Implements StandardSchemaV1 for cross-library compatibility
- */
-declare class Type<T = unknown> {
-    readonly type: string;
-    _default?: any;
-    _optional?: boolean;
-    _meta?: TypeMeta;
-    _check?: (obj: any) => boolean;
-    _object?: any;
-    _type?: any;
-    _union?: any;
-    _enumValues?: any;
-    _args?: any;
-    _ret?: any;
-    _info?: any;
-    constructor(name: string, options?: Partial<Type<T>>);
-    /**
-     * Standard Schema V1 compliance property
-     * Provides a standard interface for validation and type inference
-     */
-    get '~standard'(): any;
-    /**
-     * Validation method for standard-schema compliance
-     */
-    validate(value: any): any;
-    /**
-     * Creates a copy of the type with new properties merged
-     */
-    private _cloneWithProps;
-    /**
-     * Helper to copy type properties when creating new type instances
-     */
-    private static _copyTypeProperties;
-    /**
-     * Marks the type as optional, meaning it can be undefined
-     * This is useful for properties that are not required.
-     */
-    optional(): Type<T | undefined>;
-    /**
-     * Sets a default value for the type, which will be used if the value is not provided
-     * The default value can be a function that receives the schema as argument, or a static value.
-     */
-    default(value: T | ((schema?: this) => T)): Type<T>;
-    /**
-     * Props / Metadata for the type, like description or other properties
-     */
-    meta(meta: TypeMeta): Type<T>;
-    /**
-     * Sets the `desc` property for the type, which is a human-readable description
-     */
-    describe(msg: string): Type<T>;
-    /**
-     * Extends the type with an object, merging the properties
-     */
-    extend<O>(obj: O): Type<T & TypeObject<O>>;
-    /**
-     * Picks certain keys from an object schema
-     */
-    pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>>;
-    /**
-     * Omits certain keys from an object schema
-     */
-    omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>>;
-    /**
-     * Helper method to modify object properties with a transformation function
-     */
-    private _transformObjectProperties;
-    /**
-     * Makes some or all properties of an object schema optional
-     */
-    partial(): Type<Partial<T>>;
-    partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>;
-    /**
-     * Makes some or all properties of an object schema required
-     */
-    required(): Type<Required<T>>;
-    required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>;
-    /**
-     * Helper method to clone a type with optional flag
-     */
-    private static _cloneTypeWithOptional;
-}
-/**
- * Type inference utility for extracting the TypeScript type from a schema Type
- */
-type Infer<T> = T extends Type<infer TT> ? TT : never;
-/**
- * Creates a string type validator
- */
-declare function string(): Type<string>;
-/**
- * Creates a number type validator
- */
-declare function number(): Type<number>;
-/**
- * Creates an integer type validator
- */
-declare function int(): Type<number>;
-/**
- * Creates a boolean type validator
- */
-declare function boolean(): Type<boolean>;
-/**
- * Creates a none type validator (undefined | null)
- * Like undefined | null in TS and nil in Swift
- */
-declare function none(): Type<undefined>;
-/**
- * Creates an any type validator that accepts any non-null value
- */
-declare function any<T = any>(): Type<T>;
-declare const float: typeof number;
-declare const double: typeof number;
-declare const real: typeof number;
-/**
- * Utility type to make object properties optional if their value type includes undefined.
- * @category Schema
- */
-type TypeObjectFixOptional<T> = {
-    [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {};
-} & {
-    [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {};
-};
-/**
- * Utility type for pretty-printing object types
- */
-type TypeObjectPretty<V> = Extract<{
-    [K in keyof V]: V[K];
-}, unknown>;
-/**
- * Main object type utility
- */
-type TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{
-    [K in keyof T]: Infer<T[K]>;
-}>>;
-/**
- * Creates an object type validator with specified properties
- */
-declare function object<T>(tobj: T): Type<TypeObject<T>>;
-/**
- * Creates a record type validator (object with string keys and uniform value type)
- */
-declare function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>>;
-/**
- * Utility type for union of types.
- * @category Schema
- */
-type TypeUnion<T extends Type<any>[]> = {
-    [K in keyof T]: T[K] extends Type<infer U> ? U : never;
-}[number];
-/**
- * Creates a union type validator (like `string | number | boolean`)
- */
-declare function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>>;
-/**
- * Utility type for literal types.
- * @category Schema
- */
-type TypeLiterals = string | number | bigint | boolean;
-/**
- * Creates a literal value validator
- */
-declare function literal<T extends TypeLiterals>(value: T): Type<T>;
-/**
- * Creates a string literal union validator (like `"a" | "b" | "c"`)
- */
-declare function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]>;
-/**
- * Utility type for tuple types.
- * @category Schema
- */
-type TypeTuple<T extends readonly Type[]> = {
-    -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never;
-};
-/**
- * Output type for TypeArray.
- * @category Schema
- */
-type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [
-    ...TypeTuple<Head>,
-    ...(Rest extends Type ? Infer<Rest>[] : [])
-];
-/**
- * Utility type for array types.
- * @category Schema
- */
-type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>;
-/**
- * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]
- */
-declare function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>>;
-/**
- * Creates an array type validator for a specific item type
- */
-declare function array<T>(itemType: Type<T>): Type<T[]>;
-/**
- * Creates a regular function type validator
- */
-declare function func<TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [], TypeFuncRet = Type, T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T>;
-/**
- * Creates an RPC function type validator that takes one argument and returns a promise
- */
-declare function rpc<TypeRpcInfo extends Type<unknown> | undefined = undefined, TypeRpcRet extends Type<unknown> = Type<void>, T = TypeRpcInfo extends undefined ? () => Infer<TypeRpcRet> : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T>;
-
-export { type Infer, Type, type TypeArray, type TypeArrayOutput, type TypeLiterals, type TypeMeta, type TypeObjectFixOptional, type TypeTuple, type TypeUnion, any, array, boolean, double, float, func, int, literal, none, number, object, real, record, rpc, string, stringLiterals, tuple, union };
+import { C as rpc, D as union, E as tuple, S as record, T as stringLiterals, _ as literal, a as TypeLiterals, b as object, c as TypeTuple, d as array, f as boolean, g as int, h as func, i as TypeArrayOutput, l as TypeUnion, m as float, n as Type, o as TypeMeta, p as double, r as TypeArray, s as TypeObjectFixOptional, t as Infer, u as any, v as none, w as string, x as real, y as number } from "../../schema-BNke0iHR.cjs";
+export { Infer, Type, TypeArray, TypeArrayOutput, TypeLiterals, TypeMeta, TypeObjectFixOptional, TypeTuple, TypeUnion, any, array, boolean, double, float, func, int, literal, none, number, object, real, record, rpc, string, stringLiterals, tuple, union };

package/dist/common/schema/schema.d.mts

@@ -0,0 +1,2 @@
+import { C as rpc, D as union, E as tuple, S as record, T as stringLiterals, _ as literal, a as TypeLiterals, b as object, c as TypeTuple, d as array, f as boolean, g as int, h as func, i as TypeArrayOutput, l as TypeUnion, m as float, n as Type, o as TypeMeta, p as double, r as TypeArray, s as TypeObjectFixOptional, t as Infer, u as any, v as none, w as string, x as real, y as number } from "../../schema-eMFkYY24.mjs";
+export { Infer, Type, TypeArray, TypeArrayOutput, TypeLiterals, TypeMeta, TypeObjectFixOptional, TypeTuple, TypeUnion, any, array, boolean, double, float, func, int, literal, none, number, object, real, record, rpc, string, stringLiterals, tuple, union };

package/dist/common/schema/schema.mjs

@@ -0,0 +1,405 @@
+import { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from "../data/is.mjs";
+
+//#region src/common/schema/schema.ts
+/**
+* Core Type class for schema validation and type inference
+* Implements StandardSchemaV1 for cross-library compatibility
+*/
+var Type = class Type {
+	type;
+	_default;
+	_optional;
+	_meta;
+	_check;
+	_object;
+	_type;
+	_union;
+	_enumValues;
+	_args;
+	_ret;
+	_info;
+	constructor(name, options = {}) {
+		this.type = name;
+		Object.assign(this, options);
+	}
+	/**
+	* Standard Schema V1 compliance property
+	* Provides a standard interface for validation and type inference
+	*/
+	get "~standard"() {
+		return {
+			version: 1,
+			vendor: "zeed",
+			validate: (value) => {
+				return this.validate(value);
+			},
+			types: {
+				input: void 0,
+				output: void 0
+			}
+		};
+	}
+	/**
+	* Validation method for standard-schema compliance
+	*/
+	validate(value) {
+		if (value == null) {
+			if (this._optional) return { value: void 0 };
+			if (this._default !== void 0) return { value: isFunction(this._default) ? this._default(this) : this._default };
+			return { issues: [{
+				message: `Required value is missing`,
+				path: []
+			}] };
+		}
+		if (this.type === "literal" && this._default !== value) return { issues: [{
+			message: `Expected literal value ${this._default}, got ${value}`,
+			path: []
+		}] };
+		if (this._enumValues && Array.isArray(this._enumValues)) {
+			if (!this._enumValues.includes(value)) return { issues: [{
+				message: `Expected one of [${this._enumValues.join(", ")}], got ${value}`,
+				path: []
+			}] };
+		}
+		if (this._union && Array.isArray(this._union)) {
+			for (const option of this._union) {
+				const result = option.validate(value);
+				if (!result.issues) return result;
+			}
+			return { issues: [{
+				message: `Value does not match any union variant`,
+				path: []
+			}] };
+		}
+		if (this.type === "array" || this.type === "tuple") {
+			if (!Array.isArray(value)) return { issues: [{
+				message: `Expected array, got ${typeof value}`,
+				path: []
+			}] };
+			if (this.type === "tuple" && this._type) {
+				const items = this._type;
+				if (value.length !== items.length) return { issues: [{
+					message: `Expected tuple of length ${items.length}, got ${value.length}`,
+					path: []
+				}] };
+				const issues = [];
+				for (let i = 0; i < items.length; i++) {
+					const itemResult = items[i].validate(value[i]);
+					if (itemResult.issues) for (const issue of itemResult.issues) issues.push({
+						message: issue.message,
+						path: [i, ...issue.path || []]
+					});
+				}
+				if (issues.length > 0) return { issues };
+			} else if (this._type) {
+				const itemType = this._type;
+				const issues = [];
+				for (let i = 0; i < value.length; i++) {
+					const itemResult = itemType.validate(value[i]);
+					if (itemResult.issues) for (const issue of itemResult.issues) issues.push({
+						message: issue.message,
+						path: [i, ...issue.path || []]
+					});
+				}
+				if (issues.length > 0) return { issues };
+			}
+		}
+		if (this._object) {
+			if (!isObject(value)) return { issues: [{
+				message: `Expected object, got ${typeof value}`,
+				path: []
+			}] };
+			const issues = [];
+			const obj = value;
+			for (const key in this._object) {
+				const propSchema = this._object[key];
+				const propValue = obj[key];
+				const propResult = propSchema.validate(propValue);
+				if (propResult.issues) for (const issue of propResult.issues) issues.push({
+					message: issue.message,
+					path: [key, ...issue.path || []]
+				});
+			}
+			if (issues.length > 0) return { issues };
+			return {
+				value,
+				issues: void 0
+			};
+		}
+		if (this.type === "record" && this._type) {
+			if (!isObject(value)) return { issues: [{
+				message: `Expected object, got ${typeof value}`,
+				path: []
+			}] };
+			const valueType = this._type;
+			const issues = [];
+			const obj = value;
+			for (const key in obj) {
+				const propResult = valueType.validate(obj[key]);
+				if (propResult.issues) for (const issue of propResult.issues) issues.push({
+					message: issue.message,
+					path: [key, ...issue.path || []]
+				});
+			}
+			if (issues.length > 0) return { issues };
+		}
+		if (this._check && !this._check(value)) return { issues: [{
+			message: `Expected ${this.type}, got ${typeof value}`,
+			path: []
+		}] };
+		return { value };
+	}
+	/**
+	* Creates a copy of the type with new properties merged
+	*/
+	_cloneWithProps(newProps = {}) {
+		const cloned = new Type(this.type);
+		for (const prop of [
+			"_default",
+			"_optional",
+			"_meta",
+			"_check",
+			"_object",
+			"_type",
+			"_union",
+			"_enumValues",
+			"_args",
+			"_ret",
+			"_info"
+		]) if (this[prop] !== void 0) cloned[prop] = this[prop];
+		Object.assign(cloned, newProps);
+		return cloned;
+	}
+	/**
+	* Helper to copy type properties when creating new type instances
+	*/
+	static _copyTypeProperties(source, target) {
+		for (const prop of [
+			"_check",
+			"_default",
+			"_meta",
+			"_object",
+			"_type",
+			"_enumValues"
+		]) if (source[prop] !== void 0) target[prop] = source[prop];
+	}
+	/**
+	* Marks the type as optional, meaning it can be undefined
+	* This is useful for properties that are not required.
+	*/
+	optional() {
+		return this._cloneWithProps({ _optional: true });
+	}
+	/**
+	* Sets a default value for the type, which will be used if the value is not provided
+	* The default value can be a function that receives the schema as argument, or a static value.
+	*/
+	default(value) {
+		return this._cloneWithProps({ _default: value });
+	}
+	/**
+	* Props / Metadata for the type, like description or other properties
+	*/
+	meta(meta) {
+		return this._cloneWithProps({ _meta: meta });
+	}
+	/**
+	* Sets the `desc` property for the type, which is a human-readable description
+	*/
+	describe(msg) {
+		const meta = this._meta || {};
+		meta.desc = msg;
+		return this._cloneWithProps({ _meta: meta });
+	}
+	/**
+	* Extends the type with an object, merging the properties
+	*/
+	extend(obj) {
+		if (!this._object) throw new Error("extend() can only be used on object schemas");
+		return object({
+			...this._object,
+			...obj
+		});
+	}
+	/**
+	* Picks certain keys from an object schema
+	*/
+	pick(keys) {
+		if (!this._object) throw new Error("pick() can only be used on object schemas");
+		const pickedObj = {};
+		for (const key of Object.keys(keys)) if (key in this._object) pickedObj[key] = this._object[key];
+		return object(pickedObj);
+	}
+	/**
+	* Omits certain keys from an object schema
+	*/
+	omit(keys) {
+		if (!this._object) throw new Error("omit() can only be used on object schemas");
+		const omittedObj = { ...this._object };
+		for (const key of Object.keys(keys)) delete omittedObj[key];
+		return object(omittedObj);
+	}
+	/**
+	* Helper method to modify object properties with a transformation function
+	*/
+	_transformObjectProperties(transform, keys) {
+		if (!this._object) throw new Error("This operation can only be used on object schemas");
+		const transformedObj = {};
+		const originalObj = this._object;
+		for (const [key, typeInstance] of Object.entries(originalObj)) transformedObj[key] = transform(key, typeInstance, !keys || key in keys);
+		return object(transformedObj);
+	}
+	partial(keys) {
+		if (!this._object) throw new Error("partial() can only be used on object schemas");
+		return this._transformObjectProperties((key, type, shouldTransform) => {
+			if (!shouldTransform) return type;
+			return Type._cloneTypeWithOptional(type, true);
+		}, keys);
+	}
+	required(keys) {
+		if (!this._object) throw new Error("required() can only be used on object schemas");
+		return this._transformObjectProperties((key, type, shouldTransform) => {
+			if (!shouldTransform) return type;
+			return Type._cloneTypeWithOptional(type, false);
+		}, keys);
+	}
+	/**
+	* Helper method to clone a type with optional flag
+	*/
+	static _cloneTypeWithOptional(originalType, optional) {
+		const newType = new Type(originalType.type);
+		Type._copyTypeProperties(originalType, newType);
+		newType._optional = optional;
+		return newType;
+	}
+};
+/**
+* Creates a string type validator
+*/
+function string() {
+	return new Type("string", { _check: isString });
+}
+/**
+* Creates a number type validator
+*/
+function number() {
+	return new Type("number", { _check: isNumber });
+}
+/**
+* Creates an integer type validator
+*/
+function int() {
+	return new Type("int", { _check: isInteger });
+}
+/**
+* Creates a boolean type validator
+*/
+function boolean() {
+	return new Type("boolean", { _check: isBoolean });
+}
+/**
+* Creates a none type validator (undefined | null)
+* Like undefined | null in TS and nil in Swift
+*/
+function none() {
+	return new Type("none", {
+		_check: (v) => v == null,
+		_optional: true
+	});
+}
+/**
+* Creates an any type validator that accepts any non-null value
+*/
+function any() {
+	return new Type("any", { _check: (v) => v != null });
+}
+const float = number;
+const double = number;
+const real = number;
+/**
+* Creates an object type validator with specified properties
+*/
+function object(tobj) {
+	return new Type("object", {
+		_check: isObject,
+		_object: tobj
+	});
+}
+/**
+* Creates a record type validator (object with string keys and uniform value type)
+*/
+function record(valueType) {
+	return new Type("record", {
+		_check: isObject,
+		_type: valueType
+	});
+}
+/**
+* Creates a union type validator (like `string | number | boolean`)
+*/
+function union(options) {
+	return new Type("union", {
+		_check: (v) => options.some((option) => option._check?.(v) ?? false),
+		_union: options
+	});
+}
+/**
+* Creates a literal value validator
+*/
+function literal(value) {
+	return new Type("literal", {
+		_check: (v) => v === value,
+		_default: value
+	});
+}
+/**
+* Creates a string literal union validator (like `"a" | "b" | "c"`)
+*/
+function stringLiterals(values) {
+	return new Type("string", {
+		_check: (v) => typeof v === "string" && values.includes(v),
+		_enumValues: values
+	});
+}
+/**
+* Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]
+*/
+function tuple(items) {
+	return new Type("tuple", {
+		_check: (v) => Array.isArray(v) && v.length === items.length && items.every((item, i) => item._check?.(v[i]) ?? false),
+		_type: items
+	});
+}
+/**
+* Creates an array type validator for a specific item type
+*/
+function array(itemType) {
+	return new Type("array", {
+		_check: isArray,
+		_type: itemType
+	});
+}
+/**
+* Creates a regular function type validator
+*/
+function func(args, ret) {
+	return new Type("function", {
+		_check: isFunction,
+		_args: args,
+		_ret: ret
+	});
+}
+/**
+* Creates an RPC function type validator that takes one argument and returns a promise
+*/
+function rpc(info, ret) {
+	return new Type("rpc", {
+		_check: isFunction,
+		_info: info,
+		_ret: ret ?? none()
+	});
+}
+
+//#endregion
+export { Type, any, array, boolean, double, float, func, int, literal, none, number, object, real, record, rpc, string, stringLiterals, tuple, union };
+//# sourceMappingURL=schema.mjs.map

package/dist/common/schema/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../../src/common/schema/schema.ts"],"sourcesContent":["// With many, many inspiration from https://github.com/badrap/valita MIT License as of 2024-09-10\n\nimport type { StandardSchemaV1 } from './schema-standard'\nimport { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from '../data/is'\n\n/**\n * Metadata interface for type descriptions and additional properties\n */\nexport interface TypeMeta {\n  desc?: string\n}\n\n/**\n * Core Type class for schema validation and type inference\n * Implements StandardSchemaV1 for cross-library compatibility\n */\nexport class Type<T = unknown> {\n  readonly type: string\n\n  _default?: any\n  _optional?: boolean\n  _meta?: TypeMeta\n  _check?: (obj: any) => boolean\n  _object?: any\n  _type?: any\n  _union?: any\n  _enumValues?: any\n  _args?: any\n  _ret?: any\n  _info?: any\n\n  // [key: `_${string}`]: any // Allow only optional dynamic properties starting with an underscore\n\n  constructor(name: string, options: Partial<Type<T>> = {}) {\n    this.type = name\n    Object.assign(this, options)\n  }\n\n  /**\n   * Standard Schema V1 compliance property\n   * Provides a standard interface for validation and type inference\n   */\n  get '~standard'(): any {\n    return {\n      version: 1,\n      vendor: 'zeed',\n      validate: (value: unknown): StandardSchemaV1.Result<T> => {\n        return this.validate(value)\n      },\n      types: {\n        input: undefined as any as T,\n        output: undefined as any as T,\n      },\n    }\n  }\n\n  /**\n   * Validation method for standard-schema compliance\n   */\n  validate(value: any): any {\n    // const messages: Array<{ path: string, message: string, type: string, valid: boolean }> = []\n\n    // Handle null/undefined cases\n    if (value == null) {\n      if (this._optional) {\n        return { value: undefined as any as T }\n      }\n      if (this._default !== undefined) {\n        const defaultValue = isFunction(this._default) ? this._default(this) : this._default\n        return { value: defaultValue }\n      }\n      return {\n        issues: [{\n          message: `Required value is missing`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle literal types\n    if (this.type === 'literal' && this._default !== value) {\n      return {\n        issues: [{\n          message: `Expected literal value ${this._default}, got ${value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle string literals (enums)\n    if (this._enumValues && Array.isArray(this._enumValues)) {\n      if (!this._enumValues.includes(value)) {\n        return {\n          issues: [{\n            message: `Expected one of [${this._enumValues.join(', ')}], got ${value}`,\n            path: [],\n          }],\n        }\n      }\n    }\n\n    // Handle union types\n    if (this._union && Array.isArray(this._union)) {\n      for (const option of this._union) {\n        const result = (option as Type<any>).validate(value)\n        if (!result.issues) {\n          return result\n        }\n      }\n      return {\n        issues: [{\n          message: `Value does not match any union variant`,\n          path: [],\n        }],\n      }\n    }\n\n    // Handle array types\n    if (this.type === 'array' || this.type === 'tuple') {\n      if (!Array.isArray(value)) {\n        return {\n          issues: [{\n            message: `Expected array, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      if (this.type === 'tuple' && this._type) {\n        const items = this._type as Type<any>[]\n        if (value.length !== items.length) {\n          return {\n            issues: [{\n              message: `Expected tuple of length ${items.length}, got ${value.length}`,\n              path: [],\n            }],\n          }\n        }\n\n        const issues: StandardSchemaV1.Issue[] = []\n        for (let i = 0; i < items.length; i++) {\n          const itemResult = items[i].validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n      else if (this._type) {\n        // Regular array with item type\n        const itemType = this._type as Type<any>\n        const issues: StandardSchemaV1.Issue[] = []\n\n        for (let i = 0; i < value.length; i++) {\n          const itemResult = itemType.validate(value[i])\n          if (itemResult.issues) {\n            for (const issue of itemResult.issues) {\n              issues.push({\n                message: issue.message,\n                path: [i, ...(issue.path || [])],\n              })\n            }\n          }\n        }\n\n        if (issues.length > 0) {\n          return { issues }\n        }\n      }\n    }\n\n    // Handle object types\n    if (this._object) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in this._object) {\n        const propSchema = this._object[key] as Type<any>\n        const propValue = obj[key]\n        const propResult = propSchema.validate(propValue)\n\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n\n      return { value: value as T, issues: undefined }\n    }\n\n    // Handle record types\n    if (this.type === 'record' && this._type) {\n      if (!isObject(value)) {\n        return {\n          issues: [{\n            message: `Expected object, got ${typeof value}`,\n            path: [],\n          }],\n        }\n      }\n\n      const valueType = this._type as Type<any>\n      const issues: StandardSchemaV1.Issue[] = []\n      const obj = value as Record<string, any>\n\n      for (const key in obj) {\n        const propResult = valueType.validate(obj[key])\n        if (propResult.issues) {\n          for (const issue of propResult.issues) {\n            issues.push({\n              message: issue.message,\n              path: [key, ...(issue.path || [])],\n            })\n          }\n        }\n      }\n\n      if (issues.length > 0) {\n        return { issues }\n      }\n    }\n\n    // Check primitive types\n    if (this._check && !this._check(value)) {\n      return {\n        issues: [{\n          message: `Expected ${this.type}, got ${typeof value}`,\n          path: [],\n        }],\n      }\n    }\n\n    // Success - return the value\n    return { value: value as T }\n  }\n\n  /**\n   * Creates a copy of the type with new properties merged\n   */\n  private _cloneWithProps<U = T>(newProps: Partial<Type<any>> = {}): Type<U> {\n    const cloned = new Type<U>(this.type)\n    // Copy all existing properties\n    const propertiesToCopy = ['_default', '_optional', '_meta', '_check', '_object', '_type', '_union', '_enumValues', '_args', '_ret', '_info']\n    for (const prop of propertiesToCopy) {\n      if ((this as any)[prop] !== undefined) {\n        (cloned as any)[prop] = (this as any)[prop]\n      }\n    }\n    // Apply new properties\n    Object.assign(cloned, newProps)\n    return cloned\n  }\n\n  /**\n   * Helper to copy type properties when creating new type instances\n   */\n  private static _copyTypeProperties(source: Type<any>, target: Type<any>): void {\n    const properties = ['_check', '_default', '_meta', '_object', '_type', '_enumValues']\n    for (const prop of properties) {\n      if ((source as any)[prop] !== undefined) {\n        (target as any)[prop] = (source as any)[prop]\n      }\n    }\n  }\n\n  /**\n   * Marks the type as optional, meaning it can be undefined\n   * This is useful for properties that are not required.\n   */\n  optional(): Type<T | undefined> {\n    return this._cloneWithProps<T | undefined>({ _optional: true })\n  }\n\n  /**\n   * Sets a default value for the type, which will be used if the value is not provided\n   * The default value can be a function that receives the schema as argument, or a static value.\n   */\n  default(value: T | ((schema?: this) => T)): Type<T> {\n    return this._cloneWithProps<T>({ _default: value })\n  }\n\n  /**\n   * Props / Metadata for the type, like description or other properties\n   */\n  meta(meta: TypeMeta): Type<T> {\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Sets the `desc` property for the type, which is a human-readable description\n   */\n  describe(msg: string): Type<T> {\n    const meta = this._meta || {}\n    meta.desc = msg\n    return this._cloneWithProps<T>({ _meta: meta })\n  }\n\n  /**\n   * Extends the type with an object, merging the properties\n   */\n  extend<O>(obj: O): Type<T & TypeObject<O>> {\n    if (!this._object) {\n      throw new Error('extend() can only be used on object schemas')\n    }\n    const newObj = { ...this._object, ...obj }\n    return object(newObj) as any\n  }\n\n  /**\n   * Picks certain keys from an object schema\n   */\n  pick<K extends keyof T>(keys: Record<K, true>): Type<Pick<T, K>> {\n    if (!this._object) {\n      throw new Error('pick() can only be used on object schemas')\n    }\n    const pickedObj: any = {}\n    for (const key of Object.keys(keys)) {\n      if (key in this._object) {\n        pickedObj[key] = (this._object as any)[key]\n      }\n    }\n    return object(pickedObj) as any\n  }\n\n  /**\n   * Omits certain keys from an object schema\n   */\n  omit<K extends keyof T>(keys: Record<K, true>): Type<Omit<T, K>> {\n    if (!this._object) {\n      throw new Error('omit() can only be used on object schemas')\n    }\n    const omittedObj: any = { ...this._object }\n    for (const key of Object.keys(keys)) {\n      delete omittedObj[key]\n    }\n    return object(omittedObj) as any\n  }\n\n  /**\n   * Helper method to modify object properties with a transformation function\n   */\n  private _transformObjectProperties(\n    transform: (key: string, type: Type<any>, shouldTransform: boolean) => Type<any>,\n    keys?: Record<string, true>,\n  ): any {\n    if (!this._object) {\n      throw new Error('This operation can only be used on object schemas')\n    }\n\n    const transformedObj: any = {}\n    const originalObj = this._object as any\n\n    for (const [key, typeInstance] of Object.entries(originalObj)) {\n      const shouldTransform = !keys || key in keys\n      transformedObj[key] = transform(key, typeInstance as Type<any>, shouldTransform)\n    }\n\n    return object(transformedObj)\n  }\n\n  /**\n   * Makes some or all properties of an object schema optional\n   */\n  partial(): Type<Partial<T>>\n  partial<K extends keyof T>(keys: Record<K, true>): Type<Partial<Pick<T, K>> & Omit<T, K>>\n  partial<K extends keyof T>(keys?: Record<K, true>): Type<Partial<T> | (Partial<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('partial() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, true)\n    }, keys)\n  }\n\n  /**\n   * Makes some or all properties of an object schema required\n   */\n  required(): Type<Required<T>>\n  required<K extends keyof T>(keys: Record<K, true>): Type<Required<Pick<T, K>> & Omit<T, K>>\n  required<K extends keyof T>(keys?: Record<K, true>): Type<Required<T> | (Required<Pick<T, K>> & Omit<T, K>)> {\n    if (!this._object) {\n      throw new Error('required() can only be used on object schemas')\n    }\n    return this._transformObjectProperties((key, type, shouldTransform) => {\n      if (!shouldTransform)\n        return type\n      return Type._cloneTypeWithOptional(type, false)\n    }, keys)\n  }\n\n  /**\n   * Helper method to clone a type with optional flag\n   */\n  private static _cloneTypeWithOptional(originalType: Type<any>, optional: boolean): Type<any> {\n    const newType = new Type(originalType.type)\n    Type._copyTypeProperties(originalType, newType)\n    newType._optional = optional\n    return newType\n  }\n}\n\n/**\n * Type inference utility for extracting the TypeScript type from a schema Type\n */\nexport type Infer<T> = T extends Type<infer TT> ? TT : never\n\n// =============================================================================\n// Primitive Types\n// =============================================================================\n\n/**\n * Creates a string type validator\n */\nexport function string(): Type<string> {\n  return new Type('string', {\n    _check: isString,\n  })\n}\n\n/**\n * Creates a number type validator\n */\nexport function number(): Type<number> {\n  return new Type('number', {\n    _check: isNumber,\n  })\n}\n\n/**\n * Creates an integer type validator\n */\nexport function int(): Type<number> {\n  return new Type('int', {\n    _check: isInteger,\n  })\n}\n\n/**\n * Creates a boolean type validator\n */\nexport function boolean(): Type<boolean> {\n  return new Type('boolean', {\n    _check: isBoolean,\n  })\n}\n\n/**\n * Creates a none type validator (undefined | null)\n * Like undefined | null in TS and nil in Swift\n */\nexport function none(): Type<undefined> {\n  return new Type('none', {\n    _check: (v: any) => v == null,\n    _optional: true,\n  })\n}\n\n/**\n * Creates an any type validator that accepts any non-null value\n */\nexport function any<T = any>(): Type<T> {\n  return new Type('any', {\n    _check: (v: any) => v != null,\n  })\n}\n\n// Aliases for number types\nexport const float = number\nexport const double = number\nexport const real = number\n\n// =============================================================================\n// Object Types\n// =============================================================================\n\n/**\n * Utility type to make object properties optional if their value type includes undefined.\n * @category Schema\n */\nexport type TypeObjectFixOptional<T> = {\n  [K in keyof T as undefined extends T[K] ? K : never]?: T[K] & {}\n} & {\n  [K in keyof T as undefined extends T[K] ? never : K]: T[K] & {}\n}\n\n/**\n * Utility type for pretty-printing object types\n */\ntype TypeObjectPretty<V> = Extract<{ [K in keyof V]: V[K] }, unknown>\n\n/**\n * Main object type utility\n */\ntype TypeObject<T> = TypeObjectPretty<TypeObjectFixOptional<{\n  [K in keyof T]: Infer<T[K]>\n}>>\n\n/**\n * Creates an object type validator with specified properties\n */\nexport function object<T>(tobj: T): Type<TypeObject<T>> {\n  return new Type('object', {\n    _check: isObject,\n    _object: tobj,\n  })\n}\n\n/**\n * Creates a record type validator (object with string keys and uniform value type)\n */\nexport function record<T extends Type>(valueType: T): Type<Record<string, Infer<T>>> {\n  return new Type('record', {\n    _check: isObject,\n    _type: valueType,\n  })\n}\n\n// =============================================================================\n// Union Types\n// =============================================================================\n\n/**\n * Utility type for union of types.\n * @category Schema\n */\nexport type TypeUnion<T extends Type<any>[]> = {\n  [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}[number]\n\n/**\n * Creates a union type validator (like `string | number | boolean`)\n */\nexport function union<T extends Type<any>[]>(options: T): Type<TypeUnion<T>> {\n  return new Type('union', {\n    _check: (v: any) => options.some(option => option._check?.(v) ?? false),\n    _union: options,\n  })\n}\n\n// =============================================================================\n// Literal Types\n// =============================================================================\n\n/**\n * Utility type for literal types.\n * @category Schema\n */\nexport type TypeLiterals = string | number | bigint | boolean\n\n/**\n * Creates a literal value validator\n */\nexport function literal<T extends TypeLiterals>(value: T): Type<T> {\n  return new Type('literal', {\n    _check: (v: any) => v === value,\n    _default: value,\n  })\n}\n\n/**\n * Creates a string literal union validator (like `\"a\" | \"b\" | \"c\"`)\n */\nexport function stringLiterals<const T extends readonly string[]>(values: T): Type<T[number]> {\n  return new Type('string', {\n    _check: (v: any) => typeof v === 'string' && (values as readonly string[]).includes(v),\n    _enumValues: values,\n  })\n}\n\n// =============================================================================\n// Collection Types\n// =============================================================================\n\n/**\n * Utility type for tuple types.\n * @category Schema\n */\nexport type TypeTuple<T extends readonly Type[]> = {\n  -readonly [K in keyof T]: T[K] extends Type<infer U> ? U : never\n}\n\n/**\n * Output type for TypeArray.\n * @category Schema\n */\nexport type TypeArrayOutput<Head extends Type[], Rest extends Type | undefined> = [\n  ...TypeTuple<Head>,\n  ...(Rest extends Type ? Infer<Rest>[] : []),\n]\n\n/**\n * Utility type for array types.\n * @category Schema\n */\nexport type TypeArray<Head extends Type[] = Type[], Rest extends Type | undefined = Type | undefined> = Type<TypeArrayOutput<Head, Rest>>\n\n/**\n * Creates a tuple type validator with fixed length and types e.g. [string, number, boolean]\n */\nexport function tuple<const T extends readonly Type[]>(items: T): Type<TypeTuple<T>> {\n  return new Type('tuple', {\n    _check: (v: any) => Array.isArray(v) && v.length === items.length && items.every((item, i) => (item as Type)._check?.(v[i]) ?? false),\n    _type: items,\n  })\n}\n\n/**\n * Creates an array type validator for a specific item type\n */\nexport function array<T>(itemType: Type<T>): Type<T[]> {\n  return new Type('array', {\n    _check: isArray,\n    _type: itemType,\n  })\n}\n\n// =============================================================================\n// Function Types\n// =============================================================================\n\n/**\n * Creates a regular function type validator\n */\nexport function func<\n  TypeFuncArgs extends [Type<unknown>, ...Type<any>[]] | [],\n  TypeFuncRet = Type,\n  T = (...args: TypeTuple<TypeFuncArgs>) => Infer<TypeFuncRet>,\n>(args: TypeFuncArgs, ret: TypeFuncRet): Type<T> {\n  return new Type('function', {\n    _check: isFunction,\n    _args: args,\n    _ret: ret,\n  })\n}\n\n/**\n * Creates an RPC function type validator that takes one argument and returns a promise\n */\nexport function rpc<\n  TypeRpcInfo extends Type<unknown> | undefined = undefined,\n  TypeRpcRet extends Type<unknown> = Type<void>,\n  T = TypeRpcInfo extends undefined\n    ? () => Infer<TypeRpcRet>\n    : (info: Infer<TypeRpcInfo>) => Infer<TypeRpcRet> | Promise<Infer<TypeRpcRet>>,\n>(info?: TypeRpcInfo, ret?: TypeRpcRet): Type<T> {\n  return new Type('rpc', {\n    _check: isFunction,\n    _info: info,\n    _ret: ret ?? none(),\n  })\n}\n"],"mappings":";;;;;;;AAgBA,IAAa,OAAb,MAAa,KAAkB;CAC7B,AAAS;CAET;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAIA,YAAY,MAAc,UAA4B,EAAE,EAAE;AACxD,OAAK,OAAO;AACZ,SAAO,OAAO,MAAM,QAAQ;;;;;;CAO9B,IAAI,cAAmB;AACrB,SAAO;GACL,SAAS;GACT,QAAQ;GACR,WAAW,UAA+C;AACxD,WAAO,KAAK,SAAS,MAAM;;GAE7B,OAAO;IACL,OAAO;IACP,QAAQ;IACT;GACF;;;;;CAMH,SAAS,OAAiB;AAIxB,MAAI,SAAS,MAAM;AACjB,OAAI,KAAK,UACP,QAAO,EAAE,OAAO,QAAuB;AAEzC,OAAI,KAAK,aAAa,OAEpB,QAAO,EAAE,OADY,WAAW,KAAK,SAAS,GAAG,KAAK,SAAS,KAAK,GAAG,KAAK,UAC9C;AAEhC,UAAO,EACL,QAAQ,CAAC;IACP,SAAS;IACT,MAAM,EAAE;IACT,CAAC,EACH;;AAIH,MAAI,KAAK,SAAS,aAAa,KAAK,aAAa,MAC/C,QAAO,EACL,QAAQ,CAAC;GACP,SAAS,0BAA0B,KAAK,SAAS,QAAQ;GACzD,MAAM,EAAE;GACT,CAAC,EACH;AAIH,MAAI,KAAK,eAAe,MAAM,QAAQ,KAAK,YAAY,EACrD;OAAI,CAAC,KAAK,YAAY,SAAS,MAAM,CACnC,QAAO,EACL,QAAQ,CAAC;IACP,SAAS,oBAAoB,KAAK,YAAY,KAAK,KAAK,CAAC,SAAS;IAClE,MAAM,EAAE;IACT,CAAC,EACH;;AAKL,MAAI,KAAK,UAAU,MAAM,QAAQ,KAAK,OAAO,EAAE;AAC7C,QAAK,MAAM,UAAU,KAAK,QAAQ;IAChC,MAAM,SAAU,OAAqB,SAAS,MAAM;AACpD,QAAI,CAAC,OAAO,OACV,QAAO;;AAGX,UAAO,EACL,QAAQ,CAAC;IACP,SAAS;IACT,MAAM,EAAE;IACT,CAAC,EACH;;AAIH,MAAI,KAAK,SAAS,WAAW,KAAK,SAAS,SAAS;AAClD,OAAI,CAAC,MAAM,QAAQ,MAAM,CACvB,QAAO,EACL,QAAQ,CAAC;IACP,SAAS,uBAAuB,OAAO;IACvC,MAAM,EAAE;IACT,CAAC,EACH;AAGH,OAAI,KAAK,SAAS,WAAW,KAAK,OAAO;IACvC,MAAM,QAAQ,KAAK;AACnB,QAAI,MAAM,WAAW,MAAM,OACzB,QAAO,EACL,QAAQ,CAAC;KACP,SAAS,4BAA4B,MAAM,OAAO,QAAQ,MAAM;KAChE,MAAM,EAAE;KACT,CAAC,EACH;IAGH,MAAM,SAAmC,EAAE;AAC3C,SAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;KACrC,MAAM,aAAa,MAAM,GAAG,SAAS,MAAM,GAAG;AAC9C,SAAI,WAAW,OACb,MAAK,MAAM,SAAS,WAAW,OAC7B,QAAO,KAAK;MACV,SAAS,MAAM;MACf,MAAM,CAAC,GAAG,GAAI,MAAM,QAAQ,EAAE,CAAE;MACjC,CAAC;;AAKR,QAAI,OAAO,SAAS,EAClB,QAAO,EAAE,QAAQ;cAGZ,KAAK,OAAO;IAEnB,MAAM,WAAW,KAAK;IACtB,MAAM,SAAmC,EAAE;AAE3C,SAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;KACrC,MAAM,aAAa,SAAS,SAAS,MAAM,GAAG;AAC9C,SAAI,WAAW,OACb,MAAK,MAAM,SAAS,WAAW,OAC7B,QAAO,KAAK;MACV,SAAS,MAAM;MACf,MAAM,CAAC,GAAG,GAAI,MAAM,QAAQ,EAAE,CAAE;MACjC,CAAC;;AAKR,QAAI,OAAO,SAAS,EAClB,QAAO,EAAE,QAAQ;;;AAMvB,MAAI,KAAK,SAAS;AAChB,OAAI,CAAC,SAAS,MAAM,CAClB,QAAO,EACL,QAAQ,CAAC;IACP,SAAS,wBAAwB,OAAO;IACxC,MAAM,EAAE;IACT,CAAC,EACH;GAGH,MAAM,SAAmC,EAAE;GAC3C,MAAM,MAAM;AAEZ,QAAK,MAAM,OAAO,KAAK,SAAS;IAC9B,MAAM,aAAa,KAAK,QAAQ;IAChC,MAAM,YAAY,IAAI;IACtB,MAAM,aAAa,WAAW,SAAS,UAAU;AAEjD,QAAI,WAAW,OACb,MAAK,MAAM,SAAS,WAAW,OAC7B,QAAO,KAAK;KACV,SAAS,MAAM;KACf,MAAM,CAAC,KAAK,GAAI,MAAM,QAAQ,EAAE,CAAE;KACnC,CAAC;;AAKR,OAAI,OAAO,SAAS,EAClB,QAAO,EAAE,QAAQ;AAGnB,UAAO;IAAS;IAAY,QAAQ;IAAW;;AAIjD,MAAI,KAAK,SAAS,YAAY,KAAK,OAAO;AACxC,OAAI,CAAC,SAAS,MAAM,CAClB,QAAO,EACL,QAAQ,CAAC;IACP,SAAS,wBAAwB,OAAO;IACxC,MAAM,EAAE;IACT,CAAC,EACH;GAGH,MAAM,YAAY,KAAK;GACvB,MAAM,SAAmC,EAAE;GAC3C,MAAM,MAAM;AAEZ,QAAK,MAAM,OAAO,KAAK;IACrB,MAAM,aAAa,UAAU,SAAS,IAAI,KAAK;AAC/C,QAAI,WAAW,OACb,MAAK,MAAM,SAAS,WAAW,OAC7B,QAAO,KAAK;KACV,SAAS,MAAM;KACf,MAAM,CAAC,KAAK,GAAI,MAAM,QAAQ,EAAE,CAAE;KACnC,CAAC;;AAKR,OAAI,OAAO,SAAS,EAClB,QAAO,EAAE,QAAQ;;AAKrB,MAAI,KAAK,UAAU,CAAC,KAAK,OAAO,MAAM,CACpC,QAAO,EACL,QAAQ,CAAC;GACP,SAAS,YAAY,KAAK,KAAK,QAAQ,OAAO;GAC9C,MAAM,EAAE;GACT,CAAC,EACH;AAIH,SAAO,EAAS,OAAY;;;;;CAM9B,AAAQ,gBAAuB,WAA+B,EAAE,EAAW;EACzE,MAAM,SAAS,IAAI,KAAQ,KAAK,KAAK;AAGrC,OAAK,MAAM,QADc;GAAC;GAAY;GAAa;GAAS;GAAU;GAAW;GAAS;GAAU;GAAe;GAAS;GAAQ;GAAQ,CAE1I,KAAK,KAAa,UAAU,OAC1B,CAAC,OAAe,QAAS,KAAa;AAI1C,SAAO,OAAO,QAAQ,SAAS;AAC/B,SAAO;;;;;CAMT,OAAe,oBAAoB,QAAmB,QAAyB;AAE7E,OAAK,MAAM,QADQ;GAAC;GAAU;GAAY;GAAS;GAAW;GAAS;GAAc,CAEnF,KAAK,OAAe,UAAU,OAC5B,CAAC,OAAe,QAAS,OAAe;;;;;;CAS9C,WAAgC;AAC9B,SAAO,KAAK,gBAA+B,EAAE,WAAW,MAAM,CAAC;;;;;;CAOjE,QAAQ,OAA4C;AAClD,SAAO,KAAK,gBAAmB,EAAE,UAAU,OAAO,CAAC;;;;;CAMrD,KAAK,MAAyB;AAC5B,SAAO,KAAK,gBAAmB,EAAE,OAAO,MAAM,CAAC;;;;;CAMjD,SAAS,KAAsB;EAC7B,MAAM,OAAO,KAAK,SAAS,EAAE;AAC7B,OAAK,OAAO;AACZ,SAAO,KAAK,gBAAmB,EAAE,OAAO,MAAM,CAAC;;;;;CAMjD,OAAU,KAAiC;AACzC,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,8CAA8C;AAGhE,SAAO,OADQ;GAAE,GAAG,KAAK;GAAS,GAAG;GAAK,CACrB;;;;;CAMvB,KAAwB,MAAyC;AAC/D,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,4CAA4C;EAE9D,MAAM,YAAiB,EAAE;AACzB,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,CACjC,KAAI,OAAO,KAAK,QACd,WAAU,OAAQ,KAAK,QAAgB;AAG3C,SAAO,OAAO,UAAU;;;;;CAM1B,KAAwB,MAAyC;AAC/D,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,4CAA4C;EAE9D,MAAM,aAAkB,EAAE,GAAG,KAAK,SAAS;AAC3C,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,CACjC,QAAO,WAAW;AAEpB,SAAO,OAAO,WAAW;;;;;CAM3B,AAAQ,2BACN,WACA,MACK;AACL,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,oDAAoD;EAGtE,MAAM,iBAAsB,EAAE;EAC9B,MAAM,cAAc,KAAK;AAEzB,OAAK,MAAM,CAAC,KAAK,iBAAiB,OAAO,QAAQ,YAAY,CAE3D,gBAAe,OAAO,UAAU,KAAK,cADb,CAAC,QAAQ,OAAO,KACwC;AAGlF,SAAO,OAAO,eAAe;;CAQ/B,QAA2B,MAA+E;AACxG,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,+CAA+C;AAEjE,SAAO,KAAK,4BAA4B,KAAK,MAAM,oBAAoB;AACrE,OAAI,CAAC,gBACH,QAAO;AACT,UAAO,KAAK,uBAAuB,MAAM,KAAK;KAC7C,KAAK;;CAQV,SAA4B,MAAiF;AAC3G,MAAI,CAAC,KAAK,QACR,OAAM,IAAI,MAAM,gDAAgD;AAElE,SAAO,KAAK,4BAA4B,KAAK,MAAM,oBAAoB;AACrE,OAAI,CAAC,gBACH,QAAO;AACT,UAAO,KAAK,uBAAuB,MAAM,MAAM;KAC9C,KAAK;;;;;CAMV,OAAe,uBAAuB,cAAyB,UAA8B;EAC3F,MAAM,UAAU,IAAI,KAAK,aAAa,KAAK;AAC3C,OAAK,oBAAoB,cAAc,QAAQ;AAC/C,UAAQ,YAAY;AACpB,SAAO;;;;;;AAgBX,SAAgB,SAAuB;AACrC,QAAO,IAAI,KAAK,UAAU,EACxB,QAAQ,UACT,CAAC;;;;;AAMJ,SAAgB,SAAuB;AACrC,QAAO,IAAI,KAAK,UAAU,EACxB,QAAQ,UACT,CAAC;;;;;AAMJ,SAAgB,MAAoB;AAClC,QAAO,IAAI,KAAK,OAAO,EACrB,QAAQ,WACT,CAAC;;;;;AAMJ,SAAgB,UAAyB;AACvC,QAAO,IAAI,KAAK,WAAW,EACzB,QAAQ,WACT,CAAC;;;;;;AAOJ,SAAgB,OAAwB;AACtC,QAAO,IAAI,KAAK,QAAQ;EACtB,SAAS,MAAW,KAAK;EACzB,WAAW;EACZ,CAAC;;;;;AAMJ,SAAgB,MAAwB;AACtC,QAAO,IAAI,KAAK,OAAO,EACrB,SAAS,MAAW,KAAK,MAC1B,CAAC;;AAIJ,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,OAAO;;;;AA+BpB,SAAgB,OAAU,MAA8B;AACtD,QAAO,IAAI,KAAK,UAAU;EACxB,QAAQ;EACR,SAAS;EACV,CAAC;;;;;AAMJ,SAAgB,OAAuB,WAA8C;AACnF,QAAO,IAAI,KAAK,UAAU;EACxB,QAAQ;EACR,OAAO;EACR,CAAC;;;;;AAkBJ,SAAgB,MAA6B,SAAgC;AAC3E,QAAO,IAAI,KAAK,SAAS;EACvB,SAAS,MAAW,QAAQ,MAAK,WAAU,OAAO,SAAS,EAAE,IAAI,MAAM;EACvE,QAAQ;EACT,CAAC;;;;;AAgBJ,SAAgB,QAAgC,OAAmB;AACjE,QAAO,IAAI,KAAK,WAAW;EACzB,SAAS,MAAW,MAAM;EAC1B,UAAU;EACX,CAAC;;;;;AAMJ,SAAgB,eAAkD,QAA4B;AAC5F,QAAO,IAAI,KAAK,UAAU;EACxB,SAAS,MAAW,OAAO,MAAM,YAAa,OAA6B,SAAS,EAAE;EACtF,aAAa;EACd,CAAC;;;;;AAiCJ,SAAgB,MAAuC,OAA8B;AACnF,QAAO,IAAI,KAAK,SAAS;EACvB,SAAS,MAAW,MAAM,QAAQ,EAAE,IAAI,EAAE,WAAW,MAAM,UAAU,MAAM,OAAO,MAAM,MAAO,KAAc,SAAS,EAAE,GAAG,IAAI,MAAM;EACrI,OAAO;EACR,CAAC;;;;;AAMJ,SAAgB,MAAS,UAA8B;AACrD,QAAO,IAAI,KAAK,SAAS;EACvB,QAAQ;EACR,OAAO;EACR,CAAC;;;;;AAUJ,SAAgB,KAId,MAAoB,KAA2B;AAC/C,QAAO,IAAI,KAAK,YAAY;EAC1B,QAAQ;EACR,OAAO;EACP,MAAM;EACP,CAAC;;;;;AAMJ,SAAgB,IAMd,MAAoB,KAA2B;AAC/C,QAAO,IAAI,KAAK,OAAO;EACrB,QAAQ;EACR,OAAO;EACP,MAAM,OAAO,MAAM;EACpB,CAAC"}