@nativescript/canvas-three 2.0.0-webgpu.27 → 2.0.0-webgpu.28

package/three/src/nodes/core/StackNode.d.ts

@@ -1,17 +1,17 @@
-import Node from "./Node.js";
+import Node from './Node.js';
 
 export default class StackNode extends Node {
-    isStackNode: true;
-    nodes: Node[];
-    outputNode: Node | null;
+	isStackNode: true;
+	nodes: Node[];
+	outputNode: Node | null;
 
-    constructor();
+	constructor();
 
-    add(node: Node): this;
+	add(node: Node): this;
 
-    if(boolNode: Node, method: () => void): this;
+	if(boolNode: Node, method: () => void): this;
 
-    elseIf(node: Node, method: () => void): this;
+	elseIf(node: Node, method: () => void): this;
 
-    else(node: Node, method: () => void): this;
+	else(node: Node, method: () => void): this;
 }

package/three/src/nodes/core/StructTypeNode.d.ts

@@ -1,8 +1,8 @@
-import Node from "./Node.js";
+import Node from './Node.js';
 declare class StructTypeNode extends Node {
-    types: string[];
-    readonly isStructTypeNode: true;
-    constructor(types: string[]);
-    getMemberTypes(): string[];
+	types: string[];
+	readonly isStructTypeNode: true;
+	constructor(types: string[]);
+	getMemberTypes(): string[];
 }
 export default StructTypeNode;

package/three/src/nodes/core/TempNode.d.ts

@@ -1,10 +1,10 @@
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
 
 export default class TempNode extends Node {
-    isTempNode: true;
+	isTempNode: true;
 
-    constructor(type: string | null);
+	constructor(type: string | null);
 
-    hasDependencies(builder: NodeBuilder): boolean;
+	hasDependencies(builder: NodeBuilder): boolean;
 }

package/three/src/nodes/core/UniformGroup.d.ts

@@ -1,7 +1,7 @@
 export default class UniformGroup {
-    name: string;
+	name: string;
 
-    readonly isUniformGroup: true;
+	readonly isUniformGroup: true;
 
-    constructor(name: string);
+	constructor(name: string);
 }

package/three/src/nodes/core/UniformGroupNode.d.ts

@@ -1,16 +1,16 @@
-import Node from "./Node.js";
+import Node from './Node.js';
 
 export default class UniformGroupNode extends Node {
-    name: string;
-    version: number;
+	name: string;
+	version: number;
 
-    shared: boolean;
+	shared: boolean;
 
-    readonly isUniformGroup: true;
+	readonly isUniformGroup: true;
 
-    constructor(name: string, shared?: boolean);
+	constructor(name: string, shared?: boolean);
 
-    set needsUpdate(value: boolean);
+	set needsUpdate(value: boolean);
 }
 
 export const uniformGroup: (name: string) => UniformGroupNode;

package/three/src/nodes/core/UniformNode.d.ts

@@ -1,23 +1,20 @@
-import { NodeUpdateType } from "./constants.js";
-import InputNode from "./InputNode.js";
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-import NodeFrame from "./NodeFrame.js";
-import UniformGroupNode from "./UniformGroupNode.js";
+import { NodeUpdateType } from './constants.js';
+import InputNode from './InputNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeFrame from './NodeFrame.js';
+import UniformGroupNode from './UniformGroupNode.js';
 declare class UniformNode<TValue> extends InputNode<TValue> {
-    readonly isUniformNode: true;
-    name: string;
-    groupNode: UniformGroupNode;
-    constructor(value: TValue, nodeType?: string | null);
-    label(name: string): this;
-    setGroup(group: UniformGroupNode): this;
-    getGroup(): UniformGroupNode;
-    getUniformHash(builder: NodeBuilder): string;
-    onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
-    generate(builder: NodeBuilder, output: string | null): string;
+	readonly isUniformNode: true;
+	name: string;
+	groupNode: UniformGroupNode;
+	constructor(value: TValue, nodeType?: string | null);
+	label(name: string): this;
+	setGroup(group: UniformGroupNode): this;
+	getGroup(): UniformGroupNode;
+	getUniformHash(builder: NodeBuilder): string;
+	onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+	generate(builder: NodeBuilder, output: string | null): string;
 }
 export default UniformNode;
