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

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

@@ -0,0 +1,125 @@
+/**
+ * The `vector` library: the three-component vector value's functions.
+ */
+
+import { LuaTable, Vector, fround } from '../../vm/vm.value.js'
+import { sign } from '../../vm/vm.num.js'
+import { checkNumber, register, typeError } from '../lib.args.js'
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} name
+ * @returns {Vector}
+ */
+function checkVector(args, i, name) {
+  const v = args[i]
+  if (!(v instanceof Vector)) throw typeError(args, i, name, 'vector')
+  return v
+}
+
+/**
+ * @param   {Vector} v
+ * @returns {number}
+ */
+function magnitude(v) {
+  return fround(Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z))
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installVector(vm, G) {
+  const lib = new LuaTable()
+  G.set('vector', lib)
+
+  /**
+   * A function of one vector that maps each component.
+   *
+   * @param {string} name
+   * @param {(n: number) => number} f
+   */
+  const mapped = function (name, f) {
+    lib.set(name, vm.native('vector.' + name, function (vm2, args) {
+      const v = checkVector(args, 0, name)
+      return new Vector(f(v.x), f(v.y), f(v.z))
+    }))
+  }
+  mapped('floor', Math.floor)
+  mapped('ceil', Math.ceil)
+  mapped('abs', Math.abs)
+  mapped('sign', sign)
+
+  register(lib, {
+    create(vm, args) {
+      return new Vector(checkNumber(args, 0, 'create'), checkNumber(args, 1, 'create'), args[2] === undefined ? 0 : checkNumber(args, 2, 'create'))
+    },
+
+    magnitude(vm, args) {
+      return magnitude(checkVector(args, 0, 'magnitude'))
+    },
+
+    normalize(vm, args) {
+      const v = checkVector(args, 0, 'normalize')
+      const m = magnitude(v)
+      return new Vector(v.x / m, v.y / m, v.z / m)
+    },
+
+    dot(vm, args) {
+      const a = checkVector(args, 0, 'dot')
+      const b = checkVector(args, 1, 'dot')
+      return fround(a.x * b.x + a.y * b.y + a.z * b.z)
+    },
+
+    cross(vm, args) {
+      const a = checkVector(args, 0, 'cross')
+      const b = checkVector(args, 1, 'cross')
+      return new Vector(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x)
+    },
+
+    angle(vm, args) {
+      const a = checkVector(args, 0, 'angle')
+      const b = checkVector(args, 1, 'angle')
+      const cx = a.y * b.z - a.z * b.y
+      const cy = a.z * b.x - a.x * b.z
+      const cz = a.x * b.y - a.y * b.x
+      return Math.atan2(Math.sqrt(cx * cx + cy * cy + cz * cz), a.x * b.x + a.y * b.y + a.z * b.z)
+    },
+
+    clamp(vm, args) {
+      const v = checkVector(args, 0, 'clamp')
+      const lo = checkVector(args, 1, 'clamp')
+      const hi = checkVector(args, 2, 'clamp')
+      return new Vector(Math.min(Math.max(v.x, lo.x), hi.x), Math.min(Math.max(v.y, lo.y), hi.y), Math.min(Math.max(v.z, lo.z), hi.z))
+    },
+
+    min(vm, args) {
+      let r = checkVector(args, 0, 'min')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkVector(args, i, 'min')
+        r = new Vector(Math.min(r.x, v.x), Math.min(r.y, v.y), Math.min(r.z, v.z))
+      }
+      return r
+    },
+
+    max(vm, args) {
+      let r = checkVector(args, 0, 'max')
+      for (let i = 1; i < args.length; i++) {
+        const v = checkVector(args, i, 'max')
+        r = new Vector(Math.max(r.x, v.x), Math.max(r.y, v.y), Math.max(r.z, v.z))
+      }
+      return r
+    },
+
+    lerp(vm, args) {
+      const a = checkVector(args, 0, 'lerp')
+      const b = checkVector(args, 1, 'lerp')
+      const t = checkNumber(args, 2, 'lerp')
+      return new Vector(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t)
+    },
+  }, 'vector.')
+
+  lib.set('zero', new Vector(0, 0, 0))
+  lib.set('one', new Vector(1, 1, 1))
+}

