hwpkit-dev 0.0.1

package/dist/index.js

@@ -0,0 +1,3546 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  A4: () => A4,
+  ArchiveKit: () => ArchiveKit,
+  BinaryKit: () => BinaryKit,
+  DEFAULT_STROKE: () => DEFAULT_STROKE,
+  Metric: () => Metric,
+  Pipeline: () => Pipeline,
+  ShieldedParser: () => ShieldedParser,
+  TextKit: () => TextKit,
+  TreeWalker: () => TreeWalker,
+  XmlKit: () => XmlKit,
+  buildCell: () => buildCell,
+  buildGrid: () => buildGrid,
+  buildImg: () => buildImg,
+  buildPageNum: () => buildPageNum,
+  buildPara: () => buildPara,
+  buildRoot: () => buildRoot,
+  buildRow: () => buildRow,
+  buildSheet: () => buildSheet,
+  buildSpan: () => buildSpan,
+  countNodes: () => countNodes,
+  fail: () => fail,
+  registry: () => registry,
+  safeAlign: () => safeAlign,
+  safeFont: () => safeFont,
+  safeFontToKr: () => safeFontToKr,
+  safeHex: () => safeHex,
+  safeStrokeDocx: () => safeStrokeDocx,
+  safeStrokeHwpx: () => safeStrokeHwpx,
+  succeed: () => succeed,
+  validateRoot: () => validateRoot,
+  walkNode: () => walkNode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/contract/result.ts
+function succeed(data, warns = []) {
+  return { ok: true, data, warns };
+}
+function fail(error, warns = []) {
+  return { ok: false, error, warns };
+}
+
+// src/pipeline/registry.ts
+var FormatRegistry = class {
+  constructor() {
+    this.decoders = /* @__PURE__ */ new Map();
+    this.encoders = /* @__PURE__ */ new Map();
+  }
+  registerDecoder(d) {
+    this.decoders.set(d.format, d);
+  }
+  registerEncoder(e) {
+    this.encoders.set(e.format, e);
+  }
+  getDecoder(fmt) {
+    return this.decoders.get(fmt);
+  }
+  getEncoder(fmt) {
+    return this.encoders.get(fmt);
+  }
+  supportedInputs() {
+    return [...this.decoders.keys()];
+  }
+  supportedOutputs() {
+    return [...this.encoders.keys()];
+  }
+};
+var registry = new FormatRegistry();
+
+// src/model/doc-props.ts
+var A4 = {
+  wPt: 595.28,
+  hPt: 841.89,
+  mt: 56.69,
+  mb: 56.69,
+  ml: 70.87,
+  mr: 70.87,
+  orient: "portrait"
+};
+var DEFAULT_STROKE = { kind: "solid", pt: 0.5, color: "000000" };
+
+// src/model/builders.ts
+function buildRoot(meta = {}, kids = []) {
+  return { tag: "root", meta, kids };
+}
+function buildSheet(kids = [], dims = A4, opts) {
+  const node = { tag: "sheet", dims, kids };
+  if (opts?.header) node.header = opts.header;
+  if (opts?.footer) node.footer = opts.footer;
+  return node;
+}
+function buildPageNum(format) {
+  return { tag: "pagenum", format };
+}
+function buildPara(kids = [], props = {}) {
+  return { tag: "para", props, kids };
+}
+function buildSpan(content, props = {}) {
+  const txt = { tag: "txt", content };
+  return { tag: "span", props, kids: [txt] };
+}
+function buildImg(b64, mime, w, h, alt) {
+  return { tag: "img", b64, mime, w, h, alt };
+}
+function buildGrid(kids, props = {}) {
+  return { tag: "grid", props, kids };
+}
+function buildRow(kids) {
+  return { tag: "row", kids };
+}
+function buildCell(kids, opts = {}) {
+  return { tag: "cell", cs: opts.cs ?? 1, rs: opts.rs ?? 1, props: opts.props ?? {}, kids };
+}
+
+// src/safety/ShieldedParser.ts
+var ShieldedParser = class {
+  constructor() {
+    this.log = [];
+  }
+  /** 단일 요소 안전 파싱 */
+  guard(fn, fallback, label) {
+    try {
+      const v = fn();
+      if (v == null) {
+        this.warn(label, "returned null/undefined");
+        return fallback;
+      }
+      return v;
+    } catch (e) {
+      this.warn(label, e?.message ?? String(e));
+      return fallback;
+    }
+  }
+  /** 배열 각 요소 독립 파싱 (하나 실패해도 나머지 계속) */
+  guardAll(items, fn, fb, label) {
+    return items.map(
+      (x, i) => this.guard(() => fn(x, i), fb(x, i), `${label}[${i}]`)
+    );
+  }
+  /**
+   * 표 전용 4단계 폴백
+   *   Lv1: Full → Lv2: Grid → Lv3: Flat → Lv4: Text
+   */
+  guardGrid(node, lv1Full, lv2Grid, lv3Flat, lv4Text, label) {
+    const levels = [
+      [lv1Full, 1],
+      [lv2Grid, 2],
+      [lv3Flat, 3],
+      [lv4Text, 4]
+    ];
+    for (const [fn, lv] of levels) {
+      try {
+        const v = fn(node);
+        if (v != null) {
+          if (lv > 1) this.warn(label, `degraded to level ${lv}`);
+          return { value: v, level: lv };
+        }
+      } catch (e) {
+        this.warn(label, `Lv${lv} failed: ${e?.message ?? String(e)}`);
+      }
+    }
+    this.warn(label, "ALL LEVELS FAILED \u2014 returning lv4Text forced");
+    return { value: lv4Text(null), level: 4 };
+  }
+  /** 이미지 안전 파싱 */
+  guardImg(node, fn, placeholder, label) {
+    try {
+      const v = fn(node);
+      if (v != null) return v;
+    } catch (e) {
+      this.warn(label, e?.message ?? String(e));
+    }
+    this.warn(label, "using placeholder image");
+    return placeholder(`[\uC774\uBBF8\uC9C0 \uB85C\uB4DC \uC2E4\uD328: ${label}]`);
+  }
+  warn(label, msg) {
+    const w = `[SHIELD] ${label}: ${msg}`;
+    console.warn(w);
+    this.log.push(w);
+  }
+  flush() {
+    const r = [...this.log];
+    this.log = [];
+    return r;
+  }
+};
+
+// src/safety/StyleBridge.ts
+var Metric = {
+  // HWP 세계 (1 inch = 7200 HWPUNIT)
+  hwpToPt: (v) => v / 100,
+  ptToHwp: (v) => Math.round(v * 100),
+  hwpToDxa: (v) => Math.round(v / 5),
+  dxaToHwp: (v) => Math.round(v * 5),
+  hwpToEmu: (v) => Math.round(v * 127),
+  emuToHwp: (v) => Math.round(v / 127),
+  // DOCX 세계 (1 inch = 1440 dxa, 1 pt = 20 dxa)
+  dxaToPt: (v) => v / 20,
+  ptToDxa: (v) => Math.round(v * 20),
+  dxaToEmu: (v) => Math.round(v * 635),
+  emuToDxa: (v) => Math.round(v / 635),
+  emuToPt: (v) => v / 12700,
+  ptToEmu: (v) => Math.round(v * 12700),
+  // HWPX charPr height: 1000 = 10pt
+  hHeightToPt: (v) => v / 100,
+  ptToHHeight: (v) => Math.round(v * 100),
+  // DOCX half-point: 24 = 12pt
+  halfPtToPt: (v) => v / 2,
+  ptToHalfPt: (v) => Math.round(v * 2)
+};
+function safeHex(raw) {
+  if (raw == null) return void 0;
+  if (typeof raw === "number") {
+    if (raw <= 0) return "000000";
+    if (raw >= 16777215) return void 0;
+    return raw.toString(16).padStart(6, "0").toUpperCase();
+  }
+  let s = String(raw).replace(/^#/, "").toUpperCase();
+  if (/^[0-9A-F]{3}$/.test(s)) s = s[0] + s[0] + s[1] + s[1] + s[2] + s[2];
+  if (/^[0-9A-F]{6}$/.test(s)) return s;
+  if (s === "AUTO" || s === "NONE" || s === "TRANSPARENT") return void 0;
+  return void 0;
+}
+var ALIGN_MAP = {
+  LEFT: "left",
+  CENTER: "center",
+  RIGHT: "right",
+  JUSTIFY: "justify",
+  BOTH: "justify",
+  DISTRIBUTE: "justify",
+  left: "left",
+  center: "center",
+  right: "right",
+  both: "justify",
+  start: "left",
+  end: "right"
+};
+function safeAlign(raw) {
+  return ALIGN_MAP[raw ?? ""] ?? "justify";
+}
+var HWPX_STROKE = {
+  SOLID: "solid",
+  NONE: "none",
+  DASH: "dash",
+  DOT: "dot",
+  DOUBLE: "double",
+  LONG_DASH: "dash",
+  DASH_DOT: "dash"
+};
+var DOCX_STROKE = {
+  single: "solid",
+  none: "none",
+  nil: "none",
+  dashed: "dash",
+  dotted: "dot",
+  double: "double",
+  wave: "solid"
+};
+function safeStrokeHwpx(type, w, c) {
+  return {
+    kind: HWPX_STROKE[type ?? ""] ?? "solid",
+    pt: w != null ? Metric.hwpToPt(w) : 0.5,
+    color: safeHex(c) ?? "000000"
+  };
+}
+function safeStrokeDocx(val, sz, c) {
+  return {
+    kind: DOCX_STROKE[val ?? ""] ?? "solid",
+    pt: sz != null ? sz / 8 : 0.5,
+    color: safeHex(c) ?? "000000"
+  };
+}
+var FONT_MAP = {
+  "\uB9D1\uC740 \uACE0\uB515": "Malgun Gothic",
+  "\uBC14\uD0D5": "Batang",
+  "\uB3CB\uC6C0": "Dotum",
+  "\uAD74\uB9BC": "Gulim",
+  "\uD55C\uCEF4\uBC14\uD0D5": "Batang",
+  "\uD55C\uCEF4\uB3CB\uC6C0": "Malgun Gothic",
+  "\uD568\uCD08\uB86C\uBC14\uD0D5": "Batang",
+  "\uD568\uCD08\uB86C\uB3CB\uC6C0": "Malgun Gothic"
+};
+function safeFont(raw) {
+  return FONT_MAP[raw ?? ""] ?? raw ?? "Malgun Gothic";
+}
+var FONT_MAP_KR = {
+  "Malgun Gothic": "\uB9D1\uC740 \uACE0\uB515",
+  "Batang": "\uBC14\uD0D5",
+  "Dotum": "\uB3CB\uC6C0",
+  "Gulim": "\uAD74\uB9BC"
+};
+function safeFontToKr(raw) {
+  return FONT_MAP_KR[raw ?? ""] ?? raw ?? "\uB9D1\uC740 \uACE0\uB515";
+}
+
+// src/toolkit/ArchiveKit.ts
+var import_pako = __toESM(require("pako"));
+var ArchiveKit = {
+  async inflate(compressed) {
+    return import_pako.default.inflate(compressed);
+  },
+  async deflate(data) {
+    return import_pako.default.deflate(data, { level: 6 });
+  },
+  async unzip(zipData) {
+    const files = /* @__PURE__ */ new Map();
+    const view = new DataView(zipData.buffer, zipData.byteOffset, zipData.byteLength);
+    let offset = 0;
+    while (offset < zipData.length - 4) {
+      const sig = view.getUint32(offset, true);
+      if (sig === 67324752) {
+        const compressionMethod = view.getUint16(offset + 8, true);
+        const compressedSize = view.getUint32(offset + 18, true);
+        const uncompressedSize = view.getUint32(offset + 22, true);
+        const fileNameLength = view.getUint16(offset + 26, true);
+        const extraLength = view.getUint16(offset + 28, true);
+        const nameBytes = zipData.subarray(offset + 30, offset + 30 + fileNameLength);
+        const name = new TextDecoder("utf-8").decode(nameBytes);
+        const dataOffset = offset + 30 + fileNameLength + extraLength;
+        let fileData;
+        if (compressionMethod === 0) {
+          fileData = zipData.subarray(dataOffset, dataOffset + uncompressedSize);
+        } else if (compressionMethod === 8) {
+          const compressed = zipData.subarray(dataOffset, dataOffset + compressedSize);
+          fileData = import_pako.default.inflateRaw(compressed);
+        } else {
+          throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
+        }
+        files.set(name, new Uint8Array(fileData));
+        offset = dataOffset + compressedSize;
+      } else if (sig === 33639248 || sig === 101010256) {
+        break;
+      } else {
+        offset++;
+      }
+    }
+    return files;
+  },
+  async zip(entries) {
+    const localHeaders = [];
+    const centralHeaders = [];
+    let localOffset = 0;
+    for (const entry of entries) {
+      const nameBytes = new TextEncoder().encode(entry.name);
+      const crc = crc32(entry.data);
+      const store = entry.name === "mimetype" || entry.name === "version.xml";
+      const method = store ? 0 : 8;
+      const payload = store ? entry.data : import_pako.default.deflateRaw(entry.data, { level: 6 });
+      const local = new Uint8Array(30 + nameBytes.length + payload.length);
+      const lv = new DataView(local.buffer);
+      lv.setUint32(0, 67324752, true);
+      lv.setUint16(4, 20, true);
+      lv.setUint16(6, 0, true);
+      lv.setUint16(8, method, true);
+      lv.setUint16(10, 0, true);
+      lv.setUint16(12, 33, true);
+      lv.setUint32(14, crc, true);
+      lv.setUint32(18, payload.length, true);
+      lv.setUint32(22, entry.data.length, true);
+      lv.setUint16(26, nameBytes.length, true);
+      lv.setUint16(28, 0, true);
+      local.set(nameBytes, 30);
+      local.set(payload, 30 + nameBytes.length);
+      const central = new Uint8Array(46 + nameBytes.length);
+      const cv = new DataView(central.buffer);
+      cv.setUint32(0, 33639248, true);
+      cv.setUint16(4, 20, true);
+      cv.setUint16(6, 20, true);
+      cv.setUint16(8, 0, true);
+      cv.setUint16(10, method, true);
+      cv.setUint16(12, 0, true);
+      cv.setUint16(14, 33, true);
+      cv.setUint32(16, crc, true);
+      cv.setUint32(20, payload.length, true);
+      cv.setUint32(24, entry.data.length, true);
+      cv.setUint16(28, nameBytes.length, true);
+      cv.setUint16(30, 0, true);
+      cv.setUint16(32, 0, true);
+      cv.setUint16(34, 0, true);
+      cv.setUint16(36, 0, true);
+      cv.setUint32(38, 0, true);
+      cv.setUint32(42, localOffset, true);
+      central.set(nameBytes, 46);
+      localHeaders.push(local);
+      centralHeaders.push(central);
+      localOffset += local.length;
+    }
+    const centralDir = concat(centralHeaders);
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    ev.setUint32(0, 101010256, true);
+    ev.setUint16(4, 0, true);
+    ev.setUint16(6, 0, true);
+    ev.setUint16(8, entries.length, true);
+    ev.setUint16(10, entries.length, true);
+    ev.setUint32(12, centralDir.length, true);
+    ev.setUint32(16, localOffset, true);
+    ev.setUint16(20, 0, true);
+    return concat([...localHeaders, centralDir, eocd]);
+  }
+};
+function concat(arrays) {
+  const total = arrays.reduce((s, a) => s + a.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/toolkit/XmlKit.ts
+var import_saxes = require("saxes");
+function parseXmlStrict(xml) {
+  return new Promise((resolve, reject) => {
+    const parser = new import_saxes.SaxesParser({ xmlns: false });
+    const stack = [];
+    let result = null;
+    parser.on("error", (err) => reject(err));
+    parser.on("opentag", (node) => {
+      const obj = {};
+      const attrs = node.attributes;
+      if (attrs && Object.keys(attrs).length > 0) {
+        obj["_attr"] = { ...attrs };
+      }
+      stack.push({ tag: node.name, obj });
+    });
+    const appendText = (text) => {
+      if (stack.length > 0 && text) {
+        const frame = stack[stack.length - 1];
+        const cur = frame.obj["_text"];
+        frame.obj["_text"] = typeof cur === "string" ? cur + text : text;
+      }
+    };
+    parser.on("text", (text) => appendText(text));
+    parser.on("cdata", (cdata) => appendText(cdata));
+    parser.on("closetag", () => {
+      const frame = stack.pop();
+      if (!frame) return;
+      const { tag, obj } = frame;
+      if (typeof obj["_text"] === "string" && !obj["_text"].trim()) {
+        delete obj["_text"];
+      }
+      if (stack.length === 0) {
+        result = { [tag]: [obj] };
+      } else {
+        const parent = stack[stack.length - 1].obj;
+        const existing = parent[tag];
+        if (Array.isArray(existing)) {
+          existing.push(obj);
+        } else {
+          parent[tag] = [obj];
+        }
+        if (!parent["_childOrder"]) parent["_childOrder"] = [];
+        parent["_childOrder"].push(tag);
+      }
+    });
+    try {
+      parser.write(xml).close();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+var XmlKit = {
+  /** @deprecated Use parseStrict instead */
+  async parse(xml) {
+    return parseXmlStrict(xml);
+  },
+  async parseStrict(xml) {
+    return parseXmlStrict(xml);
+  },
+  attr(node, key) {
+    const a = node["_attr"];
+    return a?.[key];
+  },
+  text(node) {
+    if (node == null) return "";
+    if (typeof node === "string") return node;
+    const t = node["_text"];
+    return typeof t === "string" ? t : "";
+  }
+};
+
+// src/toolkit/TextKit.ts
+var TextKit = {
+  decode(data, encoding = "utf-8") {
+    try {
+      return new TextDecoder(encoding, { fatal: true }).decode(data);
+    } catch {
+      return new TextDecoder("utf-8", { fatal: false }).decode(data);
+    }
+  },
+  encode(text) {
+    return new TextEncoder().encode(text);
+  },
+  escapeXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  },
+  unescapeXml(s) {
+    return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+  },
+  normalizeWhitespace(s) {
+    return s.replace(/\s+/g, " ").trim();
+  },
+  stripControl(s) {
+    return s.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+  },
+  base64Encode(data) {
+    let binary = "";
+    for (let i = 0; i < data.length; i++) {
+      binary += String.fromCharCode(data[i]);
+    }
+    return btoa(binary);
+  },
+  base64Decode(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+};
+
+// src/decoders/hwpx/HwpxDecoder.ts
+var HwpxDecoder = class {
+  constructor() {
+    this.format = "hwpx";
+  }
+  async decode(data) {
+    const shield = new ShieldedParser();
+    const warns = [];
+    try {
+      const files = await ArchiveKit.unzip(data);
+      const bodyXml = files.get("Contents/section0.xml") ?? files.get("section0.xml") ?? findSectionFile(files);
+      if (!bodyXml) return fail("HWPX: section0.xml not found in archive");
+      const headXml = files.get("Contents/header.xml") ?? files.get("header.xml");
+      let meta = {};
+      let dims = { ...A4 };
+      let borderFills = /* @__PURE__ */ new Map();
+      let charPrs = /* @__PURE__ */ new Map();
+      let paraPrs = /* @__PURE__ */ new Map();
+      if (headXml) {
+        try {
+          const headStr = TextKit.decode(headXml);
+          const headObj = await XmlKit.parseStrict(headStr);
+          if (headObj) {
+            meta = extractMeta(headObj);
+            dims = extractDims(headObj) ?? dims;
+            borderFills = extractBorderFills(headObj);
+            charPrs = extractCharPrs(headObj);
+            paraPrs = extractParaPrs(headObj);
+          }
+        } catch {
+        }
+      }
+      const ctx = { files, shield, borderFills, charPrs, paraPrs, warns };
+      const bodyStr = TextKit.decode(bodyXml);
+      const bodyObj = await XmlKit.parseStrict(bodyStr);
+      const sections = normalizeSections(bodyObj);
+      const kids = shield.guardAll(
+        sections,
+        (sec) => decodeSection(sec, dims, ctx),
+        () => buildSheet([buildPara([buildSpan("[\uC139\uC158 \uD30C\uC2F1 \uC2E4\uD328]")])], dims),
+        "hwpx:section"
+      );
+      warns.push(...shield.flush());
+      return succeed(buildRoot(meta, kids), warns);
+    } catch (e) {
+      warns.push(...shield.flush());
+      return fail(`HWPX decode error: ${e?.message ?? String(e)}`, warns);
+    }
+  }
+};
+function findSectionFile(files) {
+  for (const [key, val] of files) {
+    if (key.toLowerCase().includes("section") && key.endsWith(".xml")) return val;
+  }
+  return void 0;
+}
+function normalizeSections(bodyObj) {
+  if (bodyObj?.["hs:sec"]) return toArr(bodyObj["hs:sec"]);
+  if (bodyObj?.["hp:SEC"]) return toArr(bodyObj["hp:SEC"]);
+  const root = bodyObj?.["hp:HWPML"] ?? bodyObj?.HWPML ?? bodyObj;
+  const body = root?.["hp:BODY"]?.[0] ?? root?.BODY?.[0] ?? root?.["hp:BODY"] ?? root?.BODY;
+  if (!body) return [bodyObj];
+  const sections = body?.["hp:SECTION"] ?? body?.SECTION ?? [];
+  return Array.isArray(sections) ? sections : [sections];
+}
+function getTag(obj, ...names) {
+  for (const n of names) {
+    const v = obj?.[n];
+    if (v != null) return toArr(v);
+  }
+  return [];
+}
+function extractMeta(headObj) {
+  try {
+    const root = headObj?.["hh:head"]?.[0] ?? headObj?.["hh:HEAD"]?.[0] ?? headObj?.HEAD?.[0] ?? headObj;
+    const info = root?.["hh:DOCSUMMARY"]?.[0] ?? root?.DOCSUMMARY?.[0];
+    if (!info) return {};
+    const a = (k) => info?.[`hh:${k}`]?.[0]?._text ?? info?.[k]?.[0]?._text ?? "";
+    return { title: a("TITLE") || void 0, author: a("AUTHOR") || void 0, subject: a("SUBJECT") || void 0 };
+  } catch {
+    return {};
+  }
+}
+function extractDims(headObj) {
+  try {
+    const root = headObj?.["hh:head"]?.[0] ?? headObj?.["hh:HEAD"]?.[0] ?? headObj?.HEAD?.[0] ?? headObj;
+    const refList = root?.["hh:refList"]?.[0] ?? root?.["hh:REFLIST"]?.[0] ?? root?.REFLIST?.[0];
+    if (!refList) return null;
+    const secPrList = refList?.["hh:SECPRLST"]?.[0]?.["hh:SECPR"] ?? refList?.SECPRLST?.[0]?.SECPR;
+    const sec = Array.isArray(secPrList) ? secPrList[0] : secPrList;
+    if (!sec) return null;
+    const pa = sec?.["hh:PAGEPROPERTY"]?.[0]?._attr ?? sec?.PAGEPROPERTY?.[0]?._attr;
+    if (!pa) return null;
+    return {
+      wPt: Metric.hwpToPt(Number(pa.Width ?? 59528)),
+      hPt: Metric.hwpToPt(Number(pa.Height ?? 84188)),
+      mt: Metric.hwpToPt(Number(pa.TopMargin ?? 5670)),
+      mb: Metric.hwpToPt(Number(pa.BottomMargin ?? 4252)),
+      ml: Metric.hwpToPt(Number(pa.LeftMargin ?? 8504)),
+      mr: Metric.hwpToPt(Number(pa.RightMargin ?? 8504)),
+      orient: Number(pa.Landscape) === 1 ? "landscape" : "portrait"
+    };
+  } catch {
+    return null;
+  }
+}
+function extractBorderFills(headObj) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const root = headObj?.["hh:head"]?.[0] ?? headObj?.["hh:HEAD"]?.[0] ?? headObj?.HEAD?.[0] ?? headObj;
+    const refList = root?.["hh:refList"]?.[0] ?? root?.["hh:REFLIST"]?.[0] ?? root?.REFLIST?.[0];
+    if (!refList) return map;
+    const bfList = refList?.["hh:borderFills"]?.[0] ?? refList?.["hh:BORDERFILLLIST"]?.[0] ?? refList?.BORDERFILLLIST?.[0];
+    if (!bfList) return map;
+    const bfs = getTag(bfList, "hh:borderFill", "hh:BORDERFILL");
+    for (const bf of bfs) {
+      const attr = bf?._attr ?? {};
+      const id = Number(attr.id ?? 0);
+      if (id === 0) continue;
+      const info = {};
+      const top = bf?.["hh:topBorder"]?.[0]?._attr ?? bf?.["hh:top"]?.[0]?._attr ?? bf?.top?.[0]?._attr;
+      if (top) {
+        const mmVal = parseFloat(top.width) || void 0;
+        const hwpVal = mmVal != null ? mmVal * 2.835 * 100 : void 0;
+        info.stroke = safeStrokeHwpx(top.type, hwpVal, top.color);
+      }
+      const fillBrush = bf?.["hc:fillBrush"]?.[0] ?? bf?.["hh:fillBrush"]?.[0] ?? bf?.["hh:fill"]?.[0] ?? bf?.fill?.[0] ?? bf?.fillBrush?.[0];
+      if (fillBrush) {
+        const winBrush = fillBrush?.["hc:winBrush"]?.[0]?._attr ?? fillBrush?.["hh:winBrush"]?.[0]?._attr ?? fillBrush?.winBrush?.[0]?._attr;
+        if (winBrush?.faceColor && winBrush.faceColor !== "none") {
+          info.bgColor = safeHex(winBrush.faceColor);
+        }
+      }
+      map.set(id, info);
+    }
+  } catch {
+  }
+  return map;
+}
+function extractCharPrs(headObj) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const root = headObj?.["hh:head"]?.[0] ?? headObj?.["hh:HEAD"]?.[0] ?? headObj?.HEAD?.[0] ?? headObj;
+    const refList = root?.["hh:refList"]?.[0] ?? root?.["hh:REFLIST"]?.[0] ?? root?.REFLIST?.[0];
+    if (!refList) return map;
+    const cpList = refList?.["hh:charProperties"]?.[0] ?? refList?.["hh:CHARPROPERTIES"]?.[0];
+    if (!cpList) return map;
+    const cps = getTag(cpList, "hh:charPr", "hh:CHARPR");
+    for (const cp of cps) {
+      const attr = cp?._attr ?? {};
+      const id = Number(attr.id ?? -1);
+      if (id < 0) continue;
+      const info = {};
+      if (attr.height) info.pt = Metric.hHeightToPt(Number(attr.height));
+      if (attr.textColor) info.color = safeHex(attr.textColor);
+      if (cp?.["hh:bold"]?.[0] != null) info.b = true;
+      if (cp?.["hh:italic"]?.[0] != null) info.i = true;
+      const ulAttr = cp?.["hh:underline"]?.[0]?._attr;
+      if (ulAttr?.type && ulAttr.type !== "NONE") info.u = true;
+      const stAttr = cp?.["hh:strikeout"]?.[0]?._attr;
+      if (stAttr?.shape && stAttr.shape !== "NONE" && stAttr.shape !== "3D") info.s = true;
+      map.set(id, info);
+    }
+  } catch {
+  }
+  return map;
+}
+function extractParaPrs(headObj) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const root = headObj?.["hh:head"]?.[0] ?? headObj?.["hh:HEAD"]?.[0] ?? headObj?.HEAD?.[0] ?? headObj;
+    const refList = root?.["hh:refList"]?.[0] ?? root?.["hh:REFLIST"]?.[0] ?? root?.REFLIST?.[0];
+    if (!refList) return map;
+    const ppList = refList?.["hh:paraProperties"]?.[0] ?? refList?.["hh:PARAPROPERTIES"]?.[0];
+    if (!ppList) return map;
+    const pps = getTag(ppList, "hh:paraPr", "hh:PARAPR");
+    for (const pp of pps) {
+      const attr = pp?._attr ?? {};
+      const id = Number(attr.id ?? -1);
+      if (id < 0) continue;
+      const alignNode = pp?.["hh:align"]?.[0]?._attr ?? pp?.["hh:ALIGN"]?.[0]?._attr;
+      const align = alignNode?.horizontal ?? alignNode?.Horizontal;
+      map.set(id, { align });
+    }
+  } catch {
+  }
+  return map;
+}
+function addParaItems(p, items) {
+  const runs = getTag(p, "hp:run", "hp:RUN");
+  let hasTable = false;
+  for (const run of runs) {
+    const tbls = getTag(run, "hp:tbl", "hp:TABLE");
+    for (const tbl of tbls) {
+      items.push({ type: "table", node: tbl });
+      hasTable = true;
+    }
+  }
+  const hasText = runs.some((run) => {
+    const ts = getTag(run, "hp:t", "hp:T", "hp:CHAR");
+    return ts.some((t) => {
+      const text = typeof t === "string" ? t : t?._text ?? "";
+      return text.trim().length > 0;
+    });
+  });
+  if (hasText || !hasTable) {
+    items.push({ type: "para", node: p });
+  }
+}
+function decodeSection(sec, dims, ctx) {
+  const firstParas = getTag(sec, "hp:p", "hp:P");
+  const pageDims = extractSecPrDims(firstParas[0]) ?? dims;
+  const items = [];
+  const paras = getTag(sec, "hp:p", "hp:P");
+  const childOrder = sec?.["_childOrder"];
+  if (Array.isArray(childOrder)) {
+    let pi = 0;
+    for (const tag of childOrder) {
+      if ((tag === "hp:p" || tag === "hp:P") && pi < paras.length) {
+        const p = paras[pi++];
+        addParaItems(p, items);
+      }
+    }
+    while (pi < paras.length) addParaItems(paras[pi++], items);
+  } else {
+    for (const p of paras) addParaItems(p, items);
+  }
+  const kids = ctx.shield.guardAll(
+    items,
+    (item) => {
+      if (item.type === "table") {
+        const { value } = ctx.shield.guardGrid(
+          item.node,
+          (n) => decodeGrid(n, ctx),
+          (n) => decodeGridSimple(n, ctx),
+          (n) => decodeGridFlat(n),
+          (n) => decodeGridText(n),
+          "hwpx:table"
+        );
+        return value;
+      }
+      return decodePara(item.node, ctx);
+    },
+    () => buildPara([buildSpan("[\uD30C\uC2F1 \uC2E4\uD328]")]),
+    "hwpx:content"
+  );
+  const headerParas = decodeHeaderFooter(sec, "header", ctx);
+  const footerParas = decodeHeaderFooter(sec, "footer", ctx);
+  return buildSheet(
+    kids.filter(Boolean),
+    pageDims,
+    { header: headerParas, footer: footerParas }
+  );
+}
+function extractSecPrDims(p) {
+  if (!p) return null;
+  try {
+    const runs = getTag(p, "hp:run", "hp:RUN");
+    for (const run of runs) {
+      const secPr = run?.["hp:secPr"]?.[0] ?? run?.["hp:SECPR"]?.[0];
+      if (!secPr) continue;
+      const pagePr = secPr?.["hp:pagePr"]?.[0]?._attr ?? secPr?.["hp:PAGEPR"]?.[0]?._attr;
+      if (!pagePr) continue;
+      const margin = secPr?.["hp:pagePr"]?.[0]?.["hp:margin"]?.[0]?._attr ?? secPr?.["hp:PAGEPR"]?.[0]?.["hp:MARGIN"]?.[0]?._attr ?? {};
+      return {
+        wPt: Metric.hwpToPt(Number(pagePr.width ?? 59528)),
+        hPt: Metric.hwpToPt(Number(pagePr.height ?? 84188)),
+        mt: Metric.hwpToPt(Number(margin.top ?? 5670)),
+        mb: Metric.hwpToPt(Number(margin.bottom ?? 4252)),
+        ml: Metric.hwpToPt(Number(margin.left ?? 8504)),
+        mr: Metric.hwpToPt(Number(margin.right ?? 8504)),
+        orient: pagePr.landscape === "NARROWLY" ? "landscape" : "portrait"
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function decodeHeaderFooter(sec, kind, ctx) {
+  try {
+    const hf = sec?.["hp:headerFooter"]?.[0] ?? sec?.["hp:HEADERFOOTER"]?.[0] ?? sec?.headerFooter?.[0] ?? sec?.HEADERFOOTER?.[0];
+    if (!hf) return void 0;
+    const part = hf?.["hp:" + kind]?.[0] ?? hf?.["hp:" + kind.toUpperCase()]?.[0] ?? hf?.[kind]?.[0] ?? hf?.[kind.toUpperCase()]?.[0];
+    if (!part) return void 0;
+    const paras = getTag(part, "hp:p", "hp:P");
+    if (paras.length === 0) return void 0;
+    return paras.map((p) => decodePara(p, ctx));
+  } catch {
+    return void 0;
+  }
+}
+function decodePara(p, ctx) {
+  const pAttr = p?._attr ?? {};
+  const paraPrIdRef = Number(pAttr.paraPrIDRef ?? -1);
+  let align;
+  const paraPrDef = ctx.paraPrs.get(paraPrIdRef);
+  if (paraPrDef?.align) align = paraPrDef.align;
+  const inlineParaPr = p?.["hp:PARAPR"]?.[0] ?? p?.["hp:paraPr"]?.[0] ?? p?.PARAPR?.[0];
+  if (inlineParaPr) {
+    const alignNode = inlineParaPr?.["hp:ALIGN"]?.[0]?._attr ?? inlineParaPr?.["hp:align"]?.[0]?._attr ?? inlineParaPr?.ALIGN?.[0]?._attr;
+    if (alignNode?.Type) align = alignNode.Type;
+    if (alignNode?.horizontal) align = alignNode.horizontal;
+  }
+  const inlineAttr = inlineParaPr?._attr ?? {};
+  const props = { align: safeAlign(align) };
+  if (inlineAttr.listType) {
+    props.listOrd = inlineAttr.listType === "DIGIT" || inlineAttr.listType === "DECIMAL";
+    props.listLv = Number(inlineAttr.listLevel ?? 0);
+  }
+  const runs = getTag(p, "hp:run", "hp:RUN");
+  const kids = [];
+  for (const run of runs) {
+    const pics = getTag(run, "hp:pic", "hp:PIC");
+    for (const pic of pics) {
+      const img = decodePic(pic, ctx);
+      if (img) kids.push(img);
+    }
+    const pageNums = getTag(run, "hp:pageNum", "hp:PAGENUM");
+    if (pageNums.length > 0) {
+      const pn = pageNums[0]?._attr ?? {};
+      const fmt = pn.formatType === "ROMAN_LOWER" ? "roman" : pn.formatType === "ROMAN_UPPER" ? "romanCaps" : "decimal";
+      const pageNumNode = { tag: "pagenum", format: fmt };
+      const spanProps2 = resolveCharPr(run, ctx);
+      kids.push({ tag: "span", props: spanProps2, kids: [pageNumNode] });
+      continue;
+    }
+    const textNodes = getTag(run, "hp:t", "hp:T", "hp:CHAR");
+    const content = textNodes.map((t) => typeof t === "string" ? t : t?._text ?? t?._ ?? "").join("");
+    if (content === "" && (run?.["hp:secPr"]?.[0] || run?.["hp:SECPR"]?.[0]) && pics.length === 0) continue;
+    const spanProps = resolveCharPr(run, ctx);
+    kids.push(buildSpan(content, spanProps));
+  }
+  return buildPara(kids.filter(Boolean), props);
+}
+function resolveCharPr(run, ctx) {
+  const runAttr = run?._attr ?? {};
+  const charPrIdRef = Number(runAttr.charPrIDRef ?? -1);
+  const def = ctx.charPrs.get(charPrIdRef);
+  if (def) {
+    return {
+      b: def.b,
+      i: def.i,
+      u: def.u,
+      s: def.s,
+      pt: def.pt,
+      color: def.color,
+      font: def.font,
+      bg: def.bg
+    };
+  }
+  const ca = run?.["hp:CHARPR"]?.[0]?._attr ?? run?.["hp:charPr"]?.[0]?._attr ?? run?.CHARPR?.[0]?._attr ?? {};
+  return {
+    b: ca.Bold === "1" || ca.Bold === "true" || void 0,
+    i: ca.Italic === "1" || ca.Italic === "true" || void 0,
+    u: ca.Underline ? ca.Underline !== "NONE" : void 0,
+    s: ca.Strikeout ? ca.Strikeout !== "NONE" : void 0,
+    font: safeFont(ca.FontName ?? ca.FaceNameHangul),
+    pt: ca.Height ? Metric.hHeightToPt(Number(ca.Height)) : void 0,
+    color: safeHex(ca.TextColor),
+    bg: safeHex(ca.BgColor)
+  };
+}
+function decodePic(pic, ctx) {
+  try {
+    const szAttr = pic?.["hp:sz"]?.[0]?._attr ?? pic?.sz?.[0]?._attr ?? {};
+    const w = Metric.hwpToPt(Number(szAttr.width ?? 0));
+    const h = Metric.hwpToPt(Number(szAttr.height ?? 0));
+    const imgNode = pic?.["hp:img"]?.[0]?._attr ?? pic?.["hc:img"]?.[0]?._attr ?? pic?.img?.[0]?._attr ?? {};
+    const binRef = imgNode.binaryItemIDRef ?? imgNode.BinaryItemIDRef;
+    if (!binRef) return null;
+    let imgData;
+    for (const [key, val] of ctx.files) {
+      if (key.includes(binRef) || key.toLowerCase().includes(binRef.toLowerCase())) {
+        imgData = val;
+        break;
+      }
+    }
+    if (!imgData) return null;
+    const ext = binRef.split(".").pop()?.toLowerCase() ?? "png";
+    const mimeMap = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      bmp: "image/bmp"
+    };
+    return buildImg(TextKit.base64Encode(imgData), mimeMap[ext] ?? "image/png", w, h);
+  } catch {
+    return null;
+  }
+}
+function decodeGrid(tbl, ctx) {
+  const tblAttr = tbl?._attr ?? {};
+  const borderFillId = Number(tblAttr.borderFillIDRef ?? 0);
+  const borderFill = ctx.borderFills.get(borderFillId);
+  const headerRow = tblAttr.repeatHeader === "1";
+  const gridProps = { headerRow: headerRow || void 0 };
+  if (borderFill?.stroke) gridProps.defaultStroke = borderFill.stroke;
+  const rowArr = getTag(tbl, "hp:tr", "hp:ROW");
+  const rowNodes = rowArr.map((row) => {
+    const cellArr = getTag(row, "hp:tc", "hp:CELL");
+    const cellNodes = cellArr.map((cell) => {
+      const ca = cell?._attr ?? {};
+      const cellBfId = Number(ca.borderFillIDRef ?? 0);
+      const cellBf = ctx.borderFills.get(cellBfId);
+      const cellProps = {
+        bg: cellBf?.bgColor ?? safeHex(ca.BgColor)
+      };
+      if (cellBf?.stroke) {
+        cellProps.top = cellBf.stroke;
+        cellProps.bot = cellBf.stroke;
+        cellProps.left = cellBf.stroke;
+        cellProps.right = cellBf.stroke;
+      }
+      const subList = cell?.["hp:subList"]?.[0] ?? cell?.subList?.[0];
+      const subAttr = subList?._attr ?? {};
+      if (subAttr.vertAlign) {
+        const vaMap = {
+          TOP: "top",
+          CENTER: "mid",
+          BOTTOM: "bot"
+        };
+        cellProps.va = vaMap[subAttr.vertAlign];
+      }
+      const cellSpan = cell?.["hp:cellSpan"]?.[0]?._attr ?? {};
+      const cs = Number(cellSpan.colSpan ?? ca.ColSpan ?? 1);
+      const rs = Number(cellSpan.rowSpan ?? ca.RowSpan ?? 1);
+      let paras;
+      if (subList) {
+        const subParas = getTag(subList, "hp:p", "hp:P");
+        paras = subParas.map((p) => decodePara(p, ctx));
+      } else {
+        paras = getTag(cell, "hp:p", "hp:P").map((p) => decodePara(p, ctx));
+      }
+      return buildCell(
+        paras.length > 0 ? paras : [buildPara([buildSpan("")])],
+        { cs, rs, props: cellProps }
+      );
+    });
+    return buildRow(cellNodes);
+  });
+  return buildGrid(rowNodes, gridProps);
+}
+function decodeGridSimple(tbl, ctx) {
+  const rowArr = getTag(tbl, "hp:tr", "hp:ROW");
+  const rowNodes = rowArr.map((row) => {
+    const cellArr = getTag(row, "hp:tc", "hp:CELL");
+    return buildRow(cellArr.map((cell) => buildCell([buildPara([buildSpan(cellText(cell))])])));
+  });
+  return buildGrid(rowNodes);
+}
+function decodeGridFlat(tbl) {
+  return buildGrid([buildRow([buildCell([buildPara([buildSpan(tableText(tbl))])])])]);
+}
+function decodeGridText(tbl) {
+  return buildPara([buildSpan(tableText(tbl))]);
+}
+function cellText(cell) {
+  const subList = cell?.["hp:subList"]?.[0] ?? cell?.subList?.[0];
+  const source = subList ?? cell;
+  return getTag(source, "hp:p", "hp:P").map(
+    (p) => getTag(p, "hp:run", "hp:RUN").map(
+      (r) => getTag(r, "hp:t", "hp:T").map((t) => typeof t === "string" ? t : t?._text ?? t?._ ?? "").join("")
+    ).join("")
+  ).join(" ");
+}
+function tableText(tbl) {
+  return getTag(tbl, "hp:tr", "hp:ROW").map(
+    (row) => getTag(row, "hp:tc", "hp:CELL").map((c) => cellText(c)).join("	")
+  ).join("\n");
+}
+function toArr(v) {
+  return v == null ? [] : Array.isArray(v) ? v : [v];
+}
+registry.registerDecoder(new HwpxDecoder());
+
+// src/toolkit/BinaryKit.ts
+var BinaryKit = {
+  readU16LE(buf, offset) {
+    return buf[offset] | buf[offset + 1] << 8;
+  },
+  readU32LE(buf, offset) {
+    return ((buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16) >>> 0) + buf[offset + 3] * 16777216;
+  },
+  isOle2(data) {
+    return data.length >= 8 && data[0] === 208 && data[1] === 207 && data[2] === 17 && data[3] === 224 && data[4] === 161 && data[5] === 177 && data[6] === 26 && data[7] === 225;
+  },
+  parseCfb(data) {
+    const streams = /* @__PURE__ */ new Map();
+    if (!this.isOle2(data)) {
+      throw new Error("Not a valid OLE2 file");
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const sectorSize = 1 << view.getUint16(30, true);
+    const miniSectorSz = 1 << view.getUint16(32, true);
+    const dirFirstSec = view.getUint32(48, true);
+    const miniStreamCutoff = view.getUint32(56, true);
+    const miniFatFirst = view.getUint32(60, true);
+    const miniFatCnt = view.getUint32(64, true);
+    const difatFirst = view.getUint32(68, true);
+    const ENDOFCHAIN = 4294967294;
+    const FREESECT = 4294967295;
+    const sectorAt = (sec) => data.subarray(512 + sec * sectorSize, 512 + (sec + 1) * sectorSize);
+    const fatSecNums = [];
+    for (let i = 0; i < 109; i++) {
+      const s = view.getUint32(76 + i * 4, true);
+      if (s === FREESECT || s === ENDOFCHAIN) break;
+      fatSecNums.push(s);
+    }
+    if (difatFirst !== ENDOFCHAIN && difatFirst !== FREESECT) {
+      let difSec = difatFirst;
+      while (difSec !== ENDOFCHAIN && difSec !== FREESECT) {
+        const sec = sectorAt(difSec);
+        const sv = new DataView(sec.buffer, sec.byteOffset, sec.byteLength);
+        for (let i = 0; i < sectorSize / 4 - 1; i++) {
+          const s = sv.getUint32(i * 4, true);
+          if (s === FREESECT || s === ENDOFCHAIN) break;
+          fatSecNums.push(s);
+        }
+        difSec = sv.getUint32(sectorSize - 4, true);
+      }
+    }
+    const fat = [];
+    for (const sec of fatSecNums) {
+      const s = sectorAt(sec);
+      const sv = new DataView(s.buffer, s.byteOffset, s.byteLength);
+      for (let i = 0; i < sectorSize / 4; i++) {
+        fat.push(sv.getUint32(i * 4, true));
+      }
+    }
+    const readChain = (startSec) => {
+      const chunks = [];
+      let sec = startSec;
+      while (sec !== ENDOFCHAIN && sec !== FREESECT && sec < fat.length) {
+        chunks.push(sectorAt(sec));
+        sec = fat[sec];
+      }
+      return concatUint8(chunks);
+    };
+    const dirData = readChain(dirFirstSec);
+    const dirView = new DataView(dirData.buffer, dirData.byteOffset, dirData.byteLength);
+    const dirCount = dirData.length / 128;
+    const dirEntries = [];
+    for (let i = 0; i < dirCount; i++) {
+      const base = i * 128;
+      const nameLen = dirView.getUint16(base + 64, true);
+      const nameBytes = dirData.subarray(base, base + Math.max(0, nameLen - 2));
+      const name = new TextDecoder("utf-16le").decode(nameBytes);
+      const type = dirData[base + 66];
+      const childId = dirView.getInt32(base + 76, true);
+      const sibLeft = dirView.getInt32(base + 68, true);
+      const sibRight = dirView.getInt32(base + 72, true);
+      const startSec = dirView.getUint32(base + 116, true);
+      const size = dirView.getUint32(base + 120, true);
+      dirEntries.push({ name, type, startSec, size, childId, siblingLeftId: sibLeft, siblingRightId: sibRight });
+    }
+    const rootEntry = dirEntries[0];
+    let miniStreamData = null;
+    let miniFat = [];
+    if (rootEntry && rootEntry.startSec !== ENDOFCHAIN && rootEntry.startSec !== FREESECT) {
+      miniStreamData = readChain(rootEntry.startSec);
+    }
+    if (miniFatCnt > 0 && miniFatFirst !== ENDOFCHAIN && miniFatFirst !== FREESECT) {
+      const mfData = readChain(miniFatFirst);
+      const mfv = new DataView(mfData.buffer, mfData.byteOffset, mfData.byteLength);
+      for (let i = 0; i < mfData.length / 4; i++) {
+        miniFat.push(mfv.getUint32(i * 4, true));
+      }
+    }
+    const readMiniChain = (startSec, size) => {
+      if (!miniStreamData) return new Uint8Array(0);
+      const chunks = [];
+      let sec = startSec;
+      let remaining = size;
+      while (sec !== ENDOFCHAIN && sec !== FREESECT && sec < miniFat.length && remaining > 0) {
+        const off = sec * miniSectorSz;
+        const chunk = miniStreamData.subarray(off, off + Math.min(miniSectorSz, remaining));
+        chunks.push(chunk);
+        remaining -= chunk.length;
+        sec = miniFat[sec];
+      }
+      return concatUint8(chunks).subarray(0, size);
+    };
+    const visit = (id, path) => {
+      if (id < 0 || id >= dirEntries.length) return;
+      const entry = dirEntries[id];
+      const fullPath = path ? `${path}/${entry.name}` : entry.name;
+      if (entry.type === 2) {
+        let streamData;
+        if (entry.size < miniStreamCutoff && miniStreamData) {
+          streamData = readMiniChain(entry.startSec, entry.size);
+        } else {
+          streamData = readChain(entry.startSec).subarray(0, entry.size);
+        }
+        streams.set(fullPath, streamData);
+        streams.set(entry.name, streamData);
+      }
+      if (entry.childId >= 0) visit(entry.childId, fullPath);
+      if (entry.siblingLeftId >= 0) visit(entry.siblingLeftId, path);
+      if (entry.siblingRightId >= 0) visit(entry.siblingRightId, path);
+    };
+    if (dirEntries.length > 0 && dirEntries[0].childId >= 0) {
+      visit(dirEntries[0].childId, "");
+    }
+    return streams;
+  }
+};
+function concatUint8(arrays) {
+  const total = arrays.reduce((s, a) => s + a.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const a of arrays) {
+    out.set(a, off);
+    off += a.length;
+  }
+  return out;
+}
+
+// src/decoders/hwp/HwpScanner.ts
+var import_pako2 = __toESM(require("pako"));
+var HWPTAG_BEGIN = 16;
+var TAG_FACE_NAME = HWPTAG_BEGIN + 3;
+var TAG_BORDER_FILL = HWPTAG_BEGIN + 4;
+var TAG_CHAR_SHAPE = HWPTAG_BEGIN + 5;
+var TAG_PARA_SHAPE = HWPTAG_BEGIN + 9;
+var TAG_PARA_HEADER = HWPTAG_BEGIN + 50;
+var TAG_PARA_TEXT = HWPTAG_BEGIN + 51;
+var TAG_PARA_CHAR_SHAPE = HWPTAG_BEGIN + 52;
+var TAG_CTRL_HEADER = HWPTAG_BEGIN + 55;
+var TAG_PAGE_DEF = HWPTAG_BEGIN + 57;
+var TAG_LIST_HEADER = HWPTAG_BEGIN + 56;
+var TAG_TABLE_A = HWPTAG_BEGIN + 61;
+var TAG_CELL_A = HWPTAG_BEGIN + 62;
+var TAG_TABLE_B = HWPTAG_BEGIN + 64;
+var TAG_CELL_B = HWPTAG_BEGIN + 65;
+function isTableTag(t) {
+  return t === TAG_TABLE_A || t === TAG_TABLE_B;
+}
+function isCellTag(t) {
+  return t === TAG_CELL_A || t === TAG_CELL_B || t === TAG_LIST_HEADER;
+}
+var CTRL_TABLE = 1952607264;
+function parseRecords(data) {
+  const out = [];
+  let off = 0;
+  while (off + 4 <= data.length) {
+    const hdr = BinaryKit.readU32LE(data, off);
+    const tag = hdr & 1023;
+    const level = hdr >> 10 & 1023;
+    let size = hdr >> 20 & 4095;
+    off += 4;
+    if (size === 4095) {
+      if (off + 4 > data.length) break;
+      size = BinaryKit.readU32LE(data, off);
+      off += 4;
+    }
+    if (off + size > data.length) break;
+    out.push({ tag, level, data: data.subarray(off, off + size) });
+    off += size;
+  }
+  return out;
+}
+function tryInflate(data) {
+  try {
+    return import_pako2.default.inflateRaw(data);
+  } catch {
+    return data;
+  }
+}
+function parseFileHeader(buf) {
+  if (buf.length < 40) return { compressed: true, encrypted: false };
+  const props = BinaryKit.readU32LE(buf, 36);
+  return { compressed: (props & 1) !== 0, encrypted: (props & 2) !== 0 };
+}
+function parseDocInfo(data, compressed) {
+  const raw = compressed ? tryInflate(data) : data;
+  const recs = parseRecords(raw);
+  const info = { faceNames: [], charShapes: [], paraShapes: [], borderFills: [] };
+  for (const r of recs) {
+    try {
+      if (r.tag === TAG_FACE_NAME) info.faceNames.push(parseFaceName(r.data));
+      if (r.tag === TAG_CHAR_SHAPE) info.charShapes.push(parseCharShape(r.data));
+      if (r.tag === TAG_PARA_SHAPE) info.paraShapes.push(parseParaShape(r.data));
+      if (r.tag === TAG_BORDER_FILL) info.borderFills.push(parseBorderFill(r.data));
+    } catch {
+    }
+  }
+  return info;
+}
+function parseFaceName(d) {
+  if (d.length < 3) return "";
+  const len = BinaryKit.readU16LE(d, 1);
+  if (d.length < 3 + len * 2) return "";
+  return new TextDecoder("utf-16le").decode(d.subarray(3, 3 + len * 2));
+}
+function parseCharShape(d) {
+  const faceIds = [];
+  for (let i = 0; i < 7; i++) faceIds.push(d.length >= (i + 1) * 2 ? BinaryKit.readU16LE(d, i * 2) : 0);
+  const height = d.length >= 46 ? BinaryKit.readU32LE(d, 42) : 1e3;
+  const attr = d.length >= 50 ? BinaryKit.readU32LE(d, 46) : 0;
+  const ulType = attr >> 2 & 7;
+  const skType = attr >> 18 & 7;
+  const suType = attr >> 16 & 3;
+  return {
+    faceIds,
+    height: height > 0 && height < 1e5 ? height : 1e3,
+    italic: (attr & 1) !== 0,
+    bold: (attr >> 1 & 1) !== 0,
+    underline: ulType !== 0,
+    strikeout: skType !== 0,
+    superscript: suType === 1,
+    subscript: suType === 2,
+    textColor: d.length >= 56 ? colorRef(d, 52) : "000000"
+  };
+}
+var ALIGN_TBL = { 0: "justify", 1: "left", 2: "right", 3: "center", 4: "justify" };
+function parseParaShape(d) {
+  if (d.length < 4) return { align: "left", spaceBefore: 0, spaceAfter: 0, lineSpacing: 160, indent: 0 };
+  const attr = BinaryKit.readU32LE(d, 0);
+  return {
+    align: ALIGN_TBL[attr & 7] ?? "left",
+    indent: d.length >= 16 ? i32(d, 12) : 0,
+    spaceBefore: d.length >= 20 ? i32(d, 16) : 0,
+    spaceAfter: d.length >= 24 ? i32(d, 20) : 0,
+    lineSpacing: d.length >= 28 ? i32(d, 24) : 160
+  };
+}
+var BORDER_W_PT = [0.28, 0.34, 0.43, 0.57, 0.71, 0.85, 1.13, 1.42, 1.7, 1.98, 2.84, 4.25, 5.67, 8.5, 11.34, 14.17];
+var BORDER_KIND = { 0: "none", 1: "solid", 2: "dash", 3: "dot", 4: "dash", 5: "dash", 6: "dash", 7: "dot", 8: "double", 9: "double", 10: "double" };
+function parseBorderFill(d) {
+  const borders = [];
+  for (let i = 0; i < 4; i++) {
+    const b = 2 + i * 6;
+    if (b + 6 <= d.length) {
+      borders.push({ type: d[b], widthPt: BORDER_W_PT[d[b + 1]] ?? 0.5, color: colorRef(d, b + 2) });
+    } else {
+      borders.push({ type: 0, widthPt: 0.5, color: "000000" });
+    }
+  }
+  let bgColor;
+  const fOff = 32;
+  if (d.length >= fOff + 8) {
+    const ft = BinaryKit.readU32LE(d, fOff);
+    if (ft & 1) bgColor = colorRef(d, fOff + 4);
+  }
+  return { borders, bgColor };
+}
+function parseBody(raw, compressed, di, shield) {
+  const recs = parseRecords(compressed ? tryInflate(raw) : raw);
+  const content = [];
+  let pageDims;
+  let i = 0;
+  while (i < recs.length) {
+    if (recs[i].tag === TAG_PAGE_DEF) {
+      pageDims = shield.guard(() => parsePageDef(recs[i].data), A4, "hwp:pageDef");
+      i++;
+    } else if (recs[i].tag === TAG_PARA_HEADER) {
+      const r = shield.guard(
+        () => parseParagraphGroup(recs, i, di, shield),
+        { nodes: [], next: i + 1 },
+        `hwp:para@${i}`
+      );
+      content.push(...r.nodes);
+      i = r.next;
+    } else {
+      i++;
+    }
+  }
+  return { content, pageDims };
+}
+function parseParagraphGroup(recs, start, di, shield) {
+  const hdr = recs[start];
+  const lv = hdr.level;
+  const psId = hdr.data.length >= 10 ? BinaryKit.readU16LE(hdr.data, 8) : 0;
+  const ps = di.paraShapes[psId];
+  let text = null;
+  let csPairs = [];
+  const grids = [];
+  let i = start + 1;
+  while (i < recs.length && recs[i].level > lv) {
+    const r = recs[i];
+    if (r.tag === TAG_PARA_TEXT && r.level === lv + 1) {
+      text = decodeParaText(r.data);
+      i++;
+    } else if (r.tag === TAG_PARA_CHAR_SHAPE && r.level === lv + 1) {
+      csPairs = parseCharShapePairs(r.data);
+      i++;
+    } else if (r.tag === TAG_CTRL_HEADER && r.level === lv + 1) {
+      if (r.data.length >= 4 && BinaryKit.readU32LE(r.data, 0) === CTRL_TABLE) {
+        const tr = shield.guard(
+          () => parseTableCtrl(recs, i, di, shield),
+          { grid: null, next: skipKids(recs, i) },
+          `hwp:tbl@${i}`
+        );
+        if (tr.grid) grids.push(tr.grid);
+        i = tr.next;
+      } else {
+        i = skipKids(recs, i);
+      }
+    } else {
+      i++;
+    }
+  }
+  const nodes = [];
+  if (text && text.chars.length > 0) {
+    const joined = text.chars.map((c) => c.ch).join("");
+    if (joined.trim()) {
+      const spans = resolveCharShapes(text.chars, csPairs, di);
+      nodes.push(buildPara(spans, buildParaProps(ps)));
+    }
+  }
+  nodes.push(...grids);
+  return { nodes, next: i };
+}
+function skipKids(recs, idx) {
+  const lv = recs[idx].level;
+  let i = idx + 1;
+  while (i < recs.length && recs[i].level > lv) i++;
+  return i;
+}
+var EXT_CTRL = /* @__PURE__ */ new Set([2, 3, 11, 12, 14, 15]);
+var INL_CTRL = /* @__PURE__ */ new Set([4, 5, 6, 7, 8]);
+function decodeParaText(d) {
+  const chars = [];
+  const controlPositions = [];
+  let i = 0, pos = 0;
+  while (i + 1 < d.length) {
+    const c = d[i] | d[i + 1] << 8;
+    if (c === 0) {
+      i += 2;
+      pos++;
+      continue;
+    }
+    if (c === 13) {
+      break;
+    }
+    if (c === 10) {
+      chars.push({ pos, ch: "\n" });
+      i += 2;
+      pos++;
+      continue;
+    }
+    if (EXT_CTRL.has(c)) {
+      controlPositions.push(pos);
+      i += 16;
+      pos += 8;
+      continue;
+    }
+    if (INL_CTRL.has(c)) {
+      i += 16;
+      pos += 8;
+      continue;
+    }
+    if (c === 9) {
+      chars.push({ pos, ch: "	" });
+      i += 16;
+      pos += 8;
+      continue;
+    }
+    if (c >= 1 && c <= 31) {
+      i += 2;
+      pos++;
+      continue;
+    }
+    chars.push({ pos, ch: String.fromCharCode(c) });
+    i += 2;
+    pos++;
+  }
+  return { chars, controlPositions };
+}
+function parseCharShapePairs(d) {
+  const out = [];
+  for (let i = 0; i + 7 < d.length; i += 8)
+    out.push([BinaryKit.readU32LE(d, i), BinaryKit.readU32LE(d, i + 4)]);
+  return out;
+}
+function resolveCharShapes(chars, pairs, di) {
+  if (chars.length === 0) return [buildSpan("")];
+  const defaultId = pairs.length > 0 ? pairs[0][1] : 0;
+  function idFor(pos) {
+    let id = defaultId;
+    for (const [p, sid] of pairs) {
+      if (p <= pos) id = sid;
+      else break;
+    }
+    return id;
+  }
+  const spans = [];
+  let curId = idFor(chars[0].pos);
+  let buf = chars[0].ch;
+  for (let k = 1; k < chars.length; k++) {
+    const sid = idFor(chars[k].pos);
+    if (sid !== curId) {
+      spans.push(styledSpan(buf, curId, di));
+      buf = "";
+      curId = sid;
+    }
+    buf += chars[k].ch;
+  }
+  if (buf) spans.push(styledSpan(buf, curId, di));
+  return spans;
+}
+function styledSpan(text, shapeId, di) {
+  const cs = di.charShapes[shapeId];
+  if (!cs) return buildSpan(text);
+  const props = {};
+  const fid = cs.faceIds[0] ?? 0;
+  if (fid < di.faceNames.length && di.faceNames[fid]) props.font = safeFont(di.faceNames[fid]);
+  if (cs.height > 0) props.pt = Metric.hwpToPt(cs.height);
+  if (cs.bold) props.b = true;
+  if (cs.italic) props.i = true;
+  if (cs.underline) props.u = true;
+  if (cs.strikeout) props.s = true;
+  if (cs.superscript) props.sup = true;
+  if (cs.subscript) props.sub = true;
+  const hex = safeHex(cs.textColor);
+  if (hex && hex !== "000000") props.color = hex;
+  return buildSpan(text, props);
+}
+function parseTableCtrl(recs, ctrlIdx, di, shield) {
+  const ctrlLv = recs[ctrlIdx].level;
+  let i = ctrlIdx + 1;
+  let tblData = null;
+  const cells = [];
+  const tblLevel = ctrlLv + 1;
+  while (i < recs.length && recs[i].level > ctrlLv) {
+    const r = recs[i];
+    if (isTableTag(r.tag) && r.level === tblLevel) {
+      tblData = r.data;
+      i++;
+    } else if (r.tag === TAG_LIST_HEADER && r.level === tblLevel) {
+      const cellData = r.data;
+      const paraCount = cellData.length >= 2 ? BinaryKit.readU16LE(cellData, 0) : 0;
+      i++;
+      const cStart = i;
+      let consumed = 0;
+      while (i < recs.length && consumed < paraCount) {
+        if (recs[i].tag === TAG_PARA_HEADER && recs[i].level === tblLevel) {
+          consumed++;
+          i++;
+          while (i < recs.length && recs[i].level > tblLevel) i++;
+        } else if (recs[i].level > tblLevel) {
+          i++;
+        } else {
+          break;
+        }
+      }
+      cells.push({ data: cellData, tag: TAG_LIST_HEADER, cStart, cEnd: i });
+    } else if (isCellTag(r.tag) && r.level === tblLevel) {
+      const cellData = r.data;
+      const cellTag = r.tag;
+      i++;
+      const cStart = i;
+      while (i < recs.length && recs[i].level > tblLevel) i++;
+      cells.push({ data: cellData, tag: cellTag, cStart, cEnd: i });
+    } else {
+      i++;
+    }
+  }
+  if (!tblData || cells.length === 0) return { grid: null, next: i };
+  const rowCnt = tblData.length >= 6 ? BinaryKit.readU16LE(tblData, 4) : 1;
+  const colCnt = tblData.length >= 8 ? BinaryKit.readU16LE(tblData, 6) : 1;
+  const parsed = [];
+  for (let ci = 0; ci < cells.length; ci++) {
+    const c = cells[ci];
+    const seqIdx = ci;
+    const pc = shield.guard(
+      () => parseCellRec(c.data, c.tag, recs, c.cStart, c.cEnd, di, shield, seqIdx, colCnt),
+      { row: Math.floor(ci / (colCnt || 1)), col: ci % (colCnt || 1), cs: 1, rs: 1, widthHwp: 0, props: {}, paras: [buildPara([buildSpan("")])] },
+      `hwp:cell@${c.cStart}`
+    );
+    parsed.push(pc);
+  }
+  const maxRow = parsed.reduce((m, c) => Math.max(m, c.row + c.rs), 0);
+  const actualRowCnt = Math.max(rowCnt, maxRow);
+  const posValid = parsed.every((c) => c.row >= 0 && c.col >= 0 && c.col < colCnt);
+  if (!posValid) {
+    let idx = 0;
+    for (const c of parsed) {
+      c.row = Math.floor(idx / colCnt);
+      c.col = idx % colCnt;
+      idx++;
+    }
+  }
+  const colWidthsPt = new Array(colCnt).fill(0);
+  for (const c of parsed) {
+    if (c.cs === 1 && c.widthHwp > 0) {
+      const wPt = Metric.hwpToPt(c.widthHwp);
+      if (wPt > colWidthsPt[c.col]) colWidthsPt[c.col] = wPt;
+    }
+  }
+  const zeroColumns = colWidthsPt.filter((w) => w === 0).length;
+  if (zeroColumns > 0) {
+    for (const c of parsed) {
+      if (c.cs > 1 && c.widthHwp > 0) {
+        let known = 0;
+        let unknownCols = 0;
+        for (let ci = c.col; ci < c.col + c.cs && ci < colCnt; ci++) {
+          if (colWidthsPt[ci] > 0) known += colWidthsPt[ci];
+          else unknownCols++;
+        }
+        if (unknownCols > 0) {
+          const remaining = Metric.hwpToPt(c.widthHwp) - known;
+          const each = remaining > 0 ? remaining / unknownCols : 0;
+          for (let ci = c.col; ci < c.col + c.cs && ci < colCnt; ci++) {
+            if (colWidthsPt[ci] === 0 && each > 0) colWidthsPt[ci] = each;
+          }
+        }
+      }
+    }
+  }
+  const rows = [];
+  for (let r = 0; r < actualRowCnt; r++) {
+    const rc = parsed.filter((c) => c.row === r).sort((a, b) => a.col - b.col);
+    if (rc.length === 0) continue;
+    rows.push(buildRow(rc.map(
+      (c) => buildCell(c.paras.length ? c.paras : [buildPara([buildSpan("")])], { cs: c.cs, rs: c.rs, props: c.props })
+    )));
+  }
+  if (rows.length === 0) return { grid: null, next: i };
+  let defStroke;
+  const bfOff = 18 + rowCnt * 2;
+  if (tblData.length >= bfOff + 2) {
+    const bfId = BinaryKit.readU16LE(tblData, bfOff);
+    defStroke = strokeFromBF(bfId, di);
+  }
+  const gp = {};
+  if (defStroke) gp.defaultStroke = defStroke;
+  const hasWidths = colWidthsPt.some((w) => w > 0);
+  if (hasWidths) gp.colWidths = colWidthsPt;
+  return { grid: buildGrid(rows, gp), next: i };
+}
+function parseCellRec(d, tag, recs, cStart, cEnd, di, shield, seqIdx, colCnt) {
+  let col, row, cs = 1, rs = 1;
+  let widthHwp = 0;
+  const props = {};
+  const attr = d.length >= 6 ? BinaryKit.readU32LE(d, 2) : 0;
+  const va = attr >> 6 & 3;
+  if (va === 1) props.va = "mid";
+  else if (va === 2) props.va = "bot";
+  if (tag === TAG_LIST_HEADER && d.length >= 22) {
+    col = BinaryKit.readU16LE(d, 8);
+    row = BinaryKit.readU16LE(d, 10);
+    rs = Math.max(1, BinaryKit.readU16LE(d, 12));
+    cs = Math.max(1, BinaryKit.readU16LE(d, 14));
+    widthHwp = BinaryKit.readU32LE(d, 16);
+    const bfId = d.length >= 34 ? BinaryKit.readU16LE(d, 32) : 0;
+    if (bfId > 0 && bfId <= di.borderFills.length) {
+      const bf = di.borderFills[bfId - 1];
+      if (bf.borders.length >= 4) {
+        props.left = toStroke(bf.borders[0]);
+        props.right = toStroke(bf.borders[1]);
+        props.top = toStroke(bf.borders[2]);
+        props.bot = toStroke(bf.borders[3]);
+      }
+      if (bf.bgColor && bf.bgColor !== "FFFFFF") props.bg = bf.bgColor;
+    }
+  } else if (tag !== TAG_LIST_HEADER) {
+    col = d.length >= 8 ? BinaryKit.readU16LE(d, 6) : seqIdx % (colCnt || 1);
+    row = d.length >= 10 ? BinaryKit.readU16LE(d, 8) : Math.floor(seqIdx / (colCnt || 1));
+    cs = d.length >= 12 ? Math.max(1, BinaryKit.readU16LE(d, 10)) : 1;
+    rs = d.length >= 14 ? Math.max(1, BinaryKit.readU16LE(d, 12)) : 1;
+    widthHwp = d.length >= 18 ? BinaryKit.readU32LE(d, 14) : 0;
+    const bfId = d.length >= 32 ? BinaryKit.readU16LE(d, 30) : 0;
+    if (bfId > 0 && bfId <= di.borderFills.length) {
+      const bf = di.borderFills[bfId - 1];
+      if (bf.borders.length >= 4) {
+        props.left = toStroke(bf.borders[0]);
+        props.right = toStroke(bf.borders[1]);
+        props.top = toStroke(bf.borders[2]);
+        props.bot = toStroke(bf.borders[3]);
+      }
+      if (bf.bgColor && bf.bgColor !== "FFFFFF") props.bg = bf.bgColor;
+    }
+  } else {
+    row = Math.floor(seqIdx / (colCnt || 1));
+    col = seqIdx % (colCnt || 1);
+  }
+  const paras = [];
+  let k = cStart;
+  while (k < cEnd) {
+    if (recs[k].tag === TAG_PARA_HEADER) {
+      const r = shield.guard(
+        () => {
+          const hdr = recs[k];
+          const lv = hdr.level;
+          const psId = hdr.data.length >= 10 ? BinaryKit.readU16LE(hdr.data, 8) : 0;
+          const ps = di.paraShapes[psId];
+          let txt = null;
+          let csp = [];
+          let j = k + 1;
+          while (j < cEnd && recs[j].level > lv) {
+            if (recs[j].tag === TAG_PARA_TEXT) {
+              txt = decodeParaText(recs[j].data);
+              j++;
+            } else if (recs[j].tag === TAG_PARA_CHAR_SHAPE) {
+              csp = parseCharShapePairs(recs[j].data);
+              j++;
+            } else j++;
+          }
+          const spans = txt && txt.chars.length > 0 ? resolveCharShapes(txt.chars, csp, di) : [buildSpan("")];
+          return { para: buildPara(spans, buildParaProps(ps)), next: j };
+        },
+        { para: buildPara([buildSpan("")]), next: k + 1 },
+        `hwp:cellP@${k}`
+      );
+      paras.push(r.para);
+      k = r.next;
+    } else {
+      k++;
+    }
+  }
+  return { row, col, cs, rs, props, widthHwp, paras: paras.length ? paras : [buildPara([buildSpan("")])] };
+}
+function parsePageDef(d) {
+  if (d.length < 24) return A4;
+  const w = BinaryKit.readU32LE(d, 0);
+  const h = BinaryKit.readU32LE(d, 4);
+  const ml = BinaryKit.readU32LE(d, 8);
+  const mr = BinaryKit.readU32LE(d, 12);
+  const mt = BinaryKit.readU32LE(d, 16);
+  const mb = BinaryKit.readU32LE(d, 20);
+  const at = d.length >= 40 ? BinaryKit.readU32LE(d, 36) : 0;
+  return {
+    wPt: Metric.hwpToPt(w),
+    hPt: Metric.hwpToPt(h),
+    ml: Metric.hwpToPt(ml),
+    mr: Metric.hwpToPt(mr),
+    mt: Metric.hwpToPt(mt),
+    mb: Metric.hwpToPt(mb),
+    orient: at & 1 ? "landscape" : "portrait"
+  };
+}
+function i32(d, o) {
+  const u = BinaryKit.readU32LE(d, o);
+  return u > 2147483647 ? u - 4294967296 : u;
+}
+function colorRef(d, o) {
+  if (o + 3 > d.length) return "000000";
+  return (d[o] << 16 | d[o + 1] << 8 | d[o + 2]).toString(16).padStart(6, "0").toUpperCase();
+}
+function toStroke(b) {
+  return { kind: BORDER_KIND[b.type] ?? "solid", pt: b.widthPt, color: b.color };
+}
+function strokeFromBF(bfId, di) {
+  if (bfId <= 0 || bfId > di.borderFills.length) return void 0;
+  const bf = di.borderFills[bfId - 1];
+  if (!bf.borders.length) return void 0;
+  const b = bf.borders[0];
+  return { kind: BORDER_KIND[b.type] ?? "solid", pt: b.widthPt, color: b.color };
+}
+function buildParaProps(ps) {
+  if (!ps) return {};
+  const p = {};
+  if (ps.align && ps.align !== "left") p.align = ps.align;
+  if (ps.spaceBefore > 0) p.spaceBefore = Metric.hwpToPt(ps.spaceBefore);
+  if (ps.spaceAfter > 0) p.spaceAfter = Metric.hwpToPt(ps.spaceAfter);
+  if (ps.lineSpacing > 0 && ps.lineSpacing !== 160) p.lineHeight = ps.lineSpacing / 100;
+  if (ps.indent > 0) p.indentPt = Metric.hwpToPt(ps.indent);
+  return p;
+}
+var HwpScanner = class {
+  constructor() {
+    this.format = "hwp";
+  }
+  async decode(data) {
+    const shield = new ShieldedParser();
+    const warns = [];
+    try {
+      if (!BinaryKit.isOle2(data)) return fail("HWP: Invalid OLE2 signature");
+      const streams = BinaryKit.parseCfb(data);
+      const fh = streams.get("FileHeader");
+      const { compressed, encrypted } = fh ? parseFileHeader(fh) : { compressed: true, encrypted: false };
+      if (encrypted) return fail("HWP: \uC554\uD638\uD654\uB41C \uD30C\uC77C\uC740 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+      const diRaw = streams.get("DocInfo");
+      let di = { faceNames: [], charShapes: [], paraShapes: [], borderFills: [] };
+      if (diRaw) {
+        di = shield.guard(() => parseDocInfo(diRaw, compressed), di, "hwp:docInfo");
+      }
+      const allContent = [];
+      let pageDims = A4;
+      for (let s = 0; s < 100; s++) {
+        const sec = streams.get(`BodyText/Section${s}`) ?? streams.get(`Section${s}`);
+        if (!sec) {
+          if (s === 0) {
+            const fb = findBodySection(streams);
+            if (fb) {
+              const r2 = parseBody(fb, compressed, di, shield);
+              allContent.push(...r2.content);
+              if (r2.pageDims) pageDims = r2.pageDims;
+            }
+          }
+          break;
+        }
+        const r = shield.guard(
+          () => parseBody(sec, compressed, di, shield),
+          { content: [], pageDims: void 0 },
+          `hwp:sec${s}`
+        );
+        allContent.push(...r.content);
+        if (r.pageDims) pageDims = r.pageDims;
+      }
+      warns.push(...shield.flush());
+      const content = allContent.length > 0 ? allContent : [buildPara([buildSpan("")])];
+      return succeed(buildRoot({}, [buildSheet(content, pageDims)]), warns);
+    } catch (e) {
+      warns.push(...shield.flush());
+      return fail(`HWP decode error: ${e?.message ?? String(e)}`, warns);
+    }
+  }
+};
+function findBodySection(streams) {
+  for (const [k, v] of streams)
+    if (k.includes("Section") && !k.includes("Header") && !k.includes("Info")) return v;
+  return void 0;
+}
+registry.registerDecoder(new HwpScanner());
+
+// src/decoders/docx/DocxDecoder.ts
+var DocxDecoder = class {
+  constructor() {
+    this.format = "docx";
+  }
+  async decode(data) {
+    const shield = new ShieldedParser();
+    const warns = [];
+    try {
+      const files = await ArchiveKit.unzip(data);
+      const docXml = files.get("word/document.xml");
+      if (!docXml) return fail("DOCX: word/document.xml not found");
+      const relsXml = files.get("word/_rels/document.xml.rels");
+      const relsMap = relsXml ? await parseRels(TextKit.decode(relsXml)) : /* @__PURE__ */ new Map();
+      const coreXml2 = files.get("docProps/core.xml");
+      let meta = {};
+      if (coreXml2) {
+        try {
+          meta = await parseCoreProps(TextKit.decode(coreXml2));
+        } catch {
+        }
+      }
+      const numXml = files.get("word/numbering.xml");
+      let numMap = /* @__PURE__ */ new Map();
+      if (numXml) {
+        try {
+          numMap = await parseNumbering(TextKit.decode(numXml));
+        } catch {
+        }
+      }
+      const docStr = TextKit.decode(docXml);
+      const docObj = await XmlKit.parseStrict(docStr);
+      const body = getBody(docObj);
+      const dims = extractDims2(body) ?? { ...A4 };
+      const elements = getBodyElements(body);
+      const decCtx = { relsMap, files, shield, numMap, warns };
+      const kids = shield.guardAll(
+        elements,
+        (el) => decodeElement(el, decCtx),
+        () => buildPara([buildSpan("[\uC694\uC18C \uD30C\uC2F1 \uC2E4\uD328]")]),
+        "docx:bodyElement"
+      );
+      const headerParas = await decodeHeaderFooter2("header", body, relsMap, files, decCtx);
+      const footerParas = await decodeHeaderFooter2("footer", body, relsMap, files, decCtx);
+      warns.push(...shield.flush());
+      const sheet = buildSheet(
+        kids.filter(Boolean),
+        dims,
+        { header: headerParas, footer: footerParas }
+      );
+      return succeed(buildRoot(meta, [sheet]), warns);
+    } catch (e) {
+      warns.push(...shield.flush());
+      return fail(`DOCX decode error: ${e?.message ?? String(e)}`, warns);
+    }
+  }
+};
+function toArr2(v) {
+  return v == null ? [] : Array.isArray(v) ? v : [v];
+}
+async function parseRels(xml) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const obj = await XmlKit.parseStrict(xml);
+    for (const rel of toArr2(obj?.Relationships?.[0]?.Relationship)) {
+      const a = rel?._attr ?? {};
+      if (a.Id && a.Target) map.set(a.Id, a.Target);
+    }
+  } catch {
+  }
+  return map;
+}
+async function parseCoreProps(xml) {
+  try {
+    const obj = await XmlKit.parseStrict(xml);
+    const c = obj?.["cp:coreProperties"]?.[0] ?? obj?.coreProperties?.[0] ?? {};
+    return {
+      title: c?.["dc:title"]?.[0]?._text ?? void 0,
+      author: c?.["dc:creator"]?.[0]?._text ?? void 0,
+      subject: c?.["dc:subject"]?.[0]?._text ?? void 0,
+      created: c?.["dcterms:created"]?.[0]?._text ?? void 0,
+      modified: c?.["dcterms:modified"]?.[0]?._text ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+async function parseNumbering(xml) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const obj = await XmlKit.parseStrict(xml);
+    const root = obj?.["w:numbering"]?.[0] ?? obj?.numbering?.[0] ?? obj;
+    const absMap = /* @__PURE__ */ new Map();
+    for (const abs of toArr2(root?.["w:abstractNum"] ?? root?.abstractNum)) {
+      const absId = Number(abs?._attr?.["w:abstractNumId"] ?? abs?._attr?.abstractNumId ?? 0);
+      const levels = /* @__PURE__ */ new Map();
+      for (const lvl of toArr2(abs?.["w:lvl"] ?? abs?.lvl)) {
+        const ilvl = Number(lvl?._attr?.["w:ilvl"] ?? lvl?._attr?.ilvl ?? 0);
+        const fmtNode = lvl?.["w:numFmt"]?.[0]?._attr ?? lvl?.numFmt?.[0]?._attr ?? {};
+        const fmt = fmtNode?.["w:val"] ?? fmtNode?.val ?? "decimal";
+        levels.set(ilvl, { fmt, isOrdered: fmt !== "bullet" });
+      }
+      absMap.set(absId, levels);
+    }
+    for (const num of toArr2(root?.["w:num"] ?? root?.num)) {
+      const numId = Number(num?._attr?.["w:numId"] ?? num?._attr?.numId ?? 0);
+      const absRef = num?.["w:abstractNumId"]?.[0]?._attr ?? num?.abstractNumId?.[0]?._attr ?? {};
+      const absId = Number(absRef?.["w:val"] ?? absRef?.val ?? 0);
+      const levels = absMap.get(absId) ?? /* @__PURE__ */ new Map();
+      map.set(numId, { levels });
+    }
+  } catch {
+  }
+  return map;
+}
+function getBody(obj) {
+  return obj?.["w:document"]?.[0]?.["w:body"]?.[0] ?? obj?.document?.[0]?.body?.[0] ?? obj;
+}
+function extractDims2(body) {
+  try {
+    const sp = body?.["w:sectPr"]?.[0] ?? body?.sectPr?.[0];
+    if (!sp) return null;
+    const sz = sp?.["w:pgSz"]?.[0]?._attr ?? sp?.pgSz?.[0]?._attr;
+    const mar = sp?.["w:pgMar"]?.[0]?._attr ?? sp?.pgMar?.[0]?._attr;
+    if (!sz) return null;
+    return {
+      wPt: Metric.dxaToPt(Number(sz["w:w"] ?? sz.w ?? 11906)),
+      hPt: Metric.dxaToPt(Number(sz["w:h"] ?? sz.h ?? 16838)),
+      mt: Metric.dxaToPt(Number(mar?.["w:top"] ?? mar?.top ?? 1440)),
+      mb: Metric.dxaToPt(Number(mar?.["w:bottom"] ?? mar?.bottom ?? 1440)),
+      ml: Metric.dxaToPt(Number(mar?.["w:left"] ?? mar?.left ?? 1800)),
+      mr: Metric.dxaToPt(Number(mar?.["w:right"] ?? mar?.right ?? 1800)),
+      orient: (sz["w:orient"] ?? sz.orient) === "landscape" ? "landscape" : "portrait"
+    };
+  } catch {
+    return null;
+  }
+}
+function getBodyElements(body) {
+  const paras = toArr2(body?.["w:p"] ?? body?.p);
+  const tables = toArr2(body?.["w:tbl"] ?? body?.tbl);
+  if (tables.length === 0) return paras.map((n) => ({ type: "para", node: n }));
+  if (paras.length === 0) return tables.map((n) => ({ type: "table", node: n }));
+  const childOrder = body?.["_childOrder"];
+  if (Array.isArray(childOrder)) {
+    const items = [];
+    let pi = 0, ti = 0;
+    for (const tag of childOrder) {
+      if ((tag === "w:p" || tag === "p") && pi < paras.length) {
+        items.push({ type: "para", node: paras[pi++] });
+      } else if ((tag === "w:tbl" || tag === "tbl") && ti < tables.length) {
+        items.push({ type: "table", node: tables[ti++] });
+      }
+    }
+    while (pi < paras.length) items.push({ type: "para", node: paras[pi++] });
+    while (ti < tables.length) items.push({ type: "table", node: tables[ti++] });
+    return items;
+  }
+  return [
+    ...paras.map((n) => ({ type: "para", node: n })),
+    ...tables.map((n) => ({ type: "table", node: n }))
+  ];
+}
+async function decodeHeaderFooter2(kind, body, relsMap, files, ctx) {
+  try {
+    const sp = body?.["w:sectPr"]?.[0] ?? body?.sectPr?.[0];
+    if (!sp) return void 0;
+    const refTag = kind === "header" ? "w:headerReference" : "w:footerReference";
+    const refs = toArr2(sp?.[refTag] ?? sp?.[refTag.replace("w:", "")]);
+    if (refs.length === 0) return void 0;
+    const rId = refs[0]?._attr?.["r:id"] ?? refs[0]?._attr?.["r:Id"] ?? refs[0]?._attr?.id;
+    if (!rId) return void 0;
+    const target = relsMap.get(rId);
+    if (!target) return void 0;
+    const filePath = target.startsWith("/") ? target.slice(1) : `word/${target}`;
+    const fileData = files.get(filePath);
+    if (!fileData) return void 0;
+    const xmlStr = TextKit.decode(fileData);
+    const obj = await XmlKit.parseStrict(xmlStr);
+    const rootTag = kind === "header" ? "w:hdr" : "w:ftr";
+    const root = obj?.[rootTag]?.[0] ?? obj?.[rootTag.replace("w:", "")]?.[0] ?? obj;
+    const paras = toArr2(root?.["w:p"] ?? root?.p);
+    if (paras.length === 0) return void 0;
+    return paras.map((p) => decodePara2(p, ctx));
+  } catch {
+    return void 0;
+  }
+}
+function decodeElement(el, ctx) {
+  if (el.type === "table") {
+    const { value } = ctx.shield.guardGrid(
+      el.node,
+      (n) => decodeGrid2(n, ctx),
+      (n) => decodeGridSimple2(n),
+      (n) => decodeGridFlat2(n),
+      (n) => decodeGridText2(n),
+      "docx:table"
+    );
+    return value;
+  }
+  return decodePara2(el.node, ctx);
+}
+function decodePara2(p, ctx) {
+  const pPr = p?.["w:pPr"]?.[0] ?? {};
+  const alignVal = pPr?.["w:jc"]?.[0]?._attr?.["w:val"] ?? pPr?.["w:jc"]?.[0]?._attr?.val;
+  const headStyle = pPr?.["w:pStyle"]?.[0]?._attr?.["w:val"] ?? pPr?.["w:pStyle"]?.[0]?._attr?.val ?? "";
+  const props = {
+    align: safeAlign(alignVal),
+    heading: parseHeading(headStyle)
+  };
+  const numPr = pPr?.["w:numPr"]?.[0] ?? pPr?.numPr?.[0];
+  if (numPr) {
+    const ilvlNode = numPr?.["w:ilvl"]?.[0]?._attr ?? numPr?.ilvl?.[0]?._attr ?? {};
+    const numIdNode = numPr?.["w:numId"]?.[0]?._attr ?? numPr?.numId?.[0]?._attr ?? {};
+    const ilvl = Number(ilvlNode?.["w:val"] ?? ilvlNode?.val ?? 0);
+    const numId = Number(numIdNode?.["w:val"] ?? numIdNode?.val ?? 0);
+    props.listLv = ilvl;
+    const numEntry = ctx.numMap.get(numId);
+    if (numEntry) {
+      const lvlInfo = numEntry.levels.get(ilvl) ?? numEntry.levels.get(0);
+      props.listOrd = lvlInfo?.isOrdered ?? false;
+    } else {
+      props.listOrd = numId >= 2;
+    }
+  }
+  const runs = toArr2(p?.["w:r"] ?? p?.r);
+  const kids = ctx.shield.guardAll(
+    runs,
+    (run) => decodeRunOrImage(run, ctx),
+    () => buildSpan(""),
+    "docx:run"
+  );
+  return buildPara(kids.filter(Boolean), props);
+}
+function decodeRunOrImage(run, ctx) {
+  const drawing = run?.["w:drawing"]?.[0] ?? run?.drawing?.[0];
+  if (drawing) {
+    const img = decodeDrawing(drawing, ctx);
+    if (img) return img;
+  }
+  return decodeRun(run, ctx);
+}
+function decodeDrawing(drawing, ctx) {
+  try {
+    const inline = drawing?.["wp:inline"]?.[0] ?? drawing?.inline?.[0];
+    const anchor = drawing?.["wp:anchor"]?.[0] ?? drawing?.anchor?.[0];
+    const container = inline ?? anchor;
+    if (!container) return null;
+    const extent = container?.["wp:extent"]?.[0]?._attr ?? container?.extent?.[0]?._attr ?? {};
+    const cx = Number(extent?.cx ?? 0);
+    const cy = Number(extent?.cy ?? 0);
+    const wPt = Metric.emuToPt(cx);
+    const hPt = Metric.emuToPt(cy);
+    const docPr = container?.["wp:docPr"]?.[0]?._attr ?? container?.docPr?.[0]?._attr ?? {};
+    const alt = docPr?.descr ?? docPr?.name ?? "";
+    const graphic = container?.["a:graphic"]?.[0] ?? container?.graphic?.[0];
+    const graphicData = graphic?.["a:graphicData"]?.[0] ?? graphic?.graphicData?.[0];
+    const pic = graphicData?.["pic:pic"]?.[0] ?? graphicData?.pic?.[0];
+    const blipFill = pic?.["pic:blipFill"]?.[0] ?? pic?.blipFill?.[0];
+    const blip = blipFill?.["a:blip"]?.[0]?._attr ?? blipFill?.blip?.[0]?._attr ?? {};
+    const rId = blip?.["r:embed"] ?? blip?.embed;
+    if (!rId) return null;
+    const target = ctx.relsMap.get(rId);
+    if (!target) return null;
+    const filePath = target.startsWith("/") ? target.slice(1) : `word/${target}`;
+    const fileData = ctx.files.get(filePath);
+    if (!fileData) return null;
+    const ext = target.split(".").pop()?.toLowerCase() ?? "png";
+    const mimeMap = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      bmp: "image/bmp"
+    };
+    const mime = mimeMap[ext] ?? "image/png";
+    return buildImg(TextKit.base64Encode(fileData), mime, wPt, hPt, alt || void 0);
+  } catch {
+    return null;
+  }
+}
+function decodeRun(run, ctx) {
+  const rPr = run?.["w:rPr"]?.[0] ?? run?.rPr?.[0] ?? {};
+  const szAttr = rPr?.["w:sz"]?.[0]?._attr ?? rPr?.sz?.[0]?._attr ?? {};
+  const szVal = szAttr?.["w:val"] ?? szAttr?.val;
+  const colorAttr = rPr?.["w:color"]?.[0]?._attr ?? rPr?.color?.[0]?._attr ?? {};
+  const colorVal = colorAttr?.["w:val"] ?? colorAttr?.val;
+  const fontAttr = rPr?.["w:rFonts"]?.[0]?._attr ?? rPr?.rFonts?.[0]?._attr ?? {};
+  const fontName = fontAttr?.["w:ascii"] ?? fontAttr?.ascii ?? fontAttr?.["w:hAnsi"] ?? fontAttr?.hAnsi ?? fontAttr?.["w:eastAsia"] ?? fontAttr?.eastAsia;
+  const underVal = rPr?.["w:u"]?.[0]?._attr?.["w:val"] ?? rPr?.["w:u"]?.[0]?._attr?.val;
+  const shdAttr = rPr?.["w:shd"]?.[0]?._attr ?? rPr?.shd?.[0]?._attr ?? {};
+  const bgVal = safeHex(shdAttr?.["w:fill"] ?? shdAttr?.fill);
+  const vertAlignVal = rPr?.["w:vertAlign"]?.[0]?._attr?.["w:val"] ?? rPr?.["w:vertAlign"]?.[0]?._attr?.val;
+  const bNode = rPr?.["w:b"]?.[0] ?? rPr?.b?.[0];
+  const isBold = bNode != null && (bNode?._attr?.["w:val"] ?? bNode?._attr?.val ?? "1") !== "0";
+  const iNode = rPr?.["w:i"]?.[0] ?? rPr?.i?.[0];
+  const isItalic = iNode != null && (iNode?._attr?.["w:val"] ?? iNode?._attr?.val ?? "1") !== "0";
+  const sNode = rPr?.["w:strike"]?.[0] ?? rPr?.strike?.[0];
+  const isStrike = sNode != null && (sNode?._attr?.["w:val"] ?? sNode?._attr?.val ?? "1") !== "0";
+  const props = {
+    b: isBold || void 0,
+    i: isItalic || void 0,
+    u: underVal && underVal !== "none" ? true : void 0,
+    s: isStrike || void 0,
+    sup: vertAlignVal === "superscript" || void 0,
+    sub: vertAlignVal === "subscript" || void 0,
+    pt: szVal ? Metric.halfPtToPt(Number(szVal)) : void 0,
+    color: safeHex(colorVal),
+    font: fontName ? safeFont(fontName) : void 0,
+    bg: bgVal
+  };
+  const fldChar = run?.["w:fldChar"]?.[0]?._attr ?? run?.fldChar?.[0]?._attr;
+  const instrText = run?.["w:instrText"]?.[0];
+  const textNodes = toArr2(run?.["w:t"] ?? run?.t);
+  const content = textNodes.map((t) => typeof t === "string" ? t : t?._ ?? t?._text ?? "").join("");
+  if (instrText) {
+    const instrStr = typeof instrText === "string" ? instrText : instrText?._text ?? "";
+    if (instrStr.trim().toUpperCase() === "PAGE") {
+      const pageNum = { tag: "pagenum", format: "decimal" };
+      return { tag: "span", props, kids: [pageNum] };
+    }
+  }
+  return buildSpan(content, props);
+}
+function decodeGrid2(tbl, ctx) {
+  const tblPr = tbl?.["w:tblPr"]?.[0] ?? tbl?.tblPr?.[0] ?? {};
+  const tblLookAttr = tblPr?.["w:tblLook"]?.[0]?._attr ?? tblPr?.tblLook?.[0]?._attr ?? {};
+  const look = {
+    firstRow: tblLookAttr?.["w:firstRow"] === "1" || void 0,
+    lastRow: tblLookAttr?.["w:lastRow"] === "1" || void 0,
+    firstCol: tblLookAttr?.["w:firstColumn"] === "1" || tblLookAttr?.["w:firstCol"] === "1" || void 0,
+    lastCol: tblLookAttr?.["w:lastColumn"] === "1" || tblLookAttr?.["w:lastCol"] === "1" || void 0,
+    bandedRows: tblLookAttr?.["w:noHBand"] === "0" || void 0,
+    bandedCols: tblLookAttr?.["w:noVBand"] === "0" || void 0
+  };
+  const tblBorders = tblPr?.["w:tblBorders"]?.[0] ?? tblPr?.tblBorders?.[0];
+  let defaultStroke = void 0;
+  if (tblBorders) {
+    const top = tblBorders?.["w:top"]?.[0]?._attr ?? tblBorders?.top?.[0]?._attr;
+    if (top) {
+      defaultStroke = safeStrokeDocx(
+        top?.["w:val"] ?? top?.val,
+        Number(top?.["w:sz"] ?? top?.sz ?? 4),
+        top?.["w:color"] ?? top?.color
+      );
+    }
+  }
+  const gridProps = { look, defaultStroke };
+  const rowArr = toArr2(tbl?.["w:tr"] ?? tbl?.tr);
+  const rawGrid = rowArr.map((row) => {
+    const cellArr = toArr2(row?.["w:tc"] ?? row?.tc);
+    return cellArr.map((cell) => {
+      const tcPr = cell?.["w:tcPr"]?.[0] ?? {};
+      const gridSpan = Number(tcPr?.["w:gridSpan"]?.[0]?._attr?.["w:val"] ?? 1);
+      const vMergeNode = tcPr?.["w:vMerge"]?.[0];
+      const vMergeVal = vMergeNode?._attr?.["w:val"] ?? vMergeNode?._attr?.val;
+      const vMergeRestart = vMergeVal === "restart";
+      const vMergeContinue = vMergeNode != null && !vMergeRestart;
+      return { cell, gridSpan, vMergeRestart, vMergeContinue };
+    });
+  });
+  const rsMap = /* @__PURE__ */ new Map();
+  for (let ri = 0; ri < rawGrid.length; ri++) {
+    let gridCol = 0;
+    for (let ci = 0; ci < rawGrid[ri].length; ci++) {
+      const rc = rawGrid[ri][ci];
+      if (rc.vMergeRestart) {
+        let span = 1;
+        for (let nr = ri + 1; nr < rawGrid.length; nr++) {
+          let col = 0;
+          let found = false;
+          for (const nc of rawGrid[nr]) {
+            if (col === gridCol && nc.vMergeContinue) {
+              span++;
+              found = true;
+              break;
+            }
+            col += nc.gridSpan;
+          }
+          if (!found) break;
+        }
+        rsMap.set(`${ri},${ci}`, span);
+      }
+      gridCol += rc.gridSpan;
+    }
+  }
+  const rowNodes = rawGrid.map((rawRow, ri) => {
+    const row = rowArr[ri];
+    const trPr = row?.["w:trPr"]?.[0] ?? row?.trPr?.[0] ?? {};
+    const isHeaderRow = trPr?.["w:tblHeader"]?.[0] != null || trPr?.tblHeader?.[0] != null;
+    if (ri === 0 && isHeaderRow) gridProps.headerRow = true;
+    const cellNodes = [];
+    for (let ci = 0; ci < rawRow.length; ci++) {
+      const rc = rawRow[ci];
+      if (rc.vMergeContinue) continue;
+      const cell = rc.cell;
+      const tcPr = cell?.["w:tcPr"]?.[0] ?? {};
+      const bgAttr = tcPr?.["w:shd"]?.[0]?._attr ?? {};
+      const bg = safeHex(bgAttr?.["w:fill"] ?? bgAttr?.fill);
+      const tcBorders = tcPr?.["w:tcBorders"]?.[0] ?? tcPr?.tcBorders?.[0];
+      const cp = { bg, isHeader: isHeaderRow || void 0 };
+      if (tcBorders) {
+        const dirs = [
+          ["top", "top"],
+          ["bottom", "bot"],
+          ["left", "left"],
+          ["right", "right"]
+        ];
+        for (const [xmlTag, propKey] of dirs) {
+          const bdr = tcBorders?.["w:" + xmlTag]?.[0]?._attr ?? tcBorders?.[xmlTag]?.[0]?._attr;
+          if (bdr) {
+            cp[propKey] = safeStrokeDocx(
+              bdr?.["w:val"] ?? bdr?.val,
+              Number(bdr?.["w:sz"] ?? bdr?.sz ?? 4),
+              bdr?.["w:color"] ?? bdr?.color
+            );
+          }
+        }
+      }
+      const vaAttr = tcPr?.["w:vAlign"]?.[0]?._attr ?? tcPr?.vAlign?.[0]?._attr ?? {};
+      const vaVal = vaAttr?.["w:val"] ?? vaAttr?.val;
+      if (vaVal) {
+        const vaMap = { top: "top", center: "mid", bottom: "bot" };
+        cp.va = vaMap[vaVal];
+      }
+      const rs = rsMap.get(`${ri},${ci}`) ?? 1;
+      const paras = toArr2(cell?.["w:p"] ?? cell?.p).map((p) => decodePara2(p, ctx));
+      cellNodes.push(buildCell(
+        paras.length > 0 ? paras : [buildPara([buildSpan("")])],
+        { cs: rc.gridSpan, rs, props: cp }
+      ));
+    }
+    return buildRow(cellNodes);
+  });
+  return buildGrid(rowNodes, gridProps);
+}
+function decodeGridSimple2(tbl) {
+  const rowArr = toArr2(tbl?.["w:tr"] ?? tbl?.tr);
+  const rowNodes = rowArr.map((row) => {
+    const cellArr = toArr2(row?.["w:tc"] ?? row?.tc);
+    return buildRow(cellArr.map((c) => buildCell([buildPara([buildSpan(cellText2(c))])])));
+  });
+  return buildGrid(rowNodes);
+}
+function decodeGridFlat2(tbl) {
+  return buildGrid([buildRow([buildCell([buildPara([buildSpan(tableText2(tbl))])])])]);
+}
+function decodeGridText2(tbl) {
+  return buildPara([buildSpan(tableText2(tbl))]);
+}
+function cellText2(cell) {
+  return toArr2(cell?.["w:p"] ?? cell?.p).map(
+    (p) => toArr2(p?.["w:r"] ?? p?.r).map(
+      (r) => toArr2(r?.["w:t"] ?? r?.t).map((t) => typeof t === "string" ? t : t?._ ?? "").join("")
+    ).join("")
+  ).join(" ");
+}
+function tableText2(tbl) {
+  return toArr2(tbl?.["w:tr"] ?? tbl?.tr).map(
+    (row) => toArr2(row?.["w:tc"] ?? row?.tc).map((c) => cellText2(c)).join("	")
+  ).join("\n");
+}
+function parseHeading(style) {
+  if (!style) return void 0;
+  const m = style.match(/[Hh]eading(\d)/);
+  if (m) {
+    const n = Number(m[1]);
+    if (n >= 1 && n <= 6) return n;
+  }
+  return void 0;
+}
+registry.registerDecoder(new DocxDecoder());
+
+// src/decoders/md/MdDecoder.ts
+var MdDecoder = class {
+  constructor() {
+    this.format = "md";
+  }
+  async decode(data) {
+    const shield = new ShieldedParser();
+    const warns = [];
+    try {
+      const text = TextKit.decode(data);
+      const lines = text.split(/\r?\n/);
+      const kids = [];
+      let i = 0;
+      while (i < lines.length) {
+        const line = lines[i];
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+          const level = headingMatch[1].length;
+          kids.push(buildPara([buildSpan(headingMatch[2], { b: level <= 2 })], { heading: level }));
+          i++;
+          continue;
+        }
+        if (line.includes("|") && i + 1 < lines.length && lines[i + 1].match(/^\s*\|?\s*[-:]+\s*\|/)) {
+          const tableResult = shield.guard(() => parseMdTable(lines, i), null, `md:table@${i}`);
+          if (tableResult) {
+            kids.push(tableResult.node);
+            i = tableResult.nextLine;
+            continue;
+          }
+        }
+        if (line.match(/^[-*_]{3,}$/)) {
+          kids.push(buildPara([buildSpan("")], {}));
+          i++;
+          continue;
+        }
+        const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.+)$/);
+        if (listMatch) {
+          kids.push(buildPara(parseInline(listMatch[3]), {
+            listLv: Math.floor(listMatch[1].length / 2),
+            listOrd: /\d+\./.test(listMatch[2])
+          }));
+          i++;
+          continue;
+        }
+        const bqMatch = line.match(/^>\s*(.*)$/);
+        if (bqMatch) {
+          kids.push(buildPara([buildSpan(bqMatch[1])], { indentPt: 28 }));
+          i++;
+          continue;
+        }
+        if (line.startsWith("```")) {
+          const codeLines = [];
+          i++;
+          while (i < lines.length && !lines[i].startsWith("```")) {
+            codeLines.push(lines[i]);
+            i++;
+          }
+          i++;
+          kids.push(buildPara([buildSpan(codeLines.join("\n"), { font: "Courier New" })], {}));
+          continue;
+        }
+        if (line.trim() === "") {
+          i++;
+          continue;
+        }
+        const alignMatch = line.match(/^<div\s+align="(center|right|left)">(.*?)<\/div>$/i);
+        if (alignMatch) {
+          const align = alignMatch[1].toLowerCase();
+          kids.push(buildPara(parseInline(alignMatch[2]), { align }));
+          i++;
+          continue;
+        }
+        kids.push(buildPara(parseInline(line), {}));
+        i++;
+      }
+      warns.push(...shield.flush());
+      const sheet = buildSheet(kids.length > 0 ? kids : [buildPara([buildSpan("")])], A4);
+      return succeed(buildRoot({}, [sheet]), warns);
+    } catch (e) {
+      warns.push(...shield.flush());
+      return fail(`MD decode error: ${e?.message ?? String(e)}`, warns);
+    }
+  }
+};
+function parseInline(text) {
+  const result = [];
+  let rem = text;
+  while (rem.length > 0) {
+    let m = rem.match(/^(.*?)!\[([^\]]*)\]\((data:([^;]+);base64,([^)]+))\)(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      const mime = m[4];
+      const validMimes = ["image/png", "image/jpeg", "image/gif", "image/bmp"];
+      result.push(buildImg(m[5], validMimes.includes(mime) ? mime : "image/png", 100, 100, m[2] || void 0));
+      rem = m[6];
+      continue;
+    }
+    m = rem.match(/^(.*?)!\[([^\]]*)\]\(([^)]+)\)(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(`[\uC774\uBBF8\uC9C0: ${m[2] || m[3]}]`));
+      rem = m[4];
+      continue;
+    }
+    m = rem.match(/^(.*?)\*\*\*(.+?)\*\*\*(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { b: true, i: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)\*\*(.+?)\*\*(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { b: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)\*(.+?)\*(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { i: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)~~(.+?)~~(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { s: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)<u>(.+?)<\/u>(.*)/si);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { u: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)<sup>(.+?)<\/sup>(.*)/si);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { sup: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)<sub>(.+?)<\/sub>(.*)/si);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { sub: true }));
+      rem = m[3];
+      continue;
+    }
+    m = rem.match(/^(.*?)`(.+?)`(.*)/s);
+    if (m) {
+      if (m[1]) result.push(buildSpan(m[1]));
+      result.push(buildSpan(m[2], { font: "Courier New" }));
+      rem = m[3];
+      continue;
+    }
+    result.push(buildSpan(rem));
+    break;
+  }
+  return result.length > 0 ? result : [buildSpan(text)];
+}
+function parseMdTable(lines, startLine) {
+  const parse = (line) => line.split("|").map((c) => c.trim()).filter((c, i, arr) => i > 0 || c !== "");
+  const headers = parse(lines[startLine]);
+  let cur = startLine + 2;
+  const rows = [];
+  while (cur < lines.length) {
+    if (!lines[cur].includes("|")) break;
+    const cells = parse(lines[cur]);
+    if (cells.length === 0) break;
+    rows.push(cells);
+    cur++;
+  }
+  const allRows = [headers, ...rows];
+  const gridRows = allRows.map(
+    (row, ri) => buildRow(row.map((cell) => buildCell([buildPara([buildSpan(cell, ri === 0 ? { b: true } : {})])])))
+  );
+  return { node: buildGrid(gridRows), nextLine: cur };
+}
+registry.registerDecoder(new MdDecoder());
+
+// src/encoders/hwpx/HwpxEncoder.ts
+var NS = [
+  'xmlns:ha="http://www.hancom.co.kr/hwpml/2011/app"',
+  'xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph"',
+  'xmlns:hp10="http://www.hancom.co.kr/hwpml/2016/paragraph"',
+  'xmlns:hs="http://www.hancom.co.kr/hwpml/2011/section"',
+  'xmlns:hc="http://www.hancom.co.kr/hwpml/2011/core"',
+  'xmlns:hh="http://www.hancom.co.kr/hwpml/2011/head"',
+  'xmlns:hhs="http://www.hancom.co.kr/hwpml/2011/history"',
+  'xmlns:hm="http://www.hancom.co.kr/hwpml/2011/master-page"',
+  'xmlns:hpf="http://www.hancom.co.kr/schema/2011/hpf"',
+  'xmlns:dc="http://purl.org/dc/elements/1.1/"',
+  'xmlns:opf="http://www.idpf.org/2007/opf/"',
+  'xmlns:ooxmlchart="http://www.hancom.co.kr/hwpml/2016/ooxmlchart"',
+  'xmlns:epub="http://www.idpf.org/2007/ops"',
+  'xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0"'
+].join(" ");
+function charPrKey(p) {
+  return `${p.b ? 1 : 0}|${p.i ? 1 : 0}|${p.u ? 1 : 0}|${p.s ? 1 : 0}|${p.pt ?? 10}|${p.color ?? "000000"}|${p.font ?? ""}|${p.bg ?? ""}`;
+}
+function paraPrKey(p) {
+  return `${p.align ?? "left"}|${p.listOrd ?? ""}|${p.listLv ?? 0}`;
+}
+function registerFont(name, ctx) {
+  const n = name || "\uAD74\uB9BC\uCCB4";
+  const existing = ctx.fontMap.get(n);
+  if (existing !== void 0) return existing;
+  const id = ctx.fonts.length;
+  ctx.fonts.push(n);
+  ctx.fontMap.set(n, id);
+  return id;
+}
+function registerCharPr(props, ctx) {
+  const key = charPrKey(props);
+  const existing = ctx.charPrMap.get(key);
+  if (existing !== void 0) return existing;
+  const fontName = safeFontToKr(props.font) || "\uAD74\uB9BC\uCCB4";
+  const fontId = registerFont(fontName, ctx);
+  const id = ctx.charPrs.length;
+  const def = {
+    id,
+    height: Metric.ptToHHeight(props.pt ?? 10),
+    bold: !!props.b,
+    italic: !!props.i,
+    underline: props.u ? "BOTTOM" : "NONE",
+    strikeout: props.s ? "SOLID" : "NONE",
+    textColor: props.color ? `#${props.color}` : "#000000",
+    fontName,
+    fontId,
+    bg: props.bg
+  };
+  ctx.charPrs.push(def);
+  ctx.charPrMap.set(key, id);
+  return id;
+}
+function registerParaPr(props, ctx) {
+  const key = paraPrKey(props);
+  const existing = ctx.paraPrMap.get(key);
+  if (existing !== void 0) return existing;
+  const id = ctx.paraPrs.length;
+  const def = {
+    id,
+    align: (props.align ?? "left").toUpperCase()
+  };
+  if (props.listOrd !== void 0) {
+    def.listType = props.listOrd ? "DIGIT" : "BULLET";
+    def.listLevel = props.listLv ?? 0;
+  }
+  ctx.paraPrs.push(def);
+  ctx.paraPrMap.set(key, id);
+  return id;
+}
+function scanContent(kids, ctx) {
+  for (const kid of kids) {
+    if (kid.tag === "para") scanPara(kid, ctx);
+    else if (kid.tag === "grid") scanGrid(kid, ctx);
+  }
+}
+function scanPara(para, ctx) {
+  registerParaPr(para.props, ctx);
+  for (const kid of para.kids) {
+    if (kid.tag === "span") registerCharPr(kid.props, ctx);
+    else if (kid.tag === "img") registerImage(kid, ctx);
+  }
+}
+function scanGrid(grid, ctx) {
+  for (const row of grid.kids)
+    for (const cell of row.kids)
+      for (const p of cell.kids) scanPara(p, ctx);
+}
+function scanParas(paras, ctx) {
+  for (const p of paras) scanPara(p, ctx);
+}
+function mimeToExt(mime) {
+  if (mime.includes("jpeg")) return "jpg";
+  if (mime.includes("gif")) return "gif";
+  if (mime.includes("bmp")) return "bmp";
+  return "png";
+}
+function registerImage(img, ctx) {
+  if (img._binId) return;
+  const ext = mimeToExt(img.mime);
+  const id = `BIN${String(ctx.nextBinNum).padStart(4, "0")}`;
+  const name = `${id}.${ext}`;
+  ctx.nextBinNum++;
+  const data = TextKit.base64Decode(img.b64);
+  ctx.bins.push({ id, name, data });
+  img._binId = id;
+}
+function addBorderFill(ctx, stroke, bgColor) {
+  const id = ctx.borderFills.length + 1;
+  const s = stroke ?? DEFAULT_STROKE;
+  const kindMap = { solid: "SOLID", dash: "DASH", dot: "DOT", double: "DOUBLE", none: "NONE" };
+  const type = kindMap[s.kind] ?? "SOLID";
+  const w = `${(s.pt * 0.3528).toFixed(2)} mm`;
+  const c = s.color.startsWith("#") ? s.color : `#${s.color}`;
+  let fill = "";
+  if (bgColor) {
+    const bc = bgColor.startsWith("#") ? bgColor : `#${bgColor}`;
+    fill = `<hc:fillBrush><hc:winBrush faceColor="${bc}" hatchColor="none" alpha="0"/></hc:fillBrush>`;
+  }
+  const xml = `<hh:borderFill id="${id}" threeD="0" shadow="0" centerLine="NONE" breakCellSeparateLine="0"><hh:slash type="NONE" Crooked="0" isCounter="0"/><hh:backSlash type="NONE" Crooked="0" isCounter="0"/><hh:leftBorder type="${type}" width="${w}" color="${c}"/><hh:rightBorder type="${type}" width="${w}" color="${c}"/><hh:topBorder type="${type}" width="${w}" color="${c}"/><hh:bottomBorder type="${type}" width="${w}" color="${c}"/><hh:diagonal type="SOLID" width="0.1 mm" color="#000000"/>${fill}</hh:borderFill>`;
+  ctx.borderFills.push({ id, xml });
+  return id;
+}
+var HwpxEncoder = class {
+  constructor() {
+    this.format = "hwpx";
+  }
+  async encode(doc) {
+    try {
+      const sheet = doc.kids[0];
+      const dims = sheet?.dims ?? A4;
+      const availableWidth = Metric.ptToHwp(dims.wPt) - Metric.ptToHwp(dims.ml) - Metric.ptToHwp(dims.mr);
+      const ctx = {
+        charPrs: [],
+        charPrMap: /* @__PURE__ */ new Map(),
+        paraPrs: [],
+        paraPrMap: /* @__PURE__ */ new Map(),
+        borderFills: [],
+        bins: [],
+        nextBinNum: 1,
+        nextElementId: 1e4,
+        availableWidth,
+        fonts: [],
+        fontMap: /* @__PURE__ */ new Map()
+      };
+      addBorderFill(ctx, { kind: "none", pt: 0.1, color: "000000" });
+      addBorderFill(ctx, DEFAULT_STROKE);
+      addBorderFill(ctx, { kind: "none", pt: 0.1, color: "000000" });
+      registerCharPr({}, ctx);
+      registerParaPr({}, ctx);
+      scanContent(sheet?.kids ?? [], ctx);
+      if (sheet?.header) scanParas(sheet.header, ctx);
+      if (sheet?.footer) scanParas(sheet.footer, ctx);
+      const previewText = extractPreviewText(sheet);
+      const sectionData = TextKit.encode(sectionXml(sheet, dims, ctx));
+      const headerData = TextKit.encode(headerXml(dims, doc.meta, ctx));
+      const entries = [
+        { name: "mimetype", data: TextKit.encode("application/hwp+zip") },
+        { name: "version.xml", data: TextKit.encode(VERSION_XML) },
+        { name: "Contents/header.xml", data: headerData },
+        { name: "Contents/section0.xml", data: sectionData },
+        { name: "Preview/PrvText.txt", data: TextKit.encode(previewText) },
+        { name: "settings.xml", data: TextKit.encode(SETTINGS_XML) },
+        { name: "META-INF/container.rdf", data: TextKit.encode(CONTAINER_RDF) },
+        { name: "Contents/content.hpf", data: TextKit.encode(contentHpf(ctx, doc.meta)) },
+        { name: "META-INF/container.xml", data: TextKit.encode(CONTAINER_XML) },
+        { name: "META-INF/manifest.xml", data: TextKit.encode(MANIFEST_XML) }
+      ];
+      for (const bin of ctx.bins) {
+        entries.push({ name: `BinData/${bin.name}`, data: bin.data });
+      }
+      return succeed(await ArchiveKit.zip(entries));
+    } catch (e) {
+      return fail(`HWPX encode error: ${e?.message ?? String(e)}`);
+    }
+  }
+};
+var VERSION_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><hv:HCFVersion xmlns:hv="http://www.hancom.co.kr/hwpml/2011/version" tagetApplication="WORDPROCESSOR" major="5" minor="1" micro="0" buildNumber="1" os="6" xmlVersion="1.2" application="Hancom Office Hangul" appVersion="11, 0, 0, 0"/>`;
+var CONTAINER_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><ocf:container xmlns:ocf="urn:oasis:names:tc:opendocument:xmlns:container" xmlns:hpf="http://www.hancom.co.kr/schema/2011/hpf"><ocf:rootfiles><ocf:rootfile full-path="Contents/content.hpf" media-type="application/hwpml-package+xml"/><ocf:rootfile full-path="Preview/PrvText.txt" media-type="text/plain"/><ocf:rootfile full-path="META-INF/container.rdf" media-type="application/rdf+xml"/></ocf:rootfiles></ocf:container>`;
+var CONTAINER_RDF = `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description rdf:about=""><ns0:hasPart xmlns:ns0="http://www.hancom.co.kr/hwpml/2016/meta/pkg#" rdf:resource="Contents/header.xml"/></rdf:Description><rdf:Description rdf:about="Contents/header.xml"><rdf:type rdf:resource="http://www.hancom.co.kr/hwpml/2016/meta/pkg#HeaderFile"/></rdf:Description><rdf:Description rdf:about=""><ns0:hasPart xmlns:ns0="http://www.hancom.co.kr/hwpml/2016/meta/pkg#" rdf:resource="Contents/section0.xml"/></rdf:Description><rdf:Description rdf:about="Contents/section0.xml"><rdf:type rdf:resource="http://www.hancom.co.kr/hwpml/2016/meta/pkg#SectionFile"/></rdf:Description><rdf:Description rdf:about=""><rdf:type rdf:resource="http://www.hancom.co.kr/hwpml/2016/meta/pkg#Document"/></rdf:Description></rdf:RDF>`;
+var MANIFEST_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><odf:manifest xmlns:odf="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"/>`;
+var SETTINGS_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><ha:HWPApplicationSetting xmlns:ha="http://www.hancom.co.kr/hwpml/2011/app" xmlns:config="urn:oasis:names:tc:opendocument:xmlns:config:1.0"><ha:CaretPosition listIDRef="0" paraIDRef="0" pos="0"/><config:config-item-set name="PrintInfo"><config:config-item name="PrintMethod" type="short">0</config:config-item><config:config-item name="ZoomX" type="short">100</config:config-item><config:config-item name="ZoomY" type="short">100</config:config-item></config:config-item-set></ha:HWPApplicationSetting>`;
+function contentHpf(ctx, meta) {
+  const title = esc(meta?.title ?? "");
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  let items = `<opf:item id="header" href="Contents/header.xml" media-type="application/xml"/><opf:item id="section0" href="Contents/section0.xml" media-type="application/xml"/><opf:item id="settings" href="settings.xml" media-type="application/xml"/>`;
+  for (const bin of ctx.bins) {
+    const ext = bin.name.split(".").pop()?.toLowerCase() ?? "png";
+    const ct = ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "gif" ? "image/gif" : "image/bmp";
+    items += `<opf:item id="${bin.id}" href="BinData/${bin.name}" media-type="${ct}" isEmbeded="1"/>`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><opf:package ${NS} version="" unique-identifier="" id=""><opf:metadata><opf:title>${title}</opf:title><opf:language>ko</opf:language><opf:meta name="creator" content="text"/><opf:meta name="subject" content="text"/><opf:meta name="description" content="text"/><opf:meta name="CreatedDate" content="text">${now}</opf:meta><opf:meta name="ModifiedDate" content="text">${now}</opf:meta><opf:meta name="keyword" content="text"/></opf:metadata><opf:manifest>${items}</opf:manifest><opf:spine><opf:itemref idref="header" linear="no"/><opf:itemref idref="section0" linear="yes"/></opf:spine></opf:package>`;
+}
+function headerXml(dims, meta, ctx) {
+  const fontCount = ctx.fonts.length || 1;
+  const langs = ["HANGUL", "LATIN", "HANJA", "JAPANESE", "OTHER", "SYMBOL", "USER"];
+  let fontFaces = `<hh:fontfaces itemCnt="${langs.length}">`;
+  for (const lang of langs) {
+    fontFaces += `<hh:fontface lang="${lang}" fontCnt="${fontCount}">`;
+    for (let fi = 0; fi < ctx.fonts.length; fi++) {
+      fontFaces += `<hh:font id="${fi}" face="${esc(ctx.fonts[fi])}" type="TTF" isEmbedded="0"><hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/></hh:font>`;
+    }
+    if (ctx.fonts.length === 0) {
+      fontFaces += `<hh:font id="0" face="\uAD74\uB9BC\uCCB4" type="TTF" isEmbedded="0"><hh:typeInfo familyType="FCAT_GOTHIC" weight="6" proportion="0" contrast="0" strokeVariation="1" armStyle="1" letterform="1" midline="1" xHeight="1"/></hh:font>`;
+    }
+    fontFaces += `</hh:fontface>`;
+  }
+  fontFaces += `</hh:fontfaces>`;
+  let charPrXml = "";
+  for (const cp of ctx.charPrs) {
+    const bold = cp.bold ? "<hh:bold/>" : "";
+    const italic = cp.italic ? "<hh:italic/>" : "";
+    const fid = cp.fontId ?? 0;
+    charPrXml += `<hh:charPr id="${cp.id}" height="${cp.height}" textColor="${cp.textColor}" shadeColor="none" useFontSpace="0" useKerning="0" symMark="NONE" borderFillIDRef="3"><hh:fontRef hangul="${fid}" latin="${fid}" hanja="${fid}" japanese="${fid}" other="${fid}" symbol="${fid}" user="${fid}"/><hh:ratio hangul="100" latin="100" hanja="100" japanese="100" other="100" symbol="100" user="100"/><hh:spacing hangul="0" latin="0" hanja="0" japanese="0" other="0" symbol="0" user="0"/><hh:relSz hangul="100" latin="100" hanja="100" japanese="100" other="100" symbol="100" user="100"/><hh:offset hangul="0" latin="0" hanja="0" japanese="0" other="0" symbol="0" user="0"/>${bold}${italic}<hh:underline type="${cp.underline}" shape="SOLID" color="#000000"/><hh:strikeout shape="${cp.strikeout}" color="#000000"/><hh:outline type="NONE"/><hh:shadow type="NONE" color="#C0C0C0" offsetX="10" offsetY="10"/></hh:charPr>`;
+  }
+  let paraPrXml = "";
+  for (const pp of ctx.paraPrs) {
+    paraPrXml += `<hh:paraPr id="${pp.id}" tabPrIDRef="0" condense="0" fontLineHeight="0" snapToGrid="0" suppressLineNumbers="0" checked="0"><hh:align horizontal="${pp.align}" vertical="BASELINE"/><hh:heading type="NONE" idRef="0" level="0"/><hh:breakSetting breakLatinWord="KEEP_WORD" breakNonLatinWord="BREAK_WORD" widowOrphan="0" keepWithNext="0" keepLines="0" pageBreakBefore="0" lineWrap="BREAK"/><hh:autoSpacing eAsianEng="0" eAsianNum="0"/><hh:margin><hc:intent value="0" unit="HWPUNIT"/><hc:left value="0" unit="HWPUNIT"/><hc:right value="0" unit="HWPUNIT"/><hc:prev value="0" unit="HWPUNIT"/><hc:next value="0" unit="HWPUNIT"/></hh:margin><hh:lineSpacing type="PERCENT" value="160" unit="HWPUNIT"/><hh:border borderFillIDRef="1" offsetLeft="0" offsetRight="0" offsetTop="0" offsetBottom="0" connect="0" ignoreMargin="0"/></hh:paraPr>`;
+  }
+  const borderFillXml = ctx.borderFills.map((bf) => bf.xml).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><hh:head ${NS} version="1.2" secCnt="1"><hh:beginNum page="1" footnote="1" endnote="1" pic="1" tbl="1" equation="1"/><hh:refList>${fontFaces}<hh:borderFills itemCnt="${ctx.borderFills.length}">${borderFillXml}</hh:borderFills><hh:charProperties itemCnt="${ctx.charPrs.length}">${charPrXml}</hh:charProperties><hh:paraProperties itemCnt="${ctx.paraPrs.length}">${paraPrXml}</hh:paraProperties><hh:tabProperties itemCnt="1"><hh:tabPr id="0" autoTabLeft="0" autoTabRight="0"/></hh:tabProperties><hh:styles itemCnt="1"><hh:style id="0" type="PARA" name="\uBC14\uD0D5\uAE00" engName="Normal" paraPrIDRef="0" charPrIDRef="0" nextStyleIDRef="0" langID="1042" lockForm="0"/></hh:styles></hh:refList><hh:compatibleDocument targetProgram="HWP201X"><hh:layoutCompatibility/></hh:compatibleDocument><hh:docOption><hh:linkinfo path="" pageInherit="1" footnoteInherit="0"/></hh:docOption><hh:trackchageConfig flags="56"/></hh:head>`;
+}
+function sectionXml(sheet, dims, ctx) {
+  const kids = sheet?.kids ?? [];
+  const secPr = `<hp:secPr id="" textDirection="HORIZONTAL" spaceColumns="1134" tabStop="8000" outlineShapeIDRef="0" memoShapeIDRef="0" textVerticalWidthHead="0" masterPageCnt="0"><hp:grid lineGrid="0" charGrid="0" wonggojiFormat="0"/><hp:startNum pageStartsOn="BOTH" page="0" pic="0" tbl="0" equation="0"/><hp:visibility hideFirstHeader="0" hideFirstFooter="0" hideFirstMasterPage="0" border="SHOW_ALL" fill="SHOW_ALL" hideFirstPageNum="0" hideFirstEmptyLine="0" showLineNumber="0"/><hp:lineNumberShape restartType="0" countBy="0" distance="0" startNumber="0"/><hp:pagePr landscape="${dims.orient === "landscape" ? "NARROWLY" : "WIDELY"}" width="${Metric.ptToHwp(dims.wPt)}" height="${Metric.ptToHwp(dims.hPt)}" gutterType="LEFT_ONLY"><hp:margin header="2834" footer="2834" gutter="0" left="${Metric.ptToHwp(dims.ml)}" right="${Metric.ptToHwp(dims.mr)}" top="${Metric.ptToHwp(dims.mt)}" bottom="${Metric.ptToHwp(dims.mb)}"/></hp:pagePr><hp:footNotePr><hp:autoNumFormat type="DIGIT" userChar="" prefixChar="" suffixChar=")" supscript="0"/><hp:noteLine length="-1" type="SOLID" width="0.12 mm" color="#000000"/><hp:noteSpacing betweenNotes="284" belowLine="568" aboveLine="852"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="EACH_COLUMN" beneathText="0"/></hp:footNotePr><hp:endNotePr><hp:autoNumFormat type="DIGIT" userChar="" prefixChar="" suffixChar=")" supscript="0"/><hp:noteLine length="0" type="NONE" width="0.12 mm" color="#000000"/><hp:noteSpacing betweenNotes="0" belowLine="576" aboveLine="864"/><hp:numbering type="CONTINUOUS" newNum="1"/><hp:placement place="END_OF_DOCUMENT" beneathText="0"/></hp:endNotePr><hp:pageBorderFill type="BOTH" borderFillIDRef="1" textBorder="PAPER" headerInside="0" footerInside="0" fillArea="PAPER"><hp:offset left="1417" right="1417" top="1417" bottom="1417"/></hp:pageBorderFill><hp:pageBorderFill type="EVEN" borderFillIDRef="1" textBorder="PAPER" headerInside="0" footerInside="0" fillArea="PAPER"><hp:offset left="1417" right="1417" top="1417" bottom="1417"/></hp:pageBorderFill><hp:pageBorderFill type="ODD" borderFillIDRef="1" textBorder="PAPER" headerInside="0" footerInside="0" fillArea="PAPER"><hp:offset left="1417" right="1417" top="1417" bottom="1417"/></hp:pageBorderFill></hp:secPr><hp:ctrl><hp:colPr id="" type="NEWSPAPER" layout="LEFT" colCount="1" sameSz="1" sameGap="0"/></hp:ctrl>`;
+  let contentXml = "";
+  let isFirst = true;
+  const defaultLineseg = `<hp:linesegarray><hp:lineseg textpos="0" vertpos="0" vertsize="1000" textheight="1000" baseline="850" spacing="600" horzpos="0" horzsize="${ctx.availableWidth}" flags="393216"/></hp:linesegarray>`;
+  for (const kid of kids) {
+    if (kid.tag === "para") {
+      contentXml += encodePara(kid, ctx, isFirst ? secPr : "");
+      isFirst = false;
+    } else if (kid.tag === "grid") {
+      const gridXml = encodeGrid(kid, ctx);
+      const prefix = isFirst ? secPr : "";
+      contentXml += `<hp:p id="${ctx.nextElementId++}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0">${prefix}${gridXml}</hp:run>${defaultLineseg}</hp:p>`;
+      isFirst = false;
+    }
+  }
+  if (contentXml === "") {
+    contentXml = `<hp:p id="${ctx.nextElementId++}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0">${secPr}<hp:t></hp:t></hp:run>${defaultLineseg}</hp:p>`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><hs:sec ${NS}>${contentXml}</hs:sec>`;
+}
+function encodePara(para, ctx, secPr = "") {
+  const paraPrId = registerParaPr(para.props, ctx);
+  let runs = "";
+  for (const kid of para.kids) {
+    if (kid.tag === "span") {
+      runs += encodeRun(kid, ctx);
+    } else if (kid.tag === "img") {
+      runs += encodeImage(kid, ctx);
+    }
+  }
+  if (runs === "") {
+    runs = `<hp:run charPrIDRef="0"><hp:t></hp:t></hp:run>`;
+  }
+  if (secPr) {
+    const firstRunEnd = runs.indexOf(">");
+    if (firstRunEnd > -1) {
+      runs = runs.substring(0, firstRunEnd + 1) + secPr + runs.substring(firstRunEnd + 1);
+    }
+  }
+  const fontSize = getFontSizeForPara(para, ctx);
+  const vertsize = fontSize;
+  const textheight = fontSize;
+  const baseline = Math.round(fontSize * 0.85);
+  const spacing = Math.round(fontSize * 0.6);
+  const linesegarray = `<hp:linesegarray><hp:lineseg textpos="0" vertpos="0" vertsize="${vertsize}" textheight="${textheight}" baseline="${baseline}" spacing="${spacing}" horzpos="0" horzsize="${ctx.availableWidth}" flags="393216"/></hp:linesegarray>`;
+  return `<hp:p id="${ctx.nextElementId++}" paraPrIDRef="${paraPrId}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">${runs}${linesegarray}</hp:p>`;
+}
+function getFontSizeForPara(para, ctx) {
+  for (const kid of para.kids) {
+    if (kid.tag === "span") {
+      const charPrId = ctx.charPrMap.get(charPrKey(kid.props));
+      if (charPrId !== void 0 && ctx.charPrs[charPrId]) {
+        return ctx.charPrs[charPrId].height;
+      }
+    }
+  }
+  return 1e3;
+}
+function encodeRun(span, ctx) {
+  const charPrId = registerCharPr(span.props, ctx);
+  const parts = [];
+  for (const kid of span.kids) {
+    if (kid.tag === "txt") {
+      if (kid.content) {
+        parts.push(`<hp:t>${esc(kid.content)}</hp:t>`);
+      } else {
+        parts.push(`<hp:t></hp:t>`);
+      }
+    } else if (kid.tag === "pagenum") {
+      const fmt = kid.format === "roman" ? "ROMAN_LOWER" : kid.format === "romanCaps" ? "ROMAN_UPPER" : "DIGIT";
+      parts.push(`<hp:pageNum pageStartsOn="BOTH" formatType="${fmt}"/>`);
+    } else if (kid.tag === "br") {
+      parts.push(`<hp:t>
+</hp:t>`);
+    }
+  }
+  return `<hp:run charPrIDRef="${charPrId}">${parts.join("")}</hp:run>`;
+}
+function encodeImage(img, ctx) {
+  const binId = img._binId;
+  if (!binId) return "";
+  const charPrId = registerCharPr({}, ctx);
+  const w = Metric.ptToHwp(img.w);
+  const h = Metric.ptToHwp(img.h);
+  return `<hp:run charPrIDRef="${charPrId}"><hp:pic id="${ctx.nextElementId++}" zOrder="0" numberingType="PICTURE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="CELL" treatAsChar="1"><hp:sz width="${w}" widthRelTo="ABSOLUTE" height="${h}" heightRelTo="ABSOLUTE" protect="0"/><hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/><hp:outMargin left="0" right="0" top="0" bottom="0"/><hp:imgRect x="0" y="0" w="${w}" h="${h}"/><hp:imgClip left="0" right="0" top="0" bottom="0"/><hp:img binaryItemIDRef="${binId}" bright="0" contrast="0" effect="REAL_PIC" alpha="0"/></hp:pic></hp:run>`;
+}
+function encodeGrid(grid, ctx) {
+  const rowCount = grid.kids.length;
+  let colCount = 0;
+  for (const row of grid.kids) {
+    let rowCols = 0;
+    for (const cell of row.kids) rowCols += cell.cs;
+    if (rowCols > colCount) colCount = rowCols;
+  }
+  if (colCount === 0) colCount = grid.kids[0]?.kids.length ?? 1;
+  const totalWidth = ctx.availableWidth;
+  const defaultColW = Math.round(totalWidth / (colCount || 1));
+  const colWidths = [];
+  if (grid.props.colWidths && grid.props.colWidths.length === colCount) {
+    const srcPt = [...grid.props.colWidths];
+    const knownTotal = srcPt.filter((w) => w > 0).reduce((s, w) => s + w, 0);
+    const zeroCount = srcPt.filter((w) => w <= 0).length;
+    const remaining = Math.max(0, Metric.hwpToPt(totalWidth) - knownTotal);
+    const zeroFill = zeroCount > 0 ? remaining / zeroCount : 0;
+    for (let i = 0; i < srcPt.length; i++) {
+      if (srcPt[i] <= 0) srcPt[i] = zeroFill > 0 ? zeroFill : Metric.hwpToPt(defaultColW);
+    }
+    for (const wPt of srcPt) colWidths.push(Metric.ptToHwp(wPt));
+  } else {
+    for (let c = 0; c < colCount; c++) colWidths.push(defaultColW);
+  }
+  const rawTotal = colWidths.reduce((s, w) => s + w, 0);
+  if (rawTotal > totalWidth * 1.05) {
+    const scale = totalWidth / rawTotal;
+    for (let i = 0; i < colWidths.length; i++) colWidths[i] = Math.round(colWidths[i] * scale);
+  }
+  const actualTotal = colWidths.reduce((s, w) => s + w, 0);
+  const tblBfId = grid.props.defaultStroke ? addBorderFill(ctx, grid.props.defaultStroke) : 2;
+  let rowsXml = "";
+  for (let ri = 0; ri < grid.kids.length; ri++) {
+    const row = grid.kids[ri];
+    let cellsXml = "";
+    let colIdx = 0;
+    for (let ci = 0; ci < row.kids.length; ci++) {
+      const cell = row.kids[ci];
+      let cellBfId = tblBfId;
+      if (cell.props.bg) {
+        cellBfId = addBorderFill(ctx, grid.props.defaultStroke ?? DEFAULT_STROKE, cell.props.bg);
+      }
+      const parasXml = cell.kids.map((p) => encodePara(p, ctx)).join("");
+      let cellW = 0;
+      for (let sc = colIdx; sc < colIdx + cell.cs && sc < colWidths.length; sc++) cellW += colWidths[sc];
+      if (cellW === 0) cellW = defaultColW * cell.cs;
+      cellsXml += `<hp:tc name="" header="0" hasMargin="1" protect="0" editable="0" dirty="0" borderFillIDRef="${cellBfId}"><hp:subList id="" textDirection="HORIZONTAL" lineWrap="BREAK" vertAlign="${cell.props.va === "mid" ? "CENTER" : cell.props.va === "bot" ? "BOTTOM" : "TOP"}" linkListIDRef="0" linkListNextIDRef="0" textWidth="0" textHeight="0" hasTextRef="0" hasNumRef="0">${parasXml}</hp:subList><hp:cellAddr colAddr="${colIdx}" rowAddr="${ri}"/><hp:cellSpan colSpan="${cell.cs}" rowSpan="${cell.rs}"/><hp:cellSz width="${cellW}" height="1000"/><hp:cellMargin left="141" right="141" top="141" bottom="141"/></hp:tc>`;
+      colIdx += cell.cs;
+    }
+    rowsXml += `<hp:tr>${cellsXml}</hp:tr>`;
+  }
+  const headerRow = grid.props.headerRow ? ' repeatHeader="1"' : "";
+  return `<hp:tbl id="${ctx.nextElementId++}" zOrder="0" numberingType="TABLE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="CELL"${headerRow} rowCnt="${rowCount}" colCnt="${colCount}" cellSpacing="0" borderFillIDRef="${tblBfId}" noAdjust="0"><hp:sz width="${actualTotal}" widthRelTo="ABSOLUTE" height="1000" heightRelTo="ABSOLUTE" protect="0"/><hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/><hp:outMargin left="0" right="0" top="0" bottom="0"/><hp:inMargin left="138" right="138" top="138" bottom="138"/>${rowsXml}</hp:tbl>`;
+}
+function extractPreviewText(sheet) {
+  if (!sheet) return "";
+  const lines = [];
+  for (const kid of sheet.kids) {
+    if (kid.tag === "para") {
+      const text = kid.kids.map((k) => {
+        if (k.tag === "span") return k.kids.map((c) => c.tag === "txt" ? c.content : "").join("");
+        return "";
+      }).join("");
+      if (text) lines.push(text);
+    } else if (kid.tag === "grid") {
+      for (const row of kid.kids) {
+        const cells = row.kids.map(
+          (cell) => cell.kids.map((p) => p.kids.map((k) => {
+            if (k.tag === "span") return k.kids.map((c) => c.tag === "txt" ? c.content : "").join("");
+            return "";
+          }).join("")).join("")
+        );
+        lines.push(cells.join("	"));
+      }
+    }
+  }
+  return lines.join("\r\n");
+}
+function esc(s) {
+  return TextKit.escapeXml(s);
+}
+registry.registerEncoder(new HwpxEncoder());
+
+// src/encoders/docx/DocxEncoder.ts
+var DocxEncoder = class {
+  constructor() {
+    this.format = "docx";
+  }
+  async encode(doc) {
+    try {
+      const sheet = doc.kids[0];
+      const dims = sheet?.dims ?? A4;
+      const kids = sheet?.kids ?? [];
+      const images = [];
+      const ctx = { images, nextId: 10, nextImgNum: 1, warns: [] };
+      collectImages(kids, ctx);
+      let headerParas = sheet?.header;
+      let footerParas = sheet?.footer;
+      const hasHeader = headerParas && headerParas.length > 0;
+      const hasFooter = footerParas && footerParas.length > 0;
+      if (hasHeader) collectImagesFromParas(headerParas, ctx);
+      if (hasFooter) collectImagesFromParas(footerParas, ctx);
+      const headerRId = hasHeader ? `rId${ctx.nextId++}` : "";
+      const footerRId = hasFooter ? `rId${ctx.nextId++}` : "";
+      const numInfo = collectNumbering(kids);
+      const entries = [
+        { name: "[Content_Types].xml", data: TextKit.encode(contentTypes(images, hasHeader, hasFooter)) },
+        { name: "_rels/.rels", data: TextKit.encode(pkgRels()) },
+        { name: "word/document.xml", data: TextKit.encode(documentXml(kids, dims, ctx, headerRId, footerRId)) },
+        { name: "word/styles.xml", data: TextKit.encode(stylesXml()) },
+        { name: "word/settings.xml", data: TextKit.encode(settingsXml()) },
+        { name: "word/_rels/document.xml.rels", data: TextKit.encode(docRels(images, headerRId, footerRId, numInfo.hasLists)) },
+        { name: "docProps/app.xml", data: TextKit.encode(appXml()) },
+        { name: "docProps/core.xml", data: TextKit.encode(coreXml(doc.meta)) }
+      ];
+      if (numInfo.hasLists) {
+        entries.push({ name: "word/numbering.xml", data: TextKit.encode(numberingXml(numInfo)) });
+      }
+      if (hasHeader) {
+        entries.push({ name: "word/header1.xml", data: TextKit.encode(headerFooterXml("hdr", headerParas, ctx)) });
+      }
+      if (hasFooter) {
+        entries.push({ name: "word/footer1.xml", data: TextKit.encode(headerFooterXml("ftr", footerParas, ctx)) });
+      }
+      for (const img of images) {
+        entries.push({ name: `word/media/${img.name}`, data: img.data });
+      }
+      return succeed(await ArchiveKit.zip(entries));
+    } catch (e) {
+      return fail(`DOCX encode error: ${e?.message ?? String(e)}`);
+    }
+  }
+};
+function mimeToExt2(mime) {
+  if (mime.includes("jpeg")) return "jpeg";
+  if (mime.includes("gif")) return "gif";
+  if (mime.includes("bmp")) return "bmp";
+  return "png";
+}
+function collectImages(kids, ctx) {
+  for (const kid of kids) {
+    if (kid.tag === "para") collectImagesFromPara(kid, ctx);
+    else if (kid.tag === "grid") {
+      for (const row of kid.kids)
+        for (const cell of row.kids)
+          for (const p of cell.kids) collectImagesFromPara(p, ctx);
+    }
+  }
+}
+function collectImagesFromParas(paras, ctx) {
+  for (const p of paras) collectImagesFromPara(p, ctx);
+}
+function collectImagesFromPara(para, ctx) {
+  for (const kid of para.kids) {
+    if (kid.tag === "img") registerImage2(kid, ctx);
+  }
+}
+function registerImage2(img, ctx) {
+  if (img._rId) return;
+  const ext = mimeToExt2(img.mime);
+  const name = `image${ctx.nextImgNum++}.${ext}`;
+  const rId = `rId${ctx.nextId++}`;
+  const data = TextKit.base64Decode(img.b64);
+  ctx.images.push({ rId, name, data, ext });
+  img._rId = rId;
+}
+function collectNumbering(kids) {
+  let hasBullet = false;
+  let hasNumbered = false;
+  for (const kid of kids) {
+    if (kid.tag === "para") {
+      if (kid.props.listOrd === true) hasNumbered = true;
+      else if (kid.props.listOrd === false) hasBullet = true;
+    }
+  }
+  return { hasLists: hasBullet || hasNumbered, hasBullet, hasNumbered };
+}
+function contentTypes(images, hasHeader, hasFooter) {
+  const imgDefaults = /* @__PURE__ */ new Set();
+  for (const img of images) imgDefaults.add(img.ext);
+  let defaults = `<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>`;
+  for (const ext of imgDefaults) {
+    const ct = ext === "png" ? "image/png" : ext === "jpeg" ? "image/jpeg" : ext === "gif" ? "image/gif" : "image/bmp";
+    defaults += `
+  <Default Extension="${ext}" ContentType="${ct}"/>`;
+  }
+  let overrides = `<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+  <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
+  <Override PartName="/word/settings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
+  <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
+  <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>`;
+  if (hasHeader) overrides += `
+  <Override PartName="/word/header1.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>`;
+  if (hasFooter) overrides += `
+  <Override PartName="/word/footer1.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>`;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  ${defaults}
+  ${overrides}
+</Types>`;
+}
+function pkgRels() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>`;
+}
+function docRels(images, headerRId, footerRId, hasLists) {
+  let rels = `<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings" Target="settings.xml"/>`;
+  if (hasLists) {
+    rels += `
+  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/>`;
+  }
+  for (const img of images) {
+    rels += `
+  <Relationship Id="${img.rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/${img.name}"/>`;
+  }
+  if (headerRId) {
+    rels += `
+  <Relationship Id="${headerRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/header" Target="header1.xml"/>`;
+  }
+  if (footerRId) {
+    rels += `
+  <Relationship Id="${footerRId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" Target="footer1.xml"/>`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  ${rels}
+</Relationships>`;
+}
+function appXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
+  <Application>hwpkit</Application>
+</Properties>`;
+}
+function coreXml(meta) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <dc:title>${esc2(meta.title ?? "")}</dc:title>
+  <dc:creator>${esc2(meta.author ?? "")}</dc:creator>
+  <dcterms:created xsi:type="dcterms:W3CDTF">${meta.created ?? now}</dcterms:created>
+  <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
+</cp:coreProperties>`;
+}
+function stylesXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:docDefaults>
+    <w:rPrDefault><w:rPr>
+      <w:rFonts w:ascii="\uB9D1\uC740 \uACE0\uB515" w:eastAsia="\uB9D1\uC740 \uACE0\uB515" w:hAnsi="\uB9D1\uC740 \uACE0\uB515"/>
+      <w:sz w:val="20"/>
+      <w:szCs w:val="20"/>
+    </w:rPr></w:rPrDefault>
+    <w:pPrDefault><w:pPr>
+      <w:spacing w:after="0" w:line="384" w:lineRule="auto"/>
+      <w:jc w:val="both"/>
+    </w:pPr></w:pPrDefault>
+  </w:docDefaults>
+  <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>
+  <w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:basedOn w:val="Normal"/><w:pPr><w:keepNext/><w:outlineLvl w:val="0"/></w:pPr><w:rPr><w:b/><w:sz w:val="44"/><w:szCs w:val="44"/></w:rPr></w:style>
+  <w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:basedOn w:val="Normal"/><w:pPr><w:keepNext/><w:outlineLvl w:val="1"/></w:pPr><w:rPr><w:b/><w:sz w:val="36"/><w:szCs w:val="36"/></w:rPr></w:style>
+  <w:style w:type="paragraph" w:styleId="Heading3"><w:name w:val="heading 3"/><w:basedOn w:val="Normal"/><w:pPr><w:keepNext/><w:outlineLvl w:val="2"/></w:pPr><w:rPr><w:b/><w:sz w:val="28"/><w:szCs w:val="28"/></w:rPr></w:style>
+  <w:style w:type="paragraph" w:styleId="Header"><w:name w:val="header"/><w:basedOn w:val="Normal"/></w:style>
+  <w:style w:type="paragraph" w:styleId="Footer"><w:name w:val="footer"/><w:basedOn w:val="Normal"/></w:style>
+  <w:style w:type="paragraph" w:styleId="ListParagraph"><w:name w:val="List Paragraph"/><w:basedOn w:val="Normal"/><w:pPr><w:ind w:left="720"/></w:pPr></w:style>
+  <w:style w:type="table" w:styleId="TableGrid"><w:name w:val="Table Grid"/><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="4" w:space="0" w:color="000000"/><w:left w:val="single" w:sz="4" w:space="0" w:color="000000"/><w:bottom w:val="single" w:sz="4" w:space="0" w:color="000000"/><w:right w:val="single" w:sz="4" w:space="0" w:color="000000"/><w:insideH w:val="single" w:sz="4" w:space="0" w:color="000000"/><w:insideV w:val="single" w:sz="4" w:space="0" w:color="000000"/></w:tblBorders></w:tblPr></w:style>
+</w:styles>`;
+}
+function settingsXml() {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:settings xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:zoom w:percent="100"/>
+  <w:bordersDoNotSurroundHeader/>
+  <w:bordersDoNotSurroundFooter/>
+  <w:defaultTabStop w:val="800"/>
+  <w:compat>
+    <w:spaceForUL/>
+    <w:balanceSingleByteDoubleByteWidth/>
+    <w:doNotLeaveBackslashAlone/>
+    <w:ulTrailSpace/>
+    <w:doNotExpandShiftReturn/>
+    <w:adjustLineHeightInTable/>
+    <w:useFELayout/>
+  </w:compat>
+</w:settings>`;
+}
+function numberingXml(info) {
+  let abstractNums = "";
+  let nums = "";
+  if (info.hasBullet) {
+    abstractNums += `<w:abstractNum w:abstractNumId="0">`;
+    for (let lvl = 0; lvl < 9; lvl++) {
+      const marker = lvl === 0 ? "\u25CF" : lvl === 1 ? "\u25CB" : "\u25A0";
+      const indent = (lvl + 1) * 720;
+      abstractNums += `<w:lvl w:ilvl="${lvl}"><w:numFmt w:val="bullet"/><w:lvlText w:val="${marker}"/><w:pPr><w:ind w:left="${indent}" w:hanging="360"/></w:pPr></w:lvl>`;
+    }
+    abstractNums += `</w:abstractNum>`;
+    nums += `<w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num>`;
+  }
+  if (info.hasNumbered) {
+    abstractNums += `<w:abstractNum w:abstractNumId="1">`;
+    for (let lvl = 0; lvl < 9; lvl++) {
+      const fmt = lvl % 3 === 0 ? "decimal" : lvl % 3 === 1 ? "lowerLetter" : "lowerRoman";
+      const indent = (lvl + 1) * 720;
+      abstractNums += `<w:lvl w:ilvl="${lvl}"><w:start w:val="1"/><w:numFmt w:val="${fmt}"/><w:lvlText w:val="%${lvl + 1}."/><w:pPr><w:ind w:left="${indent}" w:hanging="360"/></w:pPr></w:lvl>`;
+    }
+    abstractNums += `</w:abstractNum>`;
+    nums += `<w:num w:numId="2"><w:abstractNumId w:val="1"/></w:num>`;
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  ${abstractNums}
+  ${nums}
+</w:numbering>`;
+}
+function headerFooterXml(type, paras, ctx) {
+  const tag = type === "hdr" ? "w:hdr" : "w:ftr";
+  const body = paras.map((p) => encodeParaInner(p, ctx)).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<${tag} xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
+${body}
+</${tag}>`;
+}
+function documentXml(kids, dims, ctx, headerRId, footerRId) {
+  const body = kids.map((k) => encodeContent(k, ctx, dims)).join("\n");
+  let sectRefs = "";
+  if (headerRId) sectRefs += `
+      <w:headerReference w:type="default" r:id="${headerRId}"/>`;
+  if (footerRId) sectRefs += `
+      <w:footerReference w:type="default" r:id="${footerRId}"/>`;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
+  <w:body>
+${body}
+    <w:sectPr>${sectRefs}
+      <w:pgSz w:w="${Metric.ptToDxa(dims.wPt)}" w:h="${Metric.ptToDxa(dims.hPt)}" w:orient="${dims.orient ?? "portrait"}"/>
+      <w:pgMar w:top="${Metric.ptToDxa(dims.mt)}" w:right="${Metric.ptToDxa(dims.mr)}" w:bottom="${Metric.ptToDxa(dims.mb)}" w:left="${Metric.ptToDxa(dims.ml)}" w:header="709" w:footer="709" w:gutter="0"/>
+    </w:sectPr>
+  </w:body>
+</w:document>`;
+}
+function encodeContent(node, ctx, dims) {
+  return node.tag === "grid" ? encodeGrid2(node, ctx, dims) : encodeParaInner(node, ctx);
+}
+function encodeParaInner(para, ctx) {
+  const align = para.props.align ?? "left";
+  const headStyle = para.props.heading ? `<w:pStyle w:val="Heading${para.props.heading}"/>` : "";
+  let numPr = "";
+  if (para.props.listOrd !== void 0) {
+    const numId = para.props.listOrd ? 2 : 1;
+    const ilvl = para.props.listLv ?? 0;
+    numPr = `<w:pStyle w:val="ListParagraph"/><w:numPr><w:ilvl w:val="${ilvl}"/><w:numId w:val="${numId}"/></w:numPr>`;
+  }
+  const runs = para.kids.map((k) => {
+    if (k.tag === "span") return encodeRun2(k, ctx);
+    if (k.tag === "img") return encodeImage2(k, ctx);
+    return "";
+  }).join("");
+  return `    <w:p>
+      <w:pPr>${headStyle}${numPr}<w:jc w:val="${align === "justify" ? "both" : align}"/></w:pPr>
+      ${runs}
+    </w:p>`;
+}
+function encodeRun2(span, _ctx) {
+  const p = span.props;
+  const rPr = [];
+  if (p.b) rPr.push("<w:b/>");
+  if (p.i) rPr.push("<w:i/>");
+  if (p.u) rPr.push('<w:u w:val="single"/>');
+  if (p.s) rPr.push("<w:strike/>");
+  if (p.sup) rPr.push('<w:vertAlign w:val="superscript"/>');
+  if (p.sub) rPr.push('<w:vertAlign w:val="subscript"/>');
+  if (p.pt) rPr.push(`<w:sz w:val="${Metric.ptToHalfPt(p.pt)}"/><w:szCs w:val="${Metric.ptToHalfPt(p.pt)}"/>`);
+  if (p.color) rPr.push(`<w:color w:val="${p.color}"/>`);
+  if (p.font) rPr.push(`<w:rFonts w:ascii="${esc2(p.font)}" w:hAnsi="${esc2(p.font)}" w:eastAsia="${esc2(p.font)}"/>`);
+  if (p.bg) rPr.push(`<w:shd w:val="clear" w:color="auto" w:fill="${p.bg}"/>`);
+  const parts = [];
+  for (const kid of span.kids) {
+    if (kid.tag === "txt") {
+      parts.push(`<w:r><w:rPr>${rPr.join("")}</w:rPr><w:t xml:space="preserve">${esc2(kid.content)}</w:t></w:r>`);
+    } else if (kid.tag === "pagenum") {
+      parts.push(`<w:r><w:rPr>${rPr.join("")}</w:rPr><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:rPr>${rPr.join("")}</w:rPr><w:instrText> PAGE </w:instrText></w:r><w:r><w:rPr>${rPr.join("")}</w:rPr><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:rPr>${rPr.join("")}</w:rPr><w:t>1</w:t></w:r><w:r><w:rPr>${rPr.join("")}</w:rPr><w:fldChar w:fldCharType="end"/></w:r>`);
+    } else if (kid.tag === "br") {
+      parts.push(`<w:r><w:br/></w:r>`);
+    } else if (kid.tag === "pb") {
+      parts.push(`<w:r><w:br w:type="page"/></w:r>`);
+    }
+  }
+  return parts.join("");
+}
+function encodeImage2(img, _ctx) {
+  const rId = img._rId;
+  if (!rId) return "";
+  const cx = Metric.ptToEmu(img.w);
+  const cy = Metric.ptToEmu(img.h);
+  const alt = esc2(img.alt ?? "");
+  return `<w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${_ctx.nextId++}" name="Image" descr="${alt}"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="Image"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${rId}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+}
+function encodeGrid2(grid, ctx, dims) {
+  const gp = grid.props;
+  const look = gp.look;
+  const firstRow = look?.firstRow ? "1" : "0";
+  const lastRow = look?.lastRow ? "1" : "0";
+  const firstCol = look?.firstCol ? "1" : "0";
+  const lastCol = look?.lastCol ? "1" : "0";
+  const noHBand = look?.bandedRows ? "0" : "1";
+  const noVBand = look?.bandedCols ? "0" : "1";
+  const d = dims ?? A4;
+  const availDxa = Metric.ptToDxa(d.wPt - d.ml - d.mr);
+  let colCount = 0;
+  for (const row of grid.kids) {
+    let rowCols = 0;
+    for (const cell of row.kids) rowCols += cell.cs;
+    if (rowCols > colCount) colCount = rowCols;
+  }
+  if (colCount === 0) colCount = grid.kids[0]?.kids.length ?? 1;
+  const defaultColDxa = Math.round(availDxa / colCount);
+  const colWidthsDxa = [];
+  if (grid.props.colWidths && grid.props.colWidths.length === colCount) {
+    const srcPt = [...grid.props.colWidths];
+    const knownTotal = srcPt.filter((w) => w > 0).reduce((s, w) => s + w, 0);
+    const zeroCount = srcPt.filter((w) => w <= 0).length;
+    const remaining = Math.max(0, Metric.dxaToPt(availDxa) - knownTotal);
+    const zeroFill = zeroCount > 0 ? remaining / zeroCount : 0;
+    for (let i = 0; i < srcPt.length; i++) {
+      if (srcPt[i] <= 0) srcPt[i] = zeroFill > 0 ? zeroFill : Metric.dxaToPt(defaultColDxa);
+    }
+    const srcWidths = srcPt.map((w) => Metric.ptToDxa(w));
+    const srcTotal = srcWidths.reduce((s, w) => s + w, 0);
+    const scale = srcTotal > availDxa ? availDxa / srcTotal : 1;
+    for (const w of srcWidths) colWidthsDxa.push(Math.round(w * scale));
+  } else {
+    for (let c = 0; c < colCount; c++) colWidthsDxa.push(defaultColDxa);
+  }
+  const totalDxa = colWidthsDxa.reduce((s, w) => s + w, 0);
+  const gridCols = colWidthsDxa.map((w) => `<w:gridCol w:w="${Math.round(w)}"/>`).join("");
+  const vMergeMap = /* @__PURE__ */ new Map();
+  for (let ri = 0; ri < grid.kids.length; ri++) {
+    let colIdx = 0;
+    for (const cell of grid.kids[ri].kids) {
+      if (cell.rs > 1) {
+        vMergeMap.set(`${ri},${colIdx}`, "restart");
+        for (let sr = 1; sr < cell.rs; sr++) {
+          vMergeMap.set(`${ri + sr},${colIdx}`, "continue");
+        }
+      }
+      colIdx += cell.cs;
+    }
+  }
+  const rows = grid.kids.map((row, ri) => {
+    let colIdx = 0;
+    const cellXmls = [];
+    let srcCellIdx = 0;
+    while (srcCellIdx < row.kids.length) {
+      const cell = row.kids[srcCellIdx];
+      const mergeType = vMergeMap.get(`${ri},${colIdx}`);
+      const cp = cell.props;
+      const tcPrParts = [];
+      let cellW = 0;
+      for (let sc = colIdx; sc < colIdx + cell.cs && sc < colWidthsDxa.length; sc++) cellW += colWidthsDxa[sc];
+      if (cellW === 0) cellW = defaultColDxa * cell.cs;
+      tcPrParts.push(`<w:tcW w:w="${Math.round(cellW)}" w:type="dxa"/>`);
+      if (cell.cs > 1) tcPrParts.push(`<w:gridSpan w:val="${cell.cs}"/>`);
+      if (cell.rs > 1) {
+        tcPrParts.push(`<w:vMerge w:val="restart"/>`);
+      }
+      const borders = encodeCellBorders(cp);
+      if (borders) tcPrParts.push(borders);
+      if (cp.bg) tcPrParts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${cp.bg}"/>`);
+      if (cp.va) {
+        const vaMap = { top: "top", mid: "center", bot: "bottom" };
+        tcPrParts.push(`<w:vAlign w:val="${vaMap[cp.va] ?? "top"}"/>`);
+      }
+      const tcPr = `<w:tcPr>${tcPrParts.join("")}</w:tcPr>`;
+      cellXmls.push(`      <w:tc>${tcPr}${cell.kids.map((p) => encodeParaInner(p, ctx)).join("")}</w:tc>`);
+      colIdx += cell.cs;
+      srcCellIdx++;
+    }
+    const finalCells = [];
+    let finalColIdx = 0;
+    let cellIter = 0;
+    const totalGridCols = colCount;
+    finalColIdx = 0;
+    cellIter = 0;
+    for (let gc = 0; gc < totalGridCols; ) {
+      const mergeType = vMergeMap.get(`${ri},${gc}`);
+      if (mergeType === "continue") {
+        let origCs = 1;
+        for (let sr = ri - 1; sr >= 0; sr--) {
+          const mt = vMergeMap.get(`${sr},${gc}`);
+          if (mt === "restart") {
+            let col = 0;
+            for (const c of grid.kids[sr].kids) {
+              if (col === gc) {
+                origCs = c.cs;
+                break;
+              }
+              col += c.cs;
+            }
+            break;
+          }
+        }
+        let cw = 0;
+        for (let sc = gc; sc < gc + origCs && sc < colWidthsDxa.length; sc++) cw += colWidthsDxa[sc];
+        if (cw === 0) cw = defaultColDxa * origCs;
+        let contParts = `<w:tcW w:w="${Math.round(cw)}" w:type="dxa"/>`;
+        if (origCs > 1) contParts += `<w:gridSpan w:val="${origCs}"/>`;
+        contParts += `<w:vMerge/>`;
+        finalCells.push(`      <w:tc><w:tcPr>${contParts}</w:tcPr><w:p><w:pPr/></w:p></w:tc>`);
+        gc += origCs;
+      } else {
+        if (cellIter < cellXmls.length) {
+          finalCells.push(cellXmls[cellIter]);
+          gc += row.kids[cellIter]?.cs ?? 1;
+          cellIter++;
+        } else {
+          gc++;
+        }
+      }
+    }
+    let trPr = "";
+    if (ri === 0 && (gp.headerRow || look?.firstRow)) {
+      trPr = "<w:trPr><w:tblHeader/></w:trPr>";
+    }
+    return `    <w:tr>${trPr}
+${finalCells.join("\n")}
+    </w:tr>`;
+  }).join("\n");
+  let tblBorders = "";
+  if (gp.defaultStroke) {
+    const s = gp.defaultStroke;
+    const strokeKindMap = { solid: "single", dash: "dashed", dot: "dotted", double: "double", none: "none" };
+    const val = strokeKindMap[s.kind] ?? "single";
+    const sz = Math.round(s.pt * 8);
+    const bdr = `w:val="${val}" w:sz="${sz}" w:space="0" w:color="${s.color}"`;
+    tblBorders = `<w:tblBorders><w:top ${bdr}/><w:left ${bdr}/><w:bottom ${bdr}/><w:right ${bdr}/><w:insideH ${bdr}/><w:insideV ${bdr}/></w:tblBorders>`;
+  }
+  return `    <w:tbl>
+      <w:tblPr><w:tblStyle w:val="TableGrid"/><w:tblW w:w="${Math.round(totalDxa)}" w:type="dxa"/><w:tblLayout w:type="fixed"/><w:tblLook w:val="04A0" w:firstRow="${firstRow}" w:lastRow="${lastRow}" w:firstColumn="${firstCol}" w:lastColumn="${lastCol}" w:noHBand="${noHBand}" w:noVBand="${noVBand}"/>${tblBorders}<w:tblCellMar><w:top w:w="28" w:type="dxa"/><w:left w:w="102" w:type="dxa"/><w:bottom w:w="28" w:type="dxa"/><w:right w:w="102" w:type="dxa"/></w:tblCellMar></w:tblPr>
+      <w:tblGrid>${gridCols}</w:tblGrid>
+${rows}
+    </w:tbl>`;
+}
+function encodeCellBorders(cp) {
+  if (!cp.top && !cp.bot && !cp.left && !cp.right) return "";
+  const strokeKindMap = { solid: "single", dash: "dashed", dot: "dotted", double: "double", none: "none" };
+  const encode = (s, tag) => {
+    if (!s || !tag) return "";
+    const val = strokeKindMap[s.kind] ?? "single";
+    return `<w:${tag} w:val="${val}" w:sz="${Math.round(s.pt * 8)}" w:space="0" w:color="${s.color}"/>`;
+  };
+  return `<w:tcBorders>${encode(cp.top, "top")}${encode(cp.bot, "bottom")}${encode(cp.left, "left")}${encode(cp.right, "right")}</w:tcBorders>`;
+}
+function esc2(s) {
+  return TextKit.escapeXml(s);
+}
+registry.registerEncoder(new DocxEncoder());
+
+// src/encoders/md/MdEncoder.ts
+var MdEncoder = class {
+  constructor() {
+    this.format = "md";
+  }
+  async encode(doc) {
+    try {
+      const warns = [];
+      const parts = [];
+      for (const sheet of doc.kids) {
+        if (sheet.header && sheet.header.length > 0) warns.push("[SHIELD] MD: \uBA38\uB9AC\uAE00(header) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428");
+        if (sheet.footer && sheet.footer.length > 0) warns.push("[SHIELD] MD: \uBC14\uB2E5\uAE00(footer) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428");
+        for (const kid of sheet.kids) parts.push(encodeContent2(kid, warns));
+      }
+      return succeed(TextKit.encode(parts.join("\n\n")), warns);
+    } catch (e) {
+      return fail(`MD encode error: ${e?.message ?? String(e)}`);
+    }
+  }
+};
+function encodeContent2(node, warns) {
+  return node.tag === "grid" ? encodeGrid3(node, warns) : encodePara2(node, warns);
+}
+function encodePara2(para, warns) {
+  const text = para.kids.map((k) => {
+    if (k.tag === "span") return encodeSpan(k, warns);
+    if (k.tag === "img") return encodeImage3(k);
+    return "";
+  }).join("");
+  if (para.props.heading) return `${"#".repeat(para.props.heading)} ${text}`;
+  if (para.props.listOrd !== void 0) {
+    const indent = "  ".repeat(para.props.listLv ?? 0);
+    return `${indent}${para.props.listOrd ? "1." : "-"} ${text}`;
+  }
+  if (para.props.align && para.props.align !== "left" && para.props.align !== "justify") {
+    return `<div align="${para.props.align}">${text}</div>`;
+  }
+  return text;
+}
+function encodeSpan(span, warns) {
+  if (span.props.font) warns.push(`[SHIELD] MD: \uAE00\uAF34(${span.props.font}) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428`);
+  if (span.props.pt) warns.push(`[SHIELD] MD: \uAE00\uC790 \uD06C\uAE30(${span.props.pt}pt) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428`);
+  if (span.props.color) warns.push(`[SHIELD] MD: \uAE00\uC790 \uC0C9\uC0C1(#${span.props.color}) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428`);
+  if (span.props.bg) warns.push(`[SHIELD] MD: \uBC30\uACBD \uC0C9\uC0C1(#${span.props.bg}) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428`);
+  let hasPageNum = false;
+  const textParts = [];
+  for (const kid of span.kids) {
+    if (kid.tag === "txt") textParts.push(kid.content);
+    else if (kid.tag === "pagenum") {
+      hasPageNum = true;
+      warns.push("[SHIELD] MD: \uD398\uC774\uC9C0 \uBC88\uD638 \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428");
+    }
+  }
+  let r = textParts.join("");
+  if (hasPageNum && r === "") r = "[\uD398\uC774\uC9C0 \uBC88\uD638]";
+  if (span.props.b && span.props.i) r = `***${r}***`;
+  else if (span.props.b) r = `**${r}**`;
+  else if (span.props.i) r = `*${r}*`;
+  if (span.props.s) r = `~~${r}~~`;
+  if (span.props.u) r = `<u>${r}</u>`;
+  if (span.props.sup) r = `<sup>${r}</sup>`;
+  if (span.props.sub) r = `<sub>${r}</sub>`;
+  return r;
+}
+function encodeImage3(img) {
+  return `![${img.alt ?? ""}](data:${img.mime};base64,${img.b64})`;
+}
+function encodeGrid3(grid, warns) {
+  if (grid.kids.length === 0) return "";
+  if (grid.props.look) warns.push("[SHIELD] MD: \uD45C \uC2A4\uD0C0\uC77C(\uC0C9\uC0C1, \uD14C\uB450\uB9AC, \uBA38\uB9AC\uD589 \uAC15\uC870) \uD45C\uD604 \uBD88\uAC00 \u2014 \uC190\uC2E4\uB428");
+  const rows = grid.kids.map(
+    (row) => `| ${row.kids.map((cell) => cell.kids.map((p) => encodePara2(p, warns)).join(" ")).join(" | ")} |`
+  );
+  if (rows.length > 0) {
+    const cols = grid.kids[0].kids.length;
+    rows.splice(1, 0, `| ${Array(cols).fill("---").join(" | ")} |`);
+  }
+  return rows.join("\n");
+}
+registry.registerEncoder(new MdEncoder());
+
+// src/pipeline/Pipeline.ts
+var Pipeline = class _Pipeline {
+  constructor(raw, srcFmt) {
+    this.raw = raw;
+    this.srcFmt = srcFmt;
+  }
+  /** 파일을 열고 포맷을 자동 감지하거나 명시 */
+  static open(input, fmt) {
+    if (typeof input === "string") {
+      return new _Pipeline(new TextEncoder().encode(input), fmt ?? "md");
+    }
+    return new _Pipeline(input, fmt ?? detectFormat(input));
+  }
+  /** File/Blob 비동기 입력 */
+  static async openAsync(input, fmt) {
+    if (input instanceof Uint8Array || typeof input === "string") {
+      return _Pipeline.open(input, fmt);
+    }
+    const buf = await input.arrayBuffer();
+    const data = new Uint8Array(buf);
+    const detectedFmt = fmt ?? (input instanceof File ? getExt(input.name) : void 0) ?? detectFormat(data);
+    return new _Pipeline(data, detectedFmt);
+  }
+  /** 목표 포맷으로 변환 */
+  async to(targetFmt) {
+    const decoder = registry.getDecoder(this.srcFmt);
+    const encoder = registry.getEncoder(targetFmt);
+    if (!decoder) return fail(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC785\uB825 \uD3EC\uB9F7: ${this.srcFmt}`);
+    if (!encoder) return fail(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uCD9C\uB825 \uD3EC\uB9F7: ${targetFmt}`);
+    const docResult = await decoder.decode(this.raw);
+    if (!docResult.ok) return docResult;
+    const encResult = await encoder.encode(docResult.data);
+    if (!encResult.ok) return { ...encResult, warns: [...docResult.warns, ...encResult.warns] };
+    return { ...encResult, warns: [...docResult.warns, ...encResult.warns] };
+  }
+  /** DocRoot만 추출 (인코딩 없이) */
+  async inspect() {
+    const decoder = registry.getDecoder(this.srcFmt);
+    if (!decoder) return fail(`\uB514\uCF54\uB354 \uC5C6\uC74C: ${this.srcFmt}`);
+    return decoder.decode(this.raw);
+  }
+};
+function detectFormat(data) {
+  if (data[0] === 80 && data[1] === 75) return "zip";
+  if (data[0] === 208 && data[1] === 207 && data[2] === 17 && data[3] === 224) return "hwp";
+  return "md";
+}
+function getExt(name) {
+  const parts = name.split(".");
+  return parts.length > 1 ? parts[parts.length - 1].toLowerCase() : void 0;
+}
+
+// src/walk/TreeWalker.ts
+function walkNode(node, cb, parent = null, depth = 0) {
+  const result = cb(node, parent, depth);
+  if (result === "stop") return false;
+  if ("kids" in node && Array.isArray(node.kids)) {
+    for (const kid of node.kids) {
+      if (!walkNode(kid, cb, node, depth + 1)) return false;
+    }
+  }
+  return true;
+}
+var TreeWalker = class {
+  walk(root, cb) {
+    walkNode(root, cb);
+  }
+  findAll(root, predicate) {
+    const results = [];
+    walkNode(root, (n) => {
+      if (predicate(n)) results.push(n);
+    });
+    return results;
+  }
+  extractText(root) {
+    const parts = [];
+    walkNode(root, (n) => {
+      if (n.tag === "txt") parts.push(n.content);
+      if (n.tag === "br") parts.push("\n");
+      if (n.tag === "pb") parts.push("\n\n");
+    });
+    return parts.join("");
+  }
+};
+
+// src/walk/tree-ops.ts
+function countNodes(root) {
+  const counts = {};
+  walkNode(root, (n) => {
+    counts[n.tag] = (counts[n.tag] ?? 0) + 1;
+  });
+  return counts;
+}
+function validateRoot(root) {
+  const errors = [];
+  if (root.tag !== "root") errors.push('Root node must have tag "root"');
+  if (!Array.isArray(root.kids)) errors.push("Root.kids must be an array");
+  if (root.kids.length === 0) errors.push("Document has no sheets");
+  walkNode(root, (n) => {
+    if (n.tag === "cell" && n.kids.length === 0) {
+      errors.push("CellNode must have at least one ParaNode child");
+    }
+    if (n.tag === "grid" && n.kids.length === 0) {
+      errors.push("GridNode must have at least one RowNode");
+    }
+  });
+  return errors;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A4,
+  ArchiveKit,
+  BinaryKit,
+  DEFAULT_STROKE,
+  Metric,
+  Pipeline,
+  ShieldedParser,
+  TextKit,
+  TreeWalker,
+  XmlKit,
+  buildCell,
+  buildGrid,
+  buildImg,
+  buildPageNum,
+  buildPara,
+  buildRoot,
+  buildRow,
+  buildSheet,
+  buildSpan,
+  countNodes,
+  fail,
+  registry,
+  safeAlign,
+  safeFont,
+  safeFontToKr,
+  safeHex,
+  safeStrokeDocx,
+  safeStrokeHwpx,
+  succeed,
+  validateRoot,
+  walkNode
+});
+//# sourceMappingURL=index.js.map