animl 0.0.0-stage → 0.1.0

package/modules/input/core/runtime.js

@@ -0,0 +1,462 @@
+import { drawWorld } from "../../../packages/core/src/draw.js";
+import { apply, invert, mul } from "../../../packages/core/src/geom.js";
+const configurations = /* @__PURE__ */ new WeakMap();
+let peers;
+const controllers = /* @__PURE__ */ new WeakMap();
+const installed = /* @__PURE__ */ new WeakSet();
+const finite = (...v) => {
+  if (!v.every(Number.isFinite)) throw Error("anima: input coordinates must be finite");
+};
+class InputController {
+  enabled = true;
+  /** Optional focus-module target; explicit key options take precedence. */
+  keyTarget;
+  contacts = /* @__PURE__ */ new Map();
+  disabled = /* @__PURE__ */ new Set();
+  pads = /* @__PURE__ */ new Map();
+  latch;
+  player;
+  constructor(player) {
+    this.player = player;
+  }
+  get listeners() {
+    return configurations.get(this.player.model.inputs) ?? [];
+  }
+  eligible(node) {
+    const p = this.player;
+    if (node < 0) return true;
+    if (!p.visible(node)) return false;
+    for (let n = node; n >= 0; n = p.model.nodes[n].parent)
+      if (p.prop(n, "pointerEnabled") === false) return false;
+    return true;
+  }
+  ancestor(parent, child) {
+    if (parent < 0) return true;
+    for (let n = child; n >= 0; n = this.player.model.nodes[n].parent)
+      if (n === parent) return true;
+    return false;
+  }
+  hits(l, x, y) {
+    return this.eligible(l.target) && this.player.hits(l.action, x, y);
+  }
+  rank = (node) => this.player.paintRank?.(node) ?? node;
+  foremost = (a, b) => this.rank(b) - this.rank(a);
+  /** Hit targets foremost first; an opaque target keeps its ancestor chain. */
+  targets(x, y, options = {}) {
+    finite(x, y);
+    const p = this.player, out = /* @__PURE__ */ new Set();
+    if (options.bounded) {
+      const [a, b, w, h] = p.model.viewBox;
+      if (x < a || y < b || x > a + w || y > b + h) return out;
+    }
+    const candidates = this.listeners.filter((l) => this.hits(l, x, y));
+    const extras = p.model.nodes.map((node, target) => ({ node, target })).filter(
+      ({ node, target }) => (node.raw.opaque || node.raw.cursor) && this.eligible(target) && p.hits({ target, pad: 0 }, x, y)
+    );
+    const blockers = [...candidates.map((l) => l.target), ...extras.map((e) => e.target)].filter(
+      (n) => n >= 0 && p.model.nodes[n].raw.opaque
+    );
+    const blocker = blockers.sort(this.foremost)[0];
+    const accepts = (target) => blocker === void 0 || this.rank(target) >= this.rank(blocker) || this.ancestor(target, blocker);
+    for (const l of candidates)
+      if ((!options.scroll || l.on.includes("scroll")) && accepts(l.target)) out.add(l.target);
+    if (!options.scroll) {
+      for (const e of extras) if (accepts(e.target)) out.add(e.target);
+    }
+    return new Set([...out].sort(this.foremost));
+  }
+  hitTest(x, y, options = {}) {
+    return [...this.targets(x, y, options)].map(
+      (n) => n < 0 ? "@icon" : this.player.model.nodes[n].id
+    );
+  }
+  occludes(x, y, options = {}) {
+    return [...this.targets(x, y, { ...options, scroll: false })].some(
+      (n) => n >= 0 && !!this.player.model.nodes[n].raw.opaque && (!options.scroll || this.listeners.some((l) => l.target === n && l.on.includes("scroll")))
+    );
+  }
+  get cursor() {
+    const over = new Set([...this.contacts.values()].flatMap((c) => [...c.over]));
+    for (const n of [...over].sort(this.foremost)) {
+      const value = n >= 0 && this.player.model.nodes[n].raw.cursor;
+      if (value) return value;
+    }
+    return void 0;
+  }
+  dispatch(on, targets, data, filter = () => true) {
+    if (!this.enabled) return false;
+    return this.deliver(on, targets, data, filter).handled;
+  }
+  deliver(on, targets, data, filter = () => true) {
+    if (!this.enabled) return { handled: false, consumed: false };
+    const ls = this.listeners.filter(
+      (l) => l.on.includes(on) && targets.has(l.target) && (on.startsWith("key-") || on.startsWith("gamepad-") ? l.target < 0 || this.player.visible(l.target) : this.eligible(l.target)) && filter(l)
+    );
+    const pointer = this.player.paintRank && !/^(key|gamepad)-/.test(on);
+    ls.sort(
+      (a, b) => Number(!!b.capture) - Number(!!a.capture) || (a.capture ? a.depth - b.depth : b.depth - a.depth) || (pointer && !a.capture ? this.foremost(a.target, b.target) : 0) || a.order - b.order
+    );
+    let claimed = false;
+    for (const l of ls) {
+      this.player.act(l.action);
+      const values = { ...data };
+      if (l.align && data.x !== void 0 && data.y !== void 0 && l.target >= 0) {
+        const n = this.player.model.nodes[l.target], inv = n.parent < 0 ? void 0 : invert(drawWorld(this.player, n.parent));
+        const [x, y] = n.parent < 0 ? [Number(data.x), Number(data.y)] : inv ? apply(inv, Number(data.x), Number(data.y)) : [NaN, NaN];
+        if (!Number.isFinite(x + y)) continue;
+        const contact = this.contacts.get(Number(data.pointerId));
+        const origin = contact?.origins.get(l.target);
+        values.x = x + (l.align === "preserve" ? origin?.[0] ?? 0 : 0);
+        values.y = y + (l.align === "preserve" ? origin?.[1] ?? 0 : 0);
+      }
+      if (l.write?.["text-index"] && data.x !== void 0 && data.y !== void 0 && l.target >= 0) {
+        const inv = invert(drawWorld(this.player, l.target));
+        const text = peers?.get("text");
+        if (inv && text?.hitTest) {
+          const [x, y] = apply(inv, Number(data.x), Number(data.y));
+          values["text-index"] = text.hitTest(this.player, l.target, x, y);
+        }
+      }
+      for (const [field, name] of Object.entries(l.write ?? {})) {
+        const value = values[field];
+        if (value !== void 0) this.player.set(name, value);
+      }
+      claimed = true;
+      if (l.consume || on.startsWith("key-") && !l.capture && !l.propagate)
+        return { handled: true, consumed: true };
+    }
+    return { handled: claimed, consumed: false };
+  }
+  children() {
+    const p = this.player;
+    const nested = p.nested?.players;
+    const children = [...nested ?? []].map(([id, player]) => ({
+      id,
+      player,
+      node: p.model.ids.get(id),
+      matrix: drawWorld(p, p.model.ids.get(id))
+    }));
+    const lists = peers?.get("lists");
+    for (const run of lists?.listState(p)?.runs ?? []) {
+      const raw = p.model.nodes[run.spec.node].raw;
+      for (const item of run.items)
+        children.push({
+          id: p.model.nodes[run.spec.node].id + "." + item.index,
+          player: item.player,
+          node: run.spec.node,
+          matrix: mul(drawWorld(p, run.spec.node), [
+            1,
+            0,
+            0,
+            1,
+            (raw.dx ?? 0) * item.index,
+            (raw.dy ?? 0) * item.index
+          ])
+        });
+    }
+    return children;
+  }
+  route(kind, x, y, opts) {
+    const children = this.children();
+    if (!children.length) {
+      if ((opts.id ?? 0) === 0 && (opts.button ?? 0) === 0)
+        this.player.nested?.pointer(kind === "cancel" ? "leave" : kind, x, y);
+      return false;
+    }
+    let claimed = false;
+    const front = this.targets(x, y);
+    const blockers = [...front].filter((n) => n >= 0 && this.player.model.nodes[n].raw.opaque);
+    for (const { node, player: child, matrix } of children) {
+      const inv = invert(matrix);
+      const valid = inv && this.eligible(node) && !blockers.some((n) => this.rank(n) > this.rank(node) && !this.ancestor(n, node));
+      const [lx, ly] = inv ? apply(inv, x, y) : [0, 0];
+      if (configurations.has(child.model.inputs))
+        claimed = child.input().pointer(valid ? kind : "cancel", lx, ly, opts) || claimed;
+      else if ((opts.id ?? 0) === 0 && (opts.button ?? 0) === 0)
+        child.pointer(valid && kind !== "cancel" ? kind : "leave", lx, ly);
+    }
+    return claimed;
+  }
+  pointer(kind, x = 0, y = 0, opts = {}) {
+    finite(x, y);
+    const id = opts.id ?? 0, button = opts.button ?? 0;
+    if (!Number.isInteger(id) || id < 0 || ![0, 1, 2].includes(button))
+      throw Error("anima: invalid pointer id or button");
+    if (!this.enabled || this.disabled.has(id)) return false;
+    let c = this.contacts.get(id);
+    if (kind === "cancel" || kind === "leave") {
+      if (!c) return false;
+      const data2 = {
+        x: c.x,
+        y: c.y,
+        "pointer-x": c.x,
+        "pointer-y": c.y,
+        "pointer-delta-x": 0,
+        "pointer-delta-y": 0,
+        pointerId: id,
+        button: c.button,
+        dx: c.x - c.startX,
+        dy: c.y - c.startY
+      };
+      let claimed2 = false;
+      if (kind === "cancel") {
+        claimed2 = this.dispatch("cancel", c.pressed, data2);
+        if (c.drag)
+          claimed2 = this.dispatch("drag-end", c.pressed, { ...data2, pressed: false }) || claimed2;
+      }
+      claimed2 = this.dispatch("leave", c.over, data2) || claimed2;
+      this.contacts.delete(id);
+      return this.route(kind, c.x, c.y, opts) || claimed2;
+    }
+    if (!c) {
+      c = {
+        x,
+        y,
+        startX: x,
+        startY: y,
+        button,
+        over: /* @__PURE__ */ new Set(),
+        pressed: /* @__PURE__ */ new Set(),
+        drag: false,
+        moved: 0,
+        origins: /* @__PURE__ */ new Map()
+      };
+      this.contacts.set(id, c);
+    }
+    const now = this.targets(x, y), data = {
+      x,
+      y,
+      "pointer-x": x,
+      "pointer-y": y,
+      "pointer-delta-x": x - c.x,
+      "pointer-delta-y": y - c.y,
+      dx: x - c.startX,
+      dy: y - c.startY,
+      startX: c.startX,
+      startY: c.startY,
+      pointerId: id,
+      button: kind === "move" ? c.button : button
+    };
+    const diff = (a, b) => new Set([...a].filter((x2) => !b.has(x2)));
+    const match = (l) => (l.button ?? 0) === data.button;
+    let claimed = this.dispatch("leave", diff(c.over, now), data);
+    claimed = this.dispatch("enter", diff(now, c.over), data) || claimed;
+    if (kind === "down") {
+      this.player.focusPointer?.(
+        x,
+        y,
+        (node) => this.eligible(node) && ![...now].some(
+          (n) => this.rank(n) > this.rank(node) && this.player.model.nodes[n].raw.opaque && !this.ancestor(n, node)
+        )
+      );
+      c.startX = x;
+      c.startY = y;
+      c.button = button;
+      c.pressed = now;
+      c.drag = false;
+      c.moved = 0;
+      c.origins.clear();
+      Object.assign(data, { dx: 0, dy: 0, startX: x, startY: y });
+      for (const n of now)
+        if (n >= 0) {
+          const parent = this.player.model.nodes[n].parent, inv = parent < 0 ? void 0 : invert(drawWorld(this.player, parent));
+          const pt = parent < 0 ? [x, y] : inv ? apply(inv, x, y) : [x, y];
+          c.origins.set(n, [
+            this.player.num(n, "x", 0) - pt[0],
+            this.player.num(n, "y", 0) - pt[1]
+          ]);
+        }
+    }
+    c.moved = Math.max(c.moved, Math.hypot(x - c.startX, y - c.startY));
+    if (kind === "move" && c.pressed.size && (c.drag || c.moved >= 0.5)) {
+      if (!c.drag) {
+        c.drag = true;
+        claimed = this.dispatch("drag-start", c.pressed, data, match) || claimed;
+      }
+      claimed = this.dispatch("drag", c.pressed, data, match) || claimed;
+    }
+    claimed = this.dispatch(kind, now, data, match) || claimed;
+    if (kind === "up" && button === c.button) {
+      if (c.drag)
+        claimed = this.dispatch("drag-end", c.pressed, { ...data, pressed: false }, match) || claimed;
+      else if (c.moved < 0.5)
+        claimed = this.dispatch("click", new Set([...now].filter((n) => c.pressed.has(n))), data, match) || claimed;
+      c.pressed = /* @__PURE__ */ new Set();
+      c.drag = false;
+    }
+    c.over = now;
+    c.x = x;
+    c.y = y;
+    return this.route(kind, x, y, opts) || claimed;
+  }
+  enablePointer(id, enabled) {
+    if (!Number.isInteger(id) || id < 0) throw Error("anima: invalid pointer id");
+    if (enabled) this.disabled.delete(id);
+    else {
+      this.pointer("cancel", 0, 0, { id });
+      this.disabled.add(id);
+    }
+  }
+  cancel() {
+    for (const id of this.contacts.keys()) this.pointer("cancel", 0, 0, { id });
+    this.cancelScroll();
+  }
+  key(kind, key, opts = {}) {
+    if (!this.enabled) return false;
+    const handled = this.dispatchKey(kind, key, opts);
+    const moved = !opts.control && !opts.alt && !opts.meta && this.player.focusKey?.(key, kind === "down", opts.shift);
+    return !!moved || handled.handled;
+  }
+  dispatchKey(kind, key, opts) {
+    const p = this.player, name = opts.target ?? this.keyTarget ?? p.focused ?? void 0;
+    const nested = name && this.children().find((c) => name.startsWith(c.id + "."));
+    const dot = nested ? nested.id.length : -1;
+    const target = nested ? nested.node : name === void 0 ? -1 : p.model.ids.get(name);
+    if (target === void 0) throw Error("anima: unknown key target");
+    const targets = /* @__PURE__ */ new Set([-1]);
+    for (let n = target; n >= 0; n = p.model.nodes[n].parent) targets.add(n);
+    const modifiers = ["shift", "control", "alt", "meta"].filter((k) => opts[k]).join("+");
+    const on = "key-" + (kind === "down" && opts.repeat ? "repeat" : kind), data = { pressed: kind === "down", "key-pressed": key };
+    const match = (l) => (!l.key || l.key === "*" || l.key === key) && (l.modifiers === void 0 || l.modifiers === modifiers);
+    const capture = this.deliver(on, targets, data, (l) => !!l.capture && match(l));
+    if (capture.consumed) return capture;
+    let childResult = { handled: false, consumed: false };
+    if (dot >= 0 && p.visible(target)) {
+      const child = nested && nested.player;
+      if (!child) throw Error("anima: unknown key target");
+      if (configurations.has(child.model.inputs))
+        childResult = child.input().dispatchKey(kind, key, { ...opts, target: name.slice(dot + 1) });
+      if (childResult.consumed) return { handled: true, consumed: true };
+    }
+    const bubble = this.deliver(on, targets, data, (l) => !l.capture && match(l));
+    return {
+      handled: capture.handled || childResult.handled || bubble.handled,
+      consumed: bubble.consumed
+    };
+  }
+  scroll(x, y, deltaX, deltaY, opts = {}) {
+    finite(x, y, deltaX, deltaY);
+    const time = opts.time ?? this.player.time;
+    finite(time);
+    if (!this.enabled) return false;
+    if (opts.phase === "cancel") {
+      this.cancelScroll();
+      return false;
+    }
+    if (this.latch && (time < this.latch.time || time - this.latch.time > 0.15 || opts.phase === "start"))
+      this.cancelScroll();
+    const targets = this.latch?.targets ?? this.targets(x, y, { scroll: true });
+    const claimed = this.dispatch("scroll", targets, {
+      x,
+      y,
+      deltaX,
+      deltaY,
+      dx: deltaX,
+      dy: deltaY
+    });
+    if (claimed) this.latch = { targets, time };
+    if (opts.phase === "end") this.cancelScroll();
+    return claimed;
+  }
+  wantsScroll(x, y, time = this.player.time) {
+    finite(time);
+    if (this.latch && (time < this.latch.time || time - this.latch.time > 0.15))
+      this.cancelScroll();
+    return this.enabled && (this.latch !== void 0 || this.targets(x, y, { scroll: true }).size > 0);
+  }
+  cancelScroll() {
+    this.latch = void 0;
+  }
+  gamepads(batch) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const r of batch) {
+      if (!Number.isInteger(r.index) || r.index < 0 || seen.has(r.index) || typeof r.connected !== "boolean" || r.axes?.some((x) => !Number.isFinite(x) || Math.abs(x) > 1) || r.buttons?.some(
+        (b) => !Number.isFinite(b.value) || b.value < 0 || b.value > 1 || typeof b.pressed !== "boolean"
+      ))
+        throw Error("anima: invalid gamepad batch");
+      seen.add(r.index);
+    }
+    if (!this.enabled) return;
+    const targets = new Set(this.listeners.map((l) => l.target));
+    for (const r of batch) {
+      const prev = this.pads.get(r.index), match = (l) => (l.index === void 0 || l.index === r.index) && (!l.mapping || l.mapping === "raw" || r.mapping === "standard");
+      if (r.connected && !prev)
+        this.dispatch("gamepad-connected", targets, { index: r.index }, match);
+      if (!r.connected && prev)
+        this.dispatch("gamepad-disconnected", targets, { index: r.index }, match);
+      if (r.connected) {
+        r.axes?.forEach((value, control) => {
+          if (value !== (prev?.axes?.[control] ?? 0))
+            this.dispatch(
+              "gamepad-axis",
+              targets,
+              { index: r.index, control, value },
+              (l) => match(l) && (l.control === void 0 || l.control === control)
+            );
+        });
+        r.buttons?.forEach((b, control) => {
+          const old = prev?.buttons?.[control] ?? { value: 0, pressed: false };
+          if (b.value !== old.value || b.pressed !== old.pressed)
+            this.dispatch(
+              "gamepad-button",
+              targets,
+              { index: r.index, control, ...b },
+              (l) => match(l) && (l.control === void 0 || l.control === control) && (!l.phase || l.phase === "both" || (l.phase === "press" ? b.pressed && !old.pressed : !b.pressed && old.pressed))
+            );
+        });
+        this.pads.set(r.index, {
+          ...r,
+          axes: r.axes?.slice(),
+          buttons: r.buttons?.map((b) => ({ ...b }))
+        });
+      } else this.pads.delete(r.index);
+    }
+  }
+}
+function install(Class, modules) {
+  peers = modules;
+  if (installed.has(Class)) return;
+  installed.add(Class);
+  const pointer = Class.prototype.pointer, visible = Class.prototype.visible, hits = Class.prototype.hits;
+  Object.defineProperty(Class.prototype, "input", {
+    configurable: true,
+    value: function() {
+      if (!configurations.has(this.model.inputs)) throw Error("anima: document requires input");
+      let c = controllers.get(this);
+      if (!c) controllers.set(this, c = new InputController(this));
+      return c;
+    }
+  });
+  Class.prototype.pointer = function(kind, x = 0, y = 0) {
+    if (configurations.has(this.model.inputs)) this.input().pointer(kind, x, y);
+    else pointer.call(this, kind, x, y);
+  };
+  Class.prototype.hits = function(listener, x, y) {
+    if (configurations.has(this.model.inputs) && listener.target >= 0) {
+      if (!this.visible(listener.target)) return false;
+      const node = this.model.nodes[listener.target];
+      if (node.type === "group")
+        return node.children.some(
+          (target) => this.prop(target, "pointerEnabled") !== false && this.hits({ ...listener, target }, x, y)
+        );
+    }
+    return hits.call(this, listener, x, y);
+  };
+  Class.prototype.visible = function(node) {
+    if (configurations.has(this.model.inputs))
+      for (let n = node; n >= 0; n = this.model.nodes[n].parent) {
+        if (this.prop(n, "collapsed") === true) return false;
+        const parent = this.model.nodes[n].parent;
+        if (parent >= 0 && this.model.nodes[parent].raw.solo !== void 0) {
+          const solo = this.num(parent, "solo", -1);
+          if (this.model.nodes[parent].children[solo] !== n) return false;
+        }
+      }
+    return visible.call(this, node);
+  };
+}
+export {
+  InputController,
+  configurations,
+  install
+};

