@skrillex1224/chrome-article-publish-extension 1.0.0

package/dist/chunk-7Q3KKWUB.js

@@ -0,0 +1,602 @@
+// src/lib/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var isProd = typeof import.meta !== "undefined" && import.meta.env?.PROD || typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+var globalConfig = {
+  enabled: true,
+  level: isProd ? "warn" : "debug"
+};
+function createLogger(prefix) {
+  const shouldLog = (level) => {
+    if (!globalConfig.enabled) return false;
+    return LOG_LEVELS[level] >= LOG_LEVELS[globalConfig.level];
+  };
+  return {
+    debug: (...args) => {
+      if (shouldLog("debug")) {
+        console.log(`[${prefix}]`, ...args);
+      }
+    },
+    info: (...args) => {
+      if (shouldLog("info")) {
+        console.log(`[${prefix}]`, ...args);
+      }
+    },
+    warn: (...args) => {
+      if (shouldLog("warn")) {
+        console.warn(`[${prefix}]`, ...args);
+      }
+    },
+    error: (...args) => {
+      if (shouldLog("error")) {
+        console.error(`[${prefix}]`, ...args);
+      }
+    }
+  };
+}
+
+// src/lib/markdown-images.ts
+function parseMarkdownImages(markdown) {
+  const results = [];
+  const len = markdown.length;
+  let i = 0;
+  const findClosingBracket = (start) => {
+    for (let j = start; j < len; j++) {
+      const ch = markdown[j];
+      if (ch === "\\") {
+        j++;
+        continue;
+      }
+      if (ch === "]") return j;
+    }
+    return -1;
+  };
+  while (i < len) {
+    const start = markdown.indexOf("![", i);
+    if (start === -1) break;
+    const altStart = start + 2;
+    const altEnd = findClosingBracket(altStart);
+    if (altEnd === -1 || markdown[altEnd + 1] !== "(") {
+      i = altStart;
+      continue;
+    }
+    let k = altEnd + 2;
+    while (k < len && /\s/.test(markdown[k])) k++;
+    let url = "";
+    if (markdown[k] === "<") {
+      const close = markdown.indexOf(">", k + 1);
+      if (close === -1) {
+        i = altEnd + 1;
+        continue;
+      }
+      url = markdown.slice(k + 1, close);
+      k = close + 1;
+    } else {
+      const urlStart = k;
+      let depth = 0;
+      while (k < len) {
+        const ch = markdown[k];
+        if (ch === "\\") {
+          k += 2;
+          continue;
+        }
+        if (ch === "(") {
+          depth++;
+        } else if (ch === ")") {
+          if (depth === 0) break;
+          depth--;
+        } else if (/\s/.test(ch) && depth === 0) {
+          break;
+        }
+        k++;
+      }
+      url = markdown.slice(urlStart, k);
+    }
+    if (!url) {
+      i = altEnd + 1;
+      continue;
+    }
+    while (k < len && /\s/.test(markdown[k])) k++;
+    if (k < len && (markdown[k] === '"' || markdown[k] === "'")) {
+      const quote = markdown[k];
+      k++;
+      while (k < len) {
+        const ch = markdown[k];
+        if (ch === "\\") {
+          k += 2;
+          continue;
+        }
+        if (ch === quote) {
+          k++;
+          break;
+        }
+        k++;
+      }
+      while (k < len && /\s/.test(markdown[k])) k++;
+    } else if (k < len && markdown[k] === "(") {
+      k++;
+      while (k < len) {
+        const ch = markdown[k];
+        if (ch === "\\") {
+          k += 2;
+          continue;
+        }
+        if (ch === ")") {
+          k++;
+          break;
+        }
+        k++;
+      }
+      while (k < len && /\s/.test(markdown[k])) k++;
+    }
+    if (markdown[k] !== ")") {
+      i = altEnd + 1;
+      continue;
+    }
+    const full = markdown.slice(start, k + 1);
+    const alt = markdown.slice(altStart, altEnd);
+    results.push({ full, alt, src: url });
+    i = k + 1;
+  }
+  return results;
+}
+
+// src/lib/turndown.ts
+import TurndownService from "turndown";
+import { marked } from "marked";
+var logger = createLogger("Turndown");
+function decodeHtmlEntities(text) {
+  let result = text;
+  for (let i = 0; i < 3; i++) {
+    const prev = result;
+    result = result.replace(/&amp;/g, "&");
+    if (prev === result) break;
+  }
+  result = result.replace(/&#[xX]([0-9a-fA-F]+);/g, (_, hex) => {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+  result = result.replace(/&#(\d+);/g, (_, dec) => {
+    return String.fromCharCode(parseInt(dec, 10));
+  });
+  const namedEntities = {
+    "&lt;": "<",
+    "&gt;": ">",
+    "&amp;": "&",
+    "&quot;": '"',
+    "&apos;": "'",
+    "&#039;": "'",
+    "&nbsp;": " ",
+    "&ndash;": "\u2013",
+    "&mdash;": "\u2014",
+    "&lsquo;": "\u2018",
+    "&rsquo;": "\u2019",
+    "&ldquo;": "\u201C",
+    "&rdquo;": "\u201D",
+    "&copy;": "\xA9",
+    "&reg;": "\xAE",
+    "&trade;": "\u2122",
+    "&hellip;": "\u2026"
+  };
+  for (const [entity, char] of Object.entries(namedEntities)) {
+    result = result.split(entity).join(char);
+  }
+  return result;
+}
+var KNOWN_HTML_TAGS = [
+  // 文本格式化
+  "span",
+  "em",
+  "strong",
+  "b",
+  "i",
+  "u",
+  "s",
+  "strike",
+  "del",
+  "ins",
+  "mark",
+  "sub",
+  "sup",
+  "small",
+  "big",
+  "font",
+  "a",
+  // 代码相关
+  "code",
+  "pre",
+  "kbd",
+  "samp",
+  "var",
+  "tt",
+  // 块级元素
+  "div",
+  "p",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "aside",
+  "nav",
+  "main",
+  "figure",
+  "figcaption",
+  "blockquote",
+  "address",
+  // 列表
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  // 表格
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  // 换行/分隔
+  "br",
+  "hr",
+  "wbr",
+  // 其他
+  "abbr",
+  "acronym",
+  "cite",
+  "dfn",
+  "q",
+  "time",
+  "ruby",
+  "rt",
+  "rp",
+  "bdi",
+  "bdo",
+  "data",
+  "meter",
+  "progress",
+  "output",
+  "details",
+  "summary",
+  // 微信特殊标签
+  "mpvoice",
+  "mpprofile",
+  "qqmusic",
+  "mpcps"
+];
+function extractCodeText(html) {
+  const LT_PLACEHOLDER = "\0__CODE_LT__\0";
+  const GT_PLACEHOLDER = "\0__CODE_GT__\0";
+  let text = html;
+  text = text.replace(/&lt;/gi, LT_PLACEHOLDER);
+  text = text.replace(/&gt;/gi, GT_PLACEHOLDER);
+  text = text.replace(/&#0*60;/gi, LT_PLACEHOLDER);
+  text = text.replace(/&#0*62;/gi, GT_PLACEHOLDER);
+  text = text.replace(/&#x0*3[cC];/gi, LT_PLACEHOLDER);
+  text = text.replace(/&#x0*3[eE];/gi, GT_PLACEHOLDER);
+  const tagPattern = KNOWN_HTML_TAGS.join("|");
+  text = text.replace(new RegExp(`<(${tagPattern})\\b[^>]*\\/?>`, "gi"), "");
+  text = text.replace(new RegExp(`<\\/(${tagPattern})>`, "gi"), "");
+  text = text.replace(new RegExp(LT_PLACEHOLDER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "<");
+  text = text.replace(new RegExp(GT_PLACEHOLDER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), ">");
+  text = decodeHtmlEntities(text);
+  return text;
+}
+function extractCodeFromHtml(html) {
+  let text = html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/div>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<\/?code[^>]*>/gi, "");
+  text = extractCodeText(text);
+  return text.trim();
+}
+function htmlToMarkdown(html, _options = {}) {
+  return htmlToMarkdownSimple(html);
+}
+function extractLangFromClass(className) {
+  if (!className) return "";
+  const patterns = [
+    /language-(\w+)/i,
+    // language-javascript
+    /lang-(\w+)/i,
+    // lang-js
+    /\bhljs\s+(\w+)/i,
+    // hljs javascript
+    /\b(javascript|typescript|python|java|cpp|c|csharp|go|rust|ruby|php|swift|kotlin|scala|sql|html|css|json|xml|yaml|markdown|bash|shell|powershell)\b/i
+  ];
+  for (const pattern of patterns) {
+    const match = className.match(pattern);
+    if (match) {
+      return match[1].toLowerCase();
+    }
+  }
+  return "";
+}
+function htmlToMarkdownSimple(html) {
+  let md = html;
+  md = md.replace(
+    /<ul[^>]*class=["'][^"']*code-snippet__line-index[^"']*["'][^>]*>[\s\S]*?<\/ul>/gi,
+    ""
+  );
+  md = convertTables(md);
+  md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "\n# $1\n");
+  md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "\n## $1\n");
+  md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "\n### $1\n");
+  md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, "\n#### $1\n");
+  md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, "\n##### $1\n");
+  md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, "\n###### $1\n");
+  md = md.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, "**$2**");
+  md = md.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, "*$2*");
+  md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, "![$2]($1)");
+  md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, "![]($1)");
+  md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (match, content) => {
+    let language = "";
+    const preLangMatch = match.match(/<pre[^>]*data-lang(?:uage)?=["'](\w+)["']/);
+    const preClassMatch = match.match(/<pre[^>]*class="([^"]*)"/);
+    if (preLangMatch) {
+      language = preLangMatch[1];
+    } else if (preClassMatch) {
+      language = extractLangFromClass(preClassMatch[1]);
+    }
+    const codeLangMatch = content.match(/<code[^>]*data-lang(?:uage)?=["'](\w+)["']/);
+    const codeClassMatch = content.match(/<code[^>]*class="([^"]*)"/);
+    if (!language) {
+      if (codeLangMatch) {
+        language = codeLangMatch[1];
+      } else if (codeClassMatch) {
+        language = extractLangFromClass(codeClassMatch[1]);
+      }
+    }
+    const text = extractCodeFromHtml(content);
+    return "\n```" + language + "\n" + text + "\n```\n";
+  });
+  md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, "$1\n");
+  md = md.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, "$1\n");
+  md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n");
+  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, "\n$1\n");
+  md = md.replace(/<br\s*\/?>/gi, "\n");
+  md = md.replace(/<hr\s*\/?>/gi, "\n---\n");
+  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => {
+    return "\n" + content.trim().split("\n").map((line) => "> " + line).join("\n") + "\n";
+  });
+  md = md.replace(/<script[^>]*type=["']math\/tex[^"']*display[^"']*["'][^>]*>([\s\S]*?)<\/script>/gi, "\n$$$$\n$1\n$$$$\n");
+  md = md.replace(/<script[^>]*type=["']math\/tex["'][^>]*>([\s\S]*?)<\/script>/gi, " $$$$$1$$$$ ");
+  md = md.replace(/<\/?[^>]+(>|$)/g, "");
+  md = md.replace(/&amp;/g, "&");
+  md = md.replace(/&lt;/g, "<");
+  md = md.replace(/&gt;/g, ">");
+  md = md.replace(/&quot;/g, '"');
+  md = md.replace(/&#039;/g, "'");
+  md = md.replace(/&nbsp;/g, " ");
+  md = md.replace(/\n{3,}/g, "\n\n");
+  md = md.trim();
+  return md;
+}
+function convertTables(html) {
+  html = html.replace(/<figure[^>]*>([\s\S]*?)<\/figure>/gi, (match, figureContent) => {
+    if (/<table[^>]*>/i.test(figureContent)) {
+      const tableMatch = figureContent.match(/<table[^>]*>([\s\S]*?)<\/table>/i);
+      const captionMatch = figureContent.match(/<figcaption[^>]*>([\s\S]*?)<\/figcaption>/i);
+      if (tableMatch) {
+        let result = tableMatch[0];
+        if (captionMatch) {
+          const caption = captionMatch[1].replace(/<[^>]+>/g, "").trim();
+          if (caption) {
+            result += "\n*" + caption + "*\n";
+          }
+        }
+        return result;
+      }
+    }
+    return match;
+  });
+  return html.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_, tableContent) => {
+    const hasTheadMatch = tableContent.match(/<thead[^>]*>([\s\S]*?)<\/thead>/i);
+    const rows = [];
+    const alignments = [];
+    let headerRowIndex = -1;
+    const rowMatches = tableContent.match(/<tr[^>]*>([\s\S]*?)<\/tr>/gi) || [];
+    for (let i = 0; i < rowMatches.length; i++) {
+      const rowContent = rowMatches[i];
+      const cells = [];
+      const rowAligns = [];
+      const cellMatches = rowContent.match(/<t[hd][^>]*>([\s\S]*?)<\/t[hd]>/gi) || [];
+      const isHeaderRow = cellMatches.length > 0 && cellMatches.every((c) => c.startsWith("<th"));
+      for (const cellMatch of cellMatches) {
+        const fullMatch = cellMatch.match(/<t[hd]([^>]*)>([\s\S]*?)<\/t[hd]>/i);
+        if (fullMatch) {
+          const attrs = fullMatch[1];
+          const rawContent = fullMatch[2];
+          const alignMatch = attrs.match(/align=["']?(left|center|right)["']?/i) || attrs.match(/style=["'][^"']*text-align:\s*(left|center|right)/i);
+          const align = alignMatch ? alignMatch[1].toLowerCase() : "";
+          rowAligns.push(align);
+          let content = rawContent.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\s+/g, " ").trim();
+          content = content.replace(/\|/g, "\\|");
+          cells.push(content);
+        }
+      }
+      if (cells.length > 0) {
+        rows.push(cells);
+        alignments.push(rowAligns);
+        if (hasTheadMatch && rowContent.indexOf("<th") !== -1) {
+          headerRowIndex = i;
+        } else if (i === 0 && isHeaderRow) {
+          headerRowIndex = 0;
+        }
+      }
+    }
+    if (rows.length === 0) {
+      return "";
+    }
+    if (headerRowIndex === -1) {
+      headerRowIndex = 0;
+    }
+    const mdRows = [];
+    const colCount = Math.max(...rows.map((r) => r.length));
+    const headerAligns = alignments[headerRowIndex] || [];
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      while (row.length < colCount) {
+        row.push("");
+      }
+      mdRows.push("| " + row.join(" | ") + " |");
+      if (i === headerRowIndex) {
+        const separators = [];
+        for (let j = 0; j < colCount; j++) {
+          const align = headerAligns[j] || "";
+          if (align === "left") {
+            separators.push(":---");
+          } else if (align === "center") {
+            separators.push(":---:");
+          } else if (align === "right") {
+            separators.push("---:");
+          } else {
+            separators.push("---");
+          }
+        }
+        mdRows.push("| " + separators.join(" | ") + " |");
+      }
+    }
+    return "\n\n" + mdRows.join("\n") + "\n\n";
+  });
+}
+function markdownToHtml(markdown) {
+  return marked.parse(markdown, { async: false });
+}
+
+// src/lib/aws4.ts
+async function hmacSha256(key, message) {
+  const keyBytes = key instanceof Uint8Array ? key : new Uint8Array(key);
+  const keyBuffer = new Uint8Array(keyBytes).buffer;
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyBuffer,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return crypto.subtle.sign("HMAC", cryptoKey, new TextEncoder().encode(message));
+}
+async function sha256(message) {
+  const msgBuffer = new TextEncoder().encode(message);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+  return arrayBufferToHex(hashBuffer);
+}
+function arrayBufferToHex(buffer) {
+  return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function formatAmzDate(date) {
+  return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+function formatDateStamp(date) {
+  return date.toISOString().slice(0, 10).replace(/-/g, "");
+}
+async function signAWS4(params) {
+  const {
+    method,
+    url,
+    accessKeyId,
+    secretAccessKey,
+    securityToken,
+    region = "cn-north-1",
+    service = "imagex",
+    headers = {},
+    body = ""
+  } = params;
+  const parsedUrl = new URL(url);
+  const path = parsedUrl.pathname;
+  const queryString = parsedUrl.search.slice(1);
+  const now = /* @__PURE__ */ new Date();
+  const amzDate = formatAmzDate(now);
+  const dateStamp = formatDateStamp(now);
+  const queryParams = new URLSearchParams(queryString);
+  const sortedParams = Array.from(queryParams.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  const canonicalQueryString = sortedParams.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  const signedHeadersObj = {
+    "x-amz-date": amzDate
+  };
+  if (securityToken) {
+    signedHeadersObj["x-amz-security-token"] = securityToken;
+  }
+  Object.assign(signedHeadersObj, headers);
+  const signedHeaderNames = Object.keys(signedHeadersObj).map((k) => k.toLowerCase()).sort().join(";");
+  const canonicalHeaders = Object.entries(signedHeadersObj).map(([k, v]) => `${k.toLowerCase()}:${v.trim()}`).sort().join("\n") + "\n";
+  const payloadHash = await sha256(body);
+  const canonicalRequest = [
+    method.toUpperCase(),
+    path || "/",
+    canonicalQueryString,
+    canonicalHeaders,
+    signedHeaderNames,
+    payloadHash
+  ].join("\n");
+  const algorithm = "AWS4-HMAC-SHA256";
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const canonicalRequestHash = await sha256(canonicalRequest);
+  const stringToSign = [
+    algorithm,
+    amzDate,
+    credentialScope,
+    canonicalRequestHash
+  ].join("\n");
+  const kDate = await hmacSha256(
+    new TextEncoder().encode("AWS4" + secretAccessKey),
+    dateStamp
+  );
+  const kRegion = await hmacSha256(kDate, region);
+  const kService = await hmacSha256(kRegion, service);
+  const kSigning = await hmacSha256(kService, "aws4_request");
+  const signatureBuffer = await hmacSha256(kSigning, stringToSign);
+  const signature = arrayBufferToHex(signatureBuffer);
+  const authorization = `${algorithm} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaderNames}, Signature=${signature}`;
+  const resultHeaders = {
+    authorization,
+    "x-amz-date": amzDate
+  };
+  if (securityToken) {
+    resultHeaders["x-amz-security-token"] = securityToken;
+  }
+  return {
+    authorization,
+    amzDate,
+    headers: resultHeaders
+  };
+}
+function crc32(data) {
+  let crc = 4294967295;
+  const table = getCRC32Table();
+  for (let i = 0; i < data.length; i++) {
+    crc = crc >>> 8 ^ table[(crc ^ data[i]) & 255];
+  }
+  return ((crc ^ 4294967295) >>> 0).toString(16).padStart(8, "0");
+}
+var crc32Table = null;
+function getCRC32Table() {
+  if (crc32Table) return crc32Table;
+  crc32Table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    crc32Table[i] = c;
+  }
+  return crc32Table;
+}
+
+export {
+  createLogger,
+  parseMarkdownImages,
+  htmlToMarkdown,
+  markdownToHtml,
+  signAWS4,
+  crc32
+};
+//# sourceMappingURL=chunk-7Q3KKWUB.js.map