confluence-cli 2.3.0 → 2.3.1

package/lib/macro-converter.js

@@ -9,6 +9,25 @@ const CALLOUT_MARKERS = ['info', 'warning', 'note'];
 // and survives editor / formatter / lint passes that strip invisible chars.
 const STASH_DELIM = '\uE000';
 
+// Inline HTML tags that markdown has no native syntax for. The walker emits
+// them as raw HTML on storage\u2192markdown, so they must round-trip back through
+// markdownToStorage; without this whitelist, MarkdownIt (html: false) escapes
+// them to literal `<...>` and the formatting is lost.
+//
+// The lookahead `(?=[\s/>])` after the tag name rejects strings that look
+// like markdown autolinks (e.g. `<u@example.com>`, `<sub:foo>`) \u2014 a plain
+// `\b` word boundary would let these through and break linkify.
+//
+// The body alternation `"[^"]*"|'[^']*'|[^>]` makes the match quote-aware
+// so a literal `>` inside a quoted attribute value (e.g.
+// `<mark title="1>0">`) does not terminate the tag prematurely.
+const PASSTHROUGH_TAG_RE = /<\/?(?:u|sub|sup|mark)(?=[\s/>])(?:"[^"]*"|'[^']*'|[^>])*>/gi;
+// Single-backtick inline code spans. Block-level code (fenced + indented) is
+// detected via MarkdownIt's tokenizer in `_findCodeRanges` because a regex
+// can't reliably distinguish a 4-space-indented code block from a list-item
+// continuation that happens to align to four spaces.
+const INLINE_CODE_RE = /`[^`\n]+`/g;
+
 class MacroConverter {
   constructor({ isCloud = false, webUrlPrefix = '', buildUrl = null, linkStyle = null } = {}) {
     this._isCloud = isCloud;
@@ -57,13 +76,79 @@ class MacroConverter {
   }
 
   markdownToStorage(markdown) {
-    const html = this.markdown.render(markdown);
-    return this.htmlToConfluenceStorage(html);
+    return this.htmlToConfluenceStorage(this._renderMarkdownToHtml(markdown));
   }
 
   markdownToNativeStorage(markdown) {
-    const html = this.markdown.render(markdown);
-    return this.htmlToConfluenceStorage(html);
+    return this.htmlToConfluenceStorage(this._renderMarkdownToHtml(markdown));
+  }
+
+  // Pre-stashes whitelisted inline HTML so MarkdownIt won't escape it, renders,
+  // then restores. Code regions (fenced, indented, and inline) are skipped so a
+  // literal `<u>` typed inside a code block survives MarkdownIt's escape and
+  // round-trips as text rather than as a real tag — which would otherwise be
+  // smuggled past the escape and dropped by `convertCodeBlock`'s text-only
+  // child collection in html-to-storage.
+  _renderMarkdownToHtml(markdown) {
+    const codeRanges = this._findCodeRanges(markdown);
+    const htmlStash = [];
+    const stashHtml = (text) => text.replace(PASSTHROUGH_TAG_RE, (m) => {
+      htmlStash.push(m);
+      return `${STASH_DELIM}H${htmlStash.length - 1}${STASH_DELIM}`;
+    });
+
+    let src = '';
+    let pos = 0;
+    for (const [start, end] of codeRanges) {
+      src += stashHtml(markdown.slice(pos, start));
+      src += markdown.slice(start, end);
+      pos = end;
+    }
+    src += stashHtml(markdown.slice(pos));
+
+    const html = this.markdown.render(src);
+    return html.replace(
+      new RegExp(`${STASH_DELIM}H(\\d+)${STASH_DELIM}`, 'g'),
+      (m, i) => htmlStash[+i] ?? m,
+    );
+  }
+
+  // Returns merged, sorted character ranges covering all code regions in the
+  // markdown source — fenced and indented blocks via MarkdownIt's tokenizer
+  // (which correctly distinguishes them from list-item continuations) and
+  // single-backtick inline spans via regex (MarkdownIt parses these into
+  // `code_inline` tokens but does not expose source positions for them).
+  _findCodeRanges(markdown) {
+    const tokens = this.markdown.parse(markdown, {});
+    const lineStarts = [0];
+    for (let i = 0; i < markdown.length; i++) {
+      if (markdown[i] === '\n') lineStarts.push(i + 1);
+    }
+    const lineToChar = (n) => (n < lineStarts.length ? lineStarts[n] : markdown.length);
+
+    const ranges = [];
+    for (const tok of tokens) {
+      if ((tok.type === 'code_block' || tok.type === 'fence') && tok.map) {
+        ranges.push([lineToChar(tok.map[0]), lineToChar(tok.map[1])]);
+      }
+    }
+    INLINE_CODE_RE.lastIndex = 0;
+    let m;
+    while ((m = INLINE_CODE_RE.exec(markdown)) !== null) {
+      ranges.push([m.index, m.index + m[0].length]);
+    }
+
+    ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const merged = [];
+    for (const r of ranges) {
+      const last = merged[merged.length - 1];
+      if (last && r[0] <= last[1]) {
+        last[1] = Math.max(last[1], r[1]);
+      } else {
+        merged.push([r[0], r[1]]);
+      }
+    }
+    return merged;
   }
 
   htmlToConfluenceStorage(html) {

package/lib/storage-walker.js

@@ -200,6 +200,7 @@ class StorageWalker {
     case 'blockquote':
       return this.handleBlockquote(node);
     case 'details': case 'summary':
+    case 'u': case 'sub': case 'sup': case 'mark':
       return `<${tag}>` + this.walkNodes(node.children) + `</${tag}>`;
     case 'ac:structured-macro':
       return this.handleMacro(node);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "confluence-cli",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "confluence-cli",
-      "version": "2.3.0",
+      "version": "2.3.1",
       "license": "MIT",
       "dependencies": {
         "axios": "^1.15.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {