roblox-opencode 1.0.0

package/vendor/fusion/Animation/Tween.luau

@@ -0,0 +1,187 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	A specialised state object for following a goal state smoothly over time,
+	using a TweenInfo to shape the motion.
+
+	https://elttob.uk/Fusion/0.3/api-reference/animation/types/tween/
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local External = require(Package.External)
+-- Memory
+local checkLifetime = require(Package.Memory.checkLifetime)
+-- Graph
+local depend = require(Package.Graph.depend)
+local evaluate = require(Package.Graph.evaluate)
+-- State
+local castToState = require(Package.State.castToState)
+local peek = require(Package.State.peek)
+-- Animation
+local ExternalTime = require(Package.Animation.ExternalTime)
+local Stopwatch = require(Package.Animation.Stopwatch)
+local lerpType = require(Package.Animation.lerpType)
+local getTweenRatio = require(Package.Animation.getTweenRatio)
+local getTweenDuration = require(Package.Animation.getTweenDuration)
+-- Utility
+local nicknames = require(Package.Utility.nicknames)
+
+export type Self<T> = Types.Tween<T> & {
+	_activeDuration: number,
+	_activeElapsed: number,
+	_activeFrom: T,
+	_activeTo: T,
+	_activeTweenInfo: TweenInfo,
+	_goal: Types.UsedAs<T>,
+	_stopwatch: Stopwatch.Stopwatch?,
+	_tweenInfo: Types.UsedAs<TweenInfo>,
+}
+
+local class = {}
+class.type = "State"
+class.kind = "Tween"
+class.timeliness = "eager"
+
+local METATABLE = table.freeze {__index = class}
+
+local function Tween<T>(
+	scope: Types.Scope<unknown>,
+	goal: Types.UsedAs<T>,
+	tweenInfo: Types.UsedAs<TweenInfo>?
+): Types.Tween<T>
+	local createdAt = os.clock()
+	if castToState(scope) then
+		External.logError("scopeMissing", nil, "Tweens", "myScope:Tween(goalState, tweenInfo)")
+	end
+
+	local goalState = castToState(goal)
+	local stopwatch = nil
+	if goalState ~= nil then
+		stopwatch = Stopwatch(scope, ExternalTime(scope))
+	end
+
+	local self: Self<T> = setmetatable(
+		{
+			createdAt = createdAt,
+			dependencySet = {},
+			dependentSet = {},
+			lastChange = nil,
+			scope = scope,
+			validity = "invalid",
+			_activeDuration = nil,
+			_activeElapsed = nil,
+			_activeFrom = nil,
+			_activeTo = nil,
+			_activeTweenInfo = nil,
+			_EXTREMELY_DANGEROUS_usedAsValue = peek(goal),
+			_goal = goal,
+			_stopwatch = stopwatch,
+			_tweenInfo = tweenInfo or TweenInfo.new()
+		},
+		METATABLE
+	) :: any
+	local destroy = function()
+		self.scope = nil
+		for dependency in pairs(self.dependencySet) do
+			dependency.dependentSet[self] = nil
+		end
+	end
+	self.oldestTask = destroy
+	nicknames[self.oldestTask] = "Tween"
+	table.insert(scope, destroy)
+
+	if goalState ~= nil then
+		checkLifetime.bOutlivesA(
+			scope, self.oldestTask,
+			goalState.scope, goalState.oldestTask,
+			checkLifetime.formatters.animationGoal
+		)
+	end
+
+	local tweenInfoState = castToState(tweenInfo)
+	if tweenInfoState ~= nil then
+		checkLifetime.bOutlivesA(
+			scope, self.oldestTask,
+			tweenInfoState.scope, tweenInfoState.oldestTask,
+			checkLifetime.formatters.parameter, "tween info"
+		)
+	end
+
+	-- Eagerly evaluated objects need to evaluate themselves so that they're
+	-- valid at all times.
+	evaluate(self, true)
+
+	return self
+end
+
+function class.get<T>(
+	self: Self<T>
+): never
+	return External.logError("stateGetWasRemoved")
+end
+
+function class._evaluate<T>(
+	self: Self<T>
+): boolean
+	local goal = castToState(self._goal)
+	-- Allow non-state goals to pass through transparently.
+	if goal == nil then
+		self._EXTREMELY_DANGEROUS_usedAsValue = self._goal :: T
+		return false
+	end
+	depend(self, goal)
+	local newTweenTo = peek(goal)
+	-- Protect against NaN goals.
+	if newTweenTo ~= newTweenTo then
+		External.logWarn("tweenNanGoal")
+		return false
+	end
+	local stopwatch = self._stopwatch :: Stopwatch.Stopwatch
+	local tweenInfo = peek(self._tweenInfo) :: TweenInfo
+	-- Restart animation when the goal changes, or if the tween info changes
+	-- partway through another animation.
+	if 
+		self._activeTo ~= newTweenTo or
+		(self._activeElapsed < self._activeDuration and self._activeTweenInfo ~= tweenInfo)
+	then
+		self._activeDuration = getTweenDuration(tweenInfo)
+		self._activeFrom = self._EXTREMELY_DANGEROUS_usedAsValue
+		self._activeTo = newTweenTo
+		self._activeTweenInfo = tweenInfo
+		stopwatch:zero()
+		stopwatch:unpause()
+	end
+	depend(self, stopwatch)
+	self._activeElapsed = peek(stopwatch)
+	if
+		self._activeFrom == self._activeTo or -- endpoints match
+		self._activeElapsed >= self._activeDuration or -- animation is done
+		typeof(self._activeTo) ~= typeof(self._activeFrom) -- type difference
+	then
+		self._activeFrom = self._activeTo
+		self._activeElapsed = self._activeDuration
+		stopwatch:pause()
+	end
+	-- Compute actual tweened value.
+	local ratio = getTweenRatio(tweenInfo, self._activeElapsed)
+	local oldValue = self._EXTREMELY_DANGEROUS_usedAsValue
+	local newValue = lerpType(self._activeFrom, self._activeTo, ratio) :: T
+	-- Protect against NaN after motion.
+	if newValue ~= newValue then
+		External.logWarn("tweenNanMotion")
+		newValue = self._activeTo
+	end
+	-- Push update and check for similarity.
+	-- Don't need to use the similarity test here because this code doesn't
+	-- deal with tables, and NaN is already guarded against, so the similarity
+	-- test doesn't actually add any new safety here.
+	self._EXTREMELY_DANGEROUS_usedAsValue = newValue
+	return oldValue ~= newValue
+end
+
+table.freeze(class)
+return Tween :: Types.TweenConstructor

