/*--------------------------------------------------------------------------

@sinclair/typebox/syntax

The MIT License (MIT)

Copyright (c) 2017-2026 Haydn Paterson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

---------------------------------------------------------------------------*/

import * as T from '../type/index'

// ------------------------------------------------------------------
//
// Dereference
//
// Referential types pull from the Context or defer dereferencing
// for later execution. This overlaps with module dereferencing,
// where named identifiers in the syntax are deferred until
// instantiation. This code should be revised as part of a
// general-purpose Instantiate module (next revision)
//
// ------------------------------------------------------------------
// prettier-ignore
type TDereference<Context extends T.TProperties, Key extends string> = (
  Key extends keyof Context ? Context[Key] : T.TRef<Key>
)
// prettier-ignore
const Dereference = (context: T.TProperties, key: string): T.TSchema => {
  return key in context ? context[key] : T.Ref(key)
}

// ------------------------------------------------------------------
//
// Delimited
//
// Delimited sequences use an accumulated buffer to parse sequence
// tokens. This approach is more scalable than using a Union + Tuple
// + Epsilon pattern, as TypeScript can instantiate deeper when
// tail-call recursive accumulators are employed. However, this
// comes with a latent processing cost due to the need to decode
// the accumulated buffer.
//
// - Encoding: [[<Ident>, ','][], [<Ident>] | []]
//
// ------------------------------------------------------------------
// prettier-ignore
type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (
  Input extends [infer Left, ...infer Right]
  ? Left extends [infer Item, infer _]
  ? TDelimitedDecode<Right, [...Result, Item]>
  : TDelimitedDecode<Right, [...Result, Left]>
  : Result
)
// prettier-ignore
type TDelimited<Input extends [unknown, unknown]> 
  = Input extends [infer Left extends unknown[], infer Right extends unknown[]]
  ? TDelimitedDecode<[...Left, ...Right]>
  : []
// prettier-ignore
const DelimitedDecode = (input: ([unknown, unknown] | unknown)[], result: unknown[] = []) => {
  return input.reduce<unknown[]>((result, left) => {
    return T.ValueGuard.IsArray(left) && left.length === 2
      ? [...result, left[0]]
      : [...result, left]
  }, [])
}
// prettier-ignore
const Delimited = (input: [unknown, unknown]) => {
  const [left, right] = input as [unknown[], unknown[]]
  return DelimitedDecode([...left, ...right])
}
// -------------------------------------------------------------------
// GenericReferenceParameterList: [[Type, ','][], [Type] | []]
// -------------------------------------------------------------------
// prettier-ignore
export type TGenericReferenceParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = TDelimited<Input>
// prettier-ignore
export function GenericReferenceParameterListMapping(input: [unknown, unknown], context: unknown) {
  return Delimited(input)
}
// -------------------------------------------------------------------
// GenericReference: [<Ident>, '<', GenericReferenceParameterList, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TGenericReferenceMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties,
  Result = Context extends T.TProperties
  ? Input extends [infer Reference extends string, '<', infer Args extends T.TSchema[], '>']
  ? T.TInstantiate<TDereference<Context, Reference>, Args>
  : never
  : never
> = Result
// prettier-ignore
export function GenericReferenceMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const type = Dereference(context as T.TProperties, input[0] as string)
  const args = input[2] as T.TSchema[]
  return T.Instantiate(type, args)
}
// -------------------------------------------------------------------
// GenericArgumentsList: [[<Ident>, ','][], [<Ident>] | []]
// -------------------------------------------------------------------
// prettier-ignore
export type TGenericArgumentsListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = TDelimited<Input>
// prettier-ignore
export function GenericArgumentsListMapping(input: [unknown, unknown], context: unknown) {
  return Delimited(input)
}
// -------------------------------------------------------------------
// GenericArguments: ['<', GenericArgumentsList, '>']
// -------------------------------------------------------------------
// prettier-ignore
type GenericArgumentsContext<Arguments extends string[], Context extends T.TProperties, Result extends T.TProperties = {}> = (
  Arguments extends [...infer Left extends string[], infer Right extends string]
  ? GenericArgumentsContext<Left, Context, Result & { [_ in Right]: T.TArgument<Left['length']> }>
  : T.Evaluate<Result & Context>
)
// prettier-ignore
export type TGenericArgumentsMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> =
  Input extends ['<', infer Arguments extends string[], '>']
  ? Context extends infer Context extends T.TProperties
  ? GenericArgumentsContext<Arguments, Context>
  : never
  : never