package/script/luau/lib/string/string.format.js

@@ -0,0 +1,143 @@
+/**
+ * `string.format`: C's printf conversions as Lua uses them.
+ */
+
+import { fail } from '../../vm/vm.value.js'
+import { formatE, formatF, formatG, repeat, trunc } from '../../vm/vm.num.js'
+import { checkNumber, checkString } from '../lib.args.js'
+
+const SPEC = /^%([-+ #0]*)(\d*)(?:\.(\d*))?([a-zA-Z%])/
+
+/**
+ * Pads `body` (with its sign or prefix split off) to `width`.
+ *
+ * @param   {string}  sign   '-', '+', ' ', a `0x` prefix or ''
+ * @param   {string}  body
+ * @param   {number}  width
+ * @param   {string}  flags
+ * @param   {boolean} zeroOk  whether the 0 flag pads with zeros here
+ * @returns {string}
+ */
+function pad(sign, body, width, flags, zeroOk) {
+  const n = width - sign.length - body.length
+  if (n <= 0) return sign + body
+  if (flags.indexOf('-') >= 0) return sign + body + repeat(' ', n)
+  if (flags.indexOf('0') >= 0 && zeroOk) return sign + repeat('0', n) + body
+  return repeat(' ', n) + sign + body
+}
+
+/**
+ * @param   {string} s
+ * @returns {string} s as a Lua string literal that reads back as s (`%q`)
+ */
+function quote(s) {
+  let out = '"'
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i)
+    const ch = s.charAt(i)
+    if (ch === '"' || ch === '\\') out += '\\' + ch
+    else if (c === 10) out += '\\\n'
+    else if (c === 13) out += '\\r'
+    else if (c === 0) out += '\\000'
+    else out += ch
+  }
+  return out + '"'
+}
+
+/**
+ * @param   {import('../../vm/vm.js').VM} vm
+ * @param   {any[]} args  the format string, then the values
+ * @returns {string}
+ */
+export function format(vm, args) {
+  const fmt = checkString(args, 0, 'format')
+  let out = ''
+  let arg = 0
+  let i = 0
+  while (i < fmt.length) {
+    const pct = fmt.indexOf('%', i)
+    if (pct < 0) {
+      out += fmt.substring(i)
+      break
+    }
+    out += fmt.substring(i, pct)
+    const m = SPEC.exec(fmt.substring(pct))
+    if (m === null) throw fail("invalid option '%" + fmt.charAt(pct + 1) + "' to 'format'")
+    i = pct + m[0].length
+    const flags = m[1]
+    const width = m[2] === '' ? 0 : parseInt(m[2], 10)
+    const hasPrecision = m[3] !== undefined
+    const precision = hasPrecision ? (m[3] === '' ? 0 : parseInt(m[3], 10)) : -1
+    const conv = m[4]
+    if (conv === '%') {
+      out += '%'
+      continue
+    }
+    arg++
+    if (arg >= args.length) throw fail('missing argument #' + (arg + 1))
+    const signOf = function (/** @type {boolean} */ negative) {
+      return negative ? '-' : flags.indexOf('+') >= 0 ? '+' : flags.indexOf(' ') >= 0 ? ' ' : ''
+    }
+    switch (conv) {
+      case 'd':
+      case 'i':
+      case 'u': {
+        const n = trunc(checkNumber(args, arg, 'format'))
+        let body = String(Math.abs(n))
+        if (hasPrecision) while (body.length < precision) body = '0' + body
+        out += pad(signOf(n < 0), body, width, flags, !hasPrecision)
+        break
+      }
+      case 'c':
+        out += pad('', String.fromCharCode(trunc(checkNumber(args, arg, 'format')) & 255), width, flags, false)
+        break
+      case 'x':
+      case 'X':
+      case 'o': {
+        let n = trunc(checkNumber(args, arg, 'format'))
+        if (n < 0) n += 4294967296
+        let body = n.toString(conv === 'o' ? 8 : 16)
+        if (conv === 'X') body = body.toUpperCase()
+        if (hasPrecision) while (body.length < precision) body = '0' + body
+        const prefix = flags.indexOf('#') >= 0 && n !== 0 ? (conv === 'o' ? '0' : conv === 'x' ? '0x' : '0X') : ''
+        out += pad(prefix, body, width, flags, !hasPrecision)
+        break
+      }
+      case 'e':
+      case 'E':
+      case 'f':
+      case 'F':
+      case 'g':
+      case 'G': {
+        const n = checkNumber(args, arg, 'format')
+        const upper = conv === 'E' || conv === 'G' || conv === 'F'
+        const alt = flags.indexOf('#') >= 0
+        const finite = n === n && n !== Infinity && n !== -Infinity
+        const neg = n < 0 || (n === 0 && 1 / n < 0)
+        let body
+        if (!finite) body = n !== n ? 'nan' : 'inf'
+        else {
+          const p = hasPrecision ? precision : 6
+          const a = Math.abs(n)
+          const lower = conv.toLowerCase()
+          body = lower === 'e' ? formatE(a, p, alt) : lower === 'f' ? formatF(a, p, alt) : formatG(a, p, alt)
+        }
+        if (upper) body = body.toUpperCase()
+        out += pad(signOf(neg), body, width, flags, finite)
+        break
+      }
+      case 'q':
+        out += quote(checkString(args, arg, 'format'))
+        break
+      case 's': {
+        let s = checkString(args, arg, 'format')
+        if (hasPrecision) s = s.substring(0, precision)
+        out += pad('', s, width, flags, false)
+        break
+      }
+      default:
+        throw fail("invalid option '%" + conv + "' to 'format'")
+    }
+  }
+  return out
+}

