1681-engine 0.0.0-stage → 0.5.9

package/dist/ambient/weather.js

@@ -0,0 +1,51 @@
+const u = { kind: "clear", intensity: 0 };
+function l(t) {
+  let i = 2166136261;
+  for (let n = 0; n < t.length; n++)
+    i ^= t.charCodeAt(n), i = Math.imul(i, 16777619);
+  return i ^= i >>> 16, i = Math.imul(i, 2246822507), i ^= i >>> 13, (i >>> 0) / 4294967296;
+}
+const M = /* @__PURE__ */ new WeakMap();
+function y(t, i) {
+  if (!t.skies) return;
+  let n = M.get(t);
+  if (!n) {
+    n = /* @__PURE__ */ new Map();
+    for (const [r, s] of Object.entries(t.skies)) for (const o of s.places) n.set(o, r);
+    M.set(t, n);
+  }
+  return n.get(i);
+}
+function a(t, i, n) {
+  const r = i.reduce((e, k) => e + k.weight, 0);
+  if (r <= 0) return u;
+  let s = l(`${t}:${n}`) * r, o = i[i.length - 1];
+  for (const e of i)
+    if (s -= e.weight, s < 0) {
+      o = e;
+      break;
+    }
+  if (o.kind === "clear") return u;
+  const [f, c] = o.intensity ?? [1, 1];
+  return { kind: o.kind, intensity: f + (c - f) * l(`${t}:${n}:i`) };
+}
+function w(t, i, n) {
+  const r = n.places[t] ?? [];
+  if (!r.length) return u;
+  const s = y(n, t), o = s === void 0 ? t : `sky:${s}`, f = s === void 0 ? r : n.skies[s].entries;
+  if (!f.length) return u;
+  const c = Math.floor(i / n.slotMs);
+  let e = a(o, f, c);
+  if (e.kind === "clear") return e;
+  if (s !== void 0) {
+    const h = r.find((p) => p.kind === e.kind)?.intensity;
+    h && (e = { kind: e.kind, intensity: h[0] + (h[1] - h[0]) * l(`${o}:${c}:i`) });
+  }
+  const k = i - c * n.slotMs, g = n.slotMs - k;
+  let d = 1;
+  return n.fadeMs > 0 && (a(o, f, c - 1).kind !== e.kind && (d = Math.min(d, k / n.fadeMs)), a(o, f, c + 1).kind !== e.kind && (d = Math.min(d, g / n.fadeMs))), { kind: e.kind, intensity: e.intensity * Math.max(0, Math.min(1, d)) };
+}
+export {
+  l as hash01,
+  w as weatherAt
+};

package/dist/anim/AnimStateMachine.js

