@windwalker-io/unicorn-next 0.1.18 → 0.1.21

package/dist/chunks/unicorn.js

@@ -1,2580 +0,0 @@
-import { Modal } from "bootstrap";
-const copyProps = (dest, src, exclude = []) => {
-  const props = Object.getOwnPropertyDescriptors(src);
-  for (let prop of exclude)
-    delete props[prop];
-  Object.defineProperties(dest, props);
-};
-const protoChain = (obj, currentChain = [obj]) => {
-  const proto = Object.getPrototypeOf(obj);
-  if (proto === null)
-    return currentChain;
-  return protoChain(proto, [...currentChain, proto]);
-};
-const nearestCommonProto = (...objs) => {
-  if (objs.length === 0)
-    return void 0;
-  let commonProto = void 0;
-  const protoChains = objs.map((obj) => protoChain(obj));
-  while (protoChains.every((protoChain2) => protoChain2.length > 0)) {
-    const protos = protoChains.map((protoChain2) => protoChain2.pop());
-    const potentialCommonProto = protos[0];
-    if (protos.every((proto) => proto === potentialCommonProto))
-      commonProto = potentialCommonProto;
-    else
-      break;
-  }
-  return commonProto;
-};
-const hardMixProtos = (ingredients, constructor, exclude = []) => {
-  var _a;
-  const base = (_a = nearestCommonProto(...ingredients)) !== null && _a !== void 0 ? _a : Object.prototype;
-  const mixedProto = Object.create(base);
-  const visitedProtos = protoChain(base);
-  for (let prototype of ingredients) {
-    let protos = protoChain(prototype);
-    for (let i = protos.length - 1; i >= 0; i--) {
-      let newProto = protos[i];
-      if (visitedProtos.indexOf(newProto) === -1) {
-        copyProps(mixedProto, newProto, ["constructor", ...exclude]);
-        visitedProtos.push(newProto);
-      }
-    }
-  }
-  mixedProto.constructor = constructor;
-  return mixedProto;
-};
-const unique = (arr) => arr.filter((e, i) => arr.indexOf(e) == i);
-const mixins = /* @__PURE__ */ new WeakMap();
-const getMixinsForClass = (clazz) => mixins.get(clazz);
-const registerMixins = (mixedClass, constituents) => mixins.set(mixedClass, constituents);
-const mergeObjectsOfDecorators = (o1, o2) => {
-  var _a, _b;
-  const allKeys = unique([...Object.getOwnPropertyNames(o1), ...Object.getOwnPropertyNames(o2)]);
-  const mergedObject = {};
-  for (let key of allKeys)
-    mergedObject[key] = unique([...(_a = o1 === null || o1 === void 0 ? void 0 : o1[key]) !== null && _a !== void 0 ? _a : [], ...(_b = o2 === null || o2 === void 0 ? void 0 : o2[key]) !== null && _b !== void 0 ? _b : []]);
-  return mergedObject;
-};
-const mergePropertyAndMethodDecorators = (d1, d2) => {
-  var _a, _b, _c, _d;
-  return {
-    property: mergeObjectsOfDecorators((_a = d1 === null || d1 === void 0 ? void 0 : d1.property) !== null && _a !== void 0 ? _a : {}, (_b = d2 === null || d2 === void 0 ? void 0 : d2.property) !== null && _b !== void 0 ? _b : {}),
-    method: mergeObjectsOfDecorators((_c = d1 === null || d1 === void 0 ? void 0 : d1.method) !== null && _c !== void 0 ? _c : {}, (_d = d2 === null || d2 === void 0 ? void 0 : d2.method) !== null && _d !== void 0 ? _d : {})
-  };
-};
-const mergeDecorators = (d1, d2) => {
-  var _a, _b, _c, _d, _e, _f;
-  return {
-    class: unique([...(_a = d1 === null || d1 === void 0 ? void 0 : d1.class) !== null && _a !== void 0 ? _a : [], ...(_b = d2 === null || d2 === void 0 ? void 0 : d2.class) !== null && _b !== void 0 ? _b : []]),
-    static: mergePropertyAndMethodDecorators((_c = d1 === null || d1 === void 0 ? void 0 : d1.static) !== null && _c !== void 0 ? _c : {}, (_d = d2 === null || d2 === void 0 ? void 0 : d2.static) !== null && _d !== void 0 ? _d : {}),
-    instance: mergePropertyAndMethodDecorators((_e = d1 === null || d1 === void 0 ? void 0 : d1.instance) !== null && _e !== void 0 ? _e : {}, (_f = d2 === null || d2 === void 0 ? void 0 : d2.instance) !== null && _f !== void 0 ? _f : {})
-  };
-};
-const decorators = /* @__PURE__ */ new Map();
-const findAllConstituentClasses = (...classes) => {
-  var _a;
-  const allClasses = /* @__PURE__ */ new Set();
-  const frontier = /* @__PURE__ */ new Set([...classes]);
-  while (frontier.size > 0) {
-    for (let clazz of frontier) {
-      const protoChainClasses = protoChain(clazz.prototype).map((proto) => proto.constructor);
-      const mixinClasses = (_a = getMixinsForClass(clazz)) !== null && _a !== void 0 ? _a : [];
-      const potentiallyNewClasses = [...protoChainClasses, ...mixinClasses];
-      const newClasses = potentiallyNewClasses.filter((c) => !allClasses.has(c));
-      for (let newClass of newClasses)
-        frontier.add(newClass);
-      allClasses.add(clazz);
-      frontier.delete(clazz);
-    }
-  }
-  return [...allClasses];
-};
-const deepDecoratorSearch = (...classes) => {
-  const decoratorsForClassChain = findAllConstituentClasses(...classes).map((clazz) => decorators.get(clazz)).filter((decorators2) => !!decorators2);
-  if (decoratorsForClassChain.length == 0)
-    return {};
-  if (decoratorsForClassChain.length == 1)
-    return decoratorsForClassChain[0];
-  return decoratorsForClassChain.reduce((d1, d2) => mergeDecorators(d1, d2));
-};
-function Mixin(...constructors) {
-  var _a, _b, _c;
-  const prototypes = constructors.map((constructor) => constructor.prototype);
-  function MixedClass(...args) {
-    for (const constructor of constructors)
-      copyProps(this, new constructor(...args));
-  }
-  MixedClass.prototype = hardMixProtos(prototypes, MixedClass);
-  Object.setPrototypeOf(
-    MixedClass,
-    hardMixProtos(constructors, null, ["prototype"])
-  );
-  let DecoratedMixedClass = MixedClass;
-  {
-    const classDecorators = deepDecoratorSearch(...constructors);
-    for (let decorator of (_a = classDecorators === null || classDecorators === void 0 ? void 0 : classDecorators.class) !== null && _a !== void 0 ? _a : []) {
-      const result = decorator(DecoratedMixedClass);
-      if (result) {
-        DecoratedMixedClass = result;
-      }
-    }
-    applyPropAndMethodDecorators((_b = classDecorators === null || classDecorators === void 0 ? void 0 : classDecorators.static) !== null && _b !== void 0 ? _b : {}, DecoratedMixedClass);
-    applyPropAndMethodDecorators((_c = classDecorators === null || classDecorators === void 0 ? void 0 : classDecorators.instance) !== null && _c !== void 0 ? _c : {}, DecoratedMixedClass.prototype);
-  }
-  registerMixins(DecoratedMixedClass, constructors);
-  return DecoratedMixedClass;
-}
-const applyPropAndMethodDecorators = (propAndMethodDecorators, target) => {
-  const propDecorators = propAndMethodDecorators.property;
-  const methodDecorators = propAndMethodDecorators.method;
-  if (propDecorators)
-    for (let key in propDecorators)
-      for (let decorator of propDecorators[key])
-        decorator(target, key);
-  if (methodDecorators)
-    for (let key in methodDecorators)
-      for (let decorator of methodDecorators[key])
-        decorator(target, key, Object.getOwnPropertyDescriptor(target, key));
-};
-function isPlainObject(val) {
-  return val && typeof val === "object" && !Array.isArray(val);
-}
-function mergeDeep(target, ...sources) {
-  let out = isPlainObject(target) ? { ...target } : target;
-  for (const source of sources) {
-    if (Array.isArray(source)) {
-      out = Array.isArray(out) ? out.concat(source) : source;
-      continue;
-    }
-    if (isPlainObject(source)) {
-      out = { ...isPlainObject(out) ? out : {} };
-      for (const key of Object.keys(source)) {
-        out[key] = key in out ? mergeDeep(out[key], source[key]) : source[key];
-      }
-      continue;
-    }
-    out = source;
-  }
-  return out;
-}
-function getData(element, name) {
-  prepareData(element);
-  if (name === void 0) {
-    return element.__unicorn;
-  }
-  return element.__unicorn[name];
-}
-function setData(element, name, value) {
-  prepareData(element);
-  element.__unicorn[name] = value;
-}
-function defData(element, name, defCallback) {
-  prepareData(element);
-  element.__unicorn[name] = element.__unicorn[name] || defCallback(element);
-  return element.__unicorn[name];
-}
-function removeData$1(element, name) {
-  prepareData(element);
-  const v = element.__unicorn[name];
-  delete element.__unicorn[name];
-  return v;
-}
-function prepareData(element) {
-  if (!element) {
-    return element;
-  }
-  element.__unicorn = element.__unicorn || {};
-  return element;
-}
-function domready(callback) {
-  let promise = new Promise((resolve) => {
-    if (document.readyState === "complete" || document.readyState === "interactive") {
-      setTimeout(resolve, 0);
-    } else {
-      document.addEventListener("DOMContentLoaded", () => resolve());
-    }
-  });
-  if (callback) {
-    promise = promise.then(callback);
-  }
-  return promise;
-}
-function selectOne(ele) {
-  let r;
-  if (typeof ele === "string") {
-    r = document.querySelector(ele);
-  } else {
-    r = ele;
-  }
-  if (!r) {
-    return r;
-  }
-  return r;
-}
-function selectAll(ele, callback = void 0) {
-  if (typeof ele === "string") {
-    ele = document.querySelectorAll(ele);
-  }
-  const resultSet = [].slice.call(ele);
-  if (callback) {
-    return resultSet.map((el) => callback(el) || el);
-  }
-  return resultSet;
-}
-function getBoundedInstance(selector, name, callback = () => null) {
-  const element = typeof selector === "string" ? document.querySelector(selector) : selector;
-  if (!element) {
-    return null;
-  }
-  return defData(element, name, callback);
-}
-function getBoundedInstanceList(selector, name, callback = () => null) {
-  const items = typeof selector === "string" ? document.querySelectorAll(selector) : selector;
-  return Array.from(items).map((ele) => getBoundedInstance(ele, name, callback));
-}
-function removeBoundedInstance(selector, name) {
-  const element = typeof selector === "string" ? document.querySelector(selector) : selector;
-  if (element) {
-    removeData(element, name);
-  }
-}
-function module$1(ele, name, callback = () => null) {
-  if (callback === false) {
-    if (typeof ele === "string" || ele instanceof Element) {
-      removeBoundedInstance(ele, name);
-      return null;
-    }
-    Array.from(ele).forEach((el) => removeBoundedInstance(el, name));
-    return null;
-  }
-  if (typeof ele === "string") {
-    return getBoundedInstanceList(ele, name, callback);
-  }
-  if (ele instanceof HTMLElement) {
-    return getBoundedInstance(ele, name, callback);
-  }
-  return getBoundedInstanceList(ele, name, callback);
-}
-function h(element, attrs = {}, content = void 0) {
-  const ele = document.createElement(element);
-  for (let i in attrs) {
-    const v = attrs[i];
-    ele.setAttribute(i, v);
-  }
-  if (content !== null) {
-    ele.innerHTML = content;
-  }
-  return ele;
-}
-function html(html2) {
-  const div = document.createElement("div");
-  div.innerHTML = html2;
-  return div.children[0];
-}
-function delegate(wrapper, selector, eventName, callback) {
-  if (typeof selector === "undefined" || selector === "") {
-    throw new Error("The provided selector is empty.");
-  }
-  if (typeof callback === "undefined" || typeof callback !== "function") {
-    throw new Error("Please specify an callback.");
-  }
-  const delegationSelectorsMap = {};
-  const wrapperElement = selectOne(wrapper);
-  wrapperElement?.addEventListener(eventName, function(event) {
-    let element = event.target;
-    let forceBreak = false;
-    while (element && element !== wrapperElement) {
-      for (const selector2 in delegationSelectorsMap) {
-        if (element.matches(selector2)) {
-          event.stopPropagation = function() {
-            forceBreak = true;
-          };
-          Object.defineProperty(
-            event,
-            "currentTarget",
-            {
-              get() {
-                return element;
-              }
-            }
-          );
-          const callbackList = delegationSelectorsMap[selector2];
-          callbackList.forEach(function(callback2) {
-            callback2(event);
-          });
-        }
-      }
-      if (forceBreak) {
-        break;
-      }
-      element = element.parentElement;
-    }
-  });
-  if (!delegationSelectorsMap[selector]) {
-    delegationSelectorsMap[selector] = [callback];
-  } else {
-    delegationSelectorsMap[selector].push(callback);
-  }
-  return function unsubscribe() {
-    if (!delegationSelectorsMap[selector]) {
-      return;
-    }
-    if (delegationSelectorsMap[selector].length >= 2) {
-      delegationSelectorsMap[selector] = delegationSelectorsMap[selector].filter((cb) => cb !== callback);
-    } else {
-      delete delegationSelectorsMap[selector];
-    }
-  };
-}
-async function injectCssToDocument(doc, ...css) {
-  if (!(doc instanceof Document)) {
-    css.push(doc);
-    doc = document;
-  }
-  const promises = [];
-  for (let cssItem of css) {
-    promises.push(
-      new Promise((resolve, reject) => {
-        if (cssItem instanceof CSSStyleSheet) {
-          resolve(cssItem);
-        } else if (typeof cssItem === "string") {
-          const style = new CSSStyleSheet();
-          style.replace(cssItem).then(() => resolve(style)).catch(reject);
-        } else if (typeof cssItem === "function") {
-          cssItem().then(({ default: result }) => {
-            const style = new CSSStyleSheet();
-            style.replace(result).then(() => resolve(style)).catch(reject);
-          }).catch(reject);
-        } else {
-          reject(new Error("Invalid CSS source"));
-        }
-      })
-    );
-  }
-  const styles = await Promise.all(promises);
-  doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, ...styles];
-  return styles;
-}
-function animateTo(element, styles, options = {}) {
-  element = selectOne(element);
-  const currentStyles = window.getComputedStyle(element);
-  const transitions = {};
-  for (const name in styles) {
-    const value = styles[name];
-    transitions[name] = Array.isArray(value) ? value : [
-      currentStyles.getPropertyValue(name),
-      value
-    ];
-  }
-  if (typeof options === "number") {
-    options = { duration: options };
-  }
-  options = Object.assign(
-    {
-      duration: 400,
-      easing: "linear",
-      fill: "both"
-    },
-    options
-  );
-  const animation = element.animate(
-    transitions,
-    options
-  );
-  animation.addEventListener("finish", () => {
-    for (const name in styles) {
-      const value = styles[name];
-      element.style.setProperty(
-        name,
-        Array.isArray(value) ? value[value.length - 1] : value
-      );
-    }
-    animation.cancel();
-  });
-  return animation;
-}
-const _AlertAdapter = class _AlertAdapter {
-};
-_AlertAdapter.alert = async (title, text) => {
-  if (text) {
-    title += " | " + text;
-  }
-  return window.alert(title);
-};
-_AlertAdapter.confirm = async (title, text) => {
-  return new Promise((resolve) => {
-    if (text) {
-      title += " | " + text;
-    }
-    const v = confirm(title);
-    resolve(v);
-  });
-};
-_AlertAdapter.deleteConfirm = async (title, text) => _AlertAdapter.confirm(title, text);
-_AlertAdapter.notify = async (title, text, type = "log") => {
-  if (text) {
-    title += " | " + text;
-  }
-  if (type === "error") {
-    console.error(title);
-  } else if (type === "warn") {
-    console.warn(title);
-  } else {
-    console.log(title);
-  }
-  return async () => {
-  };
-};
-_AlertAdapter.clearNotifies = async () => {
-};
-_AlertAdapter.confirmText = () => "OK";
-_AlertAdapter.cancelText = () => "Cancel";
-_AlertAdapter.deleteText = () => "Delete";
-let AlertAdapter = _AlertAdapter;
-async function simpleAlert(title, text = "", icon = "info", extra) {
-  return AlertAdapter.alert(title, text, icon, extra);
-}
-async function simpleConfirm(title, text = "", icon = "info", extra) {
-  return AlertAdapter.confirm(title, text, icon, extra);
-}
-async function deleteConfirm(title, text = "", icon = "info", extra) {
-  return AlertAdapter.deleteConfirm(title, text, icon, extra);
-}
-async function simpleNotify(title, text = "", type = "info", extra) {
-  return AlertAdapter.notify(title, text, type, extra);
-}
-async function clearNotifies() {
-  return AlertAdapter.clearNotifies();
-}
-function isNode() {
-  return typeof window === "undefined";
-}
-function uid(prefix = "", timebase = false) {
-  if (timebase) {
-    const start = performance?.timeOrigin ? Math.round(performance.timeOrigin) : performance.timing.navigationStart;
-    const time = start * 1e5 + performance.now() * 100;
-    return prefix + time.toString(12) + randomBytesString(4);
-  }
-  return prefix + randomBytesString(12);
-}
-function tid(prefix = "") {
-  return uid(prefix, true);
-}
-function randomBytesString(size = 12) {
-  if (!isNode() && !globalThis.crypto) {
-    return String(Math.floor(Math.random() * size ** 10));
-  }
-  return Array.from(randomBytes(size)).map((x) => x.toString(16).padStart(2, "0")).join("");
-}
-function randomBytes(size = 12) {
-  const arr = new Uint8Array(size);
-  globalThis.crypto.getRandomValues(arr);
-  return arr;
-}
-function promiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((rs, rj) => {
-    resolve = rs;
-    reject = rj;
-  });
-  return { promise, resolve, reject };
-}
-class TaskQueue {
-  constructor(maxRunning = 1) {
-    this.maxRunning = maxRunning;
-    this.items = [];
-    this.currentRunning = 0;
-    this.running = false;
-    this.observers = [];
-  }
-  push(callback) {
-    const p = new Promise((resolve, reject) => {
-      this.items.push(() => {
-        return Promise.resolve(callback()).then(resolve).catch(reject);
-      });
-    });
-    this.run();
-    return p;
-  }
-  run() {
-    if (!this.running) {
-      this.running = true;
-    }
-    this.pop();
-  }
-  async pop() {
-    const callback = this.items.shift();
-    if (!callback) {
-      this.running = false;
-      return Promise.resolve();
-    }
-    if (this.currentRunning >= this.maxRunning) {
-      this.items.unshift(callback);
-      return Promise.resolve();
-    }
-    this.currentRunning++;
-    this.notice();
-    try {
-      return await callback();
-    } catch (e) {
-      throw e;
-    } finally {
-      this.endPop();
-    }
-  }
-  endPop() {
-    this.currentRunning--;
-    this.notice();
-    this.pop();
-  }
-  clear() {
-    this.items = [];
-    this.notice();
-    return this;
-  }
-  isEmpty() {
-    return this.items.length === 0;
-  }
-  get length() {
-    return this.items.length;
-  }
-  peek() {
-    return this.items;
-  }
-  observe(handler, options = {}) {
-    this.observers.push({
-      handler,
-      once: options.once || false
-    });
-    return () => {
-      this.off(handler);
-    };
-  }
-  once(handler, options = {}) {
-    options.once = true;
-    return this.observe(handler, options);
-  }
-  onEnd(callback, options = {}) {
-    return this.observe((queue2, length, running) => {
-      if (length === 0 && running === 0) {
-        callback(queue2, length, running);
-      }
-    }, options);
-  }
-  notice() {
-    this.observers.forEach((observer) => {
-      observer.handler(this, this.length, this.currentRunning);
-    });
-    this.observers = this.observers.filter((observer) => !observer.once);
-    return this;
-  }
-  off(callback) {
-    if (callback == null) {
-      this.observers = [];
-      return this;
-    }
-    this.observers = this.observers.filter((observer) => observer.handler !== callback);
-    return this;
-  }
-}
-function queue(maxRunning = 1) {
-  return new TaskQueue(maxRunning);
-}
-class Stack {
-  constructor(store = []) {
-    this.store = store;
-    this.observers = [];
-  }
-  push(value) {
-    const r = this.store.push(value ?? true);
-    this.notice();
-    return r;
-  }
-  pop() {
-    const r = this.store.pop();
-    this.notice();
-    return r;
-  }
-  clear() {
-    this.store = [];
-    this.notice();
-    return this;
-  }
-  isEmpty() {
-    return this.store.length === 0;
-  }
-  get length() {
-    return this.store.length;
-  }
-  peek() {
-    return this.store;
-  }
-  observe(handler) {
-    this.observers.push({
-      handler,
-      once: false
-    });
-    return () => {
-      this.off(handler);
-    };
-  }
-  once(handler) {
-    this.observers.push({
-      handler,
-      once: true
-    });
-    return () => {
-      this.off(handler);
-    };
-  }
-  notice() {
-    this.observers.forEach((observer) => {
-      observer.handler(this, this.length);
-    });
-    this.observers = this.observers.filter((observer) => observer.once !== true);
-    return this;
-  }
-  off(callback) {
-    this.observers = this.observers.filter((observer) => observer.handler !== callback);
-    return this;
-  }
-}
-function stack(store = []) {
-  return new Stack(store);
-}
-function sleep(time) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-}
-function base64UrlEncode(string) {
-  return btoa(String(string)).replace(/\+/, "-").replace(new RegExp("\\/"), "_").replace(/=+$/, "");
-}
-function base64UrlDecode(string) {
-  return atob(
-    String(string).replace(/-/, "+").replace(/_/, "/")
-  );
-}
-let globalSerial = 1;
-function serial() {
-  return globalSerial++;
-}
-function watchAttributes(el, callback) {
-  return new AttributeMutationObserver(el, callback);
-}
-class AttributeMutationObserver {
-  constructor(element, callback) {
-    this.element = element;
-    this.callback = callback;
-    this.element = element;
-    this.observer = new MutationObserver((mutations) => {
-      for (const mutation of mutations) {
-        if (mutation.type === "attributes") {
-          const attrName = mutation.attributeName;
-          const target = mutation.target;
-          const value = target.getAttribute(attrName);
-          this.callback?.(
-            target,
-            attrName,
-            value,
-            mutation.oldValue
-          );
-          if (this.watches[attrName]) {
-            for (const watch of this.watches[attrName]) {
-              watch(target, value, mutation.oldValue);
-            }
-          }
-        }
-      }
-    });
-    this.observe();
-  }
-  observer;
-  watches = {};
-  watch(name, callback) {
-    this.watches[name] ??= [];
-    this.watches[name].push(callback);
-    return () => {
-      this.watches[name] = this.watches[name].filter((fn) => fn !== callback);
-    };
-  }
-  observe() {
-    this.observer.observe(this.element, {
-      attributes: true,
-      attributeOldValue: true
-    });
-  }
-  disconnect() {
-    this.observer.disconnect();
-  }
-}
-function forceArray(item) {
-  if (Array.isArray(item)) {
-    return item;
-  } else {
-    return [item];
-  }
-}
-function debounce(handler, wait2 = 1) {
-  let timer, result;
-  return function(...args) {
-    clearTimeout(timer);
-    timer = setTimeout(() => result = handler.call(this, ...args), wait2);
-    return result;
-  };
-}
-function throttle(handler, wait2 = 1) {
-  return function(...args) {
-    {
-      return handler.call(this, ...args);
-    }
-  };
-}
-function isDebug() {
-  return Boolean(data("windwalker.debug"));
-}
-function nextTick(callback) {
-  return Promise.resolve().then(callback ?? (() => null));
-}
-function wait(...promisee) {
-  return Promise.all(promisee);
-}
-function isError(e) {
-  return e instanceof Error;
-}
-var sprintf = {};
-var hasRequiredSprintf;
-function requireSprintf() {
-  if (hasRequiredSprintf) return sprintf;
-  hasRequiredSprintf = 1;
-  (function(exports$1) {
-    !(function() {
-      var re = {
-        not_type: /[^T]/,
-        not_primitive: /[^v]/,
-        number: /[diefg]/,
-        numeric_arg: /[bcdiefguxX]/,
-        json: /[j]/,
-        text: /^[^\x25]+/,
-        modulo: /^\x25{2}/,
-        placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
-        key: /^([a-z_][a-z_\d]*)/i,
-        key_access: /^\.([a-z_][a-z_\d]*)/i,
-        index_access: /^\[(\d+)\]/,
-        sign: /^[+-]/
-      };
-      function sprintf2(key) {
-        return sprintf_format(sprintf_parse(key), arguments);
-      }
-      function vsprintf(fmt, argv) {
-        return sprintf2.apply(null, [fmt].concat(argv || []));
-      }
-      function sprintf_format(parse_tree, argv) {
-        var cursor = 1, tree_length = parse_tree.length, arg, output = "", i, k, ph, pad, pad_character, pad_length, is_positive, sign;
-        for (i = 0; i < tree_length; i++) {
-          if (typeof parse_tree[i] === "string") {
-            output += parse_tree[i];
-          } else if (typeof parse_tree[i] === "object") {
-            ph = parse_tree[i];
-            if (ph.keys) {
-              arg = argv[cursor];
-              for (k = 0; k < ph.keys.length; k++) {
-                if (arg == void 0) {
-                  throw new Error(sprintf2('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1]));
-                }
-                arg = arg[ph.keys[k]];
-              }
-            } else if (ph.param_no) {
-              arg = argv[ph.param_no];
-            } else {
-              arg = argv[cursor++];
-            }
-            if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
-              arg = arg();
-            }
-            if (re.numeric_arg.test(ph.type) && (typeof arg !== "number" && isNaN(arg))) {
-              throw new TypeError(sprintf2("[sprintf] expecting number but found %T", arg));
-            }
-            if (re.number.test(ph.type)) {
-              is_positive = arg >= 0;
-            }
-            switch (ph.type) {
-              case "b":
-                arg = parseInt(arg, 10).toString(2);
-                break;
-              case "c":
-                arg = String.fromCharCode(parseInt(arg, 10));
-                break;
-              case "d":
-              case "i":
-                arg = parseInt(arg, 10);
-                break;
-              case "j":
-                arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0);
-                break;
-              case "e":
-                arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential();
-                break;
-              case "f":
-                arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg);
-                break;
-              case "g":
-                arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg);
-                break;
-              case "o":
-                arg = (parseInt(arg, 10) >>> 0).toString(8);
-                break;
-              case "s":
-                arg = String(arg);
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg;
-                break;
-              case "t":
-                arg = String(!!arg);
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg;
-                break;
-              case "T":
-                arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg;
-                break;
-              case "u":
-                arg = parseInt(arg, 10) >>> 0;
-                break;
-              case "v":
-                arg = arg.valueOf();
-                arg = ph.precision ? arg.substring(0, ph.precision) : arg;
-                break;
-              case "x":
-                arg = (parseInt(arg, 10) >>> 0).toString(16);
-                break;
-              case "X":
-                arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase();
-                break;
-            }
-            if (re.json.test(ph.type)) {
-              output += arg;
-            } else {
-              if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
-                sign = is_positive ? "+" : "-";
-                arg = arg.toString().replace(re.sign, "");
-              } else {
-                sign = "";
-              }
-              pad_character = ph.pad_char ? ph.pad_char === "0" ? "0" : ph.pad_char.charAt(1) : " ";
-              pad_length = ph.width - (sign + arg).length;
-              pad = ph.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : "";
-              output += ph.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg;
-            }
-          }
-        }
-        return output;
-      }
-      var sprintf_cache = /* @__PURE__ */ Object.create(null);
-      function sprintf_parse(fmt) {
-        if (sprintf_cache[fmt]) {
-          return sprintf_cache[fmt];
-        }
-        var _fmt = fmt, match, parse_tree = [], arg_names = 0;
-        while (_fmt) {
-          if ((match = re.text.exec(_fmt)) !== null) {
-            parse_tree.push(match[0]);
-          } else if ((match = re.modulo.exec(_fmt)) !== null) {
-            parse_tree.push("%");
-          } else if ((match = re.placeholder.exec(_fmt)) !== null) {
-            if (match[2]) {
-              arg_names |= 1;
-              var field_list = [], replacement_field = match[2], field_match = [];
-              if ((field_match = re.key.exec(replacement_field)) !== null) {
-                field_list.push(field_match[1]);
-                while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") {
-                  if ((field_match = re.key_access.exec(replacement_field)) !== null) {
-                    field_list.push(field_match[1]);
-                  } else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
-                    field_list.push(field_match[1]);
-                  } else {
-                    throw new SyntaxError("[sprintf] failed to parse named argument key");
-                  }
-                }
-              } else {
-                throw new SyntaxError("[sprintf] failed to parse named argument key");
-              }
-              match[2] = field_list;
-            } else {
-              arg_names |= 2;
-            }
-            if (arg_names === 3) {
-              throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");
-            }
-            parse_tree.push(
-              {
-                placeholder: match[0],
-                param_no: match[1],
-                keys: match[2],
-                sign: match[3],
-                pad_char: match[4],
-                align: match[5],
-                width: match[6],
-                precision: match[7],
-                type: match[8]
-              }
-            );
-          } else {
-            throw new SyntaxError("[sprintf] unexpected placeholder");
-          }
-          _fmt = _fmt.substring(match[0].length);
-        }
-        return sprintf_cache[fmt] = parse_tree;
-      }
-      {
-        exports$1["sprintf"] = sprintf2;
-        exports$1["vsprintf"] = vsprintf;
-      }
-      if (typeof window !== "undefined") {
-        window["sprintf"] = sprintf2;
-        window["vsprintf"] = vsprintf;
-      }
-    })();
-  })(sprintf);
-  return sprintf;
-}
-var sprintfExports = /* @__PURE__ */ requireSprintf();
-let lang;
-function useLang() {
-  return lang ??= new UnicornLang();
-}
-function trans(id, ...args) {
-  return useLang().trans(id, ...args);
-}
-function __(id, ...args) {
-  return trans(id, ...args);
-}
-class UnicornLang {
-  /**
-   * Translate a string.
-   */
-  trans(id, ...args) {
-    const key = this.normalize(id);
-    let translated = this.get(key) || "";
-    translated = this.replace(translated, args);
-    return translated !== "" ? translated : this.wrapDebug(id, false);
-  }
-  replace(str, args) {
-    let replacements = {};
-    let values = [];
-    for (const arg of args) {
-      if (typeof arg === "object") {
-        replacements = { ...replacements, ...arg };
-      } else {
-        values.push(arg);
-      }
-    }
-    if (values.length) {
-      str = sprintfExports.vsprintf(str, values);
-    }
-    if (Object.values(replacements).length) {
-      for (const key in replacements) {
-        let value = replacements[key];
-        if (typeof value === "function") {
-          value = value();
-        }
-        str = str.replace(new RegExp(":" + key, "g"), String(value));
-      }
-    }
-    return str;
-  }
-  /**
-   * Find text.
-   */
-  get(id) {
-    const strings = this.getStrings();
-    if (strings[id]) {
-      return strings[id];
-    }
-    return null;
-  }
-  /**
-   * Has language key.
-   */
-  has(key) {
-    const strings = this.getStrings();
-    return strings[key] !== void 0;
-  }
-  /**
-   * Add language key.
-   */
-  add(key, value) {
-    const strings = this.getStrings();
-    strings[this.normalize(key)] = value;
-    data("unicorn.languages", strings);
-    return this;
-  }
-  /**
-   * Replace all symbols to dot(.).
-   */
-  normalize(text) {
-    return text.replace(/[^A-Z0-9]+/ig, ".");
-  }
-  wrapDebug(text, success) {
-    if (isDebug()) {
-      if (success) {
-        return "**" + text + "**";
-      }
-      return "??" + text + "??";
-    }
-    return text;
-  }
-  getStrings() {
-    return data("unicorn.languages") || {};
-  }
-}
-async function useScriptImport(src, attrs = {}) {
-  if (typeof src === "function") {
-    src = (await src()).default;
-  }
-  const script = document.createElement("script");
-  script.src = resolveUrl(src);
-  for (const key in attrs) {
-    script.setAttribute(key, attrs[key]);
-  }
-  return new Promise((resolve, reject) => {
-    script.onload = () => {
-      resolve();
-      document.body.removeChild(script);
-    };
-    script.onerror = (e) => {
-      reject(e);
-      document.body.removeChild(script);
-    };
-    document.body.appendChild(script);
-  });
-}
-function doImport(src) {
-  return import(
-    /* @vite-ignore */
-    src
-  );
-}
-async function useImport(...src) {
-  if (src.length === 1) {
-    return doImport(src[0]);
-  }
-  const promises = [];
-  src.forEach((link) => {
-    promises.push(
-      link instanceof Promise ? link : doImport(link)
-    );
-  });
-  return Promise.all(promises);
-}
-async function useSeriesImport(...src) {
-  const modules = [];
-  for (const source of src) {
-    if (Array.isArray(source)) {
-      const m2 = await useImport(...source);
-      modules.push(m2);
-      continue;
-    }
-    const m = await useImport(source);
-    modules.push(m);
-  }
-  return modules;
-}
-async function useCssIncludes(...hrefs) {
-  const promises = hrefs.map((href) => {
-    return new Promise((resolve, reject) => {
-      resolveSource(href).then((href2) => {
-        href2 = resolveUrl(href2);
-        const link = document.createElement("link");
-        link.rel = "stylesheet";
-        link.href = href2;
-        link.onload = () => resolve();
-        link.onerror = (e) => reject(e);
-        document.head.appendChild(link);
-      });
-    });
-  });
-  return Promise.all(promises);
-}
-const importedSheets = {};
-async function useCssImport(...hrefs) {
-  const modules = await Promise.all(
-    hrefs.map((href) => {
-      return new Promise((resolve) => {
-        resolveSource(href).then((href2) => {
-          href2 = resolveUrl(href2);
-          if (!importedSheets[href2]) {
-            importedSheets[href2] = simulateCssImport(href2);
-          }
-          resolve(importedSheets[href2]);
-        });
-      });
-    })
-  );
-  const styles = modules.map((module) => module.default);
-  return injectCssToDocument(...styles);
-}
-async function simulateCssImport(href) {
-  const response = await fetch(href);
-  if (!response.ok) {
-    throw new Error(`Failed to load CSS: ${href}`);
-  }
-  const cssText = await response.text();
-  const sheet = new CSSStyleSheet();
-  await sheet.replace(cssText);
-  return { default: sheet };
-}
-let importMap;
-function parseImportMap() {
-  const importMapScript = document.querySelector('script[type="importmap"]');
-  if (importMapScript) {
-    try {
-      return JSON.parse(importMapScript.textContent || "{}").imports || {};
-    } catch (e) {
-      console.error("Failed to parse import map:", e);
-    }
-  }
-  return {};
-}
-function resolveUrl(specifier) {
-  importMap ??= parseImportMap();
-  for (const [prefix, target] of Object.entries(importMap)) {
-    if (specifier === prefix) {
-      return target;
-    }
-  }
-  for (const [prefix, target] of Object.entries(importMap)) {
-    if (specifier.startsWith(prefix)) {
-      return specifier.replace(prefix, target);
-    }
-  }
-  return specifier;
-}
-async function resolveSource(src) {
-  if (typeof src === "function") {
-    return (await src()).default;
-  }
-  return src;
-}
-async function useUIBootstrap5(install = false, pushToGlobal = false) {
-  const { UIBootstrap5 } = await import("./ui-bootstrap5.js");
-  const theme = UIBootstrap5.get();
-  if (install) {
-    useUITheme(theme);
-    if (pushToGlobal) {
-      theme.pushBootstrapToGlobal();
-    }
-  }
-  return theme;
-}
-async function useBs5Tooltip(selector = '[data-bs-toggle="tooltip"]', config = {}) {
-  const bs5 = await useUIBootstrap5();
-  return bs5.tooltip(selector, config);
-}
-const useBs5KeepTab = async (selector, options = {}) => {
-  const bs5 = await useUIBootstrap5();
-  return bs5.keepTab(selector, options);
-};
-const useBs5ButtonRadio = async (selector, options = {}) => {
-  const bs5 = await useUIBootstrap5();
-  return bs5.buttonRadio(selector, options);
-};
-const defaultOptions = {
-  buttons: [
-    "OK"
-  ]
-};
-async function useBsModalAlert(id, options) {
-  await useUIBootstrap5();
-  let modalElement = void 0;
-  if (typeof id !== "string" && !(id instanceof HTMLElement)) {
-    options = id;
-    id = "uni-modal-alert";
-    modalElement = document.getElementById(id);
-  } else {
-    modalElement = typeof id === "string" ? document.getElementById(id) : id;
-  }
-  if (!modalElement) {
-    modalElement = html(`<div id="${id}" class="uni-modal-alert modal fade" tabindex="-1" role="dialog">
-  <div class="modal-dialog" role="document">
-    <div class="modal-content">
-      <div class="modal-body text-center p-4"></div>
-      <div class="modal-footer"></div>
-    </div>
-  </div>
-</div>`);
-    document.body.appendChild(modalElement);
-  }
-  const modal = Modal.getOrCreateInstance(modalElement, options);
-  return {
-    show: (title, text, icon, options2) => {
-      if (typeof title === "string") {
-        options2 = options2 || {};
-        options2.title = title;
-        options2.text = text;
-        options2.icon = icon;
-      } else {
-        options2 = title;
-      }
-      return new Promise((resolve) => {
-        prepareModalElement(modalElement, resolve, options2);
-        modal.show(options2?.relatedTarget);
-      });
-    },
-    hide: () => {
-      modal.hide();
-    },
-    dispose: () => {
-      modal.dispose();
-    },
-    toggle: (relatedTarget) => {
-      modal.toggle(relatedTarget);
-    },
-    destroy: () => {
-      modal.dispose();
-      modalElement.remove();
-    },
-    instance: modal,
-    el: modalElement
-  };
-}
-async function prepareModalElement(modalElement, handler, options) {
-  options = Object.assign({}, defaultOptions, options || {});
-  let header = options.header;
-  const content = options.content;
-  modalElement.querySelector(".modal-header")?.remove();
-  modalElement.querySelector(".modal-body").innerHTML = "";
-  modalElement.querySelector(".modal-footer").innerHTML = "";
-  const dialog = modalElement.querySelector(".modal-dialog");
-  dialog?.classList.remove("modal-sm", "modal-lg", "modal-xl", "modal-xxl");
-  if (header) {
-    if (typeof header === "string") {
-      header = `<div class="modal-header">
-        <h5 class="modal-title">${header}</h5>
-        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-      </div>`;
-    }
-    header = await anyToElement(header);
-    modalElement.querySelector(".modal-content").insertAdjacentElement("afterbegin", header);
-  }
-  if (content) {
-    let contentElement = await anyToElement(content);
-    modalElement.querySelector(".modal-body").appendChild(contentElement);
-  } else {
-    const title = options.title;
-    const text = options.text;
-    let icon = options.icon;
-    if (icon) {
-      if (typeof icon === "string") {
-        icon = `<div class="uni-modal-alert__icon text-center mb-4"><span class="${icon}" style="font-size: 48px;"></span></div>`;
-      }
-      icon = await anyToElement(icon);
-      modalElement.querySelector(".modal-body").appendChild(icon);
-    }
-    if (title) {
-      const titleEl = html(`<h4 class="uni-modal-alert__title">${title}</h4>`);
-      modalElement.querySelector(".modal-body").appendChild(titleEl);
-    }
-    if (text) {
-      const textEl = html(`<div class="uni-modal-alert__text">${text}</div>`);
-      modalElement.querySelector(".modal-body").appendChild(textEl);
-    }
-  }
-  const buttons = options.buttons;
-  for (const i in buttons) {
-    const button = buttons[i];
-    const isConfirm = buttons.length === 1 || buttons.length === 2 && Number(i) === 1;
-    const buttonElement = createButton(
-      button,
-      handler,
-      isConfirm
-    );
-    modalElement.querySelector(".modal-footer").appendChild(await buttonElement);
-  }
-  if (options.size) {
-    modalElement.querySelector(".modal-dialog").classList.add(`modal-${options.size}`);
-  }
-  return modalElement;
-}
-async function anyToElement(content) {
-  if (typeof content === "function") {
-    return content();
-  }
-  return typeof content === "string" ? html(content) : content;
-}
-async function createButton(buttonOption, handler, isConfirm) {
-  if (typeof buttonOption === "function") {
-    return await buttonOption();
-  }
-  if (typeof buttonOption === "string") {
-    buttonOption = {
-      text: buttonOption,
-      value: isConfirm ?? false,
-      class: isConfirm ? "btn btn-primary is-confirm" : "btn btn-outline-secondary",
-      styles: isConfirm ? { width: "150px" } : {},
-      dismiss: true
-    };
-  }
-  let button;
-  if (buttonOption instanceof HTMLElement) {
-    button = buttonOption;
-  } else {
-    const {
-      text,
-      class: className = "btn btn-secondary",
-      attrs = {},
-      styles = {},
-      dismiss = true,
-      value,
-      href,
-      target,
-      onClick
-    } = buttonOption;
-    const tag = href ? "a" : "button";
-    const el = document.createElement(tag);
-    if (el instanceof HTMLAnchorElement) {
-      el.href = href;
-      el.target = target || "_self";
-    }
-    if (el instanceof HTMLButtonElement) {
-      el.type = "button";
-    }
-    el.setAttribute("class", className);
-    for (let attr in attrs) {
-      el.setAttribute(attr, attrs[attr]);
-    }
-    for (let style in styles) {
-      el.style[style] = styles[style];
-    }
-    if (dismiss) {
-      el.setAttribute("data-bs-dismiss", "modal");
-    }
-    if (typeof text === "string") {
-      el.textContent = text;
-    } else if (typeof text === "function") {
-      text(el);
-    }
-    el.addEventListener("click", (e) => {
-      onClick?.(value, e);
-      handler(value);
-    });
-    button = el;
-  }
-  return button;
-}
-async function useCheckboxesMultiSelect(selector, options = {}) {
-  const m = await import("./checkboxes-multi-select.js");
-  if (selector) {
-    m.CheckboxesMultiSelect.handle(selector, options);
-  }
-  return m;
-}
-async function useFieldCascadeSelect() {
-  const module = await import("./field-cascade-select.js");
-  await module.ready;
-  return module;
-}
-async function useFieldFileDrag() {
-  const module = await import("./field-file-drag.js");
-  await module.ready;
-  return module;
-}
-function useFieldFlatpickr() {
-  return import("./field-flatpickr.js");
-}
-function useFieldModalSelect() {
-  return import("./field-modal-select.js");
-}
-function useFieldModalTree() {
-  return import("./field-modal-tree.js");
-}
-async function useFieldRepeatable() {
-  const module = await import("./field-repeatable.js");
-  await module.ready;
-  return module;
-}
-async function useFieldSingleImageDrag() {
-  const module = await import("./field-single-image-drag.js");
-  await module.ready;
-  return module;
-}
-let formElement;
-function useFormAsync(ele, options = {}) {
-  const promise = import("./form.js").then(({ UnicornFormElement }) => {
-    formElement ??= UnicornFormElement;
-    return useForm(ele, options);
-  });
-  const proxy = new Proxy({}, {
-    get(target, prop) {
-      return (...args) => {
-        if (prop === "then" || prop === "catch") {
-          return promise[prop].apply(promise, args);
-        }
-        return promise.then((form) => {
-          const p = form[prop];
-          if (typeof p === "function") {
-            return p.apply(form, args);
-          }
-          return p;
-        });
-      };
-    }
-  });
-  return proxy;
-}
-function useForm(ele, options = {}) {
-  if (!formElement) {
-    throw new Error("Form module is not loaded. Please use useFormAsync() to load the module before using useForm().");
-  }
-  if (ele == null) {
-    return new formElement(void 0, void 0, options);
-  }
-  let selector = void 0;
-  let el = void 0;
-  if (typeof ele === "string") {
-    selector = ele;
-    el = selectOne(ele) ?? void 0;
-  } else {
-    el = ele;
-  }
-  if (!el) {
-    return new formElement(selector, el, options);
-  }
-  return module$1(
-    el,
-    "unicorn.form",
-    () => new formElement(selector, el, options)
-  );
-}
-async function useFormComponent(ele, options = {}) {
-  const form = await useFormAsync(ele, options);
-  await form?.initComponent();
-  return form;
-}
-async function useFormSubmit(options = {}) {
-  const form = await useFormAsync(options.form);
-  const func = options.method?.toLowerCase() || "post";
-  return form[func](options.url, options.data);
-}
-let gridElement;
-async function useGridAsync(ele, options = {}) {
-  await useFormAsync();
-  const { UnicornGridElement } = await import("./grid.js");
-  gridElement ??= UnicornGridElement;
-  if (!ele) {
-    return null;
-  }
-  return useGrid(ele, options);
-}
-function useGrid(ele, options = {}) {
-  const selector = typeof ele === "string" ? ele : "";
-  const element = selectOne(ele);
-  if (!element) {
-    throw new Error("Element is empty");
-  }
-  const form = useForm(selector || element);
-  if (!form) {
-    throw new Error("UnicornGrid is depends on UnicornForm");
-  }
-  return module$1(
-    element,
-    "grid.plugin",
-    () => new gridElement(selector, element, form, options)
-  );
-}
-async function useGridComponent(ele, options = {}) {
-  const grid = await useGridAsync(ele, options);
-  await grid?.initComponent();
-  return grid;
-}
-function useHttpClient(config) {
-  const promise = import("./http-client.js").then(({ createHttpClient }) => {
-    return createHttpClient(config);
-  });
-  const data2 = {
-    request: (options) => {
-      return promise.then((client) => client.request(options));
-    },
-    get: (url, options) => {
-      return promise.then((client) => client.get(url, options));
-    },
-    post: (url, data22, options) => {
-      return promise.then((client) => client.post(url, data22, options));
-    },
-    put: (url, data22, options) => {
-      return promise.then((client) => client.put(url, data22, options));
-    },
-    patch: (url, data22, options) => {
-      return promise.then((client) => client.patch(url, data22, options));
-    },
-    delete: (url, data22, options) => {
-      return promise.then((client) => client.delete(url, data22, options));
-    },
-    head: (url, options) => {
-      return promise.then((client) => client.head(url, options));
-    },
-    options: (url, options) => {
-      return promise.then((client) => client.options(url, options));
-    },
-    http: promise
-  };
-  Object.assign(data2, {
-    then: promise.then.bind(promise),
-    catch: promise.catch.bind(promise)
-  });
-  return data2;
-}
-async function useIframeModal() {
-  const module = await import("./iframe-modal.js");
-  await module.ready;
-  return module;
-}
-async function useListDependent(element, dependent, options = {}) {
-  const module = await import("./list-dependent.js");
-  await module.ready;
-  if (element) {
-    const { ListDependent } = module;
-    return ListDependent.handle(element, dependent ?? void 0, options);
-  }
-  return module;
-}
-const queues = {};
-function useQueue(name = "default", maxRunning = 1) {
-  return queues[name] ??= createQueue(maxRunning);
-}
-function createQueue(maxRunning = 1) {
-  return queue(maxRunning);
-}
-async function useS3Uploader(name, options = {}) {
-  const module = await import("./s3-uploader.js");
-  if (!name) {
-    return module;
-  }
-  const { get } = module;
-  return get(name, options);
-}
-async function useS3MultipartUploader(options) {
-  const module = await import("./s3-multipart-uploader.js");
-  if (options != null) {
-    return new module.S3MultipartUploader(options);
-  }
-  return module;
-}
-async function useShowOn() {
-  const module = await import("./show-on.js");
-  await module.ready;
-  return module;
-}
-const stacks = {};
-function useStack(name = "default", store = []) {
-  return stacks[name] ??= createStack(store);
-}
-function createStack(store = []) {
-  return stack(store);
-}
-async function useTomSelect(selector, options = {}, theme = "bootstrap5") {
-  const [m] = await wait(
-    useImport("@vendor/tom-select/dist/js/tom-select.complete.min.js"),
-    useCssImport(`@vendor/tom-select/dist/css/tom-select.${theme}.min.css`)
-  );
-  if (selector) {
-    module$1(
-      selector,
-      "tom.select",
-      (ele) => {
-        options = mergeDeep({
-          allowEmptyOption: true,
-          maxOptions: null,
-          plugins: {
-            caret_position: {},
-            clear_button: {}
-          }
-        }, options);
-        if (ele.multiple) {
-          options.plugins.remove_button = {};
-        } else {
-          options.plugins.dropdown_input = {};
-        }
-        class UnicornTomSelect extends TomSelect {
-          syncOptionsWithoutKeepSelected() {
-            const oldValue = ele.value;
-            this.clear();
-            this.clearOptions();
-            this.sync();
-            if (ele.value !== oldValue) {
-              this.setValue(
-                ele.querySelector(`option[value="${oldValue}"]`)?.value ?? ele.querySelector("option")?.value ?? "",
-                true
-              );
-            }
-          }
-        }
-        const t = new UnicornTomSelect(ele, options);
-        ele.addEventListener("list:updated", () => {
-          t.syncOptionsWithoutKeepSelected();
-        });
-        return t;
-      }
-    );
-  }
-  return m;
-}
-async function useTinymce(selector, options = {}) {
-  const module = await import("./tinymce.js");
-  if (selector) {
-    return module.get(selector, options);
-  }
-  return module;
-}
-async function useTinymceHook(handler) {
-  const { addHook } = await import("./tinymce.js");
-  return addHook(handler);
-}
-let instances = {};
-async function useWebDirective(name = "unicorn", options = {}) {
-  if (options === false) {
-    delete instances[name];
-    return;
-  }
-  return instances[name] ??= await createWebDirective(Object.assign({}, options, { prefix: "uni-" }));
-}
-async function useUniDirective(name, handler, wdInstance = "unicorn") {
-  const wd = typeof wdInstance === "string" ? await useWebDirective(wdInstance) : wdInstance;
-  wd.register(name, handler);
-}
-async function createWebDirective(options = {}) {
-  const WebDirective = (await import("web-directive")).default;
-  const wd = new WebDirective(options);
-  wd.listen();
-  return wd;
-}
-async function useFormValidation(selector) {
-  const module = await import("./validation.js");
-  await module.ready;
-  if (!selector) {
-    return module;
-  }
-  return useFormValidationInstance(selector);
-}
-function useFormValidationInstance(selector) {
-  return getBoundedInstance(selector, "form.validation");
-}
-function useFieldValidationInstance(selector) {
-  return getBoundedInstance(selector, "field.validation");
-}
-async function addGlobalValidator(name, validator, options = {}) {
-  const { UnicornFormValidation } = await useFormValidation();
-  UnicornFormValidation.addGlobalValidator(name, validator, options);
-}
-let ui;
-AlertAdapter.alert = (title, text = "", type = "info") => {
-  if (text) {
-    title += " | " + text;
-  }
-  window.alert(title);
-  return Promise.resolve();
-};
-AlertAdapter.confirm = (message, text = "", type = "info") => {
-  message = message || "Are you sure?";
-  if (text) {
-    message += " | " + text;
-  }
-  return new Promise((resolve) => {
-    resolve(window.confirm(message));
-  });
-};
-AlertAdapter.notify = async (title, text, type = "log") => {
-  if (text) {
-    title += " | " + text;
-  }
-  return ui.theme?.renderMessage(title, type) ?? (() => null);
-};
-AlertAdapter.clearNotifies = async () => {
-  ui.theme?.clearMessages();
-};
-AlertAdapter.confirmText = () => "OK";
-AlertAdapter.cancelText = () => "Cancel";
-AlertAdapter.deleteText = () => "Delete";
-function useAlertAdapter(config) {
-  if (config) {
-    Object.assign(AlertAdapter, config);
-  }
-  return AlertAdapter;
-}
-function useUI(instance) {
-  if (instance) {
-    ui = instance;
-  }
-  return ui ??= new UnicornUI();
-}
-function useUITheme(theme) {
-  const ui2 = useUI();
-  if (ui2.theme && !theme) {
-    return ui2.theme;
-  }
-  if (typeof theme === "function") {
-    theme = new theme();
-  }
-  ui2.installTheme(theme);
-  return ui2.theme;
-}
-class UnicornUI {
-  theme;
-  static get defaultOptions() {
-    return {
-      messageSelector: ".message-wrap"
-    };
-  }
-  installTheme(theme) {
-    this.theme = theme;
-  }
-  // confirm(message: string): Promise<boolean> {
-  //   message = message || 'Are you sure?';
-  //
-  //   return new Promise((resolve) => {
-  //     resolve(window.confirm(message));
-  //   });
-  // }
-  //
-  // alert(title: string, text = '', type = 'info'): Promise<boolean> {
-  //   if (text) {
-  //     title += ' | ' + text;
-  //   }
-  //
-  //   window.alert(title);
-  //
-  //   return Promise.resolve(true);
-  // }
-}
-const prepares = [];
-const { promise: alpineLoaded, resolve: alpineResolve } = /* @__PURE__ */ promiseWithResolvers();
-async function loadAlpine(callback) {
-  if (callback && !window.Alpine) {
-    prepares.push(callback);
-  }
-  const { default: Alpine } = await useImport("@alpinejs");
-  if (!window.Alpine) {
-    await Promise.all(prepares.map((callback2) => Promise.resolve(callback2(Alpine))));
-    Alpine.start();
-    window.Alpine = Alpine;
-    alpineResolve(Alpine);
-  } else if (callback) {
-    await callback(Alpine);
-  }
-  return Alpine;
-}
-async function initAlpineComponent(directive) {
-  const Alpine = await alpineLoaded;
-  await nextTick();
-  selectAll(`[${directive}]`, (el) => {
-    const code = el.getAttribute(directive) || "";
-    el.removeAttribute(directive);
-    Alpine.mutateDom(() => {
-      el.setAttribute("x-data", code);
-    });
-    Alpine.initTree(el);
-  });
-}
-async function prepareAlpine(callback) {
-  if (window.Alpine) {
-    await callback(window.Alpine);
-  } else {
-    prepares.push(callback);
-  }
-}
-async function prepareAlpineDefer(callback) {
-  await alpineLoaded;
-  await callback(window.Alpine);
-}
-function renderMessage(messages, type = "info") {
-  return ui.theme?.renderMessage(messages, type);
-}
-function clearMessages() {
-  ui.theme?.clearMessages();
-}
-async function mark(selector, keyword = "", options = {}) {
-  const modules = await useImport("@vendor/mark.js/dist/mark.min.js");
-  if (selector != null) {
-    const instance = new Mark(selector);
-    instance.mark(keyword, options);
-  }
-  return modules;
-}
-async function slideUp(target, duration = 300) {
-  const ele = selectOne(target);
-  if (!ele) {
-    return Promise.resolve();
-  }
-  ele.style.overflow = "hidden";
-  const animation = animateTo(
-    ele,
-    { height: 0, paddingTop: 0, paddingBottom: 0 },
-    { duration, easing: "ease-out" }
-  );
-  data(ele, "animation.sliding.up", true);
-  const r = await animation.finished;
-  if (!data(ele, "animation.sliding.down")) {
-    ele.style.display = "none";
-  }
-  removeData(ele, "animation.sliding.up");
-  return r;
-}
-function slideDown(target, duration = 300, display = "block") {
-  const ele = selectOne(target);
-  if (!ele) {
-    return Promise.resolve();
-  }
-  data(ele, "animation.sliding.down", true);
-  ele.style.display = display;
-  ele.style.overflow = "hidden";
-  let maxHeight = 0;
-  for (const child of Array.from(ele.children)) {
-    maxHeight = Math.max(child.offsetHeight, maxHeight);
-  }
-  const animation = animateTo(
-    ele,
-    {
-      height: [
-        0,
-        maxHeight + "px"
-      ]
-    },
-    { duration, easing: "ease-out" }
-  );
-  animation.addEventListener("finish", () => {
-    ele.style.height = "";
-    if (!data(ele, "animation.sliding.up")) {
-      ele.style.overflow = "visible";
-    }
-    removeData(ele, "animation.sliding.down");
-  });
-  return animation.finished;
-}
-function slideToggle(target, duration = 500, display = "block") {
-  const ele = selectOne(target);
-  if (!ele) {
-    return Promise.resolve();
-  }
-  if (window.getComputedStyle(ele).display === "none") {
-    return slideDown(ele, duration, display);
-  } else {
-    return slideUp(ele, duration);
-  }
-}
-async function fadeOut(selector, duration = 500) {
-  const el = selectOne(selector);
-  if (!el) {
-    return;
-  }
-  const animation = animateTo(el, { opacity: 0 }, { duration, easing: "ease-out" });
-  const p = await animation.finished;
-  el.style.display = "none";
-  return p;
-}
-async function fadeIn(selector, duration = 500, display = "block") {
-  const el = selectOne(selector);
-  if (!el) {
-    return;
-  }
-  el.style.display = "";
-  if (window.getComputedStyle(el).display !== display) {
-    el.style.display = display;
-  }
-  const animation = animateTo(el, { opacity: 1 }, { duration, easing: "ease-out" });
-  return animation.finished;
-}
-async function highlight(selector, color = "#ffff99", duration = 600) {
-  const ele = selectOne(selector);
-  if (!ele) {
-    return;
-  }
-  duration /= 2;
-  const bg = window.getComputedStyle(ele).backgroundColor;
-  const animation = animateTo(ele, { backgroundColor: color }, { duration });
-  await animation.finished;
-  return animateTo(ele, { backgroundColor: bg }, { duration });
-}
-async function useColorPicker(selector, options = {}) {
-  if (options?.theme === "dark") {
-    useCssImport("@spectrum/spectrum-dark.min.css");
-  } else if (!options?.theme) {
-    useCssImport("@spectrum/spectrum.min.css");
-  }
-  const m = await useImport("@spectrum");
-  if (typeof options.locale === "string") {
-    let ls = options.locale.split("-").map((l) => l.toLowerCase());
-    if (ls[0] === ls[1]) {
-      ls = [ls];
-    }
-    ls = ls.join("-");
-    try {
-      await useImport(`@spectrum/i18n/${ls}.js`);
-    } catch (e) {
-      console.warn(`Unable to load Spectrum locale "${ls}" (${options.locale})`);
-    }
-  }
-  if (selector) {
-    return module$1(selector, "spectrum", (ele) => Spectrum.getInstance(ele, options));
-  }
-  return m;
-}
-function useDisableOnSubmit(formSelector = "#admin-form", buttonSelector = "", options = {}) {
-  buttonSelector = buttonSelector || [
-    "#admin-toolbar button",
-    "#admin-toolbar a",
-    formSelector + " .disable-on-submit",
-    formSelector + " .js-dos",
-    formSelector + " [data-dos]"
-  ].join(",");
-  const iconSelector = options.iconSelector || [
-    '[class*="fa-"]',
-    "[data-spin]",
-    "[data-spinner]"
-  ].join(",");
-  const event = options.event || "submit";
-  const spinnerClass = options.spinnerClass || "spinner-border spinner-border-sm";
-  const loadingClass = options.loadingCass || "is-loading";
-  selectAll(buttonSelector, (button) => {
-    button.addEventListener("click", (e) => {
-      button.dataset.clicked = "1";
-      setTimeout(() => {
-        delete button.dataset.clicked;
-      }, 1500);
-    });
-  });
-  const form = selectOne(formSelector);
-  form?.addEventListener(event, (e) => {
-    setTimeout(() => {
-      if (!form.checkValidity()) {
-        return;
-      }
-      selectAll(buttonSelector, (button) => {
-        button.style.pointerEvents = "none";
-        button.setAttribute("disabled", "disabled");
-        button.classList.add("disabled");
-        if (button.dataset.clicked) {
-          let icon = button.querySelector(iconSelector);
-          button.classList.add(loadingClass);
-          if (icon) {
-            const i = html("<i></i>");
-            icon.parentNode.replaceChild(i, icon);
-            i.setAttribute("class", spinnerClass);
-          }
-        }
-      });
-    }, 0);
-  });
-}
-function useDisableIfStackNotEmpty(buttonSelector = "[data-task=save]", stackName = "uploading") {
-  const stack2 = useStack(stackName);
-  stack2.observe((stack22, length) => {
-    for (const button of selectAll(buttonSelector)) {
-      if (length > 0) {
-        button.setAttribute("disabled", "disabled");
-        button.classList.add("disabled");
-      } else {
-        button.removeAttribute("disabled");
-        button.classList.remove("disabled");
-      }
-    }
-  });
-}
-function useKeepAlive(url, time = 6e4) {
-  const aliveHandle = window.setInterval(() => fetch(url), time);
-  return () => {
-    clearInterval(aliveHandle);
-  };
-}
-async function useVueComponentField(selector, value, options = {}) {
-  const m = await useImport("@unicorn/field/vue-component-field.js");
-  if (selector) {
-    m.VueComponentField.init(selector, value, options);
-  }
-  return m;
-}
-function useSystemUri(type, path) {
-  const uri2 = UnicornSystemUri.get();
-  if (type) {
-    return uri2[type](path);
-  }
-  return uri2;
-}
-function useAssetUri(type, path) {
-  const asset2 = UnicornAssetUri.get();
-  if (type) {
-    return asset2[type](path);
-  }
-  return asset2;
-}
-function uri(type) {
-  return data("unicorn.uri")[type];
-}
-function asset(type) {
-  return uri("asset")[type];
-}
-function addUriBase(uri2, type = "path") {
-  if (uri2.substring(0, 2) === "//" || uri2.substring(0, 4) === "http") {
-    return uri2;
-  }
-  return asset(type) + "/" + uri2;
-}
-class UnicornSystemUri extends URL {
-  static instance;
-  static get() {
-    return this.instance ??= new this(uri("full"));
-  }
-  path(path = "") {
-    return uri("path") + path;
-  }
-  root(path = "") {
-    return uri("root") + path;
-  }
-  current() {
-    return uri("current") || "";
-  }
-  full() {
-    return uri("full") || "";
-  }
-  route() {
-    return uri("route") || "";
-  }
-  script() {
-    return uri("script") || "";
-  }
-  routeWithQuery() {
-    const route2 = this.route();
-    const query = this.searchParams.toString();
-    return query ? `${route2}?${query}` : route2;
-  }
-  routeAndQuery() {
-    const route2 = this.route();
-    const query = this.searchParams.toString();
-    return [route2, query];
-  }
-}
-class UnicornAssetUri {
-  static instance;
-  static get() {
-    return this.instance ??= new this();
-  }
-  path(path = "") {
-    return asset("path") + path;
-  }
-  root(path = "") {
-    return asset("root") + path;
-  }
-}
-function encode(obj, pfx) {
-  var k, i, tmp, str = "";
-  for (k in obj) {
-    if ((tmp = obj[k]) !== void 0) {
-      if (Array.isArray(tmp)) {
-        for (i = 0; i < tmp.length; i++) {
-          str && (str += "&");
-          str += encodeURIComponent(k) + "=" + encodeURIComponent(tmp[i]);
-        }
-      } else {
-        str && (str += "&");
-        str += encodeURIComponent(k) + "=" + encodeURIComponent(tmp);
-      }
-    }
-  }
-  return "" + str;
-}
-function toValue(mix) {
-  if (!mix) return "";
-  var str = decodeURIComponent(mix);
-  if (str === "false") return false;
-  if (str === "true") return true;
-  return +str * 0 === 0 ? +str : str;
-}
-function decode(str) {
-  var tmp, k, out = {}, arr = str.split("&");
-  while (tmp = arr.shift()) {
-    tmp = tmp.split("=");
-    k = tmp.shift();
-    if (out[k] !== void 0) {
-      out[k] = [].concat(out[k], toValue(tmp.shift()));
-    } else {
-      out[k] = toValue(tmp.shift());
-    }
-  }
-  return out;
-}
-function addRoute(route2, url) {
-  const routes = data("unicorn.routes") || {};
-  routes[route2] = url;
-  data("unicorn.routes", routes);
-}
-function route(route2, query) {
-  const source = route2;
-  const extract = extractRoute(source);
-  route2 = extract.route;
-  let path = extract.path;
-  const routes = data("unicorn.routes") || {};
-  let url = routes[route2];
-  if (url == null) {
-    if (!route2.startsWith("@")) {
-      route2 = "@" + route2;
-    } else {
-      route2 = route2.substring(1);
-    }
-  }
-  url = routes[route2];
-  if (url == null) {
-    throw new Error(`Route: "${source}" not found`);
-  }
-  if (path) {
-    const { route: u1, path: u1q } = extractRoute(url, "?");
-    const { route: u2, path: u2q } = extractRoute(path, "?");
-    url = u1 + "/" + u2;
-    if (u1q || u2q) {
-      const q = [u1q, u2q].filter((u) => u).join("&");
-      url += "?" + q;
-    }
-  }
-  return addQuery(url, query);
-}
-function extractRoute(route2, sep = "/") {
-  if (route2.indexOf(sep) === -1) {
-    return { route: route2, path: "" };
-  }
-  const segments = route2.split(sep);
-  route2 = segments.shift() || "";
-  const path = segments.join(sep);
-  return { route: route2, path };
-}
-function hasRoute(route2) {
-  return void 0 !== data("unicorn.routes")[route2];
-}
-function addQuery(url, query) {
-  if (query == null) {
-    return url;
-  }
-  for (let k in query) {
-    const v = query[k];
-    const placeholder = `{${k}}`;
-    if (url.indexOf(placeholder) !== -1) {
-      url = url.replace(
-        new RegExp(`${placeholder}`, "g"),
-        v
-      );
-      delete query[k];
-    }
-    const encodedPlaceholder = encodeURIComponent(`{${k}}`);
-    if (url.indexOf(encodedPlaceholder) !== -1) {
-      url = url.replace(
-        new RegExp(`${encodedPlaceholder}`, "g"),
-        v
-      );
-      delete query[k];
-    }
-  }
-  if (Object.keys(query).length === 0) {
-    return url;
-  }
-  const queryString = encode(query);
-  return url + (/\?/.test(url) ? `&${queryString}` : `?${queryString}`);
-}
-function parseQuery(queryString) {
-  return decode(queryString);
-}
-function buildQuery(query) {
-  return encode(query);
-}
-function removeCloak() {
-  if (globalThis.document == null) {
-    return;
-  }
-  selectAll("[uni-cloak]", (el) => el.removeAttribute("uni-cloak"));
-}
-function data(ele, name, value) {
-  if (!(ele instanceof HTMLElement)) {
-    value = name;
-    name = ele;
-    ele = document;
-  }
-  if (name === void 0) {
-    return getData(ele);
-  }
-  if (value === void 0) {
-    return getData(ele, name);
-  }
-  setData(ele, name, value);
-}
-function removeData(ele, name = void 0) {
-  if (!(ele instanceof HTMLElement)) {
-    name = ele;
-    ele = document;
-  }
-  removeData$1(ele, name);
-}
-class EventMixin {
-  _listeners = {};
-  on(event, handler) {
-    if (Array.isArray(event)) {
-      for (const e of event) {
-        this.on(e, handler);
-      }
-      return this;
-    }
-    this._listeners[event] ??= [];
-    this._listeners[event].push(handler);
-    return this;
-  }
-  once(event, handler) {
-    handler.once = true;
-    return this.on(event, handler);
-  }
-  off(event, handler) {
-    if (handler) {
-      this._listeners[event] = this.listeners(event).filter((listener) => listener !== handler);
-      return this;
-    }
-    delete this._listeners[event];
-    return this;
-  }
-  trigger(event, ...args) {
-    if (Array.isArray(event)) {
-      for (const e of event) {
-        this.trigger(e);
-      }
-      return this;
-    }
-    for (const listener of this.listeners(event)) {
-      listener(...args);
-    }
-    this._listeners[event] = this.listeners(event).filter((listener) => listener?.once !== true);
-    return this;
-  }
-  listeners(event) {
-    return this._listeners[event] === void 0 ? [] : this._listeners[event];
-  }
-}
-class UnicornApp extends (/* @__PURE__ */ Mixin(EventMixin)) {
-  registry = /* @__PURE__ */ new Map();
-  plugins = /* @__PURE__ */ new Map();
-  // _listeners = {};
-  waits = [];
-  options;
-  defaultOptions = {};
-  domready = domready;
-  data = data;
-  constructor(options = {}) {
-    super();
-    this.options = Object.assign({}, this.defaultOptions, options);
-    if (typeof document !== "undefined") {
-      this.wait((resolve) => {
-        document.addEventListener("DOMContentLoaded", () => resolve());
-      });
-      document.addEventListener("DOMContentLoaded", () => {
-        this.completed().then(() => this.trigger("loaded"));
-      });
-    }
-  }
-  use(plugin, options = {}) {
-    if (Array.isArray(plugin)) {
-      plugin.forEach((p) => this.use(p));
-      return this;
-    }
-    plugin?.install?.(this, options);
-    this.trigger("plugin.installed", plugin);
-    this.plugins.set(plugin, plugin);
-    return this;
-  }
-  detach(plugin) {
-    if (plugin.uninstall) {
-      plugin.uninstall(this);
-    }
-    this.trigger("plugin.uninstalled", plugin);
-    return this;
-  }
-  inject(id, def) {
-    if (!this.registry.has(id)) {
-      if (def !== void 0) {
-        return def;
-      }
-      throw new Error(`Injectable: "${id.name ?? id}" not found.`);
-    }
-    return this.registry.get(id);
-  }
-  provide(id, value) {
-    this.registry.set(id, value);
-    return this;
-  }
-  // trigger(event, ...args) {
-  //   return this.tap(super.trigger(event, ...args), () => {
-  //     if (this.data('windwalker.debug')) {
-  //       console.debug(`[Unicorn Event] ${event}`, args, this.listeners(event));
-  //     }
-  //   });
-  // }
-  wait(callback) {
-    const p = new Promise((resolve, reject) => {
-      const promise = callback(resolve, reject);
-      if (promise && "then" in promise) {
-        promise.then(resolve).catch(reject);
-      }
-    });
-    this.waits.push(p);
-    return p;
-  }
-  completed() {
-    const promise = Promise.all(this.waits);
-    this.waits = [];
-    return promise;
-  }
-  macro(name, prop) {
-    if (this[name]) {
-      throw new Error(`Macro: ${name} already exists.`);
-    }
-    this[name] = prop;
-    return this;
-  }
-}
-function formRequestSubmit(prototype) {
-  if (typeof prototype.requestSubmit == "function") {
-    return;
-  }
-  prototype.requestSubmit = function(submitter) {
-    if (submitter) {
-      validateSubmitter(submitter, this);
-      submitter.click();
-    } else {
-      submitter = document.createElement("input");
-      submitter.type = "submit";
-      submitter.hidden = true;
-      this.appendChild(submitter);
-      submitter.click();
-      this.removeChild(submitter);
-    }
-  };
-  function validateSubmitter(submitter, form) {
-    submitter instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
-    submitter.type == "submit" || raise(TypeError, "The specified element is not a submit button");
-    submitter.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
-  }
-  function raise(errorConstructor, message, name) {
-    throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
-  }
-}
-function polyfill() {
-  if (typeof window !== "undefined") {
-    formRequestSubmit(HTMLFormElement.prototype);
-  }
-}
-async function useFieldMultiUploader() {
-  const module = await import("./field-multi-uploader.js");
-  await module.ready;
-  return module;
-}
-function useUnicornPhpAdapter(app2) {
-  app2 ??= useUnicorn();
-  app2.use(UnicornPhpAdapter);
-  return app2.$ui;
-}
-const methods = {
-  repeatable: useFieldRepeatable,
-  flatpickr: useFieldFlatpickr,
-  fileDrag: useFieldFileDrag,
-  modalField: useFieldModalSelect,
-  cascadeSelect: useFieldCascadeSelect,
-  sid: useFieldSingleImageDrag,
-  tinymce: {
-    init: useTinymce
-  },
-  s3Uploader: useS3Uploader,
-  iframeModal: useIframeModal,
-  initShowOn: useShowOn,
-  modalTree: useFieldModalTree,
-  multiUploader: useFieldMultiUploader,
-  tomSelect: useTomSelect,
-  listDependent: useListDependent,
-  bootstrap: {
-    tooltip: useBs5Tooltip,
-    buttonRadio: useBs5ButtonRadio,
-    keepTab: useBs5KeepTab
-  }
-};
-class UnicornPhpAdapter {
-  static install(app2) {
-    if (app2.$ui) {
-      app2.$ui = { ...app2.$ui, ...methods };
-    } else {
-      app2.$ui = methods;
-    }
-  }
-}
-let app;
-function createUnicorn() {
-  polyfill();
-  removeCloak();
-  return app = new UnicornApp();
-}
-function createUnicornWithPlugins() {
-  const app2 = createUnicorn();
-  return app2;
-}
-function useUnicorn(instance) {
-  if (instance) {
-    app = instance;
-  }
-  return app ??= createUnicorn();
-}
-const useInject = (id, def) => {
-  return useUnicorn().inject(id, def);
-};
-function pushUnicornToGlobal(app2) {
-  window.u = app2 ?? useUnicorn();
-}
-function useMacro(name, prop) {
-  const app2 = useUnicorn();
-  if (typeof name === "string") {
-    app2.macro(name, prop);
-  } else {
-    for (const k in name) {
-      app2.macro(k, name[k]);
-    }
-  }
-  return app2;
-}
-async function useLegacy(app2) {
-  app2 ??= useUnicorn();
-  pushUnicornToGlobal(app2);
-  const { useLegacyMethods } = await import("./legacy.js");
-  await useLegacyMethods(app2);
-  return app2;
-}
-export {
-  useBs5KeepTab as $,
-  h as A,
-  html as B,
-  delegate as C,
-  debounce as D,
-  throttle as E,
-  simpleConfirm as F,
-  simpleAlert as G,
-  sprintfExports as H,
-  base64UrlEncode as I,
-  base64UrlDecode as J,
-  uid as K,
-  tid as L,
-  serial as M,
-  mark as N,
-  useTomSelect as O,
-  slideUp as P,
-  slideDown as Q,
-  slideToggle as R,
-  fadeOut as S,
-  fadeIn as T,
-  highlight as U,
-  useColorPicker as V,
-  useDisableOnSubmit as W,
-  useDisableIfStackNotEmpty as X,
-  useCheckboxesMultiSelect as Y,
-  useKeepAlive as Z,
-  __ as _,
-  useUniDirective as a,
-  useS3MultipartUploader as a$,
-  useBs5ButtonRadio as a0,
-  useBs5Tooltip as a1,
-  useFormAsync as a2,
-  useGridAsync as a3,
-  useForm as a4,
-  useGrid as a5,
-  mergeDeep as a6,
-  trans as a7,
-  useUITheme as a8,
-  prepareAlpineDefer as a9,
-  isError as aA,
-  nextTick as aB,
-  parseQuery as aC,
-  pushUnicornToGlobal as aD,
-  randomBytes as aE,
-  randomBytesString as aF,
-  removeBoundedInstance as aG,
-  removeData as aH,
-  useAlertAdapter as aI,
-  useBsModalAlert as aJ,
-  useCssIncludes as aK,
-  useFieldCascadeSelect as aL,
-  useFieldFileDrag as aM,
-  useFieldFlatpickr as aN,
-  useFieldModalSelect as aO,
-  useFieldModalTree as aP,
-  useFieldRepeatable as aQ,
-  useFieldSingleImageDrag as aR,
-  useFormComponent as aS,
-  useFormSubmit as aT,
-  useGridComponent as aU,
-  useIframeModal as aV,
-  useInject as aW,
-  useLang as aX,
-  useLegacy as aY,
-  useListDependent as aZ,
-  useMacro as a_,
-  watchAttributes as aa,
-  injectCssToDocument as ab,
-  useImport as ac,
-  useCssImport as ad,
-  data as ae,
-  forceArray as af,
-  deleteConfirm as ag,
-  Mixin as ah,
-  EventMixin as ai,
-  createQueue as aj,
-  useScriptImport as ak,
-  sleep as al,
-  AttributeMutationObserver as am,
-  UnicornAssetUri as an,
-  UnicornPhpAdapter as ao,
-  UnicornSystemUri as ap,
-  UnicornUI as aq,
-  addQuery as ar,
-  addRoute as as,
-  addUriBase as at,
-  buildQuery as au,
-  createStack as av,
-  createUnicorn as aw,
-  createUnicornWithPlugins as ax,
-  doImport as ay,
-  hasRoute as az,
-  animateTo as b,
-  useS3Uploader as b0,
-  useSeriesImport as b1,
-  useShowOn as b2,
-  useTinymce as b3,
-  useTinymceHook as b4,
-  useUI as b5,
-  useUIBootstrap5 as b6,
-  useUnicorn as b7,
-  useUnicornPhpAdapter as b8,
-  useVueComponentField as b9,
-  useWebDirective as ba,
-  wait as bb,
-  renderMessage as c,
-  clearMessages as d,
-  clearNotifies as e,
-  initAlpineComponent as f,
-  useFormValidation as g,
-  addGlobalValidator as h,
-  isDebug as i,
-  useFieldValidationInstance as j,
-  useFormValidationInstance as k,
-  loadAlpine as l,
-  useStack as m,
-  useQueue as n,
-  useSystemUri as o,
-  prepareAlpine as p,
-  useAssetUri as q,
-  route as r,
-  simpleNotify as s,
-  domready as t,
-  useHttpClient as u,
-  selectOne as v,
-  selectAll as w,
-  getBoundedInstance as x,
-  getBoundedInstanceList as y,
-  module$1 as z
-};
-//# sourceMappingURL=unicorn.js.map