image-to-pixel 3.0.0 → 3.1.0

package/lib/core/export/scale.js

@@ -1,103 +1,103 @@
-// Pure pixel helpers (no DOM): integer upscaling, grid lines, colour counting.
-
-import { parseColor, toHex } from '../color.js';
-
-/**
- * Nearest-neighbour integer upscale.
- * @param {{ width: number, height: number, data: ArrayLike<number> }} img
- * @param {number} k scale factor (integer ≥ 1)
- * @param {{ grid?: boolean, gridColor?: string, gridAlpha?: number }} [opts] grid: 1px lines between source pixels
- */
-export function upscale(img, k = 1, opts = {}) {
-  k = Math.max(1, Math.round(k));
-  const w = img.width * k, h = img.height * k;
-  const out = new Uint8ClampedArray(w * h * 4);
-  const src = img.data, sw = img.width;
-  for (let y = 0; y < h; y++) {
-    const sy = (y / k) | 0;
-    for (let x = 0; x < w; x++) {
-      const so = (sy * sw + ((x / k) | 0)) * 4, o = (y * w + x) * 4;
-      out[o] = src[so]; out[o + 1] = src[so + 1]; out[o + 2] = src[so + 2]; out[o + 3] = src[so + 3];
-    }
-  }
-  if (opts.grid && k >= 3) {
-    const [r, g, b] = parseColor(opts.gridColor || '#000000');
-    const a = opts.gridAlpha ?? 0.35;
-    for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-      if (x % k && y % k) continue;
-      const o = (y * w + x) * 4;
-      const sa = out[o + 3] / 255, oa = a + sa * (1 - a);
-      out[o] = (r * a + out[o] * sa * (1 - a)) / oa;
-      out[o + 1] = (g * a + out[o + 1] * sa * (1 - a)) / oa;
-      out[o + 2] = (b * a + out[o + 2] * sa * (1 - a)) / oa;
-      out[o + 3] = oa * 255;
-    }
-  }
-  return { width: w, height: h, data: out };
-}
-
-/**
- * Nearest-neighbour resize to any size (used to export at the source's resolution, like 2.x's
- * "full resolution" download). Pixels may differ by one in size when the ratio isn't whole.
- */
-export function resizeNearest(img, width, height) {
-  width = Math.max(1, Math.round(width)); height = Math.max(1, Math.round(height));
-  const out = new Uint8ClampedArray(width * height * 4);
-  const xs = new Int32Array(width);
-  for (let x = 0; x < width; x++) xs[x] = Math.min(img.width - 1, Math.floor((x + 0.5) * img.width / width));
-  for (let y = 0; y < height; y++) {
-    const sy = Math.min(img.height - 1, Math.floor((y + 0.5) * img.height / height));
-    for (let x = 0; x < width; x++) {
-      const so = (sy * img.width + xs[x]) * 4, o = (y * width + x) * 4;
-      out[o] = img.data[so]; out[o + 1] = img.data[so + 1]; out[o + 2] = img.data[so + 2]; out[o + 3] = img.data[so + 3];
-    }
-  }
-  return { width, height, data: out };
-}
-
-/** Distinct opaque colours in an image ('#rrggbb'), in order of first appearance. */
-export function uniqueColors(img, limit = Infinity) {
-  const seen = new Set();
-  const d = img.data;
-  for (let o = 0; o < d.length; o += 4) {
-    if (d[o + 3] === 0) continue;
-    seen.add((d[o] << 16) | (d[o + 1] << 8) | d[o + 2]);
-    if (seen.size > limit) break;
-  }
-  return [...seen].map(v => toHex([v >> 16, (v >> 8) & 255, v & 255]));
-}
-
-/** True when the image has at least one non-opaque pixel. */
-export function hasTransparency(img) {
-  for (let o = 3; o < img.data.length; o += 4) if (img.data[o] < 255) return true;
-  return false;
-}
-
-/**
- * Detect the pixel-grid size of an upscaled pixel-art image (e.g. a sprite saved at 4×).
- * Returns the largest block size b such that the image is made of b×b solid blocks
- * (allowing a small tolerance for JPEG noise), or 1.
- */
-export function detectGrid(img, tolerance = 8) {
-  const { width: w, height: h, data: d } = img;
-  const same = (a, b) => Math.abs(d[a] - d[b]) <= tolerance && Math.abs(d[a + 1] - d[b + 1]) <= tolerance && Math.abs(d[a + 2] - d[b + 2]) <= tolerance && Math.abs(d[a + 3] - d[b + 3]) <= tolerance;
-  // run lengths along rows and columns; the block size divides all of them (mostly)
-  const gcd = (a, b) => (b ? gcd(b, a % b) : a);
-  let g = 0;
-  const stepY = Math.max(1, Math.floor(h / 64)), stepX = Math.max(1, Math.floor(w / 64));
-  for (let y = 0; y < h; y += stepY) {
-    let run = 1;
-    for (let x = 1; x < w; x++) {
-      if (same((y * w + x) * 4, (y * w + x - 1) * 4)) run++;
-      else { g = gcd(g, run); run = 1; if (g === 1) return 1; }
-    }
-  }
-  for (let x = 0; x < w; x += stepX) {
-    let run = 1;
-    for (let y = 1; y < h; y++) {
-      if (same((y * w + x) * 4, ((y - 1) * w + x) * 4)) run++;
-      else { g = gcd(g, run); run = 1; if (g === 1) return 1; }
-    }
-  }
-  return g || 1;
-}
+// Pure pixel helpers (no DOM): integer upscaling, grid lines, colour counting.
+
+import { parseColor, toHex } from '../color.js';
+
+/**
+ * Nearest-neighbour integer upscale.
+ * @param {{ width: number, height: number, data: ArrayLike<number> }} img
+ * @param {number} k scale factor (integer ≥ 1)
+ * @param {{ grid?: boolean, gridColor?: string, gridAlpha?: number }} [opts] grid: 1px lines between source pixels
+ */
+export function upscale(img, k = 1, opts = {}) {
+  k = Math.max(1, Math.round(k));
+  const w = img.width * k, h = img.height * k;
+  const out = new Uint8ClampedArray(w * h * 4);
+  const src = img.data, sw = img.width;
+  for (let y = 0; y < h; y++) {
+    const sy = (y / k) | 0;
+    for (let x = 0; x < w; x++) {
+      const so = (sy * sw + ((x / k) | 0)) * 4, o = (y * w + x) * 4;
+      out[o] = src[so]; out[o + 1] = src[so + 1]; out[o + 2] = src[so + 2]; out[o + 3] = src[so + 3];
+    }
+  }
+  if (opts.grid && k >= 3) {
+    const [r, g, b] = parseColor(opts.gridColor || '#000000');
+    const a = opts.gridAlpha ?? 0.35;
+    for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+      if (x % k && y % k) continue;
+      const o = (y * w + x) * 4;
+      const sa = out[o + 3] / 255, oa = a + sa * (1 - a);
+      out[o] = (r * a + out[o] * sa * (1 - a)) / oa;
+      out[o + 1] = (g * a + out[o + 1] * sa * (1 - a)) / oa;
+      out[o + 2] = (b * a + out[o + 2] * sa * (1 - a)) / oa;
+      out[o + 3] = oa * 255;
+    }
+  }
+  return { width: w, height: h, data: out };
+}
+
+/**
+ * Nearest-neighbour resize to any size (used to export at the source's resolution, like 2.x's
+ * "full resolution" download). Pixels may differ by one in size when the ratio isn't whole.
+ */
+export function resizeNearest(img, width, height) {
+  width = Math.max(1, Math.round(width)); height = Math.max(1, Math.round(height));
+  const out = new Uint8ClampedArray(width * height * 4);
+  const xs = new Int32Array(width);
+  for (let x = 0; x < width; x++) xs[x] = Math.min(img.width - 1, Math.floor((x + 0.5) * img.width / width));
+  for (let y = 0; y < height; y++) {
+    const sy = Math.min(img.height - 1, Math.floor((y + 0.5) * img.height / height));
+    for (let x = 0; x < width; x++) {
+      const so = (sy * img.width + xs[x]) * 4, o = (y * width + x) * 4;
+      out[o] = img.data[so]; out[o + 1] = img.data[so + 1]; out[o + 2] = img.data[so + 2]; out[o + 3] = img.data[so + 3];
+    }
+  }
+  return { width, height, data: out };
+}
+
+/** Distinct opaque colours in an image ('#rrggbb'), in order of first appearance. */
+export function uniqueColors(img, limit = Infinity) {
+  const seen = new Set();
+  const d = img.data;
+  for (let o = 0; o < d.length; o += 4) {
+    if (d[o + 3] === 0) continue;
+    seen.add((d[o] << 16) | (d[o + 1] << 8) | d[o + 2]);
+    if (seen.size > limit) break;
+  }
+  return [...seen].map(v => toHex([v >> 16, (v >> 8) & 255, v & 255]));
+}
+
+/** True when the image has at least one non-opaque pixel. */
+export function hasTransparency(img) {
+  for (let o = 3; o < img.data.length; o += 4) if (img.data[o] < 255) return true;
+  return false;
+}
+
+/**
+ * Detect the pixel-grid size of an upscaled pixel-art image (e.g. a sprite saved at 4×).
+ * Returns the largest block size b such that the image is made of b×b solid blocks
+ * (allowing a small tolerance for JPEG noise), or 1.
+ */
+export function detectGrid(img, tolerance = 8) {
+  const { width: w, height: h, data: d } = img;
+  const same = (a, b) => Math.abs(d[a] - d[b]) <= tolerance && Math.abs(d[a + 1] - d[b + 1]) <= tolerance && Math.abs(d[a + 2] - d[b + 2]) <= tolerance && Math.abs(d[a + 3] - d[b + 3]) <= tolerance;
+  // run lengths along rows and columns; the block size divides all of them (mostly)
+  const gcd = (a, b) => (b ? gcd(b, a % b) : a);
+  let g = 0;
+  const stepY = Math.max(1, Math.floor(h / 64)), stepX = Math.max(1, Math.floor(w / 64));
+  for (let y = 0; y < h; y += stepY) {
+    let run = 1;
+    for (let x = 1; x < w; x++) {
+      if (same((y * w + x) * 4, (y * w + x - 1) * 4)) run++;
+      else { g = gcd(g, run); run = 1; if (g === 1) return 1; }
+    }
+  }
+  for (let x = 0; x < w; x += stepX) {
+    let run = 1;
+    for (let y = 1; y < h; y++) {
+      if (same((y * w + x) * 4, ((y - 1) * w + x) * 4)) run++;
+      else { g = gcd(g, run); run = 1; if (g === 1) return 1; }
+    }
+  }
+  return g || 1;
+}

