// node_modules/fflate/esm/browser.js
var u8 = Uint8Array;
var u16 = Uint16Array;
var i32 = Int32Array;
var fleb = new u8([
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  1,
  1,
  1,
  1,
  2,
  2,
  2,
  2,
  3,
  3,
  3,
  3,
  4,
  4,
  4,
  4,
  5,
  5,
  5,
  5,
  0,
  /* unused */
  0,
  0,
  /* impossible */
  0
]);
var fdeb = new u8([
  0,
  0,
  0,
  0,
  1,
  1,
  2,
  2,
  3,
  3,
  4,
  4,
  5,
  5,
  6,
  6,
  7,
  7,
  8,
  8,
  9,
  9,
  10,
  10,
  11,
  11,
  12,
  12,
  13,
  13,
  /* unused */
  0,
  0
]);
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
var freb = function(eb, start) {
  var b = new u16(31);
  for (var i = 0; i < 31; ++i) {
    b[i] = start += 1 << eb[i - 1];
  }
  var r = new i32(b[30]);
  for (var i = 1; i < 30; ++i) {
    for (var j = b[i]; j < b[i + 1]; ++j) {
      r[j] = j - b[i] << 5 | i;
    }
  }
  return { b, r };
};
var _a = freb(fleb, 2);
var fl = _a.b;
var revfl = _a.r;
fl[28] = 258, revfl[258] = 28;
var _b = freb(fdeb, 0);
var fd = _b.b;
var revfd = _b.r;
var rev = new u16(32768);
for (i = 0; i < 32768; ++i) {
  x = (i & 43690) >> 1 | (i & 21845) << 1;
  x = (x & 52428) >> 2 | (x & 13107) << 2;
  x = (x & 61680) >> 4 | (x & 3855) << 4;
  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
}
var x;
var i;
var hMap = (function(cd, mb, r) {
  var s = cd.length;
  var i = 0;
  var l = new u16(mb);
  for (; i < s; ++i) {
    if (cd[i])
      ++l[cd[i] - 1];
  }
  var le = new u16(mb);
  for (i = 1; i < mb; ++i) {
    le[i] = le[i - 1] + l[i - 1] << 1;
  }
  var co;
  if (r) {
    co = new u16(1 << mb);
    var rvb = 15 - mb;
    for (i = 0; i < s; ++i) {
      if (cd[i]) {
        var sv = i << 4 | cd[i];
        var r_1 = mb - cd[i];
        var v = le[cd[i] - 1]++ << r_1;
        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
          co[rev[v] >> rvb] = sv;
        }
      }
    }
  } else {
    co = new u16(s);
    for (i = 0; i < s; ++i) {
      if (cd[i]) {
        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
      }
    }
  }
  return co;
});
var flt = new u8(288);
for (i = 0; i < 144; ++i)
  flt[i] = 8;
var i;
for (i = 144; i < 256; ++i)
  flt[i] = 9;
var i;
for (i = 256; i < 280; ++i)
  flt[i] = 7;
var i;
for (i = 280; i < 288; ++i)
  flt[i] = 8;
var i;
var fdt = new u8(32);
for (i = 0; i < 32; ++i)
  fdt[i] = 5;
