@axpecter/lync 1.4.3 → 1.5.0

package/src/codec/datatype/IntVector.luau

@@ -1,25 +1,25 @@
 --!strict
 --!native
--- Vector2int16 (4B) and Vector3int16 (6B) codecs.
+-- Vector2int16(4B) and Vector3int16(6B) codecs.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    vec2int16 = Base.define (4, function (b: buffer, o: number, v: Vector2int16): ()
-        buffer.writei16 (b, o, v.X)
-        buffer.writei16 (b, o + 2, v.Y)
-    end, function (b: buffer, o: number): Vector2int16
-        return Vector2int16.new (buffer.readi16 (b, o), buffer.readi16 (b, o + 2))
+return table.freeze({
+    vec2int16 = Base.define(4, function(b: buffer, o: number, v: Vector2int16): ()
+        buffer.writei16(b, o, v.X)
+        buffer.writei16(b, o + 2, v.Y)
+    end, function(b: buffer, o: number): Vector2int16
+        return Vector2int16.new(buffer.readi16(b, o), buffer.readi16(b, o + 2))
     end),
-    vec3int16 = Base.define (6, function (b: buffer, o: number, v: Vector3int16): ()
-        buffer.writei16 (b, o, v.X)
-        buffer.writei16 (b, o + 2, v.Y)
-        buffer.writei16 (b, o + 4, v.Z)
-    end, function (b: buffer, o: number): Vector3int16
-        return Vector3int16.new (
-            buffer.readi16 (b, o),
-            buffer.readi16 (b, o + 2),
-            buffer.readi16 (b, o + 4)
+    vec3int16 = Base.define(6, function(b: buffer, o: number, v: Vector3int16): ()
+        buffer.writei16(b, o, v.X)
+        buffer.writei16(b, o + 2, v.Y)
+        buffer.writei16(b, o + 4, v.Z)
+    end, function(b: buffer, o: number): Vector3int16
+        return Vector3int16.new(
+            buffer.readi16(b, o),
+            buffer.readi16(b, o + 2),
+            buffer.readi16(b, o + 4)
         )
     end),
 })

package/src/codec/datatype/NumberRange.luau

@@ -2,13 +2,13 @@
 --!native
 -- NumberRange codec. 8 bytes: min f32 + max f32.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    numberRange = Base.define (8, function (b: buffer, o: number, v: NumberRange): ()
-        buffer.writef32 (b, o, v.Min)
-        buffer.writef32 (b, o + 4, v.Max)
-    end, function (b: buffer, o: number): NumberRange
-        return NumberRange.new (buffer.readf32 (b, o), buffer.readf32 (b, o + 4))
+return table.freeze({
+    numberRange = Base.define(8, function(b: buffer, o: number, v: NumberRange): ()
+        buffer.writef32(b, o, v.Min)
+        buffer.writef32(b, o + 4, v.Max)
+    end, function(b: buffer, o: number): NumberRange
+        return NumberRange.new(buffer.readf32(b, o), buffer.readf32(b, o + 4))
     end),
 })

package/src/codec/datatype/Ray.luau

@@ -2,25 +2,25 @@
 --!native
 -- Ray codec. 24 bytes: origin vec3 + direction vec3.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    ray = Base.define (24, function (b: buffer, o: number, v: Ray): ()
+return table.freeze({
+    ray = Base.define(24, function(b: buffer, o: number, v: Ray): ()
         local origin = v.Origin
         local direction = v.Direction
-        buffer.writef32 (b, o, origin.X)
-        buffer.writef32 (b, o + 4, origin.Y)
-        buffer.writef32 (b, o + 8, origin.Z)
-        buffer.writef32 (b, o + 12, direction.X)
-        buffer.writef32 (b, o + 16, direction.Y)
-        buffer.writef32 (b, o + 20, direction.Z)
-    end, function (b: buffer, o: number): Ray
-        return Ray.new (
-            Vector3.new (buffer.readf32 (b, o), buffer.readf32 (b, o + 4), buffer.readf32 (b, o + 8)),
-            Vector3.new (
-                buffer.readf32 (b, o + 12),
-                buffer.readf32 (b, o + 16),
-                buffer.readf32 (b, o + 20)
+        buffer.writef32(b, o, origin.X)
+        buffer.writef32(b, o + 4, origin.Y)
+        buffer.writef32(b, o + 8, origin.Z)
+        buffer.writef32(b, o + 12, direction.X)
+        buffer.writef32(b, o + 16, direction.Y)
+        buffer.writef32(b, o + 20, direction.Z)
+    end, function(b: buffer, o: number): Ray
+        return Ray.new(
+            Vector3.new(buffer.readf32(b, o), buffer.readf32(b, o + 4), buffer.readf32(b, o + 8)),
+            Vector3.new(
+                buffer.readf32(b, o + 12),
+                buffer.readf32(b, o + 16),
+                buffer.readf32(b, o + 20)
             )
         )
     end),

package/src/codec/datatype/Rect.luau

@@ -2,20 +2,20 @@
 --!native
 -- Rect codec. 16 bytes: 4x f32.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    rect = Base.define (16, function (b: buffer, o: number, v: Rect): ()
-        buffer.writef32 (b, o, v.Min.X)
-        buffer.writef32 (b, o + 4, v.Min.Y)
-        buffer.writef32 (b, o + 8, v.Max.X)
-        buffer.writef32 (b, o + 12, v.Max.Y)
-    end, function (b: buffer, o: number): Rect
-        return Rect.new (
-            buffer.readf32 (b, o),
-            buffer.readf32 (b, o + 4),
-            buffer.readf32 (b, o + 8),
-            buffer.readf32 (b, o + 12)
+return table.freeze({
+    rect = Base.define(16, function(b: buffer, o: number, v: Rect): ()
+        buffer.writef32(b, o, v.Min.X)
+        buffer.writef32(b, o + 4, v.Min.Y)
+        buffer.writef32(b, o + 8, v.Max.X)
+        buffer.writef32(b, o + 12, v.Max.Y)
+    end, function(b: buffer, o: number): Rect
+        return Rect.new(
+            buffer.readf32(b, o),
+            buffer.readf32(b, o + 4),
+            buffer.readf32(b, o + 8),
+            buffer.readf32(b, o + 12)
         )
     end),
 })

package/src/codec/datatype/Region.luau

@@ -1,57 +1,53 @@
 --!strict
 --!native
--- Region3 (24B) and Region3int16 (12B) codecs.
+-- Region3(24B) and Region3int16(12B) codecs.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-local function writeRegion3 (b: buffer, o: number, v: Region3): ()
+local function writeRegion3(b: buffer, o: number, v: Region3): ()
     local cf = v.CFrame
     local size = v.Size
     local halfSize = size * 0.5
     local pos = cf.Position
     local minV = pos - halfSize
     local maxV = pos + halfSize
-    buffer.writef32 (b, o, minV.X)
-    buffer.writef32 (b, o + 4, minV.Y)
-    buffer.writef32 (b, o + 8, minV.Z)
-    buffer.writef32 (b, o + 12, maxV.X)
-    buffer.writef32 (b, o + 16, maxV.Y)
-    buffer.writef32 (b, o + 20, maxV.Z)
+    buffer.writef32(b, o, minV.X)
+    buffer.writef32(b, o + 4, minV.Y)
+    buffer.writef32(b, o + 8, minV.Z)
+    buffer.writef32(b, o + 12, maxV.X)
+    buffer.writef32(b, o + 16, maxV.Y)
+    buffer.writef32(b, o + 20, maxV.Z)
 end
 
-local function readRegion3 (b: buffer, o: number): Region3
-    return Region3.new (
-        Vector3.new (buffer.readf32 (b, o), buffer.readf32 (b, o + 4), buffer.readf32 (b, o + 8)),
-        Vector3.new (
-            buffer.readf32 (b, o + 12),
-            buffer.readf32 (b, o + 16),
-            buffer.readf32 (b, o + 20)
-        )
+local function readRegion3(b: buffer, o: number): Region3
+    return Region3.new(
+        Vector3.new(buffer.readf32(b, o), buffer.readf32(b, o + 4), buffer.readf32(b, o + 8)),
+        Vector3.new(buffer.readf32(b, o + 12), buffer.readf32(b, o + 16), buffer.readf32(b, o + 20))
     )
 end
 
-return table.freeze ({
-    region3 = Base.define (24, writeRegion3, readRegion3),
-    region3int16 = Base.define (12, function (b: buffer, o: number, v: Region3int16): ()
+return table.freeze({
+    region3 = Base.define(24, writeRegion3, readRegion3),
+    region3int16 = Base.define(12, function(b: buffer, o: number, v: Region3int16): ()
         local minV = v.Min
         local maxV = v.Max
-        buffer.writei16 (b, o, minV.X)
-        buffer.writei16 (b, o + 2, minV.Y)
-        buffer.writei16 (b, o + 4, minV.Z)
-        buffer.writei16 (b, o + 6, maxV.X)
-        buffer.writei16 (b, o + 8, maxV.Y)
-        buffer.writei16 (b, o + 10, maxV.Z)
-    end, function (b: buffer, o: number): Region3int16
-        return Region3int16.new (
-            Vector3int16.new (
-                buffer.readi16 (b, o),
-                buffer.readi16 (b, o + 2),
-                buffer.readi16 (b, o + 4)
+        buffer.writei16(b, o, minV.X)
+        buffer.writei16(b, o + 2, minV.Y)
+        buffer.writei16(b, o + 4, minV.Z)
+        buffer.writei16(b, o + 6, maxV.X)
+        buffer.writei16(b, o + 8, maxV.Y)
+        buffer.writei16(b, o + 10, maxV.Z)
+    end, function(b: buffer, o: number): Region3int16
+        return Region3int16.new(
+            Vector3int16.new(
+                buffer.readi16(b, o),
+                buffer.readi16(b, o + 2),
+                buffer.readi16(b, o + 4)
             ),
-            Vector3int16.new (
-                buffer.readi16 (b, o + 6),
-                buffer.readi16 (b, o + 8),
-                buffer.readi16 (b, o + 10)
+            Vector3int16.new(
+                buffer.readi16(b, o + 6),
+                buffer.readi16(b, o + 8),
+                buffer.readi16(b, o + 10)
             )
         )
     end),

package/src/codec/datatype/Sequence.luau

@@ -2,15 +2,15 @@
 --!native
 -- NumberSequence and ColorSequence codecs with varint length prefix.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
-local Varint = require (script.Parent.Parent.primitive.Varint)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
+local Varint = require(script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Constants ----------------------------------------------------------
+-- Constants -----------------------------------------------------------
 
 local NS_STRIDE = 12
 local CS_STRIDE = 7
@@ -18,15 +18,15 @@ local CS_STRIDE = 7
 local round = math.round
 local clamp = math.clamp
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local Sequence = {}
 
-Sequence.numberSequence = table.freeze ({
-    write = function (ch: ChannelState, value: NumberSequence): ()
+Sequence.numberSequence = table.freeze({
+    write = function(ch: ChannelState, value: NumberSequence): ()
         local keypoints = value.Keypoints
         local count = #keypoints
-        Varint.write (ch, count)
+        Varint.write(ch, count)
 
         if count == 0 then
             return
@@ -35,47 +35,47 @@ Sequence.numberSequence = table.freeze ({
         local totalBytes = count * NS_STRIDE
         local c = ch.cursor
         if c + totalBytes > ch.size then
-            alloc (ch, totalBytes)
+            alloc(ch, totalBytes)
         end
 
         local b = ch.buff
         for i = 1, count do
             local kp = keypoints[i]
-            buffer.writef32 (b, c, kp.Time)
-            buffer.writef32 (b, c + 4, kp.Value)
-            buffer.writef32 (b, c + 8, kp.Envelope)
+            buffer.writef32(b, c, kp.Time)
+            buffer.writef32(b, c + 4, kp.Value)
+            buffer.writef32(b, c + 8, kp.Envelope)
             c += NS_STRIDE
         end
 
         ch.cursor = c
     end,
-    read = function (src: buffer, pos: number, _refs: { Instance }?): (NumberSequence, number)
-        local count, lenBytes = Varint.read (src, pos)
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (NumberSequence, number)
+        local count, lenBytes = Varint.read(src, pos)
         local absPos = pos + lenBytes
 
         if count == 0 then
-            return NumberSequence.new (0), lenBytes
+            return NumberSequence.new(0), lenBytes
         end
 
-        local keypoints = table.create (count)
+        local keypoints = table.create(count)
         for i = 1, count do
-            keypoints[i] = NumberSequenceKeypoint.new (
-                buffer.readf32 (src, absPos),
-                buffer.readf32 (src, absPos + 4),
-                buffer.readf32 (src, absPos + 8)
+            keypoints[i] = NumberSequenceKeypoint.new(
+                buffer.readf32(src, absPos),
+                buffer.readf32(src, absPos + 4),
+                buffer.readf32(src, absPos + 8)
             )
             absPos += NS_STRIDE
         end
 
-        return NumberSequence.new (keypoints), absPos - pos
+        return NumberSequence.new(keypoints), absPos - pos
     end,
 })
 
-Sequence.colorSequence = table.freeze ({
-    write = function (ch: ChannelState, value: ColorSequence): ()
+Sequence.colorSequence = table.freeze({
+    write = function(ch: ChannelState, value: ColorSequence): ()
         local keypoints = value.Keypoints
         local count = #keypoints
-        Varint.write (ch, count)
+        Varint.write(ch, count)
 
         if count == 0 then
             return
@@ -84,45 +84,45 @@ Sequence.colorSequence = table.freeze ({
         local totalBytes = count * CS_STRIDE
         local c = ch.cursor
         if c + totalBytes > ch.size then
-            alloc (ch, totalBytes)
+            alloc(ch, totalBytes)
         end
 
         local b = ch.buff
         for i = 1, count do
             local kp = keypoints[i]
             local color = kp.Value
-            buffer.writef32 (b, c, kp.Time)
-            buffer.writeu8 (b, c + 4, round (clamp (color.R, 0, 1) * 255))
-            buffer.writeu8 (b, c + 5, round (clamp (color.G, 0, 1) * 255))
-            buffer.writeu8 (b, c + 6, round (clamp (color.B, 0, 1) * 255))
+            buffer.writef32(b, c, kp.Time)
+            buffer.writeu8(b, c + 4, round(clamp(color.R, 0, 1) * 255))
+            buffer.writeu8(b, c + 5, round(clamp(color.G, 0, 1) * 255))
+            buffer.writeu8(b, c + 6, round(clamp(color.B, 0, 1) * 255))
             c += CS_STRIDE
         end
 
         ch.cursor = c
     end,
-    read = function (src: buffer, pos: number, _refs: { Instance }?): (ColorSequence, number)
-        local count, lenBytes = Varint.read (src, pos)
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (ColorSequence, number)
+        local count, lenBytes = Varint.read(src, pos)
         local absPos = pos + lenBytes
 
         if count == 0 then
-            return ColorSequence.new (Color3.new ()), lenBytes
+            return ColorSequence.new(Color3.new()), lenBytes
         end
 
-        local keypoints = table.create (count)
+        local keypoints = table.create(count)
         for i = 1, count do
-            keypoints[i] = ColorSequenceKeypoint.new (
-                buffer.readf32 (src, absPos),
-                Color3.fromRGB (
-                    buffer.readu8 (src, absPos + 4),
-                    buffer.readu8 (src, absPos + 5),
-                    buffer.readu8 (src, absPos + 6)
+            keypoints[i] = ColorSequenceKeypoint.new(
+                buffer.readf32(src, absPos),
+                Color3.fromRGB(
+                    buffer.readu8(src, absPos + 4),
+                    buffer.readu8(src, absPos + 5),
+                    buffer.readu8(src, absPos + 6)
                 )
             )
             absPos += CS_STRIDE
         end
 
-        return ColorSequence.new (keypoints), absPos - pos
+        return ColorSequence.new(keypoints), absPos - pos
     end,
 })
 
-return table.freeze (Sequence)
+return table.freeze(Sequence)

package/src/codec/datatype/String.luau

@@ -2,83 +2,83 @@
 --!native
 -- Variable-length string codec with varint length prefix.
 
-local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local Types = require (script.Parent.Parent.Parent.Types)
-local Varint = require (script.Parent.Parent.primitive.Varint)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Types = require(script.Parent.Parent.Parent.Types)
+local Varint = require(script.Parent.Parent.primitive.Varint)
 
 type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Public -------------------------------------------------------------
+-- Public --------------------------------------------------------------
 
 local String = {}
 
-String.string = table.freeze ({
-    write = function (ch: ChannelState, value: string): ()
+String.string = table.freeze({
+    write = function(ch: ChannelState, value: string): ()
         local len = #value
 
         if len < 128 then
             local total = 1 + len
             local c = ch.cursor
             if c + total > ch.size then
-                alloc (ch, total)
+                alloc(ch, total)
             end
             local b = ch.buff
-            buffer.writeu8 (b, c, len)
+            buffer.writeu8(b, c, len)
             if len > 0 then
-                buffer.writestring (b, c + 1, value)
+                buffer.writestring(b, c + 1, value)
             end
             ch.cursor = c + total
         else
-            Varint.write (ch, len)
+            Varint.write(ch, len)
             local c = ch.cursor
             if c + len > ch.size then
-                alloc (ch, len)
+                alloc(ch, len)
             end
-            buffer.writestring (ch.buff, c, value)
+            buffer.writestring(ch.buff, c, value)
             ch.cursor = c + len
         end
     end,
-    read = function (src: buffer, pos: number, _refs: { Instance }?): (string, number)
-        local len, lenBytes = Varint.read (src, pos)
+    read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+        local len, lenBytes = Varint.read(src, pos)
         if len == 0 then
             return "", lenBytes
         end
 
-        local remaining = buffer.len (src) - pos - lenBytes
+        local remaining = buffer.len(src) - pos - lenBytes
         if len > remaining then
-            error (`[Lync] String length exceeds buffer: {len} > {remaining}`)
+            error(`[Lync] String length exceeds buffer: {len} > {remaining}`)
         end
 
-        return buffer.readstring (src, pos + lenBytes, len), lenBytes + len
+        return buffer.readstring(src, pos + lenBytes, len), lenBytes + len
     end,
 })
 
-function String.bounded (maxLength: number): any
-    if maxLength <= 0 or maxLength ~= math.floor (maxLength) then
-        error (`[Lync] boundedString maxLength must be a positive integer, got {maxLength}`)
+function String.bounded(maxLength: number): any
+    if maxLength <= 0 or maxLength ~= math.floor(maxLength) then
+        error(`[Lync] boundedString maxLength must be a positive integer, got {maxLength}`)
     end
 
-    return table.freeze ({
+    return table.freeze({
         write = String.string.write,
-        read = function (src: buffer, pos: number, _refs: { Instance }?): (string, number)
-            local len, lenBytes = Varint.read (src, pos)
+        read = function(src: buffer, pos: number, _refs: { Instance }?): (string, number)
+            local len, lenBytes = Varint.read(src, pos)
             if len > maxLength then
-                error (`[Lync] String length {len} exceeds max {maxLength}`)
+                error(`[Lync] String length {len} exceeds max {maxLength}`)
             end
             if len == 0 then
                 return "", lenBytes
             end
 
-            local remaining = buffer.len (src) - pos - lenBytes
+            local remaining = buffer.len(src) - pos - lenBytes
             if len > remaining then
-                error (`[Lync] String length exceeds buffer: {len} > {remaining}`)
+                error(`[Lync] String length exceeds buffer: {len} > {remaining}`)
             end
 
-            return buffer.readstring (src, pos + lenBytes, len), lenBytes + len
+            return buffer.readstring(src, pos + lenBytes, len), lenBytes + len
         end,
     })
 end
 
-return table.freeze (String)
+return table.freeze(String)

package/src/codec/datatype/UDim.luau

@@ -1,27 +1,27 @@
 --!strict
 --!native
--- UDim (8B) and UDim2 (16B) codecs.
+-- UDim(8B) and UDim2(16B) codecs.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    udim = Base.define (8, function (b: buffer, o: number, v: UDim): ()
-        buffer.writef32 (b, o, v.Scale)
-        buffer.writei32 (b, o + 4, v.Offset)
-    end, function (b: buffer, o: number): UDim
-        return UDim.new (buffer.readf32 (b, o), buffer.readi32 (b, o + 4))
+return table.freeze({
+    udim = Base.define(8, function(b: buffer, o: number, v: UDim): ()
+        buffer.writef32(b, o, v.Scale)
+        buffer.writei32(b, o + 4, v.Offset)
+    end, function(b: buffer, o: number): UDim
+        return UDim.new(buffer.readf32(b, o), buffer.readi32(b, o + 4))
     end),
-    udim2 = Base.define (16, function (b: buffer, o: number, v: UDim2): ()
+    udim2 = Base.define(16, function(b: buffer, o: number, v: UDim2): ()
         local x = v.X
         local y = v.Y
-        buffer.writef32 (b, o, x.Scale)
-        buffer.writei32 (b, o + 4, x.Offset)
-        buffer.writef32 (b, o + 8, y.Scale)
-        buffer.writei32 (b, o + 12, y.Offset)
-    end, function (b: buffer, o: number): UDim2
-        return UDim2.new (
-            UDim.new (buffer.readf32 (b, o), buffer.readi32 (b, o + 4)),
-            UDim.new (buffer.readf32 (b, o + 8), buffer.readi32 (b, o + 12))
+        buffer.writef32(b, o, x.Scale)
+        buffer.writei32(b, o + 4, x.Offset)
+        buffer.writef32(b, o + 8, y.Scale)
+        buffer.writei32(b, o + 12, y.Offset)
+    end, function(b: buffer, o: number): UDim2
+        return UDim2.new(
+            UDim.new(buffer.readf32(b, o), buffer.readi32(b, o + 4)),
+            UDim.new(buffer.readf32(b, o + 8), buffer.readi32(b, o + 12))
         )
     end),
 })

package/src/codec/datatype/Vector.luau

@@ -1,25 +1,21 @@
 --!strict
 --!native
--- Vector2 (8B) and Vector3 (12B) codecs.
+-- Vector2(8B) and Vector3(12B) codecs.
 
-local Base = require (script.Parent.Parent.Base)
+local Base = require(script.Parent.Parent.Base)
 
-return table.freeze ({
-    vec2 = Base.define (8, function (b: buffer, o: number, v: Vector2): ()
-        buffer.writef32 (b, o, v.X)
-        buffer.writef32 (b, o + 4, v.Y)
-    end, function (b: buffer, o: number): Vector2
-        return Vector2.new (buffer.readf32 (b, o), buffer.readf32 (b, o + 4))
+return table.freeze({
+    vec2 = Base.define(8, function(b: buffer, o: number, v: Vector2): ()
+        buffer.writef32(b, o, v.X)
+        buffer.writef32(b, o + 4, v.Y)
+    end, function(b: buffer, o: number): Vector2
+        return Vector2.new(buffer.readf32(b, o), buffer.readf32(b, o + 4))
     end),
-    vec3 = Base.define (12, function (b: buffer, o: number, v: Vector3): ()
-        buffer.writef32 (b, o, v.X)
-        buffer.writef32 (b, o + 4, v.Y)
-        buffer.writef32 (b, o + 8, v.Z)
-    end, function (b: buffer, o: number): Vector3
-        return Vector3.new (
-            buffer.readf32 (b, o),
-            buffer.readf32 (b, o + 4),
-            buffer.readf32 (b, o + 8)
-        )
+    vec3 = Base.define(12, function(b: buffer, o: number, v: Vector3): ()
+        buffer.writef32(b, o, v.X)
+        buffer.writef32(b, o + 4, v.Y)
+        buffer.writef32(b, o + 8, v.Z)
+    end, function(b: buffer, o: number): Vector3
+        return Vector3.new(buffer.readf32(b, o), buffer.readf32(b, o + 4), buffer.readf32(b, o + 8))
     end),
 })