xiv-strat-board 0.1.1

package/dist/index.js

@@ -0,0 +1,1144 @@
+import pako from 'pako';
+
+// src/constants.ts
+var CIPHER_TABLE = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  78,
+  0,
+  80,
+  0,
+  0,
+  120,
+  103,
+  48,
+  75,
+  56,
+  83,
+  74,
+  50,
+  115,
+  90,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  68,
+  70,
+  116,
+  84,
+  54,
+  69,
+  97,
+  86,
+  99,
+  112,
+  76,
+  77,
+  109,
+  101,
+  106,
+  57,
+  88,
+  66,
+  52,
+  82,
+  89,
+  55,
+  95,
+  110,
+  79,
+  98,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  105,
+  45,
+  118,
+  72,
+  67,
+  65,
+  114,
+  87,
+  111,
+  100,
+  73,
+  113,
+  104,
+  85,
+  108,
+  107,
+  51,
+  102,
+  121,
+  53,
+  71,
+  119,
+  49,
+  117,
+  122,
+  81,
+  0,
+  0,
+  0,
+  0,
+  0
+]);
+var KEY_REVERSE = {};
+for (let i = 0; i < CIPHER_TABLE.length; i++) {
+  if (CIPHER_TABLE[i] !== 0) {
+    KEY_REVERSE[CIPHER_TABLE[i]] = i;
+  }
+}
+var INVERSE_MAPPING = {
+  98: 45,
+  50: 48,
+  119: 49,
+  55: 50,
+  113: 51,
+  83: 52,
+  116: 53,
+  69: 54,
+  86: 55,
+  52: 56,
+  80: 57,
+  102: 65,
+  82: 66,
+  101: 67,
+  65: 68,
+  70: 69,
+  66: 70,
+  117: 71,
+  100: 72,
+  107: 73,
+  54: 74,
+  51: 75,
+  75: 76,
+  76: 77,
+  43: 78,
+  89: 79,
+  45: 80,
+  122: 81,
+  84: 82,
+  53: 83,
+  68: 84,
+  110: 85,
+  72: 86,
+  104: 87,
+  81: 88,
+  85: 89,
+  57: 90,
+  87: 95,
+  71: 97,
+  90: 98,
+  73: 99,
+  106: 100,
+  78: 101,
+  114: 102,
+  49: 103,
+  109: 104,
+  97: 105,
+  79: 106,
+  112: 107,
+  111: 108,
+  77: 109,
+  88: 110,
+  105: 111,
+  74: 112,
+  108: 113,
+  103: 114,
+  56: 115,
+  67: 116,
+  120: 117,
+  99: 118,
+  118: 119,
+  48: 120,
+  115: 121,
+  121: 122
+};
+var FORWARD_MAPPING = {};
+for (const [k, v] of Object.entries(INVERSE_MAPPING)) {
+  FORWARD_MAPPING[v] = Number(k);
+}
+var ICON_TYPE_IDS = {
+  // Field backgrounds (type 1)
+  checkered_circle: 4,
+  checkered_square: 8,
+  grey_circle: 124,
+  grey_square: 125,
+  // AoE/Mechanics (type 6)
+  circle_aoe: 9,
+  fan_aoe: 10,
+  line_aoe: 11,
+  line: 12,
+  gaze: 13,
+  stack: 14,
+  line_stack: 15,
+  proximity: 16,
+  donut: 17,
+  stack_multi: 106,
+  proximity_player: 107,
+  tankbuster: 108,
+  radial_knockback: 109,
+  linear_knockback: 110,
+  tower: 111,
+  targeting: 112,
+  moving_circle_aoe: 126,
+  "1person_aoe": 127,
+  "2person_aoe": 128,
+  "3person_aoe": 129,
+  "4person_aoe": 130,
+  // Base classes (type 2)
+  gladiator: 18,
+  pugilist: 19,
+  marauder: 20,
+  lancer: 21,
+  archer: 22,
+  conjurer: 23,
+  thaumaturge: 24,
+  arcanist: 25,
+  rogue: 26,
+  // Jobs (type 2)
+  paladin: 27,
+  monk: 28,
+  warrior: 29,
+  dragoon: 30,
+  bard: 31,
+  white_mage: 32,
+  black_mage: 33,
+  summoner: 34,
+  scholar: 35,
+  ninja: 36,
+  machinist: 37,
+  dark_knight: 38,
+  astrologian: 39,
+  samurai: 40,
+  red_mage: 41,
+  blue_mage: 42,
+  gunbreaker: 43,
+  dancer: 44,
+  reaper: 45,
+  sage: 46,
+  viper: 101,
+  pictomancer: 102,
+  // Role markers (type 2)
+  tank: 47,
+  tank_1: 48,
+  tank_2: 49,
+  healer: 50,
+  healer_1: 51,
+  healer_2: 52,
+  dps: 53,
+  dps_1: 54,
+  dps_2: 55,
+  dps_3: 56,
+  dps_4: 57,
+  melee_dps: 118,
+  ranged_dps: 119,
+  physical_ranged_dps: 120,
+  magical_ranged_dps: 121,
+  pure_healer: 122,
+  barrier_healer: 123,
+  // Enemies (type 3)
+  small_enemy: 60,
+  medium_enemy: 62,
+  large_enemy: 64,
+  // Target markers (type 3)
+  attack_1: 65,
+  attack_2: 66,
+  attack_3: 67,
+  attack_4: 68,
+  attack_5: 69,
+  attack_6: 115,
+  attack_7: 116,
+  attack_8: 117,
+  bind_1: 70,
+  bind_2: 71,
+  bind_3: 72,
+  ignore_1: 73,
+  ignore_2: 74,
+  // Chain markers (type 3)
+  square_marker: 75,
+  circle_marker: 76,
+  plus_marker: 77,
+  triangle_marker: 78,
+  // Waymarks (type 3)
+  waymark_a: 79,
+  waymark_b: 80,
+  waymark_c: 81,
+  waymark_d: 82,
+  waymark_1: 83,
+  waymark_2: 84,
+  waymark_3: 85,
+  waymark_4: 86,
+  // Shapes (type 4)
+  shape_circle: 87,
+  shape_x: 88,
+  shape_triangle: 89,
+  shape_square: 90,
+  up_arrow: 94,
+  text: 100,
+  rotate: 103,
+  highlighted_circle: 135,
+  highlighted_x: 136,
+  highlighted_square: 137,
+  highlighted_triangle: 138,
+  rotate_clockwise: 139,
+  rotate_counterclockwise: 140,
+  // Effects (type 3)
+  enhancement: 113,
+  enfeeblement: 114,
+  // Lock-on markers (type 3)
+  lockon_red: 131,
+  lockon_blue: 132,
+  lockon_purple: 133,
+  lockon_green: 134,
+  // Groups (type 5)
+  group: 105
+};
+var ICON_TYPES = {};
+for (const [name, id] of Object.entries(ICON_TYPE_IDS)) {
+  ICON_TYPES[id] = name;
+}
+var BOARD_BACKGROUND_TYPES = {
+  1: "none",
+  2: "checkered",
+  3: "checkered_circle",
+  4: "checkered_square",
+  5: "grey",
+  6: "grey_circle",
+  7: "grey_square"
+};
+var BOARD_BACKGROUND_IDS = {
+  none: 1,
+  checkered: 2,
+  checkered_circle: 3,
+  checkered_square: 4,
+  grey: 5,
+  grey_circle: 6,
+  grey_square: 7
+};
+var OBJECT_BACKGROUND_TYPES = {
+  0: "none",
+  1: "checkered",
+  2: "checkered_circle",
+  3: "checkered_square",
+  4: "grey",
+  5: "grey_circle",
+  6: "grey_square"
+};
+var OBJECT_BACKGROUND_IDS = {
+  none: 0,
+  checkered: 1,
+  checkered_circle: 2,
+  checkered_square: 3,
+  grey: 4,
+  grey_circle: 5,
+  grey_square: 6
+};
+
+// src/validation.ts
+var BOUNDS = {
+  /** Minimum X coordinate (allows slight overflow for edge objects) */
+  minX: -100,
+  /** Maximum X coordinate */
+  maxX: 612,
+  /** Minimum Y coordinate */
+  minY: -100,
+  /** Maximum Y coordinate */
+  maxY: 484,
+  /** Minimum size percentage */
+  minSize: 1,
+  /** Maximum size percentage */
+  maxSize: 255,
+  /** Minimum arc angle */
+  minArc: 0,
+  /** Maximum arc angle */
+  maxArc: 360,
+  /** Minimum donut radius */
+  minDonut: 0,
+  /** Maximum donut radius */
+  maxDonut: 255,
+  /** Maximum number of objects per board */
+  maxObjects: 50,
+  /** Maximum name length (bytes) */
+  maxNameLength: 7
+};
+var VALID_CIPHER_CHARS = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-_".split("")
+);
+function validateShareCode(code) {
+  if (typeof code !== "string") {
+    throw new Error("Share code must be a string");
+  }
+  if (code.length < 10) {
+    throw new Error("Share code is too short");
+  }
+  if (code.length > 1e4) {
+    throw new Error("Share code is too long");
+  }
+  if (!code.startsWith("[stgy:a")) {
+    throw new Error('Share code must start with "[stgy:a"');
+  }
+  if (!code.endsWith("]")) {
+    throw new Error('Share code must end with "]"');
+  }
+  const body = code.slice(7, -1);
+  if (body.length < 2) {
+    throw new Error("Share code body is too short");
+  }
+  for (const char of body) {
+    if (!VALID_CIPHER_CHARS.has(char)) {
+      throw new Error(`Invalid character in share code: "${char}"`);
+    }
+  }
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function sanitizeName(name) {
+  if (!name || typeof name !== "string") {
+    return "board";
+  }
+  const sanitized = name.replace(/[^\x20-\x7E]/g, "").replace(/[<>:"/\\|?*]/g, "").trim().slice(0, BOUNDS.maxNameLength);
+  return sanitized || "board";
+}
+function sanitizeCoordinate(value, isX) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return isX ? 256 : 192;
+  }
+  const min = isX ? BOUNDS.minX : BOUNDS.minY;
+  const max = isX ? BOUNDS.maxX : BOUNDS.maxY;
+  return clamp(Math.round(value * 10) / 10, min, max);
+}
+function sanitizeSize(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 100;
+  }
+  return clamp(Math.round(value), BOUNDS.minSize, BOUNDS.maxSize);
+}
+function sanitizeColorComponent(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 255;
+  }
+  return clamp(Math.round(value), 0, 255);
+}
+function parseHexColor(color) {
+  if (!color || typeof color !== "string") {
+    return null;
+  }
+  const hex = color.replace(/^#/, "");
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
+    return null;
+  }
+  return {
+    r: parseInt(hex.slice(0, 2), 16),
+    g: parseInt(hex.slice(2, 4), 16),
+    b: parseInt(hex.slice(4, 6), 16)
+  };
+}
+function validateBackground(value) {
+  if (typeof value === "number") {
+    if (value >= 0 && value <= 6) {
+      return value;
+    }
+    return 0;
+  }
+  if (typeof value === "string") {
+    const id = OBJECT_BACKGROUND_IDS[value.toLowerCase()];
+    return id ?? 0;
+  }
+  return 0;
+}
+function validateBoardBackground(value) {
+  if (typeof value === "string") {
+    const id = BOARD_BACKGROUND_IDS[value.toLowerCase()];
+    return id ?? 1;
+  }
+  if (typeof value === "number" && value >= 1 && value <= 7) {
+    return value;
+  }
+  return 1;
+}
+function validateIconType(typeName, typeId) {
+  if (typeof typeId === "number" && Number.isFinite(typeId) && typeId > 0 && typeId < 256) {
+    return typeId;
+  }
+  const id = ICON_TYPE_IDS[typeName];
+  if (id !== void 0) {
+    return id;
+  }
+  const unknownMatch = typeName.match(/^unknown_(\d+)$/);
+  if (unknownMatch) {
+    const parsedId = parseInt(unknownMatch[1], 10);
+    if (parsedId > 0 && parsedId < 256) {
+      return parsedId;
+    }
+  }
+  throw new Error(`Unknown icon type: "${typeName}"`);
+}
+function sanitizeObject(obj, index) {
+  if (!obj || typeof obj !== "object") {
+    throw new Error(`Object at index ${index} is not a valid object`);
+  }
+  if (!obj.type && !obj.typeId) {
+    throw new Error(`Object at index ${index} must have a type or typeId`);
+  }
+  const typeId = validateIconType(obj.type || "", obj.typeId);
+  let colorR = obj.colorR ?? 255;
+  let colorG = obj.colorG ?? 255;
+  let colorB = obj.colorB ?? 255;
+  if (obj.color) {
+    const parsed = parseHexColor(obj.color);
+    if (parsed) {
+      colorR = parsed.r;
+      colorG = parsed.g;
+      colorB = parsed.b;
+    }
+  }
+  return {
+    typeId,
+    x: sanitizeCoordinate(obj.x, true),
+    y: sanitizeCoordinate(obj.y, false),
+    size: sanitizeSize(obj.size),
+    background: validateBackground(obj.background),
+    colorR: sanitizeColorComponent(colorR),
+    colorG: sanitizeColorComponent(colorG),
+    colorB: sanitizeColorComponent(colorB),
+    transparency: sanitizeColorComponent(obj.transparency ?? 0),
+    arcAngle: clamp(Math.round(obj.arcAngle ?? 0), BOUNDS.minArc, BOUNDS.maxArc),
+    donutRadius: clamp(Math.round(obj.donutRadius ?? 0), BOUNDS.minDonut, BOUNDS.maxDonut),
+    hidden: Boolean(obj.hidden),
+    locked: Boolean(obj.locked)
+  };
+}
+function sanitizeBoard(board) {
+  if (!board || typeof board !== "object") {
+    throw new Error("Board must be an object");
+  }
+  if (!Array.isArray(board.objects)) {
+    throw new Error("Board must have an objects array");
+  }
+  if (board.objects.length > BOUNDS.maxObjects) {
+    throw new Error(`Board has too many objects (max ${BOUNDS.maxObjects})`);
+  }
+  return {
+    name: sanitizeName(board.name),
+    boardBackground: validateBoardBackground(board.boardBackground),
+    objects: board.objects.map((obj, i) => sanitizeObject(obj, i))
+  };
+}
+
+// src/binary.ts
+var BinaryReader = class {
+  view;
+  pos;
+  constructor(data) {
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    this.pos = 0;
+  }
+  get position() {
+    return this.pos;
+  }
+  get length() {
+    return this.view.byteLength;
+  }
+  get remaining() {
+    return this.length - this.pos;
+  }
+  seek(pos) {
+    if (pos < 0 || pos > this.length) {
+      throw new Error(`Seek position ${pos} out of bounds [0, ${this.length}]`);
+    }
+    this.pos = pos;
+  }
+  readUint8() {
+    if (this.pos + 1 > this.length) {
+      throw new Error("Unexpected end of data reading uint8");
+    }
+    const val = this.view.getUint8(this.pos);
+    this.pos += 1;
+    return val;
+  }
+  readInt16() {
+    if (this.pos + 2 > this.length) {
+      throw new Error("Unexpected end of data reading int16");
+    }
+    const val = this.view.getInt16(this.pos, true);
+    this.pos += 2;
+    return val;
+  }
+  readUint16() {
+    if (this.pos + 2 > this.length) {
+      throw new Error("Unexpected end of data reading uint16");
+    }
+    const val = this.view.getUint16(this.pos, true);
+    this.pos += 2;
+    return val;
+  }
+  readUint32() {
+    if (this.pos + 4 > this.length) {
+      throw new Error("Unexpected end of data reading uint32");
+    }
+    const val = this.view.getUint32(this.pos, true);
+    this.pos += 4;
+    return val;
+  }
+  readBytes(count) {
+    if (this.pos + count > this.length) {
+      throw new Error(`Unexpected end of data reading ${count} bytes`);
+    }
+    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, count);
+    this.pos += count;
+    return data;
+  }
+};
+function parseBinary(data) {
+  if (data.length < 28) {
+    throw new Error("Binary data is too short for header");
+  }
+  const reader = new BinaryReader(data);
+  const version = reader.readUint32();
+  reader.seek(24);
+  reader.readUint16();
+  const nameLength = reader.readUint16();
+  if (data.length < 28 + nameLength) {
+    throw new Error("Binary data is too short for name field");
+  }
+  const nameBytes = reader.readBytes(nameLength);
+  const name = new TextDecoder("utf-8", { fatal: false }).decode(nameBytes).replace(/\0+$/, "").trim();
+  const icons = [];
+  const textContents = [];
+  while (reader.remaining >= 4) {
+    const marker = reader.readUint16();
+    if (marker === 2) {
+      const iconId = reader.readUint16();
+      icons.push(iconId);
+    } else if (marker === 3) {
+      const val = reader.readUint16();
+      if (val > 1) {
+        if (reader.remaining < val) break;
+        const textBytes = reader.readBytes(val);
+        const textContent = new TextDecoder("utf-8", { fatal: false }).decode(textBytes).replace(/\0+$/, "");
+        textContents.push(textContent);
+      } else {
+        reader.seek(reader.position - 4);
+        break;
+      }
+    } else {
+      reader.seek(reader.position - 2);
+      break;
+    }
+  }
+  const n = icons.length;
+  const positions = [];
+  const backgrounds = [];
+  const sizes = [];
+  const colors = [];
+  const tag10 = [];
+  const tag11 = [];
+  const tag12 = [];
+  const objectFlags = [];
+  let boardBackground = 1;
+  while (reader.remaining >= 2) {
+    const tag = reader.readUint16();
+    if (tag === 2) {
+      if (reader.remaining < 2) break;
+      const iconId = reader.readUint16();
+      icons.push(iconId);
+    } else if (tag === 4) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const countVal = reader.readUint16();
+      if (countVal > 1) {
+        if (reader.remaining < countVal * 2) break;
+        for (let i = 0; i < countVal; i++) {
+          objectFlags.push(reader.readUint16());
+        }
+      } else {
+        if (reader.remaining < 2) break;
+        objectFlags.push(reader.readUint16());
+      }
+    } else if (tag === 5) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 4; i++) {
+        const x = reader.readInt16() / 10;
+        const y = reader.readInt16() / 10;
+        positions.push({ x, y });
+      }
+    } else if (tag === 6) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 2; i++) {
+        backgrounds.push(reader.readInt16());
+      }
+    } else if (tag === 7) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 1; i++) {
+        sizes.push(reader.readUint8());
+      }
+      if (count % 2 === 1 && reader.remaining >= 1) {
+        reader.readUint8();
+      }
+    } else if (tag === 8) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 4; i++) {
+        const r = reader.readUint8();
+        const g = reader.readUint8();
+        const b = reader.readUint8();
+        const a = reader.readUint8();
+        colors.push({ r, g, b, a });
+      }
+    } else if (tag === 10) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 2; i++) {
+        tag10.push(reader.readUint16());
+      }
+    } else if (tag === 11) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 2; i++) {
+        tag11.push(reader.readUint16());
+      }
+    } else if (tag === 12) {
+      if (reader.remaining < 4) break;
+      reader.readUint16();
+      const count = reader.readUint16();
+      for (let i = 0; i < count && reader.remaining >= 2; i++) {
+        tag12.push(reader.readUint16());
+      }
+    } else if (tag === 3) {
+      if (reader.remaining < 2) break;
+      const val = reader.readUint16();
+      if (val === 1) {
+        if (reader.remaining < 4) break;
+        reader.readUint16();
+        boardBackground = reader.readUint16();
+        break;
+      } else {
+        if (reader.remaining < val) break;
+        const textBytes = reader.readBytes(val);
+        const textContent = new TextDecoder("utf-8", { fatal: false }).decode(textBytes).replace(/\0+$/, "");
+        textContents.push(textContent);
+      }
+    } else {
+      break;
+    }
+  }
+  const objects = [];
+  for (let i = 0; i < n; i++) {
+    const iconId = icons[i];
+    const typeName = ICON_TYPES[iconId] ?? `unknown_${iconId}`;
+    const obj = {
+      type: typeName,
+      typeId: iconId,
+      x: positions[i]?.x ?? 0,
+      y: positions[i]?.y ?? 0
+    };
+    obj.size = sizes[i] && sizes[i] > 0 ? sizes[i] : 100;
+    const rotatableTypes = /* @__PURE__ */ new Set([10, 11, 12, 15, 16, 17, 18, 19, 110]);
+    if (rotatableTypes.has(iconId)) {
+      if (backgrounds[i] !== void 0 && backgrounds[i] !== 0) {
+        obj.angle = backgrounds[i];
+      }
+    } else if (backgrounds[i] !== void 0 && backgrounds[i] > 0) {
+      const bgName = OBJECT_BACKGROUND_TYPES[backgrounds[i]];
+      obj.background = bgName ?? backgrounds[i];
+    }
+    const colorableTypes = /* @__PURE__ */ new Set([11, 12, 100]);
+    if (colors[i] && colorableTypes.has(iconId)) {
+      const { r, g, b, a } = colors[i];
+      const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+      obj.color = hex;
+      if (a > 0) {
+        obj.transparency = a;
+      }
+    }
+    if (iconId === 11) {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.width = tag10[i];
+      }
+      if (tag11[i] && tag11[i] > 0) {
+        obj.height = tag11[i];
+      }
+    } else if (iconId === 10) {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.arcAngle = tag10[i];
+      }
+    } else if (iconId === 12) {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.endX = tag10[i] / 10;
+      }
+      if (tag11[i] && tag11[i] > 0) {
+        obj.endY = tag11[i] / 10;
+      }
+      if (tag12[i] && tag12[i] > 0) {
+        obj.height = tag12[i];
+      }
+    } else if (iconId === 15) {
+      if (tag11[i] && tag11[i] > 0) {
+        obj.displayCount = tag11[i];
+      }
+    } else if (iconId === 110) {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.horizontalCount = tag10[i];
+      }
+      if (tag11[i] && tag11[i] > 0) {
+        obj.verticalCount = tag11[i];
+      }
+    } else if (iconId === 17) {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.arcAngle = tag10[i];
+      }
+      if (tag11[i] && tag11[i] > 0) {
+        obj.donutRadius = tag11[i];
+      }
+    } else {
+      if (tag10[i] && tag10[i] > 0) {
+        obj.arcAngle = tag10[i];
+      }
+      if (tag11[i] && tag11[i] > 0) {
+        obj.donutRadius = tag11[i];
+      }
+    }
+    if (iconId === 100 && textContents.length > 0) {
+      obj.text = textContents.shift();
+    }
+    const objFlags = objectFlags[i] ?? 1;
+    if ((objFlags & 1) === 0) {
+      obj.hidden = true;
+    }
+    if (objFlags & 2) {
+      obj.horizontalFlip = true;
+    }
+    if (objFlags & 4) {
+      obj.verticalFlip = true;
+    }
+    if (objFlags & 8) {
+      obj.locked = true;
+    }
+    objects.push(obj);
+  }
+  return {
+    version,
+    name: name || void 0,
+    boardBackground: BOARD_BACKGROUND_TYPES[boardBackground] ?? "none",
+    objects
+  };
+}
+function buildBinary(data) {
+  const { name, boardBackground, objects } = data;
+  const n = objects.length;
+  const tag4Size = n <= 1 ? 8 : 6 + n * 2;
+  const tag7Size = 6 + n + (n % 2 === 1 ? 1 : 0);
+  const bufferSize = n === 0 ? 36 + 8 : 36 + n * 4 + tag4Size + (6 + n * 4) + (6 + n * 2) + tag7Size + (6 + n * 4) + (6 + n * 2) + (6 + n * 2) + (6 + n * 2) + 8;
+  const buffer = new ArrayBuffer(bufferSize);
+  const view = new DataView(buffer);
+  let pos = 0;
+  const writeUint8 = (val) => {
+    view.setUint8(pos, val);
+    pos += 1;
+  };
+  const writeUint16 = (val) => {
+    view.setUint16(pos, val, true);
+    pos += 2;
+  };
+  const writeInt16 = (val) => {
+    view.setInt16(pos, val, true);
+    pos += 2;
+  };
+  const writeUint32 = (val) => {
+    view.setUint32(pos, val, true);
+    pos += 4;
+  };
+  writeUint32(2);
+  writeUint32(0);
+  for (let i = 0; i < 10; i++) writeUint8(0);
+  writeUint32(0);
+  writeUint16(0);
+  writeUint16(1);
+  writeUint16(8);
+  const nameBytes = new TextEncoder().encode(name.slice(0, 7));
+  for (let i = 0; i < 8; i++) {
+    writeUint8(nameBytes[i] ?? 0);
+  }
+  for (const obj of objects) {
+    writeUint16(2);
+    writeUint16(obj.typeId);
+  }
+  if (n === 0) ; else if (n === 1) {
+    writeUint16(4);
+    writeUint16(1);
+    const obj = objects[0];
+    let flagsVal = 1;
+    if (obj.hidden) {
+      flagsVal = 0;
+    } else if (obj.locked) {
+      flagsVal = 9;
+    }
+    writeUint16(1);
+    writeUint16(flagsVal);
+  } else {
+    writeUint16(4);
+    writeUint16(1);
+    writeUint16(n);
+    for (let i = 0; i < n; i++) {
+      writeUint16(1);
+    }
+  }
+  if (n > 0) {
+    writeUint16(5);
+    writeUint16(3);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeInt16(Math.round(obj.x * 10));
+      writeInt16(Math.round(obj.y * 10));
+    }
+    writeUint16(6);
+    writeUint16(1);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeUint16(obj.background);
+    }
+    writeUint16(7);
+    writeUint16(0);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeUint8(obj.size & 255);
+    }
+    if (n % 2 === 1) {
+      writeUint8(0);
+    }
+    writeUint16(8);
+    writeUint16(2);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeUint8(obj.colorR);
+      writeUint8(obj.colorG);
+      writeUint8(obj.colorB);
+      writeUint8(obj.transparency);
+    }
+    writeUint16(10);
+    writeUint16(1);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeUint16(obj.arcAngle);
+    }
+    writeUint16(11);
+    writeUint16(1);
+    writeUint16(n);
+    for (const obj of objects) {
+      writeUint16(obj.donutRadius);
+    }
+    writeUint16(12);
+    writeUint16(1);
+    writeUint16(n);
+    for (let i = 0; i < n; i++) {
+      writeUint16(0);
+    }
+  }
+  writeUint16(3);
+  writeUint16(1);
+  writeUint16(1);
+  writeUint16(boardBackground);
+  const result = new Uint8Array(buffer, 0, pos);
+  const headerView = new DataView(result.buffer, result.byteOffset, result.byteLength);
+  const payloadSize = pos - 28;
+  headerView.setUint32(18, payloadSize, true);
+  const field04 = pos - 16;
+  headerView.setUint32(4, field04, true);
+  return result;
+}
+function charToBase64Value(c) {
+  const o = c.charCodeAt(0);
+  if (o >= 65 && o <= 90) return o - 65;
+  if (o >= 97 && o <= 122) return o - 71;
+  if (o >= 48 && o <= 57) return o + 4;
+  if (c === "-") return 62;
+  if (c === "_") return 63;
+  return 0;
+}
+function base64ValueToChar(val) {
+  val = val & 63;
+  if (val < 26) return String.fromCharCode(val + 65);
+  if (val < 52) return String.fromCharCode(val + 71);
+  if (val < 62) return String.fromCharCode(val - 4);
+  if (val === 62) return "-";
+  if (val === 63) return "_";
+  return "A";
+}
+function decodeCipher(stgyString) {
+  const data = stgyString.slice(7, -1);
+  if (data.length < 2) {
+    throw new Error("Share code body is too short");
+  }
+  const keyChar = data[0];
+  const keyCharCode = keyChar.charCodeAt(0);
+  if (keyCharCode >= CIPHER_TABLE.length) {
+    throw new Error("Invalid key character in share code");
+  }
+  const keyMapped = CIPHER_TABLE[keyCharCode];
+  if (keyMapped === 0) {
+    throw new Error("Invalid key character in share code");
+  }
+  const keyMappedChar = String.fromCharCode(keyMapped);
+  const key = charToBase64Value(keyMappedChar);
+  const decoded = [];
+  for (let i = 0; i < data.length - 1; i++) {
+    const c = data[i + 1];
+    const charCode = c.charCodeAt(0);
+    const standardCharCode = INVERSE_MAPPING[charCode] ?? 65;
+    const standardChar = String.fromCharCode(standardCharCode);
+    const val = charToBase64Value(standardChar);
+    const decodedVal = val - i - key & 63;
+    decoded.push(base64ValueToChar(decodedVal));
+  }
+  let b64String = decoded.join("").replace(/-/g, "+").replace(/_/g, "/");
+  const padLength = (4 - b64String.length % 4) % 4;
+  b64String += "=".repeat(padLength);
+  const binaryString = atob(b64String);
+  const binaryData = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    binaryData[i] = binaryString.charCodeAt(i);
+  }
+  if (binaryData.length < 7) {
+    throw new Error("Binary data is too short");
+  }
+  try {
+    const compressed = binaryData.slice(6);
+    return pako.inflate(compressed);
+  } catch (e) {
+    throw new Error(`Failed to decompress data: ${e instanceof Error ? e.message : "unknown error"}`);
+  }
+}
+function encodeCipher(binaryData, key) {
+  const compressed = pako.deflate(binaryData, { level: 6 });
+  const length = binaryData.length;
+  const lengthBytes = new Uint8Array(2);
+  lengthBytes[0] = length & 255;
+  lengthBytes[1] = length >> 8 & 255;
+  const checksumInput = new Uint8Array(2 + compressed.length);
+  checksumInput.set(lengthBytes, 0);
+  checksumInput.set(compressed, 2);
+  const checksum = crc32(checksumInput);
+  const fullData = new Uint8Array(6 + compressed.length);
+  fullData[0] = checksum & 255;
+  fullData[1] = checksum >> 8 & 255;
+  fullData[2] = checksum >> 16 & 255;
+  fullData[3] = checksum >> 24 & 255;
+  fullData[4] = lengthBytes[0];
+  fullData[5] = lengthBytes[1];
+  fullData.set(compressed, 6);
+  let b64 = "";
+  for (let i = 0; i < fullData.length; i++) {
+    b64 += String.fromCharCode(fullData[i]);
+  }
+  b64 = btoa(b64);
+  b64 = b64.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+  if (key === void 0 || key < 0 || key > 63) {
+    key = Math.floor(Math.random() * 64);
+  }
+  const keyCharStandard = base64ValueToChar(key);
+  const keyCharCode = keyCharStandard.charCodeAt(0);
+  const keySource = KEY_REVERSE[keyCharCode] ?? 86;
+  const encoded = [];
+  for (let i = 0; i < b64.length; i++) {
+    const c = b64[i];
+    const val = charToBase64Value(c);
+    const encodedVal = val + i + key & 63;
+    const standardChar = base64ValueToChar(encodedVal);
+    const standardCharCode = standardChar.charCodeAt(0);
+    const substChar = FORWARD_MAPPING[standardCharCode] ?? 65;
+    encoded.push(String.fromCharCode(substChar));
+  }
+  return `[stgy:a${String.fromCharCode(keySource)}${encoded.join("")}]`;
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i];
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = crc >>> 1 ^ 3988292384;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/encoder.ts
+function encode(board, options) {
+  const sanitized = sanitizeBoard(board);
+  const binary = buildBinary(sanitized);
+  return encodeCipher(binary, options?.key);
+}
+
+// src/decoder.ts
+function decode(shareCode) {
+  validateShareCode(shareCode);
+  const binary = decodeCipher(shareCode);
+  return parseBinary(binary);
+}
+
+export { ICON_TYPES, ICON_TYPE_IDS, decode, encode };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map