tdecollab 0.3.4 → 0.3.6

package/dist/{chunk-5OB3KU5D.js → chunk-SIKUIQKX.js}

@@ -4,16 +4,21 @@ import {
 
 // 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"),
@@ -21,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 {
@@ -38,14 +59,14 @@ var ConfluenceContentApi = class {
   }
   async getPage(id, expand) {
     const expandParam = expand ? expand.join(",") : "body.storage,version,space,metadata.labels";
-    const response = await this.client.get(`/rest/api/content/${id}`, {
+    const response = await this.client.get(`rest/api/content/${id}`, {
       params: { expand: expandParam }
     });
     return response.data;
   }
   async getPageByTitle(spaceKey, title, expand) {
     const expandParam = expand ? expand.join(",") : "body.storage,version,space";
-    const response = await this.client.get("/rest/api/content", {
+    const response = await this.client.get("rest/api/content", {
       params: {
         spaceKey,
         title,
@@ -73,7 +94,7 @@ var ConfluenceContentApi = class {
     if (params.parentId) {
       data.ancestors = [{ id: params.parentId }];
     }
-    const response = await this.client.post("/rest/api/content", data);
+    const response = await this.client.post("rest/api/content", data);
     if (params.labels && params.labels.length > 0) {
       await this.addLabels(response.data.id, params.labels);
     }
@@ -91,14 +112,14 @@ var ConfluenceContentApi = class {
         }
       }
     };
-    const response = await this.client.put(`/rest/api/content/${params.id}`, data);
+    const response = await this.client.put(`rest/api/content/${params.id}`, data);
     return response.data;
   }
   async deletePage(id) {
-    await this.client.delete(`/rest/api/content/${id}`);
+    await this.client.delete(`rest/api/content/${id}`);
   }
   async getChildPages(id, start = 0, limit = 25) {
-    const response = await this.client.get(`/rest/api/content/${id}/child/page`, {
+    const response = await this.client.get(`rest/api/content/${id}/child/page`, {
       params: { start, limit }
     });
     return response.data.results;
@@ -112,7 +133,7 @@ var ConfluenceContentApi = class {
   // For now, simple implementation to support createPage.
   async addLabels(id, labels) {
     const data = labels.map((name) => ({ prefix: "global", name }));
-    await this.client.post(`/rest/api/content/${id}/label`, data);
+    await this.client.post(`rest/api/content/${id}/label`, data);
   }
   // Attachment 관련 메서드 (upsert: 기존 파일이 있으면 업데이트, 없으면 신규 업로드)
   async uploadAttachment(pageId, filename, fileContent, contentType) {
@@ -132,13 +153,13 @@ var ConfluenceContentApi = class {
     let response;
     if (existing) {
       response = await this.client.post(
-        `/rest/api/content/${pageId}/child/attachment/${existing.id}/data`,
+        `rest/api/content/${pageId}/child/attachment/${existing.id}/data`,
         form,
         { headers }
       );
     } else {
       response = await this.client.post(
-        `/rest/api/content/${pageId}/child/attachment`,
+        `rest/api/content/${pageId}/child/attachment`,
         form,
         { headers }
       );
@@ -149,7 +170,7 @@ var ConfluenceContentApi = class {
     return response.data;
   }
   async getAttachments(pageId, filename) {
-    const response = await this.client.get(`/rest/api/content/${pageId}/child/attachment`, {
+    const response = await this.client.get(`rest/api/content/${pageId}/child/attachment`, {
       params: {
         filename,
         expand: "version"
@@ -171,7 +192,7 @@ var ConfluenceSpaceApi = class {
     this.client = client;
   }
   async getSpaces(type = "global", start = 0, limit = 25) {
-    const response = await this.client.get("/rest/api/space", {
+    const response = await this.client.get("rest/api/space", {
       params: { type, start, limit }
     });
     return response.data.results;
@@ -189,7 +210,7 @@ var ConfluenceSearchApi = class {
   }
   async searchByCql(cql, start = 0, limit = 25, expand) {
     const expandParam = expand ? expand.join(",") : "body.storage,version,space,metadata.labels";
-    const response = await this.client.get("/rest/api/content/search", {
+    const response = await this.client.get("rest/api/content/search", {
       params: {
         cql,
         start,
@@ -237,20 +258,23 @@ var ConflictError = class extends TdeCollabError {
 
 // tools/common/http-client.ts
 function createHttpClient(config) {
+  const normalizedBaseUrl = config.baseUrl.endsWith("/") ? config.baseUrl : `${config.baseUrl}/`;
   const client = axios.create({
-    baseURL: config.baseUrl,
+    baseURL: normalizedBaseUrl,
     timeout: 3e4,
     // 30초 타임아웃
+    adapter: "http",
+    // Electron 환경(Obsidian)에서 XHR 대신 Node.js http 모듈을 사용하여 CORS 우회
     headers: {
       "Content-Type": "application/json"
     }
   });
   client.interceptors.request.use((reqConfig) => {
-    if (config.auth.token && !reqConfig.headers.Authorization && !reqConfig.headers["PRIVATE-TOKEN"]) {
-      reqConfig.headers.Authorization = `Bearer ${config.auth.token}`;
-    } else if (config.auth.username && config.auth.token && !reqConfig.headers.Authorization) {
+    if (config.auth.username && config.auth.token && !reqConfig.headers.Authorization) {
       const token = Buffer.from(`${config.auth.username}:${config.auth.token}`).toString("base64");
       reqConfig.headers.Authorization = `Basic ${token}`;
+    } else if (config.auth.token && !reqConfig.headers.Authorization && !reqConfig.headers["PRIVATE-TOKEN"]) {
+      reqConfig.headers.Authorization = `Bearer ${config.auth.token}`;
     }
     logger.debug(`[HTTP Request] ${reqConfig.method?.toUpperCase()} ${reqConfig.url}`, {
       headers: reqConfig.headers,
@@ -318,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;";
@@ -365,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,
@@ -380,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();
@@ -400,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) => {
@@ -420,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) {
@@ -446,7 +694,38 @@ var MarkdownToStorageConverter = class {
 // tools/confluence/converters/storage-to-md.ts
 import TurndownService from "turndown";
 import { gfm } from "turndown-plugin-gfm";
-import { JSDOM } from "jsdom";
+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;
@@ -464,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) => {
@@ -563,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 "";
@@ -571,14 +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} />`;
     });
-    const dom = new JSDOM(processedHtml);
-    const document = dom.window.document;
+    const document = parseHtmlDocument(processedHtml);
+    this.normalizeMalformedConfluenceLists(document);
     if (imageUrlMap && imageUrlMap.size > 0) {
       const images = document.querySelectorAll("img");
       images.forEach((img) => {
@@ -630,7 +1019,7 @@ var JiraIssueApi = class {
     if (params.customFields) {
       Object.assign(fields, params.customFields);
     }
-    const response = await this.client.post("/rest/api/2/issue", { fields });
+    const response = await this.client.post("rest/api/2/issue", { fields });
     return response.data;
   }
   async updateIssue(issueKey, params) {
@@ -716,7 +1105,7 @@ var JiraSearchApi = class {
     if (fields && fields.length > 0) {
       params.fields = fields.join(",");
     }
-    const response = await this.client.get("/rest/api/2/search", { params });
+    const response = await this.client.get("rest/api/2/search", { params });
     return response.data;
   }
 };
@@ -829,6 +1218,7 @@ function createGitlabClient(config) {
 
 export {
   loadEnv,
+  getEnvSource,
   ConfluenceContentApi,
   ConfluenceSpaceApi,
   ConfluenceSearchApi,
@@ -847,4 +1237,4 @@ export {
   GitlabPipelineApi,
   createGitlabClient
 };
-//# sourceMappingURL=chunk-5OB3KU5D.js.map
+//# sourceMappingURL=chunk-SIKUIQKX.js.map