@knowvah/dot-engine 2.6.6 → 2.6.7

package/dist/render.js

@@ -5982,13 +5982,14 @@ function skipSpace(text, i) {
   return j;
 }
 var byteLength = (s) => new TextEncoder().encode(s).length;
-function fedBytes(unit, isText) {
-  if (!isText) return byteLength(unit);
-  let text = unit.replace(/&([^;&<]*);/g, (m, name) => {
+function fedText(piece, endsUnit) {
+  const text = piece.replace(/&([^;&<]*);/g, (m, name) => {
     return name.length >= 2 && Object.hasOwn(HTML_ENTITIES, name) ? `&#${HTML_ENTITIES[name]};` : m;
   });
-  if (text.endsWith("]")) text = `${text.slice(0, -1)}&#93;`;
-  return byteLength(text);
+  return endsUnit && text.endsWith("]") ? `${text.slice(0, -1)}&#93;` : text;
+}
+function fedBytes(unit, isText) {
+  return byteLength(isText ? fedText(unit, true) : unit);
 }
 function scanValue(text, j) {
   const q = text[j];
@@ -6090,26 +6091,45 @@ function scanMarkup(text, p) {
   if (c === "!") return { scan: scanDeclaration(text, p), kind: "tag" };
   return { scan: scanStartTag(text, p), kind: "tag" };
 }
-function scanContent(text, base) {
+var CDATA_OPEN = "<![CDATA[";
+var CDATA_CLOSE = "]]>";
+function scanCdata(text, p, base, dataOf, tokens) {
+  const close = text.indexOf(CDATA_CLOSE, p);
+  const end = close < 0 ? text.length : close;
+  if (end > p) tokens.push({ kind: "cdata", start: base + p, end: base + end, data: dataOf(base + p, base + end) });
+  return close < 0 ? -1 : close + CDATA_CLOSE.length;
+}
+function scanText(text, p, base, tokens) {
+  const e = text.indexOf("<", p);
+  const end = e < 0 ? text.length : e;
+  tokens.push({ kind: "text", start: base + p, end: base + end });
+  return end;
+}
+function scanContent(text, base, inCdata, dataOf) {
   const tokens = [];
   let p = 0;
+  let inSection = inCdata;
   while (p < text.length) {
+    if (inSection || text.startsWith(CDATA_OPEN, p)) {
+      const after2 = scanCdata(text, inSection ? p : p + CDATA_OPEN.length, base, dataOf, tokens);
+      if (after2 < 0) return { tokens, consumed: text.length, inCdata: true };
+      inSection = false;
+      p = after2;
+      continue;
+    }
     if (text[p] !== "<") {
-      const e = text.indexOf("<", p);
-      const end = e < 0 ? text.length : e;
-      tokens.push({ kind: "text", start: base + p, end: base + end });
-      p = end;
+      p = scanText(text, p, base, tokens);
       continue;
     }
     const { scan, kind } = scanMarkup(text, p);
-    if (scan.kind === "invalid") return { tokens, consumed: p, invalid: base + scan.offset };
-    if (scan.kind === "partial") return { tokens, consumed: p };
+    if (scan.kind === "invalid") return { tokens, consumed: p, invalid: base + scan.offset, inCdata: false };
+    if (scan.kind === "partial") return { tokens, consumed: p, inCdata: false };
     const tok = { kind, start: base + p, end: base + scan.end };
     if (scan.dup !== void 0) tok.dup = base + scan.dup;
     tokens.push(tok);
     p = scan.end;
   }
-  return { tokens, consumed: p };
+  return { tokens, consumed: p, inCdata: inSection };
 }
 var InputBuffer = class {
   size = 0;
@@ -6160,24 +6180,42 @@ var ExpatFeed = class {
   buffer = new InputBuffer();
   heldStart = 0;
   fedEnd = 0;
+  inCdata = false;
+  /** Source ranges of the text units fed so far: their bytes went through findNext's rewrite. */
+  textUnits = [];
   /** Start of the token expat still holds, or undefined when it holds nothing. */
   get held() {
     return this.heldStart < this.fedEnd ? this.heldStart : void 0;
   }
-  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`. */
-  feed(start, end, nbytes) {
-    this.buffer.append(nbytes);
+  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`; `isText` for a text unit. */
+  feed(start, end, isText) {
+    if (isText) this.textUnits.push([start, end]);
+    this.buffer.append(fedBytes(this.src.slice(start, end), isText));
     this.fedEnd = end;
     if (!this.buffer.enough) return { tokens: [] };
     const text = this.src.slice(this.heldStart, end);
-    const scan = scanContent(text, this.heldStart);
+    const scan = scanContent(text, this.heldStart, this.inCdata, (a, b) => this.fedBetween(a, b));
     if (scan.invalid !== void 0) {
       return { tokens: scan.tokens, invalid: { message: XML_ERROR_INVALID_TOKEN, offset: scan.invalid } };
     }
+    this.inCdata = scan.inCdata;
     this.heldStart += scan.consumed;
     this.buffer.consumedTo(byteLength(this.src.slice(this.heldStart, end)), scan.consumed > 0);
     return { tokens: scan.tokens };
   }
+  /** What expat read for source offsets [start, end): text-unit pieces as findNext rewrote them. */
+  fedBetween(start, end) {
+    let out = "";
+    let p = start;
+    for (const [us, ue] of this.textUnits) {
+      if (ue <= p || us >= end) continue;
+      if (us > p) out += this.src.slice(p, us);
+      const e = Math.min(ue, end);
+      out += fedText(this.src.slice(Math.max(us, p), e), e === ue);
+      p = e;
+    }
+    return out + this.src.slice(p, end);
+  }
 };
 var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
 var ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
@@ -6202,6 +6240,46 @@ function parseTagChunk(chunk) {
   return { close, selfClose: !close && body.endsWith("/"), name };
 }
 
+// src/common/htmltable-lex-chardata.ts
+var initialCharData = () => ({ inCell: true, xb: "" });
+function startInCell(name, inCell) {
+  if (name === "TABLE" || name === "TR" || name === "TH") return false;
+  return name === "TD" ? true : inCell;
+}
+function endInCell(name, inCell) {
+  if (name === "TABLE") return true;
+  return name === "TD" ? false : inCell;
+}
+function tagInCell(st, tag) {
+  const name = tag.name.toUpperCase();
+  if (tag.close) {
+    st.inCell = endInCell(name, st.inCell);
+    return;
+  }
+  st.inCell = startInCell(name, st.inCell);
+  if (tag.selfClose) st.inCell = endInCell(name, st.inCell);
+}
+function keepLostText(st, lost) {
+  for (const t of lost) if (t.type === "text") st.xb += t.value;
+}
+function releaseXb(st, first) {
+  if (st.xb === "") return;
+  if (first.type === "text") first.value = st.xb + first.value;
+  else if (first.type === "open" && first.tag === "TABLE") first.heldText = st.xb;
+  else return;
+  st.xb = "";
+}
+function cleanText(decoded) {
+  return decoded.replace(/[\x00-\x1f]/g, "");
+}
+function textTokens(raw) {
+  return charDataTokens(htmlEntityUTF8(raw));
+}
+function charDataTokens(decoded) {
+  const clean = cleanText(decoded);
+  return clean.length > 0 ? [{ type: "text", value: clean }] : [];
+}
+
 // src/common/htmltable-lex-units.ts
 var UNCLOSED_COMMENT = "Warning: Unclosed comment\n";
 var LABEL_CLOSED = "Warning: Label closed before end of HTML element\n";
@@ -6306,20 +6384,17 @@ function parseCloseToken(inner) {
   checkTag(tag);
   return { type: "close", tag: normalizeTag(tag) };
 }
-function cleanText(raw) {
-  const isKeep = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
-  return raw.replace(/[\x00-\x1f\x7f]/g, (c) => isKeep(c) ? c : "");
-}
-function textTokens(raw) {
-  const clean = htmlEntityUTF8(cleanText(raw));
-  return clean.length > 0 ? [{ type: "text", value: clean }] : [];
-}
+var EMPTY_ELEMENTS = /* @__PURE__ */ new Set(["BR", "HR", "VR", "IMG"]);
 function tagTokens(text) {
   const inner = text.slice(1, -1).trim();
   if (inner.startsWith("/")) return [parseCloseToken(inner)];
   if (inner.endsWith("/")) {
     const open = parseOpenToken(inner.slice(0, -1).trim());
-    return [open, { type: "close", tag: open.tag }];
+    if (EMPTY_ELEMENTS.has(open.tag)) return [open, { type: "close", tag: open.tag }];
+    const close = { type: "close", tag: open.tag };
+    if (open.warnings !== void 0) close.warnings = open.warnings;
+    if (open.warn === true) close.warn = true;
+    return [close];
   }
   return [parseOpenToken(inner)];
 }
@@ -6392,6 +6467,7 @@ function eventTokens(site) {
   const { src, tok, st } = site;
   const text = src.slice(tok.start, tok.end);
   if (tok.kind === "comment" || tok.kind === "pi") return [];
+  if (tok.kind === "cdata") return charDataTokens(tok.data ?? "");
   if (tok.kind === "tag") {
     checkTagToken(site);
     return tagTokens(text);
@@ -6417,7 +6493,13 @@ function absorb(carry, lost) {
 function eventGroups(run, res) {
   const groups = [];
   for (const tok of res.tokens) {
-    const tokens = eventTokens({ src: run.src, tok, st: run.st });
+    let tokens = eventTokens({ src: run.src, tok, st: run.st });
+    if (tok.kind === "tag") {
+      const tag = parseTagChunk(run.src.slice(tok.start, tok.end));
+      if (tag !== void 0) tagInCell(run.cd, tag);
+    } else if (!run.cd.inCell) {
+      tokens = [];
+    }
     if (tokens.length > 0) groups.push({ tokens, tok });
   }
   if (res.invalid !== void 0) {
@@ -6428,6 +6510,7 @@ function eventGroups(run, res) {
 }
 function deliver(run, last) {
   const first = last.tokens[0];
+  releaseXb(run.cd, first);
   attachCarry(run.carry, first);
   const info = { src: run.src, pos: last.tok.start, end: last.tok.end, context: run.st.prev + run.st.curr };
   const prev = run.tokens.at(-1);
@@ -6442,7 +6525,10 @@ function deliver(run, last) {
 function runEvents(run, res) {
   const groups = eventGroups(run, res);
   const last = groups.pop();
-  for (const g of groups) absorb(run.carry, g.tokens);
+  for (const g of groups) {
+    absorb(run.carry, g.tokens);
+    keepLostText(run.cd, g.tokens);
+  }
   if (last !== void 0) deliver(run, last);
 }
 function appendString(into, more) {
@@ -6473,7 +6559,8 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
     tokens: [],
     st: { stack: [], prev: "", curr: "" },
     expat: new ExpatFeed(src),
-    carry: { warnings: [], warn: false }
+    carry: { warnings: [], warn: false },
+    cd: initialCharData()
   };
   let error;
   try {
@@ -6482,8 +6569,7 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
       run.st.curr = src.slice(u.start, u.end);
       run.carry.warnings.push(...u.warnings);
       if (u.warn) run.carry.warn = true;
-      const nbytes = fedBytes(run.st.curr, !run.st.curr.startsWith("<"));
-      runEvents(run, run.expat.feed(u.start, u.end, nbytes));
+      runEvents(run, run.expat.feed(u.start, u.end, !run.st.curr.startsWith("<")));
     }
     const held = run.expat.held;
     if (held !== void 0) error = unfinishedError(run, held);
@@ -6648,7 +6734,8 @@ var tableFont = (fontStack) => {
 var MSG_SYNTAX_ERROR = "syntax error";
 var MSG_TEXT_BEFORE_TABLE = "Syntax error: non-space string used before <TABLE>";
 var MSG_TEXT_AFTER_TABLE = "Syntax error: non-space string used after </TABLE>";
-var nonSpace = (text) => /[^ \t\n\r]/.test(text);
+var nonSpace = (text) => /[^ ]/.test(text);
+var heldNonSpace = (tbl) => tbl?.type === "open" && nonSpace(tbl.heldText ?? "");
 var parseError = (s, tok, message) => {
   if (tok !== void 0) emitWarnings(s, tok);
   else emitEof(s);
@@ -6669,41 +6756,29 @@ var applyBrTag = (s, t, fontStack, items) => {
   items.push({ br: true, brAlign: parseAlign(t.attrs["align"] ?? ""), ...fontItemProps(font) });
   consumeClose(s, "BR");
 };
-var applyFontTag = (s, t, fontStack, items) => {
-  consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, {
-    fontColor: t.attrs["color"],
-    fontFace: t.attrs["face"],
-    fontSize: num(t.attrs["point-size"])
-  }));
+var parseStyledText = (s, tag, fontStack, items) => {
   const inner = parseText(s, fontStack);
   fontStack.pop();
-  items.push(...inner.items);
   const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "FONT") consume(s);
+  if (inner.items.length === 0 || nxt?.type !== "close" || nxt.tag !== tag) {
+    throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  }
+  items.push(...inner.items);
+  consume(s);
 };
-var applyInlineTag = (s, t, fontStack, items) => {
+var applyStyleTag = (s, t, fontStack, items) => {
   consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, inlineFontState(t.tag, t.attrs)));
-  const inner = parseText(s, fontStack);
-  fontStack.pop();
-  items.push(...inner.items);
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === t.tag) consume(s);
+  const own = t.tag === "FONT" ? { fontColor: t.attrs["color"], fontFace: t.attrs["face"], fontSize: num(t.attrs["point-size"]) } : inlineFontState(t.tag, t.attrs);
+  fontStack.push(mergeFontState(fontStack[fontStack.length - 1] ?? {}, own));
+  parseStyledText(s, t.tag, fontStack, items);
 };
 var applyOpenTag = (s, t, fontStack, items) => {
   if (t.tag === "BR") {
     applyBrTag(s, t, fontStack, items);
     return true;
   }
-  if (t.tag === "FONT") {
-    applyFontTag(s, t, fontStack, items);
-    return true;
-  }
-  if (isInlineTag(t.tag)) {
-    applyInlineTag(s, t, fontStack, items);
+  if (t.tag === "FONT" || isInlineTag(t.tag)) {
+    applyStyleTag(s, t, fontStack, items);
     return true;
   }
   return false;
@@ -6746,7 +6821,7 @@ var parseFontTable = (s, open, fontStack) => {
   fontStack.push(wrapperFont(open, fontStack));
   const textBefore = skipStrings(s);
   const tblTok = peek(s);
-  if (textBefore && tblTok !== void 0) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
+  if ((textBefore || heldNonSpace(tblTok)) && tblTok !== void 0) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   const textAfter = skipStrings(s);
   const close = peek(s);
@@ -6775,7 +6850,7 @@ var parseImgContent = (s, t, cellAttrs) => {
 };
 var scanCellTable = (s, t, fontStack, st) => {
   if (st.kind === "image" || st.kind === "table") throw parseError(s, t, MSG_SYNTAX_ERROR);
-  if (st.textNonSpace) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
+  if (st.textNonSpace || heldNonSpace(t)) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
   const tbl = parseTable(s, fontStack);
   st.kind = "table";
   return [tbl];
@@ -6930,14 +7005,14 @@ var consumeRowHr = (s, rows) => {
 var findFirstRealToken = (tokens, start) => {
   for (let i = start; i < tokens.length; i++) {
     const tk = tokens[i];
-    if (tk.type !== "text" || tk.value.trim() !== "") return tk;
+    if (tk.type !== "text" || nonSpace(tk.value)) return tk;
   }
   return void 0;
 };
 var skipLeadingWs = (s) => {
   while (true) {
     const nxt = peek(s);
-    if (!nxt || nxt.type !== "text" || nxt.value.trim() !== "") break;
+    if (!nxt || nxt.type !== "text" || nonSpace(nxt.value)) break;
     consume(s);
   }
 };
@@ -6963,6 +7038,7 @@ var parseFontTableLabel = (s, open, fontStack) => {
 };
 var parseTableLabel = (s, fontStack) => {
   skipLeadingWs(s);
+  if (heldNonSpace(peek(s))) throw parseError(s, peek(s), MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   finishTableLabel(s);
   return { kind: "table", table };