@dotmon/core 0.1.0

package/dist/render/index.d.ts

@@ -0,0 +1,42 @@
+import { F as Frame, V as View, G as GenerateOptions, b as Locale } from '../types-kWKrAd-B.js';
+
+declare function svgToCanvas(svg: string, size: number, background?: string): Promise<HTMLCanvasElement>;
+interface RasterOptions {
+    size?: number;
+    background?: string;
+}
+declare function toPng(svg: string, opts?: RasterOptions): Promise<Blob>;
+
+declare function lzwEncode(minCodeSize: number, indices: Uint8Array): number[];
+declare function encodeGif(w: number, h: number, palette: number[][], transparentIndex: number, frames: Uint8Array[], delayCs: number): Uint8Array;
+interface GifOptions {
+    size?: number;
+    background?: string;
+    delayMs?: number;
+}
+declare function toGif(frames: [string, string], opts?: GifOptions): Promise<Blob>;
+
+declare function crc32(data: Uint8Array): number;
+interface ZipEntry {
+    name: string;
+    data: Uint8Array;
+}
+declare function buildZip(files: ZipEntry[]): Blob;
+
+declare const SHEET_POSES: [string, Frame][];
+declare const SHEET_ROWS: View[];
+interface SpriteSheetResult {
+    png: Blob;
+    json: Record<string, unknown>;
+}
+declare function toSpriteSheet(seed: string, options?: GenerateOptions): Promise<SpriteSheetResult>;
+
+interface AssetZipOptions extends GenerateOptions {
+    background?: string;
+    locale?: Locale;
+}
+declare function toAssetZip(seed: string, options?: AssetZipOptions): Promise<Blob>;
+
+declare function assetReadme(seed: string, locale?: Locale): string;
+
+export { type AssetZipOptions, type GifOptions, type RasterOptions, SHEET_POSES, SHEET_ROWS, type SpriteSheetResult, type ZipEntry, assetReadme, buildZip, crc32, encodeGif, lzwEncode, svgToCanvas, toAssetZip, toGif, toPng, toSpriteSheet };

package/dist/render/index.js

