kordoc 4.14.2 → 4.14.4

package/dist/redact-doc-QBHNJ2BU.js

@@ -0,0 +1,1284 @@
+#!/usr/bin/env node
+import {
+  compressWithTail,
+  parse,
+  replaceOleStream,
+  wipeFreeSectors
+} from "./chunk-XVXHXQIO.js";
+import {
+  allLinesegRemovalSplices,
+  findElementEnd,
+  patchZipEntries,
+  scanSectionXml
+} from "./chunk-HIJUKZHM.js";
+import {
+  DEFAULT_REDACT_RULES,
+  mdMarkerRanges,
+  nameParticleAt,
+  normalizeForDetect,
+  redactMarkdown,
+  redactText
+} from "./chunk-DPWWXUOG.js";
+import "./chunk-VJIL6PIL.js";
+import {
+  FLAG_COMPRESSED,
+  FLAG_DISTRIBUTION,
+  FLAG_DRM,
+  FLAG_ENCRYPTED,
+  TAG_CTRL_DATA,
+  TAG_CTRL_HEADER,
+  TAG_PARA_TEXT,
+  decompressStream,
+  detectFormat,
+  detectOle2Format,
+  detectZipFormat,
+  isExtendedOnlyCtrlChar,
+  parseFileHeader,
+  readRecords
+} from "./chunk-D4U2TXDC.js";
+import "./chunk-7FCNOKOR.js";
+import "./chunk-6BWU6SQX.js";
+import "./chunk-MOL7MDBG.js";
+import "./chunk-YAKC46HZ.js";
+import "./chunk-NLU6LBLY.js";
+import "./chunk-V3DX4DUF.js";
+import "./chunk-TITDJWVZ.js";
+
+// src/redact-scrub.ts
+import { createRequire } from "module";
+import JSZip from "jszip";
+import { deflateSync, inflateSync } from "zlib";
+var require2 = createRequire(import.meta.url);
+var CFB = require2("cfb");
+function cannotContainPii(text) {
+  if (text.includes("@") || text.includes("\uFF20")) return false;
+  let digits = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 48 && c <= 57 || c >= 65296 && c <= 65305) {
+      if (++digits >= 4) return false;
+    }
+  }
+  return true;
+}
+var LIT_KEY = 6;
+var LIT_KEY_SHORT = 2;
+var literalIndex = /* @__PURE__ */ new WeakMap();
+function literalBuckets(lits) {
+  let m = literalIndex.get(lits);
+  if (!m) {
+    m = { long: /* @__PURE__ */ new Map(), short: /* @__PURE__ */ new Map() };
+    for (const l of [...lits].sort((a, b) => b.norm.length - a.norm.length)) {
+      const short = l.norm.length < LIT_KEY;
+      const k = l.norm.slice(0, short ? LIT_KEY_SHORT : LIT_KEY);
+      const map = short ? m.short : m.long;
+      const list = map.get(k);
+      if (list) list.push(l);
+      else map.set(k, [l]);
+    }
+    literalIndex.set(lits, m);
+  }
+  return m;
+}
+var isAlnum = (c) => c !== void 0 && /[0-9A-Za-z]/.test(c);
+var isHangul = (c) => c !== void 0 && c >= "\uAC00" && c <= "\uD7A3";
+function literalBoundaryOk(norm, i, l) {
+  const end = i + l.norm.length;
+  if (isAlnum(norm[end - 1]) && isAlnum(norm[end])) return false;
+  if (isHangul(l.norm[0]) && isHangul(norm[i - 1])) return false;
+  return !isHangul(l.norm[l.norm.length - 1]) || !isHangul(norm[end]) || nameParticleAt(norm, end);
+}
+function findLiterals(norm, lits) {
+  const out = [];
+  if (lits.length === 0) return out;
+  const { long, short } = literalBuckets(lits);
+  const hit = (cand, i) => cand?.find((l) => norm.startsWith(l.norm, i) && literalBoundaryOk(norm, i, l));
+  for (let i = 0; i + LIT_KEY_SHORT <= norm.length; i++) {
+    if (isAlnum(norm[i - 1]) && isAlnum(norm[i])) continue;
+    const lit = (long.size > 0 ? hit(long.get(norm.slice(i, i + LIT_KEY)), i) : void 0) ?? (short.size > 0 ? hit(short.get(norm.slice(i, i + LIT_KEY_SHORT)), i) : void 0);
+    if (!lit) continue;
+    out.push({ index: i, lit });
+    i += lit.norm.length - 1;
+  }
+  return out;
+}
+var TEXT_RULES = /* @__PURE__ */ new Set(["name", "address"]);
+function binaryCtx(ctx) {
+  return ctx.rules.some((r) => TEXT_RULES.has(r)) ? { ...ctx, rules: ctx.rules.filter((r) => !TEXT_RULES.has(r)) } : ctx;
+}
+function findPii(text, ctx) {
+  const textRules = ctx.rules.some((r) => TEXT_RULES.has(r));
+  const hits = textRules ? redactText(text, { rules: ctx.rules, maskChar: ctx.maskChar }).hits : text.length < 5 || cannotContainPii(text) ? [] : redactText(text, { rules: ctx.rules, maskChar: ctx.maskChar }).hits;
+  if (ctx.literals.length === 0) return hits;
+  for (const { index: i, lit } of findLiterals(normalizeForDetect(text), ctx.literals)) {
+    const end = i + lit.norm.length;
+    if (hits.some((h) => i < h.index + h.length && end > h.index)) continue;
+    let masked = "";
+    for (let k = 0; k < lit.norm.length; k++) masked += lit.masked[k] !== lit.value[k] ? ctx.maskChar : text[i + k];
+    hits.push({ rule: lit.rule, masked, index: i, length: lit.norm.length });
+  }
+  const view = parserView(text);
+  if (view) {
+    for (const { index: i, lit } of findLiterals(normalizeForDetect(view.text), ctx.literals)) {
+      const start = view.pos[i];
+      const end = view.pos[i + lit.norm.length - 1] + 1;
+      if (hits.some((h) => start < h.index + h.length && end > h.index)) continue;
+      const chars = text.slice(start, end).split("");
+      for (let k = 0; k < lit.norm.length; k++) if (lit.masked[k] !== lit.value[k]) chars[view.pos[i + k] - start] = ctx.maskChar;
+      hits.push({ rule: lit.rule, masked: chars.join(""), index: start, length: end - start });
+    }
+  }
+  return hits.sort((a, b) => a.index - b.index);
+}
+function parserView(text) {
+  if (!text.includes(" ")) return null;
+  let squeeze = false;
+  if (text.length <= 400) {
+    const tokens = text.replace(/ {2,}/g, " ").trim().split(" ");
+    const hangul1 = (t) => t.length === 1 && /[\uAC00-\uD7AF\u3131-\u318E]/.test(t);
+    squeeze = tokens.join(" ").length <= 30 && tokens.length >= 3 && tokens.filter(hangul1).length / tokens.length >= 0.7 && !tokens.every((t) => !hangul1(t) || /[년월일시분초]/.test(t));
+  }
+  if (!squeeze && !text.includes("  ")) return null;
+  const pos = [];
+  for (let i = 0; i < text.length; i++) if (text[i] !== " " || !squeeze && text[i - 1] !== " ") pos.push(i);
+  return { text: pos.map((i) => text[i]).join(""), pos };
+}
+function literalsFromMarkdown(markdown, hits) {
+  const out = /* @__PURE__ */ new Map();
+  const lineMarkers = /* @__PURE__ */ new Map();
+  for (const h of hits) {
+    const rawValue = markdown.slice(h.index, h.index + h.length);
+    const lineStart = markdown.lastIndexOf("\n", h.index - 1) + 1;
+    let ranges = lineMarkers.get(lineStart);
+    if (!ranges) {
+      const lineEnd = markdown.indexOf("\n", h.index);
+      ranges = mdMarkerRanges(markdown.slice(lineStart, lineEnd < 0 ? void 0 : lineEnd));
+      lineMarkers.set(lineStart, ranges);
+    }
+    const drop = /* @__PURE__ */ new Set();
+    for (const [ms, me] of ranges) {
+      for (let p = ms + lineStart; p < me + lineStart; p++) if (p >= h.index && p < h.index + h.length) drop.add(p - h.index);
+    }
+    const value = rawValue.split("").filter((_, k) => !drop.has(k)).join("");
+    const masked = h.masked.split("").filter((_, k) => !drop.has(k)).join("");
+    const norm = normalizeForDetect(value);
+    const tooShort = TEXT_RULES.has(h.rule) ? norm.length < 2 : norm.replace(/[^0-9A-Za-z]/g, "").length < 6;
+    if (tooShort || out.has(norm)) continue;
+    out.set(norm, { norm, value, masked, rule: h.rule });
+  }
+  return [...out.values()];
+}
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(data.length, 0);
+  head.write(type, 4, "ascii");
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])), 0);
+  return Buffer.concat([head, data, crc]);
+}
+function blankPng(width, height) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 0;
+  const row = Buffer.alloc(width + 1, 255);
+  row[0] = 0;
+  const raw = Buffer.alloc(row.length * height);
+  for (let y = 0; y < height; y++) row.copy(raw, y * row.length);
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", deflateSync(raw)),
+    pngChunk("IEND", new Uint8Array(0))
+  ]);
+}
+function blankGif(width, height) {
+  const b = Buffer.from([
+    71,
+    73,
+    70,
+    56,
+    57,
+    97,
+    0,
+    0,
+    0,
+    0,
+    128,
+    0,
+    0,
+    // GIF89a, 화면 크기, 전역 팔레트 2색
+    255,
+    255,
+    255,
+    255,
+    255,
+    255,
+    44,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    0,
+    0,
+    // 이미지 1×1 @(0,0)
+    2,
+    2,
+    68,
+    1,
+    0,
+    59
+    // LZW: clear·0·end, 트레일러
+  ]);
+  b.writeUInt16LE(Math.min(width, 65535), 6);
+  b.writeUInt16LE(Math.min(height, 65535), 8);
+  return b;
+}
+function blankPreviewImage(img) {
+  const b = Buffer.from(img.buffer, img.byteOffset, img.byteLength);
+  if (b.length >= 24 && b.readUInt32BE(0) === 2303741511) {
+    const w = b.readUInt32BE(16);
+    const h = b.readUInt32BE(20);
+    if (w > 0 && h > 0 && w <= 8192 && h <= 8192) return blankPng(w, h);
+    return blankPng(1, 1);
+  }
+  if (b.length >= 10 && b.toString("latin1", 0, 3) === "GIF") return blankGif(b.readUInt16LE(6), b.readUInt16LE(8));
+  if (b.length >= 26 && b.toString("latin1", 0, 2) === "BM") {
+    const out = Buffer.from(b);
+    const pixelOffset = out.readUInt32LE(10);
+    if (pixelOffset > 0 && pixelOffset < out.length) out.fill(255, pixelOffset);
+    return out;
+  }
+  return null;
+}
+var isTextUnit = (u) => u >= 32 && u < 127 || u >= 160 && u <= 55295 || u >= 57344 && u <= 65533 || u === 9;
+function isBindingPath(s) {
+  const t = s.trim();
+  return /^\.?\/[^\s]*\//.test(t) || /^[^\s]*\[\d+\][^\s]*\//.test(t) || /[A-Za-z]\.Code@code\.[A-Z]/.test(t);
+}
+function scrubUtf16Runs(buf, ctx, mode, onHit, skipBinding = false) {
+  let changed = false;
+  const mc = ctx.maskChar.charCodeAt(0);
+  const minRun = ctx.literals.some((l) => l.norm.length < 6) ? 2 : 6;
+  const literalOnly = { ...ctx, rules: [] };
+  const binCtx = binaryCtx(ctx);
+  for (let align = 0; align < 2; align++) {
+    let runStart = -1;
+    let text = "";
+    const flush = () => {
+      if (runStart >= 0 && text.length >= minRun && !(skipBinding && isBindingPath(text))) {
+        for (const h of findPii(text, text.length >= 6 ? binCtx : literalOnly)) {
+          onHit(h);
+          if (mode !== "mask") continue;
+          const orig = text.slice(h.index, h.index + h.length);
+          for (let k = 0; k < h.length; k++) {
+            if (h.masked[k] !== orig[k]) {
+              buf.writeUInt16LE(mc, runStart + (h.index + k) * 2);
+              changed = true;
+            }
+          }
+        }
+      }
+      runStart = -1;
+      text = "";
+    };
+    for (let off = align; off + 1 < buf.length; off += 2) {
+      const u = buf.readUInt16LE(off);
+      if (isTextUnit(u)) {
+        if (runStart < 0) runStart = off;
+        text += String.fromCharCode(u);
+      } else flush();
+    }
+    flush();
+  }
+  return changed;
+}
+function scrubAsciiRuns(buf, ctx, mode, onHit) {
+  let changed = false;
+  let runStart = -1;
+  const byteCtx = { ...binaryCtx(ctx), maskChar: "*" };
+  const flush = (end) => {
+    if (runStart >= 0 && end - runStart >= 6) {
+      const text = buf.toString("latin1", runStart, end);
+      for (const h of findPii(text, byteCtx)) {
+        onHit({ ...h, masked: h.masked.split("*").join(ctx.maskChar) });
+        if (mode !== "mask") continue;
+        for (let k = 0; k < h.length; k++) {
+          if (h.masked[k] !== text[h.index + k]) {
+            buf[runStart + h.index + k] = 42;
+            changed = true;
+          }
+        }
+      }
+    }
+    runStart = -1;
+  };
+  for (let i = 0; i < buf.length; i++) {
+    const c = buf[i];
+    if (c >= 32 && c < 127) {
+      if (runStart < 0) runStart = i;
+    } else flush(i);
+  }
+  flush(buf.length);
+  return changed;
+}
+function looksUtf16le(b) {
+  if (b.length < 2 || b.length % 2 !== 0) return false;
+  let text = 0;
+  let asciiHi0 = 0;
+  const n = b.length / 2;
+  for (let i = 0; i < b.length; i += 2) {
+    const u = b[i] | b[i + 1] << 8;
+    if (isTextUnit(u) || u === 10 || u === 13 || u === 65279) text++;
+    if (b[i + 1] === 0 && b[i] !== 0) asciiHi0++;
+  }
+  return text / n >= 0.95 && asciiHi0 > 0;
+}
+function utf8WithOffsets(b, start, end) {
+  const text = [];
+  const at = [];
+  let i = start;
+  while (i < end) {
+    const c = b[i];
+    const len = c < 128 ? 1 : c >= 240 ? 4 : c >= 224 ? 3 : c >= 192 ? 2 : 1;
+    const ch = len === 1 && c >= 128 ? "\uFFFD" : b.toString("utf8", i, Math.min(end, i + len));
+    for (let k = 0; k < ch.length; k++) {
+      text.push(ch[k]);
+      at.push(i);
+    }
+    i += len;
+  }
+  return { text: text.join(""), at };
+}
+function scrubTextBytes(b, start, end, ctx, mode, onHit) {
+  const { text, at } = utf8WithOffsets(b, start, end);
+  let changed = false;
+  for (const h of findPii(text, { ...ctx, maskChar: "*" })) {
+    onHit({ ...h, masked: h.masked.split("*").join(ctx.maskChar) });
+    if (mode !== "mask") continue;
+    for (let k = 0; k < h.length; k++) {
+      const pos = at[h.index + k];
+      if (h.masked[k] !== text[h.index + k] && b[pos] < 128) {
+        b[pos] = 42;
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+var XMP_HEADER = "http://ns.adobe.com/xap/1.0/\0";
+function scrubImageMeta(buf, ctx, mode, onHit) {
+  let changed = false;
+  if (buf.length > 4 && buf[0] === 255 && buf[1] === 216) {
+    for (let o = 2; o + 4 <= buf.length; ) {
+      if (buf[o] !== 255) break;
+      const m = buf[o + 1];
+      if (m === 216 || m === 1 || m >= 208 && m <= 215) {
+        o += 2;
+        continue;
+      }
+      const len = buf.readUInt16BE(o + 2);
+      const segStart = o + 4;
+      const segEnd = Math.min(buf.length, o + 2 + len);
+      if (m === 225 && buf.toString("latin1", segStart, segStart + XMP_HEADER.length) === XMP_HEADER) {
+        if (scrubTextBytes(buf, segStart + XMP_HEADER.length, segEnd, ctx, mode, onHit)) changed = true;
+      } else if (m === 254) {
+        if (scrubTextBytes(buf, segStart, segEnd, ctx, mode, onHit)) changed = true;
+      }
+      if (m === 218) break;
+      o += 2 + len;
+    }
+  } else if (buf.length > 8 && buf.readUInt32BE(0) === 2303741511) {
+    for (let o = 8; o + 12 <= buf.length; ) {
+      const len = buf.readUInt32BE(o);
+      const type = buf.toString("latin1", o + 4, o + 8);
+      const dStart = o + 8;
+      const dEnd = Math.min(buf.length, dStart + len);
+      let chunkChanged = false;
+      if (type === "tEXt" || type === "iTXt") {
+        const k = buf.indexOf(0, dStart);
+        let textStart = k + 1;
+        if (type === "iTXt" && k >= 0) {
+          const compressed = buf[k + 1] === 1;
+          const lang = buf.indexOf(0, k + 3);
+          const trans = lang >= 0 ? buf.indexOf(0, lang + 1) : -1;
+          textStart = trans + 1;
+          if (compressed) {
+            if (mode === "check") {
+              try {
+                for (const h of findPii(inflateSync(buf.subarray(textStart, dEnd)).toString("utf8"), ctx)) onHit(h);
+              } catch {
+              }
+            }
+            textStart = -1;
+          }
+        }
+        if (k >= 0 && textStart > 0 && textStart <= dEnd) chunkChanged = scrubTextBytes(buf, textStart, dEnd, ctx, mode, onHit);
+      } else if (type === "zTXt" && mode === "check") {
+        const k = buf.indexOf(0, dStart);
+        try {
+          for (const h of findPii(inflateSync(buf.subarray(k + 2, dEnd)).toString("latin1"), ctx)) onHit(h);
+        } catch {
+        }
+      }
+      if (chunkChanged) {
+        changed = true;
+        buf.writeUInt32BE(crc32(buf.subarray(o + 4, dEnd)), dEnd);
+      }
+      if (type === "IEND") break;
+      o += 12 + len;
+    }
+  }
+  return changed;
+}
+var OLE_SIG = Buffer.from("d0cf11e0a1b11ae1", "hex");
+function isOleBin(b) {
+  const i = b.indexOf(OLE_SIG);
+  return i >= 0 && i < 16;
+}
+function isMetaImage(b) {
+  return b.length > 3 && b[0] === 255 && b[1] === 216 && b[2] === 255 || b.length > 8 && b.readUInt32BE(0) === 2303741511;
+}
+function isEmf(b) {
+  return b.length > 44 && b.readUInt32LE(0) === 1 && b.readUInt32LE(40) === 1179469088;
+}
+var decodeXmlEntities = (s) => s.replace(/&#x([0-9a-fA-F]+);/g, (e, h) => {
+  const c = parseInt(h, 16);
+  return c <= 1114111 ? String.fromCodePoint(c) : e;
+}).replace(/&#(\d+);/g, (e, d) => {
+  const c = Number(d);
+  return c <= 1114111 ? String.fromCodePoint(c) : e;
+}).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+function checkXmlText(xml, ctx, onHit) {
+  for (const h of findPii(decodeXmlEntities(xml.replace(/(?:<[^>]*>)+/g, " ")), ctx)) onHit(h);
+  for (const m of xml.matchAll(/=\s*"([^"]{5,})"/g)) for (const h of findPii(decodeXmlEntities(m[1]), ctx)) onHit(h);
+}
+async function checkEmbeddedOle(data, ctx, onHit) {
+  let inner;
+  try {
+    inner = CFB.parse(data.subarray(data.indexOf(OLE_SIG)));
+  } catch {
+    scrubUtf16Runs(Buffer.from(data), ctx, "check", onHit);
+    return;
+  }
+  for (let i = 0; i < inner.FullPaths.length; i++) {
+    const e = inner.FileIndex[i];
+    if (e.type !== 2 || !e.content) continue;
+    const c = Buffer.from(e.content);
+    if (c.length >= 4 && c.readUInt32LE(0) === 67324752) {
+      let zip = null;
+      try {
+        zip = await JSZip.loadAsync(c);
+      } catch {
+      }
+      if (!zip) {
+        scrubUtf16Runs(c, ctx, "check", onHit);
+        continue;
+      }
+      for (const [name, z] of Object.entries(zip.files)) {
+        if (z.dir) continue;
+        const b = Buffer.from(await z.async("uint8array"));
+        if (/\.(xml|rels|vml)$/i.test(name)) checkXmlText(b.toString("utf8"), ctx, onHit);
+        else scrubUtf16Runs(b, ctx, "check", onHit);
+      }
+    } else if (/^(?:\xef\xbb\xbf)?\s*<(?:\?xml|[A-Za-z])/.test(c.toString("latin1", 0, 64))) {
+      checkXmlText(c.toString("utf8"), ctx, onHit);
+    } else {
+      scrubUtf16Runs(c, ctx, "check", onHit);
+      if (/(?:^|\/)(?:Workbook|Book)$/.test(inner.FullPaths[i])) scrubAsciiRuns(c, ctx, "check", onHit);
+    }
+  }
+}
+
+// src/redact-hwpx.ts
+import JSZip2 from "jszip";
+var WS_TAGS = /* @__PURE__ */ new Set(["tab", "lineBreak", "br", "fwSpace", "hwSpace", "nbSpace"]);
+var GAP_SEPARATORS = /* @__PURE__ */ new Set([...WS_TAGS, "deleteBegin", "deleteEnd", "insertBegin", "insertEnd"]);
+var FLOW_OBJECTS = /* @__PURE__ */ new Set([
+  "tbl",
+  "pic",
+  "rect",
+  "ellipse",
+  "line",
+  "arc",
+  "polygon",
+  "curve",
+  "connectLine",
+  "container",
+  "ole",
+  "chart",
+  "textart",
+  "video",
+  "equation",
+  "footNote",
+  "endNote",
+  "header",
+  "footer",
+  "hiddenComment",
+  "memo",
+  "memogroup"
+]);
+var T_INNER_TRANSPARENT = /* @__PURE__ */ new Set(["markpenBegin", "markpenEnd", "hyphen", "titleMark", "indexmark"]);
+var ENTITY_RE = /&(?:#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/y;
+function decodeEntity(ent) {
+  switch (ent) {
+    case "&lt;":
+      return "<";
+    case "&gt;":
+      return ">";
+    case "&amp;":
+      return "&";
+    case "&quot;":
+      return '"';
+    case "&apos;":
+      return "'";
+  }
+  const m = /^&#(x?)([0-9a-fA-F]+);$/.exec(ent);
+  if (m) {
+    const code = parseInt(m[2], m[1] ? 16 : 10);
+    if (code >= 0 && code <= 1114111) return String.fromCodePoint(code);
+  }
+  return ent;
+}
+function appendDecoded(xml, start, end, out) {
+  let i = start;
+  while (i < end) {
+    if (xml[i] === "&") {
+      ENTITY_RE.lastIndex = i;
+      const m = ENTITY_RE.exec(xml);
+      if (m && i + m[0].length <= end) {
+        const dec = decodeEntity(m[0]);
+        for (let k = 0; k < dec.length; k++) {
+          out.text += dec[k];
+          out.pos.push(k === 0 && dec.length === 1 ? [i, i + m[0].length] : null);
+        }
+        i += m[0].length;
+        continue;
+      }
+    }
+    out.text += xml[i];
+    out.pos.push([i, i + 1]);
+    i++;
+  }
+}
+function appendRaw(xml, start, end, out) {
+  for (let i = start; i < end; i++) {
+    out.text += xml[i];
+    out.pos.push([i, i + 1]);
+  }
+}
+var localName = (qname) => qname.slice(qname.indexOf(":") + 1);
+function appendTContent(xml, start, end, out) {
+  const tokRe = /<!--[\s\S]*?-->|<!\[CDATA\[([\s\S]*?)\]\]>|<\?[\s\S]*?\?>|<\/?([^\s/>!?]+)[^>]*>/g;
+  tokRe.lastIndex = start;
+  let cursor = start;
+  let m;
+  while ((m = tokRe.exec(xml)) !== null && m.index < end) {
+    appendDecoded(xml, cursor, m.index, out);
+    if (m[1] !== void 0) appendRaw(xml, m.index + 9, m.index + 9 + m[1].length, out);
+    else if (m[2] !== void 0 && !T_INNER_TRANSPARENT.has(localName(m[2]))) {
+      out.text += " ";
+      out.pos.push(null);
+    }
+    cursor = m.index + m[0].length;
+  }
+  appendDecoded(xml, cursor, end, out);
+}
+function gapSeparates(gap) {
+  const tagRe = /<(\/?)([^\s/>!?]+)(?:"[^"]*"|'[^']*'|[^>"'])*>/g;
+  let m;
+  while ((m = tagRe.exec(gap)) !== null) {
+    const l = localName(m[2]);
+    if (m[1] === "" && FLOW_OBJECTS.has(l) && !m[0].endsWith("/>")) {
+      if (l === "equation" || l === "footNote" || l === "endNote") return true;
+      const end = findElementEnd(gap, m.index);
+      if (end < 0) return true;
+      const pos = l === "tbl" ? /<(?:[\w]+:)?pos\b[^>]*>/.exec(gap.slice(m.index, end))?.[0] : void 0;
+      if (pos && /\btreatAsChar="1"/.test(pos)) return true;
+      tagRe.lastIndex = end;
+      continue;
+    }
+    if (GAP_SEPARATORS.has(l)) return true;
+  }
+  return false;
+}
+function paragraphText(xml, para) {
+  const out = { text: "", pos: [] };
+  let prevEnd = -1;
+  for (const t of para.tRanges) {
+    if (prevEnd >= 0 && gapSeparates(xml.slice(prevEnd, t.contentStart))) {
+      out.text += " ";
+      out.pos.push(null);
+    }
+    if (!t.selfClosing) appendTContent(xml, t.contentStart, t.contentEnd, out);
+    prevEnd = t.contentEnd;
+  }
+  return out;
+}
+function allParagraphs(scan) {
+  const out = [...scan.bodyParagraphs, ...scan.excludedParagraphs];
+  const walk = (t, depth) => {
+    if (depth > 32) return;
+    for (const row of t.rows) for (const cell of row) {
+      out.push(...cell.paragraphs);
+      for (const n of cell.tables) walk(n, depth + 1);
+    }
+  };
+  for (const t of [...scan.tables, ...scan.orphanTables]) walk(t, 0);
+  return out;
+}
+var CONTAINER_WHERE = {
+  header: "header",
+  footer: "footer",
+  footNote: "footnote",
+  endNote: "endnote",
+  fn: "footnote",
+  en: "endnote",
+  caption: "caption",
+  memo: "memo",
+  memogroup: "memo",
+  hiddenComment: "hidden"
+};
+function containerRanges(xml) {
+  const out = [];
+  for (const m of xml.matchAll(/<((?:[\w]+:)?(header|footer|footNote|endNote|caption|memogroup|memo|hiddenComment))[\s>]/g)) {
+    const end = findElementEnd(xml, m.index);
+    if (end > 0) out.push({ start: m.index, end, where: CONTAINER_WHERE[m[2]] ?? "other" });
+  }
+  return out;
+}
+function paragraphWhere(para, ranges) {
+  if (para.kind === "body") return "body";
+  if (para.kind === "draw") return "textbox";
+  if (para.kind === "cell") return para.inTextbox ? "textbox" : "table";
+  let best;
+  for (const r of ranges) {
+    if (r.start < para.start && para.start < r.end && (!best || r.start > best.start)) best = r;
+  }
+  return best?.where ?? "other";
+}
+function maskMapped(m, ctx, onHit, splices) {
+  for (const h of findPii(m.text, ctx)) {
+    onHit(h);
+    if (!splices) continue;
+    let run = null;
+    for (let k = 0; k < h.length; k++) {
+      const p = m.pos[h.index + k];
+      if (!p || h.masked[k] === m.text[h.index + k]) {
+        run = null;
+        continue;
+      }
+      if (run && run.end === p[0]) {
+        run.end = p[1];
+        run.replacement += ctx.maskChar;
+      } else {
+        run = { start: p[0], end: p[1], replacement: ctx.maskChar };
+        splices.push(run);
+      }
+    }
+  }
+}
+function applySplicesLinear(src, splices) {
+  const sorted = [...splices].sort((a, b) => a.start - b.start || a.end - b.end);
+  const parts = [];
+  let cursor = 0;
+  for (const s of sorted) {
+    if (s.start < cursor) throw new Error("\uB9C8\uC2A4\uD0B9 splice \uBC94\uC704 \uACB9\uCE68 \u2014 \uB0B4\uBD80 \uC624\uB958");
+    parts.push(src.slice(cursor, s.start), s.replacement);
+    cursor = s.end;
+  }
+  parts.push(src.slice(cursor));
+  return parts.join("");
+}
+var STRUCTURAL_ELEMENTS = /* @__PURE__ */ new Set(["lineseg", "linesegarray"]);
+function scrubLooseText(xml, owned, ctx, partWhere, report, splices) {
+  const tokenRe = /<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)\]\]>|<\?([\s\S]*?)\?>|<!((?:"[^"]*"|'[^']*'|[^>"'])*)>|<(\/?)([^\s/>!?]+)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>|([^<]+)/g;
+  const stack = [];
+  const shortLits = ctx.literals.some((l) => l.norm.length < 6);
+  const minText = shortLits ? 2 : 5;
+  let oi = 0;
+  let pending = null;
+  let pendingWhere = "other";
+  const whereOf = (fallback) => {
+    if (partWhere) return partWhere;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const l = stack[i];
+      if (l === "stringParam" || l === "fieldBegin" || l === "parameters") return "field";
+      if (l === "shapeComment") return "attribute";
+      if (CONTAINER_WHERE[l]) return CONTAINER_WHERE[l];
+    }
+    return fallback;
+  };
+  const flush = () => {
+    if (pending && pending.text.length >= minText && !isBindingPath(pending.text)) {
+      const where = pendingWhere;
+      maskMapped(pending, ctx, (h) => report(h, where), splices);
+    }
+    pending = null;
+  };
+  const addText = (fill) => {
+    if (!pending) {
+      pending = { text: "", pos: [] };
+      pendingWhere = whereOf("other");
+    }
+    fill(pending);
+  };
+  const scanInner = (start, text) => {
+    const mapped = { text: "", pos: [] };
+    appendRaw(xml, start, start + text.length, mapped);
+    maskMapped(mapped, ctx, (h) => report(h, partWhere ?? "other"), splices);
+  };
+  const isOwned = (at) => {
+    while (oi < owned.length && owned[oi][1] <= at) oi++;
+    return oi < owned.length && owned[oi][0] <= at && at < owned[oi][1];
+  };
+  for (const m of xml.matchAll(tokenRe)) {
+    const at = m.index;
+    if (m[9] !== void 0 || m[2] !== void 0) {
+      if (isOwned(at)) {
+        flush();
+        continue;
+      }
+      if (m[9] !== void 0) addText((out) => appendDecoded(xml, at, at + m[9].length, out));
+      else addText((out) => appendRaw(xml, at + 9, at + 9 + m[2].length, out));
+      continue;
+    }
+    if (m[1] !== void 0) {
+      scanInner(at + 4, m[1]);
+      continue;
+    }
+    if (m[3] !== void 0) {
+      scanInner(at + 2, m[3]);
+      continue;
+    }
+    if (m[4] !== void 0) {
+      flush();
+      scanInner(at + 2, m[4]);
+      continue;
+    }
+    if (m[6] === void 0) continue;
+    flush();
+    const local = localName(m[6]);
+    if (m[5] === "/") {
+      const i = stack.lastIndexOf(local);
+      if (i >= 0) stack.length = i;
+      continue;
+    }
+    const attrs = m[7] ?? "";
+    if (attrs.includes("=") && !STRUCTURAL_ELEMENTS.has(local)) {
+      const attrBase = at + 1 + m[6].length;
+      for (const a of attrs.matchAll(/([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) {
+        const val = a[2] ?? a[3] ?? "";
+        if (val.length < minText || !shortLits && !/[0-9A-Za-z]/.test(val) || isBindingPath(val)) continue;
+        const valStart = attrBase + a.index + a[0].length - val.length - 1;
+        const mapped = { text: "", pos: [] };
+        appendDecoded(xml, valStart, valStart + val.length, mapped);
+        maskMapped(mapped, ctx, (h) => report(h, partWhere ?? "attribute"), splices);
+      }
+    }
+    if (m[8] !== "/") stack.push(local);
+  }
+  flush();
+}
+function scrubXml(xml, part, ctx, mode, hits) {
+  const splices = mode === "mask" ? [] : null;
+  const partWhere = /content\.hpf$/i.test(part) ? "metadata" : null;
+  const owned = [];
+  if (/<(?:[\w]+:)?p[\s>]/.test(xml) && /<(?:[\w]+:)?t[\s>/]/.test(xml)) {
+    const scan = scanSectionXml(xml, 0);
+    const ranges = containerRanges(xml);
+    for (const para of allParagraphs(scan)) {
+      for (const t of para.tRanges) owned.push([t.contentStart, t.contentEnd]);
+      const where = paragraphWhere(para, ranges);
+      maskMapped(paragraphText(xml, para), ctx, (h) => hits.push({ rule: h.rule, masked: h.masked, part, where }), splices);
+    }
+    owned.sort((a, b) => a[0] - b[0]);
+  }
+  scrubLooseText(xml, owned, ctx, partWhere, (h, where) => hits.push({ rule: h.rule, masked: h.masked, part, where }), splices);
+  if (!splices || splices.length === 0) return null;
+  if (xml.includes("linesegarray")) splices.push(...allLinesegRemovalSplices(xml));
+  return applySplicesLinear(xml, splices);
+}
+function scrubPlainText(text, part, ctx, mode, hits) {
+  const where = /^Preview\//i.test(part) ? "preview" : "other";
+  let changed = false;
+  const lines = text.split("\n").map((line) => {
+    const found = findPii(line, ctx);
+    if (found.length === 0) return line;
+    let out = "";
+    let cursor = 0;
+    for (const h of found) {
+      hits.push({ rule: h.rule, masked: h.masked, part, where });
+      out += line.slice(cursor, h.index) + h.masked;
+      cursor = h.index + h.length;
+    }
+    changed = true;
+    return out + line.slice(cursor);
+  });
+  return mode === "mask" && changed ? lines.join("\n") : null;
+}
+var isXmlName = (n) => /\.(xml|hpf|rdf)$/i.test(n);
+var isTextName = (n) => /\.(txt|js|json|csv|html?)$/i.test(n) || /^Scripts\//i.test(n);
+var isPreviewImage = (n) => /^Preview\/PrvImage\./i.test(n);
+var nameList = (names) => names.length <= 5 ? names.join(", ") : `${names.slice(0, 5).join(", ")} \uC678 ${names.length - 5}\uAC1C`;
+function literalLeftovers(xml, part, ctx, hits) {
+  if (ctx.literals.length === 0) return;
+  const stripped = normalizeForDetect(xml.replace(/<[^>]*>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&"));
+  for (const { lit } of findLiterals(stripped, ctx.literals)) {
+    if (!hits.some((x) => x.part === part && x.masked === lit.masked)) hits.push({ rule: lit.rule, masked: lit.masked, part, where: "other" });
+  }
+}
+async function scrubHwpx(original, ctx, mode) {
+  const zip = await JSZip2.loadAsync(original);
+  const hits = [];
+  const warnings = [];
+  const unscanned = [];
+  const replacements = /* @__PURE__ */ new Map();
+  const encoder = new TextEncoder();
+  const previews = [];
+  const pictures = [];
+  const embedded = [];
+  const decode = (bytes) => {
+    if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254 || bytes.includes(0) && looksUtf16le(bytes)) {
+      return { text: bytes.toString("utf16le"), encode: (x) => Buffer.from(x, "utf16le") };
+    }
+    return bytes.includes(0) ? null : { text: bytes.toString("utf8"), encode: (x) => encoder.encode(x) };
+  };
+  for (const [name, entry] of Object.entries(zip.files)) {
+    if (entry.dir || name === "mimetype") continue;
+    if (isPreviewImage(name)) {
+      previews.push(name);
+      continue;
+    }
+    const bytes = Buffer.from(await entry.async("uint8array"));
+    if (isXmlName(name) || /^BinData\/.*\.svg$/i.test(name)) {
+      const dec2 = decode(bytes);
+      if (!dec2) {
+        unscanned.push(name);
+        continue;
+      }
+      const next = scrubXml(dec2.text, name, ctx, mode, hits);
+      if (next !== null) replacements.set(name, dec2.encode(next));
+      if (mode === "check") literalLeftovers(dec2.text, name, ctx, hits);
+      continue;
+    }
+    if (/^BinData\//i.test(name)) {
+      const report = (where) => (h) => {
+        hits.push({ rule: h.rule, masked: h.masked, part: name, where });
+      };
+      if (isOleBin(bytes) || isEmf(bytes)) {
+        embedded.push(name);
+        if (mode === "check") {
+          if (isOleBin(bytes)) await checkEmbeddedOle(bytes, ctx, report("other"));
+          else scrubUtf16Runs(bytes, ctx, "check", report("other"));
+        }
+      } else {
+        pictures.push(name);
+        if (isMetaImage(bytes) && scrubImageMeta(bytes, ctx, mode, report("metadata"))) replacements.set(name, bytes);
+      }
+      continue;
+    }
+    const dec = decode(bytes);
+    if (dec) {
+      const next = scrubPlainText(dec.text, name, ctx, mode, hits);
+      if (next !== null) replacements.set(name, dec.encode(next));
+    } else if (isTextName(name)) {
+      unscanned.push(name);
+    } else {
+      warnings.push(`\uC54C \uC218 \uC5C6\uB294 \uBC14\uC774\uB108\uB9AC \uC5D4\uD2B8\uB9AC ${name} \uB294 \uAC80\uC0AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`);
+    }
+  }
+  if (mode === "mask") {
+    if (hits.length > 0 || ctx.literals.length > 0) {
+      for (const name of previews) {
+        const blank = blankPreviewImage(await zip.file(name).async("uint8array"));
+        if (blank) replacements.set(name, blank);
+        else warnings.push(`${name}: \uD615\uC2DD\uC744 \uBAB0\uB77C \uBBF8\uB9AC\uBCF4\uAE30 \uC774\uBBF8\uC9C0\uB97C \uC9C0\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uCCAB \uCABD \uB80C\uB354\uC5D0 PII \uAC00 \uBCF4\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4`);
+      }
+      if (previews.length > 0) warnings.push(`\uBBF8\uB9AC\uBCF4\uAE30 \uC774\uBBF8\uC9C0(${previews.join(", ")})\uB97C \uAC19\uC740 \uD06C\uAE30\uC758 \uD770 \uC774\uBBF8\uC9C0\uB85C \uBC14\uAFE8\uC2B5\uB2C8\uB2E4 \u2014 \uD55C\uCEF4\uC5D0\uC11C \uC800\uC7A5\uD558\uBA74 \uB2E4\uC2DC \uB9CC\uB4E4\uC5B4\uC9D1\uB2C8\uB2E4`);
+    }
+    if (pictures.length > 0) warnings.push(`\uC0BD\uC785 \uADF8\uB9BC ${pictures.length}\uAC1C(${nameList(pictures)})\uB294 \uD654\uC18C \uC18D \uAE00\uC790(\uC2A4\uCE94 \uBB38\uC11C \uB4F1)\uB97C \uD0D0\uC9C0\uD558\uC9C0 \uBABB\uD569\uB2C8\uB2E4 \u2014 JPEG\xB7PNG \uBA54\uD0C0\uB370\uC774\uD130\uB9CC \uAC80\uC0AC\uD588\uC2B5\uB2C8\uB2E4`);
+    if (embedded.length > 0) warnings.push(`\uC0BD\uC785 \uAC1C\uCCB4 ${embedded.length}\uAC1C(${nameList(embedded)} \u2014 OLE\xB7EMF)\uB294 \uAC00\uB9AC\uC9C0 \uBABB\uD569\uB2C8\uB2E4 \u2014 \uC548\uC758 \uAE00\uC790\uC5D0 PII \uAC00 \uC788\uC73C\uBA74 \uC7AC\uAC80\uC0AC \uC794\uC874\uC73C\uB85C \uBCF4\uACE0\uB429\uB2C8\uB2E4`);
+    if (unscanned.length > 0) warnings.push(`\uC778\uCF54\uB529\uC744 \uBAB0\uB77C \uAC80\uC0AC\uD558\uC9C0 \uBABB\uD55C \uAE00\uC790 \uC5D4\uD2B8\uB9AC: ${unscanned.join(", ")}`);
+  }
+  const data = mode === "mask" && replacements.size > 0 ? patchZipEntries(original, replacements) : original;
+  return { data, hits, warnings, unscanned };
+}
+
+// src/redact-hwp5.ts
+import { createRequire as createRequire2 } from "module";
+import { deflateRawSync, inflateRawSync, constants as zlibConstants } from "zlib";
+var require3 = createRequire2(import.meta.url);
+var CFB2 = require3("cfb");
+var CTRL_WHERE = {
+  "tbl ": "table",
+  head: "header",
+  foot: "footer",
+  "fn  ": "footnote",
+  "en  ": "endnote",
+  "gso ": "textbox",
+  tcmt: "hidden"
+};
+var BREAKING_CTRLS = /* @__PURE__ */ new Set(["eqed", "atno", "fn  ", "en  "]);
+function ctrlName(data) {
+  if (data.length < 4) return "";
+  const id = data.readUInt32LE(0);
+  return String.fromCharCode(id >>> 24, id >>> 16 & 255, id >>> 8 & 255, id & 255);
+}
+function decodeParaText(data) {
+  let text = "";
+  const pos = [];
+  let i = 0;
+  const sep = (c = " ") => {
+    text += c;
+    pos.push(-1);
+  };
+  while (i + 1 < data.length) {
+    const ch = data.readUInt16LE(i);
+    if (ch >= 32) {
+      text += String.fromCharCode(ch);
+      pos.push(i);
+      i += 2;
+      continue;
+    }
+    if (ch === 13) {
+      sep("\n");
+      i += 2;
+      continue;
+    }
+    if (ch === 10) {
+      if (i + 18 <= data.length && data.readUInt16LE(i + 2) === 11) {
+        sep();
+        i += 18;
+        continue;
+      }
+      sep("\n");
+      i += 2;
+      continue;
+    }
+    const extended = isExtendedOnlyCtrlChar(ch);
+    if ((extended || ch >= 4 && ch <= 9 || ch === 19 || ch === 20) && i + 16 <= data.length) {
+      if (ch === 9 || extended && BREAKING_CTRLS.has(ctrlName(data.subarray(i + 2, i + 6)))) sep();
+      i += 16;
+      continue;
+    }
+    if (ch === 30 || ch === 31) sep();
+    i += 2;
+  }
+  return { text, pos };
+}
+function scrubParaText(data, ctx, mode, where, report) {
+  const { text, pos } = decodeParaText(data);
+  let changed = false;
+  const mc = ctx.maskChar.charCodeAt(0);
+  for (const h of findPii(text, ctx)) {
+    report(h.rule, h.masked, where);
+    if (mode !== "mask") continue;
+    for (let k = 0; k < h.length; k++) {
+      const p = pos[h.index + k];
+      if (p >= 0 && h.masked[k] !== text[h.index + k]) {
+        data.writeUInt16LE(mc, p);
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function scrubRecords(data, ctx, mode, report) {
+  let changed = false;
+  const ctrlStack = [];
+  for (const rec of readRecords(data)) {
+    while (ctrlStack.length > 0 && ctrlStack[ctrlStack.length - 1].level >= rec.level) ctrlStack.pop();
+    if (rec.tagId === TAG_PARA_TEXT) {
+      let where2 = "body";
+      for (let i = ctrlStack.length - 1; i >= 0; i--) {
+        const w = CTRL_WHERE[ctrlStack[i].id];
+        if (w) {
+          where2 = w;
+          break;
+        }
+      }
+      if (scrubParaText(rec.data, ctx, mode, where2, report)) changed = true;
+      continue;
+    }
+    let where = "other";
+    if (rec.tagId === TAG_CTRL_HEADER) {
+      const id = ctrlName(rec.data);
+      ctrlStack.push({ level: rec.level, id });
+      where = id.startsWith("%") ? "field" : "attribute";
+    } else if (rec.tagId === TAG_CTRL_DATA) where = "field";
+    if (scrubUtf16Runs(rec.data, ctx, mode, (h) => report(h.rule, h.masked, where), true)) changed = true;
+  }
+  return changed;
+}
+function scrubRaw(data, ctx, mode, where, report, ascii) {
+  const a = scrubUtf16Runs(data, ctx, mode, (h) => report(h.rule, h.masked, where));
+  const b = ascii && scrubAsciiRuns(data, ctx, mode, (h) => report(h.rule, h.masked, where));
+  return a || b;
+}
+function tryInflate(data) {
+  try {
+    return decompressStream(data);
+  } catch {
+    return null;
+  }
+}
+function hasHancomTail(stream, raw) {
+  return stream.length >= 8 && stream.readUInt32LE(stream.length - 4) === raw.length >>> 0 && stream.readUInt32LE(stream.length - 8) === crc32(raw);
+}
+var recompress = (raw, tail) => tail ? compressWithTail(raw) : deflateRawSync(raw);
+var BLOCK = 64;
+function changedSpans(a, b) {
+  const spans = [];
+  const n = Math.min(a.length, b.length);
+  let start = -1;
+  for (let o = 0; o < n; o += BLOCK) {
+    const e = Math.min(n, o + BLOCK);
+    const diff = a.compare(b, o, e, o, e) !== 0;
+    if (diff && start < 0) start = o;
+    else if (!diff && start >= 0) {
+      spans.push([start, o]);
+      start = -1;
+    }
+  }
+  if (start >= 0) spans.push([start, n]);
+  return spans;
+}
+function mayStartDeflate(b, o) {
+  const type = b[o] >> 1 & 3;
+  if (type === 3) return false;
+  if (type === 0) return o + 5 <= b.length && (b.readUInt16LE(o + 1) ^ b.readUInt16LE(o + 3)) === 65535;
+  return true;
+}
+function scanSlack(before, after, ctx, onHit) {
+  let bytes = 0;
+  for (const [s, e] of changedSpans(before, after)) {
+    bytes += e - s;
+    const region = Buffer.from(before.subarray(s, e));
+    scrubUtf16Runs(region, ctx, "check", onHit);
+    for (let o = 0; o + 8 <= region.length; o += BLOCK) {
+      if (!mayStartDeflate(region, o)) continue;
+      let out;
+      try {
+        out = inflateRawSync(region.subarray(o), { finishFlush: zlibConstants.Z_SYNC_FLUSH, maxOutputLength: 64 * 1024 * 1024 });
+      } catch {
+        continue;
+      }
+      if (out.length >= 16) scrubUtf16Runs(out, ctx, "check", onHit);
+    }
+  }
+  return bytes;
+}
+var nameList2 = (names) => names.length <= 5 ? names.join(", ") : `${names.slice(0, 5).join(", ")} \uC678 ${names.length - 5}\uAC1C`;
+async function scrubHwp5(original, ctx, mode) {
+  const file = Buffer.from(original.buffer, original.byteOffset, original.byteLength);
+  const cfb = CFB2.parse(file);
+  const headerEntry = CFB2.find(cfb, "/FileHeader");
+  if (!headerEntry?.content) throw new Error("HWP FileHeader \uC2A4\uD2B8\uB9BC\uC774 \uC5C6\uC2B5\uB2C8\uB2E4");
+  const header = parseFileHeader(Buffer.from(headerEntry.content));
+  if (header.flags & (FLAG_ENCRYPTED | FLAG_DISTRIBUTION | FLAG_DRM)) {
+    throw new Error("\uBC30\uD3EC\uC6A9\xB7\uC554\uD638\xB7DRM \uBB38\uC11C\uB294 \uBCF8\uBB38\uC774 \uC554\uD638\uD654\uB3FC \uC788\uC5B4 \uB9C8\uC2A4\uD0B9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  }
+  const compressed = (header.flags & FLAG_COMPRESSED) !== 0;
+  const hits = [];
+  const warnings = [];
+  const replaced = /* @__PURE__ */ new Map();
+  const pictures = [];
+  const embedded = [];
+  let previewPath = null;
+  for (let idx = 0; idx < cfb.FullPaths.length; idx++) {
+    const entry = cfb.FileIndex[idx];
+    if (entry.type !== 2 || !entry.content) continue;
+    const path = cfb.FullPaths[idx].replace(/^[^/]*\//, "");
+    const content = Buffer.from(entry.content);
+    const part = path.replace(/[\x00-\x1f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
+    const report = (rule, masked, where) => hits.push({ rule, masked, part, where });
+    if (path === "FileHeader") continue;
+    if (path === "PrvImage") {
+      previewPath = path;
+      continue;
+    }
+    let next = null;
+    if (path.startsWith("BinData/")) {
+      const inflated = tryInflate(content);
+      const data2 = inflated ?? Buffer.from(content);
+      const tail = inflated ? hasHancomTail(content, inflated) : false;
+      if (isOleBin(data2) || isEmf(data2)) {
+        embedded.push(part);
+        if (mode === "check") {
+          if (isOleBin(data2)) await checkEmbeddedOle(data2, ctx, (h) => report(h.rule, h.masked, "other"));
+          else scrubUtf16Runs(data2, ctx, "check", (h) => report(h.rule, h.masked, "other"));
+        }
+      } else {
+        pictures.push(part);
+        if (isMetaImage(data2) && scrubImageMeta(data2, ctx, mode, (h) => report(h.rule, h.masked, "metadata"))) next = inflated ? recompress(data2, tail) : data2;
+      }
+    } else if (/^BodyText\/Section\d+$/.test(path) || path === "DocInfo") {
+      const data2 = compressed ? decompressStream(content) : Buffer.from(content);
+      const tail = compressed && hasHancomTail(content, data2);
+      if (scrubRecords(data2, ctx, mode, report)) next = compressed ? recompress(data2, tail) : data2;
+    } else if (path === "PrvText") {
+      const data2 = Buffer.from(content);
+      if (scrubUtf16Runs(data2, ctx, mode, (h) => report(h.rule, h.masked, "preview"))) next = data2;
+    } else if (path.startsWith("")) {
+      const data2 = Buffer.from(content);
+      if (scrubRaw(data2, ctx, mode, "metadata", report, true)) next = data2;
+    } else {
+      const inflated = compressed ? tryInflate(content) : null;
+      const data2 = inflated ?? Buffer.from(content);
+      const tail = inflated ? hasHancomTail(content, inflated) : false;
+      if (scrubRaw(data2, ctx, mode, "other", report, path.startsWith("Scripts/"))) next = inflated ? recompress(data2, tail) : data2;
+      if (path.startsWith("DocHistory/")) warnings.push(`\uBB38\uC11C \uC774\uB825(${path})\uC774 \uB4E4\uC5B4 \uC788\uC2B5\uB2C8\uB2E4 \u2014 \uC774\uC804 \uD310\uC758 \uAE00\uC790\uB294 \uBB38\uC790\uC5F4 \uC870\uAC01 \uB2E8\uC704\uB85C\uB9CC \uAC80\uC0AC\uD588\uC2B5\uB2C8\uB2E4`);
+    }
+    if (next) replaced.set(path, next);
+  }
+  let data = original;
+  if (mode === "mask") {
+    if (previewPath && (hits.length > 0 || ctx.literals.length > 0)) {
+      const img = CFB2.find(cfb, "/PrvImage")?.content;
+      const blank = img ? blankPreviewImage(Buffer.from(img)) : null;
+      if (blank) {
+        replaced.set(previewPath, blank);
+        warnings.push("\uBBF8\uB9AC\uBCF4\uAE30 \uC774\uBBF8\uC9C0(PrvImage)\uB97C \uAC19\uC740 \uD06C\uAE30\uC758 \uD770 \uC774\uBBF8\uC9C0\uB85C \uBC14\uAFE8\uC2B5\uB2C8\uB2E4 \u2014 \uD55C\uCEF4\uC5D0\uC11C \uC800\uC7A5\uD558\uBA74 \uB2E4\uC2DC \uB9CC\uB4E4\uC5B4\uC9D1\uB2C8\uB2E4");
+      } else warnings.push("\uBBF8\uB9AC\uBCF4\uAE30 \uC774\uBBF8\uC9C0(PrvImage) \uD615\uC2DD\uC744 \uBAB0\uB77C \uC9C0\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uCCAB \uCABD \uB80C\uB354\uC5D0 PII \uAC00 \uBCF4\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4");
+    }
+    if (pictures.length > 0) warnings.push(`\uC0BD\uC785 \uADF8\uB9BC ${pictures.length}\uAC1C(${nameList2(pictures)})\uB294 \uD654\uC18C \uC18D \uAE00\uC790(\uC2A4\uCE94 \uBB38\uC11C \uB4F1)\uB97C \uD0D0\uC9C0\uD558\uC9C0 \uBABB\uD569\uB2C8\uB2E4 \u2014 JPEG\xB7PNG \uBA54\uD0C0\uB370\uC774\uD130\uB9CC \uAC80\uC0AC\uD588\uC2B5\uB2C8\uB2E4`);
+    if (embedded.length > 0) warnings.push(`\uC0BD\uC785 \uAC1C\uCCB4 ${embedded.length}\uAC1C(${nameList2(embedded)} \u2014 OLE\xB7EMF)\uB294 \uAC00\uB9AC\uC9C0 \uBABB\uD569\uB2C8\uB2E4 \u2014 \uC548\uC758 \uAE00\uC790\uC5D0 PII \uAC00 \uC788\uC73C\uBA74 \uC7AC\uAC80\uC0AC \uC794\uC874\uC73C\uB85C \uBCF4\uACE0\uB429\uB2C8\uB2E4`);
+    let out = Buffer.from(file);
+    for (const [path, content] of replaced) out = replaceOleStream(out, path, content);
+    try {
+      const wiped = wipeFreeSectors(out);
+      const before = hits.length;
+      const seen = /* @__PURE__ */ new Set();
+      const bytes = scanSlack(out, wiped, ctx, (h) => {
+        const key = `${h.rule}\0${h.masked}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        hits.push({ rule: h.rule, masked: h.masked, part: "(\uBBF8\uD560\uB2F9 \uC139\uD130)", where: "slack" });
+      });
+      if (bytes > 0) {
+        const found = hits.length - before;
+        warnings.push(`\uBBF8\uD560\uB2F9 \uC601\uC5ED(\uD55C\uCEF4\uC774 \uB0A8\uAE34 \uC61B \uC2A4\uD2B8\uB9BC \uC0AC\uBCF8 \uB4F1) ${Math.ceil(bytes / 1024)}KB\uB97C 0\uC73C\uB85C \uBE44\uC6E0\uC2B5\uB2C8\uB2E4${found > 0 ? ` \u2014 \uADF8 \uC548\uC5D0 \uAC1C\uC778\uC815\uBCF4 ${found}\uAC74\uC774 \uC788\uC5C8\uC2B5\uB2C8\uB2E4` : ""}`);
+      }
+      out = wiped;
+    } catch (err) {
+      warnings.push(`\uBBF8\uD560\uB2F9 \uC139\uD130\uB97C \uBE44\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 (${err instanceof Error ? err.message : String(err)}) \u2014 \uC61B \uC2A4\uD2B8\uB9BC \uC0AC\uBCF8\uC774 \uB0A8\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4`);
+    }
+    if (!out.equals(file)) data = new Uint8Array(out);
+  } else {
+    const add = (part, where) => (h) => {
+      if (!hits.some((x) => x.masked === h.masked && x.rule === h.rule)) hits.push({ rule: h.rule, masked: h.masked, part, where });
+    };
+    scrubUtf16Runs(Buffer.from(file), ctx, "check", add("(OLE \uC6D0\uC2DC \uBC14\uC774\uD2B8)", "other"));
+    try {
+      scanSlack(file, wipeFreeSectors(Buffer.from(file)), ctx, add("(\uBBF8\uD560\uB2F9 \uC139\uD130)", "slack"));
+    } catch {
+    }
+  }
+  return { data, hits, warnings, unscanned: [] };
+}
+
+// src/redact-doc.ts
+async function preciseFormat(buffer) {
+  let format = detectFormat(buffer);
+  if (format === "hwpx") {
+    const z = await detectZipFormat(buffer);
+    if (z !== "unknown") format = z;
+  } else if (format === "hwp") {
+    const o = detectOle2Format(buffer);
+    if (o !== "unknown") format = o;
+  }
+  return format;
+}
+async function redactDocument(input, options) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  const rules = options?.rules ?? DEFAULT_REDACT_RULES;
+  const maskChar = options?.maskChar ?? "\u25CF";
+  const format = await preciseFormat(buffer);
+  const parsed = await parse(buffer, options?.filePath ? { filePath: options.filePath } : void 0);
+  if (!parsed.success) throw new Error(`\uD30C\uC2F1 \uC2E4\uD328: ${parsed.error}`);
+  const md = redactMarkdown(parsed.markdown, { rules, maskChar });
+  const ctx = { rules, maskChar, literals: literalsFromMarkdown(parsed.markdown, md.hits) };
+  const lit = maskLiterals(md.text, ctx);
+  const base = { format, markdown: lit.text, markdownHits: [...md.hits, ...lit.hits].sort((a, b) => a.index - b.index) };
+  if (format === "hwpx" || format === "hwp") {
+    const scrub = format === "hwpx" ? scrubHwpx : scrubHwp5;
+    const r = await scrub(bytes, ctx, "mask");
+    const check = await scrub(r.data, ctx, "check");
+    const residual = [...check.hits];
+    const unscanned = [...r.unscanned];
+    if (r.data === bytes) residual.push(...markdownLeftovers(parsed.markdown, ctx));
+    else {
+      const re = await parse(r.data.buffer.slice(r.data.byteOffset, r.data.byteOffset + r.data.byteLength));
+      if (re.success) residual.push(...markdownLeftovers(re.markdown, ctx));
+      else unscanned.push(`\uACB0\uACFC \uD30C\uC77C \uC7AC\uD30C\uC2F1 \uC2E4\uD328 (${re.error}) \u2014 \uACB0\uACFC \uBCF8\uBB38\uC744 \uAC80\uC99D\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4`);
+    }
+    return {
+      ...base,
+      data: options?.dryRun ? void 0 : r.data,
+      changed: r.data !== bytes,
+      fileHits: r.hits,
+      residual,
+      unscanned,
+      warnings: r.warnings
+    };
+  }
+  const warnings = [
+    `${format} \uC6D0\uBCF8 \uD30C\uC77C\uC740 \uC218\uC815\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 \u2014 \uB9C8\uC2A4\uD0B9\uB41C \uB9C8\uD06C\uB2E4\uC6B4\uB9CC \uB9CC\uB4ED\uB2C8\uB2E4. \uC6D0\uBCF8\uC758 \uD14D\uC2A4\uD2B8 \uB808\uC774\uC5B4\xB7\uC774\uBBF8\uC9C0\xB7\uBA54\uD0C0\uB370\uC774\uD130\uC5D0\uB294 PII \uAC00 \uADF8\uB300\uB85C \uB0A8\uC2B5\uB2C8\uB2E4.`
+  ];
+  if (format === "pdf") warnings.push("PDF \uB97C \uACF5\uAC1C\uD558\uB824\uBA74 PDF \uD3B8\uC9D1\uAE30\uC758 \uAC00\uB9BC(redaction) \uAE30\uB2A5\uC73C\uB85C \uD14D\uC2A4\uD2B8\uB97C \uC2E4\uC81C\uB85C \uC9C0\uC6B0\uAC70\uB098, \uB9C8\uC2A4\uD0B9\uB41C \uB9C8\uD06C\uB2E4\uC6B4\uC73C\uB85C \uC0C8 \uBB38\uC11C\uB97C \uB9CC\uB4DC\uC138\uC694.");
+  return { ...base, changed: false, fileHits: [], residual: markdownLeftovers(lit.text, ctx), unscanned: [], warnings };
+}
+function maskLiterals(markdown, ctx) {
+  if (ctx.literals.length === 0) return { text: markdown, hits: [] };
+  const hits = [];
+  let offset = 0;
+  const lines = markdown.split("\n").map((line) => {
+    const at = offset;
+    offset += line.length + 1;
+    if (line.includes("data:image/")) return line;
+    const found = findLiterals(normalizeForDetect(line), ctx.literals);
+    if (found.length === 0) return line;
+    let out = "";
+    let cursor = 0;
+    for (const { index, lit } of found) {
+      let masked = "";
+      for (let k = 0; k < lit.norm.length; k++) masked += lit.masked[k] !== lit.value[k] ? ctx.maskChar : line[index + k];
+      out += line.slice(cursor, index) + masked;
+      cursor = index + lit.norm.length;
+      hits.push({ rule: lit.rule, masked, index: at + index, length: lit.norm.length });
+    }
+    return out + line.slice(cursor);
+  });
+  return { text: lines.join("\n"), hits };
+}
+function markdownLeftovers(markdown, ctx) {
+  const out = redactMarkdown(markdown, { rules: ctx.rules, maskChar: ctx.maskChar }).hits.map((h) => ({ rule: h.rule, masked: h.masked, part: "(\uACB0\uACFC \uBCF8\uBB38 \uC7AC\uD30C\uC2F1)", where: "body" }));
+  for (const { lit } of findLiterals(normalizeForDetect(markdown), ctx.literals)) {
+    if (!out.some((h) => h.masked === lit.masked)) out.push({ rule: lit.rule, masked: lit.masked, part: "(\uACB0\uACFC \uBCF8\uBB38 \uC7AC\uD30C\uC2F1)", where: "body" });
+  }
+  return out;
+}
+export {
+  redactDocument
+};
+//# sourceMappingURL=redact-doc-QBHNJ2BU.js.map