package/vendor/fusion/Animation/getTweenDuration.luau

@@ -0,0 +1,27 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Given a `tweenInfo`, returns how many seconds it will take before the tween
+	finishes moving. The result may be infinite if the tween repeats forever.
+]]
+
+local TweenService = game:GetService("TweenService")
+
+local function getTweenDuration(
+	tweenInfo: TweenInfo
+): number
+	if tweenInfo.RepeatCount <= -1 then
+		return math.huge
+	end
+	local tweenDuration = tweenInfo.DelayTime + tweenInfo.Time
+	if tweenInfo.Reverses then
+		tweenDuration += tweenInfo.Time
+	end
+	tweenDuration *= tweenInfo.RepeatCount + 1
+	return tweenDuration
+end
+
+return getTweenDuration

package/vendor/fusion/Animation/getTweenRatio.luau

@@ -0,0 +1,47 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Given a `tweenInfo` and `currentTime`, returns a ratio which can be used to
+	tween between two values over time.
+]]
+
+local TweenService = game:GetService("TweenService")
+
+local function getTweenRatio(
+	tweenInfo: TweenInfo,
+	currentTime: number
+): number
+	local delay = tweenInfo.DelayTime
+	local duration = tweenInfo.Time
+	local reverses = tweenInfo.Reverses
+	local numCycles = 1 + tweenInfo.RepeatCount
+	local easeStyle = tweenInfo.EasingStyle
+	local easeDirection = tweenInfo.EasingDirection
+	local cycleDuration = delay + duration
+	if reverses then
+		cycleDuration += duration
+	end
+	-- If currentTime is infinity, then presumably the tween should be over.
+	-- This avoids NaN when the duration of an infinitely repeating tween is given.
+	if currentTime == math.huge then
+		return 1
+	end
+	if currentTime >= cycleDuration * numCycles and tweenInfo.RepeatCount > -1 then
+		return 1
+	end
+	local cycleTime = currentTime % cycleDuration
+	if cycleTime <= delay then
+		return 0
+	end
+	local tweenProgress = (cycleTime - delay) / duration
+	if tweenProgress > 1 then
+		tweenProgress = 2 - tweenProgress
+	end
+	local ratio = TweenService:GetValue(tweenProgress, easeStyle, easeDirection)
+	return ratio
+end
+
+return getTweenRatio

