1681-engine 0.5.9 → 0.5.10

package/dist/cjs/updates/webPlan.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planWeb = planWeb;
+/**
+ * What to copy and what to download for `target`, given the web held now (`have`: path → sha256): a file whose path
+ * holds the same content is copied from there, one whose content lies under another path (a bundler renamed it) is
+ * copied from that path, and only content found nowhere is downloaded — once, however many paths share it. This is
+ * what makes a patch cost only what changed, the way a game launcher patches.
+ */
+function planWeb(target, have) {
+    const byHash = new Map();
+    for (const [path, sha] of have)
+        if (!byHash.has(sha))
+            byHash.set(sha, path);
+    const copy = [];
+    const download = [];
+    const fetched = new Set();
+    let bytes = 0;
+    for (const f of target.files) {
+        const there = byHash.get(f.sha256);
+        if (have.get(f.path) === f.sha256)
+            copy.push({ path: f.path, from: f.path });
+        else if (there !== undefined)
+            copy.push({ path: f.path, from: there });
+        else {
+            download.push(f);
+            if (!fetched.has(f.sha256)) {
+                fetched.add(f.sha256);
+                bytes += f.size;
+            }
+        }
+    }
+    return { copy, download, bytes };
+}

package/dist/electron/lockdown.js

@@ -0,0 +1,31 @@
+import { isAllowedNavigation as a, isDevToolsKey as d, debuggerRequested as f, isAllowedExternal as u } from "./lockdownRules.js";
+function g(r, n) {
+  const i = n.log ?? ((...e) => console.log(...e)), t = r.webContents, s = (e, o) => {
+    u(e, n.external) ? n.shell.openExternal(e).catch((c) => i("could not open", e, c)) : i(`refused ${o}:`, e);
+  };
+  t.setWindowOpenHandler(({ url: e }) => (s(e, "external link"), { action: "deny" })), t.on("will-navigate", (e, o) => {
+    a(o, n.devServerUrl) || (e.preventDefault(), s(o, "navigation"));
+  }), t.on("will-redirect", (e, o) => {
+    a(o, n.devServerUrl) || e.preventDefault();
+  });
+  const l = n.devToolsKey === void 0 ? "F12" : n.devToolsKey;
+  t.on("before-input-event", (e, o) => {
+    if (n.packaged) {
+      d(o) && e.preventDefault();
+      return;
+    }
+    l && o.type === "keyDown" && o.key === l && (t.toggleDevTools(), e.preventDefault());
+  });
+}
+function w(r, n = []) {
+  const i = new Set(n);
+  r.setPermissionRequestHandler((t, s, l) => l(i.has(s))), r.setPermissionCheckHandler((t, s) => i.has(s));
+}
+function p(r, n = process.argv, i = (t) => process.exit(t)) {
+  return !r.isPackaged || !f(n, (t) => r.commandLine.hasSwitch(t)) ? !1 : (console.error("[main] refusing to run with a debugger attached"), i(1), !0);
+}
+export {
+  w as denyPermissions,
+  g as lockDownWindow,
+  p as refuseDebugLaunch
+};

package/dist/electron/lockdownRules.js

@@ -0,0 +1,42 @@
+function i(e) {
+  try {
+    return new URL(e);
+  } catch {
+    return null;
+  }
+}
+function g(e, r) {
+  const t = i(e);
+  if (!t || t.protocol !== "https:" || t.username || t.password) return !1;
+  const o = t.hostname.toLowerCase(), s = (r.paths ?? []).filter((n) => n.host.toLowerCase() === o);
+  return s.length ? s.some((n) => t.pathname.toLowerCase().startsWith(n.prefix.toLowerCase())) : r.hosts.some((n) => {
+    const a = n.toLowerCase();
+    return o === a || o.endsWith(`.${a}`);
+  });
+}
+function f(e, r) {
+  const t = i(e);
+  if (!t) return !1;
+  if (r) {
+    const o = i(r);
+    return !!o && t.origin === o.origin;
+  }
+  return t.protocol === "file:";
+}
+function l(e) {
+  if (e.type !== "keyDown") return !1;
+  if (e.key === "F12") return !0;
+  const r = e.key.toLowerCase();
+  return (e.control || e.meta) && (e.shift || e.alt) && (r === "i" || r === "j" || r === "c");
+}
+const c = ["--inspect", "--remote-debugging-port", "--remote-debugging-pipe", "--remote-debugging-address"], u = ["remote-debugging-port", "remote-debugging-pipe", "inspect", "inspect-brk"];
+function d(e, r = () => !1) {
+  return e.some((o) => c.some((s) => o === s || o.startsWith(`${s}=`) || o.startsWith(`${s}-`))) || u.some((o) => r(o));
+}
+export {
+  c as DEBUG_SWITCHES,
+  d as debuggerRequested,
+  g as isAllowedExternal,
+  f as isAllowedNavigation,
+  l as isDevToolsKey
+};

