@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/build/import/type/guard/type.mjs

@@ -0,0 +1,366 @@
+import * as ValueGuard from './value.mjs';
+import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
+export class TypeGuardUnknownTypeError extends Error {
+}
+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) || 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) || TSchema(value);
+}
+export function TReadonly(schema) {
+    return ValueGuard.IsObject(schema) && schema[ReadonlyKind] === 'Readonly';
+}
+export function TOptional(schema) {
+    return ValueGuard.IsObject(schema) && schema[OptionalKind] === 'Optional';
+}
+export function TAny(schema) {
+    return (TKindOf(schema, 'Any') &&
+        IsOptionalString(schema.$id));
+}
+export function TArray(schema) {
+    return (TKindOf(schema, 'Array') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items) &&
+        IsOptionalNumber(schema.minItems) &&
+        IsOptionalNumber(schema.maxItems) &&
+        IsOptionalBoolean(schema.uniqueItems) &&
+        IsOptionalSchema(schema.contains) &&
+        IsOptionalNumber(schema.minContains) &&
+        IsOptionalNumber(schema.maxContains));
+}
+export function TAsyncIterator(schema) {
+    return (TKindOf(schema, 'AsyncIterator') &&
+        schema.type === 'AsyncIterator' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items));
+}
+export 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));
+}
+export function TBoolean(schema) {
+    return (TKindOf(schema, 'Boolean') &&
+        schema.type === 'boolean' &&
+        IsOptionalString(schema.$id));
+}
+export function TConstructor(schema) {
+    return (TKindOf(schema, 'Constructor') &&
+        schema.type === 'Constructor' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => TSchema(schema)) &&
+        TSchema(schema.returns));
+}
+export 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));
+}
+export function TFunction(schema) {
+    return (TKindOf(schema, 'Function') &&
+        schema.type === 'Function' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => TSchema(schema)) &&
+        TSchema(schema.returns));
+}
+export 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));
+}
+export function TIntersect(schema) {
+    return (TKindOf(schema, 'Intersect') &&
+        (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
+        ValueGuard.IsArray(schema.allOf) &&
+        schema.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
+        IsOptionalString(schema.type) &&
+        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+        IsOptionalString(schema.$id));
+}
+export function TIterator(schema) {
+    return (TKindOf(schema, 'Iterator') &&
+        schema.type === 'Iterator' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.items));
+}
+export function TKindOf(schema, kind) {
+    return ValueGuard.IsObject(schema) && Kind in schema && schema[Kind] === kind;
+}
+export function TLiteralString(schema) {
+    return TLiteral(schema) && ValueGuard.IsString(schema.const);
+}
+export function TLiteralNumber(schema) {
+    return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
+}
+export function TLiteralBoolean(schema) {
+    return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
+}
+export function TLiteral(schema) {
+    return (TKindOf(schema, 'Literal') &&
+        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
+        ValueGuard.IsNumber(schema.const) ||
+        ValueGuard.IsString(schema.const)));
+}
+export function TNever(schema) {
+    return (TKindOf(schema, 'Never') &&
+        ValueGuard.IsObject(schema.not) &&
+        Object.getOwnPropertyNames(schema.not).length === 0);
+}
+export function TNot(schema) {
+    return (TKindOf(schema, 'Not') &&
+        TSchema(schema.not));
+}
+export function TNull(schema) {
+    return (TKindOf(schema, 'Null') &&
+        schema.type === 'null' &&
+        IsOptionalString(schema.$id));
+}
+export 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));
+}
+export 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) && TSchema(schema)) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties));
+}
+export function TPromise(schema) {
+    return (TKindOf(schema, 'Promise') &&
+        schema.type === 'Promise' &&
+        IsOptionalString(schema.$id) &&
+        TSchema(schema.item));
+}
+export 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) &&
+                TSchema(schema.patternProperties[keys[0]]));
+        })(schema));
+}
+export function TRecursive(schema) {
+    return ValueGuard.IsObject(schema) && Hint in schema && schema[Hint] === 'Recursive';
+}
+export function TRef(schema) {
+    return (TKindOf(schema, 'Ref') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+export 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));
+}
+export function TSymbol(schema) {
+    return (TKindOf(schema, 'Symbol') &&
+        schema.type === 'symbol' &&
+        IsOptionalString(schema.$id));
+}
+export function TTemplateLiteral(schema) {
+    return (TKindOf(schema, 'TemplateLiteral') &&
+        schema.type === 'string' &&
+        ValueGuard.IsString(schema.pattern) &&
+        schema.pattern[0] === '^' &&
+        schema.pattern[schema.pattern.length - 1] === '$');
+}
+export function TThis(schema) {
+    return (TKindOf(schema, 'This') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+export function TTransform(schema) {
+    return ValueGuard.IsObject(schema) && TransformKind in schema;
+}
+export 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 => TSchema(schema)))));
+}
+export function TUndefined(schema) {
+    return (TKindOf(schema, 'Undefined') &&
+        schema.type === 'undefined' &&
+        IsOptionalString(schema.$id));
+}
+export function TUnionLiteral(schema) {
+    return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+}
+export function TUnion(schema) {
+    return (TKindOf(schema, 'Union') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema) &&
+        ValueGuard.IsArray(schema.anyOf) &&
+        schema.anyOf.every(schema => TSchema(schema)));
+}
+export function TUint8Array(schema) {
+    return (TKindOf(schema, 'Uint8Array') &&
+        schema.type === 'Uint8Array' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minByteLength) &&
+        IsOptionalNumber(schema.maxByteLength));
+}
+export function TUnknown(schema) {
+    return (TKindOf(schema, 'Unknown') &&
+        IsOptionalString(schema.$id));
+}
+export function TUnsafe(schema) {
+    return TKindOf(schema, 'Unsafe');
+}
+export function TVoid(schema) {
+    return (TKindOf(schema, 'Void') &&
+        schema.type === 'void' &&
+        IsOptionalString(schema.$id));
+}
+export function TKind(schema) {
+    return ValueGuard.IsObject(schema) && Kind in schema && ValueGuard.IsString(schema[Kind]) && !KnownTypes.includes(schema[Kind]);
+}
+export function TSchema(schema) {
+    return (ValueGuard.IsObject(schema)) && (TAny(schema) ||
+        TArray(schema) ||
+        TBoolean(schema) ||
+        TBigInt(schema) ||
+        TAsyncIterator(schema) ||
+        TConstructor(schema) ||
+        TDate(schema) ||
+        TFunction(schema) ||
+        TInteger(schema) ||
+        TIntersect(schema) ||
+        TIterator(schema) ||
+        TLiteral(schema) ||
+        TNever(schema) ||
+        TNot(schema) ||
+        TNull(schema) ||
+        TNumber(schema) ||
+        TObject(schema) ||
+        TPromise(schema) ||
+        TRecord(schema) ||
+        TRef(schema) ||
+        TString(schema) ||
+        TSymbol(schema) ||
+        TTemplateLiteral(schema) ||
+        TThis(schema) ||
+        TTuple(schema) ||
+        TUndefined(schema) ||
+        TUnion(schema) ||
+        TUint8Array(schema) ||
+        TUnknown(schema) ||
+        TUnsafe(schema) ||
+        TVoid(schema) ||
+        TKind(schema));
+}