package/vendor/fusion/Animation/lerpType.luau

@@ -0,0 +1,164 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Linearly interpolates the given animatable types by a ratio.
+	If the types are different or not animatable, then the first value will be
+	returned for ratios below 0.5, and the second value for 0.5 and above.
+]]
+
+local Package = script.Parent.Parent
+local Oklab = require(Package.Colour.Oklab)
+
+local function lerpType(
+	from: unknown, 
+	to: unknown, 
+	ratio: number
+): unknown
+	local typeString = typeof(from)
+
+	if typeof(to) == typeString then
+		-- both types must match for interpolation to make sense
+		if typeString == "number" then
+			local to, from = to :: number, from :: number
+			return (to - from) * ratio + from
+
+		elseif typeString == "CFrame" then
+			local to, from = to :: CFrame, from :: CFrame
+			return from:Lerp(to, ratio)
+
+		elseif typeString == "Color3" then
+			local to, from = to :: Color3, from :: Color3
+			local fromLab = Oklab.fromSRGB(from)
+			local toLab = Oklab.fromSRGB(to)
+			return Oklab.toSRGB(
+				fromLab:Lerp(toLab, ratio),
+				false
+			)
+
+		elseif typeString == "ColorSequenceKeypoint" then
+			local to, from = to :: ColorSequenceKeypoint, from :: ColorSequenceKeypoint
+			local fromLab = Oklab.fromSRGB(from.Value)
+			local toLab = Oklab.fromSRGB(to.Value)
+			return ColorSequenceKeypoint.new(
+				(to.Time - from.Time) * ratio + from.Time,
+				Oklab.toSRGB(
+					fromLab:Lerp(toLab, ratio),
+					false
+				)
+			)
+
+		elseif typeString == "DateTime" then
+			local to, from = to :: DateTime, from :: DateTime
+			return DateTime.fromUnixTimestampMillis(
+				(to.UnixTimestampMillis - from.UnixTimestampMillis) * ratio + from.UnixTimestampMillis
+			)
+
+		elseif typeString == "NumberRange" then
+			local to, from = to :: NumberRange, from :: NumberRange
+			return NumberRange.new(
+				(to.Min - from.Min) * ratio + from.Min,
+				(to.Max - from.Max) * ratio + from.Max
+			)
+
+		elseif typeString == "NumberSequenceKeypoint" then
+			local to, from = to :: NumberSequenceKeypoint, from :: NumberSequenceKeypoint
+			return NumberSequenceKeypoint.new(
+				(to.Time - from.Time) * ratio + from.Time,
+				(to.Value - from.Value) * ratio + from.Value,
+				(to.Envelope - from.Envelope) * ratio + from.Envelope
+			)
+
+		elseif typeString == "PhysicalProperties" then
+			local to, from = to :: PhysicalProperties, from :: PhysicalProperties
+			return PhysicalProperties.new(
+				(to.Density - from.Density) * ratio + from.Density,
+				(to.Friction - from.Friction) * ratio + from.Friction,
+				(to.Elasticity - from.Elasticity) * ratio + from.Elasticity,
+				(to.FrictionWeight - from.FrictionWeight) * ratio + from.FrictionWeight,
+				(to.ElasticityWeight - from.ElasticityWeight) * ratio + from.ElasticityWeight
+			)
+
+		elseif typeString == "Ray" then
+			local to, from = to :: Ray, from :: Ray
+			return Ray.new(
+				from.Origin:Lerp(to.Origin, ratio),
+				from.Direction:Lerp(to.Direction, ratio)
+			)
+
+		elseif typeString == "Rect" then
+			local to, from = to :: Rect, from :: Rect
+			return Rect.new(
+				from.Min:Lerp(to.Min, ratio),
+				from.Max:Lerp(to.Max, ratio)
+			)
+
+		elseif typeString == "Region3" then
+			local to, from = to :: Region3, from :: Region3
+			-- FUTURE: support rotated Region3s if/when they become constructable
+			local position = from.CFrame.Position:Lerp(to.CFrame.Position, ratio)
+			local halfSize = from.Size:Lerp(to.Size, ratio) / 2
+			return Region3.new(position - halfSize, position + halfSize)
+
+		elseif typeString == "Region3int16" then
+			local to, from = to :: Region3int16, from :: Region3int16
+			return Region3int16.new(
+				Vector3int16.new(
+					(to.Min.X - from.Min.X) * ratio + from.Min.X,
+					(to.Min.Y - from.Min.Y) * ratio + from.Min.Y,
+					(to.Min.Z - from.Min.Z) * ratio + from.Min.Z
+				),
+				Vector3int16.new(
+					(to.Max.X - from.Max.X) * ratio + from.Max.X,
+					(to.Max.Y - from.Max.Y) * ratio + from.Max.Y,
+					(to.Max.Z - from.Max.Z) * ratio + from.Max.Z
+				)
+			)
+
+		elseif typeString == "UDim" then
+			local to, from = to :: UDim, from :: UDim
+			return UDim.new(
+				(to.Scale - from.Scale) * ratio + from.Scale,
+				(to.Offset - from.Offset) * ratio + from.Offset
+			)
+
+		elseif typeString == "UDim2" then
+			local to, from = to :: UDim2, from :: UDim2
+			return from:Lerp(to, ratio)
+
+		elseif typeString == "Vector2" then
+			local to, from = to :: Vector2, from :: Vector2
+			return from:Lerp(to, ratio)
+
+		elseif typeString == "Vector2int16" then
+			local to, from = to :: Vector2int16, from :: Vector2int16
+			return Vector2int16.new(
+				(to.X - from.X) * ratio + from.X,
+				(to.Y - from.Y) * ratio + from.Y
+			)
+
+		elseif typeString == "Vector3" then
+			local to, from = to :: Vector3, from :: Vector3
+			return from:Lerp(to, ratio)
+
+		elseif typeString == "Vector3int16" then
+			local to, from = to :: Vector3int16, from :: Vector3int16
+			return Vector3int16.new(
+				(to.X - from.X) * ratio + from.X,
+				(to.Y - from.Y) * ratio + from.Y,
+				(to.Z - from.Z) * ratio + from.Z
+			)
+		end
+	end
+
+	-- fallback case: the types are different or not animatable
+	if ratio < 0.5 then
+		return from
+	else
+		return to
+	end
+end
+
+return lerpType

