@cogitator-ai/wasm-tools 0.4.1 → 0.5.0

package/dist/temp/markdown.js

@@ -0,0 +1,220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/markdown.ts
+var markdown_exports = {};
+__export(markdown_exports, {
+  markdown: () => markdown
+});
+module.exports = __toCommonJS(markdown_exports);
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function parseInline(text, sanitize) {
+  let result = sanitize ? escapeHtml(text) : text;
+  result = result.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  result = result.replace(/`([^`]+)`/g, "<code>$1</code>");
+  result = result.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  result = result.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+  result = result.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  result = result.replace(/_([^_]+)_/g, "<em>$1</em>");
+  result = result.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+  return result;
+}
+function parseMarkdown(md, sanitize, gfm) {
+  const lines = md.split("\n");
+  const html = [];
+  let inCodeBlock = false;
+  let codeBlockContent = [];
+  let codeBlockLang = "";
+  let inList = false;
+  let listType = "ul";
+  let inBlockquote = false;
+  let blockquoteContent = [];
+  let inParagraph = false;
+  let paragraphContent = [];
+  const flushParagraph = () => {
+    if (inParagraph && paragraphContent.length > 0) {
+      html.push(`<p>${parseInline(paragraphContent.join(" "), sanitize)}</p>`);
+      paragraphContent = [];
+      inParagraph = false;
+    }
+  };
+  const flushBlockquote = () => {
+    if (inBlockquote && blockquoteContent.length > 0) {
+      html.push(`<blockquote><p>${parseInline(blockquoteContent.join(" "), sanitize)}</p></blockquote>`);
+      blockquoteContent = [];
+      inBlockquote = false;
+    }
+  };
+  const flushList = () => {
+    if (inList) {
+      html.push(listType === "ul" ? "</ul>" : "</ol>");
+      inList = false;
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      if (inCodeBlock) {
+        const content = sanitize ? escapeHtml(codeBlockContent.join("\n")) : codeBlockContent.join("\n");
+        html.push(`<pre><code${codeBlockLang ? ` class="language-${codeBlockLang}"` : ""}>${content}</code></pre>`);
+        codeBlockContent = [];
+        codeBlockLang = "";
+        inCodeBlock = false;
+      } else {
+        flushParagraph();
+        flushBlockquote();
+        flushList();
+        codeBlockLang = line.slice(3).trim();
+        inCodeBlock = true;
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockContent.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      flushParagraph();
+      flushBlockquote();
+      flushList();
+      continue;
+    }
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      flushParagraph();
+      flushBlockquote();
+      flushList();
+      const level = headerMatch[1].length;
+      const content = parseInline(headerMatch[2], sanitize);
+      html.push(`<h${level}>${content}</h${level}>`);
+      continue;
+    }
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(line.trim())) {
+      flushParagraph();
+      flushBlockquote();
+      flushList();
+      html.push("<hr>");
+      continue;
+    }
+    const blockquoteMatch = line.match(/^>\s?(.*)$/);
+    if (blockquoteMatch) {
+      flushParagraph();
+      flushList();
+      inBlockquote = true;
+      blockquoteContent.push(blockquoteMatch[1]);
+      continue;
+    }
+    const ulMatch = line.match(/^[-*+]\s+(.+)$/);
+    if (ulMatch) {
+      flushParagraph();
+      flushBlockquote();
+      if (!inList || listType !== "ul") {
+        flushList();
+        html.push("<ul>");
+        inList = true;
+        listType = "ul";
+      }
+      html.push(`<li>${parseInline(ulMatch[1], sanitize)}</li>`);
+      continue;
+    }
+    const olMatch = line.match(/^\d+\.\s+(.+)$/);
+    if (olMatch) {
+      flushParagraph();
+      flushBlockquote();
+      if (!inList || listType !== "ol") {
+        flushList();
+        html.push("<ol>");
+        inList = true;
+        listType = "ol";
+      }
+      html.push(`<li>${parseInline(olMatch[1], sanitize)}</li>`);
+      continue;
+    }
+    if (gfm && line.includes("|")) {
+      flushParagraph();
+      flushBlockquote();
+      flushList();
+      const tableLines = [line];
+      while (i + 1 < lines.length && lines[i + 1].includes("|")) {
+        i++;
+        tableLines.push(lines[i]);
+      }
+      if (tableLines.length >= 2) {
+        const headerCells = tableLines[0].split("|").map((c) => c.trim()).filter((c) => c);
+        const rows = tableLines.slice(2);
+        html.push("<table>");
+        html.push("<thead><tr>");
+        for (const cell of headerCells) {
+          html.push(`<th>${parseInline(cell, sanitize)}</th>`);
+        }
+        html.push("</tr></thead>");
+        if (rows.length > 0) {
+          html.push("<tbody>");
+          for (const row of rows) {
+            const cells = row.split("|").map((c) => c.trim()).filter((c) => c);
+            html.push("<tr>");
+            for (const cell of cells) {
+              html.push(`<td>${parseInline(cell, sanitize)}</td>`);
+            }
+            html.push("</tr>");
+          }
+          html.push("</tbody>");
+        }
+        html.push("</table>");
+      }
+      continue;
+    }
+    flushBlockquote();
+    flushList();
+    inParagraph = true;
+    paragraphContent.push(line.trim());
+  }
+  flushParagraph();
+  flushBlockquote();
+  flushList();
+  if (inCodeBlock) {
+    const content = sanitize ? escapeHtml(codeBlockContent.join("\n")) : codeBlockContent.join("\n");
+    html.push(`<pre><code>${content}</code></pre>`);
+  }
+  return html.join("\n");
+}
+function markdown() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const sanitize = input.options?.sanitize ?? true;
+    const gfm = input.options?.gfm ?? true;
+    const htmlResult = parseMarkdown(input.markdown, sanitize, gfm);
+    const output = {
+      html: htmlResult
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      html: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/dist/temp/regex.js

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/regex.ts
+var regex_exports = {};
+__export(regex_exports, {
+  regex: () => regex
+});
+module.exports = __toCommonJS(regex_exports);
+var MAX_ITERATIONS = 1e5;
+var DANGEROUS_PATTERNS = [
+  /\(\?[^)]*\)\+\+/,
+  /\(\.\*\)\+/,
+  /\(\.\+\)\+/,
+  /\([^)]+\+\)\+/,
+  /\([^)]+\*\)\*/
+];
+function isDangerousPattern(pattern) {
+  for (const dangerous of DANGEROUS_PATTERNS) {
+    if (dangerous.test(pattern)) {
+      return true;
+    }
+  }
+  let depth = 0;
+  let quantifiers = 0;
+  for (const char of pattern) {
+    if (char === "(") depth++;
+    if (char === ")") depth--;
+    if ((char === "+" || char === "*") && depth > 0) quantifiers++;
+  }
+  return quantifiers > 3;
+}
+function safeMatch(text, regex2) {
+  const match = text.match(regex2);
+  if (!match) return null;
+  return {
+    match: match[0],
+    index: match.index ?? 0,
+    groups: match.groups
+  };
+}
+function safeMatchAll(text, regex2, limit) {
+  const results = [];
+  let iterations = 0;
+  const globalRegex = new RegExp(
+    regex2.source,
+    regex2.flags.includes("g") ? regex2.flags : regex2.flags + "g"
+  );
+  let match;
+  while ((match = globalRegex.exec(text)) !== null) {
+    results.push({
+      match: match[0],
+      index: match.index,
+      groups: match.groups
+    });
+    iterations++;
+    if (iterations >= limit || iterations >= MAX_ITERATIONS) break;
+    if (match[0].length === 0) {
+      globalRegex.lastIndex++;
+    }
+  }
+  return results;
+}
+function safeReplace(text, regex2, replacement) {
+  return text.replace(regex2, replacement);
+}
+function safeSplit(text, regex2, limit) {
+  return text.split(regex2, limit);
+}
+function safeTest(text, regex2) {
+  return regex2.test(text);
+}
+function regex() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    if (isDangerousPattern(input.pattern)) {
+      throw new Error("Pattern may cause ReDoS - nested quantifiers detected");
+    }
+    const flags = input.flags ?? "";
+    const regex2 = new RegExp(input.pattern, flags);
+    const limit = input.limit ?? 1e3;
+    let result;
+    let matchCount;
+    switch (input.operation) {
+      case "test":
+        result = safeTest(input.text, regex2);
+        break;
+      case "match":
+        result = safeMatch(input.text, regex2);
+        matchCount = result ? 1 : 0;
+        break;
+      case "matchAll":
+        const matches = safeMatchAll(input.text, regex2, limit);
+        result = matches;
+        matchCount = matches.length;
+        break;
+      case "replace":
+        if (input.replacement === void 0) {
+          throw new Error("replacement is required for replace operation");
+        }
+        result = safeReplace(input.text, regex2, input.replacement);
+        break;
+      case "split":
+        result = safeSplit(input.text, regex2, input.limit);
+        break;
+      default:
+        throw new Error(`Unknown operation: ${input.operation}`);
+    }
+    const output = {
+      result,
+      matchCount
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      result: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}