-export declare const uniform: <TValue>(
-    arg1: InputNode<TValue> | TValue,
-    arg2?: Node | string,
-) => import("../shadernode/ShaderNode.js").ShaderNodeObject<UniformNode<TValue>>;
+export declare const uniform: <TValue>(arg1: InputNode<TValue> | TValue, arg2?: Node | string) => import('../shadernode/ShaderNode.js').ShaderNodeObject<UniformNode<TValue>>;

package/three/src/nodes/core/VarNode.d.ts

@@ -1,28 +1,28 @@
-import { OperatorNodeOp } from "../math/OperatorNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
+import { OperatorNodeOp } from '../math/OperatorNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
 
 export default class VarNode extends Node {
-    node: Node;
-    name: string | null;
+	node: Node;
+	name: string | null;
 
-    readonly isVarNode: true;
+	readonly isVarNode: true;
 
-    constructor(node: Node, name?: string | null);
+	constructor(node: Node, name?: string | null);
 
-    op(op: OperatorNodeOp, ...params: Node[]): this;
-    assign(...params: Node[]): this;
-    add(...params: Node[]): this;
-    sub(...params: Node[]): this;
-    mul(...params: Node[]): this;
-    div(...params: Node[]): this;
+	op(op: OperatorNodeOp, ...params: Node[]): this;
+	assign(...params: Node[]): this;
+	add(...params: Node[]): this;
+	sub(...params: Node[]): this;
+	mul(...params: Node[]): this;
+	div(...params: Node[]): this;
 }
 
 export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        temp: typeof temp;
-        toVar: typeof temp;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		temp: typeof temp;
+		toVar: typeof temp;
+	}
 }

package/three/src/nodes/core/VaryingNode.d.ts

@@ -1,21 +1,21 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-import NodeVarying from "./NodeVarying.js";
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeVarying from './NodeVarying.js';
 
 export default class VaryingNode extends Node {
-    node: Node;
-    name: string | null;
+	node: Node;
+	name: string | null;
 
-    constructor(node: Node, name?: string | null);
+	constructor(node: Node, name?: string | null);
 
-    setupVarying(builder: NodeBuilder): NodeVarying;
+	setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        varying: typeof varying;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		varying: typeof varying;
+	}
 }

package/three/src/nodes/core/constants.d.ts

@@ -1,26 +1,26 @@
 export declare const NodeShaderStage: {
-    readonly VERTEX: "vertex";
-    readonly FRAGMENT: "fragment";
+	readonly VERTEX: 'vertex';
+	readonly FRAGMENT: 'fragment';
 };
 export declare const NodeUpdateType: {
-    readonly NONE: "none";
-    readonly FRAME: "frame";
-    readonly RENDER: "render";
-    readonly OBJECT: "object";
+	readonly NONE: 'none';
+	readonly FRAME: 'frame';
+	readonly RENDER: 'render';
+	readonly OBJECT: 'object';
 };
 export declare const NodeType: {
-    readonly BOOLEAN: "bool";
-    readonly INTEGER: "int";
-    readonly FLOAT: "float";
-    readonly VECTOR2: "vec2";
-    readonly VECTOR3: "vec3";
-    readonly VECTOR4: "vec4";
-    readonly MATRIX2: "mat2";
-    readonly MATRIX3: "mat3";
-    readonly MATRIX4: "mat4";
+	readonly BOOLEAN: 'bool';
+	readonly INTEGER: 'int';
+	readonly FLOAT: 'float';
+	readonly VECTOR2: 'vec2';
+	readonly VECTOR3: 'vec3';
+	readonly VECTOR4: 'vec4';
+	readonly MATRIX2: 'mat2';
+	readonly MATRIX3: 'mat3';
+	readonly MATRIX4: 'mat4';
 };
-export type NodeShaderStage = "vertex" | "fragment" | "compute";
-export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export type NodeShaderStage = 'vertex' | 'fragment' | 'compute';
+export type NodeUpdateType = 'none' | 'frame' | 'render' | 'object';
 export declare const defaultShaderStages: NodeShaderStage[];
 export declare const defaultBuildStages: string[];
 export declare const shaderStages: NodeShaderStage[];

package/three/src/nodes/display/AfterImageNode.d.ts

