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

package/script/rive/api/math/math.mat2d.js

@@ -0,0 +1,180 @@
+/**
+ * Rive's `Mat2D`: a 2D affine matrix with fields `xx xy yx yy tx ty` (also
+ * indexed 1 to 6 in that order), where a point maps to
+ * `(xx * x + yx * y + tx, xy * x + yy * y + ty)`. These six numbers are
+ * Lottie's `[a, b, c, d, tx, ty]` in order. `a * b` applies `b` first.
+ */
+
+import { LuaTable, NativeFunction, Vector, fail } from '../../../luau/vm/vm.value.js'
+import { defineType, num, optNum, badArg, wrapped } from '../api.type.js'
+
+/** The field names, in index order */
+const NAMES = [ 'xx', 'xy', 'yx', 'yy', 'tx', 'ty' ]
+
+/** @typedef {number[]} Matrix  [xx, xy, yx, yy, tx, ty] */
+
+/** @returns {Matrix} */
+export function identity() {
+  return [ 1, 0, 0, 1, 0, 0 ]
+}
+
+/**
+ * The matrix that applies `b` first, then `a`.
+ *
+ * @param   {Matrix} a
+ * @param   {Matrix} b
+ * @returns {Matrix}
+ */
+export function multiply(a, b) {
+  return [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5],
+  ]
+}
+
+/**
+ * @param   {Matrix} m
+ * @returns {Matrix | null} the inverse, or null when there is none
+ */
+export function invert(m) {
+  const det = m[0] * m[3] - m[1] * m[2]
+  if (det === 0 || det !== det) return null
+  const id = 1 / det
+  return [
+    m[3] * id,
+    -m[1] * id,
+    -m[2] * id,
+    m[0] * id,
+    (m[2] * m[5] - m[3] * m[4]) * id,
+    (m[1] * m[4] - m[0] * m[5]) * id,
+  ]
+}
+
+/**
+ * @param   {Matrix} m
+ * @param   {number} x
+ * @param   {number} y
+ * @returns {number[]} [x, y]
+ */
+export function apply(m, x, y) {
+  return [ m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5] ]
+}
+
+/** @type {Record<string, { get: (h: Matrix) => any, set: (h: Matrix, v: any) => void }>} */
+const fields = Object.create(null)
+NAMES.forEach(function (name, i) {
+  fields[name] = {
+    get: (h) => h[i],
+    set: (h, v) => {
+      if (typeof v !== 'number') throw fail('Mat2D.' + name + ' must be a number')
+      h[i] = v
+    },
+  }
+})
+
+export const Mat2D = defineType('Mat2D', {
+  fields,
+  methods: {
+    invert: (h) => {
+      const inv = invert(h)
+      return inv ? Mat2D.wrap(inv) : undefined
+    },
+    isIdentity: (h) => h[0] === 1 && h[1] === 0 && h[2] === 0 && h[3] === 1 && h[4] === 0 && h[5] === 0,
+  },
+  index: (h, key) => (typeof key === 'number' && key >= 1 && key <= 6 && key === Math.floor(key) ? h[key - 1] : undefined),
+  newindex: (h, key, value) => {
+    if (typeof key !== 'number' || key < 1 || key > 6 || typeof value !== 'number') throw fail('invalid Mat2D index')
+    h[key - 1] = value
+  },
+  meta: {
+    __mul: (vm, args) => {
+      const a = Mat2D.unwrap(args[0])
+      if (a === undefined) throw badArg(0, 'Mat2D.__mul', 'Mat2D', args)
+      const b = args[1]
+      if (b instanceof Vector) {
+        const p = apply(a, b.x, b.y)
+        return new Vector(p[0], p[1], b.z)
+      }
+      const m = Mat2D.unwrap(b)
+      if (m === undefined) throw badArg(1, 'Mat2D.__mul', 'Vector or Mat2D', args)
+      return Mat2D.wrap(multiply(a, m))
+    },
+    __eq: (vm, args) => {
+      const a = Mat2D.unwrap(args[0])
+      const b = Mat2D.unwrap(args[1])
+      if (a === undefined || b === undefined) return false
+      for (let i = 0; i < 6; i++) if (a[i] !== b[i]) return false
+      return true
+    },
+    __tostring: (vm, args) => 'Mat2D(' + Mat2D.unwrap(args[0]).join(', ') + ')',
+  },
+})
+
+/**
+ * @param   {any[]} args
+ * @param   {number} i      first of two numbers or one vector
+ * @param   {string} fname
+ * @param   {boolean} [single]  a lone number stands for both axes
+ * @returns {number[]}  [x, y]
+ */
+function pair(args, i, fname, single) {
+  const v = args[i]
+  if (v instanceof Vector) return [ v.x, v.y ]
+  const x = num(args, i, fname)
+  return [ x, single && args[i + 1] === undefined ? x : optNum(args, i + 1, fname, 0) ]
+}
+
+/** @type {Record<string, (args: any[]) => any>} */
+const STATICS = {
+  identity: () => Mat2D.wrap(identity()),
+  values: (a) => Mat2D.wrap([ num(a, 0, 'values'), num(a, 1, 'values'), num(a, 2, 'values'), num(a, 3, 'values'), num(a, 4, 'values'), num(a, 5, 'values') ]),
+  withRotation: (a) => {
+    const r = num(a, 0, 'withRotation')
+    const c = Math.cos(r)
+    const s = Math.sin(r)
+    return Mat2D.wrap([ c, s, -s, c, 0, 0 ])
+  },
+  withTranslation: (a) => {
+    const t = pair(a, 0, 'withTranslation')
+    return Mat2D.wrap([ 1, 0, 0, 1, t[0], t[1] ])
+  },
+  withScale: (a) => {
+    const s = pair(a, 0, 'withScale', true)
+    return Mat2D.wrap([ s[0], 0, 0, s[1], 0, 0 ])
+  },
+  withScaleAndTranslation: (a) => {
+    if (a[0] instanceof Vector) {
+      const s = pair(a, 0, 'withScaleAndTranslation')
+      const t = pair(a, 1, 'withScaleAndTranslation')
+      return Mat2D.wrap([ s[0], 0, 0, s[1], t[0], t[1] ])
+    }
+    return Mat2D.wrap([ num(a, 0, 'withScaleAndTranslation'), 0, 0, num(a, 1, 'withScaleAndTranslation'), num(a, 2, 'withScaleAndTranslation'), num(a, 3, 'withScaleAndTranslation') ])
+  },
+  invert: (a) => {
+    const out = wrapped(a, 0, Mat2D, 'invert')
+    const inv = invert(wrapped(a, 1, Mat2D, 'invert'))
+    if (!inv) return false
+    for (let i = 0; i < 6; i++) out[i] = inv[i]
+    return true
+  },
+}
+
+/**
+ * Installs the `Mat2D` global.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ */
+export function installMat2D(vm) {
+  const table = new LuaTable()
+  for (const name in STATICS) {
+    const fn = STATICS[name]
+    table.set(name, new NativeFunction('Mat2D.' + name, function (vm2, args) {
+      return fn(args)
+    }))
+  }
+  vm.globals.set('Mat2D', table)
+}

