@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.1

package/dist/agent/chunks/fields-B0bitgmr.mjs

@@ -0,0 +1,476 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+const OPTION_COLORS = ["gray", "blue", "green", "yellow", "orange", "red", "purple", "pink", "teal", "indigo"];
+function colorAt(index) {
+  return OPTION_COLORS[(index % OPTION_COLORS.length + OPTION_COLORS.length) % OPTION_COLORS.length];
+}
+class FieldValidationError extends Error {
+  constructor(errors) {
+    super(errors.map((e) => e.message).join("; "));
+    this.errors = errors;
+    this.name = "FieldValidationError";
+  }
+}
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PHONE_RE = /^\+?[0-9 ().\-/]{5,25}(\s*(x|ext\.?)\s*\d{1,6})?$/i;
+const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const FILE_REF_RE = /^[A-Za-z0-9_-]{1,80}$/;
+const TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "y", "1", "oui", "on", "x", "✓"]);
+const FALSE_WORDS = /* @__PURE__ */ new Set(["false", "no", "n", "0", "non", "off", ""]);
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (typeof value === "number") return Number.isNaN(value);
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.values(value).every((v) => isEmptyValue(v));
+  return false;
+}
+function isEmptyFieldValue(field, value) {
+  if (field.type === "boolean") return value === void 0 || value === null;
+  if (field.type === "rating") return value === void 0 || value === null || value === 0;
+  return isEmptyValue(value);
+}
+function findOption(field, raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  const s = String(raw).trim();
+  if (!s) return void 0;
+  const options = field.options ?? [];
+  const lower = s.toLowerCase();
+  return options.find((o) => o.id === s) ?? options.find((o) => o.label.toLowerCase() === lower) ?? options.find((o) => o.id.toLowerCase() === lower);
+}
+function optionLabel(field, id) {
+  return findOption(field, id)?.label ?? (id == null ? "" : String(id));
+}
+function splitList(raw) {
+  if (Array.isArray(raw)) return raw.flatMap((v) => v == null ? [] : [String(v).trim()]).filter(Boolean);
+  if (raw === void 0 || raw === null) return [];
+  return String(raw).split(/[,;|\n]/).map((s) => s.trim()).filter(Boolean);
+}
+function parseNumber(raw) {
+  if (typeof raw === "number") return Number.isFinite(raw) ? raw : null;
+  if (typeof raw !== "string") return null;
+  let s = raw.trim().replace(/[\s  ]/g, "").replace(/[€$£¥₹%]|[A-Z]{3}$/gi, "");
+  if (!s) return null;
+  let mult = 1;
+  const suffix = /([kmb])$/i.exec(s);
+  if (suffix) {
+    mult = { k: 1e3, m: 1e6, b: 1e9 }[suffix[1].toLowerCase()];
+    s = s.slice(0, -1);
+  }
+  const lastComma = s.lastIndexOf(",");
+  const lastDot = s.lastIndexOf(".");
+  if (lastComma > -1 && lastDot > -1) {
+    s = lastComma > lastDot ? s.replace(/\./g, "").replace(",", ".") : s.replace(/,/g, "");
+  } else if (lastComma > -1) {
+    s = /,\d{3}$/.test(s) && s.split(",").length >= 2 && !/^0,/.test(s) ? s.replace(/,/g, "") : s.replace(",", ".");
+  }
+  if (!/^[-+]?\d*\.?\d+(e[-+]?\d+)?$/i.test(s)) return null;
+  const n = Number(s) * mult;
+  return Number.isFinite(n) ? n : null;
+}
+function pad(n, w = 2) {
+  return String(n).padStart(w, "0");
+}
+function toIsoDate(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function parseDateValue(raw, opts = {}) {
+  if (raw instanceof Date) return Number.isNaN(raw.getTime()) ? null : toIsoDate(raw);
+  if (typeof raw === "number") return Number.isFinite(raw) ? toIsoDate(new Date(raw)) : null;
+  if (typeof raw !== "string") return null;
+  const s = raw.trim();
+  if (!s) return null;
+  const iso = DATE_RE.exec(s);
+  if (iso) return validYmd(+iso[1], +iso[2], +iso[3]);
+  const slash = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$/.exec(s);
+  if (slash) {
+    let a = +slash[1];
+    let b = +slash[2];
+    let y = +slash[3];
+    if (y < 100) y += 2e3;
+    const dayFirst = a > 12 ? true : b > 12 ? false : opts.dayFirst ?? false;
+    if (!dayFirst) [a, b] = [b, a];
+    return validYmd(y, b, a);
+  }
+  const t = Date.parse(s);
+  if (!Number.isNaN(t)) {
+    const prefix = /^(\d{4})-(\d{2})-(\d{2})T/.exec(s);
+    return prefix ? validYmd(+prefix[1], +prefix[2], +prefix[3]) : toIsoDate(new Date(t));
+  }
+  return null;
+}
+function validYmd(y, m, d) {
+  if (m < 1 || m > 12 || d < 1 || d > 31) return null;
+  const date = new Date(Date.UTC(y, m - 1, d));
+  if (date.getUTCMonth() !== m - 1) return null;
+  return `${String(y).padStart(4, "0")}-${pad(m)}-${pad(d)}`;
+}
+function parseDateTimeValue(raw) {
+  if (raw instanceof Date) return Number.isNaN(raw.getTime()) ? null : raw.getTime();
+  if (typeof raw === "number") return Number.isFinite(raw) ? raw : null;
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const s = raw.trim();
+  if (/^\d{10,13}$/.test(s)) return Number(s) * (s.length === 10 ? 1e3 : 1);
+  const date = parseDateValue(s);
+  const t = Date.parse(DATE_RE.test(s) ? `${s}T00:00:00` : s);
+  if (!Number.isNaN(t)) return t;
+  return date ? Date.parse(`${date}T00:00:00`) : null;
+}
+function dateValueToMs(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const m = DATE_RE.exec(value);
+    if (m) return new Date(+m[1], +m[2] - 1, +m[3]).getTime();
+    const t = Date.parse(value);
+    return Number.isNaN(t) ? null : t;
+  }
+  if (value instanceof Date) return value.getTime();
+  return null;
+}
+function normalizeUrl(raw) {
+  const s = raw.trim();
+  if (!s) return null;
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(s) ? s : `https://${s}`;
+  try {
+    const u = new URL(withScheme);
+    if (!/^https?:$/.test(u.protocol) || !u.hostname.includes(".")) return null;
+    return withScheme.replace(/\/+$/, "") === `${u.protocol}//${u.host}` ? `${u.protocol}//${u.host}` : u.href.replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function normalizeDomain(raw) {
+  if (typeof raw !== "string") return "";
+  let s = raw.trim().toLowerCase();
+  if (!s) return "";
+  s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//, "").replace(/^www\./, "");
+  s = s.split(/[/?#]/)[0].split("@").pop() ?? "";
+  return s.replace(/:\d+$/, "").replace(/\.$/, "");
+}
+function normalizeEmail(raw) {
+  return typeof raw === "string" ? raw.trim().toLowerCase() : "";
+}
+const fail = (code, message) => ({ ok: false, code, message });
+const ok = (value) => ({ ok: true, value });
+function coerceFieldValue(field, raw, opts = {}) {
+  if (field.type !== "boolean" && (raw === void 0 || raw === null || typeof raw === "string" && raw.trim() === "" || Array.isArray(raw) && raw.length === 0)) {
+    return ok(void 0);
+  }
+  const label = field.label;
+  switch (field.type) {
+    case "text":
+    case "longText": {
+      if (typeof raw === "object") return fail("invalidText", `${label}: expected text.`);
+      const s = String(raw);
+      return ok(field.type === "text" ? s.trim() : s);
+    }
+    case "email": {
+      const s = normalizeEmail(String(raw));
+      return EMAIL_RE.test(s) ? ok(s) : fail("invalidEmail", `${label}: "${raw}" is not a valid email address.`);
+    }
+    case "phone": {
+      const s = String(raw).trim();
+      return PHONE_RE.test(s) ? ok(s) : fail("invalidPhone", `${label}: "${raw}" is not a valid phone number.`);
+    }
+    case "url": {
+      const s = normalizeUrl(String(raw));
+      return s ? ok(s) : fail("invalidUrl", `${label}: "${raw}" is not a valid URL.`);
+    }
+    case "number":
+    case "currency":
+    case "percent": {
+      const n = parseNumber(raw);
+      if (n === null) return fail("invalidNumber", `${label}: "${raw}" is not a number.`);
+      if (field.type === "percent" && typeof raw === "number" && raw > 0 && raw < 1 && !Number.isInteger(raw)) {
+        return ok(Math.round(raw * 1e4) / 100);
+      }
+      return ok(n);
+    }
+    case "rating": {
+      const n = parseNumber(raw);
+      if (n === null) return fail("invalidNumber", `${label}: "${raw}" is not a rating.`);
+      const r = Math.round(n);
+      if (r === 0) return ok(void 0);
+      return r >= 1 && r <= 5 ? ok(r) : fail("outOfRange", `${label}: rating must be between 1 and 5.`);
+    }
+    case "date": {
+      const d = parseDateValue(raw, opts);
+      return d ? ok(d) : fail("invalidDate", `${label}: "${raw}" is not a valid date.`);
+    }
+    case "datetime": {
+      const t = parseDateTimeValue(raw);
+      return t !== null ? ok(t) : fail("invalidDate", `${label}: "${raw}" is not a valid date/time.`);
+    }
+    case "boolean": {
+      if (raw === void 0 || raw === null) return ok(void 0);
+      if (typeof raw === "boolean") return ok(raw);
+      if (typeof raw === "number") return ok(raw !== 0);
+      const s = String(raw).trim().toLowerCase();
+      if (TRUE_WORDS.has(s)) return ok(true);
+      if (FALSE_WORDS.has(s)) return s === "" ? ok(void 0) : ok(false);
+      return fail("invalidBoolean", `${label}: "${raw}" is not yes/no.`);
+    }
+    case "select": {
+      const value = Array.isArray(raw) ? raw[0] : raw;
+      const opt = findOption(field, value);
+      if (opt) return ok(opt.id);
+      if (opts.unknownOptions === "keep") return ok(String(value).trim());
+      return fail("unknownOption", `${label}: "${value}" is not one of ${(field.options ?? []).map((o) => o.label).join(", ") || "(no options)"}.`);
+    }
+    case "multiSelect": {
+      const out = [];
+      for (const part of splitList(raw)) {
+        const opt = findOption(field, part);
+        if (opt) {
+          if (!out.includes(opt.id)) out.push(opt.id);
+        } else if (opts.unknownOptions === "keep") {
+          if (!out.includes(part)) out.push(part);
+        } else {
+          return fail("unknownOption", `${label}: "${part}" is not one of ${(field.options ?? []).map((o) => o.label).join(", ")}.`);
+        }
+      }
+      return ok(out.length ? out : void 0);
+    }
+    case "tags": {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const t of splitList(raw)) {
+        const key = t.toLowerCase();
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push(t);
+        }
+      }
+      return ok(out.length ? out : void 0);
+    }
+    case "relation": {
+      const many = field.relation?.cardinality === "many";
+      const ids = splitList(raw);
+      if (ids.some((id) => !/^[\w-]{1,64}$/.test(id))) return fail("invalidRelation", `${label}: expected record id(s).`);
+      if (many) return ok(ids.length ? [...new Set(ids)] : void 0);
+      if (ids.length > 1) return fail("invalidRelation", `${label}: only one record can be linked.`);
+      return ok(ids[0]);
+    }
+    case "user": {
+      const value = Array.isArray(raw) ? raw[0] : raw;
+      const s = String(value).trim();
+      return /^[\w@.+-]{1,128}$/.test(s) ? ok(s) : fail("invalidUser", `${label}: expected a user id.`);
+    }
+    case "image": {
+      const value = Array.isArray(raw) ? raw[0] : raw;
+      const s = String(value ?? "").trim();
+      return FILE_REF_RE.test(s) ? ok(s) : fail("invalidFile", `${label}: expected a file id (upload the image first).`);
+    }
+    case "files": {
+      const ids = splitList(raw);
+      if (ids.some((id) => !FILE_REF_RE.test(id))) return fail("invalidFile", `${label}: expected file id(s) (upload the files first).`);
+      return ok(ids.length ? [...new Set(ids)] : void 0);
+    }
+    case "address": {
+      if (typeof raw === "string") return ok({ street: raw.trim() });
+      if (typeof raw !== "object" || Array.isArray(raw)) return fail("invalidAddress", `${label}: expected an address.`);
+      const src = raw;
+      const out = {};
+      for (const k of ["street", "city", "postalCode", "region", "country"]) {
+        const v = src[k];
+        if (v !== void 0 && v !== null && String(v).trim()) out[k] = String(v).trim();
+      }
+      return ok(Object.keys(out).length ? out : void 0);
+    }
+  }
+}
+function validateRecordFields(object, input, opts = {}) {
+  const byId = new Map(object.fields.map((f) => [f.id, f]));
+  const values = {};
+  const errors = [];
+  for (const [key, raw] of Object.entries(input)) {
+    const field = byId.get(key);
+    if (!field) {
+      if (opts.unknownFields !== "drop") errors.push({ field: key, code: "unknownField", message: `Unknown field "${key}" on ${object.labelPlural}.` });
+      continue;
+    }
+    const res = coerceFieldValue(field, raw, opts);
+    if (!res.ok) errors.push({ field: key, code: res.code, message: res.message });
+    else values[key] = res.value;
+  }
+  for (const field of object.fields) {
+    if (!field.required) continue;
+    const provided = Object.prototype.hasOwnProperty.call(input, field.id);
+    if (opts.partial && !provided) continue;
+    if (isEmptyFieldValue(field, values[field.id]) && !errors.some((e) => e.field === field.id)) {
+      errors.push({ field: field.id, code: "required", message: `${field.label} is required.` });
+    }
+  }
+  return { ok: errors.length === 0, values, errors };
+}
+function defaultFieldValues(object) {
+  const out = {};
+  for (const f of object.fields) {
+    if (f.defaultValue === void 0) continue;
+    const res = coerceFieldValue(f, f.defaultValue);
+    if (res.ok && res.value !== void 0) out[f.id] = res.value;
+  }
+  return out;
+}
+function formatNumber(n, locale = "en-US", opts = {}) {
+  try {
+    return new Intl.NumberFormat(locale, { maximumFractionDigits: 2, ...opts }).format(n);
+  } catch {
+    return String(n);
+  }
+}
+function formatCurrency(n, currency = "USD", locale = "en-US", compact = false) {
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      maximumFractionDigits: compact || Number.isInteger(n) ? 0 : 2,
+      ...compact ? { notation: "compact" } : {}
+    }).format(n);
+  } catch {
+    return `${formatNumber(n, locale)} ${currency}`;
+  }
+}
+function formatAddress(a) {
+  if (!a || typeof a !== "object") return "";
+  const cityLine = [a.postalCode, a.city].filter(Boolean).join(" ");
+  return [a.street, cityLine, a.region, a.country].filter(Boolean).join(", ");
+}
+function formatFieldValue(field, value, ctx = {}) {
+  if (isEmptyFieldValue(field, value)) return "";
+  const locale = ctx.locale ?? "en-US";
+  switch (field.type) {
+    case "number":
+      return typeof value === "number" ? formatNumber(value, locale) : String(value);
+    case "currency":
+      return typeof value === "number" ? formatCurrency(value, field.currency ?? ctx.currency ?? "USD", locale) : String(value);
+    case "percent":
+      return typeof value === "number" ? `${formatNumber(value, locale)} %`.replace(" %", locale.startsWith("en") ? "%" : " %") : String(value);
+    case "rating":
+      return "★".repeat(Number(value) || 0);
+    case "date": {
+      const ms = dateValueToMs(value);
+      return ms === null ? String(value) : new Intl.DateTimeFormat(locale, { year: "numeric", month: "short", day: "numeric" }).format(ms);
+    }
+    case "datetime": {
+      const ms = dateValueToMs(value);
+      return ms === null ? String(value) : new Intl.DateTimeFormat(locale, { year: "numeric", month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" }).format(ms);
+    }
+    case "boolean":
+      return value ? "Yes" : "No";
+    case "select":
+      return optionLabel(field, value);
+    case "multiSelect":
+      return (Array.isArray(value) ? value : [value]).map((v) => optionLabel(field, v)).join(", ");
+    case "tags":
+      return (Array.isArray(value) ? value : [value]).map(String).join(", ");
+    case "relation": {
+      const ids = Array.isArray(value) ? value : [value];
+      const target = field.relation?.object ?? "";
+      return ids.map((id) => ctx.recordLabel?.(target, String(id)) ?? String(id)).join(", ");
+    }
+    case "user":
+      return ctx.userName?.(String(value)) ?? String(value);
+    case "address":
+      return formatAddress(value);
+    case "image":
+    case "files":
+      return (Array.isArray(value) ? value : [value]).map((id) => ctx.fileName?.(String(id)) ?? String(id)).join(", ");
+    default:
+      return String(value);
+  }
+}
+function comparableValue(field, value, ctx = {}) {
+  if (value === void 0 || value === null || value === "") return null;
+  if (!field) return typeof value === "number" ? value : String(value).toLowerCase();
+  switch (field.type) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "rating":
+      return typeof value === "number" ? value : parseNumber(value);
+    case "date":
+    case "datetime":
+      return dateValueToMs(value);
+    case "boolean":
+      return value ? 1 : 0;
+    case "select": {
+      const idx = (field.options ?? []).findIndex((o) => o.id === value);
+      return idx === -1 ? String(value).toLowerCase() : idx;
+    }
+    default: {
+      const text = formatFieldValue(field, value, ctx);
+      return text ? text.toLowerCase() : null;
+    }
+  }
+}
+function getField(object, fieldId) {
+  return object.fields.find((f) => f.id === fieldId);
+}
+function recordLabel(object, record) {
+  if (!object) return record.id;
+  const primary = record.fields[object.labelField];
+  if (typeof primary === "string" && primary.trim()) return primary.trim();
+  const first = record.fields.firstName;
+  const last = record.fields.lastName;
+  const full = [first, last].filter((v) => typeof v === "string" && v.trim()).join(" ");
+  if (full) return full;
+  for (const key of ["email", "domain", "title", "subject"]) {
+    const v = record.fields[key];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return `${object.labelSingular} ${record.id.slice(-4)}`;
+}
+function canConvertType(from, to) {
+  if (from === to) return true;
+  if (from === "relation" || to === "relation") return false;
+  const fileTypes = ["image", "files"];
+  if (fileTypes.includes(from) || fileTypes.includes(to)) return fileTypes.includes(from) && fileTypes.includes(to);
+  return true;
+}
+function convertValue(from, to, value) {
+  if (isEmptyFieldValue(from, value)) return void 0;
+  if (from.type === to.type && from.type !== "select" && from.type !== "multiSelect") return value;
+  let human = value;
+  if (from.type === "select") human = optionLabel(from, value);
+  else if (from.type === "multiSelect") human = (Array.isArray(value) ? value : [value]).map((v) => optionLabel(from, v));
+  else if (from.type === "address") human = formatAddress(value);
+  else if (from.type === "datetime" && to.type === "date") human = typeof value === "number" ? toIsoDate(new Date(value)) : value;
+  else if (from.type === "boolean" && (to.type === "text" || to.type === "longText")) human = value ? "Yes" : "No";
+  if (to.type === "select" && Array.isArray(human)) human = human[0];
+  const res = coerceFieldValue(to, human, { unknownOptions: "fail" });
+  return res.ok ? res.value : void 0;
+}
+export {
+  FieldValidationError,
+  OPTION_COLORS,
+  canConvertType,
+  coerceFieldValue,
+  colorAt,
+  comparableValue,
+  convertValue,
+  dateValueToMs,
+  defaultFieldValues,
+  findOption,
+  formatAddress,
+  formatCurrency,
+  formatFieldValue,
+  formatNumber,
+  getField,
+  isEmptyFieldValue,
+  isEmptyValue,
+  normalizeDomain,
+  normalizeEmail,
+  normalizeUrl,
+  optionLabel,
+  parseDateTimeValue,
+  parseDateValue,
+  parseNumber,
+  recordLabel,
+  toIsoDate,
+  validateRecordFields
+};

package/dist/agent/chunks/files-CjsPJSR6.mjs

@@ -0,0 +1,158 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+const DEFAULT_MAX_UPLOAD_MB = 25;
+const IMAGE_MAX_DIMENSION = 2560;
+const IMAGE_QUALITY = 0.85;
+const THUMB_SIZE = 320;
+const THUMB_SUFFIX = "_t";
+const thumbIdOf = (id) => `${id}${THUMB_SUFFIX}`;
+const MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  heic: "image/heic",
+  bmp: "image/bmp",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  json: "application/json",
+  html: "text/html",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odt: "application/vnd.oasis.opendocument.text",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  rtf: "application/rtf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  eml: "message/rfc822",
+  ics: "text/calendar",
+  vcf: "text/vcard"
+};
+function extensionOf(name) {
+  const m = /\.([A-Za-z0-9]{1,8})$/.exec(name.trim());
+  return m ? m[1].toLowerCase() : "";
+}
+function guessMime(name, given) {
+  const g = (given ?? "").split(";")[0].trim().toLowerCase();
+  if (g && g !== "application/octet-stream") return g;
+  return MIME_BY_EXT[extensionOf(name)] ?? "application/octet-stream";
+}
+function isImageMime(mime) {
+  return /^image\/(png|jpe?g|gif|webp|avif|bmp|svg\+xml)$/.test(mime);
+}
+function isResizableImage(mime) {
+  return /^image\/(png|jpe?g|webp|bmp|avif)$/.test(mime);
+}
+function fileKind(mime, name = "") {
+  const m = guessMime(name, mime);
+  if (isImageMime(m)) return "image";
+  if (m === "application/pdf") return "pdf";
+  if (/spreadsheet|excel|csv/.test(m)) return "spreadsheet";
+  if (/presentation|powerpoint/.test(m)) return "presentation";
+  if (/wordprocessing|msword|opendocument\.text|rtf/.test(m)) return "document";
+  if (/zip|gzip|tar|compressed|7z|rar/.test(m)) return "archive";
+  if (m.startsWith("audio/")) return "audio";
+  if (m.startsWith("video/")) return "video";
+  if (m.startsWith("text/") || m === "application/json" || m === "message/rfc822") return "text";
+  return "other";
+}
+function isPreviewable(mime) {
+  return /^image\/(png|jpe?g|gif|webp|avif|bmp)$/.test(mime) || mime === "application/pdf" || mime === "text/plain" || mime.startsWith("video/") || mime.startsWith("audio/");
+}
+function formatBytes(n, locale = "en-US") {
+  if (!Number.isFinite(n) || n < 0) return "";
+  const units = ["B", "KB", "MB", "GB"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  const digits = i === 0 || v >= 100 ? 0 : 1;
+  return `${new Intl.NumberFormat(locale, { maximumFractionDigits: digits }).format(v)} ${units[i]}`;
+}
+function sanitizeFileName(name) {
+  const base = String(name ?? "").split(/[\\/]/).pop() ?? "";
+  const clean = base.replace(/[\u0000-\u001f\u007f<>:"|?*]/g, "").replace(/\s+/g, " ").trim().slice(0, 200);
+  return clean || "file";
+}
+async function sha256Hex(bytes) {
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fileImageMarkdown(name, id) {
+  return `![${name.replace(/[[\]]/g, "")}](file:${id})`;
+}
+function inlineFileIds(markdown) {
+  const out = [];
+  for (const m of (markdown ?? "").matchAll(/\]\(file:([A-Za-z0-9_-]{1,80})\)/g)) if (!out.includes(m[1])) out.push(m[1]);
+  return out;
+}
+function imageDimensions(bytes) {
+  const b = bytes;
+  const u16be = (i) => b[i] << 8 | b[i + 1];
+  const u16le = (i) => b[i] | b[i + 1] << 8;
+  const u32be = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+  if (b.length > 24 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return { width: u32be(16), height: u32be(20) };
+  if (b.length > 10 && b[0] === 71 && b[1] === 73 && b[2] === 70) return { width: u16le(6), height: u16le(8) };
+  if (b.length > 30 && String.fromCharCode(...b.slice(0, 4)) === "RIFF" && String.fromCharCode(...b.slice(8, 12)) === "WEBP") {
+    const kind = String.fromCharCode(...b.slice(12, 16));
+    if (kind === "VP8X") return { width: 1 + (b[24] | b[25] << 8 | b[26] << 16), height: 1 + (b[27] | b[28] << 8 | b[29] << 16) };
+    if (kind === "VP8 ") return { width: u16le(26) & 16383, height: u16le(28) & 16383 };
+    if (kind === "VP8L") {
+      const bits = b[21] | b[22] << 8 | b[23] << 16 | b[24] << 24;
+      return { width: (bits & 16383) + 1, height: (bits >> 14 & 16383) + 1 };
+    }
+  }
+  if (b.length > 4 && b[0] === 255 && b[1] === 216) {
+    let i = 2;
+    while (i + 9 < b.length) {
+      if (b[i] !== 255) return null;
+      const marker = b[i + 1];
+      const len = u16be(i + 2);
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return { width: u16be(i + 7), height: u16be(i + 5) };
+      i += 2 + len;
+    }
+  }
+  return null;
+}
+export {
+  DEFAULT_MAX_UPLOAD_MB,
+  IMAGE_MAX_DIMENSION,
+  IMAGE_QUALITY,
+  THUMB_SIZE,
+  THUMB_SUFFIX,
+  extensionOf,
+  fileImageMarkdown,
+  fileKind,
+  formatBytes,
+  guessMime,
+  imageDimensions,
+  inlineFileIds,
+  isImageMime,
+  isPreviewable,
+  isResizableImage,
+  sanitizeFileName,
+  sha256Hex,
+  thumbIdOf
+};