package/vendor/fusion/Animation/packType.luau

@@ -0,0 +1,100 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Packs an array of numbers into a given animatable data type.
+	If the type is not animatable, nil will be returned.
+]]
+
+local Package = script.Parent.Parent
+local Types = require(Package.Types)
+local Oklab = require(Package.Colour.Oklab)
+
+local function packType(
+	numbers: {number},
+	typeString: string
+): Types.Animatable?
+	if typeString == "number" then
+		return numbers[1]
+
+	elseif typeString == "CFrame" then
+		return
+			CFrame.new(numbers[1], numbers[2], numbers[3]) *
+			CFrame.fromAxisAngle(
+				Vector3.new(numbers[4], numbers[5], numbers[6]).Unit,
+				numbers[7]
+			)
+
+	elseif typeString == "Color3" then
+		return Oklab.toSRGB(
+			Vector3.new(numbers[1], numbers[2], numbers[3]),
+			false
+		)
+
+	elseif typeString == "ColorSequenceKeypoint" then
+		return ColorSequenceKeypoint.new(
+			numbers[4],
+			Oklab.toSRGB(
+				Vector3.new(numbers[1], numbers[2], numbers[3]),
+				false
+			)
+		)
+
+	elseif typeString == "DateTime" then
+		return DateTime.fromUnixTimestampMillis(numbers[1])
+
+	elseif typeString == "NumberRange" then
+		return NumberRange.new(numbers[1], numbers[2])
+
+	elseif typeString == "NumberSequenceKeypoint" then
+		return NumberSequenceKeypoint.new(numbers[2], numbers[1], numbers[3])
+
+	elseif typeString == "PhysicalProperties" then
+		return PhysicalProperties.new(numbers[1], numbers[2], numbers[3], numbers[4], numbers[5])
+
+	elseif typeString == "Ray" then
+		return Ray.new(
+			Vector3.new(numbers[1], numbers[2], numbers[3]),
+			Vector3.new(numbers[4], numbers[5], numbers[6])
+		)
+
+	elseif typeString == "Rect" then
+		return Rect.new(numbers[1], numbers[2], numbers[3], numbers[4])
+
+	elseif typeString == "Region3" then
+		-- FUTURE: support rotated Region3s if/when they become constructable
+		local position = Vector3.new(numbers[1], numbers[2], numbers[3])
+		local halfSize = Vector3.new(numbers[4] / 2, numbers[5] / 2, numbers[6] / 2)
+		return Region3.new(position - halfSize, position + halfSize)
+
+	elseif typeString == "Region3int16" then
+		return Region3int16.new(
+			Vector3int16.new(numbers[1], numbers[2], numbers[3]),
+			Vector3int16.new(numbers[4], numbers[5], numbers[6])
+		)
+
+	elseif typeString == "UDim" then
+		return UDim.new(numbers[1], numbers[2])
+
+	elseif typeString == "UDim2" then
+		return UDim2.new(numbers[1], numbers[2], numbers[3], numbers[4])
+
+	elseif typeString == "Vector2" then
+		return Vector2.new(numbers[1], numbers[2])
+
+	elseif typeString == "Vector2int16" then
+		return Vector2int16.new(numbers[1], numbers[2])
+
+	elseif typeString == "Vector3" then
+		return Vector3.new(numbers[1], numbers[2], numbers[3])
+
+	elseif typeString == "Vector3int16" then
+		return Vector3int16.new(numbers[1], numbers[2], numbers[3])
+	else
+		return nil
+	end
+end
+
+return packType