package/lib/core/export/sheet.js

@@ -1,95 +1,95 @@
-// Sprite sheets (many frames → one image + atlas JSON) and tilesets (one image → unique tiles + map).
-
-const blank = (w, h) => ({ width: w, height: h, data: new Uint8ClampedArray(w * h * 4) });
-
-function blit(dst, src, dx, dy, sx = 0, sy = 0, sw = src.width, sh = src.height) {
-  for (let y = 0; y < sh; y++) {
-    const so = ((sy + y) * src.width + sx) * 4, o = ((dy + y) * dst.width + dx) * 4;
-    dst.data.set(src.data.subarray ? src.data.subarray(so, so + sw * 4) : Array.prototype.slice.call(src.data, so, so + sw * 4), o);
-  }
-}
-
-/**
- * Pack frames into a grid. Frames may differ in size; cells use the largest frame.
- * @param {{ width: number, height: number, data: ArrayLike<number>, name?: string, delay?: number }[]} frames
- * @param {{ columns?: number, padding?: number, name?: string }} [opts] columns: 0 = roughly square
- * @returns {{ image: { width, height, data }, atlas: object }}
- */
-export function packSpriteSheet(frames, opts = {}) {
-  if (!frames.length) throw new Error('No frames');
-  const pad = Math.max(0, opts.padding | 0);
-  const cw = Math.max(...frames.map(f => f.width)), ch = Math.max(...frames.map(f => f.height));
-  const cols = Math.max(1, Math.min(frames.length, opts.columns || Math.ceil(Math.sqrt(frames.length))));
-  const rows = Math.ceil(frames.length / cols);
-  const W = cols * cw + (cols - 1) * pad, H = rows * ch + (rows - 1) * pad;
-  const image = blank(W, H);
-  const out = {};
-  frames.forEach((f, i) => {
-    const x = (i % cols) * (cw + pad), y = Math.floor(i / cols) * (ch + pad);
-    blit(image, f, x, y);
-    out[f.name || `frame-${String(i).padStart(3, '0')}`] = {
-      frame: { x, y, w: f.width, h: f.height },
-      sourceSize: { w: f.width, h: f.height },
-      ...(f.delay != null ? { duration: Math.round(f.delay) } : {}),
-    };
-  });
-  // the "hash" flavour of the TexturePacker / Aseprite JSON format, which most engines read
-  const atlas = { frames: out, meta: { app: 'image-to-pixel', image: (opts.name || 'sheet') + '.png', size: { w: W, h: H }, scale: '1', columns: cols, rows, padding: pad } };
-  return { image, atlas };
-}
-
-/**
- * Cut an image into tiles, drop duplicates (optionally counting mirrored tiles as duplicates)
- * and return the tileset image and a tile map.
- * @param {{ width, height, data }} img
- * @param {{ tileWidth?: number, tileHeight?: number, columns?: number, flips?: boolean }} [opts]
- * @returns {{ image, map: { width: number, height: number, tiles: number[], flips?: number[] }, count: number }}
- */
-export function buildTileset(img, opts = {}) {
-  const tw = Math.max(1, opts.tileWidth || 8), th = Math.max(1, opts.tileHeight || tw);
-  const mw = Math.ceil(img.width / tw), mh = Math.ceil(img.height / th);
-  const tiles = [], keys = new Map(), map = [], flipsOut = [];
-  const read = (tx, ty) => {
-    const t = blank(tw, th);
-    for (let y = 0; y < th; y++) for (let x = 0; x < tw; x++) {
-      const sx = tx * tw + x, sy = ty * th + y;
-      if (sx >= img.width || sy >= img.height) continue;
-      const so = (sy * img.width + sx) * 4;
-      t.data.set([img.data[so], img.data[so + 1], img.data[so + 2], img.data[so + 3]], (y * tw + x) * 4);
-    }
-    return t;
-  };
-  const key = t => {
-    let s = '';
-    for (let i = 0; i < t.data.length; i += 4) s += t.data[i + 3] === 0 ? '.' : String.fromCharCode(t.data[i] + 1, t.data[i + 1] + 1, t.data[i + 2] + 1);
-    return s;
-  };
-  const flip = (t, fx, fy) => {
-    const o = blank(tw, th);
-    for (let y = 0; y < th; y++) for (let x = 0; x < tw; x++) {
-      const si = ((fy ? th - 1 - y : y) * tw + (fx ? tw - 1 - x : x)) * 4;
-      o.data.set(t.data.subarray(si, si + 4), (y * tw + x) * 4);
-    }
-    return o;
-  };
-  for (let ty = 0; ty < mh; ty++) {
-    for (let tx = 0; tx < mw; tx++) {
-      const t = read(tx, ty);
-      let id = keys.get(key(t)), f = 0;
-      if (id === undefined && opts.flips) {
-        for (const [fx, fy, code] of [[1, 0, 1], [0, 1, 2], [1, 1, 3]]) {
-          const k = keys.get(key(flip(t, fx, fy)));
-          if (k !== undefined) { id = k; f = code; break; }
-        }
-      }
-      if (id === undefined) { id = tiles.length; tiles.push(t); keys.set(key(t), id); }
-      map.push(id); flipsOut.push(f);
-    }
-  }
-  const sheet = packSpriteSheet(tiles, { columns: opts.columns || Math.min(16, tiles.length) });
-  return {
-    image: sheet.image,
-    map: { width: mw, height: mh, tileWidth: tw, tileHeight: th, tiles: map, ...(opts.flips ? { flips: flipsOut } : {}) },
-    count: tiles.length,
-  };
-}
+// Sprite sheets (many frames → one image + atlas JSON) and tilesets (one image → unique tiles + map).
+
+const blank = (w, h) => ({ width: w, height: h, data: new Uint8ClampedArray(w * h * 4) });
+
+function blit(dst, src, dx, dy, sx = 0, sy = 0, sw = src.width, sh = src.height) {
+  for (let y = 0; y < sh; y++) {
+    const so = ((sy + y) * src.width + sx) * 4, o = ((dy + y) * dst.width + dx) * 4;
+    dst.data.set(src.data.subarray ? src.data.subarray(so, so + sw * 4) : Array.prototype.slice.call(src.data, so, so + sw * 4), o);
+  }
+}
+
+/**
+ * Pack frames into a grid. Frames may differ in size; cells use the largest frame.
+ * @param {{ width: number, height: number, data: ArrayLike<number>, name?: string, delay?: number }[]} frames
+ * @param {{ columns?: number, padding?: number, name?: string }} [opts] columns: 0 = roughly square
+ * @returns {{ image: { width, height, data }, atlas: object }}
+ */
+export function packSpriteSheet(frames, opts = {}) {
+  if (!frames.length) throw new Error('No frames');
+  const pad = Math.max(0, opts.padding | 0);
+  const cw = Math.max(...frames.map(f => f.width)), ch = Math.max(...frames.map(f => f.height));
+  const cols = Math.max(1, Math.min(frames.length, opts.columns || Math.ceil(Math.sqrt(frames.length))));
+  const rows = Math.ceil(frames.length / cols);
+  const W = cols * cw + (cols - 1) * pad, H = rows * ch + (rows - 1) * pad;
+  const image = blank(W, H);
+  const out = {};
+  frames.forEach((f, i) => {
+    const x = (i % cols) * (cw + pad), y = Math.floor(i / cols) * (ch + pad);
+    blit(image, f, x, y);
+    out[f.name || `frame-${String(i).padStart(3, '0')}`] = {
+      frame: { x, y, w: f.width, h: f.height },
+      sourceSize: { w: f.width, h: f.height },
+      ...(f.delay != null ? { duration: Math.round(f.delay) } : {}),
+    };
+  });
+  // the "hash" flavour of the TexturePacker / Aseprite JSON format, which most engines read
+  const atlas = { frames: out, meta: { app: 'image-to-pixel', image: (opts.name || 'sheet') + '.png', size: { w: W, h: H }, scale: '1', columns: cols, rows, padding: pad } };
+  return { image, atlas };
+}
+
+/**
+ * Cut an image into tiles, drop duplicates (optionally counting mirrored tiles as duplicates)
+ * and return the tileset image and a tile map.
+ * @param {{ width, height, data }} img
+ * @param {{ tileWidth?: number, tileHeight?: number, columns?: number, flips?: boolean }} [opts]
+ * @returns {{ image, map: { width: number, height: number, tiles: number[], flips?: number[] }, count: number }}
+ */
+export function buildTileset(img, opts = {}) {
+  const tw = Math.max(1, opts.tileWidth || 8), th = Math.max(1, opts.tileHeight || tw);
+  const mw = Math.ceil(img.width / tw), mh = Math.ceil(img.height / th);
+  const tiles = [], keys = new Map(), map = [], flipsOut = [];
+  const read = (tx, ty) => {
+    const t = blank(tw, th);
+    for (let y = 0; y < th; y++) for (let x = 0; x < tw; x++) {
+      const sx = tx * tw + x, sy = ty * th + y;
+      if (sx >= img.width || sy >= img.height) continue;
+      const so = (sy * img.width + sx) * 4;
+      t.data.set([img.data[so], img.data[so + 1], img.data[so + 2], img.data[so + 3]], (y * tw + x) * 4);
+    }
+    return t;
+  };
+  const key = t => {
+    let s = '';
+    for (let i = 0; i < t.data.length; i += 4) s += t.data[i + 3] === 0 ? '.' : String.fromCharCode(t.data[i] + 1, t.data[i + 1] + 1, t.data[i + 2] + 1);
+    return s;
+  };
+  const flip = (t, fx, fy) => {
+    const o = blank(tw, th);
+    for (let y = 0; y < th; y++) for (let x = 0; x < tw; x++) {
+      const si = ((fy ? th - 1 - y : y) * tw + (fx ? tw - 1 - x : x)) * 4;
+      o.data.set(t.data.subarray(si, si + 4), (y * tw + x) * 4);
+    }
+    return o;
+  };
+  for (let ty = 0; ty < mh; ty++) {
+    for (let tx = 0; tx < mw; tx++) {
+      const t = read(tx, ty);
+      let id = keys.get(key(t)), f = 0;
+      if (id === undefined && opts.flips) {
+        for (const [fx, fy, code] of [[1, 0, 1], [0, 1, 2], [1, 1, 3]]) {
+          const k = keys.get(key(flip(t, fx, fy)));
+          if (k !== undefined) { id = k; f = code; break; }
+        }
+      }
+      if (id === undefined) { id = tiles.length; tiles.push(t); keys.set(key(t), id); }
+      map.push(id); flipsOut.push(f);
+    }
+  }
+  const sheet = packSpriteSheet(tiles, { columns: opts.columns || Math.min(16, tiles.length) });
+  return {
+    image: sheet.image,
+    map: { width: mw, height: mh, tileWidth: tw, tileHeight: th, tiles: map, ...(opts.flips ? { flips: flipsOut } : {}) },
+    count: tiles.length,
+  };
+}