package/dist/electron/sessionStore.js

@@ -0,0 +1,48 @@
+import { promises as r } from "node:fs";
+import { join as n } from "node:path";
+class l {
+  constructor(t) {
+    this.o = t, this.file = n(t.dir, t.fileName ?? "session.bin"), this.maxLength = t.maxLength ?? 4096, this.platform = t.platform ?? process.platform;
+  }
+  o;
+  file;
+  maxLength;
+  platform;
+  /** Whether the OS can encrypt for real here. */
+  canEncrypt() {
+    const t = this.o.safeStorage;
+    return t.isEncryptionAvailable() ? this.platform !== "linux" || t.getSelectedStorageBackend?.() !== "basic_text" : !1;
+  }
+  /** The saved value, or null when there is none, it cannot be decrypted (another OS user, a reinstall) or nothing may be. */
+  async get() {
+    if (!this.canEncrypt()) return null;
+    try {
+      return this.o.safeStorage.decryptString(await r.readFile(this.file));
+    } catch {
+      return null;
+    }
+  }
+  /** Saves `value`; false when it is not a string, too long, or the OS cannot encrypt it. */
+  async set(t) {
+    if (typeof t != "string" || t.length > this.maxLength || !this.canEncrypt()) return !1;
+    const e = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await r.mkdir(this.o.dir, { recursive: !0 }), await r.writeFile(e, this.o.safeStorage.encryptString(t)), await r.rename(e, this.file);
+    } catch (a) {
+      throw await r.rm(e, { force: !0 }), a;
+    }
+    return !0;
+  }
+  async clear() {
+    await r.rm(this.file, { force: !0 });
+  }
+}
+function h(s, t, e = "session") {
+  return s.handle(`${e}:get`, () => t.get()), s.handle(`${e}:set`, (a, i) => t.set(i)), s.handle(`${e}:clear`, () => t.clear()), () => {
+    for (const a of ["get", "set", "clear"]) s.removeHandler?.(`${e}:${a}`);
+  };
+}
+export {
+  l as SessionStore,
+  h as registerSessionStore
+};

package/dist/electron/shellId.js

@@ -0,0 +1,18 @@
+import { createHash as a } from "node:crypto";
+import { readdirSync as f, readFileSync as d } from "node:fs";
+import { join as i } from "node:path";
+function p(n, r) {
+  const o = typeof r == "string" ? { dirs: [r] } : r, s = o.match ?? ((t) => t.endsWith(".cjs")), e = a("sha256");
+  e.update(`electron ${n}
+`);
+  for (const t of o.dirs)
+    for (const c of f(t).filter(s).sort())
+      e.update(`${c}
+`), e.update(d(i(t, c)));
+  for (const t of o.extra ?? []) e.update(`extra ${t}
+`);
+  return e.digest("hex").slice(0, o.length ?? 16);
+}
+export {
+  p as shellId
+};

package/dist/electron/webFiles.js

@@ -0,0 +1,36 @@
+import { createHash as s } from "node:crypto";
+import { readFile as c, mkdir as l, writeFile as u, readdir as f } from "node:fs/promises";
+import { join as r, dirname as h } from "node:path";
+const m = (t) => s("sha256").update(t).digest("hex");
+async function n(t, e = "") {
+  const i = [];
+  for (const a of await f(r(t, e), { withFileTypes: !0 })) {
+    const o = e ? `${e}/${a.name}` : a.name;
+    a.isDirectory() ? i.push(...await n(t, o)) : i.push(o);
+  }
+  return i;
+}
+async function d(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const i of await n(t)) e.set(i, m(await c(r(t, ...i.split("/")))));
+  return e;
+}
+async function F(t, e, i) {
+  const a = r(t, ...e.split("/"));
+  await l(h(a), { recursive: !0 }), await u(a, i);
+}
+async function T(t, e, i) {
+  const a = new AbortController(), o = setTimeout(() => a.abort(), i);
+  try {
+    return await t(e, { signal: a.signal, cache: "no-store" });
+  } finally {
+    clearTimeout(o);
+  }
+}
+export {
+  T as fetchWithTimeout,
+  d as hashWeb,
+  n as listFiles,
+  F as putFile,
+  m as sha256
+};

