chore(deps): upgrade Biome

Author: Conaclos

biome.json

@@ -1,55 +1,57 @@
 {
-  "$schema": "https://next.biomejs.dev/schemas/2.2.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.4/schema.json",
   "root": true,
   "files": {
     "ignoreUnknown": true
   },
   "formatter": {
-    "includes": [
-      "**",
-      "!tests-corpus/**"
-    ],
     "indentStyle": "space",
     "indentWidth": 4
   },
   "linter": {
     "domains": {
       "project": "recommended",
-      "test": "recommended"
+      "test": "recommended",
+      "types": "recommended"
     },
     "rules": {
       "complexity": {
         "noImplicitCoercions": "on",
-        "noUselessLoneBlockStatements": "off",
-        "noVoid": "on"
+        "noUselessCatchBinding": "on",
+        "noUselessLoneBlockStatements": "on",
+        "noUselessUndefined": "on",
+        "noVoid": "on",
+        "useWhile": "on"
       },
       "nursery": {
-        "noDeprecatedImports": "on",
-        "noDuplicateDependencies": "on",
-        "noImportCycles": "on",
-        "noUselessUndefined": "off",
-        "useExhaustiveSwitchCases": "off",
+        "useExhaustiveSwitchCases": "on",
         "useExplicitType": "off"
       },
       "performance": {
         "noDelete": "on"
       },
       "style": {
         "noDefaultExport": "on",
+        "noExportedImports": "on",
         "noImplicitBoolean": "on",
         "noInferrableTypes": "on",
         "noNamespace": "on",
         "noNegationElse": "on",
         "noParameterAssign": "on",
         "noParameterProperties": "on",
+        "noSubstr": "on",
         "noUnusedTemplateLiteral": "on",
         "noUselessElse": "on",
         "noYodaExpression": "on",
         "useAsConstAssertion": "on",
         "useBlockStatements": "on",
         "useCollapsedElseIf": "on",
+        "useCollapsedIf": "on",
         "useConsistentArrayType": "on",
+        "useConsistentArrowReturn": "on",
         "useConsistentBuiltinInstantiation": "on",
+        "useConsistentMemberAccessibility": "on",
+        "useConsistentObjectDefinitions": "on",
         "useConst": "on",
         "useDefaultParameterLast": "on",
         "useEnumInitializers": "on",
@@ -93,12 +95,13 @@
         },
         "useNodeAssertStrict": "on",
         "useNumberNamespace": "on",
-        "useNumericSeparators": "off",
+        "useNumericSeparators": "on",
         "useReadonlyClassProperties": "on",
         "useShorthandAssign": "on",
         "useSingleVarDeclarator": "on",
         "useThrowNewError": "on",
         "useThrowOnlyError": "on",
+        "useTrimStartEnd": "on",
         "useUnifiedTypeSignatures": "on"
       },
       "suspicious": {
@@ -113,18 +116,18 @@
           }
         },
         "noConstantBinaryExpressions": "on",
+        "noDeprecatedImports": "on",
+        "noDuplicateDependencies": "on",
         "noEmptyBlockStatements": "on",
         "noEvolvingTypes": "on",
         "noExportsInTest": "on",
+        "noImportCycles": "on",
         "noUnassignedVariables": "on",
+        "noUnusedExpressions": "on",
         "noUselessEscapeInString": "on",
         "noVar": "on",
         "useErrorMessage": "on",
         "useNumberToFixedDigitsArgument": "on"
-      },
-      "correctness": {
-        "noInvalidUseBeforeDeclaration": "off",
-        "useJsonImportAttributes": "on"
       }
     }
   },

package-lock.json

@@ -70,7 +70,7 @@
     "version": "sh ./scripts/version.sh"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.12",
+    "@biomejs/biome": "2.4.4",
     "@types/node": "22.18.13",
     "esbuild": "0.27.2",
     "typescript": "5.9.3"

package.json