var i;
var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
var max = function(a) {
  var m = a[0];
  for (var i = 1; i < a.length; ++i) {
    if (a[i] > m)
      m = a[i];
  }
  return m;
};
var bits = function(d, p, m) {
  var o = p / 8 | 0;
  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
};
var bits16 = function(d, p) {
  var o = p / 8 | 0;
  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
};
var shft = function(p) {
  return (p + 7) / 8 | 0;
};
var slc = function(v, s, e) {
  if (s == null || s < 0)
    s = 0;
  if (e == null || e > v.length)
    e = v.length;
  return new u8(v.subarray(s, e));
};
var ec = [
  "unexpected EOF",
  "invalid block type",
  "invalid length/literal",
  "invalid distance",
  "stream finished",
  "no stream handler",
  ,
  // determined by compression function
  "no callback",
  "invalid UTF-8 data",
  "extra field too long",
  "date not in range 1980-2099",
  "filename too long",
  "stream finishing",
  "invalid zip data"
  // determined by unknown compression method
];
var err = function(ind, msg, nt) {
  var e = new Error(msg || ec[ind]);
  e.code = ind;
  if (Error.captureStackTrace)
    Error.captureStackTrace(e, err);
  if (!nt)
    throw e;
  return e;
};
var inflt = function(dat, st, buf, dict) {
  var sl = dat.length, dl = dict ? dict.length : 0;
  if (!sl || st.f && !st.l)
    return buf || new u8(0);
  var noBuf = !buf;
  var resize = noBuf || st.i != 2;
  var noSt = st.i;
  if (noBuf)
    buf = new u8(sl * 3);
  var cbuf = function(l2) {
    var bl = buf.length;
    if (l2 > bl) {
      var nbuf = new u8(Math.max(bl * 2, l2));
      nbuf.set(buf);
      buf = nbuf;
    }
  };
  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
  var tbts = sl * 8;
  do {
    if (!lm) {
      final = bits(dat, pos, 1);
      var type = bits(dat, pos + 1, 3);
      pos += 3;
      if (!type) {
        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
        if (t > sl) {
          if (noSt)
            err(0);
          break;
        }
        if (resize)
          cbuf(bt + l);
        buf.set(dat.subarray(s, t), bt);
        st.b = bt += l, st.p = pos = t * 8, st.f = final;
        continue;
      } else if (type == 1)
        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
      else if (type == 2) {
        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
        var tl = hLit + bits(dat, pos + 5, 31) + 1;
        pos += 14;
        var ldt = new u8(tl);
        var clt = new u8(19);
        for (var i = 0; i < hcLen; ++i) {
          clt[clim[i]] = bits(dat, pos + i * 3, 7);
        }
        pos += hcLen * 3;
        var clb = max(clt), clbmsk = (1 << clb) - 1;
        var clm = hMap(clt, clb, 1);
        for (var i = 0; i < tl; ) {
          var r = clm[bits(dat, pos, clbmsk)];
          pos += r & 15;
          var s = r >> 4;
          if (s < 16) {
            ldt[i++] = s;
          } else {
            var c = 0, n = 0;
            if (s == 16)
              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
            else if (s == 17)
              n = 3 + bits(dat, pos, 7), pos += 3;
            else if (s == 18)
              n = 11 + bits(dat, pos, 127), pos += 7;
            while (n--)
              ldt[i++] = c;
          }
        }
        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
        lbt = max(lt);
        dbt = max(dt);
        lm = hMap(lt, lbt, 1);
        dm = hMap(dt, dbt, 1);
      } else
        err(1);
      if (pos > tbts) {
        if (noSt)
          err(0);
        break;
      }
    }
    if (resize)
      cbuf(bt + 131072);
    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
    var lpos = pos;
    for (; ; lpos = pos) {
      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
      pos += c & 15;
      if (pos > tbts) {
        if (noSt)
          err(0);
        break;
      }
      if (!c)
        err(2);
      if (sym < 256)
        buf[bt++] = sym;
      else if (sym == 256) {
        lpos = pos, lm = null;
        break;
      } else {
        var add = sym - 254;
        if (sym > 264) {
          var i = sym - 257, b = fleb[i];
          add = bits(dat, pos, (1 << b) - 1) + fl[i];
          pos += b;
        }
        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
        if (!d)
          err(3);
        pos += d & 15;
        var dt = fd[dsym];
        if (dsym > 3) {
          var b = fdeb[dsym];
          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
        }
        if (pos > tbts) {
          if (noSt)
            err(0);
          break;
        }
        if (resize)
          cbuf(bt + 131072);
        var end = bt + add;
        if (bt < dt) {
          var shift = dl - dt, dend = Math.min(dt, end);
          if (shift + bt < 0)
            err(3);
          for (; bt < dend; ++bt)
            buf[bt] = dict[shift + bt];
        }
        for (; bt < end; ++bt)
          buf[bt] = buf[bt - dt];
      }
    }
    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
    if (lm)
      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
  } while (!final);
  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
};
var et = /* @__PURE__ */ new u8(0);
var b2 = function(d, b) {
  return d[b] | d[b + 1] << 8;
};
var b4 = function(d, b) {
  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
};
var b8 = function(d, b) {
  return b4(d, b) + b4(d, b + 4) * 4294967296;
};
function inflateSync(data, opts) {
  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
}
var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
var tds = 0;
try {
  td.decode(et, { stream: true });
  tds = 1;
} catch (e) {
}
var dutf8 = function(d) {
  for (var r = "", i = 0; ; ) {
    var c = d[i++];
    var eb = (c > 127) + (c > 223) + (c > 239);
    if (i + eb > d.length)
      return { s: r, r: slc(d, i - 1) };
    if (!eb)
      r += String.fromCharCode(c);
    else if (eb == 3) {
      c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
    } else if (eb & 1)
      r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
    else
      r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
  }
};
function strFromU8(dat, latin1) {
  if (latin1) {
    var r = "";
    for (var i = 0; i < dat.length; i += 16384)
      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
    return r;
  } else if (td) {
    return td.decode(dat);
  } else {
    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
    if (r.length)
      err(8);
    return s;
  }
}
var slzh = function(d, b) {
  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
};
var zh = function(d, b, z) {
  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
};
var z64hs = function(d, b, l, z, sc, su, off) {
  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
  var nf = nsc + nsu + noff;
  if (z && nf) {
    for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
      if (b2(d, b) == 1) {
        return [
          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
          nsu ? b8(d, b + 4) : su,
          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
          1
        ];
      }
    }
    if (z < 2)
      err(13);
  }
  return [sc, su, off, 0];
};
function unzipSync(data, opts) {
  var files = {};
  var e = data.length - 22;
  for (; b4(data, e) != 101010256; --e) {
    if (!e || data.length - e > 65558)
      err(13);
  }
  ;
  var c = b2(data, e + 8);
  if (!c)
    return {};
  var o = b4(data, e + 16);
  var z = b4(data, e - 20) == 117853008;
  if (z) {
    var ze = b4(data, e - 12);
    z = b4(data, ze) == 101075792;
    if (z) {
      c = b4(data, ze + 32);
      o = b4(data, ze + 48);
    }
  }
  var fltr = opts && opts.filter;
  for (var i = 0; i < c; ++i) {
    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
    o = no;
    if (!fltr || fltr({
      name: fn,
      size: sc,
      originalSize: su,
      compression: c_2
    })) {
      if (!c_2)
        files[fn] = slc(data, b, b + sc);
      else if (c_2 == 8)
        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
      else
        err(14, "unknown compression type " + c_2);
    }
  }
  return files;
}

