@scaleflex/dam-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1189 @@
+const N = "https://api.filerobot.com";
+function B(s) {
+  return s === 404 || s === 408 || s === 429 || s >= 500;
+}
+const G = (s) => new Promise((e) => setTimeout(e, s));
+function M(s, e) {
+  return `${(e || N).replace(/\/+$/, "")}/${s}`;
+}
+async function W(s, e, t, i = {}) {
+  const r = `${M(s, t)}/key/${encodeURIComponent(e)}`, o = i.retries ?? 2, l = i.retryDelayMs ?? 400;
+  let a = new Error("SASS key exchange failed");
+  for (let c = 0; c <= o; c++) {
+    c > 0 && await G(l * c);
+    const h = new AbortController(), f = setTimeout(() => h.abort(), 3e4);
+    try {
+      const d = await fetch(r, { signal: h.signal, cache: "no-store" });
+      if (clearTimeout(f), !d.ok) {
+        if (a = new Error(`SASS key exchange failed (HTTP ${d.status})`), B(d.status) && c < o) continue;
+        throw a;
+      }
+      const u = await d.json();
+      if (u.status === "error")
+        throw new Error(`SASS key exchange failed: ${u.msg || "Unknown error"}`);
+      return u.key;
+    } catch (d) {
+      if (clearTimeout(f), d instanceof DOMException && d.name === "AbortError")
+        throw new Error("SASS key exchange timed out");
+      if (d instanceof TypeError && c < o) {
+        a = d;
+        continue;
+      }
+      throw d;
+    }
+  }
+  throw a;
+}
+function T(s, e) {
+  const t = {};
+  switch (s.mode) {
+    case "security-template":
+      if (!e)
+        throw new Error(
+          "[dam-core] Cannot build auth headers for security-template mode: SASS key exchange has not been performed. Call resolveAuth() first, or use sass-key mode."
+        );
+      t["X-Filerobot-Key"] = e;
+      break;
+    case "sass-key":
+      t["X-Filerobot-Key"] = s.sassKey;
+      break;
+  }
+  return s.airboxPuid && (t["X-Filerobot-Airbox-Puid"] = s.airboxPuid), t;
+}
+function X(s) {
+  return s.mode === "securityTemplate" || s.mode === "sassKey";
+}
+function V(s) {
+  return X(s) ? s.mode === "securityTemplate" ? {
+    mode: "security-template",
+    container: s.projectToken,
+    securityTemplateId: s.securityTemplateKey,
+    airboxPuid: s.airboxPuid
+  } : {
+    mode: "sass-key",
+    container: s.projectToken,
+    sassKey: s.sassKey,
+    airboxPuid: s.airboxPuid
+  } : s;
+}
+async function I(s, e) {
+  const t = V(s), i = M(t.container, e);
+  if (t.mode === "security-template") {
+    const r = await W(t.container, t.securityTemplateId, e);
+    return { apiBase: i, headers: T(t, r), sassKey: r };
+  }
+  return { apiBase: i, headers: T(t) };
+}
+const H = 3e4;
+class O {
+  constructor(e, t, i) {
+    this.baseUrl = `${e.apiBase}/v5`, this.headers = e.headers, this.auth = t, this.apiDomain = i;
+  }
+  /** Resolve an AuthConfig (performing key exchange if needed) and build a client. */
+  static async create(e, t) {
+    const i = await I(e, t);
+    return new O(i, e, t);
+  }
+  get(e, t) {
+    const i = new URL(`${this.baseUrl}${e}`);
+    if (t)
+      for (const [r, o] of Object.entries(t))
+        o != null && i.searchParams.set(r, Array.isArray(o) ? o.join(",") : String(o));
+    return this.send(i, { method: "GET" });
+  }
+  post(e, t) {
+    return this.sendJson("POST", e, t);
+  }
+  put(e, t) {
+    return this.sendJson("PUT", e, t);
+  }
+  delete(e, t) {
+    return this.sendJson("DELETE", e, t);
+  }
+  /**
+   * Absolute REST URL (incl. the `/v5` base) for a path — for building direct
+   * browser-download links (e.g. the archive ZIP) that bypass `fetch`.
+   */
+  absoluteUrl(e) {
+    return `${this.baseUrl}${e}`;
+  }
+  /** The Filerobot key (`X-Filerobot-Key`), for query-param auth on direct downloads. */
+  get authKey() {
+    return this.headers["X-Filerobot-Key"];
+  }
+  sendJson(e, t, i) {
+    return this.send(new URL(`${this.baseUrl}${t}`), {
+      method: e,
+      headers: { "Content-Type": "application/json" },
+      body: i === void 0 ? void 0 : JSON.stringify(i)
+    });
+  }
+  async send(e, t, i = !1) {
+    var l;
+    const r = new AbortController(), o = setTimeout(() => r.abort(), H);
+    try {
+      const a = await fetch(e.toString(), {
+        ...t,
+        headers: { ...this.headers, ...t.headers },
+        signal: r.signal
+      });
+      if (clearTimeout(o), a.status === 401 && !i && ((l = this.auth) == null ? void 0 : l.mode) === "security-template") {
+        const f = await I(this.auth, this.apiDomain);
+        return this.headers = f.headers, this.send(e, t, !0);
+      }
+      if (!a.ok) {
+        let f = `API error: ${a.status} ${a.statusText}`;
+        try {
+          const d = await a.json();
+          d != null && d.msg && (f = `API error: ${a.status} - ${d.msg}`);
+        } catch {
+        }
+        throw new Error(f);
+      }
+      if (a.status === 204) return;
+      const c = await a.text();
+      if (!c) return;
+      const h = JSON.parse(c);
+      if ((h == null ? void 0 : h.status) === "error")
+        throw new Error(`API error: ${h.msg || "Unknown error"}`);
+      return h;
+    } catch (a) {
+      throw clearTimeout(o), a instanceof DOMException && a.name === "AbortError" ? new Error("API request timed out") : a;
+    }
+  }
+}
+function J(s) {
+  const e = s.path ?? s.name, t = e.replace(/\/[^/]*$/, "") || "/";
+  return {
+    uuid: s.uuid,
+    name: s.name.split("/").pop() || s.name,
+    path: e,
+    parentPath: t,
+    createdAt: s.created_at,
+    modifiedAt: s.modified_at
+  };
+}
+async function b(s, e = {}) {
+  const t = e.sortBy ?? "name", i = e.sortDirection ?? "asc";
+  return ((await s.get("/folders", {
+    folder: e.folderPath ?? "/",
+    recursive: e.recursive ?? 0,
+    limit: e.limit ?? 1e3,
+    offset: e.offset ?? 0,
+    q: e.q,
+    sort: `${t}:${i}`
+  })).folders ?? []).map(J);
+}
+async function K(s, e, t) {
+  const i = t.replace(/\/+$/, ""), r = i ? `${i}/${e}` : `/${e}`, o = await s.post("/folders", { name: r });
+  if (o.status !== "success") throw new Error(o.msg || "Failed to create folder");
+}
+async function Y(s, e, t) {
+  const i = await s.put(`/folder/${encodeURIComponent(e)}/name`, {
+    name: t
+  });
+  if ((i == null ? void 0 : i.status) === "error") throw new Error(i.msg || "Failed to rename folder");
+}
+async function Z(s, e) {
+  const t = await s.delete("/folders", { folders_uuids: e });
+  if ((t == null ? void 0 : t.status) === "error") throw new Error(t.msg || "Failed to delete folders");
+}
+async function Q(s, e, t) {
+  const i = await s.post("/folders", {
+    folders_uuids: e,
+    new_folder_name: t
+  });
+  if ((i == null ? void 0 : i.status) === "error") throw new Error(i.msg || "Failed to move folders");
+}
+const R = {
+  small: [null, 1048576],
+  // < 1 MB
+  medium: [1048576, 10485760],
+  // 1–10 MB
+  large: [10485760, 104857600],
+  // 10–100 MB
+  huge: [104857600, null]
+  // > 100 MB
+}, ee = {
+  today: 0,
+  week: 7,
+  month: 30,
+  year: 365
+};
+function y(s, e) {
+  const t = new Date(e);
+  return t.setUTCHours(0, 0, 0, 0), t.setUTCDate(t.getUTCDate() - ee[s]), t;
+}
+const L = ["cdn_permalink"], F = {}, m = (s, e) => e.split(" ").forEach((t) => F[t] = s);
+m("image", "jpg jpeg png gif webp svg avif bmp tif tiff heic ico");
+m("video", "mp4 webm mov m4v avi mkv ogv");
+m("audio", "mp3 wav ogg oga m4a aac flac");
+m("document", "pdf doc docx xls xlsx ppt pptx txt csv rtf md");
+m("model", "glb gltf obj fbx stl usdz ply 3ds dae");
+function te(s) {
+  const e = (s.name.split(".").pop() || "").toLowerCase();
+  if (F[e] === "model") return "model";
+  const t = (s.file_type || s.type || "").toLowerCase();
+  return t.startsWith("image") ? "image" : t.startsWith("video") ? "video" : t.startsWith("audio") ? "audio" : t.includes("pdf") || t.includes("document") || t.includes("text") ? "document" : F[e] ?? "other";
+}
+function z(s) {
+  var e, t, i, r, o;
+  return {
+    uuid: s.uuid,
+    name: s.name,
+    folder: s.folder ?? "/",
+    type: te(s),
+    fileType: s.file_type ?? s.type,
+    cdnUrl: s.cdn_permalink ?? s.cdn_url,
+    thumbnailUrl: ((e = s.info) == null ? void 0 : e.video_thumbnail) ?? ((t = s.info) == null ? void 0 : t.image_thumbnail) ?? ((i = s.info) == null ? void 0 : i.thumbnail) ?? ((r = s.info) == null ? void 0 : r.preview),
+    // Live API returns `size: { bytes, pretty }`; tolerate a plain number too.
+    size: typeof s.size == "object" ? (o = s.size) == null ? void 0 : o.bytes : s.size,
+    width: s.width,
+    height: s.height,
+    createdAt: s.created_at,
+    modifiedAt: s.modified_at
+  };
+}
+function se(s) {
+  var l;
+  const e = s.fields ?? L, t = s.sortBy ?? "created_at", i = s.sortDirection ?? "desc", r = [];
+  if (s.search && r.push(s.search), s.q && r.push(s.q), (l = s.types) != null && l.length && r.push(`type:${s.types.map((a) => `"${a}"`).join(",")}`), s.sizeBucket) {
+    const [a, c] = R[s.sizeBucket];
+    r.push(`size:"${a ?? ""}..${c ?? ""}"`);
+  }
+  const o = Date.now();
+  return s.createdWithin && r.push(`created>"${y(s.createdWithin, o).toISOString()}"`), s.updatedWithin && r.push(`updated>"${y(s.updatedWithin, o).toISOString()}"`), {
+    offset: s.offset ?? 0,
+    limit: s.limit ?? 100,
+    format: "json,regvar:api,select:internal",
+    preview: 2301,
+    // Filerobot preview-size preset for thumbnails
+    recursive: s.recursive ?? 1,
+    fields: e.length ? e : void 0,
+    sort: `${t}:${i}`,
+    folder: s.folder,
+    q: r.length ? r.join(" ") : void 0
+  };
+}
+async function w(s, e = {}) {
+  const t = se(e), i = await s.get("/files", t), r = (i.files ?? []).map(z), o = typeof i.total == "number" ? i.total : i.count ?? r.length;
+  return { assets: r, total: o };
+}
+async function $e(s, e = {}) {
+  return (await w(s, e)).assets;
+}
+const ie = {
+  image: "image",
+  video: "video",
+  audio: "audio",
+  document: "document",
+  model: "other",
+  // no dedicated 'model' facet — folds into "Other"
+  archive: "other",
+  font: "other",
+  other: "other"
+};
+function re(s, e, t) {
+  var i;
+  if ((i = e.types) != null && i.length && !e.types.includes(ie[s.type])) return !1;
+  if (e.sizeBucket) {
+    const [r, o] = R[e.sizeBucket];
+    if (s.size == null || r != null && s.size < r || o != null && s.size >= o) return !1;
+  }
+  return !(e.createdWithin && !((s.createdAt ? Date.parse(s.createdAt) : NaN) >= y(e.createdWithin, t).getTime()) || e.updatedWithin && !((s.modifiedAt ? Date.parse(s.modifiedAt) : NaN) >= y(e.updatedWithin, t).getTime()));
+}
+function ne(s, e, t) {
+  const i = t === "asc" ? 1 : -1, r = (o) => {
+    var l;
+    switch (e) {
+      case "name":
+        return ((l = o.name) == null ? void 0 : l.toLowerCase()) ?? "";
+      case "size":
+        return o.size ?? 0;
+      case "type":
+        return o.type;
+      case "modified_at":
+        return o.modifiedAt ? Date.parse(o.modifiedAt) : 0;
+      default:
+        return o.createdAt ? Date.parse(o.createdAt) : 0;
+    }
+  };
+  return [...s].sort((o, l) => {
+    const a = r(o), c = r(l);
+    return a < c ? -i : a > c ? i : 0;
+  });
+}
+async function oe(s, e, t = {}) {
+  const i = t.fields ?? L, r = new Array(e.length);
+  let o = 0;
+  const l = async () => {
+    for (; o < e.length; ) {
+      const c = o++;
+      try {
+        const h = await s.get(`/file/${encodeURIComponent(e[c])}`, {
+          format: "json,regvar:api,select:internal",
+          preview: 2301,
+          fields: i.length ? i : void 0
+        });
+        h != null && h.file && (r[c] = z(h.file));
+      } catch {
+      }
+    }
+  }, a = Math.min(t.concurrency ?? 8, e.length);
+  return await Promise.all(Array.from({ length: a }, l)), r.filter((c) => c !== void 0);
+}
+async function ae(s, e, t) {
+  const i = await s.put(`/file/${encodeURIComponent(e)}/name`, {
+    name: t
+  });
+  if ((i == null ? void 0 : i.status) === "error") throw new Error(i.msg || "Failed to rename file");
+}
+async function ce(s, e) {
+  const t = await s.delete("/files", { files_uuids: e });
+  if ((t == null ? void 0 : t.status) === "error") throw new Error(t.msg || "Failed to delete files");
+}
+async function le(s, e, t) {
+  const i = await s.post("/files", {
+    files_uuids: e,
+    new_folder_name: t
+  });
+  if ((i == null ? void 0 : i.status) === "error") throw new Error(i.msg || "Failed to move files");
+}
+async function de(s) {
+  return (await s.get("/labels")).labels ?? [];
+}
+function he(s) {
+  if (s.sid)
+    return `labels:${s.sid.replace(/^#/, "")}`;
+}
+function $(s, e) {
+  try {
+    const t = new URL(s);
+    return t.searchParams.set("p", e), t.toString();
+  } catch {
+    return s;
+  }
+}
+function x(s) {
+  var e, t, i, r, o;
+  return {
+    uuid: s.uuid,
+    name: s.name,
+    url: s.url,
+    previewUrl: s.preview ?? s.url,
+    width: (e = s.info) == null ? void 0 : e.img_w,
+    height: (t = s.info) == null ? void 0 : t.img_h,
+    size: (i = s.info) == null ? void 0 : i.size,
+    format: (r = s.info) == null ? void 0 : r.img_type,
+    isOriginal: !1,
+    isPreset: !1,
+    bgRemoved: ((o = s.info) == null ? void 0 : o.remove_background) === !0
+  };
+}
+function fe(s) {
+  return {
+    uuid: s.uuid,
+    name: s.name,
+    url: s.cdnUrl ?? "",
+    previewUrl: s.thumbnailUrl ?? s.cdnUrl,
+    width: s.width,
+    height: s.height,
+    size: s.size,
+    format: s.fileType,
+    isOriginal: !0,
+    isPreset: !1,
+    bgRemoved: !1
+  };
+}
+function ue(s, e) {
+  const t = s.cdnUrl ?? "";
+  return {
+    uuid: `preset-${e.name}`,
+    name: e.name,
+    url: $(t, e.name),
+    previewUrl: $(s.thumbnailUrl ?? t, e.name),
+    isOriginal: !1,
+    isPreset: !0,
+    bgRemoved: !1
+  };
+}
+function ve({
+  asset: s,
+  variants: e = [],
+  presets: t = []
+}) {
+  const i = new Set(t.map((a) => a.name)), r = e.filter((a) => {
+    var c;
+    return !i.has(a.name) && ((c = a.info) == null ? void 0 : c.remove_background) !== !0;
+  }).map(x), o = e.filter((a) => {
+    var c;
+    return ((c = a.info) == null ? void 0 : c.remove_background) === !0 && !i.has(a.name);
+  }).map(x), l = t.map((a) => ue(s, a));
+  return [fe(s), ...r, ...o, ...l];
+}
+async function ge(s, e) {
+  const t = await s.get(
+    `/file/${encodeURIComponent(e)}/variants`
+  );
+  return (t == null ? void 0 : t.variants) ?? [];
+}
+function me(s) {
+  return Array.isArray(s) ? s.map(
+    (e) => typeof e == "string" ? { name: e } : e && typeof e.name == "string" ? { name: e.name, desc: e.desc } : null
+  ).filter((e) => e !== null) : [];
+}
+async function pe(s) {
+  var i, r, o;
+  const e = await s.get("/settings"), t = (e == null ? void 0 : e.presets) ?? ((i = e == null ? void 0 : e.cloudimg) == null ? void 0 : i.presets) ?? ((o = (r = e == null ? void 0 : e.settings) == null ? void 0 : r.cloudimg) == null ? void 0 : o.presets) ?? void 0;
+  return me(t);
+}
+async function xe(s, e) {
+  const [t, i] = await Promise.all([
+    ge(s, e.uuid),
+    pe(s)
+  ]);
+  return ve({ asset: e, variants: t, presets: i });
+}
+async function we(s, e) {
+  const t = await s.post("/file-archive", {
+    files_uuids: e.filesUuids ?? [],
+    folders_uuids: e.foldersUuids ?? [],
+    urls: e.urls ?? []
+  });
+  if (!(t != null && t.task_id)) throw new Error("Archive task was not created");
+  return t.task_id;
+}
+function ye(s, e) {
+  return s.get(`/file-archive/${encodeURIComponent(e)}`, {
+    status_only: 1
+  });
+}
+const Se = /* @__PURE__ */ new Set(["PENDING", "RUNNING", "PROCESSING", ""]);
+function be(s) {
+  const e = ((s == null ? void 0 : s.task_status) ?? "").toUpperCase(), t = typeof (s == null ? void 0 : s.task_percent) == "number" ? s.task_percent : 0;
+  if (e === "DONE") return { done: !0, progress: 100 };
+  if (Se.has(e)) return { done: !1, progress: t };
+  throw new Error(`Archive job failed: ${(s == null ? void 0 : s.task_status) ?? "unknown status"}`);
+}
+async function _e(s, e, t = {}) {
+  var f, d;
+  const i = t.intervalMs ?? 1500, r = t.timeoutMs ?? 12e4, o = t.maxRetries ?? 5, l = t.sleep ?? ((u) => new Promise((g) => setTimeout(g, u))), a = t.now ?? Date.now, c = a() + r;
+  let h = 0;
+  for (; ; ) {
+    if ((f = t.signal) != null && f.aborted) throw new Error("Archive polling aborted");
+    if (a() > c) throw new Error("Archive polling timed out");
+    let u;
+    try {
+      u = await ye(s, e);
+    } catch (S) {
+      if (h++ < o) {
+        await l(i);
+        continue;
+      }
+      throw S;
+    }
+    const { done: g, progress: p } = be(u);
+    if ((d = t.onProgress) == null || d.call(t, p), g) return;
+    await l(i);
+  }
+}
+function Ae(s, e) {
+  const t = s.absoluteUrl(`/file-archive/${encodeURIComponent(e)}`), i = s.authKey;
+  if (!i) return t;
+  const r = t.includes("?") ? "&" : "?";
+  return `${t}${r}secret_key=${encodeURIComponent(i)}`;
+}
+async function Ce(s, e, t = {}) {
+  const i = await we(s, e);
+  return await _e(s, i, t), Ae(s, i);
+}
+const Fe = ["cdn_permalink"], q = {
+  created_at: "created_at",
+  modified_at: "modified_at",
+  name: "name",
+  size: "size",
+  type: "type"
+};
+function Pe(s) {
+  const e = s.fields ?? Fe, t = {
+    offset: s.offset ?? 0,
+    limit: s.limit ?? 100,
+    format: "json,regvar:api,select:internal",
+    preview: 2301,
+    recursive: s.recursive ?? 1
+  };
+  e.length > 0 && (t.fields = e);
+  const i = s.sort_by ?? "created_at", r = s.sort_direction ?? "desc";
+  t.sort = `${q[i] || i}:${r}`, s.folder && (t.folder = s.folder);
+  const o = [];
+  return s.search && !s.with_ai && o.push(s.search), s.q && o.push(s.q), o.length > 0 && (t.q = o.join(" ")), s.with_ai && (t.with_ai = !0, s.ai_query && (t.ai_query = s.ai_query), s.ai_lang && (t.ai_lang = s.ai_lang)), s.collection_uuid && (t.collection_uuid = s.collection_uuid), s.f64 && (t.f64 = s.f64), t;
+}
+function Ue(s, e) {
+  return s.get("/files", Pe(e));
+}
+function De(s, e) {
+  const t = { recursive: e.recursive ?? 1 };
+  e.folder && (t.folder = e.folder);
+  const i = [];
+  return e.search && !e.with_ai && i.push(e.search), e.q && i.push(e.q), i.length > 0 && (t.q = i.join(" ")), e.with_ai && (t.with_ai = !0, e.ai_query && (t.ai_query = e.ai_query), e.ai_lang && (t.ai_lang = e.ai_lang)), e.collection_uuid && (t.collection_uuid = e.collection_uuid), e.f64 && (t.f64 = e.f64), s.get("/files/stats", t);
+}
+function ke(s, e = {}) {
+  const t = {
+    recursive: e.recursive ?? 0,
+    folder: e.folderPath ?? "/",
+    limit: e.limit ?? 1e3,
+    offset: e.offset ?? 0
+  };
+  e.q && (t.q = e.q);
+  const i = e.sort_by ?? "created_at", r = e.sort_direction ?? "asc";
+  return t.sort = `${q[i] || i}:${r}`, s.get("/folders", t);
+}
+async function Me(s, e) {
+  return e.length === 0 ? {} : (await s.post("/folders/previews", {
+    folders: e
+  })).folders || {};
+}
+const C = 100, U = 1e3, D = { types: [], size: null, created: null, updated: null };
+class P {
+  constructor(e, t = {}) {
+    this.client = e, this.listeners = /* @__PURE__ */ new Set(), this.loadSeq = 0, this.treeSeq = 0, this.fetchedCount = 0, this.selectionAnchor = null, this.favAdapter = t.favourites, this.onScopeChange = t.onScopeChange, this.state = {
+      scope: { type: "folder", value: t.rootFolder ?? "/" },
+      viewMode: t.viewMode ?? "grid",
+      gridSize: t.gridSize ?? "m",
+      sortBy: t.sortBy ?? "created_at",
+      sortDirection: t.sortDirection ?? "desc",
+      searchQuery: "",
+      filters: { ...D },
+      folders: [],
+      labels: [],
+      assets: [],
+      total: 0,
+      truncated: !1,
+      hasMore: !1,
+      loadingMore: !1,
+      treeChildren: {},
+      expandedFolders: /* @__PURE__ */ new Set(),
+      selection: /* @__PURE__ */ new Set(),
+      favourites: /* @__PURE__ */ new Set(),
+      loading: !1,
+      error: null
+    };
+  }
+  /** Load sidebar metadata (labels, favourites, root folder tree) then the scope. */
+  async init() {
+    await Promise.all([this.loadLabels(), this.loadFavourites(), this.loadFolderChildren("/")]), await this.load();
+  }
+  // ── folder tree (lazy) ──────────────────────────────────────────────────────
+  /** Fetch and cache a folder's children (no-op if already cached). */
+  async loadFolderChildren(e) {
+    if (!this.state.treeChildren[e])
+      try {
+        const t = await b(this.client, { folderPath: e });
+        this.set({ treeChildren: { ...this.state.treeChildren, [e]: t } });
+      } catch {
+      }
+  }
+  /** Expand/collapse a folder node, lazy-loading its children on first expand. */
+  async toggleFolder(e) {
+    const t = new Set(this.state.expandedFolders);
+    t.has(e) ? (t.delete(e), this.set({ expandedFolders: t })) : (await this.loadFolderChildren(e), t.add(e), this.set({ expandedFolders: t }));
+  }
+  async loadLabels() {
+    try {
+      this.set({ labels: await de(this.client) });
+    } catch {
+    }
+  }
+  async loadFavourites() {
+    if (this.favAdapter)
+      try {
+        this.set({ favourites: new Set(await this.favAdapter.list()) });
+      } catch {
+      }
+  }
+  /** Toggle an asset's favourite status (per-user, via the adapter). */
+  async toggleFavourite(e) {
+    const t = this.state.favourites.has(e), i = new Set(this.state.favourites);
+    t ? i.delete(e) : i.add(e), this.set({ favourites: i });
+    try {
+      this.favAdapter && (t ? await this.favAdapter.remove(e) : await this.favAdapter.add(e));
+    } catch {
+      const r = new Set(this.state.favourites);
+      t ? r.add(e) : r.delete(e), this.set({ favourites: r });
+      return;
+    }
+    this.state.scope.type === "favourites" && this.load();
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  set(e) {
+    this.state = { ...this.state, ...e };
+    for (const t of this.listeners) t(this.state);
+  }
+  // ── navigation / scope ─────────────────────────────────────────────────────
+  setScope(e) {
+    var t;
+    this.selectionAnchor = null, this.set({ scope: e, selection: /* @__PURE__ */ new Set() }), (t = this.onScopeChange) == null || t.call(this, e), this.load();
+  }
+  openFolder(e) {
+    this.setScope({ type: "folder", value: e });
+  }
+  openLabel(e) {
+    this.setScope({ type: "label", value: e });
+  }
+  openFavourites() {
+    this.setScope({ type: "favourites" });
+  }
+  // ── view controls ──────────────────────────────────────────────────────────
+  setViewMode(e) {
+    this.set({ viewMode: e });
+  }
+  setGridSize(e) {
+    this.set({ gridSize: e });
+  }
+  setSort(e, t) {
+    this.set({ sortBy: e, sortDirection: t }), this.load();
+  }
+  setSearch(e) {
+    this.set({ searchQuery: e }), this.load();
+  }
+  /** Merge a partial facet patch into the active filters and reload from page 1. */
+  setFilters(e) {
+    this.set({ filters: { ...this.state.filters, ...e } }), this.load();
+  }
+  /** Toggle one file-type in the type facet. Reloads from page 1. */
+  toggleType(e) {
+    const t = this.state.filters.types;
+    this.setFilters({
+      types: t.includes(e) ? t.filter((i) => i !== e) : [...t, e]
+    });
+  }
+  /** Number of active facets across all groups (for the toolbar badge). */
+  get activeFilterCount() {
+    const { types: e, size: t, created: i, updated: r } = this.state.filters;
+    return e.length + (t ? 1 : 0) + (i ? 1 : 0) + (r ? 1 : 0);
+  }
+  /** Clear every facet in one update, then reload. No-op if nothing is active. */
+  clearFilters() {
+    this.activeFilterCount && (this.set({ filters: { ...D } }), this.load());
+  }
+  // ── selection ──────────────────────────────────────────────────────────────
+  toggleSelect(e, t = !1) {
+    const i = new Set(t ? this.state.selection : []), r = !i.has(e);
+    r ? i.add(e) : i.delete(e), r && (this.selectionAnchor = e), this.set({ selection: i });
+  }
+  /**
+   * Shift-click range selection: add every asset between the anchor (the last
+   * individually-selected item) and `uuid` — in the current display order — to
+   * the selection. Additive: existing selections are preserved, and the anchor
+   * stays put so the range can be re-adjusted with another shift-click. With no
+   * anchor yet, behaves like a plain multi-select toggle.
+   */
+  selectRange(e) {
+    const t = this.state.assets, i = t.findIndex((c) => c.uuid === e);
+    if (i < 0) return;
+    const r = this.selectionAnchor != null ? t.findIndex((c) => c.uuid === this.selectionAnchor) : -1;
+    if (r < 0) {
+      this.toggleSelect(e, !0);
+      return;
+    }
+    const [o, l] = r <= i ? [r, i] : [i, r], a = new Set(this.state.selection);
+    for (let c = o; c <= l; c++) a.add(t[c].uuid);
+    this.set({ selection: a });
+  }
+  /** Replace the whole selection in one update (e.g. "select all", marquee drag). */
+  setSelection(e) {
+    const t = new Set(e);
+    let i = null;
+    for (const r of t) i = r;
+    this.selectionAnchor = i, this.set({ selection: t });
+  }
+  clearSelection() {
+    this.selectionAnchor = null, this.set({ selection: /* @__PURE__ */ new Set() });
+  }
+  // ── mutations (light-dam's management layer) ───────────────────────────────
+  // Orchestrated in core so the CRUD lives with dam-core, and every mutation
+  // reloads the current scope. Endpoints verified against js-admin-react-filerobot-v5.
+  /** Path of the folder currently in view (root when not in folder scope). */
+  get currentFolderPath() {
+    return this.state.scope.type === "folder" ? this.state.scope.value ?? "/" : "/";
+  }
+  /**
+   * Folder mutations change the hierarchy — re-fetch the relevant tree nodes
+   * (root, current, expanded) and swap them in atomically. Unlike a blank-then-
+   * refill, this never shows an empty tree, keeps unrelated cached nodes, and a
+   * `treeSeq` guard discards a superseded refresh.
+   */
+  async refreshTree() {
+    const e = ++this.treeSeq, t = /* @__PURE__ */ new Set(["/", this.currentFolderPath, ...this.state.expandedFolders]), i = {};
+    await Promise.all(
+      [...t].map(async (r) => {
+        try {
+          i[r] = await b(this.client, { folderPath: r });
+        } catch {
+        }
+      })
+    ), e === this.treeSeq && this.set({ treeChildren: { ...this.state.treeChildren, ...i } });
+  }
+  static parentOf(e) {
+    return e.replace(/\/[^/]*$/, "") || "/";
+  }
+  /** Public: resolve a cached folder's path by uuid (e.g. for the move picker). */
+  findFolderPath(e) {
+    return this.folderPath(e);
+  }
+  /** Find a cached folder's path by uuid (across the tree cache + current list). */
+  folderPath(e) {
+    for (const t of [this.state.folders, ...Object.values(this.state.treeChildren)]) {
+      const i = t.find((r) => r.uuid === e);
+      if (i) return i.path;
+    }
+  }
+  /**
+   * After a folder is renamed/moved/deleted, keep the user out of a "ghost"
+   * scope: if they're viewing the affected folder (or a descendant), remap the
+   * scope to its new path (or the parent on delete). Returns true if it redirected
+   * (which itself triggers a reload), so the caller can skip its own load().
+   */
+  redirectScope(e, t) {
+    const { scope: i } = this.state;
+    if (i.type !== "folder" || !i.value) return !1;
+    const r = i.value;
+    return r !== e && !r.startsWith(e + "/") ? !1 : (t === null ? this.openFolder(P.parentOf(e)) : this.openFolder(r === e ? t : t + r.slice(e.length)), !0);
+  }
+  async createFolder(e) {
+    await K(this.client, e, this.currentFolderPath), await this.refreshTree(), await this.load();
+  }
+  async renameFolderById(e, t) {
+    const i = this.folderPath(e);
+    await Y(this.client, e, t), await this.refreshTree();
+    const r = i ? `${P.parentOf(i).replace(/\/$/, "")}/${t}` : null;
+    i && r && this.redirectScope(i, r) || await this.load();
+  }
+  async deleteFolderById(e) {
+    const t = this.folderPath(e);
+    await Z(this.client, [e]), await this.refreshTree(), t && this.redirectScope(t, null) || await this.load();
+  }
+  async moveFolderById(e, t) {
+    const i = this.folderPath(e);
+    await Q(this.client, [e], t), await this.refreshTree();
+    const r = (i == null ? void 0 : i.split("/").pop()) ?? "", o = i ? `${t.replace(/\/$/, "")}/${r}` : null;
+    i && o && this.redirectScope(i, o) || await this.load();
+  }
+  async renameAsset(e, t) {
+    await ae(this.client, e, t), await this.load();
+  }
+  async deleteAssets(e) {
+    await ce(this.client, e), this.clearSelection(), await this.load();
+  }
+  async moveAssets(e, t) {
+    await le(this.client, e, t), this.clearSelection(), await this.load();
+  }
+  // ── data loading ───────────────────────────────────────────────────────────
+  /** Translate the active filter facets into the api query shape (undefined = off). */
+  facetParams() {
+    const { types: e, size: t, created: i, updated: r } = this.state.filters;
+    return {
+      types: e.length ? e : void 0,
+      sizeBucket: t ?? void 0,
+      createdWithin: i ?? void 0,
+      updatedWithin: r ?? void 0
+    };
+  }
+  /**
+   * Fetch one page of the current scope's assets starting at server `offset`.
+   *
+   * Folder/label/all are server-paged (offset + PAGE_SIZE) so infinite scroll
+   * appends page by page. Favourites is a known uuid set, so it's fetched
+   * directly by uuid (cheap, bounded by MAX_FAVOURITES) and filtered/sorted in
+   * memory — no whole-library scan — and reports no further pages.
+   *
+   * `fetched` is the raw count returned by the server (before client dedupe), so
+   * the caller advances its offset cursor correctly even when dedupe drops items.
+   */
+  async fetchAssetsPage(e) {
+    const { scope: t, sortBy: i, sortDirection: r } = this.state, o = this.state.searchQuery || void 0, l = this.facetParams();
+    if (t.type === "favourites") {
+      const f = [...this.state.favourites], d = await oe(this.client, f.slice(0, U)), u = Date.now(), g = d.filter((S) => re(S, l, u)), p = ne(g, i, r);
+      return {
+        assets: p,
+        total: p.length,
+        truncated: f.length > U,
+        hasMore: !1,
+        fetched: 0
+      };
+    }
+    const a = { sortBy: i, sortDirection: r, search: o, ...l, offset: e, limit: C };
+    let c;
+    if (t.type === "folder")
+      c = await w(this.client, { ...a, folder: t.value ?? "/", recursive: 0 });
+    else if (t.type === "label") {
+      const f = this.state.labels.find((u) => u.uuid === t.value), d = f ? he(f) : void 0;
+      c = await w(this.client, { ...a, recursive: 1, q: d });
+    } else
+      c = await w(this.client, { ...a, recursive: 1 });
+    const h = c.assets.length === C;
+    return {
+      assets: c.assets,
+      total: c.total,
+      truncated: !1,
+      hasMore: h,
+      fetched: c.assets.length
+    };
+  }
+  /** Reload everything for the current scope from page 1. Stale responses are discarded. */
+  async load() {
+    const e = ++this.loadSeq;
+    this.set({ loading: !0, loadingMore: !1, error: null });
+    try {
+      const t = b(this.client, { folderPath: this.currentFolderPath }), i = this.fetchAssetsPage(0), [r, o] = await Promise.all([t, i]);
+      if (e !== this.loadSeq) return;
+      this.fetchedCount = o.fetched, this.set({
+        folders: r,
+        assets: o.assets,
+        total: o.total,
+        truncated: o.truncated,
+        hasMore: o.hasMore,
+        loading: !1,
+        // keep the tree cache warm for the folder we just listed
+        treeChildren: { ...this.state.treeChildren, [this.currentFolderPath]: r }
+      });
+    } catch (t) {
+      if (e !== this.loadSeq) return;
+      this.set({ error: t instanceof Error ? t.message : String(t), loading: !1 });
+    }
+  }
+  /**
+   * Append the next page of assets for the current scope (infinite scroll).
+   * No-op while already loading, when no more pages exist, or if the scope
+   * changes mid-flight (the `loadSeq` guard discards a stale page).
+   *
+   * Offset comes from `fetchedCount` (raw items fetched), NOT the displayed
+   * length, so dedupe dropping an item never re-requests the same page. Appended
+   * assets are still de-duplicated by uuid so a shifting window can't double a card.
+   */
+  async loadMore() {
+    if (this.state.loading || this.state.loadingMore || !this.state.hasMore) return;
+    const e = this.loadSeq;
+    this.set({ loadingMore: !0 });
+    try {
+      const t = await this.fetchAssetsPage(this.fetchedCount);
+      if (e !== this.loadSeq) return;
+      this.fetchedCount += t.fetched;
+      const i = new Set(this.state.assets.map((o) => o.uuid)), r = t.assets.filter((o) => !i.has(o.uuid));
+      this.set({
+        assets: [...this.state.assets, ...r],
+        total: t.total,
+        hasMore: t.hasMore,
+        loadingMore: !1,
+        error: null
+        // a recovered page clears any prior load-more failure
+      });
+    } catch (t) {
+      if (e !== this.loadSeq) return;
+      this.set({ error: t instanceof Error ? t.message : String(t), loadingMore: !1 });
+    }
+  }
+}
+class Oe {
+  constructor(e = "sfx-light-dam:favourites") {
+    this.key = e;
+  }
+  read() {
+    try {
+      const e = localStorage.getItem(this.key);
+      return new Set(e ? JSON.parse(e) : []);
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  write(e) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify([...e]));
+    } catch {
+    }
+  }
+  list() {
+    return [...this.read()];
+  }
+  has(e) {
+    return this.read().has(e);
+  }
+  add(e) {
+    const t = this.read();
+    t.add(e), this.write(t);
+  }
+  remove(e) {
+    const t = this.read();
+    t.delete(e), this.write(t);
+  }
+}
+function Re(s, e) {
+  const t = new URL(s);
+  return e.width && t.searchParams.set("w", String(e.width)), e.height && t.searchParams.set("h", String(e.height)), e.quality !== void 0 && t.searchParams.set("q", String(e.quality)), t.toString();
+}
+const Le = { excellent: 90, good: 75, fair: 60 }, ze = { fullhd: 1920, large: 1200, medium: 600, small: 300 }, Ee = {
+  webp: "awebp,webp",
+  gif: "agif,gif"
+};
+function j(s, e) {
+  s.searchParams.delete("download"), e.width && s.searchParams.set("w", String(e.width)), e.height && s.searchParams.set("h", String(e.height)), e.quality != null && s.searchParams.set("q", String(e.quality)), e.format && s.searchParams.set("force_format", Ee[e.format] ?? e.format), e.strictSizes !== void 0 && (e.width || e.height) && s.searchParams.set("func", e.strictSizes ? "bound" : "cover");
+}
+function Te(s, e) {
+  if (!e) return s;
+  const t = e === "jpeg" ? "jpg" : e;
+  return `${s.replace(/\.[^./\\]+$/, "") || s}.${t}`;
+}
+function qe(s, e, t = {}) {
+  const i = new URL(s);
+  return j(i, t), i.searchParams.set("force_download", Te(e, t.format)), i.toString();
+}
+function je(s, e = {}) {
+  const t = new URL(s);
+  return j(t, e), t.toString();
+}
+const k = /^(https:\/\/)([a-z0-9_-]+)\.filerobot\.com\//i;
+function _(s) {
+  if (!s) return "";
+  const e = (i) => i.replace(/(\.filerobot\.com\/[a-z0-9_-]+)\/v\d+\//i, "$1/");
+  if (s.includes("assets.filerobot.com")) return e(s);
+  const t = s.match(k);
+  return t ? e(s.replace(k, `$1assets.filerobot.com/${t[2]}/`)) : s;
+}
+function A(s, e) {
+  try {
+    const t = new URL(s);
+    for (const [i, r] of Object.entries(e)) t.searchParams.set(i, r);
+    return t.toString();
+  } catch {
+    return s;
+  }
+}
+function Ne(s, e = 240) {
+  const t = String(e);
+  if (s.type === "video")
+    return s.thumbnailUrl ? A(_(s.thumbnailUrl), { w: t, force_format: "webp,jpeg" }) : "";
+  if (s.type === "document" && /\.pdf$/i.test(s.name)) {
+    const i = _(s.cdnUrl ?? "");
+    if (!i) return "";
+    const r = i.replace(/([?&])func=proxy&?/, "$1").replace(/[?&]$/, "");
+    return A(r, {
+      w: t,
+      force_format: "webp,jpeg",
+      doc_page: "1",
+      bypass_process_proxy: "1"
+    });
+  }
+  if (s.type === "image" || s.thumbnailUrl) {
+    const i = s.thumbnailUrl ?? s.cdnUrl;
+    return i ? A(_(i), { w: t, func: "bound" }) : "";
+  }
+  return "";
+}
+const n = "https://scaleflex.cloudimg.io/v7/assets/file-types/v3/", Ie = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" fill="none"><path d="M24 4 42 14v20L24 44 6 34V14z" fill="#eef2ff" stroke="#6366f1" stroke-width="2" stroke-linejoin="round"/><path d="M24 4 42 14 24 24 6 14z" fill="#c7d2fe" stroke="#6366f1" stroke-width="2" stroke-linejoin="round"/><path d="M24 24v20M24 24 6 14M24 24 42 14" stroke="#6366f1" stroke-width="2" stroke-linejoin="round"/></svg>', v = `data:image/svg+xml,${encodeURIComponent(Ie)}`, E = {
+  _default: n + "GENERIC.svg?vh=9a518a",
+  // Images
+  png: n + "PNG.svg?vh=96cd9a",
+  jpg: n + "JPG.svg?vh=06e819",
+  jpg2: n + "JPG2.svg?vh=f0eb7f",
+  jpeg: n + "JPEG.svg?vh=6a65e9",
+  gif: n + "GIF.svg?vh=c3c2c3",
+  bmp: n + "BMP.svg?vh=d2243a",
+  webp: n + "WEBP.svg?vh=fedd74",
+  svg: n + "SVG.svg?vh=a15e46",
+  tiff: n + "TIFF.svg?vh=1f30c3",
+  tif: n + "TIF.svg?vh=b383c9",
+  heic: n + "HEIC.svg?vh=84adfe",
+  avif: n + "AVIF.svg?vh=536b30",
+  ico: n + "ICO.svg?vh=79063d",
+  psd: n + "PSD.svg?vh=be6140",
+  psb: n + "PSB.svg?vh=678646",
+  ai: n + "AI.svg?vh=84b254",
+  dwg: n + "DWG.svg?vh=971fb3",
+  // Video
+  mp4: n + "MP4.svg?vh=42f175",
+  webm: n + "WEBM.svg?vh=26a84a",
+  avi: n + "AVI.svg?vh=d22ba8",
+  mpeg: n + "MPEG.svg?vh=ba93bb",
+  ogv: n + "OGV.svg?vh=74d453",
+  "3gp": n + "3GP.svg?vh=f0d388",
+  "3g2": n + "3G2.svg?vh=04c652",
+  swf: n + "SWF.svg?vh=3955e2",
+  fla: n + "FLA.svg?vh=daf585",
+  m3u8: n + "M3U8.svg?vh=7d5e62",
+  // Audio
+  mp3: n + "MP3.svg?vh=66bbef",
+  wav: n + "WAV.svg?vh=d7a7d5",
+  aac: n + "AAC.svg?vh=07f3f9",
+  oga: n + "OGA.svg?vh=a5c622",
+  opus: n + "OPUS.svg?vh=9548b1",
+  weba: n + "WEBA.svg?vh=4dcf70",
+  mid: n + "MID.svg?vh=3f0e29",
+  midi: n + "MIDI.svg?vh=9fedec",
+  cda: n + "CDA.svg?vh=85b83b",
+  // Documents
+  pdf: n + "PDF.svg?vh=18c5f7",
+  doc: n + "DOC.svg?vh=d1b47c",
+  docx: n + "DOCX.svg?vh=1eb6b0",
+  txt: n + "TXT.svg?vh=307979",
+  rtf: n + "RTF.svg?vh=978c5f",
+  xls: n + "XLS.svg?vh=13b5f7",
+  xlsx: n + "XLSX.svg?vh=79d64a",
+  ppt: n + "PPT.svg?vh=4ee29b",
+  pptx: n + "PPTX.svg?vh=8b1568",
+  csv: n + "CSV.svg?vh=4add78",
+  odt: n + "ODT.svg?vh=940781",
+  ods: n + "ODS.svg?vh=9fbe9a",
+  odp: n + "ODP.svg?vh=bf892d",
+  dbf: n + "DBF.svg?vh=457bd4",
+  vsd: n + "VSD.svg?vh=8a9ccb",
+  abw: n + "ABW.svg?vh=313dc7",
+  epub: n + "EPUB.svg?vh=15263d",
+  azw: n + "AZW.svg?vh=a018b1",
+  ics: n + "ICS.svg?vh=909f63",
+  ogx: n + "OGX.svg?vh=f694d2",
+  // Archives
+  zip: n + "ZIP.svg?vh=84f98b",
+  rar: n + "RAR.svg?vh=1d6423",
+  "7z": n + "7Z.svg?vh=e007e5",
+  tar: n + "TAR.svg?vh=603aed",
+  gz: n + "GZ.svg?vh=de13f7",
+  bz: n + "BZ.svg?vh=0374ff",
+  bz2: n + "BZ2.svg?vh=e14294",
+  arc: n + "ARC.svg?vh=942fad",
+  jar: n + "JAR.svg?vh=149796",
+  mpkg: n + "MPKG.svg?vh=dea655",
+  // Fonts
+  ttf: n + "TTF.svg?vh=d2e2c1",
+  otf: n + "OTF.svg?vh=c904fd",
+  woff: n + "WOFF.svg?vh=4b8177",
+  woff2: n + "WOFF2.svg?vh=b532d3",
+  eot: n + "EOT.svg?vh=a54980",
+  // Code / Scripts
+  js: n + "JS.svg?vh=524691",
+  mjs: n + "MJS.svg?vh=d57921",
+  ts: n + "TS.svg?vh=9af3ae",
+  css: n + "CSS.svg?vh=287863",
+  html: n + "HTML.svg?vh=fa7a87",
+  htm: n + "HTM.svg?vh=21323d",
+  xhtml: n + "XHTML.svg?vh=e6d6a9",
+  xul: n + "XUL.svg?vh=6c9c71",
+  json: n + "JSON.svg?vh=104c9e",
+  jsonld: n + "JSONLD.svg?vh=f30c0f",
+  xml: n + "XML.svg?vh=7f7194",
+  php: n + "PHP.svg?vh=503e36",
+  sh: n + "SH.svg?vh=3b820e",
+  csh: n + "CSH.svg?vh=08c0cc",
+  // Executables / Disk images
+  exe: n + "EXE.svg?vh=ccca53",
+  iso: n + "ISO.svg?vh=064b8f",
+  bin: n + "BIN.svg?vh=1e9618",
+  // 3D models (local override — not in asset-picker's hosted set)
+  glb: v,
+  gltf: v,
+  obj: v,
+  fbx: v,
+  stl: v,
+  usdz: v,
+  ply: v,
+  "3ds": v,
+  dae: v
+};
+function Be() {
+  return E._default;
+}
+function Ge(s) {
+  const e = (s.split(".").pop() || "").toLowerCase();
+  return E[e] || E._default;
+}
+function We(s) {
+  if (s == null || !Number.isFinite(s) || s < 0) return "—";
+  const e = ["B", "KB", "MB", "GB", "TB"];
+  let t = s, i = 0;
+  for (; t >= 1024 && i < e.length - 1; )
+    t /= 1024, i++;
+  const r = (a, c) => {
+    const h = c > 0 && Math.round(a * 10) / 10 < 10 ? 1 : 0, f = a.toFixed(h);
+    return { str: f, rounded: Number(f) };
+  }, o = r(t, i);
+  let l = o.str;
+  return o.rounded >= 1024 && i < e.length - 1 && (t /= 1024, i++, l = r(t, i).str), `${l} ${e[i]}`;
+}
+function Xe(s) {
+  if (!s) return "—";
+  const e = new Date(s);
+  return Number.isNaN(e.getTime()) ? s : e.toLocaleDateString(void 0, { year: "numeric", month: "short", day: "numeric" });
+}
+function Ve(s, e) {
+  return s && e ? `${s} × ${e}` : "—";
+}
+function He(s, e) {
+  let t;
+  const i = ((...r) => {
+    clearTimeout(t), t = setTimeout(() => s(...r), e);
+  });
+  return i.cancel = () => clearTimeout(t), i;
+}
+export {
+  P as BrowseStore,
+  O as DamClient,
+  Oe as LocalFavouritesAdapter,
+  U as MAX_FAVOURITES,
+  C as PAGE_SIZE,
+  Le as QUALITY_LEVELS,
+  ze as RESIZE_PRESETS,
+  Re as addCdnParams,
+  Ae as archiveDownloadUrl,
+  be as archiveStatusOutcome,
+  ve as assembleVariations,
+  re as assetMatchesFacets,
+  T as buildAuthHeaders,
+  je as buildEmbedUrl,
+  qe as buildTransformedDownloadUrl,
+  Ce as createAndPollArchive,
+  we as createArchive,
+  K as createFolder,
+  He as debounce,
+  ce as deleteFiles,
+  Z as deleteFolders,
+  W as exchangeSassKey,
+  Xe as formatDate,
+  Ve as formatDimensions,
+  We as formatFileSize,
+  M as getApiBase,
+  ye as getArchiveStatus,
+  Be as getDefaultFileTypeIconUrl,
+  Ge as getFileTypeIconUrl,
+  ge as getFileVariations,
+  $e as getFiles,
+  oe as getFilesByUuids,
+  w as getFilesPage,
+  Ue as getFilesRaw,
+  De as getFilesStats,
+  Me as getFolderPreviews,
+  b as getFolders,
+  ke as getFoldersRaw,
+  _ as getFormattedPreviewUrl,
+  de as getLabels,
+  pe as getPresets,
+  Ne as getThumbnailUrl,
+  he as labelFilterQuery,
+  xe as loadVariations,
+  le as moveFiles,
+  Q as moveFolders,
+  V as normalizeAuth,
+  me as normalizePresets,
+  x as normalizeVariation,
+  _e as pollArchive,
+  $ as presetUrl,
+  ae as renameFile,
+  Y as renameFolder,
+  I as resolveAuth,
+  ne as sortAssets,
+  Te as transformedFileName
+};
+//# sourceMappingURL=index.js.map