package/lib/core/export/zip.js

@@ -1,55 +1,55 @@
-// Store-only zip writer (PNGs and GIFs are already compressed, so deflating again buys little).
-
-import { crc32 } from './crc32.js';
-
-const enc = new TextEncoder();
-
-/**
- * @param {{ name: string, data: Uint8Array | string, date?: Date }[]} entries
- * @returns {Uint8Array}
- */
-export function createZip(entries) {
-  const files = [], central = [];
-  let offset = 0;
-  const used = new Set();
-  for (const e of entries) {
-    let name = e.name.replace(/\\/g, '/').replace(/^\/+/, '');
-    // avoid duplicate names inside one archive
-    if (used.has(name)) { const m = /^(.*?)(\.[^.]*)?$/.exec(name); let i = 2; while (used.has(`${m[1]}-${i}${m[2] || ''}`)) i++; name = `${m[1]}-${i}${m[2] || ''}`; }
-    used.add(name);
-    const nameBytes = enc.encode(name);
-    const data = typeof e.data === 'string' ? enc.encode(e.data) : e.data;
-    const crc = crc32(data);
-    const d = e.date || new Date();
-    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1);
-    const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
-
-    const local = new Uint8Array(30 + nameBytes.length);
-    const lv = new DataView(local.buffer);
-    lv.setUint32(0, 0x04034b50, true); lv.setUint16(4, 20, true); lv.setUint16(6, 0x0800, true);   // UTF-8 names
-    lv.setUint16(8, 0, true); lv.setUint16(10, time, true); lv.setUint16(12, date, true);
-    lv.setUint32(14, crc, true); lv.setUint32(18, data.length, true); lv.setUint32(22, data.length, true);
-    lv.setUint16(26, nameBytes.length, true); lv.setUint16(28, 0, true);
-    local.set(nameBytes, 30);
-
-    const cen = new Uint8Array(46 + nameBytes.length);
-    const cv = new DataView(cen.buffer);
-    cv.setUint32(0, 0x02014b50, true); cv.setUint16(4, 20, true); cv.setUint16(6, 20, true); cv.setUint16(8, 0x0800, true);
-    cv.setUint16(10, 0, true); cv.setUint16(12, time, true); cv.setUint16(14, date, true);
-    cv.setUint32(16, crc, true); cv.setUint32(20, data.length, true); cv.setUint32(24, data.length, true);
-    cv.setUint16(28, nameBytes.length, true); cv.setUint32(42, offset, true);
-    cen.set(nameBytes, 46);
-
-    files.push(local, data); central.push(cen);
-    offset += local.length + data.length;
-  }
-  const cenSize = central.reduce((s, c) => s + c.length, 0);
-  const end = new Uint8Array(22);
-  const ev = new DataView(end.buffer);
-  ev.setUint32(0, 0x06054b50, true); ev.setUint16(8, entries.length, true); ev.setUint16(10, entries.length, true);
-  ev.setUint32(12, cenSize, true); ev.setUint32(16, offset, true);
-  const out = new Uint8Array(offset + cenSize + 22);
-  let o = 0;
-  for (const p of [...files, ...central, end]) { out.set(p, o); o += p.length; }
-  return out;
-}
+// Store-only zip writer (PNGs and GIFs are already compressed, so deflating again buys little).
+
+import { crc32 } from './crc32.js';
+
+const enc = new TextEncoder();
+
+/**
+ * @param {{ name: string, data: Uint8Array | string, date?: Date }[]} entries
+ * @returns {Uint8Array}
+ */
+export function createZip(entries) {
+  const files = [], central = [];
+  let offset = 0;
+  const used = new Set();
+  for (const e of entries) {
+    let name = e.name.replace(/\\/g, '/').replace(/^\/+/, '');
+    // avoid duplicate names inside one archive
+    if (used.has(name)) { const m = /^(.*?)(\.[^.]*)?$/.exec(name); let i = 2; while (used.has(`${m[1]}-${i}${m[2] || ''}`)) i++; name = `${m[1]}-${i}${m[2] || ''}`; }
+    used.add(name);
+    const nameBytes = enc.encode(name);
+    const data = typeof e.data === 'string' ? enc.encode(e.data) : e.data;
+    const crc = crc32(data);
+    const d = e.date || new Date();
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1);
+    const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+
+    const local = new Uint8Array(30 + nameBytes.length);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, 0x04034b50, true); lv.setUint16(4, 20, true); lv.setUint16(6, 0x0800, true);   // UTF-8 names
+    lv.setUint16(8, 0, true); lv.setUint16(10, time, true); lv.setUint16(12, date, true);
+    lv.setUint32(14, crc, true); lv.setUint32(18, data.length, true); lv.setUint32(22, data.length, true);
+    lv.setUint16(26, nameBytes.length, true); lv.setUint16(28, 0, true);
+    local.set(nameBytes, 30);
+
+    const cen = new Uint8Array(46 + nameBytes.length);
+    const cv = new DataView(cen.buffer);
+    cv.setUint32(0, 0x02014b50, true); cv.setUint16(4, 20, true); cv.setUint16(6, 20, true); cv.setUint16(8, 0x0800, true);
+    cv.setUint16(10, 0, true); cv.setUint16(12, time, true); cv.setUint16(14, date, true);
+    cv.setUint32(16, crc, true); cv.setUint32(20, data.length, true); cv.setUint32(24, data.length, true);
+    cv.setUint16(28, nameBytes.length, true); cv.setUint32(42, offset, true);
+    cen.set(nameBytes, 46);
+
+    files.push(local, data); central.push(cen);
+    offset += local.length + data.length;
+  }
+  const cenSize = central.reduce((s, c) => s + c.length, 0);
+  const end = new Uint8Array(22);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, 0x06054b50, true); ev.setUint16(8, entries.length, true); ev.setUint16(10, entries.length, true);
+  ev.setUint32(12, cenSize, true); ev.setUint32(16, offset, true);
+  const out = new Uint8Array(offset + cenSize + 22);
+  let o = 0;
+  for (const p of [...files, ...central, end]) { out.set(p, o); o += p.length; }
+  return out;
+}