1681-engine 0.5.9 → 0.5.10

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
+};

package/dist/types/ambient/life/Birds.d.ts

@@ -0,0 +1,50 @@
+import type { ViewRect } from '../../core/Camera.js';
+import type { Stage } from '../../core/Stage.js';
+import { type LifeAir } from './lifeMotion.js';
+export interface BirdsOptions {
+    /** Birds in a flock, [least, most]; never more than `maxFlock`. */
+    flock: readonly [number, number];
+    /** Seconds between flocks, [least, most]. */
+    everyS: readonly [number, number];
+    /** The two frames, seen from above: wings raised (a V), then the downstroke. */
+    frames: readonly [string, string];
+    /** A small shadow on the ground far below each bird: it is what tells the eye how high they are. */
+    shadow?: string;
+    /** The pool's size (default 6). */
+    maxFlock?: number;
+    /** Depth of the birds (default 950_000: over every prop and body, under the names). */
+    depth?: number;
+    /** Depth of their shadows (default -999_980: on the ground, under the bodies). */
+    shadowDepth?: number;
+    /** Past this `night` no flock sets off (default 0.5). */
+    maxNight?: number;
+    /** The first flock comes this many ms after the first update, [least, most] (default [3000, 9000]). */
+    firstMs?: readonly [number, number];
+    snap?: boolean;
+    random?: () => number;
+}
+/**
+ * A flock crossing the sky now and then: a few painted birds in a loose V flying straight across the camera's view,
+ * wings beating on their own clocks, each with its shadow on the ground below. Not at night.
+ */
+export declare class Birds {
+    private readonly options;
+    private readonly birds;
+    private readonly snap;
+    private readonly random;
+    private active;
+    private nextAt;
+    private x;
+    private y;
+    private vx;
+    private vy;
+    private altitude;
+    constructor(stage: Stage, options: BirdsOptions);
+    /** Whether a flock is crossing now. */
+    get flying(): boolean;
+    update(now: number, dt: number, view: ViewRect, air: LifeAir, enabled?: boolean): void;
+    destroy(): void;
+    private launch;
+    private land;
+}
+//# sourceMappingURL=Birds.d.ts.map

package/dist/types/ambient/life/Birds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Birds.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/Birds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAwB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAElE,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,6CAA6C;IAC7C,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,gFAAgF;IAChF,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uGAAuG;IACvG,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAUD;;;GAGG;AACH,qBAAa,KAAK;IAcd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,CAAC,CAAK;IACd,OAAO,CAAC,CAAC,CAAK;IACd,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,QAAQ,CAAM;gBAGpB,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,YAAY;IAcxC,uCAAuC;IACvC,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,IAAI;IA4BnF,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,MAAM;IAwBd,OAAO,CAAC,IAAI;CAOb"}

package/dist/types/ambient/life/Butterflies.d.ts

@@ -0,0 +1,32 @@
+import type { ViewRect } from '../../core/Camera.js';
+import type { Stage } from '../../core/Stage.js';
+import type { LifeAir, LifeSource } from './lifeMotion.js';
+export interface ButterfliesOptions {
+    count: number;
+    /** Each tone's two frames, wings open then shut; butterfly `i` wears `looks[i % looks.length]`. */
+    looks: readonly (readonly [open: string, shut: string])[];
+    /** A flower patch in view to settle round, or null when none is on screen. */
+    home: LifeSource;
+    /** Depth in the world layer (default 900_000). */
+    depth?: number;
+    /** Past this `night` they are gone (default 0.4). */
+    maxNight?: number;
+    snap?: boolean;
+    random?: () => number;
+}
+/**
+ * Butterflies by day round the flowers on screen: each settles on a patch in view and wanders round it in short
+ * jinks, wings opening and shutting on their own beat, bobbing a pixel over the bloom. They leave when the night
+ * comes in, and where `home` finds nothing they are simply not drawn.
+ */
+export declare class Butterflies {
+    private readonly options;
+    private readonly flies;
+    private readonly snap;
+    private readonly random;
+    constructor(stage: Stage, options: ButterfliesOptions);
+    update(now: number, dt: number, view: ViewRect, air: LifeAir, enabled?: boolean): void;
+    destroy(): void;
+    private settle;
+}
+//# sourceMappingURL=Butterflies.d.ts.map