package/vendor/fusion/Animation/springCoefficients.luau

@@ -0,0 +1,80 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Returns a 2x2 matrix of coefficients for a given time, damping and angular
+	frequency (aka 'speed').
+	
+	Specifically, this returns four coefficients - posPos, posVel, velPos, and
+	velVel - which can be multiplied with position and velocity like so:
+
+	local newPosition = oldPosition * posPos + oldVelocity * posVel
+	local newVelocity = oldPosition * velPos + oldVelocity * velVel
+
+	For speed = 1 and damping = 0, the result is a simple harmonic oscillator
+	with a period of tau.
+
+	Special thanks to AxisAngle for helping to improve numerical precision.
+]]
+
+local function springCoefficients(
+	time: number,
+	damping: number,
+	speed: number
+): (number, number, number, number)
+	-- if time or speed is 0, then the spring won't move
+	if time == 0 or speed == 0 then
+		return 1, 0, 0, 1
+	end
+	local posPos, posVel, velPos, velVel
+
+	if damping > 1 then
+		-- overdamped spring
+
+		local alpha = math.sqrt(damping^2 - 1)
+		local negHalf_over_alpha_speed = -0.5 / (alpha * speed)
+		local z1 = speed * (alpha + damping) * -1
+		local z2 = speed * (alpha - damping)
+		local exp1 = math.exp(time * z1)
+		local exp2 = math.exp(time * z2)
+
+		posPos = (exp2 * z1 - exp1 * z2) * negHalf_over_alpha_speed
+		posVel = (exp1 - exp2) * negHalf_over_alpha_speed / speed
+		velPos = (exp2 - exp1) * negHalf_over_alpha_speed * speed
+		velVel = (exp1 * z1 - exp2 * z2) * negHalf_over_alpha_speed
+
+	elseif damping == 1 then
+		-- critically damped spring
+
+		local time_speed = time * speed
+		local time_speed_neg1 = time_speed * -1
+		local exp = math.exp(time_speed_neg1)
+
+		posPos = exp * (time_speed + 1)
+		posVel = exp * time
+		velPos = exp * (time_speed_neg1 * speed)
+		velVel = exp * (time_speed_neg1 + 1)
+	else
+		-- underdamped spring
+
+		local alpha = speed * math.sqrt(1 - damping^2)
+		local overAlpha = 1 / alpha
+		local exp = math.exp(-1 * time * speed * damping)
+		local sin = math.sin(alpha * time)
+		local cos = math.cos(alpha * time)
+		local exp_sin = exp * sin
+		local exp_cos = exp * cos
+		local exp_sin_speed_damping_overAlpha = exp_sin * speed * damping * overAlpha
+
+		posPos = exp_sin_speed_damping_overAlpha + exp_cos
+		posVel = exp_sin * overAlpha
+		velPos = -1 * ( exp_sin * alpha + speed * damping * exp_sin_speed_damping_overAlpha )
+		velVel = exp_cos - exp_sin_speed_damping_overAlpha
+	end
+
+	return posPos, posVel, velPos, velVel
+end
+
+return springCoefficients

