export {}
declare global
{
  namespace Van {

    interface State<T> {
      val: T
      readonly oldVal: T
      readonly rawVal: T
    }
    
    // Defining readonly view of State<T> for covariance.
    // Basically we want StateView<string> to implement StateView<string | number>
    type StateView<T> = Readonly<State<T>>
    
    type Val<T> = State<T> | T
    
    type Primitive = string | number | boolean | bigint
    
    // deno-lint-ignore no-explicit-any
    type PropValue = Primitive | ((e: any) => void) | null
    
    type PropValueOrDerived = PropValue | StateView<PropValue> | (() => PropValue)
    
    type Props = Record<string, PropValueOrDerived> & { class?: PropValueOrDerived; is?: string }
    
    type PropsWithKnownKeys<ElementType> = Partial<{[K in keyof ElementType]: PropValueOrDerived}>
    
    type ValidChildDomValue = Primitive | Node | null | undefined
    
    type BindingFunc = ((dom?: Node) => ValidChildDomValue) | ((dom?: Element) => Element)
    
    type ChildDom = ValidChildDomValue | StateView<Primitive | null | undefined> | BindingFunc | readonly ChildDom[]
    
    type TagFunc<Result> = (first?: Props & PropsWithKnownKeys<Result> | ChildDom, ...rest: readonly ChildDom[]) => Result
    
    type Tags = Readonly<Record<string, TagFunc<Element>>> & {
      [K in keyof HTMLElementTagNameMap]: TagFunc<HTMLElementTagNameMap[K]>
    }
  }
  
  const Van:{
    readonly state: <T>(initVal: T)=> Van.State<T>
    readonly derive: <T>(f: () => T) => Van.State<T>
    readonly add: (dom: Element, ...children: readonly Van.ChildDom[]) => Element
    readonly tags: Van.Tags & ((namespaceURI: string) => Readonly<Record<string, Van.TagFunc<Element>>>)
    readonly hydrate: <T extends Node>(dom: T, f: (dom: T) => T | null | undefined) => T
  };


  namespace VanX
  {
    type StateOf<T> = { readonly [K in keyof T]: Van.State<T[K]> }
    type ValueType<T> = T extends (infer V)[] ? V : T[keyof T]
    type KeyType<T> = T extends unknown[] ? number : string
    type ReplacementFunc<T> =
        T extends (infer V)[] ? (items: V[]) => readonly V[] :
        (items: [string, T[keyof T]][]) => readonly [string, T[keyof T]][]
  }
  const VanX:{
    readonly calc: <R>(f: () => R) => R
    readonly reactive: <T extends object>(obj: T) => T
    readonly noreactive: <T extends object>(obj: T) => T
    readonly stateFields: <T extends object>(obj: T) => VanX.StateOf<T>
    readonly raw: <T extends object>(obj: T) => T
    readonly list: <T extends object, ElementType extends Element>(container: (() => ElementType) | ElementType, items: T,itemFunc: (v: Van.State<VanX.ValueType<T>>, deleter: () => void, k: VanX.KeyType<T>) => Node) => ElementType
    readonly replace: <T extends object>(obj: T, replacement: VanX.ReplacementFunc<T> | T) => T
    readonly compact: <T extends object>(obj: T) => T
  };

  namespace Gale { 
    type KeyQuery = "@";
    type KeyPseudo = ":";
    type KeyChild = ".";
    type KeyGroup = "^";
    type UserStyles = Partial<CSSStyleDeclaration> & {[key: `${KeyQuery|KeyPseudo|KeyChild|KeyGroup}${string}`]: UserStyles }
    type UserSheet = Record<string, UserStyles>
    type CollectKeys<Obj> = {[Key in keyof Obj]: Obj[Key] extends object ? Key | CollectKeys<Obj[Key]> : Key }[keyof Obj]
    type FilterKeys<Keys> = Keys extends `${KeyChild|KeyGroup}${infer Rest}` ? Keys : never
    type CrossMultiply<A, B> = A extends string ? B extends string ? `${A}${B}` : never : never 
    type CrossMultiplyRecord<Rec> = keyof Rec | { [K in keyof Rec]: K extends string ? CrossMultiply<K, FilterKeys<CollectKeys<Rec[K]>>> : never }[keyof Rec]
    type Tier = (selector:string, obj:UserStyles)=>string;
    type CreateSheet = <T extends UserSheet>(sheet:UserSheet&T)=> ((...args:CrossMultiplyRecord<T>[])=>string)&{css:string}
  }

  const Gale:Gale.CreateSheet

}