cluaupp 1.0.0 → 1.4.0

package/runtime/Fusion/Animation/Tween.luau

@@ -1,178 +0,0 @@
---!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()
-
-	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._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/runtime/Fusion/Animation/getTweenDuration.luau

@@ -1,27 +0,0 @@
---!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/runtime/Fusion/Animation/getTweenRatio.luau

@@ -1,47 +0,0 @@
---!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/runtime/Fusion/Animation/lerpType.luau

@@ -1,164 +0,0 @@
---!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/runtime/Fusion/Animation/packType.luau

@@ -1,100 +0,0 @@
---!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(math.round(numbers[1]), math.round(numbers[2]), math.round(numbers[3])),
-			Vector3int16.new(math.round(numbers[4]), math.round(numbers[5]), math.round(numbers[6]))
-		)
-
-	elseif typeString == "UDim" then
-		return UDim.new(numbers[1], math.round(numbers[2]))
-
-	elseif typeString == "UDim2" then
-		return UDim2.new(numbers[1], math.round(numbers[2]), numbers[3], math.round(numbers[4]))
-
-	elseif typeString == "Vector2" then
-		return Vector2.new(numbers[1], numbers[2])
-
-	elseif typeString == "Vector2int16" then
-		return Vector2int16.new(math.round(numbers[1]), math.round(numbers[2]))
-
-	elseif typeString == "Vector3" then
-		return Vector3.new(numbers[1], numbers[2], numbers[3])
-
-	elseif typeString == "Vector3int16" then
-		return Vector3int16.new(math.round(numbers[1]), math.round(numbers[2]), math.round(numbers[3]))
-	else
-		return nil
-	end
-end
-
-return packType

package/runtime/Fusion/Animation/springCoefficients.luau

@@ -1,80 +0,0 @@
---!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/runtime/Fusion/Animation/unpackType.luau

@@ -1,103 +0,0 @@
---!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