package/dist/types/ambient/life/Butterflies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Butterflies.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/Butterflies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,mGAAmG;IACnG,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAC1D,8EAA8E;IAC9E,IAAI,EAAE,UAAU,CAAC;IACjB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAgBD;;;;GAIG;AACH,qBAAa,WAAW;IAOpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAGpC,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,kBAAkB;IAY9C,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,IAAI;IA8BnF,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,MAAM;CAUf"}

package/dist/types/ambient/life/ChimneySmoke.d.ts

@@ -0,0 +1,37 @@
+import type { ViewRect } from '../../core/Camera.js';
+import type { Stage } from '../../core/Stage.js';
+import { type LifeAir, type LifePoint } from './lifeMotion.js';
+export interface ChimneySmokeOptions {
+    /** The chimneys' mouths in world pixels. */
+    mouths: readonly LifePoint[];
+    /** The puff's frames from young to old (it grows through them and dithers away). */
+    frames: readonly string[];
+    /** Puffs in each chimney's pool (default 7). */
+    puffs?: number;
+    /** A puff every this many ms, give or take 30% (default 650). */
+    puffEveryMs?: number;
+    /** A puff's life (ms, default 4600). */
+    lifeMs?: number;
+    /** World px a second it climbs (default 7). */
+    rise?: number;
+    /** World px a second the wind leans it (default 9). */
+    drift?: number;
+    /** Depth in the world layer (default 900_000). */
+    depth?: number;
+    snap?: boolean;
+    random?: () => number;
+}
+/**
+ * Smoke rising from chimneys: each mouth lets out a puff every so often that climbs, grows through its frames, leans
+ * downwind and is gone. Only mouths on screen puff; a mouth that leaves the view drops its puffs at once.
+ */
+export declare class ChimneySmoke {
+    private readonly options;
+    private readonly chimneys;
+    private readonly snap;
+    private readonly random;
+    constructor(stage: Stage, options: ChimneySmokeOptions);
+    update(now: number, view: ViewRect, air: LifeAir, enabled?: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=ChimneySmoke.d.ts.map

package/dist/types/ambient/life/ChimneySmoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChimneySmoke.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/ChimneySmoke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAc,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAExE,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IAC7B,oFAAoF;IACpF,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAeD;;;GAGG;AACH,qBAAa,YAAY;IAOrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAGpC,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,mBAAmB;IAgB/C,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,IAAI;IAwCvE,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/ambient/life/Drift.d.ts

@@ -0,0 +1,58 @@
+import type { ViewRect } from '../../core/Camera.js';
+import type { Stage } from '../../core/Stage.js';
+import type { LifeAir, LifeSource } from './lifeMotion.js';
+/**
+ * How a drift moves:
+ * - `leaf`: tumbles down through its frames, lands, lies a moment and is gone;
+ * - `seed`: blown across the view on a slow wobble (dandelion seed, spores, ash on the wind);
+ * - `ember`: rises, cooling through its frames, and goes out within a tile or three;
+ * - `mote`: hangs in the air, barely moving, and winks out now and then (underground dust);
+ * - `ash`: blown across like a seed, but from a source it lifts off the ground instead.
+ */
+export type DriftKind = 'leaf' | 'seed' | 'ember' | 'mote' | 'ash';
+export interface DriftOptions {
+    kind: DriftKind;
+    /** Bodies in the pool; a body off screen is hidden and re-used, never freed. */
+    count: number;
+    /**
+     * The looks, each a list of frames; body `i` wears `looks[i % looks.length]`. A leaf tumbles through its frames and
+     * lies on the first; an ember cools from its first to its last; the others wear the first.
+     */
+    looks: readonly (readonly string[])[];
+    /**
+     * Where a body sets off from, if anywhere in particular: a canopy on screen a leaf falls from (and lands just under),
+     * a patch of ground ash or embers lift off. Null when there is none in view now.
+     */
+    from?: LifeSource;
+    /**
+     * Only from `from` (a drift over certain ground): a body waits rather than drift in from the view's edge. Default
+     * false — a leaf with no canopy in view still blows in from the edge.
+     */
+    sourceOnly?: boolean;
+    /** Depth in the world layer (default 900_000: over the bodies and props, under the weather and the names). */
+    depth?: number;
+    /** Positions on whole world pixels (default true). */
+    snap?: boolean;
+    random?: () => number;
+}
+/**
+ * One kind of thing on the air: a fixed pool that lives only inside the camera's view, each body on whole world
+ * pixels and flipped between painted frames rather than rotated (a rotated pixel leaf reads as a different art style).
+ * Feed it the frame's view and the air; `enabled` false hides it (a reduced-effects setting).
+ */
+export declare class Drift {
+    private readonly options;
+    private readonly motes;
+    private readonly kind;
+    private readonly snap;
+    private readonly random;
+    constructor(stage: Stage, options: DriftOptions);
+    /** `now` and `dt` in ms. */
+    update(now: number, dt: number, view: ViewRect, air: LifeAir, enabled?: boolean): void;
+    destroy(): void;
+    /** `anywhere`: a first fill lands bodies all over the view, not only at its edge, so a scene opens already alive. */
+    private spawn;
+    private spawnFrom;
+    private step;
+}
+//# sourceMappingURL=Drift.d.ts.map

package/dist/types/ambient/life/Drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drift.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/Drift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAW,UAAU,EAAE,MAAM,cAAc,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IACtC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8GAA8G;IAC9G,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAuBD;;;;GAIG;AACH,qBAAa,KAAK;IAQd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAY;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAGpC,KAAK,EAAE,KAAK,EACK,OAAO,EAAE,YAAY;IAaxC,4BAA4B;IAC5B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,IAAI;IAuBnF,OAAO,IAAI,IAAI;IAKf,qHAAqH;IACrH,OAAO,CAAC,KAAK;IA2Bb,OAAO,CAAC,SAAS;IAwBjB,OAAO,CAAC,IAAI;CAwCb"}

package/dist/types/ambient/life/Fireflies.d.ts

@@ -0,0 +1,43 @@
+import { Container } from 'pixi.js';
+import type { ViewRect } from '../../core/Camera.js';
+import type { Stage } from '../../core/Stage.js';
+import { type LifeAir, type LifeSource } from './lifeMotion.js';
+export interface FirefliesOptions {
+    count: number;
+    /** The two frames: a dim pixel, and the glow. */
+    frames: readonly [dim: string, lit: string];
+    /** Somewhere in view to hover round (the water's edge, the feet of trees), or null when none is on screen. */
+    home: LifeSource;
+    /**
+     * Where the layer goes. Default `'screen'`: on the screen layer, following the camera, so it can be laid **over** a
+     * darkness drawn there (`NightShade`, `Darkness`) instead of being darkened with the world under it — add it after
+     * the darkness. `'world'`: in the world layer at `depth`, for a game with no darkness over its world.
+     */
+    layer?: 'screen' | 'world';
+    /** World-layer depth when `layer` is `'world'` (default 900_000). */
+    depth?: number;
+    snap?: boolean;
+    random?: () => number;
+}
+/**
+ * Fireflies at night: single pixels drifting slowly round homes on screen, each lighting up and going out on its own
+ * clock. How many are out grows with the dark (none before night 0.5, all by 0.85). They are a light, so by default
+ * their layer sits on the screen and follows the camera (`Camera.follow` copies the world layer's transform, shake
+ * included, once the frame's camera is known).
+ */
+export declare class Fireflies {
+    private readonly stage;
+    private readonly options;
+    readonly layer: Container<import("pixi.js").ContainerChild>;
+    private readonly flies;
+    private readonly dim;
+    private readonly lit;
+    private readonly onScreen;
+    private readonly snap;
+    private readonly random;
+    constructor(stage: Stage, options: FirefliesOptions);
+    update(now: number, view: ViewRect, air: LifeAir, enabled?: boolean): void;
+    destroy(): void;
+    private settle;
+}
+//# sourceMappingURL=Fireflies.d.ts.map

package/dist/types/ambient/life/Fireflies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fireflies.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/Fireflies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAwB,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAA4C,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEvG,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,MAAM,EAAE,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;IAC5C,8GAA8G;IAC9G,IAAI,EAAE,UAAU,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC3B,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAUD;;;;;GAKG;AACH,qBAAa,SAAS;IAUlB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAV1B,QAAQ,CAAC,KAAK,8CAAmB;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAU;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAU;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAGnB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,gBAAgB;IAwB5C,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAAO,GAAG,IAAI;IA8BvE,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,MAAM;CAQf"}

package/dist/types/ambient/life/lifeMotion.d.ts

@@ -0,0 +1,63 @@
+import type { ViewRect } from '../../core/Camera.js';
+/** A point in world pixels. */
+export interface LifePoint {
+    x: number;
+    y: number;
+}
+/** A box in world pixels (a canopy leaves fall from, a tile ash lifts off); a point is a box of no size. */
+export interface LifeBox extends LifePoint {
+    w?: number;
+    h?: number;
+}
+/** The air the life reads: how dark it is and how hard the wind blows. */
+export interface LifeAir {
+    /** 0 by day, 1 at full night (birds and butterflies keep away from the dark, fireflies come out of it). */
+    night: number;
+    /** 0 still air, 1 a gale: leans the drift, hastens a flock, bends smoke. */
+    wind: number;
+}
+/** Hands back somewhere to be: inside the camera's view, or null when there is nowhere there now. */
+export type LifeSource<T extends LifeBox = LifeBox> = (view: ViewRect, random: () => number) => T | null;
+/** Whether the box touches the view grown by `margin` on every side. */
+export declare function boxInView(b: LifeBox, view: ViewRect, margin?: number): boolean;
+/**
+ * One of `items` in view, tried `tries` times at random rather than filtered: a forest's thousands of tiles cost the
+ * same few reads as a hamlet's dozen, and a miss only means the body waits a frame to try again.
+ */
+export declare function pickInView<T extends LifeBox>(items: readonly T[], view: ViewRect, random: () => number, tries?: number): T | null;
+/** A `LifeSource` over a fixed list (flower beds, the water's edge, tiles of burnt ground). */
+export declare function sourceOf<T extends LifeBox>(items: readonly T[], tries?: number): LifeSource<T>;
+/** A bird's frame: a few beats (0, 1, 0, 1, 0), then a glide on raised wings (0) for three, each bird on its clock. */
+export declare function birdFrame(now: number, offset: number, beatMs?: number): 0 | 1;
+/**
+ * Where the `i`-th bird of a flock flies behind the leader: a loose V trailing back along `dirX` (its sign), ranks
+ * alternating side to side. `jitter` (0..1 each) loosens it so no two flocks are drawn alike.
+ */
+export declare function flockSlot(i: number, dirX: number, jitterX: number, jitterY: number): {
+    dx: number;
+    dy: number;
+};
+/** A firefly's blink at `t` seconds: 0 dark most of the time, 2 a glow for a beat, 1 a dim pixel either side of it. */
+export declare function fireflyGlow(t: number): 0 | 1 | 2;
+/** A firefly's slow wander about its home at `t` seconds: two sines across, one up and down. */
+export declare function fireflyOffset(t: number): {
+    dx: number;
+    dy: number;
+};
+/** How many of a pool of `count` fireflies are out at `night`: none before 0.5, all by 0.85. */
+export declare function firefliesOut(count: number, night: number): number;
+export interface PuffMotion {
+    /** World px a second it climbs. */
+    rise: number;
+    /** World px a second the wind leans it at full age. */
+    drift: number;
+}
+/**
+ * Where a puff of smoke is `sec` seconds after it left a chimney's mouth, `age` the share of its life gone: it climbs
+ * straight out of the pot, then the wind takes it more the higher it gets. `seed` (0..1) gives each its own wobble.
+ */
+export declare function puffOffset(sec: number, age: number, seed: number, wind: number, m: PuffMotion): {
+    dx: number;
+    dy: number;
+};
+//# sourceMappingURL=lifeMotion.d.ts.map

package/dist/types/ambient/life/lifeMotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeMotion.d.ts","sourceRoot":"","sources":["../../../../src/ambient/life/lifeMotion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAQlD,+BAA+B;AAC/B,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,4GAA4G;AAC5G,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,0EAA0E;AAC1E,MAAM,WAAW,OAAO;IACtB,2GAA2G;IAC3G,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qGAAqG;AACrG,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC;AAEzG,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAI,GAAG,OAAO,CAEzE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,MAAM,EAAE,KAAK,SAAI,GAAG,CAAC,GAAG,IAAI,CAO5H;AAED,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,SAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAEzF;AAED,uHAAuH;AACvH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,CAAC,GAAG,CAAC,CAG1E;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAI/G;AAED,uHAAuH;AACvH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAGhD;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAEnE;AAED,gGAAgG;AAChG,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE;AAED,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAK1H"}

package/dist/types/assets/AssetLoader.d.ts

@@ -1,4 +1,5 @@
 import type { CanvasTexture } from '../core/TextureRegistry.js';
+import type { LdtkProject } from '../tilemap/ldtk.js';
 import { type TileMap, type Tileset } from '../tilemap/tiled.js';
 import { type AtlasFrame } from './textureAtlas.js';
 /** Where loaded images go: the stage's `TextureRegistry` satisfies it. */
@@ -50,6 +51,13 @@ export interface TilemapAssetOptions {
     /** The texture key a tileset's image is loaded under (default: the tileset's name). */
     textureKey?: (tileset: Tileset) => string;
 }
+export interface LdtkAssetOptions extends TilemapAssetOptions {
+    /**
+     * Which external level files to fetch with the project (by level identifier); default every one. A level left out
+     * stays `loaded: false`, to be fetched later and read with `loadLdtkLevel`.
+     */
+    levels?: readonly string[];
+}
 export interface LoadProgress {
     done: number;
     total: number;
@@ -79,6 +87,7 @@ export declare class AssetLoader {
     private readonly queue;
     private readonly data;
     private readonly maps;
+    private readonly ldtks;
     private readonly atlases;
     /** Decoded audio by key; a key with bytes only waits for a context (`decodeAudio`). */
     private readonly audioBuffers;
@@ -99,6 +108,14 @@ export declare class AssetLoader {
     text(key: string, url: string): this;
     /** A Tiled JSON map, then every tileset image it names (resolved beside the map file). */
     tilemap(key: string, url: string, options?: TilemapAssetOptions): this;
+    /**
+     * An LDtk project: the `.ldtk` file, the `.ldtkl` file of each level it saves apart (resolved beside the project),
+     * then every tileset image (resolved beside the project, as LDtk writes `relPath`). Counts as one asset, plus one
+     * per tileset image. Read it back with `ldtkProject(key)`; each level's `map` goes to `TilemapView` as it is.
+     */
+    ldtk(key: string, url: string, options?: LdtkAssetOptions): this;
+    /** A loaded LDtk project. */
+    ldtkProject(key: string): LdtkProject;
     /**
      * A TexturePacker (or Pixi) JSON atlas, hash or array format: its page image, and for a multipack atlas every page
      * named in `meta.related_multi_packs` (each resolved beside the file naming it). The first page is the texture
@@ -132,8 +149,11 @@ export declare class AssetLoader {
     /** A loaded Tiled map. */
     map(key: string): TileMap;
     private add;
+    private full;
     private request;
     private blob;
+    /** An image file decoded into a canvas; a file that is not an image fails naming its URL. */
+    private canvas;
     private bytes;
     private decode;
 }