switch to signed-first approach

It turns out signed math is more performant

src/commonTest/kotlin/com/infendro/bytes/bytearray/Operators.kt

@@ -0,0 +1,65 @@
+package com.infendro.bytes.bytearray
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertFails
+
+class ByteArrayOperatorsTest {
+    @Test
+    fun inv() {
+        val expected = ubyteArrayOf(0xFFU, 0xE0U).asByteArray()
+        val actual = byteArrayOf(0x00, 0x1F).inv()
+        assertContentEquals(expected, actual)
+    }
+
+    @Test
+    fun andSize() {
+        assertFails {
+            byteArrayOf() and byteArrayOf(0x00)
+        }
+        assertFails {
+            byteArrayOf(0x00) and byteArrayOf()
+        }
+    }
+
+    @Test
+    fun and() {
+        val expected = byteArrayOf(0x18, 0x00)
+        val actual = byteArrayOf(0x5C, 0x70) and byteArrayOf(0x3A, 0x0F)
+        assertContentEquals(expected, actual)
+    }
+
+    @Test
+    fun orSize() {
+        assertFails {
+            byteArrayOf() or byteArrayOf(0x00)
+        }
+        assertFails {
+            byteArrayOf(0x00) or byteArrayOf()
+        }
+    }
+
+    @Test
+    fun or() {
+        val expected = byteArrayOf(0x7E, 0x7F)
+        val actual = byteArrayOf(0x5C, 0x70) or byteArrayOf(0x3A, 0x0F)
+        assertContentEquals(expected, actual)
+    }
+
+    @Test
+    fun xorSize() {
+        assertFails {
+            byteArrayOf() xor byteArrayOf(0x00)
+        }
+        assertFails {
+            byteArrayOf(0x00) xor byteArrayOf()
+        }
+    }
+
+    @Test
+    fun xor() {
+        val expected = byteArrayOf(0x66, 0x7F)
+        val actual = byteArrayOf(0x5C, 0x70) xor byteArrayOf(0x3A, 0x0F)
+        assertContentEquals(expected, actual)
+    }
+}