@@ -0,0 +1,348 @@
+import { resolveOptions, SIZE, generateSvg, safeFileName } from '../chunk-QBHMZDDB.js';
+
+// src/render/raster.ts
+function svgToCanvas(svg, size, background = "transparent") {
+  return new Promise((resolve, reject) => {
+    const sized = svg.replace("<svg ", `<svg width="${size}" height="${size}" `);
+    const img = new Image();
+    img.onload = () => {
+      const c = document.createElement("canvas");
+      c.width = size;
+      c.height = size;
+      const ctx = c.getContext("2d");
+      ctx.imageSmoothingEnabled = false;
+      if (background !== "transparent") {
+        ctx.fillStyle = background;
+        ctx.fillRect(0, 0, size, size);
+      }
+      ctx.drawImage(img, 0, 0, size, size);
+      resolve(c);
+    };
+    img.onerror = reject;
+    img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(sized);
+  });
+}
+async function toPng(svg, opts = {}) {
+  const { size = 512, background = "transparent" } = opts;
+  const c = await svgToCanvas(svg, size, background);
+  return new Promise((res) => c.toBlob((b) => res(b), "image/png"));
+}
+async function pngBytes(svg, size, background) {
+  const blob = await toPng(svg, { size, background });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+
+// src/render/gif.ts
+function lzwEncode(minCodeSize, indices) {
+  const CLEAR = 1 << minCodeSize;
+  const EOI = CLEAR + 1;
+  let dict;
+  let nextCode = 0;
+  let codeSize = 0;
+  const out = [];
+  let bitBuf = 0;
+  let bitLen = 0;
+  const emit = (code) => {
+    bitBuf |= code << bitLen;
+    bitLen += codeSize;
+    while (bitLen >= 8) {
+      out.push(bitBuf & 255);
+      bitBuf >>= 8;
+      bitLen -= 8;
+    }
+  };
+  const init = () => {
+    dict = /* @__PURE__ */ new Map();
+    for (let i = 0; i < CLEAR; i++) dict.set(String(i), i);
+    nextCode = EOI + 1;
+    codeSize = minCodeSize + 1;
+  };
+  init();
+  emit(CLEAR);
+  let prefix = String(indices[0]);
+  for (let i = 1; i < indices.length; i++) {
+    const k = indices[i];
+    const key = prefix + "," + k;
+    if (dict.has(key)) {
+      prefix = key;
+      continue;
+    }
+    emit(dict.get(prefix));
+    if (nextCode < 4096) {
+      dict.set(key, nextCode);
+      if (nextCode === 1 << codeSize && codeSize < 12) codeSize++;
+      nextCode++;
+    } else {
+      emit(CLEAR);
+      init();
+    }
+    prefix = String(k);
+  }
+  emit(dict.get(prefix));
+  emit(EOI);
+  if (bitLen > 0) out.push(bitBuf & 255);
+  return out;
+}
+function encodeGif(w, h, palette, transparentIndex, frames, delayCs) {
+  const bytes = [];
+  const put = (b) => bytes.push(b & 255);
+  const put16 = (v) => {
+    put(v);
+    put(v >> 8);
+  };
+  const putStr = (s) => {
+    for (let i = 0; i < s.length; i++) put(s.charCodeAt(i));
+  };
+  let bits = 1;
+  while (1 << bits < palette.length) bits++;
+  putStr("GIF89a");
+  put16(w);
+  put16(h);
+  put(128 | 112 | bits - 1);
+  put(0);
+  put(0);
+  for (let i = 0; i < 1 << bits; i++) {
+    const c = palette[i] || [0, 0, 0];
+    put(c[0]);
+    put(c[1]);
+    put(c[2]);
+  }
+  put(33);
+  put(255);
+  put(11);
+  putStr("NETSCAPE2.0");
+  put(3);
+  put(1);
+  put16(0);
+  put(0);
+  const minCode = Math.max(2, bits);
+  for (const indices of frames) {
+    put(33);
+    put(249);
+    put(4);
+    put(2 << 2 | (transparentIndex >= 0 ? 1 : 0));
+    put16(delayCs);
+    put(transparentIndex >= 0 ? transparentIndex : 0);
+    put(0);
+    put(44);
+    put16(0);
+    put16(0);
+    put16(w);
+    put16(h);
+    put(0);
+    put(minCode);
+    const data = lzwEncode(minCode, indices);
+    for (let i = 0; i < data.length; i += 255) {
+      const n = Math.min(255, data.length - i);
+      put(n);
+      for (let j = 0; j < n; j++) put(data[i + j]);
+    }
+    put(0);
+  }
+  put(59);
+  return new Uint8Array(bytes);
+}
+async function toGif(frames, opts = {}) {
+  const { size = 256, background = "transparent", delayMs = 400 } = opts;
+  const bytes = await gifBytes(frames[0], frames[1], size, background, Math.round(delayMs / 10));
+  return new Blob([bytes], { type: "image/gif" });
+}
+async function gifBytes(svgA, svgB, px, bg, delayCs = 40) {
+  const canvases = [await svgToCanvas(svgA, px, bg), await svgToCanvas(svgB, px, bg)];
+  const palette = [];
+  const cmap = /* @__PURE__ */ new Map();
+  let transparentIndex = -1;
+  if (bg === "transparent") {
+    transparentIndex = 0;
+    palette.push([0, 0, 0]);
+  }
+  const frames = canvases.map((c) => {
+    const d = c.getContext("2d").getImageData(0, 0, px, px).data;
+    const out = new Uint8Array(px * px);
+    for (let i = 0; i < px * px; i++) {
+      const r = d[i * 4], gr = d[i * 4 + 1], bl = d[i * 4 + 2], a = d[i * 4 + 3];
+      if (a < 128 && transparentIndex >= 0) {
+        out[i] = transparentIndex;
+        continue;
+      }
+      const key = r << 16 | gr << 8 | bl;
+      let idx = cmap.get(key);
+      if (idx === void 0) {
+        idx = palette.length;
+        palette.push([r, gr, bl]);
+        cmap.set(key, idx);
+      }
+      out[i] = idx;
+    }
+    return out;
+  });
+  return encodeGif(px, px, palette, transparentIndex, frames, delayCs);
+}
+
+// src/render/zip.ts
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c;
+  }
+  return t;
+})();
+function crc32(data) {
+  let c = 4294967295;
+  for (let i = 0; i < data.length; i++) c = CRC_TABLE[(c ^ data[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function buildZip(files) {
+  const enc = new TextEncoder();
+  const u16 = (v) => [v & 255, v >> 8 & 255];
+  const u32 = (v) => [v & 255, v >>> 8 & 255, v >>> 16 & 255, v >>> 24 & 255];
+  const now = /* @__PURE__ */ new Date();
+  const dosTime = (now.getHours() << 11 | now.getMinutes() << 5 | now.getSeconds() >> 1) & 65535;
+  const dosDate = (now.getFullYear() - 1980 << 9 | now.getMonth() + 1 << 5 | now.getDate()) & 65535;
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const f of files) {
+    const name = enc.encode(f.name);
+    const crc = crc32(f.data);
+    const head = new Uint8Array([80, 75, 3, 4, ...u16(20), ...u16(2048), ...u16(0), ...u16(dosTime), ...u16(dosDate), ...u32(crc), ...u32(f.data.length), ...u32(f.data.length), ...u16(name.length), ...u16(0)]);
+    chunks.push(head, name, f.data);
+    central.push({ name, crc, size: f.data.length, offset });
+    offset += head.length + name.length + f.data.length;
+  }
+  const cd = [];
+  let cdSize = 0;
+  for (const c of central) {
+    const rec = new Uint8Array([80, 75, 1, 2, ...u16(20), ...u16(20), ...u16(2048), ...u16(0), ...u16(dosTime), ...u16(dosDate), ...u32(c.crc), ...u32(c.size), ...u32(c.size), ...u16(c.name.length), ...u16(0), ...u16(0), ...u16(0), ...u16(0), ...u32(0), ...u32(c.offset)]);
+    cd.push(rec, c.name);
+    cdSize += rec.length + c.name.length;
+  }
+  const eocd = new Uint8Array([80, 75, 5, 6, ...u16(0), ...u16(0), ...u16(files.length), ...u16(files.length), ...u32(cdSize), ...u32(offset), ...u16(0)]);
+  const parts = [...chunks, ...cd, eocd].map((p) => p instanceof Uint8Array ? p : new Uint8Array(p));
+  return new Blob(parts, { type: "application/zip" });
+}
+
+// src/render/sheet.ts
+var SHEET_POSES = [
+  ["idle", 0],
+  ["walk1", 1],
+  ["walk2", 2]
+];
+var SHEET_ROWS = ["front", "left", "right", "back"];
+async function toSpriteSheet(seed, options = {}) {
+  const o = resolveOptions(options);
+  const cell = SIZE;
+  const sheet = document.createElement("canvas");
+  sheet.width = cell * SHEET_POSES.length;
+  sheet.height = cell * SHEET_ROWS.length;
+  const ctx = sheet.getContext("2d");
+  ctx.imageSmoothingEnabled = false;
+  const frames = {};
+  const animations = {};
+  for (let r = 0; r < SHEET_ROWS.length; r++) {
+    const view = SHEET_ROWS[r];
+    for (let c = 0; c < SHEET_POSES.length; c++) {
+      const [pose, frame] = SHEET_POSES[c];
+      const cellCanvas = await svgToCanvas(generateSvg(seed, { ...o, view, frame }).svg, cell, "transparent");
+      ctx.drawImage(cellCanvas, c * cell, r * cell);
+      frames[`${view}_${pose}`] = {
+        frame: { x: c * cell, y: r * cell, w: cell, h: cell },
+        rotated: false,
+        trimmed: false,
+        spriteSourceSize: { x: 0, y: 0, w: cell, h: cell },
+        sourceSize: { w: cell, h: cell }
+      };
+    }
+    animations[`idle_${view}`] = [`${view}_idle`];
+    animations[`walk_${view}`] = [`${view}_walk1`, `${view}_walk2`];
+  }
+  const json = {
+    frames,
+    animations,
+    meta: {
+      app: "dotmon",
+      seed,
+      image: "sheet.png",
+      format: "RGBA8888",
+      size: { w: sheet.width, h: sheet.height },
+      scale: "1",
+      grid: { cols: SHEET_POSES.length, rows: SHEET_ROWS.length, cellW: cell, cellH: cell },
+      rowOrder: SHEET_ROWS,
+      colOrder: SHEET_POSES.map((p) => p[0]),
+      note: "Pixel art: scale with nearest neighbor. Walk = alternate walk1/walk2 (~400ms). Sheet is always transparent."
+    }
+  };
+  const png = await new Promise((res) => sheet.toBlob((b) => res(b), "image/png"));
+  return { png, json };
+}
+
+// src/render/readme.ts
+function assetReadme(seed, locale = "en") {
+  if (locale === "ja") {
+    return `${seed} \u306E\u30E2\u30F3\u30B9\u30BF\u30FC\u30BB\u30C3\u30C8
+=========================
+\u3053\u306EZIP\u306B\u306F\u3001\u30B2\u30FC\u30E0\u3084\u30A2\u30A4\u30B3\u30F3\u306B\u305D\u306E\u307E\u307E\u4F7F\u3048\u308B\u753B\u50CF\u304C\u5165\u3063\u3066\u3044\u307E\u3059\u3002
+
+\u25A0 \u500B\u5225\u753B\u50CF\uFF08512px / \u4FDD\u5B58\u6642\u306E\u80CC\u666F\u8A2D\u5B9A\u3064\u304D\uFF09
+  front_idle.png / front_walk1.png / front_walk2.png \u2026 \u307E\u3048\u5411\u304D\u306E \u7ACB\u3061\u30FB\u6B69\u304D1\u30FB\u6B69\u304D2
+  \u540C\u3058\u7D44\u307F\u5408\u308F\u305B\u304C back\uFF08\u3046\u3057\u308D\uFF09/ left\uFF08\u3072\u3060\u308A\uFF09/ right\uFF08\u307F\u304E\uFF09\u306B\u3082\u3042\u308A\u307E\u3059\uFF08\u8A0812\u679A\uFF09
+
+\u25A0 \u52D5\u304FGIF\uFF08256px\u30FB2\u30B3\u30DE\u30FB\u7121\u9650\u30EB\u30FC\u30D7\uFF09
+  front.gif / back.gif / left.gif / right.gif
+
+\u25A0 \u30B2\u30FC\u30E0\u7528\u30B9\u30D7\u30E9\u30A4\u30C8\u30B7\u30FC\u30C8
+  sheet.png  \u2026 16px\u30C9\u30C3\u30C8\u539F\u5BF8\u30FB3\u5217\xD74\u884C\uFF08\u5217: \u7ACB\u3061/\u6B69\u304D1/\u6B69\u304D2\u3001\u884C: \u307E\u3048/\u3072\u3060\u308A/\u307F\u304E/\u3046\u3057\u308D\uFF09
+  sheet.json \u2026 \u5404\u30B3\u30DE\u306E\u5EA7\u6A19\u3068\u30A2\u30CB\u30E1\u5B9A\u7FA9\uFF08TexturePacker\u4E92\u63DB\u3002Phaser / PixiJS \u3067\u305D\u306E\u307E\u307E\u8AAD\u3081\u307E\u3059\uFF09
+
+\u203B\u30C9\u30C3\u30C8\u7D75\u306A\u306E\u3067\u3001\u62E1\u5927\u3059\u308B\u3068\u304D\u306F\u300C\u307C\u304B\u3057\u306A\u3057\uFF08nearest neighbor\uFF09\u300D\u3092\u9078\u3076\u3068\u304D\u308C\u3044\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002
+`;
+  }
+  return `Monster asset set for "${seed}"
+=========================
+This ZIP contains images ready to use in games or as icons.
+
+- Individual PNGs (512px, with your background setting)
+  front_idle.png / front_walk1.png / front_walk2.png = front-facing idle / walk 1 / walk 2
+  The same set exists for back / left / right (12 images total)
+
+- Animated GIFs (256px, 2 frames, infinite loop)
+  front.gif / back.gif / left.gif / right.gif
+
+- Game sprite sheet
+  sheet.png  = native 16px pixels, 3 cols x 4 rows (cols: idle/walk1/walk2, rows: front/left/right/back)
+  sheet.json = frame coordinates + animation definitions (TexturePacker compatible; loads directly in Phaser / PixiJS)
+
+Tip: this is pixel art \u2014 scale it up with "nearest neighbor" (no smoothing) for crisp results.
+`;
+}
+
+// src/render/assetZip.ts
+var VIEWS = ["front", "back", "left", "right"];
+async function toAssetZip(seed, options = {}) {
+  const { background = "transparent", locale = "en", ...genOptions } = options;
+  const o = resolveOptions(genOptions);
+  const dir = safeFileName(seed);
+  const files = [];
+  files.push({ name: `${dir}/README.txt`, data: new TextEncoder().encode(assetReadme(seed, locale)) });
+  for (const view of VIEWS) {
+    for (const [pose, frame] of SHEET_POSES) {
+      files.push({
+        name: `${dir}/${view}_${pose}.png`,
+        data: await pngBytes(generateSvg(seed, { ...o, view, frame }).svg, 512, background)
+      });
+    }
+    const gif = await toGif(
+      [generateSvg(seed, { ...o, view, frame: 1 }).svg, generateSvg(seed, { ...o, view, frame: 2 }).svg],
+      { size: 256, background }
+    );
+    files.push({ name: `${dir}/${view}.gif`, data: new Uint8Array(await gif.arrayBuffer()) });
+  }
+  const sheet = await toSpriteSheet(seed, o);
+  files.push({ name: `${dir}/sheet.png`, data: new Uint8Array(await sheet.png.arrayBuffer()) });
+  files.push({ name: `${dir}/sheet.json`, data: new TextEncoder().encode(JSON.stringify(sheet.json, null, 2)) });
+  return buildZip(files);
+}
+
+export { SHEET_POSES, SHEET_ROWS, assetReadme, buildZip, crc32, encodeGif, lzwEncode, svgToCanvas, toAssetZip, toGif, toPng, toSpriteSheet };

package/dist/stats-BMnyxbee.d.ts

@@ -0,0 +1,17 @@
+import { G as GenerateOptions } from './types-kWKrAd-B.js';
+
+declare const NATURE_IDS: readonly ["cheerful", "easygoing", "timid", "stubborn", "headstrong", "gentle", "playful", "calm", "shy", "hungry", "sleepyhead", "whimsical"];
+type NatureId = (typeof NATURE_IDS)[number];
+interface Stats {
+    lv: number;
+    nature: NatureId;
+    hp: number;
+    mp: number;
+    atk: number;
+    def: number;
+    spd: number;
+    luck: number;
+}
+declare function getStats(seed: string, options?: GenerateOptions): Stats;
+
+export { NATURE_IDS as N, type Stats as S, type NatureId as a, getStats as g };

package/dist/stats-Cs0yRJTk.d.cts

@@ -0,0 +1,17 @@
+import { G as GenerateOptions } from './types-kWKrAd-B.cjs';
+
+declare const NATURE_IDS: readonly ["cheerful", "easygoing", "timid", "stubborn", "headstrong", "gentle", "playful", "calm", "shy", "hungry", "sleepyhead", "whimsical"];
+type NatureId = (typeof NATURE_IDS)[number];
+interface Stats {
+    lv: number;
+    nature: NatureId;
+    hp: number;
+    mp: number;
+    atk: number;
+    def: number;
+    spd: number;
+    luck: number;
+}
+declare function getStats(seed: string, options?: GenerateOptions): Stats;
+
+export { NATURE_IDS as N, type Stats as S, type NatureId as a, getStats as g };

package/dist/types-CsVv0MnX.d.cts

@@ -0,0 +1,12 @@
+import { a as NatureId } from './stats-Cs0yRJTk.cjs';
+import { c as Legs, P as Preset } from './types-kWKrAd-B.cjs';
+
+interface LocaleDict {
+    natures: Record<NatureId, string>;
+    stats: Record<"lv" | "hp" | "mp" | "atk" | "def" | "spd" | "luck", string>;
+    legs: Record<Legs, string>;
+    presets: Record<Preset, string>;
+    presetDescriptions: Record<Preset, string>;
+}
+
+export type { LocaleDict as L };

package/dist/types-DYNij_HS.d.ts

@@ -0,0 +1,12 @@
+import { a as NatureId } from './stats-BMnyxbee.js';
+import { c as Legs, P as Preset } from './types-kWKrAd-B.js';
+
+interface LocaleDict {
+    natures: Record<NatureId, string>;
+    stats: Record<"lv" | "hp" | "mp" | "atk" | "def" | "spd" | "luck", string>;
+    legs: Record<Legs, string>;
+    presets: Record<Preset, string>;
+    presetDescriptions: Record<Preset, string>;
+}
+
+export type { LocaleDict as L };

package/dist/types-kWKrAd-B.d.cts

@@ -0,0 +1,27 @@
+type Preset = "mochi" | "retro" | "chaos";
+type Legs = "auto" | "none" | "two" | "many";
+type LegStyle = "none" | "two" | "many";
+type View = "front" | "back" | "left" | "right";
+type Frame = 0 | 1 | 2;
+type Locale = "en" | "ja";
+/** 解決済みの生成オプション（決定論の入力単位） */
+interface ResolvedOpts {
+    connected: boolean;
+    symmetric: boolean;
+    outline: boolean;
+    face: boolean;
+    legs: Legs;
+}
+/** 公開APIのオプション: preset + 個別上書き + view/frame */
+interface GenerateOptions extends Partial<ResolvedOpts> {
+    preset?: Preset;
+    view?: View;
+    frame?: Frame;
+}
+interface GenerateResult {
+    svg: string;
+    drawnLegStyle: LegStyle;
+    size: 16;
+}
+
+export type { Frame as F, GenerateOptions as G, LegStyle as L, Preset as P, ResolvedOpts as R, View as V, GenerateResult as a, Locale as b, Legs as c };

package/dist/types-kWKrAd-B.d.ts

@@ -0,0 +1,27 @@
+type Preset = "mochi" | "retro" | "chaos";
+type Legs = "auto" | "none" | "two" | "many";
+type LegStyle = "none" | "two" | "many";
+type View = "front" | "back" | "left" | "right";
+type Frame = 0 | 1 | 2;
+type Locale = "en" | "ja";
+/** 解決済みの生成オプション（決定論の入力単位） */
+interface ResolvedOpts {
+    connected: boolean;
+    symmetric: boolean;
+    outline: boolean;
+    face: boolean;
+    legs: Legs;
+}
+/** 公開APIのオプション: preset + 個別上書き + view/frame */
+interface GenerateOptions extends Partial<ResolvedOpts> {
+    preset?: Preset;
+    view?: View;
+    frame?: Frame;
+}
+interface GenerateResult {
+    svg: string;
+    drawnLegStyle: LegStyle;
+    size: 16;
+}
+
+export type { Frame as F, GenerateOptions as G, LegStyle as L, Preset as P, ResolvedOpts as R, View as V, GenerateResult as a, Locale as b, Legs as c };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@dotmon/core",
+  "version": "0.1.0",
+  "description": "Turn any name into a unique pixel-art monster. Deterministic, animated, zero dependencies.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dotmon-org/dotmon.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./render": {
+      "types": "./dist/render/index.d.ts",
+      "import": "./dist/render/index.js",
+      "require": "./dist/render/index.cjs"
+    },
+    "./locales": {
+      "types": "./dist/locales/index.d.ts",
+      "import": "./dist/locales/index.js",
+      "require": "./dist/locales/index.cjs"
+    },
+    "./locales/en": {
+      "types": "./dist/locales/en.d.ts",
+      "import": "./dist/locales/en.js",
+      "require": "./dist/locales/en.cjs"
+    },
+    "./locales/ja": {
+      "types": "./dist/locales/ja.d.ts",
+      "import": "./dist/locales/ja.js",
+      "require": "./dist/locales/ja.cjs"
+    }
+  },
+  "keywords": [
+    "avatar",
+    "pixel-art",
+    "monster",
+    "generator",
+    "deterministic",
+    "sprite",
+    "svg"
+  ],
+  "devDependencies": {
+    "@types/node": "^22",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "golden:update": "node --experimental-strip-types scripts/update-golden.ts"
+  }
+}