@fabi-play/sdk 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,490 @@
+import {
+  BodyInterpolator,
+  NS,
+  PROTOCOL_VERSION,
+  __publicField,
+  defaultAvatarFor,
+  drawAvatar,
+  isAvatarId,
+  parseDeviceHint,
+  parseGameStats,
+  parseView,
+  smoothBody,
+  toScreen,
+  wire
+} from "./chunks/chunk-QJPCNRFI.js";
+
+// src/adapters.ts
+function muteDuringBreaks(play, win = window) {
+  const contexts = /* @__PURE__ */ new Set();
+  const Original = win.AudioContext;
+  if (Original) {
+    win.AudioContext = class extends Original {
+      constructor(...args) {
+        super(...args);
+        contexts.add(this);
+      }
+    };
+  }
+  let paused = [];
+  let suspended = [];
+  void Promise.resolve(play).then((p) => {
+    p.on("break-start", () => {
+      paused = [...win.document.querySelectorAll("audio, video")].filter((m) => !m.paused);
+      paused.forEach((m) => m.pause());
+      suspended = [...contexts].filter((c) => c.state === "running");
+      suspended.forEach((c) => void c.suspend());
+    });
+    p.on("break-done", () => {
+      paused.forEach((m) => void m.play().catch(() => void 0));
+      suspended.forEach((c) => void c.resume());
+      paused = [];
+      suspended = [];
+    });
+  });
+}
+var DEFAULT_KEYS = { jump: "Space", squat: "ArrowDown", left: "ArrowLeft", right: "ArrowRight", clap: "Enter" };
+function parseKeys(value) {
+  if (value.trim() === "default") return void 0;
+  const map = {};
+  for (const pair of value.split(",")) {
+    const [action, code] = pair.split(":").map((s) => s.trim());
+    if (action && code) map[action] = code;
+  }
+  return map;
+}
+var NAMED = {
+  Space: [" ", 32],
+  Enter: ["Enter", 13],
+  Escape: ["Escape", 27],
+  ShiftLeft: ["Shift", 16],
+  ArrowLeft: ["ArrowLeft", 37],
+  ArrowUp: ["ArrowUp", 38],
+  ArrowRight: ["ArrowRight", 39],
+  ArrowDown: ["ArrowDown", 40]
+};
+function keyInfo(code) {
+  const named = NAMED[code];
+  if (named) return { key: named[0], code, keyCode: named[1] };
+  const letter = /^Key([A-Z])$/.exec(code);
+  if (letter) return { key: letter[1].toLowerCase(), code, keyCode: letter[1].charCodeAt(0) };
+  const digit = /^Digit([0-9])$/.exec(code);
+  if (digit) return { key: digit[1], code, keyCode: 48 + Number(digit[1]) };
+  throw new Error(`Fabi Play: unknown key "${code}" (use Space, Enter, Arrow\u2026, KeyA\u2026, Digit0\u2026)`);
+}
+var domKeys = (doc = document) => ({
+  dispatch(type, k) {
+    const e = new KeyboardEvent(type, { key: k.key, code: k.code, bubbles: true, cancelable: true });
+    for (const name of ["keyCode", "which"]) Object.defineProperty(e, name, { get: () => k.keyCode });
+    (doc.activeElement ?? doc.body ?? doc).dispatchEvent(e);
+  }
+});
+var TAP_MS = 80;
+var MAX_HOLD_MS = 800;
+function keyboard(play, map = DEFAULT_KEYS, options = {}) {
+  const player = options.player ?? 1;
+  const target = options.target ?? domKeys();
+  const later = options.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
+  const held = /* @__PURE__ */ new Set();
+  let lane = 0;
+  const down = (a) => {
+    const code = map[a];
+    if (!code || held.has(a)) return;
+    held.add(a);
+    target.dispatch("keydown", keyInfo(code));
+  };
+  const up = (a) => {
+    const code = map[a];
+    if (!code || !held.has(a)) return;
+    held.delete(a);
+    target.dispatch("keyup", keyInfo(code));
+  };
+  const tap = (a) => {
+    down(a);
+    later(() => up(a), TAP_MS);
+  };
+  const onGesture = (g) => {
+    if (g.player !== player) return;
+    const lanes = { "lane-left": -1, "lane-center": 0, "lane-right": 1 };
+    switch (g.gesture) {
+      case "jump":
+        down("jump");
+        later(() => up("jump"), MAX_HOLD_MS);
+        break;
+      case "land":
+        up("jump");
+        break;
+      case "squat":
+        down("squat");
+        break;
+      case "stand":
+        up("squat");
+        break;
+      case "clap":
+        tap("clap");
+        break;
+      default: {
+        const next = lanes[g.gesture];
+        if (next === void 0) break;
+        const dir = next > lane ? "right" : "left";
+        for (let i = 0; i < Math.abs(next - lane); i++) later(() => tap(dir), i * (TAP_MS * 2));
+        lane = next;
+      }
+    }
+  };
+  const onFrame = (f) => {
+    const p = f.players.find((x) => x.id === player);
+    if (!p) return;
+    if (p.shape === "arms-up") down("arms-up");
+    else up("arms-up");
+  };
+  const offs = [play.on("gesture", onGesture), play.on("frame", onFrame), play.on("break-start", () => [...held].forEach(up))];
+  return () => {
+    offs.forEach((off) => off());
+    [...held].forEach(up);
+  };
+}
+function domPointer(doc = document) {
+  const ring = doc.createElement("div");
+  ring.setAttribute("aria-hidden", "true");
+  ring.style.cssText = "position:fixed;left:0;top:0;width:56px;height:56px;margin:-28px 0 0 -28px;border-radius:50%;border:6px solid #FBE7B8;background:rgba(251,231,184,.25);pointer-events:none;z-index:2147483647;box-sizing:border-box;transition:transform 60ms linear";
+  doc.body.appendChild(ring);
+  const fire = (x, y, ...types) => {
+    const el = doc.elementFromPoint(x, y) ?? doc.body;
+    for (const type of types) {
+      const init = { bubbles: true, cancelable: true, clientX: x, clientY: y, pointerId: 1, pointerType: "touch", isPrimary: true };
+      el.dispatchEvent(type.startsWith("pointer") ? new PointerEvent(type, init) : new MouseEvent(type, init));
+    }
+  };
+  return {
+    size: () => ({ width: doc.documentElement.clientWidth, height: doc.documentElement.clientHeight }),
+    move: (x, y) => fire(x, y, "pointermove", "mousemove"),
+    click: (x, y) => fire(x, y, "pointerdown", "mousedown", "pointerup", "mouseup", "click"),
+    cursor: (x, y, progress) => {
+      ring.style.transform = `translate(${x}px, ${y}px) scale(${1 - progress * 0.35})`;
+      ring.style.borderColor = progress > 0 ? "#EE6A43" : "#FBE7B8";
+    }
+  };
+}
+function pointer(play, options = {}) {
+  const player = options.player ?? 1;
+  const hand = options.hand ?? "any";
+  const dwell = options.dwellMs ?? 800;
+  const radius = options.radius ?? 0.04;
+  const target = options.target ?? domPointer();
+  let anchor = null;
+  let clicked = false;
+  return play.on("frame", (f) => {
+    const p = f.players.find((x2) => x2.id === player);
+    if (!p) return;
+    const pick = (a, b) => a && b ? a.y < b.y ? a : b : a ?? b;
+    const h = hand === "left" ? p.leftHand : hand === "right" ? p.rightHand : pick(p.leftHand, p.rightHand);
+    if (!h) return;
+    const { width, height } = target.size();
+    const x = h.x * width;
+    const y = h.y * height;
+    target.move(x, y);
+    const far = anchor ? Math.hypot(x - anchor.x, y - anchor.y) > radius * Math.hypot(width, height) : true;
+    if (far) {
+      anchor = { x, y, t: f.t };
+      clicked = false;
+    }
+    const progress = clicked ? 0 : Math.min((f.t - anchor.t) / dwell, 1);
+    if (progress >= 1) {
+      clicked = true;
+      target.click(anchor.x, anchor.y);
+    }
+    target.cursor(x, y, clicked ? 0 : progress);
+  });
+}
+
+// src/avatars.ts
+var frameTime = () => {
+  const t = typeof document !== "undefined" ? document.timeline?.currentTime : null;
+  return typeof t === "number" && Number.isFinite(t) ? t : globalThis.performance?.now() ?? Date.now();
+};
+var clockNow = () => globalThis.performance?.now() ?? Date.now();
+var AvatarBook = class {
+  /** now: this frame's time (tests). */
+  constructor(now = frameTime) {
+    __publicField(this, "now", now);
+    __publicField(this, "known", /* @__PURE__ */ new Map());
+    __publicField(this, "smoothed", /* @__PURE__ */ new Map());
+    /** When each body of the host's frames was taken (the frame's t) and arrived. */
+    __publicField(this, "times", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "lerp", new BodyInterpolator());
+    /** Animation frames something was drawn in, for stats. */
+    __publicField(this, "drawnAt", NaN);
+    __publicField(this, "drawn", 0);
+    /**
+     * A player's smoothed body (see Play.smoothedBody): a frame's body smoothed for its player and interpolated for
+     * this animation frame, or a player id's (null if none yet).
+     */
+    __publicField(this, "smoothedBody", (who, options = {}) => {
+      const interpolate = options.interpolate !== false;
+      if (typeof who === "number") {
+        const last = this.smoothed.get(who);
+        if (!last) return null;
+        return interpolate ? this.lerp.at(who, this.tick()) ?? last.body : last.body;
+      }
+      if (typeof who !== "object" || who === null || !Array.isArray(who.body)) return null;
+      return this.posed(who.id, who.body, smoothAmount(options.smooth), interpolate);
+    });
+  }
+  /** Every frame from the host: the latest avatar of each player, and when their bodies were taken (t). */
+  note(players, t, arrival = clockNow()) {
+    for (const p of players) {
+      this.known.set(p.id, this.resolve(p.id, p.avatar));
+      if (t !== void 0 && Number.isFinite(t) && Array.isArray(p.body)) this.times.set(p.body, { t, arrival });
+    }
+  }
+  /**
+   * The avatar id of a player (an id, 1-based, or a frame): the one the child picked, or the default of the slot
+   * (fox, lion, dragon, unicorn: the 6–8 band's, as no age is known here) before the first frame, from an older host, or for an id this SDK doesn't know.
+   */
+  of(player) {
+    if (typeof player === "object" && player !== null) return player.avatar !== void 0 ? this.resolve(player.id, player.avatar) : this.of(player.id);
+    return this.known.get(player) ?? defaultAvatarFor(player - 1);
+  }
+  /**
+   * The body to draw for this player now: body smoothed (amount below 1) against the player's previous one, then,
+   * with interpolate, at this animation frame's time between the last two.
+   */
+  posed(player, body, amount, interpolate = true) {
+    const sample = this.smooth(player, body, amount);
+    return interpolate ? this.lerp.at(player, this.tick()) ?? sample : sample;
+  }
+  /** body smoothed against this player's previous one; the same body twice in a row is smoothed once. */
+  smooth(player, body, amount) {
+    const last = this.smoothed.get(player);
+    if (last && last.raw === body && last.amount === amount) return last.body;
+    if (last && last.amount !== amount) this.lerp.forget(player);
+    const next = amount < 1 ? smoothBody(last?.body, body, amount) : body;
+    this.smoothed.set(player, { raw: body, body: next, amount });
+    const at = this.times.get(body);
+    const arrival = at?.arrival ?? clockNow();
+    this.lerp.push(player, at?.t ?? arrival, next, arrival);
+    return next;
+  }
+  /**
+   * Animation frames the avatars were drawn in, since the last call; for stats. Frames are
+   * told apart by their time, so any number of avatars or calls in one frame count once.
+   */
+  takeDrawn() {
+    const n = this.drawn;
+    this.drawn = 0;
+    return n;
+  }
+  tick() {
+    const t = this.now();
+    if (t !== this.drawnAt) {
+      this.drawnAt = t;
+      this.drawn++;
+    }
+    return t;
+  }
+  resolve(id, avatar) {
+    return isAvatarId(avatar) ? avatar : defaultAvatarFor(id - 1);
+  }
+};
+function defaultBox(ctx, view) {
+  const t = typeof ctx.getTransform === "function" ? ctx.getTransform() : null;
+  const sx = t ? Math.hypot(t.a, t.b) || 1 : 1;
+  const sy = t ? Math.hypot(t.c, t.d) || 1 : 1;
+  const w = (ctx.canvas?.width ?? 0) / sx;
+  const h = (ctx.canvas?.height ?? 0) / sy;
+  return view ? { x: view.x * w, y: view.y * h, w: view.w * w, h: view.h * h } : { x: 0, y: 0, w, h };
+}
+var smoothAmount = (smooth) => smooth === false ? 1 : typeof smooth === "number" ? Math.min(Math.max(smooth, 0.05), 1) : 0.5;
+function avatarDrawer(book, scene) {
+  return (ctx, who, player, box, options = {}) => {
+    const frame = Array.isArray(who) ? null : who;
+    const body = frame ? frame.body : who;
+    if (!Array.isArray(body)) return null;
+    const avatar = typeof player === "string" ? player : book.of(typeof player === "number" ? player : frame ?? 1);
+    const id = typeof player === "number" ? player : frame?.id;
+    const posed = id !== void 0 ? book.posed(id, body, smoothAmount(options.smooth), options.interpolate !== false) : body;
+    return drawAvatar(ctx, posed, avatar, box ?? defaultBox(ctx, scene().view), options.alpha !== void 0 ? { alpha: options.alpha } : {}) ? posed : null;
+  };
+}
+
+// src/easy.ts
+function easy(connecting) {
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, data) => listeners.get(event)?.forEach((l) => l(data));
+  let play = null;
+  const queue = [];
+  const withPlay = (fn) => play ? fn(play) : queue.push(fn);
+  const early = new AvatarBook();
+  const drawEarly = avatarDrawer(early, () => ({ view: null }));
+  void connecting.then((p) => {
+    play = p;
+    const shapes = /* @__PURE__ */ new Map();
+    p.on("gesture", (g) => emit(g.gesture, { player: g.player }));
+    p.on("pause", (m) => emit("pause", { reason: m.reason === "distance" ? "distance" : "user" }));
+    p.on("resume", () => emit("resume", {}));
+    p.on("break-start", () => emit("break-start", {}));
+    p.on("break-done", (m) => emit("break-end", { shown: m.shown }));
+    p.onBackdrop((backdrop, view) => emit("backdrop", { backdrop, view }));
+    p.on("frame", (f) => {
+      emit("players", { players: f.players });
+      for (const pl of f.players) {
+        emit("hands", { player: pl.id, left: pl.leftHand, right: pl.rightHand });
+        if (shapes.get(pl.id) !== pl.shape) {
+          shapes.set(pl.id, pl.shape);
+          emit("shape", { player: pl.id, shape: pl.shape });
+        }
+      }
+    });
+    emit("start", startInfo(p));
+    queue.splice(0).forEach((fn) => fn(p));
+  });
+  return {
+    on(event, listener) {
+      const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+      set.add(listener);
+      if (event === "start" && play) listener(startInfo(play));
+      return () => void set.delete(listener);
+    },
+    ready: () => withPlay((p) => p.ready()),
+    score: (score, player = 1) => withPlay((p) => p.score(player, score)),
+    break: (reason) => new Promise((resolve) => withPlay((p) => void p.break(reason).then(resolve))),
+    end: (score) => withPlay(
+      (p) => p.end(typeof score === "number" ? [{ player: 1, score, stars: 2 }] : score.map((s) => ({ player: s.player, score: s.score, stars: s.stars ?? 2 })))
+    ),
+    keys: (map, options) => withPlay((p) => void keyboard(p, map, options)),
+    pointer: (options) => withPlay((p) => void pointer(p, options)),
+    get view() {
+      return play?.view ?? null;
+    },
+    get device() {
+      return play?.device ?? null;
+    },
+    reportStats: (s) => play?.reportStats(s),
+    toScreen: (p) => play ? play.toScreen(p) : toScreen(null, p),
+    avatarOf: (player) => play ? play.avatarOf(player) : early.of(player),
+    drawAvatar: (...args) => play ? play.drawAvatar(...args) : drawEarly(...args),
+    smoothedBody: (...args) => play ? play.smoothedBody(...args) : early.smoothedBody(...args)
+  };
+}
+var startInfo = (p) => ({ ageRange: p.ageRange, players: p.players, locale: p.locale, mode: p.mode, backdrop: p.backdrop, view: p.view, device: p.device });
+
+// src/index.ts
+var windowChannel = (win = window) => ({
+  post: (m) => win.parent.postMessage(m, "*"),
+  // Only the screen that embeds the game speaks to it.
+  listen: (l) => win.addEventListener("message", (e) => e.source === win.parent && l(e.data))
+});
+var INIT_TIMEOUT_MS = 1e4;
+var STATS_MS = 1e3;
+function connect(channel = windowChannel()) {
+  return new Promise((resolve, reject) => {
+    const listeners = /* @__PURE__ */ new Map();
+    const breaks = [];
+    let started = false;
+    let backdrop = "none";
+    let view = null;
+    const backdropListeners = /* @__PURE__ */ new Set();
+    const avatars = new AvatarBook();
+    const drawAvatar2 = avatarDrawer(avatars, () => ({ view }));
+    const smoothedBody = avatars.smoothedBody;
+    const timer = setTimeout(() => reject(new Error("Fabi Play: no host, is the game opened from Fabi Play?")), INIT_TIMEOUT_MS);
+    channel.listen((data) => {
+      if (typeof data !== "object" || data === null || data.ns !== NS) return;
+      const m = data;
+      if (m.type === "init" && !started) {
+        if (m.v !== PROTOCOL_VERSION) {
+          clearTimeout(timer);
+          return reject(new Error(`Fabi Play: protocol ${m.v}, this SDK speaks ${PROTOCOL_VERSION}`));
+        }
+        started = true;
+        clearTimeout(timer);
+        backdrop = m.backdrop === "video" ? "video" : "none";
+        view = parseView(m.view) ?? null;
+        const device = parseDeviceHint(m.device) ?? null;
+        let reported = {};
+        if (m.stats === true) {
+          let since = performance.now();
+          const stats = setInterval(() => {
+            const now = performance.now();
+            channel.post(wire({ type: "stats", renderFps: Math.round(avatars.takeDrawn() * 1e3 / Math.max(now - since, 1)), ...reported }));
+            since = now;
+          }, STATS_MS);
+          stats.unref?.();
+        }
+        resolve({
+          locale: m.locale,
+          mode: m.mode,
+          players: m.players,
+          muted: m.muted,
+          ageRange: m.ageRange ?? "6-8",
+          get backdrop() {
+            return backdrop;
+          },
+          get view() {
+            return view;
+          },
+          device,
+          reportStats: (s) => {
+            reported = parseGameStats(s);
+          },
+          toScreen: (p) => toScreen(view, p),
+          avatarOf: (player) => avatars.of(player),
+          drawAvatar: drawAvatar2,
+          smoothedBody,
+          onBackdrop(listener) {
+            backdropListeners.add(listener);
+            return () => void backdropListeners.delete(listener);
+          },
+          on(event, listener) {
+            const set = listeners.get(event) ?? /* @__PURE__ */ new Set();
+            listeners.set(event, set);
+            set.add(listener);
+            return () => void set.delete(listener);
+          },
+          ready: () => channel.post(wire({ type: "ready" })),
+          score: (player, score) => channel.post(wire({ type: "score", player, score })),
+          break: (reason = "level") => new Promise((done) => {
+            breaks.push(done);
+            channel.post(wire({ type: "break", reason }));
+          }),
+          end: (scores) => channel.post(wire({ type: "end", scores }))
+        });
+      } else if (!started) return;
+      else {
+        let message = m;
+        if (m.type === "frame" && Array.isArray(m.players)) avatars.note(m.players, m.t);
+        if (m.type === "backdrop") {
+          if (m.backdrop !== "video" && m.backdrop !== "none") return;
+          const next = parseView(m.view) ?? null;
+          if (m.backdrop === backdrop && sameView(next, view)) return;
+          backdrop = m.backdrop;
+          view = next;
+          message = { type: "backdrop", backdrop, ...view ? { view } : {} };
+          for (const l of [...backdropListeners]) l(backdrop, view);
+        }
+        for (const l of listeners.get(m.type) ?? []) l(message);
+        if (m.type === "break-done") breaks.shift()?.(m.shown);
+      }
+    });
+  });
+}
+var sameView = (a, b) => a === b || a !== null && b !== null && a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+export {
+  AvatarBook,
+  DEFAULT_KEYS,
+  avatarDrawer,
+  connect,
+  defaultBox,
+  domKeys,
+  domPointer,
+  easy,
+  keyInfo,
+  keyboard,
+  muteDuringBreaks,
+  parseKeys,
+  pointer,
+  smoothBody,
+  windowChannel
+};