package/modules/input/core/svg.d.ts

@@ -0,0 +1,2 @@
+import type { SVGBackend } from '../../../packages/core/src/svg.js';
+export declare const inputSVG: SVGBackend;

package/modules/input/core/svg.js

@@ -0,0 +1,4 @@
+const inputSVG = {};
+export {
+  inputSVG
+};

package/modules/input/core/types.d.ts

@@ -0,0 +1,53 @@
+import type { ListenerM } from '../../../packages/core/src/load.js';
+export declare const events: readonly ["enter", "leave", "move", "down", "up", "click", "cancel", "drag-start", "drag", "drag-end", "key-down", "key-repeat", "key-up", "scroll", "gamepad-axis", "gamepad-button", "gamepad-connected", "gamepad-disconnected"];
+export type InputEvent = (typeof events)[number];
+export type PointerEventKind = 'move' | 'down' | 'up' | 'leave' | 'cancel';
+export interface PointerOptions {
+    id?: number;
+    button?: number;
+}
+export interface KeyOptions {
+    repeat?: boolean;
+    shift?: boolean;
+    control?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+    target?: string;
+}
+export interface ScrollOptions {
+    phase?: 'start' | 'move' | 'end' | 'cancel';
+    time?: number;
+}
+export interface GamepadRecord {
+    index: number;
+    connected: boolean;
+    mapping?: string;
+    axes?: number[];
+    buttons?: {
+        value: number;
+        pressed: boolean;
+    }[];
+}
+export interface InputListener {
+    action: ListenerM;
+    on: string[];
+    target: number;
+    order: number;
+    depth: number;
+    button?: number;
+    capture?: boolean;
+    consume?: boolean;
+    propagate?: boolean;
+    key?: string;
+    modifiers?: string;
+    index?: number;
+    control?: number;
+    mapping?: 'standard' | 'raw';
+    phase?: 'press' | 'release' | 'both';
+    write?: Record<string, string>;
+    align?: 'preserve' | 'snap';
+}
+export declare const cursors: readonly ["arrow", "hidden", "pointer", "resize-horizontal", "resize-vertical", "text"];
+export type Cursor = (typeof cursors)[number];
+export declare const fields: readonly ["x", "y", "dx", "dy", "startX", "startY", "pointerId", "button", "value", "pressed", "index", "control", "deltaX", "deltaY", "text-index", "pointer-x", "pointer-y", "pointer-delta-x", "pointer-delta-y", "key-pressed"];
+export type Data = Partial<Record<(typeof fields)[number], number | boolean | string>>;