@@ -0,0 +1,163 @@
+import { Animator as o } from "./Animator.js";
+import { compileParams as m, compileStates as c, compileTransitions as d, PARAM_TRIGGER as h, PARAM_BOOL as p, OP_LE as l, OP_LT as g, OP_GE as f, OP_GT as u, OP_NE as x, OP_EQ as k } from "./animStateCompile.js";
+class v {
+  /** The animator it drives; read `frame` off it (or off the machine). */
+  animator;
+  /** Fired for every marker playback reaches, the state's first frame's on entering it. */
+  onEvent = null;
+  /** Fired after each change of state. */
+  onStateChange = null;
+  params;
+  states;
+  tr;
+  keepTriggers;
+  stateIndex;
+  /** Time played in this state, ms, scaled by speed as the animator scales it. */
+  time = 0;
+  constructor(t, s) {
+    const e = s;
+    this.params = m(s.params ?? {}), this.states = c(e, t, this.params), this.tr = d(e, this.states, this.params), this.keepTriggers = s.keepTriggers === !0, this.stateIndex = this.states.index.get(s.initial), this.animator = new o(t, this.states.clips[this.stateIndex]), this.applySpeed();
+  }
+  /** The state playing. */
+  get state() {
+    return this.states.names[this.stateIndex];
+  }
+  /** The frame to show now (a sheet frame index or name, as the clip lists it). */
+  get frame() {
+    return this.animator.frame;
+  }
+  /** How much of this state's clip has played: 0 at entry, 1 after one pass, 2 after two loops. */
+  get normalizedTime() {
+    return this.time / this.states.lengths[this.stateIndex];
+  }
+  /** Sets a bool or number parameter. */
+  set(t, s) {
+    const e = this.paramIndex(t);
+    if (this.params.kinds[e] === h) throw new Error(`AnimStateMachine: "${t}" is a trigger; use trigger()`);
+    return this.params.values[e] = typeof s == "boolean" ? s ? 1 : 0 : s, this;
+  }
+  /** A parameter's value: bools as booleans, triggers as whether they are set. */
+  get(t) {
+    const s = this.paramIndex(t), e = this.params.values[s];
+    return this.params.kinds[s] === p || this.params.kinds[s] === h ? e !== 0 : e;
+  }
+  /** Fires a trigger: the next update's transitions see it once. */
+  trigger(t) {
+    return this.params.values[this.triggerIndex(t)] = 1, this;
+  }
+  resetTrigger(t) {
+    return this.params.values[this.triggerIndex(t)] = 0, this;
+  }
+  /** Goes to `state` now, whatever the transitions say (a respawn, a cut scene). */
+  play(t) {
+    const s = this.states.index.get(t);
+    if (s === void 0) throw new Error(`AnimStateMachine: no state "${t}"`);
+    return this.enter(s), this;
+  }
+  /** Back to the initial values of every parameter (triggers cleared). */
+  resetParams() {
+    return this.params.values.set(this.params.initial), this;
+  }
+  /**
+   * Advances the clip by `dt` seconds, fires the markers it passed, then takes at most one transition (so a chain of
+   * them never runs through several states in one frame). `update(0)` only checks the transitions.
+   */
+  update(t) {
+    const s = this.stateIndex;
+    this.applySpeed();
+    const e = this.animator, n = e.frameIndex, a = e.finished;
+    if (e.update(t), t > 0 && e.speed > 0) {
+      const r = t * 1e3 * e.speed;
+      this.time += r, a || this.firePassed(s, n, e.frameIndex, r);
+    }
+    const i = this.pick(this.stateIndex);
+    i >= 0 && (this.consumeTriggers(i), this.enter(this.tr.to[i])), this.keepTriggers || this.clearTriggers();
+  }
+  pick(t) {
+    const s = this.states.candidates[t], e = this.tr, n = this.animator.finished || this.time >= this.states.lengths[t];
+    for (let a = 0; a < s.length; a++) {
+      const i = s[a];
+      if (!(e.to[i] === t && e.anyState[i] && !e.self[i]) && !(e.onEnd[i] && !n) && !(e.exitTime[i] >= 0 && this.normalizedTime < e.exitTime[i]) && this.holds(i))
+        return i;
+    }
+    return -1;
+  }
+  holds(t) {
+    const s = this.tr, e = this.params.values;
+    for (let n = s.condStart[t]; n < s.condEnd[t]; n++) {
+      const a = e[s.condParam[n]], i = s.condValue[n];
+      let r;
+      switch (s.condOp[n]) {
+        case k:
+          r = a === i;
+          break;
+        case x:
+          r = a !== i;
+          break;
+        case u:
+          r = a > i;
+          break;
+        case f:
+          r = a >= i;
+          break;
+        case g:
+          r = a < i;
+          break;
+        case l:
+          r = a <= i;
+          break;
+        default:
+          r = !1;
+      }
+      if (!r) return !1;
+    }
+    return !0;
+  }
+  enter(t) {
+    const s = this.stateIndex;
+    this.stateIndex = t, this.time = 0, this.animator.play(this.states.clips[t], !0), this.applySpeed(), this.onStateChange?.(this.states.names[s], this.states.names[t]), this.fire(t, 0);
+  }
+  /**
+   * Fires the markers of every frame after `from` up to `to`. The animator skips frames on a long step, so they are
+   * walked rather than only the one landed on; a step long enough to loop the whole clip fires each frame once.
+   */
+  firePassed(t, s, e, n) {
+    const a = this.states.frameCounts[t];
+    let i = (e - s + a) % a;
+    i === 0 && n >= this.states.lengths[t] && (i = a);
+    for (let r = 1; r <= i; r++)
+      if (this.fire(t, (s + r) % a), this.stateIndex !== t) return;
+  }
+  fire(t, s) {
+    const e = this.states.markers[t][s];
+    if (!e || !this.onEvent) return;
+    const n = this.states.names[t];
+    for (let a = 0; a < e.length; a++) this.onEvent(e[a], n, s);
+  }
+  applySpeed() {
+    const t = this.stateIndex, s = this.states.speedParams[t];
+    this.animator.speed = this.states.speeds[t] * (s >= 0 ? Math.abs(this.params.values[s]) : 1);
+  }
+  consumeTriggers(t) {
+    const s = this.tr;
+    for (let e = s.condStart[t]; e < s.condEnd[t]; e++)
+      this.params.kinds[s.condParam[e]] === h && (this.params.values[s.condParam[e]] = 0);
+  }
+  clearTriggers() {
+    const { kinds: t, values: s } = this.params;
+    for (let e = 0; e < t.length; e++) t[e] === h && (s[e] = 0);
+  }
+  paramIndex(t) {
+    const s = this.params.index.get(t);
+    if (s === void 0) throw new Error(`AnimStateMachine: no parameter "${t}"`);
+    return s;
+  }
+  triggerIndex(t) {
+    const s = this.paramIndex(t);
+    if (this.params.kinds[s] !== h) throw new Error(`AnimStateMachine: "${t}" is not a trigger`);
+    return s;
+  }
+}
+export {
+  v as AnimStateMachine
+};

