@clazic/kordoc 2.1.6 → 2.2.0

package/dist/index.js

@@ -1,12 +1,41 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 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
+));
 
 // src/page-range.ts
 var page_range_exports = {};
@@ -21,27 +50,2270 @@ function parsePageRange(spec, maxPages) {
       const page = Math.round(n);
       if (page >= 1 && page <= maxPages) result.add(page);
     }
-    return result;
+    return result;
+  }
+  if (typeof spec !== "string" || spec.trim() === "") return result;
+  const parts = spec.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const rangeMatch = trimmed.match(/^(\d+)\s*-\s*(\d+)$/);
+    if (rangeMatch) {
+      const start = Math.max(1, parseInt(rangeMatch[1], 10));
+      const end = Math.min(maxPages, parseInt(rangeMatch[2], 10));
+      for (let i = start; i <= end; i++) result.add(i);
+    } else {
+      const page = parseInt(trimmed, 10);
+      if (!isNaN(page) && page >= 1 && page <= maxPages) result.add(page);
+    }
+  }
+  return result;
+}
+var init_page_range = __esm({
+  "src/page-range.ts"() {
+    "use strict";
+  }
+});
+
+// node_modules/cfb/cfb.js
+var require_cfb = __commonJS({
+  "node_modules/cfb/cfb.js"(exports, module) {
+    "use strict";
+    var Base64_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    function Base64_encode(input) {
+      var o = "";
+      var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+      for (var i = 0; i < input.length; ) {
+        c1 = input.charCodeAt(i++);
+        e1 = c1 >> 2;
+        c2 = input.charCodeAt(i++);
+        e2 = (c1 & 3) << 4 | c2 >> 4;
+        c3 = input.charCodeAt(i++);
+        e3 = (c2 & 15) << 2 | c3 >> 6;
+        e4 = c3 & 63;
+        if (isNaN(c2)) e3 = e4 = 64;
+        else if (isNaN(c3)) e4 = 64;
+        o += Base64_map.charAt(e1) + Base64_map.charAt(e2) + Base64_map.charAt(e3) + Base64_map.charAt(e4);
+      }
+      return o;
+    }
+    function Base64_decode(input) {
+      var o = "";
+      var c1 = 0, c2 = 0, c3 = 0, e1 = 0, e2 = 0, e3 = 0, e4 = 0;
+      input = input.replace(/[^\w\+\/\=]/g, "");
+      for (var i = 0; i < input.length; ) {
+        e1 = Base64_map.indexOf(input.charAt(i++));
+        e2 = Base64_map.indexOf(input.charAt(i++));
+        c1 = e1 << 2 | e2 >> 4;
+        o += String.fromCharCode(c1);
+        e3 = Base64_map.indexOf(input.charAt(i++));
+        c2 = (e2 & 15) << 4 | e3 >> 2;
+        if (e3 !== 64) o += String.fromCharCode(c2);
+        e4 = Base64_map.indexOf(input.charAt(i++));
+        c3 = (e3 & 3) << 6 | e4;
+        if (e4 !== 64) o += String.fromCharCode(c3);
+      }
+      return o;
+    }
+    var has_buf = (function() {
+      return typeof Buffer !== "undefined" && typeof process !== "undefined" && typeof process.versions !== "undefined" && !!process.versions.node;
+    })();
+    var Buffer_from = (function() {
+      if (typeof Buffer !== "undefined") {
+        var nbfs = !Buffer.from;
+        if (!nbfs) try {
+          Buffer.from("foo", "utf8");
+        } catch (e) {
+          nbfs = true;
+        }
+        return nbfs ? function(buf, enc) {
+          return enc ? new Buffer(buf, enc) : new Buffer(buf);
+        } : Buffer.from.bind(Buffer);
+      }
+      return function() {
+      };
+    })();
+    function new_raw_buf(len) {
+      if (has_buf) {
+        if (Buffer.alloc) return Buffer.alloc(len);
+        var b = new Buffer(len);
+        b.fill(0);
+        return b;
+      }
+      return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+    }
+    function new_unsafe_buf(len) {
+      if (has_buf) return Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : new Buffer(len);
+      return typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
+    }
+    var s2a = function s2a2(s) {
+      if (has_buf) return Buffer_from(s, "binary");
+      return s.split("").map(function(x) {
+        return x.charCodeAt(0) & 255;
+      });
+    };
+    var chr0 = /\u0000/g;
+    var chr1 = /[\u0001-\u0006]/g;
+    var __toBuffer = function(bufs) {
+      var x = [];
+      for (var i = 0; i < bufs[0].length; ++i) {
+        x.push.apply(x, bufs[0][i]);
+      }
+      return x;
+    };
+    var ___toBuffer = __toBuffer;
+    var __utf16le = function(b, s, e) {
+      var ss = [];
+      for (var i = s; i < e; i += 2) ss.push(String.fromCharCode(__readUInt16LE(b, i)));
+      return ss.join("").replace(chr0, "");
+    };
+    var ___utf16le = __utf16le;
+    var __hexlify = function(b, s, l) {
+      var ss = [];
+      for (var i = s; i < s + l; ++i) ss.push(("0" + b[i].toString(16)).slice(-2));
+      return ss.join("");
+    };
+    var ___hexlify = __hexlify;
+    var __bconcat = function(bufs) {
+      if (Array.isArray(bufs[0])) return [].concat.apply([], bufs);
+      var maxlen = 0, i = 0;
+      for (i = 0; i < bufs.length; ++i) maxlen += bufs[i].length;
+      var o = new Uint8Array(maxlen);
+      for (i = 0, maxlen = 0; i < bufs.length; maxlen += bufs[i].length, ++i) o.set(bufs[i], maxlen);
+      return o;
+    };
+    var bconcat = __bconcat;
+    if (has_buf) {
+      __utf16le = function(b, s, e) {
+        if (!Buffer.isBuffer(b)) return ___utf16le(b, s, e);
+        return b.toString("utf16le", s, e).replace(chr0, "");
+      };
+      __hexlify = function(b, s, l) {
+        return Buffer.isBuffer(b) ? b.toString("hex", s, s + l) : ___hexlify(b, s, l);
+      };
+      __toBuffer = function(bufs) {
+        return bufs[0].length > 0 && Buffer.isBuffer(bufs[0][0]) ? Buffer.concat(bufs[0]) : ___toBuffer(bufs);
+      };
+      s2a = function(s) {
+        return Buffer_from(s, "binary");
+      };
+      bconcat = function(bufs) {
+        return Buffer.isBuffer(bufs[0]) ? Buffer.concat(bufs) : __bconcat(bufs);
+      };
+    }
+    var __readUInt8 = function(b, idx) {
+      return b[idx];
+    };
+    var __readUInt16LE = function(b, idx) {
+      return b[idx + 1] * (1 << 8) + b[idx];
+    };
+    var __readInt16LE = function(b, idx) {
+      var u = b[idx + 1] * (1 << 8) + b[idx];
+      return u < 32768 ? u : (65535 - u + 1) * -1;
+    };
+    var __readUInt32LE = function(b, idx) {
+      return b[idx + 3] * (1 << 24) + (b[idx + 2] << 16) + (b[idx + 1] << 8) + b[idx];
+    };
+    var __readInt32LE = function(b, idx) {
+      return (b[idx + 3] << 24) + (b[idx + 2] << 16) + (b[idx + 1] << 8) + b[idx];
+    };
+    function ReadShift(size, t) {
+      var oI, oS, type = 0;
+      switch (size) {
+        case 1:
+          oI = __readUInt8(this, this.l);
+          break;
+        case 2:
+          oI = (t !== "i" ? __readUInt16LE : __readInt16LE)(this, this.l);
+          break;
+        case 4:
+          oI = __readInt32LE(this, this.l);
+          break;
+        case 16:
+          type = 2;
+          oS = __hexlify(this, this.l, size);
+      }
+      this.l += size;
+      if (type === 0) return oI;
+      return oS;
+    }
+    var __writeUInt32LE = function(b, val, idx) {
+      b[idx] = val & 255;
+      b[idx + 1] = val >>> 8 & 255;
+      b[idx + 2] = val >>> 16 & 255;
+      b[idx + 3] = val >>> 24 & 255;
+    };
+    var __writeInt32LE = function(b, val, idx) {
+      b[idx] = val & 255;
+      b[idx + 1] = val >> 8 & 255;
+      b[idx + 2] = val >> 16 & 255;
+      b[idx + 3] = val >> 24 & 255;
+    };
+    function WriteShift(t, val, f) {
+      var size = 0, i = 0;
+      switch (f) {
+        case "hex":
+          for (; i < t; ++i) {
+            this[this.l++] = parseInt(val.slice(2 * i, 2 * i + 2), 16) || 0;
+          }
+          return this;
+        case "utf16le":
+          var end = this.l + t;
+          for (i = 0; i < Math.min(val.length, t); ++i) {
+            var cc = val.charCodeAt(i);
+            this[this.l++] = cc & 255;
+            this[this.l++] = cc >> 8;
+          }
+          while (this.l < end) this[this.l++] = 0;
+          return this;
+      }
+      switch (t) {
+        case 1:
+          size = 1;
+          this[this.l] = val & 255;
+          break;
+        case 2:
+          size = 2;
+          this[this.l] = val & 255;
+          val >>>= 8;
+          this[this.l + 1] = val & 255;
+          break;
+        case 4:
+          size = 4;
+          __writeUInt32LE(this, val, this.l);
+          break;
+        case -4:
+          size = 4;
+          __writeInt32LE(this, val, this.l);
+          break;
+      }
+      this.l += size;
+      return this;
+    }
+    function CheckField(hexstr, fld) {
+      var m = __hexlify(this, this.l, hexstr.length >> 1);
+      if (m !== hexstr) throw new Error(fld + "Expected " + hexstr + " saw " + m);
+      this.l += hexstr.length >> 1;
+    }
+    function prep_blob(blob, pos) {
+      blob.l = pos;
+      blob.read_shift = ReadShift;
+      blob.chk = CheckField;
+      blob.write_shift = WriteShift;
+    }
+    function new_buf(sz) {
+      var o = new_raw_buf(sz);
+      prep_blob(o, 0);
+      return o;
+    }
+    var CRC32 = (function() {
+      var CRC322 = {};
+      CRC322.version = "1.2.1";
+      function signed_crc_table() {
+        var c = 0, table = new Array(256);
+        for (var n = 0; n != 256; ++n) {
+          c = n;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
+          table[n] = c;
+        }
+        return typeof Int32Array !== "undefined" ? new Int32Array(table) : table;
+      }
+      var T0 = signed_crc_table();
+      function slice_by_16_tables(T) {
+        var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? new Int32Array(4096) : new Array(4096);
+        for (n = 0; n != 256; ++n) table[n] = T[n];
+        for (n = 0; n != 256; ++n) {
+          v = T[n];
+          for (c = 256 + n; c < 4096; c += 256) v = table[c] = v >>> 8 ^ T[v & 255];
+        }
+        var out = [];
+        for (n = 1; n != 16; ++n) out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
+        return out;
+      }
+      var TT = slice_by_16_tables(T0);
+      var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
+      var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
+      var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
+      function crc32_bstr(bstr, seed) {
+        var C = seed ^ -1;
+        for (var i = 0, L = bstr.length; i < L; ) C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255];
+        return ~C;
+      }
+      function crc32_buf(B, seed) {
+        var C = seed ^ -1, L = B.length - 15, i = 0;
+        for (; i < L; ) C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
+        L += 15;
+        while (i < L) C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];
+        return ~C;
+      }
+      function crc32_str(str, seed) {
+        var C = seed ^ -1;
+        for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {
+          c = str.charCodeAt(i++);
+          if (c < 128) {
+            C = C >>> 8 ^ T0[(C ^ c) & 255];
+          } else if (c < 2048) {
+            C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+          } else if (c >= 55296 && c < 57344) {
+            c = (c & 1023) + 64;
+            d = str.charCodeAt(i++) & 1023;
+            C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];
+          } else {
+            C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];
+            C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
+          }
+        }
+        return ~C;
+      }
+      CRC322.table = T0;
+      CRC322.bstr = crc32_bstr;
+      CRC322.buf = crc32_buf;
+      CRC322.str = crc32_str;
+      return CRC322;
+    })();
+    var CFB2 = (function _CFB() {
+      var exports2 = {};
+      exports2.version = "1.2.2";
+      function namecmp(l, r) {
+        var L = l.split("/"), R = r.split("/");
+        for (var i2 = 0, c = 0, Z = Math.min(L.length, R.length); i2 < Z; ++i2) {
+          if (c = L[i2].length - R[i2].length) return c;
+          if (L[i2] != R[i2]) return L[i2] < R[i2] ? -1 : 1;
+        }
+        return L.length - R.length;
+      }
+      function dirname(p) {
+        if (p.charAt(p.length - 1) == "/") return p.slice(0, -1).indexOf("/") === -1 ? p : dirname(p.slice(0, -1));
+        var c = p.lastIndexOf("/");
+        return c === -1 ? p : p.slice(0, c + 1);
+      }
+      function filename(p) {
+        if (p.charAt(p.length - 1) == "/") return filename(p.slice(0, -1));
+        var c = p.lastIndexOf("/");
+        return c === -1 ? p : p.slice(c + 1);
+      }
+      function write_dos_date(buf, date) {
+        if (typeof date === "string") date = new Date(date);
+        var hms = date.getHours();
+        hms = hms << 6 | date.getMinutes();
+        hms = hms << 5 | date.getSeconds() >>> 1;
+        buf.write_shift(2, hms);
+        var ymd = date.getFullYear() - 1980;
+        ymd = ymd << 4 | date.getMonth() + 1;
+        ymd = ymd << 5 | date.getDate();
+        buf.write_shift(2, ymd);
+      }
+      function parse_dos_date(buf) {
+        var hms = buf.read_shift(2) & 65535;
+        var ymd = buf.read_shift(2) & 65535;
+        var val = /* @__PURE__ */ new Date();
+        var d = ymd & 31;
+        ymd >>>= 5;
+        var m = ymd & 15;
+        ymd >>>= 4;
+        val.setMilliseconds(0);
+        val.setFullYear(ymd + 1980);
+        val.setMonth(m - 1);
+        val.setDate(d);
+        var S = hms & 31;
+        hms >>>= 5;
+        var M = hms & 63;
+        hms >>>= 6;
+        val.setHours(hms);
+        val.setMinutes(M);
+        val.setSeconds(S << 1);
+        return val;
+      }
+      function parse_extra_field(blob) {
+        prep_blob(blob, 0);
+        var o = {};
+        var flags = 0;
+        while (blob.l <= blob.length - 4) {
+          var type = blob.read_shift(2);
+          var sz = blob.read_shift(2), tgt = blob.l + sz;
+          var p = {};
+          switch (type) {
+            /* UNIX-style Timestamps */
+            case 21589:
+              {
+                flags = blob.read_shift(1);
+                if (flags & 1) p.mtime = blob.read_shift(4);
+                if (sz > 5) {
+                  if (flags & 2) p.atime = blob.read_shift(4);
+                  if (flags & 4) p.ctime = blob.read_shift(4);
+                }
+                if (p.mtime) p.mt = new Date(p.mtime * 1e3);
+              }
+              break;
+          }
+          blob.l = tgt;
+          o[type] = p;
+        }
+        return o;
+      }
+      var fs;
+      function get_fs() {
+        return fs || (fs = __require("fs"));
+      }
+      function parse3(file, options) {
+        if (file[0] == 80 && file[1] == 75) return parse_zip(file, options);
+        if ((file[0] | 32) == 109 && (file[1] | 32) == 105) return parse_mad(file, options);
+        if (file.length < 512) throw new Error("CFB file size " + file.length + " < 512");
+        var mver = 3;
+        var ssz = 512;
+        var nmfs = 0;
+        var difat_sec_cnt = 0;
+        var dir_start = 0;
+        var minifat_start = 0;
+        var difat_start = 0;
+        var fat_addrs = [];
+        var blob = file.slice(0, 512);
+        prep_blob(blob, 0);
+        var mv = check_get_mver(blob);
+        mver = mv[0];
+        switch (mver) {
+          case 3:
+            ssz = 512;
+            break;
+          case 4:
+            ssz = 4096;
+            break;
+          case 0:
+            if (mv[1] == 0) return parse_zip(file, options);
+          /* falls through */
+          default:
+            throw new Error("Major Version: Expected 3 or 4 saw " + mver);
+        }
+        if (ssz !== 512) {
+          blob = file.slice(0, ssz);
+          prep_blob(
+            blob,
+            28
+            /* blob.l */
+          );
+        }
+        var header = file.slice(0, ssz);
+        check_shifts(blob, mver);
+        var dir_cnt = blob.read_shift(4, "i");
+        if (mver === 3 && dir_cnt !== 0) throw new Error("# Directory Sectors: Expected 0 saw " + dir_cnt);
+        blob.l += 4;
+        dir_start = blob.read_shift(4, "i");
+        blob.l += 4;
+        blob.chk("00100000", "Mini Stream Cutoff Size: ");
+        minifat_start = blob.read_shift(4, "i");
+        nmfs = blob.read_shift(4, "i");
+        difat_start = blob.read_shift(4, "i");
+        difat_sec_cnt = blob.read_shift(4, "i");
+        for (var q2 = -1, j = 0; j < 109; ++j) {
+          q2 = blob.read_shift(4, "i");
+          if (q2 < 0) break;
+          fat_addrs[j] = q2;
+        }
+        var sectors = sectorify(file, ssz);
+        sleuth_fat(difat_start, difat_sec_cnt, sectors, ssz, fat_addrs);
+        var sector_list = make_sector_list(sectors, dir_start, fat_addrs, ssz);
+        sector_list[dir_start].name = "!Directory";
+        if (nmfs > 0 && minifat_start !== ENDOFCHAIN) sector_list[minifat_start].name = "!MiniFAT";
+        sector_list[fat_addrs[0]].name = "!FAT";
+        sector_list.fat_addrs = fat_addrs;
+        sector_list.ssz = ssz;
+        var files = {}, Paths = [], FileIndex = [], FullPaths = [];
+        read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, minifat_start);
+        build_full_paths(FileIndex, FullPaths, Paths);
+        Paths.shift();
+        var o = {
+          FileIndex,
+          FullPaths
+        };
+        if (options && options.raw) o.raw = { header, sectors };
+        return o;
+      }
+      function check_get_mver(blob) {
+        if (blob[blob.l] == 80 && blob[blob.l + 1] == 75) return [0, 0];
+        blob.chk(HEADER_SIGNATURE, "Header Signature: ");
+        blob.l += 16;
+        var mver = blob.read_shift(2, "u");
+        return [blob.read_shift(2, "u"), mver];
+      }
+      function check_shifts(blob, mver) {
+        var shift = 9;
+        blob.l += 2;
+        switch (shift = blob.read_shift(2)) {
+          case 9:
+            if (mver != 3) throw new Error("Sector Shift: Expected 9 saw " + shift);
+            break;
+          case 12:
+            if (mver != 4) throw new Error("Sector Shift: Expected 12 saw " + shift);
+            break;
+          default:
+            throw new Error("Sector Shift: Expected 9 or 12 saw " + shift);
+        }
+        blob.chk("0600", "Mini Sector Shift: ");
+        blob.chk("000000000000", "Reserved: ");
+      }
+      function sectorify(file, ssz) {
+        var nsectors = Math.ceil(file.length / ssz) - 1;
+        var sectors = [];
+        for (var i2 = 1; i2 < nsectors; ++i2) sectors[i2 - 1] = file.slice(i2 * ssz, (i2 + 1) * ssz);
+        sectors[nsectors - 1] = file.slice(nsectors * ssz);
+        return sectors;
+      }
+      function build_full_paths(FI, FP, Paths) {
+        var i2 = 0, L = 0, R = 0, C = 0, j = 0, pl = Paths.length;
+        var dad = [], q2 = [];
+        for (; i2 < pl; ++i2) {
+          dad[i2] = q2[i2] = i2;
+          FP[i2] = Paths[i2];
+        }
+        for (; j < q2.length; ++j) {
+          i2 = q2[j];
+          L = FI[i2].L;
+          R = FI[i2].R;
+          C = FI[i2].C;
+          if (dad[i2] === i2) {
+            if (L !== -1 && dad[L] !== L) dad[i2] = dad[L];
+            if (R !== -1 && dad[R] !== R) dad[i2] = dad[R];
+          }
+          if (C !== -1) dad[C] = i2;
+          if (L !== -1 && i2 != dad[i2]) {
+            dad[L] = dad[i2];
+            if (q2.lastIndexOf(L) < j) q2.push(L);
+          }
+          if (R !== -1 && i2 != dad[i2]) {
+            dad[R] = dad[i2];
+            if (q2.lastIndexOf(R) < j) q2.push(R);
+          }
+        }
+        for (i2 = 1; i2 < pl; ++i2) if (dad[i2] === i2) {
+          if (R !== -1 && dad[R] !== R) dad[i2] = dad[R];
+          else if (L !== -1 && dad[L] !== L) dad[i2] = dad[L];
+        }
+        for (i2 = 1; i2 < pl; ++i2) {
+          if (FI[i2].type === 0) continue;
+          j = i2;
+          if (j != dad[j]) do {
+            j = dad[j];
+            FP[i2] = FP[j] + "/" + FP[i2];
+          } while (j !== 0 && -1 !== dad[j] && j != dad[j]);
+          dad[i2] = -1;
+        }
+        FP[0] += "/";
+        for (i2 = 1; i2 < pl; ++i2) {
+          if (FI[i2].type !== 2) FP[i2] += "/";
+        }
+      }
+      function get_mfat_entry(entry, payload, mini) {
+        var start = entry.start, size = entry.size;
+        var o = [];
+        var idx = start;
+        while (mini && size > 0 && idx >= 0) {
+          o.push(payload.slice(idx * MSSZ, idx * MSSZ + MSSZ));
+          size -= MSSZ;
+          idx = __readInt32LE(mini, idx * 4);
+        }
+        if (o.length === 0) return new_buf(0);
+        return bconcat(o).slice(0, entry.size);
+      }
+      function sleuth_fat(idx, cnt, sectors, ssz, fat_addrs) {
+        var q2 = ENDOFCHAIN;
+        if (idx === ENDOFCHAIN) {
+          if (cnt !== 0) throw new Error("DIFAT chain shorter than expected");
+        } else if (idx !== -1) {
+          var sector = sectors[idx], m = (ssz >>> 2) - 1;
+          if (!sector) return;
+          for (var i2 = 0; i2 < m; ++i2) {
+            if ((q2 = __readInt32LE(sector, i2 * 4)) === ENDOFCHAIN) break;
+            fat_addrs.push(q2);
+          }
+          if (cnt >= 1) sleuth_fat(__readInt32LE(sector, ssz - 4), cnt - 1, sectors, ssz, fat_addrs);
+        }
+      }
+      function get_sector_list(sectors, start, fat_addrs, ssz, chkd) {
+        var buf = [], buf_chain = [];
+        if (!chkd) chkd = [];
+        var modulus = ssz - 1, j = 0, jj = 0;
+        for (j = start; j >= 0; ) {
+          chkd[j] = true;
+          buf[buf.length] = j;
+          buf_chain.push(sectors[j]);
+          var addr = fat_addrs[Math.floor(j * 4 / ssz)];
+          jj = j * 4 & modulus;
+          if (ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 " + ssz);
+          if (!sectors[addr]) break;
+          j = __readInt32LE(sectors[addr], jj);
+        }
+        return { nodes: buf, data: __toBuffer([buf_chain]) };
+      }
+      function make_sector_list(sectors, dir_start, fat_addrs, ssz) {
+        var sl = sectors.length, sector_list = [];
+        var chkd = [], buf = [], buf_chain = [];
+        var modulus = ssz - 1, i2 = 0, j = 0, k = 0, jj = 0;
+        for (i2 = 0; i2 < sl; ++i2) {
+          buf = [];
+          k = i2 + dir_start;
+          if (k >= sl) k -= sl;
+          if (chkd[k]) continue;
+          buf_chain = [];
+          var seen = [];
+          for (j = k; j >= 0; ) {
+            seen[j] = true;
+            chkd[j] = true;
+            buf[buf.length] = j;
+            buf_chain.push(sectors[j]);
+            var addr = fat_addrs[Math.floor(j * 4 / ssz)];
+            jj = j * 4 & modulus;
+            if (ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 " + ssz);
+            if (!sectors[addr]) break;
+            j = __readInt32LE(sectors[addr], jj);
+            if (seen[j]) break;
+          }
+          sector_list[k] = { nodes: buf, data: __toBuffer([buf_chain]) };
+        }
+        return sector_list;
+      }
+      function read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex, mini) {
+        var minifat_store = 0, pl = Paths.length ? 2 : 0;
+        var sector = sector_list[dir_start].data;
+        var i2 = 0, namelen = 0, name;
+        for (; i2 < sector.length; i2 += 128) {
+          var blob = sector.slice(i2, i2 + 128);
+          prep_blob(blob, 64);
+          namelen = blob.read_shift(2);
+          name = __utf16le(blob, 0, namelen - pl);
+          Paths.push(name);
+          var o = {
+            name,
+            type: blob.read_shift(1),
+            color: blob.read_shift(1),
+            L: blob.read_shift(4, "i"),
+            R: blob.read_shift(4, "i"),
+            C: blob.read_shift(4, "i"),
+            clsid: blob.read_shift(16),
+            state: blob.read_shift(4, "i"),
+            start: 0,
+            size: 0
+          };
+          var ctime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
+          if (ctime !== 0) o.ct = read_date(blob, blob.l - 8);
+          var mtime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
+          if (mtime !== 0) o.mt = read_date(blob, blob.l - 8);
+          o.start = blob.read_shift(4, "i");
+          o.size = blob.read_shift(4, "i");
+          if (o.size < 0 && o.start < 0) {
+            o.size = o.type = 0;
+            o.start = ENDOFCHAIN;
+            o.name = "";
+          }
+          if (o.type === 5) {
+            minifat_store = o.start;
+            if (nmfs > 0 && minifat_store !== ENDOFCHAIN) sector_list[minifat_store].name = "!StreamData";
+          } else if (o.size >= 4096) {
+            o.storage = "fat";
+            if (sector_list[o.start] === void 0) sector_list[o.start] = get_sector_list(sectors, o.start, sector_list.fat_addrs, sector_list.ssz);
+            sector_list[o.start].name = o.name;
+            o.content = sector_list[o.start].data.slice(0, o.size);
+          } else {
+            o.storage = "minifat";
+            if (o.size < 0) o.size = 0;
+            else if (minifat_store !== ENDOFCHAIN && o.start !== ENDOFCHAIN && sector_list[minifat_store]) {
+              o.content = get_mfat_entry(o, sector_list[minifat_store].data, (sector_list[mini] || {}).data);
+            }
+          }
+          if (o.content) prep_blob(o.content, 0);
+          files[name] = o;
+          FileIndex.push(o);
+        }
+      }
+      function read_date(blob, offset) {
+        return new Date((__readUInt32LE(blob, offset + 4) / 1e7 * Math.pow(2, 32) + __readUInt32LE(blob, offset) / 1e7 - 11644473600) * 1e3);
+      }
+      function read_file(filename2, options) {
+        get_fs();
+        return parse3(fs.readFileSync(filename2), options);
+      }
+      function read(blob, options) {
+        var type = options && options.type;
+        if (!type) {
+          if (has_buf && Buffer.isBuffer(blob)) type = "buffer";
+        }
+        switch (type || "base64") {
+          case "file":
+            return read_file(blob, options);
+          case "base64":
+            return parse3(s2a(Base64_decode(blob)), options);
+          case "binary":
+            return parse3(s2a(blob), options);
+        }
+        return parse3(blob, options);
+      }
+      function init_cfb(cfb, opts) {
+        var o = opts || {}, root = o.root || "Root Entry";
+        if (!cfb.FullPaths) cfb.FullPaths = [];
+        if (!cfb.FileIndex) cfb.FileIndex = [];
+        if (cfb.FullPaths.length !== cfb.FileIndex.length) throw new Error("inconsistent CFB structure");
+        if (cfb.FullPaths.length === 0) {
+          cfb.FullPaths[0] = root + "/";
+          cfb.FileIndex[0] = { name: root, type: 5 };
+        }
+        if (o.CLSID) cfb.FileIndex[0].clsid = o.CLSID;
+        seed_cfb(cfb);
+      }
+      function seed_cfb(cfb) {
+        var nm = "
Sh33tJ5";
+        if (CFB2.find(cfb, "/" + nm)) return;
+        var p = new_buf(4);
+        p[0] = 55;
+        p[1] = p[3] = 50;
+        p[2] = 54;
+        cfb.FileIndex.push({ name: nm, type: 2, content: p, size: 4, L: 69, R: 69, C: 69 });
+        cfb.FullPaths.push(cfb.FullPaths[0] + nm);
+        rebuild_cfb(cfb);
+      }
+      function rebuild_cfb(cfb, f) {
+        init_cfb(cfb);
+        var gc = false, s = false;
+        for (var i2 = cfb.FullPaths.length - 1; i2 >= 0; --i2) {
+          var _file = cfb.FileIndex[i2];
+          switch (_file.type) {
+            case 0:
+              if (s) gc = true;
+              else {
+                cfb.FileIndex.pop();
+                cfb.FullPaths.pop();
+              }
+              break;
+            case 1:
+            case 2:
+            case 5:
+              s = true;
+              if (isNaN(_file.R * _file.L * _file.C)) gc = true;
+              if (_file.R > -1 && _file.L > -1 && _file.R == _file.L) gc = true;
+              break;
+            default:
+              gc = true;
+              break;
+          }
+        }
+        if (!gc && !f) return;
+        var now = new Date(1987, 1, 19), j = 0;
+        var fullPaths = Object.create ? /* @__PURE__ */ Object.create(null) : {};
+        var data = [];
+        for (i2 = 0; i2 < cfb.FullPaths.length; ++i2) {
+          fullPaths[cfb.FullPaths[i2]] = true;
+          if (cfb.FileIndex[i2].type === 0) continue;
+          data.push([cfb.FullPaths[i2], cfb.FileIndex[i2]]);
+        }
+        for (i2 = 0; i2 < data.length; ++i2) {
+          var dad = dirname(data[i2][0]);
+          s = fullPaths[dad];
+          while (!s) {
+            while (dirname(dad) && !fullPaths[dirname(dad)]) dad = dirname(dad);
+            data.push([dad, {
+              name: filename(dad).replace("/", ""),
+              type: 1,
+              clsid: HEADER_CLSID,
+              ct: now,
+              mt: now,
+              content: null
+            }]);
+            fullPaths[dad] = true;
+            dad = dirname(data[i2][0]);
+            s = fullPaths[dad];
+          }
+        }
+        data.sort(function(x, y) {
+          return namecmp(x[0], y[0]);
+        });
+        cfb.FullPaths = [];
+        cfb.FileIndex = [];
+        for (i2 = 0; i2 < data.length; ++i2) {
+          cfb.FullPaths[i2] = data[i2][0];
+          cfb.FileIndex[i2] = data[i2][1];
+        }
+        for (i2 = 0; i2 < data.length; ++i2) {
+          var elt = cfb.FileIndex[i2];
+          var nm = cfb.FullPaths[i2];
+          elt.name = filename(nm).replace("/", "");
+          elt.L = elt.R = elt.C = -(elt.color = 1);
+          elt.size = elt.content ? elt.content.length : 0;
+          elt.start = 0;
+          elt.clsid = elt.clsid || HEADER_CLSID;
+          if (i2 === 0) {
+            elt.C = data.length > 1 ? 1 : -1;
+            elt.size = 0;
+            elt.type = 5;
+          } else if (nm.slice(-1) == "/") {
+            for (j = i2 + 1; j < data.length; ++j) if (dirname(cfb.FullPaths[j]) == nm) break;
+            elt.C = j >= data.length ? -1 : j;
+            for (j = i2 + 1; j < data.length; ++j) if (dirname(cfb.FullPaths[j]) == dirname(nm)) break;
+            elt.R = j >= data.length ? -1 : j;
+            elt.type = 1;
+          } else {
+            if (dirname(cfb.FullPaths[i2 + 1] || "") == dirname(nm)) elt.R = i2 + 1;
+            elt.type = 2;
+          }
+        }
+      }
+      function _write(cfb, options) {
+        var _opts = options || {};
+        if (_opts.fileType == "mad") return write_mad(cfb, _opts);
+        rebuild_cfb(cfb);
+        switch (_opts.fileType) {
+          case "zip":
+            return write_zip(cfb, _opts);
+        }
+        var L = (function(cfb2) {
+          var mini_size = 0, fat_size = 0;
+          for (var i3 = 0; i3 < cfb2.FileIndex.length; ++i3) {
+            var file2 = cfb2.FileIndex[i3];
+            if (!file2.content) continue;
+            var flen2 = file2.content.length;
+            if (flen2 > 0) {
+              if (flen2 < 4096) mini_size += flen2 + 63 >> 6;
+              else fat_size += flen2 + 511 >> 9;
+            }
+          }
+          var dir_cnt = cfb2.FullPaths.length + 3 >> 2;
+          var mini_cnt = mini_size + 7 >> 3;
+          var mfat_cnt = mini_size + 127 >> 7;
+          var fat_base = mini_cnt + fat_size + dir_cnt + mfat_cnt;
+          var fat_cnt = fat_base + 127 >> 7;
+          var difat_cnt = fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt - 109) / 127);
+          while (fat_base + fat_cnt + difat_cnt + 127 >> 7 > fat_cnt) difat_cnt = ++fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt - 109) / 127);
+          var L2 = [1, difat_cnt, fat_cnt, mfat_cnt, dir_cnt, fat_size, mini_size, 0];
+          cfb2.FileIndex[0].size = mini_size << 6;
+          L2[7] = (cfb2.FileIndex[0].start = L2[0] + L2[1] + L2[2] + L2[3] + L2[4] + L2[5]) + (L2[6] + 7 >> 3);
+          return L2;
+        })(cfb);
+        var o = new_buf(L[7] << 9);
+        var i2 = 0, T = 0;
+        {
+          for (i2 = 0; i2 < 8; ++i2) o.write_shift(1, HEADER_SIG[i2]);
+          for (i2 = 0; i2 < 8; ++i2) o.write_shift(2, 0);
+          o.write_shift(2, 62);
+          o.write_shift(2, 3);
+          o.write_shift(2, 65534);
+          o.write_shift(2, 9);
+          o.write_shift(2, 6);
+          for (i2 = 0; i2 < 3; ++i2) o.write_shift(2, 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, L[2]);
+          o.write_shift(4, L[0] + L[1] + L[2] + L[3] - 1);
+          o.write_shift(4, 0);
+          o.write_shift(4, 1 << 12);
+          o.write_shift(4, L[3] ? L[0] + L[1] + L[2] - 1 : ENDOFCHAIN);
+          o.write_shift(4, L[3]);
+          o.write_shift(-4, L[1] ? L[0] - 1 : ENDOFCHAIN);
+          o.write_shift(4, L[1]);
+          for (i2 = 0; i2 < 109; ++i2) o.write_shift(-4, i2 < L[2] ? L[1] + i2 : -1);
+        }
+        if (L[1]) {
+          for (T = 0; T < L[1]; ++T) {
+            for (; i2 < 236 + T * 127; ++i2) o.write_shift(-4, i2 < L[2] ? L[1] + i2 : -1);
+            o.write_shift(-4, T === L[1] - 1 ? ENDOFCHAIN : T + 1);
+          }
+        }
+        var chainit = function(w) {
+          for (T += w; i2 < T - 1; ++i2) o.write_shift(-4, i2 + 1);
+          if (w) {
+            ++i2;
+            o.write_shift(-4, ENDOFCHAIN);
+          }
+        };
+        T = i2 = 0;
+        for (T += L[1]; i2 < T; ++i2) o.write_shift(-4, consts.DIFSECT);
+        for (T += L[2]; i2 < T; ++i2) o.write_shift(-4, consts.FATSECT);
+        chainit(L[3]);
+        chainit(L[4]);
+        var j = 0, flen = 0;
+        var file = cfb.FileIndex[0];
+        for (; j < cfb.FileIndex.length; ++j) {
+          file = cfb.FileIndex[j];
+          if (!file.content) continue;
+          flen = file.content.length;
+          if (flen < 4096) continue;
+          file.start = T;
+          chainit(flen + 511 >> 9);
+        }
+        chainit(L[6] + 7 >> 3);
+        while (o.l & 511) o.write_shift(-4, consts.ENDOFCHAIN);
+        T = i2 = 0;
+        for (j = 0; j < cfb.FileIndex.length; ++j) {
+          file = cfb.FileIndex[j];
+          if (!file.content) continue;
+          flen = file.content.length;
+          if (!flen || flen >= 4096) continue;
+          file.start = T;
+          chainit(flen + 63 >> 6);
+        }
+        while (o.l & 511) o.write_shift(-4, consts.ENDOFCHAIN);
+        for (i2 = 0; i2 < L[4] << 2; ++i2) {
+          var nm = cfb.FullPaths[i2];
+          if (!nm || nm.length === 0) {
+            for (j = 0; j < 17; ++j) o.write_shift(4, 0);
+            for (j = 0; j < 3; ++j) o.write_shift(4, -1);
+            for (j = 0; j < 12; ++j) o.write_shift(4, 0);
+            continue;
+          }
+          file = cfb.FileIndex[i2];
+          if (i2 === 0) file.start = file.size ? file.start - 1 : ENDOFCHAIN;
+          var _nm = i2 === 0 && _opts.root || file.name;
+          if (_nm.length > 32) {
+            console.error("Name " + _nm + " will be truncated to " + _nm.slice(0, 32));
+            _nm = _nm.slice(0, 32);
+          }
+          flen = 2 * (_nm.length + 1);
+          o.write_shift(64, _nm, "utf16le");
+          o.write_shift(2, flen);
+          o.write_shift(1, file.type);
+          o.write_shift(1, file.color);
+          o.write_shift(-4, file.L);
+          o.write_shift(-4, file.R);
+          o.write_shift(-4, file.C);
+          if (!file.clsid) for (j = 0; j < 4; ++j) o.write_shift(4, 0);
+          else o.write_shift(16, file.clsid, "hex");
+          o.write_shift(4, file.state || 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, file.start);
+          o.write_shift(4, file.size);
+          o.write_shift(4, 0);
+        }
+        for (i2 = 1; i2 < cfb.FileIndex.length; ++i2) {
+          file = cfb.FileIndex[i2];
+          if (file.size >= 4096) {
+            o.l = file.start + 1 << 9;
+            if (has_buf && Buffer.isBuffer(file.content)) {
+              file.content.copy(o, o.l, 0, file.size);
+              o.l += file.size + 511 & -512;
+            } else {
+              for (j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+              for (; j & 511; ++j) o.write_shift(1, 0);
+            }
+          }
+        }
+        for (i2 = 1; i2 < cfb.FileIndex.length; ++i2) {
+          file = cfb.FileIndex[i2];
+          if (file.size > 0 && file.size < 4096) {
+            if (has_buf && Buffer.isBuffer(file.content)) {
+              file.content.copy(o, o.l, 0, file.size);
+              o.l += file.size + 63 & -64;
+            } else {
+              for (j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
+              for (; j & 63; ++j) o.write_shift(1, 0);
+            }
+          }
+        }
+        if (has_buf) {
+          o.l = o.length;
+        } else {
+          while (o.l < o.length) o.write_shift(1, 0);
+        }
+        return o;
+      }
+      function find2(cfb, path) {
+        var UCFullPaths = cfb.FullPaths.map(function(x) {
+          return x.toUpperCase();
+        });
+        var UCPaths = UCFullPaths.map(function(x) {
+          var y = x.split("/");
+          return y[y.length - (x.slice(-1) == "/" ? 2 : 1)];
+        });
+        var k = false;
+        if (path.charCodeAt(0) === 47) {
+          k = true;
+          path = UCFullPaths[0].slice(0, -1) + path;
+        } else k = path.indexOf("/") !== -1;
+        var UCPath = path.toUpperCase();
+        var w = k === true ? UCFullPaths.indexOf(UCPath) : UCPaths.indexOf(UCPath);
+        if (w !== -1) return cfb.FileIndex[w];
+        var m = !UCPath.match(chr1);
+        UCPath = UCPath.replace(chr0, "");
+        if (m) UCPath = UCPath.replace(chr1, "!");
+        for (w = 0; w < UCFullPaths.length; ++w) {
+          if ((m ? UCFullPaths[w].replace(chr1, "!") : UCFullPaths[w]).replace(chr0, "") == UCPath) return cfb.FileIndex[w];
+          if ((m ? UCPaths[w].replace(chr1, "!") : UCPaths[w]).replace(chr0, "") == UCPath) return cfb.FileIndex[w];
+        }
+        return null;
+      }
+      var MSSZ = 64;
+      var ENDOFCHAIN = -2;
+      var HEADER_SIGNATURE = "d0cf11e0a1b11ae1";
+      var HEADER_SIG = [208, 207, 17, 224, 161, 177, 26, 225];
+      var HEADER_CLSID = "00000000000000000000000000000000";
+      var consts = {
+        /* 2.1 Compund File Sector Numbers and Types */
+        MAXREGSECT: -6,
+        DIFSECT: -4,
+        FATSECT: -3,
+        ENDOFCHAIN,
+        FREESECT: -1,
+        /* 2.2 Compound File Header */
+        HEADER_SIGNATURE,
+        HEADER_MINOR_VERSION: "3e00",
+        MAXREGSID: -6,
+        NOSTREAM: -1,
+        HEADER_CLSID,
+        /* 2.6.1 Compound File Directory Entry */
+        EntryTypes: ["unknown", "storage", "stream", "lockbytes", "property", "root"]
+      };
+      function write_file(cfb, filename2, options) {
+        get_fs();
+        var o = _write(cfb, options);
+        fs.writeFileSync(filename2, o);
+      }
+      function a2s(o) {
+        var out = new Array(o.length);
+        for (var i2 = 0; i2 < o.length; ++i2) out[i2] = String.fromCharCode(o[i2]);
+        return out.join("");
+      }
+      function write(cfb, options) {
+        var o = _write(cfb, options);
+        switch (options && options.type || "buffer") {
+          case "file":
+            get_fs();
+            fs.writeFileSync(options.filename, o);
+            return o;
+          case "binary":
+            return typeof o == "string" ? o : a2s(o);
+          case "base64":
+            return Base64_encode(typeof o == "string" ? o : a2s(o));
+          case "buffer":
+            if (has_buf) return Buffer.isBuffer(o) ? o : Buffer_from(o);
+          /* falls through */
+          case "array":
+            return typeof o == "string" ? s2a(o) : o;
+        }
+        return o;
+      }
+      var _zlib;
+      function use_zlib(zlib) {
+        try {
+          var InflateRaw = zlib.InflateRaw;
+          var InflRaw = new InflateRaw();
+          InflRaw._processChunk(new Uint8Array([3, 0]), InflRaw._finishFlushFlag);
+          if (InflRaw.bytesRead) _zlib = zlib;
+          else throw new Error("zlib does not expose bytesRead");
+        } catch (e) {
+          console.error("cannot use native zlib: " + (e.message || e));
+        }
+      }
+      function _inflateRawSync(payload, usz) {
+        if (!_zlib) return _inflate(payload, usz);
+        var InflateRaw = _zlib.InflateRaw;
+        var InflRaw = new InflateRaw();
+        var out = InflRaw._processChunk(payload.slice(payload.l), InflRaw._finishFlushFlag);
+        payload.l += InflRaw.bytesRead;
+        return out;
+      }
+      function _deflateRawSync(payload) {
+        return _zlib ? _zlib.deflateRawSync(payload) : _deflate(payload);
+      }
+      var CLEN_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+      var LEN_LN = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+      var DST_LN = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+      function bit_swap_8(n) {
+        var t = (n << 1 | n << 11) & 139536 | (n << 5 | n << 15) & 558144;
+        return (t >> 16 | t >> 8 | t) & 255;
+      }
+      var use_typed_arrays = typeof Uint8Array !== "undefined";
+      var bitswap8 = use_typed_arrays ? new Uint8Array(1 << 8) : [];
+      for (var q = 0; q < 1 << 8; ++q) bitswap8[q] = bit_swap_8(q);
+      function bit_swap_n(n, b) {
+        var rev = bitswap8[n & 255];
+        if (b <= 8) return rev >>> 8 - b;
+        rev = rev << 8 | bitswap8[n >> 8 & 255];
+        if (b <= 16) return rev >>> 16 - b;
+        rev = rev << 8 | bitswap8[n >> 16 & 255];
+        return rev >>> 24 - b;
+      }
+      function read_bits_2(buf, bl) {
+        var w = bl & 7, h = bl >>> 3;
+        return (buf[h] | (w <= 6 ? 0 : buf[h + 1] << 8)) >>> w & 3;
+      }
+      function read_bits_3(buf, bl) {
+        var w = bl & 7, h = bl >>> 3;
+        return (buf[h] | (w <= 5 ? 0 : buf[h + 1] << 8)) >>> w & 7;
+      }
+      function read_bits_4(buf, bl) {
+        var w = bl & 7, h = bl >>> 3;
+        return (buf[h] | (w <= 4 ? 0 : buf[h + 1] << 8)) >>> w & 15;
+      }
+      function read_bits_5(buf, bl) {
+        var w = bl & 7, h = bl >>> 3;
+        return (buf[h] | (w <= 3 ? 0 : buf[h + 1] << 8)) >>> w & 31;
+      }
+      function read_bits_7(buf, bl) {
+        var w = bl & 7, h = bl >>> 3;
+        return (buf[h] | (w <= 1 ? 0 : buf[h + 1] << 8)) >>> w & 127;
+      }
+      function read_bits_n(buf, bl, n) {
+        var w = bl & 7, h = bl >>> 3, f = (1 << n) - 1;
+        var v = buf[h] >>> w;
+        if (n < 8 - w) return v & f;
+        v |= buf[h + 1] << 8 - w;
+        if (n < 16 - w) return v & f;
+        v |= buf[h + 2] << 16 - w;
+        if (n < 24 - w) return v & f;
+        v |= buf[h + 3] << 24 - w;
+        return v & f;
+      }
+      function write_bits_3(buf, bl, v) {
+        var w = bl & 7, h = bl >>> 3;
+        if (w <= 5) buf[h] |= (v & 7) << w;
+        else {
+          buf[h] |= v << w & 255;
+          buf[h + 1] = (v & 7) >> 8 - w;
+        }
+        return bl + 3;
+      }
+      function write_bits_1(buf, bl, v) {
+        var w = bl & 7, h = bl >>> 3;
+        v = (v & 1) << w;
+        buf[h] |= v;
+        return bl + 1;
+      }
+      function write_bits_8(buf, bl, v) {
+        var w = bl & 7, h = bl >>> 3;
+        v <<= w;
+        buf[h] |= v & 255;
+        v >>>= 8;
+        buf[h + 1] = v;
+        return bl + 8;
+      }
+      function write_bits_16(buf, bl, v) {
+        var w = bl & 7, h = bl >>> 3;
+        v <<= w;
+        buf[h] |= v & 255;
+        v >>>= 8;
+        buf[h + 1] = v & 255;
+        buf[h + 2] = v >>> 8;
+        return bl + 16;
+      }
+      function realloc(b, sz) {
+        var L = b.length, M = 2 * L > sz ? 2 * L : sz + 5, i2 = 0;
+        if (L >= sz) return b;
+        if (has_buf) {
+          var o = new_unsafe_buf(M);
+          if (b.copy) b.copy(o);
+          else for (; i2 < b.length; ++i2) o[i2] = b[i2];
+          return o;
+        } else if (use_typed_arrays) {
+          var a = new Uint8Array(M);
+          if (a.set) a.set(b);
+          else for (; i2 < L; ++i2) a[i2] = b[i2];
+          return a;
+        }
+        b.length = M;
+        return b;
+      }
+      function zero_fill_array(n) {
+        var o = new Array(n);
+        for (var i2 = 0; i2 < n; ++i2) o[i2] = 0;
+        return o;
+      }
+      function build_tree(clens, cmap, MAX) {
+        var maxlen = 1, w = 0, i2 = 0, j = 0, ccode = 0, L = clens.length;
+        var bl_count = use_typed_arrays ? new Uint16Array(32) : zero_fill_array(32);
+        for (i2 = 0; i2 < 32; ++i2) bl_count[i2] = 0;
+        for (i2 = L; i2 < MAX; ++i2) clens[i2] = 0;
+        L = clens.length;
+        var ctree = use_typed_arrays ? new Uint16Array(L) : zero_fill_array(L);
+        for (i2 = 0; i2 < L; ++i2) {
+          bl_count[w = clens[i2]]++;
+          if (maxlen < w) maxlen = w;
+          ctree[i2] = 0;
+        }
+        bl_count[0] = 0;
+        for (i2 = 1; i2 <= maxlen; ++i2) bl_count[i2 + 16] = ccode = ccode + bl_count[i2 - 1] << 1;
+        for (i2 = 0; i2 < L; ++i2) {
+          ccode = clens[i2];
+          if (ccode != 0) ctree[i2] = bl_count[ccode + 16]++;
+        }
+        var cleni = 0;
+        for (i2 = 0; i2 < L; ++i2) {
+          cleni = clens[i2];
+          if (cleni != 0) {
+            ccode = bit_swap_n(ctree[i2], maxlen) >> maxlen - cleni;
+            for (j = (1 << maxlen + 4 - cleni) - 1; j >= 0; --j)
+              cmap[ccode | j << cleni] = cleni & 15 | i2 << 4;
+          }
+        }
+        return maxlen;
+      }
+      var fix_lmap = use_typed_arrays ? new Uint16Array(512) : zero_fill_array(512);
+      var fix_dmap = use_typed_arrays ? new Uint16Array(32) : zero_fill_array(32);
+      if (!use_typed_arrays) {
+        for (var i = 0; i < 512; ++i) fix_lmap[i] = 0;
+        for (i = 0; i < 32; ++i) fix_dmap[i] = 0;
+      }
+      (function() {
+        var dlens = [];
+        var i2 = 0;
+        for (; i2 < 32; i2++) dlens.push(5);
+        build_tree(dlens, fix_dmap, 32);
+        var clens = [];
+        i2 = 0;
+        for (; i2 <= 143; i2++) clens.push(8);
+        for (; i2 <= 255; i2++) clens.push(9);
+        for (; i2 <= 279; i2++) clens.push(7);
+        for (; i2 <= 287; i2++) clens.push(8);
+        build_tree(clens, fix_lmap, 288);
+      })();
+      var _deflateRaw = (function _deflateRawIIFE() {
+        var DST_LN_RE = use_typed_arrays ? new Uint8Array(32768) : [];
+        var j = 0, k = 0;
+        for (; j < DST_LN.length - 1; ++j) {
+          for (; k < DST_LN[j + 1]; ++k) DST_LN_RE[k] = j;
+        }
+        for (; k < 32768; ++k) DST_LN_RE[k] = 29;
+        var LEN_LN_RE = use_typed_arrays ? new Uint8Array(259) : [];
+        for (j = 0, k = 0; j < LEN_LN.length - 1; ++j) {
+          for (; k < LEN_LN[j + 1]; ++k) LEN_LN_RE[k] = j;
+        }
+        function write_stored(data, out) {
+          var boff = 0;
+          while (boff < data.length) {
+            var L = Math.min(65535, data.length - boff);
+            var h = boff + L == data.length;
+            out.write_shift(1, +h);
+            out.write_shift(2, L);
+            out.write_shift(2, ~L & 65535);
+            while (L-- > 0) out[out.l++] = data[boff++];
+          }
+          return out.l;
+        }
+        function write_huff_fixed(data, out) {
+          var bl = 0;
+          var boff = 0;
+          var addrs = use_typed_arrays ? new Uint16Array(32768) : [];
+          while (boff < data.length) {
+            var L = (
+              /* data.length - boff; */
+              Math.min(65535, data.length - boff)
+            );
+            if (L < 10) {
+              bl = write_bits_3(out, bl, +!!(boff + L == data.length));
+              if (bl & 7) bl += 8 - (bl & 7);
+              out.l = bl / 8 | 0;
+              out.write_shift(2, L);
+              out.write_shift(2, ~L & 65535);
+              while (L-- > 0) out[out.l++] = data[boff++];
+              bl = out.l * 8;
+              continue;
+            }
+            bl = write_bits_3(out, bl, +!!(boff + L == data.length) + 2);
+            var hash = 0;
+            while (L-- > 0) {
+              var d = data[boff];
+              hash = (hash << 5 ^ d) & 32767;
+              var match = -1, mlen = 0;
+              if (match = addrs[hash]) {
+                match |= boff & ~32767;
+                if (match > boff) match -= 32768;
+                if (match < boff) while (data[match + mlen] == data[boff + mlen] && mlen < 250) ++mlen;
+              }
+              if (mlen > 2) {
+                d = LEN_LN_RE[mlen];
+                if (d <= 22) bl = write_bits_8(out, bl, bitswap8[d + 1] >> 1) - 1;
+                else {
+                  write_bits_8(out, bl, 3);
+                  bl += 5;
+                  write_bits_8(out, bl, bitswap8[d - 23] >> 5);
+                  bl += 3;
+                }
+                var len_eb = d < 8 ? 0 : d - 4 >> 2;
+                if (len_eb > 0) {
+                  write_bits_16(out, bl, mlen - LEN_LN[d]);
+                  bl += len_eb;
+                }
+                d = DST_LN_RE[boff - match];
+                bl = write_bits_8(out, bl, bitswap8[d] >> 3);
+                bl -= 3;
+                var dst_eb = d < 4 ? 0 : d - 2 >> 1;
+                if (dst_eb > 0) {
+                  write_bits_16(out, bl, boff - match - DST_LN[d]);
+                  bl += dst_eb;
+                }
+                for (var q2 = 0; q2 < mlen; ++q2) {
+                  addrs[hash] = boff & 32767;
+                  hash = (hash << 5 ^ data[boff]) & 32767;
+                  ++boff;
+                }
+                L -= mlen - 1;
+              } else {
+                if (d <= 143) d = d + 48;
+                else bl = write_bits_1(out, bl, 1);
+                bl = write_bits_8(out, bl, bitswap8[d]);
+                addrs[hash] = boff & 32767;
+                ++boff;
+              }
+            }
+            bl = write_bits_8(out, bl, 0) - 1;
+          }
+          out.l = (bl + 7) / 8 | 0;
+          return out.l;
+        }
+        return function _deflateRaw2(data, out) {
+          if (data.length < 8) return write_stored(data, out);
+          return write_huff_fixed(data, out);
+        };
+      })();
+      function _deflate(data) {
+        var buf = new_buf(50 + Math.floor(data.length * 1.1));
+        var off = _deflateRaw(data, buf);
+        return buf.slice(0, off);
+      }
+      var dyn_lmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
+      var dyn_dmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
+      var dyn_cmap = use_typed_arrays ? new Uint16Array(128) : zero_fill_array(128);
+      var dyn_len_1 = 1, dyn_len_2 = 1;
+      function dyn(data, boff) {
+        var _HLIT = read_bits_5(data, boff) + 257;
+        boff += 5;
+        var _HDIST = read_bits_5(data, boff) + 1;
+        boff += 5;
+        var _HCLEN = read_bits_4(data, boff) + 4;
+        boff += 4;
+        var w = 0;
+        var clens = use_typed_arrays ? new Uint8Array(19) : zero_fill_array(19);
+        var ctree = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        var maxlen = 1;
+        var bl_count = use_typed_arrays ? new Uint8Array(8) : zero_fill_array(8);
+        var next_code = use_typed_arrays ? new Uint8Array(8) : zero_fill_array(8);
+        var L = clens.length;
+        for (var i2 = 0; i2 < _HCLEN; ++i2) {
+          clens[CLEN_ORDER[i2]] = w = read_bits_3(data, boff);
+          if (maxlen < w) maxlen = w;
+          bl_count[w]++;
+          boff += 3;
+        }
+        var ccode = 0;
+        bl_count[0] = 0;
+        for (i2 = 1; i2 <= maxlen; ++i2) next_code[i2] = ccode = ccode + bl_count[i2 - 1] << 1;
+        for (i2 = 0; i2 < L; ++i2) if ((ccode = clens[i2]) != 0) ctree[i2] = next_code[ccode]++;
+        var cleni = 0;
+        for (i2 = 0; i2 < L; ++i2) {
+          cleni = clens[i2];
+          if (cleni != 0) {
+            ccode = bitswap8[ctree[i2]] >> 8 - cleni;
+            for (var j = (1 << 7 - cleni) - 1; j >= 0; --j) dyn_cmap[ccode | j << cleni] = cleni & 7 | i2 << 3;
+          }
+        }
+        var hcodes = [];
+        maxlen = 1;
+        for (; hcodes.length < _HLIT + _HDIST; ) {
+          ccode = dyn_cmap[read_bits_7(data, boff)];
+          boff += ccode & 7;
+          switch (ccode >>>= 3) {
+            case 16:
+              w = 3 + read_bits_2(data, boff);
+              boff += 2;
+              ccode = hcodes[hcodes.length - 1];
+              while (w-- > 0) hcodes.push(ccode);
+              break;
+            case 17:
+              w = 3 + read_bits_3(data, boff);
+              boff += 3;
+              while (w-- > 0) hcodes.push(0);
+              break;
+            case 18:
+              w = 11 + read_bits_7(data, boff);
+              boff += 7;
+              while (w-- > 0) hcodes.push(0);
+              break;
+            default:
+              hcodes.push(ccode);
+              if (maxlen < ccode) maxlen = ccode;
+              break;
+          }
+        }
+        var h1 = hcodes.slice(0, _HLIT), h2 = hcodes.slice(_HLIT);
+        for (i2 = _HLIT; i2 < 286; ++i2) h1[i2] = 0;
+        for (i2 = _HDIST; i2 < 30; ++i2) h2[i2] = 0;
+        dyn_len_1 = build_tree(h1, dyn_lmap, 286);
+        dyn_len_2 = build_tree(h2, dyn_dmap, 30);
+        return boff;
+      }
+      function inflate(data, usz) {
+        if (data[0] == 3 && !(data[1] & 3)) {
+          return [new_raw_buf(usz), 2];
+        }
+        var boff = 0;
+        var header = 0;
+        var outbuf = new_unsafe_buf(usz ? usz : 1 << 18);
+        var woff = 0;
+        var OL = outbuf.length >>> 0;
+        var max_len_1 = 0, max_len_2 = 0;
+        while ((header & 1) == 0) {
+          header = read_bits_3(data, boff);
+          boff += 3;
+          if (header >>> 1 == 0) {
+            if (boff & 7) boff += 8 - (boff & 7);
+            var sz = data[boff >>> 3] | data[(boff >>> 3) + 1] << 8;
+            boff += 32;
+            if (sz > 0) {
+              if (!usz && OL < woff + sz) {
+                outbuf = realloc(outbuf, woff + sz);
+                OL = outbuf.length;
+              }
+              while (sz-- > 0) {
+                outbuf[woff++] = data[boff >>> 3];
+                boff += 8;
+              }
+            }
+            continue;
+          } else if (header >> 1 == 1) {
+            max_len_1 = 9;
+            max_len_2 = 5;
+          } else {
+            boff = dyn(data, boff);
+            max_len_1 = dyn_len_1;
+            max_len_2 = dyn_len_2;
+          }
+          for (; ; ) {
+            if (!usz && OL < woff + 32767) {
+              outbuf = realloc(outbuf, woff + 32767);
+              OL = outbuf.length;
+            }
+            var bits = read_bits_n(data, boff, max_len_1);
+            var code = header >>> 1 == 1 ? fix_lmap[bits] : dyn_lmap[bits];
+            boff += code & 15;
+            code >>>= 4;
+            if ((code >>> 8 & 255) === 0) outbuf[woff++] = code;
+            else if (code == 256) break;
+            else {
+              code -= 257;
+              var len_eb = code < 8 ? 0 : code - 4 >> 2;
+              if (len_eb > 5) len_eb = 0;
+              var tgt = woff + LEN_LN[code];
+              if (len_eb > 0) {
+                tgt += read_bits_n(data, boff, len_eb);
+                boff += len_eb;
+              }
+              bits = read_bits_n(data, boff, max_len_2);
+              code = header >>> 1 == 1 ? fix_dmap[bits] : dyn_dmap[bits];
+              boff += code & 15;
+              code >>>= 4;
+              var dst_eb = code < 4 ? 0 : code - 2 >> 1;
+              var dst = DST_LN[code];
+              if (dst_eb > 0) {
+                dst += read_bits_n(data, boff, dst_eb);
+                boff += dst_eb;
+              }
+              if (!usz && OL < tgt) {
+                outbuf = realloc(outbuf, tgt + 100);
+                OL = outbuf.length;
+              }
+              while (woff < tgt) {
+                outbuf[woff] = outbuf[woff - dst];
+                ++woff;
+              }
+            }
+          }
+        }
+        if (usz) return [outbuf, boff + 7 >>> 3];
+        return [outbuf.slice(0, woff), boff + 7 >>> 3];
+      }
+      function _inflate(payload, usz) {
+        var data = payload.slice(payload.l || 0);
+        var out = inflate(data, usz);
+        payload.l += out[1];
+        return out[0];
+      }
+      function warn_or_throw(wrn, msg) {
+        if (wrn) {
+          if (typeof console !== "undefined") console.error(msg);
+        } else throw new Error(msg);
+      }
+      function parse_zip(file, options) {
+        var blob = file;
+        prep_blob(blob, 0);
+        var FileIndex = [], FullPaths = [];
+        var o = {
+          FileIndex,
+          FullPaths
+        };
+        init_cfb(o, { root: options.root });
+        var i2 = blob.length - 4;
+        while ((blob[i2] != 80 || blob[i2 + 1] != 75 || blob[i2 + 2] != 5 || blob[i2 + 3] != 6) && i2 >= 0) --i2;
+        blob.l = i2 + 4;
+        blob.l += 4;
+        var fcnt = blob.read_shift(2);
+        blob.l += 6;
+        var start_cd = blob.read_shift(4);
+        blob.l = start_cd;
+        for (i2 = 0; i2 < fcnt; ++i2) {
+          blob.l += 20;
+          var csz = blob.read_shift(4);
+          var usz = blob.read_shift(4);
+          var namelen = blob.read_shift(2);
+          var efsz = blob.read_shift(2);
+          var fcsz = blob.read_shift(2);
+          blob.l += 8;
+          var offset = blob.read_shift(4);
+          var EF = parse_extra_field(blob.slice(blob.l + namelen, blob.l + namelen + efsz));
+          blob.l += namelen + efsz + fcsz;
+          var L = blob.l;
+          blob.l = offset + 4;
+          parse_local_file(blob, csz, usz, o, EF);
+          blob.l = L;
+        }
+        return o;
+      }
+      function parse_local_file(blob, csz, usz, o, EF) {
+        blob.l += 2;
+        var flags = blob.read_shift(2);
+        var meth = blob.read_shift(2);
+        var date = parse_dos_date(blob);
+        if (flags & 8257) throw new Error("Unsupported ZIP encryption");
+        var crc32 = blob.read_shift(4);
+        var _csz = blob.read_shift(4);
+        var _usz = blob.read_shift(4);
+        var namelen = blob.read_shift(2);
+        var efsz = blob.read_shift(2);
+        var name = "";
+        for (var i2 = 0; i2 < namelen; ++i2) name += String.fromCharCode(blob[blob.l++]);
+        if (efsz) {
+          var ef = parse_extra_field(blob.slice(blob.l, blob.l + efsz));
+          if ((ef[21589] || {}).mt) date = ef[21589].mt;
+          if (((EF || {})[21589] || {}).mt) date = EF[21589].mt;
+        }
+        blob.l += efsz;
+        var data = blob.slice(blob.l, blob.l + _csz);
+        switch (meth) {
+          case 8:
+            data = _inflateRawSync(blob, _usz);
+            break;
+          case 0:
+            break;
+          // TODO: scan for magic number
+          default:
+            throw new Error("Unsupported ZIP Compression method " + meth);
+        }
+        var wrn = false;
+        if (flags & 8) {
+          crc32 = blob.read_shift(4);
+          if (crc32 == 134695760) {
+            crc32 = blob.read_shift(4);
+            wrn = true;
+          }
+          _csz = blob.read_shift(4);
+          _usz = blob.read_shift(4);
+        }
+        if (_csz != csz) warn_or_throw(wrn, "Bad compressed size: " + csz + " != " + _csz);
+        if (_usz != usz) warn_or_throw(wrn, "Bad uncompressed size: " + usz + " != " + _usz);
+        var _crc32 = CRC32.buf(data, 0);
+        if (crc32 >> 0 != _crc32 >> 0) warn_or_throw(wrn, "Bad CRC32 checksum: " + crc32 + " != " + _crc32);
+        cfb_add(o, name, data, { unsafe: true, mt: date });
+      }
+      function write_zip(cfb, options) {
+        var _opts = options || {};
+        var out = [], cdirs = [];
+        var o = new_buf(1);
+        var method = _opts.compression ? 8 : 0, flags = 0;
+        var desc = false;
+        if (desc) flags |= 8;
+        var i2 = 0, j = 0;
+        var start_cd = 0, fcnt = 0;
+        var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+        var crcs = [];
+        var sz_cd = 0;
+        for (i2 = 1; i2 < cfb.FullPaths.length; ++i2) {
+          fp = cfb.FullPaths[i2].slice(root.length);
+          fi = cfb.FileIndex[i2];
+          if (!fi.size || !fi.content || fp == "
Sh33tJ5") continue;
+          var start = start_cd;
+          var namebuf = new_buf(fp.length);
+          for (j = 0; j < fp.length; ++j) namebuf.write_shift(1, fp.charCodeAt(j) & 127);
+          namebuf = namebuf.slice(0, namebuf.l);
+          crcs[fcnt] = CRC32.buf(fi.content, 0);
+          var outbuf = fi.content;
+          if (method == 8) outbuf = _deflateRawSync(outbuf);
+          o = new_buf(30);
+          o.write_shift(4, 67324752);
+          o.write_shift(2, 20);
+          o.write_shift(2, flags);
+          o.write_shift(2, method);
+          if (fi.mt) write_dos_date(o, fi.mt);
+          else o.write_shift(4, 0);
+          o.write_shift(-4, flags & 8 ? 0 : crcs[fcnt]);
+          o.write_shift(4, flags & 8 ? 0 : outbuf.length);
+          o.write_shift(4, flags & 8 ? 0 : fi.content.length);
+          o.write_shift(2, namebuf.length);
+          o.write_shift(2, 0);
+          start_cd += o.length;
+          out.push(o);
+          start_cd += namebuf.length;
+          out.push(namebuf);
+          start_cd += outbuf.length;
+          out.push(outbuf);
+          if (flags & 8) {
+            o = new_buf(12);
+            o.write_shift(-4, crcs[fcnt]);
+            o.write_shift(4, outbuf.length);
+            o.write_shift(4, fi.content.length);
+            start_cd += o.l;
+            out.push(o);
+          }
+          o = new_buf(46);
+          o.write_shift(4, 33639248);
+          o.write_shift(2, 0);
+          o.write_shift(2, 20);
+          o.write_shift(2, flags);
+          o.write_shift(2, method);
+          o.write_shift(4, 0);
+          o.write_shift(-4, crcs[fcnt]);
+          o.write_shift(4, outbuf.length);
+          o.write_shift(4, fi.content.length);
+          o.write_shift(2, namebuf.length);
+          o.write_shift(2, 0);
+          o.write_shift(2, 0);
+          o.write_shift(2, 0);
+          o.write_shift(2, 0);
+          o.write_shift(4, 0);
+          o.write_shift(4, start);
+          sz_cd += o.l;
+          cdirs.push(o);
+          sz_cd += namebuf.length;
+          cdirs.push(namebuf);
+          ++fcnt;
+        }
+        o = new_buf(22);
+        o.write_shift(4, 101010256);
+        o.write_shift(2, 0);
+        o.write_shift(2, 0);
+        o.write_shift(2, fcnt);
+        o.write_shift(2, fcnt);
+        o.write_shift(4, sz_cd);
+        o.write_shift(4, start_cd);
+        o.write_shift(2, 0);
+        return bconcat([bconcat(out), bconcat(cdirs), o]);
+      }
+      var ContentTypeMap = {
+        "htm": "text/html",
+        "xml": "text/xml",
+        "gif": "image/gif",
+        "jpg": "image/jpeg",
+        "png": "image/png",
+        "mso": "application/x-mso",
+        "thmx": "application/vnd.ms-officetheme",
+        "sh33tj5": "application/octet-stream"
+      };
+      function get_content_type(fi, fp) {
+        if (fi.ctype) return fi.ctype;
+        var ext = fi.name || "", m = ext.match(/\.([^\.]+)$/);
+        if (m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+        if (fp) {
+          m = (ext = fp).match(/[\.\\]([^\.\\])+$/);
+          if (m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
+        }
+        return "application/octet-stream";
+      }
+      function write_base64_76(bstr) {
+        var data = Base64_encode(bstr);
+        var o = [];
+        for (var i2 = 0; i2 < data.length; i2 += 76) o.push(data.slice(i2, i2 + 76));
+        return o.join("\r\n") + "\r\n";
+      }
+      function write_quoted_printable(text) {
+        var encoded = text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF=]/g, function(c) {
+          var w = c.charCodeAt(0).toString(16).toUpperCase();
+          return "=" + (w.length == 1 ? "0" + w : w);
+        });
+        encoded = encoded.replace(/ $/mg, "=20").replace(/\t$/mg, "=09");
+        if (encoded.charAt(0) == "\n") encoded = "=0D" + encoded.slice(1);
+        encoded = encoded.replace(/\r(?!\n)/mg, "=0D").replace(/\n\n/mg, "\n=0A").replace(/([^\r\n])\n/mg, "$1=0A");
+        var o = [], split = encoded.split("\r\n");
+        for (var si = 0; si < split.length; ++si) {
+          var str = split[si];
+          if (str.length == 0) {
+            o.push("");
+            continue;
+          }
+          for (var i2 = 0; i2 < str.length; ) {
+            var end = 76;
+            var tmp = str.slice(i2, i2 + end);
+            if (tmp.charAt(end - 1) == "=") end--;
+            else if (tmp.charAt(end - 2) == "=") end -= 2;
+            else if (tmp.charAt(end - 3) == "=") end -= 3;
+            tmp = str.slice(i2, i2 + end);
+            i2 += end;
+            if (i2 < str.length) tmp += "=";
+            o.push(tmp);
+          }
+        }
+        return o.join("\r\n");
+      }
+      function parse_quoted_printable(data) {
+        var o = [];
+        for (var di = 0; di < data.length; ++di) {
+          var line = data[di];
+          while (di <= data.length && line.charAt(line.length - 1) == "=") line = line.slice(0, line.length - 1) + data[++di];
+          o.push(line);
+        }
+        for (var oi = 0; oi < o.length; ++oi) o[oi] = o[oi].replace(/[=][0-9A-Fa-f]{2}/g, function($$) {
+          return String.fromCharCode(parseInt($$.slice(1), 16));
+        });
+        return s2a(o.join("\r\n"));
+      }
+      function parse_mime(cfb, data, root) {
+        var fname = "", cte = "", ctype = "", fdata;
+        var di = 0;
+        for (; di < 10; ++di) {
+          var line = data[di];
+          if (!line || line.match(/^\s*$/)) break;
+          var m = line.match(/^(.*?):\s*([^\s].*)$/);
+          if (m) switch (m[1].toLowerCase()) {
+            case "content-location":
+              fname = m[2].trim();
+              break;
+            case "content-type":
+              ctype = m[2].trim();
+              break;
+            case "content-transfer-encoding":
+              cte = m[2].trim();
+              break;
+          }
+        }
+        ++di;
+        switch (cte.toLowerCase()) {
+          case "base64":
+            fdata = s2a(Base64_decode(data.slice(di).join("")));
+            break;
+          case "quoted-printable":
+            fdata = parse_quoted_printable(data.slice(di));
+            break;
+          default:
+            throw new Error("Unsupported Content-Transfer-Encoding " + cte);
+        }
+        var file = cfb_add(cfb, fname.slice(root.length), fdata, { unsafe: true });
+        if (ctype) file.ctype = ctype;
+      }
+      function parse_mad(file, options) {
+        if (a2s(file.slice(0, 13)).toLowerCase() != "mime-version:") throw new Error("Unsupported MAD header");
+        var root = options && options.root || "";
+        var data = (has_buf && Buffer.isBuffer(file) ? file.toString("binary") : a2s(file)).split("\r\n");
+        var di = 0, row = "";
+        for (di = 0; di < data.length; ++di) {
+          row = data[di];
+          if (!/^Content-Location:/i.test(row)) continue;
+          row = row.slice(row.indexOf("file"));
+          if (!root) root = row.slice(0, row.lastIndexOf("/") + 1);
+          if (row.slice(0, root.length) == root) continue;
+          while (root.length > 0) {
+            root = root.slice(0, root.length - 1);
+            root = root.slice(0, root.lastIndexOf("/") + 1);
+            if (row.slice(0, root.length) == root) break;
+          }
+        }
+        var mboundary = (data[1] || "").match(/boundary="(.*?)"/);
+        if (!mboundary) throw new Error("MAD cannot find boundary");
+        var boundary = "--" + (mboundary[1] || "");
+        var FileIndex = [], FullPaths = [];
+        var o = {
+          FileIndex,
+          FullPaths
+        };
+        init_cfb(o);
+        var start_di, fcnt = 0;
+        for (di = 0; di < data.length; ++di) {
+          var line = data[di];
+          if (line !== boundary && line !== boundary + "--") continue;
+          if (fcnt++) parse_mime(o, data.slice(start_di, di), root);
+          start_di = di;
+        }
+        return o;
+      }
+      function write_mad(cfb, options) {
+        var opts = options || {};
+        var boundary = opts.boundary || "SheetJS";
+        boundary = "------=" + boundary;
+        var out = [
+          "MIME-Version: 1.0",
+          'Content-Type: multipart/related; boundary="' + boundary.slice(2) + '"',
+          "",
+          "",
+          ""
+        ];
+        var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
+        for (var i2 = 1; i2 < cfb.FullPaths.length; ++i2) {
+          fp = cfb.FullPaths[i2].slice(root.length);
+          fi = cfb.FileIndex[i2];
+          if (!fi.size || !fi.content || fp == "
Sh33tJ5") continue;
+          fp = fp.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF]/g, function(c) {
+            return "_x" + c.charCodeAt(0).toString(16) + "_";
+          }).replace(/[\u0080-\uFFFF]/g, function(u) {
+            return "_u" + u.charCodeAt(0).toString(16) + "_";
+          });
+          var ca = fi.content;
+          var cstr = has_buf && Buffer.isBuffer(ca) ? ca.toString("binary") : a2s(ca);
+          var dispcnt = 0, L = Math.min(1024, cstr.length), cc = 0;
+          for (var csl = 0; csl <= L; ++csl) if ((cc = cstr.charCodeAt(csl)) >= 32 && cc < 128) ++dispcnt;
+          var qp = dispcnt >= L * 4 / 5;
+          out.push(boundary);
+          out.push("Content-Location: " + (opts.root || "file:///C:/SheetJS/") + fp);
+          out.push("Content-Transfer-Encoding: " + (qp ? "quoted-printable" : "base64"));
+          out.push("Content-Type: " + get_content_type(fi, fp));
+          out.push("");
+          out.push(qp ? write_quoted_printable(cstr) : write_base64_76(cstr));
+        }
+        out.push(boundary + "--\r\n");
+        return out.join("\r\n");
+      }
+      function cfb_new(opts) {
+        var o = {};
+        init_cfb(o, opts);
+        return o;
+      }
+      function cfb_add(cfb, name, content, opts) {
+        var unsafe = opts && opts.unsafe;
+        if (!unsafe) init_cfb(cfb);
+        var file = !unsafe && CFB2.find(cfb, name);
+        if (!file) {
+          var fpath = cfb.FullPaths[0];
+          if (name.slice(0, fpath.length) == fpath) fpath = name;
+          else {
+            if (fpath.slice(-1) != "/") fpath += "/";
+            fpath = (fpath + name).replace("//", "/");
+          }
+          file = { name: filename(name), type: 2 };
+          cfb.FileIndex.push(file);
+          cfb.FullPaths.push(fpath);
+          if (!unsafe) CFB2.utils.cfb_gc(cfb);
+        }
+        file.content = content;
+        file.size = content ? content.length : 0;
+        if (opts) {
+          if (opts.CLSID) file.clsid = opts.CLSID;
+          if (opts.mt) file.mt = opts.mt;
+          if (opts.ct) file.ct = opts.ct;
+        }
+        return file;
+      }
+      function cfb_del(cfb, name) {
+        init_cfb(cfb);
+        var file = CFB2.find(cfb, name);
+        if (file) {
+          for (var j = 0; j < cfb.FileIndex.length; ++j) if (cfb.FileIndex[j] == file) {
+            cfb.FileIndex.splice(j, 1);
+            cfb.FullPaths.splice(j, 1);
+            return true;
+          }
+        }
+        return false;
+      }
+      function cfb_mov(cfb, old_name, new_name) {
+        init_cfb(cfb);
+        var file = CFB2.find(cfb, old_name);
+        if (file) {
+          for (var j = 0; j < cfb.FileIndex.length; ++j) if (cfb.FileIndex[j] == file) {
+            cfb.FileIndex[j].name = filename(new_name);
+            cfb.FullPaths[j] = new_name;
+            return true;
+          }
+        }
+        return false;
+      }
+      function cfb_gc(cfb) {
+        rebuild_cfb(cfb, true);
+      }
+      exports2.find = find2;
+      exports2.read = read;
+      exports2.parse = parse3;
+      exports2.write = write;
+      exports2.writeFile = write_file;
+      exports2.utils = {
+        cfb_new,
+        cfb_add,
+        cfb_del,
+        cfb_mov,
+        cfb_gc,
+        ReadShift,
+        CheckField,
+        prep_blob,
+        bconcat,
+        use_zlib,
+        _deflateRaw: _deflate,
+        _inflateRaw: _inflate,
+        consts
+      };
+      return exports2;
+    })();
+    if (typeof __require !== "undefined" && typeof module !== "undefined" && typeof DO_NOT_EXPORT_CFB === "undefined") {
+      module.exports = CFB2;
+    }
+  }
+});
+
+// src/ocr/auto-detect.ts
+import { execSync } from "child_process";
+import { createRequire } from "module";
+function detectAvailableOcr() {
+  for (const cli of CLI_PRIORITY) {
+    if (isCliInstalled(cli)) return cli;
+  }
+  if (isTesseractAvailable()) return "tesseract";
+  return null;
+}
+function isCliInstalled(name) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    execSync(`${cmd} ${name}`, { stdio: "ignore", timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isTesseractAvailable() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    require2.resolve("tesseract.js");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateOcrMode(mode) {
+  if (mode === "auto" || mode === "off") return;
+  if (mode === "tesseract") {
+    if (!isTesseractAvailable()) {
+      throw new Error(
+        "tesseract.js\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.\n\uC124\uCE58: npm install tesseract.js"
+      );
+    }
+    return;
+  }
+  if (!isCliInstalled(mode)) {
+    throw new Error(`'${mode}' CLI\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.
+${getInstallGuide(mode)}`);
+  }
+}
+function getInstallGuide(mode) {
+  const guides = {
+    gemini: "\uC124\uCE58: https://ai.google.dev/gemini-api/docs/cli",
+    claude: "\uC124\uCE58: npm install -g @anthropic-ai/claude-code \uB610\uB294 https://claude.ai/code",
+    codex: "\uC124\uCE58: npm install -g @openai/codex \uB610\uB294 https://github.com/openai/codex",
+    ollama: "\uC124\uCE58: brew install ollama \uB610\uB294 https://ollama.com/download"
+  };
+  return guides[mode] || `'${mode}'\uC744(\uB97C) \uC124\uCE58\uD574\uC8FC\uC138\uC694.`;
+}
+var CLI_PRIORITY;
+var init_auto_detect = __esm({
+  "src/ocr/auto-detect.ts"() {
+    "use strict";
+    CLI_PRIORITY = ["gemini", "claude", "codex", "ollama"];
+  }
+});
+
+// src/ocr/cli-provider.ts
+import { spawnSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+function getTempDir() {
+  if (!_tempDir) _tempDir = mkdtempSync(join(tmpdir(), "kordoc-ocr-"));
+  return _tempDir;
+}
+function createCliOcrProvider(mode) {
+  return async (pageImage, pageNumber) => {
+    const tempPath = join(getTempDir(), `page-${pageNumber}.png`);
+    try {
+      writeFileSync(tempPath, pageImage);
+      let output;
+      if (mode === "ollama") {
+        output = await callOllamaApi(tempPath);
+      } else {
+        output = callCli(mode, tempPath);
+      }
+      return { markdown: stripCodeFence(output.trim()) };
+    } finally {
+      try {
+        unlinkSync(tempPath);
+      } catch {
+      }
+    }
+  };
+}
+function callCli(mode, imagePath) {
+  const args = buildCliArgs(mode, imagePath);
+  const result = spawnSync(mode === "codex" ? "codex" : mode, args, {
+    encoding: "utf-8",
+    timeout: 6e4,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  if (result.error) {
+    throw new Error(`${mode} CLI \uC2E4\uD589 \uC2E4\uD328: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const errMsg = result.stderr?.trim() || `exit code ${result.status}`;
+    throw new Error(`${mode} OCR \uC2E4\uD328: ${errMsg}`);
+  }
+  return result.stdout || "";
+}
+function buildCliArgs(mode, imagePath) {
+  const promptWithImage = `${OCR_PROMPT}
+
+\uC774\uBBF8\uC9C0: @${imagePath}`;
+  const promptOnly = OCR_PROMPT;
+  switch (mode) {
+    case "gemini":
+      return ["--prompt", promptWithImage, "--yolo"];
+    case "claude":
+      return ["--print", promptWithImage];
+    case "codex":
+      return ["exec", "--image", imagePath, promptOnly];
+    default:
+      throw new Error(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 CLI: ${mode}`);
+  }
+}
+async function callOllamaApi(imagePath) {
+  const { readFileSync } = await import("fs");
+  const imageBase64 = readFileSync(imagePath).toString("base64");
+  const model = process.env.KORDOC_OLLAMA_MODEL || "gemma4:27b";
+  const host = process.env.KORDOC_OLLAMA_HOST || "http://localhost:11434";
+  const response = await fetch(`${host}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages: [{
+        role: "user",
+        content: OCR_PROMPT,
+        images: [imageBase64]
+      }],
+      stream: false
+    }),
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!response.ok) {
+    throw new Error(`Ollama API \uC624\uB958: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.message?.content || "";
+}
+function stripCodeFence(text) {
+  const match = text.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/m);
+  return match ? match[1].trim() : text;
+}
+var OCR_PROMPT, _tempDir;
+var init_cli_provider = __esm({
+  "src/ocr/cli-provider.ts"() {
+    "use strict";
+    OCR_PROMPT = "\uC774 PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0\uC5D0\uC11C \uD14D\uC2A4\uD2B8\uC640 \uD14C\uC774\uBE14\uC744 \uCD94\uCD9C\uD558\uC5EC \uC21C\uC218 Markdown\uC73C\uB85C \uBCC0\uD658\uD558\uC138\uC694.\n\uADDC\uCE59:\n- \uD14C\uC774\uBE14\uC740 Markdown \uD14C\uC774\uBE14 \uBB38\uBC95 \uC0AC\uC6A9 (| \uAD6C\uBD84, |---|---| \uD5E4\uB354 \uAD6C\uBD84\uC120 \uD3EC\uD568)\n- \uBCD1\uD569\uB41C \uC140\uC740 \uD574\uB2F9 \uC704\uCE58\uC5D0 \uB0B4\uC6A9 \uAE30\uC7AC\n- \uD5E4\uB529\uC740 \uAE00\uC790 \uD06C\uAE30\uC5D0 \uB530\uB77C ## ~ ###### \uC0AC\uC6A9\n- \uB9AC\uC2A4\uD2B8\uB294 - \uB610\uB294 1. \uC0AC\uC6A9\n- \uC774\uBBF8\uC9C0, \uB3C4\uD615 \uB4F1 \uBE44\uD14D\uC2A4\uD2B8 \uC694\uC18C\uB294 \uBB34\uC2DC\n- \uC6D0\uBB38\uC758 \uC77D\uAE30 \uC21C\uC11C\uC640 \uAD6C\uC870\uB97C \uC720\uC9C0\n- ```\uB85C \uAC10\uC2F8\uC9C0 \uB9D0\uACE0 \uC21C\uC218 Markdown\uB9CC \uCD9C\uB825";
+    _tempDir = null;
+  }
+});
+
+// src/ocr/tesseract-provider.ts
+var tesseract_provider_exports = {};
+__export(tesseract_provider_exports, {
+  createTesseractProvider: () => createTesseractProvider
+});
+async function createTesseractProvider() {
+  let tesseract;
+  try {
+    tesseract = await import("tesseract.js");
+  } catch {
+    throw new Error(
+      "tesseract.js\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.\n\uC124\uCE58: npm install tesseract.js"
+    );
+  }
+  const worker = await tesseract.createWorker("kor+eng");
+  let terminated = false;
+  const provider = async (pageImage, _pageNumber, _mimeType) => {
+    const { data } = await worker.recognize(pageImage);
+    return data.text;
+  };
+  provider.terminate = async () => {
+    if (!terminated) {
+      await worker.terminate();
+      terminated = true;
+    }
+  };
+  return provider;
+}
+var init_tesseract_provider = __esm({
+  "src/ocr/tesseract-provider.ts"() {
+    "use strict";
+  }
+});
+
+// src/ocr/resolve.ts
+var resolve_exports = {};
+__export(resolve_exports, {
+  resolveOcrProvider: () => resolveOcrProvider
+});
+async function resolveOcrProvider(mode, warnings) {
+  if (mode === "off") {
+    throw new Error("OCR\uC774 \uBE44\uD65C\uC131\uD654\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4 (--ocr off).");
+  }
+  if (mode !== "auto") {
+    validateOcrMode(mode);
+    if (mode === "tesseract") {
+      const { createTesseractProvider: createTesseractProvider2 } = await Promise.resolve().then(() => (init_tesseract_provider(), tesseract_provider_exports));
+      return createTesseractProvider2();
+    }
+    return createCliOcrProvider(mode);
+  }
+  const detected = detectAvailableOcr();
+  if (!detected) {
+    throw new Error("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C OCR \uB3C4\uAD6C\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  }
+  if (detected !== "gemini") {
+    warnings?.push({
+      message: `OCR: '${detected}' \uC0AC\uC6A9 \uC911 (gemini CLI\uAC00 \uC5C6\uC5B4 fallback). \uB354 \uB098\uC740 \uD488\uC9C8\uC744 \uC704\uD574 gemini CLI \uC124\uCE58\uB97C \uAD8C\uC7A5\uD569\uB2C8\uB2E4.`,
+      code: "OCR_CLI_FALLBACK"
+    });
+  }
+  if (detected === "tesseract") {
+    warnings?.push({
+      message: "tesseract.js\uB294 \uD14C\uC774\uBE14 \uAD6C\uC870\uB97C \uBCF5\uC6D0\uD558\uC9C0 \uBABB\uD569\uB2C8\uB2E4. Vision LLM CLI(gemini/claude/codex) \uC124\uCE58\uB97C \uAD8C\uC7A5\uD569\uB2C8\uB2E4.",
+      code: "OCR_CLI_FALLBACK"
+    });
+    const { createTesseractProvider: createTesseractProvider2 } = await Promise.resolve().then(() => (init_tesseract_provider(), tesseract_provider_exports));
+    return createTesseractProvider2();
+  }
+  return createCliOcrProvider(detected);
+}
+var init_resolve = __esm({
+  "src/ocr/resolve.ts"() {
+    "use strict";
+    init_auto_detect();
+    init_cli_provider();
+  }
+});
+
+// src/ocr/markdown-to-blocks.ts
+function markdownToBlocks(markdown, pageNumber) {
+  const blocks = [];
+  const lines = markdown.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      blocks.push({
+        type: "heading",
+        level: headingMatch[1].length,
+        text: headingMatch[2].trim(),
+        pageNumber
+      });
+      i++;
+      continue;
+    }
+    if (/^[-*_]{3,}\s*$/.test(line.trim())) {
+      blocks.push({ type: "separator", pageNumber });
+      i++;
+      continue;
+    }
+    if (line.trim().startsWith("|")) {
+      const tableLines = [];
+      while (i < lines.length && lines[i].trim().startsWith("|")) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      const table = parseMarkdownTable(tableLines);
+      if (table) {
+        blocks.push({ type: "table", table, pageNumber });
+      }
+      continue;
+    }
+    const ulMatch = line.match(/^(\s*)[-*+]\s+(.+)$/);
+    if (ulMatch) {
+      blocks.push({
+        type: "list",
+        listType: "unordered",
+        text: ulMatch[2].trim(),
+        pageNumber
+      });
+      i++;
+      continue;
+    }
+    const olMatch = line.match(/^(\s*)\d+\.\s+(.+)$/);
+    if (olMatch) {
+      blocks.push({
+        type: "list",
+        listType: "ordered",
+        text: olMatch[2].trim(),
+        pageNumber
+      });
+      i++;
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== "" && !isStructuralLine(lines[i])) {
+      paraLines.push(lines[i].trim());
+      i++;
+    }
+    if (paraLines.length > 0) {
+      blocks.push({
+        type: "paragraph",
+        text: paraLines.join("\n"),
+        pageNumber
+      });
+    }
   }
-  if (typeof spec !== "string" || spec.trim() === "") return result;
-  const parts = spec.split(",");
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (!trimmed) continue;
-    const rangeMatch = trimmed.match(/^(\d+)\s*-\s*(\d+)$/);
-    if (rangeMatch) {
-      const start = Math.max(1, parseInt(rangeMatch[1], 10));
-      const end = Math.min(maxPages, parseInt(rangeMatch[2], 10));
-      for (let i = start; i <= end; i++) result.add(i);
-    } else {
-      const page = parseInt(trimmed, 10);
-      if (!isNaN(page) && page >= 1 && page <= maxPages) result.add(page);
+  return blocks;
+}
+function isStructuralLine(line) {
+  if (/^#{1,6}\s+/.test(line)) return true;
+  if (line.trim().startsWith("|")) return true;
+  if (/^[-*_]{3,}\s*$/.test(line.trim())) return true;
+  if (/^\s*[-*+]\s+/.test(line)) return true;
+  if (/^\s*\d+\.\s+/.test(line)) return true;
+  return false;
+}
+function parseMarkdownTable(lines) {
+  const hasSeparator = lines.some((line) => /^\|[\s:|-]+\|$/.test(line.trim()));
+  const rows = [];
+  let maxCols = 0;
+  for (const line of lines) {
+    if (/^\|\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/.test(line.trim())) continue;
+    const parts = line.split("|");
+    const cells = parts.slice(1, parts[parts.length - 1].trim() === "" ? -1 : void 0).map((cell) => ({
+      text: cell.trim(),
+      colSpan: 1,
+      rowSpan: 1
+    }));
+    if (cells.length > 0) {
+      rows.push(cells);
+      maxCols = Math.max(maxCols, cells.length);
     }
   }
-  return result;
+  if (rows.length === 0) return null;
+  for (const row of rows) {
+    while (row.length < maxCols) {
+      row.push({ text: "", colSpan: 1, rowSpan: 1 });
+    }
+  }
+  return {
+    rows: rows.length,
+    cols: maxCols,
+    cells: rows,
+    hasHeader: hasSeparator && rows.length > 1
+  };
 }
-var init_page_range = __esm({
-  "src/page-range.ts"() {
+var init_markdown_to_blocks = __esm({
+  "src/ocr/markdown-to-blocks.ts"() {
     "use strict";
   }
 });
@@ -51,18 +2323,31 @@ var provider_exports = {};
 __export(provider_exports, {
   ocrPages: () => ocrPages
 });
-async function ocrPages(doc, provider, pageFilter, effectivePageCount) {
+async function ocrPages(doc, provider, pageFilter, effectivePageCount, warnings) {
   const blocks = [];
   for (let i = 1; i <= effectivePageCount; i++) {
     if (pageFilter && !pageFilter.has(i)) continue;
     const page = await doc.getPage(i);
     try {
       const imageData = await renderPageToPng(page);
-      const text = await provider(imageData, i, "image/png");
-      if (text.trim()) {
-        blocks.push({ type: "paragraph", text: text.trim(), pageNumber: i });
+      const result = await provider(imageData, i, "image/png");
+      if (typeof result === "string") {
+        if (result.trim()) {
+          blocks.push({ type: "paragraph", text: result.trim(), pageNumber: i });
+        }
+      } else if (result && typeof result === "object" && "markdown" in result) {
+        const structured = result;
+        if (structured.markdown.trim()) {
+          const pageBlocks = markdownToBlocks(structured.markdown, i);
+          for (const b of pageBlocks) blocks.push(b);
+        }
       }
-    } catch {
+    } catch (err) {
+      warnings?.push({
+        page: i,
+        message: `\uD398\uC774\uC9C0 ${i} OCR \uC2E4\uD328: ${err instanceof Error ? err.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`,
+        code: "OCR_PAGE_FAILED"
+      });
     }
   }
   return blocks;
@@ -85,6 +2370,7 @@ async function renderPageToPng(page) {
 var init_provider = __esm({
   "src/ocr/provider.ts"() {
     "use strict";
+    init_markdown_to_blocks();
   }
 });
 
@@ -137,7 +2423,7 @@ import JSZip2 from "jszip";
 import { DOMParser } from "@xmldom/xmldom";
 
 // src/utils.ts
-var VERSION = true ? "2.1.6" : "0.0.0-dev";
+var VERSION = true ? "2.2.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -470,7 +2756,7 @@ var HEADING_RATIO_H3 = 1.15;
 // src/hwpx/parser.ts
 init_page_range();
 var MAX_DECOMPRESS_SIZE = 500 * 1024 * 1024;
-var MAX_ZIP_ENTRIES = 500;
+var MAX_ZIP_ENTRIES = 2e3;
 function clampSpan(val, max) {
   return Math.max(1, Math.min(val, max));
 }
@@ -629,6 +2915,16 @@ function imageExtToMime(ext) {
       return "application/octet-stream";
   }
 }
+function detectImageMimeFromBytes(data) {
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg";
+  if (data.length >= 4 && data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png";
+  if (data.length >= 3 && data[0] === 71 && data[1] === 73 && data[2] === 70) return "image/gif";
+  if (data.length >= 2 && data[0] === 66 && data[1] === 77) return "image/bmp";
+  if (data.length >= 4 && data[0] === 215 && data[1] === 205 && data[2] === 198 && data[3] === 154) return "image/wmf";
+  if (data.length >= 4 && (data[0] === 1 || data[0] === 2) && data[1] === 0 && data[2] === 9 && data[3] === 0) return "image/wmf";
+  if (data.length >= 4 && data[0] === 1 && data[1] === 0 && data[2] === 0 && data[3] === 0) return "image/emf";
+  return "image/png";
+}
 function mimeToExt(mime) {
   if (mime.includes("jpeg")) return "jpg";
   if (mime.includes("png")) return "png";
@@ -646,12 +2942,12 @@ async function extractImagesFromZip(zip, blocks, decompressed, warnings) {
   for (const block of blocks) {
     if (block.type !== "image" || !block.text) continue;
     const ref = block.text;
-    const candidates = [
-      `BinData/${ref}`,
-      `Contents/BinData/${ref}`,
-      ref
-      // 절대 경로일 수도 있음
-    ];
+    const exts = ref.includes(".") ? [""] : [".jpg", ".jpeg", ".png", ".bmp", ".gif", ".wmf", ".emf", ".tif", ""];
+    const candidates = exts.flatMap((ext) => [
+      `BinData/${ref}${ext}`,
+      `Contents/BinData/${ref}${ext}`,
+      `${ref}${ext}`
+    ]);
     let found = false;
     for (const path of candidates) {
       if (isPathTraversal(path)) continue;
@@ -661,8 +2957,10 @@ async function extractImagesFromZip(zip, blocks, decompressed, warnings) {
         const data = await file.async("uint8array");
         decompressed.total += data.length;
         if (decompressed.total > MAX_DECOMPRESS_SIZE) throw new KordocError("ZIP \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (ZIP bomb \uC758\uC2EC)");
-        const ext = ref.includes(".") ? ref.split(".").pop() : "png";
-        const mimeType = imageExtToMime(ext);
+        const refExt = ref.includes(".") ? ref.split(".").pop().toLowerCase() : "";
+        const pathExt = !refExt && path.includes(".") ? path.split(".").pop().toLowerCase() : "";
+        const ext = refExt || pathExt;
+        const mimeType = ext ? imageExtToMime(ext) : detectImageMimeFromBytes(data);
         imageIndex++;
         const filename = `image_${String(imageIndex).padStart(3, "0")}.${mimeToExt(mimeType)}`;
         images.push({ filename, data, mimeType });
@@ -985,13 +3283,18 @@ function walkSection(node, blocks, tableCtx, tableStack, styleMap, warnings, sec
         }
         break;
       case "p": {
-        const { text, href, footnote, style } = extractParagraphInfo(el, styleMap);
+        const { text, href, footnote, style, headingLevel } = extractParagraphInfo(el, styleMap);
         if (text) {
           if (tableCtx?.cell) {
             tableCtx.cell.text += (tableCtx.cell.text ? "\n" : "") + text;
           } else if (!tableCtx) {
-            const block = { type: "paragraph", text, pageNumber: sectionNum };
-            if (style) block.style = style;
+            let block;
+            if (headingLevel) {
+              block = { type: "heading", text, level: headingLevel, pageNumber: sectionNum };
+            } else {
+              block = { type: "paragraph", text, pageNumber: sectionNum };
+              if (style) block.style = style;
+            }
             if (href) block.href = href;
             if (footnote) block.footnoteText = footnote;
             blocks.push(block);
@@ -1225,7 +3528,19 @@ function extractParagraphInfo(para, styleMap) {
       if (!style.fontSize && !style.bold && !style.italic) style = void 0;
     }
   }
-  return { text: cleanText, href, footnote, style };
+  let headingLevel;
+  const styleIdRef = para.getAttribute("styleIDRef");
+  if (styleMap && styleIdRef) {
+    const styleDef = styleMap.styles.get(styleIdRef);
+    if (styleDef?.name) {
+      const sn = styleDef.name;
+      if (/장제목|대제목|간지제목|제목[\s_]?1|개요[\s_]?1|heading[\s_]?1/i.test(sn)) headingLevel = 1;
+      else if (/절제목|제목[\s_]?2|개요[\s_]?2|heading[\s_]?2|^B-1\.$|[\s(]1\.$/i.test(sn)) headingLevel = 2;
+      else if (/제목[\s_]?3|개요[\s_]?3|heading[\s_]?3|1\.1\s*제목|1\.1[\s_]|^B-1\.1/i.test(sn)) headingLevel = 3;
+      else if (/제목[\s_]?4|개요[\s_]?4|heading[\s_]?4/i.test(sn)) headingLevel = 4;
+    }
+  }
+  return { text: cleanText, href, footnote, style, headingLevel };
 }
 function extractTextFromNode(node) {
   let result = "";
@@ -2291,9 +4606,7 @@ function parseLenientCfb(data) {
 
 // src/hwp5/parser.ts
 init_page_range();
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var CFB = require2("cfb");
+var CFB = __toESM(require_cfb(), 1);
 var MAX_SECTIONS = 100;
 var MAX_TOTAL_DECOMPRESS = 500 * 1024 * 1024;
 function parseHwp5Document(buffer, options) {
@@ -3152,7 +5465,7 @@ function clusterCoordinates(values) {
 }
 function groupConnectedLines(lines) {
   const parent = lines.map((_, i) => i);
-  function find(x) {
+  function find2(x) {
     while (parent[x] !== x) {
       parent[x] = parent[parent[x]];
       x = parent[x];
@@ -3160,7 +5473,7 @@ function groupConnectedLines(lines) {
     return x;
   }
   function union(a, b) {
-    const ra = find(a), rb = find(b);
+    const ra = find2(a), rb = find2(b);
     if (ra !== rb) parent[ra] = rb;
   }
   for (let i = 0; i < lines.length; i++) {
@@ -3172,7 +5485,7 @@ function groupConnectedLines(lines) {
   }
   const groups = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
-    const root = find(i);
+    const root = find2(i);
     if (!groups.has(root)) groups.set(root, []);
     groups.get(root).push(lines[i]);
   }
@@ -3622,18 +5935,43 @@ async function parsePdfDocument(buffer, options) {
     }
     const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
     if (totalChars / Math.max(parsedPageCount, 1) < 10) {
-      if (options?.ocr) {
+      let ocrProvider = options?.ocr ?? null;
+      const ocrMode = options?.ocrMode;
+      if (!ocrProvider && ocrMode && ocrMode !== "off") {
+        try {
+          const { resolveOcrProvider: resolveOcrProvider2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
+          ocrProvider = await resolveOcrProvider2(ocrMode, warnings);
+        } catch (resolveErr) {
+          if (ocrMode !== "auto") {
+            throw Object.assign(
+              new KordocError(resolveErr instanceof Error ? resolveErr.message : "OCR \uD504\uB85C\uBC14\uC774\uB354 \uCD08\uAE30\uD654 \uC2E4\uD328"),
+              { isImageBased: true }
+            );
+          }
+        }
+      }
+      if (ocrProvider) {
         try {
           const { ocrPages: ocrPages2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
-          const ocrBlocks = await ocrPages2(doc, options.ocr, pageFilter, effectivePageCount);
+          const ocrBlocks = await ocrPages2(doc, ocrProvider, pageFilter, effectivePageCount, warnings);
           if (ocrBlocks.length > 0) {
-            const ocrMarkdown = ocrBlocks.map((b) => b.text || "").filter(Boolean).join("\n\n");
-            return { markdown: ocrMarkdown, blocks: ocrBlocks, metadata, warnings, isImageBased: true };
+            const ocrMarkdown = blocksToMarkdown(ocrBlocks);
+            return {
+              markdown: ocrMarkdown,
+              blocks: ocrBlocks,
+              metadata,
+              warnings: warnings.length > 0 ? warnings : void 0,
+              isImageBased: true
+            };
           }
         } catch {
         }
       }
-      throw Object.assign(new KordocError(`\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`), { isImageBased: true });
+      if (ocrMode === "off") {
+        throw Object.assign(new KordocError(`\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`), { isImageBased: true });
+      }
+      const errMsg = ocrMode ? `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF \u2014 OCR \uC2E4\uD328 (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)` : `\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (${pageCount}\uD398\uC774\uC9C0, ${totalChars}\uC790)`;
+      throw Object.assign(new KordocError(errMsg), { isImageBased: true });
     }
     if (options?.removeHeaderFooter !== false && parsedPageCount >= 3) {
       const removed = removeHeaderFooterBlocks(blocks, pageHeights, warnings);
@@ -5245,8 +7583,8 @@ function levenshtein(a, b) {
 var SIMILARITY_THRESHOLD = 0.4;
 async function compare(bufferA, bufferB, options) {
   const [resultA, resultB] = await Promise.all([
-    parse(bufferA, options),
-    parse(bufferB, options)
+    parse2(bufferA, options),
+    parse2(bufferB, options)
   ]);
   if (!resultA.success) throw new Error(`\uBB38\uC11CA \uD30C\uC2F1 \uC2E4\uD328: ${resultA.error}`);
   if (!resultB.success) throw new Error(`\uBB38\uC11CB \uD30C\uC2F1 \uC2E4\uD328: ${resultB.error}`);
@@ -5567,7 +7905,7 @@ var HEADER_XML = `<?xml version='1.0' encoding='UTF-8'?>
         </hh:font>
       </hh:fontface>
     </hh:fontfaces>
-    <hh:borderFills itemCnt="3">
+    <hh:borderFills itemCnt="5">
       <hh:borderFill id="1" threeD="0" shadow="0" centerLine="NONE" breakCellSeparateLine="0">
         <hh:slash type="NONE" Crooked="0" isCounter="0"/>
         <hh:backSlash type="NONE" Crooked="0" isCounter="0"/>
@@ -5598,8 +7936,26 @@ var HEADER_XML = `<?xml version='1.0' encoding='UTF-8'?>
         <hh:bottomBorder type="SOLID" width="0.12 mm" color="#000000"/>
         <hh:diagonal type="SOLID" width="0.1 mm" color="#000000"/>
       </hh:borderFill>
+      <hh:borderFill id="4" 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="SOLID" width="0.5 mm" color="#AAAAAA"/>
+        <hh:rightBorder type="NONE" width="0.1 mm" color="#000000"/>
+        <hh:topBorder type="NONE" width="0.1 mm" color="#000000"/>
+        <hh:bottomBorder type="NONE" width="0.1 mm" color="#000000"/>
+        <hh:diagonal type="SOLID" width="0.1 mm" color="#000000"/>
+      </hh:borderFill>
+      <hh:borderFill id="5" 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="NONE" width="0.1 mm" color="#000000"/>
+        <hh:rightBorder type="NONE" width="0.1 mm" color="#000000"/>
+        <hh:topBorder type="NONE" width="0.1 mm" color="#000000"/>
+        <hh:bottomBorder type="SOLID" width="0.4 mm" color="#888888"/>
+        <hh:diagonal type="SOLID" width="0.1 mm" color="#000000"/>
+      </hh:borderFill>
     </hh:borderFills>
-    <hh:charProperties itemCnt="15">
+    <hh:charProperties itemCnt="16">
       <hh:charPr id="0" height="1000" textColor="#000000" shadeColor="none" useFontSpace="0" useKerning="0" symMark="NONE" borderFillIDRef="2">
         <hh:fontRef hangul="1" latin="1" hanja="1" japanese="1" other="1" symbol="1" user="1"/>
         <hh:ratio hangul="100" latin="100" hanja="100" japanese="100" other="100" symbol="100" user="100"/>
@@ -5774,6 +8130,17 @@ var HEADER_XML = `<?xml version='1.0' encoding='UTF-8'?>
         <hh:outline type="NONE"/>
         <hh:shadow type="NONE" color="#C0C0C0" offsetX="10" offsetY="10"/>
       </hh:charPr>
+      <hh:charPr id="15" height="1000" textColor="#000000" shadeColor="none" useFontSpace="0" useKerning="0" symMark="NONE" borderFillIDRef="2">
+        <hh:fontRef hangul="1" latin="1" hanja="1" japanese="1" other="1" symbol="1" user="1"/>
+        <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"/>
+        <hh:underline type="NONE" shape="SOLID" color="#000000"/>
+        <hh:strikeout shape="SINGLE" color="#000000"/>
+        <hh:outline type="NONE"/>
+        <hh:shadow type="NONE" color="#C0C0C0" offsetX="10" offsetY="10"/>
+      </hh:charPr>
     </hh:charProperties>
     <hh:tabProperties itemCnt="3">
       <hh:tabPr id="0" autoTabLeft="0" autoTabRight="0"/>
@@ -5794,7 +8161,7 @@ var HEADER_XML = `<?xml version='1.0' encoding='UTF-8'?>
         <hh:paraHead start="1" level="10" align="LEFT" useInstWidth="1" autoIndent="1" widthAdjust="0" textOffsetType="PERCENT" textOffset="50" numFormat="ROMAN_SMALL" charPrIDRef="4294967295" checkable="1"/>
       </hh:numbering>
     </hh:numberings>
-    <hh:paraProperties itemCnt="20">
+    <hh:paraProperties itemCnt="22">
       <hh:paraPr id="0" tabPrIDRef="0" condense="0" fontLineHeight="0" snapToGrid="1" suppressLineNumbers="0" checked="0" textDir="LTR">
         <hh:align horizontal="JUSTIFY" vertical="BASELINE"/>
         <hh:heading type="NONE" idRef="0" level="0"/>
@@ -6396,6 +8763,64 @@ var HEADER_XML = `<?xml version='1.0' encoding='UTF-8'?>
         </hp:switch>
         <hh:border borderFillIDRef="2" offsetLeft="0" offsetRight="0" offsetTop="0" offsetBottom="0" connect="0" ignoreMargin="0"/>
       </hh:paraPr>
+      <hh:paraPr id="20" tabPrIDRef="0" condense="0" fontLineHeight="0" snapToGrid="1" suppressLineNumbers="0" checked="0" textDir="LTR">
+        <hh:align horizontal="JUSTIFY" 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"/>
+        <hp:switch>
+          <hp:case hp:required-namespace="http://www.hancom.co.kr/hwpml/2016/HwpUnitChar">
+            <hh:margin>
+              <hc:intent value="0" unit="HWPUNIT"/>
+              <hc:left value="4252" 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"/>
+          </hp:case>
+          <hp:default>
+            <hh:margin>
+              <hc:intent value="0" unit="HWPUNIT"/>
+              <hc:left value="4252" 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"/>
+          </hp:default>
+        </hp:switch>
+        <hh:border borderFillIDRef="4" offsetLeft="0" offsetRight="0" offsetTop="0" offsetBottom="0" connect="0" ignoreMargin="0"/>
+      </hh:paraPr>
+      <hh:paraPr id="21" tabPrIDRef="0" condense="0" fontLineHeight="0" snapToGrid="1" suppressLineNumbers="0" checked="0" textDir="LTR">
+        <hh:align horizontal="JUSTIFY" 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"/>
+        <hp:switch>
+          <hp:case hp:required-namespace="http://www.hancom.co.kr/hwpml/2016/HwpUnitChar">
+            <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"/>
+          </hp:case>
+          <hp:default>
+            <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"/>
+          </hp:default>
+        </hp:switch>
+        <hh:border borderFillIDRef="5" offsetLeft="0" offsetRight="0" offsetTop="0" offsetBottom="0" connect="0" ignoreMargin="0"/>
+      </hh:paraPr>
     </hh:paraProperties>
     <hh:styles itemCnt="23">
       <hh:style id="0" type="PARA" name="\uBC14\uD0D5\uAE00" engName="Normal" paraPrIDRef="0" charPrIDRef="0" nextStyleIDRef="0" langID="1042" lockForm="0"/>
@@ -6499,7 +8924,11 @@ async function extractTemplateStyles(templateArrayBuffer) {
     charPr: /* @__PURE__ */ new Map(),
     paraPr: /* @__PURE__ */ new Map(),
     borderFill: /* @__PURE__ */ new Map(),
-    fontfaces: /* @__PURE__ */ new Map()
+    fontfaces: /* @__PURE__ */ new Map(),
+    styles: /* @__PURE__ */ new Map(),
+    stylesById: /* @__PURE__ */ new Map(),
+    masterpages: [],
+    headerXml: headerXmlText
   };
   const fontfaces = doc.getElementsByTagNameNS(ns.hh, "fontFamily");
   for (let i = 0; i < fontfaces.length; i++) {
@@ -6574,6 +9003,34 @@ async function extractTemplateStyles(templateArrayBuffer) {
     if (fillColor) borderFillProp.fillColor = fillColor;
     template.borderFill.set(id, borderFillProp);
   }
+  const styleEls = doc.getElementsByTagNameNS(ns.hh, "style");
+  for (let i = 0; i < styleEls.length; i++) {
+    const el = styleEls.item(i);
+    const id = el.getAttribute("id");
+    const name = el.getAttribute("name") || "";
+    const engName = el.getAttribute("engName") || "";
+    const charPrIDRef = el.getAttribute("charPrIDRef") || "0";
+    const paraPrIDRef = el.getAttribute("paraPrIDRef") || "0";
+    if (!id) continue;
+    const def = { id, name, engName, charPrIDRef, paraPrIDRef };
+    template.styles.set(name, def);
+    template.stylesById.set(id, def);
+  }
+  const section0File = zip.file("Contents/section0.xml");
+  if (section0File) {
+    const sec0 = await section0File.async("text");
+    const secPrMatch = sec0.match(/<hp:secPr[\s\S]*?<\/hp:secPr>/);
+    if (secPrMatch) template.secPrXml = secPrMatch[0];
+    const colPrMatch = sec0.match(/<hp:ctrl>[\s\S]*?<\/hp:ctrl>/);
+    if (colPrMatch) template.colPrXml = colPrMatch[0];
+  }
+  for (const [path, file] of Object.entries(zip.files)) {
+    if (/^Contents\/masterpage\d+\.xml$/.test(path)) {
+      const content = await file.async("text");
+      template.masterpages.push({ filename: path, content });
+    }
+  }
+  template.masterpages.sort((a, b) => a.filename.localeCompare(b.filename));
   return template;
 }
 function findCharPrByCharacteristic(charPrMap, characteristic) {
@@ -6634,35 +9091,61 @@ function getDefaultBorderFillId(borderFillMap) {
 }
 
 // src/hwpx/style-matcher.ts
+function findStyleByName(styles, candidates) {
+  for (const cand of candidates) {
+    if (styles.has(cand)) return styles.get(cand);
+  }
+  for (const cand of candidates) {
+    for (const [name, def] of styles) {
+      if (name === `B-${cand}` || name.endsWith(` ${cand}`) || name.endsWith(`-${cand}`)) return def;
+    }
+  }
+  for (const cand of candidates) {
+    let best = null;
+    for (const [name, def] of styles) {
+      if (name.includes(cand)) {
+        if (!best || name.length < best[0].length) best = [name, def];
+      }
+    }
+    if (best) return best[1];
+  }
+  return null;
+}
 function createStyleMap(template, warnings = []) {
   const charPrMap = template.charPr || /* @__PURE__ */ new Map();
-  const paraPrMap = template.paraPr || /* @__PURE__ */ new Map();
   const borderFillMap = template.borderFill || /* @__PURE__ */ new Map();
+  const styles = template.styles || /* @__PURE__ */ new Map();
   const defaultCharPr = getDefaultCharPrId(charPrMap);
-  const defaultParaPr = getDefaultParaPrId(paraPrMap);
+  const defaultParaPr = getDefaultParaPrId(template.paraPr || /* @__PURE__ */ new Map());
   const defaultBorderFill = getDefaultBorderFillId(borderFillMap);
-  const h1CharPr = findCharPrByCharacteristic(charPrMap, "heading1") || defaultCharPr;
-  const h2CharPr = findCharPrByCharacteristic(charPrMap, "heading2") || defaultCharPr;
-  const h3CharPr = findCharPrByCharacteristic(charPrMap, "heading3") || defaultCharPr;
-  const boldCharPr = findCharPrByCharacteristic(charPrMap, "bold") || defaultCharPr;
-  const italicCharPr = findCharPrByCharacteristic(charPrMap, "italic") || defaultCharPr;
-  const bodyCharPr = findCharPrByCharacteristic(charPrMap, "normal") || defaultCharPr;
-  if (h1CharPr === defaultCharPr) {
-    warnings.push("[warn] \uD15C\uD50C\uB9BF\uC5D0\uC11C H1 \uC81C\uBAA9 \uC2A4\uD0C0\uC77C\uC744 \uAC10\uC9C0\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uAE30\uBCF8\uAC12 \uC0AC\uC6A9");
-  }
-  if (h2CharPr === defaultCharPr) {
-    warnings.push("[warn] \uD15C\uD50C\uB9BF\uC5D0\uC11C H2 \uC81C\uBAA9 \uC2A4\uD0C0\uC77C\uC744 \uAC10\uC9C0\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uAE30\uBCF8\uAC12 \uC0AC\uC6A9");
-  }
+  const defaultStyleId = "0";
+  const toEntry = (def, fallbackCharPr) => ({
+    charPr: def?.charPrIDRef ?? fallbackCharPr,
+    paraPr: def?.paraPrIDRef ?? defaultParaPr,
+    styleId: def?.id ?? defaultStyleId
+  });
+  const bodyDef = findStyleByName(styles, ["\uBC14\uD0D5\uAE00", "Normal", "\uBCF8\uBB38", "\uBC14\uD0D5"]) || findStyleByName(styles, ["body", "normal"]);
+  const h1Def = findStyleByName(styles, ["\uC81C\uBAA91", "\uC81C\uBAA9 1", "\uAC1C\uC694 1", "\uAC1C\uC6941", "Heading 1"]) || findStyleByName(styles, ["\uC7A5\uC81C\uBAA9", "\uB300\uC81C\uBAA9", "\uC81C\uBAA9"]);
+  const h2Def = findStyleByName(styles, ["\uC81C\uBAA92", "\uC81C\uBAA9 2", "\uAC1C\uC694 2", "\uAC1C\uC6942", "Heading 2"]) || findStyleByName(styles, ["\uC808\uC81C\uBAA9", "1.", "1 "]);
+  const h3Def = findStyleByName(styles, ["\uC81C\uBAA93", "\uC81C\uBAA9 3", "\uAC1C\uC694 3", "\uAC1C\uC6943", "Heading 3"]) || findStyleByName(styles, ["1.1", "\uD56D\uBAA9"]);
+  const tableCellDef = findStyleByName(styles, ["\uD45C \uB0B4\uC6A9", "\uD45C\uB0B4\uC6A9", "B-\uD45C\uB0B4\uC6A9", "\uD45C \uB0B4\uC6A9(\uC77C\uBC18)"]) || findStyleByName(styles, ["\uD45C", "table"]);
+  const tableHeaderDef = findStyleByName(styles, ["\uD45C\uC81C\uBAA9", "\uD45C \uC81C\uBAA9", "B-\uD45C\uC81C\uBAA9", "\uD45C \uB0B4\uC6A9(\uAC15\uC870)"]) || tableCellDef;
+  const bodyCharPr = bodyDef?.charPrIDRef ?? findCharPrByCharacteristic(charPrMap, "normal") ?? defaultCharPr;
+  const h1CharPr = h1Def?.charPrIDRef ?? findCharPrByCharacteristic(charPrMap, "heading1") ?? defaultCharPr;
+  const h2CharPr = h2Def?.charPrIDRef ?? findCharPrByCharacteristic(charPrMap, "heading2") ?? defaultCharPr;
+  const h3CharPr = h3Def?.charPrIDRef ?? findCharPrByCharacteristic(charPrMap, "heading3") ?? defaultCharPr;
+  const boldCharPr = findCharPrByCharacteristic(charPrMap, "bold") ?? defaultCharPr;
+  const italicCharPr = findCharPrByCharacteristic(charPrMap, "italic") ?? defaultCharPr;
   return {
-    h1: { charPr: h1CharPr, paraPr: defaultParaPr },
-    h2: { charPr: h2CharPr, paraPr: defaultParaPr },
-    h3: { charPr: h3CharPr, paraPr: defaultParaPr },
-    h456: { charPr: defaultCharPr, paraPr: defaultParaPr },
-    body: { charPr: bodyCharPr, paraPr: defaultParaPr },
+    h1: { charPr: h1CharPr, paraPr: h1Def?.paraPrIDRef ?? defaultParaPr, styleId: h1Def?.id ?? defaultStyleId },
+    h2: { charPr: h2CharPr, paraPr: h2Def?.paraPrIDRef ?? defaultParaPr, styleId: h2Def?.id ?? defaultStyleId },
+    h3: { charPr: h3CharPr, paraPr: h3Def?.paraPrIDRef ?? defaultParaPr, styleId: h3Def?.id ?? defaultStyleId },
+    h456: { charPr: h3CharPr, paraPr: h3Def?.paraPrIDRef ?? defaultParaPr, styleId: h3Def?.id ?? defaultStyleId },
+    body: { charPr: bodyCharPr, paraPr: bodyDef?.paraPrIDRef ?? defaultParaPr, styleId: bodyDef?.id ?? defaultStyleId },
     bold: { charPr: boldCharPr },
     italic: { charPr: italicCharPr },
-    tableCell: { charPr: bodyCharPr, borderFill: defaultBorderFill },
-    tableHeader: { charPr: boldCharPr, borderFill: defaultBorderFill }
+    tableCell: { charPr: tableCellDef?.charPrIDRef ?? bodyCharPr, paraPr: tableCellDef?.paraPrIDRef ?? defaultParaPr, styleId: tableCellDef?.id ?? defaultStyleId, borderFill: defaultBorderFill },
+    tableHeader: { charPr: tableHeaderDef?.charPrIDRef ?? bodyCharPr, paraPr: tableHeaderDef?.paraPrIDRef ?? defaultParaPr, styleId: tableHeaderDef?.id ?? defaultStyleId, borderFill: defaultBorderFill }
   };
 }
 function getStyleForBlock(styleMap, blockType, inlineStyle) {
@@ -6698,7 +9181,10 @@ var CHAR_BOLD = "11";
 var CHAR_ITALIC = "12";
 var CHAR_BOLD_ITALIC = "13";
 var CHAR_CODE = "14";
+var CHAR_STRIKETHROUGH = "15";
 var PARA_NORMAL = "0";
+var PARA_BLOCKQUOTE = "20";
+var PARA_HR = "21";
 var SEC_NS = [
   `xmlns:ha="http://www.hancom.co.kr/hwpml/2011/app"`,
   `xmlns:hp="http://www.hancom.co.kr/hwpml/2011/paragraph"`,
@@ -6725,7 +9211,7 @@ function escapeXml(text) {
 }
 function parseInlineRuns(text) {
   const runs = [];
-  const re = /\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[([^\]]+)\]\(([^)]+)\)/g;
+  const re = /\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|~~(.+?)~~|\[([^\]]+)\]\(([^)]+)\)/g;
   let last = 0;
   let m;
   while ((m = re.exec(text)) !== null) {
@@ -6735,7 +9221,8 @@ function parseInlineRuns(text) {
     else if (m[3]) runs.push({ text: m[3], italic: true });
     else if (m[4]) runs.push({ text: m[4], italic: true });
     else if (m[5]) runs.push({ text: m[5], code: true });
-    else if (m[6]) runs.push({ text: m[6], url: m[7] });
+    else if (m[6]) runs.push({ text: m[6], strikethrough: true });
+    else if (m[7]) runs.push({ text: m[7], url: m[8] });
     last = m.index + m[0].length;
   }
   if (last < text.length) runs.push({ text: text.slice(last) });
@@ -6743,6 +9230,7 @@ function parseInlineRuns(text) {
 }
 function charPrForRun(run) {
   if (run.code) return CHAR_CODE;
+  if (run.strikethrough) return CHAR_STRIKETHROUGH;
   if (run.bold && run.italic) return CHAR_BOLD_ITALIC;
   if (run.bold) return CHAR_BOLD;
   if (run.italic) return CHAR_ITALIC;
@@ -6771,25 +9259,51 @@ function makeHyperlinkRun(text, url, charPrId, nextId) {
   ].join("\n");
 }
 function makeRunsFromText(text, defaultCharPr, nextId) {
+  if (/<br\s*\/?>/i.test(text)) {
+    const parts = text.split(/<br\s*\/?>/i);
+    return parts.map((part, i) => {
+      const seg = makeRunsFromText(part, defaultCharPr, nextId);
+      return i < parts.length - 1 ? seg + `<hp:run charPrIDRef="${defaultCharPr}"><hp:lf/></hp:run>` : seg;
+    }).join("");
+  }
   const runs = parseInlineRuns(text);
   if (runs.length === 0) return makeRun("", defaultCharPr);
-  const isPlain = runs.length === 1 && !runs[0].bold && !runs[0].italic && !runs[0].code && !runs[0].url;
+  const isPlain = runs.length === 1 && !runs[0].bold && !runs[0].italic && !runs[0].code && !runs[0].strikethrough && !runs[0].url;
   if (isPlain) return makeRun(runs[0].text, defaultCharPr);
   return runs.map((r) => {
     if (r.url && nextId) return makeHyperlinkRun(r.text, r.url, CHAR_NORMAL, nextId);
     return makeRun(r.text, charPrForRun(r));
   }).join("");
 }
-var LINESEG = `  <hp:linesegarray>
-    <hp:lineseg textpos="0" vertpos="0" vertsize="1000" textheight="1000" baseline="850" spacing="600" horzpos="0" horzsize="42520" flags="393216"/>
+function makeLineseg(horzsize, vertsize) {
+  const baseline = Math.round(vertsize * 0.85);
+  return `  <hp:linesegarray>
+    <hp:lineseg textpos="0" vertpos="0" vertsize="${vertsize}" textheight="${vertsize}" baseline="${baseline}" spacing="600" horzpos="0" horzsize="${horzsize}" flags="393216"/>
+  </hp:linesegarray>`;
+}
+var CHAR_HWP = 1e3;
+var LINE_HWP = 1400;
+var BASELINE_RATIO = 0.85;
+function estimateCellLineseg(plainText, cellHorzsize) {
+  const stripped = plainText.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+  const charsPerLine = Math.max(1, Math.floor(cellHorzsize / CHAR_HWP));
+  const lineCount = Math.max(1, Math.ceil(stripped.length / charsPerLine));
+  const baseline = Math.round(LINE_HWP * BASELINE_RATIO);
+  const segs = Array.from({ length: lineCount }, (_, i) => {
+    const textpos = i * charsPerLine;
+    const vertpos = i * LINE_HWP;
+    return `    <hp:lineseg textpos="${textpos}" vertpos="${vertpos}" vertsize="${LINE_HWP}" textheight="${LINE_HWP}" baseline="${vertpos + baseline}" spacing="600" horzpos="0" horzsize="${cellHorzsize}" flags="393216"/>`;
+  });
+  return `  <hp:linesegarray>
+${segs.join("\n")}
   </hp:linesegarray>`;
-function makeParagraph(text, charPrId, paraPrId, nextId) {
+}
+function makeParagraph(text, charPrId, paraPrId, nextId, styleId = "0") {
   const id = nextId();
   const runs = makeRunsFromText(text, charPrId, nextId);
   return [
-    `<hp:p id="${id}" paraPrIDRef="${paraPrId}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
+    `<hp:p id="${id}" paraPrIDRef="${paraPrId}" styleIDRef="${styleId}" pageBreak="0" columnBreak="0" merged="0">`,
     `  ${runs}`,
-    LINESEG,
     `</hp:p>`
   ].join("\n");
 }
@@ -6798,7 +9312,23 @@ function makeEmptyParagraph(nextId) {
   return [
     `<hp:p id="${id}" paraPrIDRef="${PARA_NORMAL}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
     `  <hp:run charPrIDRef="${CHAR_NORMAL}"><hp:t/></hp:run>`,
-    LINESEG,
+    `</hp:p>`
+  ].join("\n");
+}
+function makeBlockquoteParagraph(text, nextId) {
+  const id = nextId();
+  const runs = makeRunsFromText(text, CHAR_ITALIC, nextId);
+  return [
+    `<hp:p id="${id}" paraPrIDRef="${PARA_BLOCKQUOTE}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
+    `  ${runs}`,
+    `</hp:p>`
+  ].join("\n");
+}
+function makeHrParagraph(nextId) {
+  const id = nextId();
+  return [
+    `<hp:p id="${id}" paraPrIDRef="${PARA_HR}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
+    `  <hp:run charPrIDRef="${CHAR_NORMAL}"><hp:t/></hp:run>`,
     `</hp:p>`
   ].join("\n");
 }
@@ -6809,8 +9339,7 @@ function headingCharPr(level) {
   return CHAR_H456;
 }
 var BODY_WIDTH = 42520;
-var ROW_HEIGHT = 2400;
-function makeTableCell(text, colAddr, rowAddr, colWidth, isHeader, nextId, styleMap) {
+function makeTableCell(text, colAddr, rowAddr, colWidth, cellHeight, isHeader, nextId, styleMap) {
   let charPr;
   let borderFill = "3";
   if (styleMap) {
@@ -6820,20 +9349,28 @@ function makeTableCell(text, colAddr, rowAddr, colWidth, isHeader, nextId, style
   } else {
     charPr = isHeader ? CHAR_BOLD : CHAR_NORMAL;
   }
-  const paraId = nextId();
   const subId = nextId();
+  const cellHorzsize = Math.max(1e3, colWidth - 2e3);
+  const segments = text.split(/<br\s*\/?>/i);
+  const cellParas = segments.map((seg) => {
+    const pid = nextId();
+    return [
+      `    <hp:p id="${pid}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
+      `      ${makeRunsFromText(seg, charPr, nextId)}`,
+      estimateCellLineseg(seg, cellHorzsize),
+      `    </hp:p>`
+    ].join("\n");
+  }).join("\n");
   return [
     `<hp:tc name="" header="${isHeader ? 1 : 0}" hasMargin="0" protect="0" editable="0" dirty="1" borderFillIDRef="${borderFill}">`,
     `  <hp:subList id="${subId}" textDirection="HORIZONTAL" lineWrap="BREAK" vertAlign="CENTER"`,
     `             linkListIDRef="0" linkListNextIDRef="0" textWidth="0" textHeight="0"`,
     `             hasTextRef="0" hasNumRef="0">`,
-    `    <hp:p id="${paraId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
-    `      <hp:run charPrIDRef="${charPr}"><hp:t${text ? `>${escapeXml(text)}</hp:t` : "/"}></hp:run>`,
-    `    </hp:p>`,
+    cellParas,
     `  </hp:subList>`,
     `  <hp:cellAddr colAddr="${colAddr}" rowAddr="${rowAddr}"/>`,
     `  <hp:cellSpan colSpan="1" rowSpan="1"/>`,
-    `  <hp:cellSz width="${colWidth}" height="${ROW_HEIGHT}"/>`,
+    `  <hp:cellSz width="${colWidth}" height="${cellHeight}"/>`,
     `  <hp:cellMargin left="1000" right="1000" top="500" bottom="500"/>`,
     `</hp:tc>`
   ].join("\n");
@@ -6843,10 +9380,21 @@ function makeTable(rows, nextId, styleMap) {
   const colCnt = rows[0].length;
   const colWidth = Math.floor(BODY_WIDTH / colCnt);
   const totalWidth = colWidth * colCnt;
-  const totalHeight = ROW_HEIGHT * rows.length;
+  const cellHorzsize = Math.max(1e3, colWidth - 2e3);
+  const rowHeights = rows.map((row) => {
+    const maxTotalLines = Math.max(1, ...row.map((cell) => {
+      return cell.split(/<br\s*\/?>/i).reduce((sum, seg) => {
+        const plain = seg.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+        const charsPerLine = Math.max(1, Math.floor(cellHorzsize / CHAR_HWP));
+        return sum + Math.max(1, Math.ceil(plain.length / charsPerLine));
+      }, 0);
+    }));
+    return maxTotalLines * LINE_HWP + 1e3;
+  });
+  const totalHeight = rowHeights.reduce((s, h) => s + h, 0);
   const trElements = rows.map(
     (row, rowIdx) => `<hp:tr>
-${row.map((cell, colIdx) => makeTableCell(cell, colIdx, rowIdx, colWidth, rowIdx === 0, nextId, styleMap)).join("\n")}
+${row.map((cell, colIdx) => makeTableCell(cell, colIdx, rowIdx, colWidth, rowHeights[rowIdx], rowIdx === 0, nextId, styleMap)).join("\n")}
 </hp:tr>`
   ).join("\n");
   const tableId = nextId();
@@ -6867,7 +9415,7 @@ ${row.map((cell, colIdx) => makeTableCell(cell, colIdx, rowIdx, colWidth, rowIdx
     trElements,
     `</hp:tbl>`,
     `</hp:run>`,
-    LINESEG,
+    makeLineseg(totalWidth, totalHeight),
     `</hp:p>`
   ].join("\n");
 }
@@ -6892,6 +9440,20 @@ function parseMarkdownToBlocks(md) {
       i++;
       continue;
     }
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+      blocks.push({ type: "hr" });
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith(">")) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].trim().startsWith(">")) {
+        quoteLines.push(lines[i].trim().replace(/^>\s?/, ""));
+        i++;
+      }
+      blocks.push({ type: "blockquote", text: quoteLines.join(" ") });
+      continue;
+    }
     const hm = trimmed.match(/^(#{1,6})\s+(.+)$/);
     if (hm) {
       blocks.push({ type: "heading", text: hm[2].trim(), level: hm[1].length });
@@ -6951,35 +9513,108 @@ function parseMarkdownToBlocks(md) {
       continue;
     }
     const paraLines = [];
-    while (i < lines.length && lines[i].trim() && !lines[i].trim().startsWith("#") && !lines[i].trim().startsWith("|") && !/^\s*[-*+]\s/.test(lines[i]) && !/^\s*\d+\.\s/.test(lines[i]) && !lines[i].trim().startsWith("```") && !lines[i].trim().match(/^!\[[^\]]*\]\([^)]+\)$/)) paraLines.push(lines[i++].trim());
+    while (i < lines.length && lines[i].trim() && !lines[i].trim().startsWith("#") && !lines[i].trim().startsWith("|") && !lines[i].trim().startsWith(">") && !/^\s*[-*+]\s/.test(lines[i]) && !/^\s*\d+\.\s/.test(lines[i]) && !lines[i].trim().startsWith("```") && !lines[i].trim().match(/^!\[[^\]]*\]\([^)]+\)$/) && !/^(-{3,}|\*{3,}|_{3,})$/.test(lines[i].trim())) paraLines.push(lines[i++].trim());
     if (paraLines.length > 0) blocks.push({ type: "paragraph", text: paraLines.join(" ") });
   }
   return blocks;
 }
+function getImageDimensions(data) {
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) {
+    if (data.length < 24) return null;
+    const w = (data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19]) >>> 0;
+    const h = (data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23]) >>> 0;
+    return w > 0 && h > 0 ? { width: w, height: h } : null;
+  }
+  if (data[0] === 255 && data[1] === 216) {
+    let i = 2;
+    while (i < data.length - 8) {
+      if (data[i] !== 255) break;
+      const marker = data[i + 1];
+      if (marker >= 192 && marker <= 195) {
+        const h = data[i + 5] << 8 | data[i + 6];
+        const w = data[i + 7] << 8 | data[i + 8];
+        return w > 0 && h > 0 ? { width: w, height: h } : null;
+      }
+      if (marker === 217 || marker === 1 || marker >= 208 && marker <= 215) {
+        i += 2;
+        continue;
+      }
+      const segLen = data[i + 2] << 8 | data[i + 3];
+      if (segLen < 2) break;
+      i += 2 + segLen;
+    }
+  }
+  return null;
+}
+function calcHwpSize(width, height) {
+  if (width <= 0 || height <= 0) return { widthHwp: 28346, heightHwp: 19843 };
+  const HWP_PER_PIXEL = 7200 / 96;
+  const naturalW = Math.round(width * HWP_PER_PIXEL);
+  const naturalH = Math.round(height * HWP_PER_PIXEL);
+  const maxWidthHwp = 28346;
+  if (naturalW <= maxWidthHwp) {
+    return { widthHwp: naturalW, heightHwp: naturalH };
+  }
+  const ratio = height / width;
+  return { widthHwp: maxWidthHwp, heightHwp: Math.round(maxWidthHwp * ratio) };
+}
 function mimeToFormat(mimeType) {
   if (mimeType.includes("jpeg") || mimeType.includes("jpg")) return "JPG";
   if (mimeType.includes("gif")) return "GIF";
   if (mimeType.includes("bmp")) return "BMP";
   return "PNG";
 }
-function makeImageParagraph(binDataId, nextId, widthHwp = 28346, heightHwp = 19843) {
+function makeImageParagraph(ref, nextId, widthHwp = 28346, heightHwp = 19843, naturalWidth, naturalHeight) {
   const paraId = nextId();
-  return [
-    `<hp:p id="${paraId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
-    `  <hp:run charPrIDRef="0">`,
-    `    <hp:pic name="" zOrder="0" numberingType="NONE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES"`,
-    `            lock="0" dropcapstyle="None" pageBreak="CELL">`,
-    `      <hp:instSz width="${widthHwp}" height="${heightHwp}" widthRelTo="ABSOLUTE" heightRelTo="ABSOLUTE" protect="0"/>`,
+  const picId = nextId();
+  const natW = naturalWidth || widthHwp;
+  const natH = naturalHeight || heightHwp;
+  const cx = Math.round(widthHwp / 2);
+  const cy = Math.round(heightHwp / 2);
+  const imgLineseg = [
+    `  <hp:linesegarray>`,
+    `    <hp:lineseg textpos="0" vertpos="0" vertsize="${heightHwp}" textheight="${heightHwp}"`,
+    `               baseline="${Math.round(heightHwp * 0.85)}" spacing="600"`,
+    `               horzpos="0" horzsize="42520" flags="393216"/>`,
+    `  </hp:linesegarray>`
+  ].join("\n");
+  const pic = [
+    `    <hp:pic id="${picId}" zOrder="0" numberingType="NONE" textWrap="SQUARE" textFlow="BOTH_SIDES"`,
+    `            lock="0" dropcapstyle="None" href="" groupLevel="0" instid="0" reverse="0">`,
+    `      <hp:offset x="0" y="0"/>`,
+    `      <hp:orgSz width="${widthHwp}" height="${heightHwp}"/>`,
+    `      <hp:curSz width="${widthHwp}" height="${heightHwp}"/>`,
+    `      <hp:flip horizontal="0" vertical="0"/>`,
+    `      <hp:rotationInfo angle="0" centerX="${cx}" centerY="${cy}" rotateimage="1"/>`,
+    `      <hp:renderingInfo>`,
+    `        <hc:transMatrix e1="1" e2="0" e3="0" e4="0" e5="1" e6="0"/>`,
+    `        <hc:scaMatrix e1="1" e2="0" e3="0" e4="0" e5="1" e6="0"/>`,
+    `        <hc:rotMatrix e1="1" e2="0" e3="0" e4="0" e5="1" e6="0"/>`,
+    `      </hp:renderingInfo>`,
+    `      <hc:img binaryItemIDRef="${ref}" bright="0" contrast="0" effect="REAL_PIC" alpha="0"/>`,
+    `      <hp:imgRect>`,
+    `        <hc:pt0 x="0" y="0"/>`,
+    `        <hc:pt1 x="${widthHwp}" y="0"/>`,
+    `        <hc:pt2 x="${widthHwp}" y="${heightHwp}"/>`,
+    `        <hc:pt3 x="0" y="${heightHwp}"/>`,
+    `      </hp:imgRect>`,
+    `      <hp:imgClip left="0" right="${natW}" top="0" bottom="${natH}"/>`,
+    `      <hp:inMargin left="0" right="0" top="0" bottom="0"/>`,
+    `      <hp:imgDim dimwidth="${natW}" dimheight="${natH}"/>`,
+    `      <hp:effects/>`,
+    `      <hp:sz width="${widthHwp}" widthRelTo="ABSOLUTE" height="${heightHwp}" heightRelTo="ABSOLUTE" protect="0"/>`,
     `      <hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0"`,
-    `             holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="COLUMN"`,
+    `             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:content binaryItemIDRef="${binDataId}"/>`,
-    `      <hp:imgRect left="0" top="0" right="${widthHwp}" bottom="${heightHwp}"/>`,
-    `      <hp:imgClip left="0" top="0" right="${widthHwp}" bottom="${heightHwp}"/>`,
-    `    </hp:pic>`,
+    `    </hp:pic>`
+  ].join("\n");
+  return [
+    `<hp:p id="${paraId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
+    `  <hp:run charPrIDRef="0">`,
+    pic,
     `  </hp:run>`,
-    LINESEG,
+    imgLineseg,
     `</hp:p>`
   ].join("\n");
 }
@@ -6991,57 +9626,51 @@ function makeCodeParagraphs(code, nextId) {
     return [
       `<hp:p id="${id}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
       `  <hp:run charPrIDRef="${CHAR_CODE}"><hp:t>${safe}</hp:t></hp:run>`,
-      LINESEG,
       `</hp:p>`
     ].join("\n");
   }).join("\n");
 }
-function generateSectionXml(blocks, styleMap, imageMap) {
+function generateSectionXml(blocks, styleMap, imageMap, imageDimsMap, secPrXml, colPrXml, masterPageCnt = 0) {
   const nextId = makeIdGen();
   const firstId = nextId();
   const defaultCharPr = styleMap ? styleMap.body.charPr : CHAR_NORMAL;
   const defaultParaPr = styleMap ? styleMap.body.paraPr : PARA_NORMAL;
+  const secPrContent = secPrXml ? secPrXml.replace(/masterPageCnt="\d+"/, `masterPageCnt="${masterPageCnt}"`) : [
+    `<hp:secPr id="" textDirection="HORIZONTAL" spaceColumns="1134" tabStop="8000" tabStopVal="4000" tabStopUnit="HWPUNIT" outlineShapeIDRef="1" memoShapeIDRef="0" textVerticalWidthHead="0" masterPageCnt="${masterPageCnt}">`,
+    `  <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="WIDELY" width="59528" height="84186" gutterType="LEFT_ONLY">`,
+    `    <hp:margin header="4252" footer="4252" gutter="0" left="8504" right="8504" top="8504" bottom="8504"/>`,
+    `  </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="283" belowLine="567" aboveLine="850"/>`,
+    `    <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="14692344" type="SOLID" width="0.12 mm" color="#000000"/>`,
+    `    <hp:noteSpacing betweenNotes="0" belowLine="567" aboveLine="850"/>`,
+    `    <hp:numbering type="CONTINUOUS" newNum="1"/>`,
+    `    <hp:placement place="END_OF_DOCUMENT" beneathText="0"/>`,
+    `  </hp:endNotePr>`,
+    `</hp:secPr>`
+  ].join("\n");
+  const colPrContent = colPrXml || `<hp:ctrl>
+  <hp:colPr id="" type="NEWSPAPER" layout="LEFT" colCount="1" sameSz="1" sameGap="0"/>
+</hp:ctrl>`;
   const secPrBlock = [
     `<hp:p id="${firstId}" paraPrIDRef="0" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">`,
     `  <hp:run charPrIDRef="0">`,
-    `    <hp:secPr id="" textDirection="HORIZONTAL" spaceColumns="1134" tabStop="8000" tabStopVal="4000" tabStopUnit="HWPUNIT" outlineShapeIDRef="1" 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="WIDELY" width="59528" height="84186" gutterType="LEFT_ONLY">`,
-    `        <hp:margin header="4252" footer="4252" gutter="0" left="8504" right="8504" top="8504" bottom="8504"/>`,
-    `      </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="283" belowLine="567" aboveLine="850"/>`,
-    `        <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="14692344" type="SOLID" width="0.12 mm" color="#000000"/>`,
-    `        <hp:noteSpacing betweenNotes="0" belowLine="567" aboveLine="850"/>`,
-    `        <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>`,
+    secPrContent,
+    colPrContent,
     `  </hp:run>`,
     `  <hp:run charPrIDRef="0"><hp:t/></hp:run>`,
-    LINESEG,
+    makeLineseg(42520, 1e3),
     `</hp:p>`
   ].join("\n");
   const bodyParts = [];
@@ -7053,23 +9682,26 @@ function generateSectionXml(blocks, styleMap, imageMap) {
         const level = block.level || 1;
         let charPrId;
         let paraPrId;
+        let styleId = "0";
         if (styleMap) {
           const blockType = level === 1 ? "h1" : level === 2 ? "h2" : level === 3 ? "h3" : "h4";
           const style = getStyleForBlock(styleMap, blockType);
           charPrId = style.charPr;
           paraPrId = style.paraPr || defaultParaPr;
+          styleId = style.styleId ?? "0";
         } else {
           charPrId = headingCharPr(level);
           paraPrId = PARA_NORMAL;
         }
-        bodyParts.push(makeParagraph(block.text || "", charPrId, paraPrId, nextId));
+        bodyParts.push(makeParagraph(block.text || "", charPrId, paraPrId, nextId, styleId));
         break;
       }
       case "paragraph": {
         if (block.text) {
           const charPrId = styleMap ? styleMap.body.charPr : CHAR_NORMAL;
           const paraPrId = styleMap ? styleMap.body.paraPr : PARA_NORMAL;
-          bodyParts.push(makeParagraph(block.text, charPrId, paraPrId, nextId));
+          const styleId = styleMap ? styleMap.body.styleId ?? "0" : "0";
+          bodyParts.push(makeParagraph(block.text, charPrId, paraPrId, nextId, styleId));
         } else {
           bodyParts.push(makeEmptyParagraph(nextId));
         }
@@ -7079,6 +9711,12 @@ function generateSectionXml(blocks, styleMap, imageMap) {
         bodyParts.push(makeCodeParagraphs(block.text || "", nextId));
         break;
       }
+      case "blockquote":
+        if (block.text) bodyParts.push(makeBlockquoteParagraph(block.text, nextId));
+        break;
+      case "hr":
+        bodyParts.push(makeHrParagraph(nextId));
+        break;
       case "empty":
         bodyParts.push(makeEmptyParagraph(nextId));
         break;
@@ -7111,9 +9749,16 @@ function generateSectionXml(blocks, styleMap, imageMap) {
         break;
       case "image": {
         const src = block.src || "";
-        const binId = imageMap?.get(src);
-        if (binId !== void 0) {
-          bodyParts.push(makeImageParagraph(binId, nextId));
+        const srcBasename = src.includes("/") || src.includes("\\") ? src.split(/[\\/]/).pop() : src;
+        const extLower = srcBasename.toLowerCase();
+        if (extLower.endsWith(".wmf") || extLower.endsWith(".emf")) break;
+        const ref = imageMap?.get(src) ?? imageMap?.get(srcBasename);
+        if (ref !== void 0) {
+          const dims = imageDimsMap?.get(ref);
+          const { widthHwp, heightHwp } = dims ? calcHwpSize(dims.width, dims.height) : { widthHwp: 28346, heightHwp: 19843 };
+          const natW = dims ? Math.round(dims.width * 75) : widthHwp;
+          const natH = dims ? Math.round(dims.height * 75) : heightHwp;
+          bodyParts.push(makeImageParagraph(ref, nextId, widthHwp, heightHwp, natW, natH));
         } else {
           const alt = block.alt || src || "(\uC774\uBBF8\uC9C0)";
           bodyParts.push(makeParagraph(`[\uC774\uBBF8\uC9C0: ${alt}]`, CHAR_NORMAL, PARA_NORMAL, nextId));
@@ -7140,44 +9785,86 @@ async function markdownToHwpx(markdown, options) {
   const warnings = opts.warnings || [];
   let styleMap = null;
   let headerXml = HEADER_XML;
-  let templateZip = null;
+  let secPrXml;
+  let colPrXml;
+  let masterpages = [];
   if (opts.templateArrayBuffer) {
     try {
       const templateStyles = await extractTemplateStyles(opts.templateArrayBuffer);
       styleMap = createStyleMap(templateStyles, warnings);
-      templateZip = new JSZip6();
-      await templateZip.loadAsync(opts.templateArrayBuffer);
-      const headerFile = templateZip.file("Contents/header.xml");
-      if (headerFile) {
-        headerXml = await headerFile.async("text");
-      }
+      if (templateStyles.headerXml) headerXml = templateStyles.headerXml;
+      if (templateStyles.secPrXml) secPrXml = templateStyles.secPrXml;
+      if (templateStyles.colPrXml) colPrXml = templateStyles.colPrXml;
+      if (templateStyles.masterpages?.length) masterpages = templateStyles.masterpages;
     } catch (err) {
       const msg = err instanceof Error ? err.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
       warnings.push(`[warn] \uD15C\uD50C\uB9BF \uCC98\uB9AC \uC2E4\uD328: ${msg}. \uAE30\uBCF8 \uC2A4\uD0C0\uC77C \uC0AC\uC6A9`);
     }
   }
   const imageMap = /* @__PURE__ */ new Map();
+  const imageDimsMap = /* @__PURE__ */ new Map();
   const binDataEntries = [];
+  const usedRefs = /* @__PURE__ */ new Set();
   if (opts.images && opts.images.length > 0) {
-    for (let idx = 0; idx < opts.images.length; idx++) {
-      const img = opts.images[idx];
-      const binId = idx + 1;
-      const format = mimeToFormat(img.mimeType);
+    for (const img of opts.images) {
       const nameWithoutExt = img.filename.replace(/\.[^.]+$/, "");
-      const binFilename = `BinData/${nameWithoutExt}`;
-      imageMap.set(img.filename, binId);
-      binDataEntries.push({ id: binId, format, filename: binFilename });
+      const format = mimeToFormat(img.mimeType);
+      const ext = format.toLowerCase() === "jpg" ? "jpg" : format.toLowerCase();
+      let ref = nameWithoutExt;
+      let counter = 1;
+      while (usedRefs.has(ref)) ref = `${nameWithoutExt}_${counter++}`;
+      usedRefs.add(ref);
+      const dims = getImageDimensions(img.data) || void 0;
+      binDataEntries.push({ ref, zipPath: `BinData/${ref}.${ext}`, data: img.data, dims });
+      if (dims) imageDimsMap.set(ref, dims);
+      imageMap.set(img.filename, ref);
+    }
+  }
+  const allBlocks = parseMarkdownToBlocks(markdown);
+  for (const block of allBlocks) {
+    if (block.type === "image" && block.src?.startsWith("data:") && !imageMap.has(block.src)) {
+      const commaIdx = block.src.indexOf(",");
+      if (commaIdx === -1) continue;
+      const header = block.src.slice(0, commaIdx);
+      const b64 = block.src.slice(commaIdx + 1);
+      const mimeMatch = header.match(/data:([^;]+)/);
+      const mimeType = mimeMatch?.[1] || "image/png";
+      const format = mimeToFormat(mimeType);
+      const ext = format.toLowerCase() === "jpg" ? "jpg" : format.toLowerCase();
+      const data = Buffer.from(b64, "base64");
+      const ref = `datauri_${binDataEntries.length + 1}`;
+      const dims = getImageDimensions(data) || void 0;
+      imageMap.set(block.src, ref);
+      binDataEntries.push({ ref, zipPath: `BinData/${ref}.${ext}`, data, dims });
+      if (dims) imageDimsMap.set(ref, dims);
     }
   }
-  if (binDataEntries.length > 0) {
-    const binXml = binDataEntries.map((e) => `    <hh:binData id="${e.id}" type="LINK" format="${e.format}" compress="NO" access="PUBLIC"><hh:sourceFile href="${e.filename}"/></hh:binData>`).join("\n");
-    headerXml = headerXml.replace("</hh:refList>", `${binXml}
-  </hh:refList>`);
-  }
   const sectionXml = generateSectionXml(
-    parseMarkdownToBlocks(markdown),
+    allBlocks,
     styleMap || void 0,
-    imageMap.size > 0 ? imageMap : void 0
+    imageMap.size > 0 ? imageMap : void 0,
+    imageDimsMap.size > 0 ? imageDimsMap : void 0,
+    secPrXml,
+    colPrXml,
+    masterpages.length
+  );
+  const formatToMediaType = (zipPath) => {
+    const ext = zipPath.split(".").pop()?.toLowerCase() || "";
+    if (ext === "png") return "image/png";
+    if (ext === "gif") return "image/gif";
+    if (ext === "bmp") return "image/bmp";
+    return "image/jpg";
+  };
+  const imageItems = binDataEntries.map((e) => `    <opf:item id="${e.ref}" href="${e.zipPath}" media-type="${formatToMediaType(e.zipPath)}" isEmbeded="1"/>`).join("\n");
+  const masterpageItems = masterpages.map((mp) => {
+    const id = mp.filename.replace("Contents/", "").replace(".xml", "");
+    return `    <opf:item id="${id}" href="${mp.filename}" media-type="application/xml"/>`;
+  }).join("\n");
+  const extraItems = [imageItems, masterpageItems].filter(Boolean).join("\n");
+  const contentHpf = CONTENT_HPF.replace(
+    `    <opf:item id="header"`,
+    extraItems ? `${extraItems}
+    <opf:item id="header"` : `    <opf:item id="header"`
   );
   const zip = new JSZip6();
   zip.file("mimetype", "application/hwp+zip", { compression: "STORE" });
@@ -7187,20 +9874,173 @@ async function markdownToHwpx(markdown, options) {
   zip.file("version.xml", VERSION_XML);
   zip.file("settings.xml", SETTINGS_XML);
   zip.file("Preview/PrvText.txt", "");
-  zip.file("Contents/content.hpf", CONTENT_HPF);
+  zip.file("Contents/content.hpf", contentHpf);
   zip.file("Contents/header.xml", headerXml);
   zip.file("Contents/section0.xml", sectionXml);
-  if (opts.images && opts.images.length > 0) {
-    for (const img of opts.images) {
-      const nameWithoutExt = img.filename.replace(/\.[^.]+$/, "");
-      zip.file(`BinData/${nameWithoutExt}`, img.data);
+  for (const mp of masterpages) {
+    zip.file(mp.filename, mp.content);
+  }
+  for (const entry of binDataEntries) {
+    if (entry.data) {
+      zip.file(entry.zipPath, entry.data);
     }
   }
   return await zip.generateAsync({ type: "arraybuffer" });
 }
 
+// src/xlsx/generator.ts
+import ExcelJS from "exceljs";
+function mimeToExtension(mimeType) {
+  if (mimeType.includes("jpeg") || mimeType.includes("jpg")) return "jpeg";
+  if (mimeType.includes("gif")) return "gif";
+  return "png";
+}
+function buildImageMap(images) {
+  const map = /* @__PURE__ */ new Map();
+  if (!images) return map;
+  for (const img of images) map.set(img.filename, img);
+  return map;
+}
+async function fillBodySheet(sheet, workbook, blocks, imageMap) {
+  sheet.getColumn(1).width = 80;
+  for (const block of blocks) {
+    switch (block.type) {
+      case "heading": {
+        const level = block.level || 1;
+        const size = level === 1 ? 20 : level === 2 ? 16 : level === 3 ? 14 : 12;
+        const row = sheet.addRow([block.text || ""]);
+        row.getCell(1).font = { bold: true, size };
+        row.getCell(1).alignment = { wrapText: true };
+        break;
+      }
+      case "paragraph": {
+        const row = sheet.addRow([block.text || ""]);
+        row.getCell(1).alignment = { wrapText: true };
+        break;
+      }
+      case "code": {
+        const lines = (block.text || "").split("\n");
+        for (const line of lines) {
+          const row = sheet.addRow([line || " "]);
+          row.getCell(1).font = { name: "Courier New", size: 9 };
+          row.getCell(1).fill = {
+            type: "pattern",
+            pattern: "solid",
+            fgColor: { argb: "FFF2F2F2" }
+          };
+        }
+        break;
+      }
+      case "blockquote": {
+        const row = sheet.addRow([block.text || ""]);
+        row.getCell(1).font = { italic: true, color: { argb: "FF888888" } };
+        row.getCell(1).alignment = { wrapText: true };
+        break;
+      }
+      case "hr": {
+        const row = sheet.addRow([""]);
+        row.getCell(1).border = {
+          bottom: { style: "medium", color: { argb: "FF888888" } }
+        };
+        break;
+      }
+      case "empty": {
+        sheet.addRow([""]);
+        break;
+      }
+      case "list": {
+        for (const item of block.items || []) {
+          const indent = "  ".repeat(item.indent);
+          const bullet = block.listType === "ordered" ? `${item.indent + 1}. ` : ["\u2022 ", "\u25E6 ", "\u25AA "][Math.min(item.indent, 2)];
+          const row = sheet.addRow([`${indent}${bullet}${item.text}`]);
+          row.getCell(1).alignment = { wrapText: true };
+        }
+        break;
+      }
+      case "image": {
+        const src = block.src || "";
+        const img = imageMap.get(src);
+        if (img) {
+          const currentRow = sheet.rowCount + 1;
+          const ext = mimeToExtension(img.mimeType);
+          const imageId = workbook.addImage({ base64: Buffer.from(img.data).toString("base64"), extension: ext });
+          sheet.addRow([""]);
+          sheet.addImage(imageId, {
+            tl: { col: 0, row: currentRow - 1 },
+            ext: { width: 300, height: 200 }
+          });
+          sheet.getRow(currentRow).height = 155;
+        } else {
+          const alt = block.alt || src || "(\uC774\uBBF8\uC9C0)";
+          const row = sheet.addRow([`[\uC774\uBBF8\uC9C0: ${alt}]`]);
+          row.getCell(1).font = { italic: true, color: { argb: "FF999999" } };
+        }
+        break;
+      }
+    }
+  }
+}
+function fillTableSheet(sheet, rows) {
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const cells = rows[rowIdx];
+    const row = sheet.addRow(cells);
+    cells.forEach((cell, colIdx) => {
+      const col = sheet.getColumn(colIdx + 1);
+      col.width = Math.max(col.width ?? 10, Math.min(cell.length + 4, 40));
+    });
+    if (rowIdx === 0) {
+      row.eachCell((cell) => {
+        cell.font = { bold: true };
+        cell.fill = { type: "pattern", pattern: "solid", fgColor: { argb: "FFD9E1F2" } };
+        cell.border = {
+          top: { style: "thin" },
+          bottom: { style: "thin" },
+          left: { style: "thin" },
+          right: { style: "thin" }
+        };
+        cell.alignment = { wrapText: true };
+      });
+    } else {
+      row.eachCell((cell) => {
+        cell.border = {
+          top: { style: "thin" },
+          bottom: { style: "thin" },
+          left: { style: "thin" },
+          right: { style: "thin" }
+        };
+        cell.alignment = { wrapText: true };
+      });
+    }
+  }
+}
+async function markdownToXlsx(markdown, options) {
+  const warnings = options?.warnings || [];
+  const imageMap = buildImageMap(options?.images);
+  const blocks = parseMarkdownToBlocks(markdown);
+  const workbook = new ExcelJS.Workbook();
+  workbook.created = /* @__PURE__ */ new Date();
+  const tableBlocks = blocks.filter((b) => b.type === "table");
+  const bodyBlocks = blocks.filter((b) => b.type !== "table");
+  const hasBodyContent = bodyBlocks.some((b) => b.type !== "empty");
+  if (hasBodyContent) {
+    const bodySheet = workbook.addWorksheet("\uBCF8\uBB38");
+    await fillBodySheet(bodySheet, workbook, bodyBlocks, imageMap);
+  }
+  tableBlocks.forEach((block, idx) => {
+    if (!block.rows?.length) return;
+    const sheet = workbook.addWorksheet(`Table ${idx + 1}`);
+    fillTableSheet(sheet, block.rows);
+  });
+  if (workbook.worksheets.length === 0) {
+    workbook.addWorksheet("\uBCF8\uBB38");
+    warnings.push("[warn] \uBCC0\uD658\uD560 \uB0B4\uC6A9\uC774 \uC5C6\uC5B4 \uBE48 \uC2DC\uD2B8\uB97C \uC0DD\uC131\uD588\uC2B5\uB2C8\uB2E4.");
+  }
+  const buffer = await workbook.xlsx.writeBuffer();
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}
+
 // src/index.ts
-async function parse(input, options) {
+async function parse2(input, options) {
   let buffer;
   if (typeof input === "string") {
     try {
@@ -7288,11 +10128,17 @@ export {
   isPdfFile,
   isZipFile,
   markdownToHwpx,
-  parse,
+  markdownToXlsx,
+  parse2 as parse,
   parseDocx,
   parseHwp,
   parseHwpx,
   parsePdf,
   parseXlsx
 };
+/*! Bundled license information:
+
+cfb/cfb.js:
+  (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
+*/
 //# sourceMappingURL=index.js.map