package/build/import/type/guard/value.mjs

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

package/build/import/type/helpers/helpers.mjs

@@ -0,0 +1,3 @@
+export function Increment(T) {
+    return (parseInt(T) + 1).toString();
+}

package/build/import/type/indexed/indexed-key.mjs

@@ -0,0 +1,29 @@
+import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralToUnion } from '../template-literal/index.mjs';
+import { TTemplateLiteral as IsTemplateLiteralType, TUnionLiteral as IsUnionLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType, TNumber as IsNumberType, TInteger as IsIntegerType } from '../guard/type.mjs';
+function FromTemplateLiteral(T) {
+    const E = TemplateLiteralParseExact(T.pattern);
+    const F = IsTemplateLiteralFinite(E);
+    const S = TemplateLiteralToUnion(T);
+    return (F === true
+        ? IsUnionLiteralType(S)
+            ? S.anyOf.map(S => S.const.toString())
+            : []
+        : []);
+}
+function FromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [...IndexedKeyResolve(L), ...FromUnion(R)]
+        : []);
+}
+function FromLiteral(T) {
+    return ([T.toString()]);
+}
+export function IndexedKeyResolve(T) {
+    return [...new Set((IsTemplateLiteralType(T) ? FromTemplateLiteral(T) :
+            IsUnionType(T) ? FromUnion(T.anyOf) :
+                IsLiteralType(T) ? FromLiteral(T.const) :
+                    IsNumberType(T) ? ['[number]'] :
+                        IsIntegerType(T) ? ['[number]'] :
+                            []))];
+}

