haiku-react-ui 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,15 +1,1404 @@
 import { cva } from 'class-variance-authority';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
-import { Icon } from '@iconify/react';
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import * as React2 from 'react';
-import { useState, useId, useRef, useCallback, useEffect } from 'react';
+import { forwardRef, useState, useEffect, createElement, useId, useRef, useCallback } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
 // src/components/Button/button.tsx
 function cn(...inputs) {
   return twMerge(clsx(inputs));
 }
+function getIconsTree(data, names) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  const resolved = /* @__PURE__ */ Object.create(null);
+  function resolve(name) {
+    if (icons[name]) return resolved[name] = [];
+    if (!(name in resolved)) {
+      resolved[name] = null;
+      const parent = aliases[name] && aliases[name].parent;
+      const value = parent && resolve(parent);
+      if (value) resolved[name] = [parent].concat(value);
+    }
+    return resolved[name];
+  }
+  Object.keys(icons).concat(Object.keys(aliases)).forEach(resolve);
+  return resolved;
+}
+var defaultIconDimensions = Object.freeze({
+  left: 0,
+  top: 0,
+  width: 16,
+  height: 16
+});
+var defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+var defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+var defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+function mergeIconTransformations(obj1, obj2) {
+  const result = {};
+  if (!obj1.hFlip !== !obj2.hFlip) result.hFlip = true;
+  if (!obj1.vFlip !== !obj2.vFlip) result.vFlip = true;
+  const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+  if (rotate) result.rotate = rotate;
+  return result;
+}
+function mergeIconData(parent, child) {
+  const result = mergeIconTransformations(parent, child);
+  for (const key in defaultExtendedIconProps) if (key in defaultIconTransformations) {
+    if (key in parent && !(key in result)) result[key] = defaultIconTransformations[key];
+  } else if (key in child) result[key] = child[key];
+  else if (key in parent) result[key] = parent[key];
+  return result;
+}
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  let currentProps = {};
+  function parse(name$1) {
+    currentProps = mergeIconData(icons[name$1] || aliases[name$1], currentProps);
+  }
+  parse(name);
+  tree.forEach(parse);
+  return mergeIconData(data, currentProps);
+}
+function parseIconSet(data, callback) {
+  const names = [];
+  if (typeof data !== "object" || typeof data.icons !== "object") return names;
+  if (data.not_found instanceof Array) data.not_found.forEach((name) => {
+    callback(name, null);
+    names.push(name);
+  });
+  const tree = getIconsTree(data);
+  for (const name in tree) {
+    const item = tree[name];
+    if (item) {
+      callback(name, internalGetIconData(data, name, item));
+      names.push(name);
+    }
+  }
+  return names;
+}
+var optionalPropertyDefaults = {
+  provider: "",
+  aliases: {},
+  not_found: {},
+  ...defaultIconDimensions
+};
+function checkOptionalProps(item, defaults) {
+  for (const prop in defaults) if (prop in item && typeof item[prop] !== typeof defaults[prop]) return false;
+  return true;
+}
+function quicklyValidateIconSet(obj) {
+  if (typeof obj !== "object" || obj === null) return null;
+  const data = obj;
+  if (typeof data.prefix !== "string" || !obj.icons || typeof obj.icons !== "object") return null;
+  if (!checkOptionalProps(obj, optionalPropertyDefaults)) return null;
+  const icons = data.icons;
+  for (const name in icons) {
+    const icon = icons[name];
+    if (!name || typeof icon.body !== "string" || !checkOptionalProps(icon, defaultExtendedIconProps)) return null;
+  }
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  for (const name in aliases) {
+    const icon = aliases[name];
+    const parent = icon.parent;
+    if (!name || typeof parent !== "string" || !icons[parent] && !aliases[parent] || !checkOptionalProps(icon, defaultExtendedIconProps)) return null;
+  }
+  return data;
+}
+var dataStorage = /* @__PURE__ */ Object.create(null);
+function newStorage(provider, prefix) {
+  return {
+    provider,
+    prefix,
+    icons: /* @__PURE__ */ Object.create(null),
+    missing: /* @__PURE__ */ new Set()
+  };
+}
+function getStorage(provider, prefix) {
+  const providerStorage = dataStorage[provider] || (dataStorage[provider] = /* @__PURE__ */ Object.create(null));
+  return providerStorage[prefix] || (providerStorage[prefix] = newStorage(provider, prefix));
+}
+function addIconSet(storage2, data) {
+  if (!quicklyValidateIconSet(data)) return [];
+  return parseIconSet(data, (name, icon) => {
+    if (icon) storage2.icons[name] = icon;
+    else storage2.missing.add(name);
+  });
+}
+function addIconToStorage(storage2, name, icon) {
+  try {
+    if (typeof icon.body === "string") {
+      storage2.icons[name] = { ...icon };
+      return true;
+    }
+  } catch (err) {
+  }
+  return false;
+}
+var matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var stringToIcon = (value, validate, allowSimpleName, provider = "") => {
+  const colonSeparated = value.split(":");
+  if (value.slice(0, 1) === "@") {
+    if (colonSeparated.length < 2 || colonSeparated.length > 3) return null;
+    provider = colonSeparated.shift().slice(1);
+  }
+  if (colonSeparated.length > 3 || !colonSeparated.length) return null;
+  if (colonSeparated.length > 1) {
+    const name$1 = colonSeparated.pop();
+    const prefix = colonSeparated.pop();
+    const result = {
+      provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+      prefix,
+      name: name$1
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  const name = colonSeparated[0];
+  const dashSeparated = name.split("-");
+  if (dashSeparated.length > 1) {
+    const result = {
+      provider,
+      prefix: dashSeparated.shift(),
+      name: dashSeparated.join("-")
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  if (allowSimpleName && provider === "") {
+    const result = {
+      provider,
+      prefix: "",
+      name
+    };
+    return validate && !validateIconName(result, allowSimpleName) ? null : result;
+  }
+  return null;
+};
+var validateIconName = (icon, allowSimpleName) => {
+  if (!icon) return false;
+  return !!((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+var simpleNames = false;
+function allowSimpleNames(allow) {
+  if (typeof allow === "boolean") simpleNames = allow;
+  return simpleNames;
+}
+function getIconData(name) {
+  const icon = typeof name === "string" ? stringToIcon(name, true, simpleNames) : name;
+  if (icon) {
+    const storage2 = getStorage(icon.provider, icon.prefix);
+    const iconName = icon.name;
+    return storage2.icons[iconName] || (storage2.missing.has(iconName) ? null : void 0);
+  }
+}
+function addIcon(name, data) {
+  const icon = stringToIcon(name, true, simpleNames);
+  if (!icon) return false;
+  const storage2 = getStorage(icon.provider, icon.prefix);
+  if (data) return addIconToStorage(storage2, icon.name, data);
+  else {
+    storage2.missing.add(icon.name);
+    return true;
+  }
+}
+function addCollection(data, provider) {
+  if (typeof data !== "object") return false;
+  if (typeof provider !== "string") provider = data.provider || "";
+  if (simpleNames && !provider && !data.prefix) {
+    let added = false;
+    if (quicklyValidateIconSet(data)) {
+      data.prefix = "";
+      parseIconSet(data, (name, icon) => {
+        if (addIcon(name, icon)) added = true;
+      });
+    }
+    return added;
+  }
+  const prefix = data.prefix;
+  if (!validateIconName({
+    prefix,
+    name: "a"
+  })) return false;
+  const storage2 = getStorage(provider, prefix);
+  return !!addIconSet(storage2, data);
+}
+var defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+var defaultIconCustomisations = Object.freeze({
+  ...defaultIconSizeCustomisations,
+  ...defaultIconTransformations
+});
+var unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+var unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+  if (ratio === 1) return size;
+  precision = precision || 100;
+  if (typeof size === "number") return Math.ceil(size * ratio * precision) / precision;
+  if (typeof size !== "string") return size;
+  const oldParts = size.split(unitsSplit);
+  if (oldParts === null || !oldParts.length) return size;
+  const newParts = [];
+  let code = oldParts.shift();
+  let isNumber2 = unitsTest.test(code);
+  while (true) {
+    if (isNumber2) {
+      const num = parseFloat(code);
+      if (isNaN(num)) newParts.push(code);
+      else newParts.push(Math.ceil(num * ratio * precision) / precision);
+    } else newParts.push(code);
+    code = oldParts.shift();
+    if (code === void 0) return newParts.join("");
+    isNumber2 = !isNumber2;
+  }
+}
+function splitSVGDefs(content, tag = "defs") {
+  let defs = "";
+  const index = content.indexOf("<" + tag);
+  while (index >= 0) {
+    const start = content.indexOf(">", index);
+    const end = content.indexOf("</" + tag);
+    if (start === -1 || end === -1) break;
+    const endEnd = content.indexOf(">", end);
+    if (endEnd === -1) break;
+    defs += content.slice(start + 1, end).trim();
+    content = content.slice(0, index).trim() + content.slice(endEnd + 1);
+  }
+  return {
+    defs,
+    content
+  };
+}
+function mergeDefsAndContent(defs, content) {
+  return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+function wrapSVGContent(body, start, end) {
+  const split = splitSVGDefs(body);
+  return mergeDefsAndContent(split.defs, start + split.content + end);
+}
+var isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+function iconToSVG(icon, customisations) {
+  const fullIcon = {
+    ...defaultIconProps,
+    ...icon
+  };
+  const fullCustomisations = {
+    ...defaultIconCustomisations,
+    ...customisations
+  };
+  const box = {
+    left: fullIcon.left,
+    top: fullIcon.top,
+    width: fullIcon.width,
+    height: fullIcon.height
+  };
+  let body = fullIcon.body;
+  [fullIcon, fullCustomisations].forEach((props) => {
+    const transformations = [];
+    const hFlip = props.hFlip;
+    const vFlip = props.vFlip;
+    let rotation = props.rotate;
+    if (hFlip) if (vFlip) rotation += 2;
+    else {
+      transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+      transformations.push("scale(-1 1)");
+      box.top = box.left = 0;
+    }
+    else if (vFlip) {
+      transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+      transformations.push("scale(1 -1)");
+      box.top = box.left = 0;
+    }
+    let tempValue;
+    if (rotation < 0) rotation -= Math.floor(rotation / 4) * 4;
+    rotation = rotation % 4;
+    switch (rotation) {
+      case 1:
+        tempValue = box.height / 2 + box.top;
+        transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+      case 2:
+        transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+        break;
+      case 3:
+        tempValue = box.width / 2 + box.left;
+        transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+    }
+    if (rotation % 2 === 1) {
+      if (box.left !== box.top) {
+        tempValue = box.left;
+        box.left = box.top;
+        box.top = tempValue;
+      }
+      if (box.width !== box.height) {
+        tempValue = box.width;
+        box.width = box.height;
+        box.height = tempValue;
+      }
+    }
+    if (transformations.length) body = wrapSVGContent(body, '<g transform="' + transformations.join(" ") + '">', "</g>");
+  });
+  const customisationsWidth = fullCustomisations.width;
+  const customisationsHeight = fullCustomisations.height;
+  const boxWidth = box.width;
+  const boxHeight = box.height;
+  let width;
+  let height;
+  if (customisationsWidth === null) {
+    height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    width = calculateSize(height, boxWidth / boxHeight);
+  } else {
+    width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+    height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+  }
+  const attributes = {};
+  const setAttr = (prop, value) => {
+    if (!isUnsetKeyword(value)) attributes[prop] = value.toString();
+  };
+  setAttr("width", width);
+  setAttr("height", height);
+  const viewBox = [
+    box.left,
+    box.top,
+    boxWidth,
+    boxHeight
+  ];
+  attributes.viewBox = viewBox.join(" ");
+  return {
+    attributes,
+    viewBox,
+    body
+  };
+}
+var regex = /\sid="(\S+)"/g;
+var randomPrefix = "IconifyId" + Date.now().toString(16) + (Math.random() * 16777216 | 0).toString(16);
+var counter = 0;
+function replaceIDs(body, prefix = randomPrefix) {
+  const ids = [];
+  let match;
+  while (match = regex.exec(body)) ids.push(match[1]);
+  if (!ids.length) return body;
+  const suffix = "suffix" + (Math.random() * 16777216 | Date.now()).toString(16);
+  ids.forEach((id) => {
+    const newID = typeof prefix === "function" ? prefix(id) : prefix + (counter++).toString();
+    const escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    body = body.replace(new RegExp('([#;"])(' + escapedID + ')([")]|\\.[a-z])', "g"), "$1" + newID + suffix + "$3");
+  });
+  body = body.replace(new RegExp(suffix, "g"), "");
+  return body;
+}
+var storage = /* @__PURE__ */ Object.create(null);
+function setAPIModule(provider, item) {
+  storage[provider] = item;
+}
+function getAPIModule(provider) {
+  return storage[provider] || storage[""];
+}
+function createAPIConfig(source) {
+  let resources;
+  if (typeof source.resources === "string") resources = [source.resources];
+  else {
+    resources = source.resources;
+    if (!(resources instanceof Array) || !resources.length) return null;
+  }
+  const result = {
+    resources,
+    path: source.path || "/",
+    maxURL: source.maxURL || 500,
+    rotate: source.rotate || 750,
+    timeout: source.timeout || 5e3,
+    random: source.random === true,
+    index: source.index || 0,
+    dataAfterTimeout: source.dataAfterTimeout !== false
+  };
+  return result;
+}
+var configStorage = /* @__PURE__ */ Object.create(null);
+var fallBackAPISources = ["https://api.simplesvg.com", "https://api.unisvg.com"];
+var fallBackAPI = [];
+while (fallBackAPISources.length > 0) if (fallBackAPISources.length === 1) fallBackAPI.push(fallBackAPISources.shift());
+else if (Math.random() > 0.5) fallBackAPI.push(fallBackAPISources.shift());
+else fallBackAPI.push(fallBackAPISources.pop());
+configStorage[""] = createAPIConfig({ resources: ["https://api.iconify.design"].concat(fallBackAPI) });
+function addAPIProvider(provider, customConfig) {
+  const config = createAPIConfig(customConfig);
+  if (config === null) return false;
+  configStorage[provider] = config;
+  return true;
+}
+function getAPIConfig(provider) {
+  return configStorage[provider];
+}
+var detectFetch = () => {
+  let callback;
+  try {
+    callback = fetch;
+    if (typeof callback === "function") return callback;
+  } catch (err) {
+  }
+};
+var fetchModule = detectFetch();
+function calculateMaxLength(provider, prefix) {
+  const config = getAPIConfig(provider);
+  if (!config) return 0;
+  let result;
+  if (!config.maxURL) result = 0;
+  else {
+    let maxHostLength = 0;
+    config.resources.forEach((item) => {
+      const host = item;
+      maxHostLength = Math.max(maxHostLength, host.length);
+    });
+    const url = prefix + ".json?icons=";
+    result = config.maxURL - maxHostLength - config.path.length - url.length;
+  }
+  return result;
+}
+function shouldAbort(status) {
+  return status === 404;
+}
+var prepare = (provider, prefix, icons) => {
+  const results = [];
+  const maxLength = calculateMaxLength(provider, prefix);
+  const type = "icons";
+  let item = {
+    type,
+    provider,
+    prefix,
+    icons: []
+  };
+  let length = 0;
+  icons.forEach((name, index) => {
+    length += name.length + 1;
+    if (length >= maxLength && index > 0) {
+      results.push(item);
+      item = {
+        type,
+        provider,
+        prefix,
+        icons: []
+      };
+      length = name.length;
+    }
+    item.icons.push(name);
+  });
+  results.push(item);
+  return results;
+};
+function getPath(provider) {
+  if (typeof provider === "string") {
+    const config = getAPIConfig(provider);
+    if (config) return config.path;
+  }
+  return "/";
+}
+var send = (host, params, callback) => {
+  if (!fetchModule) {
+    callback("abort", 424);
+    return;
+  }
+  let path = getPath(params.provider);
+  switch (params.type) {
+    case "icons": {
+      const prefix = params.prefix;
+      const icons = params.icons;
+      const iconsList = icons.join(",");
+      const urlParams = new URLSearchParams({ icons: iconsList });
+      path += prefix + ".json?" + urlParams.toString();
+      break;
+    }
+    case "custom": {
+      const uri = params.uri;
+      path += uri.slice(0, 1) === "/" ? uri.slice(1) : uri;
+      break;
+    }
+    default:
+      callback("abort", 400);
+      return;
+  }
+  let defaultError = 503;
+  fetchModule(host + path).then((response) => {
+    const status = response.status;
+    if (status !== 200) {
+      setTimeout(() => {
+        callback(shouldAbort(status) ? "abort" : "next", status);
+      });
+      return;
+    }
+    defaultError = 501;
+    return response.json();
+  }).then((data) => {
+    if (typeof data !== "object" || data === null) {
+      setTimeout(() => {
+        if (data === 404) callback("abort", data);
+        else callback("next", defaultError);
+      });
+      return;
+    }
+    setTimeout(() => {
+      callback("success", data);
+    });
+  }).catch(() => {
+    callback("next", defaultError);
+  });
+};
+var fetchAPIModule = {
+  prepare,
+  send
+};
+function removeCallback(storages, id) {
+  storages.forEach((storage2) => {
+    const items = storage2.loaderCallbacks;
+    if (items) storage2.loaderCallbacks = items.filter((row) => row.id !== id);
+  });
+}
+function updateCallbacks(storage2) {
+  if (!storage2.pendingCallbacksFlag) {
+    storage2.pendingCallbacksFlag = true;
+    setTimeout(() => {
+      storage2.pendingCallbacksFlag = false;
+      const items = storage2.loaderCallbacks ? storage2.loaderCallbacks.slice(0) : [];
+      if (!items.length) return;
+      let hasPending = false;
+      const provider = storage2.provider;
+      const prefix = storage2.prefix;
+      items.forEach((item) => {
+        const icons = item.icons;
+        const oldLength = icons.pending.length;
+        icons.pending = icons.pending.filter((icon) => {
+          if (icon.prefix !== prefix) return true;
+          const name = icon.name;
+          if (storage2.icons[name]) icons.loaded.push({
+            provider,
+            prefix,
+            name
+          });
+          else if (storage2.missing.has(name)) icons.missing.push({
+            provider,
+            prefix,
+            name
+          });
+          else {
+            hasPending = true;
+            return true;
+          }
+          return false;
+        });
+        if (icons.pending.length !== oldLength) {
+          if (!hasPending) removeCallback([storage2], item.id);
+          item.callback(icons.loaded.slice(0), icons.missing.slice(0), icons.pending.slice(0), item.abort);
+        }
+      });
+    });
+  }
+}
+var idCounter = 0;
+function storeCallback(callback, icons, pendingSources) {
+  const id = idCounter++;
+  const abort = removeCallback.bind(null, pendingSources, id);
+  if (!icons.pending.length) return abort;
+  const item = {
+    id,
+    icons,
+    callback,
+    abort
+  };
+  pendingSources.forEach((storage2) => {
+    (storage2.loaderCallbacks || (storage2.loaderCallbacks = [])).push(item);
+  });
+  return abort;
+}
+function sortIcons(icons) {
+  const result = {
+    loaded: [],
+    missing: [],
+    pending: []
+  };
+  const storage2 = /* @__PURE__ */ Object.create(null);
+  icons.sort((a, b) => {
+    if (a.provider !== b.provider) return a.provider.localeCompare(b.provider);
+    if (a.prefix !== b.prefix) return a.prefix.localeCompare(b.prefix);
+    return a.name.localeCompare(b.name);
+  });
+  let lastIcon = {
+    provider: "",
+    prefix: "",
+    name: ""
+  };
+  icons.forEach((icon) => {
+    if (lastIcon.name === icon.name && lastIcon.prefix === icon.prefix && lastIcon.provider === icon.provider) return;
+    lastIcon = icon;
+    const provider = icon.provider;
+    const prefix = icon.prefix;
+    const name = icon.name;
+    const providerStorage = storage2[provider] || (storage2[provider] = /* @__PURE__ */ Object.create(null));
+    const localStorage = providerStorage[prefix] || (providerStorage[prefix] = getStorage(provider, prefix));
+    let list;
+    if (name in localStorage.icons) list = result.loaded;
+    else if (prefix === "" || localStorage.missing.has(name)) list = result.missing;
+    else list = result.pending;
+    const item = {
+      provider,
+      prefix,
+      name
+    };
+    list.push(item);
+  });
+  return result;
+}
+function listToIcons(list, validate = true, simpleNames2 = false) {
+  const result = [];
+  list.forEach((item) => {
+    const icon = typeof item === "string" ? stringToIcon(item, validate, simpleNames2) : item;
+    if (icon) result.push(icon);
+  });
+  return result;
+}
+var defaultConfig = {
+  resources: [],
+  index: 0,
+  timeout: 2e3,
+  rotate: 750,
+  random: false,
+  dataAfterTimeout: false
+};
+function sendQuery(config, payload, query, done) {
+  const resourcesCount = config.resources.length;
+  const startIndex = config.random ? Math.floor(Math.random() * resourcesCount) : config.index;
+  let resources;
+  if (config.random) {
+    let list = config.resources.slice(0);
+    resources = [];
+    while (list.length > 1) {
+      const nextIndex = Math.floor(Math.random() * list.length);
+      resources.push(list[nextIndex]);
+      list = list.slice(0, nextIndex).concat(list.slice(nextIndex + 1));
+    }
+    resources = resources.concat(list);
+  } else resources = config.resources.slice(startIndex).concat(config.resources.slice(0, startIndex));
+  const startTime = Date.now();
+  let status = "pending";
+  let queriesSent = 0;
+  let lastError;
+  let timer = null;
+  let queue = [];
+  let doneCallbacks = [];
+  if (typeof done === "function") doneCallbacks.push(done);
+  function resetTimer() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function abort() {
+    if (status === "pending") status = "aborted";
+    resetTimer();
+    queue.forEach((item) => {
+      if (item.status === "pending") item.status = "aborted";
+    });
+    queue = [];
+  }
+  function subscribe(callback, overwrite) {
+    if (overwrite) doneCallbacks = [];
+    if (typeof callback === "function") doneCallbacks.push(callback);
+  }
+  function getQueryStatus() {
+    return {
+      startTime,
+      payload,
+      status,
+      queriesSent,
+      queriesPending: queue.length,
+      subscribe,
+      abort
+    };
+  }
+  function failQuery() {
+    status = "failed";
+    doneCallbacks.forEach((callback) => {
+      callback(void 0, lastError);
+    });
+  }
+  function clearQueue() {
+    queue.forEach((item) => {
+      if (item.status === "pending") item.status = "aborted";
+    });
+    queue = [];
+  }
+  function moduleResponse(item, response, data) {
+    const isError = response !== "success";
+    queue = queue.filter((queued) => queued !== item);
+    switch (status) {
+      case "pending":
+        break;
+      case "failed":
+        if (isError || !config.dataAfterTimeout) return;
+        break;
+      default:
+        return;
+    }
+    if (response === "abort") {
+      lastError = data;
+      failQuery();
+      return;
+    }
+    if (isError) {
+      lastError = data;
+      if (!queue.length) if (!resources.length) failQuery();
+      else execNext();
+      return;
+    }
+    resetTimer();
+    clearQueue();
+    if (!config.random) {
+      const index = config.resources.indexOf(item.resource);
+      if (index !== -1 && index !== config.index) config.index = index;
+    }
+    status = "completed";
+    doneCallbacks.forEach((callback) => {
+      callback(data);
+    });
+  }
+  function execNext() {
+    if (status !== "pending") return;
+    resetTimer();
+    const resource = resources.shift();
+    if (resource === void 0) {
+      if (queue.length) {
+        timer = setTimeout(() => {
+          resetTimer();
+          if (status === "pending") {
+            clearQueue();
+            failQuery();
+          }
+        }, config.timeout);
+        return;
+      }
+      failQuery();
+      return;
+    }
+    const item = {
+      status: "pending",
+      resource,
+      callback: (status$1, data) => {
+        moduleResponse(item, status$1, data);
+      }
+    };
+    queue.push(item);
+    queriesSent++;
+    timer = setTimeout(execNext, config.rotate);
+    query(resource, payload, item.callback);
+  }
+  setTimeout(execNext);
+  return getQueryStatus;
+}
+function initRedundancy(cfg) {
+  const config = {
+    ...defaultConfig,
+    ...cfg
+  };
+  let queries = [];
+  function cleanup() {
+    queries = queries.filter((item) => item().status === "pending");
+  }
+  function query(payload, queryCallback, doneCallback) {
+    const query$1 = sendQuery(config, payload, queryCallback, (data, error) => {
+      cleanup();
+      if (doneCallback) doneCallback(data, error);
+    });
+    queries.push(query$1);
+    return query$1;
+  }
+  function find(callback) {
+    return queries.find((value) => {
+      return callback(value);
+    }) || null;
+  }
+  const instance = {
+    query,
+    find,
+    setIndex: (index) => {
+      config.index = index;
+    },
+    getIndex: () => config.index,
+    cleanup
+  };
+  return instance;
+}
+function emptyCallback$1() {
+}
+var redundancyCache = /* @__PURE__ */ Object.create(null);
+function getRedundancyCache(provider) {
+  if (!redundancyCache[provider]) {
+    const config = getAPIConfig(provider);
+    if (!config) return;
+    const redundancy = initRedundancy(config);
+    const cachedReundancy = {
+      config,
+      redundancy
+    };
+    redundancyCache[provider] = cachedReundancy;
+  }
+  return redundancyCache[provider];
+}
+function sendAPIQuery(target, query, callback) {
+  let redundancy;
+  let send2;
+  if (typeof target === "string") {
+    const api = getAPIModule(target);
+    if (!api) {
+      callback(void 0, 424);
+      return emptyCallback$1;
+    }
+    send2 = api.send;
+    const cached = getRedundancyCache(target);
+    if (cached) redundancy = cached.redundancy;
+  } else {
+    const config = createAPIConfig(target);
+    if (config) {
+      redundancy = initRedundancy(config);
+      const moduleKey = target.resources ? target.resources[0] : "";
+      const api = getAPIModule(moduleKey);
+      if (api) send2 = api.send;
+    }
+  }
+  if (!redundancy || !send2) {
+    callback(void 0, 424);
+    return emptyCallback$1;
+  }
+  return redundancy.query(query, send2, callback)().abort;
+}
+function emptyCallback() {
+}
+function loadedNewIcons(storage2) {
+  if (!storage2.iconsLoaderFlag) {
+    storage2.iconsLoaderFlag = true;
+    setTimeout(() => {
+      storage2.iconsLoaderFlag = false;
+      updateCallbacks(storage2);
+    });
+  }
+}
+function checkIconNamesForAPI(icons) {
+  const valid = [];
+  const invalid = [];
+  icons.forEach((name) => {
+    (name.match(matchIconName) ? valid : invalid).push(name);
+  });
+  return {
+    valid,
+    invalid
+  };
+}
+function parseLoaderResponse(storage2, icons, data) {
+  function checkMissing() {
+    const pending = storage2.pendingIcons;
+    icons.forEach((name) => {
+      if (pending) pending.delete(name);
+      if (!storage2.icons[name]) storage2.missing.add(name);
+    });
+  }
+  if (data && typeof data === "object") try {
+    const parsed = addIconSet(storage2, data);
+    if (!parsed.length) {
+      checkMissing();
+      return;
+    }
+  } catch (err) {
+    console.error(err);
+  }
+  checkMissing();
+  loadedNewIcons(storage2);
+}
+function parsePossiblyAsyncResponse(response, callback) {
+  if (response instanceof Promise) response.then((data) => {
+    callback(data);
+  }).catch(() => {
+    callback(null);
+  });
+  else callback(response);
+}
+function loadNewIcons(storage2, icons) {
+  if (!storage2.iconsToLoad) storage2.iconsToLoad = icons;
+  else storage2.iconsToLoad = storage2.iconsToLoad.concat(icons).sort();
+  if (!storage2.iconsQueueFlag) {
+    storage2.iconsQueueFlag = true;
+    setTimeout(() => {
+      storage2.iconsQueueFlag = false;
+      const { provider, prefix } = storage2;
+      const icons$1 = storage2.iconsToLoad;
+      delete storage2.iconsToLoad;
+      if (!icons$1 || !icons$1.length) return;
+      const customIconLoader = storage2.loadIcon;
+      if (storage2.loadIcons && (icons$1.length > 1 || !customIconLoader)) {
+        parsePossiblyAsyncResponse(storage2.loadIcons(icons$1, prefix, provider), (data) => {
+          parseLoaderResponse(storage2, icons$1, data);
+        });
+        return;
+      }
+      if (customIconLoader) {
+        icons$1.forEach((name) => {
+          const response = customIconLoader(name, prefix, provider);
+          parsePossiblyAsyncResponse(response, (data) => {
+            const iconSet = data ? {
+              prefix,
+              icons: { [name]: data }
+            } : null;
+            parseLoaderResponse(storage2, [name], iconSet);
+          });
+        });
+        return;
+      }
+      const { valid, invalid } = checkIconNamesForAPI(icons$1);
+      if (invalid.length) parseLoaderResponse(storage2, invalid, null);
+      if (!valid.length) return;
+      const api = prefix.match(matchIconName) ? getAPIModule(provider) : null;
+      if (!api) {
+        parseLoaderResponse(storage2, valid, null);
+        return;
+      }
+      const params = api.prepare(provider, prefix, valid);
+      params.forEach((item) => {
+        sendAPIQuery(provider, item, (data) => {
+          parseLoaderResponse(storage2, item.icons, data);
+        });
+      });
+    });
+  }
+}
+var loadIcons = (icons, callback) => {
+  const cleanedIcons = listToIcons(icons, true, allowSimpleNames());
+  const sortedIcons = sortIcons(cleanedIcons);
+  if (!sortedIcons.pending.length) {
+    let callCallback = true;
+    if (callback) setTimeout(() => {
+      if (callCallback) callback(sortedIcons.loaded, sortedIcons.missing, sortedIcons.pending, emptyCallback);
+    });
+    return () => {
+      callCallback = false;
+    };
+  }
+  const newIcons = /* @__PURE__ */ Object.create(null);
+  const sources = [];
+  let lastProvider, lastPrefix;
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix } = icon;
+    if (prefix === lastPrefix && provider === lastProvider) return;
+    lastProvider = provider;
+    lastPrefix = prefix;
+    sources.push(getStorage(provider, prefix));
+    const providerNewIcons = newIcons[provider] || (newIcons[provider] = /* @__PURE__ */ Object.create(null));
+    if (!providerNewIcons[prefix]) providerNewIcons[prefix] = [];
+  });
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix, name } = icon;
+    const storage2 = getStorage(provider, prefix);
+    const pendingQueue = storage2.pendingIcons || (storage2.pendingIcons = /* @__PURE__ */ new Set());
+    if (!pendingQueue.has(name)) {
+      pendingQueue.add(name);
+      newIcons[provider][prefix].push(name);
+    }
+  });
+  sources.forEach((storage2) => {
+    const list = newIcons[storage2.provider][storage2.prefix];
+    if (list.length) loadNewIcons(storage2, list);
+  });
+  return callback ? storeCallback(callback, sortedIcons, sources) : emptyCallback;
+};
+function mergeCustomisations(defaults, item) {
+  const result = { ...defaults };
+  for (const key in item) {
+    const value = item[key];
+    const valueType = typeof value;
+    if (key in defaultIconSizeCustomisations) {
+      if (value === null || value && (valueType === "string" || valueType === "number")) result[key] = value;
+    } else if (valueType === typeof result[key]) result[key] = key === "rotate" ? value % 4 : value;
+  }
+  return result;
+}
+var separator = /[\s,]+/;
+function flipFromString(custom, flip) {
+  flip.split(separator).forEach((str) => {
+    const value = str.trim();
+    switch (value) {
+      case "horizontal":
+        custom.hFlip = true;
+        break;
+      case "vertical":
+        custom.vFlip = true;
+        break;
+    }
+  });
+}
+function rotateFromString(value, defaultValue = 0) {
+  const units = value.replace(/^-?[0-9.]*/, "");
+  function cleanup(value$1) {
+    while (value$1 < 0) value$1 += 4;
+    return value$1 % 4;
+  }
+  if (units === "") {
+    const num = parseInt(value);
+    return isNaN(num) ? 0 : cleanup(num);
+  } else if (units !== value) {
+    let split = 0;
+    switch (units) {
+      case "%":
+        split = 25;
+        break;
+      case "deg":
+        split = 90;
+    }
+    if (split) {
+      let num = parseFloat(value.slice(0, value.length - units.length));
+      if (isNaN(num)) return 0;
+      num = num / split;
+      return num % 1 === 0 ? cleanup(num) : 0;
+    }
+  }
+  return defaultValue;
+}
+function iconToHTML(body, attributes) {
+  let renderAttribsHTML = body.indexOf("xlink:") === -1 ? "" : ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+  for (const attr in attributes) renderAttribsHTML += " " + attr + '="' + attributes[attr] + '"';
+  return '<svg xmlns="http://www.w3.org/2000/svg"' + renderAttribsHTML + ">" + body + "</svg>";
+}
+function encodeSVGforURL(svg) {
+  return svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ");
+}
+function svgToData(svg) {
+  return "data:image/svg+xml," + encodeSVGforURL(svg);
+}
+function svgToURL(svg) {
+  return 'url("' + svgToData(svg) + '")';
+}
+var policy;
+function createPolicy() {
+  try {
+    policy = window.trustedTypes.createPolicy("iconify", { createHTML: (s) => s });
+  } catch (err) {
+    policy = null;
+  }
+}
+function cleanUpInnerHTML(html) {
+  if (policy === void 0) createPolicy();
+  return policy ? policy.createHTML(html) : html;
+}
+var defaultExtendedIconCustomisations = {
+  ...defaultIconCustomisations,
+  inline: false
+};
+var svgDefaults = {
+  "xmlns": "http://www.w3.org/2000/svg",
+  "xmlnsXlink": "http://www.w3.org/1999/xlink",
+  "aria-hidden": true,
+  "role": "img"
+};
+var commonProps = {
+  display: "inline-block"
+};
+var monotoneProps = {
+  backgroundColor: "currentColor"
+};
+var coloredProps = {
+  backgroundColor: "transparent"
+};
+var propsToAdd = {
+  Image: "var(--svg)",
+  Repeat: "no-repeat",
+  Size: "100% 100%"
+};
+var propsToAddTo = {
+  WebkitMask: monotoneProps,
+  mask: monotoneProps,
+  background: coloredProps
+};
+for (const prefix in propsToAddTo) {
+  const list = propsToAddTo[prefix];
+  for (const prop in propsToAdd) {
+    list[prefix + prop] = propsToAdd[prop];
+  }
+}
+var inlineDefaults = {
+  ...defaultExtendedIconCustomisations,
+  inline: true
+};
+function fixSize(value) {
+  return value + (value.match(/^[-0-9.]+$/) ? "px" : "");
+}
+var render = (icon, props, name) => {
+  const defaultProps = props.inline ? inlineDefaults : defaultExtendedIconCustomisations;
+  const customisations = mergeCustomisations(defaultProps, props);
+  const mode = props.mode || "svg";
+  const style = {};
+  const customStyle = props.style || {};
+  const componentProps = {
+    ...mode === "svg" ? svgDefaults : {}
+  };
+  if (name) {
+    const iconName = stringToIcon(name, false, true);
+    if (iconName) {
+      const classNames = ["iconify"];
+      const props2 = [
+        "provider",
+        "prefix"
+      ];
+      for (const prop of props2) {
+        if (iconName[prop]) {
+          classNames.push("iconify--" + iconName[prop]);
+        }
+      }
+      componentProps.className = classNames.join(" ");
+    }
+  }
+  for (let key in props) {
+    const value = props[key];
+    if (value === void 0) {
+      continue;
+    }
+    switch (key) {
+      // Properties to ignore
+      case "icon":
+      case "style":
+      case "children":
+      case "onLoad":
+      case "mode":
+      case "ssr":
+      case "fallback":
+        break;
+      // Forward ref
+      case "_ref":
+        componentProps.ref = value;
+        break;
+      // Merge class names
+      case "className":
+        componentProps[key] = (componentProps[key] ? componentProps[key] + " " : "") + value;
+        break;
+      // Boolean attributes
+      case "inline":
+      case "hFlip":
+      case "vFlip":
+        customisations[key] = value === true || value === "true" || value === 1;
+        break;
+      // Flip as string: 'horizontal,vertical'
+      case "flip":
+        if (typeof value === "string") {
+          flipFromString(customisations, value);
+        }
+        break;
+      // Color: copy to style
+      case "color":
+        style.color = value;
+        break;
+      // Rotation as string
+      case "rotate":
+        if (typeof value === "string") {
+          customisations[key] = rotateFromString(value);
+        } else if (typeof value === "number") {
+          customisations[key] = value;
+        }
+        break;
+      // Remove aria-hidden
+      case "ariaHidden":
+      case "aria-hidden":
+        if (value !== true && value !== "true") {
+          delete componentProps["aria-hidden"];
+        }
+        break;
+      // Copy missing property if it does not exist in customisations
+      default:
+        if (defaultProps[key] === void 0) {
+          componentProps[key] = value;
+        }
+    }
+  }
+  const item = iconToSVG(icon, customisations);
+  const renderAttribs = item.attributes;
+  if (customisations.inline) {
+    style.verticalAlign = "-0.125em";
+  }
+  if (mode === "svg") {
+    componentProps.style = {
+      ...style,
+      ...customStyle
+    };
+    Object.assign(componentProps, renderAttribs);
+    let localCounter = 0;
+    let id = props.id;
+    if (typeof id === "string") {
+      id = id.replace(/-/g, "_");
+    }
+    componentProps.dangerouslySetInnerHTML = {
+      __html: cleanUpInnerHTML(replaceIDs(item.body, id ? () => id + "ID" + localCounter++ : "iconifyReact"))
+    };
+    return createElement("svg", componentProps);
+  }
+  const { body, width, height } = icon;
+  const useMask = mode === "mask" || (mode === "bg" ? false : body.indexOf("currentColor") !== -1);
+  const html = iconToHTML(body, {
+    ...renderAttribs,
+    width: width + "",
+    height: height + ""
+  });
+  componentProps.style = {
+    ...style,
+    "--svg": svgToURL(html),
+    "width": fixSize(renderAttribs.width),
+    "height": fixSize(renderAttribs.height),
+    ...commonProps,
+    ...useMask ? monotoneProps : coloredProps,
+    ...customStyle
+  };
+  return createElement("span", componentProps);
+};
+allowSimpleNames(true);
+setAPIModule("", fetchAPIModule);
+if (typeof document !== "undefined" && typeof window !== "undefined") {
+  const _window = window;
+  if (_window.IconifyPreload !== void 0) {
+    const preload = _window.IconifyPreload;
+    const err = "Invalid IconifyPreload syntax.";
+    if (typeof preload === "object" && preload !== null) {
+      (preload instanceof Array ? preload : [preload]).forEach((item) => {
+        try {
+          if (
+            // Check if item is an object and not null/array
+            typeof item !== "object" || item === null || item instanceof Array || // Check for 'icons' and 'prefix'
+            typeof item.icons !== "object" || typeof item.prefix !== "string" || // Add icon set
+            !addCollection(item)
+          ) {
+            console.error(err);
+          }
+        } catch (e) {
+          console.error(err);
+        }
+      });
+    }
+  }
+  if (_window.IconifyProviders !== void 0) {
+    const providers = _window.IconifyProviders;
+    if (typeof providers === "object" && providers !== null) {
+      for (let key in providers) {
+        const err = "IconifyProviders[" + key + "] is invalid.";
+        try {
+          const value = providers[key];
+          if (typeof value !== "object" || !value || value.resources === void 0) {
+            continue;
+          }
+          if (!addAPIProvider(key, value)) {
+            console.error(err);
+          }
+        } catch (e) {
+          console.error(err);
+        }
+      }
+    }
+  }
+}
+function IconComponent(props) {
+  const [mounted, setMounted] = useState(!!props.ssr);
+  const [abort, setAbort] = useState({});
+  function getInitialState(mounted2) {
+    if (mounted2) {
+      const name2 = props.icon;
+      if (typeof name2 === "object") {
+        return {
+          name: "",
+          data: name2
+        };
+      }
+      const data2 = getIconData(name2);
+      if (data2) {
+        return {
+          name: name2,
+          data: data2
+        };
+      }
+    }
+    return {
+      name: ""
+    };
+  }
+  const [state, setState] = useState(getInitialState(!!props.ssr));
+  function cleanup() {
+    const callback = abort.callback;
+    if (callback) {
+      callback();
+      setAbort({});
+    }
+  }
+  function changeState(newState) {
+    if (JSON.stringify(state) !== JSON.stringify(newState)) {
+      cleanup();
+      setState(newState);
+      return true;
+    }
+  }
+  function updateState() {
+    var _a;
+    const name2 = props.icon;
+    if (typeof name2 === "object") {
+      changeState({
+        name: "",
+        data: name2
+      });
+      return;
+    }
+    const data2 = getIconData(name2);
+    if (changeState({
+      name: name2,
+      data: data2
+    })) {
+      if (data2 === void 0) {
+        const callback = loadIcons([name2], updateState);
+        setAbort({
+          callback
+        });
+      } else if (data2) {
+        (_a = props.onLoad) === null || _a === void 0 ? void 0 : _a.call(props, name2);
+      }
+    }
+  }
+  useEffect(() => {
+    setMounted(true);
+    return cleanup;
+  }, []);
+  useEffect(() => {
+    if (mounted) {
+      updateState();
+    }
+  }, [props.icon, mounted]);
+  const { name, data } = state;
+  if (!data) {
+    return props.children ? props.children : props.fallback ? props.fallback : createElement("span", {});
+  }
+  return render({
+    ...defaultIconProps,
+    ...data
+  }, props, name);
+}
+var Icon = forwardRef((props, ref) => IconComponent({
+  ...props,
+  _ref: ref
+}));
+forwardRef((props, ref) => IconComponent({
+  inline: true,
+  ...props,
+  _ref: ref
+}));
 var buttonVariants = cva(
   "inline-flex cursor-pointer items-center justify-center gap-2 whitespace-nowrap text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary-300 focus-visible:ring-offset-2 focus-visible:ring-offset-white dark:focus-visible:ring-primary-700 dark:focus-visible:ring-offset-zinc-950",
   {
@@ -833,6 +2222,138 @@ var uploadFile = ({
   }
   xhr.send(formData);
 });
+var splitFileIntoChunks = (file, chunkSize) => {
+  const chunks = [];
+  let start = 0;
+  let index = 0;
+  while (start < file.size) {
+    const end = Math.min(start + chunkSize, file.size);
+    const blob = file.slice(start, end);
+    chunks.push({
+      blob,
+      index,
+      start,
+      end
+    });
+    start = end;
+    index++;
+  }
+  return chunks;
+};
+var uploadChunk = ({
+  action,
+  chunk,
+  chunkIndex,
+  totalChunks,
+  fileName,
+  fileSize,
+  method = "post",
+  headers,
+  onProgress,
+  signal
+}) => new Promise((resolve, reject) => {
+  const xhr = new XMLHttpRequest();
+  xhr.open(method.toUpperCase(), action, true);
+  const handleAbort = () => {
+    xhr.abort();
+  };
+  if (headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      xhr.setRequestHeader(key, value);
+    });
+  }
+  xhr.upload.onprogress = (event) => {
+    onProgress == null ? void 0 : onProgress(event);
+  };
+  xhr.onload = () => {
+    signal == null ? void 0 : signal.removeEventListener("abort", handleAbort);
+    if (xhr.status >= 200 && xhr.status < 300) {
+      resolve(xhr.responseText);
+    } else {
+      reject(new Error(`Chunk upload failed: ${xhr.statusText}`));
+    }
+  };
+  xhr.onerror = (event) => {
+    signal == null ? void 0 : signal.removeEventListener("abort", handleAbort);
+    reject(event);
+  };
+  xhr.onabort = () => {
+    signal == null ? void 0 : signal.removeEventListener("abort", handleAbort);
+    reject(new DOMException("Chunk upload aborted", "AbortError"));
+  };
+  if (signal == null ? void 0 : signal.aborted) {
+    reject(new DOMException("Chunk upload aborted", "AbortError"));
+    return;
+  }
+  signal == null ? void 0 : signal.addEventListener("abort", handleAbort);
+  const formData = new FormData();
+  formData.append("file", chunk);
+  formData.append("chunkIndex", String(chunkIndex));
+  formData.append("totalChunks", String(totalChunks));
+  formData.append("fileName", fileName);
+  formData.append("fileSize", String(fileSize));
+  xhr.send(formData);
+});
+var checkUploadedChunks = (action, file, chunkSize, headers) => new Promise((resolve, _reject) => {
+  const xhr = new XMLHttpRequest();
+  const params = new URLSearchParams({
+    fileName: file.name,
+    fileSize: String(file.size),
+    chunkSize: String(chunkSize)
+  });
+  xhr.open("GET", `${action}?${params}`, true);
+  if (headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      xhr.setRequestHeader(key, value);
+    });
+  }
+  xhr.onload = () => {
+    if (xhr.status >= 200 && xhr.status < 300) {
+      resolve(xhr.responseText);
+    } else {
+      resolve("[]");
+    }
+  };
+  xhr.onerror = () => {
+    resolve("[]");
+  };
+  xhr.ontimeout = () => {
+    resolve("[]");
+  };
+  xhr.send();
+}).then((responseText) => {
+  try {
+    const data = JSON.parse(responseText);
+    return data.uploadedChunks || [];
+  } catch (e) {
+    return [];
+  }
+});
+var mergeChunks = (action, fileName, totalChunks, method = "post", headers) => new Promise((resolve, reject) => {
+  const xhr = new XMLHttpRequest();
+  xhr.open(method.toUpperCase(), action, true);
+  if (headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      xhr.setRequestHeader(key, value);
+    });
+  }
+  xhr.setRequestHeader("Content-Type", "application/json");
+  xhr.onload = () => {
+    if (xhr.status >= 200 && xhr.status < 300) {
+      resolve(xhr.responseText);
+    } else {
+      reject(new Error(`Merge chunks failed: ${xhr.statusText}`));
+    }
+  };
+  xhr.onerror = (event) => {
+    reject(event);
+  };
+  const body = JSON.stringify({
+    fileName,
+    totalChunks
+  });
+  xhr.send(body);
+});
 var uploadTriggerVariants = cva(
   "flex cursor-pointer select-none items-center justify-center gap-2 whitespace-nowrap text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary-300 focus-visible:ring-offset-2 focus-visible:ring-offset-white",
   {
@@ -1084,7 +2605,97 @@ function ImageUpload({
     }
   );
 }
-function FileItem({ file, onRemove, onCancel }) {
+function ChunkItem({ index, progress, isCompleted, isUploading, isPending }) {
+  const getStatusColor = () => {
+    if (isCompleted) return "bg-green-500";
+    if (isUploading) return "bg-blue-500";
+    return "bg-gray-300";
+  };
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1", children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `w-2 h-2 rounded-full ${getStatusColor()} transition-all duration-200`,
+      title: `\u5206\u7247 ${index + 1}: ${isCompleted ? "\u5DF2\u5B8C\u6210" : isUploading ? `${progress}%` : "\u7B49\u5F85\u4E2D"}`,
+      children: isUploading && /* @__PURE__ */ jsxs("svg", { className: "w-2 h-2 -rotate-90", viewBox: "0 0 8 8", children: [
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: "4",
+            cy: "4",
+            r: "3",
+            fill: "none",
+            stroke: "#e5e7eb",
+            strokeWidth: "1"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: "4",
+            cy: "4",
+            r: "3",
+            fill: "none",
+            stroke: "#3b82f6",
+            strokeWidth: "1",
+            strokeDasharray: `${progress * 0.188} 18.8`,
+            strokeLinecap: "round"
+          }
+        )
+      ] })
+    }
+  ) });
+}
+function ChunkList({ chunkProgress, totalChunks }) {
+  if (!chunkProgress || totalChunks <= 1) {
+    return null;
+  }
+  const { uploadedChunks, chunkIndex, chunkProgress: currentProgress } = chunkProgress;
+  const chunks = Array.from({ length: totalChunks }, (_, i) => {
+    if (i < uploadedChunks) {
+      return { index: i, status: "completed" };
+    } else if (i === chunkIndex) {
+      return { index: i, status: "uploading", progress: currentProgress };
+    } else {
+      return { index: i, status: "pending" };
+    }
+  });
+  if (totalChunks > 20) {
+    return /* @__PURE__ */ jsx("div", { className: "mt-1 text-xs text-gray-400", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsxs("span", { children: [
+        uploadedChunks,
+        "/",
+        totalChunks,
+        " \u5206\u7247\u5DF2\u4E0A\u4F20"
+      ] }),
+      chunkIndex !== void 0 && /* @__PURE__ */ jsxs("span", { className: "text-blue-500", children: [
+        "\u5F53\u524D: \u5206\u7247 ",
+        chunkIndex + 1,
+        " (",
+        currentProgress,
+        "%)"
+      ] })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "mt-1 flex items-center gap-0.5 flex-wrap", children: [
+    chunks.map((chunk) => /* @__PURE__ */ jsx(
+      ChunkItem,
+      {
+        index: chunk.index,
+        progress: chunk.progress || 0,
+        isCompleted: chunk.status === "completed",
+        isUploading: chunk.status === "uploading",
+        isPending: chunk.status === "pending"
+      },
+      chunk.index
+    )),
+    /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-400 ml-1", children: [
+      uploadedChunks,
+      "/",
+      totalChunks
+    ] })
+  ] });
+}
+function FileItem({ file, onRemove, onCancel, chunkProgress }) {
   const { id, file: fileData, status, progress, error } = file;
   const iconMap = {
     idle: { icon: "lucide:file", className: "text-gray-400" },
@@ -1106,17 +2717,26 @@ function FileItem({ file, onRemove, onCancel }) {
         /* @__PURE__ */ jsx("span", { className: "text-xs text-gray-500 ml-2", children: formatSize(fileData.size) })
       ] }),
       (status === "uploading" || status === "success") && /* @__PURE__ */ jsxs("div", { className: "mt-1", children: [
-        /* @__PURE__ */ jsx("div", { className: "h-1.5 w-full bg-gray-200 rounded-full overflow-hidden", children: /* @__PURE__ */ jsx(
-          "div",
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1 h-1.5 bg-gray-200 rounded-full overflow-hidden", children: /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "h-full bg-blue-500 transition-all duration-300",
+              style: { width: `${progress}%` }
+            }
+          ) }),
+          /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-500 whitespace-nowrap", children: [
+            progress,
+            "%"
+          ] })
+        ] }),
+        chunkProgress && chunkProgress.totalChunks > 1 && /* @__PURE__ */ jsx(
+          ChunkList,
           {
-            className: "h-full bg-blue-500 transition-all duration-300",
-            style: { width: `${progress}%` }
+            chunkProgress,
+            totalChunks: chunkProgress.totalChunks
           }
-        ) }),
-        /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-500", children: [
-          progress,
-          "%"
-        ] })
+        )
       ] }),
       status === "error" && error && /* @__PURE__ */ jsx("div", { className: "mt-1 text-xs text-red-500", children: error.message })
     ] }),