package/dist/anim/Animator.js

@@ -0,0 +1,66 @@
+class r {
+  constructor(e, t) {
+    this.clips = e;
+    const s = e[t];
+    if (!s) throw new Error(`Animator: no clip "${t}"`);
+    if (s.frames.length === 0) throw new Error(`Animator: clip "${t}" has no frames`);
+    this.clip = s, this.name = t;
+  }
+  clips;
+  clip;
+  index = 0;
+  elapsed = 0;
+  ended = !1;
+  name;
+  /** Called when a clip that does not loop reaches its last frame. */
+  onComplete = null;
+  /** Playback speed multiplier (1 normal, 0 paused). */
+  speed = 1;
+  /** The clip playing. */
+  get current() {
+    return this.name;
+  }
+  /** The frame to show now. */
+  get frame() {
+    return this.clip.frames[this.index];
+  }
+  /** Which frame of the clip (0-based). */
+  get frameIndex() {
+    return this.index;
+  }
+  /** A non-looping clip has reached its last frame. */
+  get finished() {
+    return this.ended;
+  }
+  /** Plays `name`. The clip already playing keeps its place unless `restart`. */
+  play(e, t = !1) {
+    if (e === this.name && !t) return this;
+    const s = this.clips[e];
+    if (!s) throw new Error(`Animator: no clip "${e}"`);
+    if (s.frames.length === 0) throw new Error(`Animator: clip "${e}" has no frames`);
+    return this.clip = s, this.name = e, this.index = 0, this.elapsed = 0, this.ended = !1, this;
+  }
+  /** Advances by `dt` seconds; returns true when the frame changed. */
+  update(e) {
+    if (this.ended || !(e > 0) || this.speed <= 0) return !1;
+    this.elapsed += e * 1e3 * this.speed;
+    const t = this.index, s = this.clip.frames.length;
+    for (let i = this.lengthOf(this.index); this.elapsed >= i; i = this.lengthOf(this.index))
+      if (this.elapsed -= i, this.index < s - 1)
+        this.index++;
+      else if (this.clip.loop !== !1)
+        this.index = 0;
+      else {
+        this.ended = !0, this.elapsed = 0, this.onComplete?.(this.name);
+        break;
+      }
+    return this.index !== t;
+  }
+  lengthOf(e) {
+    const t = this.clip.durations?.[e] ?? 1e3 / (this.clip.fps ?? 10);
+    return Math.max(1, t);
+  }
+}
+export {
+  r as Animator
+};

package/dist/anim/animStateCompile.js

