@atmaticai/agent-tools-core 1.0.0

package/dist/index.js

@@ -0,0 +1,3744 @@
+'use strict';
+
+var Ajv = require('ajv');
+var addFormats = require('ajv-formats');
+var jsonpathPlus = require('jsonpath-plus');
+var jmespath = require('jmespath');
+var JSON5 = require('json5');
+var yaml = require('js-yaml');
+var TOML = require('smol-toml');
+var fastJsonPatch = require('fast-json-patch');
+var Papa = require('papaparse');
+var pdfLib = require('pdf-lib');
+var fastXmlParser = require('fast-xml-parser');
+var ExcelJS = require('exceljs');
+var sharp2 = require('sharp');
+var marked = require('marked');
+var TurndownService = require('turndown');
+var archiver = require('archiver');
+var stream = require('stream');
+var AdmZip = require('adm-zip');
+var diff$1 = require('diff');
+var sqlFormatter = require('sql-formatter');
+var nodeSqlParser = require('node-sql-parser');
+var crypto = require('crypto');
+var luxon = require('luxon');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
+var jmespath__default = /*#__PURE__*/_interopDefault(jmespath);
+var JSON5__default = /*#__PURE__*/_interopDefault(JSON5);
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+var TOML__namespace = /*#__PURE__*/_interopNamespace(TOML);
+var Papa__default = /*#__PURE__*/_interopDefault(Papa);
+var ExcelJS__default = /*#__PURE__*/_interopDefault(ExcelJS);
+var sharp2__default = /*#__PURE__*/_interopDefault(sharp2);
+var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
+var archiver__default = /*#__PURE__*/_interopDefault(archiver);
+var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/json/index.ts
+var json_exports = {};
+__export(json_exports, {
+  applyPatch: () => applyPatch,
+  convert: () => convert,
+  detectFormat: () => detectFormat,
+  diff: () => diff,
+  diffValues: () => diffValues,
+  format: () => format,
+  fromJson: () => fromJson,
+  getSizeInfo: () => getSizeInfo,
+  getStats: () => getStats,
+  isValidJson: () => isValidJson,
+  minify: () => minify,
+  parse: () => parse,
+  query: () => query,
+  queryMultiple: () => queryMultiple,
+  queryValue: () => queryValue,
+  stringify: () => stringify,
+  toJson: () => toJson,
+  validate: () => validate,
+  validateWithSummary: () => validateWithSummary
+});
+
+// src/json/format.ts
+function getIndentString(indent) {
+  if (indent === "tab") return "	";
+  return indent;
+}
+function sortObjectKeys(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeys);
+  }
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = sortObjectKeys(obj[key]);
+  }
+  return sorted;
+}
+function format(input, options = {}) {
+  const { indent = 2, sortKeys = false } = options;
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error.message}`);
+  }
+  if (sortKeys) {
+    parsed = sortObjectKeys(parsed);
+  }
+  const indentValue = getIndentString(indent);
+  return JSON.stringify(parsed, null, indentValue);
+}
+function minify(input) {
+  const parsed = JSON.parse(input);
+  return JSON.stringify(parsed);
+}
+function parse(input) {
+  return JSON.parse(input);
+}
+function stringify(value, options = {}) {
+  const { indent = 2, sortKeys = false } = options;
+  let data = value;
+  if (sortKeys) {
+    data = sortObjectKeys(value);
+  }
+  const indentValue = getIndentString(indent);
+  return JSON.stringify(data, null, indentValue);
+}
+var ajv = new Ajv__default.default({ allErrors: true, verbose: true });
+addFormats__default.default(ajv);
+function validate(input, schema) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: `Invalid JSON: ${error.message}`,
+          keyword: "parse"
+        }
+      ]
+    };
+  }
+  if (!schema) {
+    return { valid: true };
+  }
+  let schemaObj;
+  try {
+    schemaObj = JSON.parse(schema);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: `Invalid schema: ${error.message}`,
+          keyword: "schema"
+        }
+      ]
+    };
+  }
+  const validateFn = ajv.compile(schemaObj);
+  const valid = validateFn(parsed);
+  if (valid) {
+    return { valid: true };
+  }
+  const errors = (validateFn.errors || []).map((err) => ({
+    path: err.instancePath || "/",
+    message: err.message || "Unknown validation error",
+    keyword: err.keyword
+  }));
+  return { valid: false, errors };
+}
+function isValidJson(input) {
+  try {
+    JSON.parse(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ajv2 = new Ajv__default.default({ allErrors: true, verbose: true });
+addFormats__default.default(ajv2);
+function countSchemaProperties(schema) {
+  const props = schema.properties;
+  const totalProperties = props ? Object.keys(props).length : 0;
+  const requiredFields = schema.required || [];
+  return { totalProperties, requiredFields };
+}
+function buildSuggestion(err) {
+  const path = err.instancePath || "/";
+  switch (err.keyword) {
+    case "type":
+      return `Change value at '${path}' from ${typeof err.data} to ${err.schema}`;
+    case "required":
+      return `Add missing required field '${err.params?.missingProperty}'`;
+    case "enum":
+      return `Change value at '${path}' to one of: ${err.schema?.join(", ")}`;
+    case "minimum":
+      return `Adjust value at '${path}' to be >= ${err.schema}`;
+    case "maximum":
+      return `Adjust value at '${path}' to be <= ${err.schema}`;
+    case "pattern":
+      return `Change value at '${path}' to match pattern: ${err.schema}`;
+    case "additionalProperties":
+      return `Remove unexpected property '${err.params?.additionalProperty}'`;
+    case "minLength":
+      return `Value at '${path}' must have at least ${err.schema} character(s)`;
+    case "maxLength":
+      return `Value at '${path}' must have at most ${err.schema} character(s)`;
+    case "minItems":
+      return `Array at '${path}' must have at least ${err.schema} item(s)`;
+    case "maxItems":
+      return `Array at '${path}' must have at most ${err.schema} item(s)`;
+    case "format":
+      return `Value at '${path}' must be a valid ${err.params?.format ?? err.schema}`;
+    default:
+      return `Fix value at '${path}': ${err.keyword}`;
+  }
+}
+function validateWithSummary(input, schema) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    return {
+      valid: false,
+      summary: `Invalid JSON input: ${error.message}`,
+      errorCount: 1,
+      errors: [{
+        path: "",
+        message: `Invalid JSON: ${error.message}`,
+        keyword: "parse",
+        suggestion: "Fix JSON syntax errors before validating against a schema"
+      }],
+      coverage: { totalProperties: 0, validProperties: 0, missingRequired: [], extraProperties: [] },
+      suggestions: ["Fix JSON syntax errors before validating against a schema"]
+    };
+  }
+  let schemaObj;
+  try {
+    schemaObj = JSON.parse(schema);
+  } catch (error) {
+    return {
+      valid: false,
+      summary: `Invalid JSON Schema: ${error.message}`,
+      errorCount: 1,
+      errors: [{
+        path: "",
+        message: `Invalid schema: ${error.message}`,
+        keyword: "schema",
+        suggestion: "Fix the JSON Schema syntax before validating"
+      }],
+      coverage: { totalProperties: 0, validProperties: 0, missingRequired: [], extraProperties: [] },
+      suggestions: ["Fix the JSON Schema syntax before validating"]
+    };
+  }
+  const { totalProperties } = countSchemaProperties(schemaObj);
+  const validateFn = ajv2.compile(schemaObj);
+  const valid = validateFn(parsed);
+  if (valid) {
+    return {
+      valid: true,
+      summary: `Validation passed. All ${totalProperties} schema properties satisfied (100%).`,
+      errorCount: 0,
+      errors: [],
+      coverage: {
+        totalProperties,
+        validProperties: totalProperties,
+        missingRequired: [],
+        extraProperties: []
+      },
+      suggestions: []
+    };
+  }
+  const ajvErrors = validateFn.errors || [];
+  const missingRequired = [];
+  const extraProperties = [];
+  const errors = ajvErrors.map((err) => {
+    if (err.keyword === "required") {
+      const field = err.params?.missingProperty;
+      if (field) missingRequired.push(field);
+    }
+    if (err.keyword === "additionalProperties") {
+      const prop = err.params?.additionalProperty;
+      if (prop) extraProperties.push(prop);
+    }
+    return {
+      path: err.instancePath || "/",
+      message: err.message || "Unknown validation error",
+      keyword: err.keyword,
+      expected: err.schema,
+      received: err.data,
+      suggestion: buildSuggestion({
+        keyword: err.keyword,
+        instancePath: err.instancePath,
+        params: err.params,
+        schema: err.schema,
+        data: err.data
+      })
+    };
+  });
+  const propertyErrorCount = new Set(
+    ajvErrors.filter((e) => e.keyword !== "required" && e.keyword !== "additionalProperties").map((e) => e.instancePath)
+  ).size;
+  const validProperties = Math.max(0, totalProperties - missingRequired.length - propertyErrorCount);
+  const coverage = {
+    totalProperties,
+    validProperties,
+    missingRequired,
+    extraProperties
+  };
+  const pct = totalProperties > 0 ? Math.round(validProperties / totalProperties * 100) : 0;
+  const parts = [
+    `Validation failed with ${errors.length} error(s).`
+  ];
+  if (totalProperties > 0) {
+    parts.push(`${validProperties} of ${totalProperties} schema properties satisfied (${pct}%).`);
+  }
+  if (missingRequired.length > 0) {
+    parts.push(`Missing required: ${missingRequired.join(", ")}.`);
+  }
+  if (extraProperties.length > 0) {
+    parts.push(`Unexpected properties: ${extraProperties.join(", ")}.`);
+  }
+  const suggestions = [...new Set(errors.map((e) => e.suggestion))];
+  return {
+    valid: false,
+    summary: parts.join(" "),
+    errorCount: errors.length,
+    errors,
+    coverage,
+    suggestions
+  };
+}
+function query(input, path, options = {}) {
+  const { dialect = "jsonpath" } = options;
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error.message}`);
+  }
+  return queryValue(parsed, path, dialect);
+}
+function queryValue(data, path, dialect = "jsonpath") {
+  if (dialect === "jsonpath") {
+    return jsonpathPlus.JSONPath({ path, json: data, wrap: false });
+  }
+  if (dialect === "jmespath") {
+    return jmespath__default.default.search(data, path);
+  }
+  throw new Error(`Unknown query dialect: ${dialect}`);
+}
+function queryMultiple(input, paths, dialect = "jsonpath") {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error.message}`);
+  }
+  const results = {};
+  for (const path of paths) {
+    results[path] = queryValue(parsed, path, dialect);
+  }
+  return results;
+}
+function getIndent(indent = 2) {
+  if (indent === "tab") return 2;
+  return indent;
+}
+function parseInput(input, from) {
+  switch (from) {
+    case "json":
+      return JSON.parse(input);
+    case "json5":
+    case "jsonc":
+      return JSON5__default.default.parse(input);
+    case "yaml":
+      return yaml__default.default.load(input);
+    case "toml":
+      return TOML__namespace.parse(input);
+    default:
+      throw new Error(`Unsupported input format: ${from}`);
+  }
+}
+function stringifyOutput(data, to, indent = 2) {
+  const indentNum = getIndent(indent);
+  switch (to) {
+    case "json":
+      return JSON.stringify(data, null, indentNum);
+    case "json5":
+    case "jsonc":
+      return JSON5__default.default.stringify(data, null, indentNum);
+    case "yaml":
+      return yaml__default.default.dump(data, { indent: indentNum, lineWidth: -1 });
+    case "toml":
+      if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new Error("TOML requires a root object");
+      }
+      return TOML__namespace.stringify(data);
+    default:
+      throw new Error(`Unsupported output format: ${to}`);
+  }
+}
+function convert(input, options) {
+  const { from, to, indent = 2 } = options;
+  if (from === to) {
+    const parsed2 = parseInput(input, from);
+    return stringifyOutput(parsed2, to, indent);
+  }
+  const parsed = parseInput(input, from);
+  return stringifyOutput(parsed, to, indent);
+}
+function toJson(input, from) {
+  return convert(input, { from, to: "json" });
+}
+function fromJson(input, to) {
+  return convert(input, { from: "json", to });
+}
+function detectFormat(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      JSON.parse(trimmed);
+      return "json";
+    } catch {
+      try {
+        JSON5__default.default.parse(trimmed);
+        return "json5";
+      } catch {
+        return null;
+      }
+    }
+  }
+  if (trimmed.includes(":") && !trimmed.includes("=")) {
+    try {
+      yaml__default.default.load(trimmed);
+      return "yaml";
+    } catch {
+      return null;
+    }
+  }
+  if (trimmed.includes("=") && (trimmed.includes("[") || trimmed.includes('"'))) {
+    try {
+      TOML__namespace.parse(trimmed);
+      return "toml";
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function diff(a, b) {
+  let parsedA;
+  let parsedB;
+  try {
+    parsedA = JSON.parse(a);
+  } catch (error) {
+    throw new Error(`Invalid JSON (first argument): ${error.message}`);
+  }
+  try {
+    parsedB = JSON.parse(b);
+  } catch (error) {
+    throw new Error(`Invalid JSON (second argument): ${error.message}`);
+  }
+  return diffValues(parsedA, parsedB);
+}
+function diffValues(a, b) {
+  const operations = fastJsonPatch.compare(
+    a,
+    b
+  );
+  const summary = {
+    added: 0,
+    removed: 0,
+    changed: 0
+  };
+  for (const op of operations) {
+    switch (op.op) {
+      case "add":
+        summary.added++;
+        break;
+      case "remove":
+        summary.removed++;
+        break;
+      case "replace":
+        summary.changed++;
+        break;
+    }
+  }
+  return {
+    identical: operations.length === 0,
+    operations,
+    summary
+  };
+}
+function applyPatch(input, operations) {
+  const parsed = JSON.parse(input);
+  for (const op of operations) {
+    applyOperation(parsed, op);
+  }
+  return JSON.stringify(parsed, null, 2);
+}
+function applyOperation(obj, operation) {
+  const pathParts = operation.path.split("/").filter(Boolean);
+  if (pathParts.length === 0) {
+    throw new Error("Cannot apply operation to root");
+  }
+  const parent = getParent(obj, pathParts);
+  const key = pathParts[pathParts.length - 1];
+  switch (operation.op) {
+    case "add":
+    case "replace":
+      if (Array.isArray(parent)) {
+        const index = parseInt(key, 10);
+        if (operation.op === "add") {
+          parent.splice(index, 0, operation.value);
+        } else {
+          parent[index] = operation.value;
+        }
+      } else if (typeof parent === "object" && parent !== null) {
+        parent[key] = operation.value;
+      }
+      break;
+    case "remove":
+      if (Array.isArray(parent)) {
+        parent.splice(parseInt(key, 10), 1);
+      } else if (typeof parent === "object" && parent !== null) {
+        delete parent[key];
+      }
+      break;
+  }
+}
+function getParent(obj, pathParts) {
+  let current = obj;
+  for (let i = 0; i < pathParts.length - 1; i++) {
+    const part = pathParts[i];
+    if (Array.isArray(current)) {
+      current = current[parseInt(part, 10)];
+    } else if (typeof current === "object" && current !== null) {
+      current = current[part];
+    }
+  }
+  return current;
+}
+
+// src/json/stats.ts
+function getStats(input) {
+  const parsed = JSON.parse(input);
+  const stats = {
+    keys: 0,
+    depth: 0,
+    arrays: 0,
+    objects: 0,
+    strings: 0,
+    numbers: 0,
+    booleans: 0,
+    nulls: 0,
+    sizeBytes: new TextEncoder().encode(input).length
+  };
+  analyzeValue(parsed, stats, 0);
+  return stats;
+}
+function analyzeValue(value, stats, depth) {
+  stats.depth = Math.max(stats.depth, depth);
+  if (value === null) {
+    stats.nulls++;
+    return;
+  }
+  switch (typeof value) {
+    case "string":
+      stats.strings++;
+      break;
+    case "number":
+      stats.numbers++;
+      break;
+    case "boolean":
+      stats.booleans++;
+      break;
+    case "object":
+      if (Array.isArray(value)) {
+        stats.arrays++;
+        for (const item of value) {
+          analyzeValue(item, stats, depth + 1);
+        }
+      } else {
+        stats.objects++;
+        const keys = Object.keys(value);
+        stats.keys += keys.length;
+        for (const key of keys) {
+          analyzeValue(value[key], stats, depth + 1);
+        }
+      }
+      break;
+  }
+}
+function getSizeInfo(input) {
+  const bytes = new TextEncoder().encode(input).length;
+  const minified = JSON.stringify(JSON.parse(input));
+  const minifiedBytes = new TextEncoder().encode(minified).length;
+  return {
+    bytes,
+    formatted: formatBytes(bytes),
+    minifiedBytes,
+    savings: bytes - minifiedBytes
+  };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/csv/index.ts
+var csv_exports = {};
+__export(csv_exports, {
+  detectDelimiter: () => detectDelimiter,
+  exportData: () => exportData,
+  exportFromData: () => exportFromData,
+  filter: () => filter,
+  filterByColumn: () => filterByColumn,
+  filterData: () => filterData,
+  getColumnStats: () => getColumnStats,
+  getHeaders: () => getHeaders,
+  getStats: () => getStats2,
+  getStatsFromData: () => getStatsFromData,
+  parse: () => parse3,
+  parseToArray: () => parseToArray,
+  sortData: () => sortData,
+  toArray: () => toArray,
+  toJson: () => toJson2,
+  toJsonLines: () => toJsonLines,
+  transform: () => transform,
+  transformData: () => transformData
+});
+function parse3(input, options = {}) {
+  const {
+    delimiter = ",",
+    header = true,
+    skipRows = 0,
+    trimFields = true,
+    dynamicTyping = true
+  } = options;
+  let processedInput = input;
+  if (skipRows > 0) {
+    const lines = input.split("\n");
+    processedInput = lines.slice(skipRows).join("\n");
+  }
+  const result = Papa__default.default.parse(processedInput, {
+    delimiter,
+    header,
+    skipEmptyLines: true,
+    transformHeader: trimFields ? (h) => h.trim() : void 0,
+    transform: trimFields ? (v) => v.trim() : void 0,
+    dynamicTyping
+  });
+  const errors = result.errors.map((e) => ({
+    row: e.row ?? -1,
+    message: e.message
+  }));
+  const headers = header ? result.meta.fields || [] : Array.from({ length: result.data[0]?.length || 0 }, (_, i) => `col_${i}`);
+  const data = header ? result.data : result.data.map((row) => {
+    const obj = {};
+    headers.forEach((h, i) => {
+      obj[h] = row[i];
+    });
+    return obj;
+  });
+  return {
+    data,
+    headers,
+    rowCount: data.length,
+    errors
+  };
+}
+function parseToArray(input, options = {}) {
+  const result = parse3(input, { ...options, header: false });
+  return result.data.map((row) => Object.values(row));
+}
+function detectDelimiter(input) {
+  const delimiters = [",", "	", ";", "|"];
+  const firstLine = input.split("\n")[0];
+  let maxCount = 0;
+  let detected = ",";
+  for (const d of delimiters) {
+    const count = (firstLine.match(new RegExp(`\\${d}`, "g")) || []).length;
+    if (count > maxCount) {
+      maxCount = count;
+      detected = d;
+    }
+  }
+  return detected;
+}
+function getHeaders(input, delimiter) {
+  const d = delimiter || detectDelimiter(input);
+  const firstLine = input.split("\n")[0];
+  return Papa__default.default.parse(firstLine, { delimiter: d }).data[0];
+}
+
+// src/csv/filter.ts
+function filter(input, filters) {
+  const result = parse3(input);
+  const filteredData = filterData(result.data, filters);
+  return toCSV(filteredData, result.headers);
+}
+function filterData(data, filters) {
+  return data.filter((row) => {
+    return filters.every((f) => matchesFilter(row, f));
+  });
+}
+function matchesFilter(row, filter2) {
+  const value = row[filter2.column];
+  const filterValue = filter2.value;
+  switch (filter2.operator) {
+    case "eq":
+      return value === filterValue;
+    case "neq":
+      return value !== filterValue;
+    case "gt":
+      return Number(value) > Number(filterValue);
+    case "gte":
+      return Number(value) >= Number(filterValue);
+    case "lt":
+      return Number(value) < Number(filterValue);
+    case "lte":
+      return Number(value) <= Number(filterValue);
+    case "contains":
+      return String(value).toLowerCase().includes(String(filterValue).toLowerCase());
+    case "startsWith":
+      return String(value).toLowerCase().startsWith(String(filterValue).toLowerCase());
+    case "endsWith":
+      return String(value).toLowerCase().endsWith(String(filterValue).toLowerCase());
+    case "matches":
+      return new RegExp(String(filterValue), "i").test(String(value));
+    case "isNull":
+      return value === null || value === void 0 || value === "";
+    case "isNotNull":
+      return value !== null && value !== void 0 && value !== "";
+    default:
+      return true;
+  }
+}
+function toCSV(data, headers) {
+  const headerRow = headers.map(escapeCSVField).join(",");
+  const dataRows = data.map(
+    (row) => headers.map((h) => escapeCSVField(row[h])).join(",")
+  );
+  return [headerRow, ...dataRows].join("\n");
+}
+function escapeCSVField(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function filterByColumn(input, column, operator, value) {
+  return filter(input, [{ column, operator, value }]);
+}
+
+// src/csv/stats.ts
+function getStats2(input) {
+  const result = parse3(input);
+  return getStatsFromData(result);
+}
+function getStatsFromData(result) {
+  const { data, headers } = result;
+  return headers.map((header) => {
+    const values = data.map((row) => row[header]);
+    return analyzeColumn(header, values);
+  });
+}
+function analyzeColumn(name, values) {
+  const nonNullValues = values.filter(
+    (v) => v !== null && v !== void 0 && v !== ""
+  );
+  const nullCount = values.length - nonNullValues.length;
+  const type = detectType(nonNullValues);
+  const stats = {
+    name,
+    type,
+    count: values.length,
+    nullCount,
+    uniqueCount: new Set(nonNullValues.map(String)).size
+  };
+  if (type === "number") {
+    const numbers = nonNullValues.map(Number).filter((n) => !isNaN(n));
+    if (numbers.length > 0) {
+      stats.min = Math.min(...numbers);
+      stats.max = Math.max(...numbers);
+      stats.sum = numbers.reduce((a, b) => a + b, 0);
+      stats.mean = stats.sum / numbers.length;
+    }
+  } else if (type === "string" || type === "date") {
+    const sorted = [...nonNullValues].map(String).sort();
+    if (sorted.length > 0) {
+      stats.min = sorted[0];
+      stats.max = sorted[sorted.length - 1];
+    }
+  }
+  stats.topValues = getTopValues(nonNullValues, 5);
+  return stats;
+}
+function detectType(values) {
+  if (values.length === 0) return "empty";
+  const types = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value === "number" || !isNaN(Number(value))) {
+      types.add("number");
+    } else if (typeof value === "boolean" || value === "true" || value === "false") {
+      types.add("boolean");
+    } else if (isDateLike(String(value))) {
+      types.add("date");
+    } else {
+      types.add("string");
+    }
+  }
+  if (types.size === 1) {
+    return types.values().next().value;
+  }
+  if (types.size === 2 && types.has("number") && types.has("string")) {
+    const numberRatio = values.filter((v) => !isNaN(Number(v))).length / values.length;
+    if (numberRatio > 0.9) return "number";
+  }
+  return "mixed";
+}
+function isDateLike(value) {
+  const datePatterns = [
+    /^\d{4}-\d{2}-\d{2}$/,
+    /^\d{2}\/\d{2}\/\d{4}$/,
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+  ];
+  return datePatterns.some((p) => p.test(value));
+}
+function getTopValues(values, limit) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = String(value);
+    const existing = counts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(key, { value, count: 1 });
+    }
+  }
+  return [...counts.values()].sort((a, b) => b.count - a.count).slice(0, limit);
+}
+function getColumnStats(input, column) {
+  const stats = getStats2(input);
+  return stats.find((s) => s.name === column) || null;
+}
+
+// src/csv/transform.ts
+function transform(input, options) {
+  const result = parse3(input);
+  const transformed = transformData(result, options);
+  return toCSV2(transformed.data, transformed.headers);
+}
+function transformData(result, options) {
+  let { data, headers } = result;
+  if (options.select) {
+    headers = options.select.filter((h) => headers.includes(h));
+  }
+  if (options.exclude) {
+    headers = headers.filter((h) => !options.exclude.includes(h));
+  }
+  if (options.rename) {
+    headers = headers.map((h) => options.rename[h] || h);
+  }
+  data = data.map((row) => {
+    const newRow = {};
+    for (const header of result.headers) {
+      if (options.select && !options.select.includes(header)) continue;
+      if (options.exclude && options.exclude.includes(header)) continue;
+      const newKey = options.rename?.[header] || header;
+      newRow[newKey] = row[header];
+    }
+    if (options.derive) {
+      for (const [key, fn] of Object.entries(options.derive)) {
+        newRow[key] = fn(row);
+      }
+    }
+    return newRow;
+  });
+  if (options.derive) {
+    headers = [...headers, ...Object.keys(options.derive)];
+  }
+  return { data, headers, rowCount: data.length, errors: [] };
+}
+function toCSV2(data, headers) {
+  const headerRow = headers.map(escapeCSVField2).join(",");
+  const dataRows = data.map(
+    (row) => headers.map((h) => escapeCSVField2(row[h])).join(",")
+  );
+  return [headerRow, ...dataRows].join("\n");
+}
+function escapeCSVField2(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function sortData(data, column, direction = "asc") {
+  return [...data].sort((a, b) => {
+    const aVal = a[column];
+    const bVal = b[column];
+    if (aVal === bVal) return 0;
+    if (aVal === null || aVal === void 0) return 1;
+    if (bVal === null || bVal === void 0) return -1;
+    const comparison = typeof aVal === "number" && typeof bVal === "number" ? aVal - bVal : String(aVal).localeCompare(String(bVal));
+    return direction === "asc" ? comparison : -comparison;
+  });
+}
+
+// src/csv/export.ts
+function exportData(input, options) {
+  const result = parse3(input);
+  return exportFromData(result, options);
+}
+function exportFromData(result, options) {
+  const { format: format4, headers = true, delimiter } = options;
+  switch (format4) {
+    case "csv":
+      return toCSV3(result.data, result.headers, delimiter || ",", headers);
+    case "tsv":
+      return toCSV3(result.data, result.headers, "	", headers);
+    case "json":
+      return JSON.stringify(result.data, null, 2);
+    case "jsonl":
+      return result.data.map((row) => JSON.stringify(row)).join("\n");
+    default:
+      throw new Error(`Unsupported export format: ${format4}`);
+  }
+}
+function toCSV3(data, headers, delimiter, includeHeaders) {
+  const lines = [];
+  if (includeHeaders) {
+    lines.push(headers.map((h) => escapeField(h, delimiter)).join(delimiter));
+  }
+  for (const row of data) {
+    lines.push(
+      headers.map((h) => escapeField(row[h], delimiter)).join(delimiter)
+    );
+  }
+  return lines.join("\n");
+}
+function escapeField(value, delimiter) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const str = String(value);
+  const needsQuoting = str.includes(delimiter) || str.includes('"') || str.includes("\n");
+  if (needsQuoting) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function toJson2(input, pretty = true) {
+  const result = parse3(input);
+  return pretty ? JSON.stringify(result.data, null, 2) : JSON.stringify(result.data);
+}
+function toJsonLines(input) {
+  const result = parse3(input);
+  return result.data.map((row) => JSON.stringify(row)).join("\n");
+}
+function toArray(input) {
+  const result = parse3(input);
+  return result.data;
+}
+
+// src/pdf/index.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  addWatermark: () => addWatermark,
+  appendPages: () => appendPages,
+  compress: () => compress,
+  deletePage: () => deletePage,
+  extractPages: () => extractPages,
+  extractText: () => extractText,
+  extractTextFromPages: () => extractTextFromPages,
+  formatBytes: () => formatBytes2,
+  getInfo: () => getInfo,
+  getMetadata: () => getMetadata,
+  getPageCount: () => getPageCount,
+  getPageInfo: () => getPageInfo,
+  hasText: () => hasText,
+  merge: () => merge,
+  mergeAll: () => mergeAll,
+  parsePageRanges: () => parsePageRanges,
+  parseRangesToGroups: () => parseRangesToGroups,
+  pdfToTemplate: () => pdfToTemplate,
+  reorderPages: () => reorderPages,
+  rotate: () => rotate,
+  setMetadata: () => setMetadata,
+  split: () => split,
+  splitEveryN: () => splitEveryN,
+  splitIntoSingle: () => splitIntoSingle,
+  templateToPdf: () => templateToPdf,
+  toUint8Array: () => toUint8Array,
+  validateTemplate: () => validateTemplate
+});
+
+// src/pdf/utils.ts
+function parsePageRanges(rangeStr, totalPages) {
+  const pages = /* @__PURE__ */ new Set();
+  const parts = rangeStr.split(",").map((s) => s.trim());
+  for (const part of parts) {
+    if (part.toLowerCase() === "all") {
+      for (let i = 1; i <= totalPages; i++) {
+        pages.add(i);
+      }
+      continue;
+    }
+    if (part.includes("-")) {
+      const [startStr, endStr] = part.split("-").map((s) => s.trim());
+      const start = parseInt(startStr, 10) || 1;
+      const end = parseInt(endStr, 10) || totalPages;
+      for (let i = Math.max(1, start); i <= Math.min(totalPages, end); i++) {
+        pages.add(i);
+      }
+    } else {
+      const page = parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        pages.add(page);
+      }
+    }
+  }
+  return [...pages].sort((a, b) => a - b);
+}
+function parseRangesToGroups(rangeStr, totalPages) {
+  const ranges = [];
+  const parts = rangeStr.split(",").map((s) => s.trim());
+  for (const part of parts) {
+    if (part.toLowerCase() === "all") {
+      ranges.push({ start: 1, end: totalPages });
+      continue;
+    }
+    if (part.includes("-")) {
+      const [startStr, endStr] = part.split("-").map((s) => s.trim());
+      const start = parseInt(startStr, 10) || 1;
+      const end = parseInt(endStr, 10) || totalPages;
+      ranges.push({
+        start: Math.max(1, start),
+        end: Math.min(totalPages, end)
+      });
+    } else {
+      const page = parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        ranges.push({ start: page, end: page });
+      }
+    }
+  }
+  return ranges;
+}
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (Buffer.isBuffer(data)) {
+    return new Uint8Array(data);
+  }
+  throw new Error("Invalid data type");
+}
+async function merge(files, options = {}) {
+  const { pageRanges } = options;
+  const mergedPdf = await pdfLib.PDFDocument.create();
+  for (let i = 0; i < files.length; i++) {
+    const fileData = toUint8Array(files[i]);
+    const sourcePdf = await pdfLib.PDFDocument.load(fileData);
+    const totalPages = sourcePdf.getPageCount();
+    let pagesToCopy;
+    if (pageRanges && pageRanges[i]) {
+      pagesToCopy = parsePageRanges(pageRanges[i], totalPages);
+    } else {
+      pagesToCopy = Array.from({ length: totalPages }, (_, j) => j + 1);
+    }
+    const pageIndices = pagesToCopy.map((p) => p - 1);
+    const copiedPages = await mergedPdf.copyPages(sourcePdf, pageIndices);
+    for (const page of copiedPages) {
+      mergedPdf.addPage(page);
+    }
+  }
+  return mergedPdf.save();
+}
+async function mergeAll(files) {
+  return merge(files);
+}
+async function appendPages(target, source, pageRange) {
+  const targetPdf = await pdfLib.PDFDocument.load(toUint8Array(target));
+  const sourcePdf = await pdfLib.PDFDocument.load(toUint8Array(source));
+  const totalPages = sourcePdf.getPageCount();
+  const pagesToCopy = pageRange ? parsePageRanges(pageRange, totalPages) : Array.from({ length: totalPages }, (_, i) => i + 1);
+  const pageIndices = pagesToCopy.map((p) => p - 1);
+  const copiedPages = await targetPdf.copyPages(sourcePdf, pageIndices);
+  for (const page of copiedPages) {
+    targetPdf.addPage(page);
+  }
+  return targetPdf.save();
+}
+async function split(file, options) {
+  const { ranges } = options;
+  const fileData = toUint8Array(file);
+  const sourcePdf = await pdfLib.PDFDocument.load(fileData);
+  const totalPages = sourcePdf.getPageCount();
+  const rangeGroups = parseRangesToGroups(ranges, totalPages);
+  const results = [];
+  for (const range of rangeGroups) {
+    const newPdf = await pdfLib.PDFDocument.create();
+    const pageIndices = [];
+    for (let i = range.start; i <= range.end; i++) {
+      pageIndices.push(i - 1);
+    }
+    const copiedPages = await newPdf.copyPages(sourcePdf, pageIndices);
+    for (const page of copiedPages) {
+      newPdf.addPage(page);
+    }
+    results.push(await newPdf.save());
+  }
+  return results;
+}
+async function extractPages(file, pageRange) {
+  const fileData = toUint8Array(file);
+  const sourcePdf = await pdfLib.PDFDocument.load(fileData);
+  const totalPages = sourcePdf.getPageCount();
+  const pages = parsePageRanges(pageRange, totalPages);
+  const newPdf = await pdfLib.PDFDocument.create();
+  const pageIndices = pages.map((p) => p - 1);
+  const copiedPages = await newPdf.copyPages(sourcePdf, pageIndices);
+  for (const page of copiedPages) {
+    newPdf.addPage(page);
+  }
+  return newPdf.save();
+}
+async function splitEveryN(file, n) {
+  const fileData = toUint8Array(file);
+  const sourcePdf = await pdfLib.PDFDocument.load(fileData);
+  const totalPages = sourcePdf.getPageCount();
+  const ranges = [];
+  for (let i = 1; i <= totalPages; i += n) {
+    const end = Math.min(i + n - 1, totalPages);
+    ranges.push(`${i}-${end}`);
+  }
+  return split(file, { ranges: ranges.join(",") });
+}
+async function splitIntoSingle(file) {
+  return splitEveryN(file, 1);
+}
+async function getInfo(file) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData, { ignoreEncryption: true });
+  return {
+    pageCount: pdf.getPageCount(),
+    metadata: {
+      title: pdf.getTitle(),
+      author: pdf.getAuthor(),
+      subject: pdf.getSubject(),
+      keywords: pdf.getKeywords()?.split(",").map((k) => k.trim()),
+      creator: pdf.getCreator(),
+      producer: pdf.getProducer(),
+      creationDate: pdf.getCreationDate(),
+      modificationDate: pdf.getModificationDate()
+    },
+    encrypted: false,
+    version: "PDF-1.7"
+  };
+}
+async function getMetadata(file) {
+  const info = await getInfo(file);
+  return info.metadata;
+}
+async function setMetadata(file, metadata) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  if (metadata.title !== void 0) pdf.setTitle(metadata.title);
+  if (metadata.author !== void 0) pdf.setAuthor(metadata.author);
+  if (metadata.subject !== void 0) pdf.setSubject(metadata.subject);
+  if (metadata.keywords !== void 0) pdf.setKeywords(metadata.keywords);
+  if (metadata.creator !== void 0) pdf.setCreator(metadata.creator);
+  if (metadata.producer !== void 0) pdf.setProducer(metadata.producer);
+  return pdf.save();
+}
+async function getPageInfo(file) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  const pages = pdf.getPages();
+  return pages.map((page, index) => ({
+    index,
+    width: page.getWidth(),
+    height: page.getHeight(),
+    rotation: page.getRotation().angle
+  }));
+}
+async function getPageCount(file) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  return pdf.getPageCount();
+}
+async function rotate(file, options) {
+  const { pages: pageRange, degrees: deg } = options;
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  const allPages = pdf.getPages();
+  const pagesToRotate = pageRange ? parsePageRanges(pageRange.join(","), allPages.length) : Array.from({ length: allPages.length }, (_, i) => i + 1);
+  for (const pageNum of pagesToRotate) {
+    const page = allPages[pageNum - 1];
+    if (page) {
+      const currentRotation = page.getRotation().angle;
+      page.setRotation(pdfLib.degrees(currentRotation + deg));
+    }
+  }
+  return pdf.save();
+}
+async function addWatermark(file, options) {
+  const {
+    text = "WATERMARK",
+    opacity = 0.3,
+    rotation = -45,
+    position = "center",
+    fontSize = 50,
+    color = { r: 0.5, g: 0.5, b: 0.5 }
+  } = options;
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  const font = await pdf.embedFont(pdfLib.StandardFonts.Helvetica);
+  const pages = pdf.getPages();
+  for (const page of pages) {
+    const { width, height } = page.getSize();
+    const textWidth = font.widthOfTextAtSize(text, fontSize);
+    const x = (width - textWidth) / 2;
+    let y = height / 2;
+    if (position === "top") {
+      y = height - fontSize - 20;
+    } else if (position === "bottom") {
+      y = 20;
+    }
+    page.drawText(text, {
+      x,
+      y,
+      size: fontSize,
+      font,
+      color: pdfLib.rgb(color.r, color.g, color.b),
+      opacity,
+      rotate: pdfLib.degrees(rotation)
+    });
+  }
+  return pdf.save();
+}
+async function reorderPages(file, newOrder) {
+  const fileData = toUint8Array(file);
+  const sourcePdf = await pdfLib.PDFDocument.load(fileData);
+  const newPdf = await pdfLib.PDFDocument.create();
+  const pageIndices = newOrder.map((p) => p - 1);
+  const copiedPages = await newPdf.copyPages(sourcePdf, pageIndices);
+  for (const page of copiedPages) {
+    newPdf.addPage(page);
+  }
+  return newPdf.save();
+}
+async function deletePage(file, pageNumbers) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  const totalPages = pdf.getPageCount();
+  const sortedPageNumbers = [...pageNumbers].sort((a, b) => b - a);
+  for (const pageNum of sortedPageNumbers) {
+    if (pageNum >= 1 && pageNum <= totalPages) {
+      pdf.removePage(pageNum - 1);
+    }
+  }
+  return pdf.save();
+}
+async function compress(file, _options = { quality: "medium" }) {
+  const fileData = toUint8Array(file);
+  const pdf = await pdfLib.PDFDocument.load(fileData);
+  return pdf.save({
+    useObjectStreams: true,
+    addDefaultPage: false
+  });
+}
+
+// src/pdf/extract.ts
+async function extractText(file, options = {}) {
+  const { pages: pageNums } = options;
+  const fileData = toUint8Array(file);
+  try {
+    const pdfParse = await import('pdf-parse');
+    const parser = pdfParse.default || pdfParse;
+    if (pageNums && pageNums.length > 0) {
+      const result2 = await parser(Buffer.from(fileData), {
+        max: Math.max(...pageNums)
+      });
+      return result2.text;
+    }
+    const result = await parser(Buffer.from(fileData));
+    return result.text;
+  } catch (error) {
+    throw new Error(`Failed to extract text: ${error.message}`);
+  }
+}
+async function extractTextFromPages(file, pageRange) {
+  const fileData = toUint8Array(file);
+  try {
+    const pdfParse = await import('pdf-parse');
+    const parser = pdfParse.default || pdfParse;
+    const result = await parser(Buffer.from(fileData));
+    const totalPages = result.numpages;
+    const pages = parsePageRanges(pageRange, totalPages);
+    const pageTexts = {};
+    const fullText = result.text;
+    const textPerPage = fullText.length / totalPages;
+    for (const pageNum of pages) {
+      const start = (pageNum - 1) * textPerPage;
+      const end = pageNum * textPerPage;
+      pageTexts[pageNum] = fullText.slice(start, end).trim();
+    }
+    return pageTexts;
+  } catch (error) {
+    throw new Error(`Failed to extract text: ${error.message}`);
+  }
+}
+async function hasText(file) {
+  try {
+    const text = await extractText(file);
+    return text.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+var PLACEHOLDER_REGEX = /\{\{(\w+)\}\}/g;
+function extractFieldName(content) {
+  const match = content.match(/^\{\{(\w+)\}\}$/);
+  return match ? match[1] : void 0;
+}
+function resolveContent(content, data, missingFieldBehavior, fields) {
+  return content.replace(PLACEHOLDER_REGEX, (match, fieldName) => {
+    if (fieldName in data) {
+      return data[fieldName];
+    }
+    switch (missingFieldBehavior) {
+      case "use_default": {
+        const field = fields.find((f) => f.name === fieldName);
+        return field?.defaultValue ?? "";
+      }
+      case "empty_string":
+        return "";
+      case "leave_placeholder":
+      default:
+        return match;
+    }
+  });
+}
+function resolveFont(font, defaults) {
+  return font ?? defaults?.font ?? { name: "Helvetica", size: 12 };
+}
+async function pdfToTemplate(file, options = {}) {
+  const fileData = toUint8Array(file);
+  const pdfDoc = await pdfLib.PDFDocument.load(fileData, { ignoreEncryption: true });
+  const pageCount = pdfDoc.getPageCount();
+  const pdfPages = pdfDoc.getPages();
+  let fullText = "";
+  try {
+    const pdfParse = await import('pdf-parse');
+    const parser = pdfParse.default || pdfParse;
+    const parsed = await parser(Buffer.from(fileData));
+    fullText = parsed.text;
+  } catch {
+    fullText = "";
+  }
+  const textPerPage = pageCount > 0 ? fullText.length / pageCount : 0;
+  const fieldsMap = /* @__PURE__ */ new Map();
+  const fonts = {};
+  const defaultFont = { name: "Helvetica", size: 12 };
+  fonts["Helvetica-12"] = defaultFont;
+  const pages = pdfPages.map((page, pageIndex) => {
+    const { width, height } = page.getSize();
+    const start = Math.floor(pageIndex * textPerPage);
+    const end = Math.floor((pageIndex + 1) * textPerPage);
+    const pageText = fullText.slice(start, end).trim();
+    const elements = [];
+    if (pageText) {
+      const lines = pageText.split("\n").filter((l) => l.trim());
+      const lineHeight = 14;
+      let yPos = height - 40;
+      for (const line of lines) {
+        const hasPlaceholder = PLACEHOLDER_REGEX.test(line);
+        PLACEHOLDER_REGEX.lastIndex = 0;
+        const element = {
+          type: hasPlaceholder ? "placeholder" : "text",
+          content: line.trim(),
+          x: 40,
+          y: yPos,
+          font: defaultFont
+        };
+        if (hasPlaceholder) {
+          const fieldName = extractFieldName(line.trim());
+          if (fieldName) {
+            element.fieldName = fieldName;
+          }
+          let match;
+          PLACEHOLDER_REGEX.lastIndex = 0;
+          while ((match = PLACEHOLDER_REGEX.exec(line)) !== null) {
+            const name = match[1];
+            if (!fieldsMap.has(name)) {
+              fieldsMap.set(name, { pages: /* @__PURE__ */ new Set(), defaultValue: "" });
+            }
+            fieldsMap.get(name).pages.add(pageIndex + 1);
+          }
+        }
+        elements.push(element);
+        yPos -= lineHeight;
+      }
+    }
+    return { width, height, elements };
+  });
+  const fields = [];
+  for (const [name, info] of fieldsMap) {
+    fields.push({
+      name,
+      defaultValue: info.defaultValue,
+      pages: [...info.pages].sort((a, b) => a - b)
+    });
+  }
+  return {
+    version: "1.0",
+    metadata: {
+      name: options.name,
+      description: options.description,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourcePageCount: pageCount
+    },
+    pages,
+    fields,
+    fonts,
+    defaults: {
+      font: defaultFont,
+      color: { r: 0, g: 0, b: 0 },
+      missingFieldBehavior: "leave_placeholder"
+    }
+  };
+}
+async function templateToPdf(template, data = {}, options = {}) {
+  validateTemplate(template);
+  const pdfDoc = await pdfLib.PDFDocument.create();
+  const font = await pdfDoc.embedFont(pdfLib.StandardFonts.Helvetica);
+  const boldFont = await pdfDoc.embedFont(pdfLib.StandardFonts.HelveticaBold);
+  const missingFieldBehavior = options.missingFieldBehavior ?? template.defaults?.missingFieldBehavior ?? "leave_placeholder";
+  const defaultColor = template.defaults?.color ?? { r: 0, g: 0, b: 0 };
+  for (const templatePage of template.pages) {
+    const page = pdfDoc.addPage([templatePage.width, templatePage.height]);
+    for (const element of templatePage.elements) {
+      const resolvedFont = resolveFont(element.font, template.defaults);
+      const color = element.color ?? defaultColor;
+      const pdfFont = resolvedFont.weight === "bold" ? boldFont : font;
+      const fontSize = resolvedFont.size;
+      const content = element.type === "placeholder" ? resolveContent(element.content, data, missingFieldBehavior, template.fields) : element.content;
+      page.drawText(content, {
+        x: element.x,
+        y: element.y,
+        size: fontSize,
+        font: pdfFont,
+        color: pdfLib.rgb(color.r, color.g, color.b)
+      });
+    }
+  }
+  return pdfDoc.save();
+}
+function validateTemplate(template) {
+  if (!template) {
+    throw new Error("Template is required");
+  }
+  if (template.version !== "1.0") {
+    throw new Error(`Unsupported template version: ${template.version}`);
+  }
+  if (!Array.isArray(template.pages) || template.pages.length === 0) {
+    throw new Error("Template must have at least one page");
+  }
+  if (!template.metadata) {
+    throw new Error("Template metadata is required");
+  }
+  if (typeof template.metadata.sourcePageCount !== "number" || template.metadata.sourcePageCount < 1) {
+    throw new Error("Template metadata.sourcePageCount must be a positive number");
+  }
+  if (!Array.isArray(template.fields)) {
+    throw new Error("Template fields must be an array");
+  }
+  for (const page of template.pages) {
+    if (typeof page.width !== "number" || typeof page.height !== "number") {
+      throw new Error("Each page must have numeric width and height");
+    }
+    if (!Array.isArray(page.elements)) {
+      throw new Error("Each page must have an elements array");
+    }
+    for (const element of page.elements) {
+      if (element.type !== "text" && element.type !== "placeholder") {
+        throw new Error(`Invalid element type: ${element.type}`);
+      }
+      if (typeof element.content !== "string") {
+        throw new Error("Element content must be a string");
+      }
+      if (typeof element.x !== "number" || typeof element.y !== "number") {
+        throw new Error("Element x and y must be numbers");
+      }
+    }
+  }
+}
+
+// src/xml/index.ts
+var xml_exports = {};
+__export(xml_exports, {
+  convert: () => convert2,
+  format: () => format2,
+  getStats: () => getStats3,
+  minify: () => minify2,
+  parse: () => parse4,
+  query: () => query2,
+  validate: () => validate2
+});
+function parse4(input, options = {}) {
+  const parser = new fastXmlParser.XMLParser({
+    preserveOrder: options.preserveOrder ?? false,
+    ignoreAttributes: options.ignoreAttributes ?? false,
+    trimValues: options.trimValues ?? true,
+    parseAttributeValue: true,
+    parseTagValue: true
+  });
+  return parser.parse(input);
+}
+function format2(input, options = {}) {
+  const indent = options.indent ?? 2;
+  const parser = new fastXmlParser.XMLParser({
+    preserveOrder: true,
+    ignoreAttributes: false,
+    trimValues: true,
+    parseAttributeValue: true,
+    parseTagValue: true
+  });
+  const parsed = parser.parse(input);
+  const builder = new fastXmlParser.XMLBuilder({
+    preserveOrder: true,
+    ignoreAttributes: false,
+    format: true,
+    indentBy: " ".repeat(indent),
+    suppressEmptyNode: false
+  });
+  return builder.build(parsed);
+}
+function minify2(input) {
+  const parser = new fastXmlParser.XMLParser({
+    preserveOrder: true,
+    ignoreAttributes: false,
+    trimValues: true,
+    parseAttributeValue: true,
+    parseTagValue: true
+  });
+  const parsed = parser.parse(input);
+  const builder = new fastXmlParser.XMLBuilder({
+    preserveOrder: true,
+    ignoreAttributes: false,
+    format: false,
+    suppressEmptyNode: false
+  });
+  return builder.build(parsed);
+}
+function validate2(input) {
+  const result = fastXmlParser.XMLValidator.validate(input, {
+    allowBooleanAttributes: true
+  });
+  if (result === true) {
+    return { valid: true, errors: [] };
+  }
+  return {
+    valid: false,
+    errors: [
+      {
+        line: result.err.line,
+        message: result.err.msg
+      }
+    ]
+  };
+}
+function query2(input, path) {
+  const parser = new fastXmlParser.XMLParser({
+    ignoreAttributes: false,
+    trimValues: true,
+    parseAttributeValue: true,
+    parseTagValue: true
+  });
+  const parsed = parser.parse(input);
+  const segments = path.replace(/^\/+/, "").split("/");
+  const matches = resolvePath(parsed, segments);
+  return {
+    matches,
+    count: matches.length
+  };
+}
+function resolvePath(obj, segments) {
+  if (segments.length === 0) {
+    return obj !== void 0 ? [obj] : [];
+  }
+  if (obj === null || obj === void 0 || typeof obj !== "object") {
+    return [];
+  }
+  const [current, ...rest] = segments;
+  if (current === "*") {
+    const results = [];
+    for (const value of Object.values(obj)) {
+      results.push(...resolvePath(value, rest));
+    }
+    return results;
+  }
+  const record = obj;
+  if (current in record) {
+    const value = record[current];
+    if (Array.isArray(value)) {
+      if (rest.length === 0) return value;
+      const results = [];
+      for (const item of value) {
+        results.push(...resolvePath(item, rest));
+      }
+      return results;
+    }
+    return resolvePath(value, rest);
+  }
+  return [];
+}
+function convert2(input, from, to) {
+  if (from === to) return input;
+  if (from === "xml" && to === "json") {
+    const parser = new fastXmlParser.XMLParser({
+      ignoreAttributes: false,
+      trimValues: true,
+      parseAttributeValue: true,
+      parseTagValue: true
+    });
+    return JSON.stringify(parser.parse(input), null, 2);
+  }
+  if (from === "json" && to === "xml") {
+    const data = JSON.parse(input);
+    const builder = new fastXmlParser.XMLBuilder({
+      ignoreAttributes: false,
+      format: true,
+      indentBy: "  ",
+      suppressEmptyNode: false
+    });
+    return builder.build(data);
+  }
+  throw new Error(`Unsupported conversion: ${from} -> ${to}`);
+}
+function getStats3(input) {
+  const parser = new fastXmlParser.XMLParser({
+    ignoreAttributes: false,
+    trimValues: true,
+    parseAttributeValue: true,
+    parseTagValue: true
+  });
+  const parsed = parser.parse(input);
+  const stats = {
+    elements: 0,
+    attributes: 0,
+    textNodes: 0,
+    depth: 0,
+    sizeBytes: Buffer.byteLength(input, "utf8")
+  };
+  countNodes(parsed, 0, stats);
+  return stats;
+}
+function countNodes(obj, depth, stats) {
+  if (obj === null || obj === void 0) return;
+  if (typeof obj !== "object") {
+    stats.textNodes++;
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      countNodes(item, depth, stats);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("@_")) {
+      stats.attributes++;
+    } else if (key === "#text") {
+      stats.textNodes++;
+    } else {
+      stats.elements++;
+      stats.depth = Math.max(stats.depth, depth + 1);
+      countNodes(value, depth + 1, stats);
+    }
+  }
+}
+
+// src/excel/index.ts
+var excel_exports = {};
+__export(excel_exports, {
+  convert: () => convert3,
+  createExcel: () => createExcel,
+  getSheets: () => getSheets,
+  getStats: () => getStats4,
+  parse: () => parse5
+});
+async function parse5(file, options = {}) {
+  const workbook = new ExcelJS__default.default.Workbook();
+  await workbook.xlsx.load(Buffer.from(file));
+  const sheets = [];
+  workbook.eachSheet((ws, id) => {
+    sheets.push({
+      name: ws.name,
+      index: id,
+      rowCount: ws.rowCount,
+      columnCount: ws.columnCount
+    });
+  });
+  const targetSheet = typeof options.sheet === "number" ? workbook.worksheets[options.sheet] : typeof options.sheet === "string" ? workbook.getWorksheet(options.sheet) : workbook.worksheets[0];
+  if (!targetSheet) {
+    throw new Error("Sheet not found");
+  }
+  const useHeaders = options.header ?? true;
+  const rows = [];
+  let headers = [];
+  targetSheet.eachRow((row, rowNumber) => {
+    const values = row.values;
+    const cells = values.slice(1);
+    if (rowNumber === 1 && useHeaders) {
+      headers = cells.map((c, i) => String(c ?? `Column${i + 1}`));
+      return;
+    }
+    const record = {};
+    const keys = useHeaders && headers.length > 0 ? headers : cells.map((_, i) => `Column${i + 1}`);
+    if (!useHeaders && rowNumber === 1) {
+      headers = keys;
+    }
+    keys.forEach((key, i) => {
+      const val = cells[i];
+      record[key] = val instanceof Date ? val.toISOString() : val ?? null;
+    });
+    rows.push(record);
+  });
+  return {
+    sheets,
+    data: rows,
+    headers,
+    rowCount: rows.length
+  };
+}
+async function getSheets(file) {
+  const workbook = new ExcelJS__default.default.Workbook();
+  await workbook.xlsx.load(Buffer.from(file));
+  const sheets = [];
+  workbook.eachSheet((ws, id) => {
+    sheets.push({
+      name: ws.name,
+      index: id,
+      rowCount: ws.rowCount,
+      columnCount: ws.columnCount
+    });
+  });
+  return sheets;
+}
+async function convert3(file, format4, options = {}) {
+  const workbook = new ExcelJS__default.default.Workbook();
+  await workbook.xlsx.load(Buffer.from(file));
+  const targetSheet = typeof options.sheet === "number" ? workbook.worksheets[options.sheet] : typeof options.sheet === "string" ? workbook.getWorksheet(options.sheet) : workbook.worksheets[0];
+  if (!targetSheet) {
+    throw new Error("Sheet not found");
+  }
+  const useHeaders = options.header ?? true;
+  const allRows = [];
+  targetSheet.eachRow((row) => {
+    const values = row.values;
+    allRows.push(values.slice(1).map((v) => v instanceof Date ? v.toISOString() : v));
+  });
+  if (allRows.length === 0) return "";
+  const headers = useHeaders ? allRows[0].map((c, i) => String(c ?? `Column${i + 1}`)) : allRows[0].map((_, i) => `Column${i + 1}`);
+  const dataRows = useHeaders ? allRows.slice(1) : allRows;
+  switch (format4) {
+    case "json": {
+      const records = dataRows.map((row) => {
+        const record = {};
+        headers.forEach((h, i) => {
+          record[h] = row[i] ?? null;
+        });
+        return record;
+      });
+      return JSON.stringify(records, null, 2);
+    }
+    case "csv":
+      return toDSV(headers, dataRows, ",");
+    case "tsv":
+      return toDSV(headers, dataRows, "	");
+    default:
+      throw new Error(`Unsupported format: ${format4}`);
+  }
+}
+function toDSV(headers, rows, delimiter) {
+  const escape = (val) => {
+    const str = String(val ?? "");
+    if (str.includes(delimiter) || str.includes('"') || str.includes("\n")) {
+      return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+  };
+  const lines = [headers.map(escape).join(delimiter)];
+  for (const row of rows) {
+    lines.push(headers.map((_, i) => escape(row[i])).join(delimiter));
+  }
+  return lines.join("\n");
+}
+async function createExcel(data, sheetName = "Sheet1") {
+  const workbook = new ExcelJS__default.default.Workbook();
+  const sheet = workbook.addWorksheet(sheetName);
+  if (data.length === 0) {
+    const buffer2 = await workbook.xlsx.writeBuffer();
+    return new Uint8Array(buffer2);
+  }
+  const headers = Object.keys(data[0]);
+  sheet.addRow(headers);
+  for (const record of data) {
+    sheet.addRow(headers.map((h) => record[h]));
+  }
+  const buffer = await workbook.xlsx.writeBuffer();
+  return new Uint8Array(buffer);
+}
+async function getStats4(file) {
+  const workbook = new ExcelJS__default.default.Workbook();
+  await workbook.xlsx.load(Buffer.from(file));
+  const sheetDetails = [];
+  let totalRows = 0;
+  let totalColumns = 0;
+  workbook.eachSheet((ws, id) => {
+    sheetDetails.push({
+      name: ws.name,
+      index: id,
+      rowCount: ws.rowCount,
+      columnCount: ws.columnCount
+    });
+    totalRows += ws.rowCount;
+    totalColumns = Math.max(totalColumns, ws.columnCount);
+  });
+  return {
+    sheets: sheetDetails.length,
+    totalRows,
+    totalColumns,
+    sheetDetails,
+    sizeBytes: file.length
+  };
+}
+
+// src/image/index.ts
+var image_exports = {};
+__export(image_exports, {
+  blur: () => blur,
+  compress: () => compress2,
+  convert: () => convert4,
+  crop: () => crop,
+  flip: () => flip,
+  flop: () => flop,
+  getMetadata: () => getMetadata2,
+  getStats: () => getStats5,
+  grayscale: () => grayscale,
+  resize: () => resize,
+  rotate: () => rotate2
+});
+async function resize(file, options) {
+  const result = await sharp2__default.default(Buffer.from(file)).resize({
+    width: options.width,
+    height: options.height,
+    fit: options.fit ?? "inside",
+    background: options.background ?? "#ffffff"
+  }).toBuffer();
+  return new Uint8Array(result);
+}
+async function crop(file, options) {
+  const result = await sharp2__default.default(Buffer.from(file)).extract({
+    left: options.left,
+    top: options.top,
+    width: options.width,
+    height: options.height
+  }).toBuffer();
+  return new Uint8Array(result);
+}
+async function rotate2(file, options) {
+  const result = await sharp2__default.default(Buffer.from(file)).rotate(options.degrees, {
+    background: options.background ?? "#ffffff"
+  }).toBuffer();
+  return new Uint8Array(result);
+}
+async function flip(file) {
+  const result = await sharp2__default.default(Buffer.from(file)).flip().toBuffer();
+  return new Uint8Array(result);
+}
+async function flop(file) {
+  const result = await sharp2__default.default(Buffer.from(file)).flop().toBuffer();
+  return new Uint8Array(result);
+}
+async function grayscale(file) {
+  const result = await sharp2__default.default(Buffer.from(file)).grayscale().toBuffer();
+  return new Uint8Array(result);
+}
+async function blur(file, sigma = 3) {
+  const result = await sharp2__default.default(Buffer.from(file)).blur(sigma).toBuffer();
+  return new Uint8Array(result);
+}
+async function convert4(file, options) {
+  let pipeline = sharp2__default.default(Buffer.from(file));
+  switch (options.format) {
+    case "png":
+      pipeline = pipeline.png();
+      break;
+    case "jpeg":
+      pipeline = pipeline.jpeg({ quality: options.quality ?? 80 });
+      break;
+    case "webp":
+      pipeline = pipeline.webp({ quality: options.quality ?? 80 });
+      break;
+    case "gif":
+      pipeline = pipeline.gif();
+      break;
+    case "tiff":
+      pipeline = pipeline.tiff({ quality: options.quality ?? 80 });
+      break;
+    case "avif":
+      pipeline = pipeline.avif({ quality: options.quality ?? 50 });
+      break;
+    default:
+      throw new Error(`Unsupported format: ${options.format}`);
+  }
+  const result = await pipeline.toBuffer();
+  return new Uint8Array(result);
+}
+async function compress2(file, options = {}) {
+  const quality = options.quality ?? 70;
+  const format4 = options.format ?? "jpeg";
+  return convert4(file, { format: format4, quality });
+}
+async function getMetadata2(file) {
+  const meta = await sharp2__default.default(Buffer.from(file)).metadata();
+  return {
+    width: meta.width ?? 0,
+    height: meta.height ?? 0,
+    format: meta.format ?? "unknown",
+    channels: meta.channels ?? 0,
+    space: meta.space ?? "unknown",
+    depth: meta.depth ?? "unknown",
+    density: meta.density,
+    hasAlpha: meta.hasAlpha ?? false,
+    sizeBytes: file.length
+  };
+}
+async function getStats5(file) {
+  const meta = await sharp2__default.default(Buffer.from(file)).metadata();
+  const width = meta.width ?? 0;
+  const height = meta.height ?? 0;
+  return {
+    width,
+    height,
+    format: meta.format ?? "unknown",
+    channels: meta.channels ?? 0,
+    hasAlpha: meta.hasAlpha ?? false,
+    sizeBytes: file.length,
+    megapixels: Math.round(width * height / 1e4) / 100
+  };
+}
+
+// src/markdown/index.ts
+var markdown_exports = {};
+__export(markdown_exports, {
+  convert: () => convert5,
+  extractFrontmatter: () => extractFrontmatter,
+  extractLinks: () => extractLinks,
+  generateToc: () => generateToc,
+  getStats: () => getStats6,
+  renderToc: () => renderToc,
+  stripFrontmatter: () => stripFrontmatter
+});
+function convert5(input, options) {
+  const { from, to } = options;
+  if (from === to) return input;
+  if (from === "markdown" && to === "html") {
+    return markdownToHtml(input, options.gfm);
+  }
+  if (from === "html" && to === "markdown") {
+    return htmlToMarkdown(input);
+  }
+  if (from === "markdown" && to === "text") {
+    return markdownToText(input);
+  }
+  if (from === "html" && to === "text") {
+    return htmlToText(input);
+  }
+  if (from === "text" && to === "markdown") {
+    return input;
+  }
+  if (from === "text" && to === "html") {
+    return `<p>${input.split("\n\n").join("</p><p>")}</p>`;
+  }
+  throw new Error(`Unsupported conversion: ${from} -> ${to}`);
+}
+function markdownToHtml(input, gfm = true) {
+  marked.marked.setOptions({ gfm });
+  return marked.marked.parse(input);
+}
+function htmlToMarkdown(input) {
+  const turndown = new TurndownService__default.default({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-"
+  });
+  return turndown.turndown(input);
+}
+function markdownToText(input) {
+  const html = markdownToHtml(input);
+  return htmlToText(html);
+}
+function htmlToText(input) {
+  return input.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/markdown/toc.ts
+function generateToc(input) {
+  const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+  const entries = [];
+  let match;
+  while ((match = headingRegex.exec(input)) !== null) {
+    const level = match[1].length;
+    const text = match[2].trim();
+    const slug = text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+    entries.push({ level, text, slug });
+  }
+  return entries;
+}
+function renderToc(entries) {
+  if (entries.length === 0) return "";
+  const minLevel = Math.min(...entries.map((e) => e.level));
+  return entries.map((entry) => {
+    const indent = "  ".repeat(entry.level - minLevel);
+    return `${indent}- [${entry.text}](#${entry.slug})`;
+  }).join("\n");
+}
+
+// src/markdown/extract.ts
+function extractLinks(input) {
+  const links = [];
+  const lines = input.split("\n");
+  const linkRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    while ((match = linkRegex.exec(lines[i])) !== null) {
+      links.push({
+        text: match[1],
+        href: match[2],
+        line: i + 1
+      });
+    }
+  }
+  return links;
+}
+function extractFrontmatter(input) {
+  const match = input.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!match) return null;
+  const frontmatter = {};
+  const lines = match[1].split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.substring(0, colonIndex).trim();
+    let value = line.substring(colonIndex + 1).trim();
+    if (value === "true") value = true;
+    else if (value === "false") value = false;
+    else if (!isNaN(Number(value)) && value !== "") value = Number(value);
+    else if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+    }
+    frontmatter[key] = value;
+  }
+  return frontmatter;
+}
+function stripFrontmatter(input) {
+  return input.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
+}
+
+// src/markdown/stats.ts
+function getStats6(input) {
+  const lines = input.split("\n");
+  const text = input.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "");
+  const headings = (text.match(/^#{1,6}\s+.+$/gm) || []).length;
+  const links = (input.match(/\[([^\]]*)\]\(([^)]+)\)/g) || []).length;
+  const images = (input.match(/!\[([^\]]*)\]\(([^)]+)\)/g) || []).length;
+  const codeBlocks = (input.match(/```/g) || []).length / 2;
+  const lists = (text.match(/^[\s]*[-*+]\s+|^[\s]*\d+\.\s+/gm) || []).length;
+  const plainText = text.replace(/#{1,6}\s+/g, "").replace(/\[([^\]]*)\]\([^)]+\)/g, "$1").replace(/[*_~`]/g, "").trim();
+  const words = plainText.split(/\s+/).filter((w) => w.length > 0).length;
+  const paragraphs = input.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length;
+  return {
+    words,
+    characters: input.length,
+    lines: lines.length,
+    paragraphs,
+    headings,
+    links,
+    images,
+    codeBlocks: Math.floor(codeBlocks),
+    lists,
+    sizeBytes: Buffer.byteLength(input, "utf8")
+  };
+}
+
+// src/archive/index.ts
+var archive_exports = {};
+__export(archive_exports, {
+  create: () => create,
+  extract: () => extract,
+  getStats: () => getStats7,
+  list: () => list
+});
+async function create(files, options = {}) {
+  const format4 = options.format ?? "zip";
+  const level = options.compressionLevel ?? 6;
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const output = new stream.PassThrough();
+    output.on("data", (chunk) => chunks.push(chunk));
+    output.on("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+    output.on("error", reject);
+    const archiverFormat = format4 === "tar.gz" ? "tar" : format4;
+    const archiverOptions = format4 === "tar.gz" ? { gzip: true, gzipOptions: { level } } : format4 === "zip" ? { zlib: { level } } : {};
+    const archive = archiver__default.default(archiverFormat, archiverOptions);
+    archive.on("error", reject);
+    archive.pipe(output);
+    for (const file of files) {
+      archive.append(file.content, { name: file.path });
+    }
+    archive.finalize();
+  });
+}
+async function extract(file, options = {}) {
+  const zip = new AdmZip__default.default(Buffer.from(file));
+  const entries = zip.getEntries();
+  const results = [];
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    if (options.files && !options.files.includes(entry.entryName)) {
+      continue;
+    }
+    results.push({
+      path: entry.entryName,
+      content: entry.getData()
+    });
+  }
+  return results;
+}
+async function list(file) {
+  const zip = new AdmZip__default.default(Buffer.from(file));
+  const entries = zip.getEntries();
+  return entries.map((entry) => ({
+    path: entry.entryName,
+    size: entry.header.size,
+    compressedSize: entry.header.compressedSize,
+    isDirectory: entry.isDirectory,
+    modified: entry.header.time ? new Date(entry.header.time).toISOString() : void 0
+  }));
+}
+async function getStats7(file) {
+  const entries = await list(file);
+  let totalSize = 0;
+  let compressedSize = 0;
+  let fileCount = 0;
+  let directoryCount = 0;
+  for (const entry of entries) {
+    if (entry.isDirectory) {
+      directoryCount++;
+    } else {
+      fileCount++;
+      totalSize += entry.size;
+      compressedSize += entry.compressedSize ?? entry.size;
+    }
+  }
+  return {
+    format: "zip",
+    fileCount,
+    directoryCount,
+    totalSize,
+    compressedSize,
+    entries
+  };
+}
+
+// src/regex/index.ts
+var regex_exports = {};
+__export(regex_exports, {
+  extract: () => extract2,
+  replace: () => replace,
+  test: () => test,
+  validate: () => validate3
+});
+
+// src/regex/utils.ts
+function buildFlags(options) {
+  let flags = options.flags ?? "";
+  if (options.global && !flags.includes("g")) flags += "g";
+  if (options.caseInsensitive && !flags.includes("i")) flags += "i";
+  if (options.multiline && !flags.includes("m")) flags += "m";
+  return flags;
+}
+
+// src/regex/test.ts
+function test(input, pattern, options = {}) {
+  const flags = buildFlags(options);
+  const regex = new RegExp(pattern, flags.includes("g") ? flags : flags + "g");
+  const results = [];
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    results.push({
+      match: match[0],
+      index: match.index,
+      groups: match.groups ? { ...match.groups } : {}
+    });
+    if (!flags.includes("g")) break;
+  }
+  return {
+    matches: results.length > 0,
+    matchCount: results.length,
+    results
+  };
+}
+
+// src/regex/replace.ts
+function replace(input, pattern, replacement, options = {}) {
+  const flags = buildFlags({ ...options, global: options.global ?? true });
+  const regex = new RegExp(pattern, flags);
+  let replacements = 0;
+  const output = input.replace(regex, (...args) => {
+    replacements++;
+    const groups = args[args.length - 1];
+    let result = replacement;
+    if (typeof groups === "object" && groups !== null) {
+      for (const [key, value] of Object.entries(groups)) {
+        result = result.replace(new RegExp(`\\$<${key}>`, "g"), String(value ?? ""));
+      }
+    }
+    for (let i = 1; i < args.length - 2; i++) {
+      result = result.replace(new RegExp(`\\$${i}`, "g"), args[i] ?? "");
+    }
+    return result;
+  });
+  return { output, replacements };
+}
+
+// src/regex/extract.ts
+function extract2(input, pattern, options = {}) {
+  const flags = buildFlags({ ...options, global: true });
+  const regex = new RegExp(pattern, flags);
+  const matches = [];
+  const groups = [];
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    matches.push(match[0]);
+    if (match.groups) {
+      groups.push({ ...match.groups });
+    }
+  }
+  return {
+    matches,
+    groups,
+    count: matches.length
+  };
+}
+
+// src/regex/validate.ts
+function validate3(pattern, flags) {
+  try {
+    new RegExp(pattern, flags);
+    return { valid: true };
+  } catch (e) {
+    return {
+      valid: false,
+      error: e.message
+    };
+  }
+}
+
+// src/diff/index.ts
+var diff_exports = {};
+__export(diff_exports, {
+  apply: () => apply,
+  compare: () => compare,
+  createUnifiedPatch: () => createUnifiedPatch,
+  parsePatchFile: () => parsePatchFile,
+  unifiedDiff: () => unifiedDiff
+});
+function compare(a, b, options = {}) {
+  const type = options.type ?? "line";
+  let rawChanges;
+  switch (type) {
+    case "word":
+      rawChanges = diff$1.diffWords(a, b, {
+        ignoreWhitespace: options.ignoreWhitespace
+      });
+      break;
+    case "char":
+      rawChanges = diff$1.diffChars(a, b);
+      break;
+    case "line":
+    default:
+      rawChanges = diff$1.diffLines(a, b, {
+        ignoreWhitespace: options.ignoreWhitespace
+      });
+      break;
+  }
+  const changes = rawChanges.map((c) => ({
+    type: c.added ? "added" : c.removed ? "removed" : "unchanged",
+    value: c.value,
+    count: c.count ?? 0
+  }));
+  let additions = 0;
+  let deletions = 0;
+  let unchanged = 0;
+  for (const change of changes) {
+    switch (change.type) {
+      case "added":
+        additions += change.count;
+        break;
+      case "removed":
+        deletions += change.count;
+        break;
+      case "unchanged":
+        unchanged += change.count;
+        break;
+    }
+  }
+  return {
+    identical: additions === 0 && deletions === 0,
+    changes,
+    stats: { additions, deletions, unchanged }
+  };
+}
+function unifiedDiff(a, b, options = {}) {
+  const fromFile = options.fromFile ?? "a";
+  const toFile = options.toFile ?? "b";
+  const context = options.context ?? 3;
+  return diff$1.createTwoFilesPatch(fromFile, toFile, a, b, void 0, void 0, {
+    context
+  });
+}
+function createUnifiedPatch(fileName, original, modified, context = 3) {
+  return diff$1.createPatch(fileName, original, modified, void 0, void 0, {
+    context
+  });
+}
+function apply(input, patch, options = {}) {
+  const result = diff$1.applyPatch(input, patch, {
+    fuzzFactor: options.fuzz ?? 0
+  });
+  if (result === false) {
+    throw new Error("Failed to apply patch: patch does not match the input");
+  }
+  return result;
+}
+function parsePatchFile(patch) {
+  return diff$1.parsePatch(patch);
+}
+
+// src/sql/index.ts
+var sql_exports = {};
+__export(sql_exports, {
+  convert: () => convert6,
+  format: () => format3,
+  getStats: () => getStats8,
+  minify: () => minify3,
+  parse: () => parse6,
+  validate: () => validate4
+});
+var dialectMap = {
+  mysql: "mysql",
+  postgresql: "postgresql",
+  sqlite: "sqlite",
+  transactsql: "transactsql",
+  bigquery: "bigquery"
+};
+function format3(input, options = {}) {
+  const language = dialectMap[options.dialect ?? "postgresql"] ?? "postgresql";
+  return sqlFormatter.format(input, {
+    language,
+    tabWidth: options.indent ?? 2,
+    useTabs: false,
+    keywordCase: options.uppercase !== false ? "upper" : "preserve",
+    linesBetweenQueries: options.linesBetweenQueries ?? 2
+  });
+}
+function minify3(input) {
+  return input.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([,;()=<>+\-*/])\s*/g, "$1").trim();
+}
+var parserDialectMap = {
+  mysql: "MySQL",
+  postgresql: "PostgresQL",
+  sqlite: "SQLite",
+  transactsql: "TransactSQL",
+  bigquery: "BigQuery"
+};
+function parse6(input, dialect = "postgresql") {
+  const parser = new nodeSqlParser.Parser();
+  const dbType = parserDialectMap[dialect] ?? "PostgresQL";
+  const ast = parser.astify(input, { database: dbType });
+  const stmts = Array.isArray(ast) ? ast : [ast];
+  const tables = /* @__PURE__ */ new Set();
+  const columns = /* @__PURE__ */ new Set();
+  for (const stmt of stmts) {
+    extractTablesAndColumns(stmt, tables, columns);
+  }
+  return {
+    type: stmts[0]?.type ?? "unknown",
+    tables: Array.from(tables),
+    columns: Array.from(columns),
+    ast
+  };
+}
+function validate4(input, dialect = "postgresql") {
+  const parser = new nodeSqlParser.Parser();
+  const dbType = parserDialectMap[dialect] ?? "PostgresQL";
+  try {
+    const ast = parser.astify(input, { database: dbType });
+    return { valid: true, ast };
+  } catch (e) {
+    return {
+      valid: false,
+      error: e.message
+    };
+  }
+}
+function getStats8(input, dialect = "postgresql") {
+  const parser = new nodeSqlParser.Parser();
+  const dbType = parserDialectMap[dialect] ?? "PostgresQL";
+  const ast = parser.astify(input, { database: dbType });
+  const stmts = Array.isArray(ast) ? ast : [ast];
+  const queryTypes = {};
+  const tables = /* @__PURE__ */ new Set();
+  let joins = 0;
+  for (const stmt of stmts) {
+    const type = (stmt.type ?? "unknown").toLowerCase();
+    queryTypes[type] = (queryTypes[type] || 0) + 1;
+    extractTablesAndColumns(stmt, tables, /* @__PURE__ */ new Set());
+    const stmtStr = JSON.stringify(stmt);
+    const joinMatches = stmtStr.match(/"join"/gi);
+    if (joinMatches) joins += joinMatches.length;
+  }
+  const subqueryRegex = /\bSELECT\b/gi;
+  const selectMatches = input.match(subqueryRegex);
+  const subqueries = Math.max(0, (selectMatches?.length ?? 0) - stmts.filter((s) => s.type === "select").length);
+  return {
+    queryCount: stmts.length,
+    queryTypes,
+    tables: Array.from(tables),
+    joins,
+    subqueries
+  };
+}
+function extractTablesAndColumns(node, tables, columns) {
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  if (obj.table && typeof obj.table === "string") {
+    tables.add(obj.table);
+  }
+  if (obj.from && Array.isArray(obj.from)) {
+    for (const item of obj.from) {
+      if (item && typeof item === "object" && "table" in item) {
+        tables.add(String(item.table));
+      }
+    }
+  }
+  if (obj.columns && Array.isArray(obj.columns)) {
+    for (const col of obj.columns) {
+      if (col && typeof col === "object" && "expr" in col) {
+        const expr = col.expr;
+        if (expr.type === "column_ref" && typeof expr.column === "string") {
+          columns.add(expr.column);
+        }
+      }
+    }
+  }
+  for (const value of Object.values(obj)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        extractTablesAndColumns(item, tables, columns);
+      }
+    } else if (typeof value === "object" && value !== null) {
+      extractTablesAndColumns(value, tables, columns);
+    }
+  }
+}
+var parserDialectMap2 = {
+  mysql: "MySQL",
+  postgresql: "PostgresQL",
+  sqlite: "SQLite",
+  transactsql: "TransactSQL",
+  bigquery: "BigQuery"
+};
+function convert6(input, options) {
+  const fromDialect = parserDialectMap2[options.from ?? "postgresql"] ?? "PostgresQL";
+  const toDialect = parserDialectMap2[options.to] ?? "PostgresQL";
+  const parser = new nodeSqlParser.Parser();
+  const ast = parser.astify(input, { database: fromDialect });
+  return parser.sqlify(ast, { database: toDialect });
+}
+
+// src/crypto/index.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  checksum: () => checksum,
+  decode: () => decode,
+  decodeJwt: () => decodeJwt,
+  encode: () => encode,
+  generateUuid: () => generateUuid,
+  hash: () => hash,
+  hmac: () => hmac
+});
+function hash(input, algorithm = "sha256") {
+  const h = crypto.createHash(algorithm).update(input).digest("hex");
+  return {
+    algorithm,
+    hash: h,
+    inputLength: input.length
+  };
+}
+function hmac(input, key, options = {}) {
+  const algorithm = options.algorithm ?? "sha256";
+  const h = crypto.createHmac(algorithm, key).update(input).digest("hex");
+  return {
+    algorithm,
+    hmac: h
+  };
+}
+function checksum(data, algorithm = "sha256") {
+  const buffer = typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
+  const h = crypto.createHash(algorithm).update(buffer).digest("hex");
+  return {
+    algorithm,
+    checksum: h,
+    sizeBytes: buffer.length
+  };
+}
+function generateUuid() {
+  let uuid;
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    uuid = globalThis.crypto.randomUUID();
+  } else {
+    uuid = crypto.randomUUID();
+  }
+  return {
+    uuid,
+    version: 4
+  };
+}
+
+// src/crypto/encode.ts
+function encode(input, format4) {
+  switch (format4) {
+    case "base64":
+      return Buffer.from(input).toString("base64");
+    case "hex":
+      return Buffer.from(input).toString("hex");
+    case "url":
+      return encodeURIComponent(input);
+    case "html":
+      return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+    default:
+      throw new Error(`Unsupported encoding format: ${format4}`);
+  }
+}
+function decode(input, format4) {
+  switch (format4) {
+    case "base64":
+      return Buffer.from(input, "base64").toString("utf8");
+    case "hex":
+      return Buffer.from(input, "hex").toString("utf8");
+    case "url":
+      return decodeURIComponent(input);
+    case "html":
+      return input.replace(/&#39;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+    default:
+      throw new Error(`Unsupported encoding format: ${format4}`);
+  }
+}
+
+// src/crypto/jwt.ts
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4;
+  if (padding) {
+    base64 += "=".repeat(4 - padding);
+  }
+  if (typeof atob === "function") {
+    return decodeURIComponent(
+      atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+  }
+  return Buffer.from(base64, "base64").toString("utf8");
+}
+function decodeJwt(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid JWT: must have 3 parts separated by dots");
+  }
+  const header = JSON.parse(base64UrlDecode(parts[0]));
+  const payload = JSON.parse(base64UrlDecode(parts[1]));
+  const result = {
+    header,
+    payload,
+    signature: parts[2]
+  };
+  if (typeof payload.exp === "number") {
+    const expDate = new Date(payload.exp * 1e3);
+    result.expired = expDate < /* @__PURE__ */ new Date();
+    result.expiresAt = expDate.toISOString();
+  }
+  return result;
+}
+
+// src/datetime/index.ts
+var datetime_exports = {};
+__export(datetime_exports, {
+  add: () => add,
+  convertTimezone: () => convertTimezone,
+  diff: () => diff2,
+  formatDate: () => formatDate,
+  listTimezones: () => listTimezones,
+  now: () => now,
+  parseCron: () => parseCron,
+  parseDate: () => parseDate,
+  subtract: () => subtract
+});
+function parseDate(input, timezone) {
+  let dt;
+  const unixNum = Number(input);
+  if (!isNaN(unixNum) && String(unixNum) === input.trim()) {
+    dt = unixNum > 1e12 ? luxon.DateTime.fromMillis(unixNum, { zone: timezone ?? "utc" }) : luxon.DateTime.fromSeconds(unixNum, { zone: timezone ?? "utc" });
+  } else {
+    dt = luxon.DateTime.fromISO(input, { zone: timezone ?? "utc" });
+    if (!dt.isValid) {
+      dt = luxon.DateTime.fromRFC2822(input, { zone: timezone ?? "utc" });
+    }
+    if (!dt.isValid) {
+      dt = luxon.DateTime.fromSQL(input, { zone: timezone ?? "utc" });
+    }
+  }
+  if (!dt.isValid) {
+    throw new Error(`Unable to parse date: ${input} (${dt.invalidReason})`);
+  }
+  return {
+    iso: dt.toISO(),
+    unix: Math.floor(dt.toSeconds()),
+    unixMs: dt.toMillis(),
+    year: dt.year,
+    month: dt.month,
+    day: dt.day,
+    hour: dt.hour,
+    minute: dt.minute,
+    second: dt.second,
+    dayOfWeek: dt.weekdayLong,
+    dayOfYear: dt.ordinal,
+    weekNumber: dt.weekNumber,
+    isLeapYear: dt.isInLeapYear,
+    timezone: dt.zoneName,
+    offset: dt.toFormat("ZZ")
+  };
+}
+function formatDate(input, options = {}) {
+  const tz = options.timezone ?? "utc";
+  let dt = luxon.DateTime.fromISO(input, { zone: tz });
+  if (!dt.isValid) {
+    dt = luxon.DateTime.fromMillis(Number(input), { zone: tz });
+  }
+  if (!dt.isValid) {
+    throw new Error(`Unable to parse date: ${input}`);
+  }
+  if (options.format) {
+    return dt.toFormat(options.format);
+  }
+  return dt.toISO();
+}
+function now(timezone) {
+  const dt = luxon.DateTime.now().setZone(timezone ?? "utc");
+  return parseDate(dt.toISO(), timezone);
+}
+function add(input, amount, timezone) {
+  const dt = luxon.DateTime.fromISO(input, { zone: timezone ?? "utc" });
+  if (!dt.isValid) {
+    throw new Error(`Unable to parse date: ${input}`);
+  }
+  const result = dt.plus(amount);
+  return result.toISO();
+}
+function subtract(input, amount, timezone) {
+  const dt = luxon.DateTime.fromISO(input, { zone: timezone ?? "utc" });
+  if (!dt.isValid) {
+    throw new Error(`Unable to parse date: ${input}`);
+  }
+  const result = dt.minus(amount);
+  return result.toISO();
+}
+function diff2(a, b) {
+  const dtA = luxon.DateTime.fromISO(a, { zone: "utc" });
+  const dtB = luxon.DateTime.fromISO(b, { zone: "utc" });
+  if (!dtA.isValid || !dtB.isValid) {
+    throw new Error("Unable to parse one or both dates");
+  }
+  const duration = dtB.diff(dtA, [
+    "years",
+    "months",
+    "days",
+    "hours",
+    "minutes",
+    "seconds"
+  ]);
+  const totalMs = dtB.toMillis() - dtA.toMillis();
+  return {
+    years: Math.floor(duration.years),
+    months: Math.floor(duration.months),
+    days: Math.floor(duration.days),
+    hours: Math.floor(duration.hours),
+    minutes: Math.floor(duration.minutes),
+    seconds: Math.floor(duration.seconds),
+    totalDays: Math.floor(totalMs / 864e5),
+    totalHours: Math.floor(totalMs / 36e5),
+    totalMinutes: Math.floor(totalMs / 6e4),
+    totalSeconds: Math.floor(totalMs / 1e3),
+    totalMilliseconds: totalMs
+  };
+}
+function convertTimezone(input, fromTimezone, toTimezone) {
+  const dtFrom = luxon.DateTime.fromISO(input, { zone: fromTimezone });
+  if (!dtFrom.isValid) {
+    throw new Error(`Unable to parse date: ${input} in timezone ${fromTimezone}`);
+  }
+  const dtTo = dtFrom.setZone(toTimezone);
+  if (!dtTo.isValid) {
+    throw new Error(`Invalid target timezone: ${toTimezone}`);
+  }
+  const offsetFrom = dtFrom.offset;
+  const offsetTo = dtTo.offset;
+  const diffMinutes = offsetTo - offsetFrom;
+  const sign = diffMinutes >= 0 ? "+" : "-";
+  const absMinutes = Math.abs(diffMinutes);
+  const hours = Math.floor(absMinutes / 60);
+  const minutes = absMinutes % 60;
+  return {
+    input: dtFrom.toISO(),
+    inputTimezone: fromTimezone,
+    output: dtTo.toISO(),
+    outputTimezone: toTimezone,
+    offsetDifference: `${sign}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
+  };
+}
+function listTimezones() {
+  return Intl.supportedValuesOf("timeZone");
+}
+
+// src/datetime/cron.ts
+var MONTH_NAMES = ["", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function parseCron(expression, count = 5) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return {
+      valid: false,
+      description: "",
+      nextRuns: [],
+      error: `Expected 5 fields, got ${parts.length}`
+    };
+  }
+  try {
+    const description = describeCron(parts);
+    const nextRuns = getNextRuns(parts, count);
+    return {
+      valid: true,
+      description,
+      nextRuns: nextRuns.map((d) => d.toISOString())
+    };
+  } catch (e) {
+    return {
+      valid: false,
+      description: "",
+      nextRuns: [],
+      error: e.message
+    };
+  }
+}
+function describeCron(parts) {
+  const [min, hour, dom, month, dow] = parts;
+  const segments = [];
+  if (min === "*" && hour === "*" && dom === "*" && month === "*" && dow === "*") {
+    return "Every minute";
+  }
+  if (min !== "*") segments.push(`at minute ${min}`);
+  if (hour !== "*") segments.push(`at hour ${hour}`);
+  if (dom !== "*") segments.push(`on day ${dom} of the month`);
+  if (month !== "*") {
+    const m = parseInt(month);
+    segments.push(`in ${!isNaN(m) && m >= 1 && m <= 12 ? MONTH_NAMES[m] : month}`);
+  }
+  if (dow !== "*") {
+    const d = parseInt(dow);
+    segments.push(`on ${!isNaN(d) && d >= 0 && d <= 6 ? DAY_NAMES[d] : dow}`);
+  }
+  return segments.join(", ") || "Every minute";
+}
+function getNextRuns(parts, count) {
+  const runs = [];
+  const now2 = /* @__PURE__ */ new Date();
+  const current = new Date(now2);
+  current.setSeconds(0, 0);
+  current.setMinutes(current.getMinutes() + 1);
+  const maxIterations = 525600;
+  let iterations = 0;
+  while (runs.length < count && iterations < maxIterations) {
+    if (matchesCron(current, parts)) {
+      runs.push(new Date(current));
+    }
+    current.setMinutes(current.getMinutes() + 1);
+    iterations++;
+  }
+  return runs;
+}
+function matchesCron(date, parts) {
+  const [minExpr, hourExpr, domExpr, monthExpr, dowExpr] = parts;
+  return matchesField(date.getMinutes(), minExpr, 0, 59) && matchesField(date.getHours(), hourExpr, 0, 23) && matchesField(date.getDate(), domExpr, 1, 31) && matchesField(date.getMonth() + 1, monthExpr, 1, 12) && matchesField(date.getDay(), dowExpr, 0, 6);
+}
+function matchesField(value, expr, min, max) {
+  if (expr === "*") return true;
+  for (const part of expr.split(",")) {
+    if (part.includes("/")) {
+      const [range, stepStr] = part.split("/");
+      const step = parseInt(stepStr);
+      const start = range === "*" ? min : parseInt(range);
+      for (let i = start; i <= max; i += step) {
+        if (i === value) return true;
+      }
+    } else if (part.includes("-")) {
+      const [startStr, endStr] = part.split("-");
+      const start = parseInt(startStr);
+      const end = parseInt(endStr);
+      if (value >= start && value <= end) return true;
+    } else {
+      if (parseInt(part) === value) return true;
+    }
+  }
+  return false;
+}
+
+// src/text/index.ts
+var text_exports = {};
+__export(text_exports, {
+  convertCase: () => convertCase,
+  generateLorem: () => generateLorem,
+  getTextStats: () => getTextStats,
+  interpolate: () => interpolate,
+  similarity: () => similarity,
+  slugify: () => slugify,
+  truncate: () => truncate
+});
+
+// src/text/case.ts
+function splitWords(input) {
+  return input.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[-_]/g, " ").split(/\s+/).filter((word) => word.length > 0);
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+function convertCase(input, to) {
+  const words = splitWords(input);
+  if (words.length === 0) {
+    return "";
+  }
+  switch (to) {
+    case "camel":
+      return words.map((word, index) => index === 0 ? word.toLowerCase() : capitalize(word)).join("");
+    case "pascal":
+      return words.map((word) => capitalize(word)).join("");
+    case "snake":
+      return words.map((word) => word.toLowerCase()).join("_");
+    case "kebab":
+      return words.map((word) => word.toLowerCase()).join("-");
+    case "constant":
+      return words.map((word) => word.toUpperCase()).join("_");
+    case "title":
+      return words.map((word) => capitalize(word)).join(" ");
+    case "sentence":
+      return words.map((word, index) => index === 0 ? capitalize(word) : word.toLowerCase()).join(" ");
+    case "upper":
+      return words.map((word) => word.toUpperCase()).join(" ");
+    case "lower":
+      return words.map((word) => word.toLowerCase()).join(" ");
+  }
+}
+
+// src/text/slug.ts
+function slugify(input, separator = "-") {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, separator).replace(new RegExp(`${escapeRegExp(separator)}+`, "g"), separator).replace(new RegExp(`^${escapeRegExp(separator)}|${escapeRegExp(separator)}$`, "g"), "");
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/text/stats.ts
+function getTextStats(input) {
+  const characters = input.length;
+  const words = input.split(/\s+/).filter((word) => word.length > 0);
+  const sentences = input.split(/[.!?](?:\s|$)/).filter((sentence) => sentence.trim().length > 0);
+  const paragraphs = input.split(/\n\n+/).filter((paragraph) => paragraph.trim().length > 0);
+  const lines = input.split(/\n/);
+  const readingTimeMs = words.length / 200 * 60 * 1e3;
+  return {
+    characters,
+    words: words.length,
+    sentences: sentences.length,
+    paragraphs: paragraphs.length,
+    lines: lines.length,
+    readingTimeMs
+  };
+}
+
+// src/text/truncate.ts
+function truncate(input, options) {
+  const { length, boundary = "word", suffix = "..." } = options;
+  if (input.length <= length) {
+    return input;
+  }
+  const maxContentLength = length - suffix.length;
+  if (maxContentLength <= 0) {
+    return suffix.slice(0, length);
+  }
+  if (boundary === "character") {
+    return input.slice(0, maxContentLength) + suffix;
+  }
+  const truncated = input.slice(0, maxContentLength);
+  const lastSpaceIndex = truncated.lastIndexOf(" ");
+  if (lastSpaceIndex === -1) {
+    return truncated + suffix;
+  }
+  return input.slice(0, lastSpaceIndex) + suffix;
+}
+
+// src/text/lorem.ts
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint",
+  "occaecat",
+  "cupidatat"
+];
+function getWord(index) {
+  return LOREM_WORDS[index % LOREM_WORDS.length];
+}
+function generateSentence(wordOffset) {
+  const wordCount = 8 + wordOffset % 8;
+  const words = [];
+  for (let i = 0; i < wordCount; i++) {
+    words.push(getWord(wordOffset + i));
+  }
+  words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1);
+  return {
+    sentence: words.join(" ") + ".",
+    nextOffset: wordOffset + wordCount
+  };
+}
+function generateLorem(count, unit = "words") {
+  if (count <= 0) {
+    return "";
+  }
+  if (unit === "words") {
+    const words = [];
+    for (let i = 0; i < count; i++) {
+      words.push(getWord(i));
+    }
+    return words.join(" ");
+  }
+  if (unit === "sentences") {
+    const sentences = [];
+    let offset2 = 0;
+    for (let i = 0; i < count; i++) {
+      const { sentence, nextOffset } = generateSentence(offset2);
+      sentences.push(sentence);
+      offset2 = nextOffset;
+    }
+    return sentences.join(" ");
+  }
+  const paragraphs = [];
+  let offset = 0;
+  for (let i = 0; i < count; i++) {
+    const sentenceCount = 3 + i % 4;
+    const sentences = [];
+    for (let j = 0; j < sentenceCount; j++) {
+      const { sentence, nextOffset } = generateSentence(offset);
+      sentences.push(sentence);
+      offset = nextOffset;
+    }
+    paragraphs.push(sentences.join(" "));
+  }
+  return paragraphs.join("\n\n");
+}
+
+// src/text/similarity.ts
+function similarity(a, b) {
+  if (a === b) {
+    return { distance: 0, similarity: 1 };
+  }
+  if (a.length === 0) {
+    return { distance: b.length, similarity: 0 };
+  }
+  if (b.length === 0) {
+    return { distance: a.length, similarity: 0 };
+  }
+  const m = a.length;
+  const n = b.length;
+  const dp = [];
+  for (let i = 0; i <= m; i++) {
+    dp[i] = new Array(n + 1);
+    dp[i][0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0][j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        // deletion
+        dp[i][j - 1] + 1,
+        // insertion
+        dp[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  const distance = dp[m][n];
+  const maxLength = Math.max(m, n);
+  const sim = 1 - distance / maxLength;
+  return { distance, similarity: sim };
+}
+
+// src/text/template.ts
+function interpolate(template, variables) {
+  const missingKeys = [];
+  const result = template.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, key) => {
+    if (key in variables) {
+      return variables[key];
+    }
+    missingKeys.push(key);
+    return match;
+  });
+  const uniqueMissingKeys = [...new Set(missingKeys)];
+  return { result, missingKeys: uniqueMissingKeys };
+}
+
+// src/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  calculateStats: () => calculateStats,
+  convertBase: () => convertBase,
+  convertUnit: () => convertUnit,
+  formatNumber: () => formatNumber,
+  percentage: () => percentage,
+  percentageChange: () => percentageChange
+});
+
+// src/math/convert.ts
+var lengthFactors = {
+  mm: 1e-3,
+  cm: 0.01,
+  m: 1,
+  km: 1e3,
+  in: 0.0254,
+  ft: 0.3048,
+  yd: 0.9144,
+  mi: 1609.344
+};
+var weightFactors = {
+  mg: 1e-3,
+  g: 1,
+  kg: 1e3,
+  oz: 28.3495,
+  lb: 453.592,
+  ton: 907185
+};
+var dataFactors = {
+  b: 1,
+  kb: 1024,
+  mb: Math.pow(1024, 2),
+  gb: Math.pow(1024, 3),
+  tb: Math.pow(1024, 4)
+};
+var temperatureUnits = /* @__PURE__ */ new Set(["celsius", "fahrenheit", "kelvin"]);
+function convertTemperature(value, from, to) {
+  if (from === to) return value;
+  let celsius;
+  switch (from) {
+    case "celsius":
+      celsius = value;
+      break;
+    case "fahrenheit":
+      celsius = (value - 32) * 5 / 9;
+      break;
+    case "kelvin":
+      celsius = value - 273.15;
+      break;
+    default:
+      throw new Error(`Unknown temperature unit: ${from}`);
+  }
+  switch (to) {
+    case "celsius":
+      return celsius;
+    case "fahrenheit":
+      return celsius * 9 / 5 + 32;
+    case "kelvin":
+      return celsius + 273.15;
+    default:
+      throw new Error(`Unknown temperature unit: ${to}`);
+  }
+}
+function getFactors(category) {
+  switch (category) {
+    case "length":
+      return lengthFactors;
+    case "weight":
+      return weightFactors;
+    case "data":
+      return dataFactors;
+    default:
+      throw new Error(`No conversion factors for category: ${category}`);
+  }
+}
+function convertUnit(value, from, to, category) {
+  const fromLower = from.toLowerCase();
+  const toLower = to.toLowerCase();
+  if (category === "temperature") {
+    if (!temperatureUnits.has(fromLower)) {
+      throw new Error(`Unit '${from}' does not belong to category 'temperature'`);
+    }
+    if (!temperatureUnits.has(toLower)) {
+      throw new Error(`Unit '${to}' does not belong to category 'temperature'`);
+    }
+    const result2 = convertTemperature(value, fromLower, toLower);
+    return { value, from: fromLower, to: toLower, result: result2 };
+  }
+  const factors = getFactors(category);
+  if (!(fromLower in factors)) {
+    throw new Error(`Unit '${from}' does not belong to category '${category}'`);
+  }
+  if (!(toLower in factors)) {
+    throw new Error(`Unit '${to}' does not belong to category '${category}'`);
+  }
+  const baseValue = value * factors[fromLower];
+  const result = baseValue / factors[toLower];
+  return { value, from: fromLower, to: toLower, result };
+}
+
+// src/math/base.ts
+var radixMap = {
+  binary: 2,
+  octal: 8,
+  decimal: 10,
+  hex: 16
+};
+function convertBase(input, fromBase) {
+  const radix = radixMap[fromBase];
+  if (radix === void 0) {
+    throw new Error(`Unknown base: ${fromBase}`);
+  }
+  let cleanInput = input.trim();
+  if (fromBase === "binary" && cleanInput.startsWith("0b")) {
+    cleanInput = cleanInput.slice(2);
+  } else if (fromBase === "octal" && cleanInput.startsWith("0o")) {
+    cleanInput = cleanInput.slice(2);
+  } else if (fromBase === "hex" && cleanInput.startsWith("0x")) {
+    cleanInput = cleanInput.slice(2);
+  }
+  const decimalValue = parseInt(cleanInput, radix);
+  if (isNaN(decimalValue)) {
+    throw new Error(`Invalid input '${input}' for base '${fromBase}'`);
+  }
+  return {
+    input,
+    fromBase,
+    binary: "0b" + decimalValue.toString(2),
+    octal: "0o" + decimalValue.toString(8),
+    decimal: decimalValue.toString(10),
+    hex: "0x" + decimalValue.toString(16)
+  };
+}
+
+// src/math/statistics.ts
+function getPercentile(sorted, p) {
+  if (sorted.length === 1) return sorted[0];
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) return sorted[lower];
+  const fraction = index - lower;
+  return sorted[lower] + fraction * (sorted[upper] - sorted[lower]);
+}
+function calculateStats(numbers) {
+  if (numbers.length === 0) {
+    throw new Error("Cannot calculate statistics for an empty array");
+  }
+  const count = numbers.length;
+  const sum = numbers.reduce((acc, n) => acc + n, 0);
+  const mean = sum / count;
+  const sorted = [...numbers].sort((a, b) => a - b);
+  let median;
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    median = (sorted[mid - 1] + sorted[mid]) / 2;
+  } else {
+    median = sorted[mid];
+  }
+  const frequencyMap = /* @__PURE__ */ new Map();
+  for (const n of numbers) {
+    frequencyMap.set(n, (frequencyMap.get(n) || 0) + 1);
+  }
+  let maxFrequency = 0;
+  for (const freq of frequencyMap.values()) {
+    if (freq > maxFrequency) maxFrequency = freq;
+  }
+  const mode = [];
+  for (const [value, freq] of frequencyMap.entries()) {
+    if (freq === maxFrequency) mode.push(value);
+  }
+  mode.sort((a, b) => a - b);
+  const min = sorted[0];
+  const max = sorted[sorted.length - 1];
+  const range = max - min;
+  const variance = numbers.reduce((acc, n) => acc + Math.pow(n - mean, 2), 0) / count;
+  const standardDeviation = Math.sqrt(variance);
+  const percentiles = {
+    p25: getPercentile(sorted, 25),
+    p50: getPercentile(sorted, 50),
+    p75: getPercentile(sorted, 75),
+    p90: getPercentile(sorted, 90),
+    p99: getPercentile(sorted, 99)
+  };
+  return {
+    count,
+    sum,
+    mean,
+    median,
+    mode,
+    min,
+    max,
+    range,
+    standardDeviation,
+    variance,
+    percentiles
+  };
+}
+
+// src/math/format.ts
+function formatNumber(value, options) {
+  const locale = options?.locale ?? "en-US";
+  const formatOptions = {};
+  if (options?.style) {
+    formatOptions.style = options.style;
+  }
+  if (options?.currency) {
+    formatOptions.currency = options.currency;
+  }
+  if (options?.minimumFractionDigits !== void 0) {
+    formatOptions.minimumFractionDigits = options.minimumFractionDigits;
+  }
+  if (options?.maximumFractionDigits !== void 0) {
+    formatOptions.maximumFractionDigits = options.maximumFractionDigits;
+  }
+  return new Intl.NumberFormat(locale, formatOptions).format(value);
+}
+
+// src/math/percentage.ts
+function percentage(value, total) {
+  if (total === 0) {
+    throw new Error("Total cannot be zero");
+  }
+  const pct = value / total * 100;
+  return {
+    value,
+    total,
+    percentage: pct,
+    formatted: `${pct}%`
+  };
+}
+function percentageChange(from, to) {
+  if (from === 0) {
+    throw new Error("Cannot calculate percentage change from zero");
+  }
+  const change = (to - from) / Math.abs(from) * 100;
+  const sign = change >= 0 ? "+" : "";
+  const formatted = `${sign}${change}%`;
+  return {
+    from,
+    to,
+    change,
+    formatted
+  };
+}
+
+// src/color/index.ts
+var color_exports = {};
+__export(color_exports, {
+  blendColors: () => blendColors,
+  colorName: () => colorName,
+  contrastRatio: () => contrastRatio,
+  convertColor: () => convertColor,
+  generatePalette: () => generatePalette,
+  hexToRgb: () => hexToRgb,
+  hslToRgb: () => hslToRgb,
+  parseColor: () => parseColor,
+  rgbToHex: () => rgbToHex,
+  rgbToHsl: () => rgbToHsl
+});
+
+// src/color/parse.ts
+function hexToRgb(hex) {
+  let h = hex.replace(/^#/, "");
+  if (h.length === 3) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  }
+  if (h.length !== 6) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  const num = parseInt(h, 16);
+  if (isNaN(num)) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  return {
+    r: num >> 16 & 255,
+    g: num >> 8 & 255,
+    b: num & 255
+  };
+}
+function hslToRgb(h, s, l) {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+  const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+  const hPrime = h / 60;
+  const x = c * (1 - Math.abs(hPrime % 2 - 1));
+  const m = lNorm - c / 2;
+  let r1 = 0;
+  let g1 = 0;
+  let b1 = 0;
+  if (hPrime >= 0 && hPrime < 1) {
+    r1 = c;
+    g1 = x;
+    b1 = 0;
+  } else if (hPrime >= 1 && hPrime < 2) {
+    r1 = x;
+    g1 = c;
+    b1 = 0;
+  } else if (hPrime >= 2 && hPrime < 3) {
+    r1 = 0;
+    g1 = c;
+    b1 = x;
+  } else if (hPrime >= 3 && hPrime < 4) {
+    r1 = 0;
+    g1 = x;
+    b1 = c;
+  } else if (hPrime >= 4 && hPrime < 5) {
+    r1 = x;
+    g1 = 0;
+    b1 = c;
+  } else if (hPrime >= 5 && hPrime < 6) {
+    r1 = c;
+    g1 = 0;
+    b1 = x;
+  }
+  return {
+    r: Math.round((r1 + m) * 255),
+    g: Math.round((g1 + m) * 255),
+    b: Math.round((b1 + m) * 255)
+  };
+}
+function rgbToHsl(r, g, b) {
+  const rNorm = r / 255;
+  const gNorm = g / 255;
+  const bNorm = b / 255;
+  const max = Math.max(rNorm, gNorm, bNorm);
+  const min = Math.min(rNorm, gNorm, bNorm);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+    if (max === rNorm) {
+      h = ((gNorm - bNorm) / delta + (gNorm < bNorm ? 6 : 0)) * 60;
+    } else if (max === gNorm) {
+      h = ((bNorm - rNorm) / delta + 2) * 60;
+    } else {
+      h = ((rNorm - gNorm) / delta + 4) * 60;
+    }
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (c) => {
+    const hex = Math.max(0, Math.min(255, c)).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+  return "#" + toHex(r) + toHex(g) + toHex(b);
+}
+function parseColor(input) {
+  const trimmed = input.trim().toLowerCase();
+  let rgb3;
+  const hexMatch = trimmed.match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/);
+  if (hexMatch) {
+    rgb3 = hexToRgb(trimmed);
+  } else {
+    const rgbMatch = trimmed.match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/);
+    if (rgbMatch) {
+      rgb3 = {
+        r: Math.min(255, parseInt(rgbMatch[1], 10)),
+        g: Math.min(255, parseInt(rgbMatch[2], 10)),
+        b: Math.min(255, parseInt(rgbMatch[3], 10))
+      };
+    } else {
+      const hslMatch = trimmed.match(/^hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*\)$/);
+      if (hslMatch) {
+        const h = Math.min(360, parseInt(hslMatch[1], 10));
+        const s = Math.min(100, parseInt(hslMatch[2], 10));
+        const l = Math.min(100, parseInt(hslMatch[3], 10));
+        rgb3 = hslToRgb(h, s, l);
+      } else {
+        throw new Error(`Unsupported color format: ${input}`);
+      }
+    }
+  }
+  const hsl = rgbToHsl(rgb3.r, rgb3.g, rgb3.b);
+  const hex = rgbToHex(rgb3.r, rgb3.g, rgb3.b);
+  return {
+    hex,
+    rgb: `rgb(${rgb3.r}, ${rgb3.g}, ${rgb3.b})`,
+    hsl: `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`,
+    values: {
+      rgb: rgb3,
+      hsl
+    }
+  };
+}
+
+// src/color/convert.ts
+function convertColor(input, to) {
+  const result = parseColor(input);
+  switch (to) {
+    case "hex":
+      return result.hex;
+    case "rgb":
+      return result.rgb;
+    case "hsl":
+      return result.hsl;
+    default:
+      throw new Error(`Unsupported target format: ${to}`);
+  }
+}
+
+// src/color/contrast.ts
+function srgbChannel(c) {
+  const normalized = c / 255;
+  return normalized <= 0.03928 ? normalized / 12.92 : Math.pow((normalized + 0.055) / 1.055, 2.4);
+}
+function relativeLuminance(r, g, b) {
+  return 0.2126 * srgbChannel(r) + 0.7152 * srgbChannel(g) + 0.0722 * srgbChannel(b);
+}
+function contrastRatio(color1, color2) {
+  const c1 = parseColor(color1);
+  const c2 = parseColor(color2);
+  const l1 = relativeLuminance(c1.values.rgb.r, c1.values.rgb.g, c1.values.rgb.b);
+  const l2 = relativeLuminance(c2.values.rgb.r, c2.values.rgb.g, c2.values.rgb.b);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  const ratio = (lighter + 0.05) / (darker + 0.05);
+  const roundedRatio = Math.round(ratio * 100) / 100;
+  return {
+    ratio: roundedRatio,
+    formatted: `${roundedRatio.toFixed(2)}:1`,
+    aa: {
+      normal: roundedRatio >= 4.5,
+      large: roundedRatio >= 3
+    },
+    aaa: {
+      normal: roundedRatio >= 7,
+      large: roundedRatio >= 4.5
+    }
+  };
+}
+
+// src/color/palette.ts
+function hslToConversionResult(h, s, l) {
+  const normalizedH = (h % 360 + 360) % 360;
+  const rgb3 = hslToRgb(normalizedH, s, l);
+  const hex = rgbToHex(rgb3.r, rgb3.g, rgb3.b);
+  const hslRecalc = rgbToHsl(rgb3.r, rgb3.g, rgb3.b);
+  return {
+    hex,
+    rgb: `rgb(${rgb3.r}, ${rgb3.g}, ${rgb3.b})`,
+    hsl: `hsl(${hslRecalc.h}, ${hslRecalc.s}%, ${hslRecalc.l}%)`,
+    values: {
+      rgb: rgb3,
+      hsl: hslRecalc
+    }
+  };
+}
+function generatePalette(base, options) {
+  const parsed = parseColor(base);
+  const { h, s, l } = parsed.values.hsl;
+  const count = options.count ?? 5;
+  switch (options.type) {
+    case "complementary": {
+      return [
+        hslToConversionResult(h, s, l),
+        hslToConversionResult(h + 180, s, l)
+      ];
+    }
+    case "analogous": {
+      const results = [];
+      const spread = 30;
+      const step = spread * 2 / (count - 1);
+      for (let i = 0; i < count; i++) {
+        const hue = h - spread + step * i;
+        results.push(hslToConversionResult(hue, s, l));
+      }
+      return results;
+    }
+    case "triadic": {
+      return [
+        hslToConversionResult(h, s, l),
+        hslToConversionResult(h + 120, s, l),
+        hslToConversionResult(h + 240, s, l)
+      ];
+    }
+    case "shades": {
+      const results = [];
+      const minL = 10;
+      const step = (l - minL) / (count - 1);
+      for (let i = 0; i < count; i++) {
+        const lightness = Math.round(l - step * i);
+        results.push(hslToConversionResult(h, s, lightness));
+      }
+      return results;
+    }
+    case "tints": {
+      const results = [];
+      const maxL = 95;
+      const step = (maxL - l) / (count - 1);
+      for (let i = 0; i < count; i++) {
+        const lightness = Math.round(l + step * i);
+        results.push(hslToConversionResult(h, s, lightness));
+      }
+      return results;
+    }
+    default:
+      throw new Error(`Unsupported palette type: ${options.type}`);
+  }
+}
+
+// src/color/blend.ts
+function blendColors(color1, color2, ratio = 0.5) {
+  if (ratio < 0 || ratio > 1) {
+    throw new Error(`Ratio must be between 0 and 1, got: ${ratio}`);
+  }
+  const c1 = parseColor(color1);
+  const c2 = parseColor(color2);
+  const r = Math.round(c1.values.rgb.r * (1 - ratio) + c2.values.rgb.r * ratio);
+  const g = Math.round(c1.values.rgb.g * (1 - ratio) + c2.values.rgb.g * ratio);
+  const b = Math.round(c1.values.rgb.b * (1 - ratio) + c2.values.rgb.b * ratio);
+  const hex = rgbToHex(r, g, b);
+  const hsl = rgbToHsl(r, g, b);
+  return {
+    color: {
+      hex,
+      rgb: `rgb(${r}, ${g}, ${b})`,
+      hsl: `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`,
+      values: {
+        rgb: { r, g, b },
+        hsl
+      }
+    },
+    ratio
+  };
+}
+
+// src/color/name.ts
+var NAMED_COLORS = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  orange: "#FFA500",
+  purple: "#800080",
+  pink: "#FFC0CB",
+  brown: "#A52A2A",
+  gray: "#808080",
+  silver: "#C0C0C0",
+  maroon: "#800000",
+  navy: "#000080",
+  teal: "#008080",
+  olive: "#808000",
+  lime: "#00FF00",
+  aqua: "#00FFFF",
+  coral: "#FF7F50",
+  salmon: "#FA8072",
+  gold: "#FFD700",
+  khaki: "#F0E68C",
+  plum: "#DDA0DD",
+  violet: "#EE82EE",
+  indigo: "#4B0082",
+  beige: "#F5F5DC",
+  ivory: "#FFFFF0",
+  lavender: "#E6E6FA"
+};
+function euclideanDistance(r1, g1, b1, r2, g2, b2) {
+  return Math.sqrt(
+    Math.pow(r1 - r2, 2) + Math.pow(g1 - g2, 2) + Math.pow(b1 - b2, 2)
+  );
+}
+function colorName(input) {
+  const parsed = parseColor(input);
+  const { r, g, b } = parsed.values.rgb;
+  let closestName = "";
+  let closestHex = "";
+  let closestDistance = Infinity;
+  for (const [name, hex] of Object.entries(NAMED_COLORS)) {
+    const namedRgb = hexToRgb(hex);
+    const distance = euclideanDistance(r, g, b, namedRgb.r, namedRgb.g, namedRgb.b);
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      closestName = name;
+      closestHex = hex.toLowerCase();
+    }
+  }
+  return {
+    name: closestName,
+    exact: closestDistance === 0,
+    hex: closestHex
+  };
+}
+
+exports.archive = archive_exports;
+exports.color = color_exports;
+exports.crypto = crypto_exports;
+exports.csv = csv_exports;
+exports.datetime = datetime_exports;
+exports.diff = diff_exports;
+exports.excel = excel_exports;
+exports.image = image_exports;
+exports.json = json_exports;
+exports.markdown = markdown_exports;
+exports.math = math_exports;
+exports.pdf = pdf_exports;
+exports.regex = regex_exports;
+exports.sql = sql_exports;
+exports.text = text_exports;
+exports.xml = xml_exports;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map