package/modules/input/core/types.js

@@ -0,0 +1,56 @@
+const events = [
+  "enter",
+  "leave",
+  "move",
+  "down",
+  "up",
+  "click",
+  "cancel",
+  "drag-start",
+  "drag",
+  "drag-end",
+  "key-down",
+  "key-repeat",
+  "key-up",
+  "scroll",
+  "gamepad-axis",
+  "gamepad-button",
+  "gamepad-connected",
+  "gamepad-disconnected"
+];
+const cursors = [
+  "arrow",
+  "hidden",
+  "pointer",
+  "resize-horizontal",
+  "resize-vertical",
+  "text"
+];
+const fields = [
+  "x",
+  "y",
+  "dx",
+  "dy",
+  "startX",
+  "startY",
+  "pointerId",
+  "button",
+  "value",
+  "pressed",
+  "index",
+  "control",
+  "deltaX",
+  "deltaY",
+  "text-index",
+  // seam(P6-7): grapheme hit position from the optional text-hit adapter.
+  "pointer-x",
+  "pointer-y",
+  "pointer-delta-x",
+  "pointer-delta-y",
+  "key-pressed"
+];
+export {
+  cursors,
+  events,
+  fields
+};

package/modules/input/core/values.d.ts

@@ -0,0 +1,7 @@
+import type { Player } from '../../../packages/core/src/player.js';
+export declare function listenerValue(p: Player, r: {
+    value: string;
+    index?: number;
+    control?: number;
+    on: string;
+}): number | boolean;

package/modules/input/core/values.js

@@ -0,0 +1,9 @@
+function listenerValue(p, r) {
+  const m = /^gamepad-(axis|button-pressed|button-value|changed-value)(?::(\d+))?$/.exec(r.value);
+  const pad = p.input().pads.get(r.index ?? 0), index = Number(m?.[2] ?? r.control ?? 0);
+  if (m?.[1] === "button-pressed") return pad?.buttons?.[index]?.pressed ?? false;
+  return m?.[1] === "axis" || m?.[1] === "changed-value" && r.on === "gamepad-axis" ? pad?.axes?.[index] ?? 0 : pad?.buttons?.[index]?.value ?? 0;
+}
+export {
+  listenerValue
+};

package/modules/input/manifest.d.ts

@@ -0,0 +1,31 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/input/index.ts': string;
+        'packages/core/src/modules/input/svg.ts': string;
+        'packages/markup/src/input.ts': string;
+        'packages/web/src/input.ts': string;
+    };
+    exports: {
+        'core:./input': string;
+        'markup:./input': string;
+        'web:./input': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;