@sng2c/pi-the-giver 0.1.0 → 0.1.1

package/node_modules/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/node_modules/typebox/build/compile/code.mjs

@@ -0,0 +1,65 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Comments and Formatting
+// ------------------------------------------------------------------
+function TsIgnore() {
+    return `// @ts-ignore`;
+}
+function Separator() {
+    return ``;
+}
+// ------------------------------------------------------------------
+// ImportSection
+// ------------------------------------------------------------------
+function ImportSection(build) {
+    const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
+    const hashing = `import { Hashing } from "typebox/system"`;
+    const format = `import { Format } from "typebox/format"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, format, guard];
+}
+// ------------------------------------------------------------------
+// ExternalSection
+// ------------------------------------------------------------------
+function ExternalSection(build) {
+    const { identifier } = build.External();
+    return [
+        Separator(),
+        TsIgnore(),
+        `let ${identifier} = []`,
+        Separator(),
+        TsIgnore(),
+        `export function SetExternal(external) { ${identifier} = external.variables }`
+    ];
+}
+// ------------------------------------------------------------------
+// FunctionSection
+// ------------------------------------------------------------------
+function FunctionSection(build) {
+    return build.Functions().map((func) => [Separator(), TsIgnore(), `${func};`].join('\n'));
+}
+// ------------------------------------------------------------------
+// ExportSection
+// ------------------------------------------------------------------
+function ExportSection(build) {
+    const body = build.UseUnevaluated()
+        ? `const context = new CheckContext({}, {}); return ${build.Call()}`
+        : `return ${build.Call()}`;
+    return [
+        Separator(),
+        TsIgnore(),
+        `export function Check(value) { ${body} }`
+    ];
+}
+/** Creates a standalone ESM validation module for the given type. */
+export function Code(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = Build(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/node_modules/typebox/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/node_modules/typebox/build/compile/compile.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export function Compile(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new Validator(context, type);
+}

package/node_modules/typebox/build/compile/index.d.mts

@@ -0,0 +1,8 @@
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/validator.d.mts

@@ -0,0 +1,42 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
+    private readonly context;
+    private readonly type;
+    private readonly isAccelerated;
+    private readonly hasCodec;
+    private readonly code;
+    private readonly check;
+    /** Constructs a Validator with the given Context and Type. */
+    constructor(context: Context, type: Type);
+    /** Constructs a Validator with the given arguments. */
+    constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the Context for this validator. */
+    Context(): Context;
+    /** Returns the underlying Type used to construct this Validator. */
+    Type(): Type;
+    /** Returns the generated code for this validator. */
+    Code(): string;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Encode;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): Encode;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Clones this validator. */
+    Clone(): Validator<Context, Type>;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
+    /** Decodes a value */
+    Decode(value: unknown): Decode;
+    /** Encodes a value */
+    Encode(value: unknown): Encode;
+}

package/node_modules/typebox/build/compile/validator.mjs

@@ -0,0 +1,116 @@
+// deno-fmt-ignore-file
+import { Settings } from '../system/settings/index.mjs';
+import { Arguments } from '../system/arguments/index.mjs';
+import { Environment } from '../system/environment/index.mjs';
+import { Base } from '../type/index.mjs';
+import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Validator<...>
+// ------------------------------------------------------------------
+export class Validator extends Base {
+    /** Constructs a Validator. */
+    constructor(...args) {
+        super();
+        const matched = Arguments.Match(args, {
+            6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
+            2: (context, type) => [context, type]
+        });
+        if (matched.length === 6) {
+            const [context, type, isEvaluated, hasCodec, code, check] = matched;
+            this.context = context;
+            this.type = type;
+            this.isAccelerated = isEvaluated;
+            this.hasCodec = hasCodec;
+            this.code = code;
+            this.check = check;
+        }
+        else {
+            const [context, type] = matched;
+            const result = Build(context, type).Evaluate();
+            this.hasCodec = HasCodec(context, type);
+            this.context = context;
+            this.type = type;
+            this.isAccelerated = result.IsAccelerated;
+            this.code = result.Code;
+            this.check = result.Check;
+        }
+    }
+    // ----------------------------------------------------------------
+    // IsAccelerated
+    // ----------------------------------------------------------------
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated() {
+        return this.isAccelerated;
+    }
+    // ----------------------------------------------------------------
+    // Context | Type
+    // ----------------------------------------------------------------
+    /** Returns the Context for this validator. */
+    Context() {
+        return this.context;
+    }
+    /** Returns the underlying Type used to construct this Validator. */
+    Type() {
+        return this.type;
+    }
+    // ----------------------------------------------------------------
+    // Code
+    // ----------------------------------------------------------------
+    /** Returns the generated code for this validator. */
+    Code() {
+        return this.code;
+    }
+    // ----------------------------------------------------------------
+    // Base<...>
+    // ----------------------------------------------------------------
+    /** Performs a type-guard check on the provided value. */
+    Check(value) {
+        return this.check(value);
+    }
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value) {
+        if (Environment.CanEvaluate() && this.check(value))
+            return [];
+        return Errors(this.context, this.type, value);
+    }
+    /** Cleans a value using the Validator type. */
+    Clean(value) {
+        return Clean(this.context, this.type, value);
+    }
+    /** Converts a value using the Validator type. */
+    Convert(value) {
+        return Convert(this.context, this.type, value);
+    }
+    /** Creates a value using the Validator type. */
+    Create() {
+        return Create(this.context, this.type);
+    }
+    /** Creates defaults using the Validator type. */
+    Default(value) {
+        return Default(this.context, this.type, value);
+    }
+    /** Clones this validator. */
+    Clone() {
+        return new Validator(this.context, this.type, this.isAccelerated, this.hasCodec, this.code, this.check);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.context, this.type, value);
+        throw new ParseError(value, this.Errors(value));
+    }
+    /** Decodes a value */
+    Decode(value) {
+        const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value);
+        return result;
+    }
+    /** Encodes a value */
+    Encode(value) {
+        const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value);
+        return result;
+    }
+}

package/node_modules/typebox/build/error/errors.d.mts

@@ -0,0 +1,214 @@
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TGuardError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export declare function IsValidationError(value: unknown): value is TValidationError;
+export type TLocalizedValidationError = TValidationError & {
+    message: string;
+};
+export declare function IsLocalizedValidationError(value: unknown): value is TLocalizedValidationError;
+export type TLocalizedValidationMessageCallback = (error: TValidationError) => string;
+export interface TValidationErrorBase {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+}
+export interface TAdditionalPropertiesError extends TValidationErrorBase {
+    keyword: 'additionalProperties';
+    params: {
+        additionalProperties: string[];
+    };
+}
+export interface TAnyOfError extends TValidationErrorBase {
+    keyword: 'anyOf';
+    params: {};
+}
+export interface TBooleanError extends TValidationErrorBase {
+    keyword: 'boolean';
+    params: {};
+}
+export interface TConstError extends TValidationErrorBase {
+    keyword: 'const';
+    params: {
+        allowedValue: unknown;
+    };
+}
+export interface TContainsError extends TValidationErrorBase {
+    keyword: 'contains';
+    params: {
+        minContains: number;
+        maxContains?: number;
+    };
+}
+export interface TDependenciesError extends TValidationErrorBase {
+    keyword: 'dependencies';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TDependentRequiredError extends TValidationErrorBase {
+    keyword: 'dependentRequired';
+    params: {
+        property: string;
+        dependencies: string[];
+    };
+}
+export interface TEnumError extends TValidationErrorBase {
+    keyword: 'enum';
+    params: {
+        allowedValues: unknown[];
+    };
+}
+export interface TExclusiveMaximumError extends TValidationErrorBase {
+    keyword: 'exclusiveMaximum';
+    params: {
+        comparison: '<';
+        limit: number | bigint;
+    };
+}
+export interface TExclusiveMinimumError extends TValidationErrorBase {
+    keyword: 'exclusiveMinimum';
+    params: {
+        comparison: '>';
+        limit: number | bigint;
+    };
+}
+export interface TFormatError extends TValidationErrorBase {
+    keyword: 'format';
+    params: {
+        format: string;
+    };
+}
+export interface TGuardError extends TValidationErrorBase {
+    keyword: '~guard';
+    params: {
+        errors: object[];
+    };
+}
+export interface TIfError extends TValidationErrorBase {
+    keyword: 'if';
+    params: {
+        failingKeyword: 'then' | 'else';
+    };
+}
+export interface TMaximumError extends TValidationErrorBase {
+    keyword: 'maximum';
+    params: {
+        comparison: '<=';
+        limit: number | bigint;
+    };
+}
+export interface TMaxItemsError extends TValidationErrorBase {
+    keyword: 'maxItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxLengthError extends TValidationErrorBase {
+    keyword: 'maxLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMaxPropertiesError extends TValidationErrorBase {
+    keyword: 'maxProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TMinItemsError extends TValidationErrorBase {
+    keyword: 'minItems';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinLengthError extends TValidationErrorBase {
+    keyword: 'minLength';
+    params: {
+        limit: number;
+    };
+}
+export interface TMinPropertiesError extends TValidationErrorBase {
+    keyword: 'minProperties';
+    params: {
+        limit: number;
+    };
+}
+export interface TMultipleOfError extends TValidationErrorBase {
+    keyword: 'multipleOf';
+    params: {
+        multipleOf: number | bigint;
+    };
+}
+export interface TMinimumError extends TValidationErrorBase {
+    keyword: 'minimum';
+    params: {
+        comparison: '>=';
+        limit: number | bigint;
+    };
+}
+export interface TNotError extends TValidationErrorBase {
+    keyword: 'not';
+    params: {};
+}
+export interface TOneOfError extends TValidationErrorBase {
+    keyword: 'oneOf';
+    params: {
+        passingSchemas: number[];
+    };
+}
+export interface TPatternError extends TValidationErrorBase {
+    keyword: 'pattern';
+    params: {
+        pattern: string | RegExp;
+    };
+}
+export interface TPropertyNamesError extends TValidationErrorBase {
+    keyword: 'propertyNames';
+    params: {
+        propertyNames: string[];
+    };
+}
+export interface TRefineError extends TValidationErrorBase {
+    keyword: '~refine';
+    params: {
+        index: number;
+        message: string;
+    };
+}
+export interface TRequiredError extends TValidationErrorBase {
+    keyword: 'required';
+    params: {
+        requiredProperties: string[];
+    };
+}
+export interface TTypeError extends TValidationErrorBase {
+    keyword: 'type';
+    params: {
+        type: string | string[];
+    };
+}
+export interface TUnevaluatedItemsError extends TValidationErrorBase {
+    keyword: 'unevaluatedItems';
+    params: {
+        unevaluatedItems: number[];
+    };
+}
+export interface TUnevaluatedPropertiesError extends TValidationErrorBase {
+    keyword: 'unevaluatedProperties';
+    params: {
+        unevaluatedProperties: PropertyKey[];
+    };
+}
+export interface TUniqueItemsError extends TValidationErrorBase {
+    keyword: 'uniqueItems';
+    params: {
+        duplicateItems: number[];
+    };
+}

package/node_modules/typebox/build/error/errors.mjs

@@ -0,0 +1,18 @@
+// deno-lint-ignore-file ban-types
+import { Guard } from '../guard/index.mjs';
+export function IsValidationError(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'keyword') &&
+        Guard.HasPropertyKey(value, 'schemaPath') &&
+        Guard.HasPropertyKey(value, 'instancePath') &&
+        Guard.HasPropertyKey(value, 'params') &&
+        Guard.IsString(value.keyword) &&
+        Guard.IsString(value.schemaPath) &&
+        Guard.IsString(value.instancePath) &&
+        Guard.IsObject(value.params);
+}
+export function IsLocalizedValidationError(value) {
+    return IsValidationError(value) &&
+        Guard.HasPropertyKey(value, 'message') &&
+        Guard.IsString(value.message);
+}

package/node_modules/typebox/build/error/index.d.mts

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

package/node_modules/typebox/build/error/index.mjs

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

package/node_modules/typebox/build/format/_idna.d.mts

@@ -0,0 +1,2 @@
+export declare function IsIdnLabel(value: string): boolean;
+export declare function IsLabel(value: string): boolean;