@gzl10/ts-helpers 4.2.1

package/dist/node/data.js

@@ -0,0 +1,880 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/environment.ts
+function isNodeEnvironment() {
+  return typeof window === "undefined" && typeof process !== "undefined" && !!process.versions?.node;
+}
+function isBrowserEnvironment() {
+  const win = typeof window !== "undefined" ? window : global.window;
+  const doc = typeof document !== "undefined" ? document : global.document;
+  return typeof win !== "undefined" && win !== null && typeof doc !== "undefined" && doc !== null;
+}
+var isNode, isBrowser;
+var init_environment = __esm({
+  "src/environment.ts"() {
+    "use strict";
+    isNode = isNodeEnvironment;
+    isBrowser = isBrowserEnvironment;
+  }
+});
+
+// src/tree.ts
+var tree_exports = {};
+__export(tree_exports, {
+  renderTreeAsText: () => renderTreeAsText
+});
+function renderTreeAsText(data, options) {
+  if (!data || !Array.isArray(data)) {
+    return "";
+  }
+  if (data.length === 0) {
+    return "";
+  }
+  const {
+    labelField = "name",
+    verticalLine = "\u2502   ",
+    middleBranch = "\u251C\u2500\u2500 ",
+    lastBranch = "\u2514\u2500\u2500 ",
+    emptySpace = "    ",
+    labelFunction
+  } = options || {};
+  const visited = /* @__PURE__ */ new WeakSet();
+  const getLabel = (node) => {
+    try {
+      if (labelFunction) return String(labelFunction(node));
+      if (node == null) return "[null]";
+      if (typeof node !== "object") return String(node);
+      return node[labelField] != null ? String(node[labelField]) : String(node);
+    } catch (_error) {
+      return "[error]";
+    }
+  };
+  const renderNode = (node, prefix = "", isLast = true, depth = 0) => {
+    if (node == null) {
+      return "";
+    }
+    if (typeof node === "object" && visited.has(node)) {
+      return `${prefix + (isLast ? lastBranch : middleBranch)}[circular reference]`;
+    }
+    if (depth > 100) {
+      return `${prefix + (isLast ? lastBranch : middleBranch)}[max depth exceeded]`;
+    }
+    if (typeof node === "object") {
+      visited.add(node);
+    }
+    const lines = [];
+    const currentPrefix = isLast ? lastBranch : middleBranch;
+    lines.push(prefix + currentPrefix + getLabel(node));
+    const children = Array.isArray(node.children) ? node.children.filter((child) => child != null) : [];
+    const nextPrefix = prefix + (isLast ? emptySpace : verticalLine);
+    children.forEach((child, index) => {
+      const isLastChild = index === children.length - 1;
+      const childOutput = renderNode(child, nextPrefix, isLastChild, depth + 1);
+      if (childOutput) {
+        lines.push(childOutput);
+      }
+    });
+    return lines.join("\n");
+  };
+  const validRoots = data.filter((root) => root != null);
+  if (validRoots.length === 0) {
+    return "";
+  }
+  return validRoots.map((root, index) => renderNode(root, "", index === validRoots.length - 1)).join("\n");
+}
+var init_tree = __esm({
+  "src/tree.ts"() {
+    "use strict";
+  }
+});
+
+// src/validators.ts
+var validators_exports = {};
+__export(validators_exports, {
+  isValidFilePath: () => isValidFilePath,
+  isValidFileSize: () => isValidFileSize,
+  isValidTextContent: () => isValidTextContent
+});
+function isValidFilePath(filePath) {
+  if (!filePath || typeof filePath !== "string") return false;
+  if (typeof filePath === "object") return false;
+  if (filePath.length === 0 || filePath.length > 1e3) return false;
+  if (filePath.includes("../") || filePath.includes("..\\")) return false;
+  const suspiciousPatterns = ["//", "\\\\", "//\\", "\\//", "/./", "\\.\\"];
+  if (suspiciousPatterns.some((pattern) => filePath.includes(pattern))) return false;
+  const encodedPatterns = [
+    "%2e%2e%2f",
+    // ../
+    "%2e%2e/",
+    // ../
+    "%2e%2e%5c",
+    // ..\
+    "%252e"
+    // double-encoded
+  ];
+  if (encodedPatterns.some((pattern) => filePath.toLowerCase().includes(pattern))) return false;
+  if (filePath.includes("\0")) return false;
+  const commandChars = [";", "&", "|", "`", "$", "(", ")", "{", "}"];
+  if (commandChars.some((char) => filePath.includes(char))) return false;
+  const sqlPatterns = ["'", '"', "--", "/*", "*/", "DROP", "DELETE", "UNION", "SELECT"];
+  const lowerPath = filePath.toLowerCase();
+  if (sqlPatterns.some(
+    (pattern) => lowerPath.includes(pattern.toLowerCase()) && (pattern === "'" || pattern === '"' || lowerPath.includes(` ${pattern.toLowerCase()}`))
+  ))
+    return false;
+  const dangerousUnicode = [
+    "\u202E",
+    // Right-to-left override
+    "\u200B",
+    // Zero-width space
+    "\u200C",
+    // Zero-width non-joiner
+    "\u200D",
+    // Zero-width joiner
+    "\uFEFF"
+    // Zero-width no-break space
+  ];
+  if (dangerousUnicode.some((char) => filePath.includes(char))) return false;
+  if (/^[A-Za-z]:\\.*\\\.\./.test(filePath)) return false;
+  return true;
+}
+function isValidFileSize(size, maxSize) {
+  return typeof size === "number" && size >= 0 && size <= maxSize;
+}
+function isValidTextContent(content, options = {}) {
+  const { maxLength = 1e6 } = options;
+  if (typeof content !== "string") return false;
+  if (content.length > maxLength) return false;
+  const lowerContent = content.toLowerCase();
+  const scriptPatterns = ["<script", "</script", "<scr<script>ipt", "<scr\0ipt"];
+  if (scriptPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const eventHandlers = [
+    "onerror",
+    "onload",
+    "onclick",
+    "onmouseover",
+    "onfocus",
+    "onblur",
+    "oninput"
+  ];
+  if (eventHandlers.some((handler) => lowerContent.includes(handler))) return false;
+  const protocolPatterns = [
+    "javascript:",
+    "data:text/html",
+    "data:text/javascript",
+    "data:application",
+    "vbscript:",
+    "file:///",
+    "steam://",
+    "slack://"
+  ];
+  if (protocolPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const encodedPatterns = [
+    "&#60;script",
+    // &#60; = <
+    "%3cscript",
+    // %3c = <
+    "\\x3cscript",
+    // \x3c = <
+    "\\u003cscript"
+    // \u003c = <
+  ];
+  if (encodedPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  if (lowerContent.includes("<svg") && lowerContent.includes("onload")) return false;
+  if (lowerContent.includes("<iframe")) return false;
+  return true;
+}
+var init_validators = __esm({
+  "src/validators.ts"() {
+    "use strict";
+  }
+});
+
+// src/csv.ts
+var csv_exports = {};
+__export(csv_exports, {
+  exportCSV: () => exportCSV,
+  importCSV: () => importCSV
+});
+async function exportCSV(data, filePath, options) {
+  if (data == null) {
+    throw new TypeError("Data cannot be null or undefined");
+  }
+  if (!Array.isArray(data)) {
+    throw new TypeError("Data must be an array");
+  }
+  if (data.length === 0) {
+    throw new Error("Data array cannot be empty");
+  }
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  const csvText = import_papaparse.default.unparse(data, {
+    delimiter: ";",
+    header: true,
+    ...options
+  });
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, `\uFEFF${csvText}`, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([`\uFEFF${csvText}`], { type: "text/csv;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "data.csv";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importCSV(filePath, options) {
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    const parseResult = import_papaparse.default.parse(content, {
+      header: true,
+      delimiter: ";",
+      skipEmptyLines: true,
+      ...options
+    });
+    return parseResult.data || [];
+  } else {
+    throw new Error("CSV import not supported in browser. Use readFileAsText() with a File object.");
+  }
+}
+var import_papaparse;
+var init_csv = __esm({
+  "src/csv.ts"() {
+    "use strict";
+    import_papaparse = __toESM(require("papaparse"));
+    init_environment();
+  }
+});
+
+// src/json.ts
+var json_exports = {};
+__export(json_exports, {
+  exportJSON: () => exportJSON,
+  importJSON: () => importJSON
+});
+async function exportJSON(data, filePath, options) {
+  if (data === null || data === void 0) {
+    throw new TypeError("Data cannot be null or undefined");
+  }
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  const { indent = 2 } = options || {};
+  let jsonText;
+  try {
+    jsonText = JSON.stringify(data, null, indent);
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("circular")) {
+      throw new TypeError("Cannot serialize data with circular references");
+    }
+    throw error;
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, jsonText, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([jsonText], { type: "application/json;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "data.json";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importJSON(filePath, _options) {
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    throw new TypeError("File path must be a non-empty string");
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, { encoding: "utf-8" });
+    const trimmed = content.trim();
+    if (trimmed === "") {
+      throw new SyntaxError("JSON file is empty");
+    }
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new SyntaxError(`Invalid JSON in file ${filePath}: ${error.message}`);
+      }
+      throw error;
+    }
+  } else {
+    throw new Error(
+      "JSON import not supported in browser. Use readFileAsText() with a File object."
+    );
+  }
+}
+var init_json = __esm({
+  "src/json.ts"() {
+    "use strict";
+    init_environment();
+  }
+});
+
+// src/data.ts
+var data_exports = {};
+__export(data_exports, {
+  detectFileExtension: () => detectFileExtension,
+  detectFormatFromFilename: () => detectFormatFromFilename,
+  detectUniversalFormat: () => detectUniversalFormat,
+  exportData: () => exportData,
+  exportTree: () => exportTree,
+  exportTxt: () => exportTxt,
+  importData: () => importData,
+  importTree: () => importTree,
+  importTxt: () => importTxt,
+  readFileAsText: () => readFileAsText,
+  validateCSVData: () => validateCSVData,
+  validateExportData: () => validateExportData
+});
+module.exports = __toCommonJS(data_exports);
+
+// src/errors.ts
+var TsHelpersError = class _TsHelpersError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "TsHelpersError";
+    this.code = options.code;
+    this.data = options.data;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TsHelpersError);
+    }
+  }
+};
+var DataError = class extends TsHelpersError {
+  constructor(message, code, data) {
+    super(message, { code, data });
+    this.name = "DataError";
+  }
+};
+function createValidationError(message, field, value) {
+  return new TsHelpersError(`Validation failed: ${message}`, {
+    code: "VALIDATION_FAILED" /* VALIDATION_FAILED */,
+    data: { field, value }
+  });
+}
+
+// src/data.ts
+init_environment();
+var readFileAsText = async (fileOrPath, encoding = "utf8") => {
+  if (isNode() && typeof fileOrPath === "string") {
+    const fs = await import("fs/promises");
+    return fs.readFile(fileOrPath, encoding);
+  } else if (isBrowser() && fileOrPath instanceof File) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (e) => resolve(e.target?.result);
+      reader.onerror = () => reject(new Error("Error reading file"));
+      reader.readAsText(fileOrPath);
+    });
+  } else {
+    throw new DataError(
+      "Invalid parameter for current environment",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      {
+        data: {
+          isNodeEnv: isNode(),
+          isBrowserEnv: isBrowser(),
+          parameterType: typeof fileOrPath
+        }
+      }
+    );
+  }
+};
+function validateExportData(data) {
+  if (!Array.isArray(data)) {
+    throw createValidationError("Data must be an array", "data", typeof data);
+  }
+  if (data.length === 0) {
+    throw createValidationError("Data array cannot be empty", "data.length", data.length);
+  }
+  const firstItem = data[0];
+  const isObjectArray = typeof firstItem === "object" && firstItem !== null && !Array.isArray(firstItem);
+  const isArrayOfArrays = Array.isArray(firstItem);
+  if (!isObjectArray && !isArrayOfArrays) {
+    throw createValidationError(
+      "Data must be an array of objects or an array of arrays",
+      "data[0]",
+      typeof firstItem
+    );
+  }
+  if (isObjectArray) {
+    for (let i = 1; i < data.length; i++) {
+      const item = data[i];
+      if (typeof item !== "object" || item === null || Array.isArray(item)) {
+        throw createValidationError(
+          "All elements must be objects if first one is an object",
+          `data[${i}]`,
+          typeof item
+        );
+      }
+    }
+  } else if (isArrayOfArrays) {
+    const firstRowLength = firstItem.length;
+    for (let i = 1; i < data.length; i++) {
+      if (!Array.isArray(data[i])) {
+        throw createValidationError(`Row ${i} is not an array`, `data[${i}]`, typeof data[i]);
+      }
+      if (data[i].length !== firstRowLength) {
+        throw createValidationError(
+          `Row ${i} has ${data[i].length} columns, but first has ${firstRowLength}`,
+          `data[${i}].length`,
+          { expected: firstRowLength, actual: data[i].length }
+        );
+      }
+    }
+  }
+  return true;
+}
+var validateCSVData = validateExportData;
+function detectFormatFromFilename(filename) {
+  const parts = filename.toLowerCase().split(".");
+  const extension = parts.length > 1 ? parts.pop() : void 0;
+  switch (extension) {
+    case "csv":
+      return "csv";
+    case "json":
+      return "json";
+    case "tree":
+      return "tree";
+    case "txt":
+      return "txt";
+    default:
+      if (!extension) {
+        throw new DataError(
+          "Could not detect file format. Must have a valid extension (.csv, .json, .tree, .txt)",
+          "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+          { data: { filename } }
+        );
+      }
+      throw new DataError(
+        `Unsupported file format: .${extension}. Use .csv, .json, .tree or .txt`,
+        "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+        { data: { filename, extension } }
+      );
+  }
+}
+function detectFileExtension(filename) {
+  if (!filename || typeof filename !== "string") {
+    return null;
+  }
+  const parts = filename.trim().split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+  const extension = parts.pop()?.toLowerCase();
+  return extension || null;
+}
+function detectUniversalFormat(filename) {
+  const extension = detectFileExtension(filename);
+  if (!extension) {
+    return {
+      extension: null,
+      category: "unknown",
+      isText: false,
+      isBinary: false,
+      mimeType: null
+    };
+  }
+  const formatInfo = {
+    // Data formats
+    json: { category: "data", isText: true, isBinary: false, mimeType: "application/json" },
+    csv: { category: "data", isText: true, isBinary: false, mimeType: "text/csv" },
+    xml: { category: "data", isText: true, isBinary: false, mimeType: "application/xml" },
+    yaml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    yml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    tree: { category: "data", isText: true, isBinary: false, mimeType: "text/plain" },
+    tsv: { category: "data", isText: true, isBinary: false, mimeType: "text/tab-separated-values" },
+    sql: { category: "data", isText: true, isBinary: false, mimeType: "application/sql" },
+    db: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    sqlite: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    // Text and code formats
+    txt: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    md: { category: "text", isText: true, isBinary: false, mimeType: "text/markdown" },
+    rst: { category: "text", isText: true, isBinary: false, mimeType: "text/x-rst" },
+    rtf: { category: "text", isText: true, isBinary: false, mimeType: "application/rtf" },
+    log: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Web formats
+    html: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    htm: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    css: { category: "web", isText: true, isBinary: false, mimeType: "text/css" },
+    scss: { category: "web", isText: true, isBinary: false, mimeType: "text/x-scss" },
+    sass: { category: "web", isText: true, isBinary: false, mimeType: "text/x-sass" },
+    less: { category: "web", isText: true, isBinary: false, mimeType: "text/x-less" },
+    // Programming languages
+    js: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    mjs: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    jsx: { category: "code", isText: true, isBinary: false, mimeType: "text/jsx" },
+    ts: { category: "code", isText: true, isBinary: false, mimeType: "application/typescript" },
+    tsx: { category: "code", isText: true, isBinary: false, mimeType: "text/tsx" },
+    py: { category: "code", isText: true, isBinary: false, mimeType: "text/x-python" },
+    java: { category: "code", isText: true, isBinary: false, mimeType: "text/x-java-source" },
+    php: { category: "code", isText: true, isBinary: false, mimeType: "application/x-httpd-php" },
+    rb: { category: "code", isText: true, isBinary: false, mimeType: "text/x-ruby" },
+    go: { category: "code", isText: true, isBinary: false, mimeType: "text/x-go" },
+    rs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-rust" },
+    c: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cpp: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    cc: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    h: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-csharp" },
+    sh: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    bash: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    ps1: { category: "code", isText: true, isBinary: false, mimeType: "application/x-powershell" },
+    // Microsoft Office documents
+    doc: { category: "document", isText: false, isBinary: true, mimeType: "application/msword" },
+    docx: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    },
+    xls: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-excel"
+    },
+    xlsx: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    },
+    ppt: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-powerpoint"
+    },
+    pptx: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    },
+    // LibreOffice/OpenOffice
+    odt: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.text"
+    },
+    ods: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.spreadsheet"
+    },
+    odp: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.presentation"
+    },
+    // Other document formats
+    pdf: { category: "document", isText: false, isBinary: true, mimeType: "application/pdf" },
+    epub: { category: "document", isText: false, isBinary: true, mimeType: "application/epub+zip" },
+    mobi: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-mobipocket-ebook"
+    },
+    // Image formats
+    jpg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    jpeg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    png: { category: "image", isText: false, isBinary: true, mimeType: "image/png" },
+    gif: { category: "image", isText: false, isBinary: true, mimeType: "image/gif" },
+    svg: { category: "image", isText: true, isBinary: false, mimeType: "image/svg+xml" },
+    webp: { category: "image", isText: false, isBinary: true, mimeType: "image/webp" },
+    avif: { category: "image", isText: false, isBinary: true, mimeType: "image/avif" },
+    bmp: { category: "image", isText: false, isBinary: true, mimeType: "image/bmp" },
+    tiff: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    tif: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    ico: { category: "image", isText: false, isBinary: true, mimeType: "image/x-icon" },
+    psd: {
+      category: "image",
+      isText: false,
+      isBinary: true,
+      mimeType: "image/vnd.adobe.photoshop"
+    },
+    // Audio formats
+    mp3: { category: "audio", isText: false, isBinary: true, mimeType: "audio/mpeg" },
+    wav: { category: "audio", isText: false, isBinary: true, mimeType: "audio/wav" },
+    flac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/flac" },
+    ogg: { category: "audio", isText: false, isBinary: true, mimeType: "audio/ogg" },
+    aac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/aac" },
+    m4a: { category: "audio", isText: false, isBinary: true, mimeType: "audio/m4a" },
+    wma: { category: "audio", isText: false, isBinary: true, mimeType: "audio/x-ms-wma" },
+    // Video formats
+    mp4: { category: "video", isText: false, isBinary: true, mimeType: "video/mp4" },
+    avi: { category: "video", isText: false, isBinary: true, mimeType: "video/x-msvideo" },
+    mov: { category: "video", isText: false, isBinary: true, mimeType: "video/quicktime" },
+    wmv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-ms-wmv" },
+    flv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-flv" },
+    webm: { category: "video", isText: false, isBinary: true, mimeType: "video/webm" },
+    mkv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-matroska" },
+    "3gp": { category: "video", isText: false, isBinary: true, mimeType: "video/3gpp" },
+    // Archive formats
+    zip: { category: "archive", isText: false, isBinary: true, mimeType: "application/zip" },
+    rar: {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-rar-compressed"
+    },
+    "7z": {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-7z-compressed"
+    },
+    tar: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-tar" },
+    gz: { category: "archive", isText: false, isBinary: true, mimeType: "application/gzip" },
+    bz2: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-bzip2" },
+    xz: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-xz" },
+    // Configuration files
+    ini: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    cfg: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    conf: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    toml: { category: "config", isText: true, isBinary: false, mimeType: "application/toml" },
+    env: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Font formats
+    ttf: { category: "font", isText: false, isBinary: true, mimeType: "font/ttf" },
+    otf: { category: "font", isText: false, isBinary: true, mimeType: "font/otf" },
+    woff: { category: "font", isText: false, isBinary: true, mimeType: "font/woff" },
+    woff2: { category: "font", isText: false, isBinary: true, mimeType: "font/woff2" },
+    eot: {
+      category: "font",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-fontobject"
+    }
+  };
+  const info = formatInfo[extension] || {
+    category: "unknown",
+    isText: false,
+    isBinary: false,
+    mimeType: null
+  };
+  return {
+    extension,
+    ...info
+  };
+}
+async function exportTree(data, filePath, options) {
+  if (!Array.isArray(data)) {
+    throw createValidationError(
+      "Data for tree format must be an array of nodes",
+      "data",
+      typeof data
+    );
+  }
+  const { renderTreeAsText: renderTreeAsText2 } = await Promise.resolve().then(() => (init_tree(), tree_exports));
+  const treeText = renderTreeAsText2(data, options);
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, treeText, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([treeText], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "tree.tree";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importTree(filePath, _options) {
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    return fs.readFile(filePath, { encoding: "utf-8" });
+  } else {
+    throw new DataError(
+      ".tree file import is not supported in browser. Use readFileAsText() with a File object.",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      { data: { environment: "browser", operation: "importTree" } }
+    );
+  }
+}
+async function exportTxt(data, filePath, options) {
+  const { separator = "\n", stringify, indent = 2 } = options || {};
+  let textContent;
+  if (stringify) {
+    textContent = stringify(data);
+  } else if (typeof data === "string") {
+    textContent = data;
+  } else if (Array.isArray(data)) {
+    textContent = data.map((item) => typeof item === "string" ? item : JSON.stringify(item, null, indent)).join(separator);
+  } else if (typeof data === "object" && data !== null) {
+    textContent = JSON.stringify(data, null, indent);
+  } else {
+    textContent = String(data);
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, textContent, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([textContent], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "file.txt";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+function sanitizeTextContent(content) {
+  return content.replace(/\r\n|\r/g, "\n").replace(/[\x00-\x08\x0E-\x1F\x7F]/g, "").replace(/\n{4,}/g, "\n\n\n").replace(/[ \t]+$/gm, "");
+}
+async function importTxt(filePath, options = {}) {
+  const {
+    maxFileSize = 10 * 1024 * 1024,
+    // 10MB default
+    maxLength = 1e6,
+    // 1M characters default
+    validateSecurity = true,
+    sanitize = true
+  } = options;
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const { isValidFilePath: isValidFilePath2, isValidFileSize: isValidFileSize2, isValidTextContent: isValidTextContent2 } = await Promise.resolve().then(() => (init_validators(), validators_exports));
+    if (!isValidFilePath2(filePath)) {
+      throw new Error("Invalid or unsafe file path");
+    }
+    const resolvedPath = path.resolve(filePath);
+    try {
+      const stats = await fs.stat(resolvedPath);
+      if (!isValidFileSize2(stats.size, maxFileSize)) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${maxFileSize})`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      throw error;
+    }
+    const content = await fs.readFile(resolvedPath, { encoding: "utf-8" });
+    if (validateSecurity && !isValidTextContent2(content, { maxLength })) {
+      throw new Error("File contains potentially dangerous content or exceeds security limits");
+    }
+    return sanitize ? sanitizeTextContent(content) : content;
+  } else {
+    throw new Error(
+      ".txt file import is not supported in browser. Use readFileAsText() with a File object."
+    );
+  }
+}
+async function exportData(data, filePath, options) {
+  const format = detectFormatFromFilename(filePath);
+  if (format === "csv") {
+    validateExportData(data);
+  }
+  switch (format) {
+    case "csv": {
+      const { exportCSV: exportCSV2 } = await Promise.resolve().then(() => (init_csv(), csv_exports));
+      return exportCSV2(data, filePath, options);
+    }
+    case "json": {
+      const { exportJSON: exportJSON2 } = await Promise.resolve().then(() => (init_json(), json_exports));
+      return exportJSON2(data, filePath, options);
+    }
+    case "tree": {
+      return exportTree(data, filePath, options);
+    }
+    case "txt": {
+      return exportTxt(data, filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+async function importData(filePath, options) {
+  const format = detectFormatFromFilename(filePath);
+  switch (format) {
+    case "csv": {
+      const { importCSV: importCSV2 } = await Promise.resolve().then(() => (init_csv(), csv_exports));
+      return importCSV2(filePath, options);
+    }
+    case "json": {
+      const { importJSON: importJSON2 } = await Promise.resolve().then(() => (init_json(), json_exports));
+      return importJSON2(filePath, options);
+    }
+    case "tree": {
+      return importTree(filePath, options);
+    }
+    case "txt": {
+      return importTxt(filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectFileExtension,
+  detectFormatFromFilename,
+  detectUniversalFormat,
+  exportData,
+  exportTree,
+  exportTxt,
+  importData,
+  importTree,
+  importTxt,
+  readFileAsText,
+  validateCSVData,
+  validateExportData
+});
+//# sourceMappingURL=data.js.map