package/script/rive/api/math/math.vector.js

@@ -0,0 +1,121 @@
+/**
+ * Rive's `Vector`: Luau's own vector value (x, y, z), made with `Vector.xy`
+ * and friends. Its methods are the same functions as the static ones, since
+ * a method call passes the vector first (`v:lerp(w, t)` is `Vector.lerp(v, w, t)`).
+ */
+
+import { LuaTable, NativeFunction, Vector } from '../../../luau/vm/vm.value.js'
+import { badArg, num, optNum } from '../api.type.js'
+
+/**
+ * @param   {any[]}  args
+ * @param   {number} i
+ * @param   {string} fname
+ * @returns {Vector}
+ */
+export function vec(args, i, fname) {
+  const v = args[i]
+  if (!(v instanceof Vector)) throw badArg(i, fname, 'Vector', args)
+  return v
+}
+
+/** @param {Vector} v */
+function length(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
+}
+
+/** @type {Record<string, (args: any[]) => any>} */
+const OPS = {
+  length: (a) => length(vec(a, 0, 'length')),
+  lengthSquared: (a) => {
+    const v = vec(a, 0, 'lengthSquared')
+    return v.x * v.x + v.y * v.y + v.z * v.z
+  },
+  normalized: (a) => {
+    const v = vec(a, 0, 'normalized')
+    const l = length(v)
+    return l === 0 ? new Vector(0, 0, 0) : new Vector(v.x / l, v.y / l, v.z / l)
+  },
+  distance: (a) => {
+    const p = vec(a, 0, 'distance')
+    const q = vec(a, 1, 'distance')
+    return length(new Vector(p.x - q.x, p.y - q.y, p.z - q.z))
+  },
+  distanceSquared: (a) => {
+    const p = vec(a, 0, 'distanceSquared')
+    const q = vec(a, 1, 'distanceSquared')
+    return (p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y) + (p.z - q.z) * (p.z - q.z)
+  },
+  dot: (a) => {
+    const p = vec(a, 0, 'dot')
+    const q = vec(a, 1, 'dot')
+    return p.x * q.x + p.y * q.y + p.z * q.z
+  },
+  lerp: (a) => {
+    const p = vec(a, 0, 'lerp')
+    const q = vec(a, 1, 'lerp')
+    const t = num(a, 2, 'lerp')
+    return new Vector(p.x + (q.x - p.x) * t, p.y + (q.y - p.y) * t, p.z + (q.z - p.z) * t)
+  },
+}
+
+/** @type {Record<string, (args: any[]) => any>} */
+const STATICS = {
+  xy: (a) => new Vector(num(a, 0, 'xy'), num(a, 1, 'xy'), 0),
+  xyz: (a) => new Vector(num(a, 0, 'xyz'), num(a, 1, 'xyz'), num(a, 2, 'xyz')),
+  origin: () => new Vector(0, 0, 0),
+  cross: (a) => {
+    const p = vec(a, 0, 'cross')
+    const q = vec(a, 1, 'cross')
+    return p.x * q.y - p.y * q.x
+  },
+  cross3: (a) => {
+    const p = vec(a, 0, 'cross3')
+    const q = vec(a, 1, 'cross3')
+    return new Vector(p.y * q.z - p.z * q.y, p.z * q.x - p.x * q.z, p.x * q.y - p.y * q.x)
+  },
+  scaleAndAdd: (a) => {
+    const p = vec(a, 0, 'scaleAndAdd')
+    const q = vec(a, 1, 'scaleAndAdd')
+    const s = optNum(a, 2, 'scaleAndAdd', 1)
+    return new Vector(p.x + q.x * s, p.y + q.y * s, p.z + q.z * s)
+  },
+  scaleAndSub: (a) => {
+    const p = vec(a, 0, 'scaleAndSub')
+    const q = vec(a, 1, 'scaleAndSub')
+    const s = optNum(a, 2, 'scaleAndSub', 1)
+    return new Vector(p.x - q.x * s, p.y - q.y * s, p.z - q.z * s)
+  },
+}
+
+/**
+ * Installs the `Vector` global and the methods vectors share.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ */
+export function installVector(vm) {
+  const statics = new LuaTable()
+  const methods = new LuaTable()
+  for (const name in STATICS) statics.set(name, native('Vector.' + name, STATICS[name]))
+  for (const name in OPS) {
+    statics.set(name, native('Vector.' + name, OPS[name]))
+    methods.set(name, native('Vector.' + name, OPS[name]))
+  }
+  vm.globals.set('Vector', statics)
+
+  const meta = vm.vectorMeta || new LuaTable()
+  meta.set('__index', methods)
+  vm.vectorMeta = meta
+}
+
+/**
+ * @param   {string} name
+ * @param   {(args: any[]) => any} fn
+ * @returns {NativeFunction}
+ */
+function native(name, fn) {
+  return new NativeFunction(name, function (vm, args) {
+    return fn(args)
+  })
+}
+