@@ -258,7 +258,7 @@ test("writeI16", () => {
 
 test("readI32", () => {
     const bc = fromBytes(0xb2, 0x9e, 0x43, 0xff)
-    assert.deepEqual(readI32(bc), -12345678)
+    assert.deepEqual(readI32(bc), -12_345_678)
     assert.throws(
         () => readI32(bc),
         { name: "BareError", issue: "missing bytes", offset: 4 },
@@ -269,7 +269,7 @@ test("readI32", () => {
 test("writeI32", () => {
     {
         const bc = fromBytes()
-        writeI32(bc, -12345678)
+        writeI32(bc, -12_345_678)
         assert.deepEqual(toBytes(bc), [0xb2, 0x9e, 0x43, 0xff])
     }
 
@@ -304,7 +304,10 @@ test("writeI32", () => {
     }
 })
 
-const BIG_NEG_INT = -(BigInt(12345678) * BigInt(10 ** 9) + BigInt(987654321))
+const BIG_NEG_INT = -(
+    BigInt(12_345_678) * BigInt(10 ** 9) +
+    BigInt(987_654_321)
+)
 
 test("readI64", () => {
     const bc = fromBytes(0x4f, 0x0b, 0x6e, 0x9d, 0xab, 0x23, 0xd4, 0xff)
@@ -495,7 +498,7 @@ test("writeU8", () => {
 
     {
         const bc = fromBytes()
-        const action = () => writeU8(bc, 0x100)
+        const action = () => writeU8(bc, 0x1_00)
         if (DEV) {
             assert.throws(
                 action,
@@ -511,7 +514,7 @@ test("writeU8", () => {
 
 test("readU16", () => {
     const bc = fromBytes(0xfe, 0xca)
-    assert.deepEqual(readU16(bc), 0xcafe)
+    assert.deepEqual(readU16(bc), 0xca_fe)
     assert.throws(
         () => readU16(bc),
         { name: "BareError", issue: "missing bytes", offset: 2 },
@@ -522,13 +525,13 @@ test("readU16", () => {
 test("writeU16", () => {
     {
         const bc = fromBytes()
-        writeU16(bc, 0xcafe)
+        writeU16(bc, 0xca_fe)
         assert.deepEqual(toBytes(bc), [0xfe, 0xca])
     }
 
     {
         const bc = fromBytes()
-        const action = () => writeU16(bc, 0x10000)
+        const action = () => writeU16(bc, 0x1_00_00)
         if (DEV) {
             assert.throws(
                 action,
@@ -544,7 +547,7 @@ test("writeU16", () => {
 
 test("readU32", () => {
     const bc = fromBytes(0xef, 0xbe, 0xad, 0xde)
-    assert.deepEqual(readU32(bc), 0xdeadbeef)
+    assert.deepEqual(readU32(bc), 0xde_ad_be_ef)
     assert.throws(
         () => readU32(bc),
         { name: "BareError", issue: "missing bytes", offset: 4 },
@@ -555,7 +558,7 @@ test("readU32", () => {
 test("writeU32", () => {
     {
         const bc = fromBytes()
-        writeU32(bc, 0xdeadbeef)
+        writeU32(bc, 0xde_ad_be_ef)
         assert.deepEqual(toBytes(bc), [0xef, 0xbe, 0xad, 0xde])
     }
 
@@ -576,7 +579,7 @@ test("writeU32", () => {
 })
 
 const CAFE_BABE_DEAD_BEEF =
-    (BigInt(0xcafe_babe) << BigInt(32)) + BigInt(0xdead_beef)
+    (BigInt(0xca_fe_ba_be) << BigInt(32)) + BigInt(0xde_ad_be_ef)
 
 test("readU64", () => {
     const bc = fromBytes(0xef, 0xbe, 0xad, 0xde, 0xbe, 0xba, 0xfe, 0xca)
@@ -648,7 +651,7 @@ test("writeU64Safe", () => {
     {
         const bc = fromBytes()
         // biome-ignore lint/correctness/noPrecisionLoss: the lost of precision is intended
-        const action = () => writeU64Safe(bc, 0xcafe_babe_dead_beef)
+        const action = () => writeU64Safe(bc, 0xca_fe_ba_be_de_ad_be_ef)
         if (DEV) {
             assert.throws(
                 action,

src/codec/fixed-primitive.test.ts

@@ -143,9 +143,9 @@ export function writeI64Safe(bc: ByteCursor, x: number): void {
     let highest32 = (x / /* 2**32 */ 0x1_00_00_00_00) | 0
     if (x < 0) {
         // get two's complement representation of the highest 21bits
-        highest32 = ~(Math.abs(highest32) & /* 2**21-1 */ 0x1f_ffff) >>> 0
+        highest32 = ~(Math.abs(highest32) & /* 2**21-1 */ 0x1f_ff_ff) >>> 0
         if (lowest32 === 0) {
-            if (highest32 === 0x1f_ffff) {
+            if (highest32 === 0x1f_ff_ff) {
                 // maps -2**53 to Number.MIN_SAFE_INTEGER
                 // this is useful when assertions are skipped
                 lowest32 = 1
@@ -232,5 +232,5 @@ export function writeU64Safe(bc: ByteCursor, x: number): void {
         assert(isU64Safe(x), TOO_LARGE_NUMBER)
     }
     writeU32(bc, x >>> 0)
-    writeU32(bc, (x / /* 2**32 */ 0x1_00_00_00_00) & /* 2**21-1 */ 0x1f_ffff)
+    writeU32(bc, (x / /* 2**32 */ 0x1_00_00_00_00) & /* 2**21-1 */ 0x1f_ff_ff)
 }

src/codec/fixed-primitive.ts

@@ -66,9 +66,9 @@ export function writeIntSafe(bc: ByteCursor, x: number): void {
         }
         // keep only the remaining 53 - 6 = 47 bits
         // this is useful when assertions are skipped
-        const low = zigZag & 0x7fff
-        const high = ((zigZag / 0x8000) >>> 0) * 0x8000
-        if (first7Bits === 0x7f && low === 0x7fff && high === 0xffff_ffff) {
+        const low = zigZag & 0x7f_ff
+        const high = ((zigZag / 0x80_00) >>> 0) * 0x80_00
+        if (first7Bits === 0x7f && low === 0x7f_ff && high === 0xff_ff_ff_ff) {
             // maps -2**53 to Number.MIN_SAFE_INTEGER
             // this is useful when assertions are skipped
             first7Bits &= ~0b10