// ...
// prettier-ignore
const GenericArgumentsContext = (_arguments: string[], context: T.TProperties) => {
  return _arguments.reduce((result, arg, index) => {
    return { ...result, [arg]: T.Argument(index) }
  }, context)
}
// prettier-ignore
export function GenericArgumentsMapping(input: [unknown, unknown, unknown], context: unknown) {
  return input.length === 3
    ? GenericArgumentsContext(input[1] as string[], context as T.TProperties)
    : {}
}
// -------------------------------------------------------------------
// KeywordString: 'string'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordStringMapping<Input extends 'string', Context extends T.TProperties>
  = T.TString
// prettier-ignore
export function KeywordStringMapping(input: 'string', context: unknown) {
  return T.String()
}
// -------------------------------------------------------------------
// KeywordNumber: 'number'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordNumberMapping<Input extends 'number', Context extends T.TProperties>
  = T.TNumber
// prettier-ignore
export function KeywordNumberMapping(input: 'number', context: unknown) {
  return T.Number()
}
// -------------------------------------------------------------------
// KeywordBoolean: 'boolean'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordBooleanMapping<Input extends 'boolean', Context extends T.TProperties>
  = T.TBoolean
// prettier-ignore
export function KeywordBooleanMapping(input: 'boolean', context: unknown) {
  return T.Boolean()
}
// -------------------------------------------------------------------
// KeywordUndefined: 'undefined'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordUndefinedMapping<Input extends 'undefined', Context extends T.TProperties>
  = T.TUndefined
// prettier-ignore
export function KeywordUndefinedMapping(input: 'undefined', context: unknown) {
  return T.Undefined()
}
// -------------------------------------------------------------------
// KeywordNull: 'null'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordNullMapping<Input extends 'null', Context extends T.TProperties>
  = T.TNull
// prettier-ignore
export function KeywordNullMapping(input: 'null', context: unknown) {
  return T.Null()
}
// -------------------------------------------------------------------
// KeywordInteger: 'integer'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordIntegerMapping<Input extends 'integer', Context extends T.TProperties>
  = T.TInteger
// prettier-ignore
export function KeywordIntegerMapping(input: 'integer', context: unknown) {
  return T.Integer()
}
// -------------------------------------------------------------------
// KeywordBigInt: 'bigint'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordBigIntMapping<Input extends 'bigint', Context extends T.TProperties>
  = T.TBigInt
// prettier-ignore
export function KeywordBigIntMapping(input: 'bigint', context: unknown) {
  return T.BigInt()
}
// -------------------------------------------------------------------
// KeywordUnknown: 'unknown'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordUnknownMapping<Input extends 'unknown', Context extends T.TProperties>
  = T.TUnknown
// prettier-ignore
export function KeywordUnknownMapping(input: 'unknown', context: unknown) {
  return T.Unknown()
}
// -------------------------------------------------------------------
// KeywordAny: 'any'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordAnyMapping<Input extends 'any', Context extends T.TProperties>
  = T.TAny
// prettier-ignore
export function KeywordAnyMapping(input: 'any', context: unknown) {
  return T.Any()
}
// -------------------------------------------------------------------
// KeywordNever: 'never'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordNeverMapping<Input extends 'never', Context extends T.TProperties>
  = T.TNever
// prettier-ignore
export function KeywordNeverMapping(input: 'never', context: unknown) {
  return T.Never()
}
// -------------------------------------------------------------------
// KeywordSymbol: 'symbol'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordSymbolMapping<Input extends 'symbol', Context extends T.TProperties>
  = T.TSymbol
// prettier-ignore
export function KeywordSymbolMapping(input: 'symbol', context: unknown) {
  return T.Symbol()
}
// -------------------------------------------------------------------
// KeywordVoid: 'void'
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordVoidMapping<Input extends 'void', Context extends T.TProperties>
  = T.TVoid
