kordoc 3.8.4 → 3.9.0

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sanitizeHref,
   stripDtd,
   toArrayBuffer
-} from "./chunk-T4SGNVVS.js";
+} from "./chunk-EZ5GBTBE.js";
 import {
   parsePageRange
 } from "./chunk-GE43BE46.js";
@@ -664,8 +664,10 @@ var CONVERT_MAP = {
   SUCC: "\\succ",
   UPLUS: "\\uplus",
   "\xB1": "\\pm",
+  "+-": "\\pm",
   "-+": "\\mp",
   "\xF7": "\\div",
+  cdot: "\\cdot",
   CIRC: "\\circ",
   BULLET: "\\bullet",
   DEG: " ^\\circ",
@@ -1054,6 +1056,10 @@ function hmlToLatex(hmlEqStr) {
     const t = tokens[i];
     if (t in CONVERT_MAP) tokens[i] = CONVERT_MAP[t];
     else if (t in MIDDLE_CONVERT_MAP) tokens[i] = MIDDLE_CONVERT_MAP[t];
+    else {
+      const quoted = /^"(.+)"$/.exec(t);
+      if (quoted) tokens[i] = `\\text{${quoted[1]}}`;
+    }
   }
   tokens = tokens.filter((tok) => tok.length !== 0);
   tokens = replaceBracket(tokens);
@@ -20770,6 +20776,16 @@ function buildPrvText(blocks) {
   }
   return lines.join("\n").slice(0, 1024);
 }