package/script/rive/api/media/media.audio.js

@@ -0,0 +1,113 @@
+/**
+ * Script audio, recorded rather than played: `AudioSource` (an audio asset,
+ * from `context:audio(name)`), the `Audio` global that starts it, and the
+ * `AudioSound` that stands for one playing. Every start, stop, pause, resume
+ * and seek is appended to the host's list as
+ * `{ kind: 'audio', action, asset, volume, time }` for the player to map to
+ * its own audio events (`host.audio()` takes the list).
+ */
+
+import { badArg, defineType, num, optNum, wrapped } from '../api.type.js'
+import { statics } from '../api.statics.js'
+
+/**
+ * @typedef {object} AudioEvent
+ * @property {'audio'} kind
+ * @property {'play' | 'stop' | 'pause' | 'resume' | 'seek'} action
+ * @property {string}  asset
+ * @property {number}  volume  0 to 1
+ * @property {number}  time    the sound's position in seconds when it happened
+ * @property {number}  [fade]  a stop's fade, in PCM frames
+ */
+
+/**
+ * @typedef {object} SoundData
+ * @property {string}       name
+ * @property {number}       volume
+ * @property {number}       time
+ * @property {boolean}      done
+ * @property {boolean}      paused
+ * @property {AudioEvent[]} sink
+ */
+
+export const AudioSource = defineType('AudioSource', {
+  fields: {
+    duration: { get: (h) => h.duration },
+  },
+})
+
+/**
+ * @param {SoundData} s
+ * @param {AudioEvent['action']} action
+ * @param {number} [fade]
+ */
+function note(s, action, fade) {
+  /** @type {AudioEvent} */
+  const e = { kind: 'audio', action, asset: s.name, volume: s.volume, time: s.time }
+  if (fade !== undefined) e.fade = fade
+  s.sink.push(e)
+}
+
+export const AudioSound = defineType('AudioSound', {
+  fields: {
+    volume: { get: (s) => s.volume, set: (s, v) => { s.volume = typeof v === 'number' ? v : s.volume } },
+  },
+  methods: {
+    play: (s) => {
+      s.done = false
+      s.paused = false
+      note(s, 'play')
+    },
+    stop: (s, args) => {
+      s.done = true
+      note(s, 'stop', optNum(args, 1, 'stop', 0))
+    },
+    pause: (s) => {
+      s.paused = true
+      note(s, 'pause')
+    },
+    resume: (s) => {
+      s.paused = false
+      note(s, 'resume')
+    },
+    seek: (s, args) => {
+      if (s.done) return false
+      s.time = num(args, 1, 'seek')
+      note(s, 'seek')
+      return true
+    },
+    seekFrame: (s, args) => {
+      if (s.done) return false
+      s.time = num(args, 1, 'seekFrame') / 48000
+      note(s, 'seek')
+      return true
+    },
+    completed: (s) => s.done,
+    time: (s) => s.time,
+    timeFrame: (s) => Math.round(s.time * 48000),
+  },
+})
+
+/**
+ * Installs the `Audio` global; its sounds report to `sink`.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ * @param {AudioEvent[]} sink
+ */
+export function installAudio(vm, sink) {
+  /**
+   * `Audio:play(source, volume?)` or `Audio.play(source, volume?)`.
+   *
+   * @param {any[]} args
+   */
+  const play = (args) => {
+    const at = AudioSource.is(args[0]) ? 0 : 1
+    if (!AudioSource.is(args[at])) throw badArg(at, 'play', 'AudioSource', args)
+    const source = wrapped(args, at, AudioSource, 'play')
+    /** @type {SoundData} */
+    const s = { name: source.name, volume: optNum(args, at + 1, 'play', 1), time: 0, done: false, paused: false, sink }
+    note(s, 'play')
+    return AudioSound.wrap(s)
+  }
+  vm.globals.set('Audio', statics('Audio', { play }))
+}