// prettier-ignore
export function KeywordVoidMapping(input: 'void', context: unknown) {
  return T.Void()
}
// -------------------------------------------------------------------
// Keyword: KeywordString | KeywordNumber | KeywordBoolean | KeywordUndefined | KeywordNull | KeywordInteger | KeywordBigInt | KeywordUnknown | KeywordAny | KeywordNever | KeywordSymbol | KeywordVoid
// -------------------------------------------------------------------
// prettier-ignore
export type TKeywordMapping<Input extends unknown, Context extends T.TProperties>
  = Input
// prettier-ignore
export function KeywordMapping(input: unknown, context: unknown) {
  return input
}
// -------------------------------------------------------------------
// LiteralString: <String>
// -------------------------------------------------------------------
// prettier-ignore
export type TLiteralStringMapping<Input extends string, Context extends T.TProperties> = 
  Input extends T.TLiteralValue ? T.TLiteral<Input> : never
// prettier-ignore
export function LiteralStringMapping(input: string, context: unknown) {
  return T.Literal(input)
}
// -------------------------------------------------------------------
// LiteralNumber: <Number>
// -------------------------------------------------------------------
// prettier-ignore
export type TLiteralNumberMapping<Input extends string, Context extends T.TProperties> =
  Input extends `${infer Value extends number}` ? T.TLiteral<Value> : never
// prettier-ignore
export function LiteralNumberMapping(input: string, context: unknown) {
  return T.Literal(parseFloat(input))
}
// -------------------------------------------------------------------
// LiteralBoolean: 'true' | 'false'
// -------------------------------------------------------------------
// prettier-ignore
export type TLiteralBooleanMapping<Input extends 'true' | 'false', Context extends T.TProperties> 
  = Input extends 'true' ? T.TLiteral<true> : T.TLiteral<false>
// prettier-ignore
export function LiteralBooleanMapping(input: 'true' | 'false', context: unknown) {
  return T.Literal(input === 'true')
}
// -------------------------------------------------------------------
// Literal: LiteralBoolean | LiteralNumber | LiteralString
// -------------------------------------------------------------------
// prettier-ignore
export type TLiteralMapping<Input extends unknown, Context extends T.TProperties>
  = Input
// prettier-ignore
export function LiteralMapping(input: unknown, context: unknown) {
  return input
}
// -------------------------------------------------------------------
// KeyOf: ['keyof'] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TKeyOfMapping<Input extends [unknown] | [], Context extends T.TProperties>
  = Input extends [unknown] ? true : false
// prettier-ignore
export function KeyOfMapping(input: [unknown] | [], context: unknown) {
  return input.length > 0
}
// -------------------------------------------------------------------
// IndexArray: ['[', Type, ']'] | ['[', ']'][]
// -------------------------------------------------------------------
// prettier-ignore
type TIndexArrayMappingReduce<Input extends unknown[], Result extends unknown[] = []> = (
  Input extends [infer Left extends unknown, ...infer Right extends unknown[]]
  ? Left extends ['[', infer Type extends T.TSchema, ']']
  ? TIndexArrayMappingReduce<Right, [...Result, [Type]]>
  : TIndexArrayMappingReduce<Right, [...Result, []]>
  : Result
)
// prettier-ignore
export type TIndexArrayMapping<Input extends ([unknown, unknown, unknown] | [unknown, unknown])[], Context extends T.TProperties>
  = Input extends unknown[]
  ? TIndexArrayMappingReduce<Input>
  : []
// prettier-ignore
export function IndexArrayMapping(input: ([unknown, unknown, unknown] | [unknown, unknown])[], context: unknown) {
  return input.reduce((result: unknown[], current) => {
    return current.length === 3
      ? [...result, [current[1]]]
      : [...result, []]
  }, [] as unknown[])
}
// -------------------------------------------------------------------
// Extends: ['extends', Type, '?', Type, ':', Type] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], Context extends T.TProperties>
  = Input extends ['extends', infer Type extends T.TSchema, '?', infer True extends T.TSchema, ':', infer False extends T.TSchema]
  ? [Type, True, False]
  : []