package/dist/integrity.json

@@ -0,0 +1,12 @@
+{
+  "package": "@fabi-play/sdk",
+  "version": "0.1.0",
+  "algorithm": "sha384",
+  "files": {
+    "fabi-play.js": "sha384-vwHpIsx7Fav+S6/jNTY6qYfWT1zq3p2NIq9zD4T56qXw+/ogk6jfdwJIs0/gFNy3",
+    "fabi-play.umd.js": "sha384-YDcTw2S3gcyQYGCn1cRcqui3DaqF1ByJ4cvS4HBP++xY7bSuLmSc6yhRH1RQ0b9G",
+    "fabi-play.umd.min.js": "sha384-Hhlc2ZXMa3NvLOfsHXMTXlWxSMzw8GwJgMHID4I++red4Xmg2a8n3c67alpHgPlD",
+    "fabi-play.d.ts": "sha384-NjFh/5P1gigt+yi1P58WplUgGh2CQUSJd77W+4puFk+r1/hDB7mkXK5tYoRKTYWB",
+    "fabi-play.schema.json": "sha384-tHySTbbJnqrjp7H93Y/NxsyIqU1QUHnMqCbx4N7hOzfUzgvXpDYOpzZLXgWTOHAU"
+  }
+}

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@fabi-play/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "What a game imports: players, movements and the end of the game, from inside its sandboxed frame.",
+  "keywords": [
+    "fabi-play",
+    "sdk",
+    "games",
+    "motion",
+    "kids"
+  ],
+  "homepage": "https://docs.fabiplay.app",
+  "bugs": "https://github.com/fabiplay/fabiplay-kit/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fabiplay/fabiplay-kit.git",
+    "directory": "packages/sdk"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Fabi Play (https://fabiplay.app)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": [
+    "./dist/fabi-play.js",
+    "./dist/fabi-play.umd.js",
+    "./dist/fabi-play.umd.min.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@fabi-play/avatars": "^0.1.0",
+    "@fabi-play/protocol": "^0.1.0",
+    "dts-bundle-generator": "9.5.1",
+    "esbuild": "0.28.2",
+    "tsx": "4.23.15",
+    "typescript": "5.7.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts",
+    "build": "node scripts/build.mjs"
+  },
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./avatars": {
+      "types": "./dist/avatars.d.ts",
+      "import": "./dist/avatars.js",
+      "default": "./dist/avatars.js"
+    },
+    "./fabi-play.js": "./dist/fabi-play.js",
+    "./fabi-play.umd.js": "./dist/fabi-play.umd.js",
+    "./fabi-play.umd.min.js": "./dist/fabi-play.umd.min.js",
+    "./fabi-play.d.ts": "./dist/fabi-play.d.ts",
+    "./fabi-play.schema.json": "./dist/fabi-play.schema.json",
+    "./integrity.json": "./dist/integrity.json",
+    "./package.json": "./package.json"
+  }
 }