package/build/import/type/indexed/indexed-type.mjs

@@ -0,0 +1,64 @@
+import { Never } from '../never/index.mjs';
+import { IntersectResolve } from '../intersect/index.mjs';
+import { UnionResolve } from '../union/index.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TNever as IsNeverType } from '../guard/type.mjs';
+function FromRest(T, K) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromKey(L, K), ...FromRest(R, K)]
+        : []);
+}
+function FromIntersectRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsNeverType(L)
+            ? [...FromIntersectRest(R)]
+            : [L, ...FromIntersectRest(R)]
+        : []);
+}
+function FromIntersect(T, K) {
+    return (IntersectResolve(FromIntersectRest(FromRest(T, K))));
+}
+function FromUnionRest(T, S = T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsNeverType(L)
+            ? []
+            : FromUnionRest(R, S)
+        : S);
+}
+function FromUnion(T, K) {
+    return (UnionResolve(FromUnionRest(FromRest(T, K))));
+}
+function FromTuple(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? UnionResolve(T) :
+            Never());
+}
+function FromArray(T, K) {
+    return (K === '[number]'
+        ? T
+        : Never());
+}
+function FromProperty(T, K) {
+    return (K in T
+        ? T[K]
+        : Never());
+}
+function FromKey(T, K) {
+    return (IsIntersectType(T) ? FromIntersect(T.allOf, K) :
+        IsUnionType(T) ? FromUnion(T.anyOf, K) :
+            IsTupleType(T) ? FromTuple(T.items ?? [], K) :
+                IsArrayType(T) ? FromArray(T.items, K) :
+                    IsObjectType(T) ? FromProperty(T.properties, K) :
+                        Never());
+}
+function FromKeys(T, K) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? [FromKey(T, L), ...FromKeys(T, R)]
+        : []);
+}
+export function IndexedTypeResolve(T, K) {
+    return (UnionResolve(FromKeys(T, K)));
+}

package/build/import/type/indexed/indexed.mjs

@@ -0,0 +1,9 @@
+import { IndexedTypeResolve } from './indexed-type.mjs';
+import { IndexedKeyResolve } from './indexed-key.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TSchema as IsSchemaType } from '../guard/type.mjs';
+export function Index(T, K, options = {}) {
+    const keys = IsSchemaType(K) ? IndexedKeyResolve(K) : K;
+    const type = IndexedTypeResolve(T, keys);
+    return CloneType(type, options);
+}

package/build/import/type/instance-type/instance-type.mjs

@@ -0,0 +1,4 @@
+import { CloneType } from '../clone/type.mjs';
+export function InstanceType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}

package/build/import/type/integer/integer.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Integer(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Integer',
+        type: 'integer',
+    };
+}

package/build/import/type/intersect/intersect.mjs

@@ -0,0 +1,25 @@
+import { Never } from '../never/index.mjs';
+import { OptionalFromIntersect } from '../modifiers/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { CloneType, CloneRest } from '../clone/type.mjs';
+import { TTransform as IsTransformType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+export function IntersectResolve(T) {
+    return (T.length === 0
+        ? Never()
+        : T.length === 1
+            ? T[0]
+            : OptionalFromIntersect(T));
+}
+export function Intersect(T, options = {}) {
+    if (T.length === 0)
+        return Never();
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransformType(schema)))
+        throw new Error('Cannot intersect transform types');
+    const allObjects = T.every((schema) => IsObjectType(schema));
+    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
+    return (options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) });
+}