// prettier-ignore
export function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [], context: unknown) {
  return input.length === 6
    ? [input[1], input[3], input[5]]
    : []
}
// -------------------------------------------------------------------
// Base: ['(', Type, ')'] | Keyword | Object | Tuple | Literal | Constructor | Function | Mapped | AsyncIterator | Iterator | ConstructorParameters | FunctionParameters | InstanceType | ReturnType | Argument | Awaited | Array | Record | Promise | Partial | Required | Pick | Omit | Exclude | Extract | Uppercase | Lowercase | Capitalize | Uncapitalize | Date | Uint8Array | GenericReference | Reference
// -------------------------------------------------------------------
// prettier-ignore
export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown, Context extends T.TProperties> = (
  Input extends ['(', infer Type extends T.TSchema, ')'] ? Type :
  Input extends infer Type extends T.TSchema ? Type :
  never
)
// prettier-ignore
export function BaseMapping(input: [unknown, unknown, unknown] | unknown, context: unknown) {
  return T.ValueGuard.IsArray(input) && input.length === 3 ? input[1] : input
}
// -------------------------------------------------------------------
// Factor: [KeyOf, Base, IndexArray, Extends]
// -------------------------------------------------------------------
// prettier-ignore
type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (
  IndexArray extends [...infer Left extends unknown[], infer Right extends T.TSchema[]] ? (
    Right extends [infer Indexer extends T.TSchema] ? T.TIndex<TFactorIndexArray<Type, Left>, T.TIndexPropertyKeys<Indexer>> :
    Right extends [] ? T.TArray<TFactorIndexArray<Type, Left>> :
    T.TNever
  ) : Type
)
// prettier-ignore
type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (
  Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema]
  ? T.TExtends<Type, Right, True, False>
  : Type
)
// prettier-ignore
export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> =
  Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]]
  ? KeyOf extends true
  ? TFactorExtends<T.TKeyOf<TFactorIndexArray<Type, IndexArray>>, Extends>
  : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extends>
  : never

// ...
// prettier-ignore
const FactorIndexArray = (Type: T.TSchema, indexArray: unknown[]): T.TSchema => {
  return indexArray.reduceRight<T.TSchema>((result, right) => {
    const _right = right as T.TSchema[]
    return (
      _right.length === 1 ? T.Index(result, _right[0]) :
      _right.length === 0 ? T.Array(result, _right[0]) :
      T.Never()
    )
  }, Type)
}
// prettier-ignore
const FactorExtends = (Type: T.TSchema, Extends: T.TSchema[]) => {
  return Extends.length === 3
    ? T.Extends(Type, Extends[0], Extends[1], Extends[2])
    : Type
}
// prettier-ignore
export function FactorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [KeyOf, Type, IndexArray, Extends] = input as [boolean, T.TSchema, unknown[], T.TSchema[]]
  return KeyOf
    ? FactorExtends(T.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
    : FactorExtends(FactorIndexArray(Type, IndexArray), Extends)
}

// ------------------------------------------------------------------
//
// ExprBinaryMapping
//
// TypeBox Union and Intersection types are flattened to prevent
// excessive nesting of `anyOf` and `allOf`, ensuring a more
// readable and presentable type for the user. This function
// recursively reduces Union and Intersection types based on
// binary expressions parsed from input.
//
// ------------------------------------------------------------------
// prettier-ignore
type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (
  Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (
    TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (
      Operator extends '&' ? (
        Schema extends T.TIntersect<infer Types extends T.TSchema[]>
        ? T.TIntersect<[Left, ...Types]>
        : T.TIntersect<[Left, Schema]>
      ) :
      Operator extends '|' ? (
        Schema extends T.TUnion<infer Types extends T.TSchema[]>
        ? T.TUnion<[Left, ...Types]>
        : T.TUnion<[Left, Schema]>
      ) : never
    ) : never
  ) : Left
)
// prettier-ignore
function ExprBinaryMapping(Left: T.TSchema, Rest: unknown[]): T.TSchema {
  return (
    Rest.length === 3 ? (() => {
      const [Operator, Right, Next] = Rest as [string, T.TSchema, unknown[]]
      const Schema = ExprBinaryMapping(Right, Next)
      if (Operator === '&') {
        return T.TypeGuard.IsIntersect(Schema)
          ? T.Intersect([Left, ...Schema.allOf])
          : T.Intersect([Left, Schema])
      }
      if (Operator === '|') {
        return T.TypeGuard.IsUnion(Schema)
          ? T.Union([Left, ...Schema.anyOf])
          : T.Union([Left, Schema])
      }
      throw 1
    })() : Left
  )
}
// -------------------------------------------------------------------
// ExprTermTail: ['&', Factor, ExprTermTail] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties>
  = Input