// upload/frontend/table/rebase_tree.js
function rebaseTree(root, prefix) {
  root.path = `${prefix}/${root.path}`;
  if (root.file) root.file = new File([root.file], root.file.name, { lastModified: root.file.lastModified });
  root.children.forEach((child) => rebaseTree(child, prefix));
  return root;
}

// upload/frontend/zip/list_zip_files.js
var DEFAULT_LIMITS = {
  maxEntries: 1e3,
  maxTotalBytes: 100 * 1024 * 1024,
  maxEntryBytes: 50 * 1024 * 1024,
  maxDepth: 20
};
function extensionAllowed(name, allowedExt) {
  const lowerName = name.toLowerCase();
  return allowedExt.some((extension) => lowerName.endsWith(extension.toLowerCase()));
}
function makeFile(data, name) {
  return new File([data], name.split("/").at(-1));
}
function safeEntryParts(entryName) {
  if (!entryName || entryName.startsWith("/") || entryName.includes("\\")) return null;
  const parts = entryName.split("/");
  if (parts.some((part) => !part || part === "." || part === "..")) return null;
  return parts;
}
function node(kind, name, path, children = [], file = null) {
  return { id: crypto.randomUUID(), kind, name, path, children, file, expanded: true };
}
function addPath(root, parts, fileNode) {
  let current = root;
  parts.forEach((part, index) => {
    const last = index === parts.length - 1;
    let child = current.children.find((item) => item.name === part);
    if (!child) {
      child = last ? fileNode : node("folder", part, `${current.path}/${part}`);
      current.children.push(child);
    }
    current = child;
  });
}
async function listEntries(data, zipName, allowedExt, depth, limits, budget) {
  if (depth > limits.maxDepth) throw new Error("\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0433\u043B\u0443\u0431\u043E\u043A\u0430\u044F \u0432\u043B\u043E\u0436\u0435\u043D\u043D\u043E\u0441\u0442\u044C ZIP");
  const entries = unzipSync(data, {
    filter: (entry) => {
      budget.entries += 1;
      if (budget.entries > limits.maxEntries) throw new Error("\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u043D\u043E\u0433\u043E ZIP entries");
      const lowerName = entry.name.toLowerCase();
      if (!extensionAllowed(lowerName, allowedExt) && !lowerName.endsWith(".zip")) return false;
      if (entry.originalSize > limits.maxEntryBytes) return false;
      if (budget.totalBytes + entry.originalSize > limits.maxTotalBytes) {
        throw new Error("\u041F\u0440\u0435\u0432\u044B\u0448\u0435\u043D \u0441\u0443\u043C\u043C\u0430\u0440\u043D\u044B\u0439 \u0440\u0430\u0437\u043C\u0435\u0440 \u0440\u0430\u0441\u043F\u0430\u043A\u043E\u0432\u0430\u043D\u043D\u044B\u0445 ZIP entries");
      }
      budget.totalBytes += entry.originalSize;
      return true;
    }
  });
  const root = node("zip", zipName, zipName);
  for (const [entryName, entryData] of Object.entries(entries)) {
    if (entryName.endsWith("/")) continue;
    const parts = safeEntryParts(entryName);
    if (!parts) continue;
    const normalizedName = parts.join("/");
    if (normalizedName.toLowerCase().endsWith(".zip")) {
      const nested = await listEntries(entryData, entryName, allowedExt, depth + 1, limits, budget);
      if (nested) {
        rebaseTree(nested, zipName);
        nested.name = parts.at(-1);
        addPath(root, parts, nested);
      }
    } else if (extensionAllowed(normalizedName, allowedExt)) {
      const path = `${zipName}/${normalizedName}`;
      const file = makeFile(entryData, path);
      addPath(root, parts, node("file", parts.at(-1), path, [], file));
    }
  }
  return root.children.length ? root : null;
}
async function listZipFiles(file, allowedExt, customLimits = {}) {
  const data = new Uint8Array(await file.arrayBuffer());
  const limits = { ...DEFAULT_LIMITS, ...customLimits };
  return listEntries(data, file.name, allowedExt, 0, limits, { entries: 0, totalBytes: 0 });
}

