@px-petals/roku.motion-web 0.0.0-stage → 1.1.0

package/script/luau/lib/base/base.table.js

@@ -0,0 +1,189 @@
+/**
+ * The `table` library.
+ */
+
+import { LuaTable, fail, typeName } from '../../vm/vm.value.js'
+import { lessThan, truthy } from '../../vm/vm.meta.js'
+import { argError, checkFunction, checkInt, checkTable, optInt, register } from '../lib.args.js'
+import { unpack } from './base.js'
+
+/** @param {LuaTable} t */
+function writable(t) {
+  if (t.frozen) throw fail('attempt to modify a readonly table')
+}
+
+/**
+ * Sorts `list` in place with `less`, stably (merge sort).
+ *
+ * @param {any[]} list
+ * @param {(a: any, b: any) => boolean} less
+ */
+function sort(list, less) {
+  const n = list.length
+  if (n < 2) return
+  let src = list
+  let dst = new Array(n)
+  for (let width = 1; width < n; width *= 2) {
+    for (let lo = 0; lo < n; lo += 2 * width) {
+      const mid = Math.min(lo + width, n)
+      const hi = Math.min(lo + 2 * width, n)
+      let i = lo
+      let j = mid
+      let o = lo
+      while (i < mid && j < hi) dst[o++] = less(src[j], src[i]) ? src[j++] : src[i++]
+      while (i < mid) dst[o++] = src[i++]
+      while (j < hi) dst[o++] = src[j++]
+    }
+    const swap = src
+    src = dst
+    dst = swap
+  }
+  if (src !== list) for (let i = 0; i < n; i++) list[i] = src[i]
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installTable(vm, G) {
+  const table = new LuaTable()
+  G.set('table', table)
+
+  register(table, {
+    insert(vm, args) {
+      const t = checkTable(args, 0, 'insert')
+      writable(t)
+      const n = t.length()
+      if (args.length === 2) {
+        t.set(n + 1, args[1])
+        return []
+      }
+      if (args.length !== 3) throw fail("wrong number of arguments to 'insert'")
+      const pos = checkInt(args, 1, 'insert')
+      if (pos < 1 || pos > n + 1) throw argError(2, 'insert', 'position out of bounds')
+      if (args[2] === undefined) return []
+      t.arr.splice(pos - 1, 0, args[2])
+      if (t.hn !== null) t.migrate()
+      return []
+    },
+
+    remove(vm, args) {
+      const t = checkTable(args, 0, 'remove')
+      writable(t)
+      const n = t.length()
+      const pos = optInt(args, 1, 'remove', n)
+      if (n === 0 && args[1] === undefined) return undefined
+      if (pos < 1 || pos > n) {
+        if (args[1] !== undefined && pos !== n + 1) throw argError(2, 'remove', 'position out of bounds')
+        return undefined
+      }
+      const v = t.arr[pos - 1]
+      t.arr.splice(pos - 1, 1)
+      let m = t.arr.length
+      while (m > 0 && t.arr[m - 1] === undefined) m--
+      t.arr.length = m
+      return v
+    },
+
+    concat(vm, args) {
+      const t = checkTable(args, 0, 'concat')
+      const sep = args[1] === undefined ? '' : String(args[1])
+      const i = optInt(args, 2, 'concat', 1)
+      const j = optInt(args, 3, 'concat', t.length())
+      const parts = []
+      for (let n = i; n <= j; n++) {
+        const v = t.get(n)
+        if (typeof v === 'string') parts.push(v)
+        else if (typeof v === 'number') parts.push(vm.tostring(v))
+        else throw fail('invalid value (' + typeName(v) + ') at index ' + n + " in table for 'concat'")
+      }
+      return parts.join(sep)
+    },
+
+    unpack(vm, args) {
+      return unpack(checkTable(args, 0, 'unpack'), args[1], args[2])
+    },
+
+    pack(vm, args) {
+      const t = new LuaTable()
+      t.setRange(1, args, 0, args.length)
+      t.set('n', args.length)
+      return t
+    },
+
+    sort(vm, args) {
+      const t = checkTable(args, 0, 'sort')
+      writable(t)
+      const cmp = args[1]
+      if (cmp !== undefined) checkFunction(args, 1, 'sort')
+      const n = t.length()
+      const list = t.arr.slice(0, n)
+      /** @type {(a: any, b: any) => boolean} */
+      const less = cmp === undefined
+        ? function (a, b) { return lessThan(vm, a, b) }
+        : function (a, b) { return truthy(vm.call(cmp, [ a, b ])[0]) }
+      sort(list, less)
+      for (let i = 0; i < n; i++) t.arr[i] = list[i]
+      return []
+    },
+
+    find(vm, args) {
+      const t = checkTable(args, 0, 'find')
+      const init = optInt(args, 2, 'find', 1)
+      const n = t.length()
+      for (let i = init; i <= n; i++) if (t.get(i) === args[1]) return i
+      return undefined
+    },
+
+    clear(vm, args) {
+      const t = checkTable(args, 0, 'clear')
+      writable(t)
+      t.arr.length = 0
+      for (let s = 0; s < t.hv.length; s++) t.hv[s] = undefined
+      t.dead = t.hv.length
+      return []
+    },
+
+    create(vm, args) {
+      const n = checkInt(args, 0, 'create')
+      if (n < 0) throw argError(1, 'create', 'size out of range')
+      const t = new LuaTable()
+      if (args[1] !== undefined) for (let i = 1; i <= n; i++) t.set(i, args[1])
+      return t
+    },
+
+    clone(vm, args) {
+      return checkTable(args, 0, 'clone').clone()
+    },
+
+    freeze(vm, args) {
+      const t = checkTable(args, 0, 'freeze')
+      if (t.meta !== undefined && t.meta.getStr('__metatable') !== undefined) throw argError(1, 'freeze', 'table has a protected metatable')
+      t.frozen = true
+      return t
+    },
+
+    isfrozen(vm, args) {
+      return checkTable(args, 0, 'isfrozen').frozen
+    },
+
+    getn(vm, args) {
+      return checkTable(args, 0, 'getn').length()
+    },
+
+    move(vm, args) {
+      const a1 = checkTable(args, 0, 'move')
+      const f = checkInt(args, 1, 'move')
+      const e = checkInt(args, 2, 'move')
+      const t = checkInt(args, 3, 'move')
+      const a2 = args[4] === undefined ? a1 : checkTable(args, 4, 'move')
+      writable(a2)
+      if (e >= f) {
+        if (!(f > 0 || e < Number.MAX_VALUE + f)) throw argError(3, 'move', 'too many elements to move')
+        if (t > e || t <= f || a1 !== a2) for (let i = 0; i <= e - f; i++) a2.set(t + i, a1.get(f + i))
+        else for (let i = e - f; i >= 0; i--) a2.set(t + i, a1.get(f + i))
+      }
+      return a2
+    },
+  }, 'table.')
+}

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.')
+}