package/vendor/fusion/Animation/unpackType.luau

@@ -0,0 +1,103 @@
+--!strict
+--!nolint LocalUnused
+--!nolint LocalShadow
+local task = nil -- Disable usage of Roblox's task scheduler
+
+--[[
+	Unpacks an animatable type into an array of numbers.
+	If the type is not animatable, an empty array will be returned.
+]]
+
+local Package = script.Parent.Parent
+local Oklab = require(Package.Colour.Oklab)
+
+local function unpackType(
+	value: unknown,
+	typeString: string
+): {number}
+	if typeString == "number" then
+		local value = value :: number
+		return {value}
+
+	elseif typeString == "CFrame" then
+		local value = value :: CFrame
+		-- FUTURE: is there a better way of doing this? doing distance
+		-- calculations on `angle` may be incorrect
+		local axis, angle = value:ToAxisAngle()
+		return {value.X, value.Y, value.Z, axis.X, axis.Y, axis.Z, angle}
+
+	elseif typeString == "Color3" then
+		local value = value :: Color3
+		local lab = Oklab.fromSRGB(value)
+		return {lab.X, lab.Y, lab.Z}
+
+	elseif typeString == "ColorSequenceKeypoint" then
+		local value = value :: ColorSequenceKeypoint
+		local lab = Oklab.fromSRGB(value.Value)
+		return {lab.X, lab.Y, lab.Z, value.Time}
+
+	elseif typeString == "DateTime" then
+		local value = value :: DateTime
+		return {value.UnixTimestampMillis}
+
+	elseif typeString == "NumberRange" then
+		local value = value :: NumberRange
+		return {value.Min, value.Max}
+
+	elseif typeString == "NumberSequenceKeypoint" then
+		local value = value :: NumberSequenceKeypoint
+		return {value.Value, value.Time, value.Envelope}
+
+	elseif typeString == "PhysicalProperties" then
+		local value = value :: PhysicalProperties
+		return {value.Density, value.Friction, value.Elasticity, value.FrictionWeight, value.ElasticityWeight}
+
+	elseif typeString == "Ray" then
+		local value = value :: Ray
+		return {value.Origin.X, value.Origin.Y, value.Origin.Z, value.Direction.X, value.Direction.Y, value.Direction.Z}
+
+	elseif typeString == "Rect" then
+		local value = value :: Rect
+		return {value.Min.X, value.Min.Y, value.Max.X, value.Max.Y}
+
+	elseif typeString == "Region3" then
+		local value = value :: Region3
+		-- FUTURE: support rotated Region3s if/when they become constructable
+		return {
+			value.CFrame.X, value.CFrame.Y, value.CFrame.Z,
+			value.Size.X, value.Size.Y, value.Size.Z
+		}
+
+	elseif typeString == "Region3int16" then
+		local value = value :: Region3int16
+		return {value.Min.X, value.Min.Y, value.Min.Z, value.Max.X, value.Max.Y, value.Max.Z}
+
+	elseif typeString == "UDim" then
+		local value = value :: UDim
+		return {value.Scale, value.Offset}
+
+	elseif typeString == "UDim2" then
+		local value = value :: UDim2
+		return {value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset}
+
+	elseif typeString == "Vector2" then
+		local value = value :: Vector2
+		return {value.X, value.Y}
+
+	elseif typeString == "Vector2int16" then
+		local value = value :: Vector2int16
+		return {value.X, value.Y}
+
+	elseif typeString == "Vector3" then
+		local value = value :: Vector3
+		return {value.X, value.Y, value.Z}
+
+	elseif typeString == "Vector3int16" then
+		local value = value :: Vector3int16
+		return {value.X, value.Y, value.Z}
+	else
+		return {}
+	end
+end
+
+return unpackType