1681-engine 0.5.9 → 0.6.0

package/dist/react.js

@@ -1,77 +1,82 @@
 import { UiProvider as r, defaultUiSettings as t, useCx as i, useUi as p } from "./react/UiProvider.js";
-import { classJoiner as l } from "./react/classNames.js";
-import { DEFAULT_LABELS as m, fillLabel as a } from "./react/labels.js";
-import { baseCss as c, injectBaseCss as n } from "./react/baseCss.js";
+import { classJoiner as f } from "./react/classNames.js";
+import { DEFAULT_LABELS as l, fillLabel as x } from "./react/labels.js";
+import { baseCss as n, injectBaseCss as c } from "./react/baseCss.js";
 import { useStore as C } from "./react/useStore.js";
-import { useViewport as u } from "./react/useViewport.js";
-import { SCROLL_CLASS as d, useFitToViewport as L } from "./react/useFitToViewport.js";
-import { useFillSheet as P } from "./react/useFillSheet.js";
-import { SPLIT_STACK_BELOW as w, cursorTip as k, listPlacement as F, pixelFit as A, sheetScaleStyle as E, splitModeFor as U, windowStyle as _ } from "./react/placement.js";
-import { Panel as B } from "./react/Panel.js";
-import { TabStrip as G } from "./react/TabStrip.js";
-import { SplitPane as V } from "./react/SplitPane.js";
-import { pickedEntry as K, usePicked as M } from "./react/usePicked.js";
-import { Select as j, stepOption as v } from "./react/Select.js";
-import { Tooltip as R } from "./react/Tooltip.js";
-import { TitleTips as q } from "./react/TitleTips.js";
-import { Modal as H } from "./react/Modal.js";
-import { ConfirmDialog as X } from "./react/ConfirmDialog.js";
-import { answerConfirm as Z, askConfirm as $, askQuantity as ee, cancelConfirm as oe, confirmStore as re, parseQuantity as te } from "./react/confirmStore.js";
-import { ChoiceDialog as pe } from "./react/ChoiceDialog.js";
-import { answerChoice as le, askChoice as se, cancelChoice as me, choiceStore as ae, firstChoice as xe } from "./react/choiceStore.js";
-import { Slider as ne, sliderKeyValue as Se } from "./react/Slider.js";
-import { PixelImage as he } from "./react/PixelImage.js";
-import { Glyph as ye, glyphPath as de, hasGlyph as Le, registerGlyph as Te } from "./react/Glyph.js";
+import { useJsonSelector as h, useStoreJson as y } from "./react/useJsonSelector.js";
+import { useViewport as L } from "./react/useViewport.js";
+import { SCROLL_CLASS as P, useFitToViewport as g } from "./react/useFitToViewport.js";
+import { useFillSheet as k } from "./react/useFillSheet.js";
+import { SPLIT_STACK_BELOW as A, cursorTip as B, listPlacement as E, pixelFit as U, sheetScaleStyle as _, splitModeFor as b, windowStyle as D } from "./react/placement.js";
+import { Panel as J } from "./react/Panel.js";
+import { TabStrip as V } from "./react/TabStrip.js";
+import { SplitPane as K } from "./react/SplitPane.js";
+import { pickedEntry as Q, usePicked as j } from "./react/usePicked.js";
+import { Select as R, stepOption as W } from "./react/Select.js";
+import { Tooltip as z } from "./react/Tooltip.js";
+import { TitleTips as N } from "./react/TitleTips.js";
+import { Modal as Y } from "./react/Modal.js";
+import { ConfirmDialog as $ } from "./react/ConfirmDialog.js";
+import { ConfirmButton as oe } from "./react/ConfirmButton.js";
+import { answerConfirm as te, askConfirm as ie, askQuantity as pe, cancelConfirm as se, confirmStore as fe, parseQuantity as me } from "./react/confirmStore.js";
+import { ChoiceDialog as xe } from "./react/ChoiceDialog.js";
+import { answerChoice as ne, askChoice as ce, cancelChoice as Se, choiceStore as Ce, firstChoice as ue } from "./react/choiceStore.js";
+import { Slider as ye, sliderKeyValue as de } from "./react/Slider.js";
+import { PixelImage as Te } from "./react/PixelImage.js";
+import { Glyph as ge, glyphPath as we, hasGlyph as ke, registerGlyph as Fe } from "./react/Glyph.js";
 export {
-  pe as ChoiceDialog,
-  X as ConfirmDialog,
-  m as DEFAULT_LABELS,
-  ye as Glyph,
-  H as Modal,
-  B as Panel,
-  he as PixelImage,
-  d as SCROLL_CLASS,
-  w as SPLIT_STACK_BELOW,
-  j as Select,
-  ne as Slider,
-  V as SplitPane,
-  G as TabStrip,
-  q as TitleTips,
-  R as Tooltip,
+  xe as ChoiceDialog,
+  oe as ConfirmButton,
+  $ as ConfirmDialog,
+  l as DEFAULT_LABELS,
+  ge as Glyph,
+  Y as Modal,
+  J as Panel,
+  Te as PixelImage,
+  P as SCROLL_CLASS,
+  A as SPLIT_STACK_BELOW,
+  R as Select,
+  ye as Slider,
+  K as SplitPane,
+  V as TabStrip,
+  N as TitleTips,
+  z as Tooltip,
   r as UiProvider,
-  le as answerChoice,
-  Z as answerConfirm,
-  se as askChoice,
-  $ as askConfirm,
-  ee as askQuantity,
-  c as baseCss,
-  me as cancelChoice,
-  oe as cancelConfirm,
-  ae as choiceStore,
-  l as classJoiner,
-  re as confirmStore,
-  k as cursorTip,
+  ne as answerChoice,
+  te as answerConfirm,
+  ce as askChoice,
+  ie as askConfirm,
+  pe as askQuantity,
+  n as baseCss,
+  Se as cancelChoice,
+  se as cancelConfirm,
+  Ce as choiceStore,
+  f as classJoiner,
+  fe as confirmStore,
+  B as cursorTip,
   t as defaultUiSettings,
-  a as fillLabel,
-  xe as firstChoice,
-  de as glyphPath,
-  Le as hasGlyph,
-  n as injectBaseCss,
-  F as listPlacement,
-  te as parseQuantity,
-  K as pickedEntry,
-  A as pixelFit,
-  Te as registerGlyph,
-  E as sheetScaleStyle,
-  Se as sliderKeyValue,
-  U as splitModeFor,
-  v as stepOption,
+  x as fillLabel,
+  ue as firstChoice,
+  we as glyphPath,
+  ke as hasGlyph,
+  c as injectBaseCss,
+  E as listPlacement,
+  me as parseQuantity,
+  Q as pickedEntry,
+  U as pixelFit,
+  Fe as registerGlyph,
+  _ as sheetScaleStyle,
+  de as sliderKeyValue,
+  b as splitModeFor,
+  W as stepOption,
   i as useCx,
-  P as useFillSheet,
-  L as useFitToViewport,
-  M as usePicked,
+  k as useFillSheet,
+  g as useFitToViewport,
+  h as useJsonSelector,
+  j as usePicked,
   C as useStore,
+  y as useStoreJson,
   p as useUi,
-  u as useViewport,
-  _ as windowStyle
+  L as useViewport,
+  D as windowStyle
 };