// upload/frontend/table/add_file_with_dedup.js
function addFileWithDedup(state, fileNode) {
  const accept = (node2) => {
    if (node2.kind === "file") {
      const key = `${node2.path}\0${node2.file.size}`;
      if (state.fileKeys.has(key)) return null;
      state.fileKeys.add(key);
      return node2;
    }
    node2.children = node2.children.map(accept).filter(Boolean);
    return node2.children.length ? node2 : null;
  };
  const accepted = accept(fileNode);
  if (!accepted || accepted.kind !== "file" && !accepted.children.length) return false;
  if (accepted.kind !== "file") {
    const existing = state.nodes.find((node2) => node2.kind !== "file" && node2.path === accepted.path);
    if (existing) {
      mergeChildren(existing, accepted);
      return true;
    }
  }
  state.nodes.push(accepted);
  return true;
}
function mergeChildren(target, incoming) {
  incoming.children.forEach((child) => {
    if (child.kind === "file") {
      const duplicate = target.children.some((existing2) => existing2.kind === "file" && existing2.path === child.path && existing2.file.size === child.file.size);
      if (!duplicate) target.children.push(child);
      return;
    }
    const existing = target.children.find((candidate) => candidate.kind !== "file" && candidate.path === child.path);
    if (existing) mergeChildren(existing, child);
    else target.children.push(child);
  });
}

// upload/frontend/table/esc.js
function esc(value) {
  return String(value).replace(/[&<>"']/g, (character) => ({
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
    '"': "&quot;",
    "'": "&#39;"
  })[character]);
}

// upload/frontend/table/fs.js
function fs(bytes) {
  return bytes < 1024 ? `${bytes} B` : bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
}

// upload/frontend/table/render.js
var DEFAULT_RENDER_CONFIG = {
  labels: {
    statusReady: "\u0433\u043E\u0442\u043E\u0432",
    remove: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C",
    empty: "\u041D\u0435\u0442 \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u044B\u0445 \u0444\u0430\u0439\u043B\u043E\u0432",
    columns: { path: "\u041F\u0443\u0442\u044C", size: "\u0420\u0430\u0437\u043C\u0435\u0440", status: "\u0421\u0442\u0430\u0442\u0443\u0441" },
    count: (count, bytes) => `${count} \u0444\u0430\u0439\u043B\u043E\u0432 \xB7 ${fs(bytes)}`
  },
  layout: { columns: ["path", "size", "status"] }
};
function renderConfig(cfg = {}) {
  return {
    labels: {
      ...DEFAULT_RENDER_CONFIG.labels,
      ...cfg.labels || {},
      columns: {
        ...DEFAULT_RENDER_CONFIG.labels.columns,
        ...cfg.labels?.columns || {}
      }
    },
    layout: { ...DEFAULT_RENDER_CONFIG.layout, ...cfg.layout || {} }
  };
}
function renderNode(node2, depth, cfg) {
  const isGroup = node2.kind !== "file";
  const padding = depth * 4;
  const name = esc(node2.name);
  const action = isGroup ? `<button class="tree-name tree-group tree-${node2.kind}" style="padding-left:${padding}ch" data-toggle="${node2.id}" aria-expanded="${node2.expanded}"><span class="tree-chevron">${node2.expanded ? "\u25BC" : "\u25B6"}</span>${name}</button>` : `<span class="tree-name" style="padding-left:${padding}ch">${name}</span>`;
  const remove = `<button class="remove-btn" type="button" data-remove="${node2.id}" aria-label="${esc(cfg.labels.remove)} ${name}">\xD7</button>`;
  const pathAttribute = node2.kind === "file" ? ` data-path="${esc(node2.path)}"` : "";
  const cells = {
    path: action,
    size: node2.kind === "file" ? fs(node2.file.size) : "",
    status: node2.error ? esc(node2.error) : node2.kind === "file" ? esc(cfg.labels.statusReady) : ""
  };
  const columns = cfg.layout.columns?.length ? cfg.layout.columns : Object.keys(DEFAULT_RENDER_CONFIG.labels.columns);
  const row = `<tr class="tree-row tree-${node2.kind}"${pathAttribute}>` + columns.map((column) => `<td>${cells[column] || ""}</td>`).join("") + `<td>${remove}</td></tr>`;
  if (!isGroup || !node2.expanded) return row;
  return row + node2.children.map((child) => renderNode(child, depth + 1, cfg)).join("");
}
function render(state, elements, cfg) {
  const normalized = renderConfig(cfg);
  const columns = normalized.layout.columns?.length ? normalized.layout.columns : Object.keys(DEFAULT_RENDER_CONFIG.labels.columns);
  elements.tableBodyEl.innerHTML = state.nodes.length ? state.nodes.map((node2) => renderNode(node2, 0, normalized)).join("") : `<tr><td colspan="${columns.length + 1}">${esc(normalized.labels.empty)}</td></tr>`;
  const files = [];
  const visit = (node2) => {
    if (node2.kind === "file") files.push(node2);
    else node2.children.forEach(visit);
  };
  state.nodes.forEach(visit);
  const totalBytes = files.reduce((sum, node2) => sum + node2.file.size, 0);
  elements.countEl.textContent = normalized.labels.count(files.length, totalBytes);
}
function findNode(nodes, id) {
  for (const node2 of nodes) {
    if (node2.id === id) return { node: node2, nodes };
    const found = findNode(node2.children || [], id);
    if (found) return found;
  }
  return null;
}
function flattenFiles(nodes, result = []) {
  nodes.forEach((node2) => {
    if (node2.kind === "file") result.push({ path: node2.path, name: node2.name, size: node2.file.size, file: node2.file });
    else flattenFiles(node2.children, result);
  });
  return result;
}

