@cogitator-ai/wasm-tools 0.4.2 → 0.5.0

package/dist/temp/slug.js

@@ -0,0 +1,198 @@
+"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/slug.ts
+var slug_exports = {};
+__export(slug_exports, {
+  slug: () => slug
+});
+module.exports = __toCommonJS(slug_exports);
+var CHAR_MAP = {
+  \u00E0: "a",
+  \u00E1: "a",
+  \u00E2: "a",
+  \u00E3: "a",
+  \u00E4: "a",
+  \u00E5: "a",
+  \u00E6: "ae",
+  \u00E7: "c",
+  \u00E8: "e",
+  \u00E9: "e",
+  \u00EA: "e",
+  \u00EB: "e",
+  \u00EC: "i",
+  \u00ED: "i",
+  \u00EE: "i",
+  \u00EF: "i",
+  \u00F0: "d",
+  \u00F1: "n",
+  \u00F2: "o",
+  \u00F3: "o",
+  \u00F4: "o",
+  \u00F5: "o",
+  \u00F6: "o",
+  \u00F8: "o",
+  \u00F9: "u",
+  \u00FA: "u",
+  \u00FB: "u",
+  \u00FC: "u",
+  \u00FD: "y",
+  \u00FF: "y",
+  \u00FE: "th",
+  \u00DF: "ss",
+  \u0105: "a",
+  \u0107: "c",
+  \u0119: "e",
+  \u0142: "l",
+  \u0144: "n",
+  \u015B: "s",
+  \u017A: "z",
+  \u017C: "z",
+  \u010D: "c",
+  \u010F: "d",
+  \u011B: "e",
+  \u0148: "n",
+  \u0159: "r",
+  \u0161: "s",
+  \u0165: "t",
+  \u016F: "u",
+  \u017E: "z",
+  \u0101: "a",
+  \u0113: "e",
+  \u0123: "g",
+  \u012B: "i",
+  \u0137: "k",
+  \u013C: "l",
+  \u0146: "n",
+  \u016B: "u",
+  \u0151: "o",
+  \u0171: "u",
+  \u0430: "a",
+  \u0431: "b",
+  \u0432: "v",
+  \u0433: "g",
+  \u0434: "d",
+  \u0435: "e",
+  \u0451: "yo",
+  \u0436: "zh",
+  \u0437: "z",
+  \u0438: "i",
+  \u0439: "y",
+  \u043A: "k",
+  \u043B: "l",
+  \u043C: "m",
+  \u043D: "n",
+  \u043E: "o",
+  \u043F: "p",
+  \u0440: "r",
+  \u0441: "s",
+  \u0442: "t",
+  \u0443: "u",
+  \u0444: "f",
+  \u0445: "h",
+  \u0446: "ts",
+  \u0447: "ch",
+  \u0448: "sh",
+  \u0449: "sch",
+  \u044A: "",
+  \u044B: "y",
+  \u044C: "",
+  \u044D: "e",
+  \u044E: "yu",
+  \u044F: "ya",
+  \u03B1: "a",
+  \u03B2: "b",
+  \u03B3: "g",
+  \u03B4: "d",
+  \u03B5: "e",
+  \u03B6: "z",
+  \u03B7: "h",
+  \u03B8: "th",
+  \u03B9: "i",
+  \u03BA: "k",
+  \u03BB: "l",
+  \u03BC: "m",
+  \u03BD: "n",
+  \u03BE: "x",
+  \u03BF: "o",
+  \u03C0: "p",
+  \u03C1: "r",
+  \u03C3: "s",
+  \u03C4: "t",
+  \u03C5: "y",
+  \u03C6: "ph",
+  \u03C7: "ch",
+  \u03C8: "ps",
+  \u03C9: "o"
+};
+function transliterate(str) {
+  let result = "";
+  for (const char of str) {
+    const lower = char.toLowerCase();
+    if (CHAR_MAP[lower]) {
+      const mapped = CHAR_MAP[lower];
+      result += char === lower ? mapped : mapped.toUpperCase();
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function generateSlug(text, separator, lowercase, maxLength) {
+  let slug2 = transliterate(text);
+  if (lowercase) {
+    slug2 = slug2.toLowerCase();
+  }
+  slug2 = slug2.replace(/[^a-zA-Z0-9\s-]/g, "").replace(/\s+/g, separator).replace(new RegExp(`${escapeRegex(separator)}+`, "g"), separator).replace(new RegExp(`^${escapeRegex(separator)}|${escapeRegex(separator)}$`, "g"), "");
+  if (maxLength && slug2.length > maxLength) {
+    slug2 = slug2.substring(0, maxLength);
+    const lastSep = slug2.lastIndexOf(separator);
+    if (lastSep > maxLength * 0.5) {
+      slug2 = slug2.substring(0, lastSep);
+    }
+    slug2 = slug2.replace(new RegExp(`${escapeRegex(separator)}$`), "");
+  }
+  return slug2;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function slug() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const separator = input.separator ?? "-";
+    const lowercase = input.lowercase ?? true;
+    const result = generateSlug(input.text, separator, lowercase, input.maxLength);
+    const output = {
+      slug: result,
+      original: input.text
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      slug: "",
+      original: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/dist/temp/validation.js

@@ -0,0 +1,125 @@
+"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/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  validate: () => validate
+});
+module.exports = __toCommonJS(validation_exports);
+var EMAIL_REGEX = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var IPV4_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV6_REGEX = /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}|:(?::[0-9a-fA-F]{1,4}){1,7}|::(?:[fF]{4}:)?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))$/;
+function validateEmail(value) {
+  const trimmed = value.trim().toLowerCase();
+  const valid = EMAIL_REGEX.test(trimmed) && trimmed.length <= 254;
+  return { valid, normalized: valid ? trimmed : void 0 };
+}
+function validateUrl(value) {
+  try {
+    const trimmed = value.trim();
+    const hasProtocol = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed);
+    const urlStr = hasProtocol ? trimmed : `https://${trimmed}`;
+    const parts = urlStr.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([^/?#]+)(.*)$/);
+    if (!parts) return { valid: false };
+    const [, protocol, host] = parts;
+    if (!["http", "https", "ftp", "ftps"].includes(protocol.toLowerCase())) {
+      return { valid: false };
+    }
+    const hostParts = host.split(":");
+    const hostname = hostParts[0];
+    const port = hostParts[1];
+    if (port && (!/^\d+$/.test(port) || parseInt(port) > 65535)) {
+      return { valid: false };
+    }
+    if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$/.test(
+      hostname
+    )) {
+      if (!IPV4_REGEX.test(hostname) && !hostname.startsWith("[")) {
+        return { valid: false };
+      }
+    }
+    return { valid: true, normalized: urlStr };
+  } catch {
+    return { valid: false };
+  }
+}
+function validateUuid(value) {
+  const trimmed = value.trim().toLowerCase();
+  const valid = UUID_REGEX.test(trimmed);
+  return { valid, normalized: valid ? trimmed : void 0 };
+}
+function validateIpv4(value) {
+  const trimmed = value.trim();
+  const valid = IPV4_REGEX.test(trimmed);
+  if (valid) {
+    const normalized = trimmed.split(".").map((n) => parseInt(n, 10).toString()).join(".");
+    return { valid: true, normalized };
+  }
+  return { valid: false };
+}
+function validateIpv6(value) {
+  const trimmed = value.trim().toLowerCase();
+  const valid = IPV6_REGEX.test(trimmed);
+  return { valid, normalized: valid ? trimmed : void 0 };
+}
+function validate() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    let result;
+    switch (input.type) {
+      case "email":
+        result = validateEmail(input.value);
+        break;
+      case "url":
+        result = validateUrl(input.value);
+        break;
+      case "uuid":
+        result = validateUuid(input.value);
+        break;
+      case "ipv4":
+        result = validateIpv4(input.value);
+        break;
+      case "ipv6":
+        result = validateIpv6(input.value);
+        break;
+      default:
+        throw new Error(`Unknown validation type: ${input.type}`);
+    }
+    const output = {
+      valid: result.valid,
+      type: input.type,
+      value: input.value,
+      normalized: result.normalized
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      valid: false,
+      type: "unknown",
+      value: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/dist/temp/xml.js

@@ -0,0 +1,289 @@
+"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/xml.ts
+var xml_exports = {};
+__export(xml_exports, {
+  xml: () => xml
+});
+module.exports = __toCommonJS(xml_exports);
+function parseXml(xml2) {
+  let pos = 0;
+  const skipWhitespace = () => {
+    while (pos < xml2.length && /\s/.test(xml2[pos])) pos++;
+  };
+  const parseAttributes = () => {
+    const attrs = {};
+    while (pos < xml2.length) {
+      skipWhitespace();
+      if (xml2[pos] === ">" || xml2[pos] === "/" || xml2[pos] === "?") break;
+      let name = "";
+      while (pos < xml2.length && /[a-zA-Z0-9_:-]/.test(xml2[pos])) {
+        name += xml2[pos++];
+      }
+      if (!name) break;
+      skipWhitespace();
+      if (xml2[pos] !== "=") {
+        attrs[name] = "true";
+        continue;
+      }
+      pos++;
+      skipWhitespace();
+      const quote = xml2[pos];
+      if (quote !== '"' && quote !== "'") {
+        throw new Error(`Expected quote at position ${pos}`);
+      }
+      pos++;
+      let value = "";
+      while (pos < xml2.length && xml2[pos] !== quote) {
+        if (xml2[pos] === "&") {
+          const entity = parseEntity();
+          value += entity;
+        } else {
+          value += xml2[pos++];
+        }
+      }
+      pos++;
+      attrs[name] = value;
+    }
+    return attrs;
+  };
+  const parseEntity = () => {
+    let entity = "";
+    pos++;
+    while (pos < xml2.length && xml2[pos] !== ";") {
+      entity += xml2[pos++];
+    }
+    pos++;
+    switch (entity) {
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "amp":
+        return "&";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCharCode(parseInt(entity.slice(2), 16));
+        } else if (entity.startsWith("#")) {
+          return String.fromCharCode(parseInt(entity.slice(1), 10));
+        }
+        return `&${entity};`;
+    }
+  };
+  const parseText = () => {
+    let text = "";
+    while (pos < xml2.length && xml2[pos] !== "<") {
+      if (xml2[pos] === "&") {
+        text += parseEntity();
+      } else {
+        text += xml2[pos++];
+      }
+    }
+    return text;
+  };
+  const parseNode = () => {
+    skipWhitespace();
+    if (pos >= xml2.length) return null;
+    if (xml2[pos] !== "<") {
+      const text = parseText().trim();
+      if (text) {
+        return { type: "text", value: text };
+      }
+      return null;
+    }
+    pos++;
+    if (xml2.slice(pos, pos + 3) === "!--") {
+      pos += 3;
+      const endPos = xml2.indexOf("-->", pos);
+      if (endPos === -1) throw new Error("Unclosed comment");
+      const value = xml2.slice(pos, endPos);
+      pos = endPos + 3;
+      return { type: "comment", value };
+    }
+    if (xml2.slice(pos, pos + 8) === "![CDATA[") {
+      pos += 8;
+      const endPos = xml2.indexOf("]]>", pos);
+      if (endPos === -1) throw new Error("Unclosed CDATA");
+      const value = xml2.slice(pos, endPos);
+      pos = endPos + 3;
+      return { type: "cdata", value };
+    }
+    if (xml2[pos] === "?") {
+      const endPos = xml2.indexOf("?>", pos);
+      if (endPos === -1) throw new Error("Unclosed processing instruction");
+      pos = endPos + 2;
+      return parseNode();
+    }
+    if (xml2[pos] === "!") {
+      const endPos = xml2.indexOf(">", pos);
+      if (endPos === -1) throw new Error("Unclosed declaration");
+      pos = endPos + 1;
+      return parseNode();
+    }
+    if (xml2[pos] === "/") {
+      return null;
+    }
+    let name = "";
+    while (pos < xml2.length && /[a-zA-Z0-9_:-]/.test(xml2[pos])) {
+      name += xml2[pos++];
+    }
+    if (!name) throw new Error(`Expected element name at position ${pos}`);
+    const attributes = parseAttributes();
+    skipWhitespace();
+    if (xml2.slice(pos, pos + 2) === "/>") {
+      pos += 2;
+      return { type: "element", name, attributes, children: [] };
+    }
+    if (xml2[pos] !== ">") {
+      throw new Error(`Expected > at position ${pos}`);
+    }
+    pos++;
+    const children = [];
+    while (pos < xml2.length) {
+      skipWhitespace();
+      if (xml2.slice(pos, pos + 2) === "</") {
+        pos += 2;
+        let closeName = "";
+        while (pos < xml2.length && /[a-zA-Z0-9_:-]/.test(xml2[pos])) {
+          closeName += xml2[pos++];
+        }
+        skipWhitespace();
+        if (xml2[pos] !== ">") throw new Error(`Expected > at position ${pos}`);
+        pos++;
+        if (closeName !== name) {
+          throw new Error(`Mismatched tags: ${name} vs ${closeName}`);
+        }
+        break;
+      }
+      const child = parseNode();
+      if (child) {
+        children.push(child);
+      } else if (xml2[pos] !== "<") {
+        break;
+      }
+    }
+    return { type: "element", name, attributes, children };
+  };
+  const root = parseNode();
+  if (!root) throw new Error("Empty document");
+  return root;
+}
+function queryXml(node, query) {
+  const parts = query.split("/").filter((p) => p);
+  if (parts.length === 0) return node;
+  let current = node;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.startsWith("@")) {
+      const attrName = part.slice(1);
+      if (Array.isArray(current)) {
+        return current.filter((n) => n.type === "element" && n.attributes?.[attrName]).map((n) => n.attributes[attrName]);
+      }
+      if (current.type === "element" && current.attributes?.[attrName]) {
+        return current.attributes[attrName];
+      }
+      return null;
+    }
+    const isRecursive = part === "";
+    if (isRecursive) {
+      i++;
+      if (i >= parts.length) return null;
+      const targetName = parts[i];
+      const results = [];
+      const findAll = (n) => {
+        if (n.type === "element") {
+          if (n.name === targetName) results.push(n);
+          if (n.children) n.children.forEach(findAll);
+        }
+      };
+      if (Array.isArray(current)) {
+        current.forEach(findAll);
+      } else {
+        findAll(current);
+      }
+      current = results;
+      continue;
+    }
+    if (Array.isArray(current)) {
+      const results = [];
+      for (const n of current) {
+        if (n.type === "element" && n.children) {
+          for (const child of n.children) {
+            if (child.type === "element" && child.name === part) {
+              results.push(child);
+            }
+          }
+        }
+      }
+      current = results;
+    } else {
+      if (current.type !== "element" || !current.children) return null;
+      const matches = current.children.filter(
+        (c) => c.type === "element" && c.name === part
+      );
+      if (matches.length === 0) return null;
+      if (matches.length === 1) {
+        current = matches[0];
+      } else {
+        current = matches;
+      }
+    }
+  }
+  return current;
+}
+function xml() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const parsed = parseXml(input.xml);
+    let result = parsed;
+    let type = "document";
+    if (input.query) {
+      result = queryXml(parsed, input.query);
+      if (result === null) {
+        type = "element";
+      } else if (typeof result === "string") {
+        type = "text";
+      } else if (Array.isArray(result)) {
+        type = "array";
+      } else {
+        type = "element";
+      }
+    }
+    const output = {
+      result,
+      type
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      result: null,
+      type: "document",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogitator-ai/wasm-tools",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "WASM-based tools for Cogitator agents",
   "type": "module",
   "main": "./dist/index.js",