package/dist/tilemap/TilemapView.js

@@ -1,17 +1,17 @@
-import { Container as M, Sprite as P } from "pixi.js";
-import { tileAt as F, tileRect as H, FLIP_D as V, FLIP_H as $, FLIP_V as L } from "./tiled.js";
-let S = 0;
-class T {
+import { Container as C, Sprite as F } from "pixi.js";
+import { tileAt as I, tileRect as T, FLIP_D as P, FLIP_H as H, FLIP_V as S } from "./tiled.js";
+let V = 0;
+class _ {
   constructor(s, i, e = {}) {
     this.stage = s, this.map = i;
-    const p = e.textureFor ?? ((t) => t.name), r = Math.max(1, e.chunkTiles ?? 32), m = e.baseDepth ?? -1e6, w = e.layers ? new Set(e.layers) : null, c = i.layers.filter((t) => t.kind === "tiles" && (w ? w.has(t.name) : t.visible)), f = e.parent ?? s.world;
-    c.forEach((t, y) => {
-      const x = typeof t.properties.depth == "number" ? t.properties.depth : m + y, l = new M();
-      l.zIndex = x, l.alpha = t.opacity, l.position.set(t.offsetX, t.offsetY), this.layers.set(t.name, l), f.addChild(l);
-      for (let n = 0; n < i.height; n += r)
-        for (let a = 0; a < i.width; a += r) {
-          const o = Math.min(r, i.width - a), d = Math.min(r, i.height - n);
-          this.paintChunk(t, l, a, n, o, d, p);
+    const l = this.textureFor = e.textureFor ?? ((t) => t.name), h = this.chunkTiles = Math.max(1, e.chunkTiles ?? 32), o = e.baseDepth ?? -1e6, f = e.layers ? new Set(e.layers) : null, n = i.layers.filter((t) => t.kind === "tiles" && (f ? f.has(t.name) : t.visible)), c = e.parent ?? s.world;
+    this.originX = e.x ?? 0, this.originY = e.y ?? 0, n.forEach((t, x) => {
+      const w = typeof t.properties.depth == "number" ? t.properties.depth : o + x, r = new C();
+      r.zIndex = w, r.sortableChildren = !0, r.alpha = t.opacity, r.position.set(this.originX + t.offsetX, this.originY + t.offsetY), this.layers.set(t.name, r), this.drawn.set(t.name, t), c.addChild(r);
+      for (let d = 0; d < i.height; d += h)
+        for (let p = 0; p < i.width; p += h) {
+          const u = Math.min(h, i.width - p), m = Math.min(h, i.height - d);
+          this.paintChunk(t, r, p, d, u, m, l);
         }
     });
   }
@@ -20,13 +20,38 @@ class T {
   /** One container per drawn tile layer, by name, each at its own depth among the bodies. */
   layers = /* @__PURE__ */ new Map();
   chunks = [];
-  id = S++;
+  id = V++;
+  chunkTiles;
+  textureFor;
+  drawn = /* @__PURE__ */ new Map();
+  originX;
+  originY;
   /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */
   update(s = 32) {
     const i = this.stage.cameras.main.worldView;
     for (const e of this.chunks)
       e.sprite.visible = e.x < i.right + s && e.x + e.w > i.x - s && e.y < i.bottom + s && e.y + e.h > i.y - s;
   }
+  /**
+   * Repaints the chunks holding these cells (row-major indices) of a drawn layer, after its `data` changed: a door
+   * opening, a wall dug out, a cell autotiled again (`updateAutotile` returns exactly the indices to pass). Costs one
+   * chunk's painting per chunk touched, so keep it out of every frame.
+   */
+  refreshTiles(s, i) {
+    const e = this.drawn.get(s), l = this.layers.get(s);
+    if (!e || !l) return;
+    const { map: h, chunkTiles: o } = this, f = /* @__PURE__ */ new Set();
+    for (const n of i)
+      n < 0 || n >= h.width * h.height || f.add(`${Math.floor(n % h.width / o) * o},${Math.floor(Math.floor(n / h.width) / o) * o}`);
+    for (const n of f) {
+      const [c, t] = n.split(",").map(Number), x = `tilemap:${this.id}:${e.name}:${c},${t}`, w = this.chunks.findIndex((r) => r.key === x);
+      if (w >= 0) {
+        const [r] = this.chunks.splice(w, 1);
+        r.sprite.destroy(), this.stage.textures.remove(x);
+      }
+      this.paintChunk(e, l, c, t, Math.min(o, h.width - c), Math.min(o, h.height - t), this.textureFor);
+    }
+  }
   /** World size of the map in px. */
   get widthPx() {
     return this.map.width * this.map.tileWidth;
@@ -40,29 +65,29 @@ class T {
     for (const s of this.layers.values()) s.destroy({ children: !0 });
     this.layers.clear();
   }
-  paintChunk(s, i, e, p, r, m, w) {
-    const { map: c } = this, f = c.tileWidth, t = c.tileHeight;
-    let y = !1;
-    const x = `tilemap:${this.id}:${s.name}:${e},${p}`, n = Math.max(t, ...c.tilesets.map((u) => u.tileHeight)) - t, a = this.stage.textures.createCanvas(x, r * f, m * t + n), o = a.context;
-    o.imageSmoothingEnabled = !1;
-    for (let u = 0; u < m; u++)
-      for (let k = 0; k < r; k++) {
-        const v = s.data[(p + u) * c.width + (e + k)], g = F(c, v);
-        if (!g) continue;
-        const b = this.stage.textures.exists(w(g.tileset)) ? this.stage.textures.get(w(g.tileset)).source.resource : null;
-        if (!b) continue;
-        const h = H(g.tileset, g.local), C = k * f, I = n + (u + 1) * t - h.h;
-        o.save(), o.translate(C + h.w / 2, I + h.h / 2), v & V && o.transform(0, 1, 1, 0, 0, 0), o.scale(v & $ ? -1 : 1, v & L ? -1 : 1), o.drawImage(b, h.x, h.y, h.w, h.h, -h.w / 2, -h.h / 2, h.w, h.h), o.restore(), y = !0;
+  paintChunk(s, i, e, l, h, o, f) {
+    const { map: n } = this, c = n.tileWidth, t = n.tileHeight;
+    let x = !1;
+    const w = `tilemap:${this.id}:${s.name}:${e},${l}`, d = Math.max(t, ...n.tilesets.map((g) => g.tileHeight)) - t, p = this.stage.textures.createCanvas(w, h * c, o * t + d), u = p.context;
+    u.imageSmoothingEnabled = !1;
+    for (let g = 0; g < o; g++)
+      for (let y = 0; y < h; y++) {
+        const M = s.data[(l + g) * n.width + (e + y)], k = I(n, M);
+        if (!k) continue;
+        const $ = this.stage.textures.exists(f(k.tileset)) ? this.stage.textures.get(f(k.tileset)).source.resource : null;
+        if (!$) continue;
+        const a = T(k.tileset, k.local), b = y * c, v = d + (g + 1) * t - a.h;
+        u.save(), u.translate(b + a.w / 2, v + a.h / 2), M & P && u.transform(0, 1, 1, 0, 0, 0), u.scale(M & H ? -1 : 1, M & S ? -1 : 1), u.drawImage($, a.x, a.y, a.w, a.h, -a.w / 2, -a.h / 2, a.w, a.h), u.restore(), x = !0;
       }
-    if (!y) {
-      this.stage.textures.remove(x);
+    if (!x) {
+      this.stage.textures.remove(w);
       return;
     }
-    a.refresh();
-    const d = new P(a.whole);
-    d.position.set(e * f, p * t - n), i.addChild(d), this.chunks.push({ sprite: d, x: d.x + s.offsetX, y: d.y + s.offsetY, w: r * f, h: m * t + n, key: x });
+    p.refresh();
+    const m = new F(p.whole);
+    m.position.set(e * c, l * t - d), m.zIndex = l * n.width + e, i.addChild(m), this.chunks.push({ sprite: m, x: m.x + i.x, y: m.y + i.y, w: h * c, h: o * t + d, key: w });
   }
 }
 export {
-  T as TilemapView
+  _ as TilemapView
 };

package/dist/tilemap/autotile.js

@@ -0,0 +1,103 @@
+const G = 1, d = 2, m = 4, A = 8, j = 1, T = 2, U = 4, v = 8, I = 16, F = 32, H = 64, K = 128;
+function f(t) {
+  let n = t & 85;
+  return t & 2 && t & 1 && t & 4 && (n |= 2), t & 8 && t & 16 && t & 4 && (n |= 8), t & 32 && t & 16 && t & 64 && (n |= 32), t & 128 && t & 1 && t & 64 && (n |= 128), n;
+}
+const S = (() => {
+  const t = /* @__PURE__ */ new Set();
+  for (let n = 0; n < 256; n++) t.add(f(n));
+  return [...t].sort((n, e) => n - e);
+})(), w = new Map(S.map((t, n) => [t, n]));
+function R(t) {
+  return w.get(f(t));
+}
+const N = [
+  [0, -1, 1],
+  [1, -1, 2],
+  [1, 0, 4],
+  [1, 1, 8],
+  [0, 1, 16],
+  [-1, 1, 32],
+  [-1, 0, 64],
+  [-1, -1, 128]
+];
+function _(t, n, e, o, B) {
+  if (e < 0 || o < 0 || e >= t.width || o >= t.height) return (B.edge ?? "same") === "same";
+  const c = t.cells[o * t.width + e];
+  return B.joins ? B.joins(n, c) : c === n;
+}
+function a(t, n, e, o = {}) {
+  const B = t.cells[e * t.width + n];
+  return (_(t, B, n, e - 1, o) ? 1 : 0) | (_(t, B, n + 1, e, o) ? 2 : 0) | (_(t, B, n, e + 1, o) ? 4 : 0) | (_(t, B, n - 1, e, o) ? 8 : 0);
+}
+function W(t, n, e, o = {}) {
+  const B = t.cells[e * t.width + n];
+  let c = 0;
+  for (const [l, u, s] of N) _(t, B, n + l, e + u, o) && (c |= s);
+  return f(c);
+}
+function b(t, n) {
+  let e = Math.imul(t, 668265261) ^ Math.imul(n, 374761393);
+  return e ^= e >>> 15, e = Math.imul(e, 739982445), (e ^ e >>> 12) >>> 0;
+}
+const p = { edges: 15, blob: 255 }, h = /* @__PURE__ */ new WeakMap();
+function D(t) {
+  let n = h.get(t);
+  if (n) return n;
+  n = /* @__PURE__ */ new Map();
+  for (const e of t.rules) {
+    const o = e.connectsTo ? new Set(e.connectsTo) : null, B = { edge: t.edge ?? "same" };
+    o && (B.joins = (c, l) => l === c || o.has(l)), n.set(e.terrain, { rule: e, options: B });
+  }
+  return h.set(t, n), n;
+}
+function E(t, n, e) {
+  return t === void 0 || typeof t == "number" ? t : t.length ? t[b(n, e) % t.length] : void 0;
+}
+function r(t, n, e, o) {
+  const B = D(n).get(t.cells[o * t.width + e]);
+  if (!B) return n.empty ?? 0;
+  const c = B.rule.mode ?? "blob", l = c === "blob" ? W(t, e, o, B.options) : a(t, e, o, B.options), { tiles: u } = B.rule;
+  return typeof u == "function" ? u(l, e, o) : E(u[l], e, o) ?? B.rule.fallback ?? E(u[p[c]], e, o) ?? n.empty ?? 0;
+}
+function X(t, n, e = new Uint32Array(t.width * t.height)) {
+  for (let o = 0; o < t.height; o++) for (let B = 0; B < t.width; B++) e[o * t.width + B] = r(t, n, B, o);
+  return e;
+}
+function M(t, n, e, o, B) {
+  const c = [];
+  for (let l = -1; l <= 1; l++)
+    for (let u = -1; u <= 1; u++) {
+      const s = o + u, i = B + l;
+      if (s < 0 || i < 0 || s >= t.width || i >= t.height) continue;
+      const L = i * t.width + s, O = r(t, n, s, i);
+      e[L] !== O && (e[L] = O, c.push(L));
+    }
+  return c;
+}
+function q(t, n, e, o, B, c) {
+  return o < 0 || B < 0 || o >= t.width || B >= t.height ? [] : (t.cells[B * t.width + o] = c, M(t, n, e, o, B));
+}
+export {
+  S as BLOB47_MASKS,
+  U as BLOB_E,
+  j as BLOB_N,
+  T as BLOB_NE,
+  K as BLOB_NW,
+  I as BLOB_S,
+  v as BLOB_SE,
+  F as BLOB_SW,
+  H as BLOB_W,
+  d as EDGE_E,
+  G as EDGE_N,
+  m as EDGE_S,
+  A as EDGE_W,
+  X as autotile,
+  r as autotileAt,
+  R as blob47Index,
+  W as blobMask,
+  a as edgeMask,
+  q as paintTerrain,
+  f as reduceBlobMask,
+  M as updateAutotile
+};

package/dist/tilemap/collision.js

@@ -1,24 +1,35 @@
-import { createCollisionGrid as c } from "../net/movement.js";
-import { gidOf as h, tileAt as y } from "./tiled.js";
-function w(i, s = {}) {
-  if (i.tileWidth !== i.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${i.tileWidth}x${i.tileHeight}`);
-  const l = s.solid ?? (i.layers.some((e) => e.kind === "tiles" && e.name === "collision") ? "collision" : { property: "solid" }), o = i.width * i.height, r = new Uint8Array(o);
-  if (typeof l == "string") {
-    const e = i.layers.find((t) => t.kind === "tiles" && t.name === l);
-    if (!e || e.kind !== "tiles") throw new Error(`Tiled map: no tile layer named "${l}"`);
-    for (let t = 0; t < o; t++) h(e.data[t]) !== 0 && (r[t] = 1);
+import { createCollisionGrid as h } from "../net/movement.js";
+import { gidOf as u, tileAt as a } from "./tiled.js";
+function g(e, l = {}) {
+  if (e.tileWidth !== e.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${e.tileWidth}x${e.tileHeight}`);
+  const n = l.solid ?? (e.layers.some((t) => t.kind === "tiles" && t.name === "collision") ? "collision" : { property: "solid" }), r = e.width * e.height, s = new Uint8Array(r);
+  if (typeof n == "string") {
+    const t = e.layers.find((i) => i.kind === "tiles" && i.name === n);
+    if (!t || t.kind !== "tiles") throw new Error(`Tiled map: no tile layer named "${n}"`);
+    for (let i = 0; i < r; i++) u(t.data[i]) !== 0 && (s[i] = 1);
   } else
-    for (const e of i.layers)
-      if (e.kind === "tiles")
-        for (let t = 0; t < o; t++) {
-          const n = y(i, e.data[t]);
-          n && n.tileset.tileProperties.get(n.local)?.[l.property] === !0 && (r[t] = 1);
+    for (const t of e.layers)
+      if (t.kind === "tiles")
+        for (let i = 0; i < r; i++) {
+          const f = a(e, t.data[i]);
+          f && f.tileset.tileProperties.get(f.local)?.[n.property] === !0 && (s[i] = 1);
         }
   let d = "";
-  for (let e = 0; e < o; e++) d += r[e] ? "1" : "0";
-  const { solid: g, ...f } = s;
-  return c(i.width, i.height, i.tileWidth, d, f);
+  for (let t = 0; t < r; t++) d += s[t] ? "1" : "0";
+  const { solid: c, ...o } = l;
+  return h(e.width, e.height, e.tileWidth, d, o);
+}
+function k(e, l, n = {}) {
+  const r = typeof l == "function" ? l : (c) => l.includes(c), s = /* @__PURE__ */ new Map();
+  let d = "";
+  for (let c = 0; c < e.values.length; c++) {
+    const o = e.values[c];
+    let t = s.get(o);
+    t === void 0 && s.set(o, t = o !== 0 && r(o, e.names.get(o))), d += t ? "1" : "0";
+  }
+  return h(e.width, e.height, e.gridSize, d, n);
 }
 export {
-  w as collisionFromTiled
+  k as collisionFromIntGrid,
+  g as collisionFromTiled
 };

package/dist/tilemap/ldtk.js

@@ -0,0 +1,21 @@
+function o(i, t) {
+  return i.levels.find((e) => e.identifier === t || e.iid === t);
+}
+function l(i, t, e, r) {
+  for (const n of i)
+    if (!(r !== void 0 && n.worldDepth !== r) && t >= n.worldX && e >= n.worldY && t < n.worldX + n.pxWidth && e < n.worldY + n.pxHeight)
+      return n;
+  return null;
+}
+function u(i, t, e) {
+  return t < 0 || e < 0 || t >= i.width || e >= i.height ? 0 : i.values[e * i.width + t];
+}
+function f(i, t) {
+  return t === void 0 ? i.entities : i.entities.filter((e) => e.identifier === t);
+}
+export {
+  f as entitiesOf,
+  u as intGridAt,
+  l as levelAt,
+  o as levelByName
+};

package/dist/tilemap/ldtkParse.js

@@ -0,0 +1,191 @@
+import { FLIP_H as z, FLIP_V as M } from "./tiled.js";
+class G extends Error {
+  constructor(n) {
+    super(`LDtk project: ${n}`);
+  }
+}
+function c(e, n) {
+  if (typeof e != "number" || !Number.isFinite(e)) throw new G(`${n} must be a number`);
+  return e;
+}
+function L(e) {
+  const n = {};
+  if (Array.isArray(e))
+    for (const r of e) r && typeof r.__identifier == "string" && (n[r.__identifier] = r.__value ?? null);
+  return n;
+}
+function N(e) {
+  const n = {};
+  for (const [r, o] of Object.entries(e)) (typeof o == "string" || typeof o == "number" || typeof o == "boolean") && (n[r] = o);
+  return n;
+}
+function W(e) {
+  return Array.isArray(e.worlds) && e.worlds.length ? e.worlds : [{ identifier: "World", iid: "", worldLayout: e.worldLayout, worldGridWidth: e.worldGridWidth, worldGridHeight: e.worldGridHeight, levels: e.levels ?? [] }];
+}
+function R(e) {
+  const n = e;
+  if (!n || typeof n != "object") return [];
+  const r = [];
+  for (const o of W(n)) for (const t of o.levels ?? []) typeof t.externalRelPath == "string" && !Array.isArray(t.layerInstances) && r.push(t.externalRelPath);
+  return r;
+}
+function A(e) {
+  const n = [], r = /* @__PURE__ */ new Map();
+  let o = 1;
+  for (const t of e?.tilesets ?? []) {
+    if (typeof t.relPath != "string") continue;
+    const a = c(t.tileGridSize, `tileset "${t.identifier}" tileGridSize`), d = c(t.__cWid, `tileset "${t.identifier}" __cWid`), s = d * c(t.__cHei, `tileset "${t.identifier}" __cHei`), l = /* @__PURE__ */ new Map(), p = (i) => l.get(i) ?? (l.set(i, {}), l.get(i));
+    for (const i of t.customData ?? []) typeof i.tileId == "number" && typeof i.data == "string" && (p(i.tileId).data = i.data);
+    for (const i of t.enumTags ?? []) for (const g of i.tileIds ?? []) typeof i.enumValueId == "string" && (p(g)[i.enumValueId] = !0);
+    const u = {
+      name: String(t.identifier ?? `tileset${t.uid}`),
+      firstGid: o,
+      image: t.relPath,
+      imageWidth: c(t.pxWid, `tileset "${t.identifier}" pxWid`),
+      imageHeight: c(t.pxHei, `tileset "${t.identifier}" pxHei`),
+      tileWidth: a,
+      tileHeight: a,
+      columns: d,
+      tileCount: s,
+      margin: Number(t.padding ?? 0),
+      spacing: Number(t.spacing ?? 0),
+      tileProperties: l,
+      animations: /* @__PURE__ */ new Map(),
+      properties: {}
+    };
+    n.push(u), r.set(c(t.uid, "tileset uid"), u), o += s;
+  }
+  return { tilesets: n, byUid: r };
+}
+function T(e, n, r, o, t, a, d) {
+  const s = [], l = (u) => {
+    for (; s.length <= u; )
+      s.push({
+        kind: "tiles",
+        name: s.length ? `${n}#${s.length}` : n,
+        data: new Uint32Array(t * a),
+        visible: e.visible !== !1,
+        opacity: typeof e.__opacity == "number" ? e.__opacity : 1,
+        offsetX: Number(e.__pxTotalOffsetX ?? 0),
+        offsetY: Number(e.__pxTotalOffsetY ?? 0),
+        properties: {}
+      });
+    return s[u];
+  }, p = new Uint8Array(t * a);
+  for (const u of r) {
+    const i = Math.floor(c(u.px?.[0], `layer "${n}" tile px`) / d), g = Math.floor(c(u.px?.[1], `layer "${n}" tile px`) / d);
+    if (i < 0 || g < 0 || i >= t || g >= a) continue;
+    const h = c(u.t, `layer "${n}" tile id`);
+    if (h < 0 || h >= o.tileCount) continue;
+    const m = g * t + i, b = Number(u.f ?? 0), y = (o.firstGid + h | (b & 1 ? z : 0) | (b & 2 ? M : 0)) >>> 0;
+    l(p[m]).data[m] = y, p[m] = Math.min(255, p[m] + 1);
+  }
+  return s.length || l(0), s;
+}
+function X(e, n) {
+  const r = /* @__PURE__ */ new Map(), o = (e?.layers ?? []).find((t) => t.uid === n);
+  for (const t of o?.intGridValues ?? []) typeof t.value == "number" && typeof t.identifier == "string" && t.identifier && r.set(t.value, t.identifier);
+  return r;
+}
+function Y(e, n, r, o, t) {
+  const a = n.filter((i) => i.__type !== "Entities"), d = a.length ? c(a[0].__gridSize, "layer __gridSize") : t;
+  for (const i of a)
+    if (i.__gridSize !== d) throw new G(`level "${e.identifier}" layer "${i.__identifier}" has a ${i.__gridSize} px grid, not ${d}: every tile and IntGrid layer of a level must share one grid`);
+  const s = a.length ? Math.max(...a.map((i) => c(i.__cWid, "layer __cWid"))) : Math.ceil(e.pxWidth / d), l = a.length ? Math.max(...a.map((i) => c(i.__cHei, "layer __cHei"))) : Math.ceil(e.pxHeight / d), p = [];
+  let u = 1;
+  for (const i of [...n].reverse()) {
+    const g = String(i.__identifier ?? ""), h = i.__type, m = Number(i.__pxTotalOffsetX ?? 0), b = Number(i.__pxTotalOffsetY ?? 0);
+    if (h === "IntGrid") {
+      const y = c(i.__cWid, "layer __cWid"), f = c(i.__cHei, "layer __cHei"), _ = i.intGridCsv;
+      if (!Array.isArray(_) || _.length !== y * f) throw new G(`layer "${g}" must hold ${y * f} IntGrid cells`);
+      const w = { name: g, width: y, height: f, gridSize: d, values: Int32Array.from(_), names: X(r, i.layerDefUid), offsetX: m, offsetY: b };
+      e.intGrids.set(g, w);
+    }
+    if (h === "IntGrid" || h === "AutoLayer" || h === "Tiles") {
+      const y = h === "Tiles" ? i.gridTiles ?? [] : i.autoLayerTiles ?? [], f = i.overrideTilesetUid ?? i.__tilesetDefUid, _ = typeof f == "number" ? o.get(f) : void 0;
+      _ && (h !== "IntGrid" || y.length) && p.push(...T(i, g, y, _, s, l, d));
+    } else if (h === "Entities") {
+      const y = [];
+      for (const f of i.entityInstances ?? []) {
+        const _ = L(f.fieldInstances), w = Number(f.width ?? 0), x = Number(f.height ?? 0), $ = Number(f.__pivot?.[0] ?? 0), I = Number(f.__pivot?.[1] ?? 0), v = c(f.px?.[0], `entity "${f.__identifier}" px`) + m, H = c(f.px?.[1], `entity "${f.__identifier}" px`) + b, S = {
+          iid: String(f.iid ?? ""),
+          identifier: String(f.__identifier ?? ""),
+          x: v,
+          y: H,
+          width: w,
+          height: x,
+          pivotX: $,
+          pivotY: I,
+          cx: Number(f.__grid?.[0] ?? Math.floor(v / d)),
+          cy: Number(f.__grid?.[1] ?? Math.floor(H / d)),
+          tags: Array.isArray(f.__tags) ? f.__tags.map(String) : [],
+          fields: _,
+          layer: g
+        };
+        e.entities.push(S), y.push({ id: u++, name: S.identifier, type: S.identifier, x: v - $ * w, y: H - I * x, width: w, height: x, rotation: 0, point: w === 0 && x === 0, ellipse: !1, properties: N(_) });
+      }
+      p.push({ kind: "objects", name: g, objects: y, visible: i.visible !== !1, properties: {} });
+    }
+  }
+  e.map.width = s, e.map.height = l, e.map.tileWidth = d, e.map.tileHeight = d, e.map.layers = p;
+}
+function P(e, n, r, o, t) {
+  const a = String(e.identifier ?? ""), d = String(e.__bgColor ?? e.bgColor ?? n.bgColor), s = {
+    identifier: a,
+    iid: String(e.iid ?? ""),
+    uid: Number(e.uid ?? 0),
+    worldX: Number(e.worldX ?? 0),
+    worldY: Number(e.worldY ?? 0),
+    worldDepth: Number(e.worldDepth ?? 0),
+    pxWidth: c(e.pxWid, `level "${a}" pxWid`),
+    pxHeight: c(e.pxHei, `level "${a}" pxHei`),
+    bgColor: d,
+    fields: L(e.fieldInstances),
+    map: { width: 0, height: 0, tileWidth: n.defaultGridSize, tileHeight: n.defaultGridSize, layers: [], tilesets: n.tilesets, properties: {}, backgroundColor: d },
+    intGrids: /* @__PURE__ */ new Map(),
+    entities: [],
+    loaded: !1
+  };
+  typeof e.externalRelPath == "string" && (s.externalRelPath = e.externalRelPath);
+  let l = e;
+  return !Array.isArray(e.layerInstances) && s.externalRelPath && (l = t(s.externalRelPath)), l && Array.isArray(l.layerInstances) && (s.fields = { ...s.fields, ...L(l.fieldInstances) }, s.map.properties = N(s.fields), Y(s, l.layerInstances, r, o, n.defaultGridSize), s.loaded = !0), s;
+}
+function k(e, n) {
+  let r = 0;
+  for (const o of e)
+    n === "LinearHorizontal" ? (o.worldX = r, o.worldY = 0, r += o.pxWidth) : (o.worldX = 0, o.worldY = r, r += o.pxHeight);
+}
+function j(e, n = {}) {
+  const r = e;
+  if (!r || typeof r != "object" || !r.defs) throw new G('not an LDtk project (no "defs")');
+  const o = n.levels, t = typeof o == "function" ? o : (l) => o?.[l], { tilesets: a, byUid: d } = A(r.defs), s = {
+    jsonVersion: String(r.jsonVersion ?? ""),
+    defaultGridSize: Number(r.defaultGridSize ?? 16),
+    bgColor: String(r.bgColor ?? "#000000"),
+    tilesets: a,
+    worlds: [],
+    levels: []
+  };
+  for (const l of W(r)) {
+    const p = l.worldLayout ?? "Free", u = {
+      identifier: String(l.identifier ?? ""),
+      iid: String(l.iid ?? ""),
+      layout: p,
+      gridWidth: Number(l.worldGridWidth ?? 0),
+      gridHeight: Number(l.worldGridHeight ?? 0),
+      levels: (l.levels ?? []).map((i) => P(i, s, r.defs, d, t))
+    };
+    (p === "LinearHorizontal" || p === "LinearVertical") && k(u.levels, p), s.worlds.push(u), s.levels.push(...u.levels);
+  }
+  return s;
+}
+function O(e, n, r, o) {
+  const t = n, { byUid: a } = A(t?.defs), d = P({ ...o, worldX: r.worldX, worldY: r.worldY, externalRelPath: r.externalRelPath }, e, t?.defs, a, () => {
+  });
+  return Object.assign(r, { map: d.map, intGrids: d.intGrids, entities: d.entities, fields: d.fields, loaded: d.loaded }), r;
+}
+export {
+  R as ldtkExternalLevels,
+  O as loadLdtkLevel,
+  j as parseLdtk
+};