// upload/frontend/table/on_files_change.js
async function addFiles(state, cfg, files, elements) {
  for (const file of Array.from(files)) {
    if (!file.name.toLowerCase().endsWith(".zip")) {
      if (!cfg.allowedExt.some((extension) => file.name.toLowerCase().endsWith(extension.toLowerCase()))) {
        continue;
      }
      addFileWithDedup(state, {
        id: crypto.randomUUID(),
        kind: "file",
        name: file.name,
        path: file.name,
        file,
        children: [],
        expanded: true
      });
      continue;
    }
    try {
      const zipTree = await listZipFiles(file, cfg.allowedExt, cfg.limits);
      if (zipTree) addFileWithDedup(state, zipTree);
    } catch (error) {
      if (typeof cfg.onError === "function") {
        cfg.onError(error, file);
      } else if (elements.statusEl) {
        elements.statusEl.textContent = `\u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F \u0430\u0440\u0445\u0438\u0432\u0430 ${file.name}: ${error.message}`;
      }
      continue;
    }
  }
  render(state, elements, cfg);
}
function onFilesChange(state, cfg, elements) {
  return async () => {
    if (state.busy) return;
    state.busy = true;
    try {
      await addFiles(state, cfg, elements.fileInputEl.files, elements);
    } finally {
      elements.fileInputEl.value = "";
      state.busy = false;
    }
  };
}

// upload/frontend/table/on_folder_change.js
function onFolderChange(state, cfg, elements) {
  return async () => {
    if (state.busy) return;
    state.busy = true;
    try {
      const roots = /* @__PURE__ */ new Map();
      for (const file of Array.from(elements.folderInputEl.files)) {
        const parts = (file.webkitRelativePath || file.name).split("/");
        const relativePath = parts.slice(1).join("/") || file.name;
        const lowerPath = relativePath.toLowerCase();
        const rootName = parts[0] || file.name;
        if (!roots.has(rootName)) {
          roots.set(rootName, {
            id: crypto.randomUUID(),
            kind: "folder",
            name: rootName,
            path: rootName,
            children: [],
            expanded: true
          });
        }
        const root = roots.get(rootName);
        const addToFolder = (node2) => {
          let current = root;
          const nodeParts = node2.path.split("/").slice(1);
          nodeParts.forEach((part, index) => {
            const last = index === nodeParts.length - 1;
            let child = current.children.find((item) => item.name === part);
            if (!child) {
              child = last ? node2 : {
                id: crypto.randomUUID(),
                kind: "folder",
                name: part,
                path: `${rootName}/${nodeParts.slice(0, index + 1).join("/")}`,
                children: [],
                expanded: true
              };
              current.children.push(child);
            }
            current = child;
          });
        };
        if (lowerPath.endsWith(".zip")) {
          try {
            const zip = await listZipFiles(file, cfg.allowedExt, cfg.limits);
            if (zip) {
              rebaseTree(zip, rootName);
              addToFolder(zip);
            }
          } catch (error) {
            if (typeof cfg.onError === "function") {
              cfg.onError(error, file);
            } else if (elements.statusEl) {
              elements.statusEl.textContent = `\u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F \u0430\u0440\u0445\u0438\u0432\u0430 ${file.name}: ${error.message}`;
            }
            continue;
          }
        } else if (cfg.allowedExt.some((extension) => lowerPath.endsWith(extension))) {
          addToFolder({
            id: crypto.randomUUID(),
            kind: "file",
            name: parts.at(-1),
            path: `${rootName}/${relativePath}`,
            file,
            children: [],
            expanded: true
          });
        }
      }
      roots.forEach((root) => addFileWithDedup(state, root));
      elements.folderInputEl.value = "";
      render(state, elements, cfg);
    } finally {
      state.busy = false;
    }
  };
}

// upload/frontend/upload/put_to_vm.js
function putToVm(file, url, options = {}) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    if (options.onXHR) {
      options.onXHR(xhr);
    }
    const abortHandler = () => {
      xhr.abort();
      reject(new DOMException("Upload aborted", "AbortError"));
    };
    if (options.signal) {
      if (options.signal.aborted) {
        reject(new DOMException("Upload aborted", "AbortError"));
        return;
      }
      options.signal.addEventListener("abort", abortHandler, { once: true });
    }
    xhr.open("PUT", url);
    xhr.timeout = options.timeoutMs || 3e5;
    xhr.upload.onprogress = (e) => {
      if (e.lengthComputable && options.onProgress) {
        const pct = Math.round(e.loaded / e.total * 100);
        options.onProgress(pct, e.loaded, e.total);
      }
    };
    xhr.onload = () => {
      if (options.signal) {
        options.signal.removeEventListener("abort", abortHandler);
      }
      if (xhr.status >= 200 && xhr.status < 300) {
        resolve();
      } else {
        reject(new Error(`\u0411\u0443\u0444\u0435\u0440: HTTP ${xhr.status} ${xhr.statusText}`));
      }
    };
    xhr.onerror = () => {
      if (options.signal) {
        options.signal.removeEventListener("abort", abortHandler);
      }
      reject(new Error("\u0421\u0435\u0442\u0435\u0432\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u0442\u043F\u0440\u0430\u0432\u043A\u0435 \u0432 \u0431\u0443\u0444\u0435\u0440"));
    };
    xhr.ontimeout = () => {
      if (options.signal) {
        options.signal.removeEventListener("abort", abortHandler);
      }
      reject(new Error(`\u0422\u0430\u0439\u043C\u0430\u0443\u0442 \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u044F \u043E\u0442\u0432\u0435\u0442\u0430 \u0431\u0443\u0444\u0435\u0440\u0430 (${Math.round(xhr.timeout / 1e3)}\u0441)`));
    };
    xhr.onabort = () => {
      if (options.signal) {
        options.signal.removeEventListener("abort", abortHandler);
      }
      reject(new DOMException("Upload aborted", "AbortError"));
    };
    xhr.send(file);
  });
}

