mineflayer 3.10.0 → 3.12.0

package/lib/plugins/inventory.js

@@ -13,6 +13,13 @@ const DIG_CLICK_TIMEOUT = 500
 // The eat time comes from https://minecraft.fandom.com/wiki/Food#Usage
 const CONSUME_TIMEOUT = 2500
 
+const ALWAYS_CONSUMABLES = [
+  'potion',
+  'milk_bucket',
+  'enchanted_golden_apple',
+  'golden_apple'
+]
+
 function inject (bot, { version, hideErrors }) {
   const Item = require('prismarine-item')(version)
   const windows = require('prismarine-windows')(version)
@@ -20,7 +27,13 @@ function inject (bot, { version, hideErrors }) {
 
   let eatingTask = createDoneTask()
 
-  let nextActionNumber = 0
+  let nextActionNumber = 0 // < 1.17
+  let stateId = -1
+  if (bot.supportFeature('stateIdUsed')) {
+    const listener = packet => { stateId = packet.stateId }
+    bot._client.on('window_items', listener)
+    bot._client.on('set_slot', listener)
+  }
   const windowClickQueue = []
   let windowItems
 
@@ -30,11 +43,36 @@ function inject (bot, { version, hideErrors }) {
   bot.inventory = windows.createWindow(0, 'minecraft:inventory', 'Inventory')
   bot.currentWindow = null
   bot.heldItem = null
+  bot.usingHeldItem = false
 
   bot._client.on('entity_status', (packet) => {
     if (packet.entityId === bot.entity.id && packet.entityStatus === 9 && !eatingTask.done) {
       eatingTask.finish()
     }
+    bot.usingHeldItem = false
+  })
+
+  let previousHeldItem = null
+  bot.on('heldItemChanged', (heldItem) => {
+    // we only disable the item if the item type or count changes
+    if (
+      heldItem?.type === previousHeldItem?.type && heldItem?.count === previousHeldItem?.count
+    ) {
+      previousHeldItem = heldItem
+      return
+    }
+    if (!eatingTask.done) {
+      eatingTask.finish()
+    }
+    bot.usingHeldItem = false
+  })
+
+  bot._client.on('set_cooldown', (packet) => {
+    if (bot.heldItem && bot.heldItem.type !== packet.itemID) return
+    if (!eatingTask.done) {
+      eatingTask.finish()
+    }
+    bot.usingHeldItem = false
   })
 
   async function consume () {
@@ -42,7 +80,7 @@ function inject (bot, { version, hideErrors }) {
       eatingTask.cancel(new Error('Consuming cancelled due to calling bot.consume() again'))
     }
 
-    if (bot.food === 20) {
+    if (bot.game.gameMode !== 'creative' && !ALWAYS_CONSUMABLES.includes(bot.heldItem.name) && bot.food === 20) {
       throw new Error('Food is full')
     }
 
@@ -54,6 +92,7 @@ function inject (bot, { version, hideErrors }) {
   }
 
   function activateItem (offHand = false) {
+    bot.usingHeldItem = true
     if (bot.supportFeature('useItemWithBlockPlace')) {
       bot._client.write('block_place', {
         location: new Vec3(-1, 255, -1),
@@ -76,9 +115,10 @@ function inject (bot, { version, hideErrors }) {
       location: new Vec3(0, 0, 0),
       face: 5
     })
+    bot.usingHeldItem = false
   }
 
-  async function putSelectedItemRange (start, end, window, slot, noWaiting = false) {
+  async function putSelectedItemRange (start, end, window, slot) {
     // put the selected item back indow the slot range in window
 
     // try to put it in an item that already exists and just increase
@@ -88,11 +128,7 @@ function inject (bot, { version, hideErrors }) {
       const item = window.findItemRange(start, end, window.selectedItem.type, window.selectedItem.metadata, true, window.selectedItem.nbt)
 
       if (item && item.stackSize !== item.count) { // something to join with
-        if (noWaiting) {
-          await clickWindow(item.slot, 0, 0)
-        } else {
-          await Promise.all([clickWindow(item.slot, 0, 0), once(window, `updateSlot:${item.slot}`)])
-        }
+        await clickWindow(item.slot, 0, 0)
       } else { // nothing to join with
         const emptySlot = window.firstEmptySlotRange(start, end)
         if (emptySlot === null) { // no room left
@@ -103,11 +139,7 @@ function inject (bot, { version, hideErrors }) {
             await tossLeftover()
           }
         } else {
-          if (noWaiting) {
-            await Promise.all([clickWindow(emptySlot, 0, 0), once(window, `updateSlot:${emptySlot}`)])
-          } else {
-            await clickWindow(emptySlot, 0, 0)
-          }
+          await clickWindow(emptySlot, 0, 0)
         }
       }
     }
@@ -171,8 +203,9 @@ function inject (bot, { version, hideErrors }) {
     await bot.lookAt(entity.position.offset(0, 1, 0), false)
     bot._client.write('use_entity', {
       target: entity.id,
-      mouse: 0,
-      sneaking: false
+      mouse: 0, // interact with entity
+      sneaking: false,
+      hand: 0 // interact with the main hand
     })
   }
 
@@ -181,8 +214,9 @@ function inject (bot, { version, hideErrors }) {
     await bot.lookAt(position, false)
     bot._client.write('use_entity', {
       target: entity.id,
-      mouse: 2,
+      mouse: 2, // interact with entity at
       sneaking: false,
+      hand: 0, // interact with the main hand
       x: position.x - entity.position.x,
       y: position.y - entity.position.y,
       z: position.z - entity.position.z
@@ -333,20 +367,84 @@ function inject (bot, { version, hideErrors }) {
     bot._client.write('close_window', {
       windowId: window.id
     })
+    copyInventory(window)
     bot.currentWindow = null
     bot.emit('windowClose', window)
   }
 
+  function copyInventory (window) {
+    const slotOffset = window.inventoryStart - bot.inventory.inventoryStart
+    for (let i = window.inventoryStart; i < window.inventoryEnd; i++) {
+      const item = window.slots[i]
+      const slot = i - slotOffset
+      if (item) {
+        item.slot = slot
+      }
+      bot.inventory.slots[slot] = item
+    }
+  }
+
+  function tradeMatch (limitItem, targetItem) {
+    return targetItem.type === limitItem.type && targetItem.count >= limitItem.count
+  }
+
+  function expectTradeUpdate (window) {
+    const trade = window.selectedTrade
+    const hasItem = !!window.slots[2]
+
+    if (hasItem !== tradeMatch(trade.inputItem1, window.slots[0])) {
+      if (trade.hasItems2) {
+        return hasItem !== tradeMatch(trade.inputItem2, window.slots[1])
+      }
+      return true
+    }
+    return false
+  }
+
+  async function waitForWindowUpdate (window, slot) {
+    if (window.type === 'minecraft:inventory') {
+      if (slot >= 1 && slot <= 4) {
+        await once(bot.inventory, 'updateSlot:0')
+      }
+    } else if (window.type === 'minecraft:crafting') {
+      if (slot >= 1 && slot <= 9) {
+        await once(bot.currentWindow, 'updateSlot:0')
+      }
+    } else if (window.type === 'minecraft:merchant') {
+      const toUpdate = []
+      if (slot <= 2 && !window.selectedTrade.tradeDisabled && expectTradeUpdate(window)) {
+        toUpdate.push(once(bot.currentWindow, 'updateSlot:2'))
+      }
+      if (slot === 2) {
+        for (const item of bot.currentWindow.containerItems()) {
+          toUpdate.push(once(bot.currentWindow, `updateSlot:${item.slot}`))
+        }
+      }
+      await Promise.all(toUpdate)
+    }
+  }
+
   function confirmTransaction (windowId, actionId, accepted) {
     // drop the queue entries for all the clicks that the server did not send
     // transaction packets for.
-    let click = windowClickQueue.shift()
-    if (click === undefined) {
+    // Also reject transactions that aren't sent from mineflayer
+    let click = windowClickQueue[0]
+    if (click === undefined || !windowClickQueue.some(clicks => clicks.id === actionId)) {
+      // mimic vanilla client and send a rejection for faulty transaction packets
+      bot._client.write('transaction', {
+        windowId: windowId,
+        action: actionId,
+        accepted: true
+        // bot.emit(`confirmTransaction${click.id}`, false)
+      })
       if (!hideErrors) {
         console.log(`WARNING : unknown transaction confirmation for window ${windowId}, action ${actionId} and accepted ${accepted}`)
       }
       return
     }
+    // shift it later if packets are sent out of order
+    click = windowClickQueue.shift()
+
     assert.ok(click.id <= actionId)
     while (actionId > click.id) {
       onAccepted()
@@ -401,37 +499,66 @@ function inject (bot, { version, hideErrors }) {
       windowId: window.id,
       item: slot === -999 ? null : window.slots[slot]
     }
-    windowClickQueue.push(click)
-    bot._client.write('window_click', {
-      windowId: window.id,
-      slot,
-      mouseButton,
-      action: actionId,
-      mode,
-      item: Item.toNotch(click.item)
-    })
 
-    const response = once(bot, `confirmTransaction${actionId}`)
+    let changedSlots
+    if (bot.supportFeature('transactionPacketExists')) {
+      windowClickQueue.push(click)
+    } else {
+      changedSlots = window.acceptClick(click)
+    }
 
-    // notchian servers are assholes and only confirm certain transactions.
-    if (!window.transactionRequiresConfirmation(click)) {
-      // jump the gun and accept the click
-      confirmTransaction(window.id, actionId, true)
+    // WHEN ADDING SUPPORT FOR OTHER CLICKS, MAKE SURE TO CHANGE changedSlots TO SUPPORT THEM
+    if (bot.supportFeature('stateIdUsed')) { // 1.17.1 +
+      bot._client.write('window_click', {
+        windowId: window.id,
+        stateId,
+        slot,
+        mouseButton,
+        mode,
+        changedSlots: changedSlots,
+        cursorItem: Item.toNotch(window.selectedItem)
+      })
+    } else if (bot.supportFeature('actionIdUsed')) { // <= 1.16.5
+      bot._client.write('window_click', {
+        windowId: window.id,
+        slot,
+        mouseButton,
+        action: actionId,
+        mode,
+        item: Item.toNotch(click.item)
+      })
+    } else { // 1.17
+      bot._client.write('window_click', {
+        windowId: window.id,
+        slot,
+        mouseButton,
+        mode,
+        changedSlots: changedSlots,
+        cursorItem: Item.toNotch(window.selectedItem)
+      })
     }
 
-    const [success] = await response
-    if (!success) {
-      throw new Error(`Server rejected transaction for clicking on slot ${slot}, on window ${JSON.stringify(window.slots, null, 2)}.`)
+    if (bot.supportFeature('transactionPacketExists')) {
+      const response = once(bot, `confirmTransaction${actionId}`)
+      if (!window.transactionRequiresConfirmation(click)) {
+        confirmTransaction(window.id, actionId, true)
+      }
+      const [success] = await response
+      if (!success) {
+        throw new Error(`Server rejected transaction for clicking on slot ${slot}, on window with id ${window?.id}.`)
+      }
+    } else {
+      await waitForWindowUpdate(window, slot)
     }
   }
 
-  async function putAway (slot, noWaiting = false) {
+  async function putAway (slot) {
     const window = bot.currentWindow || bot.inventory
     const promisePutAway = once(window, `updateSlot:${slot}`)
     await clickWindow(slot, 0, 0)
     const start = window.inventoryStart
     const end = window.inventoryEnd
-    await putSelectedItemRange(start, end, window, null, noWaiting)
+    await putSelectedItemRange(start, end, window, null)
     await promisePutAway
   }
 
@@ -448,9 +575,6 @@ function inject (bot, { version, hideErrors }) {
 
   bot._client.on('transaction', (packet) => {
     // confirm transaction
-    if (packet.action < 0) {
-      return
-    }
     confirmTransaction(packet.windowId, packet.action, packet.accepted)
   })
 

package/lib/plugins/physics.js

@@ -1,4 +1,4 @@
-const Vec3 = require('vec3').Vec3
+const { Vec3 } = require('vec3')
 const assert = require('assert')
 const math = require('../math')
 const conv = require('../conversions')
@@ -33,6 +33,7 @@ function inject (bot, { physicsEnabled }) {
     sneak: false
   }
   let lastSentYaw = null
+  let lastSentPitch = null
   let doPhysicsTimer = null
   let lastPhysicsFrameTime = null
   let shouldUsePhysics = false
@@ -122,13 +123,16 @@ function inject (bot, { physicsEnabled }) {
 
     // Increment the yaw in baby steps so that notchian clients (not the server) can keep up.
     const dYaw = deltaYaw(bot.entity.yaw, lastSentYaw)
+    const dPitch = bot.entity.pitch - (lastSentPitch || 0)
 
     // Vanilla doesn't clamp yaw, so we don't want to do it either
     const maxDeltaYaw = dt * physics.yawSpeed
+    const maxDeltaPitch = dt * physics.pitchSpeed
     lastSentYaw += math.clamp(-maxDeltaYaw, dYaw, maxDeltaYaw)
+    lastSentPitch += math.clamp(-maxDeltaPitch, dPitch, maxDeltaPitch)
 
-    const yaw = conv.toNotchianYaw(lastSentYaw)
-    const pitch = conv.toNotchianPitch(bot.entity.pitch)
+    const yaw = Math.fround(conv.toNotchianYaw(lastSentYaw))
+    const pitch = Math.fround(conv.toNotchianPitch(lastSentPitch))
     const position = bot.entity.position
     const onGround = bot.entity.onGround
 
@@ -225,8 +229,15 @@ function inject (bot, { physicsEnabled }) {
     }
     lookingTask = createTask()
 
-    bot.entity.yaw = yaw
-    bot.entity.pitch = pitch
+    // this is done to bypass certain anticheat checks that detect the player's sensitivity
+    // by calculating the gcd of how much they move the mouse each tick
+    const sensitivity = conv.fromNotchianPitch(0.15) // this is equal to 100% sensitivity in vanilla
+    const yawChange = Math.round((yaw - bot.entity.yaw) / sensitivity) * sensitivity
+    const pitchChange = Math.round((pitch - bot.entity.pitch) / sensitivity) * sensitivity
+
+    bot.entity.yaw += yawChange
+    bot.entity.pitch += pitchChange
+
     if (force) {
       lastSentYaw = yaw
       return

package/lib/plugins/place_block.js

@@ -4,13 +4,14 @@ module.exports = inject
 
 function inject (bot) {
   async function placeBlockWithOptions (referenceBlock, faceVector, options) {
-    bot.swingArm()
-    const pos = await bot._genericPlace(referenceBlock, faceVector, options)
+    const dest = referenceBlock.position.plus(faceVector)
+    let oldBlock = bot.blockAt(dest)
+    await bot._genericPlace(referenceBlock, faceVector, options)
 
-    const dest = pos.plus(faceVector)
-    const eventName = `blockUpdate:${dest}`
-
-    const [oldBlock, newBlock] = await onceWithCleanup(bot, eventName, { timeout: 5000 })
+    let newBlock = bot.blockAt(dest)
+    if (oldBlock.type === newBlock.type) {
+      [oldBlock, newBlock] = await onceWithCleanup(bot, `blockUpdate:${dest}`, { timeout: 5000 })
+    }
 
     if (oldBlock.type === newBlock.type) {
       throw new Error(`No block has been placed : the block is still ${oldBlock.name}`)

package/lib/plugins/ray_trace.js

@@ -23,4 +23,14 @@ module.exports = (bot) => {
 
     return bot.world.raycast(eyePosition, viewDirection, maxDistance, matcher)
   }
+
+  bot.blockAtEntityCursor = (entity = bot.entity, maxDistance = 256, matcher = null) => {
+    if (!entity.position || !entity.height || !entity.pitch || !entity.yaw) return null
+    const { position, height, pitch, yaw } = entity
+
+    const eyePosition = position.offset(0, height, 0)
+    const viewDirection = getViewDirection(pitch, yaw)
+
+    return bot.world.raycast(eyePosition, viewDirection, maxDistance, matcher)
+  }
 }

package/lib/plugins/simple_inventory.js

@@ -91,7 +91,7 @@ function inject (bot) {
       item = bot.inventory.findInventoryItem(item)
     }
     if (item == null || typeof item !== 'object') {
-      throw new Error('Invalid item object in equip')
+      throw new Error('Invalid item object in equip (item is null or typeof item is not object)')
     }
     if (!destination || destination === null) {
       destination = 'hand'

package/lib/plugins/sound.js

@@ -1,4 +1,4 @@
-const Vec3 = require('vec3').Vec3
+const { Vec3 } = require('vec3')
 
 module.exports = inject
 

package/lib/plugins/spawn_point.js

@@ -1,4 +1,4 @@
-const Vec3 = require('vec3').Vec3
+const { Vec3 } = require('vec3')
 
 module.exports = inject
 

package/lib/plugins/villager.js

@@ -83,6 +83,7 @@ function inject (bot, { version }) {
     }
 
     villager.trades = null
+    villager.selectedTrade = null
 
     villager.once('close', () => {
       bot._client.removeListener(tradeListPacket, gotTrades)
@@ -117,7 +118,6 @@ function inject (bot, { version }) {
       if (!ready) {
         ready = true
         villager.emit('ready')
-        console.log('emit ready')
       }
     }
   }
@@ -127,6 +127,7 @@ function inject (bot, { version }) {
     assert.notStrictEqual(villager.trades, null)
     assert.notStrictEqual(villager.trades[choice], null)
     const Trade = villager.trades[choice]
+    villager.selectedTrade = Trade
     count = count || Trade.maximumNbTradeUses - Trade.nbTradeUses
     assert.ok(Trade.maximumNbTradeUses - Trade.nbTradeUses > 0, 'trade blocked')
     assert.ok(Trade.maximumNbTradeUses - Trade.nbTradeUses >= count)
@@ -134,8 +135,9 @@ function inject (bot, { version }) {
     const itemCount1 = villager.count(Trade.inputItem1.type, Trade.inputItem1.metadata)
     const hasEnoughItem1 = itemCount1 >= Trade.realPrice * count
     let hasEnoughItem2 = true
+    let itemCount2 = 0
     if (Trade.hasItem2) {
-      const itemCount2 = villager.count(Trade.inputItem2.type, Trade.inputItem2.metadata)
+      itemCount2 = villager.count(Trade.inputItem2.type, Trade.inputItem2.metadata)
       hasEnoughItem2 = itemCount2 >= Trade.inputItem2.count * count
     }
     if (!hasEnoughItem1 || !hasEnoughItem2) {
@@ -143,60 +145,73 @@ function inject (bot, { version }) {
     }
 
     selectTrade(choice)
-
     if (bot.supportFeature('selectingTradeMovesItems')) { // 1.14+ the server moves items around by itself after selecting a trade
-      await new Promise((resolve, reject) => {
-        const updatedSlots = {}
-        function cb (slot) {
-          updatedSlots[slot] = true
-          if (updatedSlots[0] && updatedSlots[2] && (!Trade.hasItem2 || updatedSlots[1])) {
-            clearTimeout(timeout)
-            villager.removeListener('updateSlot', cb)
-            resolve()
+      const proms = []
+      proms.push(once(villager, 'updateSlot:0'))
+      if (Trade.hasItem2) proms.push(once(villager, 'updateSlot:1'))
+      if (bot.supportFeature('setSlotAsTransaction')) {
+        proms.push(once(villager, 'updateSlot:2'))
+        await new Promise((resolve, reject) => {
+          let countOfItemOneLeftToTake = itemCount1 > 64 ? 64 : itemCount1
+          let countOfItemTwoLeftToTake = 0
+          if (Trade.hasItem2) {
+            countOfItemTwoLeftToTake = itemCount2 > 64 ? 64 : itemCount2
           }
-        }
-        villager.on('updateSlot', cb)
-        const timeout = setTimeout(() => {
-          clearTimeout(timeout)
-          villager.removeListener('updateSlot', cb)
-          reject(new Error('Timed out waiting for window updates'))
-        }, 30000)
-      })
+          const listener = (slot, oldItem, newItem) => {
+            if (!(slot >= villager.inventoryStart && slot <= villager.inventoryEnd)) return
+            if (newItem === null) {
+              if (oldItem.type === Trade.inputItem1.type) countOfItemOneLeftToTake -= oldItem.count
+              else if (Trade.hasItem2 && oldItem.type === Trade.inputItem2.type) countOfItemTwoLeftToTake -= oldItem.count
+            }
+            if (countOfItemOneLeftToTake === 0 && countOfItemTwoLeftToTake === 0) {
+              villager.off('updateSlot', listener)
+              resolve()
+            }
+          }
+          villager.on('updateSlot', listener)
+        })
+      }
+      await Promise.all(proms)
     }
+
     for (let i = 0; i < count; i++) {
       await putRequirements(villager, Trade, count)
-      villager.updateSlot(2, Object.assign({}, Trade.outputItem))
-      await bot.putAway(2, true)
-      const [slot1, slot2] = villager.slots
-      if (slot1) {
-        assert.strictEqual(slot1.type, Trade.inputItem1.type)
-        const updatedCount1 = slot1.count - Trade.realPrice
-        const updatedSlot1 = updatedCount1 <= 0
-          ? null
-          : { ...slot1, count: updatedCount1 }
-        villager.updateSlot(0, updatedSlot1)
+      // ToDo: See if this does anything kappa
+      Trade.nbTradeUses++
+      if (Trade.maximumNbTradeUses - Trade.nbTradeUses === 0) {
+        Trade.tradeDisabled = true
       }
+      if (!bot.supportFeature('setSlotAsTransaction')) {
+        villager.updateSlot(2, Object.assign({}, Trade.outputItem))
+
+        const [slot1, slot2] = villager.slots
+        if (slot1) {
+          assert.strictEqual(slot1.type, Trade.inputItem1.type)
+          const updatedCount1 = slot1.count - Trade.realPrice
+          const updatedSlot1 = updatedCount1 <= 0
+            ? null
+            : { ...slot1, count: updatedCount1 }
+          villager.updateSlot(0, updatedSlot1)
+        }
 
-      if (slot2) {
-        assert.strictEqual(slot2.type, Trade.inputItem2.type)
-        const updatedCount2 = slot2.count - Trade.inputItem2.count
-        const updatedSlot2 = updatedCount2 <= 0
-          ? null
-          : { ...slot2, count: updatedCount2 }
-        villager.updateSlot(1, updatedSlot2)
+        if (slot2) {
+          assert.strictEqual(slot2.type, Trade.inputItem2.type)
+          const updatedCount2 = slot2.count - Trade.inputItem2.count
+          const updatedSlot2 = updatedCount2 <= 0
+            ? null
+            : { ...slot2, count: updatedCount2 }
+          villager.updateSlot(1, updatedSlot2)
+        }
       }
-      Trade.nbTradeUses++
+
+      await bot.putAway(2)
     }
 
     for (const i of [0, 1]) {
       if (villager.slots[i]) {
-        await bot.putAway(i, true) // 1.14+ whole stacks of items will automatically be placed , so there might be some left over
+        await bot.putAway(i) // 1.14+ whole stacks of items will automatically be placed , so there might be some left over
       }
     }
-
-    if (Trade.maximumNbTradeUses - Trade.nbTradeUses === 0) {
-      Trade.tradeDisabled = true
-    }
   }
 
   async function putRequirements (window, Trade, count) {

package/lib/version.js

@@ -1,4 +1,4 @@
 module.exports = {
-  supportedVersions: ['1.8', '1.9', '1.10', '1.11', '1.12', '1.13', '1.14', '1.15', '1.16'],
-  testedVersions: ['1.8.8', '1.9.4', '1.10.2', '1.11.2', '1.12.2', '1.13.2', '1.14.4', '1.15.2', '1.16.5']
-}
+  supportedVersions: ['1.8', '1.9', '1.10', '1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17'],
+  testedVersions: ['1.8.8', '1.9.4', '1.10.2', '1.11.2', '1.12.2', '1.13.2', '1.14.4', '1.15.2', '1.16.5', '1.17.1']
+} // when updating testedVersions, make sure to update CI.yml

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mineflayer",
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "create minecraft bots with a stable, high level API",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,31 +21,32 @@
   },
   "license": "MIT",
   "dependencies": {
-    "minecraft-data": "^2.79.0",
-    "minecraft-protocol": "^1.17.0",
-    "prismarine-biome": "^1.1.0",
-    "prismarine-block": "^1.6.0",
-    "prismarine-chat": "^1.1.0",
-    "prismarine-chunk": "^1.20.3",
-    "prismarine-entity": "^1.0.0",
-    "prismarine-item": "^1.6.0",
-    "prismarine-physics": "^1.0.4",
+    "minecraft-data": "^2.95.0",
+    "minecraft-protocol": "^1.26.5",
+    "prismarine-biome": "^1.1.1",
+    "prismarine-block": "^1.10.3",
+    "prismarine-chat": "^1.3.3",
+    "prismarine-chunk": "^1.26.0",
+    "prismarine-entity": "^1.2.0",
+    "prismarine-item": "^1.11.0",
+    "prismarine-nbt": "^2.0.0",
+    "prismarine-physics": "^1.3.1",
     "prismarine-recipe": "^1.1.0",
-    "prismarine-windows": "^2.2.0",
+    "prismarine-windows": "^2.4.2",
     "prismarine-world": "^3.6.0",
-    "protodef": "^1.8.0",
-    "typed-emitter": "^1.2.0",
-    "vec3": "^0.1.6"
+    "protodef": "^1.14.0",
+    "typed-emitter": "^1.3.1",
+    "vec3": "^0.1.7"
   },
   "devDependencies": {
-    "@types/node": "^16.0.1",
-    "doctoc": "^2.0.0",
-    "minecraft-wrap": "^1.2.1",
+    "@types/node": "^17.0.0",
+    "doctoc": "^2.0.1",
+    "minecraft-wrap": "^1.3.0",
     "mineflayer": "file:.",
-    "mocha": "^9.0.0",
-    "standard": "^16.0.1",
-    "ts-standard": "^10.0.0",
-    "typescript": "^4.3.2",
-    "standard-markdown": "^6.0.0"
+    "mocha": "^9.1.2",
+    "standard": "^16.0.4",
+    "standard-markdown": "^7.1.0",
+    "ts-standard": "^11.0.0",
+    "typescript": "^4.4.3"
   }
 }