@@ -1,25 +1,25 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class AfterImageNode extends TempNode {
-    textureNode: TextureNode;
-    textureNodeOld: Node;
-    damp: UniformNode<number>;
+	textureNode: TextureNode;
+	textureNodeOld: Node;
+	damp: UniformNode<number>;
 
-    constructor(textureNode: Node, damp?: number);
+	constructor(textureNode: Node, damp?: number);
 
-    getTextureNode(): TextureNode;
+	getTextureNode(): TextureNode;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 }
 
 export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        afterImage: typeof afterImage;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		afterImage: typeof afterImage;
+	}
 }

package/three/src/nodes/display/AnamorphicNode.d.ts

@@ -1,31 +1,26 @@
-import { Vector2 } from "../../math/Vector2.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Vector2 } from '../../math/Vector2.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class AnamorphicNode extends TempNode {
-    textureNode: Node;
-    thresholdNode: Node;
-    scaleNode: Node;
-    samples: number;
-    resolution: Vector2;
+	textureNode: Node;
+	thresholdNode: Node;
+	scaleNode: Node;
+	samples: number;
+	resolution: Vector2;
 
-    constructor(textureNode: Node, thresholdNode: Node, scaleNode: Node, samples: number);
+	constructor(textureNode: Node, thresholdNode: Node, scaleNode: Node, samples: number);
 
-    getTextureNode(): Node;
+	getTextureNode(): Node;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 }
 
-export const anamorphic: (
-    node: Node,
-    threshold?: NodeRepresentation,
-    scale?: NodeRepresentation,
-    samples?: NodeRepresentation,
-) => ShaderNodeObject<AnamorphicNode>;
+export const anamorphic: (node: Node, threshold?: NodeRepresentation, scale?: NodeRepresentation, samples?: NodeRepresentation) => ShaderNodeObject<AnamorphicNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        anamorphic: typeof anamorphic;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		anamorphic: typeof anamorphic;
+	}
 }

package/three/src/nodes/display/BlendModeNode.d.ts

@@ -1,7 +1,7 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { JoinNode } from "../Nodes.js";
-import { NodeRepresentation, ShaderNode, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { JoinNode } from '../Nodes.js';
+import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
@@ -11,25 +11,21 @@ export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject
 
 export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export type BlendMode =
-    | typeof BlendModeNode.BURN
-    | typeof BlendModeNode.DODGE
-    | typeof BlendModeNode.SCREEN
-    | typeof BlendModeNode.OVERLAY;
+export type BlendMode = typeof BlendModeNode.BURN | typeof BlendModeNode.DODGE | typeof BlendModeNode.SCREEN | typeof BlendModeNode.OVERLAY;
 
 export default class BlendModeNode extends TempNode {
-    static BURN: "burn";
-    static DODGE: "dodge";
-    static SCREEN: "screen";
-    static OVERLAY: "overlay";
+	static BURN: 'burn';
+	static DODGE: 'dodge';
+	static SCREEN: 'screen';
+	static OVERLAY: 'overlay';
 
-    baseNode: Node;
-    blendMode: BlendMode;
-    blendNode: Node;
+	baseNode: Node;
+	blendMode: BlendMode;
+	blendNode: Node;
 
-    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
+	constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
 
-    setup(): Node;
+	setup(): Node;
 }
 
 export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
@@ -37,11 +33,11 @@ export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentatio
 export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        burn: typeof burn;
-        dodge: typeof dodge;
-        overlay: typeof overlay;
-        screen: typeof screen;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		burn: typeof burn;
+		dodge: typeof dodge;
+		overlay: typeof overlay;
+		screen: typeof screen;
+	}
 }

package/three/src/nodes/display/BloomNode.d.ts

@@ -1,35 +1,30 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class BloomNode extends TempNode {
-    inputNode: Node;
-    strength: UniformNode<number>;
-    radius: UniformNode<number>;
-    threshold: UniformNode<number>;
+	inputNode: Node;
+	strength: UniformNode<number>;
+	radius: UniformNode<number>;
+	threshold: UniformNode<number>;
 
-    smoothWidth: UniformNode<number>;
+	smoothWidth: UniformNode<number>;
 
-    constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
+	constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
 
-    getTexture(): ShaderNodeObject<TextureNode>;
+	getTexture(): ShaderNodeObject<TextureNode>;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 }
 