package/build/import/type/intrinsic/intrinsic.mjs

@@ -0,0 +1,59 @@
+import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Union } from '../union/index.mjs';
+import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
+import { CloneType } from '../clone/type.mjs';
+function ApplyUncapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toLowerCase(), rest].join('');
+}
+function ApplyCapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toUpperCase(), rest].join('');
+}
+function ApplyUppercase(value) {
+    return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+    return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    const finite = IsTemplateLiteralFinite(expression);
+    if (!finite)
+        return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+    const strings = [...TemplateLiteralGenerate(expression)];
+    const literals = strings.map((value) => Literal(value));
+    const mapped = FromRest(literals, mode);
+    const union = Union(mapped);
+    return TemplateLiteral([union]);
+}
+function FromLiteralValue(value, mode) {
+    return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
+        mode === 'Capitalize' ? ApplyCapitalize(value) :
+            mode === 'Uppercase' ? ApplyUppercase(value) :
+                mode === 'Lowercase' ? ApplyLowercase(value) :
+                    value) : value.toString());
+}
+function FromRest(T, mode) {
+    const [L, ...R] = T;
+    return (T.length > 0 ? [IntrinsicResolve(L, mode), ...FromRest(R, mode)] : []);
+}
+export function IntrinsicResolve(schema, mode) {
+    return (IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
+        IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
+            IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
+                schema);
+}
+export function Uncapitalize(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Uncapitalize'), options);
+}
+export function Uppercase(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Uppercase'), options);
+}
+export function Lowercase(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Lowercase'), options);
+}
+export function Capitalize(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Capitalize'), options);
+}

package/build/import/type/iterator/iterator.mjs

@@ -0,0 +1,10 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Iterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Iterator',
+        type: 'Iterator',
+        items: CloneType(items),
+    };
+}

package/build/import/type/keyof/keyof-string.mjs

@@ -0,0 +1,55 @@
+import { Increment } from '../helpers/index.mjs';
+import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TRecord as IsRecordType } from '../guard/type.mjs';
+function FromRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [KeyOfStringResolve(L), ...FromRest(R)]
+        : []);
+}
+function FromIntersect(T, C = FromRest(T)) {
+    return OperatorUnionMany(C);
+}
+function FromUnion(T) {
+    const C = FromRest(T);
+    return OperatorIntersectMany(C);
+}
+function FromTuple(T, I = '0') {
+    const [_, ...R] = T;
+    return (T.length > 0
+        ? [I, ...FromTuple(R, Increment(I))]
+        : []);
+}
+function FromArray(_) {
+    return (['[number]']);
+}
+function FromProperties(T) {
+    return (globalThis.Object.getOwnPropertyNames(T));
+}
+function FromPatternProperties(patternProperties) {
+    if (!includePatternProperties)
+        return [];
+    const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+    return patternPropertyKeys.map(key => {
+        return (key[0] === '^' && key[key.length - 1] === '$')
+            ? key.slice(1, key.length - 1)
+            : key;
+    });
+}
+export function KeyOfStringResolve(T) {
+    return (IsIntersectType(T) ? FromIntersect(T.allOf) :
+        IsUnionType(T) ? FromUnion(T.anyOf) :
+            IsTupleType(T) ? FromTuple(T.items ?? []) :
+                IsArrayType(T) ? FromArray(T.items) :
+                    IsObjectType(T) ? FromProperties(T.properties) :
+                        IsRecordType(T) ? FromPatternProperties(T.patternProperties) :
+                            []);
+}
+let includePatternProperties = false;
+export function KeyOfStringResolvePattern(schema) {
+    includePatternProperties = true;
+    const keys = KeyOfStringResolve(schema);
+    includePatternProperties = false;
+    const pattern = keys.map((key) => `(${key})`);
+    return `^(${pattern.join('|')})$`;
+}