@trioforge/crucible 0.1.0 → 0.3.0

package/out/maths/spline/curve.luau

@@ -0,0 +1,1122 @@
+-- Compiled with roblox-ts v3.0.0
+-- Arrow properties compile to dot calls, so Luau callers write curve.pointAt(t) and can detach them.
+local build, catmullRomSpans
+local function catmullRom(points, options)
+	if options == nil then
+		options = {}
+	end
+	local _condition = options.alpha
+	if _condition == nil then
+		_condition = 0.5
+	end
+	local alpha = _condition
+	if not (alpha >= 0 and alpha <= 1) then
+		error(`a Catmull-Rom alpha must be from 0 to 1, got {alpha}`)
+	end
+	return build(points, options, function(lifted, closed)
+		return catmullRomSpans(lifted, closed, alpha)
+	end)
+end
+local bezierSpans
+local function cubicBezier(points, options)
+	if options == nil then
+		options = {}
+	end
+	return build(points, options, bezierSpans)
+end
+local bSplineSpans
+local function uniformBSpline(points, options)
+	if options == nil then
+		options = {}
+	end
+	return build(points, options, bSplineSpans)
+end
+-- A span's squared speed as a polynomial in u, highest power first.
+local UP = Vector3.new(0, 1, 0)
+local AXES = { Vector3.new(1, 0, 0), UP, Vector3.new(0, 0, 1) }
+local LENGTH_DEPTH = 40
+local FRAME_DEPTH = 10
+local FRAME_TURN = math.cos(math.rad(5))
+local SEARCH_BUDGET = 20000
+local GAUSS_INNER = math.sqrt(5 - 2 * math.sqrt(10 / 7)) / 3
+local GAUSS_OUTER = math.sqrt(5 + 2 * math.sqrt(10 / 7)) / 3
+local GAUSS = { { 0, 128 / 225 }, { GAUSS_INNER, (322 + 13 * math.sqrt(70)) / 900 }, { -GAUSS_INNER, (322 + 13 * math.sqrt(70)) / 900 }, { GAUSS_OUTER, (322 - 13 * math.sqrt(70)) / 900 }, { -GAUSS_OUTER, (322 - 13 * math.sqrt(70)) / 900 } }
+local function finite(value)
+	return math.abs(value) < math.huge
+end
+local function liftPlanar(point)
+	local _point = point
+	if not (typeof(_point) == "Vector2") then
+		error("a Vector2 curve takes only Vector2 points")
+	end
+	if not finite(point.X) or not finite(point.Y) then
+		error("curve points must be finite")
+	end
+	return Vector3.new(point.X, point.Y, 0)
+end
+local function lowerPlanar(point)
+	return Vector2.new(point.X, point.Y)
+end
+local function liftSpatial(point)
+	local _point = point
+	if not (typeof(_point) == "Vector3") then
+		error("a Vector3 curve takes only Vector3 points")
+	end
+	if not finite(point.X) or not finite(point.Y) or not finite(point.Z) then
+		error("curve points must be finite")
+	end
+	return point
+end
+local function keepSpatial(point)
+	return point
+end
+local createCurve, shape
+function build(points, options, toSpans)
+	if #points == 0 then
+		error("a curve needs at least one point")
+	end
+	local _condition = options.closed
+	if _condition == nil then
+		_condition = false
+	end
+	local closed = _condition
+	local initialNormal = options.initialNormal
+	local _arg0 = points[1]
+	if typeof(_arg0) == "Vector2" then
+		if initialNormal ~= nil then
+			error("initialNormal applies only to Vector3 curves")
+		end
+		local _fn = toSpans
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#points)
+		for _k, _v in points do
+			_newValue[_k] = liftPlanar(_v, _k - 1, points)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		return createCurve(shape(_fn(_newValue, closed), closed, true), liftPlanar, lowerPlanar)
+	end
+	local seed = if initialNormal == nil then nil else liftSpatial(initialNormal)
+	local _fn = toSpans
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#points)
+	for _k, _v in points do
+		_newValue[_k] = liftSpatial(_v, _k - 1, points)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return createCurve(shape(_fn(_newValue, closed), closed, false, seed), liftSpatial, keepSpatial)
+end
+function shape(spans, closed, planar, initialNormal)
+	local low = spans[1][1]
+	local high = low
+	for _, span in spans do
+		for _1, control in span do
+			if not finite(control.X) or not finite(control.Y) or not finite(control.Z) then
+				error("the curve's controls overflow")
+			end
+			low = low:Min(control)
+			high = high:Max(control)
+		end
+	end
+	local _object = {
+		spans = spans,
+		closed = closed,
+		planar = planar,
+		initialNormal = initialNormal,
+	}
+	local _left = "tolerance"
+	local _high = high
+	local _low = low
+	_object[_left] = math.max(1e-4, 1e-5 * (_high - _low).Magnitude)
+	return _object
+end
+-- One axis of a span's velocity as a polynomial in u, constant term first.
+local function hodograph(a, b, c, d)
+	return 3 * (b - a), 6 * (c - 2 * b + a), 3 * (d - 3 * c + 3 * b - a)
+end
+-- Expanded from components in doubles, so arc length integrates without Vector3 arithmetic.
+local function squaredSpeed(_param)
+	local a = _param[1]
+	local b = _param[2]
+	local c = _param[3]
+	local d = _param[4]
+	local x0, x1, x2 = hodograph(a.X, b.X, c.X, d.X)
+	local y0, y1, y2 = hodograph(a.Y, b.Y, c.Y, d.Y)
+	local z0, z1, z2 = hodograph(a.Z, b.Z, c.Z, d.Z)
+	return { x2 * x2 + y2 * y2 + z2 * z2, 2 * (x2 * x1 + y2 * y1 + z2 * z1), x1 * x1 + y1 * y1 + z1 * z1 + 2 * (x2 * x0 + y2 * y0 + z2 * z0), 2 * (x1 * x0 + y1 * y0 + z1 * z0), x0 * x0 + y0 * y0 + z0 * z0 }
+end
+function catmullRomSpans(input, closed, alpha)
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(point, index)
+		return index == 0 or point ~= input[index]
+	end
+	local _length = 0
+	for _k, _v in input do
+		if _callback(_v, _k - 1, input) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	local points = _newValue
+	if closed and #points > 1 and points[#points] == points[1] then
+		points[#points] = nil
+	end
+	local count = #points
+	if count == 1 then
+		return { { points[1], points[1], points[1], points[1] } }
+	end
+	if closed and count < 3 then
+		error("a closed Catmull-Rom curve needs three distinct points")
+	end
+	local at = function(index)
+		if closed then
+			return points[(index + count) % count + 1]
+		end
+		if index < 0 then
+			local _exp = points[1] * 2
+			local _arg0 = points[2]
+			return _exp - _arg0
+		end
+		if index >= count then
+			local _exp = points[count] * 2
+			local _arg0 = points[count - 1]
+			return _exp - _arg0
+		end
+		return points[index + 1]
+	end
+	local last = if closed then count - 1 else count - 2
+	-- gaps[k] spaces at(k - 1) and at(k). Neighboring spans share them.
+	local gaps = {}
+	for index = -1, last + 1 do
+		local _exp = at(index + 1)
+		local _arg0 = at(index)
+		local _arg0_1 = (_exp - _arg0).Magnitude ^ alpha
+		table.insert(gaps, _arg0_1)
+	end
+	local span = function(index)
+		local p0, p1, p2, p3 = at(index - 1), at(index), at(index + 1), at(index + 2)
+		local d01, d12, d23 = gaps[index + 1], gaps[index + 2], gaps[index + 3]
+		local _exp = (p1 - p0) / d01
+		local _exp_1 = p2 - p0
+		local _arg0 = d01 + d12
+		local _arg0_1 = (p2 - p1) / d12
+		local m1 = _exp - (_exp_1 / _arg0) + _arg0_1
+		local _exp_2 = (p2 - p1) / d12
+		local _exp_3 = p3 - p1
+		local _arg0_2 = d12 + d23
+		local _arg0_3 = (p3 - p2) / d23
+		local m2 = _exp_2 - (_exp_3 / _arg0_2) + _arg0_3
+		local _arg0_4 = d12 / 3
+		local _arg0_5 = m1 * _arg0_4
+		local _exp_4 = p1 + _arg0_5
+		local _arg0_6 = d12 / 3
+		local _arg0_7 = m2 * _arg0_6
+		return { p1, _exp_4, p2 - _arg0_7, p2 }
+	end
+	local spans = { span(0) }
+	for index = 1, last do
+		local _arg0 = span(index)
+		table.insert(spans, _arg0)
+	end
+	return spans
+end
+function bezierSpans(points, closed)
+	local count = #points
+	if if closed then count % 3 ~= 0 else count < 4 or count % 3 ~= 1 then
+		error(`a {if closed then "closed cubic Bezier needs 3n" else "cubic Bezier needs 3n + 1"} points, got {count}`)
+	end
+	local span = function(start)
+		return { points[start + 1], points[start + 2], points[start + 3], points[(start + 3) % count + 1] }
+	end
+	local spans = { span(0) }
+	for index = 1, math.floor(count / 3) - 1 do
+		local _arg0 = span(index * 3)
+		table.insert(spans, _arg0)
+	end
+	return spans
+end
+function bSplineSpans(points, closed)
+	local count = #points
+	local least = if closed then 3 else 4
+	if count < least then
+		error(`a {if closed then "closed " else ""}uniform B-spline needs {least} points, got {count}`)
+	end
+	local at = function(index)
+		return points[(if closed then (index + count - 1) % count else index) + 1]
+	end
+	local thirdOrSame = function(near, far)
+		local _result
+		if near == far then
+			_result = near
+		else
+			local _exp = near * 2
+			local _far = far
+			_result = (_exp + _far) / 3
+		end
+		return _result
+	end
+	local jointOrSame = function(a, b, c)
+		local _result
+		if a == b and b == c then
+			_result = b
+		else
+			local _a = a
+			local _arg0 = b * 4
+			local _c = c
+			_result = (_a + _arg0 + _c) / 6
+		end
+		return _result
+	end
+	local span = function(index)
+		local q0, q1, q2, q3 = at(index), at(index + 1), at(index + 2), at(index + 3)
+		return { jointOrSame(q0, q1, q2), thirdOrSame(q1, q2), thirdOrSame(q2, q1), jointOrSame(q1, q2, q3) }
+	end
+	local spans = { span(0) }
+	for index = 1, (if closed then count else count - 3) - 1 do
+		local _arg0 = span(index)
+		table.insert(spans, _arg0)
+	end
+	return spans
+end
+local function locate(geometry, parameter)
+	local count = #geometry.spans
+	local wrapped = if geometry.closed then parameter - math.floor(parameter) else math.clamp(parameter, 0, 1)
+	local scaled = wrapped * count
+	local index = math.min(math.floor(scaled), count - 1)
+	return index, scaled - index
+end
+local function bernstein(_param, u)
+	local a = _param[1]
+	local b = _param[2]
+	local c = _param[3]
+	local d = _param[4]
+	local v = 1 - u
+	local _arg0 = v * v * v
+	local _exp = a * _arg0
+	local _arg0_1 = 3 * v * v * u
+	local _arg0_2 = b * _arg0_1
+	local _arg0_3 = 3 * v * u * u
+	local _arg0_4 = c * _arg0_3
+	local _arg0_5 = u * u * u
+	local _arg0_6 = d * _arg0_5
+	return _exp + _arg0_2 + _arg0_4 + _arg0_6
+end
+local function velocity(_param, u)
+	local a = _param[1]
+	local b = _param[2]
+	local c = _param[3]
+	local d = _param[4]
+	local v = 1 - u
+	local _exp = b - a
+	local _arg0 = 3 * v * v
+	local _exp_1 = c - b
+	local _arg0_1 = 6 * v * u
+	local _exp_2 = d - c
+	local _arg0_2 = 3 * u * u
+	return _exp * _arg0 + (_exp_1 * _arg0_1) + (_exp_2 * _arg0_2)
+end
+local function acceleration(_param, u)
+	local a = _param[1]
+	local b = _param[2]
+	local c = _param[3]
+	local d = _param[4]
+	local _arg0 = b * 2
+	local _exp = c - _arg0 + a
+	local _arg0_1 = 6 * (1 - u)
+	local _arg0_2 = c * 2
+	local _exp_1 = d - _arg0_2 + b
+	local _arg0_3 = 6 * u
+	return _exp * _arg0_1 + (_exp_1 * _arg0_3)
+end
+local function direction(vector)
+	local size = vector.Magnitude
+	return if size > 0 then vector / size else nil
+end
+-- Rounding can take a near-zero square slightly negative.
+local function speed(_param, u)
+	local u4 = _param[1]
+	local u3 = _param[2]
+	local u2 = _param[3]
+	local u1 = _param[4]
+	local u0 = _param[5]
+	return math.sqrt(math.max((((u4 * u + u3) * u + u2) * u + u1) * u + u0, 0))
+end
+local function travel(_param, from, to)
+	local u4 = _param[1]
+	local u3 = _param[2]
+	local u2 = _param[3]
+	local u1 = _param[4]
+	local u0 = _param[5]
+	local half = (to - from) / 2
+	local middle = (from + to) / 2
+	local sum = 0
+	for _, _binding in GAUSS do
+		local node = _binding[1]
+		local weight = _binding[2]
+		local u = middle + half * node
+		sum += weight * math.sqrt(math.max((((u4 * u + u3) * u + u2) * u + u1) * u + u0, 0))
+	end
+	return sum * half
+end
+local function measure(geometry)
+	local count = #geometry.spans
+	local length = 0
+	local _exp = geometry.spans
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	for _k, _v in _exp do
+		_newValue[_k] = squaredSpeed(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local quartics = _newValue
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue_1 = table.create(#quartics)
+	local _callback = function(quartic)
+		local stops = { 0 }
+		local distances = { length }
+		local speeds = { speed(quartic, 0) }
+		local visit
+		visit = function(from, to, whole, depth)
+			local middle = (from + to) / 2
+			local left = travel(quartic, from, middle)
+			local right = travel(quartic, middle, to)
+			local allowed = math.max((geometry.tolerance * (to - from)) / count, 1e-6 * whole)
+			if depth >= 2 and math.abs(left + right - whole) <= allowed then
+				length += left + right
+				local _to = to
+				table.insert(stops, _to)
+				local _length = length
+				table.insert(distances, _length)
+				local _arg0 = speed(quartic, to)
+				table.insert(speeds, _arg0)
+				return nil
+			end
+			if depth >= LENGTH_DEPTH then
+				error("a curve span is too irregular to measure")
+			end
+			visit(from, middle, left, depth + 1)
+			visit(middle, to, right, depth + 1)
+		end
+		visit(0, 1, travel(quartic, 0, 1), 0)
+		return {
+			stops = stops,
+			distances = distances,
+			speeds = speeds,
+		}
+	end
+	for _k, _v in quartics do
+		_newValue_1[_k] = _callback(_v, _k - 1, quartics)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local spans = _newValue_1
+	local _object = {
+		quartics = quartics,
+		spans = spans,
+	}
+	local _left = "ends"
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue_2 = table.create(#spans)
+	local _callback_1 = function(_param)
+		local distances = _param.distances
+		return distances[#distances]
+	end
+	for _k, _v in spans do
+		_newValue_2[_k] = _callback_1(_v, _k - 1, spans)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	_object[_left] = _newValue_2
+	_object.length = length
+	return _object
+end
+local function lastAtMost(values, value)
+	local low = 0
+	local high = #values - 1
+	while low < high do
+		local middle = math.ceil((low + high) / 2)
+		if values[middle + 1] <= value then
+			low = middle
+		else
+			high = middle - 1
+		end
+	end
+	return low
+end
+local function firstAtLeast(values, value, from)
+	if from == nil then
+		from = 0
+	end
+	local low = from
+	local high = #values - 1
+	while low < high do
+		local middle = math.floor((low + high) / 2)
+		if values[middle + 1] >= value then
+			high = middle
+		else
+			low = middle + 1
+		end
+	end
+	return low
+end
+local function distanceAt(arc, index, u)
+	local _binding = arc.spans[index + 1]
+	local stops = _binding.stops
+	local distances = _binding.distances
+	local station = lastAtMost(stops, u)
+	if stops[station + 1] == u then
+		return distances[station + 1]
+	end
+	return distances[station + 1] + travel(arc.quartics[index + 1], stops[station + 1], u)
+end
+-- Inverts distance over one stop with a cubic Hermite in the stop's share of distance, using du/ds = 1 / speed.
+local function hermiteGuess(low, high, run, share, startSpeed, endSpeed)
+	local linear = low + (high - low) * share
+	if not (startSpeed > 0 and endSpeed > 0) then
+		return linear
+	end
+	local square = share * share
+	local cube = square * share
+	local guess = low * (2 * cube - 3 * square + 1) + (run / startSpeed) * (cube - 2 * square + share) + high * (3 * square - 2 * cube) + (run / endSpeed) * (cube - square)
+	return if guess > low and guess < high then guess else linear
+end
+local function parameterAt(geometry, arc, distance)
+	local total = arc.length
+	if geometry.closed then
+		distance -= math.floor(distance / total) * total
+	end
+	if not (distance > 0 and distance < total) then
+		return if geometry.closed or distance <= 0 then 0 else 1
+	end
+	local count = #geometry.spans
+	local index = firstAtLeast(arc.ends, distance)
+	local quartic = arc.quartics[index + 1]
+	local _binding = arc.spans[index + 1]
+	local stops = _binding.stops
+	local distances = _binding.distances
+	local speeds = _binding.speeds
+	local station = firstAtLeast(distances, distance, 1) - 1
+	local from = stops[station + 1]
+	local start = distances[station + 1]
+	local run = distances[station + 2] - start
+	local low = from
+	local high = stops[station + 2]
+	local u = if run > 0 then hermiteGuess(low, high, run, (distance - start) / run, speeds[station + 1], speeds[station + 2]) else low
+	do
+		local step = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				step += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (step < 40 and high - low > 1e-12) then
+				break
+			end
+			local miss = start + travel(quartic, from, u) - distance
+			if math.abs(miss) <= geometry.tolerance * 1e-2 then
+				break
+			end
+			if miss > 0 then
+				high = u
+			else
+				low = u
+			end
+			local pace = speed(quartic, u)
+			local stepped = if pace > 0 then u - miss / pace else low
+			u = if stepped > low and stepped < high then stepped else (low + high) / 2
+		end
+	end
+	return (index + u) / count
+end
+local function perpendicular(vector, tangent)
+	local _vector = vector
+	local _tangent = tangent
+	local _arg0 = tangent:Dot(vector)
+	local flat = _vector - (_tangent * _arg0)
+	local size = flat.Magnitude
+	return if size > 1e-4 * vector.Magnitude then flat / size else nil
+end
+local function seed(tangent, preferred)
+	if preferred == nil then
+		preferred = UP
+	end
+	local normal = perpendicular(preferred, tangent)
+	if normal ~= nil then
+		return normal
+	end
+	local axis = AXES[1]
+	for _, candidate in AXES do
+		if math.abs(candidate:Dot(tangent)) < math.abs(axis:Dot(tangent)) then
+			axis = candidate
+		end
+	end
+	local _axis = axis
+	local _tangent = tangent
+	local _arg0 = tangent:Dot(axis)
+	return (_axis - (_tangent * _arg0)).Unit
+end
+local function minimalRotation(from, to, normal)
+	local _from = from
+	local _to = to
+	local sum = _from + _to
+	local size = sum:Dot(sum)
+	if size <= 1e-12 then
+		return normal
+	end
+	local _normal = normal
+	local _from_1 = from
+	local _arg0 = 2 * from:Dot(normal)
+	local flipped = _normal - (_from_1 * _arg0)
+	local _arg0_1 = (2 * sum:Dot(flipped)) / size
+	local _arg0_2 = sum * _arg0_1
+	return flipped - _arg0_2
+end
+local function transport(from, point, tangent, tolerance)
+	local _point = point
+	local _point_1 = from.point
+	local chord = _point - _point_1
+	local c1 = chord:Dot(chord)
+	local normal
+	if c1 <= (tolerance * 1e-3) ^ 2 then
+		normal = minimalRotation(from.tangent, tangent, from.normal)
+	else
+		local _normal = from.normal
+		local _arg0 = (2 * chord:Dot(from.normal)) / c1
+		local _arg0_1 = chord * _arg0
+		local reflectedNormal = _normal - _arg0_1
+		local _tangent = from.tangent
+		local _arg0_2 = (2 * chord:Dot(from.tangent)) / c1
+		local _arg0_3 = chord * _arg0_2
+		local reflectedTangent = _tangent - _arg0_3
+		local second = tangent - reflectedTangent
+		local c2 = second:Dot(second)
+		local _result
+		if c2 > 0 then
+			local _arg0_4 = (2 * second:Dot(reflectedNormal)) / c2
+			local _arg0_5 = second * _arg0_4
+			_result = reflectedNormal - _arg0_5
+		else
+			_result = reflectedNormal
+		end
+		normal = _result
+	end
+	return perpendicular(normal, tangent) or seed(tangent, from.normal)
+end
+-- Returns the stops that have a tangent, with that tangent, which the frame table reuses.
+local function frameStops(span)
+	local stops = {}
+	local tangents = {}
+	local keep = function(u, tangent)
+		if tangent == nil then
+			return nil
+		end
+		local _u = u
+		table.insert(stops, _u)
+		local _tangent = tangent
+		table.insert(tangents, _tangent)
+	end
+	local start = direction(velocity(span, 0))
+	keep(0, start)
+	local turns = function(a, b)
+		return if a == nil or b == nil then a ~= b else a:Dot(b) < FRAME_TURN
+	end
+	local visit
+	visit = function(from, fromTangent, to, toTangent, depth)
+		local middle = (from + to) / 2
+		local middleTangent = direction(velocity(span, middle))
+		if depth < FRAME_DEPTH and (depth < 2 or turns(fromTangent, middleTangent) or turns(middleTangent, toTangent)) then
+			visit(from, fromTangent, middle, middleTangent, depth + 1)
+			visit(middle, middleTangent, to, toTangent, depth + 1)
+		else
+			keep(to, toTangent)
+		end
+	end
+	visit(0, start, 1, direction(velocity(span, 1)), 0)
+	return stops, tangents
+end
+local function travelBetween(quartics, from, fromU, to, toU)
+	if from == to then
+		return travel(quartics[from + 1], fromU, toU)
+	end
+	local sum = travel(quartics[from + 1], fromU, 1) + travel(quartics[to + 1], 0, toU)
+	for index = from + 1, to - 1 do
+		sum += travel(quartics[index + 1], 0, 1)
+	end
+	return sum
+end
+local function transportFrames(geometry)
+	local positions = {}
+	local stations = {}
+	local _exp = geometry.spans
+	-- ▼ ReadonlyArray.forEach ▼
+	local _callback = function(span, index)
+		local stops, tangents = frameStops(span)
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_1 = function(u, position)
+			local tangent = tangents[position + 1]
+			local point = bernstein(span, u)
+			local normal = if #stations == 0 then seed(tangent, geometry.initialNormal) else transport(stations[#stations], point, tangent, geometry.tolerance)
+			local _arg0 = index + u
+			table.insert(positions, _arg0)
+			local _arg0_1 = {
+				index = index,
+				u = u,
+				point = point,
+				tangent = tangent,
+				normal = normal,
+			}
+			table.insert(stations, _arg0_1)
+		end
+		for _k, _v in stops do
+			_callback_1(_v, _k - 1, stops)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+	end
+	for _k, _v in _exp do
+		_callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.forEach ▲
+	local count = #geometry.spans
+	local first = stations[1]
+	local last = stations[#stations]
+	if not geometry.closed or #stations == 0 or positions[1] ~= 0 or positions[#positions] ~= count then
+		return {
+			positions = positions,
+			stations = stations,
+			seamRoll = 0,
+			quartics = {},
+			distances = {},
+		}
+	end
+	local arrived = minimalRotation(last.tangent, first.tangent, last.normal)
+	local seamRoll = math.atan2(first.tangent:Dot(arrived:Cross(first.normal)), arrived:Dot(first.normal))
+	local _exp_1 = geometry.spans
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp_1)
+	for _k, _v in _exp_1 do
+		_newValue[_k] = squaredSpeed(_v, _k - 1, _exp_1)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local quartics = _newValue
+	local distances = { 0 }
+	for index = 1, #stations - 1 do
+		local from, to = stations[index], stations[index + 1]
+		local _arg0 = distances[index] + travelBetween(quartics, from.index, from.u, to.index, to.u)
+		table.insert(distances, _arg0)
+	end
+	return {
+		positions = positions,
+		stations = stations,
+		seamRoll = seamRoll,
+		quartics = quartics,
+		distances = distances,
+	}
+end
+local roll
+local function spatialNormal(geometry, frames, index, u, point, tangent)
+	if #frames.stations == 0 then
+		return seed(tangent, geometry.initialNormal)
+	end
+	local found = lastAtMost(frames.positions, index + u)
+	local station = frames.stations[found + 1]
+	local normal = transport(station, point, tangent, geometry.tolerance)
+	if frames.seamRoll == 0 then
+		return normal
+	end
+	-- The seam correction spreads by distance from the first station to the last.
+	local _binding = frames
+	local quartics = _binding.quartics
+	local distances = _binding.distances
+	local distance = distances[found + 1] + travelBetween(quartics, station.index, station.u, index, u)
+	return roll(normal, tangent, (frames.seamRoll * distance) / distances[#distances])
+end
+function roll(normal, axis, angle)
+	local _normal = normal
+	local _arg0 = math.cos(angle)
+	local _exp = axis:Cross(normal)
+	local _arg0_1 = math.sin(angle)
+	return _normal * _arg0 + (_exp * _arg0_1)
+end
+local function halve(_param)
+	local a = _param[1]
+	local b = _param[2]
+	local c = _param[3]
+	local d = _param[4]
+	local ab = (a + b) * 0.5
+	local bc = (b + c) * 0.5
+	local cd = (c + d) * 0.5
+	local abc = (ab + bc) * 0.5
+	local bcd = (bc + cd) * 0.5
+	local middle = (abc + bcd) * 0.5
+	return { a, ab, abc, middle }, { middle, bcd, cd, d }
+end
+local function segmentGap(point, a, d)
+	local _d = d
+	local _a = a
+	local chord = _d - _a
+	local _point = point
+	local _a_1 = a
+	local offset = _point - _a_1
+	local along = chord:Dot(chord)
+	if along <= 0 then
+		return offset.Magnitude
+	end
+	local _arg0 = math.clamp(offset:Dot(chord) / along, 0, 1)
+	local _arg0_1 = chord * _arg0
+	return (offset - _arg0_1).Magnitude
+end
+local function boxGap(low, high, query)
+	local _query = query
+	local _arg0 = query:Max(low):Min(high)
+	return (_query - _arg0).Magnitude
+end
+-- Both bounds hold by the convex hull property. The chord bound shrinks with the square of a piece's size,
+-- the box bound only linearly, but the box is tighter on wide pieces such as a loop's whole span.
+local function gapBound(controls, query)
+	local _binding = controls
+	local a = _binding[1]
+	local b = _binding[2]
+	local c = _binding[3]
+	local d = _binding[4]
+	local reach = math.max(segmentGap(b, a, d), segmentGap(c, a, d))
+	return math.max(boxGap(a:Min(b, c, d), a:Max(b, c, d), query), segmentGap(query, a, d) - reach)
+end
+-- Boxes over runs of neighboring spans, so a query skips spans far from it.
+local function cluster(spans, first, last)
+	if first == last then
+		local _binding = spans[first + 1]
+		local a = _binding[1]
+		local b = _binding[2]
+		local c = _binding[3]
+		local d = _binding[4]
+		return {
+			low = a:Min(b, c, d),
+			high = a:Max(b, c, d),
+			index = first,
+		}
+	end
+	local middle = math.floor((first + last) / 2)
+	local left = cluster(spans, first, middle)
+	local right = cluster(spans, middle + 1, last)
+	return {
+		low = left.low:Min(right.low),
+		high = left.high:Max(right.high),
+		index = first,
+		children = { left, right },
+	}
+end
+local function pushEntry(heap, entry)
+	local position = #heap
+	local _heap = heap
+	local _entry = entry
+	table.insert(_heap, _entry)
+	while position > 0 do
+		local parent = math.floor((position - 1) / 2)
+		if heap[parent + 1].bound <= entry.bound then
+			break
+		end
+		heap[position + 1] = heap[parent + 1]
+		position = parent
+	end
+	heap[position + 1] = entry
+end
+local function popEntry(heap)
+	local top = heap[1]
+	-- ▼ Array.pop ▼
+	local _length = #heap
+	local _result = heap[_length]
+	heap[_length] = nil
+	-- ▲ Array.pop ▲
+	local last = _result
+	local size = #heap
+	if last == nil or size == 0 then
+		return last
+	end
+	local position = 0
+	do
+		local _child = 1
+		local _shouldIncrement = false
+		while true do
+			local child = _child
+			if _shouldIncrement then
+				child = 2 * position + 1
+			else
+				_shouldIncrement = true
+			end
+			if not (child < size) then
+				break
+			end
+			if child + 1 < size and heap[child + 2].bound < heap[child + 1].bound then
+				child += 1
+			end
+			if heap[child + 1].bound >= last.bound then
+				break
+			end
+			heap[position + 1] = heap[child + 1]
+			position = child
+			_child = child
+		end
+	end
+	heap[position + 1] = last
+	return top
+end
+local polish
+local function nearest(geometry, tree, query)
+	local tolerance = geometry.tolerance
+	local _object = {
+		index = 0,
+		u = 0,
+	}
+	local _left = "separation"
+	local _exp = geometry.spans[1][1]
+	local _query = query
+	_object[_left] = (_exp - _query).Magnitude
+	local best = _object
+	local offer = function(index, u, point)
+		local _point = point
+		local _query_1 = query
+		local separation = (_point - _query_1).Magnitude
+		if separation < best.separation or (separation == best.separation and index + u < best.index + best.u) then
+			best = {
+				index = index,
+				u = u,
+				separation = separation,
+			}
+		end
+	end
+	local heap = { {
+		bound = boxGap(tree.low, tree.high, query),
+		cluster = tree,
+	} }
+	do
+		local step = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				step += 1
+			else
+				_shouldIncrement = true
+			end
+			local entry = popEntry(heap)
+			if entry == nil or entry.bound >= best.separation - tolerance then
+				break
+			end
+			if step >= SEARCH_BUDGET then
+				error("the closest point search did not converge")
+			end
+			if entry.cluster ~= nil then
+				local _binding = entry.cluster
+				local index = _binding.index
+				local children = _binding.children
+				if children ~= nil then
+					for _, child in children do
+						local bound = boxGap(child.low, child.high, query)
+						if bound < best.separation - tolerance then
+							pushEntry(heap, {
+								bound = bound,
+								cluster = child,
+							})
+						end
+					end
+					continue
+				end
+				local span = geometry.spans[index + 1]
+				offer(index, 0, span[1])
+				offer(index, 1, span[4])
+				local bound = gapBound(span, query)
+				if bound < best.separation - tolerance then
+					pushEntry(heap, {
+						index = index,
+						controls = span,
+						from = 0,
+						to = 1,
+						bound = bound,
+					})
+				end
+				continue
+			end
+			local _binding = entry
+			local index = _binding.index
+			local controls = _binding.controls
+			local from = _binding.from
+			local to = _binding.to
+			local _binding_1 = controls
+			local a = _binding_1[1]
+			local d = _binding_1[4]
+			-- The chord's foot lands near the piece's closest point, so the best gap tightens quickly.
+			local chord = d - a
+			local along = chord:Dot(chord)
+			if along > 0 then
+				local u = from + (to - from) * math.clamp((query - a):Dot(chord) / along, 0, 1)
+				offer(index, u, bernstein(geometry.spans[index + 1], u))
+			end
+			local middle = (from + to) / 2
+			local left, right = halve(controls)
+			offer(index, middle, left[4])
+			local limit = best.separation - tolerance
+			local leftBound = gapBound(left, query)
+			if leftBound < limit then
+				pushEntry(heap, {
+					index = index,
+					controls = left,
+					from = from,
+					to = middle,
+					bound = leftBound,
+				})
+			end
+			local rightBound = gapBound(right, query)
+			if rightBound < limit then
+				pushEntry(heap, {
+					index = index,
+					controls = right,
+					from = middle,
+					to = to,
+					bound = rightBound,
+				})
+			end
+		end
+	end
+	return polish(geometry, query, best)
+end
+-- The search stops within tolerance, which can leave the best point on a joint while the true closest point
+-- lies just inside the neighboring span, where Newton's clamp to one span can't reach.
+local refineClosest
+function polish(geometry, query, found)
+	local best = refineClosest(geometry.spans[found.index + 1], query, found)
+	local count = #geometry.spans
+	local step = if best.u == 1 then 1 elseif best.u == 0 then -1 else 0
+	local neighbor = best.index + step
+	if step == 0 or (not geometry.closed and (neighbor < 0 or neighbor >= count)) then
+		return best
+	end
+	local index = (neighbor + count) % count
+	local across = refineClosest(geometry.spans[index + 1], query, {
+		index = index,
+		u = if step > 0 then 0 else 1,
+		separation = best.separation,
+	})
+	return if across.separation < best.separation then across else best
+end
+function refineClosest(span, query, found)
+	local best = found
+	local u = best.u
+	for step = 0, 7 do
+		local _exp = bernstein(span, u)
+		local _query = query
+		local offset = _exp - _query
+		local motion = velocity(span, u)
+		local slope = motion:Dot(motion) + offset:Dot(acceleration(span, u))
+		if not (slope > 0) then
+			break
+		end
+		u = math.clamp(u - offset:Dot(motion) / slope, 0, 1)
+		local _exp_1 = bernstein(span, u)
+		local _query_1 = query
+		local separation = (_exp_1 - _query_1).Magnitude
+		if not (separation < best.separation) then
+			break
+		end
+		best = {
+			index = best.index,
+			u = u,
+			separation = separation,
+		}
+	end
+	return best
+end
+function createCurve(geometry, lift, lower)
+	local arc
+	local frames
+	local tree
+	local measured = function()
+		if arc == nil then
+			arc = measure(geometry)
+		end
+		return arc
+	end
+	local framed = function()
+		if frames == nil then
+			frames = transportFrames(geometry)
+		end
+		return frames
+	end
+	local clustered = function()
+		if tree == nil then
+			tree = cluster(geometry.spans, 0, #geometry.spans - 1)
+		end
+		return tree
+	end
+	local locateChecked = function(parameter)
+		if not finite(parameter) then
+			error("curve parameters must be finite")
+		end
+		return locate(geometry, parameter)
+	end
+	return {
+		pointAt = function(parameter)
+			local index, u = locateChecked(parameter)
+			return lower(bernstein(geometry.spans[index + 1], u))
+		end,
+		tangentAt = function(parameter)
+			local index, u = locateChecked(parameter)
+			local tangent = direction(velocity(geometry.spans[index + 1], u))
+			return if tangent == nil then nil else lower(tangent)
+		end,
+		frameAt = function(parameter)
+			local index, u = locateChecked(parameter)
+			local span = geometry.spans[index + 1]
+			local tangent = direction(velocity(span, u))
+			if tangent == nil then
+				return nil
+			end
+			local point = bernstein(span, u)
+			local normal = if geometry.planar then Vector3.new(-tangent.Y, tangent.X, 0) else spatialNormal(geometry, framed(), index, u, point, tangent)
+			return {
+				point = lower(point),
+				tangent = lower(tangent),
+				normal = lower(normal),
+			}
+		end,
+		length = function()
+			return measured().length
+		end,
+		parameterAtDistance = function(distance)
+			if not finite(distance) then
+				error("curve distances must be finite")
+			end
+			local lengths = measured()
+			return if lengths.length > 0 then parameterAt(geometry, lengths, distance) else 0
+		end,
+		distanceAtParameter = function(parameter)
+			local index, u = locateChecked(parameter)
+			return distanceAt(measured(), index, u)
+		end,
+		closest = function(query)
+			local target = lift(query)
+			local found = nearest(geometry, clustered(), target)
+			local count = #geometry.spans
+			local parameter = if geometry.closed and found.index + found.u >= count then 0 else (found.index + found.u) / count
+			local index, u = locate(geometry, parameter)
+			local point = bernstein(geometry.spans[index + 1], u)
+			return {
+				parameter = parameter,
+				point = lower(point),
+				distance = distanceAt(measured(), index, u),
+				separation = (point - target).Magnitude,
+			}
+		end,
+		prepare = function()
+			measured()
+			clustered()
+			if not geometry.planar then
+				framed()
+			end
+		end,
+	}
+end
+return {
+	catmullRom = catmullRom,
+	cubicBezier = cubicBezier,
+	uniformBSpline = uniformBSpline,
+}