minecraft-renderer 0.1.78 → 0.1.80

package/src/three/holdingBlockItemIdentity.test.ts

@@ -6,12 +6,12 @@ test('hand item render key ignores live use state but keeps first-person display
   const getItemRenderData = vi.fn(() => ({ modelName: 'item/bow' }))
   const worldRenderer = {
     playerStateReactive: {
-      itemUsageTicks: 20,
+      itemUsageTicks: 20
     },
     resourcesManager: {
-      currentResources: {},
+      currentResources: {}
     },
-    getItemRenderData,
+    getItemRenderData
   } as any
 
   const handItem = {
@@ -19,8 +19,8 @@ test('hand item render key ignores live use state but keeps first-person display
     id: 261,
     name: 'minecraft:bow',
     fullItem: {
-      count: 1,
-    },
+      count: 1
+    }
   } as const
 
   const activeKey = getHandItemRenderKey(worldRenderer, handItem)
@@ -28,16 +28,24 @@ test('hand item render key ignores live use state but keeps first-person display
   const idleKey = getHandItemRenderKey(worldRenderer, handItem)
 
   expect(activeKey).toBe(idleKey)
-  expect(getItemRenderData).toHaveBeenNthCalledWith(1, {
-    ...handItem.fullItem,
-    itemId: handItem.id,
-  }, {
-    'minecraft:display_context': 'firstperson',
-  })
-  expect(getItemRenderData).toHaveBeenNthCalledWith(2, {
-    ...handItem.fullItem,
-    itemId: handItem.id,
-  }, {
-    'minecraft:display_context': 'firstperson',
-  })
+  expect(getItemRenderData).toHaveBeenNthCalledWith(
+    1,
+    {
+      ...handItem.fullItem,
+      itemId: handItem.id
+    },
+    {
+      'minecraft:display_context': 'firstperson'
+    }
+  )
+  expect(getItemRenderData).toHaveBeenNthCalledWith(
+    2,
+    {
+      ...handItem.fullItem,
+      itemId: handItem.id
+    },
+    {
+      'minecraft:display_context': 'firstperson'
+    }
+  )
 })

package/src/three/holdingBlockItemIdentity.ts

@@ -5,11 +5,11 @@ import type { WorldRendererThree } from './worldRendererThree'
 export const getFirstPersonItemSpecificProps = (worldRenderer: WorldRendererThree): ItemSpecificContextProperties => ({
   'minecraft:display_context': 'firstperson',
   'minecraft:use_duration': worldRenderer.playerStateReactive.itemUsageTicks,
-  'minecraft:using_item': !!worldRenderer.playerStateReactive.itemUsageTicks,
+  'minecraft:using_item': !!worldRenderer.playerStateReactive.itemUsageTicks
 })
 
 const getFirstPersonItemIdentityProps = (): ItemSpecificContextProperties => ({
-  'minecraft:display_context': 'firstperson',
+  'minecraft:display_context': 'firstperson'
 })
 
 export const getHandItemRenderKey = (worldRenderer: WorldRendererThree, handItem?: HandItemBlock) => {
@@ -21,10 +21,13 @@ export const getHandItemRenderKey = (worldRenderer: WorldRendererThree, handItem
     return `${handItem.type}:${itemIdentifier}`
   }
 
-  const renderData = worldRenderer.getItemRenderData({
-    ...handItem.fullItem,
-    itemId: handItem.id,
-  }, getFirstPersonItemIdentityProps())
+  const renderData = worldRenderer.getItemRenderData(
+    {
+      ...handItem.fullItem,
+      itemId: handItem.id
+    },
+    getFirstPersonItemIdentityProps()
+  )
 
   return `${handItem.type}:${itemIdentifier}:${renderData.modelName}`
 }

package/src/three/holdingBlockLegacy.ts