@@ -0,0 +1,112 @@
+const _ = 0, $ = 1, R = 2, b = 0, S = 1, x = 2, v = 3, I = 4, U = 5, E = { "==": 0, "!=": 1, ">": 2, ">=": 3, "<": 4, "<=": 5 };
+function M(t) {
+  let n = 0;
+  for (let r = 0; r < t.frames.length; r++) n += Math.max(1, t.durations?.[r] ?? 1e3 / (t.fps ?? 10));
+  return n;
+}
+function T(t) {
+  const n = Object.keys(t), r = new Uint8Array(n.length), s = new Float64Array(n.length);
+  return n.forEach((e, a) => {
+    const c = t[e];
+    if (c === "trigger") r[a] = 2;
+    else if (typeof c == "boolean")
+      r[a] = 0, s[a] = c ? 1 : 0;
+    else if (typeof c == "number" && Number.isFinite(c))
+      r[a] = 1, s[a] = c;
+    else throw new Error(`AnimStateMachine: parameter "${e}" must start as a boolean, a number or 'trigger'`);
+  }), { names: n, index: new Map(n.map((e, a) => [e, a])), kinds: r, values: s.slice(), initial: s };
+}
+function F(t, n, r) {
+  const s = Object.keys(t.states);
+  if (!s.includes(t.initial)) throw new Error(`AnimStateMachine: no state "${t.initial}"`);
+  const e = s.length, a = {
+    names: s,
+    index: new Map(s.map((c, h) => [c, h])),
+    clips: [],
+    speeds: new Float64Array(e),
+    speedParams: new Int32Array(e),
+    lengths: new Float64Array(e),
+    frameCounts: new Int32Array(e),
+    markers: [],
+    candidates: []
+  };
+  return s.forEach((c, h) => {
+    const o = t.states[c], f = n[o.clip];
+    if (!f) throw new Error(`AnimStateMachine: state "${c}" plays clip "${o.clip}", which does not exist`);
+    if (f.frames.length === 0) throw new Error(`AnimStateMachine: clip "${o.clip}" has no frames`);
+    a.clips.push(o.clip), a.speeds[h] = o.speed ?? 1, a.speedParams[h] = o.speedParam === void 0 ? -1 : g(r, o.speedParam, 1, `state "${c}"`), a.lengths[h] = M(f), a.frameCounts[h] = f.frames.length;
+    const u = new Array(f.frames.length).fill(void 0);
+    for (const A of o.markers ?? []) {
+      if (!(A.frame >= 0 && A.frame < f.frames.length)) throw new Error(`AnimStateMachine: marker "${A.name}" of state "${c}" is past its clip`);
+      (u[A.frame] ??= []).push(A.name);
+    }
+    a.markers.push(u);
+  }), a;
+}
+function N(t, n, r) {
+  const s = t.transitions ?? [], e = s.length, a = [], c = [], h = [], o = {
+    to: new Int32Array(e),
+    anyState: new Uint8Array(e),
+    self: new Uint8Array(e),
+    onEnd: new Uint8Array(e),
+    exitTime: new Float64Array(e),
+    condStart: new Int32Array(e),
+    condEnd: new Int32Array(e),
+    condParam: new Int32Array(0),
+    condOp: new Uint8Array(0),
+    condValue: new Float64Array(0)
+  }, f = n.names.map(() => []), u = (i, m) => {
+    const l = n.index.get(i);
+    if (l === void 0) throw new Error(`AnimStateMachine: ${m} names no state "${i}"`);
+    return l;
+  };
+  s.forEach((i, m) => {
+    const l = `transition ${m} (→ ${i.to})`;
+    if (o.to[m] = u(i.to, l), o.anyState[m] = i.from === "*" ? 1 : 0, o.self[m] = i.self ? 1 : 0, o.onEnd[m] = i.onEnd ? 1 : 0, o.exitTime[m] = i.exitTime ?? -1, i.from === "*") n.names.forEach((p, w) => f[w].push(m));
+    else for (const p of typeof i.from == "string" ? [i.from] : i.from) f[u(p, l)].push(m);
+    o.condStart[m] = a.length;
+    for (const [p, w] of Object.entries(i.when ?? {})) {
+      const d = r.index.get(p);
+      if (d === void 0) throw new Error(`AnimStateMachine: ${l} asks for parameter "${p}", which is not declared`);
+      const [y, P] = O(r.kinds[d], w, `${l}, parameter "${p}"`);
+      a.push(d), c.push(y), h.push(P);
+    }
+    o.condEnd[m] = a.length;
+  }), o.condParam = Int32Array.from(a), o.condOp = Uint8Array.from(c), o.condValue = Float64Array.from(h);
+  const A = (i) => s[i].priority ?? 0;
+  return n.candidates = f.map((i) => Int32Array.from(i.sort((m, l) => A(l) - A(m) || m - l))), o;
+}
+function O(t, n, r) {
+  if (Array.isArray(n)) {
+    const [s, e] = n;
+    if (t !== 1) throw new Error(`AnimStateMachine: ${r} compares a parameter that is not a number`);
+    if (!(s in E) || !Number.isFinite(e)) throw new Error(`AnimStateMachine: ${r} has a bad comparison`);
+    return [E[s], e];
+  }
+  if (t === 1) {
+    if (typeof n != "number") throw new Error(`AnimStateMachine: ${r} is a number; give a number or [op, number]`);
+    return [0, n];
+  }
+  if (typeof n != "boolean") throw new Error(`AnimStateMachine: ${r} is a ${t === 0 ? "bool" : "trigger"}; give true or false`);
+  return [0, n ? 1 : 0];
+}
+function g(t, n, r, s) {
+  const e = t.index.get(n);
+  if (e === void 0 || t.kinds[e] !== r) throw new Error(`AnimStateMachine: ${s} names "${n}", which is not a number parameter`);
+  return e;
+}
+export {
+  b as OP_EQ,
+  v as OP_GE,
+  x as OP_GT,
+  U as OP_LE,
+  I as OP_LT,
+  S as OP_NE,
+  _ as PARAM_BOOL,
+  $ as PARAM_NUMBER,
+  R as PARAM_TRIGGER,
+  M as clipLength,
+  T as compileParams,
+  F as compileStates,
+  N as compileTransitions
+};