// prettier-ignore
export function ExprTermTailMapping(input: [unknown, unknown, unknown] | [], context: unknown) {
  return input
}
// -------------------------------------------------------------------
// ExprTerm: [Factor, ExprTermTail]
// -------------------------------------------------------------------
// prettier-ignore
export type TExprTermMapping<Input extends [unknown, unknown], Context extends T.TProperties> = (
  Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]]
  ? TExprBinaryMapping<Left, Rest>
  : []
)
// prettier-ignore
export function ExprTermMapping(input: [unknown, unknown], context: unknown) {
  const [left, rest] = input as [T.TSchema, unknown[]]
  return ExprBinaryMapping(left, rest)
}
// -------------------------------------------------------------------
// ExprTail: ['|', ExprTerm, ExprTail] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TExprTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties>
  = Input
// prettier-ignore
export function ExprTailMapping(input: [unknown, unknown, unknown] | [], context: unknown) {
  return input
}
// -------------------------------------------------------------------
// Expr: [ExprTerm, ExprTail]
// -------------------------------------------------------------------
// prettier-ignore
export type TExprMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]]
  ? TExprBinaryMapping<Left, Rest>
  : []
// prettier-ignore
export function ExprMapping(input: [unknown, unknown], context: unknown) {
  const [left, rest] = input as [T.TSchema, unknown[]]
  return ExprBinaryMapping(left, rest)
}
// -------------------------------------------------------------------
// Type: GenericArguments -> Expr | Expr
// -------------------------------------------------------------------
// prettier-ignore
export type TTypeMapping<Input extends unknown, Context extends T.TProperties>
  = Input
// prettier-ignore
export function TypeMapping(input: unknown, context: unknown) {
  return input
}
// -------------------------------------------------------------------
// PropertyKey: <Ident> | <String>
// -------------------------------------------------------------------
// prettier-ignore
export type TPropertyKeyMapping<Input extends string, Context extends T.TProperties>
  = Input
// prettier-ignore
export function PropertyKeyMapping(input: string, context: unknown) {
  return input
}
// -------------------------------------------------------------------
// Readonly: ['readonly'] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TReadonlyMapping<Input extends [unknown] | [], Context extends T.TProperties>
  = Input extends [unknown] ? true : false
// prettier-ignore
export function ReadonlyMapping(input: [unknown] | [], context: unknown) {
  return input.length > 0
}
// -------------------------------------------------------------------
// Optional: ['?'] | []
// -------------------------------------------------------------------
// prettier-ignore
export type TOptionalMapping<Input extends [unknown] | [], Context extends T.TProperties>
  = Input extends [unknown] ? true : false
// prettier-ignore
export function OptionalMapping(input: [unknown] | [], context: unknown) {
  return input.length > 0
}
// -------------------------------------------------------------------
// Property: [Readonly, PropertyKey, Optional, ':', Type]
// -------------------------------------------------------------------
// prettier-ignore
export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends T.TSchema] ? {
    [_ in Key]: (
      [IsReadonly, IsOptional] extends [true, true] ? T.TReadonlyOptional<Type> :
      [IsReadonly, IsOptional] extends [true, false] ? T.TReadonly<Type> :
      [IsReadonly, IsOptional] extends [false, true] ? T.TOptional<Type> :
      Type
    )
  } : never
// prettier-ignore
export function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [isReadonly, key, isOptional, _colon, type] = input as [boolean, string, boolean, ':', T.TSchema]
  return {
    [key]: (
      isReadonly && isOptional ? T.ReadonlyOptional(type) :
      isReadonly && !isOptional ? T.Readonly(type) :
      !isReadonly && isOptional ? T.Optional(type) :
      type
    )
  }
}
// -------------------------------------------------------------------
// PropertyDelimiter: [',', '\n'] | [';', '\n'] | [','] | [';'] | ['\n']
// -------------------------------------------------------------------
// prettier-ignore
export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown], Context extends T.TProperties>
  = Input
