@utilix-tech/sdk 0.1.0

package/dist/chunk-UC656APA.js

@@ -0,0 +1,1080 @@
+import { __export } from './chunk-MLKGABMK.js';
+import * as yaml from 'js-yaml';
+import { parse, stringify } from 'smol-toml';
+
+// src/tools/data.ts
+var data_exports = {};
+__export(data_exports, {
+  csvToJson: () => csvToJson,
+  detectDelimiter: () => detectDelimiter,
+  envToExport: () => envToExport,
+  envToJson: () => envToJson,
+  formatToml: () => formatToml,
+  formatXml: () => formatXml,
+  getSection: () => getSection,
+  getSectionNames: () => getSectionNames,
+  getTomlStats: () => getTomlStats,
+  getXmlStats: () => getXmlStats,
+  getYamlStats: () => getYamlStats,
+  iniToJson: () => iniToJson,
+  jsonToIni: () => jsonToIni,
+  jsonToToml: () => jsonToToml,
+  jsonToXml: () => jsonToXml,
+  minifyToml: () => minifyToml,
+  minifyXml: () => minifyXml,
+  parseCsv: () => parseCsv,
+  parseEnv: () => parseEnv,
+  parseIni: () => parseIni,
+  parseXmlToObject: () => parseXmlToObject,
+  stringifyIni: () => stringifyIni,
+  toCsvString: () => toCsvString,
+  tomlToJson: () => tomlToJson,
+  validateEnvKey: () => validateEnvKey,
+  validateIni: () => validateIni,
+  validateToml: () => validateToml,
+  validateXml: () => validateXml,
+  validateYaml: () => validateYaml,
+  xmlToJson: () => xmlToJson
+});
+function validateYaml(input) {
+  if (!input.trim()) {
+    return { valid: true, documentCount: 0, keyCount: 0 };
+  }
+  try {
+    const docs = [];
+    yaml.loadAll(input, (doc) => docs.push(doc));
+    const first = docs[0];
+    const keyCount = first && typeof first === "object" && first !== null ? Object.keys(first).length : 0;
+    return { valid: true, documentCount: docs.length, keyCount };
+  } catch (e) {
+    const err = e;
+    return {
+      valid: false,
+      error: {
+        message: err.reason ?? err.message,
+        line: err.mark?.line != null ? err.mark.line + 1 : void 0,
+        column: err.mark?.column != null ? err.mark.column + 1 : void 0
+      },
+      documentCount: 0,
+      keyCount: 0
+    };
+  }
+}
+function _yamlMaxDepth(value, current = 0) {
+  if (value === null || typeof value !== "object") return current;
+  const children = Array.isArray(value) ? value : Object.values(value);
+  if (children.length === 0) return current;
+  return Math.max(...children.map((child) => _yamlMaxDepth(child, current + 1)));
+}
+function _yamlCountKeys(value) {
+  if (value === null || typeof value !== "object") return 0;
+  if (Array.isArray(value))
+    return value.reduce((sum, item) => sum + _yamlCountKeys(item), 0);
+  const obj = value;
+  return Object.keys(obj).length + Object.values(obj).reduce((sum, v) => sum + _yamlCountKeys(v), 0);
+}
+function getYamlStats(input) {
+  if (!input.trim()) return { lines: 0, keys: 0, depth: 0 };
+  try {
+    const doc = yaml.load(input);
+    return {
+      lines: input.split("\n").length,
+      keys: _yamlCountKeys(doc),
+      depth: _yamlMaxDepth(doc)
+    };
+  } catch (e) {
+    const err = e;
+    return { error: err.reason ?? err.message };
+  }
+}
+function formatToml(input) {
+  try {
+    const parsed = parse(input);
+    const output = stringify(parsed);
+    return { output, valid: true };
+  } catch (e) {
+    return { output: input, valid: false, error: e.message };
+  }
+}
+function minifyToml(input) {
+  try {
+    const parsed = parse(input);
+    const output = stringify(parsed);
+    return { output, valid: true };
+  } catch (e) {
+    return { output: input, valid: false, error: e.message };
+  }
+}
+function validateToml(input) {
+  try {
+    parse(input);
+    return { valid: true };
+  } catch (e) {
+    return { valid: false, error: e.message };
+  }
+}
+function tomlToJson(input) {
+  try {
+    const parsed = parse(input);
+    return JSON.stringify(parsed, null, 2);
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+function jsonToToml(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return stringify(parsed);
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+function _tomlCountStats(obj, stats) {
+  if (obj === null || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+        stats.tables++;
+        _tomlCountStats(item, stats);
+      } else if (Array.isArray(item)) {
+        stats.arrays++;
+        _tomlCountStats(item, stats);
+      } else {
+        stats.keys++;
+      }
+    }
+  } else {
+    for (const value of Object.values(obj)) {
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        stats.tables++;
+        _tomlCountStats(value, stats);
+      } else if (Array.isArray(value)) {
+        stats.arrays++;
+        _tomlCountStats(value, stats);
+      } else {
+        stats.keys++;
+      }
+    }
+  }
+}
+function getTomlStats(input) {
+  try {
+    const parsed = parse(input);
+    const stats = { keys: 0, tables: 0, arrays: 0 };
+    _tomlCountStats(parsed, stats);
+    return stats;
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+function validateXml(input) {
+  const stack = [];
+  let hasRoot = false;
+  const tagRegex = /<(?:[^"'<>]|"[^"]*"|'[^']*')*>/g;
+  let match;
+  while ((match = tagRegex.exec(input)) !== null) {
+    const tag = match[0];
+    if (tag.startsWith("<?")) continue;
+    if (tag.startsWith("<!--")) continue;
+    if (tag.startsWith("<![CDATA[")) continue;
+    if (tag.endsWith("/>")) continue;
+    if (tag.startsWith("</")) {
+      const nameMatch2 = tag.match(/^<\/([A-Za-z_][\w.-]*)/);
+      if (!nameMatch2) return { valid: false, error: "Invalid closing tag: " + tag };
+      const name2 = nameMatch2[1];
+      if (stack.length === 0) {
+        return { valid: false, error: `Unexpected closing tag </${name2}>` };
+      }
+      const top = stack.pop();
+      if (top !== name2) {
+        return {
+          valid: false,
+          error: `Mismatched tags: expected </${top}> but found </${name2}>`
+        };
+      }
+      continue;
+    }
+    const nameMatch = tag.match(/^<([A-Za-z_][\w.-]*)/);
+    if (!nameMatch) return { valid: false, error: "Invalid tag: " + tag };
+    const name = nameMatch[1];
+    stack.push(name);
+    hasRoot = true;
+  }
+  if (!hasRoot) {
+    return { valid: false, error: "No root element found" };
+  }
+  if (stack.length > 0) {
+    return { valid: false, error: `Unclosed tag: <${stack[stack.length - 1]}>` };
+  }
+  return { valid: true };
+}
+function _tokenizeXml(input) {
+  const tokens = [];
+  let pos = 0;
+  const len = input.length;
+  while (pos < len) {
+    if (input[pos] !== "<") {
+      const end = input.indexOf("<", pos);
+      const text = end === -1 ? input.slice(pos) : input.slice(pos, end);
+      if (text) tokens.push({ type: "text", value: text });
+      pos = end === -1 ? len : end;
+      continue;
+    }
+    if (input.startsWith("<?", pos)) {
+      const end = input.indexOf("?>", pos);
+      if (end === -1) {
+        tokens.push({ type: "pi", value: input.slice(pos) });
+        pos = len;
+      } else {
+        tokens.push({ type: "pi", value: input.slice(pos, end + 2) });
+        pos = end + 2;
+      }
+      continue;
+    }
+    if (input.startsWith("<!--", pos)) {
+      const end = input.indexOf("-->", pos);
+      if (end === -1) {
+        tokens.push({ type: "comment", value: input.slice(pos) });
+        pos = len;
+      } else {
+        tokens.push({ type: "comment", value: input.slice(pos, end + 3) });
+        pos = end + 3;
+      }
+      continue;
+    }
+    if (input.startsWith("<![CDATA[", pos)) {
+      const end = input.indexOf("]]>", pos);
+      if (end === -1) {
+        tokens.push({ type: "cdata", value: input.slice(pos) });
+        pos = len;
+      } else {
+        tokens.push({ type: "cdata", value: input.slice(pos, end + 3) });
+        pos = end + 3;
+      }
+      continue;
+    }
+    let tagEnd = pos + 1;
+    let inString = null;
+    while (tagEnd < len) {
+      const ch = input[tagEnd];
+      if (inString) {
+        if (ch === inString) inString = null;
+      } else {
+        if (ch === '"' || ch === "'") inString = ch;
+        else if (ch === ">") break;
+      }
+      tagEnd++;
+    }
+    const tag = input.slice(pos, tagEnd + 1);
+    pos = tagEnd + 1;
+    if (tag.startsWith("</")) {
+      const nameMatch2 = tag.match(/^<\/([A-Za-z_][\w.-]*)/);
+      const name2 = nameMatch2 ? nameMatch2[1] : "";
+      tokens.push({ type: "close", value: tag, name: name2 });
+      continue;
+    }
+    if (tag.endsWith("/>")) {
+      tokens.push({ type: "selfclose", value: tag });
+      continue;
+    }
+    const nameMatch = tag.match(/^<([A-Za-z_][\w.-]*)/);
+    const name = nameMatch ? nameMatch[1] : "";
+    tokens.push({ type: "open", value: tag, name });
+  }
+  return tokens;
+}
+function formatXml(input, indentSize = 2) {
+  const validation = validateXml(input);
+  const tokens = _tokenizeXml(input);
+  const indent = " ".repeat(indentSize);
+  const lines = [];
+  let level = 0;
+  const pad = (n) => indent.repeat(n);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    switch (token.type) {
+      case "pi":
+        lines.push(token.value);
+        break;
+      case "comment":
+        lines.push(pad(level) + token.value);
+        break;
+      case "cdata":
+        lines.push(pad(level) + token.value);
+        break;
+      case "open": {
+        const next = tokens[i + 1];
+        if (next && next.type === "close" && next.name === token.name) {
+          lines.push(pad(level) + `<${token.name}/>`);
+          i++;
+        } else {
+          lines.push(pad(level) + token.value);
+          level++;
+        }
+        break;
+      }
+      case "close":
+        level = Math.max(0, level - 1);
+        lines.push(pad(level) + token.value);
+        break;
+      case "selfclose":
+        lines.push(pad(level) + token.value);
+        break;
+      case "text": {
+        const trimmed = token.value.trim();
+        if (trimmed) {
+          lines.push(pad(level) + trimmed);
+        }
+        break;
+      }
+    }
+  }
+  const output = lines.join("\n");
+  return {
+    output,
+    originalSize: input.length,
+    outputSize: output.length,
+    valid: validation.valid,
+    error: validation.error
+  };
+}
+function minifyXml(input) {
+  const validation = validateXml(input);
+  const cdataRegex = /(<!\[CDATA\[[\s\S]*?]]>)/g;
+  const parts = input.split(cdataRegex);
+  const processed = parts.map((part, idx) => {
+    if (idx % 2 === 1) return part;
+    let result = part.replace(/<!--[\s\S]*?-->/g, "");
+    result = result.replace(/>\s+</g, "><");
+    return result;
+  }).join("");
+  const output = processed.trim();
+  return {
+    output,
+    originalSize: input.length,
+    outputSize: output.length,
+    valid: validation.valid,
+    error: validation.error
+  };
+}
+function _parseAttributes(attrStr) {
+  const attrs = {};
+  const re = /([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+  let m;
+  while ((m = re.exec(attrStr)) !== null) {
+    attrs[m[1]] = m[2] ?? m[3] ?? m[4] ?? "";
+  }
+  return attrs;
+}
+function _xmlTokenize(xml) {
+  const tokens = [];
+  let i = 0;
+  const len = xml.length;
+  while (i < len) {
+    if (xml[i] !== "<") {
+      const start = i;
+      while (i < len && xml[i] !== "<") i++;
+      const text = xml.slice(start, i);
+      if (text.trim().length > 0) {
+        tokens.push({ type: "TEXT", value: text.trim() });
+      }
+      continue;
+    }
+    if (xml.startsWith("<?", i)) {
+      const end = xml.indexOf("?>", i);
+      if (end === -1) {
+        i = len;
+      } else {
+        tokens.push({ type: "XML_DECL" });
+        i = end + 2;
+      }
+    } else if (xml.startsWith("<!--", i)) {
+      const end = xml.indexOf("-->", i);
+      if (end === -1) {
+        i = len;
+      } else {
+        tokens.push({ type: "COMMENT" });
+        i = end + 3;
+      }
+    } else if (xml.startsWith("<![CDATA[", i)) {
+      const end = xml.indexOf("]]>", i);
+      if (end === -1) {
+        i = len;
+      } else {
+        const cdataValue = xml.slice(i + 9, end);
+        tokens.push({ type: "CDATA", value: cdataValue });
+        i = end + 3;
+      }
+    } else if (xml.startsWith("</", i)) {
+      const end = xml.indexOf(">", i);
+      if (end === -1) {
+        i = len;
+      } else {
+        const name = xml.slice(i + 2, end).trim();
+        tokens.push({ type: "CLOSE_TAG", name });
+        i = end + 1;
+      }
+    } else {
+      const end = xml.indexOf(">", i);
+      if (end === -1) {
+        i = len;
+      } else {
+        const raw = xml.slice(i + 1, end);
+        const selfClose = raw.endsWith("/");
+        const content = selfClose ? raw.slice(0, -1).trim() : raw.trim();
+        const spaceIdx = content.search(/\s/);
+        const name = spaceIdx === -1 ? content : content.slice(0, spaceIdx);
+        const attrStr = spaceIdx === -1 ? "" : content.slice(spaceIdx + 1);
+        const attrs = _parseAttributes(attrStr);
+        tokens.push({
+          type: selfClose ? "SELF_CLOSE" : "OPEN_TAG",
+          name,
+          attrs
+        });
+        i = end + 1;
+      }
+    }
+  }
+  return tokens;
+}
+function _buildTree(tokens) {
+  const root = { name: "__root__", attrs: {}, children: [], text: "" };
+  const stack = [root];
+  for (const tok of tokens) {
+    const current = stack[stack.length - 1];
+    if (tok.type === "OPEN_TAG") {
+      const node = { name: tok.name, attrs: tok.attrs ?? {}, children: [], text: "" };
+      current.children.push(node);
+      stack.push(node);
+    } else if (tok.type === "SELF_CLOSE") {
+      const node = { name: tok.name, attrs: tok.attrs ?? {}, children: [], text: "" };
+      current.children.push(node);
+    } else if (tok.type === "CLOSE_TAG") {
+      if (stack.length > 1) stack.pop();
+    } else if (tok.type === "TEXT") {
+      current.text += tok.value ?? "";
+    } else if (tok.type === "CDATA") {
+      current.text += tok.value ?? "";
+    }
+  }
+  return root.children[0] ?? null;
+}
+function _nodeToObject(node, opts) {
+  const obj = {};
+  if (!opts.ignoreAttributes) {
+    for (const [k, v] of Object.entries(node.attrs)) {
+      obj[opts.attributePrefix + k] = v;
+    }
+  }
+  const childGroups = {};
+  for (const child of node.children) {
+    if (!childGroups[child.name]) childGroups[child.name] = [];
+    childGroups[child.name].push(child);
+  }
+  for (const [childName, childNodes] of Object.entries(childGroups)) {
+    const converted = childNodes.map((c) => _nodeToObject(c, opts));
+    if (opts.arrayMode || childNodes.length > 1) {
+      obj[childName] = converted;
+    } else {
+      obj[childName] = converted[0];
+    }
+  }
+  const hasText = node.text.length > 0;
+  const hasChildren = node.children.length > 0;
+  const hasAttrs = Object.keys(obj).length > 0;
+  if (hasText) {
+    if (!hasChildren && !hasAttrs && opts.compact) {
+      return node.text;
+    }
+    obj[opts.textKey] = node.text;
+  }
+  if (!hasText && !hasChildren && !hasAttrs) {
+    return opts.compact ? "" : obj;
+  }
+  return obj;
+}
+function _resolvedXmlOptions(options) {
+  return {
+    compact: options?.compact ?? true,
+    ignoreAttributes: options?.ignoreAttributes ?? false,
+    attributePrefix: options?.attributePrefix ?? "@_",
+    textKey: options?.textKey ?? "#text",
+    arrayMode: options?.arrayMode ?? false,
+    spaces: options?.spaces ?? 2
+  };
+}
+function parseXmlToObject(xml, options) {
+  try {
+    const trimmed = xml.trim();
+    if (!trimmed) return { error: "Input is empty" };
+    const opts = _resolvedXmlOptions(options);
+    const tokens = _xmlTokenize(trimmed);
+    const tree = _buildTree(tokens);
+    if (!tree) return { error: "No root element found" };
+    const value = _nodeToObject(tree, opts);
+    return { [tree.name]: value };
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function xmlToJson(xml, options) {
+  const result = parseXmlToObject(xml, options);
+  if ("error" in result) return { error: result.error };
+  const spaces = options?.spaces ?? 2;
+  return JSON.stringify(result, null, spaces);
+}
+function getXmlStats(xml) {
+  try {
+    const trimmed = xml.trim();
+    if (!trimmed) return { elements: 0, attributes: 0, depth: 0, rootElement: "" };
+    const tokens = _xmlTokenize(trimmed);
+    let elements = 0;
+    let attributes = 0;
+    let depth = 0;
+    let maxDepth = 0;
+    let rootElement = "";
+    let rootFound = false;
+    for (const tok of tokens) {
+      if (tok.type === "OPEN_TAG") {
+        elements++;
+        depth++;
+        if (!rootFound) {
+          rootElement = tok.name;
+          rootFound = true;
+        }
+        if (depth > maxDepth) maxDepth = depth;
+        attributes += Object.keys(tok.attrs ?? {}).length;
+      } else if (tok.type === "SELF_CLOSE") {
+        elements++;
+        if (!rootFound) {
+          rootElement = tok.name;
+          rootFound = true;
+        }
+        const selfDepth = depth + 1;
+        if (selfDepth > maxDepth) maxDepth = selfDepth;
+        attributes += Object.keys(tok.attrs ?? {}).length;
+      } else if (tok.type === "CLOSE_TAG") {
+        depth--;
+      }
+    }
+    return { elements, attributes, depth: maxDepth, rootElement };
+  } catch {
+    return { elements: 0, attributes: 0, depth: 0, rootElement: "" };
+  }
+}
+function _valueToXml(tag, value, indent, spaces) {
+  const pad = " ".repeat(spaces);
+  if (Array.isArray(value)) {
+    return value.map((item) => _valueToXml(tag, item, indent, spaces)).join("\n");
+  }
+  if (value === null || value === void 0) {
+    return `${indent}<${tag} />`;
+  }
+  if (typeof value !== "object") {
+    return `${indent}<${tag}>${String(value)}</${tag}>`;
+  }
+  const obj = value;
+  const attrParts = [];
+  let textContent;
+  const children = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (k.startsWith("@_")) {
+      attrParts.push(`${k.slice(2)}="${String(v)}"`);
+    } else if (k === "#text") {
+      textContent = String(v);
+    } else {
+      children.push([k, v]);
+    }
+  }
+  const attrStr = attrParts.length > 0 ? " " + attrParts.join(" ") : "";
+  if (children.length === 0 && textContent !== void 0) {
+    return `${indent}<${tag}${attrStr}>${textContent}</${tag}>`;
+  }
+  if (children.length === 0 && textContent === void 0) {
+    return `${indent}<${tag}${attrStr} />`;
+  }
+  const childLines = children.map(([childTag, childVal]) => _valueToXml(childTag, childVal, indent + pad, spaces)).join("\n");
+  const textLine = textContent !== void 0 ? `${indent}${pad}${textContent}
+` : "";
+  return `${indent}<${tag}${attrStr}>
+${textLine}${childLines}
+${indent}</${tag}>`;
+}
+function jsonToXml(json, options) {
+  try {
+    const parsed = JSON.parse(json);
+    const spaces = options?.spaces ?? 2;
+    if (options?.rootElement) {
+      return _valueToXml(options.rootElement, parsed, "", spaces);
+    }
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const entries = Object.entries(parsed);
+      if (entries.length === 1) {
+        return _valueToXml(entries[0][0], entries[0][1], "", spaces);
+      }
+      const lines = entries.map(([k, v]) => _valueToXml(k, v, " ".repeat(spaces), spaces)).join("\n");
+      return `<root>
+${lines}
+</root>`;
+    }
+    return _valueToXml("root", parsed, "", spaces);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function detectDelimiter(input) {
+  const firstLine = input.split("\n")[0] ?? "";
+  const commaCount = (firstLine.match(/,/g) ?? []).length;
+  const tabCount = (firstLine.match(/\t/g) ?? []).length;
+  const semicolonCount = (firstLine.match(/;/g) ?? []).length;
+  if (tabCount > commaCount && tabCount > semicolonCount) return "	";
+  if (semicolonCount > commaCount) return ";";
+  return ",";
+}
+function _parseRow(line, delimiter, trim) {
+  const fields = [];
+  let i = 0;
+  while (i <= line.length) {
+    if (i === line.length) {
+      fields.push("");
+      break;
+    }
+    if (line[i] === '"') {
+      i++;
+      let field = "";
+      while (i < line.length) {
+        if (line[i] === '"') {
+          if (i + 1 < line.length && line[i + 1] === '"') {
+            field += '"';
+            i += 2;
+          } else {
+            i++;
+            break;
+          }
+        } else {
+          field += line[i];
+          i++;
+        }
+      }
+      if (trim) field = field.trim();
+      fields.push(field);
+      if (i < line.length && line.slice(i, i + delimiter.length) === delimiter) {
+        i += delimiter.length;
+      } else if (i < line.length) {
+        return { error: `Unexpected character after quoted field at position ${i}` };
+      }
+    } else {
+      const nextDelim = line.indexOf(delimiter, i);
+      const raw = nextDelim === -1 ? line.slice(i) : line.slice(i, nextDelim);
+      fields.push(trim ? raw.trim() : raw);
+      i = nextDelim === -1 ? line.length + 1 : nextDelim + delimiter.length;
+    }
+  }
+  return fields;
+}
+function _splitIntoLines(input, _delimiter) {
+  const lines = [];
+  let current = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === '"') {
+      if (inQuotes && i + 1 < input.length && input[i + 1] === '"') {
+        current += '""';
+        i += 2;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      current += ch;
+      i++;
+    } else if (!inQuotes && (ch === "\n" || ch === "\r" && input[i + 1] === "\n")) {
+      lines.push(current);
+      current = "";
+      if (ch === "\r") i++;
+      i++;
+    } else if (!inQuotes && ch === "\r") {
+      lines.push(current);
+      current = "";
+      i++;
+    } else {
+      current += ch;
+      i++;
+    }
+  }
+  if (current.length > 0) lines.push(current);
+  return lines;
+}
+function parseCsv(input, options) {
+  if (!input || input.trim() === "") return { error: "Input is empty" };
+  const delimiter = options?.delimiter ?? ",";
+  const hasHeader = options?.hasHeader !== false;
+  const trim = options?.trimWhitespace ?? false;
+  const maxRows = options?.maxRows;
+  const lines = _splitIntoLines(input);
+  if (lines.length === 0) return { error: "No data found" };
+  const warnings = [];
+  const allRows = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const result = _parseRow(line, delimiter, trim);
+    if ("error" in result) return { error: `Line ${i + 1}: ${result.error}` };
+    allRows.push(result);
+  }
+  if (allRows.length === 0) return { error: "No data found after parsing" };
+  const maxCols = Math.max(...allRows.map((r) => r.length));
+  let headers;
+  let dataRows;
+  if (hasHeader) {
+    headers = allRows[0];
+    dataRows = allRows.slice(1);
+  } else {
+    headers = Array.from({ length: maxCols }, (_, idx) => `Column ${idx + 1}`);
+    dataRows = allRows;
+  }
+  for (let i = 0; i < dataRows.length; i++) {
+    if (dataRows[i].length !== maxCols) {
+      warnings.push(`Row ${i + 1} has ${dataRows[i].length} columns, expected ${maxCols}`);
+    }
+  }
+  const totalRows = dataRows.length;
+  if (maxRows !== void 0 && dataRows.length > maxRows) {
+    warnings.push(`Truncated to ${maxRows} rows (${dataRows.length} total)`);
+    dataRows = dataRows.slice(0, maxRows);
+  }
+  return {
+    headers,
+    rows: dataRows,
+    totalRows,
+    totalCols: maxCols,
+    warnings
+  };
+}
+function csvToJson(input, options) {
+  const result = parseCsv(input, options);
+  if ("error" in result) return result;
+  const objects = result.rows.map((row) => {
+    const obj = {};
+    result.headers.forEach((header, i) => {
+      obj[header] = row[i] ?? "";
+    });
+    return obj;
+  });
+  return JSON.stringify(objects, null, 2);
+}
+function toCsvString(headers, rows) {
+  const escapeField = (field) => {
+    if (field.includes(",") || field.includes('"') || field.includes("\n") || field.includes("\r")) {
+      return `"${field.replace(/"/g, '""')}"`;
+    }
+    return field;
+  };
+  const lines = [];
+  lines.push(headers.map(escapeField).join(","));
+  for (const row of rows) {
+    lines.push(row.map(escapeField).join(","));
+  }
+  return lines.join("\n");
+}
+function parseIni(input) {
+  if (typeof input !== "string") {
+    return { error: "Input must be a string" };
+  }
+  const lines = input.split("\n");
+  const sections = [];
+  let currentSection = {
+    name: "",
+    keys: {},
+    comments: [],
+    lineStart: 1,
+    lineEnd: lines.length
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith(";")) {
+      currentSection.comments.push(trimmed);
+      continue;
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      currentSection.lineEnd = lineNum - 1;
+      sections.push(currentSection);
+      const sectionName = trimmed.slice(1, -1).trim();
+      currentSection = {
+        name: sectionName,
+        keys: {},
+        comments: [],
+        lineStart: lineNum,
+        lineEnd: lines.length
+      };
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    const colonIndex = trimmed.indexOf(":");
+    let sepIndex = -1;
+    if (eqIndex !== -1 && colonIndex !== -1) {
+      sepIndex = Math.min(eqIndex, colonIndex);
+    } else if (eqIndex !== -1) {
+      sepIndex = eqIndex;
+    } else if (colonIndex !== -1) {
+      sepIndex = colonIndex;
+    }
+    if (sepIndex !== -1) {
+      const key = trimmed.slice(0, sepIndex).trim();
+      let value = trimmed.slice(sepIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      currentSection.keys[key] = value;
+    }
+  }
+  currentSection.lineEnd = lines.length;
+  sections.push(currentSection);
+  const globalSection = sections.find((s) => s.name === "");
+  const globalKeys = globalSection ? { ...globalSection.keys } : {};
+  return {
+    sections,
+    global: globalKeys,
+    raw: input
+  };
+}
+function stringifyIni(parsed) {
+  const parts = [];
+  const globalSection = parsed.sections.find((s) => s.name === "");
+  if (globalSection) {
+    for (const comment of globalSection.comments) {
+      parts.push(comment);
+    }
+    for (const [key, value] of Object.entries(globalSection.keys)) {
+      parts.push(`${key} = ${value}`);
+    }
+  }
+  for (const section of parsed.sections) {
+    if (section.name === "") continue;
+    if (parts.length > 0) {
+      parts.push("");
+    }
+    parts.push(`[${section.name}]`);
+    for (const comment of section.comments) {
+      parts.push(comment);
+    }
+    for (const [key, value] of Object.entries(section.keys)) {
+      parts.push(`${key} = ${value}`);
+    }
+  }
+  return parts.join("\n");
+}
+function iniToJson(input) {
+  const result = parseIni(input);
+  if (typeof result === "object" && "error" in result) {
+    return result;
+  }
+  const obj = {};
+  for (const [key, value] of Object.entries(result.global)) {
+    obj[key] = value;
+  }
+  for (const section of result.sections) {
+    if (section.name === "") continue;
+    obj[section.name] = { ...section.keys };
+  }
+  return JSON.stringify(obj, null, 2);
+}
+function jsonToIni(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { error: "JSON must be a plain object" };
+  }
+  const globalLines = [];
+  const sectionLines = [];
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      sectionLines.push(`[${key}]`);
+      for (const [k, v] of Object.entries(value)) {
+        sectionLines.push(`${k} = ${v}`);
+      }
+      sectionLines.push("");
+    } else {
+      globalLines.push(`${key} = ${value}`);
+    }
+  }
+  const parts = [...globalLines];
+  if (globalLines.length > 0 && sectionLines.length > 0) {
+    parts.push("");
+  }
+  parts.push(...sectionLines);
+  return parts.join("\n").trimEnd();
+}
+function getSection(parsed, name) {
+  const section = parsed.sections.find((s) => s.name === name);
+  return section ? { ...section.keys } : null;
+}
+function getSectionNames(parsed) {
+  return parsed.sections.filter((s) => s.name !== "").map((s) => s.name);
+}
+function validateIni(input) {
+  const errors = [];
+  if (typeof input !== "string") {
+    return { valid: false, errors: ["Input must be a string"] };
+  }
+  const lines = input.split("\n");
+  const seenKeys = {};
+  let currentSection = "";
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      currentSection = trimmed.slice(1, -1).trim();
+      if (!seenKeys[currentSection]) {
+        seenKeys[currentSection] = /* @__PURE__ */ new Set();
+      }
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    const colonIndex = trimmed.indexOf(":");
+    let sepIndex = -1;
+    if (eqIndex !== -1 && colonIndex !== -1) {
+      sepIndex = Math.min(eqIndex, colonIndex);
+    } else if (eqIndex !== -1) {
+      sepIndex = eqIndex;
+    } else if (colonIndex !== -1) {
+      sepIndex = colonIndex;
+    }
+    if (sepIndex !== -1) {
+      const key = trimmed.slice(0, sepIndex).trim();
+      if (!seenKeys[currentSection]) {
+        seenKeys[currentSection] = /* @__PURE__ */ new Set();
+      }
+      if (seenKeys[currentSection].has(key)) {
+        errors.push(
+          `Duplicate key "${key}" in section "${currentSection || "global"}" at line ${lineNum}`
+        );
+      } else {
+        seenKeys[currentSection].add(key);
+      }
+    } else {
+      errors.push(`Malformed line at line ${lineNum}: "${trimmed}"`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function parseEnv(input) {
+  const entries = [];
+  const comments = [];
+  const errors = [];
+  const keyCount = {};
+  const rawLines = input.split("\n");
+  const lines = [];
+  let i = 0;
+  while (i < rawLines.length) {
+    let line = rawLines[i];
+    while (line.endsWith("\\") && i + 1 < rawLines.length) {
+      line = line.slice(0, -1) + rawLines[i + 1];
+      i++;
+    }
+    lines.push(line);
+    i++;
+  }
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const lineNum = lineIdx + 1;
+    const line = lines[lineIdx];
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("#")) {
+      comments.push({ line: lineNum, text: trimmed.slice(1).trim() });
+      continue;
+    }
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) {
+      errors.push({ line: lineNum, message: `Invalid line: missing '='` });
+      continue;
+    }
+    const key = trimmed.slice(0, eqIdx).trim();
+    if (!validateEnvKey(key)) {
+      errors.push({ line: lineNum, message: `Invalid key: '${key}'` });
+      continue;
+    }
+    const rest = trimmed.slice(eqIdx + 1);
+    let value = "";
+    let hasQuotes = false;
+    let inlineComment;
+    if (rest.startsWith('"')) {
+      hasQuotes = true;
+      const closeIdx = rest.indexOf('"', 1);
+      if (closeIdx === -1) {
+        errors.push({ line: lineNum, message: `Unclosed double quote for key '${key}'` });
+        continue;
+      }
+      value = rest.slice(1, closeIdx);
+      const afterQuote = rest.slice(closeIdx + 1).trim();
+      if (afterQuote.startsWith("#")) {
+        inlineComment = afterQuote.slice(1).trim();
+      }
+    } else if (rest.startsWith("'")) {
+      hasQuotes = true;
+      const closeIdx = rest.indexOf("'", 1);
+      if (closeIdx === -1) {
+        errors.push({ line: lineNum, message: `Unclosed single quote for key '${key}'` });
+        continue;
+      }
+      value = rest.slice(1, closeIdx);
+      const afterQuote = rest.slice(closeIdx + 1).trim();
+      if (afterQuote.startsWith("#")) {
+        inlineComment = afterQuote.slice(1).trim();
+      }
+    } else {
+      const hashIdx = rest.indexOf("#");
+      if (hashIdx !== -1) {
+        inlineComment = rest.slice(hashIdx + 1).trim();
+        value = rest.slice(0, hashIdx).trim();
+      } else {
+        value = rest.trim();
+      }
+    }
+    const interpolated = /\$\{[^}]+\}/.test(value);
+    keyCount[key] = (keyCount[key] ?? 0) + 1;
+    const entry = {
+      key,
+      value,
+      line: lineNum,
+      hasQuotes,
+      interpolated
+    };
+    if (inlineComment !== void 0) {
+      entry.comment = inlineComment;
+    }
+    entries.push(entry);
+  }
+  const duplicates = Object.entries(keyCount).filter(([, count]) => count > 1).map(([key]) => key);
+  return { entries, comments, errors, duplicates };
+}
+function envToJson(input) {
+  const result = parseEnv(input);
+  if (result.errors.length > 0) {
+    return { error: result.errors.map((e) => `Line ${e.line}: ${e.message}`).join("; ") };
+  }
+  const obj = {};
+  for (const entry of result.entries) {
+    obj[entry.key] = entry.value;
+  }
+  return JSON.stringify(obj, null, 2);
+}
+function envToExport(input) {
+  const result = parseEnv(input);
+  return result.entries.map((entry) => `export ${entry.key}="${entry.value.replace(/"/g, '\\"')}"`).join("\n");
+}
+function validateEnvKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+
+export { csvToJson, data_exports, detectDelimiter, envToExport, envToJson, formatToml, formatXml, getSection, getSectionNames, getTomlStats, getXmlStats, getYamlStats, iniToJson, jsonToIni, jsonToToml, jsonToXml, minifyToml, minifyXml, parseCsv, parseEnv, parseIni, parseXmlToObject, stringifyIni, toCsvString, tomlToJson, validateEnvKey, validateIni, validateToml, validateXml, validateYaml, xmlToJson };