package/dist/anim/animStateSystem.js

@@ -0,0 +1,16 @@
+import { defineComponent as r, system as i } from "../ecs/World.js";
+import { SpriteComponent as f } from "./animationSystem.js";
+const p = r("AnimState");
+function u(n = "anim-state") {
+  return i(n, "frame", ({ world: a, dt: o }) => {
+    a.each(f, p, (S, e, t) => {
+      t.update(o);
+      const m = t.frame;
+      e.frameName !== String(m) && e.setFrame(m);
+    });
+  });
+}
+export {
+  p as AnimStateComponent,
+  u as animStateSystem
+};

package/dist/anim/animationSystem.js

@@ -0,0 +1,14 @@
+import { defineComponent as t, system as i } from "../ecs/World.js";
+const r = t("Sprite"), f = t("Animation");
+function d(o = "animation") {
+  return i(o, "frame", ({ world: m, dt: a }) => {
+    m.each(r, f, (c, n, e) => {
+      (e.update(a) || n.frameName !== String(e.frame)) && n.setFrame(e.frame);
+    });
+  });
+}
+export {
+  f as AnimationComponent,
+  r as SpriteComponent,
+  d as animationSystem
+};

package/dist/anim/asepriteSlices.js

@@ -0,0 +1,21 @@
+function r(t, n) {
+  return t.slices.find((e) => e.name === n);
+}
+function i(t, n = 0) {
+  let e;
+  for (const o of t.keys) {
+    if (o.frame > n) break;
+    e = o;
+  }
+  return e;
+}
+function c(t) {
+  const n = t.center;
+  if (n)
+    return { left: n.x, top: n.y, right: t.bounds.w - n.x - n.w, bottom: t.bounds.h - n.y - n.h };
+}
+export {
+  i as sliceAt,
+  c as sliceBorders,
+  r as sliceNamed
+};

package/dist/anim/asepriteTags.js

@@ -0,0 +1,34 @@
+const h = ["forward", "reverse", "pingpong", "pingpong_reverse"];
+function v(e) {
+  return h.includes(e) ? e : "forward";
+}
+function m(e) {
+  const o = typeof e == "number" ? e : e === void 0 ? 0 : Number.parseInt(e, 10);
+  return Number.isFinite(o) && o > 0 ? Math.floor(o) : 0;
+}
+function b(e, o, c, i) {
+  const l = Math.min(e, o), a = Math.max(e, o), t = [];
+  for (let n = l; n <= a; n++) t.push(n);
+  const p = t.slice().reverse(), u = c === "reverse" || c === "pingpong_reverse", s = u ? p : t, g = c === "pingpong" || c === "pingpong_reverse";
+  if (i === 0) {
+    if (!g || t.length <= 2) return s;
+    const n = u ? t : p;
+    return s.concat(n.slice(1, -1));
+  }
+  if (!g) {
+    const n = [];
+    for (let r = 0; r < i; r++) n.push(...s);
+    return n;
+  }
+  const f = s.slice();
+  for (let n = 1; n < i; n++) {
+    const r = n % 2 === 0 ? s : u ? t : p;
+    f.push(...t.length > 1 ? r.slice(1) : r);
+  }
+  return f;
+}
+export {
+  v as tagDirection,
+  b as tagFrames,
+  m as tagRepeat
+};

package/dist/anim/parseAseprite.js

