-- Shared helpers for the Data.Int FFI. PureScript Int is 32-bit two's

-- complement; these mirror the JS semantics the upstream FFI relies on.

-- JS ToInt32: truncate toward zero, then wrap to signed 32-bit.

local function toInt32(n)

n = math.modf(n)

n = n % 0x100000000

if n >= 0x80000000 then n = n - 0x100000000 end

return n

end

-- Value of a single base-36 digit (0-9, a-z / A-Z), or nil if not a digit.

local function digitValue(c)

local b = c:byte()

if b >= 48 and b <= 57 then return b - 48 end

if b >= 97 and b <= 122 then return b - 97 + 10 end

if b >= 65 and b <= 90 then return b - 65 + 10 end

return nil

end

return {

fromNumberImpl = (function(just)

return function(nothing)

return function(n)

-- Just only for an integral value inside the Int32 range (JS:

-- `(n | 0) === n ? just(n) : nothing`); otherwise Nothing.

local i = math.modf(n)

if i == n and n >= -2147483648 and n <= 2147483647 then return just(n) end

return nothing

end

end

end),

toNumber = (function(n) return n end),

fromStringAsImpl = (function(just)

return function(nothing)

return function(radix)

return function(s)

-- Mirror the JS regex `^[+-]?<digits>+$` + Int32 range check:

-- parse the sign ourselves (Lua 5.1 `tonumber` mishandles a leading

-- '-' in non-decimal bases) and reject any illegal digit, fractional

-- point, or surrounding whitespace that `tonumber` would tolerate.

local sign, body = 1, s

local first = s:sub(1, 1)

if first == "-" then

sign, body = -1, s:sub(2)

elseif first == "+" then

body = s:sub(2)

end

if #body == 0 then return nothing end

local n = 0

for i = 1, #body do

local d = digitValue(body:sub(i, i))

if d == nil or d >= radix then return nothing end

n = n * radix + d

end

n = sign * n

if n < -2147483648 or n > 2147483647 then return nothing end

return just(n)

end

end

end

end),

toStringAs = (function(radix)

return function(i)

local floor, insert = math.floor, table.insert

local n = floor(i)

if radix == 10 then return tostring(n) end

-- JS Number.prototype.toString(radix) uses lowercase digits.

local digits = "0123456789abcdefghijklmnopqrstuvwxyz"

local t = {}

local sign = ""

if n < 0 then

sign = "-"

n = -n

end

repeat

local d = (n % radix) + 1

n = floor(n / radix)

insert(t, 1, digits:sub(d, d))

until n == 0

return sign .. table.concat(t, "")

end

end),

quot = (function(x)

return function(y)

if y == 0 then return 0 end

local q, _ = math.modf(x / y)

return q

end

end),

rem = (function(x)

return function(y)

-- Truncated remainder with the sign of the dividend (JS `x % y`),

-- consistent with `quot`; Lua's `%` is floored and differs in sign.

if y == 0 then return 0 end

local q = math.modf(x / y)

return x - q * y

end

end),

pow = (function(x)

return function(y)

-- JS `Math.pow(x, y) | 0`: truncate toward zero and wrap to Int32.

return toInt32(math.pow(x, y))

end

end)

}