glre 0.32.0 → 0.34.0

package/dist/index.d.ts

@@ -3,7 +3,32 @@ import { Queue, Frame } from 'refr';
 export { Frame, Fun, Queue } from 'refr';
 import { Nested, EventState } from 'reev';
 
-declare const CONSTANTS: readonly ["bool", "uint", "int", "float", "bvec2", "ivec2", "uvec2", "vec2", "bvec3", "ivec3", "uvec3", "vec3", "bvec4", "ivec4", "uvec4", "vec4", "color", "mat2", "mat3", "mat4", "texture", "sampler2D"];
+declare const TYPE_MAPPING: {
+    readonly bool: "bool";
+    readonly uint: "u32";
+    readonly int: "i32";
+    readonly float: "f32";
+    readonly bvec2: "vec2<bool>";
+    readonly ivec2: "vec2i";
+    readonly uvec2: "vec2u";
+    readonly vec2: "vec2f";
+    readonly bvec3: "vec3<bool>";
+    readonly ivec3: "vec3i";
+    readonly uvec3: "vec3u";
+    readonly vec3: "vec3f";
+    readonly bvec4: "vec4<bool>";
+    readonly ivec4: "vec4i";
+    readonly uvec4: "vec4u";
+    readonly vec4: "vec4f";
+    readonly color: "color";
+    readonly mat2: "mat2x2f";
+    readonly mat3: "mat3x3f";
+    readonly mat4: "mat4x4f";
+    readonly texture: "texture_2d<f32>";
+    readonly sampler2D: "sampler";
+    readonly struct: "struct";
+};
+declare const CONSTANTS: keyof typeof TYPE_MAPPING;
 declare const CONVERSIONS: readonly ["toBool", "toUint", "toInt", "toFloat", "toBvec2", "toIvec2", "toUvec2", "toVec2", "toBvec3", "toIvec3", "toUvec3", "toVec3", "toBvec4", "toIvec4", "toUvec4", "toVec4", "toColor", "toMat2", "toMat3", "toMat4"];
 declare const OPERATORS: {
     readonly add: "+";
@@ -26,7 +51,7 @@ declare const OPERATORS: {
     readonly shiftRight: ">>";
 };
 declare const OPERATOR_KEYS: (keyof typeof OPERATORS)[];
-declare const FUNCTIONS: readonly ["dot", "distance", "length", "lengthSq", "determinant", "luminance", "all", "any", "abs", "sign", "floor", "ceil", "round", "fract", "trunc", "sin", "cos", "tan", "asin", "acos", "atan", "exp", "exp2", "log", "log2", "sqrt", "inverseSqrt", "normalize", "oneMinus", "saturate", "negate", "reciprocal", "dFdx", "dFdy", "fwidth", "cross", "reflect", "refract", "min", "max", "mix", "clamp", "step", "smoothstep", "texture", "textureLod", "textureSize", "cubeTexture", "atan2", "degrees", "faceforward", "bitcast", "cbrt", "difference", "equals", "pow", "pow2", "pow3", "pow4", "radians", "transformDirection"];
+declare const FUNCTIONS: readonly ["dot", "distance", "length", "lengthSq", "determinant", "luminance", "all", "any", "abs", "sign", "floor", "ceil", "round", "fract", "trunc", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "exp", "exp2", "log", "log2", "sqrt", "inverseSqrt", "normalize", "oneMinus", "saturate", "negate", "reciprocal", "dFdx", "dFdy", "fwidth", "degrees", "radians", "cross", "reflect", "refract", "min", "max", "mix", "clamp", "step", "smoothstep", "pow", "atan2", "texture", "textureLod", "textureSize", "cubeTexture", "faceforward", "bitcast", "cbrt", "difference", "equals", "pow2", "pow3", "pow4", "transformDirection"];
 
 type Constants = (typeof CONSTANTS)[number] | 'void';
 type Conversions = (typeof CONVERSIONS)[number];
@@ -43,277 +68,1848 @@ interface FnLayout {
 /**
  * Node
  */
-type NodeTypes = 'attribute' | 'uniform' | 'constant' | 'variable' | 'varying' | 'swizzle' | 'ternary' | 'builtin' | 'conversion' | 'operator' | 'function' | 'scope' | 'assign' | 'loop' | 'define' | 'if' | 'switch' | 'declare' | 'return';
-interface NodeProps {
+type NodeTypes = 'attribute' | 'uniform' | 'constant' | 'variable' | 'varying' | 'ternary' | 'builtin' | 'conversion' | 'operator' | 'function' | 'struct' | 'member' | 'scope' | 'assign' | 'loop' | 'define' | 'if' | 'switch' | 'declare' | 'return';
+interface NodeProps<T extends Record<string, NodeProxy> = {}> {
     id?: string;
-    args?: X[];
+    args?: any[];
     type?: string;
-    children?: X[];
-    inferFrom?: X[];
+    children?: any[];
+    inferFrom?: any[];
     layout?: FnLayout;
     parent?: NodeProxy;
+    fields?: T;
+    initialValues?: T;
 }
 interface NodeContext {
+    gl?: Partial<GL>;
     isFrag?: boolean;
     isWebGL?: boolean;
     binding?: number;
     infers?: WeakMap<NodeProxy, Constants>;
     onMount?: (name: string) => void;
-    webgpu?: WebGPUState;
-    headers?: Map<string, string>;
-    fragInputs?: Map<string, string>;
-    vertInputs?: Map<string, string>;
-    vertOutputs?: Map<string, string>;
-    vertVaryings?: Map<string, string>;
+    code?: {
+        headers: Map<string, string>;
+        fragInputs: Map<string, string>;
+        vertInputs: Map<string, string>;
+        vertOutputs: Map<string, string>;
+        vertVaryings: Map<string, string>;
+        dependencies: Map<string, Set<string>>;
+    };
 }
 /**
- * NodeProxy
+ * infer
+ */
+type InferOperator<L extends Constants, R extends Constants> = L extends R ? L : L extends 'float' | 'int' ? R : R extends 'float' | 'int' ? L : L extends 'mat4' ? R extends 'vec4' ? R : L : L extends 'mat3' ? R extends 'vec3' ? R : L : L extends 'mat2' ? R extends 'vec2' ? R : L : L extends 'vec4' ? R extends 'mat4' ? L : L : L extends 'vec3' ? R extends 'mat3' ? L : L : L extends 'vec2' ? R extends 'mat2' ? L : L : L;
+type _StringLength<S extends string> = S extends `${infer _}${infer Rest}` ? Rest extends '' ? 1 : Rest extends `${infer _}${infer Rest2}` ? Rest2 extends '' ? 2 : Rest2 extends `${infer _}${infer Rest3}` ? Rest3 extends '' ? 3 : 4 : never : never : 0;
+type InferSwizzleType<S extends string> = _StringLength<S> extends 4 ? 'vec4' : _StringLength<S> extends 3 ? 'vec3' : _StringLength<S> extends 2 ? 'vec2' : 'float';
+/**
+ * Swizzles
  */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`;
 type Swizzles = _Swizzles<'x' | 'y' | 'z' | 'w'> | _Swizzles<'r' | 'g' | 'b' | 'a'> | _Swizzles<'p' | 'q'> | _Swizzles<'s' | 't'>;
 type NodeProxyMethods = Functions | Operators | Conversions | Swizzles | 'type' | 'props' | 'isProxy' | 'assign' | 'toVar' | 'toString';
-type DynamicProperties = {
-    [K in string as K extends NodeProxyMethods ? never : K]: NodeProxy;
-};
-interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
-    assign(n: X): NodeProxy;
-    toVar(name?: string): NodeProxy;
+interface BaseNodeProxy<T extends Constants> {
+    assign(x: any): NodeProxy<T>;
+    toVar(name?: string): NodeProxy<T>;
     toString(c?: NodeContext): string;
     type: NodeTypes;
     props: NodeProps;
     isProxy: true;
-    add(n: X): NodeProxy;
-    sub(n: X): NodeProxy;
-    mul(n: X): NodeProxy;
-    div(n: X): NodeProxy;
-    mod(n: X): NodeProxy;
-    equal(n: X): NodeProxy;
-    notEqual(n: X): NodeProxy;
-    lessThan(n: X): NodeProxy;
-    lessThanEqual(n: X): NodeProxy;
-    greaterThan(n: X): NodeProxy;
-    greaterThanEqual(n: X): NodeProxy;
-    and(n: X): NodeProxy;
-    or(n: X): NodeProxy;
-    not(): NodeProxy;
-    toBool(): NodeProxy;
-    toUint(): NodeProxy;
-    toInt(): NodeProxy;
-    toFloat(): NodeProxy;
-    toBvec2(): NodeProxy;
-    toIvec2(): NodeProxy;
-    toUvec2(): NodeProxy;
-    toVec2(): NodeProxy;
-    toBvec3(): NodeProxy;
-    toIvec3(): NodeProxy;
-    toUvec3(): NodeProxy;
-    toVec3(): NodeProxy;
-    toBvec4(): NodeProxy;
-    toIvec4(): NodeProxy;
-    toUvec4(): NodeProxy;
-    toVec4(): NodeProxy;
-    toColor(): NodeProxy;
-    toMat2(): NodeProxy;
-    toMat3(): NodeProxy;
-    toMat4(): NodeProxy;
-    abs(): NodeProxy;
-    sin(): NodeProxy;
-    cos(): NodeProxy;
-    tan(): NodeProxy;
-    asin(): NodeProxy;
-    acos(): NodeProxy;
-    atan(): NodeProxy;
-    atan2(x: X): NodeProxy;
-    pow(y: X): NodeProxy;
-    pow2(): NodeProxy;
-    pow3(): NodeProxy;
-    pow4(): NodeProxy;
-    sqrt(): NodeProxy;
-    inverseSqrt(): NodeProxy;
-    exp(): NodeProxy;
-    exp2(): NodeProxy;
-    log(): NodeProxy;
-    log2(): NodeProxy;
-    floor(): NodeProxy;
-    ceil(): NodeProxy;
-    round(): NodeProxy;
-    fract(): NodeProxy;
-    trunc(): NodeProxy;
-    min(y: X): NodeProxy;
-    max(y: X): NodeProxy;
-    clamp(min: X, max: X): NodeProxy;
-    saturate(): NodeProxy;
-    mix(y: X, a: X): NodeProxy;
-    step(edge: X): NodeProxy;
-    smoothstep(edge0: X, edge1: X): NodeProxy;
-    length(): NodeProxy;
-    distance(y: X): NodeProxy;
-    dot(y: X): NodeProxy;
-    cross(y: X): NodeProxy;
-    normalize(): NodeProxy;
-    reflect(N: X): NodeProxy;
-    refract(N: X, eta: X): NodeProxy;
-    sign(): NodeProxy;
-    oneMinus(): NodeProxy;
-    reciprocal(): NodeProxy;
-    negate(): NodeProxy;
-    dFdx(): NodeProxy;
-    dFdy(): NodeProxy;
-    fwidth(): NodeProxy;
+    listeners: Set<(value: any) => void>;
+    add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    mul<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    div<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    mod<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    equal<U extends Constants>(x: X<U>): Bool;
+    notEqual<U extends Constants>(x: X<U>): Bool;
+    lessThan<U extends Constants>(x: X<U>): Bool;
+    lessThanEqual<U extends Constants>(x: X<U>): Bool;
+    greaterThan<U extends Constants>(x: X<U>): Bool;
+    greaterThanEqual<U extends Constants>(x: X<U>): Bool;
+    and(x: X<'bool'>): Bool;
+    or(x: X<'bool'>): Bool;
+    not(): Bool;
+    bitAnd(x: X<T>): NodeProxy<T>;
+    bitOr(x: X<T>): NodeProxy<T>;
+    bitXor(x: X<T>): NodeProxy<T>;
+    bitNot(): NodeProxy<T>;
+    shiftLeft<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    shiftRight<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>;
+    toBool(): Bool;
+    toUint(): UInt;
+    toInt(): Int;
+    toFloat(): Float;
+    toBvec2(): BVec2;
+    toIvec2(): IVec2;
+    toUvec2(): UVec2;
+    toVec2(): Vec2;
+    toBvec3(): BVec3;
+    toIvec3(): IVec3;
+    toUvec3(): UVec3;
+    toVec3(): Vec3;
+    toBvec4(): BVec4;
+    toIvec4(): IVec4;
+    toUvec4(): UVec4;
+    toVec4(): Vec4;
+    toColor(): Color;
+    toMat2(): Mat2;
+    toMat3(): Mat3;
+    toMat4(): Mat4;
+    abs(): NodeProxy<T>;
+    sign(): NodeProxy<T>;
+    floor(): NodeProxy<T>;
+    ceil(): NodeProxy<T>;
+    round(): NodeProxy<T>;
+    fract(): NodeProxy<T>;
+    trunc(): NodeProxy<T>;
+    sin(): NodeProxy<T>;
+    cos(): NodeProxy<T>;
+    tan(): NodeProxy<T>;
+    asin(): NodeProxy<T>;
+    acos(): NodeProxy<T>;
+    atan(): NodeProxy<T>;
+    exp(): NodeProxy<T>;
+    exp2(): NodeProxy<T>;
+    log(): NodeProxy<T>;
+    log2(): NodeProxy<T>;
+    sqrt(): NodeProxy<T>;
+    inverseSqrt(): NodeProxy<T>;
+    normalize(): NodeProxy<T>;
+    oneMinus(): NodeProxy<T>;
+    saturate(): NodeProxy<T>;
+    negate(): NodeProxy<T>;
+    reciprocal(): NodeProxy<T>;
+    dFdx(): NodeProxy<T>;
+    dFdy(): NodeProxy<T>;
+    fwidth(): NodeProxy<T>;
+    length(): Float;
+    lengthSq(): Float;
+    determinant(): Float;
+    luminance(): Float;
+    all(): Bool;
+    any(): Bool;
+    cross<U extends Constants>(y: X<U>): Vec3;
+    atan2<U extends Constants>(x: X<U>): NodeProxy<T>;
+    pow<U extends Constants>(y: X<U>): NodeProxy<T>;
+    distance<U extends Constants>(y: X<U>): Float;
+    dot<U extends Constants>(y: X<U>): Float;
+    reflect<U extends Constants>(N: X<U>): NodeProxy<T>;
+    refract<U extends Constants>(N: X<U>, eta: any): NodeProxy<T>;
+    min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>;
+    max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>;
+    mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>;
+    clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>;
+    step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>;
+    smoothstep<U extends Constants, V>(edge0: X<U>, edge1: V): NodeProxy<InferOperator<T, U>>;
+    pow2(): NodeProxy<T>;
+    pow3(): NodeProxy<T>;
+    pow4(): NodeProxy<T>;
+}
+type ReadNodeProxy = {
+    [K in string as K extends NodeProxyMethods ? never : K]: any;
+} & {
+    [K in Swizzles]: NodeProxy<InferSwizzleType<K>>;
+};
+type NodeProxyImpl<T extends Constants = string> = BaseNodeProxy<T> & ReadNodeProxy;
+type Bool = NodeProxyImpl<'bool'>;
+type UInt = NodeProxyImpl<'uint'>;
+type Int = NodeProxyImpl<'int'>;
+type Float = NodeProxyImpl<'float'>;
+type BVec2 = NodeProxyImpl<'bvec2'>;
+type IVec2 = NodeProxyImpl<'ivec2'>;
+type UVec2 = NodeProxyImpl<'uvec2'>;
+type Vec2 = NodeProxyImpl<'vec2'>;
+type BVec3 = NodeProxyImpl<'bvec3'>;
+type IVec3 = NodeProxyImpl<'ivec3'>;
+type UVec3 = NodeProxyImpl<'uvec3'>;
+type Vec3 = NodeProxyImpl<'vec3'>;
+type BVec4 = NodeProxyImpl<'bvec4'>;
+type IVec4 = NodeProxyImpl<'ivec4'>;
+type UVec4 = NodeProxyImpl<'uvec4'>;
+type Vec4 = NodeProxyImpl<'vec4'>;
+type Color = NodeProxyImpl<'color'>;
+type Mat2 = NodeProxyImpl<'mat2'>;
+type Mat3 = NodeProxyImpl<'mat3'>;
+type Mat4 = NodeProxyImpl<'mat4'>;
+type Texture = NodeProxyImpl<'texture'>;
+type Sampler2D = NodeProxyImpl<'sampler2D'>;
+type Struct = NodeProxyImpl<'struct'>;
+interface ConstantsToType {
+    bool: Bool;
+    uint: UInt;
+    int: Int;
+    float: Float;
+    bvec2: BVec2;
+    ivec2: IVec2;
+    uvec2: UVec2;
+    vec2: Vec2;
+    bvec3: BVec3;
+    ivec3: IVec3;
+    uvec3: UVec3;
+    vec3: Vec3;
+    bvec4: BVec4;
+    ivec4: IVec4;
+    uvec4: UVec4;
+    vec4: Vec4;
+    color: Color;
+    mat2: Mat2;
+    mat3: Mat3;
+    mat4: Mat4;
+    texture: Texture;
+    sampler2D: Sampler2D;
+    struct: Struct;
 }
-type NodeProxy = BaseNodeProxy & DynamicProperties;
-type X = NodeProxy | number | string | boolean | undefined;
+type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType ? ConstantsToType[T] : NodeProxyImpl<T>;
+type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[];
 
-declare const code: (target: X, c?: NodeContext | null) => string;
+declare const code: <T extends Constants>(target: X<T>, c?: NodeContext | null) => string;
 
-declare const node: (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => NodeProxy;
-declare const attribute: (x: X, id?: string) => NodeProxy;
-declare const constant: (x: X, id?: string) => NodeProxy;
-declare const uniform: (x: X, id?: string) => NodeProxy;
-declare const variable: (id?: string) => NodeProxy;
-declare const builtin: (id?: string) => NodeProxy;
-declare const vertexStage: (x: X, id?: string) => NodeProxy;
-declare const swizzle: (key: Swizzles, x: X) => NodeProxy;
-declare const operator: (key: Operators, ...x: X[]) => NodeProxy;
-declare const function_: (key: Functions, ...x: X[]) => NodeProxy;
-declare const conversion: (key: string, ...x: X[]) => NodeProxy;
-declare const select: (x: X, y: X, z: X) => NodeProxy;
+declare const node: <T extends Constants>(type: NodeTypes, props?: NodeProps | null, ...args: X[]) => NodeProxy<T>;
+declare const attribute: <T extends Constants>(x: X, id?: string) => NodeProxy<T>;
+declare const constant: <T extends Constants>(x: X<T>, id?: string) => NodeProxy<T>;
+declare const uniform: <T extends Constants>(x: X<T>, id?: string) => NodeProxy<T>;
+declare const variable: <T extends Constants>(id?: string) => NodeProxy<T>;
+declare const builtin: <T extends Constants>(id?: string) => NodeProxy<T>;
+declare const vertexStage: <T extends Constants>(x: X<T>, id?: string) => NodeProxy<T>;
+declare const member: <T extends Constants>(key: string, x: X) => NodeProxy<T>;
+declare const select: <T extends Constants>(x: X<T>, y: X<T>, z: X) => NodeProxy<T>;
+declare const operator: <T extends Constants>(key: Operators, ...x: X[]) => NodeProxy<T>;
+declare const function_: <T extends Constants>(key: Functions, ...x: X[]) => NodeProxy<T>;
+declare const conversion: <T extends Constants>(key: T, ...x: X[]) => NodeProxy<T>;
 
-declare const toVar: (x: X, id?: string) => NodeProxy;
-declare const assign: (x: X, y: X) => X;
-declare const Return: (x: X) => NodeProxy;
-declare const If: (x: X, fun: () => void) => {
+declare const toVar: <T extends Constants>(x: X<T>, id?: string) => NodeProxy<T>;
+declare const assign: <T extends Constants>(x: X<T>, y: X<T>) => X<T>;
+declare const Return: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const struct: <T extends Record<string, NodeProxy>>(fields: T, id?: string) => (initialValues?: T, instanceId?: string) => BaseNodeProxy<string> & {
+    [x: string]: any;
+} & {
+    x: Float;
+    y: Float;
+    z: Float;
+    w: Float;
+    xx: Vec2;
+    xy: Vec2;
+    xz: Vec2;
+    xw: Vec2;
+    yx: Vec2;
+    yy: Vec2;
+    yz: Vec2;
+    yw: Vec2;
+    zx: Vec2;
+    zy: Vec2;
+    zz: Vec2;
+    zw: Vec2;
+    wx: Vec2;
+    wy: Vec2;
+    wz: Vec2;
+    ww: Vec2;
+    xxx: Vec3;
+    xxy: Vec3;
+    xxz: Vec3;
+    xxw: Vec3;
+    xyx: Vec3;
+    xyy: Vec3;
+    xyz: Vec3;
+    xyw: Vec3;
+    xzx: Vec3;
+    xzy: Vec3;
+    xzz: Vec3;
+    xzw: Vec3;
+    xwx: Vec3;
+    xwy: Vec3;
+    xwz: Vec3;
+    xww: Vec3;
+    yxx: Vec3;
+    yxy: Vec3;
+    yxz: Vec3;
+    yxw: Vec3;
+    yyx: Vec3;
+    yyy: Vec3;
+    yyz: Vec3;
+    yyw: Vec3;
+    yzx: Vec3;
+    yzy: Vec3;
+    yzz: Vec3;
+    yzw: Vec3;
+    ywx: Vec3;
+    ywy: Vec3;
+    ywz: Vec3;
+    yww: Vec3;
+    zxx: Vec3;
+    zxy: Vec3;
+    zxz: Vec3;
+    zxw: Vec3;
+    zyx: Vec3;
+    zyy: Vec3;
+    zyz: Vec3;
+    zyw: Vec3;
+    zzx: Vec3;
+    zzy: Vec3;
+    zzz: Vec3;
+    zzw: Vec3;
+    zwx: Vec3;
+    zwy: Vec3;
+    zwz: Vec3;
+    zww: Vec3;
+    wxx: Vec3;
+    wxy: Vec3;
+    wxz: Vec3;
+    wxw: Vec3;
+    wyx: Vec3;
+    wyy: Vec3;
+    wyz: Vec3;
+    wyw: Vec3;
+    wzx: Vec3;
+    wzy: Vec3;
+    wzz: Vec3;
+    wzw: Vec3;
+    wwx: Vec3;
+    wwy: Vec3;
+    wwz: Vec3;
+    www: Vec3;
+    xxxx: Vec4;
+    xxxy: Vec4;
+    xxxz: Vec4;
+    xxxw: Vec4;
+    xxyx: Vec4;
+    xxyy: Vec4;
+    xxyz: Vec4;
+    xxyw: Vec4;
+    xxzx: Vec4;
+    xxzy: Vec4;
+    xxzz: Vec4;
+    xxzw: Vec4;
+    xxwx: Vec4;
+    xxwy: Vec4;
+    xxwz: Vec4;
+    xxww: Vec4;
+    xyxx: Vec4;
+    xyxy: Vec4;
+    xyxz: Vec4;
+    xyxw: Vec4;
+    xyyx: Vec4;
+    xyyy: Vec4;
+    xyyz: Vec4;
+    xyyw: Vec4;
+    xyzx: Vec4;
+    xyzy: Vec4;
+    xyzz: Vec4;
+    xyzw: Vec4;
+    xywx: Vec4;
+    xywy: Vec4;
+    xywz: Vec4;
+    xyww: Vec4;
+    xzxx: Vec4;
+    xzxy: Vec4;
+    xzxz: Vec4;
+    xzxw: Vec4;
+    xzyx: Vec4;
+    xzyy: Vec4;
+    xzyz: Vec4;
+    xzyw: Vec4;
+    xzzx: Vec4;
+    xzzy: Vec4;
+    xzzz: Vec4;
+    xzzw: Vec4;
+    xzwx: Vec4;
+    xzwy: Vec4;
+    xzwz: Vec4;
+    xzww: Vec4;
+    xwxx: Vec4;
+    xwxy: Vec4;
+    xwxz: Vec4;
+    xwxw: Vec4;
+    xwyx: Vec4;
+    xwyy: Vec4;
+    xwyz: Vec4;
+    xwyw: Vec4;
+    xwzx: Vec4;
+    xwzy: Vec4;
+    xwzz: Vec4;
+    xwzw: Vec4;
+    xwwx: Vec4;
+    xwwy: Vec4;
+    xwwz: Vec4;
+    xwww: Vec4;
+    yxxx: Vec4;
+    yxxy: Vec4;
+    yxxz: Vec4;
+    yxxw: Vec4;
+    yxyx: Vec4;
+    yxyy: Vec4;
+    yxyz: Vec4;
+    yxyw: Vec4;
+    yxzx: Vec4;
+    yxzy: Vec4;
+    yxzz: Vec4;
+    yxzw: Vec4;
+    yxwx: Vec4;
+    yxwy: Vec4;
+    yxwz: Vec4;
+    yxww: Vec4;
+    yyxx: Vec4;
+    yyxy: Vec4;
+    yyxz: Vec4;
+    yyxw: Vec4;
+    yyyx: Vec4;
+    yyyy: Vec4;
+    yyyz: Vec4;
+    yyyw: Vec4;
+    yyzx: Vec4;
+    yyzy: Vec4;
+    yyzz: Vec4;
+    yyzw: Vec4;
+    yywx: Vec4;
+    yywy: Vec4;
+    yywz: Vec4;
+    yyww: Vec4;
+    yzxx: Vec4;
+    yzxy: Vec4;
+    yzxz: Vec4;
+    yzxw: Vec4;
+    yzyx: Vec4;
+    yzyy: Vec4;
+    yzyz: Vec4;
+    yzyw: Vec4;
+    yzzx: Vec4;
+    yzzy: Vec4;
+    yzzz: Vec4;
+    yzzw: Vec4;
+    yzwx: Vec4;
+    yzwy: Vec4;
+    yzwz: Vec4;
+    yzww: Vec4;
+    ywxx: Vec4;
+    ywxy: Vec4;
+    ywxz: Vec4;
+    ywxw: Vec4;
+    ywyx: Vec4;
+    ywyy: Vec4;
+    ywyz: Vec4;
+    ywyw: Vec4;
+    ywzx: Vec4;
+    ywzy: Vec4;
+    ywzz: Vec4;
+    ywzw: Vec4;
+    ywwx: Vec4;
+    ywwy: Vec4;
+    ywwz: Vec4;
+    ywww: Vec4;
+    zxxx: Vec4;
+    zxxy: Vec4;
+    zxxz: Vec4;
+    zxxw: Vec4;
+    zxyx: Vec4;
+    zxyy: Vec4;
+    zxyz: Vec4;
+    zxyw: Vec4;
+    zxzx: Vec4;
+    zxzy: Vec4;
+    zxzz: Vec4;
+    zxzw: Vec4;
+    zxwx: Vec4;
+    zxwy: Vec4;
+    zxwz: Vec4;
+    zxww: Vec4;
+    zyxx: Vec4;
+    zyxy: Vec4;
+    zyxz: Vec4;
+    zyxw: Vec4;
+    zyyx: Vec4;
+    zyyy: Vec4;
+    zyyz: Vec4;
+    zyyw: Vec4;
+    zyzx: Vec4;
+    zyzy: Vec4;
+    zyzz: Vec4;
+    zyzw: Vec4;
+    zywx: Vec4;
+    zywy: Vec4;
+    zywz: Vec4;
+    zyww: Vec4;
+    zzxx: Vec4;
+    zzxy: Vec4;
+    zzxz: Vec4;
+    zzxw: Vec4;
+    zzyx: Vec4;
+    zzyy: Vec4;
+    zzyz: Vec4;
+    zzyw: Vec4;
+    zzzx: Vec4;
+    zzzy: Vec4;
+    zzzz: Vec4;
+    zzzw: Vec4;
+    zzwx: Vec4;
+    zzwy: Vec4;
+    zzwz: Vec4;
+    zzww: Vec4;
+    zwxx: Vec4;
+    zwxy: Vec4;
+    zwxz: Vec4;
+    zwxw: Vec4;
+    zwyx: Vec4;
+    zwyy: Vec4;
+    zwyz: Vec4;
+    zwyw: Vec4;
+    zwzx: Vec4;
+    zwzy: Vec4;
+    zwzz: Vec4;
+    zwzw: Vec4;
+    zwwx: Vec4;
+    zwwy: Vec4;
+    zwwz: Vec4;
+    zwww: Vec4;
+    wxxx: Vec4;
+    wxxy: Vec4;
+    wxxz: Vec4;
+    wxxw: Vec4;
+    wxyx: Vec4;
+    wxyy: Vec4;
+    wxyz: Vec4;
+    wxyw: Vec4;
+    wxzx: Vec4;
+    wxzy: Vec4;
+    wxzz: Vec4;
+    wxzw: Vec4;
+    wxwx: Vec4;
+    wxwy: Vec4;
+    wxwz: Vec4;
+    wxww: Vec4;
+    wyxx: Vec4;
+    wyxy: Vec4;
+    wyxz: Vec4;
+    wyxw: Vec4;
+    wyyx: Vec4;
+    wyyy: Vec4;
+    wyyz: Vec4;
+    wyyw: Vec4;
+    wyzx: Vec4;
+    wyzy: Vec4;
+    wyzz: Vec4;
+    wyzw: Vec4;
+    wywx: Vec4;
+    wywy: Vec4;
+    wywz: Vec4;
+    wyww: Vec4;
+    wzxx: Vec4;
+    wzxy: Vec4;
+    wzxz: Vec4;
+    wzxw: Vec4;
+    wzyx: Vec4;
+    wzyy: Vec4;
+    wzyz: Vec4;
+    wzyw: Vec4;
+    wzzx: Vec4;
+    wzzy: Vec4;
+    wzzz: Vec4;
+    wzzw: Vec4;
+    wzwx: Vec4;
+    wzwy: Vec4;
+    wzwz: Vec4;
+    wzww: Vec4;
+    wwxx: Vec4;
+    wwxy: Vec4;
+    wwxz: Vec4;
+    wwxw: Vec4;
+    wwyx: Vec4;
+    wwyy: Vec4;
+    wwyz: Vec4;
+    wwyw: Vec4;
+    wwzx: Vec4;
+    wwzy: Vec4;
+    wwzz: Vec4;
+    wwzw: Vec4;
+    wwwx: Vec4;
+    wwwy: Vec4;
+    wwwz: Vec4;
+    wwww: Vec4;
+    r: Float;
+    g: Float;
+    b: Float;
+    a: Float;
+    rr: Vec2;
+    rg: Vec2;
+    rb: Vec2;
+    ra: Vec2;
+    gr: Vec2;
+    gg: Vec2;
+    gb: Vec2;
+    ga: Vec2;
+    br: Vec2;
+    bg: Vec2;
+    bb: Vec2;
+    ba: Vec2;
+    ar: Vec2;
+    ag: Vec2;
+    ab: Vec2;
+    aa: Vec2;
+    rrr: Vec3;
+    rrg: Vec3;
+    rrb: Vec3;
+    rra: Vec3;
+    rgr: Vec3;
+    rgg: Vec3;
+    rgb: Vec3;
+    rga: Vec3;
+    rbr: Vec3;
+    rbg: Vec3;
+    rbb: Vec3;
+    rba: Vec3;
+    rar: Vec3;
+    rag: Vec3;
+    rab: Vec3;
+    raa: Vec3;
+    grr: Vec3;
+    grg: Vec3;
+    grb: Vec3;
+    gra: Vec3;
+    ggr: Vec3;
+    ggg: Vec3;
+    ggb: Vec3;
+    gga: Vec3;
+    gbr: Vec3;
+    gbg: Vec3;
+    gbb: Vec3;
+    gba: Vec3;
+    gar: Vec3;
+    gag: Vec3;
+    gab: Vec3;
+    gaa: Vec3;
+    brr: Vec3;
+    brg: Vec3;
+    brb: Vec3;
+    bra: Vec3;
+    bgr: Vec3;
+    bgg: Vec3;
+    bgb: Vec3;
+    bga: Vec3;
+    bbr: Vec3;
+    bbg: Vec3;
+    bbb: Vec3;
+    bba: Vec3;
+    bar: Vec3;
+    bag: Vec3;
+    bab: Vec3;
+    baa: Vec3;
+    arr: Vec3;
+    arg: Vec3;
+    arb: Vec3;
+    ara: Vec3;
+    agr: Vec3;
+    agg: Vec3;
+    agb: Vec3;
+    aga: Vec3;
+    abr: Vec3;
+    abg: Vec3;
+    abb: Vec3;
+    aba: Vec3;
+    aar: Vec3;
+    aag: Vec3;
+    aab: Vec3;
+    aaa: Vec3;
+    rrrr: Vec4;
+    rrrg: Vec4;
+    rrrb: Vec4;
+    rrra: Vec4;
+    rrgr: Vec4;
+    rrgg: Vec4;
+    rrgb: Vec4;
+    rrga: Vec4;
+    rrbr: Vec4;
+    rrbg: Vec4;
+    rrbb: Vec4;
+    rrba: Vec4;
+    rrar: Vec4;
+    rrag: Vec4;
+    rrab: Vec4;
+    rraa: Vec4;
+    rgrr: Vec4;
+    rgrg: Vec4;
+    rgrb: Vec4;
+    rgra: Vec4;
+    rggr: Vec4;
+    rggg: Vec4;
+    rggb: Vec4;
+    rgga: Vec4;
+    rgbr: Vec4;
+    rgbg: Vec4;
+    rgbb: Vec4;
+    rgba: Vec4;
+    rgar: Vec4;
+    rgag: Vec4;
+    rgab: Vec4;
+    rgaa: Vec4;
+    rbrr: Vec4;
+    rbrg: Vec4;
+    rbrb: Vec4;
+    rbra: Vec4;
+    rbgr: Vec4;
+    rbgg: Vec4;
+    rbgb: Vec4;
+    rbga: Vec4;
+    rbbr: Vec4;
+    rbbg: Vec4;
+    rbbb: Vec4;
+    rbba: Vec4;
+    rbar: Vec4;
+    rbag: Vec4;
+    rbab: Vec4;
+    rbaa: Vec4;
+    rarr: Vec4;
+    rarg: Vec4;
+    rarb: Vec4;
+    rara: Vec4;
+    ragr: Vec4;
+    ragg: Vec4;
+    ragb: Vec4;
+    raga: Vec4;
+    rabr: Vec4;
+    rabg: Vec4;
+    rabb: Vec4;
+    raba: Vec4;
+    raar: Vec4;
+    raag: Vec4;
+    raab: Vec4;
+    raaa: Vec4;
+    grrr: Vec4;
+    grrg: Vec4;
+    grrb: Vec4;
+    grra: Vec4;
+    grgr: Vec4;
+    grgg: Vec4;
+    grgb: Vec4;
+    grga: Vec4;
+    grbr: Vec4;
+    grbg: Vec4;
+    grbb: Vec4;
+    grba: Vec4;
+    grar: Vec4;
+    grag: Vec4;
+    grab: Vec4;
+    graa: Vec4;
+    ggrr: Vec4;
+    ggrg: Vec4;
+    ggrb: Vec4;
+    ggra: Vec4;
+    gggr: Vec4;
+    gggg: Vec4;
+    gggb: Vec4;
+    ggga: Vec4;
+    ggbr: Vec4;
+    ggbg: Vec4;
+    ggbb: Vec4;
+    ggba: Vec4;
+    ggar: Vec4;
+    ggag: Vec4;
+    ggab: Vec4;
+    ggaa: Vec4;
+    gbrr: Vec4;
+    gbrg: Vec4;
+    gbrb: Vec4;
+    gbra: Vec4;
+    gbgr: Vec4;
+    gbgg: Vec4;
+    gbgb: Vec4;
+    gbga: Vec4;
+    gbbr: Vec4;
+    gbbg: Vec4;
+    gbbb: Vec4;
+    gbba: Vec4;
+    gbar: Vec4;
+    gbag: Vec4;
+    gbab: Vec4;
+    gbaa: Vec4;
+    garr: Vec4;
+    garg: Vec4;
+    garb: Vec4;
+    gara: Vec4;
+    gagr: Vec4;
+    gagg: Vec4;
+    gagb: Vec4;
+    gaga: Vec4;
+    gabr: Vec4;
+    gabg: Vec4;
+    gabb: Vec4;
+    gaba: Vec4;
+    gaar: Vec4;
+    gaag: Vec4;
+    gaab: Vec4;
+    gaaa: Vec4;
+    brrr: Vec4;
+    brrg: Vec4;
+    brrb: Vec4;
+    brra: Vec4;
+    brgr: Vec4;
+    brgg: Vec4;
+    brgb: Vec4;
+    brga: Vec4;
+    brbr: Vec4;
+    brbg: Vec4;
+    brbb: Vec4;
+    brba: Vec4;
+    brar: Vec4;
+    brag: Vec4;
+    brab: Vec4;
+    braa: Vec4;
+    bgrr: Vec4;
+    bgrg: Vec4;
+    bgrb: Vec4;
+    bgra: Vec4;
+    bggr: Vec4;
+    bggg: Vec4;
+    bggb: Vec4;
+    bgga: Vec4;
+    bgbr: Vec4;
+    bgbg: Vec4;
+    bgbb: Vec4;
+    bgba: Vec4;
+    bgar: Vec4;
+    bgag: Vec4;
+    bgab: Vec4;
+    bgaa: Vec4;
+    bbrr: Vec4;
+    bbrg: Vec4;
+    bbrb: Vec4;
+    bbra: Vec4;
+    bbgr: Vec4;
+    bbgg: Vec4;
+    bbgb: Vec4;
+    bbga: Vec4;
+    bbbr: Vec4;
+    bbbg: Vec4;
+    bbbb: Vec4;
+    bbba: Vec4;
+    bbar: Vec4;
+    bbag: Vec4;
+    bbab: Vec4;
+    bbaa: Vec4;
+    barr: Vec4;
+    barg: Vec4;
+    barb: Vec4;
+    bara: Vec4;
+    bagr: Vec4;
+    bagg: Vec4;
+    bagb: Vec4;
+    baga: Vec4;
+    babr: Vec4;
+    babg: Vec4;
+    babb: Vec4;
+    baba: Vec4;
+    baar: Vec4;
+    baag: Vec4;
+    baab: Vec4;
+    baaa: Vec4;
+    arrr: Vec4;
+    arrg: Vec4;
+    arrb: Vec4;
+    arra: Vec4;
+    argr: Vec4;
+    argg: Vec4;
+    argb: Vec4;
+    arga: Vec4;
+    arbr: Vec4;
+    arbg: Vec4;
+    arbb: Vec4;
+    arba: Vec4;
+    arar: Vec4;
+    arag: Vec4;
+    arab: Vec4;
+    araa: Vec4;
+    agrr: Vec4;
+    agrg: Vec4;
+    agrb: Vec4;
+    agra: Vec4;
+    aggr: Vec4;
+    aggg: Vec4;
+    aggb: Vec4;
+    agga: Vec4;
+    agbr: Vec4;
+    agbg: Vec4;
+    agbb: Vec4;
+    agba: Vec4;
+    agar: Vec4;
+    agag: Vec4;
+    agab: Vec4;
+    agaa: Vec4;
+    abrr: Vec4;
+    abrg: Vec4;
+    abrb: Vec4;
+    abra: Vec4;
+    abgr: Vec4;
+    abgg: Vec4;
+    abgb: Vec4;
+    abga: Vec4;
+    abbr: Vec4;
+    abbg: Vec4;
+    abbb: Vec4;
+    abba: Vec4;
+    abar: Vec4;
+    abag: Vec4;
+    abab: Vec4;
+    abaa: Vec4;
+    aarr: Vec4;
+    aarg: Vec4;
+    aarb: Vec4;
+    aara: Vec4;
+    aagr: Vec4;
+    aagg: Vec4;
+    aagb: Vec4;
+    aaga: Vec4;
+    aabr: Vec4;
+    aabg: Vec4;
+    aabb: Vec4;
+    aaba: Vec4;
+    aaar: Vec4;
+    aaag: Vec4;
+    aaab: Vec4;
+    aaaa: Vec4;
+    p: Float;
+    q: Float;
+    pp: Vec2;
+    pq: Vec2;
+    qp: Vec2;
+    qq: Vec2;
+    ppp: Vec3;
+    ppq: Vec3;
+    pqp: Vec3;
+    pqq: Vec3;
+    qpp: Vec3;
+    qpq: Vec3;
+    qqp: Vec3;
+    qqq: Vec3;
+    pppp: Vec4;
+    pppq: Vec4;
+    ppqp: Vec4;
+    ppqq: Vec4;
+    pqpp: Vec4;
+    pqpq: Vec4;
+    pqqp: Vec4;
+    pqqq: Vec4;
+    qppp: Vec4;
+    qppq: Vec4;
+    qpqp: Vec4;
+    qpqq: Vec4;
+    qqpp: Vec4;
+    qqpq: Vec4;
+    qqqp: Vec4;
+    qqqq: Vec4;
+    s: Float;
+    t: Float;
+    ss: Vec2;
+    st: Vec2;
+    ts: Vec2;
+    tt: Vec2;
+    sss: Vec3;
+    sst: Vec3;
+    sts: Vec3;
+    stt: Vec3;
+    tss: Vec3;
+    tst: Vec3;
+    tts: Vec3;
+    ttt: Vec3;
+    ssss: Vec4;
+    ssst: Vec4;
+    ssts: Vec4;
+    sstt: Vec4;
+    stss: Vec4;
+    stst: Vec4;
+    stts: Vec4;
+    sttt: Vec4;
+    tsss: Vec4;
+    tsst: Vec4;
+    tsts: Vec4;
+    tstt: Vec4;
+    ttss: Vec4;
+    ttst: Vec4;
+    ttts: Vec4;
+    tttt: Vec4;
+};
+declare const If: (x: NodeProxy, fun: () => void) => {
     ElseIf: (_x: X, _fun: () => void) => /*elided*/ any;
     Else: (_fun: () => void) => void;
 };
-declare const Loop: (x: X, fun: (params: {
-    i: NodeProxy;
-}) => void) => NodeProxy;
-declare const Switch: (x: X) => {
+declare const Loop: (x: NodeProxy, fun: (params: {
+    i: Int;
+}) => void) => BaseNodeProxy<string> & {
+    [x: string]: any;
+} & {
+    x: Float;
+    y: Float;
+    z: Float;
+    w: Float;
+    xx: Vec2;
+    xy: Vec2;
+    xz: Vec2;
+    xw: Vec2;
+    yx: Vec2;
+    yy: Vec2;
+    yz: Vec2;
+    yw: Vec2;
+    zx: Vec2;
+    zy: Vec2;
+    zz: Vec2;
+    zw: Vec2;
+    wx: Vec2;
+    wy: Vec2;
+    wz: Vec2;
+    ww: Vec2;
+    xxx: Vec3;
+    xxy: Vec3;
+    xxz: Vec3;
+    xxw: Vec3;
+    xyx: Vec3;
+    xyy: Vec3;
+    xyz: Vec3;
+    xyw: Vec3;
+    xzx: Vec3;
+    xzy: Vec3;
+    xzz: Vec3;
+    xzw: Vec3;
+    xwx: Vec3;
+    xwy: Vec3;
+    xwz: Vec3;
+    xww: Vec3;
+    yxx: Vec3;
+    yxy: Vec3;
+    yxz: Vec3;
+    yxw: Vec3;
+    yyx: Vec3;
+    yyy: Vec3;
+    yyz: Vec3;
+    yyw: Vec3;
+    yzx: Vec3;
+    yzy: Vec3;
+    yzz: Vec3;
+    yzw: Vec3;
+    ywx: Vec3;
+    ywy: Vec3;
+    ywz: Vec3;
+    yww: Vec3;
+    zxx: Vec3;
+    zxy: Vec3;
+    zxz: Vec3;
+    zxw: Vec3;
+    zyx: Vec3;
+    zyy: Vec3;
+    zyz: Vec3;
+    zyw: Vec3;
+    zzx: Vec3;
+    zzy: Vec3;
+    zzz: Vec3;
+    zzw: Vec3;
+    zwx: Vec3;
+    zwy: Vec3;
+    zwz: Vec3;
+    zww: Vec3;
+    wxx: Vec3;
+    wxy: Vec3;
+    wxz: Vec3;
+    wxw: Vec3;
+    wyx: Vec3;
+    wyy: Vec3;
+    wyz: Vec3;
+    wyw: Vec3;
+    wzx: Vec3;
+    wzy: Vec3;
+    wzz: Vec3;
+    wzw: Vec3;
+    wwx: Vec3;
+    wwy: Vec3;
+    wwz: Vec3;
+    www: Vec3;
+    xxxx: Vec4;
+    xxxy: Vec4;
+    xxxz: Vec4;
+    xxxw: Vec4;
+    xxyx: Vec4;
+    xxyy: Vec4;
+    xxyz: Vec4;
+    xxyw: Vec4;
+    xxzx: Vec4;
+    xxzy: Vec4;
+    xxzz: Vec4;
+    xxzw: Vec4;
+    xxwx: Vec4;
+    xxwy: Vec4;
+    xxwz: Vec4;
+    xxww: Vec4;
+    xyxx: Vec4;
+    xyxy: Vec4;
+    xyxz: Vec4;
+    xyxw: Vec4;
+    xyyx: Vec4;
+    xyyy: Vec4;
+    xyyz: Vec4;
+    xyyw: Vec4;
+    xyzx: Vec4;
+    xyzy: Vec4;
+    xyzz: Vec4;
+    xyzw: Vec4;
+    xywx: Vec4;
+    xywy: Vec4;
+    xywz: Vec4;
+    xyww: Vec4;
+    xzxx: Vec4;
+    xzxy: Vec4;
+    xzxz: Vec4;
+    xzxw: Vec4;
+    xzyx: Vec4;
+    xzyy: Vec4;
+    xzyz: Vec4;
+    xzyw: Vec4;
+    xzzx: Vec4;
+    xzzy: Vec4;
+    xzzz: Vec4;
+    xzzw: Vec4;
+    xzwx: Vec4;
+    xzwy: Vec4;
+    xzwz: Vec4;
+    xzww: Vec4;
+    xwxx: Vec4;
+    xwxy: Vec4;
+    xwxz: Vec4;
+    xwxw: Vec4;
+    xwyx: Vec4;
+    xwyy: Vec4;
+    xwyz: Vec4;
+    xwyw: Vec4;
+    xwzx: Vec4;
+    xwzy: Vec4;
+    xwzz: Vec4;
+    xwzw: Vec4;
+    xwwx: Vec4;
+    xwwy: Vec4;
+    xwwz: Vec4;
+    xwww: Vec4;
+    yxxx: Vec4;
+    yxxy: Vec4;
+    yxxz: Vec4;
+    yxxw: Vec4;
+    yxyx: Vec4;
+    yxyy: Vec4;
+    yxyz: Vec4;
+    yxyw: Vec4;
+    yxzx: Vec4;
+    yxzy: Vec4;
+    yxzz: Vec4;
+    yxzw: Vec4;
+    yxwx: Vec4;
+    yxwy: Vec4;
+    yxwz: Vec4;
+    yxww: Vec4;
+    yyxx: Vec4;
+    yyxy: Vec4;
+    yyxz: Vec4;
+    yyxw: Vec4;
+    yyyx: Vec4;
+    yyyy: Vec4;
+    yyyz: Vec4;
+    yyyw: Vec4;
+    yyzx: Vec4;
+    yyzy: Vec4;
+    yyzz: Vec4;
+    yyzw: Vec4;
+    yywx: Vec4;
+    yywy: Vec4;
+    yywz: Vec4;
+    yyww: Vec4;
+    yzxx: Vec4;
+    yzxy: Vec4;
+    yzxz: Vec4;
+    yzxw: Vec4;
+    yzyx: Vec4;
+    yzyy: Vec4;
+    yzyz: Vec4;
+    yzyw: Vec4;
+    yzzx: Vec4;
+    yzzy: Vec4;
+    yzzz: Vec4;
+    yzzw: Vec4;
+    yzwx: Vec4;
+    yzwy: Vec4;
+    yzwz: Vec4;
+    yzww: Vec4;
+    ywxx: Vec4;
+    ywxy: Vec4;
+    ywxz: Vec4;
+    ywxw: Vec4;
+    ywyx: Vec4;
+    ywyy: Vec4;
+    ywyz: Vec4;
+    ywyw: Vec4;
+    ywzx: Vec4;
+    ywzy: Vec4;
+    ywzz: Vec4;
+    ywzw: Vec4;
+    ywwx: Vec4;
+    ywwy: Vec4;
+    ywwz: Vec4;
+    ywww: Vec4;
+    zxxx: Vec4;
+    zxxy: Vec4;
+    zxxz: Vec4;
+    zxxw: Vec4;
+    zxyx: Vec4;
+    zxyy: Vec4;
+    zxyz: Vec4;
+    zxyw: Vec4;
+    zxzx: Vec4;
+    zxzy: Vec4;
+    zxzz: Vec4;
+    zxzw: Vec4;
+    zxwx: Vec4;
+    zxwy: Vec4;
+    zxwz: Vec4;
+    zxww: Vec4;
+    zyxx: Vec4;
+    zyxy: Vec4;
+    zyxz: Vec4;
+    zyxw: Vec4;
+    zyyx: Vec4;
+    zyyy: Vec4;
+    zyyz: Vec4;
+    zyyw: Vec4;
+    zyzx: Vec4;
+    zyzy: Vec4;
+    zyzz: Vec4;
+    zyzw: Vec4;
+    zywx: Vec4;
+    zywy: Vec4;
+    zywz: Vec4;
+    zyww: Vec4;
+    zzxx: Vec4;
+    zzxy: Vec4;
+    zzxz: Vec4;
+    zzxw: Vec4;
+    zzyx: Vec4;
+    zzyy: Vec4;
+    zzyz: Vec4;
+    zzyw: Vec4;
+    zzzx: Vec4;
+    zzzy: Vec4;
+    zzzz: Vec4;
+    zzzw: Vec4;
+    zzwx: Vec4;
+    zzwy: Vec4;
+    zzwz: Vec4;
+    zzww: Vec4;
+    zwxx: Vec4;
+    zwxy: Vec4;
+    zwxz: Vec4;
+    zwxw: Vec4;
+    zwyx: Vec4;
+    zwyy: Vec4;
+    zwyz: Vec4;
+    zwyw: Vec4;
+    zwzx: Vec4;
+    zwzy: Vec4;
+    zwzz: Vec4;
+    zwzw: Vec4;
+    zwwx: Vec4;
+    zwwy: Vec4;
+    zwwz: Vec4;
+    zwww: Vec4;
+    wxxx: Vec4;
+    wxxy: Vec4;
+    wxxz: Vec4;
+    wxxw: Vec4;
+    wxyx: Vec4;
+    wxyy: Vec4;
+    wxyz: Vec4;
+    wxyw: Vec4;
+    wxzx: Vec4;
+    wxzy: Vec4;
+    wxzz: Vec4;
+    wxzw: Vec4;
+    wxwx: Vec4;
+    wxwy: Vec4;
+    wxwz: Vec4;
+    wxww: Vec4;
+    wyxx: Vec4;
+    wyxy: Vec4;
+    wyxz: Vec4;
+    wyxw: Vec4;
+    wyyx: Vec4;
+    wyyy: Vec4;
+    wyyz: Vec4;
+    wyyw: Vec4;
+    wyzx: Vec4;
+    wyzy: Vec4;
+    wyzz: Vec4;
+    wyzw: Vec4;
+    wywx: Vec4;
+    wywy: Vec4;
+    wywz: Vec4;
+    wyww: Vec4;
+    wzxx: Vec4;
+    wzxy: Vec4;
+    wzxz: Vec4;
+    wzxw: Vec4;
+    wzyx: Vec4;
+    wzyy: Vec4;
+    wzyz: Vec4;
+    wzyw: Vec4;
+    wzzx: Vec4;
+    wzzy: Vec4;
+    wzzz: Vec4;
+    wzzw: Vec4;
+    wzwx: Vec4;
+    wzwy: Vec4;
+    wzwz: Vec4;
+    wzww: Vec4;
+    wwxx: Vec4;
+    wwxy: Vec4;
+    wwxz: Vec4;
+    wwxw: Vec4;
+    wwyx: Vec4;
+    wwyy: Vec4;
+    wwyz: Vec4;
+    wwyw: Vec4;
+    wwzx: Vec4;
+    wwzy: Vec4;
+    wwzz: Vec4;
+    wwzw: Vec4;
+    wwwx: Vec4;
+    wwwy: Vec4;
+    wwwz: Vec4;
+    wwww: Vec4;
+    r: Float;
+    g: Float;
+    b: Float;
+    a: Float;
+    rr: Vec2;
+    rg: Vec2;
+    rb: Vec2;
+    ra: Vec2;
+    gr: Vec2;
+    gg: Vec2;
+    gb: Vec2;
+    ga: Vec2;
+    br: Vec2;
+    bg: Vec2;
+    bb: Vec2;
+    ba: Vec2;
+    ar: Vec2;
+    ag: Vec2;
+    ab: Vec2;
+    aa: Vec2;
+    rrr: Vec3;
+    rrg: Vec3;
+    rrb: Vec3;
+    rra: Vec3;
+    rgr: Vec3;
+    rgg: Vec3;
+    rgb: Vec3;
+    rga: Vec3;
+    rbr: Vec3;
+    rbg: Vec3;
+    rbb: Vec3;
+    rba: Vec3;
+    rar: Vec3;
+    rag: Vec3;
+    rab: Vec3;
+    raa: Vec3;
+    grr: Vec3;
+    grg: Vec3;
+    grb: Vec3;
+    gra: Vec3;
+    ggr: Vec3;
+    ggg: Vec3;
+    ggb: Vec3;
+    gga: Vec3;
+    gbr: Vec3;
+    gbg: Vec3;
+    gbb: Vec3;
+    gba: Vec3;
+    gar: Vec3;
+    gag: Vec3;
+    gab: Vec3;
+    gaa: Vec3;
+    brr: Vec3;
+    brg: Vec3;
+    brb: Vec3;
+    bra: Vec3;
+    bgr: Vec3;
+    bgg: Vec3;
+    bgb: Vec3;
+    bga: Vec3;
+    bbr: Vec3;
+    bbg: Vec3;
+    bbb: Vec3;
+    bba: Vec3;
+    bar: Vec3;
+    bag: Vec3;
+    bab: Vec3;
+    baa: Vec3;
+    arr: Vec3;
+    arg: Vec3;
+    arb: Vec3;
+    ara: Vec3;
+    agr: Vec3;
+    agg: Vec3;
+    agb: Vec3;
+    aga: Vec3;
+    abr: Vec3;
+    abg: Vec3;
+    abb: Vec3;
+    aba: Vec3;
+    aar: Vec3;
+    aag: Vec3;
+    aab: Vec3;
+    aaa: Vec3;
+    rrrr: Vec4;
+    rrrg: Vec4;
+    rrrb: Vec4;
+    rrra: Vec4;
+    rrgr: Vec4;
+    rrgg: Vec4;
+    rrgb: Vec4;
+    rrga: Vec4;
+    rrbr: Vec4;
+    rrbg: Vec4;
+    rrbb: Vec4;
+    rrba: Vec4;
+    rrar: Vec4;
+    rrag: Vec4;
+    rrab: Vec4;
+    rraa: Vec4;
+    rgrr: Vec4;
+    rgrg: Vec4;
+    rgrb: Vec4;
+    rgra: Vec4;
+    rggr: Vec4;
+    rggg: Vec4;
+    rggb: Vec4;
+    rgga: Vec4;
+    rgbr: Vec4;
+    rgbg: Vec4;
+    rgbb: Vec4;
+    rgba: Vec4;
+    rgar: Vec4;
+    rgag: Vec4;
+    rgab: Vec4;
+    rgaa: Vec4;
+    rbrr: Vec4;
+    rbrg: Vec4;
+    rbrb: Vec4;
+    rbra: Vec4;
+    rbgr: Vec4;
+    rbgg: Vec4;
+    rbgb: Vec4;
+    rbga: Vec4;
+    rbbr: Vec4;
+    rbbg: Vec4;
+    rbbb: Vec4;
+    rbba: Vec4;
+    rbar: Vec4;
+    rbag: Vec4;
+    rbab: Vec4;
+    rbaa: Vec4;
+    rarr: Vec4;
+    rarg: Vec4;
+    rarb: Vec4;
+    rara: Vec4;
+    ragr: Vec4;
+    ragg: Vec4;
+    ragb: Vec4;
+    raga: Vec4;
+    rabr: Vec4;
+    rabg: Vec4;
+    rabb: Vec4;
+    raba: Vec4;
+    raar: Vec4;
+    raag: Vec4;
+    raab: Vec4;
+    raaa: Vec4;
+    grrr: Vec4;
+    grrg: Vec4;
+    grrb: Vec4;
+    grra: Vec4;
+    grgr: Vec4;
+    grgg: Vec4;
+    grgb: Vec4;
+    grga: Vec4;
+    grbr: Vec4;
+    grbg: Vec4;
+    grbb: Vec4;
+    grba: Vec4;
+    grar: Vec4;
+    grag: Vec4;
+    grab: Vec4;
+    graa: Vec4;
+    ggrr: Vec4;
+    ggrg: Vec4;
+    ggrb: Vec4;
+    ggra: Vec4;
+    gggr: Vec4;
+    gggg: Vec4;
+    gggb: Vec4;
+    ggga: Vec4;
+    ggbr: Vec4;
+    ggbg: Vec4;
+    ggbb: Vec4;
+    ggba: Vec4;
+    ggar: Vec4;
+    ggag: Vec4;
+    ggab: Vec4;
+    ggaa: Vec4;
+    gbrr: Vec4;
+    gbrg: Vec4;
+    gbrb: Vec4;
+    gbra: Vec4;
+    gbgr: Vec4;
+    gbgg: Vec4;
+    gbgb: Vec4;
+    gbga: Vec4;
+    gbbr: Vec4;
+    gbbg: Vec4;
+    gbbb: Vec4;
+    gbba: Vec4;
+    gbar: Vec4;
+    gbag: Vec4;
+    gbab: Vec4;
+    gbaa: Vec4;
+    garr: Vec4;
+    garg: Vec4;
+    garb: Vec4;
+    gara: Vec4;
+    gagr: Vec4;
+    gagg: Vec4;
+    gagb: Vec4;
+    gaga: Vec4;
+    gabr: Vec4;
+    gabg: Vec4;
+    gabb: Vec4;
+    gaba: Vec4;
+    gaar: Vec4;
+    gaag: Vec4;
+    gaab: Vec4;
+    gaaa: Vec4;
+    brrr: Vec4;
+    brrg: Vec4;
+    brrb: Vec4;
+    brra: Vec4;
+    brgr: Vec4;
+    brgg: Vec4;
+    brgb: Vec4;
+    brga: Vec4;
+    brbr: Vec4;
+    brbg: Vec4;
+    brbb: Vec4;
+    brba: Vec4;
+    brar: Vec4;
+    brag: Vec4;
+    brab: Vec4;
+    braa: Vec4;
+    bgrr: Vec4;
+    bgrg: Vec4;
+    bgrb: Vec4;
+    bgra: Vec4;
+    bggr: Vec4;
+    bggg: Vec4;
+    bggb: Vec4;
+    bgga: Vec4;
+    bgbr: Vec4;
+    bgbg: Vec4;
+    bgbb: Vec4;
+    bgba: Vec4;
+    bgar: Vec4;
+    bgag: Vec4;
+    bgab: Vec4;
+    bgaa: Vec4;
+    bbrr: Vec4;
+    bbrg: Vec4;
+    bbrb: Vec4;
+    bbra: Vec4;
+    bbgr: Vec4;
+    bbgg: Vec4;
+    bbgb: Vec4;
+    bbga: Vec4;
+    bbbr: Vec4;
+    bbbg: Vec4;
+    bbbb: Vec4;
+    bbba: Vec4;
+    bbar: Vec4;
+    bbag: Vec4;
+    bbab: Vec4;
+    bbaa: Vec4;
+    barr: Vec4;
+    barg: Vec4;
+    barb: Vec4;
+    bara: Vec4;
+    bagr: Vec4;
+    bagg: Vec4;
+    bagb: Vec4;
+    baga: Vec4;
+    babr: Vec4;
+    babg: Vec4;
+    babb: Vec4;
+    baba: Vec4;
+    baar: Vec4;
+    baag: Vec4;
+    baab: Vec4;
+    baaa: Vec4;
+    arrr: Vec4;
+    arrg: Vec4;
+    arrb: Vec4;
+    arra: Vec4;
+    argr: Vec4;
+    argg: Vec4;
+    argb: Vec4;
+    arga: Vec4;
+    arbr: Vec4;
+    arbg: Vec4;
+    arbb: Vec4;
+    arba: Vec4;
+    arar: Vec4;
+    arag: Vec4;
+    arab: Vec4;
+    araa: Vec4;
+    agrr: Vec4;
+    agrg: Vec4;
+    agrb: Vec4;
+    agra: Vec4;
+    aggr: Vec4;
+    aggg: Vec4;
+    aggb: Vec4;
+    agga: Vec4;
+    agbr: Vec4;
+    agbg: Vec4;
+    agbb: Vec4;
+    agba: Vec4;
+    agar: Vec4;
+    agag: Vec4;
+    agab: Vec4;
+    agaa: Vec4;
+    abrr: Vec4;
+    abrg: Vec4;
+    abrb: Vec4;
+    abra: Vec4;
+    abgr: Vec4;
+    abgg: Vec4;
+    abgb: Vec4;
+    abga: Vec4;
+    abbr: Vec4;
+    abbg: Vec4;
+    abbb: Vec4;
+    abba: Vec4;
+    abar: Vec4;
+    abag: Vec4;
+    abab: Vec4;
+    abaa: Vec4;
+    aarr: Vec4;
+    aarg: Vec4;
+    aarb: Vec4;
+    aara: Vec4;
+    aagr: Vec4;
+    aagg: Vec4;
+    aagb: Vec4;
+    aaga: Vec4;
+    aabr: Vec4;
+    aabg: Vec4;
+    aabb: Vec4;
+    aaba: Vec4;
+    aaar: Vec4;
+    aaag: Vec4;
+    aaab: Vec4;
+    aaaa: Vec4;
+    p: Float;
+    q: Float;
+    pp: Vec2;
+    pq: Vec2;
+    qp: Vec2;
+    qq: Vec2;
+    ppp: Vec3;
+    ppq: Vec3;
+    pqp: Vec3;
+    pqq: Vec3;
+    qpp: Vec3;
+    qpq: Vec3;
+    qqp: Vec3;
+    qqq: Vec3;
+    pppp: Vec4;
+    pppq: Vec4;
+    ppqp: Vec4;
+    ppqq: Vec4;
+    pqpp: Vec4;
+    pqpq: Vec4;
+    pqqp: Vec4;
+    pqqq: Vec4;
+    qppp: Vec4;
+    qppq: Vec4;
+    qpqp: Vec4;
+    qpqq: Vec4;
+    qqpp: Vec4;
+    qqpq: Vec4;
+    qqqp: Vec4;
+    qqqq: Vec4;
+    s: Float;
+    t: Float;
+    ss: Vec2;
+    st: Vec2;
+    ts: Vec2;
+    tt: Vec2;
+    sss: Vec3;
+    sst: Vec3;
+    sts: Vec3;
+    stt: Vec3;
+    tss: Vec3;
+    tst: Vec3;
+    tts: Vec3;
+    ttt: Vec3;
+    ssss: Vec4;
+    ssst: Vec4;
+    ssts: Vec4;
+    sstt: Vec4;
+    stss: Vec4;
+    stst: Vec4;
+    stts: Vec4;
+    sttt: Vec4;
+    tsss: Vec4;
+    tsst: Vec4;
+    tsts: Vec4;
+    tstt: Vec4;
+    ttss: Vec4;
+    ttst: Vec4;
+    ttts: Vec4;
+    tttt: Vec4;
+};
+declare const Switch: (x: NodeProxy) => {
     Case: (...values: X[]) => (fun: () => void) => /*elided*/ any;
     Default: (fun: () => void) => void;
 };
-declare const Fn: (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
-    (...args: X[]): NodeProxy;
-    setLayout(newLayout: FnLayout): /*elided*/ any;
+declare const Fn: <ReturnType extends Constants, Args extends Constants[]>(fun: (paramVars: NodeProxy[]) => NodeProxy<ReturnType> | void, defaultId?: string) => {
+    (...args: X<Args[number]>[]): NodeProxy<ReturnType>;
+    setLayout(_layout: FnLayout): /*elided*/ any;
 };
 
 declare const isSwizzle: (key: unknown) => key is Swizzles;
 declare const isOperator: (key: unknown) => key is Operators;
 declare const isFunction: (key: unknown) => key is Functions;
 declare const isConversion: (key: unknown) => key is Conversions;
-declare const isNodeProxy: (x: unknown) => x is NodeProxy;
-declare const isConstantsType: (type?: Constants | "auto") => type is Constants;
+declare const isNodeProxy: <T extends Constants>(x: unknown) => x is NodeProxy<T>;
+declare const isConstants: (type?: unknown) => type is Constants;
 declare const hex2rgb: (hex: number) => number[];
 declare const getId: () => string;
-declare const joins: (children: X[], c: NodeContext) => string;
-declare const formatConversions: (x: X, c?: NodeContext) => string;
-declare const getOperator: (op: X) => "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "&" | "|" | "^" | "<<" | ">>";
+declare const formatConversions: <T extends Constants>(x: X<T>, c?: NodeContext) => string;
+declare const getOperator: (op: X<string>) => "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "&" | "|" | "^" | "<<" | ">>";
 declare const getBluiltin: (id: string) => "gl_FragCoord" | "gl_VertexID" | "gl_InstanceID" | "gl_FrontFacing" | "gl_FragDepth" | "gl_SampleID" | "gl_SampleMask" | "gl_PointCoord" | "gl_FragCoord.xy";
 declare const conversionToConstant: (conversionKey: string) => Constants;
+declare const getEventFun: (c: NodeContext, id: string, isAttribute?: boolean, isTexture?: boolean) => (value: any) => GL | undefined;
+declare const safeEventCall: <T extends Constants>(x: X<T>, fun: (value: unknown) => void) => void;
+declare const initNodeContext: (c: NodeContext) => NodeContext;
+declare const addDependency: (c: NodeContext, id: string | undefined, type: string) => void;
+declare const sortHeadersByDependencies: (headers: Map<string, string>, dependencies: Map<string, Set<string>>) => [string, string][];
 
 declare const vertex: (x: X, c: NodeContext) => string;
 declare const fragment: (x: X, c: NodeContext) => string;
-declare const position: NodeProxy;
-declare const vertexIndex: NodeProxy;
-declare const instanceIndex: NodeProxy;
-declare const frontFacing: NodeProxy;
-declare const fragDepth: NodeProxy;
-declare const sampleIndex: NodeProxy;
-declare const sampleMask: NodeProxy;
-declare const pointCoord: NodeProxy;
-declare const normalLocal: NodeProxy;
-declare const normalWorld: NodeProxy;
-declare const normalView: NodeProxy;
-declare const positionLocal: NodeProxy;
-declare const positionWorld: NodeProxy;
-declare const positionView: NodeProxy;
-declare const screenCoordinate: NodeProxy;
-declare const screenUV: NodeProxy;
-declare const float: (x: X) => NodeProxy;
-declare const int: (x: X) => NodeProxy;
-declare const uint: (x: X) => NodeProxy;
-declare const bool: (x: X) => NodeProxy;
-declare const vec2: (x?: X, y?: X) => NodeProxy;
-declare const vec3: (x?: X, y?: X, z?: X) => NodeProxy;
-declare const vec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
-declare const mat2: (...args: X[]) => NodeProxy;
-declare const mat3: (...args: X[]) => NodeProxy;
-declare const mat4: (...args: X[]) => NodeProxy;
-declare const ivec2: (x?: X, y?: X) => NodeProxy;
-declare const ivec3: (x?: X, y?: X, z?: X) => NodeProxy;
-declare const ivec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
-declare const uvec2: (x?: X, y?: X) => NodeProxy;
-declare const uvec3: (x?: X, y?: X, z?: X) => NodeProxy;
-declare const uvec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
-declare const bvec2: (x?: X, y?: X) => NodeProxy;
-declare const bvec3: (x?: X, y?: X, z?: X) => NodeProxy;
-declare const bvec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
-declare const texture2D: () => NodeProxy;
-declare const sampler2D: () => NodeProxy;
-declare const color: (r?: X, g?: X, b?: X) => NodeProxy;
-declare const iResolution: NodeProxy;
-declare const iMouse: NodeProxy;
-declare const iTime: NodeProxy;
-declare const uv: () => NodeProxy;
-declare const texture: (x: X, y: X, z?: X) => NodeProxy;
-declare const cubeTexture: (x: X, y: X, z?: X) => NodeProxy;
-declare const textureSize: (x: X, y?: X) => NodeProxy;
-declare const abs: (x: X) => NodeProxy;
-declare const acos: (x: X) => NodeProxy;
-declare const all: (x: X) => NodeProxy;
-declare const any: (x: X) => NodeProxy;
-declare const asin: (x: X) => NodeProxy;
-declare const atan: (y: X, x?: X) => NodeProxy;
-declare const atan2: (y: X, x: X) => NodeProxy;
-declare const bitcast: (x: X, y: X) => NodeProxy;
-declare const cbrt: (x: X) => NodeProxy;
-declare const ceil: (x: X) => NodeProxy;
-declare const clamp: (x: X, min: X, max: X) => NodeProxy;
-declare const cos: (x: X) => NodeProxy;
-declare const cross: (x: X, y: X) => NodeProxy;
-declare const dFdx: (p: X) => NodeProxy;
-declare const dFdy: (p: X) => NodeProxy;
-declare const degrees: (radians: X) => NodeProxy;
-declare const difference: (x: X, y: X) => NodeProxy;
-declare const distance: (x: X, y: X) => NodeProxy;
-declare const dot: (x: X, y: X) => NodeProxy;
-declare const equals: (x: X, y: X) => NodeProxy;
-declare const exp: (x: X) => NodeProxy;
-declare const exp2: (x: X) => NodeProxy;
-declare const faceforward: (N: X, I: X, Nref: X) => NodeProxy;
-declare const floor: (x: X) => NodeProxy;
-declare const fract: (x: X) => NodeProxy;
-declare const fwidth: (x: X) => NodeProxy;
-declare const inverseSqrt: (x: X) => NodeProxy;
-declare const length: (x: X) => NodeProxy;
-declare const lengthSq: (x: X) => NodeProxy;
-declare const log: (x: X) => NodeProxy;
-declare const log2: (x: X) => NodeProxy;
-declare const max: (x: X, y: X) => NodeProxy;
-declare const min: (x: X, y: X) => NodeProxy;
-declare const mix: (x: X, y: X, a: X) => NodeProxy;
-declare const negate: (x: X) => NodeProxy;
-declare const normalize: (x: X) => NodeProxy;
-declare const oneMinus: (x: X) => NodeProxy;
-declare const pow: (x: X, y: X) => NodeProxy;
-declare const pow2: (x: X) => NodeProxy;
-declare const pow3: (x: X) => NodeProxy;
-declare const pow4: (x: X) => NodeProxy;
-declare const radians: (degrees: X) => NodeProxy;
-declare const reciprocal: (x: X) => NodeProxy;
-declare const reflect: (I: X, N: X) => NodeProxy;
-declare const refract: (I: X, N: X, eta: X) => NodeProxy;
-declare const round: (x: X) => NodeProxy;
-declare const saturate: (x: X) => NodeProxy;
-declare const sign: (x: X) => NodeProxy;
-declare const sin: (x: X) => NodeProxy;
-declare const smoothstep: (e0: X, e1: X, x: X) => NodeProxy;
-declare const sqrt: (x: X) => NodeProxy;
-declare const step: (edge: X, x: X) => NodeProxy;
-declare const tan: (x: X) => NodeProxy;
-declare const transformDirection: (dir: X, matrix: X) => NodeProxy;
-declare const trunc: (x: X) => NodeProxy;
+declare const position: Vec4;
+declare const vertexIndex: UInt;
+declare const instanceIndex: UInt;
+declare const frontFacing: Bool;
+declare const fragDepth: Float;
+declare const sampleIndex: UInt;
+declare const sampleMask: UInt;
+declare const pointCoord: Vec2;
+declare const positionLocal: Vec3;
+declare const positionWorld: Vec3;
+declare const positionView: Vec3;
+declare const normalLocal: Vec3;
+declare const normalWorld: Vec3;
+declare const normalView: Vec3;
+declare const screenCoordinate: Vec2;
+declare const screenUV: Vec2;
+declare const float: (x?: X) => Float;
+declare const int: (x?: X) => Int;
+declare const uint: (x?: X) => UInt;
+declare const bool: (x?: X) => Bool;
+declare const vec2: (x?: X, y?: X) => Vec2;
+declare const vec3: (x?: X, y?: X, z?: X) => Vec3;
+declare const vec4: (x?: X, y?: X, z?: X, w?: X) => Vec4;
+declare const mat2: (...args: X[]) => Mat2;
+declare const mat3: (...args: X[]) => Mat3;
+declare const mat4: (...args: X[]) => Mat4;
+declare const ivec2: (x?: X, y?: X) => IVec2;
+declare const ivec3: (x?: X, y?: X, z?: X) => IVec3;
+declare const ivec4: (x?: X, y?: X, z?: X, w?: X) => IVec4;
+declare const uvec2: (x?: X, y?: X) => UVec2;
+declare const uvec3: (x?: X, y?: X, z?: X) => UVec3;
+declare const uvec4: (x?: X, y?: X, z?: X, w?: X) => UVec4;
+declare const bvec2: (x?: X, y?: X) => BVec2;
+declare const bvec3: (x?: X, y?: X, z?: X) => BVec3;
+declare const bvec4: (x?: X, y?: X, z?: X, w?: X) => BVec4;
+declare const texture2D: (x?: X) => Texture;
+declare const sampler2D: () => Sampler2D;
+declare const color: (r?: X, g?: X, b?: X) => Vec3;
+declare const iResolution: Vec2;
+declare const iMouse: Vec2;
+declare const iTime: Float;
+declare const uv: Vec2;
+declare const texture: (x: X, y: X, z?: X) => Vec4;
+declare const cubeTexture: (x: X, y: X, z?: X) => Vec4;
+declare const textureSize: (x: X, y?: X) => Vec4;
+declare const length: (x: X) => Float;
+declare const lengthSq: (x: X) => Float;
+declare const distance: (x: X, y: X) => Float;
+declare const dot: (x: X, y: X) => Float;
+declare const all: <T extends Constants>(x: X<T>) => Bool;
+declare const any: <T extends Constants>(x: X<T>) => Bool;
+declare const cross: (x: X<"vec3">, y: X<"vec3">) => Vec3;
+declare const abs: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const sign: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const floor: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const ceil: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const round: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const fract: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const trunc: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const sin: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const cos: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const tan: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const asin: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const acos: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const atan: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const sinh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const cosh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const tanh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const asinh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const acosh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const atanh: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const exp: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const exp2: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const log: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const log2: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const sqrt: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const inverseSqrt: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const normalize: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const oneMinus: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const saturate: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const negate: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const reciprocal: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const dFdx: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const dFdy: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const fwidth: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const degrees: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const radians: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const reflect: <T extends Constants>(I: X<T>, N: X) => NodeProxy<T>;
+declare const refract: <T extends Constants>(I: X<T>, N: X, eta: X) => NodeProxy<T>;
+declare const min: <T extends Constants>(x: X<T>, y: X) => NodeProxy<T>;
+declare const max: <T extends Constants>(x: X<T>, y: X) => NodeProxy<T>;
+declare const mix: <T extends Constants>(x: X<T>, y: X, a: X) => NodeProxy<T>;
+declare const clamp: <T extends Constants>(x: X<T>, minVal: X, maxVal: X) => NodeProxy<T>;
+declare const step: <T extends Constants>(edge: X, x: X<T>) => NodeProxy<T>;
+declare const smoothstep: <T extends Constants>(e0: X, e1: X, x: X<T>) => NodeProxy<T>;
+declare const atan2: <T extends Constants>(y: X<T>, x: X) => NodeProxy<T>;
+declare const pow: <T extends Constants>(x: X<T>, y: X) => NodeProxy<T>;
+declare const pow2: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const pow3: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const pow4: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const bitcast: <T extends Constants>(x: X<T>, y: X) => NodeProxy<T>;
+declare const cbrt: <T extends Constants>(x: X<T>) => NodeProxy<T>;
+declare const difference: <T extends Constants>(x: X<T>, y: X) => NodeProxy<T>;
+declare const equals: (x: X, y: X) => Bool;
+declare const faceforward: <T extends Constants>(N: X<T>, I: X, Nref: X) => NodeProxy<T>;
+declare const transformDirection: <T extends Constants>(dir: X<T>, matrix: X) => NodeProxy<T>;
 
 type PrecisionMode = 'highp' | 'mediump' | 'lowp';
 type GLClearMode = 'COLOR_BUFFER_BIT' | 'DEPTH_BUFFER_BIT' | 'STENCIL_BUFFER_BIT';
@@ -330,6 +1926,7 @@ interface TextureData {
     group: number;
     texture: GPUTexture;
     sampler: GPUSampler;
+    view: GPUTextureView;
 }
 interface AttribData {
     array: Float32Array;
@@ -365,12 +1962,12 @@ type GL = EventState<{
     mouse: [number, number];
     count: number;
     el: HTMLCanvasElement;
-    vs: string | NodeProxy;
-    fs: string | NodeProxy;
-    vert: string | NodeProxy;
-    frag: string | NodeProxy;
-    vertex: string | NodeProxy;
-    fragment: string | NodeProxy;
+    vs: string | Vec4;
+    fs: string | Vec4;
+    vert: string | Vec4;
+    frag: string | Vec4;
+    vertex: string | Vec4;
+    fragment: string | Vec4;
     /**
      * core state
      */
@@ -462,7 +2059,15 @@ declare const createBindings: () => {
         location: number;
     };
 };
-declare const createPipeline: (device: GPUDevice, format: GPUTextureFormat, bufferLayouts: GPUVertexBufferLayout[], bindGroupLayouts: GPUBindGroupLayout[], webgpu: WebGPUState, vs: string | X, fs: string | X) => GPURenderPipeline;
+declare const createVertexBuffers: (attribs: Iterable<AttribData>) => {
+    vertexBuffers: GPUBuffer[];
+    bufferLayouts: GPUVertexBufferLayout[];
+};
+declare const createBindGroup: (device: GPUDevice, uniforms: Iterable<UniformData>, textures: Iterable<TextureData>) => {
+    bindGroups: GPUBindGroup[];
+    bindGroupLayouts: GPUBindGroupLayout[];
+};
+declare const createPipeline: (device: GPUDevice, format: GPUTextureFormat, bufferLayouts: GPUVertexBufferLayout[], bindGroupLayouts: GPUBindGroupLayout[], vs: string, fs: string) => GPURenderPipeline;
 /**
  * buffers
  */
@@ -474,25 +2079,17 @@ declare const createAttribBuffer: (device: GPUDevice, value: number[]) => {
     array: Float32Array<ArrayBuffer>;
     buffer: GPUBuffer;
 };
+declare const createDescriptor: (c: GPUCanvasContext, depthTexture: GPUTexture) => GPURenderPassDescriptor;
 /**
- * uniforms
+ * textures
  */
-declare const createBindGroup: (device: GPUDevice, uniforms: Map<string, UniformData>, textures: Map<string, TextureData>) => {
-    bindGroups: GPUBindGroup[];
-    bindGroupLayouts: GPUBindGroupLayout[];
-};
-declare const createDescriptor: (c: GPUCanvasContext, depthTexture: GPUTexture) => GPURenderPassDescriptor;
 declare const createTextureSampler: (device: GPUDevice, width?: number, height?: number) => {
     texture: GPUTexture;
     sampler: GPUSampler;
 };
 declare const createDepthTexture: (device: GPUDevice, width: number, height: number) => GPUTexture;
-declare const createVertexBuffers: (attribs: Map<string, AttribData>) => {
-    vertexBuffers: GPUBuffer[];
-    bufferLayouts: GPUVertexBufferLayout[];
-};
 
-declare const createProgram: (c: WebGLRenderingContext, vs: X, fs: string | X, onError?: () => void, gl?: any) => void | WebGLProgram;
+declare const createProgram: (c: WebGLRenderingContext, vert: string, frag: string, onError?: () => void) => void | WebGLProgram;
 declare const createVbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
 declare const createIbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
 declare const getStride: (count: number, value: number[], iboValue?: number[]) => number;
@@ -532,12 +2129,12 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     mouse: [number, number];
     count: number;
     el: HTMLCanvasElement;
-    vs: string | NodeProxy;
-    fs: string | NodeProxy;
-    vert: string | NodeProxy;
-    frag: string | NodeProxy;
-    vertex: string | NodeProxy;
-    fragment: string | NodeProxy;
+    vs: string | Vec4;
+    fs: string | Vec4;
+    vert: string | Vec4;
+    frag: string | Vec4;
+    vertex: string | Vec4;
+    fragment: string | Vec4;
     webgpu: WebGPUState;
     webgl: WebGLState;
     queue: refr.Queue;
@@ -568,4 +2165,4 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     }): GL;
 }, any[] | unknown[]>;
 
-export { AttribData, Attribute, Attributes, BaseNodeProxy, Constants, Conversions, DynamicProperties, Fn, FnLayout, Functions, GL, GLClearMode, GLDrawMode, GLDrawType, If, Loop, NodeContext, NodeProps, NodeProxy, NodeTypes, Operators, PrecisionMode, Return, Switch, Swizzles, TextureData, Uniform, UniformData, Uniforms, WebGLState, WebGPUState, X, abs, acos, all, any, asin, assign, atan, atan2, attribute, bitcast, bool, builtin, bvec2, bvec3, bvec4, cbrt, ceil, clamp, code, color, constant, conversion, conversionToConstant, cos, createAttrib, createAttribBuffer, createBindGroup, createBindings, createDepthTexture, createDescriptor, createDevice, createGL, createIbo, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createVertexBuffers, cross, cubeTexture, dFdx, dFdy, createGL as default, degrees, difference, dig, distance, dot, each, equals, exp, exp2, ext, faceforward, fig, float, floor, flush, formatConversions, fract, fragDepth, fragment, frontFacing, function_, fwidth, getBluiltin, getId, getOperator, getStride, hex2rgb, iMouse, iResolution, iTime, instanceIndex, int, inverseSqrt, is, isConstantsType, isConversion, isFunction, isGL, isNodeProxy, isOperator, isServer, isSwizzle, isWebGPUSupported, ivec2, ivec3, ivec4, joins, length, lengthSq, log, log2, mat2, mat3, mat4, max, min, mix, negate, node, normalLocal, normalView, normalWorld, normalize, oneMinus, operator, pointCoord, position, positionLocal, positionView, positionWorld, pow, pow2, pow3, pow4, radians, reciprocal, reflect, refract, replace, round, sampleIndex, sampleMask, sampler2D, saturate, screenCoordinate, screenUV, select, sig, sign, sin, smoothstep, sqrt, step, swizzle, tan, texture, texture2D, textureSize, toVar, transformDirection, trunc, uint, uniform, uv, uvec2, uvec3, uvec4, variable, vec2, vec3, vec4, vertex, vertexIndex, vertexStage, webgl, webgpu };
+export { AttribData, Attribute, Attributes, BVec2, BVec3, BVec4, BaseNodeProxy, Bool, Color, Constants, ConstantsToType, Conversions, Float, Fn, FnLayout, Functions, GL, GLClearMode, GLDrawMode, GLDrawType, IVec2, IVec3, IVec4, If, Int, Loop, Mat2, Mat3, Mat4, NodeContext, NodeProps, NodeProxy, NodeTypes, Operators, PrecisionMode, Return, Sampler2D, Struct, Switch, Swizzles, Texture, TextureData, UInt, UVec2, UVec3, UVec4, Uniform, UniformData, Uniforms, Vec2, Vec3, Vec4, WebGLState, WebGPUState, X, abs, acos, acosh, addDependency, all, any, asin, asinh, assign, atan, atan2, atanh, attribute, bitcast, bool, builtin, bvec2, bvec3, bvec4, cbrt, ceil, clamp, code, color, constant, conversion, conversionToConstant, cos, cosh, createAttrib, createAttribBuffer, createBindGroup, createBindings, createDepthTexture, createDescriptor, createDevice, createGL, createIbo, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createVertexBuffers, cross, cubeTexture, dFdx, dFdy, createGL as default, degrees, difference, dig, distance, dot, each, equals, exp, exp2, ext, faceforward, fig, float, floor, flush, formatConversions, fract, fragDepth, fragment, frontFacing, function_, fwidth, getBluiltin, getEventFun, getId, getOperator, getStride, hex2rgb, iMouse, iResolution, iTime, initNodeContext, instanceIndex, int, inverseSqrt, is, isConstants, isConversion, isFunction, isGL, isNodeProxy, isOperator, isServer, isSwizzle, isWebGPUSupported, ivec2, ivec3, ivec4, length, lengthSq, log, log2, mat2, mat3, mat4, max, member, min, mix, negate, node, normalLocal, normalView, normalWorld, normalize, oneMinus, operator, pointCoord, position, positionLocal, positionView, positionWorld, pow, pow2, pow3, pow4, radians, reciprocal, reflect, refract, replace, round, safeEventCall, sampleIndex, sampleMask, sampler2D, saturate, screenCoordinate, screenUV, select, sig, sign, sin, sinh, smoothstep, sortHeadersByDependencies, sqrt, step, struct, tan, tanh, texture, texture2D, textureSize, toVar, transformDirection, trunc, uint, uniform, uv, uvec2, uvec3, uvec4, variable, vec2, vec3, vec4, vertex, vertexIndex, vertexStage, webgl, webgpu };