package/script/rive/api/media/media.draw.js

@@ -0,0 +1,73 @@
+/**
+ * What `Renderer` records for images: `drawImage` and `drawImageMesh`, and
+ * the stamp every non-path record carries (the matrix, clips, opacity and
+ * colour modulation in force).
+ */
+
+import { num, text, wrapped } from '../api.type.js'
+import { Image, ImageSampler } from './media.image.js'
+import { TriangleBuffer, VertexBuffer } from './media.mesh.js'
+
+/**
+ * @typedef {object} ImageDrawing
+ * @property {'image'} kind
+ * @property {string}  asset
+ * @property {number}  width
+ * @property {number}  height
+ * @property {number[]} transform   [xx, xy, yx, yy, tx, ty]; shared, never changed
+ * @property {number[][][]} clips   the clips in force
+ * @property {number}  opacity      0 to 1: `modulateOpacity` times the call's own
+ * @property {number}  color        the colour modulation, ARGB
+ * @property {string}  blendMode
+ * @property {import('./media.image.js').SamplerData} sampler
+ * @property {{ vertices: number[], uvs: number[], indices: number[] } | null} mesh  a mesh's points, UVs and triangle indices
+ */
+
+/**
+ * The state a drawing is made under, as the fields every record shares.
+ *
+ * @param   {import('../draw/draw.renderer.js').Recorder} r
+ * @param   {string} kind
+ * @returns {{ kind: string, transform: number[], clips: any[], opacity: number, color: number }}
+ */
+export function stamp(r, kind) {
+  const s = r.state
+  return { kind, transform: s.m, clips: s.clips, opacity: s.opacity, color: s.color }
+}
+
+/**
+ * @param   {import('../draw/draw.renderer.js').Recorder} r
+ * @param   {any[]} args  image, sampler, then what each call takes
+ * @param   {number} at   where blendMode and opacity start
+ * @param   {boolean} mesh
+ */
+function record(r, args, at, mesh) {
+  const fname = mesh ? 'drawImageMesh' : 'drawImage'
+  const image = wrapped(args, 1, Image, fname)
+  const sampler = wrapped(args, 2, ImageSampler, fname)
+  const rec = /** @type {any} */ (stamp(r, 'image'))
+  rec.asset = image.name
+  rec.width = image.width
+  rec.height = image.height
+  rec.blendMode = args[at] === undefined ? 'srcOver' : text(args, at, fname)
+  rec.opacity = r.state.opacity * (args[at + 1] === undefined ? 1 : num(args, at + 1, fname))
+  rec.sampler = sampler
+  rec.mesh = mesh
+    ? {
+        vertices: wrapped(args, 3, VertexBuffer, fname).data.slice(),
+        uvs: wrapped(args, 4, VertexBuffer, fname).data.slice(),
+        indices: wrapped(args, 5, TriangleBuffer, fname).data.slice(),
+      }
+    : null
+  r.drawings.push(rec)
+}
+
+/** `drawImage(image, sampler, blendMode, opacity)` @param {any} r @param {any[]} args */
+export function drawImage(r, args) {
+  record(r, args, 3, false)
+}
+
+/** `drawImageMesh(image, sampler, vertices, uvs, triangles, blendMode, opacity)` @param {any} r @param {any[]} args */
+export function drawImageMesh(r, args) {
+  record(r, args, 6, true)
+}

