kmcom-nuxt-layers 1.7.9 → 2.2.0

package/layers/shader/app/composables/useCSSColourUniform.ts

@@ -1,3 +1,5 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { Color, Vector3 } from 'three'
 import { uniform } from 'three/tsl'
 
@@ -10,21 +12,20 @@ import { uniform } from 'three/tsl'
  * // Use primaryNode directly inside useShaderStage closures.
  */
 export function useCSSColourUniform(varName: string) {
-  // @ts-ignore — TSL uniform types
+  // @ts-expect-error — TSL uniform types
   const node = uniform(new Vector3(0, 0, 0))
   const c = new Color()
 
   function sync() {
-    const raw = getComputedStyle(document.documentElement)
-      .getPropertyValue(varName)
-      .trim()
+    const raw = getComputedStyle(document.documentElement).getPropertyValue(varName).trim()
     if (!raw) return
     try {
       c.set(raw)
-      // @ts-ignore
+      // @ts-expect-error
       node.value.set(c.r, c.g, c.b)
+    } catch {
+      /* unsupported format — leave previous value */
     }
-    catch { /* unsupported format — leave previous value */ }
   }
 
   onMounted(() => {

package/layers/shader/app/composables/useCSSFloatUniform.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { uniform } from 'three/tsl'
 
 /**
@@ -8,15 +9,13 @@ import { uniform } from 'three/tsl'
  * const spacingNode = useCSSFloatUniform('--spacing-scale')
  */
 export function useCSSFloatUniform(varName: string) {
-  // @ts-ignore — TSL uniform types
+  // @ts-expect-error — TSL uniform types
   const node = uniform(0)
 
   function sync() {
-    const raw = getComputedStyle(document.documentElement)
-      .getPropertyValue(varName)
-      .trim()
+    const raw = getComputedStyle(document.documentElement).getPropertyValue(varName).trim()
     const val = parseFloat(raw)
-    // @ts-ignore
+    // @ts-expect-error
     if (!isNaN(val)) node.value = val
   }
 

package/layers/shader/app/composables/useMousePosition.ts

@@ -1,7 +1,7 @@
 import { useMouse, useWindowSize } from '@vueuse/core'
 import { vec2 as tslVec2, uniform } from 'three/tsl'
 
-export interface MousePositionOptions {
+export type MousePositionOptions = {
   /** Smoothing factor (0-1, lower = smoother) */
   smoothing?: number
   /** Normalize to -1 to 1 range instead of 0 to 1 */

package/layers/shader/app/composables/useShader.ts

@@ -1,11 +1,13 @@
-/* eslint-disable no-restricted-imports */
-import { MeshBasicNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu'
+/* eslint-disable complexity */
+/* eslint-disable no-restricted-syntax */
 import { onUnmounted, shallowRef } from 'vue'
+import { MeshBasicNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu'
+
 import type { NodeMaterialConfig, TSLNode } from '../types'
 
 export type ShaderMaterialType = 'basic' | 'standard'
 
-export interface UseShaderOptions {
+export type UseShaderOptions = {
   type?: ShaderMaterialType
   config?: NodeMaterialConfig
   autoDispose?: boolean

package/layers/shader/app/composables/useShaderColor.ts

@@ -1,6 +1,9 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex
 import { Color } from 'three'
 import { uniform } from 'three/tsl'
+
 import type { TweenHandle } from '../utils/tsl/tween'
 
 /**
@@ -31,7 +34,11 @@ export function useShaderColor(initialHex: string) {
     hex.value = `#${color.getHexString()}`
   }
 
-  function tweenTo(targetHex: string, duration: number, easing?: (t: number) => number): TweenHandle {
+  function tweenTo(
+    targetHex: string,
+    duration: number,
+    easing?: (t: number) => number
+  ): TweenHandle {
     activeTween?.cancel()
 
     const startR = color.r

package/layers/shader/app/composables/useShaderFloat.ts

@@ -1,8 +1,10 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex
 import { uniform } from 'three/tsl'
+
 import type { TweenHandle } from '../utils/tsl/tween'
 
-export interface ShaderFloatOptions {
+export type ShaderFloatOptions = {
   min?: number
   max?: number
 }

package/layers/shader/app/composables/useShaderGraph.ts

@@ -1,18 +1,21 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex
-import { mix as tslMix } from 'three/tsl'
 import type { InjectionKey } from 'vue'
+import { mix as tslMix } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 export type BlendMode = 'normal' | 'add' | 'multiply' | 'screen' | 'overlay' | 'mix'
 
-export interface ShaderGraphEntry {
+export type ShaderGraphEntry = {
   node: TSLNode
   order: number
   blend: BlendMode
   opacity: number
 }
 
-export interface ShaderGraph {
+export type ShaderGraph = {
   register: (id: string, node: TSLNode, order?: number, blend?: BlendMode, opacity?: number) => void
   unregister: (id: string) => void
   update: (id: string, node: TSLNode) => void

package/layers/shader/app/composables/useShaderPerf.ts

@@ -33,13 +33,13 @@ export function useShaderPerf(label = 'pipeline') {
 
     if (accumMs >= 500) {
       fps.value = Math.round((frames / accumMs) * 1000)
-      frameMs.value = Math.round(accumMs / frames * 10) / 10
+      frameMs.value = Math.round((accumMs / frames) * 10) / 10
       frames = 0
       accumMs = 0
     }
 
     stageCount.value = pipeline
-      ? (pipeline.stagesFor('uv').length + pipeline.stagesFor('fragment').length)
+      ? pipeline.stagesFor('uv').length + pipeline.stagesFor('fragment').length
       : 0
     rafId = requestAnimationFrame(tick)
   }
@@ -64,7 +64,6 @@ export function useShaderPerf(label = 'pipeline') {
 
   if (import.meta.dev) {
     watch([fps, frameMs, stageCount], ([f, ms, s]) => {
-      // eslint-disable-next-line no-console
       console.debug(`[ShaderPerf:${label}] ${f}fps  ${ms}ms/frame  ${s} stages`)
     })
   }

package/layers/shader/app/composables/useShaderPipeline.ts

@@ -1,15 +1,16 @@
 import type { InjectionKey, Ref, ShallowRef } from 'vue'
+
 import type { TSLNode } from '../types'
 
 export type ShaderStage = 'fragment' | 'vertex' | 'ray' | 'uv'
 
-export interface ShaderStageEntry {
+export type ShaderStageEntry = {
   fn: (input: TSLNode) => TSLNode
   order: number
   stage: ShaderStage
 }
 
-export interface ShaderPipelineContext {
+export type ShaderPipelineContext = {
   register: (fn: ShaderStageEntry['fn'], order?: number, stage?: ShaderStage) => void
   unregister: (fn: ShaderStageEntry['fn']) => void
   stagesFor: (stage: ShaderStage) => ShaderStageEntry[]
@@ -41,7 +42,7 @@ export function useShaderPipeline(): ShaderPipelineContext {
   }
 
   function unregister(fn: ShaderStageEntry['fn']) {
-    const i = entries.findIndex(e => e.fn === fn)
+    const i = entries.findIndex((e) => e.fn === fn)
     if (i !== -1) {
       entries.splice(i, 1)
       version.value++
@@ -49,10 +50,17 @@ export function useShaderPipeline(): ShaderPipelineContext {
   }
 
   function stagesFor(stage: ShaderStage): ShaderStageEntry[] {
-    return entries.filter(e => e.stage === stage).sort((a, b) => a.order - b.order)
+    return entries.filter((e) => e.stage === stage).sort((a, b) => a.order - b.order)
   }
 
-  const context: ShaderPipelineContext = { register, unregister, stagesFor, version, uvNode, rayNode }
+  const context: ShaderPipelineContext = {
+    register,
+    unregister,
+    stagesFor,
+    version,
+    uvNode,
+    rayNode,
+  }
   provide(SHADER_PIPELINE_KEY, context)
   return context
 }
@@ -75,7 +83,7 @@ export function useShaderPipeline(): ShaderPipelineContext {
 export function useShaderStage(
   stageFn: ShaderStageEntry['fn'],
   order = 0,
-  stage: ShaderStage = 'fragment',
+  stage: ShaderStage = 'fragment'
 ): void {
   const pipeline = inject(SHADER_PIPELINE_KEY)
   if (!pipeline) {

package/layers/shader/app/composables/useShaderRuntime.ts

@@ -1,11 +1,14 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex
+import type { InjectionKey } from 'vue'
 import { Color } from 'three'
 import { uniform } from 'three/tsl'
-import type { InjectionKey } from 'vue'
-import type { ShaderTimeOptions } from './useShaderTime'
+
 import type { MousePositionOptions } from './useMousePosition'
+import type { ShaderTimeOptions } from './useShaderTime'
 
-export interface ShaderRuntimeOptions {
+export type ShaderRuntimeOptions = {
   speed?: number
   accentColor?: string
   darkMode?: boolean
@@ -13,7 +16,7 @@ export interface ShaderRuntimeOptions {
   autoStart?: boolean
 }
 
-export interface ShaderRuntime {
+export type ShaderRuntime = {
   // Sub-systems
   time: ReturnType<typeof useShaderTime>
   mouse: ReturnType<typeof useMousePosition>

package/layers/shader/app/composables/useShaderVec2.ts

@@ -1,6 +1,10 @@
+/* eslint-disable max-params */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex
 import { Vector2 } from 'three'
 import { uniform } from 'three/tsl'
+
 import type { TweenHandle } from '../utils/tsl/tween'
 
 /**

package/layers/shader/app/composables/useSunDirectionUniform.ts

@@ -1,7 +1,8 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { Vector2 } from 'three'
 import { float, time, uniform, vec3 } from 'three/tsl'
 
-export interface SunDirectionOptions {
+export type SunDirectionOptions = {
   /** Animation speed (radians/second). Only used when useMouseY is false. */
   speed?: number
   /** Drive elevation from mouse Y instead of time. */
@@ -25,12 +26,12 @@ export function useSunDirectionUniform(options: SunDirectionOptions = {}) {
   const { speed = 0.05, useMouseY = false } = options
 
   if (useMouseY) {
-    // @ts-ignore
+    // @ts-expect-error
     const mouse = uniform(new Vector2(0.5, 0.5))
 
     onMounted(() => {
       const onMove = (e: MouseEvent) => {
-        // @ts-ignore
+        // @ts-expect-error
         mouse.value.set(e.clientX / window.innerWidth, e.clientY / window.innerHeight)
       }
       window.addEventListener('mousemove', onMove)
@@ -40,15 +41,15 @@ export function useSunDirectionUniform(options: SunDirectionOptions = {}) {
     // angle = -(mouseY - 0.5) — top of screen = sun high, bottom = sun low
     const angle = mouse.y.oneMinus().sub(0.5)
     const a = angle.mul(5).add(0.5)
-    // @ts-ignore
+    // @ts-expect-error
     return vec3(float(0), a.sin().negate(), a.cos())
   }
 
   // Animated mode — pure TSL expression, no JS uniform needed
-  // @ts-ignore
+  // @ts-expect-error
   const speedNode = uniform(speed)
   const angle = time.mul(speedNode).sin().div(8).sub(0.2)
   const a = angle.mul(5).add(0.5)
-  // @ts-ignore
+  // @ts-expect-error
   return vec3(float(0), a.sin().negate(), a.cos())
 }

package/layers/shader/app/composables/useTSLNodes.ts

@@ -1,4 +1,5 @@
 import * as TSL from 'three/tsl'
+
 import * as animation from '../utils/tsl/animation'
 import * as color from '../utils/tsl/color'
 import * as math from '../utils/tsl/math'

package/layers/shader/app/composables/useThemeColors.ts

@@ -1,4 +1,5 @@
-import { parseOKLCH, oklchToColor } from '../utils/tsl/oklch'
+/* eslint-disable no-restricted-syntax */
+import { oklchToColor, parseOKLCH } from '../utils/tsl/oklch'
 
 export function useThemeColors() {
   const { activeAccent } = useAccentColor()
@@ -9,13 +10,10 @@ export function useThemeColors() {
   const infoHex = ref('#38bdf8')
   const primaryLightHex = ref('#a78bfa')
 
-  const clearColor = computed(() =>
-    colorMode.value === 'dark' ? '#0a0a0a' : '#f8f8f8'
-  )
+  const clearColor = computed(() => (colorMode.value === 'dark' ? '#0a0a0a' : '#f8f8f8'))
 
   function cssVarToHex(varName: string): string {
-    const raw = getComputedStyle(document.documentElement)
-      .getPropertyValue(varName).trim()
+    const raw = getComputedStyle(document.documentElement).getPropertyValue(varName).trim()
     try {
       const [l, c, h] = parseOKLCH(raw)
       return `#${oklchToColor(l, c, h).getHexString()}`
@@ -32,10 +30,16 @@ export function useThemeColors() {
       requestAnimationFrame(applyColors)
       return
     }
-    primaryHex.value      = primary
-    secondaryHex.value    = isDark ? cssVarToHex('--ui-color-neutral-700')   : cssVarToHex('--ui-color-secondary-500')
-    primaryLightHex.value = isDark ? cssVarToHex('--ui-color-neutral-900')   : cssVarToHex('--ui-color-primary-300')
-    infoHex.value         = isDark ? cssVarToHex('--ui-color-secondary-500') : cssVarToHex('--ui-color-neutral-300')
+    primaryHex.value = primary
+    secondaryHex.value = isDark
+      ? cssVarToHex('--ui-color-neutral-700')
+      : cssVarToHex('--ui-color-secondary-500')
+    primaryLightHex.value = isDark
+      ? cssVarToHex('--ui-color-neutral-900')
+      : cssVarToHex('--ui-color-primary-300')
+    infoHex.value = isDark
+      ? cssVarToHex('--ui-color-secondary-500')
+      : cssVarToHex('--ui-color-neutral-300')
   }
 
   function refresh() {

package/layers/shader/app/composables/useUniforms.ts

@@ -1,8 +1,11 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
-/* eslint-disable no-restricted-imports */
+
+import { reactive, ref, watch } from 'vue'
 import { Color, Vector2, Vector3 } from 'three'
 import { uniform } from 'three/tsl'
-import { reactive, ref, watch } from 'vue'
+
 import type { UniformValue, UniformValues } from '../types'
 
 /**

package/layers/shader/app/plugins/shader.client.ts

@@ -1,5 +1,6 @@
-/* eslint-disable no-console */
-import { checkWebGPUSupport } from '../composables/useRendererCapabilities'
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import { checkWebGPUSupport } from '#layers/canvas/app/composables/useRendererCapabilities'
 
 export default defineNuxtPlugin(async () => {
   const config = useAppConfig()

package/layers/shader/app/shaders/common/blend.ts

@@ -1,9 +1,12 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Color Blending Utilities
  * Provides composable blend mode functions for shader effects
  */
 import { abs, clamp, float, max, min, mix, step, vec3 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================

package/layers/shader/app/shaders/common/complex.ts

@@ -1,9 +1,11 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Complex number arithmetic in TSL
  * Both functions operate on vec2 (x = real, y = imaginary).
  */
-import { vec2, dot } from 'three/tsl'
+import { dot, vec2 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 /**
@@ -13,10 +15,7 @@ import type { TSLNode } from '../types'
  */
 export function complexDiv(a: TSLNode, b: TSLNode): TSLNode {
   const denom = dot(b, b)
-  return vec2(
-    a.x.mul(b.x).add(a.y.mul(b.y)).div(denom),
-    a.y.mul(b.x).sub(a.x.mul(b.y)).div(denom),
-  )
+  return vec2(a.x.mul(b.x).add(a.y.mul(b.y)).div(denom), a.y.mul(b.x).sub(a.x.mul(b.y)).div(denom))
 }
 
 /**

package/layers/shader/app/shaders/common/effects.ts

@@ -1,3 +1,6 @@
+/* eslint-disable complexity */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Post-Processing Effects
@@ -16,13 +19,14 @@ import {
   vec2,
   vec4,
 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================
 // LED Effect
 // ============================================
 
-export interface LEDEffectOptions {
+export type LEDEffectOptions = {
   scalar?: TSLNode | number
   zoom?: TSLNode | number
   exponent?: TSLNode | number
@@ -65,7 +69,7 @@ export function ledEffect(
 // Pixellation Effect
 // ============================================
 
-export interface PixellationEffectOptions {
+export type PixellationEffectOptions = {
   size?: TSLNode | number
 }
 
@@ -104,7 +108,7 @@ export function pixellationEffect(
 // Chromatic Aberration Effect
 // ============================================
 
-export interface ChromaticAberrationOptions {
+export type ChromaticAberrationOptions = {
   strength?: TSLNode | number
   radial?: TSLNode | number
   direction?: TSLNode | [number, number]
@@ -161,7 +165,7 @@ export function chromaticAberrationEffect(
 // Bulge/Pinch Effect
 // ============================================
 
-export interface BulgeEffectOptions {
+export type BulgeEffectOptions = {
   strength?: TSLNode | number
   radius?: TSLNode | number
   power?: TSLNode | number
@@ -207,7 +211,7 @@ export function bulgeEffect(
 // Wave Distortion Effect
 // ============================================
 
-export interface WaveDistortionOptions {
+export type WaveDistortionOptions = {
   frequency?: TSLNode | number
   amplitude?: TSLNode | number
   time?: TSLNode | number
@@ -254,7 +258,7 @@ export function waveDistortionEffect(
 // Swirl Distortion Effect
 // ============================================
 
-export interface SwirlDistortionOptions {
+export type SwirlDistortionOptions = {
   strength?: TSLNode | number
   radius?: TSLNode | number
   center?: TSLNode | [number, number]

package/layers/shader/app/shaders/common/grain.ts

@@ -1,9 +1,13 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Grain & Film Effects
  * Provides composable grain and texture overlay functions
  */
 import { clamp, dot, float, floor, fract, mix, sin, smoothstep, vec2, vec3 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================

package/layers/shader/app/shaders/common/lighting.ts

@@ -1,9 +1,12 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Lighting Utilities
  * Provides common lighting models for shader effects
  */
 import { dot, float, max, mix, normalize, pow, reflect, vec3 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================
@@ -110,7 +113,7 @@ export function blinnPhongSpecular(
 // Combined Lighting
 // ============================================
 
-export interface LightingOptions {
+export type LightingOptions = {
   ambient?: TSLNode | number
   diffuseStrength?: TSLNode | number
   specularStrength?: TSLNode | number

package/layers/shader/app/shaders/common/math.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Math Utilities
@@ -23,6 +25,7 @@ import {
   vec2,
   vec4,
 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================

package/layers/shader/app/shaders/common/noise.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Noise Utilities
@@ -26,6 +28,7 @@ import {
   vec3,
   vec4,
 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 import {
   fade,
@@ -204,7 +207,7 @@ export function gradientNoise3D(p: TSLNode): TSLNode {
 // FBM (Fractal Brownian Motion)
 // ============================================
 
-export interface FBMOptions {
+export type FBMOptions = {
   octaves?: number
   lacunarity?: number
   gain?: number
@@ -255,7 +258,7 @@ export function fbm3D(p: TSLNode, options: FBMOptions = {}): TSLNode {
 // Voronoi / Cellular Noise
 // ============================================
 
-export interface VoronoiResult {
+export type VoronoiResult = {
   distance: TSLNode
   cellId: TSLNode
 }
@@ -699,7 +702,7 @@ export function ridgedFbm3d(p: TSLNode, options: FBMOptions = {}): TSLNode {
 // Warped FBM Coordinates
 // ============================================
 
-export interface WarpedFbmOptions {
+export type WarpedFbmOptions = {
   frequency?: number
   offset1?: number
   offset2?: number
@@ -751,7 +754,7 @@ export function warpedFbmCoords(
 // Turbulence Rotational (XorDev style)
 // ============================================
 
-export interface TurbulenceRotationalOptions {
+export type TurbulenceRotationalOptions = {
   octaves?: number
   amplitude?: number
   speed?: number

package/layers/shader/app/shaders/common/noiseHelpers.ts

@@ -1,9 +1,11 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Noise Helper Functions
  * Provides primitive functions required by 3D/4D noise algorithms
  */
 import { abs, dot, floor, fract, lessThan, mod, mul, sub, vec3, vec4 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================

package/layers/shader/app/shaders/common/palette.ts

@@ -1,3 +1,7 @@
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck - TSL types are complex and not fully exported from three/tsl
 /**
  * Modular TSL Palette & Color Utilities
@@ -19,13 +23,14 @@ import {
   vec3,
   vec4,
 } from 'three/tsl'
+
 import type { TSLNode } from '../types'
 
 // ============================================
 // Color Stop Types
 // ============================================
 
-export interface ColorStop {
+export type ColorStop = {
   position: number
   color: string | [number, number, number]
 }