@@ -0,0 +1,82 @@
+import { tagRepeat as w, tagDirection as y, tagFrames as v } from "./asepriteTags.js";
+const A = 100;
+function S(s) {
+  if (!s || typeof s != "object") throw new Error("parseAseprite: not an Aseprite JSON object");
+  const r = s;
+  if (!r.frames || typeof r.frames != "object") throw new Error('parseAseprite: no "frames"');
+  const n = r.meta ?? {}, a = (Array.isArray(r.frames) ? r.frames.map((e, o) => [e.filename ?? String(o), e]) : Object.entries(r.frames)).map(([e, o], t) => b(e, o, t));
+  if (a.length === 0) throw new Error("parseAseprite: the sheet has no frames");
+  const i = (n.frameTags ?? []).map((e) => {
+    if (!(e.from >= 0 && e.to < a.length && e.from <= e.to))
+      throw new Error(`parseAseprite: tag "${e.name}" spans frames ${e.from}–${e.to} of ${a.length}`);
+    const o = { name: e.name, from: e.from, to: e.to, direction: y(e.direction), repeat: w(e.repeat) };
+    return e.color !== void 0 && (o.color = e.color), e.data !== void 0 && (o.data = e.data), o;
+  }), c = {};
+  for (const e of i) {
+    let o = e.name;
+    for (let t = 2; o in c; t++) o = `${e.name}#${t}`;
+    c[o] = h(a, v(e.from, e.to, e.direction, e.repeat), e.repeat === 0);
+  }
+  const f = h(a, a.map((e) => e.index), !0), p = (n.slices ?? []).map((e) => {
+    const o = {
+      name: e.name,
+      keys: (e.keys ?? []).map((t) => ({
+        frame: t.frame,
+        bounds: { ...t.bounds },
+        ...t.center ? { center: { ...t.center } } : {},
+        ...t.pivot ? { pivot: { ...t.pivot } } : {}
+      })).sort((t, g) => t.frame - g.frame)
+    };
+    return e.color !== void 0 && (o.color = e.color), e.data !== void 0 && (o.data = e.data), o;
+  }), d = [], u = [];
+  for (const e of n.layers ?? []) {
+    const o = { name: e.name, opacity: e.opacity ?? 255, blendMode: e.blendMode ?? "normal" };
+    e.group !== void 0 && (o.group = e.group), e.color !== void 0 && (o.color = e.color), e.data !== void 0 && (o.data = e.data), d.push(o);
+    for (const t of e.cels ?? []) t.data && u.push({ layer: e.name, frame: t.frame, data: t.data });
+  }
+  const l = n.size ?? { w: 0, h: 0 };
+  return { image: n.image ?? "", width: l.w, height: l.h, frames: a, tags: i, clips: c, all: f, slices: p, layers: d, cues: u };
+}
+function b(s, r, n) {
+  if (!r || !r.frame) throw new Error(`parseAseprite: frame "${s}" has no rect`);
+  if (r.rotated) throw new Error(`parseAseprite: frame "${s}" is rotated, which is not supported`);
+  const { x: m, y: a, w: i, h: c } = r.frame, f = r.sourceSize ?? { w: i, h: c }, p = r.trimmed && r.spriteSourceSize ? r.spriteSourceSize : { x: 0, y: 0 };
+  return {
+    index: n,
+    name: s,
+    rect: { x: m, y: a, w: i, h: c },
+    duration: r.duration !== void 0 && r.duration > 0 ? r.duration : A,
+    sourceW: f.w,
+    sourceH: f.h,
+    offsetX: p.x,
+    offsetY: p.y,
+    trimmed: r.trimmed === !0
+  };
+}
+function h(s, r, n) {
+  return { frames: r.slice(), durations: r.map((m) => s[m].duration), loop: n };
+}
+function $(s, r) {
+  return s.frames.findIndex((n) => n.name === r);
+}
+function x(s, r) {
+  const n = /* @__PURE__ */ new Map();
+  for (const a of s.cues) {
+    if (r !== void 0 && a.layer !== r) continue;
+    const i = n.get(a.frame) ?? [];
+    i.push(a.data), n.set(a.frame, i);
+  }
+  const m = {};
+  for (const [a, i] of Object.entries(s.clips)) {
+    const c = [];
+    i.frames.forEach((f, p) => {
+      for (const d of n.get(Number(f)) ?? []) c.push({ frame: p, name: d });
+    }), c.length && (m[a] = c);
+  }
+  return m;
+}
+export {
+  x as clipMarkers,
+  $ as frameNamed,
+  S as parseAseprite
+};