@alexislours/ltd-sharemii 1.0.0

package/dist/index.js

@@ -0,0 +1,1230 @@
+// src/sidecar.ts
+var EMPTY_SIDECAR = {
+  origin: "none",
+  files: /* @__PURE__ */ new Map()
+};
+function normalizeName(name) {
+  const idx = Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\"));
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function isSidecarFileName(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith(".canvas.zs") || lower.endsWith(".ugctex.zs");
+}
+function isJunkArchiveEntry(path) {
+  if (!path) return true;
+  if (path.endsWith("/") || path.endsWith("\\")) return true;
+  if (path.includes("__MACOSX/") || path.includes("__MACOSX\\")) return true;
+  const idx = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  const base = idx >= 0 ? path.slice(idx + 1) : path;
+  if (!base || base.startsWith(".")) return true;
+  return false;
+}
+
+// src/errors.ts
+var ShareMiiError = class extends Error {
+  code;
+  params;
+  constructor(code, params = {}) {
+    super(code);
+    this.name = "ShareMiiError";
+    this.code = code;
+    this.params = params;
+  }
+};
+
+// src/utf16.ts
+function decodeUtf16Name(buf) {
+  let end = 0;
+  while (end + 1 < buf.byteLength) {
+    if (buf[end] === 0 && buf[end + 1] === 0) break;
+    end += 2;
+  }
+  const code = [];
+  for (let i = 0; i < end; i += 2) {
+    code.push(buf[i] | buf[i + 1] << 8);
+  }
+  return String.fromCharCode(...code);
+}
+function sanitizeFileName(name) {
+  const cleaned = name.replace(/[^\w.-]/g, "_");
+  return cleaned.length > 0 ? cleaned : "mii";
+}
+function encodeUtf16Name(text, byteLen) {
+  const out = new Uint8Array(byteLen);
+  const maxChars = Math.floor((byteLen - 2) / 2);
+  const truncated = text.length > maxChars ? text.slice(0, maxChars) : text;
+  for (let i = 0; i < truncated.length; i++) {
+    const code = truncated.charCodeAt(i);
+    out[i * 2] = code & 255;
+    out[i * 2 + 1] = code >> 8 & 255;
+  }
+  return out;
+}
+
+// src/ugcKinds.ts
+var UGC_KINDS = [
+  "Food",
+  "Cloth",
+  "Goods",
+  "Interior",
+  "Exterior",
+  "MapObject",
+  "MapFloor"
+];
+var UGC_DISPLAY_LABELS = {
+  Food: "Food",
+  Cloth: "Clothing",
+  Goods: "Treasure",
+  Interior: "Interior",
+  Exterior: "Exterior",
+  MapObject: "Objects",
+  MapFloor: "Landscaping"
+};
+var UGC_FILE_EXTENSIONS = {
+  Food: ".ltdf",
+  Cloth: ".ltdc",
+  Goods: ".ltdg",
+  Interior: ".ltdi",
+  Exterior: ".ltde",
+  MapObject: ".ltdo",
+  MapFloor: ".ltdl"
+};
+function ugcKindIndex(kind) {
+  return UGC_KINDS.indexOf(kind);
+}
+var UGC_MAX_SLOTS = {
+  Food: 99,
+  Cloth: 299,
+  Goods: 99,
+  Interior: 99,
+  Exterior: 99,
+  MapObject: 99,
+  MapFloor: 99
+};
+function ugcFileBase(kind, slot) {
+  return `Ugc${kind}${String(slot).padStart(3, "0")}`;
+}
+function ugcCanvasFileName(kind, slot) {
+  return `${ugcFileBase(kind, slot)}.canvas.zs`;
+}
+function ugcTexFileName(kind, slot) {
+  return `${ugcFileBase(kind, slot)}.ugctex.zs`;
+}
+function ugcThumbFileName(kind, slot) {
+  return `${ugcFileBase(kind, slot)}_Thumb.ugctex.zs`;
+}
+function facepaintFileBase(id) {
+  return `UgcFacePaint${String(id).padStart(3, "0")}`;
+}
+function facepaintCanvasFileName(id) {
+  return `${facepaintFileBase(id)}.canvas.zs`;
+}
+function facepaintTexFileName(id) {
+  return `${facepaintFileBase(id)}.ugctex.zs`;
+}
+var UGC_HASHES = {
+  Food: {
+    fields: [
+      813690618,
+      1871970237,
+      1554592622,
+      4150813194,
+      1525697515,
+      766601413,
+      1665663150,
+      3717033050,
+      2937161423,
+      1491512019
+    ],
+    names: [1082430709, 3121564591]
+  },
+  Cloth: {
+    fields: [
+      3356837374,
+      800658541,
+      2050092951,
+      2129409513,
+      1580399935,
+      230342183,
+      1902255256,
+      757535545,
+      3455262389,
+      673438675
+    ],
+    names: [1081148994, 3482981354]
+  },
+  Goods: {
+    fields: [
+      1068114466,
+      2185200279,
+      2127333984,
+      2296126787,
+      2291588566,
+      3220345970,
+      1570133858,
+      2027131400,
+      1405575856,
+      1087555326,
+      3232153670,
+      2922855181,
+      2103442359,
+      2660732766,
+      4130642217,
+      2419641808,
+      2589586826
+    ],
+    names: [796475057, 4132811578, 4083833355, 2791532523],
+    vector: 4083961384
+  },
+  Interior: {
+    fields: [
+      2836489218,
+      2203129025,
+      3966100196,
+      175960773,
+      1714214919,
+      28534302,
+      1525981343,
+      1107239425
+    ],
+    names: [1038271965, 2242083728]
+  },
+  Exterior: {
+    fields: [
+      3986018063,
+      1140132282,
+      2812311356,
+      2812311356,
+      884629785,
+      1584308108,
+      688373824,
+      2542165355,
+      1621039485,
+      1201997093,
+      1911191348
+    ],
+    names: [667448790, 236315640],
+    vector: 1007944286,
+    vector2: 3117554511
+  },
+  MapObject: {
+    fields: [
+      658921937,
+      3706201852,
+      3763215979,
+      91172640,
+      3162340912,
+      1009501487,
+      3489582274,
+      1544938297,
+      1593794062,
+      2553816651,
+      1215794662,
+      1655525687,
+      3518214551
+    ],
+    names: [1459196728, 4002552546],
+    vector: 670231774,
+    vector2: 798367803
+  },
+  MapFloor: {
+    fields: [
+      567640793,
+      3732715812,
+      3904736393,
+      3277556495,
+      1625456891,
+      2126742378,
+      4060734201,
+      1837378252
+    ],
+    names: [2441639337, 1345622240]
+  }
+};
+var UGC_ENABLE_HASHES = {
+  Food: 4104362341,
+  Cloth: 2937232435,
+  Goods: 446431486,
+  Interior: 2744599785,
+  Exterior: 4106137026,
+  MapObject: 1498481931,
+  MapFloor: 2702339378
+};
+var UGC_TEXTURE_HASHES = {
+  Food: 895006591,
+  Cloth: 1505733075,
+  Goods: 1892747848,
+  Interior: 3891909689,
+  Exterior: 371358800,
+  MapObject: 2848313272,
+  MapFloor: 111649100
+};
+var UGC_HASH_ID_HASHES = {
+  Food: 1833498850,
+  Cloth: 2314362028,
+  Goods: 1444946176,
+  Interior: 2146402173,
+  Exterior: 953624469,
+  MapObject: 455651696,
+  MapFloor: 2171424931
+};
+var UGC_TEX_DATA = new Uint8Array([
+  65,
+  73,
+  147,
+  86,
+  227,
+  194,
+  47,
+  180,
+  65,
+  73,
+  147,
+  86,
+  227,
+  194,
+  47,
+  180,
+  227,
+  194,
+  47,
+  180,
+  227,
+  194,
+  47,
+  180,
+  227,
+  194,
+  47,
+  180
+]);
+var UGC_HASH_INDICES = {
+  Food: 1,
+  Cloth: 3,
+  Goods: 2,
+  Interior: 6,
+  Exterior: 7,
+  MapObject: 4,
+  MapFloor: 5
+};
+var FACEPAINT_HASHES = {
+  price: 1285036516,
+  textureSourceType: 3737946452,
+  state: 588471237,
+  unknown: 4291252406,
+  hash: 2775466732
+};
+var MII_HASHES = {
+  facePaintIndex: 1580379636,
+  tempSlotMii: 290389897,
+  names: 614055898,
+  pronunciation: 979294725,
+  rawMii: 2283577978,
+  isLoveGender: 3754435107,
+  satisfyLevel: 2576988121,
+  personality: [
+    1137522255,
+    3448617720,
+    632586788,
+    1618714976,
+    1759581006,
+    1226026522,
+    337567878,
+    129618293,
+    2177845002,
+    1299767906,
+    4223926192,
+    594423155,
+    4089699929,
+    1712083527,
+    1568489285,
+    2878005387,
+    625337731,
+    1827964148
+  ]
+};
+var UGC_NAME_HASHES = {
+  Food: 1082430709,
+  Cloth: 1081148994,
+  Goods: 796475057,
+  Interior: 1038271965,
+  Exterior: 667448790,
+  MapObject: 1459196728,
+  MapFloor: 2441639337
+};
+
+// src/savAccess.ts
+import { buildHashMap } from "@alexislours/ltd-savedata";
+import "@alexislours/ltd-savedata/schema";
+function leafByHashOrThrow(schema, hash, label, expected) {
+  const leaf = buildHashMap(schema).get(hash >>> 0);
+  if (!leaf) throw new ShareMiiError("save_format_error", { label });
+  if (leaf.type !== expected) {
+    throw new ShareMiiError("save_format_error", { label });
+  }
+  return leaf;
+}
+
+// src/codec.ts
+var MII_BLOCK = 156;
+var PERSONALITY_LEN = 18 * 4;
+var NAME_LEN = 64;
+var PRONOUNCE_LEN = 128;
+var SEXUALITY_LEN = 4;
+var MARK_CANVAS = new Uint8Array([163, 163, 163, 163]);
+var MARK_UGC = new Uint8Array([164, 164, 164, 164]);
+var MARK_NAME = new Uint8Array([162, 162, 162, 162]);
+var MARK_THUMB = new Uint8Array([165, 165, 165, 165]);
+function encodeLtdMii(m) {
+  if (m.miiBlock.byteLength !== MII_BLOCK) throw new Error("miiBlock must be 156 bytes");
+  if (m.personality.byteLength !== PERSONALITY_LEN) throw new Error("personality must be 72 bytes");
+  if (m.name.byteLength !== NAME_LEN) throw new Error("name must be 64 bytes");
+  if (m.pronounce.byteLength !== PRONOUNCE_LEN) throw new Error("pronounce must be 128 bytes");
+  if (m.sexuality.byteLength !== SEXUALITY_LEN) throw new Error("sexuality must be 4 bytes");
+  const total = 4 + MII_BLOCK + PERSONALITY_LEN + NAME_LEN + PRONOUNCE_LEN + SEXUALITY_LEN + 4 + m.canvasTex.byteLength + 4 + m.ugcTex.byteLength;
+  const out = new Uint8Array(total);
+  let p = 0;
+  out[p++] = m.version & 255;
+  out[p++] = m.hasCanvas ? 1 : 0;
+  out[p++] = m.hasUgcTex ? 1 : 0;
+  out[p++] = 0;
+  out.set(m.miiBlock, p);
+  p += MII_BLOCK;
+  out.set(m.personality, p);
+  p += PERSONALITY_LEN;
+  out.set(m.name, p);
+  p += NAME_LEN;
+  out.set(m.pronounce, p);
+  p += PRONOUNCE_LEN;
+  out.set(m.sexuality, p);
+  p += SEXUALITY_LEN;
+  out.set(MARK_CANVAS, p);
+  p += 4;
+  out.set(m.canvasTex, p);
+  p += m.canvasTex.byteLength;
+  out.set(MARK_UGC, p);
+  p += 4;
+  out.set(m.ugcTex, p);
+  return out;
+}
+function decodeLtdMii(bytes) {
+  if (bytes.byteLength < 4) throw new ShareMiiError("invalid_ltd_file");
+  let buf = new Uint8Array(bytes);
+  const originalVersion = buf[0];
+  let version = originalVersion;
+  if (version < 1 || version > 3) {
+    throw new ShareMiiError("unsupported_ltd_version", { version });
+  }
+  if (version < 3) {
+    buf = upgradeToV3(buf);
+    version = 3;
+  }
+  const hasCanvas = buf[1] !== 0;
+  const hasUgcTex = buf[2] !== 0;
+  let p = 4;
+  const miiBlock = buf.slice(p, p + MII_BLOCK);
+  p += MII_BLOCK;
+  const personality = buf.slice(p, p + PERSONALITY_LEN);
+  p += PERSONALITY_LEN;
+  const name = buf.slice(p, p + NAME_LEN);
+  p += NAME_LEN;
+  const pronounce = buf.slice(p, p + PRONOUNCE_LEN);
+  p += PRONOUNCE_LEN;
+  const sexuality = buf.slice(p, p + SEXUALITY_LEN);
+  p += SEXUALITY_LEN;
+  const canvasStart = findMarker(buf, MARK_CANVAS, p);
+  if (canvasStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "canvas" });
+  const ugcStart = findMarker(buf, MARK_UGC, canvasStart + 4);
+  if (ugcStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "ugc" });
+  const canvasTex = buf.slice(canvasStart + 4, ugcStart);
+  const ugcTex = buf.slice(ugcStart + 4);
+  return {
+    version,
+    originalVersion,
+    hasCanvas,
+    hasUgcTex,
+    miiBlock,
+    personality,
+    name,
+    pronounce,
+    sexuality,
+    canvasTex,
+    ugcTex
+  };
+}
+function upgradeToV3(input) {
+  const mii = Array.from(input);
+  const originalVersion = mii[0];
+  mii.splice(4, 1);
+  if (originalVersion === 2) {
+    mii.splice(427, 0, 0);
+    const canvasMarkerStart = findMarkerArr(mii, [163, 163, 163]);
+    if (canvasMarkerStart < 0)
+      throw new ShareMiiError("ltd_missing_marker", { marker: "v2_canvas" });
+    const canvasStart = canvasMarkerStart + 3;
+    const ugcMarkerStart = lastFindMarkerArr(mii, [163, 163, 163]);
+    mii.splice(canvasStart, 0, 163);
+    mii[ugcMarkerStart + 1] = 164;
+    mii[ugcMarkerStart + 2] = 164;
+    mii[ugcMarkerStart + 3] = 164;
+    mii.splice(ugcMarkerStart + 3, 0, 164);
+  }
+  mii[0] = 3;
+  return new Uint8Array(mii);
+}
+function findMarker(buf, marker, from) {
+  outer: for (let i = from; i <= buf.byteLength - marker.byteLength; i++) {
+    for (let j = 0; j < marker.byteLength; j++) {
+      if (buf[i + j] !== marker[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function findMarkerArr(buf, marker) {
+  outer: for (let i = 0; i <= buf.length - marker.length; i++) {
+    for (let j = 0; j < marker.length; j++) {
+      if (buf[i + j] !== marker[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function lastFindMarkerArr(buf, marker) {
+  outer: for (let i = buf.length - marker.length; i >= 0; i--) {
+    for (let j = 0; j < marker.length; j++) {
+      if (buf[i + j] !== marker[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function encodeLtdUgc(u) {
+  const ltdHeader = new Uint8Array([u.kindIndex & 255, 0, 0, 0]);
+  const namesBlock = u.goodsText ? concat(u.name, u.pronounce, u.goodsText, u.goodsPronounce ?? new Uint8Array(0)) : concat(u.name, u.pronounce);
+  return concat(
+    ltdHeader,
+    u.fields,
+    u.vector,
+    u.vector2,
+    MARK_NAME,
+    namesBlock,
+    MARK_CANVAS,
+    u.canvasTex,
+    MARK_UGC,
+    u.ugcTex,
+    MARK_THUMB,
+    u.thumbTex
+  );
+}
+function decodeLtdUgc(bytes) {
+  if (bytes.byteLength < 4) throw new ShareMiiError("invalid_ltd_file");
+  const kindIndex = bytes[0];
+  const nameStart = findMarker(bytes, MARK_NAME, 4);
+  if (nameStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "name" });
+  const canvasStart = findMarker(bytes, MARK_CANVAS, nameStart + 4);
+  if (canvasStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "canvas" });
+  const ugcStart = findMarker(bytes, MARK_UGC, canvasStart + 4);
+  if (ugcStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "ugc" });
+  const thumbStart = findMarker(bytes, MARK_THUMB, ugcStart + 4);
+  if (thumbStart < 0) throw new ShareMiiError("ltd_missing_marker", { marker: "thumb" });
+  return {
+    kindIndex,
+    fieldsAndVectors: bytes.slice(4, nameStart),
+    namesBlock: bytes.slice(nameStart + 4, canvasStart),
+    canvasTex: bytes.slice(canvasStart + 4, ugcStart),
+    ugcTex: bytes.slice(ugcStart + 4, thumbStart),
+    thumbTex: bytes.slice(thumbStart + 4)
+  };
+}
+function concat(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.byteLength;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.byteLength;
+  }
+  return out;
+}
+
+// src/applyMii.ts
+import { DataType as DataType2, buildHashMap as buildHashMap2 } from "@alexislours/ltd-savedata";
+import { MII_SCHEMA as MII_SCHEMA2, PLAYER_SCHEMA as PLAYER_SCHEMA2 } from "@alexislours/ltd-savedata/schema";
+var MII_SLOTS = 70;
+var MII_BLOCK_LEN = 156;
+var MII_DATA_LEN = 152;
+function wrapMiiBlock(data) {
+  const out = new Uint8Array(MII_BLOCK_LEN);
+  new DataView(out.buffer).setUint32(0, MII_DATA_LEN, true);
+  out.set(data, 4);
+  return out;
+}
+function unwrapMiiBlock(block) {
+  return block.slice(4, MII_BLOCK_LEN);
+}
+var FP_TEX_SRC_USED = 1452493121 | 0;
+var FP_TEX_SRC_UNUSED = 3069107721 | 0;
+var FP_STATE_USED = 494906868 | 0;
+var FP_STATE_UNUSED = 2952759973 | 0;
+var FP_UNKNOWN_USED = 32768 | 0;
+var FP_UNKNOWN_UNUSED = 0 | 0;
+var FP_PRICE = 500;
+var FP_HASH_UNUSED = 0 | 0;
+var FP_INDEX_UNUSED = -1;
+function fpHashValue(facepaintId) {
+  return 8 << 16 | facepaintId | 0;
+}
+var PLAYER_LEAVES = {
+  fpPrice: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    FACEPAINT_HASHES.price,
+    "Facepaint.Price",
+    DataType2.IntArray
+  ),
+  fpTexSrc: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    FACEPAINT_HASHES.textureSourceType,
+    "Facepaint.TextureSourceType",
+    DataType2.EnumArray
+  ),
+  fpState: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    FACEPAINT_HASHES.state,
+    "Facepaint.State",
+    DataType2.EnumArray
+  ),
+  fpUnknown: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    FACEPAINT_HASHES.unknown,
+    "Facepaint.Unknown",
+    DataType2.UIntArray
+  ),
+  fpHash: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    FACEPAINT_HASHES.hash,
+    "Facepaint.Hash",
+    DataType2.UIntArray
+  ),
+  tempSlot: leafByHashOrThrow(
+    PLAYER_SCHEMA2,
+    MII_HASHES.tempSlotMii,
+    "Player.TempSlotMii",
+    DataType2.Binary
+  )
+};
+var MII_LEAVES = {
+  facePaintIndex: leafByHashOrThrow(
+    MII_SCHEMA2,
+    MII_HASHES.facePaintIndex,
+    "Mii.FacePaintIndex",
+    DataType2.IntArray
+  ),
+  names: leafByHashOrThrow(MII_SCHEMA2, MII_HASHES.names, "Mii.Names", DataType2.WString32Array),
+  pronunciation: leafByHashOrThrow(
+    MII_SCHEMA2,
+    MII_HASHES.pronunciation,
+    "Mii.Pronunciation",
+    DataType2.WString64Array
+  ),
+  rawMii: leafByHashOrThrow(MII_SCHEMA2, MII_HASHES.rawMii, "Mii.Raw", DataType2.BinaryArray),
+  isLoveGender: leafByHashOrThrow(
+    MII_SCHEMA2,
+    MII_HASHES.isLoveGender,
+    "Mii.IsLoveGender",
+    DataType2.BoolArray
+  ),
+  satisfyLevel: leafByHashOrThrow(
+    MII_SCHEMA2,
+    MII_HASHES.satisfyLevel,
+    "Mii.SatisfyInfo.Level",
+    DataType2.IntArray
+  ),
+  personality: MII_HASHES.personality.map((h, i) => {
+    const leaf = buildHashMap2(MII_SCHEMA2).get(h >>> 0);
+    if (!leaf) throw new ShareMiiError("save_format_error", { label: `Personality[${i}]` });
+    if (leaf.type !== DataType2.IntArray && leaf.type !== DataType2.EnumArray) {
+      throw new ShareMiiError("save_format_error", { label: `Personality[${i}]` });
+    }
+    return leaf;
+  })
+};
+function getPersonalityElement(mii, leaf, i) {
+  if (leaf.type === DataType2.IntArray) return mii.getElement(leaf, i);
+  return mii.getElement(leaf, i);
+}
+function setPersonalityElement(mii, leaf, i, v) {
+  if (leaf.type === DataType2.IntArray) mii.setElement(leaf, i, v);
+  else mii.setElement(leaf, i, v >>> 0);
+}
+function listMiiSlots(saves) {
+  const out = [];
+  out.push({ slot: 0, empty: false, name: "In-Progress Mii" });
+  for (let s = 0; s < MII_SLOTS; s++) {
+    const data = saves.mii.getElement(MII_LEAVES.rawMii, s);
+    const empty = isEmptyDataBlock(data);
+    const name = saves.mii.getElement(MII_LEAVES.names, s);
+    out.push({ slot: s + 1, empty, name: empty ? "" : name });
+  }
+  return out;
+}
+function isEmptyDataBlock(data) {
+  if (data.byteLength !== MII_DATA_LEN) return false;
+  for (const b of data) if (b !== 0) return false;
+  return true;
+}
+function isEmptyMiiBlock(block) {
+  if (block.byteLength !== MII_BLOCK_LEN) return false;
+  let sum = 0;
+  for (const b of block) sum += b;
+  return sum === 152;
+}
+function readMiiBlock(saves, isTemp, slotIdx) {
+  if (isTemp) {
+    const data2 = saves.player.get(PLAYER_LEAVES.tempSlot);
+    if (data2.byteLength < MII_DATA_LEN) throw new ShareMiiError("mii_not_initialized");
+    return wrapMiiBlock(data2.subarray(0, MII_DATA_LEN));
+  }
+  const data = saves.mii.getElement(MII_LEAVES.rawMii, slotIdx);
+  if (data.byteLength !== MII_DATA_LEN) {
+    throw new ShareMiiError("save_format_error", { label: "Mii.Raw" });
+  }
+  return wrapMiiBlock(data);
+}
+function writeMiiBlock(saves, isTemp, slotIdx, block) {
+  const data = unwrapMiiBlock(block);
+  if (isTemp) {
+    const buf = saves.player.get(PLAYER_LEAVES.tempSlot);
+    buf.set(data, 0);
+    saves.player.set(PLAYER_LEAVES.tempSlot, buf);
+  } else {
+    saves.mii.setElement(MII_LEAVES.rawMii, slotIdx, data);
+  }
+}
+function extractMii(saves, slot, sidecar = EMPTY_SIDECAR) {
+  const isTemp = slot === 0;
+  const slotIdx = slot - 1;
+  const block = readMiiBlock(saves, isTemp, slotIdx);
+  if (isEmptyMiiBlock(block)) {
+    throw new ShareMiiError("mii_not_initialized");
+  }
+  let facepaintId = null;
+  if (isTemp) {
+    if (saves.player.getElement(PLAYER_LEAVES.fpState, 70) !== FP_STATE_UNUSED) facepaintId = 70;
+  } else {
+    const id = saves.mii.getElement(MII_LEAVES.facePaintIndex, slotIdx);
+    if (id !== FP_INDEX_UNUSED) facepaintId = id;
+  }
+  const personality = new Uint8Array(72);
+  const dv = new DataView(personality.buffer);
+  for (let i = 0; i < 18; i++) {
+    const v = isTemp ? 0 : getPersonalityElement(saves.mii, MII_LEAVES.personality[i], slotIdx);
+    dv.setInt32(i * 4, v | 0, true);
+  }
+  const name = new Uint8Array(64);
+  let decodedName;
+  if (isTemp) {
+    const tempName = new TextEncoder().encode("Temp");
+    for (let i = 0; i < tempName.length; i++) name[i * 2] = tempName[i];
+    decodedName = "Mii";
+  } else {
+    const nameStr = saves.mii.getElement(MII_LEAVES.names, slotIdx);
+    name.set(encodeUtf16Name(nameStr, 64));
+    decodedName = decodeUtf16Name(name);
+  }
+  const pronounce = new Uint8Array(128);
+  if (!isTemp) {
+    const pStr = saves.mii.getElement(MII_LEAVES.pronunciation, slotIdx);
+    pronounce.set(encodeUtf16Name(pStr, 128));
+  }
+  const sexuality = new Uint8Array(4);
+  if (!isTemp) {
+    const base = slotIdx * 3;
+    sexuality[0] = saves.mii.getElement(MII_LEAVES.isLoveGender, base) ? 1 : 0;
+    sexuality[1] = saves.mii.getElement(MII_LEAVES.isLoveGender, base + 1) ? 1 : 0;
+    sexuality[2] = saves.mii.getElement(MII_LEAVES.isLoveGender, base + 2) ? 1 : 0;
+  }
+  let canvasTex = new Uint8Array(0);
+  let ugcTex = new Uint8Array(0);
+  const facepaint = [];
+  if (facepaintId !== null) {
+    const canvasName = facepaintCanvasFileName(facepaintId);
+    const texName = facepaintTexFileName(facepaintId);
+    const c = sidecar.files.get(canvasName);
+    const t = sidecar.files.get(texName);
+    if (c && t) {
+      canvasTex = new Uint8Array(c);
+      ugcTex = new Uint8Array(t);
+      facepaint.push({ name: canvasName, bytes: canvasTex }, { name: texName, bytes: ugcTex });
+    }
+  }
+  const ltd = {
+    version: isTemp ? 1 : 3,
+    originalVersion: isTemp ? 1 : 3,
+    hasCanvas: canvasTex.byteLength > 0,
+    hasUgcTex: ugcTex.byteLength > 0,
+    miiBlock: block.slice(),
+    personality,
+    name,
+    pronounce,
+    sexuality,
+    canvasTex,
+    ugcTex
+  };
+  const bytes = encodeLtdMii(ltd);
+  const baseName = isTemp ? "Mii" : sanitizeFileName(decodedName);
+  return {
+    bytes,
+    fileName: `${baseName}.ltd`,
+    miiName: decodedName || "Mii",
+    facepaint
+  };
+}
+function applyMii(saves, slot, ltdBytes, sidecar = EMPTY_SIDECAR) {
+  const ltd = decodeLtdMii(ltdBytes);
+  const isTemp = slot === 0;
+  const slotIdx = slot - 1;
+  if (!isTemp && isEmptyMiiBlock(readMiiBlock(saves, isTemp, slotIdx))) {
+    throw new ShareMiiError("mii_not_initialized");
+  }
+  writeMiiBlock(saves, isTemp, slotIdx, ltd.miiBlock);
+  const facepaintAvailable = ltd.hasCanvas && ltd.hasUgcTex ? "inline" : null;
+  const prevFacepaintId = isTemp ? FP_INDEX_UNUSED : saves.mii.getElement(MII_LEAVES.facePaintIndex, slotIdx);
+  let facepaintId = prevFacepaintId;
+  const facepaintWrites = [];
+  if (facepaintAvailable === "inline") {
+    if (isTemp) {
+      facepaintId = 70;
+    } else if (facepaintId === FP_INDEX_UNUSED) {
+      facepaintId = pickFacepaintId(saves.mii);
+      saves.mii.setElement(MII_LEAVES.facePaintIndex, slotIdx, facepaintId);
+    }
+    saves.player.setElement(PLAYER_LEAVES.fpPrice, facepaintId, FP_PRICE);
+    saves.player.setElement(PLAYER_LEAVES.fpTexSrc, facepaintId, FP_TEX_SRC_USED);
+    saves.player.setElement(PLAYER_LEAVES.fpState, facepaintId, FP_STATE_USED);
+    saves.player.setElement(PLAYER_LEAVES.fpUnknown, facepaintId, FP_UNKNOWN_USED);
+    saves.player.setElement(PLAYER_LEAVES.fpHash, facepaintId, fpHashValue(facepaintId));
+    facepaintWrites.push({
+      name: facepaintCanvasFileName(facepaintId),
+      bytes: ltd.canvasTex
+    });
+    facepaintWrites.push({
+      name: facepaintTexFileName(facepaintId),
+      bytes: ltd.ugcTex
+    });
+  } else if (prevFacepaintId !== FP_INDEX_UNUSED) {
+    if (!isTemp) {
+      saves.mii.setElement(MII_LEAVES.facePaintIndex, slotIdx, FP_INDEX_UNUSED);
+    }
+    saves.player.setElement(PLAYER_LEAVES.fpPrice, prevFacepaintId, 0);
+    saves.player.setElement(PLAYER_LEAVES.fpTexSrc, prevFacepaintId, FP_TEX_SRC_UNUSED);
+    saves.player.setElement(PLAYER_LEAVES.fpState, prevFacepaintId, FP_STATE_UNUSED);
+    saves.player.setElement(PLAYER_LEAVES.fpUnknown, prevFacepaintId, FP_UNKNOWN_UNUSED);
+    saves.player.setElement(PLAYER_LEAVES.fpHash, prevFacepaintId, FP_HASH_UNUSED);
+  }
+  if (ltd.originalVersion >= 2 && !isTemp) {
+    const sdv = new DataView(
+      ltd.personality.buffer,
+      ltd.personality.byteOffset,
+      ltd.personality.byteLength
+    );
+    for (let i = 0; i < 18; i++) {
+      setPersonalityElement(
+        saves.mii,
+        MII_LEAVES.personality[i],
+        slotIdx,
+        sdv.getInt32(i * 4, true)
+      );
+    }
+    saves.mii.setElement(MII_LEAVES.names, slotIdx, decodeUtf16Name(ltd.name));
+    saves.mii.setElement(MII_LEAVES.pronunciation, slotIdx, decodeUtf16Name(ltd.pronounce));
+    if (saves.mii.getElement(MII_LEAVES.satisfyLevel, slotIdx) < 2) {
+      const base = slotIdx * 3;
+      saves.mii.setElement(MII_LEAVES.isLoveGender, base, (ltd.sexuality[0] & 1) === 1);
+      saves.mii.setElement(MII_LEAVES.isLoveGender, base + 1, (ltd.sexuality[1] & 1) === 1);
+      saves.mii.setElement(MII_LEAVES.isLoveGender, base + 2, (ltd.sexuality[2] & 1) === 1);
+    }
+  }
+  if (sidecar.origin !== "none" && facepaintWrites.length > 0) {
+    for (const f of facepaintWrites) sidecar.files.set(f.name, f.bytes);
+  }
+  return { facepaintWrites };
+}
+function pickFacepaintId(mii) {
+  const used = /* @__PURE__ */ new Set();
+  for (let s = 0; s < MII_SLOTS; s++) {
+    const id = mii.getElement(MII_LEAVES.facePaintIndex, s);
+    if (id !== FP_INDEX_UNUSED) used.add(id);
+  }
+  for (let i = 0; i < MII_SLOTS; i++) {
+    if (!used.has(i)) return i;
+  }
+  throw new ShareMiiError("no_free_facepaint_slot");
+}
+
+// src/applyUgc.ts
+import { arrayElementSize, DataType as DataType3, buildHashMap as buildHashMap3 } from "@alexislours/ltd-savedata";
+import { PLAYER_SCHEMA as PLAYER_SCHEMA3 } from "@alexislours/ltd-savedata/schema";
+var ENABLE_USED = 494906868 >>> 0;
+function resolveScalarFieldLeaf(hash, label) {
+  const leaf = buildHashMap3(PLAYER_SCHEMA3).get(hash >>> 0);
+  if (!leaf) throw new ShareMiiError("save_format_error", { label });
+  const t = leaf.type;
+  if (t !== DataType3.IntArray && t !== DataType3.UIntArray && t !== DataType3.EnumArray && t !== DataType3.FloatArray && t !== DataType3.BoolArray) {
+    throw new ShareMiiError("save_format_error", { label });
+  }
+  return leaf;
+}
+function resolveNameLeaf(hash, label) {
+  const leaf = buildHashMap3(PLAYER_SCHEMA3).get(hash >>> 0);
+  if (!leaf) throw new ShareMiiError("save_format_error", { label });
+  const t = leaf.type;
+  if (t !== DataType3.WString32Array && t !== DataType3.WString64Array) {
+    throw new ShareMiiError("save_format_error", { label });
+  }
+  return leaf;
+}
+function resolveUgcLeaves(kind) {
+  const h = UGC_HASHES[kind];
+  return {
+    fields: h.fields.map((hash, i) => resolveScalarFieldLeaf(hash, `${kind}.field[${i}]`)),
+    names: h.names.map((hash, i) => resolveNameLeaf(hash, `${kind}.name[${i}]`)),
+    vector: h.vector ? leafByHashOrThrow(PLAYER_SCHEMA3, h.vector, `${kind}.vector`, DataType3.Vector3Array) : null,
+    vector2: h.vector2 ? leafByHashOrThrow(PLAYER_SCHEMA3, h.vector2, `${kind}.vector2`, DataType3.Vector2Array) : null,
+    enable: leafByHashOrThrow(
+      PLAYER_SCHEMA3,
+      UGC_ENABLE_HASHES[kind],
+      `${kind}.enable`,
+      DataType3.EnumArray
+    ),
+    texture: leafByHashOrThrow(
+      PLAYER_SCHEMA3,
+      UGC_TEXTURE_HASHES[kind],
+      `${kind}.texture`,
+      DataType3.EnumArray
+    ),
+    hashId: leafByHashOrThrow(
+      PLAYER_SCHEMA3,
+      UGC_HASH_ID_HASHES[kind],
+      `${kind}.hashId`,
+      DataType3.UIntArray
+    )
+  };
+}
+function ugcSlotCapacity(saves, leaves, kind) {
+  const player = saves.player;
+  let cap = UGC_MAX_SLOTS[kind];
+  for (const leaf of leaves.fields) cap = Math.min(cap, player.get(leaf).length);
+  for (const leaf of leaves.names) cap = Math.min(cap, player.get(leaf).length);
+  if (leaves.vector) cap = Math.min(cap, player.get(leaves.vector).length);
+  if (leaves.vector2) cap = Math.min(cap, player.get(leaves.vector2).length);
+  cap = Math.min(cap, player.get(leaves.enable).length);
+  cap = Math.min(cap, player.get(leaves.texture).length);
+  cap = Math.min(cap, player.get(leaves.hashId).length);
+  return cap;
+}
+function readField4(player, leaf, slotIdx) {
+  const out = new Uint8Array(4);
+  const dv = new DataView(out.buffer);
+  switch (leaf.type) {
+    case DataType3.IntArray:
+      dv.setInt32(0, player.getElement(leaf, slotIdx) | 0, true);
+      return out;
+    case DataType3.UIntArray:
+      dv.setUint32(
+        0,
+        player.getElement(leaf, slotIdx) >>> 0,
+        true
+      );
+      return out;
+    case DataType3.EnumArray:
+      dv.setUint32(
+        0,
+        player.getElement(leaf, slotIdx) >>> 0,
+        true
+      );
+      return out;
+    case DataType3.FloatArray:
+      dv.setFloat32(0, player.getElement(leaf, slotIdx), true);
+      return out;
+    case DataType3.BoolArray:
+      out[0] = player.getElement(leaf, slotIdx) ? 1 : 0;
+      return out;
+  }
+}
+function writeField4(player, leaf, slotIdx, src) {
+  const dv = new DataView(src.buffer, src.byteOffset, 4);
+  switch (leaf.type) {
+    case DataType3.IntArray:
+      player.setElement(leaf, slotIdx, dv.getInt32(0, true) | 0);
+      return;
+    case DataType3.UIntArray:
+      player.setElement(
+        leaf,
+        slotIdx,
+        dv.getUint32(0, true) >>> 0
+      );
+      return;
+    case DataType3.EnumArray:
+      player.setElement(
+        leaf,
+        slotIdx,
+        dv.getUint32(0, true) >>> 0
+      );
+      return;
+    case DataType3.FloatArray:
+      player.setElement(leaf, slotIdx, dv.getFloat32(0, true));
+      return;
+    case DataType3.BoolArray:
+      player.setElement(
+        leaf,
+        slotIdx,
+        (src[0] | src[1] | src[2] | src[3]) !== 0
+      );
+      return;
+  }
+}
+function nameByteLen(leaf) {
+  const sz = arrayElementSize(leaf.type);
+  if (sz !== 64 && sz !== 128) {
+    throw new ShareMiiError("save_format_error", { label: "name" });
+  }
+  return sz;
+}
+function readNameBlock(player, leaf, slotIdx) {
+  const str = player.getElement(leaf, slotIdx);
+  return encodeUtf16Name(str, nameByteLen(leaf));
+}
+function writeNameBlock(player, leaf, slotIdx, src) {
+  player.setElement(leaf, slotIdx, decodeUtf16Name(src));
+}
+function readVector3(player, leaf, slotIdx) {
+  const v = player.getElement(leaf, slotIdx);
+  const out = new Uint8Array(12);
+  const dv = new DataView(out.buffer);
+  dv.setFloat32(0, v.x, true);
+  dv.setFloat32(4, v.y, true);
+  dv.setFloat32(8, v.z, true);
+  return out;
+}
+function writeVector3(player, leaf, slotIdx, src) {
+  const dv = new DataView(src.buffer, src.byteOffset, 12);
+  player.setElement(leaf, slotIdx, {
+    x: dv.getFloat32(0, true),
+    y: dv.getFloat32(4, true),
+    z: dv.getFloat32(8, true)
+  });
+}
+function readVector2(player, leaf, slotIdx) {
+  const v = player.getElement(leaf, slotIdx);
+  const out = new Uint8Array(8);
+  const dv = new DataView(out.buffer);
+  dv.setFloat32(0, v.x, true);
+  dv.setFloat32(4, v.y, true);
+  return out;
+}
+function writeVector2(player, leaf, slotIdx, src) {
+  const dv = new DataView(src.buffer, src.byteOffset, 8);
+  player.setElement(leaf, slotIdx, {
+    x: dv.getFloat32(0, true),
+    y: dv.getFloat32(4, true)
+  });
+}
+function listUgcSlots(saves, kind, sidecar = EMPTY_SIDECAR) {
+  const out = [];
+  let max = UGC_MAX_SLOTS[kind];
+  let nameLeaf;
+  try {
+    const leaves = resolveUgcLeaves(kind);
+    nameLeaf = resolveNameLeaf(UGC_NAME_HASHES[kind], `${kind}.names`);
+    max = ugcSlotCapacity(saves, leaves, kind);
+  } catch {
+    nameLeaf = null;
+  }
+  let foundAddSlot = false;
+  for (let i = 0; i < max; i++) {
+    const fileName = ugcCanvasFileName(kind, i);
+    const exists = sidecar.files.has(fileName);
+    const decoded = nameLeaf ? saves.player.getElement(nameLeaf, i) : "";
+    const looksFilled = decoded.length > 0;
+    if (exists || sidecar.origin === "none" && looksFilled) {
+      out.push({ slot: i + 1, empty: false, name: decoded, isAddNew: false });
+    } else if (!foundAddSlot) {
+      out.push({ slot: i + 1, empty: true, name: "", isAddNew: true });
+      foundAddSlot = true;
+    }
+  }
+  return out;
+}
+function extractUgc(saves, slot, kind, sidecar = EMPTY_SIDECAR) {
+  const leaves = resolveUgcLeaves(kind);
+  const player = saves.player;
+  const slotIdx = slot - 1;
+  const kindIndex = ugcKindIndex(kind);
+  const fields = new Uint8Array(leaves.fields.length * 4);
+  for (let i = 0; i < leaves.fields.length; i++) {
+    fields.set(readField4(player, leaves.fields[i], slotIdx), i * 4);
+  }
+  const vector = leaves.vector ? readVector3(player, leaves.vector, slotIdx) : new Uint8Array(12);
+  const vector2 = leaves.vector2 ? readVector2(player, leaves.vector2, slotIdx) : new Uint8Array(8);
+  const name = readNameBlock(player, leaves.names[0], slotIdx);
+  const pronounce = readNameBlock(player, leaves.names[1], slotIdx);
+  let goodsText;
+  let goodsPronounce;
+  if (kind === "Goods" && leaves.names[2] !== void 0 && leaves.names[3] !== void 0) {
+    goodsText = readNameBlock(player, leaves.names[2], slotIdx);
+    goodsPronounce = readNameBlock(player, leaves.names[3], slotIdx);
+  }
+  const canvasName = ugcCanvasFileName(kind, slotIdx);
+  const texName = ugcTexFileName(kind, slotIdx);
+  const thumbName = ugcThumbFileName(kind, slotIdx);
+  const canvasTex = sidecar.files.get(canvasName);
+  const ugcTex = sidecar.files.get(texName);
+  const thumbTex = sidecar.files.get(thumbName);
+  if (!canvasTex || !ugcTex || !thumbTex) {
+    throw new ShareMiiError("ugc_missing_textures");
+  }
+  const ltd = {
+    kindIndex,
+    fields,
+    vector,
+    vector2,
+    name,
+    pronounce,
+    goodsText,
+    goodsPronounce,
+    canvasTex,
+    ugcTex,
+    thumbTex
+  };
+  const bytes = encodeLtdUgc(ltd);
+  const decodedName = decodeUtf16Name(name) || `Ugc${kind}${slotIdx}`;
+  const fileName = `${sanitizeFileName(decodedName)}${UGC_FILE_EXTENSIONS[kind]}`;
+  return {
+    bytes,
+    fileName,
+    itemName: decodedName,
+    textures: [
+      { name: canvasName, bytes: canvasTex },
+      { name: texName, bytes: ugcTex },
+      { name: thumbName, bytes: thumbTex }
+    ]
+  };
+}
+function applyUgc(saves, slot, kind, ltdBytes, isAdding, sidecar = EMPTY_SIDECAR) {
+  const decoded = decodeLtdUgc(ltdBytes);
+  const expected = ugcKindIndex(kind);
+  if (decoded.kindIndex !== expected) {
+    throw new ShareMiiError("wrong_ugc_kind", { got: decoded.kindIndex, expected });
+  }
+  const leaves = resolveUgcLeaves(kind);
+  const player = saves.player;
+  const slotIdx = slot - 1;
+  const capacity = ugcSlotCapacity(saves, leaves, kind);
+  if (slotIdx < 0 || slotIdx >= capacity) {
+    throw new ShareMiiError("slot_out_of_range", { slot, kind, capacity });
+  }
+  if ((kind === "Cloth" || kind === "Goods") && !isAdding) {
+    const existing = readField4(player, leaves.fields[0], slotIdx);
+    const incoming = decoded.fieldsAndVectors.subarray(0, 4);
+    if (!buffersEqual(existing, incoming)) {
+      throw new ShareMiiError("subtype_mismatch");
+    }
+  }
+  if ((kind === "Exterior" || kind === "MapObject") && !isAdding) {
+    throw new ShareMiiError("cannot_replace_kind", { kind });
+  }
+  for (let i = 0; i < leaves.fields.length; i++) {
+    const src = decoded.fieldsAndVectors.subarray(i * 4, i * 4 + 4);
+    writeField4(player, leaves.fields[i], slotIdx, src);
+  }
+  if (isAdding) {
+    player.setElement(leaves.enable, slotIdx, ENABLE_USED);
+    const texDv = new DataView(
+      UGC_TEX_DATA.buffer,
+      UGC_TEX_DATA.byteOffset,
+      UGC_TEX_DATA.byteLength
+    );
+    const texVal = texDv.getUint32(expected * 4, true) >>> 0;
+    player.setElement(leaves.texture, slotIdx, texVal);
+    const hashIdVal = (slotIdx & 255 | (UGC_HASH_INDICES[kind] & 255) << 16) >>> 0;
+    player.setElement(leaves.hashId, slotIdx, hashIdVal);
+  }
+  const namesBlock = decoded.namesBlock;
+  writeNameBlock(player, leaves.names[0], slotIdx, namesBlock.subarray(0, 128));
+  writeNameBlock(player, leaves.names[1], slotIdx, namesBlock.subarray(128, 256));
+  if (kind === "Goods" && leaves.names[2] !== void 0 && leaves.names[3] !== void 0) {
+    writeNameBlock(player, leaves.names[2], slotIdx, namesBlock.subarray(256, 320));
+    writeNameBlock(player, leaves.names[3], slotIdx, namesBlock.subarray(320, 448));
+  }
+  const fav = decoded.fieldsAndVectors;
+  if (leaves.vector) {
+    const vStart = fav.byteLength - 20;
+    writeVector3(player, leaves.vector, slotIdx, fav.subarray(vStart, vStart + 12));
+  }
+  if (leaves.vector2) {
+    const v2Start = fav.byteLength - 8;
+    writeVector2(player, leaves.vector2, slotIdx, fav.subarray(v2Start, v2Start + 8));
+  }
+  const writes = [
+    { name: ugcCanvasFileName(kind, slotIdx), bytes: decoded.canvasTex },
+    { name: ugcTexFileName(kind, slotIdx), bytes: decoded.ugcTex },
+    { name: ugcThumbFileName(kind, slotIdx), bytes: decoded.thumbTex }
+  ];
+  if (sidecar.origin !== "none") {
+    for (const f of writes) sidecar.files.set(f.name, f.bytes);
+  }
+  return { textureWrites: writes };
+}
+function buffersEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+export {
+  EMPTY_SIDECAR,
+  FACEPAINT_HASHES,
+  FP_STATE_UNUSED,
+  MII_HASHES,
+  MII_SLOTS,
+  ShareMiiError,
+  UGC_DISPLAY_LABELS,
+  UGC_ENABLE_HASHES,
+  UGC_FILE_EXTENSIONS,
+  UGC_HASHES,
+  UGC_HASH_ID_HASHES,
+  UGC_HASH_INDICES,
+  UGC_KINDS,
+  UGC_MAX_SLOTS,
+  UGC_NAME_HASHES,
+  UGC_TEXTURE_HASHES,
+  UGC_TEX_DATA,
+  applyMii,
+  applyUgc,
+  decodeLtdMii,
+  decodeLtdUgc,
+  decodeUtf16Name,
+  encodeLtdMii,
+  encodeLtdUgc,
+  encodeUtf16Name,
+  extractMii,
+  extractUgc,
+  facepaintCanvasFileName,
+  facepaintTexFileName,
+  isJunkArchiveEntry,
+  isSidecarFileName,
+  leafByHashOrThrow,
+  listMiiSlots,
+  listUgcSlots,
+  normalizeName,
+  sanitizeFileName,
+  ugcCanvasFileName,
+  ugcKindIndex,
+  ugcTexFileName,
+  ugcThumbFileName
+};
+//# sourceMappingURL=index.js.map