@sinclair/typebox 0.32.0-dev-2 → 0.32.0-dev-4

package/type/function/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./function"), exports);

package/type/guard/index.d.ts

@@ -0,0 +1,2 @@
+export * as TypeGuard from './type';
+export * as ValueGuard from './value';

package/type/guard/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueGuard = exports.TypeGuard = void 0;
+exports.TypeGuard = require("./type");
+exports.ValueGuard = require("./value");

package/type/guard/type.d.ts

@@ -0,0 +1,88 @@
+import { Kind, Hint, TransformKind } from '../symbols/index';
+import type { TransformOptions } from '../transform/index';
+import type { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TRecord } from '../record/index';
+import type { TString } from '../string/index';
+import type { TUnion } from '../union/index';
+import type { TAny } from '../any/index';
+import type { TAsyncIterator } from '../async-iterator/index';
+import type { TBigInt } from '../bigint/index';
+import type { TConstructor } from '../constructor/index';
+import type { TFunction } from '../function/index';
+import type { TInteger } from '../integer/index';
+import type { TIntersect } from '../intersect/index';
+import type { TIterator } from '../iterator/index';
+import type { TLiteral } from '../literal/index';
+import type { TNever } from '../never/index';
+import type { TNot } from '../not/index';
+import type { TNull } from '../null/index';
+import type { TNumber } from '../number/index';
+import type { TObject } from '../object/index';
+import type { TOptional } from '../optional/index';
+import type { TPromise } from '../promise/index';
+import type { TReadonly } from '../readonly/index';
+import type { TRef } from '../ref/index';
+import type { TSchema } from '../schema/index';
+import type { TSymbol } from '../symbol/index';
+import type { TTuple } from '../tuple/index';
+import type { TUint8Array } from '../uint8array/index';
+import type { TUndefined } from '../undefined/index';
+import type { TUnknown } from '../unknown/index';
+import type { TUnsafe } from '../unsafe/index';
+import type { TVoid } from '../void/index';
+import type { TDate } from '../date/index';
+import type { TThis } from '../recursive/index';
+export declare class TypeGuardUnknownTypeError extends Error {
+}
+export declare function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
+export declare function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
+export declare function TAny(schema: unknown): schema is TAny;
+export declare function TArray(schema: unknown): schema is TArray;
+export declare function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
+export declare function TBigInt(schema: unknown): schema is TBigInt;
+export declare function TBoolean(schema: unknown): schema is TBoolean;
+export declare function TConstructor(schema: unknown): schema is TConstructor;
+export declare function TDate(schema: unknown): schema is TDate;
+export declare function TFunction(schema: unknown): schema is TFunction;
+export declare function TInteger(schema: unknown): schema is TInteger;
+export declare function TIntersect(schema: unknown): schema is TIntersect;
+export declare function TIterator(schema: unknown): schema is TIterator;
+export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
+    [Kind]: T;
+};
+export declare function TLiteralString(schema: unknown): schema is TLiteral<string>;
+export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
+export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
+export declare function TLiteral(schema: unknown): schema is TLiteral;
+export declare function TNever(schema: unknown): schema is TNever;
+export declare function TNot(schema: unknown): schema is TNot;
+export declare function TNull(schema: unknown): schema is TNull;
+export declare function TNumber(schema: unknown): schema is TNumber;
+export declare function TObject(schema: unknown): schema is TObject;
+export declare function TPromise(schema: unknown): schema is TPromise;
+export declare function TRecord(schema: unknown): schema is TRecord;
+export declare function TRecursive(schema: unknown): schema is {
+    [Hint]: 'Recursive';
+};
+export declare function TRef(schema: unknown): schema is TRef;
+export declare function TString(schema: unknown): schema is TString;
+export declare function TSymbol(schema: unknown): schema is TSymbol;
+export declare function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral<TTemplateLiteralKind[]>;
+export declare function TThis(schema: unknown): schema is TThis;
+export declare function TTransform(schema: unknown): schema is {
+    [TransformKind]: TransformOptions;
+};
+export declare function TTuple(schema: unknown): schema is TTuple;
+export declare function TUndefined(schema: unknown): schema is TUndefined;
+export declare function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
+export declare function TUnion(schema: unknown): schema is TUnion;
+export declare function TUint8Array(schema: unknown): schema is TUint8Array;
+export declare function TUnknown(schema: unknown): schema is TUnknown;
+export declare function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
+export declare function TVoid(schema: unknown): schema is TVoid;
+export declare function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
+    [Kind]: string;
+};
+export declare function TSchema(schema: unknown): schema is TSchema;