// upload/frontend/upload/upload_via_vm.js
function generateUuid() {
  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
    return crypto.randomUUID();
  }
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
    const r = Math.random() * 16 | 0;
    const v = c === "x" ? r : r & 3 | 8;
    return v.toString(16);
  });
}
function normalizeFileEntry(item) {
  if (item instanceof File || item instanceof Blob) {
    return { name: item.name || "unnamed", size: item.size, file: item, path: item.name || "" };
  }
  if (item && item.file) {
    return {
      name: item.name || item.file.name || "unnamed",
      size: item.size ?? item.file.size ?? 0,
      file: item.file,
      path: item.path || item.name || ""
    };
  }
  throw new Error("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 \u043E\u0431\u044A\u0435\u043A\u0442 \u0444\u0430\u0439\u043B\u0430");
}
async function uploadViaVM(files, options = {}) {
  if (!options.vmUploadUrl) {
    return { ok: false, error: "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 options.vmUploadUrl \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u0435\u043D" };
  }
  const normalizedFiles = Array.from(files).map(normalizeFileEntry);
  const total = normalizedFiles.length;
  if (total === 0) {
    return { ok: true, session: options.session || "", count: 0 };
  }
  const backendUrl = options.backendUploadUrl || (options.apiBase || "") + "/api/upload_refs";
  const vmBase = options.vmUploadUrl.endsWith("/") ? options.vmUploadUrl : `${options.vmUploadUrl}/`;
  let currentSession = options.session || "";
  let totalAdded = 0;
  for (let k = 0; k < total; k++) {
    if (options.signal?.aborted) {
      return { ok: false, error: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u0430", aborted: true, session: currentSession };
    }
    const { name, size, file } = normalizedFiles[k];
    const fileKey = `${generateUuid()}_${k}`;
    const fileUrl = `${vmBase}${fileKey}`;
    if (options.onStatus) {
      options.onStatus(`\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u0432 \u0431\u0443\u0444\u0435\u0440 (${k + 1}/${total}): ${name}`);
    }
    if (options.onFileStatus) {
      options.onFileStatus(k, "\u23F3 \u0412 \u0431\u0443\u0444\u0435\u0440...");
    }
    const t0 = performance.now();
    try {
      await putToVm(file, fileUrl, {
        signal: options.signal,
        onXHR: options.onXHR,
        onProgress(pct, loaded, fileTotal) {
          const elapsed = (performance.now() - t0) / 1e3;
          const speed = elapsed > 0 ? loaded / elapsed : 0;
          if (options.onFileStatus) {
            options.onFileStatus(k, `\u23F3 ${pct}% (${fs(speed)}/s)`);
          }
          if (options.onProgress) {
            options.onProgress({ index: k, total, pct, speed, loaded, fileTotal, name });
          }
        }
      });
    } catch (err2) {
      if (options.signal?.aborted) {
        return { ok: false, error: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u0430", aborted: true, session: currentSession };
      }
      if (options.onFileStatus) {
        options.onFileStatus(k, "\u2717 \u041E\u0448\u0438\u0431\u043A\u0430 \u0431\u0443\u0444\u0435\u0440\u0430");
      }
      return {
        ok: false,
        error: `\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0442\u043F\u0440\u0430\u0432\u043A\u0438 \u0444\u0430\u0439\u043B\u0430 ${name} \u0432 \u0431\u0443\u0444\u0435\u0440: ${err2.message}`,
        failedIndex: k,
        session: currentSession
      };
    }
    if (options.onStatus) {
      options.onStatus(`\u041F\u0440\u0438\u0451\u043C \u0441\u0435\u0440\u0432\u0438\u0441\u043E\u043C (${k + 1}/${total}): ${name}`);
    }
    if (options.onFileStatus) {
      options.onFileStatus(k, "\u26A1 \u0412 \u0441\u0435\u0441\u0441\u0438\u044E...");
    }
    try {
      const resp = await fetch(backendUrl, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          session: currentSession,
          files: [{ name, size, url: fileUrl }]
        }),
        signal: options.signal
      });
      if (!resp.ok) {
        throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
      }
      const data = await resp.json();
      if (!data.ok) {
        throw new Error(data.error || "\u0411\u044D\u043A\u0435\u043D\u0434 \u0432\u0435\u0440\u043D\u0443\u043B \u043E\u0448\u0438\u0431\u043A\u0443");
      }
      currentSession = data.session || currentSession;
      totalAdded = data.count ?? totalAdded + 1;
      if (options.onFileStatus) {
        options.onFileStatus(k, "\u2713 \u0414\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D");
      }
      if (options.onFileComplete) {
        options.onFileComplete({
          fileIndex: k,
          name,
          size,
          session: currentSession,
          totalAdded
        });
      }
    } catch (err2) {
      if (options.signal?.aborted) {
        return { ok: false, error: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u0430", aborted: true, session: currentSession };
      }
      if (options.onFileStatus) {
        options.onFileStatus(k, "\u2717 \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438\u0451\u043C\u0430");
      }
      return {
        ok: false,
        error: `\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438\u0451\u043C\u0430 \u0444\u0430\u0439\u043B\u0430 ${name} \u0431\u044D\u043A\u0435\u043D\u0434\u043E\u043C: ${err2.message}`,
        failedIndex: k,
        session: currentSession
      };
    }
  }
  if (options.onStatus) {
    options.onStatus(`\u0417\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u043E. \u0423\u0441\u043F\u0435\u0448\u043D\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u043E \u0444\u0430\u0439\u043B\u043E\u0432: ${total}`);
  }
  return { ok: true, session: currentSession, count: totalAdded };
}

