RandomUtils

local function _W(f) local e=setmetatable({}, {__index = _ENV or getfenv()}) if setfenv then setfenv(f, e) end return f(e) or e end
local Core=_W(function(_ENV, ...)
local Core = {}

function Core.identity(o)
  return o
end

function Core.isEqual(v,vv)
  if(type(v) ~= type(vv)) then return false end
  if(type(v) == "table") then
    for k,v in pairs(v) do
      if(vv[k] ~= v) then
        return false
      end
    end
    return true
  end
  return v==vv
end

function Core.toBoolean(v)
  return v and true or false
end

function Core.isCallable(v)
  if(type(v) == "table") then
    return type(getmetatable(v).__call) == "function"
  end
  return type(v) == "function"
end

function Core.isTable(v)
  return type(v) == "table"
end

function Core.isNil(v)
  return v == nil
end

function Core.isArray(v)
  if not Core.isTable(v) then return false end
  local i = 0
  for _,_ in pairs(v) do
    i = i + 1
    if Core.isNil(v[i]) then return false end
  end
  return true
end

function Core.isIterable(v)
  return Core.toBoolean(pcall(pairs,v))
end

function Core.isString(v)
  return type(v) == "string"
end

function Core.isEmpty(v)
  if Core.isNil(v) then return true end
  if Core.isString(v) then return #v == 0 end
  if Core.isTable(v) then return next(v) == nil end
  return true
end

function Core.isNumber(v)
  return type(v) == "number"
end

function Core.isNaN(v)
  return Core.isNumber(v) and v ~= v
end

function Core.isFinite(v)
  if not Core.isNumber(v) then return false end
  return v > -math.huge and v < math.huge
end

function Core.isBoolean(v)
  return type(v) == "boolean"
end

function Core.isInteger(v)
  return type(v) == "number" and math.floor(v) == v
end

function Core.once(f)
  local ran = false
  local res = false
  return function(...)
    if(ran) then return res end
    res = f(unpack({...}))
    return res
  end
end

function Core.functions(obj)
  local methods = {}
  for k,v in pairs(obj) do
    if(type(v) == "function") then
      table.insert(methods,k)
    end
  end
  return methods
end

function Core.clone(obj)
  if(type(obj) ~= "table") then return obj end
  local t = {}
  for k,v in pairs(obj) do
    t[Core.clone(k)] = Core.clone(v)
  end
  return t
end

function Core.result(obj,method,...)
  if(obj[method]) then
    if(Core.isCallable(obj[method])) then
      return obj[method](obj,...)
    else
      return obj[method]
    end
  elseif _.isCallable(method) then
    return method(obj,...)
  end
end

function Core.memoize(f,hash)
  local h = hash or Core.identity
  local mem = {}
  return function(...)
    for k,v in pairs(mem) do
      if(Core.isEqual(k,{...})) then return v end
    end
    local res = f(...)
    mem[{...}] = res
    return res
  end
end

function Core.after(f,count)
  local i,l = 0,count
  return function(...)
    i = i + 1
    if(i>=l) then return f(...) end
  end
end

function Core.compose(...)
  local functions = {...}
  return function(...)
    local ret = functions[1](...)
    for k,v in pairs(functions) do
      if(k~=1) then ret = v(ret) end
    end
    return ret
  end
end

function Core.pipe(value,...)
  return Core.compose(...)(value)
end

function Core.times(n,f,...)
  local res = {}
  for i = 1,n do
    res[i] = f(i,...)
  end
  return res
end

function Core.bind(f,v)
  return function(...)
    return f(v,...)
  end
end

function Core.bindn(f,...)
  local args = {...}
  return function(...)
    return f(unpack(args),...)
  end
end

function Core.tap(val,f,...)
  f(val,...)
  return val
end

return Core
end)
local Table=_W(function(_ENV, ...)
local Table = {}

function Table.each(t,f,...)
  for k,v in pairs(t) do
    f(k,v,...)
  end
end

function Table.at(t,...)
  local keys = {...}
  local vals = {}
  for _,v in pairs(keys) do
    vals[#vals+1] = t[v]
  end
  return vals
end

function Table.count(t,v)
  if(v == nil) then return #t end
  local i = 0
  for k,vv in pairs(t) do if(_.isEqual(v,v)) then i = i + 1 end end
  return i
end

function Table.cycle(t,n)
  n = n or 1
  if n<=0 then return function() end end
  local k, fk
  local i = 0
  while true do
    return function()
      k = k and next(t,k) or next(t)
      fk = not fk and k or fk
      if n then
        i = (k==fk) and i+1 or i
        if i > n then
          return
        end
      end
      return k, t[k]
    end
  end
end

function Table.map(t,f)
  local tt = {}
  for k,v in pairs(t) do
    tt[k] = f(k,v)
  end
  return tt
end

function Table.reduce(t,f)
  local m = ""
  for _,v in pairs(t) do
    m = f(m,v)
  end
  return m
end

function Table.mapReduce(t,f)
  local s = {}
  local m = ""
  for _,v in pairs(t) do
    m = f(m,v)
    s[#s+1] = m
  end
  return s
end

function Table.detect(t,v)

  for k,vv in pairs(t) do
    if(_.isCallable(v)) then
      if(_.isEqual(vv,v(vv))) then return k end
    else
      if(_.isEqual(v,vv)) then return k end
    end
  end
  return nil
end

function Table.all(t,f)
  for k,v in pairs(t) do
    if(not f(k,v)) then return false end
  end
  return true
end

function Table.include(t,v)
  return Table.detect(t,v) ~= nil
end

return Table
end)
local Array=_W(function(_ENV, ...)
local Array = {}

function Array.toArray(...)
  return {...}
end

function Array.find(a,v,n)
  for i = (n or 1),#a do
    if(a[i] == v) then return i end
  end
end

function Array.reverse(a)
  local aa = {}
  for i = #a,1,-1 do
    aa[#a-i+1] = a[i]
  end
  return aa
end

function Array.selectWhile(a,f,...)
  local selected = {}
  for i = 1,#a do
    if(f(i,a[i],...)) then selected[#selected+1] = a[i] else break end
  end
  return selected
end

function Array.dropWhile(a,f,...)
  local selected = {}
  for i = 1,#a do
    if(not f(i,a[i],...)) then select[#selected+1] = a[i] else break end
  end
  return selected
end

function Array.indexOf(a,v)
  for i,_v in pairs(a) do
    if(v==_v) then return i end
  end
end

function Array.lastIndexOf(a,v)
  local ind
  for i,_v in pairs(a) do
    if(v==_v) then ind = i end
  end
  return ind
end

function Array.push(a,...)
  for _,v in pairs({...}) do
    a[#a+1] = v
  end
  return a
end

function Array.pop(a)
  local r = a[1]
  table.remove(a,1)
  return r
end

function Array.unshift(a)
  local r = a[#a]
  table.remove(a,#a)
  return r
end

function Array.pull(a,...)
  local l = {} for _,v in pairs({...}) do l[v] = true end
  local aa = {}
  for _,v in pairs(a) do
    if(not l[v]) then aa[#aa+1] = v end
  end
  return aa
end

function Array.removeRange(a,s,f)
  for i = s,f do
    table.remove(a,s)
  end
  return a
end

function Array.slice(a,s,f)
  local aa = {}
  for i = s,f do
    aa[#aa+1] = a[i]
  end
  return aa
end

function Array.first(a,n)
  local aa = {}
  for i = 1,(n or 1) do
    aa[i] = a[i]
  end
  return aa
end

function Array.initial(a,n)
  local aa = {}
  for i = 1,#a-(n or 1) do
    aa[i] = a[i]
  end
  return aa
end

function Array.last(a,n)
  local aa = {}
  for i = #a-(n or 1),#a do
    aa[#aa+1] = a[i]
  end
  return aa
end

function Array.nth(a,i)
  return a[i]
end

function Array.difference(a,aa)
  local aaa = {}
  local l = {} for _,v in pairs(aa) do l[v] = true end
  for _,v in pairs(a) do if(not l[v]) then aaa[#aaa+1] = v end end
  return aaa
end

function Array.union(...)
  local a = {}
  local l = {}
  for _,_a in pairs({...}) do
    for _,e in pairs(_a) do
      if(not l[e]) then
        a[#a+1] = e
        l[e] = true
      end
    end
  end
  return
end

function Array.unique(a)
  local l = {}
  local aa = {}
  for _,v in pairs(a) do
    if(not l[v]) then
      aa[#aa+1] = v
      l[v] = true
    end
  end
  return aa
end

function Array.isunique(a)
  local l = {}
  local aa = {}
  for _,v in pairs(a) do
    if(not l[v]) then
      l[v] = true
    else
      return false
    end
  end
  return true
end

function Array.append(a,o)
  local aa = a
  for k,v in pairs(o) do
    aa[#aa+o] = v
  end
  return aa
end

function Array.range(s,f,i)
  local i = i or 1
  local a = {}
  if(not f) then
    for j = 0,s,i do
      a[#a+1] = j
    end
  else
    for j = s,f,i do
      a[#a+1] = j
    end
  end
  return a
end

function Array.rep(v,n)
  local a = {}
  for i = 1,n do
    a[#a+1] = v
  end
  return a
end

function Array.concat(v,g)
  local s = ""
  local g = g or ""
  for k,v in ipairs(v) do
    s = s..g..v
  end
  return s
end

function Array.split(v,p)
  local p = p or " "
  local t = {}
  for m in v:gmatch("[^"..p.."]+") do
    table.insert(t,m)
  end
  return t
end

return Array
end)
local _ = {}
_G._ = setmetatable({},{__index=_})
local function merge(t,tt)
  if(not t) then return end
  for k,v in pairs(t) do
    if(not tt[k]) then tt[k] = v end
  end
end

merge(Core,_)
merge(Array,_)
merge(Table,_)
merge(Helper,_)

_._MODULES = {}
_._MODULES.Core = true
_._MODULES.Array = _.toBoolean(Array)
_._MODULES.Table = _.toBoolean(Table)
_._MODULES.Computercraft = _.toBoolean(CC)
_._MODULES.Helper = _.toBoolean(Helper)

function _.new(v)
  local i = {_value=v,_wrapped=true}
  local function chainindex(t,k)
    if(k == "value") then return function() return i._value end end
    if(_.isCallable(_[k])) then
      return function(...)
        return _.new(_[k](i._value,...))
      end
    end
  end
  return setmetatable(i,{__index = chainindex})
end

function _.chain(v)
  return _.new(v)
end