@axpecter/lync 1.4.3 → 1.5.0

package/src/codec/meta/Enum.luau

@@ -2,80 +2,80 @@
 --!native
 -- String enum codec. Maps values to u8 indices at definition time.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local EnumCodec = {}
 
-function EnumCodec.define (...: string): Codec<string>
+function EnumCodec.define(...: string): Codec<string>
     local values = { ... }
     local count = #values
     if count == 0 then
-        error ("[Lync] Enum requires at least one value")
+        error("[Lync] Enum requires at least one value")
     end
     if count > 256 then
-        error (`[Lync] Enum exceeds 256 values: {count}`)
+        error(`[Lync] Enum exceeds 256 values: {count}`)
     end
 
     local toIndex = {} :: { [string]: number }
-    local toValue = table.create (count) :: { string }
+    local toValue = table.create(count) :: { string }
 
     for i, value in values do
         if toIndex[value] ~= nil then
-            error (`[Lync] Duplicate enum value: "{value}"`)
+            error(`[Lync] Duplicate enum value: "{value}"`)
         end
         toIndex[value] = i - 1
         toValue[i] = value
     end
 
-    table.freeze (toIndex)
-    table.freeze (toValue)
+    table.freeze(toIndex)
+    table.freeze(toValue)
 
-    return table.freeze ({
+    return table.freeze({
         _size = 1,
-        _directWrite = function (b: buffer, offset: number, value: string): ()
+        _directWrite = function(b: buffer, offset: number, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: "{value}"`)
+                error(`[Lync] Invalid enum value: "{value}"`)
             end
-            buffer.writeu8 (b, offset, idx)
+            buffer.writeu8(b, offset, idx)
         end,
-        _directRead = function (b: buffer, offset: number): string
-            local idx = buffer.readu8 (b, offset)
+        _directRead = function(b: buffer, offset: number): string
+            local idx = buffer.readu8(b, offset)
             local value = toValue[idx + 1]
             if value == nil then
-                error (`[Lync] Invalid enum index: {idx}`)
+                error(`[Lync] Invalid enum index: {idx}`)
             end
             return value
         end,
-        write = function (ch: ChannelState, value: string): ()
+        write = function(ch: ChannelState, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: "{value}"`)
+                error(`[Lync] Invalid enum value: "{value}"`)
             end
             local c = ch.cursor
             if c + 1 > ch.size then
-                alloc (ch, 1)
+                alloc(ch, 1)
             end
-            buffer.writeu8 (ch.buff, c, idx)
+            buffer.writeu8(ch.buff, c, idx)
             ch.cursor = c + 1
         end,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (string, number)
-            local idx = buffer.readu8 (src, pos)
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+            local idx = buffer.readu8(src, pos)
             local value = toValue[idx + 1]
             if value == nil then
-                error (`[Lync] Invalid enum index: {idx}`)
+                error(`[Lync] Invalid enum index: {idx}`)
             end
             return value, 1
         end,
     })
 end
 
-return table.freeze (EnumCodec)
+return table.freeze(EnumCodec)

package/src/codec/meta/Nothing.luau

@@ -2,8 +2,8 @@
 --!native
 -- Zero-byte codec. Reads nil. Good for fire-and-forget signals.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    nothing = Base.zero (),
+return table.freeze({
+    nothing = Base.zero(),
 })

package/src/codec/meta/Quantized.luau

@@ -2,15 +2,15 @@
 --!native
 -- Fixed-point compression. Maps float ranges to integer ranges.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
 local alloc = Channel.alloc
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local clamp = math.clamp
 local round = math.round
@@ -20,9 +20,9 @@ local max = math.max
 
 local U32_MAX = 4294967295
 
--- Private ------------------------------------------------------------
+-- Private -------------------------------------------------------------
 
-local function selectIO (bytes: number): ((b: buffer, offset: number, v: number) -> (), (
+local function selectIO(bytes: number): ((b: buffer, offset: number, v: number) -> (), (
     b: buffer,
     offset: number
 ) -> number)
@@ -35,7 +35,7 @@ local function selectIO (bytes: number): ((b: buffer, offset: number, v: number)
     return buffer.writeu32, buffer.readu32
 end
 
-local function selectWidth (maxInt: number): number
+local function selectWidth(maxInt: number): number
     if maxInt <= 255 then
         return 1
     end
@@ -45,17 +45,21 @@ local function selectWidth (maxInt: number): number
     return 4
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Quantized = {}
 
 -- Shared validation and precomputation for both float and vec3 quantizers.
-local function setup (minVal: number, maxVal: number, precision: number)
+local function setup(
+    minVal: number,
+    maxVal: number,
+    precision: number
+): (number?, number?, number?, any?, any?, number?, number?)
     if minVal > maxVal then
-        error (`[Lync] Quantized min > max: {minVal} > {maxVal}`)
+        error(`[Lync] Quantized min > max: {minVal} > {maxVal}`)
     end
     if precision <= 0 then
-        error (`[Lync] Quantized precision must be positive: {precision}`)
+        error(`[Lync] Quantized precision must be positive: {precision}`)
     end
 
     local delta = maxVal - minVal
@@ -63,66 +67,65 @@ local function setup (minVal: number, maxVal: number, precision: number)
         return nil
     end
 
-    local maxInt = min (U32_MAX, max (1, ceil (delta / precision)))
-    local bytes = selectWidth (maxInt)
-    local wfn, rfn = selectIO (bytes)
+    local maxInt = min(U32_MAX, max(1, ceil(delta / precision)))
+    local bytes = selectWidth(maxInt)
+    local wfn, rfn = selectIO(bytes)
     local invDelta = 1 / delta
     local invMaxInt = delta / maxInt
 
     return delta, maxInt, bytes, wfn, rfn, invDelta, invMaxInt
 end
 
-function Quantized.float (minVal: number, maxVal: number, precision: number): Codec<number>
-    local delta, maxInt, bytes, wfn, rfn, invDelta, invMaxInt = setup (minVal, maxVal, precision)
+function Quantized.float(minVal: number, maxVal: number, precision: number): Codec<number>
+    local delta, maxInt, bytes, wfn, rfn, invDelta, invMaxInt = setup(minVal, maxVal, precision)
     if not delta then
-        return table.freeze ({
+        return table.freeze({
             _size = 0,
-            _directWrite = function (_b: buffer, _offset: number, _value: number): () end,
-            _directRead = function (_b: buffer, _offset: number): number
+            _directWrite = function(_b: buffer, _offset: number, _value: number): () end,
+            _directRead = function(_b: buffer, _offset: number): number
                 return minVal
             end,
-            write = function (_ch: ChannelState, _value: number): () end,
-            read = function (_src: buffer, _pos: number, _refs: { Instance }?): (number, number)
+            write = function(_ch: ChannelState, _value: number): () end,
+            read = function(_src: buffer, _pos: number, _refs: { Instance }?): (number, number)
                 return minVal, 0
             end,
         })
     end
 
-    return table.freeze ({
+    return table.freeze({
         _size = bytes,
-        _directWrite = function (b: buffer, offset: number, value: number): ()
-            wfn (b, offset, round (clamp ((value - minVal) * invDelta, 0, 1) * maxInt))
+        _directWrite = function(b: buffer, offset: number, value: number): ()
+            wfn(b, offset, round(clamp((value - minVal) * invDelta, 0, 1) * maxInt))
         end,
-        _directRead = function (b: buffer, offset: number): number
-            return rfn (b, offset) * invMaxInt + minVal
+        _directRead = function(b: buffer, offset: number): number
+            return rfn(b, offset) * invMaxInt + minVal
         end,
-        write = function (ch: ChannelState, value: number): ()
+        write = function(ch: ChannelState, value: number): ()
             local c = ch.cursor
             if c + bytes > ch.size then
-                alloc (ch, bytes)
+                alloc(ch, bytes)
             end
-            wfn (ch.buff, c, round (clamp ((value - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(ch.buff, c, round(clamp((value - minVal) * invDelta, 0, 1) * maxInt))
             ch.cursor = c + bytes
         end,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (number, number)
-            return rfn (src, pos) * invMaxInt + minVal, bytes
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
+            return rfn(src, pos) * invMaxInt + minVal, bytes
         end,
     })
 end
 
-function Quantized.vec3 (minVal: number, maxVal: number, precision: number): Codec<Vector3>
-    local delta, maxInt, compBytes, wfn, rfn, invDelta, invMaxInt =
-        setup (minVal, maxVal, precision)
+function Quantized.vec3(minVal: number, maxVal: number, precision: number): Codec<Vector3>
+    local delta, maxInt, compBytes, wfn, rfn, invDelta, invMaxInt = setup(minVal, maxVal, precision)
     if not delta then
-        local val = Vector3.new (minVal, minVal, minVal)
-        return table.freeze ({
+        local val = Vector3.new(minVal, minVal, minVal)
+        return table.freeze({
             _size = 0,
-            _directWrite = function (_b: buffer, _offset: number, _value: Vector3): () end,
-            _directRead = function (_b: buffer, _offset: number): Vector3
+            _directWrite = function(_b: buffer, _offset: number, _value: Vector3): () end,
+            _directRead = function(_b: buffer, _offset: number): Vector3
                 return val
             end,
-            write = function (_ch: ChannelState, _value: Vector3): () end,
-            read = function (_src: buffer, _pos: number, _refs: { Instance }?): (Vector3, number)
+            write = function(_ch: ChannelState, _value: Vector3): () end,
+            read = function(_src: buffer, _pos: number, _refs: { Instance }?): (Vector3, number)
                 return val, 0
             end,
         })
@@ -132,40 +135,40 @@ function Quantized.vec3 (minVal: number, maxVal: number, precision: number): Cod
     local stride = compBytes
     local stride2 = compBytes * 2
 
-    return table.freeze ({
+    return table.freeze({
         _size = totalBytes,
-        _directWrite = function (b: buffer, offset: number, value: Vector3): ()
-            wfn (b, offset, round (clamp ((value.X - minVal) * invDelta, 0, 1) * maxInt))
-            wfn (b, offset + stride, round (clamp ((value.Y - minVal) * invDelta, 0, 1) * maxInt))
-            wfn (b, offset + stride2, round (clamp ((value.Z - minVal) * invDelta, 0, 1) * maxInt))
+        _directWrite = function(b: buffer, offset: number, value: Vector3): ()
+            wfn(b, offset, round(clamp((value.X - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(b, offset + stride, round(clamp((value.Y - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(b, offset + stride2, round(clamp((value.Z - minVal) * invDelta, 0, 1) * maxInt))
         end,
-        _directRead = function (b: buffer, offset: number): Vector3
-            return Vector3.new (
-                rfn (b, offset) * invMaxInt + minVal,
-                rfn (b, offset + stride) * invMaxInt + minVal,
-                rfn (b, offset + stride2) * invMaxInt + minVal
+        _directRead = function(b: buffer, offset: number): Vector3
+            return Vector3.new(
+                rfn(b, offset) * invMaxInt + minVal,
+                rfn(b, offset + stride) * invMaxInt + minVal,
+                rfn(b, offset + stride2) * invMaxInt + minVal
             )
         end,
-        write = function (ch: ChannelState, value: Vector3): ()
+        write = function(ch: ChannelState, value: Vector3): ()
             local c = ch.cursor
             if c + totalBytes > ch.size then
-                alloc (ch, totalBytes)
+                alloc(ch, totalBytes)
             end
             local b = ch.buff
-            wfn (b, c, round (clamp ((value.X - minVal) * invDelta, 0, 1) * maxInt))
-            wfn (b, c + stride, round (clamp ((value.Y - minVal) * invDelta, 0, 1) * maxInt))
-            wfn (b, c + stride2, round (clamp ((value.Z - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(b, c, round(clamp((value.X - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(b, c + stride, round(clamp((value.Y - minVal) * invDelta, 0, 1) * maxInt))
+            wfn(b, c + stride2, round(clamp((value.Z - minVal) * invDelta, 0, 1) * maxInt))
             ch.cursor = c + totalBytes
         end,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
-            return Vector3.new (
-                rfn (src, pos) * invMaxInt + minVal,
-                rfn (src, pos + stride) * invMaxInt + minVal,
-                rfn (src, pos + stride2) * invMaxInt + minVal
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (Vector3, number)
+            return Vector3.new(
+                rfn(src, pos) * invMaxInt + minVal,
+                rfn(src, pos + stride) * invMaxInt + minVal,
+                rfn(src, pos + stride2) * invMaxInt + minVal
             ),
                 totalBytes
         end,
     })
 end
 
-return table.freeze (Quantized)
+return table.freeze(Quantized)

package/src/codec/meta/Unknown.luau

@@ -2,37 +2,37 @@
 --!native
 -- Sidecar codec. Bypasses buffer serialization, uses Roblox remote refs.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
-return table.freeze ({
-    unknown = table.freeze ({
-        write = function (ch: ChannelState, value: any): ()
+return table.freeze({
+    unknown = table.freeze({
+        write = function(ch: ChannelState, value: any): ()
             local refs = ch.refs
             local idx = #refs + 1
             if idx > 65535 then
-                error (`[Lync] Unknown ref overflow: {idx} exceeds u16 max`)
+                error(`[Lync] Unknown ref overflow: {idx} exceeds u16 max`)
             end
 
             refs[idx] = value
 
             local c = ch.cursor
             if c + 2 > ch.size then
-                alloc (ch, 2)
+                alloc(ch, 2)
             end
-            buffer.writeu16 (ch.buff, c, idx)
+            buffer.writeu16(ch.buff, c, idx)
             ch.cursor = c + 2
         end,
-        read = function (src: buffer, pos: number, refs: { Instance }?): (any, number)
+        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
             if not refs then
-                error ("[Lync] Unknown read requires refs array")
+                error("[Lync] Unknown read requires refs array")
             end
 
-            local idx = buffer.readu16 (src, pos)
+            local idx = buffer.readu16(src, pos)
             return refs[idx], 2
         end,
     }),

package/src/codec/primitive/Bool.luau

@@ -2,29 +2,29 @@
 --!native
 -- Boolean codec. _isBool tells struct to pack into bitfields.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local alloc = Channel.alloc
 
-return table.freeze ({
-    bool = table.freeze ({
+return table.freeze({
+    bool = table.freeze({
         _size = 1,
         _isBool = true,
-        _directWrite = function (b: buffer, offset: number, value: boolean): ()
-            buffer.writeu8 (b, offset, if value then 1 else 0)
+        _directWrite = function(b: buffer, offset: number, value: boolean): ()
+            buffer.writeu8(b, offset, if value then 1 else 0)
         end,
-        _directRead = function (b: buffer, offset: number): boolean
-            return buffer.readu8 (b, offset) ~= 0
+        _directRead = function(b: buffer, offset: number): boolean
+            return buffer.readu8(b, offset) ~= 0
         end,
-        write = function (ch: any, value: boolean): ()
+        write = function(ch: any, value: boolean): ()
             local c = ch.cursor
             if c + 1 > ch.size then
-                alloc (ch, 1)
+                alloc(ch, 1)
             end
-            buffer.writeu8 (ch.buff, c, if value then 1 else 0)
+            buffer.writeu8(ch.buff, c, if value then 1 else 0)
             ch.cursor = c + 1
         end,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (boolean, number)
-            return buffer.readu8 (src, pos) ~= 0, 1
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (boolean, number)
+            return buffer.readu8(src, pos) ~= 0, 1
         end,
     }),
 })

package/src/codec/primitive/Float16.luau

@@ -2,14 +2,14 @@
 --!native
 -- Half-precision float codec. 2 bytes, ±65504, ~3 decimal digits.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
 
 local alloc = Channel.alloc
 
 type ChannelState = Types.ChannelState
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local MAX_HALF = 65504
 local BIAS = 15
@@ -29,9 +29,9 @@ local ldexp = math.ldexp
 local round = math.round
 local huge = math.huge
 
--- Private ------------------------------------------------------------
+-- Private -------------------------------------------------------------
 
-local function encode (value: number): number
+local function encode(value: number): number
     if value ~= value then
         return NAN_BITS
     end
@@ -46,10 +46,10 @@ local function encode (value: number): number
     end
 
     if value > MAX_HALF then
-        return bor (sign, INF_BITS)
+        return bor(sign, INF_BITS)
     end
 
-    local mantissa, exponent = frexp (value)
+    local mantissa, exponent = frexp(value)
     exponent += 14
 
     local bits: number
@@ -58,55 +58,55 @@ local function encode (value: number): number
         if shift < 0 then
             return sign
         end
-        bits = round (mantissa * lshift (1, shift))
+        bits = round(mantissa * lshift(1, shift))
     elseif exponent >= EXP_MAX then
         bits = INF_BITS
     else
-        bits = bor (lshift (exponent, MANT_BITS), round ((mantissa * 2 - 1) * MANT_SCALE))
+        bits = bor(lshift(exponent, MANT_BITS), round((mantissa * 2 - 1) * MANT_SCALE))
     end
 
-    return bor (sign, bits)
+    return bor(sign, bits)
 end
 
-local function decode (packed: number): number
-    local exponent = band (rshift (packed, MANT_BITS), 0x1F)
-    local mantissa = band (packed, 0x03FF)
+local function decode(packed: number): number
+    local exponent = band(rshift(packed, MANT_BITS), 0x1F)
+    local mantissa = band(packed, 0x03FF)
 
     local result: number
     if exponent == 0 then
-        result = if mantissa == 0 then 0 else ldexp (mantissa / MANT_SCALE, 1 - BIAS)
+        result = if mantissa == 0 then 0 else ldexp(mantissa / MANT_SCALE, 1 - BIAS)
     elseif exponent == EXP_MAX then
         result = if mantissa == 0 then huge else 0 / 0
     else
-        result = ldexp (mantissa / MANT_SCALE + 1, exponent - BIAS)
+        result = ldexp(mantissa / MANT_SCALE + 1, exponent - BIAS)
     end
 
-    return if band (packed, SIGN_BIT) ~= 0 then -result else result
+    return if band(packed, SIGN_BIT) ~= 0 then -result else result
 end
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Float16 = {}
 
-Float16.f16 = table.freeze ({
+Float16.f16 = table.freeze({
     _size = 2,
-    _directWrite = function (b: buffer, offset: number, value: number): ()
-        buffer.writeu16 (b, offset, encode (value))
+    _directWrite = function(b: buffer, offset: number, value: number): ()
+        buffer.writeu16(b, offset, encode(value))
     end,
-    _directRead = function (b: buffer, offset: number): number
-        return decode (buffer.readu16 (b, offset))
+    _directRead = function(b: buffer, offset: number): number
+        return decode(buffer.readu16(b, offset))
     end,
-    write = function (ch: ChannelState, value: number): ()
+    write = function(ch: ChannelState, value: number): ()
         local c = ch.cursor
         if c + 2 > ch.size then
-            alloc (ch, 2)
+            alloc(ch, 2)
         end
-        buffer.writeu16 (ch.buff, c, encode (value))
+        buffer.writeu16(ch.buff, c, encode(value))
         ch.cursor = c + 2
     end,
-    read = function (src: buffer, pos: number, _refs: { Instance }?): (number, number)
-        return decode (buffer.readu16 (src, pos)), 2
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (number, number)
+        return decode(buffer.readu16(src, pos)), 2
     end,
 })
 
-return table.freeze (Float16)
+return table.freeze(Float16)

package/src/codec/primitive/Number.luau

@@ -2,47 +2,47 @@
 --!native
 -- u8, u16, u32, i8, i16, i32, f32, f64 codecs.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    u8 = Base.define (1, function (b: buffer, o: number, v: number): ()
-        buffer.writeu8 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readu8 (b, o)
-    end),
-    u16 = Base.define (2, function (b: buffer, o: number, v: number): ()
-        buffer.writeu16 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readu16 (b, o)
-    end),
-    u32 = Base.define (4, function (b: buffer, o: number, v: number): ()
-        buffer.writeu32 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readu32 (b, o)
-    end),
-    i8 = Base.define (1, function (b: buffer, o: number, v: number): ()
-        buffer.writei8 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readi8 (b, o)
-    end),
-    i16 = Base.define (2, function (b: buffer, o: number, v: number): ()
-        buffer.writei16 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readi16 (b, o)
-    end),
-    i32 = Base.define (4, function (b: buffer, o: number, v: number): ()
-        buffer.writei32 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readi32 (b, o)
-    end),
-    f32 = Base.define (4, function (b: buffer, o: number, v: number): ()
-        buffer.writef32 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readf32 (b, o)
-    end),
-    f64 = Base.define (8, function (b: buffer, o: number, v: number): ()
-        buffer.writef64 (b, o, v)
-    end, function (b: buffer, o: number): number
-        return buffer.readf64 (b, o)
+return table.freeze({
+    u8 = Base.define(1, function(b: buffer, o: number, v: number): ()
+        buffer.writeu8(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readu8(b, o)
+    end),
+    u16 = Base.define(2, function(b: buffer, o: number, v: number): ()
+        buffer.writeu16(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readu16(b, o)
+    end),
+    u32 = Base.define(4, function(b: buffer, o: number, v: number): ()
+        buffer.writeu32(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readu32(b, o)
+    end),
+    i8 = Base.define(1, function(b: buffer, o: number, v: number): ()
+        buffer.writei8(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readi8(b, o)
+    end),
+    i16 = Base.define(2, function(b: buffer, o: number, v: number): ()
+        buffer.writei16(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readi16(b, o)
+    end),
+    i32 = Base.define(4, function(b: buffer, o: number, v: number): ()
+        buffer.writei32(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readi32(b, o)
+    end),
+    f32 = Base.define(4, function(b: buffer, o: number, v: number): ()
+        buffer.writef32(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readf32(b, o)
+    end),
+    f64 = Base.define(8, function(b: buffer, o: number, v: number): ()
+        buffer.writef64(b, o, v)
+    end, function(b: buffer, o: number): number
+        return buffer.readf64(b, o)
     end),
 })