@@ -1144,7 +2764,7 @@ function FileItem({ file, onRemove, onCancel }) {
     ] })
   ] });
 }
-function FileList({ files, onRemove, onCancel, show = true }) {
+function FileList({ files, onRemove, onCancel, show = true, chunkProgressMap }) {
   if (!show || files.length === 0) {
     return null;
   }
@@ -1153,7 +2773,8 @@ function FileList({ files, onRemove, onCancel, show = true }) {
     {
       file,
       onRemove,
-      onCancel
+      onCancel,
+      chunkProgress: chunkProgressMap == null ? void 0 : chunkProgressMap[file.id]
     },
     file.id
   )) });
@@ -1168,6 +2789,26 @@ var DEFAULT_OPTIONS = {
   method: "post",
   name: "file"
 };
+var DEFAULT_CHUNKED_CONFIG = {
+  chunked: false,
+  chunkSize: 2 * 1024 * 1024,
+  // 2MB
+  chunkConcurrency: 0,
+  // 0 表示根据文件大小自动计算
+  resumable: false,
+  chunkedUrl: "",
+  mergeUrl: "",
+  chunkThreshold: 5 * 1024 * 1024
+  // 5MB
+};
+var calculateConcurrency = (fileSize) => {
+  const mb = fileSize / 1024 / 1024;
+  if (mb < 10) return 2;
+  if (mb < 50) return 3;
+  if (mb < 100) return 4;
+  if (mb < 500) return 5;
+  return 6;
+};
 var createUploadError = (type, message, file, originalError) => ({
   type,
   message,
@@ -1180,6 +2821,10 @@ function Upload(config) {
     ...DEFAULT_OPTIONS,
     ...config
   };
+  const chunkedConfig = {
+    ...DEFAULT_CHUNKED_CONFIG,
+    ...config.chunkedConfig
+  };
   const {
     mode,
     autoUpload,
@@ -1203,11 +2848,21 @@ function Upload(config) {
     onError,
     onComplete
   } = options;
+  const {
+    chunked,
+    chunkSize,
+    chunkConcurrency,
+    resumable,
+    chunkedUrl,
+    mergeUrl,
+    chunkThreshold
+  } = chunkedConfig;
   const [files, setFiles] = useState([]);
   const [isDragging, setIsDragging] = useState(false);
   const [previewUrl, setPreviewUrl] = useState(null);
   const [status, setStatus] = useState("idle");
   const [progress, setProgress] = useState(0);
+  const [chunkProgress, setChunkProgress] = useState({});
   const inputId = useId();
   const abortRef = useRef(null);
   const cancelRef = useRef(false);
@@ -1257,6 +2912,24 @@ function Upload(config) {
     const { file } = fileItem;
     const controller = new AbortController();
     abortRef.current = controller;
+    const useChunkedUpload = chunked && file.size > chunkThreshold;
+    if (!useChunkedUpload) {
+      return uploadWithNormalMode(
+        fileItem,
+        totalBytes,
+        uploadedBytes,
+        controller
+      );
+    }
+    return uploadWithChunkedMode(
+      fileItem,
+      totalBytes,
+      uploadedBytes,
+      controller
+    );
+  };
+  const uploadWithNormalMode = async (fileItem, totalBytes, uploadedBytes, controller) => {
+    const { file } = fileItem;
     try {
       const formData = new FormData();
       formData.append(name, file);
@@ -1314,6 +2987,156 @@ function Upload(config) {
       return { ...fileItem, status: "error", error };
     }
   };
+  const uploadWithChunkedMode = async (fileItem, totalBytes, uploadedBytes, controller) => {
+    const { file } = fileItem;
+    const fileId = fileItem.id;
+    try {
+      let uploadedChunkIndices = [];
+      if (resumable && chunkedUrl) {
+        uploadedChunkIndices = await checkUploadedChunks(
+          chunkedUrl,
+          file,
+          chunkSize,
+          headers
+        );
+      }
+      const chunks = splitFileIntoChunks(file, chunkSize);
+      const totalChunks = chunks.length;
+      const actualConcurrency = chunkConcurrency > 0 ? Math.min(chunkConcurrency, totalChunks) : Math.min(calculateConcurrency(file.size), totalChunks);
+      const chunksToUpload = chunks.filter(
+        (chunk) => !uploadedChunkIndices.includes(chunk.index)
+      );
+      const completedChunksRef = { current: uploadedChunkIndices.length };
+      const chunkProgressMapRef = { current: /* @__PURE__ */ new Map() };
+      const uploadTasks = chunksToUpload.map((chunk) => async () => {
+        if (cancelRef.current || controller.signal.aborted) {
+          throw new DOMException("Upload aborted", "AbortError");
+        }
+        chunkProgressMapRef.current.set(chunk.index, 0);
+        await uploadChunk({
+          action,
+          chunk: chunk.blob,
+          chunkIndex: chunk.index,
+          totalChunks,
+          fileName: file.name,
+          fileSize: file.size,
+          method,
+          headers,
+          signal: controller.signal,
+          onProgress: (event) => {
+            if (!event.lengthComputable) {
+              return;
+            }
+            const chunkLoaded = event.loaded;
+            const chunkTotal = chunk.end - chunk.start;
+            const chunkProgressPercent = Math.min(
+              100,
+              Math.round(chunkLoaded / chunkTotal * 100)
+            );
+            chunkProgressMapRef.current.set(chunk.index, chunkProgressPercent);
+            const completedCount = completedChunksRef.current;
+            let inProgressProgress = 0;
+            chunkProgressMapRef.current.forEach((progress2) => {
+              inProgressProgress += progress2;
+            });
+            const totalProgress = Math.min(
+              100,
+              Math.round(
+                (completedCount * 100 + inProgressProgress) / totalChunks
+              )
+            );
+            setChunkProgress((prev) => ({
+              ...prev,
+              [fileId]: {
+                chunkIndex: chunk.index,
+                chunkProgress: chunkProgressPercent,
+                totalProgress,
+                uploadedChunks: completedCount,
+                totalChunks
+              }
+            }));
+            setProgress(totalProgress);
+            onProgress == null ? void 0 : onProgress(totalProgress, file);
+            setFiles(
+              (prev) => prev.map(
+                (f) => f.id === fileItem.id ? { ...f, progress: totalProgress } : f
+              )
+            );
+          }
+        });
+        completedChunksRef.current++;
+        chunkProgressMapRef.current.delete(chunk.index);
+        return chunk.index;
+      });
+      const executeWithConcurrency = async (tasks, limit) => {
+        const results = [];
+        const executing = [];
+        let taskIndex = 0;
+        const runTask = async (task) => {
+          const result = await task();
+          return result;
+        };
+        while (taskIndex < tasks.length || executing.length > 0) {
+          while (taskIndex < tasks.length && executing.length < limit) {
+            const task = tasks[taskIndex];
+            taskIndex++;
+            const promise = runTask(task).then((result) => {
+              results.push(result);
+              return result;
+            });
+            executing.push(promise);
+          }
+          if (executing.length > 0) {
+            await Promise.race(executing);
+            const completedIndex = executing.findIndex(
+              (p) => p.then !== void 0
+            );
+            if (completedIndex !== -1) {
+              executing.splice(completedIndex, 1);
+            }
+          }
+        }
+        return results;
+      };
+      await executeWithConcurrency(uploadTasks, actualConcurrency);
+      let responseText = "";
+      if (mergeUrl) {
+        responseText = await mergeChunks(
+          mergeUrl,
+          file.name,
+          totalChunks,
+          method === "get" ? "post" : method,
+          headers
+        );
+      }
+      const updatedFile = {
+        ...fileItem,
+        status: "success",
+        progress: 100,
+        response: responseText || "Chunked upload completed"
+      };
+      setChunkProgress((prev) => {
+        const newProgress = { ...prev };
+        delete newProgress[fileId];
+        return newProgress;
+      });
+      onSuccess == null ? void 0 : onSuccess(responseText || "Chunked upload completed", file);
+      return updatedFile;
+    } catch (event) {
+      const isAbort = cancelRef.current || (event == null ? void 0 : event.name) === "AbortError";
+      if (isAbort) {
+        return { ...fileItem, status: "idle", progress: 0 };
+      }
+      const error = createUploadError(
+        "NETWORK_ERROR",
+        event instanceof Error ? event.message : "\u5206\u7247\u4E0A\u4F20\u5931\u8D25",
+        file,
+        event instanceof Error ? event : void 0
+      );
+      onError == null ? void 0 : onError(error, file);
+      return { ...fileItem, status: "error", error };
+    }
+  };
   const uploadFiles = useCallback(async (filesToUpload) => {
     var _a;
     if (!action || filesToUpload.length === 0) {
@@ -1347,7 +3170,12 @@ function Upload(config) {
       uploadedFiles.push(result);
       setFiles(
         (prev) => prev.map(
-          (f) => f.id === fileItem.id ? { ...f, status: result.status, response: result.response } : f
+          (f) => f.id === fileItem.id ? {
+            ...f,
+            status: result.status,
+            response: result.response,
+            progress: result.status === "success" ? 100 : f.progress
+          } : f
         )
       );
       if (result.status === "success") {
@@ -1513,7 +3341,8 @@ function Upload(config) {
         files,
         show: showFileList,
         onRemove: handleRemoveFile,
-        onCancel: handleCancelFile
+        onCancel: handleCancelFile,
+        chunkProgressMap: chunkProgress
       }
     )
   ] });