+function findMathDelim(s, from) {
+  let i = s.indexOf("$$", from);
+  while (i > 0) {
+    let backslashes = 0;
+    for (let j = i - 1; j >= 0 && s[j] === "\\"; j--) backslashes++;
+    if (backslashes % 2 === 0) break;
+    i = s.indexOf("$$", i + 1);
+  }
+  return i;
+}
 function parseMarkdownToBlocks(md2) {
   const lines = md2.split("\n");
   const blocks = [];
@@ -20780,6 +20796,45 @@ function parseMarkdownToBlocks(md2) {
       i++;
       continue;
     }
+    const mathOpen = /^\s*\$\$/.exec(line);
+    if (mathOpen) {
+      const afterOpen = line.slice(mathOpen[0].length);
+      const closeSame = findMathDelim(afterOpen, 0);
+      if (closeSame >= 0) {
+        const inner = afterOpen.slice(0, closeSame).trim();
+        const trailing2 = afterOpen.slice(closeSame + 2).trim();
+        if (inner) blocks.push({ type: "equation", text: inner });
+        if (trailing2) blocks.push({ type: "paragraph", text: trailing2 });
+        i++;
+        continue;
+      }
+      const mathLines = [];
+      if (afterOpen.trim()) mathLines.push(afterOpen);
+      let closed = false;
+      let trailing = "";
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const l = lines[j];
+        if (!l.trim() || /^\s*(`{3,}|~{3,})/.test(l)) break;
+        const end = findMathDelim(l, 0);
+        if (end >= 0) {
+          const before = l.slice(0, end);
+          if (before.trim()) mathLines.push(before);
+          trailing = l.slice(end + 2).trim();
+          closed = true;
+          j++;
+          break;
+        }
+        mathLines.push(l);
+      }
+      if (closed) {
+        const text = mathLines.join("\n").trim();
+        if (text) blocks.push({ type: "equation", text });
+        if (trailing) blocks.push({ type: "paragraph", text: trailing });
+        i = j;
+        continue;
+      }
+    }
     const fenceMatch = line.match(/^(`{3,}|~{3,})(.*)$/);
     if (fenceMatch) {
       const fence = fenceMatch[1];
@@ -21172,6 +21227,7 @@ function precomputeGongmunList(blocks, gongmun) {
       i++;
       continue;
     }
+    const passThrough = (t) => t === "table" || t === "html_table" || t === "equation";
     const run = [];
     while (i < blocks.length) {
       const t = blocks[i].type;
@@ -21180,9 +21236,9 @@ function precomputeGongmunList(blocks, gongmun) {
         i++;
         continue;
       }
-      if (t === "table" || t === "html_table") {
+      if (passThrough(t)) {
         let j = i + 1;
-        while (j < blocks.length && (blocks[j].type === "table" || blocks[j].type === "html_table")) j++;
+        while (j < blocks.length && passThrough(blocks[j].type)) j++;
         if (j < blocks.length && blocks[j].type === "list_item") {
           i = j;
           continue;
@@ -21708,6 +21764,280 @@ function generateHtmlTableXml(rawHtml, theme, totalWidth = 44e3) {
   return `<hp:tbl id="${tblId}" zOrder="0" numberingType="TABLE" pageBreak="CELL" repeatHeader="0" rowCnt="${rowCnt}" colCnt="${colCnt}" cellSpacing="0" borderFillIDRef="2" noShading="0"><hp:sz width="${tblW}" widthRelTo="ABSOLUTE" height="${cellH * rowCnt}" heightRelTo="ABSOLUTE" protect="0"/><hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="0" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/><hp:outMargin left="0" right="0" top="0" bottom="0"/><hp:inMargin left="510" right="510" top="141" bottom="141"/>` + trXmls.join("") + `</hp:tbl>`;
 }
 
+// src/hwpx/equation-generate.ts
+var MAX_EQUATION_SOURCE = 1e4;
+var MAX_GROUP_DEPTH = 64;
+var COMMAND_MAP = {
+  alpha: "alpha",
+  beta: "beta",
+  gamma: "gamma",
+  delta: "delta",
+  epsilon: "epsilon",
+  zeta: "zeta",
+  eta: "eta",
+  theta: "theta",
+  iota: "iota",
+  kappa: "kappa",
+  lambda: "lambda",
+  mu: "mu",
+  nu: "nu",
+  xi: "xi",
+  pi: "pi",
+  rho: "rho",
+  sigma: "sigma",
+  tau: "tau",
+  upsilon: "upsilon",
+  phi: "phi",
+  chi: "chi",
+  psi: "psi",
+  omega: "omega",
+  Gamma: "GAMMA",
+  Delta: "DELTA",
+  Theta: "THETA",
+  Lambda: "LAMBDA",
+  Xi: "XI",
+  Pi: "PI",
+  Sigma: "SIGMA",
+  Upsilon: "UPSILON",
+  Phi: "PHI",
+  Psi: "PSI",
+  Omega: "OMEGA",
+  le: "LEQ",
+  leq: "LEQ",
+  ge: "GEQ",
+  geq: "GEQ",
+  ne: "!=",
+  neq: "!=",
+  pm: "+-",
+  mp: "-+",
+  times: "TIMES",
+  cdot: "cdot",
+  ast: "AST",
+  circ: "CIRC",
+  bullet: "BULLET",
+  in: "IN",
+  notin: "NOTIN",
+  subset: "SUBSET",
+  subseteq: "SUBSETEQ",
+  supset: "SUPERSET",
+  supseteq: "SUPSETEQ",
+  cup: "CUP",
+  cap: "SMALLINTER",
+  emptyset: "EMPTYSET",
+  forall: "FORALL",
+  exists: "EXIST",
+  infinity: "INF",
+  infty: "INF",
+  partial: "Partial",
+  nabla: "NABLA",
+  int: "int",
+  iint: "dint",
+  iiint: "tint",
+  oint: "oint",
+  sum: "sum",
+  prod: "prod",
+  lim: "lim",
+  to: "->",
+  rightarrow: "->",
+  leftarrow: "larrow",
+  leftrightarrow: "<->",
+  Rightarrow: "RARROW",
+  Leftarrow: "LARROW",
+  Leftrightarrow: "LRARROW",
+  cdots: "CDOTS",
+  ldots: "LDOTS",
+  vdots: "VDOTS",
+  ddots: "DDOTS"
+};
+var ACCENT_COMMANDS = {
+  bar: "bar",
+  overline: "bar",
+  vec: "vec",
+  overrightarrow: "vec",
+  hat: "hat",
+  widehat: "hat",
+  tilde: "tilde",
+  widetilde: "tilde",
+  dot: "dot",
+  ddot: "ddot",
+  underline: "under"
+};
+var RESERVED_WORDS = new Set(
+  [...Object.keys(CONVERT_MAP), ...Object.keys(MIDDLE_CONVERT_MAP), "over", "root", "of"].filter((w) => /^[A-Za-z]+$/.test(w))
+);
+function skipSpaces(input, idx) {
+  while (idx < input.length && /\s/.test(input[idx])) idx++;
+  return idx;
+}
+function normalizeEqEdit(input) {
+  return input.replace(/\s+/g, " ").trim();
+}
+function stripMathDelimiters(input) {
+  let s = input.trim();
+  if (s.startsWith("$$") && s.endsWith("$$")) s = s.slice(2, -2).trim();
+  if (s.startsWith("\\[") && s.endsWith("\\]")) s = s.slice(2, -2).trim();
+  return s;
+}
+function readBalanced(input, idx, open, close) {
+  let depth = 1;
+  let cursor = idx + 1;
+  while (cursor < input.length) {
+    const ch = input[cursor];
+    if (ch === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (ch === open) depth++;
+    else if (ch === close) depth--;
+    if (depth === 0) {
+      return { value: input.slice(idx + 1, cursor), next: cursor + 1 };
+    }
+    cursor++;
+  }
+  return { value: input.slice(idx + 1), next: input.length };
+}
+function readGroupOrToken(input, idx, depth) {
+  const start = skipSpaces(input, idx);
+  if (depth > MAX_GROUP_DEPTH) return { value: input.slice(start), next: input.length };
+  if (input[start] === "{") {
+    const group = readBalanced(input, start, "{", "}");
+    return { value: convertLatexFragment(group.value, depth + 1), next: group.next };
+  }
+  if (input[start] === "\\") {
+    const cmd = readCommand(input, start, depth + 1);
+    return { value: cmd.value, next: cmd.next };
+  }
+  return { value: input[start] ?? "", next: Math.min(start + 1, input.length) };
+}
+function readCommandName(input, idx) {
+  if (input[idx + 1] === "\\") return { value: "\\", next: idx + 2 };
+  const match = /^[A-Za-z]+/.exec(input.slice(idx + 1));
+  if (match) return { value: match[0], next: idx + 1 + match[0].length };
+  return { value: input[idx + 1] ?? "", next: Math.min(idx + 2, input.length) };
+}
+function readCommand(input, idx, depth) {
+  const name = readCommandName(input, idx);
+  const command = name.value;
+  if (command === "\\") return { value: "#", next: name.next };
+  if (command === "frac") {
+    const num = readGroupOrToken(input, name.next, depth);
+    const den = readGroupOrToken(input, num.next, depth);
+    return { value: `{${num.value}} over {${den.value}}`, next: den.next };
+  }
+  if (command === "sqrt") {
+    let cursor = skipSpaces(input, name.next);
+    let root = null;
+    if (input[cursor] === "[") {
+      const opt = readBalanced(input, cursor, "[", "]");
+      root = { value: convertLatexFragment(opt.value, depth + 1), next: opt.next };
+      cursor = opt.next;
+    }
+    const body = readGroupOrToken(input, cursor, depth);
+    if (root) return { value: `root {${root.value}} of {${body.value}}`, next: body.next };
+    return { value: `sqrt{${body.value}}`, next: body.next };
+  }
+  if (command === "begin") {
+    const env = readGroupOrToken(input, name.next, depth);
+    const endTag = `\\end{${env.value}}`;
+    const endIdx = input.indexOf(endTag, env.next);
+    if (endIdx === -1) return { value: env.value, next: env.next };
+    const body = convertLatexFragment(input.slice(env.next, endIdx), depth + 1);
+    if (env.value === "matrix" || env.value === "pmatrix" || env.value === "bmatrix") {
+      return { value: `{${env.value}{${body}}}`, next: endIdx + endTag.length };
+    }
+    return { value: body, next: endIdx + endTag.length };
+  }
+  if (command === "left" || command === "right") {
+    const kw = command === "left" ? "LEFT" : "RIGHT";
+    const cursor = skipSpaces(input, name.next);
+    let delimiter = input[cursor] ?? "";
+    let next = delimiter ? cursor + 1 : cursor;
+    if (delimiter === "\\") {
+      const escaped = readCommandName(input, cursor);
+      delimiter = escaped.value === "\\" ? "\\" : COMMAND_MAP[escaped.value] ?? escaped.value;
+      next = escaped.next;
+    }
+    return { value: delimiter ? `${kw} ${delimiter}` : kw, next };
+  }
+  if (command in ACCENT_COMMANDS) {
+    const body = readGroupOrToken(input, name.next, depth);
+    return { value: `${ACCENT_COMMANDS[command]}{${body.value}}`, next: body.next };
+  }
+  if (command === "mathrm" || command === "text") {
+    const start = skipSpaces(input, name.next);
+    if (input[start] === "{") {
+      const group = readBalanced(input, start, "{", "}");
+      return { value: `"${group.value}"`, next: group.next };
+    }
+    const tok = readGroupOrToken(input, start, depth);
+    return { value: `"${tok.value}"`, next: tok.next };
+  }
+  return { value: COMMAND_MAP[command] ?? command, next: name.next };
+}
+function convertLatexFragment(input, depth) {
+  if (depth > MAX_GROUP_DEPTH) return normalizeEqEdit(input);
+  let out = "";
+  let idx = 0;
+  while (idx < input.length) {
+    const ch = input[idx];
+    if (ch === "\\") {
+      const cmd = readCommand(input, idx, depth + 1);
+      out += ` ${cmd.value} `;
+      idx = cmd.next;
+      continue;
+    }
+    if (ch === "{") {
+      const group = readBalanced(input, idx, "{", "}");
+      out += `{${convertLatexFragment(group.value, depth + 1)}}`;
+      idx = group.next;
+      continue;
+    }
+    if (ch === "_" || ch === "^") {
+      const script = readGroupOrToken(input, idx + 1, depth);
+      out += ` ${ch}{${script.value}}`;
+      idx = script.next;
+      continue;
+    }
+    if (ch === "&") {
+      out += " & ";
+      idx++;
+      continue;
+    }
+    out += ch;
+    idx++;
+  }
+  return normalizeEqEdit(out);
+}
+function quoteReservedKeywords(latex) {
+  return latex.replace(/([_^])\s*\{\s*([A-Za-z]+)\s*\}/g, (match, op, word) => RESERVED_WORDS.has(word) ? `${op}{"${word}"}` : match);
+}
+function latexLikeToEqEdit(input) {
+  const src = stripMathDelimiters(input);
+  if (src.length > MAX_EQUATION_SOURCE) return normalizeEqEdit(src);
+  return convertLatexFragment(quoteReservedKeywords(src), 0);
+}
+function estimateEquationMetrics(script) {
+  const cleaned = script.replace(/[{}\\^_]/g, "").replace(/\s+/g, " ").trim();
+  const width = Math.min(Math.max(cleaned.length, 5) * 700 + 2e3, 4e4);
+  const rowCount = Math.max(1, (script.match(/#/g) ?? []).length + 1);
+  if (/\bmatrix\b|#/.test(script)) {
+    if (rowCount >= 4) return { width, height: 5500, baseline: 55 };
+    if (rowCount === 3) return { width, height: 4500, baseline: 60 };
+    return { width, height: 3260, baseline: 63 };
+  }
+  if (/\bover\b|\broot\b|\bsqrt\b/.test(script)) return { width, height: 3010, baseline: 69 };
+  return { width, height: 1450, baseline: 71 };
+}
+function generateEquationXml(script, zOrder = 0) {
+  const { width, height, baseline } = estimateEquationMetrics(script);
+  const eqId = 2000000001 + zOrder;
+  return `<hp:equation id="${eqId}" zOrder="${zOrder}" numberingType="EQUATION" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" version="Equation Version 60" baseLine="${baseline}" textColor="#000000" baseUnit="1200" lineMode="CHAR" font="HYhwpEQ"><hp:sz width="${width}" widthRelTo="ABSOLUTE" height="${height}" heightRelTo="ABSOLUTE" protect="0"/><hp:pos treatAsChar="1" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="PARA" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/><hp:outMargin left="56" right="56" top="0" bottom="0"/><hp:shapeComment>\uC218\uC2DD\uC785\uB2C8\uB2E4.</hp:shapeComment><hp:script>${escapeXml(script)}</hp:script></hp:equation>`;
+}
+function generateEquationParagraph(input, zOrder = 0) {
+  const script = latexLikeToEqEdit(input);
+  return `<hp:p paraPrIDRef="${PARA_NORMAL}" styleIDRef="0"><hp:run charPrIDRef="${CHAR_NORMAL}">${generateEquationXml(script, zOrder)}</hp:run></hp:p>`;
+}
+
 // src/hwpx/gen-section.ts
 function generateSecPr(gongmun) {
   const m = gongmun ? {
@@ -21755,6 +22085,15 @@ function blocksToSectionXml(blocks, theme, gongmun, gongmunList = gongmun ? prec
         xml = codeLines.map((line) => generateParagraph(line || " ", PARA_CODE)).join("\n  ");
         break;
       }
+      case "equation": {
+        if (isFirst) {
+          const secRun = `<hp:run charPrIDRef="0">${generateSecPr(gongmun)}<hp:t></hp:t></hp:run>`;
+          paraXmls.push(`<hp:p paraPrIDRef="0" styleIDRef="0">${secRun}</hp:p>`);
+          isFirst = false;
+        }
+        xml = generateEquationParagraph(block.text || "", blockIdx);
+        break;
+      }
       case "blockquote":
         xml = generateParagraph(
           block.text || "",
@@ -24586,7 +24925,7 @@ async function parseHwp(buffer, options) {
 async function parsePdf(buffer, options) {
   let parsePdfDocument;
   try {
-    const mod = await import("./parser-2THIF623.js");
+    const mod = await import("./parser-NCNME2Z6.js");
     parsePdfDocument = mod.parsePdfDocument;
   } catch {
     return {