@@ -20,82 +20,36 @@ import { getFirstPersonItemSpecificProps, getHandItemRenderKey } from './holding
 
 const rotationPositionData = {
   itemRight: {
-    'rotation': [
-      0,
-      -90,
-      25
-    ],
-    'translation': [
-      1.13,
-      3.2,
-      1.13
-    ],
-    'scale': [
-      0.68,
-      0.68,
-      0.68
-    ]
+    rotation: [0, -90, 25],
+    translation: [1.13, 3.2, 1.13],
+    scale: [0.68, 0.68, 0.68]
   },
   itemLeft: {
-    'rotation': [
-      0,
-      90,
-      -25
-    ],
-    'translation': [
-      1.13,
-      3.2,
-      1.13
-    ],
-    'scale': [
-      0.68,
-      0.68,
-      0.68
-    ]
+    rotation: [0, 90, -25],
+    translation: [1.13, 3.2, 1.13],
+    scale: [0.68, 0.68, 0.68]
   },
   blockRight: {
-    'rotation': [
-      0,
-      45,
-      0
-    ],
-    'translation': [
-      0,
-      0,
-      0
-    ],
-    'scale': [
-      0.4,
-      0.4,
-      0.4
-    ]
+    rotation: [0, 45, 0],
+    translation: [0, 0, 0],
+    scale: [0.4, 0.4, 0.4]
   },
   blockLeft: {
-    'rotation': [
-      0,
-      225,
-      0
-    ],
-    'translation': [
-      0,
-      0,
-      0
-    ],
-    'scale': [
-      0.4,
-      0.4,
-      0.4
-    ]
+    rotation: [0, 225, 0],
+    translation: [0, 0, 0],
+    scale: [0.4, 0.4, 0.4]
   }
 }
 
 export default class HoldingBlockLegacy implements IHoldingBlock {
   // TODO refactor with the tree builder for better visual understanding
   holdingBlock: THREE.Object3D | undefined = undefined
-  blockSwapAnimation: {
-    switcher: SmoothSwitcher
-    // hidden: boolean
-  } | undefined = undefined
+  blockSwapAnimation:
+    | {
+        switcher: SmoothSwitcher
+        // hidden: boolean
+      }
+    | undefined = undefined
   cameraGroup = new THREE.Mesh()
   objectOuterGroup = new THREE.Group() // 3
   objectInnerGroup = new THREE.Group() // 4
@@ -118,51 +72,63 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
   private disposed = false
   unsubs: Array<() => void> = []
 
-  constructor(public worldRenderer: WorldRendererThree, public offHand = false) {
+  constructor(
+    public worldRenderer: WorldRendererThree,
+    public offHand = false
+  ) {
     this.initCameraGroup()
-    this.unsubs.push(subscribeKey(this.worldRenderer.playerStateReactive, 'heldItemMain', () => {
-      if (!this.offHand) {
-        this.updateItem()
-      }
-    }))
-    this.unsubs.push(subscribeKey(this.worldRenderer.playerStateReactive, 'heldItemOff', () => {
-      if (this.offHand) {
-        this.updateItem()
-      }
-    }))
+    this.unsubs.push(
+      subscribeKey(this.worldRenderer.playerStateReactive, 'heldItemMain', () => {
+        if (!this.offHand) {
+          this.updateItem()
+        }
+      })
+    )
+    this.unsubs.push(
+      subscribeKey(this.worldRenderer.playerStateReactive, 'heldItemOff', () => {
+        if (this.offHand) {
+          this.updateItem()
+        }
+      })
+    )
     this.config = worldRenderer.displayOptions.inWorldRenderingConfig
 
     this.offHandDisplay = this.offHand
     // this.offHandDisplay = true
     if (!this.offHand) {
       // load default hand
-      void getMyHand().then((hand) => {
-        if (this.disposed) return
-        this.playerHand = hand
-        // trigger update
-        this.updateItem()
-      }).then(() => {
-        if (this.disposed) return
-        // now watch over the player skin
-        const unsub = watchProperty(
-          async () => {
-            return getMyHand(this.worldRenderer.playerStateReactive.playerSkin, this.worldRenderer.playerStateReactive.onlineMode ? this.worldRenderer.playerStateReactive.username : undefined)
-          },
-          this.worldRenderer.playerStateReactive,
-          'playerSkin',
-          (newHand) => {
-            if (newHand) {
-              this.playerHand = newHand
-              // trigger update
-              this.updateItem()
+      void getMyHand()
+        .then(hand => {
+          if (this.disposed) return
+          this.playerHand = hand
+          // trigger update
+          this.updateItem()
+        })
+        .then(() => {
+          if (this.disposed) return
+          // now watch over the player skin
+          const unsub = watchProperty(
+            async () => {
+              return getMyHand(
+                this.worldRenderer.playerStateReactive.playerSkin,
+                this.worldRenderer.playerStateReactive.onlineMode ? this.worldRenderer.playerStateReactive.username : undefined
+              )
+            },
+            this.worldRenderer.playerStateReactive,
+            'playerSkin',
+            newHand => {
+              if (newHand) {
+                this.playerHand = newHand
+                // trigger update
+                this.updateItem()
+              }
+            },
+            oldHand => {
+              disposeObject(oldHand!, true)
             }
-          },
-          (oldHand) => {
-            disposeObject(oldHand!, true)
-          }
-        )
-        this.unsubs.push(unsub)
-      })
+          )
+          this.unsubs.push(unsub)
+        })
     }
   }
 
@@ -175,7 +141,7 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
       void this.setNewItem()
     } else {
       void this.setNewItem({
-        type: 'hand',
+        type: 'hand'
       })
     }
   }
@@ -195,7 +161,8 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
   render(originalCamera: THREE.PerspectiveCamera, renderer: THREE.WebGLRenderer, ambientLight: THREE.AmbientLight, directionalLight: THREE.DirectionalLight) {
     if (!this.lastHeldItem) return
     const now = performance.now()
-    if (this.lastUpdate && now - this.lastUpdate > 50) { // one tick
+    if (this.lastUpdate && now - this.lastUpdate > 50) {
+      // one tick
       void this.replaceItemModel(this.lastHeldItem)
     }
 
@@ -280,14 +247,14 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
     //   throw new Error(`forceState does not match current state ${forceState} !== ${newState}`)
     // }
 
-    const targetY = this.objectInnerGroup.position.y + (this.objectInnerGroup.scale.y * 1.5 * (newState === 'appeared' ? 1 : -1))
+    const targetY = this.objectInnerGroup.position.y + this.objectInnerGroup.scale.y * 1.5 * (newState === 'appeared' ? 1 : -1)
 
     // if (newState === this.blockSwapAnimation.switcher.transitioningToStateName) {
     //   return false
     // }
 
     let cancelled = false
-    return new Promise<boolean>((resolve) => {
+    return new Promise<boolean>(resolve => {
       this.blockSwapAnimation!.switcher.transitionTo(
         { y: targetY },
         newState,
@@ -318,16 +285,11 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
     // const aspect = viewerSize.width / viewerSize.height
     const aspect = 1
 
-
     // Adjust the position based on the aspect ratio
     const { position, scale: scaleData } = this.getHandHeld3d()
     const distance = -position.z
     const side = this.offHandModeLegacy ? -1 : 1
-    this.objectOuterGroup.position.set(
-      distance * position.x * aspect * side,
-      distance * position.y,
-      -distance
-    )
+    this.objectOuterGroup.position.set(distance * position.x * aspect * side, distance * position.y, -distance)
 
     // const scale = Math.min(0.8, Math.max(1, 1 * aspect))
     const scale = scaleData * 2.22 * 0.2
@@ -341,10 +303,15 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
 
     let blockInner: THREE.Object3D | undefined
     if (handItem.type === 'item' || handItem.type === 'block') {
-      const result = this.worldRenderer.entities.getItemMesh({
-        ...handItem.fullItem,
-        itemId: handItem.id,
-      }, getFirstPersonItemSpecificProps(this.worldRenderer), false, this.lastItemModelName)
+      const result = this.worldRenderer.entities.getItemMesh(
+        {
+          ...handItem.fullItem,
+          itemId: handItem.id
+        },
+        getFirstPersonItemSpecificProps(this.worldRenderer),
+        false,
+        this.lastItemModelName
+      )
       if (result) {
         const { mesh: itemMesh, isBlock, modelName } = result
         if (isBlock) {
@@ -391,8 +358,6 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
     this.holdingBlock?.removeFromParent()
     this.holdingBlock = result.model
     this.holdingBlockInnerGroup.add(result.model)
-
-
   }
 
   testUnknownBlockSwitch() {
@@ -568,7 +533,10 @@ class HandIdleAnimator {
 
   private readonly debugGui: DebugGui
 
-  constructor(public handMesh: THREE.Object3D, public playerState: PlayerStateRenderer) {
+  constructor(
+    public handMesh: THREE.Object3D,
+    public playerState: PlayerStateRenderer
+  ) {
     this.handMesh = handMesh
     this.globalTime = 0
     this.currentState = 'NOT_MOVING'
@@ -597,12 +565,24 @@ class HandIdleAnimator {
       },
       (property, value) => {
         switch (property) {
-          case 'x': this.handMesh.position.x = value; break
-          case 'y': this.handMesh.position.y = value; break
-          case 'z': this.handMesh.position.z = value; break
-          case 'rotationX': this.handMesh.rotation.x = value; break
-          case 'rotationY': this.handMesh.rotation.y = value; break
-          case 'rotationZ': this.handMesh.rotation.z = value; break
+          case 'x':
+            this.handMesh.position.x = value
+            break
+          case 'y':
+            this.handMesh.position.y = value
+            break
+          case 'z':
+            this.handMesh.position.z = value
+            break
+          case 'rotationX':
+            this.handMesh.rotation.x = value
+            break
+          case 'rotationY':
+            this.handMesh.rotation.y = value
+            break
+          case 'rotationZ':
+            this.handMesh.rotation.z = value
+            break
         }
       },
       {
@@ -628,10 +608,13 @@ class HandIdleAnimator {
     this.idleOffset.rotationZ = this.handMesh.rotation.z - this.defaultPosition.rotationZ
 
     this.idleTween = new tweenJs.Tween(this.idleOffset, this.tween)
-      .to({
-        y: 0.05,
-        rotationZ: 0.05
-      }, 3000)
+      .to(
+        {
+          y: 0.05,
+          rotationZ: 0.05
+        },
+        3000
+      )
       .easing(tweenJs.Easing.Sinusoidal.InOut)
       .yoyo(true)
       .repeat(Infinity)
@@ -729,8 +712,7 @@ class HandIdleAnimator {
     }
 
     // If we're not transitioning between states and in a stable state that should have idle animation
-    if (!this.stateSwitcher.isTransitioning &&
-      (this.currentState === 'NOT_MOVING' || this.currentState === 'SNEAKING')) {
+    if (!this.stateSwitcher.isTransitioning && (this.currentState === 'NOT_MOVING' || this.currentState === 'SNEAKING')) {
       // Start idle animation if not already running
       if (!this.idleTween?.isPlaying()) {
         this.startIdleAnimation()
@@ -744,8 +726,7 @@ class HandIdleAnimator {
     }
 
     // If we're in a movement state and not transitioning, update the movement animation
-    if (!this.stateSwitcher.isTransitioning &&
-      (this.currentState === 'WALKING' || this.currentState === 'SPRINTING')) {
+    if (!this.stateSwitcher.isTransitioning && (this.currentState === 'WALKING' || this.currentState === 'SPRINTING')) {
       const stateTransform = this.getStateTransform(this.currentState, this.globalTime)
       Object.assign(this.handMesh.position, stateTransform)
       Object.assign(this.handMesh.rotation, {

package/src/three/itemMesh.ts

@@ -4,7 +4,7 @@ import * as THREE from 'three'
 /** Canvas used for item texture extraction (main thread or worker). */
 export type ItemTextureCanvas = HTMLCanvasElement | OffscreenCanvas
 
-function createItemTextureCanvas (width: number, height: number): ItemTextureCanvas {
+function createItemTextureCanvas(width: number, height: number): ItemTextureCanvas {
   if (typeof document !== 'undefined') {
     const canvas = document.createElement('canvas')
     canvas.width = width
@@ -29,10 +29,7 @@ export interface Create3DItemMeshResult {
  * Creates a 3D item geometry with front/back faces and connecting edges
  * from a canvas containing the item texture
  */
-export function create3DItemMesh (
-  canvas: ItemTextureCanvas,
-  options: Create3DItemMeshOptions
-): Create3DItemMeshResult {
+export function create3DItemMesh(canvas: ItemTextureCanvas, options: Create3DItemMeshOptions): Create3DItemMeshResult {
   const { depth, pixelSize } = options
 
   // Validate canvas dimensions
@@ -47,7 +44,7 @@ export function create3DItemMesh (
   const w = canvas.width
   const h = canvas.height
   const halfDepth = depth / 2
-  const actualPixelSize = pixelSize ?? (1 / Math.max(w, h))
+  const actualPixelSize = pixelSize ?? 1 / Math.max(w, h)
 
   // Find opaque pixels
   const isOpaque = (x: number, y: number) => {
@@ -256,10 +253,7 @@ export interface ItemMeshResult {
 /**
  * Extracts item texture region to a canvas
  */
-export function extractItemTextureToCanvas (
-  sourceTexture: THREE.Texture<HTMLImageElement | ImageBitmap>,
-  textureInfo: ItemTextureInfo
-): ItemTextureCanvas {
+export function extractItemTextureToCanvas(sourceTexture: THREE.Texture<HTMLImageElement | ImageBitmap>, textureInfo: ItemTextureInfo): ItemTextureCanvas {
   const { u, v, sizeX, sizeY } = textureInfo
 
   // Calculate canvas size - fix the calculation
@@ -292,7 +286,7 @@ export function extractItemTextureToCanvas (
 /**
  * Creates either a 2D or 3D item mesh based on parameters
  */
-export function createItemMesh (
+export function createItemMesh(
   sourceTexture: THREE.Texture,
   textureInfo: ItemTextureInfo,
   options: {
@@ -317,14 +311,14 @@ export function createItemMesh (
     const spriteMat = new THREE.SpriteMaterial({
       map: itemsTexture,
       transparent: true,
-      alphaTest: 0.1,
+      alphaTest: 0.1
     })
     const mesh = new THREE.Sprite(spriteMat)
 
     return {
       mesh,
       itemsTexture,
-      cleanup () {
+      cleanup() {
         itemsTexture.dispose()
       }
     }
@@ -333,10 +327,7 @@ export function createItemMesh (
   if (use3D) {
     // Try to create 3D mesh
     try {
-      const canvas = extractItemTextureToCanvas(
-        sourceTexture as THREE.Texture<HTMLImageElement | ImageBitmap>,
-        textureInfo
-      )
+      const canvas = extractItemTextureToCanvas(sourceTexture as THREE.Texture<HTMLImageElement | ImageBitmap>, textureInfo)
       const { geometry } = create3DItemMesh(canvas, { depth })
 
       // Create texture from canvas for the 3D mesh
@@ -351,7 +342,7 @@ export function createItemMesh (
         map: itemsTexture,
         side: THREE.DoubleSide,
         transparent: true,
-        alphaTest: 0.1,
+        alphaTest: 0.1
       })
 
       const mesh = new THREE.Mesh(geometry, material)
@@ -359,7 +350,7 @@ export function createItemMesh (
       return {
         mesh,
         itemsTexture,
-        cleanup () {
+        cleanup() {
           itemsTexture.dispose()
           geometry.dispose()
           if (material.map) material.map.dispose()
@@ -389,24 +380,27 @@ export function createItemMesh (
   const material = new THREE.MeshStandardMaterial({
     map: itemsTexture,
     transparent: true,
-    alphaTest: 0.1,
+    alphaTest: 0.1
   })
   const materialFlipped = new THREE.MeshStandardMaterial({
     map: itemsTextureFlipped,
     transparent: true,
-    alphaTest: 0.1,
+    alphaTest: 0.1
   })
   const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 0), [
-    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }), new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
-    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }), new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
-    material, materialFlipped,
+    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
+    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
+    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
+    new THREE.MeshBasicMaterial({ color: 0x00_00_00 }),
+    material,
+    materialFlipped
   ])
 
   return {
     mesh,
     itemsTexture,
     itemsTextureFlipped,
-    cleanup () {
+    cleanup() {
       itemsTexture.dispose()
       itemsTextureFlipped.dispose()
       material.dispose()
@@ -418,10 +412,7 @@ export function createItemMesh (
 /**
  * Creates a complete 3D item mesh from a canvas texture
  */
-export function createItemMeshFromCanvas (
-  canvas: HTMLCanvasElement,
-  options: Create3DItemMeshOptions
-): THREE.Mesh {
+export function createItemMeshFromCanvas(canvas: HTMLCanvasElement, options: Create3DItemMeshOptions): THREE.Mesh {
   const { geometry } = create3DItemMesh(canvas, options)
 
   // Base color texture for the item

package/src/three/legacyMultiDraw.ts

@@ -0,0 +1,93 @@
+//@ts-nocheck
+import { MAX_OPAQUE_SPANS } from './globalLegacyBuffer'
+
+export type LegacyMultiDrawTier = 'A' | 'B' | 'C'
+
+export type LegacyDrawSpan = { indexStart: number; indexCount: number }
+
+export type LegacyMultiDrawCaps = {
+  tier: LegacyMultiDrawTier
+  ext: MultiDrawElementsExt | null
+}
+
+type MultiDrawElementsExt = {
+  multiDrawElementsWEBGL: (
+    mode: number,
+    counts: Int32Array,
+    countsOffset: number,
+    type: number,
+    offsets: Int32Array,
+    offsetsOffset: number,
+    drawCount: number
+  ) => void
+}
+
+export type LegacyMultiDrawScratch = {
+  counts: Int32Array
+  offsets: Int32Array
+}
+
+export function createLegacyMultiDrawScratch(): LegacyMultiDrawScratch {
+  return {
+    counts: new Int32Array(MAX_OPAQUE_SPANS),
+    offsets: new Int32Array(MAX_OPAQUE_SPANS)
+  }
+}
+
+/** Grow scratch arrays when blend (uncapped) span count exceeds opaque cap. */
+function ensureScratchCapacity(scratch: LegacyMultiDrawScratch, minLength: number): void {
+  if (scratch.counts.length >= minLength) return
+  let newLen = scratch.counts.length
+  while (newLen < minLength) newLen *= 2
+  scratch.counts = new Int32Array(newLen)
+  scratch.offsets = new Int32Array(newLen)
+}
+
+export function detectLegacyMultiDrawCaps(gl: WebGL2RenderingContext): LegacyMultiDrawCaps {
+  const ext = gl.getExtension('WEBGL_multi_draw')
+  if (ext) {
+    return { tier: 'A', ext: ext as MultiDrawElementsExt }
+  }
+  return { tier: 'B', ext: null }
+}
+
+let tierLogged = false
+
+export function logLegacyMultiDrawTierOnce(tier: LegacyMultiDrawTier, debug: boolean): void {
+  if (tierLogged || !debug) return
+  tierLogged = true
+  console.info('[globalLegacyBuffer] legacy multi_draw tier', tier)
+}
+
+/**
+ * Issue indexed legacy draws for visible spans. Tier B/C loop drawElements.
+ */
+export function drawLegacySpans(
+  gl: WebGL2RenderingContext,
+  caps: LegacyMultiDrawCaps,
+  spans: readonly LegacyDrawSpan[],
+  scratch: LegacyMultiDrawScratch
+): void {
+  const drawCount = spans.length
+  if (drawCount === 0) return
+
+  ensureScratchCapacity(scratch, drawCount)
+
+  const mode = gl.TRIANGLES
+  const type = gl.UNSIGNED_INT
+
+  for (let i = 0; i < drawCount; i++) {
+    const span = spans[i]!
+    scratch.counts[i] = span.indexCount
+    scratch.offsets[i] = span.indexStart * 4
+  }
+
+  if (caps.tier === 'A' && caps.ext) {
+    caps.ext.multiDrawElementsWEBGL(mode, scratch.counts, 0, type, scratch.offsets, 0, drawCount)
+    return
+  }
+
+  for (let i = 0; i < drawCount; i++) {
+    gl.drawElements(mode, scratch.counts[i]!, type, scratch.offsets[i]!)
+  }
+}