package/dist/electron/webPatcher.js

@@ -0,0 +1,147 @@
+import { existsSync as b } from "node:fs";
+import { rm as d, mkdir as M, readFile as V, rename as T, readdir as x } from "node:fs/promises";
+import { join as s } from "node:path";
+import { isNewer as y, validManifest as $, fileUrl as U } from "../updates/manifest.js";
+import { planWeb as D } from "../updates/webPlan.js";
+import { fetchWithTimeout as u, hashWeb as E, putFile as g, sha256 as P } from "./webFiles.js";
+import { WebPointers as W } from "./webPointers.js";
+class C {
+  constructor(e) {
+    this.options = e, this.o = {
+      root: e.root,
+      builtinDir: e.builtinDir,
+      appVersion: e.appVersion,
+      channelUrl: e.channelUrl,
+      packaged: e.packaged ?? !0,
+      maxTries: e.maxTries ?? 2,
+      keepPrevious: e.keepPrevious ?? !0,
+      entry: e.entry ?? "index.html",
+      parallel: e.parallel ?? 6,
+      fetchTimeoutMs: e.fetchTimeoutMs ?? 15e3,
+      fetch: e.fetch ?? ((t, i) => globalThis.fetch(t, i)),
+      log: e.log ?? ((...t) => console.error(...t))
+    }, this.pointers = new W(e.root);
+  }
+  options;
+  o;
+  pointers;
+  shellValue = null;
+  /** The web this run loads, and its version (the installed build's own when none is patched in). */
+  loaded = null;
+  /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
+  tidying = Promise.resolve();
+  /** This shell's identity. */
+  get shell() {
+    const e = this.options.shell;
+    return this.shellValue ??= typeof e == "string" ? e : e(), this.shellValue;
+  }
+  /** Where the window loads the page from: a patched web when there is a good one, else the built-in copy. */
+  startEntry() {
+    if (!this.o.packaged)
+      return this.loaded = { dir: this.o.builtinDir, version: this.o.appVersion }, s(this.o.builtinDir, this.o.entry);
+    try {
+      const e = this.pointers.read("pending");
+      this.usable(e) && this.promote(e, 0), this.pointers.write("pending", null);
+      const t = this.pointers.read("active");
+      if (this.usable(t) && (t.booted || t.tries < this.o.maxTries))
+        t.booted || this.pointers.write("active", { ...t, tries: t.tries + 1 }), this.loaded = { dir: s(this.o.root, t.version), version: t.version };
+      else {
+        t && this.pointers.write("active", null);
+        const i = this.pointers.read("previous");
+        this.pointers.write("previous", null), this.o.keepPrevious && i?.booted && this.usable(i) && (this.pointers.write("active", i), this.loaded = { dir: s(this.o.root, i.version), version: i.version });
+      }
+    } catch (e) {
+      this.o.log("[web] could not read the patched web, using the built-in one", e);
+    }
+    return this.loaded ??= { dir: this.o.builtinDir, version: this.o.appVersion }, this.tidying = this.tidy(), s(this.loaded.dir, this.o.entry);
+  }
+  /** The version of the web running now. */
+  webVersion() {
+    return this.loaded?.version ?? this.o.appVersion;
+  }
+  /** The page came up: the web it was loaded from is kept from now on. Call it from the page's own "booted" message. */
+  markBooted() {
+    const e = this.pointers.read("active");
+    e && this.loaded && e.version === this.loaded.version && !e.booted && this.pointers.write("active", { ...e, booted: !0 });
+  }
+  /** The channel's newest build, or null when the store cannot be read. */
+  async latest() {
+    try {
+      const e = await u(this.o.fetch, `${this.o.channelUrl}/latest.json`, this.o.fetchTimeoutMs);
+      if (!e.ok) return null;
+      const t = await e.json();
+      return typeof t?.version == "string" ? t : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Whether `l`'s web can be patched in here rather than installed: newer than the web running, for this shell. */
+  patchable(e) {
+    return !!e.web && e.web.shell === this.shell && y(e.version, this.webVersion());
+  }
+  /**
+   * Builds `l`'s web beside the one running: the files held are copied, the rest downloaded and checked, into
+   * `<version>.part/`, which becomes `<version>/` and the pending web once whole — a crash mid-way never leaves a
+   * folder that looks finished. `onProgress` gets 0–100. Resolves with the version built; throws on any failure.
+   */
+  async prepare(e, t = () => {
+  }) {
+    if (!e.web) throw new Error("no web in this release");
+    const i = await u(this.o.fetch, `${this.o.channelUrl}/${e.web.manifest}`, this.o.fetchTimeoutMs);
+    if (!i.ok) throw new Error(`web manifest ${i.status}`);
+    const o = await i.json();
+    if (!$(o) || o.version !== e.version || o.shell !== this.shell) throw new Error("bad web manifest");
+    const l = s(this.o.root, o.version), p = { version: o.version, shell: o.shell, booted: !1, tries: 0 };
+    if (b(s(l, this.o.entry)) && this.pointers.read("active")?.version !== o.version)
+      return this.pointers.write("pending", p), t(100), o.version;
+    await this.tidying;
+    const f = this.loaded?.dir ?? this.o.builtinDir, h = D(o, await E(f)), n = s(this.o.root, `${o.version}.part`);
+    await d(n, { recursive: !0, force: !0 }), await M(n, { recursive: !0 });
+    for (const r of h.copy) await g(n, r.path, await V(s(f, ...r.from.split("/"))));
+    let v = 0;
+    const w = /* @__PURE__ */ new Map(), m = [...h.download];
+    t(h.bytes ? 0 : 100);
+    const k = async () => {
+      for (let r = m.shift(); r; r = m.shift()) {
+        let a = w.get(r.sha256);
+        if (!a) {
+          const c = await u(this.o.fetch, U(this.o.channelUrl, r.sha256), this.o.fetchTimeoutMs);
+          if (!c.ok) throw new Error(`${r.path}: ${c.status}`);
+          if (a = new Uint8Array(await c.arrayBuffer()), P(a) !== r.sha256) throw new Error(`${r.path}: checksum`);
+          w.set(r.sha256, a), v += r.size, t(Math.min(99, Math.round(v / Math.max(1, h.bytes) * 100)));
+        }
+        await g(n, r.path, a);
+      }
+    };
+    return await Promise.all(Array.from({ length: Math.max(1, this.o.parallel) }, k)), await d(l, { recursive: !0, force: !0 }), await T(n, l), this.pointers.write("pending", p), t(100), o.version;
+  }
+  /**
+   * Puts the pending web in use now and returns the page to load (reload every window from it), or null when there is
+   * none this shell may load. The switch counts as its first start, so a web that never boots is still dropped.
+   */
+  applyPending() {
+    const e = this.pointers.read("pending");
+    return this.usable(e) ? (this.promote(e, 1), this.pointers.write("pending", null), this.loaded = { dir: s(this.o.root, e.version), version: e.version }, s(this.loaded.dir, this.o.entry)) : null;
+  }
+  /** Makes `p` the active web, keeping the one it replaces as the fallback when that one ever booted. */
+  promote(e, t) {
+    const i = this.pointers.read("active");
+    this.o.keepPrevious && i?.booted && i.version !== e.version && this.pointers.write("previous", i), this.pointers.write("active", { ...e, booted: !1, tries: t });
+  }
+  /** A pointer this shell may load: its own shell, newer than the installed build, its folder whole. */
+  usable(e) {
+    return !!e && e.shell === this.shell && y(e.version, this.o.appVersion) && b(s(this.o.root, e.version, this.o.entry));
+  }
+  /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
+  async tidy() {
+    try {
+      const e = ["active", "pending", "previous"], t = new Set([...e.map((i) => this.pointers.read(i)?.version), this.loaded?.version].filter((i) => !!i));
+      for (const i of await x(this.o.root))
+        i.endsWith(".json") || t.has(i) || await d(s(this.o.root, i), { recursive: !0, force: !0 });
+    } catch {
+    }
+  }
+}
+export {
+  C as WebPatcher
+};

package/dist/electron/webPointers.js

@@ -0,0 +1,25 @@
+import { readFileSync as t, mkdirSync as i, writeFileSync as o, rmSync as s } from "node:fs";
+import { join as n } from "node:path";
+class c {
+  constructor(e) {
+    this.root = e;
+  }
+  root;
+  read(e) {
+    try {
+      const r = JSON.parse(t(this.file(e), "utf8"));
+      return typeof r?.version != "string" || typeof r.shell != "string" ? null : { version: r.version, shell: r.shell, booted: r.booted === !0, tries: typeof r.tries == "number" ? r.tries : 0 };
+    } catch {
+      return null;
+    }
+  }
+  write(e, r) {
+    r ? (i(this.root, { recursive: !0 }), o(this.file(e), JSON.stringify(r))) : s(this.file(e), { force: !0 });
+  }
+  file(e) {
+    return n(this.root, `${e}.json`);
+  }
+}
+export {
+  c as WebPointers
+};

package/dist/electron.js

@@ -0,0 +1,19 @@
+import { shellId as r } from "./electron/shellId.js";
+import { WebPatcher as t } from "./electron/webPatcher.js";
+import { SessionStore as l, registerSessionStore as n } from "./electron/sessionStore.js";
+import { DEBUG_SWITCHES as f, debuggerRequested as m, isAllowedExternal as x, isAllowedNavigation as S, isDevToolsKey as a } from "./electron/lockdownRules.js";
+import { denyPermissions as p, lockDownWindow as u, refuseDebugLaunch as w } from "./electron/lockdown.js";
+export {
+  f as DEBUG_SWITCHES,
+  l as SessionStore,
+  t as WebPatcher,
+  m as debuggerRequested,
+  p as denyPermissions,
+  x as isAllowedExternal,
+  S as isAllowedNavigation,
+  a as isDevToolsKey,
+  u as lockDownWindow,
+  w as refuseDebugLaunch,
+  n as registerSessionStore,
+  r as shellId
+};

package/dist/input/haptics.js

@@ -0,0 +1,50 @@
+class n {
+  constructor(t = {}) {
+    this.gaps = t;
+  }
+  gaps;
+  last = /* @__PURE__ */ new Map();
+  /** Whether a buzz of `kind` at `now` (ms) may go; one that may is counted. */
+  allow(t, e) {
+    const r = this.last.get(t), s = this.gaps[t] ?? 0;
+    return r !== void 0 && e - r < s ? !1 : (this.last.set(t, e), !0);
+  }
+  /** Forgets every kind's last buzz. */
+  reset() {
+    this.last.clear();
+  }
+}
+function c(a) {
+  const t = typeof navigator > "u" ? void 0 : navigator;
+  if (typeof t?.vibrate != "function") return !1;
+  try {
+    return t.vibrate(typeof a == "number" ? a : [...a]);
+  } catch {
+    return !1;
+  }
+}
+class i {
+  gate;
+  play;
+  enabled;
+  now;
+  constructor(t = {}) {
+    this.gate = new n(t.gaps), this.play = t.play ?? ((e) => c(t.patterns?.[e] ?? 15)), this.enabled = t.enabled ?? (() => !0), this.now = t.now ?? (() => performance.now());
+  }
+  /** Buzzes for `kind`; returns whether it was let through (not whether the device did buzz). */
+  buzz(t) {
+    if (!this.enabled() || !this.gate.allow(t, this.now())) return !1;
+    try {
+      const e = this.play(t);
+      e && typeof e.catch == "function" && e.catch(() => {
+      });
+    } catch {
+    }
+    return !0;
+  }
+}
+export {
+  n as HapticGate,
+  i as Haptics,
+  c as vibrate
+};

package/dist/net/ApiClient.js

@@ -0,0 +1,96 @@
+import { timeoutSignal as p } from "../platform/timeoutSignal.js";
+class g extends Error {
+  constructor(t, e, r, n, u) {
+    super(r), this.status = t, this.code = e, this.details = n, this.body = u, this.name = "ApiError";
+  }
+  status;
+  code;
+  details;
+  body;
+}
+function y(i) {
+  if (!i || typeof i != "object") return {};
+  const t = i;
+  return {
+    code: typeof t.code == "string" ? t.code : void 0,
+    message: typeof t.message == "string" ? t.message : void 0,
+    details: t.details && typeof t.details == "object" ? t.details : void 0
+  };
+}
+function v(i) {
+  const t = AbortSignal.any;
+  if (typeof t == "function") return t.call(AbortSignal, [...i]);
+  const e = new AbortController();
+  for (const r of i) {
+    if (r.aborted) {
+      e.abort(r.reason);
+      break;
+    }
+    r.addEventListener("abort", () => e.abort(r.reason), { once: !0 });
+  }
+  return e.signal;
+}
+class E {
+  constructor(t) {
+    this.options = t;
+  }
+  options;
+  token = null;
+  /** A new access token for a 401 (`RefreshResult`); unset, a 401 is simply thrown. */
+  refresher = null;
+  /** Called when a 401 ends the session: no refresher, a refused refresh, or a retry refused again. */
+  onUnauthorized = null;
+  get accessToken() {
+    return this.token;
+  }
+  setToken(t) {
+    this.token = t;
+  }
+  /** Sends a request and returns its parsed JSON body (undefined for an empty or unreadable one). */
+  async request(t, e, r, n = {}, u = !1) {
+    const o = this.options, l = { Accept: "application/json", ...o.headers?.(), ...n.headers };
+    r !== void 0 && (l["Content-Type"] = "application/json");
+    const f = this.token;
+    f && (l.Authorization = `Bearer ${f}`);
+    const w = p(n.timeoutMs ?? o.timeoutMs ?? 1e4), b = n.signal ? v([w, n.signal]) : w;
+    let s, h;
+    try {
+      const a = typeof o.baseUrl == "function" ? o.baseUrl(e) : o.baseUrl;
+      s = await (o.fetch ?? fetch)(a + e, {
+        method: t,
+        headers: l,
+        body: r !== void 0 ? JSON.stringify(r) : void 0,
+        signal: b
+      }), h = s.status === 204 ? "" : await s.text();
+    } catch (a) {
+      throw n.signal?.aborted ? new g(0, "ABORTED", "Aborted.") : (console.warn("[api] network error", t, e, a), this.networkError());
+    }
+    let c;
+    if (h)
+      try {
+        c = JSON.parse(h);
+      } catch {
+        c = void 0;
+      }
+    if (s.ok) return c;
+    const d = (o.describe ?? y)(c, s.status), k = new g(s.status, d.code ?? `HTTP_${s.status}`, d.message ?? `HTTP ${s.status}`, d.details, c);
+    if (o.onError?.(k), o.onStatus?.[s.status]?.(k), s.status === 401 && this.token && !u && !o.noRefresh?.(e)) {
+      if (f !== this.token) return this.request(t, e, r, n, !0);
+      if (this.refresher) {
+        const a = await this.refresher().catch(() => null);
+        if (a !== null && a !== "refused")
+          return this.token = a, this.request(t, e, r, n, !0);
+        if (a === null) throw this.networkError();
+      }
+    }
+    throw s.status === 401 && this.token && this.onUnauthorized?.(), k;
+  }
+  networkError() {
+    const t = this.options.networkMessage;
+    return new g(0, "NETWORK", typeof t == "function" ? t() : t ?? "Cannot reach the server.");
+  }
+}
+export {
+  E as ApiClient,
+  g as ApiError
+};

package/dist/pixel/lifeArt.js

@@ -0,0 +1,83 @@
+const F = {
+  leaves: [
+    ["#7ab04e", "#3d7a36"],
+    ["#d8a040", "#9a5a24"]
+  ],
+  seed: ["#f6f2e4", "#c8c2b0"],
+  ember: ["#ffd070", "#ff8a30", "#a8481c"],
+  mote: ["rgba(206,226,240,0.85)", "rgba(150,180,206,0.7)"],
+  ash: [
+    ["#8a827c", "#5c5652"],
+    ["#6e6864", "#3e3a38"]
+  ],
+  butterflies: [
+    ["#f0d050", "#9a7420"],
+    ["#f4f0e8", "#a8a098"],
+    ["#e8883a", "#8a4418"],
+    ["#9ab8f0", "#465e9c"]
+  ],
+  butterflyBody: "#3a2a20",
+  bird: "#2c2830",
+  birdShadow: ["rgba(0,0,0,0.3)", "rgba(0,0,0,0.22)"],
+  firefly: ["#f0ff9a", "#a8c850"],
+  smoke: ["#b8b0b4", "#9a9296", "#7c7478"]
+}, v = 6;
+function L(o, e) {
+  const l = Number.parseInt(o.replace("#", ""), 16);
+  return `rgba(${l >> 16 & 255},${l >> 8 & 255},${l & 255},${e})`;
+}
+function M(o, e = F.smoke) {
+  const l = [[2, 2], [3, 3], [4, 3], [5, 4], [6, 5], [7, 5]], [s, n] = l[Math.max(0, Math.min(v - 1, o))], [b, _, p] = e, h = [], y = (s - 1) / 2, u = (n - 1) / 2, S = o < 3 ? 0.9 : o < 5 ? 0.78 : 0.62;
+  for (let a = 0; a < n; a++)
+    for (let r = 0; r < s; r++) {
+      const $ = (r - y) / (s / 2), m = (a - u) / (n / 2), g = (r * 7 + a * 13 + o * 5) % 5 / 10;
+      if ($ * $ + m * m > 0.85 + g || o >= v - 2 && (r + a + o) % 2) continue;
+      const w = $ + m, d = w < -0.35 ? b : w > 0.45 ? p : _;
+      h.push([r, a, d.startsWith("#") ? L(d, S) : d]);
+    }
+  return { w: s, h: n, px: h };
+}
+function f(o, e, l, s, n) {
+  if (o.exists(e)) return e;
+  const b = document.createElement("canvas");
+  b.width = l, b.height = s;
+  const _ = b.getContext("2d");
+  for (const [p, h, y] of n)
+    _.fillStyle = y, _.fillRect(p, h, 1, 1);
+  return o.addCanvas(e, b), e;
+}
+function R(o, e = {}, l = "life_") {
+  const s = { ...F, ...e }, n = (c) => l + c, b = s.leaves.map(([c, t], i) => [
+    f(o, n(`leaf_${i}_0`), 2, 1, [[0, 0, c], [1, 0, t]]),
+    f(o, n(`leaf_${i}_1`), 2, 2, [[0, 0, c], [1, 1, t]]),
+    f(o, n(`leaf_${i}_2`), 1, 2, [[0, 0, c], [0, 1, t]])
+  ]), _ = [
+    [f(o, n("seed_0"), 1, 1, [[0, 0, s.seed[0]]])],
+    [f(o, n("seed_1"), 2, 1, [[0, 0, s.seed[0]], [1, 0, s.seed[1]]])]
+  ], p = [s.ember.map((c, t) => f(o, n(`ember_${t}`), 1, 1, [[0, 0, c]]))], h = s.mote.map((c, t) => [f(o, n(`mote_${t}`), 1, 1, [[0, 0, c]])]), y = s.ash.map(
+    ([c, t], i) => (
+      // the first flake flat, the next tumbling on its corner
+      [f(o, n(`ash_${i}`), 2, i % 2 ? 2 : 1, i % 2 ? [[0, 0, c], [1, 1, t]] : [[0, 0, c], [1, 0, t]])]
+    )
+  ), u = s.butterflyBody, S = s.butterflies.map(([c, t], i) => [
+    f(o, n(`fly_${i}_o`), 3, 2, [[0, 0, c], [2, 0, c], [1, 0, u], [0, 1, t], [1, 1, u], [2, 1, t]]),
+    f(o, n(`fly_${i}_c`), 3, 2, [[1, 0, c], [1, 1, t]])
+  ]), a = s.bird, r = [
+    f(o, n("bird_0"), 5, 2, [[0, 0, a], [4, 0, a], [1, 1, a], [2, 1, a], [3, 1, a]]),
+    f(o, n("bird_1"), 5, 2, [[0, 1, a], [1, 0, a], [2, 0, a], [3, 0, a], [4, 1, a]])
+  ], [$, m] = s.birdShadow, g = f(o, n("bird_shadow"), 3, 1, [[0, 0, m], [1, 0, $], [2, 0, m]]), [w, d] = s.firefly, A = [
+    f(o, n("firefly_dim"), 3, 3, [[1, 1, d]]),
+    f(o, n("firefly_lit"), 3, 3, [[1, 1, w], [0, 1, d], [2, 1, d], [1, 0, d], [1, 2, d]])
+  ], C = [];
+  for (let c = 0; c < v; c++) {
+    const { w: t, h: i, px: E } = M(c, s.smoke);
+    C.push(f(o, n(`puff_${c}`), t, i, E));
+  }
+  return { leaves: b, seeds: _, embers: p, motes: h, ash: y, butterflies: S, bird: r, birdShadow: g, firefly: A, puffs: C };
+}
+export {
+  F as LIFE_COLORS,
+  v as PUFF_FRAMES,
+  R as paintLifeArt,
+  M as puffPixels
+};