glre 0.38.0 → 0.40.0

package/dist/node.d.ts

@@ -0,0 +1,626 @@
+import { EventState, Nested } from 'reev';
+import { Queue, Frame } from 'refr';
+
+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 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 OPERATORS: {
+    readonly not: "";
+    readonly add: "+";
+    readonly sub: "-";
+    readonly mul: "*";
+    readonly div: "/";
+    readonly mod: "%";
+    readonly equal: "==";
+    readonly notEqual: "!=";
+    readonly lessThan: "<";
+    readonly lessThanEqual: "<=";
+    readonly greaterThan: ">";
+    readonly greaterThanEqual: ">=";
+    readonly and: "&&";
+    readonly or: "||";
+    readonly bitAnd: "&";
+    readonly bitOr: "|";
+    readonly bitXor: "^";
+    readonly shiftLeft: "<<";
+    readonly shiftRight: ">>";
+    readonly addAssign: "+=";
+    readonly subAssign: "-=";
+    readonly mulAssign: "*=";
+    readonly divAssign: "/=";
+    readonly modAssign: "%=";
+    readonly bitAndAssign: "&=";
+    readonly bitOrAssign: "|=";
+    readonly bitXorAssign: "^=";
+    readonly shiftLeftAssign: "<<=";
+    readonly shiftRightAssign: ">>=";
+};
+declare const OPERATOR_KEYS: (keyof typeof OPERATORS)[];
+declare const OPERATOR_TYPE_RULES: readonly [readonly ["float", "vec2", "vec2"], readonly ["float", "vec3", "vec3"], readonly ["float", "vec4", "vec4"], readonly ["int", "ivec2", "ivec2"], readonly ["int", "ivec3", "ivec3"], readonly ["int", "ivec4", "ivec4"], readonly ["uint", "uvec2", "uvec2"], readonly ["uint", "uvec3", "uvec3"], readonly ["uint", "uvec4", "uvec4"], readonly ["mat2", "vec2", "vec2"], readonly ["mat3", "vec3", "vec3"], readonly ["mat4", "vec4", "vec4"], readonly ["vec2", "mat2", "vec2"], readonly ["vec3", "mat3", "vec3"], readonly ["vec4", "mat4", "vec4"]];
+/**
+ * 2.2. unified with:
+ * 1.2. index.ts functions and
+ * 3.2. types.ts _N
+ */
+declare const FUNCTIONS: readonly [...("texture" | "all" | "any" | "determinant" | "distance" | "dot" | "length" | "lengthSq" | "luminance" | "cross" | "cubeTexture" | "texelFetch" | "textureLod")[], "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "ceil", "cos", "cosh", "dFdx", "dFdy", "degrees", "exp", "exp2", "floor", "fract", "fwidth", "inverse", "inverseSqrt", "log", "log2", "negate", "normalize", "oneMinus", "radians", "reciprocal", "round", "sign", "sin", "sinh", "sqrt", "tan", "tanh", "trunc", "saturate", "atan2", "clamp", "max", "min", "mix", "pow", "reflect", "refract", "smoothstep", "step"];
+
+type GL = EventState<{
+    /**
+     * initial value
+     */
+    isNative: boolean;
+    isWebGL: boolean;
+    isError: boolean;
+    isLoop: boolean;
+    isDebug: boolean;
+    isDepth: boolean;
+    isGL: true;
+    width?: number;
+    height?: number;
+    size: [number, number];
+    mouse: [number, number];
+    count: number;
+    instanceCount: number;
+    particleCount: number | [number, number] | [number, number, number];
+    loading: number;
+    el: HTMLCanvasElement;
+    vs?: string | Vec4;
+    cs?: string | Void;
+    fs?: string | Vec4;
+    vert?: string | Vec4;
+    comp?: string | Void;
+    frag?: string | Vec4;
+    vertex?: string | Vec4;
+    compute?: string | Void;
+    fragment?: string | Vec4;
+    /**
+     * core state
+     */
+    webgpu: WebGPUState;
+    webgl: WebGLState;
+    queue: Queue;
+    frame: Frame;
+    /**
+     * events
+     */
+    ref?: any;
+    mount(): void;
+    clean(): void;
+    error(e?: string): void;
+    render(): void;
+    resize(e?: Event): void;
+    mousemove(e: MouseEvent): void;
+    loop(): void;
+    /**
+     * setter
+     */
+    _uniform?(key: string, value: Uniform, isMatrix?: boolean): GL;
+    uniform(key: string, value: Uniform, isMatrix?: boolean): GL;
+    uniform(target: {
+        [key: string]: Uniform;
+    }): GL;
+    _texture?(key: string, value: string): GL;
+    texture(key: string, value: string): GL;
+    texture(target: {
+        [key: string]: string;
+    }): GL;
+    _attribute?(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(target: {
+        [key: string]: Attribute;
+    }): GL;
+    _instance?(key: string, value: Attribute, at?: number): GL;
+    instance(key: string, value: Attribute, at?: number): GL;
+    instance(target: {
+        [key: string]: Attribute;
+    }): GL;
+    _storage?(key: string, value: Storage): GL;
+    storage(key: string, value: Storage): GL;
+    storage(target: {
+        [key: string]: Storage;
+    }): GL;
+}>;
+type Uniform = number | number[] | Float32Array;
+type Attribute = number[] | Float32Array;
+type Storage = number[] | Float32Array;
+/**
+ * for webgpu
+ */
+interface UniformData {
+    array: Float32Array;
+    buffer: GPUBuffer;
+    binding: number;
+    group: number;
+}
+interface TextureData {
+    binding: number;
+    group: number;
+    texture: GPUTexture;
+    sampler: GPUSampler;
+    view: GPUTextureView;
+}
+interface AttribData {
+    array: Float32Array;
+    buffer: GPUBuffer;
+    location: number;
+    stride: number;
+    isInstance?: boolean;
+}
+interface StorageData {
+    array: Float32Array;
+    buffer: GPUBuffer;
+    binding: number;
+    group: number;
+}
+interface WebGPUState {
+    device: GPUDevice;
+    uniforms: Nested<UniformData>;
+    textures: Nested<TextureData>;
+    attribs: Nested<AttribData>;
+    storages: Nested<StorageData>;
+}
+/**
+ * for webgl
+ */
+interface WebGLState {
+    context: WebGLRenderingContext;
+    program: WebGLProgram;
+    storages: any;
+}
+
+type Constants = (typeof CONSTANTS)[number] | 'void';
+type Conversions = (typeof CONVERSIONS)[number];
+type Functions = (typeof FUNCTIONS)[number];
+type Operators = (typeof OPERATOR_KEYS)[number];
+/**
+ * scope
+ */
+interface FnLayout {
+    name: string;
+    type: C | 'auto';
+    inputs?: Array<{
+        name: string;
+        type: C | 'auto';
+    }>;
+}
+interface FnType<T extends X | Struct | void, Args extends any[]> {
+    (...args: Args): T extends void ? Void : T;
+    getLayout(): FnLayout;
+    setLayout(layout: FnLayout): FnType<T, Args>;
+}
+type StructFields = Record<string, X>;
+interface StructFactory<T extends StructFields> {
+    (initialValues?: StructFields, instanceId?: string): Struct<T>;
+}
+/**
+ * node
+ */
+type NodeTypes = 'attribute' | 'instance' | 'storage' | 'uniform' | 'constant' | 'variable' | 'varying' | 'ternary' | 'builtin' | 'conversion' | 'operator' | 'function' | 'struct' | 'member' | 'element' | 'gather' | 'scatter' | 'scope' | 'assign' | 'loop' | 'define' | 'if' | 'switch' | 'declare' | 'return' | 'break' | 'continue';
+interface NodeProps {
+    id?: string;
+    args?: any[];
+    type?: string;
+    children?: any[];
+    inferFrom?: any[];
+    layout?: FnLayout;
+    fields?: StructFields;
+    initialValues?: StructFields;
+}
+interface NodeContext {
+    gl?: Partial<GL>;
+    label?: 'vert' | 'frag' | 'compute';
+    isWebGL?: boolean;
+    units?: any;
+    infers?: WeakMap<X, C>;
+    onMount?: (name: string) => void;
+    code?: {
+        headers: Map<string, string>;
+        fragInputs: Map<string, string>;
+        vertInputs: Map<string, string>;
+        vertOutputs: Map<string, string>;
+        vertVaryings: Map<string, string>;
+        computeInputs: Map<string, string>;
+        dependencies: Map<string, Set<string>>;
+        structStructFields: Map<string, StructFields>;
+    };
+}
+/**
+ * infer
+ */
+type _StringLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
+type InferOperator<L extends C, R extends C> = 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 InferArrayElement<T extends C> = T extends 'mat4' ? 'vec4' : T extends 'mat3' ? 'vec3' : T extends 'mat2' ? 'vec2' : 'float';
+type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] | [R, L] : never;
+type OperatorTypeRules = ExtractPairs<(typeof OPERATOR_TYPE_RULES)[number]>;
+type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0;
+type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>;
+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 Void = XImpl<'void'>;
+type Bool = XImpl<'bool'>;
+type UInt = XImpl<'uint'>;
+type Int = XImpl<'int'>;
+type Float = XImpl<'float'>;
+type BVec2 = XImpl<'bvec2'>;
+type IVec2 = XImpl<'ivec2'>;
+type UVec2 = XImpl<'uvec2'>;
+type Vec2 = XImpl<'vec2'>;
+type BVec3 = XImpl<'bvec3'>;
+type IVec3 = XImpl<'ivec3'>;
+type UVec3 = XImpl<'uvec3'>;
+type Vec3 = XImpl<'vec3'>;
+type BVec4 = XImpl<'bvec4'>;
+type IVec4 = XImpl<'ivec4'>;
+type UVec4 = XImpl<'uvec4'>;
+type Vec4 = XImpl<'vec4'>;
+type Color = XImpl<'color'>;
+type Mat2 = XImpl<'mat2'>;
+type Mat3 = XImpl<'mat3'>;
+type Mat4 = XImpl<'mat4'>;
+type Texture = XImpl<'texture'>;
+type Sampler2D = XImpl<'sampler2D'>;
+type StructBase = XImpl<'struct'>;
+type Struct<T extends StructFields = any> = Omit<StructBase, keyof T> & {
+    [K in keyof T]: T[K] extends X<infer U> ? X<U> : never;
+} & {
+    toVar(id?: string): Struct<T>;
+};
+interface ConstantsToType {
+    void: Void;
+    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: StructBase;
+}
+/**
+ * X and Y
+ */
+type XImpl<T extends C> = _X<T> & {
+    [K in string as K extends Methods ? never : K]: any;
+} & {
+    [K in Swizzles]: X<InferSwizzleType<K>>;
+};
+type C = Constants;
+type X<T extends C = C> = T extends keyof ConstantsToType ? ConstantsToType[T] : _X<T>;
+type Y<T extends C = C> = number | number[] | string | boolean | undefined | X<T>;
+type Methods = Functions | Operators | Conversions | Swizzles | '__nodeType' | 'type' | 'props' | 'isProxy' | 'assign' | 'toVar' | 'toString' | 'element' | 'select';
+interface _X<T extends C> {
+    readonly __nodeType?: T;
+    assign(x: any): X<T>;
+    select(x: number | X<T>, y: X<'bool'>): X<T>;
+    fragment(c: NodeContext): string;
+    toVar(name?: string): X<T>;
+    toString(c?: NodeContext): string;
+    fragment(c?: NodeContext): string;
+    compute(c?: NodeContext): string;
+    vertex(c?: NodeContext): string;
+    type: NodeTypes;
+    props: NodeProps;
+    isProxy: true;
+    listeners: Set<(value: any) => void>;
+    element<Index extends X>(index: Index): X<InferArrayElement<T>>;
+    member<K extends string>(key: K): K extends keyof T ? (T[K] extends X<infer U> ? X<U> : never) : never;
+    add<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>;
+    sub<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>;
+    mul<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>;
+    div<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>;
+    mod<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>;
+    equal<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    notEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    lessThan<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    lessThanEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    greaterThan<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    greaterThanEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool;
+    and(x: Bool): Bool;
+    or(x: Bool): Bool;
+    not(): Bool;
+    bitAnd(x: X<T>): X<T>;
+    bitOr(x: X<T>): X<T>;
+    bitXor(x: X<T>): X<T>;
+    bitNot(): X<T>;
+    shiftLeft<U extends C>(x: X<U>): X<InferOperator<T, U>>;
+    shiftRight<U extends C>(x: X<U>): X<InferOperator<T, U>>;
+    addAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    subAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    mulAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    divAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    modAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    bitAndAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    bitOrAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    bitXorAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    shiftLeftAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    shiftRightAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>;
+    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;
+    /**
+     * 3.1. unified logic with:
+     * 1.1. index.ts functions and
+     * 2.1. const.ts FUNCTION_RETURN_TYPES
+     */
+    all(): Bool;
+    any(): Bool;
+    determinant(): T extends 'mat2' | 'mat3' | 'mat4' ? Float : never;
+    distance<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): Float;
+    dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? U extends T ? number | X<U> : never : never): T extends `ivec${string}` ? Int : Float;
+    length(): T extends 'vec2' | 'vec3' | 'vec4' ? Float : never;
+    lengthSq(): Float;
+    luminance(): Float;
+    cross<U extends C = 'vec3'>(y: T extends 'vec3' ? (U extends 'vec3' ? number | X<U> : never) : never): Vec3;
+    cubeTexture(...args: X[]): Vec4;
+    texture(...args: X[]): Vec4;
+    texelFetch(...args: X[]): Vec4;
+    textureLod(...args: X[]): Vec4;
+    /**
+     * 3.2. unified with:
+     * 1.2. index.ts functions and
+     * 2.2. const.ts FUNCTIONS
+     */
+    abs(): X<T>;
+    acos(): X<T>;
+    acosh(): X<T>;
+    asin(): X<T>;
+    asinh(): X<T>;
+    atan(): X<T>;
+    atanh(): X<T>;
+    ceil(): X<T>;
+    cos(): X<T>;
+    cosh(): X<T>;
+    degrees(): X<T>;
+    dFdx(): X<T>;
+    dFdy(): X<T>;
+    exp(): X<T>;
+    exp2(): X<T>;
+    floor(): X<T>;
+    fract(): X<T>;
+    fwidth(): X<T>;
+    inverseSqrt(): X<T>;
+    log(): X<T>;
+    log2(): X<T>;
+    negate(): X<T>;
+    normalize(): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never;
+    oneMinus(): X<T>;
+    radians(): X<T>;
+    reciprocal(): X<T>;
+    round(): X<T>;
+    saturate(): X<T>;
+    sign(): X<T>;
+    sin(): X<T>;
+    sinh(): X<T>;
+    sqrt(): X<T>;
+    tan(): X<T>;
+    tanh(): X<T>;
+    trunc(): X<T>;
+    atan2<U extends C>(x: number | X<U>): X<T>;
+    clamp<U extends C>(min: number | X<U>, max: number | X<U>): X<InferOperator<T, U>>;
+    max<U extends C>(y: number | X<U>): X<InferOperator<T, U>>;
+    min<U extends C>(y: number | X<U>): X<InferOperator<T, U>>;
+    mix<U extends C>(y: number | X<U>, a: number | Float | X<U>): X<InferOperator<T, U>>;
+    pow<U extends C>(y: number | X<U>): X<T>;
+    reflect<U extends C>(N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): X<T>;
+    refract<U extends C>(N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never, eta: number | Float): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never;
+    smoothstep<U extends C>(edge0: number | X<U>, edge1: number | X<U>): X<InferOperator<T, U>>;
+    step<U extends C>(edge: number | X<U>): X<InferOperator<T, U>>;
+}
+
+declare const fragment: (x: X, c?: NodeContext) => string;
+declare const vertex: (x: X, c?: NodeContext) => string;
+declare const compute: (x: X, c?: NodeContext) => string;
+
+declare const create: <T extends Constants>(type: NodeTypes, props?: NodeProps | null, ...args: Y[]) => X<T>;
+declare const attribute: <T extends Constants>(x: Y<T>, id?: string) => X<T>;
+declare const instance: <T extends Constants>(x: Y<T>, id?: string) => X<T>;
+declare const constant: <T extends Constants>(x: Y<T>, id?: string) => X<T>;
+declare const uniform: <T extends Constants>(x: Y<T>, id?: string) => X<T>;
+declare const storage: <T extends Constants>(x: Y<T>, id?: string) => X<T>;
+declare const variable: <T extends Constants>(id?: string) => X<T>;
+declare const builtin: <T extends Constants>(id?: string) => X<T>;
+declare const vertexStage: <T extends Constants>(x: X<T>, id?: string) => X<T>;
+declare const member: <T extends Constants>(x: X, index: Y) => X<T>;
+declare const element: <T extends Constants>(x: X, index: Y) => X<T>;
+declare const gather: <T extends Constants>(x: X, index: Y) => X<T>;
+declare const scatter: <T extends Constants>(x: X, index: Y) => X<T>;
+declare const select: <T extends Constants>(x: Y, y: Y, z: Y) => X<T>;
+declare const operator: <T extends Constants>(key: Operators, ...x: Y[]) => X<T>;
+declare const function_: <T extends Constants>(key: Functions, ...x: Y[]) => X<T>;
+declare const conversion: <T extends Constants>(key: T, ...x: Y[]) => X<T>;
+
+declare const addToScope: <T extends Constants>(x: X<T>) => X<T> | undefined;
+declare function toVar<T extends StructFields>(x: Struct<T>, id?: string): Struct<T>;
+declare const assign: <T extends Constants>(x: X<T>, isScatter: boolean | undefined, y: Y<T>) => X<T>;
+declare const Return: <T extends Constants>(x?: Y<T>) => Y<T>;
+declare const Break: () => Y;
+declare const Continue: () => Y;
+declare const struct: <T extends StructFields>(fields: T, id?: string) => StructFactory<T>;
+declare const scoped: (x: X, fun: () => X | void, y?: X | null) => void;
+declare const Scope: <T extends X>(fun: () => T | void) => T;
+declare const If: (x: Y, fun: () => void) => {
+    ElseIf: (_x: X, _fun: () => void) => /*elided*/ any;
+    Else: (_fun: () => void) => void;
+};
+declare const Loop: (x: Y, fun: (params: {
+    i: Int;
+}) => void) => Bool | Color | StructBase | UInt | Int | Float | BVec2 | IVec2 | UVec2 | Vec2 | BVec3 | IVec3 | UVec3 | Vec3 | BVec4 | IVec4 | UVec4 | Vec4 | Mat2 | Mat3 | Mat4 | Texture | Sampler2D | Void | undefined;
+declare const Switch: (x: Y) => {
+    Case: (...values: X[]) => (fun: () => void) => /*elided*/ any;
+    Default: (fun: () => void) => void;
+};
+declare function Fn<T extends X | Struct | void, Args extends any[]>(fun: (args: Args) => T, layout?: FnLayout): Args extends readonly unknown[] ? FnType<T, Args> : never;
+
+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 id: UVec3;
+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?: Y) => Float;
+declare const int: (x?: Y) => Int;
+declare const uint: (x?: Y) => UInt;
+declare const bool: (x?: Y) => Bool;
+declare const vec2: (x?: Y, y?: Y) => Vec2;
+declare const vec3: (x?: Y, y?: Y, z?: Y) => Vec3;
+declare const vec4: (x?: Y, y?: Y, z?: Y, w?: Y) => Vec4;
+declare const mat2: (...args: Y[]) => Mat2;
+declare const mat3: (...args: Y[]) => Mat3;
+declare const mat4: (...args: Y[]) => Mat4;
+declare const ivec2: (x?: Y, y?: Y) => IVec2;
+declare const ivec3: (x?: Y, y?: Y, z?: Y) => IVec3;
+declare const ivec4: (x?: Y, y?: Y, z?: Y, w?: Y) => IVec4;
+declare const uvec2: (x?: Y, y?: Y) => UVec2;
+declare const uvec3: (x?: Y, y?: Y, z?: Y) => UVec3;
+declare const uvec4: (x?: Y, y?: Y, z?: Y, w?: Y) => UVec4;
+declare const bvec2: (x?: Y, y?: Y) => BVec2;
+declare const bvec3: (x?: Y, y?: Y, z?: Y) => BVec3;
+declare const bvec4: (x?: Y, y?: Y, z?: Y, w?: Y) => BVec4;
+declare const texture2D: (x?: Y) => Texture;
+declare const sampler2D: () => Sampler2D;
+declare const color: (r?: Y, g?: Y, b?: Y) => Vec3;
+declare const iResolution: Vec2;
+declare const iMouse: Vec2;
+declare const iTime: Float;
+declare const uv: Vec2;
+/**
+ * 1.1. unified with:
+ * 2.1. const.ts BUILTIN_VARIABLES and
+ * 3.1. types.ts _N
+ */
+declare const all: <T extends Constants>(x: X<T>) => Bool;
+declare const any: <T extends Constants>(x: X<T>) => Bool;
+declare const determinant: <T extends "mat2" | "mat3" | "mat4">(x: X<T>) => Float;
+declare const distance: <T extends "vec2" | "vec3" | "vec4", U extends Constants>(x: X<T>, y: number | X<U>) => Float;
+declare const dot: <T extends "vec2" | "vec3" | "vec4" | "ivec2" | "ivec3" | "ivec4", U extends Constants>(x: X<T>, y: number | X<U>) => X<T extends `ivec${string}` ? "int" : "float">;
+declare const length: <T extends "vec2" | "vec3" | "vec4">(x: X<T>) => Float;
+declare const lengthSq: (x: X) => Float;
+declare const luminance: (x: X) => Float;
+declare const cross: <U extends Constants = "vec3">(x: X<"vec3">, y: number | X<U>) => Vec3;
+declare const cubeTexture: (x: X, y: X, z?: X) => Vec4;
+declare const texture: (x: X, y: X, z?: X) => Vec4;
+declare const texelFetch: (x: X, y: X, z?: X) => Vec4;
+declare const textureLod: (x: X, y: X, z?: X) => Vec4;
+/**
+ * 1.2. unified with:
+ * 2.2. const.ts FUNCTIONS and
+ * 3.2. types.ts _N
+ */
+declare const abs: <T extends Constants>(x: X<T>) => X<T>;
+declare const acos: <T extends Constants>(x: X<T>) => X<T>;
+declare const acosh: <T extends Constants>(x: X<T>) => X<T>;
+declare const asin: <T extends Constants>(x: X<T>) => X<T>;
+declare const asinh: <T extends Constants>(x: X<T>) => X<T>;
+declare const atan: <T extends Constants>(x: X<T>) => X<T>;
+declare const atanh: <T extends Constants>(x: X<T>) => X<T>;
+declare const ceil: <T extends Constants>(x: X<T>) => X<T>;
+declare const cos: <T extends Constants>(x: X<T>) => X<T>;
+declare const cosh: <T extends Constants>(x: X<T>) => X<T>;
+declare const dFdx: <T extends Constants>(x: X<T>) => X<T>;
+declare const dFdy: <T extends Constants>(x: X<T>) => X<T>;
+declare const degrees: <T extends Constants>(x: X<T>) => X<T>;
+declare const exp: <T extends Constants>(x: X<T>) => X<T>;
+declare const exp2: <T extends Constants>(x: X<T>) => X<T>;
+declare const floor: <T extends Constants>(x: X<T>) => X<T>;
+declare const fract: <T extends Constants>(x: X<T>) => X<T>;
+declare const fwidth: <T extends Constants>(x: X<T>) => X<T>;
+declare const inverseSqrt: <T extends Constants>(x: X<T>) => X<T>;
+declare const log: <T extends Constants>(x: X<T>) => X<T>;
+declare const log2: <T extends Constants>(x: X<T>) => X<T>;
+declare const negate: <T extends Constants>(x: X<T>) => X<T>;
+declare const normalize: <T extends "vec2" | "vec3" | "vec4">(x: X<T>) => X<T>;
+declare const oneMinus: <T extends Constants>(x: X<T>) => X<T>;
+declare const radians: <T extends Constants>(x: X<T>) => X<T>;
+declare const reciprocal: <T extends Constants>(x: X<T>) => X<T>;
+declare const round: <T extends Constants>(x: X<T>) => X<T>;
+declare const sign: <T extends Constants>(x: X<T>) => X<T>;
+declare const sin: <T extends Constants>(x: X<T>) => X<T>;
+declare const sinh: <T extends Constants>(x: X<T>) => X<T>;
+declare const sqrt: <T extends Constants>(x: X<T>) => X<T>;
+declare const tan: <T extends Constants>(x: X<T>) => X<T>;
+declare const tanh: <T extends Constants>(x: X<T>) => X<T>;
+declare const trunc: <T extends Constants>(x: X<T>) => X<T>;
+declare const atan2: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>) => X<T>;
+declare const clamp: <T extends Constants, U extends Constants>(x: X<T>, min: number | X<U>, max: number | X<U>) => X<T>;
+declare const max: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>) => X<T>;
+declare const min: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>) => X<T>;
+declare const mix: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>, a: number | Float | X<U>) => X<T>;
+declare const pow: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>) => X<T>;
+declare const reflect: <T extends "vec2" | "vec3" | "vec4", U extends Constants>(I: X<T>, N: number | X<U>) => X<T>;
+declare const refract: <T extends "vec2" | "vec3" | "vec4", U extends Constants>(I: X<T>, N: number | X<U>, eta: number | Float) => X<T>;
+declare const smoothstep: <T extends Constants, U extends Constants>(e0: number | X<U>, e1: number | X<U>, x: X<T>) => X<T>;
+declare const step: <T extends Constants, U extends Constants>(edge: number | X<U>, x: X<T>) => X<T>;
+declare const mod: <T extends Constants, U extends Constants>(x: X<T>, y: number | X<U>) => X<T>;
+
+export { type BVec2, type BVec3, type BVec4, type Bool, Break, type Color, type Constants, type ConstantsToType, Continue, type Conversions, type Float, Fn, type FnLayout, type FnType, type Functions, type IVec2, type IVec3, type IVec4, If, type Int, Loop, type Mat2, type Mat3, type Mat4, type NodeContext, type NodeProps, type NodeTypes, type Operators, Return, type Sampler2D, Scope, type Struct, type StructBase, type StructFactory, type StructFields, Switch, type Swizzles, type Texture, type UInt, type UVec2, type UVec3, type UVec4, type Vec2, type Vec3, type Vec4, type Void, type X, type Y, abs, acos, acosh, addToScope, all, any, asin, asinh, assign, atan, atan2, atanh, attribute, bool, builtin, bvec2, bvec3, bvec4, ceil, clamp, color, compute, constant, conversion, cos, cosh, create, cross, cubeTexture, dFdx, dFdy, degrees, determinant, distance, dot, element, exp, exp2, float, floor, fract, fragDepth, fragment, frontFacing, function_, fwidth, gather, iMouse, iResolution, iTime, id, instance, instanceIndex, int, inverseSqrt, ivec2, ivec3, ivec4, length, lengthSq, log, log2, luminance, mat2, mat3, mat4, max, member, min, mix, mod, negate, normalLocal, normalView, normalWorld, normalize, oneMinus, operator, pointCoord, position, positionLocal, positionView, positionWorld, pow, radians, reciprocal, reflect, refract, round, sampleIndex, sampleMask, sampler2D, scatter, scoped, screenCoordinate, screenUV, select, sign, sin, sinh, smoothstep, sqrt, step, storage, struct, tan, tanh, texelFetch, texture, texture2D, textureLod, toVar, trunc, uint, uniform, uv, uvec2, uvec3, uvec4, variable, vec2, vec3, vec4, vertex, vertexIndex, vertexStage };