tdecollab 0.3.5 → 0.3.6

package/dist/{chunk-JUM5ZG64.js → chunk-SIKUIQKX.js}

@@ -1,20 +1,24 @@
 import {
-  __require,
   logger
-} from "./chunk-6RIA6AJ3.js";
+} from "./chunk-IFYMZLQI.js";
 
 // tools/common/env-loader.ts
 import dotenv from "dotenv";
+import fs from "fs";
 import path from "path";
 import os from "os";
 var loaded = false;
+var lastResult = null;
 function getHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
 function loadEnv() {
-  const result = { loadedFiles: [], skippedFiles: [] };
-  if (loaded) return result;
+  if (loaded && lastResult) return lastResult;
+  const result = { loadedFiles: [], skippedFiles: [], sources: {} };
   loaded = true;
+  for (const key of Object.keys(process.env)) {
+    result.sources[key] = "shell env";
+  }
   const candidates = [
     // 우선순위 2: 현재 디렉토리
     path.resolve(process.cwd(), "tdecollab.env"),
@@ -22,15 +26,31 @@ function loadEnv() {
     path.join(getHomeDir(), ".config", "tdecollab", ".env")
   ];
   for (const filepath of candidates) {
+    let parsed = {};
+    try {
+      parsed = dotenv.parse(fs.readFileSync(filepath, "utf-8"));
+    } catch {
+    }
+    const beforeKeys = new Set(Object.keys(process.env));
     const out = dotenv.config({ path: filepath, override: false });
     if (out.error) {
       result.skippedFiles.push(filepath);
     } else {
       result.loadedFiles.push(filepath);
+      for (const key of Object.keys(parsed)) {
+        if (!beforeKeys.has(key) && process.env[key] !== void 0) {
+          result.sources[key] = filepath;
+        }
+      }
     }
   }
+  lastResult = result;
   return result;
 }
+function getEnvSource(key) {
+  const result = loadEnv();
+  return result.sources[key] || "<unset>";
+}
 
 // tools/confluence/api/content.ts
 var ConfluenceContentApi = class {
@@ -322,7 +342,8 @@ function getEnvOrThrow(key, description) {
 }
 function loadConfluenceConfig() {
   const baseUrl = getEnvOrThrow("CONFLUENCE_BASE_URL", "Confluence \uAE30\uBCF8 URL");
-  const username = process.env.CONFLUENCE_USERNAME;
+  const authType = (process.env.CONFLUENCE_AUTH_TYPE || "bearer").toLowerCase();
+  const username = authType === "basic" ? process.env.CONFLUENCE_USERNAME : void 0;
   const token = getEnvOrThrow("CONFLUENCE_API_TOKEN", "Confluence PAT \uD1A0\uD070");
   const mermaidMacroName = process.env.CONFLUENCE_MERMAID_MACRO_NAME || "mermaiddiagram";
   const inlineCodeStyle = process.env.CONFLUENCE_INLINE_CODE_STYLE || "color: #d04437; font-weight: bold;";
@@ -369,14 +390,191 @@ function loadGitlabConfig() {
 
 // tools/confluence/converters/md-to-storage.ts
 import MarkdownIt from "markdown-it";
+var DEFAULT_MERMAID_MACRO_NAME = "mermaiddiagram";
+var DEFAULT_INLINE_CODE_STYLE = "color: #d04437; font-weight: bold;";
+var TASK_ITEM_PATTERN = /^\[([ xX])\]\s+/;
+function decodeLocalImagePath(value) {
+  try {
+    return decodeURI(value);
+  } catch {
+    return value;
+  }
+}
+function escapeXmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function parseImageDimensionTitle(title) {
+  if (!title) {
+    return "";
+  }
+  const width = title.match(/\bwidth=(\d+)\b/i)?.[1];
+  const height = title.match(/\bheight=(\d+)\b/i)?.[1];
+  const attrs = [
+    width ? ` ac:width="${escapeXmlAttribute(width)}"` : "",
+    height ? ` ac:height="${escapeXmlAttribute(height)}"` : ""
+  ];
+  return attrs.join("");
+}
+function getTaskMarker(content) {
+  const match = content.match(TASK_ITEM_PATTERN);
+  if (!match) {
+    return null;
+  }
+  return {
+    checked: match[1].toLowerCase() === "x",
+    body: content.slice(match[0].length)
+  };
+}
+function findMatchingCloseIndex(tokens, openIndex) {
+  const openToken = tokens[openIndex];
+  let nesting = 1;
+  for (let idx = openIndex + 1; idx < tokens.length; idx++) {
+    const token = tokens[idx];
+    if (token.type === openToken.type) {
+      nesting++;
+    }
+    if (token.type === openToken.type.replace("_open", "_close")) {
+      nesting--;
+      if (nesting === 0) {
+        return idx;
+      }
+    }
+  }
+  return openIndex;
+}
+function annotateTaskListTokens(tokens) {
+  const listItemStack = [];
+  for (let idx = 0; idx < tokens.length; idx++) {
+    const token = tokens[idx];
+    if (token.type === "list_item_open") {
+      listItemStack.push(idx);
+      continue;
+    }
+    if (token.type === "list_item_close") {
+      listItemStack.pop();
+      continue;
+    }
+    if (token.type !== "inline" || listItemStack.length === 0) {
+      continue;
+    }
+    const task = getTaskMarker(token.content);
+    if (!task) {
+      continue;
+    }
+    const listItemOpenIndex = listItemStack[listItemStack.length - 1];
+    if (tokens[listItemOpenIndex].meta?.task) {
+      continue;
+    }
+    token.content = task.body;
+    if (token.children?.[0]?.type === "text") {
+      token.children[0].content = token.children[0].content.replace(TASK_ITEM_PATTERN, "");
+    }
+    tokens[listItemOpenIndex].meta = {
+      ...tokens[listItemOpenIndex].meta || {},
+      task
+    };
+    if (tokens[idx - 1]?.type === "paragraph_open") {
+      tokens[idx - 1].meta = {
+        ...tokens[idx - 1].meta || {},
+        taskBodyParagraph: true
+      };
+    }
+    if (tokens[idx + 1]?.type === "paragraph_close") {
+      tokens[idx + 1].meta = {
+        ...tokens[idx + 1].meta || {},
+        taskBodyParagraph: true
+      };
+    }
+  }
+  annotateTaskListBoundaries(tokens);
+  annotateTaskListCloseTokens(tokens);
+}
+function annotateTaskListBoundaries(tokens) {
+  for (let idx = 0; idx < tokens.length; idx++) {
+    const token = tokens[idx];
+    if (token.type !== "bullet_list_open") {
+      continue;
+    }
+    const closeIndex = findMatchingCloseIndex(tokens, idx);
+    const directItemIndexes = [];
+    for (let cursor = idx + 1; cursor < closeIndex; cursor++) {
+      if (tokens[cursor].type === "list_item_open" && tokens[cursor].level === token.level + 1) {
+        directItemIndexes.push(cursor);
+      }
+    }
+    if (directItemIndexes.length === 0) {
+      continue;
+    }
+    const itemKinds = directItemIndexes.map((itemIndex) => !!tokens[itemIndex].meta?.task);
+    const firstIsNormal = !itemKinds[0];
+    const lastIsNormal = !itemKinds[itemKinds.length - 1];
+    token.meta = { ...token.meta || {}, renderList: firstIsNormal };
+    tokens[closeIndex].meta = { ...tokens[closeIndex].meta || {}, renderList: lastIsNormal };
+    directItemIndexes.forEach((itemIndex, itemPosition) => {
+      const itemToken = tokens[itemIndex];
+      if (!itemToken.meta?.task) {
+        return;
+      }
+      itemToken.meta.taskCloseParentBefore = itemPosition > 0 && !itemKinds[itemPosition - 1];
+      itemToken.meta.taskOpenParentAfter = itemPosition < itemKinds.length - 1 && !itemKinds[itemPosition + 1];
+    });
+  }
+}
+function annotateTaskListCloseTokens(tokens) {
+  const listItemStack = [];
+  for (let idx = 0; idx < tokens.length; idx++) {
+    const token = tokens[idx];
+    if (token.type === "list_item_open") {
+      listItemStack.push(idx);
+      continue;
+    }
+    if (token.type !== "list_item_close") {
+      continue;
+    }
+    const openIndex = listItemStack.pop();
+    if (openIndex === void 0 || !tokens[openIndex].meta?.task) {
+      continue;
+    }
+    token.meta = {
+      ...token.meta || {},
+      task: tokens[openIndex].meta.task,
+      taskOpenParentAfter: tokens[openIndex].meta.taskOpenParentAfter
+    };
+  }
+}
+function stripMarkdownFrontmatter(markdown) {
+  const frontmatterMatch = markdown.match(/^---[ \t]*\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/);
+  if (!frontmatterMatch) {
+    return markdown;
+  }
+  return markdown.slice(frontmatterMatch[0].length).replace(/^\r?\n/, "");
+}
+function stripLeakedConfluencePageIdArtifacts(markdown) {
+  let prepared = markdown;
+  const leakedPageIdPattern = /^(?:[ \t]*\r?\n)*(?:---|\*\*\*)[ \t]*\r?\n+(?:[ \t]*\r?\n)*#{1,6}[ \t]+confluence\\?_page\\?_id:[ \t]*\d+[ \t]*\r?\n+/i;
+  while (leakedPageIdPattern.test(prepared)) {
+    prepared = prepared.replace(leakedPageIdPattern, "").replace(/^\r?\n/, "");
+  }
+  return prepared;
+}
+function prepareMarkdownForConfluenceStorage(markdown) {
+  const withoutLeadingArtifacts = stripLeakedConfluencePageIdArtifacts(markdown);
+  const withoutFrontmatter = stripMarkdownFrontmatter(withoutLeadingArtifacts);
+  return stripLeakedConfluencePageIdArtifacts(withoutFrontmatter);
+}
 var MarkdownToStorageConverter = class {
   md;
   mermaidMacroName;
   inlineCodeStyle;
-  constructor() {
-    const config = loadConfluenceConfig();
-    this.mermaidMacroName = config.mermaidMacroName;
-    this.inlineCodeStyle = config.inlineCodeStyle;
+  constructor(options) {
+    if (options) {
+      this.mermaidMacroName = options.mermaidMacroName || DEFAULT_MERMAID_MACRO_NAME;
+      this.inlineCodeStyle = options.inlineCodeStyle || DEFAULT_INLINE_CODE_STYLE;
+    } else {
+      const config = loadConfluenceConfig();
+      this.mermaidMacroName = config.mermaidMacroName;
+      this.inlineCodeStyle = config.inlineCodeStyle;
+    }
     this.md = new MarkdownIt({
       html: true,
       linkify: true,
@@ -384,6 +582,50 @@ var MarkdownToStorageConverter = class {
       xhtmlOut: true
       // Confluence XML 파서와의 호환성을 위해 XHTML 출력 활성화
     });
+    this.md.core.ruler.after("inline", "confluence_task_list", (state) => {
+      annotateTaskListTokens(state.tokens);
+    });
+    this.md.renderer.rules.bullet_list_open = (tokens, idx, options2, env, self) => {
+      if (tokens[idx].meta?.renderList === false) {
+        return "";
+      }
+      return self.renderToken(tokens, idx, options2);
+    };
+    this.md.renderer.rules.bullet_list_close = (tokens, idx, options2, env, self) => {
+      if (tokens[idx].meta?.renderList === false) {
+        return "";
+      }
+      return self.renderToken(tokens, idx, options2);
+    };
+    this.md.renderer.rules.list_item_open = (tokens, idx, options2, env, self) => {
+      const task = tokens[idx].meta?.task;
+      if (!task) {
+        return self.renderToken(tokens, idx, options2);
+      }
+      const prefix = tokens[idx].meta.taskCloseParentBefore ? "</ul>\n" : "";
+      const status = task.checked ? "complete" : "incomplete";
+      return `${prefix}<ac:task-list><ac:task><ac:task-status>${status}</ac:task-status><ac:task-body>`;
+    };
+    this.md.renderer.rules.list_item_close = (tokens, idx, options2, env, self) => {
+      if (!tokens[idx].meta?.task) {
+        return self.renderToken(tokens, idx, options2);
+      }
+      const suffix = tokens[idx].meta.taskOpenParentAfter ? "\n<ul>" : "";
+      return suffix;
+    };
+    this.md.renderer.rules.paragraph_open = (tokens, idx, options2, env, self) => {
+      if (tokens[idx].meta?.taskBodyParagraph) {
+        return "";
+      }
+      return self.renderToken(tokens, idx, options2);
+    };
+    this.md.renderer.rules.paragraph_close = (tokens, idx, options2, env, self) => {
+      const task = tokens[idx].meta?.taskBodyParagraph;
+      if (task) {
+        return "</ac:task-body></ac:task></ac:task-list>";
+      }
+      return self.renderToken(tokens, idx, options2);
+    };
     this.md.renderer.rules.fence = (tokens, idx) => {
       const token = tokens[idx];
       const code = token.content.trim();
@@ -404,17 +646,19 @@ var MarkdownToStorageConverter = class {
   <ac:plain-text-body><![CDATA[${code}]]></ac:plain-text-body>
 </ac:structured-macro>`;
     };
-    this.md.renderer.rules.image = (tokens, idx, options, env, self) => {
+    this.md.renderer.rules.image = (tokens, idx, options2, env, self) => {
       const token = tokens[idx];
       const src = token.attrGet("src") || "";
       const alt = token.content || "";
+      const dimensionAttrs = parseImageDimensionTitle(token.attrGet("title"));
       const isExternal = src.startsWith("http://") || src.startsWith("https://");
-      const altAttr = alt ? ` ac:alt="${this.md.utils.escapeHtml(alt)}"` : "";
+      const altAttr = alt ? ` ac:alt="${escapeXmlAttribute(alt)}"` : "";
       if (isExternal) {
-        return `<ac:image${altAttr}><ri:url ri:value="${src}" /></ac:image>`;
+        return `<ac:image${altAttr}${dimensionAttrs}><ri:url ri:value="${escapeXmlAttribute(src)}" /></ac:image>`;
       } else {
-        const filename = src.split("/").pop() || src;
-        return `<ac:image${altAttr}><ri:attachment ri:filename="${filename}" /></ac:image>`;
+        const decodedSrc = decodeLocalImagePath(src);
+        const filename = decodedSrc.split("/").pop() || decodedSrc;
+        return `<ac:image${altAttr}${dimensionAttrs}><ri:attachment ri:filename="${escapeXmlAttribute(filename)}" /></ac:image>`;
       }
     };
     this.md.renderer.rules.code_inline = (tokens, idx) => {
@@ -424,10 +668,10 @@ var MarkdownToStorageConverter = class {
     };
   }
   convert(markdown) {
-    return this.md.render(markdown);
+    return this.md.render(prepareMarkdownForConfluenceStorage(markdown));
   }
   extractLocalImages(markdown) {
-    const tokens = this.md.parse(markdown, {});
+    const tokens = this.md.parse(prepareMarkdownForConfluenceStorage(markdown), {});
     const localImages = /* @__PURE__ */ new Set();
     const walk = (tokens2) => {
       for (const token of tokens2) {
@@ -450,6 +694,38 @@ var MarkdownToStorageConverter = class {
 // tools/confluence/converters/storage-to-md.ts
 import TurndownService from "turndown";
 import { gfm } from "turndown-plugin-gfm";
+import { createRequire } from "module";
+function parseHtmlDocument(html) {
+  if (typeof window !== "undefined" && typeof window.DOMParser !== "undefined") {
+    const parser = new window.DOMParser();
+    return parser.parseFromString(html, "text/html");
+  }
+  const requireBase = process.argv[1] || `${process.cwd()}/package.json`;
+  const nodeRequire = createRequire(requireBase);
+  const { JSDOM } = nodeRequire("jsdom");
+  return new JSDOM(html).window.document;
+}
+function getXmlAttribute(attrs, name) {
+  const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return attrs.match(new RegExp(`(?:^|\\s)${escapedName}="([^"]*)"`, "i"))?.[1];
+}
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeMarkdownImageText(value) {
+  return value.replace(/\\/g, "\\\\").replace(/]/g, "\\]");
+}
+function escapeMarkdownImageDestination(value) {
+  return value.replace(/\)/g, "\\)");
+}
+function buildImageDimensionAttributes(attrs) {
+  const width = getXmlAttribute(attrs, "ac:width") || getXmlAttribute(attrs, "width");
+  const height = getXmlAttribute(attrs, "ac:height") || getXmlAttribute(attrs, "height");
+  return [
+    width ? ` width="${escapeHtmlAttribute(width)}"` : "",
+    height ? ` height="${escapeHtmlAttribute(height)}"` : ""
+  ].join("");
+}
 var StorageToMarkdownConverter = class {
   turndown;
   jiraBaseUrl;
@@ -467,6 +743,37 @@ var StorageToMarkdownConverter = class {
     this.setupRules();
   }
   setupRules() {
+    this.turndown.addRule("imagesWithDimensions", {
+      filter: (node) => {
+        if (node.nodeName.toLowerCase() !== "img") return false;
+        const element = node;
+        return element.hasAttribute("width") || element.hasAttribute("height");
+      },
+      replacement: (_content, node) => {
+        const element = node;
+        const src = element.getAttribute("src") || "";
+        const alt = element.getAttribute("alt") || "";
+        const width = element.getAttribute("width");
+        const height = element.getAttribute("height");
+        const title = [
+          width ? `width=${width}` : "",
+          height ? `height=${height}` : ""
+        ].filter(Boolean).join(" ");
+        return `![${escapeMarkdownImageText(alt)}](${escapeMarkdownImageDestination(src)} "${title}")`;
+      }
+    });
+    this.turndown.addRule("lists", {
+      filter: (node) => {
+        const nodeName = node.nodeName.toLowerCase();
+        if (nodeName !== "ul" && nodeName !== "ol") return false;
+        return Array.from(node.children).some((child) => {
+          return child.nodeName.toLowerCase() === "li" && this.getExplicitListItemDepth(child) !== void 0;
+        });
+      },
+      replacement: (_content, node) => {
+        return this.renderList(node, 0);
+      }
+    });
     this.turndown.addRule("tables", {
       filter: ["table"],
       replacement: (content, node) => {
@@ -566,6 +873,83 @@ ${bodyMd}
       }
     });
   }
+  renderList(listElement, depth) {
+    const isOrdered = listElement.nodeName.toLowerCase() === "ol";
+    const start = Number(listElement.getAttribute("start") || "1");
+    let orderedIndex = Number.isFinite(start) && start > 0 ? start : 1;
+    const renderedItems = Array.from(listElement.children).filter((child) => child.nodeName.toLowerCase() === "li").map((item) => {
+      const itemDepth = this.getListItemDepth(item, depth);
+      const marker = isOrdered ? `${orderedIndex++}.` : "-";
+      const indent = "    ".repeat(itemDepth);
+      const content = this.renderListItemContent(item);
+      const firstLine = `${indent}${marker}${content ? ` ${content.split("\n")[0]}` : ""}`;
+      const remainingLines = content.split("\n").slice(1).filter((line) => line.trim().length > 0).map((line) => `${indent}  ${line}`).join("\n");
+      const nestedLists = Array.from(item.children).filter((child) => {
+        const nodeName = child.nodeName.toLowerCase();
+        return nodeName === "ul" || nodeName === "ol";
+      }).map((child) => this.renderList(child, itemDepth + 1).trim()).filter(Boolean).join("\n");
+      return [firstLine, remainingLines, nestedLists].filter(Boolean).join("\n");
+    }).filter(Boolean);
+    return `
+
+${renderedItems.join("\n")}
+
+`;
+  }
+  renderListItemContent(item) {
+    const clone = item.cloneNode(true);
+    clone.querySelectorAll("ul, ol").forEach((child) => child.remove());
+    return this.turndown.turndown(clone.innerHTML).replace(/\n{2,}/g, "\n").trim();
+  }
+  getListItemDepth(item, fallbackDepth) {
+    return this.getExplicitListItemDepth(item) ?? fallbackDepth;
+  }
+  getExplicitListItemDepth(item) {
+    const explicitDepth = item.getAttribute("data-indent-level") || item.getAttribute("data-indent") || item.getAttribute("data-level");
+    if (explicitDepth !== null) {
+      const parsedDepth = Number(explicitDepth);
+      if (Number.isFinite(parsedDepth) && parsedDepth >= 0) {
+        return parsedDepth;
+      }
+    }
+    const className = item.getAttribute("class") || "";
+    const classDepth = className.match(/(?:^|\s)(?:ql-indent|indent)-(\d+)(?:\s|$)/)?.[1];
+    if (classDepth) {
+      const parsedDepth = Number(classDepth);
+      if (Number.isFinite(parsedDepth) && parsedDepth >= 0) {
+        return parsedDepth;
+      }
+    }
+    const style = item.getAttribute("style") || "";
+    const marginLeftPx = style.match(/margin-left:\s*(\d+(?:\.\d+)?)px/i)?.[1];
+    if (marginLeftPx) {
+      const parsedPx = Number(marginLeftPx);
+      if (Number.isFinite(parsedPx) && parsedPx > 0) {
+        return Math.max(0, Math.round(parsedPx / 40));
+      }
+    }
+    return void 0;
+  }
+  normalizeMalformedConfluenceLists(document) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      const lists = Array.from(document.querySelectorAll("ul, ol"));
+      for (const list of lists) {
+        const childLists = Array.from(list.children).filter((child) => {
+          const nodeName = child.nodeName.toLowerCase();
+          return nodeName === "ul" || nodeName === "ol";
+        });
+        for (const childList of childLists) {
+          const previous = childList.previousElementSibling;
+          if (previous?.nodeName.toLowerCase() === "li") {
+            previous.appendChild(childList);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
   convert(storageHtml, imageUrlMap, jiraIssueMap) {
     this.jiraIssueMap = jiraIssueMap;
     if (!storageHtml) return "";
@@ -574,21 +958,16 @@ ${bodyMd}
     }).replace(/<ac:structured-macro\s+ac:name="([^"]*)"/gi, '<div data-macro-name-tag data-macro-name="$1"').replace(/<\/ac:structured-macro>/gi, "</div>").replace(/<ac:parameter\s+ac:name="([^"]*)"/gi, '<div data-macro-param-tag data-macro-param-name="$1"').replace(/<\/ac:parameter>/gi, "</div>").replace(/<ac:plain-text-body>/gi, "<pre data-macro-body>").replace(/<\/ac:plain-text-body>/gi, "</pre>").replace(/<ac:rich-text-body>/gi, "<div data-macro-rich-body>").replace(/<\/ac:rich-text-body>/gi, "</div>").replace(/<ac:image([^>]*)>[\s\S]*?<ri:attachment\s+ri:filename="([^"]*)"\s*\/?>[\s\S]*?<\/ac:image>/gi, (match, attrs, filename) => {
       const altMatch = attrs.match(/ac:alt="([^"]*)"/i);
       const alt = altMatch ? altMatch[1] : filename;
-      return `<img src="${filename}" alt="${alt}" />`;
+      const dimensions = buildImageDimensionAttributes(attrs);
+      return `<img src="${escapeHtmlAttribute(filename)}" alt="${escapeHtmlAttribute(alt)}"${dimensions} />`;
     }).replace(/<ac:image([^>]*)>[\s\S]*?<ri:url\s+ri:value="([^"]*)"\s*\/?>[\s\S]*?<\/ac:image>/gi, (match, attrs, url) => {
       const altMatch = attrs.match(/ac:alt="([^"]*)"/i);
       const alt = altMatch ? altMatch[1] : "";
-      return `<img src="${url}" alt="${alt}" />`;
+      const dimensions = buildImageDimensionAttributes(attrs);
+      return `<img src="${escapeHtmlAttribute(url)}" alt="${escapeHtmlAttribute(alt)}"${dimensions} />`;
     });
-    let document;
-    if (typeof window !== "undefined" && typeof window.DOMParser !== "undefined") {
-      const parser = new window.DOMParser();
-      document = parser.parseFromString(processedHtml, "text/html");
-    } else {
-      const { JSDOM } = __require("jsdom");
-      const dom = new JSDOM(processedHtml);
-      document = dom.window.document;
-    }
+    const document = parseHtmlDocument(processedHtml);
+    this.normalizeMalformedConfluenceLists(document);
     if (imageUrlMap && imageUrlMap.size > 0) {
       const images = document.querySelectorAll("img");
       images.forEach((img) => {
@@ -839,6 +1218,7 @@ function createGitlabClient(config) {
 
 export {
   loadEnv,
+  getEnvSource,
   ConfluenceContentApi,
   ConfluenceSpaceApi,
   ConfluenceSearchApi,
@@ -857,4 +1237,4 @@ export {
   GitlabPipelineApi,
   createGitlabClient
 };
-//# sourceMappingURL=chunk-JUM5ZG64.js.map
+//# sourceMappingURL=chunk-SIKUIQKX.js.map