package/script/luau/lib/string/string.js

@@ -0,0 +1,160 @@
+/**
+ * The `string` library, and the string metatable that makes `("x"):upper()`
+ * work. Strings are byte strings, so `upper` and `lower` change ASCII letters
+ * only, as C's locale does.
+ */
+
+import { LuaTable, fail, typeName } from '../../vm/vm.value.js'
+import { numberToString, repeat } from '../../vm/vm.num.js'
+import { argError, checkFunction, checkInt, checkString, optInt, optString, register, typeError } from '../lib.args.js'
+import { format } from './string.format.js'
+import { find, gmatch, gsub } from './string.pattern.js'
+
+/**
+ * @param   {number} i    a 1-based position, negative from the end
+ * @param   {number} len
+ * @returns {number}
+ */
+function posrelat(i, len) {
+  return i >= 0 ? i : -i > len ? 0 : len + i + 1
+}
+
+/**
+ * @param {import('../../vm/vm.js').VM} vm
+ * @param {LuaTable} G
+ */
+export function installString(vm, G) {
+  const string = new LuaTable()
+  G.set('string', string)
+
+  register(string, {
+    len(vm, args) {
+      return checkString(args, 0, 'len').length
+    },
+
+    sub(vm, args) {
+      const s = checkString(args, 0, 'sub')
+      let i = posrelat(checkInt(args, 1, 'sub'), s.length)
+      let j = posrelat(optInt(args, 2, 'sub', -1), s.length)
+      if (i < 1) i = 1
+      if (j > s.length) j = s.length
+      return i > j ? '' : s.substring(i - 1, j)
+    },
+
+    upper(vm, args) {
+      return checkString(args, 0, 'upper').replace(/[a-z]+/g, function (m) { return m.toUpperCase() })
+    },
+
+    lower(vm, args) {
+      return checkString(args, 0, 'lower').replace(/[A-Z]+/g, function (m) { return m.toLowerCase() })
+    },
+
+    rep(vm, args) {
+      const s = checkString(args, 0, 'rep')
+      const n = checkInt(args, 1, 'rep')
+      if (n <= 0) return ''
+      if (s.length * n > 1e9) throw fail('resulting string too large')
+      return repeat(s, n)
+    },
+
+    reverse(vm, args) {
+      const s = checkString(args, 0, 'reverse')
+      let out = ''
+      for (let i = s.length - 1; i >= 0; i--) out += s.charAt(i)
+      return out
+    },
+
+    byte(vm, args) {
+      const s = checkString(args, 0, 'byte')
+      const i = posrelat(optInt(args, 1, 'byte', 1), s.length)
+      let j = posrelat(optInt(args, 2, 'byte', i), s.length)
+      const start = Math.max(i, 1)
+      if (j > s.length) j = s.length
+      const out = []
+      for (let n = start; n <= j; n++) out.push(s.charCodeAt(n - 1))
+      return out
+    },
+
+    char(vm, args) {
+      let out = ''
+      for (let i = 0; i < args.length; i++) {
+        const c = checkInt(args, i, 'char')
+        if (c < 0 || c > 255) throw argError(i + 1, 'char', 'invalid value')
+        out += String.fromCharCode(c)
+      }
+      return out
+    },
+
+    find(vm, args) {
+      const s = checkString(args, 0, 'find')
+      const r = find(s, checkString(args, 1, 'find'), optInt(args, 2, 'find', 1), args[3] !== undefined && args[3] !== false, true)
+      return r === undefined ? undefined : r
+    },
+
+    match(vm, args) {
+      const s = checkString(args, 0, 'match')
+      const r = find(s, checkString(args, 1, 'match'), optInt(args, 2, 'match', 1), false, false)
+      return r === undefined ? undefined : r
+    },
+
+    gmatch(vm, args) {
+      const next = gmatch(checkString(args, 0, 'gmatch'), checkString(args, 1, 'gmatch'))
+      return vm.native('gmatch_iterator', function () {
+        const r = next()
+        return r === undefined ? undefined : r
+      })
+    },
+
+    gsub(vm, args) {
+      const s = checkString(args, 0, 'gsub')
+      const pat = checkString(args, 1, 'gsub')
+      const repl = args[2]
+      const max = args[3] === undefined ? s.length + 1 : checkInt(args, 3, 'gsub')
+      /** @type {string | null} */
+      let template = null
+      /** @type {(c: (string | number)[]) => any} */
+      let replace = function () { return undefined }
+      if (typeof repl === 'string') template = repl
+      else if (typeof repl === 'number') template = numberToString(repl)
+      else if (repl instanceof LuaTable) {
+        replace = function (c) {
+          return convertReplacement(repl.get(c[0]))
+        }
+      } else if (repl !== undefined && typeName(repl) === 'function') {
+        checkFunction(args, 2, 'gsub')
+        replace = function (c) {
+          return convertReplacement(vm.call(repl, c)[0])
+        }
+      } else throw typeError(args, 2, 'gsub', 'string/function/table')
+      return gsub(s, pat, replace, template, max)
+    },
+
+    format(vm, args) {
+      return format(vm, args)
+    },
+
+    split(vm, args) {
+      const s = checkString(args, 0, 'split')
+      const sep = optString(args, 1, 'split', ',')
+      const t = new LuaTable()
+      const parts = sep === '' ? [ s ] : s.split(sep)
+      t.setRange(1, parts, 0, parts.length)
+      return t
+    },
+  }, 'string.')
+
+  const meta = new LuaTable()
+  meta.set('__index', string)
+  vm.stringMeta = meta
+}
+
+/**
+ * @param   {any} v  what a gsub callback or table gave
+ * @returns {string | number | boolean | undefined}
+ */
+function convertReplacement(v) {
+  if (v === undefined || v === false) return v
+  if (typeof v === 'string') return v
+  if (typeof v === 'number') return numberToString(v)
+  throw fail('invalid replacement value (a ' + typeName(v) + ')')
+}