package/script/rive/api/media/media.image.js

@@ -0,0 +1,61 @@
+/**
+ * `Image` (a decoded picture the script holds, by asset name) and
+ * `ImageSampler` (how it is read when drawn). A player gives a script images
+ * through `context:image(name)`, an image input, or an image view-model
+ * property; the host only names the asset and knows its size.
+ */
+
+import { defineType, text } from '../api.type.js'
+import { statics } from '../api.statics.js'
+
+/**
+ * @typedef {object} ImageData
+ * @property {string} name    the asset
+ * @property {number} width   0 until the player knows it
+ * @property {number} height
+ */
+
+/**
+ * @typedef {object} SamplerData
+ * @property {string} wrapX    `clamp`, `repeat` or `mirror`
+ * @property {string} wrapY
+ * @property {string} filter   `bilinear` or `nearest`
+ */
+
+export const Image = defineType('Image', {
+  fields: {
+    width: { get: (h) => h.width },
+    height: { get: (h) => h.height },
+  },
+})
+
+export const ImageSampler = defineType('ImageSampler', {
+  fields: {
+    wrapX: { get: (h) => h.wrapX },
+    wrapY: { get: (h) => h.wrapY },
+    filter: { get: (h) => h.filter },
+  },
+})
+
+/**
+ * @param   {any[]} a  wrapX, wrapY, filter
+ * @returns {any}
+ */
+function newSampler(a) {
+  /** @type {SamplerData} */
+  const h = {
+    wrapX: a[0] === undefined ? 'clamp' : text(a, 0, 'ImageSampler'),
+    wrapY: a[1] === undefined ? 'clamp' : text(a, 1, 'ImageSampler'),
+    filter: a[2] === undefined ? 'bilinear' : text(a, 2, 'ImageSampler'),
+  }
+  return ImageSampler.wrap(h)
+}
+
+/**
+ * Installs the `ImageSampler` global.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ */
+export function installImage(vm) {
+  vm.globals.set('ImageSampler', statics('ImageSampler', { new: newSampler }, 'new'))
+}