// prettier-ignore
export function PropertyDelimiterMapping(input: [unknown, unknown] | [unknown], context: unknown) {
  return input
}
// -------------------------------------------------------------------
// PropertyList: [[Property, PropertyDelimiter][], [Property] | []]
// -------------------------------------------------------------------
// prettier-ignore
export type TPropertyListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = TDelimited<Input>
// prettier-ignore
export function PropertyListMapping(input: [unknown, unknown], context: unknown) {
  return Delimited(input)
}
// -------------------------------------------------------------------
// Object: ['{', PropertyList, '}']
// -------------------------------------------------------------------
// prettier-ignore
type TObjectMappingReduce<PropertiesList extends T.TProperties[], Result extends T.TProperties = {}> = (
  PropertiesList extends [infer Left extends T.TProperties, ...infer Right extends T.TProperties[]]
  ? TObjectMappingReduce<Right, Result & Left>
  : { [Key in keyof Result]: Result[Key] }
)
// prettier-ignore
export type TObjectMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> =
  Input extends ['{', infer PropertyList extends T.TProperties[], '}']
  ? T.TObject<TObjectMappingReduce<PropertyList>>
  : never
// prettier-ignore
export function ObjectMapping(input: [unknown, unknown, unknown], context: unknown) {
  const propertyList = input[1] as T.TProperties[]
  return T.Object(propertyList.reduce((result, property) => {
    return { ...result, ...property }
  }, {} as T.TProperties))
}
// -------------------------------------------------------------------
// ElementList: [[Type, ','][], [Type] | []]
// -------------------------------------------------------------------
// prettier-ignore
export type TElementListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = TDelimited<Input>
// prettier-ignore
export function ElementListMapping(input: [unknown, unknown], context: unknown) {
  return Delimited(input)
}
// -------------------------------------------------------------------
// Tuple: ['[', ElementList, ']']
// -------------------------------------------------------------------
// prettier-ignore
export type TTupleMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never
// prettier-ignore
export function TupleMapping(input: [unknown, unknown, unknown], context: unknown) {
  return T.Tuple(input[1] as T.TSchema[])
}
// -------------------------------------------------------------------
// Parameter: [<Ident>, ':', Type]
// -------------------------------------------------------------------
// prettier-ignore
export type TParameterMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends [string, ':', infer Type extends T.TSchema] ? Type : never
// prettier-ignore
export function ParameterMapping(input: [unknown, unknown, unknown], context: unknown) {
  const [_ident, _colon, type] = input as [string, ':', T.TSchema]
  return type
}
// -------------------------------------------------------------------
// ParameterList: [[Parameter, ','][], [Parameter] | []]
// -------------------------------------------------------------------
// prettier-ignore
export type TParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties>
  = TDelimited<Input>
// prettier-ignore
export function ParameterListMapping(input: [unknown, unknown], context: unknown) {
  return Delimited(input)
}
// -------------------------------------------------------------------
// Function: ['(', ParameterList, ')', '=>', Type]
// -------------------------------------------------------------------
// prettier-ignore
export type TFunctionMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema]
  ? T.TFunction<ParameterList, ReturnType>
  : never
// prettier-ignore
export function FunctionMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_lparan, parameterList, _rparan, _arrow, returnType] = input as ['(', T.TSchema[], ')', '=>', T.TSchema]
  return T.Function(parameterList, returnType)
}
// -------------------------------------------------------------------
// Constructor: ['new', '(', ParameterList, ')', '=>', Type]
// -------------------------------------------------------------------
// prettier-ignore
export type TConstructorMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema]
  ? T.TConstructor<ParameterList, InstanceType>
  : never
// prettier-ignore
export function ConstructorMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_new, _lparan, parameterList, _rparan, _arrow, instanceType] = input as ['new', '(', T.TSchema[], ')', '=>', T.TSchema]
  return T.Constructor(parameterList, instanceType)
}
// -------------------------------------------------------------------
// Mapped: ['{', '[', <Ident>, 'in', Type, ']', ':', Type, '}']
// -------------------------------------------------------------------
// prettier-ignore
export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['{', '[', infer _Key extends string, 'in', infer _Right extends T.TSchema, ']', ':', infer _Type extends T.TSchema, '}']
  ? T.TLiteral<'Mapped types not supported'>
  : never
// prettier-ignore
export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_lbrace, _lbracket, _key, _in, _right, _rbracket, _colon, _type] = input as ['{', '[', string, 'in', T.TSchema, ']', ':', T.TSchema, '}']
  return T.Literal('Mapped types not supported')
}
// -------------------------------------------------------------------
// AsyncIterator: ['AsyncIterator', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TAsyncIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['AsyncIterator', '<', infer Type extends T.TSchema, '>']
  ? T.TAsyncIterator<Type>
  : never
