@px-petals/roku.motion-web 1.0.0 → 1.1.0

package/script/luau/lib/lib.args.js

@@ -0,0 +1,152 @@
+/**
+ * Argument checks for native library functions, with Luau's messages
+ * (`invalid argument #1 to 'insert' (table expected, got nil)`).
+ */
+
+import { LuaTable, NativeFunction, LuaClosure, fail, typeName } from '../vm/vm.value.js'
+import { toNumber } from '../vm/vm.meta.js'
+import { numberToString } from '../vm/vm.num.js'
+
+/**
+ * @param   {number} n  1-based argument number
+ * @param   {string} fname
+ * @param   {string} message
+ */
+export function argError(n, fname, message) {
+  return fail('invalid argument #' + n + " to '" + fname + "' (" + message + ')')
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i  0-based
+ * @returns {string}
+ */
+function got(args, i) {
+  return typeName(args[i])
+}
+
+/**
+ * The error for an argument of the wrong type: Luau says "missing argument"
+ * when there is none at all, and "invalid argument" with the type it got otherwise.
+ *
+ * @param   {any[]}  args
+ * @param   {number} i  0-based
+ * @param   {string} fname
+ * @param   {string} expected  such as 'table'
+ */
+export function typeError(args, i, fname, expected) {
+  if (i >= args.length) return fail('missing argument #' + (i + 1) + " to '" + fname + "' (" + expected + ' expected)')
+  return argError(i + 1, fname, expected + ' expected, got ' + got(args, i))
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i      0-based
+ * @param   {string} fname
+ * @returns {LuaTable}
+ */
+export function checkTable(args, i, fname) {
+  const v = args[i]
+  if (!(v instanceof LuaTable)) throw typeError(args, i, fname, 'table')
+  return v
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @returns {number} a number, or a string that reads as one
+ */
+export function checkNumber(args, i, fname) {
+  const n = toNumber(args[i])
+  if (n === undefined) throw typeError(args, i, fname, 'number')
+  return n
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @param   {number} def
+ * @returns {number}
+ */
+export function optNumber(args, i, fname, def) {
+  return args[i] === undefined ? def : checkNumber(args, i, fname)
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @returns {number} an integer: the number cut toward zero
+ */
+export function checkInt(args, i, fname) {
+  const n = checkNumber(args, i, fname)
+  return n < 0 ? Math.ceil(n) : Math.floor(n)
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @param   {number} def
+ * @returns {number}
+ */
+export function optInt(args, i, fname, def) {
+  return args[i] === undefined ? def : checkInt(args, i, fname)
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @returns {string} a string, or a number written as one
+ */
+export function checkString(args, i, fname) {
+  const v = args[i]
+  if (typeof v === 'string') return v
+  if (typeof v === 'number') return numberToString(v)
+  throw typeError(args, i, fname, 'string')
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @param   {string} def
+ * @returns {string}
+ */
+export function optString(args, i, fname, def) {
+  return args[i] === undefined ? def : checkString(args, i, fname)
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @returns {any}    a function
+ */
+export function checkFunction(args, i, fname) {
+  const v = args[i]
+  if (!(v instanceof LuaClosure) && !(v instanceof NativeFunction)) throw typeError(args, i, fname, 'function')
+  return v
+}
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ */
+export function checkAny(args, i) {
+  if (i >= args.length) throw fail('missing argument #' + (i + 1))
+}
+
+/**
+ * Puts native functions into a table under their names.
+ *
+ * @param {LuaTable} table
+ * @param {Record<string, import('../vm/vm.value.js').NativeCall>} fns
+ * @param {string} [prefix]  such as 'string.', so errors and `tostring` name the function
+ */
+export function register(table, fns, prefix) {
+  for (const name in fns) table.set(name, new NativeFunction((prefix || '') + name, fns[name]))
+}

package/script/luau/lib/lib.js

@@ -0,0 +1,23 @@
+/**
+ * Installs the standard library subset into a VM's globals: base, `string`,
+ * `table`, `math`, `bit32`, `vector` and `os`. The host adds its own globals
+ * to `vm.globals` afterwards.
+ */
+
+import { installBase } from './base/base.js'
+import { installTable } from './base/base.table.js'
+import { installBit32 } from './math/math.bit32.js'
+import { installMath } from './math/math.js'
+import { installVector } from './math/math.vector.js'
+import { installString } from './string/string.js'
+
+/** @param {import('../vm/vm.js').VM} vm */
+export function installLibs(vm) {
+  const G = vm.globals
+  installBase(vm, G)
+  installString(vm, G)
+  installTable(vm, G)
+  installMath(vm, G)
+  installBit32(vm, G)
+  installVector(vm, G)
+}

package/script/luau/lib/math/math.bit32.js

@@ -0,0 +1,144 @@
+/**
+ * The `bit32` library: 32-bit unsigned integer operations on doubles.
+ */
+
+import { LuaTable, fail } from '../../vm/vm.value.js'
+import { argError, checkNumber, register } from '../lib.args.js'
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} name
+ * @returns {number} the argument as an unsigned 32-bit integer
+ */
+function u32(args, i, name) {
+  return checkNumber(args, i, name) >>> 0
+}
+
+/**
+ * @param   {number} x
+ * @param   {number} disp  positive shifts left, negative right
+ * @returns {number}
+ */
+function shift(x, disp) {
+  if (disp <= -32 || disp >= 32) return 0
+  return (disp >= 0 ? x << disp : x >>> -disp) >>> 0
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installBit32(vm, G) {
+  const bit32 = new LuaTable()
+  G.set('bit32', bit32)
+
+  /**
+   * @param {string} name
+   * @param {(a: number, b: number) => number} f
+   * @param {number} init
+   */
+  const fold = function (name, f, init) {
+    bit32.set(name, vm.native('bit32.' + name, function (vm2, args) {
+      let r = init
+      for (let i = 0; i < args.length; i++) r = f(r, u32(args, i, name)) >>> 0
+      return r
+    }))
+  }
+  fold('band', function (a, b) { return a & b }, 0xffffffff)
+  fold('bor', function (a, b) { return a | b }, 0)
+  fold('bxor', function (a, b) { return a ^ b }, 0)
+
+  /**
+   * @param {any[]} args
+   * @param {string} name
+   * @returns {[number, number]} field start and width
+   */
+  const field = function (args, name) {
+    const f = checkNumber(args, 1, name)
+    const w = args[2] === undefined ? 1 : checkNumber(args, 2, name)
+    if (f < 0) throw argError(2, name, 'field cannot be negative')
+    if (w <= 0) throw argError(3, name, 'width must be positive')
+    if (f + w > 32) throw fail('trying to access non-existent bits')
+    return [ f, w ]
+  }
+
+  register(bit32, {
+    bnot(vm, args) {
+      return ~u32(args, 0, 'bnot') >>> 0
+    },
+
+    btest(vm, args) {
+      let r = 0xffffffff
+      for (let i = 0; i < args.length; i++) r = (r & u32(args, i, 'btest')) >>> 0
+      return r !== 0
+    },
+
+    lshift(vm, args) {
+      return shift(u32(args, 0, 'lshift'), Math.floor(checkNumber(args, 1, 'lshift')))
+    },
+
+    rshift(vm, args) {
+      return shift(u32(args, 0, 'rshift'), -Math.floor(checkNumber(args, 1, 'rshift')))
+    },
+
+    arshift(vm, args) {
+      const x = u32(args, 0, 'arshift')
+      const d = Math.floor(checkNumber(args, 1, 'arshift'))
+      if (d >= 32) return (x & 0x80000000) !== 0 ? 0xffffffff : 0
+      if (d <= -32) return 0
+      return d >= 0 ? (x | 0) >> d >>> 0 : shift(x, -d)
+    },
+
+    lrotate(vm, args) {
+      const x = u32(args, 0, 'lrotate')
+      const r = Math.floor(checkNumber(args, 1, 'lrotate')) & 31
+      return r === 0 ? x : ((x << r) | (x >>> (32 - r))) >>> 0
+    },
+
+    rrotate(vm, args) {
+      const x = u32(args, 0, 'rrotate')
+      const r = Math.floor(checkNumber(args, 1, 'rrotate')) & 31
+      return r === 0 ? x : ((x >>> r) | (x << (32 - r))) >>> 0
+    },
+
+    extract(vm, args) {
+      const x = u32(args, 0, 'extract')
+      const fw = field(args, 'extract')
+      return fw[1] === 32 ? x : (x >>> fw[0]) & (Math.pow(2, fw[1]) - 1)
+    },
+
+    replace(vm, args) {
+      const x = u32(args, 0, 'replace')
+      const v = u32(args, 1, 'replace')
+      const f = checkNumber(args, 2, 'replace')
+      const w = args[3] === undefined ? 1 : checkNumber(args, 3, 'replace')
+      if (f < 0) throw argError(3, 'replace', 'field cannot be negative')
+      if (w <= 0) throw argError(4, 'replace', 'width must be positive')
+      if (f + w > 32) throw fail('trying to access non-existent bits')
+      const mask = w === 32 ? 0xffffffff : Math.pow(2, w) - 1
+      return (((x & ~(mask * Math.pow(2, f))) | ((v & mask) << f)) >>> 0)
+    },
+
+    countlz(vm, args) {
+      const x = u32(args, 0, 'countlz')
+      if (x === 0) return 32
+      let n = 0
+      for (let bit = 0x80000000; (x & bit) === 0; bit >>>= 1) n++
+      return n
+    },
+
+    countrz(vm, args) {
+      const x = u32(args, 0, 'countrz')
+      if (x === 0) return 32
+      let n = 0
+      while (((x >>> n) & 1) === 0) n++
+      return n
+    },
+
+    byteswap(vm, args) {
+      const x = u32(args, 0, 'byteswap')
+      return (((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x >>> 8) & 0xff00) | (x >>> 24)) >>> 0
+    },
+  }, 'bit32.')
+}

package/script/luau/lib/math/math.js

@@ -0,0 +1,288 @@
+/**
+ * The `math` library, and `os`. Functions ES5 lacks (`sinh`, `log10`, `sign`,
+ * ...) are written out, because the oldest browsers this runs in lack them.
+ */
+
+import { LuaTable } from '../../vm/vm.value.js'
+import { sign, trunc } from '../../vm/vm.num.js'
+import { argError, checkInt, checkNumber, optNumber, register } from '../lib.args.js'
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function sinh(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2
+}
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function cosh(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2
+}
+
+/**
+ * @param   {number} x
+ * @returns {number}
+ */
+function tanh(x) {
+  if (x > 20) return 1
+  if (x < -20) return -1
+  const a = Math.exp(2 * x)
+  return (a - 1) / (a + 1)
+}
+
+/**
+ * The log of x in base `b`, exact where x is a power of b.
+ *
+ * @param   {number} x
+ * @param   {number} lnb  the natural log of the base
+ * @param   {number} b
+ * @returns {number}
+ */
+function logBase(x, lnb, b) {
+  const r = Math.log(x) / lnb
+  const rounded = Math.round(r)
+  return Math.abs(r - rounded) < 1e-9 && Math.pow(b, rounded) === x ? rounded : r
+}
+
+/**
+ * A small deterministic generator (mulberry32), 32 bits of state.
+ *
+ * @param {number} seed
+ */
+function makeRandom(seed) {
+  let state = seed >>> 0
+  return function () {
+    state = (state + 0x6d2b79f5) >>> 0
+    let t = state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installMath(vm, G) {
+  const math = new LuaTable()
+  G.set('math', math)
+  let random = makeRandom(0x2545f491)
+
+  /**
+   * One-argument functions.
+   *
+   * @param {string} name
+   * @param {(x: number) => number} f
+   */
+  const unary = function (name, f) {
+    math.set(name, vm.native('math.' + name, function (vm2, args) {
+      return f(checkNumber(args, 0, name))
+    }))
+  }
+
+  unary('abs', Math.abs)
+  unary('acos', Math.acos)
+  unary('asin', Math.asin)
+  unary('atan', Math.atan)
+  unary('ceil', Math.ceil)
+  unary('cos', Math.cos)
+  unary('cosh', cosh)
+  unary('deg', function (x) { return x * (180 / Math.PI) })
+  unary('exp', Math.exp)
+  unary('floor', Math.floor)
+  unary('log10', function (x) { return logBase(x, Math.LN10, 10) })
+  unary('rad', function (x) { return x * (Math.PI / 180) })
+  unary('sin', Math.sin)
+  unary('sinh', sinh)
+  unary('sqrt', Math.sqrt)
+  unary('tan', Math.tan)
+  unary('tanh', tanh)
+  unary('sign', sign)
+  unary('round', function (x) { return x < 0 ? -Math.floor(-x + 0.5) : Math.floor(x + 0.5) })
+  unary('isnan', function (x) { return /** @type {any} */ (x !== x) })
+  unary('isinf', function (x) { return /** @type {any} */ (x === Infinity || x === -Infinity) })
+  unary('isfinite', function (x) { return /** @type {any} */ (x === x && x !== Infinity && x !== -Infinity) })
+
+  register(math, {
+    atan2(vm, args) {
+      return Math.atan2(checkNumber(args, 0, 'atan2'), checkNumber(args, 1, 'atan2'))
+    },
+
+    fmod(vm, args) {
+      return checkNumber(args, 0, 'fmod') % checkNumber(args, 1, 'fmod')
+    },
+
+    frexp(vm, args) {
+      const x = checkNumber(args, 0, 'frexp')
+      if (x === 0 || x !== x || x === Infinity || x === -Infinity) return [ x, 0 ]
+      let e = Math.max(-1023, Math.floor(logBase(Math.abs(x), Math.LN2, 2)) + 1)
+      let m = x * Math.pow(2, -e)
+      while (Math.abs(m) < 0.5) {
+        m *= 2
+        e--
+      }
+      while (Math.abs(m) >= 1) {
+        m /= 2
+        e++
+      }
+      return [ m, e ]
+    },
+
+    ldexp(vm, args) {
+      return checkNumber(args, 0, 'ldexp') * Math.pow(2, checkInt(args, 1, 'ldexp'))
+    },
+
+    log(vm, args) {
+      const x = checkNumber(args, 0, 'log')
+      if (args[1] === undefined) return Math.log(x)
+      const b = checkNumber(args, 1, 'log')
+      if (b === 2) return logBase(x, Math.LN2, 2)
+      if (b === 10) return logBase(x, Math.LN10, 10)
+      return Math.log(x) / Math.log(b)
+    },
+
+    max(vm, args) {
+      let m = checkNumber(args, 0, 'max')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkNumber(args, i, 'max')
+        if (v > m) m = v
+      }
+      return m
+    },
+
+    min(vm, args) {
+      let m = checkNumber(args, 0, 'min')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkNumber(args, i, 'min')
+        if (v < m) m = v
+      }
+      return m
+    },
+
+    modf(vm, args) {
+      const x = checkNumber(args, 0, 'modf')
+      const whole = trunc(x)
+      return [ whole, x - whole ]
+    },
+
+    pow(vm, args) {
+      return Math.pow(checkNumber(args, 0, 'pow'), checkNumber(args, 1, 'pow'))
+    },
+
+    clamp(vm, args) {
+      const v = checkNumber(args, 0, 'clamp')
+      const lo = checkNumber(args, 1, 'clamp')
+      const hi = checkNumber(args, 2, 'clamp')
+      if (lo > hi) throw argError(3, 'clamp', 'max must be greater than min')
+      return v < lo ? lo : v > hi ? hi : v
+    },
+
+    lerp(vm, args) {
+      const a = checkNumber(args, 0, 'lerp')
+      const b = checkNumber(args, 1, 'lerp')
+      const t = checkNumber(args, 2, 'lerp')
+      return t === 1 ? b : a + (b - a) * t
+    },
+
+    random(vm, args) {
+      const r = random()
+      if (args.length === 0) return r
+      const lo = args.length === 1 ? 1 : checkInt(args, 0, 'random')
+      const hi = checkInt(args, args.length === 1 ? 0 : 1, 'random')
+      if (lo > hi) throw argError(args.length === 1 ? 1 : 2, 'random', 'interval is empty')
+      return lo + Math.floor(r * (hi - lo + 1))
+    },
+
+    randomseed(vm, args) {
+      random = makeRandom(checkInt(args, 0, 'randomseed'))
+      return []
+    },
+
+    noise(vm, args) {
+      return noise(checkNumber(args, 0, 'noise'), optNumber(args, 1, 'noise', 0), optNumber(args, 2, 'noise', 0))
+    },
+  }, 'math.')
+
+  math.set('pi', Math.PI)
+  math.set('huge', Infinity)
+
+  // os
+  const os = new LuaTable()
+  G.set('os', os)
+  register(os, {
+    clock() {
+      return now() / 1000
+    },
+    time() {
+      return Math.floor(Date.now() / 1000)
+    },
+  }, 'os.')
+}
+
+/** @returns {number} milliseconds, from a clock that only moves forward where the host has one */
+function now() {
+  const perf = typeof performance !== 'undefined' ? performance : null
+  return perf !== null && typeof perf.now === 'function' ? perf.now() : Date.now()
+}
+
+/**
+ * Perlin gradient noise in 1 to 3 dimensions, in about -1..1.
+ *
+ * @param   {number} x
+ * @param   {number} y
+ * @param   {number} z
+ * @returns {number}
+ */
+function noise(x, y, z) {
+  const xi = Math.floor(x)
+  const yi = Math.floor(y)
+  const zi = Math.floor(z)
+  const xf = x - xi
+  const yf = y - yi
+  const zf = z - zi
+  /** @param {number} t */
+  const fade = function (t) { return t * t * t * (t * (t * 6 - 15) + 10) }
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @param {number} c
+   */
+  const hash = function (a, b, c) {
+    let h = Math.imul(a, 374761393) + Math.imul(b, 668265263) + Math.imul(c, 1274126177)
+    h = Math.imul(h ^ (h >>> 13), 1274126177)
+    return (h ^ (h >>> 16)) & 15
+  }
+  /**
+   * @param {number} h
+   * @param {number} dx
+   * @param {number} dy
+   * @param {number} dz
+   */
+  const grad = function (h, dx, dy, dz) {
+    const u = h < 8 ? dx : dy
+    const v = h < 4 ? dy : h === 12 || h === 14 ? dx : dz
+    return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v)
+  }
+  const u = fade(xf)
+  const v = fade(yf)
+  const w = fade(zf)
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @param {number} t
+   */
+  const lerp = function (a, b, t) { return a + (b - a) * t }
+  const c = function (/** @type {number} */ dx, /** @type {number} */ dy, /** @type {number} */ dz) {
+    return grad(hash(xi + dx, yi + dy, zi + dz), xf - dx, yf - dy, zf - dz)
+  }
+  return lerp(
+    lerp(lerp(c(0, 0, 0), c(1, 0, 0), u), lerp(c(0, 1, 0), c(1, 1, 0), u), v),
+    lerp(lerp(c(0, 0, 1), c(1, 0, 1), u), lerp(c(0, 1, 1), c(1, 1, 1), u), v),
+    w,
+  )
+}