package/type/guard/type.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
+const ValueGuard = require("./value");
+const index_1 = require("../symbols/index");
+class TypeGuardUnknownTypeError extends Error {
+}
+exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+const KnownTypes = [
+    'Any',
+    'Array',
+    'AsyncIterator',
+    'BigInt',
+    'Boolean',
+    'Constructor',
+    'Date',
+    'Enum',
+    'Function',
+    'Integer',
+    'Intersect',
+    'Iterator',
+    'Literal',
+    'Not',
+    'Null',
+    'Number',
+    'Object',
+    'Promise',
+    'Record',
+    'Ref',
+    'String',
+    'Symbol',
+    'TemplateLiteral',
+    'This',
+    'Tuple',
+    'Undefined',
+    'Union',
+    'Uint8Array',
+    'Unknown',
+    'Void',
+];
+function IsPattern(value) {
+    try {
+        new RegExp(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function IsControlCharacterFree(value) {
+    if (!ValueGuard.IsString(value))
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+            return false;
+        }
+    }
+    return true;
+}
+function IsAdditionalProperties(value) {
+    return IsOptionalBoolean(value) || (0, index_2.TSchema)(value);
+}
+function IsOptionalBigInt(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
+}
+function IsOptionalString(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
+}
+function IsOptionalPattern(value) {
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+}
+function IsOptionalFormat(value) {
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
+}
+function IsOptionalSchema(value) {
+    return ValueGuard.IsUndefined(value) || (0, index_2.TSchema)(value);
+}
+function TReadonly(schema) {
+    return ValueGuard.IsObject(schema) && schema[index_1.ReadonlyKind] === 'Readonly';
+}
+exports.TReadonly = TReadonly;
+function TOptional(schema) {
+    return ValueGuard.IsObject(schema) && schema[index_1.OptionalKind] === 'Optional';
+}
+exports.TOptional = TOptional;
+function TAny(schema) {
+    return (TKindOf(schema, 'Any') &&
+        IsOptionalString(schema.$id));
+}
+exports.TAny = TAny;
+function TArray(schema) {
+    return (TKindOf(schema, 'Array') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_2.TSchema)(schema.items) &&
+        IsOptionalNumber(schema.minItems) &&
+        IsOptionalNumber(schema.maxItems) &&
+        IsOptionalBoolean(schema.uniqueItems) &&
+        IsOptionalSchema(schema.contains) &&
+        IsOptionalNumber(schema.minContains) &&
+        IsOptionalNumber(schema.maxContains));
+}
+exports.TArray = TArray;
+function TAsyncIterator(schema) {
+    return (TKindOf(schema, 'AsyncIterator') &&
+        schema.type === 'AsyncIterator' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_2.TSchema)(schema.items));
+}
+exports.TAsyncIterator = TAsyncIterator;
+function TBigInt(schema) {
+    return (TKindOf(schema, 'BigInt') &&
+        schema.type === 'bigint' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalBigInt(schema.exclusiveMaximum) &&
+        IsOptionalBigInt(schema.exclusiveMinimum) &&
+        IsOptionalBigInt(schema.maximum) &&
+        IsOptionalBigInt(schema.minimum) &&
+        IsOptionalBigInt(schema.multipleOf));
+}
+exports.TBigInt = TBigInt;
+function TBoolean(schema) {
+    return (TKindOf(schema, 'Boolean') &&
+        schema.type === 'boolean' &&
+        IsOptionalString(schema.$id));
+}
+exports.TBoolean = TBoolean;
+function TConstructor(schema) {
+    return (TKindOf(schema, 'Constructor') &&
+        schema.type === 'Constructor' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
+        (0, index_2.TSchema)(schema.returns));
+}
+exports.TConstructor = TConstructor;
+function TDate(schema) {
+    return (TKindOf(schema, 'Date') &&
+        schema.type === 'Date' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
+        IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+        IsOptionalNumber(schema.maximumTimestamp) &&
+        IsOptionalNumber(schema.minimumTimestamp) &&
+        IsOptionalNumber(schema.multipleOfTimestamp));
+}
+exports.TDate = TDate;
+function TFunction(schema) {
+    return (TKindOf(schema, 'Function') &&
+        schema.type === 'Function' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => (0, index_2.TSchema)(schema)) &&
+        (0, index_2.TSchema)(schema.returns));
+}
+exports.TFunction = TFunction;
+function TInteger(schema) {
+    return (TKindOf(schema, 'Integer') &&
+        schema.type === 'integer' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximum) &&
+        IsOptionalNumber(schema.exclusiveMinimum) &&
+        IsOptionalNumber(schema.maximum) &&
+        IsOptionalNumber(schema.minimum) &&
+        IsOptionalNumber(schema.multipleOf));
+}
+exports.TInteger = TInteger;
+function TIntersect(schema) {
+    return (TKindOf(schema, 'Intersect') &&
+        (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
+        ValueGuard.IsArray(schema.allOf) &&
+        schema.allOf.every(schema => (0, index_2.TSchema)(schema) && !TTransform(schema)) &&
+        IsOptionalString(schema.type) &&
+        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+        IsOptionalString(schema.$id));
+}
+exports.TIntersect = TIntersect;
+function TIterator(schema) {
+    return (TKindOf(schema, 'Iterator') &&
+        schema.type === 'Iterator' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_2.TSchema)(schema.items));
+}
+exports.TIterator = TIterator;
+function TKindOf(schema, kind) {
+    return ValueGuard.IsObject(schema) && index_1.Kind in schema && schema[index_1.Kind] === kind;
+}
+exports.TKindOf = TKindOf;
+function TLiteralString(schema) {
+    return (0, index_3.TLiteral)(schema) && ValueGuard.IsString(schema.const);
+}
+exports.TLiteralString = TLiteralString;
+function TLiteralNumber(schema) {
+    return (0, index_3.TLiteral)(schema) && ValueGuard.IsNumber(schema.const);
+}
+exports.TLiteralNumber = TLiteralNumber;
+function TLiteralBoolean(schema) {
+    return (0, index_3.TLiteral)(schema) && ValueGuard.IsBoolean(schema.const);
+}
+exports.TLiteralBoolean = TLiteralBoolean;
+function TLiteral(schema) {
+    return (TKindOf(schema, 'Literal') &&
+        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
+        ValueGuard.IsNumber(schema.const) ||
+        ValueGuard.IsString(schema.const)));
+}
+exports.TLiteral = TLiteral;
+function TNever(schema) {
+    return (TKindOf(schema, 'Never') &&
+        ValueGuard.IsObject(schema.not) &&
+        Object.getOwnPropertyNames(schema.not).length === 0);
+}
+exports.TNever = TNever;
+function TNot(schema) {
+    return (TKindOf(schema, 'Not') &&
+        (0, index_2.TSchema)(schema.not));
+}
+exports.TNot = TNot;
+function TNull(schema) {
+    return (TKindOf(schema, 'Null') &&
+        schema.type === 'null' &&
+        IsOptionalString(schema.$id));
+}
+exports.TNull = TNull;
+function TNumber(schema) {
+    return (TKindOf(schema, 'Number') &&
+        schema.type === 'number' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximum) &&
+        IsOptionalNumber(schema.exclusiveMinimum) &&
+        IsOptionalNumber(schema.maximum) &&
+        IsOptionalNumber(schema.minimum) &&
+        IsOptionalNumber(schema.multipleOf));
+}
+exports.TNumber = TNumber;
+function TObject(schema) {
+    return (TKindOf(schema, 'Object') &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema.properties) &&
+        Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties));
+}
+exports.TObject = TObject;
+function TPromise(schema) {
+    return (TKindOf(schema, 'Promise') &&
+        schema.type === 'Promise' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_2.TSchema)(schema.item));
+}
+exports.TPromise = TPromise;
+function TRecord(schema) {
+    return (TKindOf(schema, 'Record') &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        ValueGuard.IsObject(schema.patternProperties) &&
+        ((schema) => {
+            const keys = Object.getOwnPropertyNames(schema.patternProperties);
+            return (keys.length === 1 &&
+                IsPattern(keys[0]) &&
+                ValueGuard.IsObject(schema.patternProperties) &&
+                (0, index_2.TSchema)(schema.patternProperties[keys[0]]));
+        })(schema));
+}
+exports.TRecord = TRecord;
+function TRecursive(schema) {
+    return ValueGuard.IsObject(schema) && index_1.Hint in schema && schema[index_1.Hint] === 'Recursive';
+}
+exports.TRecursive = TRecursive;
+function TRef(schema) {
+    return (TKindOf(schema, 'Ref') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+exports.TRef = TRef;
+function TString(schema) {
+    return (TKindOf(schema, 'String') &&
+        schema.type === 'string' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minLength) &&
+        IsOptionalNumber(schema.maxLength) &&
+        IsOptionalPattern(schema.pattern) &&
+        IsOptionalFormat(schema.format));
+}
+exports.TString = TString;
+function TSymbol(schema) {
+    return (TKindOf(schema, 'Symbol') &&
+        schema.type === 'symbol' &&
+        IsOptionalString(schema.$id));
+}
+exports.TSymbol = TSymbol;
+function TTemplateLiteral(schema) {
+    return (TKindOf(schema, 'TemplateLiteral') &&
+        schema.type === 'string' &&
+        ValueGuard.IsString(schema.pattern) &&
+        schema.pattern[0] === '^' &&
+        schema.pattern[schema.pattern.length - 1] === '$');
+}
+exports.TTemplateLiteral = TTemplateLiteral;
+function TThis(schema) {
+    return (TKindOf(schema, 'This') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+exports.TThis = TThis;
+function TTransform(schema) {
+    return ValueGuard.IsObject(schema) && index_1.TransformKind in schema;
+}
+exports.TTransform = TTransform;
+function TTuple(schema) {
+    return (TKindOf(schema, 'Tuple') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsNumber(schema.minItems) &&
+        ValueGuard.IsNumber(schema.maxItems) &&
+        schema.minItems === schema.maxItems &&
+        ((ValueGuard.IsUndefined(schema.items) &&
+            ValueGuard.IsUndefined(schema.additionalItems) &&
+            schema.minItems === 0) || (ValueGuard.IsArray(schema.items) &&
+            schema.items.every(schema => (0, index_2.TSchema)(schema)))));
+}
+exports.TTuple = TTuple;
+function TUndefined(schema) {
+    return (TKindOf(schema, 'Undefined') &&
+        schema.type === 'undefined' &&
+        IsOptionalString(schema.$id));
+}
+exports.TUndefined = TUndefined;
+function TUnionLiteral(schema) {
+    return (0, index_4.TUnion)(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+}
+exports.TUnionLiteral = TUnionLiteral;
+function TUnion(schema) {
+    return (TKindOf(schema, 'Union') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema) &&
+        ValueGuard.IsArray(schema.anyOf) &&
+        schema.anyOf.every(schema => (0, index_2.TSchema)(schema)));
+}
+exports.TUnion = TUnion;
+function TUint8Array(schema) {
+    return (TKindOf(schema, 'Uint8Array') &&
+        schema.type === 'Uint8Array' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minByteLength) &&
+        IsOptionalNumber(schema.maxByteLength));
+}
+exports.TUint8Array = TUint8Array;
+function TUnknown(schema) {
+    return (TKindOf(schema, 'Unknown') &&
+        IsOptionalString(schema.$id));
+}
+exports.TUnknown = TUnknown;
+function TUnsafe(schema) {
+    return TKindOf(schema, 'Unsafe');
+}
+exports.TUnsafe = TUnsafe;
+function TVoid(schema) {
+    return (TKindOf(schema, 'Void') &&
+        schema.type === 'void' &&
+        IsOptionalString(schema.$id));
+}
+exports.TVoid = TVoid;
+function TKind(schema) {
+    return ValueGuard.IsObject(schema) && index_1.Kind in schema && ValueGuard.IsString(schema[index_1.Kind]) && !KnownTypes.includes(schema[index_1.Kind]);
+}
+exports.TKind = TKind;
+function TSchema(schema) {
+    return (ValueGuard.IsObject(schema)) && ((0, index_5.TAny)(schema) ||
+        (0, index_6.TArray)(schema) ||
+        (0, index_7.TBoolean)(schema) ||
+        (0, index_8.TBigInt)(schema) ||
+        (0, index_9.TAsyncIterator)(schema) ||
+        (0, index_10.TConstructor)(schema) ||
+        (0, index_11.TDate)(schema) ||
+        (0, index_12.TFunction)(schema) ||
+        (0, index_13.TInteger)(schema) ||
+        (0, index_14.TIntersect)(schema) ||
+        (0, index_15.TIterator)(schema) ||
+        (0, index_3.TLiteral)(schema) ||
+        (0, index_16.TNever)(schema) ||
+        (0, index_17.TNot)(schema) ||
+        (0, index_18.TNull)(schema) ||
+        (0, index_19.TNumber)(schema) ||
+        (0, index_20.TObject)(schema) ||
+        (0, index_21.TPromise)(schema) ||
+        (0, index_22.TRecord)(schema) ||
+        (0, index_23.TRef)(schema) ||
+        (0, index_24.TString)(schema) ||
+        (0, index_25.TSymbol)(schema) ||
+        (0, index_26.TTemplateLiteral)(schema) ||
+        (0, index_27.TThis)(schema) ||
+        (0, index_28.TTuple)(schema) ||
+        (0, index_29.TUndefined)(schema) ||
+        (0, index_4.TUnion)(schema) ||
+        (0, index_30.TUint8Array)(schema) ||
+        (0, index_31.TUnknown)(schema) ||
+        (0, index_32.TUnsafe)(schema) ||
+        (0, index_33.TVoid)(schema) ||
+        TKind(schema));
+}
+exports.TSchema = TSchema;

package/type/guard/value.d.ts

@@ -0,0 +1,14 @@
+export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
+export declare function IsArray(value: unknown): value is unknown[];
+export declare function IsBigInt(value: unknown): value is bigint;
+export declare function IsBoolean(value: unknown): value is boolean;
+export declare function IsDate(value: unknown): value is Date;
+export declare function IsFunction(value: unknown): value is Function;
+export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
+export declare function IsNull(value: unknown): value is null;
+export declare function IsNumber(value: unknown): value is number;
+export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+export declare function IsString(value: unknown): value is string;
+export declare function IsSymbol(value: unknown): value is symbol;
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+export declare function IsUndefined(value: unknown): value is undefined;

package/type/guard/value.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUndefined = exports.IsUint8Array = exports.IsSymbol = exports.IsString = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsArray = exports.IsAsyncIterator = void 0;
+function IsAsyncIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+exports.IsAsyncIterator = IsAsyncIterator;
+function IsArray(value) {
+    return Array.isArray(value);
+}
+exports.IsArray = IsArray;
+function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+exports.IsBigInt = IsBigInt;
+function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+exports.IsBoolean = IsBoolean;
+function IsDate(value) {
+    return value instanceof globalThis.Date;
+}
+exports.IsDate = IsDate;
+function IsFunction(value) {
+    return typeof value === 'function';
+}
+exports.IsFunction = IsFunction;
+function IsIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+exports.IsIterator = IsIterator;
+function IsNull(value) {
+    return value === null;
+}
+exports.IsNull = IsNull;
+function IsNumber(value) {
+    return typeof value === 'number';
+}
+exports.IsNumber = IsNumber;
+function IsObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+exports.IsObject = IsObject;
+function IsString(value) {
+    return typeof value === 'string';
+}
+exports.IsString = IsString;
+function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+exports.IsSymbol = IsSymbol;
+function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+exports.IsUint8Array = IsUint8Array;
+function IsUndefined(value) {
+    return value === undefined;
+}
+exports.IsUndefined = IsUndefined;

package/type/helpers/helpers.d.ts

@@ -0,0 +1,41 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import type { TNever } from '../never/index';
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
+export type TupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type EmptyString = '';
+export type ZeroString = '0';
+type IncrementBase = {
+    m: '9';
+    t: '01';
+    '0': '1';
+    '1': '2';
+    '2': '3';
+    '3': '4';
+    '4': '5';
+    '5': '6';
+    '6': '7';
+    '7': '8';
+    '8': '9';
+    '9': '0';
+};
+type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
+type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
+type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
+export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+export declare function Increment<T extends string>(T: T): Increment<T>;
+export type AssertProperties<T> = T extends TProperties ? T : TProperties;
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export {};

package/type/helpers/helpers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Increment = void 0;
+function Increment(T) {
+    return (parseInt(T) + 1).toString();
+}
+exports.Increment = Increment;

package/type/helpers/index.d.ts

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

package/type/helpers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helpers"), exports);