-export const bloom: (
-    node: NodeRepresentation,
-    strength?: number,
-    radius?: number,
-    threshold?: number,
-) => ShaderNodeObject<BloomNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bloom: typeof bloom;
-    }
+export const bloom: (node: NodeRepresentation, strength?: number, radius?: number, threshold?: number) => ShaderNodeObject<BloomNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		bloom: typeof bloom;
+	}
 }
 
 export default BloomNode;

package/three/src/nodes/display/ColorAdjustmentNode.d.ts

@@ -1,47 +1,35 @@
-import TempNode from "../core/TempNode.js";
-import MathNode from "../math/MathNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TempNode from '../core/TempNode.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export type ColorAdjustmentMethod =
-    | typeof ColorAdjustmentNode.SATURATION
-    | typeof ColorAdjustmentNode.VIBRANCE
-    | typeof ColorAdjustmentNode.HUE;
+export type ColorAdjustmentMethod = typeof ColorAdjustmentNode.SATURATION | typeof ColorAdjustmentNode.VIBRANCE | typeof ColorAdjustmentNode.HUE;
 
 export default class ColorAdjustmentNode extends TempNode {
-    static SATURATION: "saturation";
-    static VIBRANCE: "vibrance";
-    static HUE: "hue";
+	static SATURATION: 'saturation';
+	static VIBRANCE: 'vibrance';
+	static HUE: 'hue';
 
-    method: ColorAdjustmentMethod;
+	method: ColorAdjustmentMethod;
 
-    colorNode: Node;
-    adjustmentNode: Node;
+	colorNode: Node;
+	adjustmentNode: Node;
 
-    constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
+	constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
 }
 
-export const saturation: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const vibrance: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const hue: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
+export const saturation: (colorNode: NodeRepresentation, adjustmentNode?: NodeRepresentation) => ShaderNodeObject<ColorAdjustmentNode>;
+export const vibrance: (colorNode: NodeRepresentation, adjustmentNode?: NodeRepresentation) => ShaderNodeObject<ColorAdjustmentNode>;
+export const hue: (colorNode: NodeRepresentation, adjustmentNode?: NodeRepresentation) => ShaderNodeObject<ColorAdjustmentNode>;
 
 export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        saturation: typeof saturation;
-        vibrance: typeof vibrance;
-        hue: typeof hue;
-        threshold: typeof threshold;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		saturation: typeof saturation;
+		vibrance: typeof vibrance;
+		hue: typeof hue;
+		threshold: typeof threshold;
+	}
 }

package/three/src/nodes/display/ColorSpaceNode.d.ts

@@ -1,22 +1,19 @@
-import { ColorSpace } from "../../constants.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ColorSpace } from '../../constants.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export type ColorSpaceNodeMethod =
-    | typeof ColorSpaceNode.LINEAR_TO_LINEAR
-    | typeof ColorSpaceNode.LINEAR_TO_sRGB
-    | typeof ColorSpaceNode.sRGB_TO_LINEAR;
+export type ColorSpaceNodeMethod = typeof ColorSpaceNode.LINEAR_TO_LINEAR | typeof ColorSpaceNode.LINEAR_TO_sRGB | typeof ColorSpaceNode.sRGB_TO_LINEAR;
 
 export default class ColorSpaceNode extends TempNode {
-    static LINEAR_TO_LINEAR: "LinearToLinear";
-    static LINEAR_TO_sRGB: "LinearTosRGB";
-    static sRGB_TO_LINEAR: "sRGBToLinear";
+	static LINEAR_TO_LINEAR: 'LinearToLinear';
+	static LINEAR_TO_sRGB: 'LinearTosRGB';
+	static sRGB_TO_LINEAR: 'sRGBToLinear';
 
-    method: ColorSpaceNodeMethod;
-    node: Node;
+	method: ColorSpaceNodeMethod;
+	node: Node;
 
-    constructor(method: ColorSpaceNodeMethod | null, node: Node);
+	constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
 
 export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
@@ -25,11 +22,11 @@ export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpa
 export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
 export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        linearTosRGB: typeof linearTosRGB;
-        sRGBToLinear: typeof sRGBToLinear;
-        linearToColorSpace: typeof linearToColorSpace;
-        colorSpaceToLinear: typeof colorSpaceToLinear;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		linearTosRGB: typeof linearTosRGB;
+		sRGBToLinear: typeof sRGBToLinear;
+		linearToColorSpace: typeof linearToColorSpace;
+		colorSpaceToLinear: typeof colorSpaceToLinear;
+	}
 }