// upload/frontend/index.js
var DEFAULTS = {
  allowedExt: [],
  labels: {
    pickFiles: "\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u0444\u0430\u0439\u043B\u044B",
    pickFolder: "\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u0430\u043F\u043A\u0443",
    clear: "\u041E\u0447\u0438\u0441\u0442\u0438\u0442\u044C",
    empty: "\u041D\u0435\u0442 \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u044B\u0445 \u0444\u0430\u0439\u043B\u043E\u0432",
    statusReady: "\u0433\u043E\u0442\u043E\u0432",
    remove: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C",
    columns: { path: "\u041F\u0443\u0442\u044C", size: "\u0420\u0430\u0437\u043C\u0435\u0440", status: "\u0421\u0442\u0430\u0442\u0443\u0441" },
    count: (count, bytes) => `${count} \u0444\u0430\u0439\u043B\u043E\u0432 \xB7 ${bytes} B`
  },
  layout: { columns: ["path", "size", "status"], controls: ["files", "folder", "clear"] },
  limits: {
    maxEntries: 1e3,
    maxTotalBytes: 100 * 1024 * 1024,
    maxEntryBytes: 50 * 1024 * 1024,
    maxDepth: 20
  }
};
function resolveMount(mount) {
  const element = typeof mount === "string" ? document.querySelector(mount) : mount;
  if (!element) throw new Error("File picker mount element \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D");
  return element;
}
function normalizeConfig(config) {
  return {
    ...config,
    allowedExt: config.allowedExt || DEFAULTS.allowedExt,
    labels: {
      ...DEFAULTS.labels,
      ...config.labels || {},
      columns: { ...DEFAULTS.labels.columns, ...config.labels?.columns || {} }
    },
    layout: { ...DEFAULTS.layout, ...config.layout || {} },
    limits: { ...DEFAULTS.limits, ...config.limits || {} }
  };
}
function injectStyles() {
  if (document.querySelector("style[data-file-picker]")) return;
  const style = document.createElement("style");
  style.dataset.filePicker = "";
  style.textContent = `
.file-picker { color: #17211b; font-family: Georgia, 'Times New Roman', serif; }
.file-picker .fp-toolbar { display: flex; flex-wrap: wrap; gap: 10px; margin: 16px 0; }
.file-picker .fp-toolbar button { border: 0; border-radius: 4px; padding: 12px 17px; color: #f7faf4; background: #1f5a3b; font: 700 13px sans-serif; cursor: pointer; }
.file-picker .fp-toolbar button.secondary { color: #1f5a3b; background: #cbdcc9; }
.file-picker .fp-toolbar button.quiet { color: #5d6a61; background: transparent; }
.file-picker .fp-table-wrap { overflow-x: auto; border-top: 1px solid #b9c7ba; }
.file-picker .fp-table { width: 100%; border-collapse: collapse; font: 14px/1.4 sans-serif; }
.file-picker .fp-table th, .file-picker .fp-table td { padding: 14px 10px; border-bottom: 1px solid #cbd5cc; text-align: left; }
.file-picker .fp-table th { color: #56745f; font-size: 11px; text-transform: uppercase; letter-spacing: 1px; }
.file-picker .fp-status, .file-picker .fp-count { color: #5d6a61; font: 13px sans-serif; }
.file-picker .fp-count { min-height: 22px; }
.file-picker .tree-name { display: inline-flex; align-items: center; gap: 8px; min-width: 240px; padding-top: 0; padding-bottom: 0; border: 0; background: transparent; color: #17211b; font: inherit; text-align: left; }
.file-picker .tree-group { padding-left: 0; cursor: pointer; }
.file-picker .tree-chevron { display: inline-block; width: 12px; color: #78917d; font-size: 10px; }
.file-picker .remove-btn { padding: 2px 7px; color: #8c5148; background: transparent; font: 20px/1 sans-serif; }
.file-picker .tree-row td:first-child { white-space: nowrap; }
@media (max-width: 600px) { .file-picker .fp-toolbar button { flex: 1 1 42%; } }
`;
  document.head.append(style);
}
function buildMarkup(root, cfg) {
  const controls = cfg.layout.controls || [];
  const control = (name, id, label, className = "") => controls.includes(name) ? `<button id="${id}" type="button" class="${className}">${esc(label)}</button>` : "";
  const columns = cfg.layout.columns?.length ? cfg.layout.columns : Object.keys(cfg.labels.columns);
  const headings = columns.map((column) => `<th>${esc(cfg.labels.columns[column] || column)}</th>`).join("");
  root.innerHTML = `
    <div class="file-picker${cfg.layout.theme ? ` ${esc(cfg.layout.theme)}` : ""}">
      <div class="fp-toolbar" aria-label="${esc(cfg.labels.pickFiles)}">
        <input class="fp-file-input" type="file" accept="${esc([...cfg.allowedExt, ".zip"].join(","))}" multiple hidden>
        <input class="fp-folder-input" type="file" accept="${esc([...cfg.allowedExt, ".zip"].join(","))}" webkitdirectory directory multiple hidden>
        ${control("files", "fp-files-btn", cfg.labels.pickFiles)}
        ${control("folder", "fp-folder-btn", cfg.labels.pickFolder, "secondary")}
        ${control("clear", "fp-clear-btn", cfg.labels.clear, "quiet")}
      </div>
      <p class="fp-status" role="status"></p>
      <div class="fp-table-wrap"><table class="fp-table"><thead><tr>${headings}<th></th></tr></thead><tbody class="fp-table-body"></tbody></table></div>
      <p class="fp-count"></p>
    </div>`;
}
function notify(cfg, state) {
  if (typeof cfg.onChange === "function") cfg.onChange([...flattenFiles(state.nodes)]);
}
function removeMetadata(state, node2) {
  if (node2.kind === "file") {
    state.fileKeys.delete(`${node2.path}\0${node2.file.size}`);
    return;
  }
  node2.children.forEach((child) => removeMetadata(state, child));
}
function removeNode(state, id) {
  const found = findNode(state.nodes, id);
  if (!found) return false;
  removeMetadata(state, found.node);
  found.nodes.splice(found.nodes.indexOf(found.node), 1);
  return true;
}
function initFilePicker(config) {
  const cfg = normalizeConfig(config);
  const mount = resolveMount(cfg.mount);
  injectStyles();
  buildMarkup(mount, cfg);
  const root = mount.firstElementChild;
  const elements = {
    fileInputEl: root.querySelector(".fp-file-input"),
    folderInputEl: root.querySelector(".fp-folder-input"),
    statusEl: root.querySelector(".fp-status"),
    tableBodyEl: root.querySelector(".fp-table-body"),
    countEl: root.querySelector(".fp-count")
  };
  const state = { nodes: [], fileKeys: /* @__PURE__ */ new Set(), busy: false };
  const listeners = [];
  const listen = (target, event, handler) => {
    target.addEventListener(event, handler);
    listeners.push(() => target.removeEventListener(event, handler));
  };
  const redraw = () => render(state, elements, cfg);
  const filesChange = onFilesChange(state, cfg, elements);
  const folderChange = onFolderChange(state, cfg, elements);
  listen(elements.fileInputEl, "change", async () => {
    await filesChange();
    notify(cfg, state);
  });
  listen(elements.folderInputEl, "change", async () => {
    await folderChange();
    notify(cfg, state);
  });
  listen(elements.tableBodyEl, "click", (event) => {
    const toggle = event.target.closest("[data-toggle]");
    if (toggle) {
      const found = findNode(state.nodes, toggle.dataset.toggle);
      if (found) found.node.expanded = !found.node.expanded;
      redraw();
      return;
    }
    const remove = event.target.closest("[data-remove]");
    if (remove) {
      if (removeNode(state, remove.dataset.remove)) {
        redraw();
        notify(cfg, state);
      }
    }
  });
  if (root.querySelector("#fp-files-btn")) listen(root.querySelector("#fp-files-btn"), "click", () => elements.fileInputEl.click());
  if (root.querySelector("#fp-folder-btn")) listen(root.querySelector("#fp-folder-btn"), "click", () => elements.folderInputEl.click());
  if (root.querySelector("#fp-clear-btn")) listen(root.querySelector("#fp-clear-btn"), "click", () => {
    state.nodes = [];
    state.fileKeys.clear();
    redraw();
    notify(cfg, state);
  });
  redraw();
  return {
    pickFiles: () => elements.fileInputEl.click(),
    pickFolder: () => elements.folderInputEl.click(),
    addFiles: async (files) => {
      await addFiles(state, cfg, files, elements);
      notify(cfg, state);
    },
    getFiles: () => [...flattenFiles(state.nodes)],
    remove: (id) => {
      if (removeNode(state, id)) {
        redraw();
        notify(cfg, state);
      }
    },
    clear: () => {
      state.nodes = [];
      state.fileKeys.clear();
      redraw();
      notify(cfg, state);
    },
    render: redraw,
    destroy: () => {
      listeners.forEach((removeListener) => removeListener());
      state.nodes = [];
      state.fileKeys.clear();
      mount.replaceChildren();
    }
  };
}
export {
  DEFAULTS,
  initFilePicker,
  putToVm,
  uploadViaVM
};