// prettier-ignore
export function AsyncIteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['AsyncIterator', '<', T.TSchema, '>']
  return T.AsyncIterator(type)
}
// -------------------------------------------------------------------
// Iterator: ['Iterator', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Iterator', '<', infer Type extends T.TSchema, '>']
  ? T.TIterator<Type>
  : never
// prettier-ignore
export function IteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Iterator', '<', T.TSchema, '>']
  return T.Iterator(type)
}
// -------------------------------------------------------------------
// Argument: ['Argument', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TArgumentMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Argument', '<', infer Type extends T.TSchema, '>']
  ? Type extends T.TLiteral<infer Index extends number>
  ? T.TArgument<Index>
  : T.TNever
  : never
// prettier-ignore
export function ArgumentMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  return T.KindGuard.IsLiteralNumber(input[2])
    ? T.Argument(Math.trunc(input[2].const))
    : T.Never()
}
// -------------------------------------------------------------------
// Awaited: ['Awaited', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TAwaitedMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Awaited', '<', infer Type extends T.TSchema, '>']
  ? T.TAwaited<Type>
  : never
// prettier-ignore
export function AwaitedMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Awaited', '<', T.TSchema, '>']
  return T.Awaited(type)
}
// -------------------------------------------------------------------
// Array: ['Array', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TArrayMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Array', '<', infer Type extends T.TSchema, '>']
  ? T.TArray<Type>
  : never
// prettier-ignore
export function ArrayMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Array', '<', T.TSchema, '>']
  return T.Array(type)
}
// -------------------------------------------------------------------
// Record: ['Record', '<', Type, ',', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TRecordMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Record', '<', infer Key extends T.TSchema, ',', infer Type extends T.TSchema, '>']
  ? T.TRecordOrObject<Key, Type>
  : never
// prettier-ignore
export function RecordMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, key, _comma, type, _rangle] = input as ['Record', '<', T.TSchema, ',', T.TSchema, '>']
  return T.Record(key, type)
}
// -------------------------------------------------------------------
// Promise: ['Promise', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TPromiseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Promise', '<', infer Type extends T.TSchema, '>']
  ? T.TPromise<Type>
  : never
// prettier-ignore
export function PromiseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Promise', '<', T.TSchema, '>']
  return T.Promise(type)
}
// -------------------------------------------------------------------
// ConstructorParameters: ['ConstructorParameters', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TConstructorParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['ConstructorParameters', '<', infer Type extends T.TSchema, '>']
  ? T.TConstructorParameters<Type>
  : never
// prettier-ignore
export function ConstructorParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['ConstructorParameters', '<', T.TSchema, '>']
  return T.ConstructorParameters(type)
}
// -------------------------------------------------------------------
// FunctionParameters: ['Parameters', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TFunctionParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Parameters', '<', infer Type extends T.TSchema, '>']
  ? T.TParameters<Type>
  : never
// prettier-ignore
export function FunctionParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Parameters', '<', T.TSchema, '>']
  return T.Parameters(type)
}
// -------------------------------------------------------------------
// InstanceType: ['InstanceType', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TInstanceTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['InstanceType', '<', infer Type extends T.TSchema, '>']
  ? T.TInstanceType<Type>
  : never
// prettier-ignore
export function InstanceTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['InstanceType', '<', T.TSchema, '>']
  return T.InstanceType(type)
}
// -------------------------------------------------------------------
// ReturnType: ['ReturnType', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TReturnTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['ReturnType', '<', infer Type extends T.TSchema, '>']
  ? T.TReturnType<Type>
  : never
// prettier-ignore
export function ReturnTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['ReturnType', '<', T.TSchema, '>']
  return T.ReturnType(type)
}
// -------------------------------------------------------------------
// Partial: ['Partial', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TPartialMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Partial', '<', infer Type extends T.TSchema, '>']
  ? T.TPartial<Type>
  : never
// prettier-ignore
export function PartialMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Partial', '<', T.TSchema, '>']
  return T.Partial(type)
}
// -------------------------------------------------------------------
// Required: ['Required', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TRequiredMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Required', '<', infer Type extends T.TSchema, '>']
  ? T.TRequired<Type>
  : never