package/script/rive/api/media/media.mesh.js

@@ -0,0 +1,50 @@
+/**
+ * `VertexBuffer` and `TriangleBuffer`: the points and the triangles of an
+ * image mesh, as flat number lists the recorder copies at the draw.
+ */
+
+import { Vector } from '../../../luau/vm/vm.value.js'
+import { badArg, defineType, num } from '../api.type.js'
+import { statics } from '../api.statics.js'
+
+export const VertexBuffer = defineType('VertexBuffer', {
+  fields: {
+    length: { get: (h) => h.data.length / 2 },
+  },
+  methods: {
+    add: (h, args) => {
+      for (let i = 1; i < args.length; i++) {
+        const v = args[i]
+        if (!(v instanceof Vector)) throw badArg(i, 'add', 'Vector', args)
+        h.data.push(v.x, v.y)
+      }
+    },
+    reset: (h) => {
+      h.data.length = 0
+    },
+  },
+})
+
+export const TriangleBuffer = defineType('TriangleBuffer', {
+  fields: {
+    length: { get: (h) => h.data.length / 3 },
+  },
+  methods: {
+    add: (h, args) => {
+      h.data.push(num(args, 1, 'add'), num(args, 2, 'add'), num(args, 3, 'add'))
+    },
+    reset: (h) => {
+      h.data.length = 0
+    },
+  },
+})
+
+/**
+ * Installs the `VertexBuffer` and `TriangleBuffer` globals.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ */
+export function installMesh(vm) {
+  vm.globals.set('VertexBuffer', statics('VertexBuffer', { new: () => VertexBuffer.wrap({ data: [] }) }, 'new'))
+  vm.globals.set('TriangleBuffer', statics('TriangleBuffer', { new: () => TriangleBuffer.wrap({ data: [] }) }, 'new'))
+}

package/script/rive/api/pointer/pointer.event.js

@@ -0,0 +1,64 @@
+/**
+ * `PointerEvent` as a scripted node receives it in `pointerDown`,
+ * `pointerMove`, `pointerUp` and `pointerExit`: `position` (the script's local
+ * space), `id`, `type`, `previousPosition`, `timeStamp`, and `hit(translucent?)`
+ * which claims the event. `PointerEvent.new(id, position)` makes one, to
+ * forward to a nested artboard.
+ */
+
+import { Vector } from '../../../luau/vm/vm.value.js'
+import { badArg, defineType, num } from '../api.type.js'
+import { statics } from '../api.statics.js'
+
+/**
+ * @typedef {object} PointerData
+ * @property {number} id
+ * @property {Vector} position
+ * @property {Vector} previous
+ * @property {string} type
+ * @property {number} time
+ * @property {boolean} hit          the script called `hit`
+ * @property {boolean} translucent  and let the event through
+ */
+
+export const PointerEvent = defineType('PointerEvent', {
+  fields: {
+    position: { get: (e) => e.position },
+    previousPosition: { get: (e) => e.previous },
+    id: { get: (e) => e.id },
+    type: { get: (e) => e.type },
+    timeStamp: { get: (e) => e.time },
+  },
+  methods: {
+    hit: (e, args) => {
+      e.hit = true
+      e.translucent = args[1] === true
+    },
+  },
+})
+
+/**
+ * @param   {number} id
+ * @param   {Vector} position
+ * @param   {Vector} previous
+ * @param   {string} type
+ * @param   {number} time
+ * @returns {PointerData}
+ */
+export function pointerData(id, position, previous, type, time) {
+  return { id, position, previous, type, time, hit: false, translucent: false }
+}
+
+/**
+ * Installs the `PointerEvent` global.
+ *
+ * @param {import('../../../luau/vm/vm.js').VM} vm
+ */
+export function installPointer(vm) {
+  vm.globals.set('PointerEvent', statics('PointerEvent', {
+    new: (a) => {
+      if (!(a[1] instanceof Vector)) throw badArg(1, 'new', 'Vector', a)
+      return PointerEvent.wrap(pointerData(num(a, 0, 'new'), a[1], a[1], 'pointerMove', 0))
+    },
+  }))
+}