// prettier-ignore
export function RequiredMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Required', '<', T.TSchema, '>']
  return T.Required(type)
}
// -------------------------------------------------------------------
// Pick: ['Pick', '<', Type, ',', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TPickMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Pick', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
  ? T.TPick<Type, Key>
  : never
// prettier-ignore
export function PickMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, key, _comma, type, _rangle] = input as ['Pick', '<', T.TSchema, ',', T.TSchema, '>']
  return T.Pick(key, type)
}
// -------------------------------------------------------------------
// Omit: ['Omit', '<', Type, ',', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TOmitMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Omit', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
  ? T.TOmit<Type, Key>
  : never
// prettier-ignore
export function OmitMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, key, _comma, type, _rangle] = input as ['Omit', '<', T.TSchema, ',', T.TSchema, '>']
  return T.Omit(key, type)
}
// -------------------------------------------------------------------
// Exclude: ['Exclude', '<', Type, ',', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TExcludeMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Exclude', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
  ? T.TExclude<Type, Key>
  : never
// prettier-ignore
export function ExcludeMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, key, _comma, type, _rangle] = input as ['Exclude', '<', T.TSchema, ',', T.TSchema, '>']
  return T.Exclude(key, type)
}
// -------------------------------------------------------------------
// Extract: ['Extract', '<', Type, ',', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TExtractMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Extract', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>']
  ? T.TExtract<Type, Key>
  : never
// prettier-ignore
export function ExtractMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, key, _comma, type, _rangle] = input as ['Extract', '<', T.TSchema, ',', T.TSchema, '>']
  return T.Extract(key, type)
}
// -------------------------------------------------------------------
// Uppercase: ['Uppercase', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TUppercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Uppercase', '<', infer Type extends T.TSchema, '>']
  ? T.TUppercase<Type>
  : never
// prettier-ignore
export function UppercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Uppercase', '<', T.TSchema, '>']
  return T.Uppercase(type)
}
// -------------------------------------------------------------------
// Lowercase: ['Lowercase', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TLowercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Lowercase', '<', infer Type extends T.TSchema, '>']
  ? T.TLowercase<Type>
  : never
// prettier-ignore
export function LowercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Lowercase', '<', T.TSchema, '>']
  return T.Lowercase(type)
}
// -------------------------------------------------------------------
// Capitalize: ['Capitalize', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TCapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Capitalize', '<', infer Type extends T.TSchema, '>']
  ? T.TCapitalize<Type>
  : never
// prettier-ignore
export function CapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Capitalize', '<', T.TSchema, '>']
  return T.Capitalize(type)
}
// -------------------------------------------------------------------
// Uncapitalize: ['Uncapitalize', '<', Type, '>']
// -------------------------------------------------------------------
// prettier-ignore
export type TUncapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties>
  = Input extends ['Uncapitalize', '<', infer Type extends T.TSchema, '>']
  ? T.TUncapitalize<Type>
  : never
// prettier-ignore
export function UncapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown) {
  const [_name, _langle, type, _rangle] = input as ['Uncapitalize', '<', T.TSchema, '>']
  return T.Uncapitalize(type)
}
// -------------------------------------------------------------------
// Date: 'Date'
// -------------------------------------------------------------------
// prettier-ignore
export type TDateMapping<Input extends 'Date', Context extends T.TProperties>
  = T.TDate
// prettier-ignore
export function DateMapping(input: 'Date', context: unknown) {
  return T.Date()
}
// -------------------------------------------------------------------
// Uint8Array: 'Uint8Array'
// -------------------------------------------------------------------
// prettier-ignore
export type TUint8ArrayMapping<Input extends 'Uint8Array', Context extends T.TProperties>
  = T.TUint8Array
// prettier-ignore
export function Uint8ArrayMapping(input: 'Uint8Array', context: unknown) {
  return T.Uint8Array()
}
// -------------------------------------------------------------------
// Reference: <Ident>
// -------------------------------------------------------------------
// prettier-ignore
export type TReferenceMapping<Input extends string, Context extends T.TProperties> 
  = Context extends T.TProperties
      ? Input extends string
        ? TDereference<Context, Input>
        : never
      : never
// prettier-ignore
export function ReferenceMapping(input: string, context: unknown) {
  const target = Dereference(context as T.TProperties, input)
  return target
}