@windwalker-io/unicorn-next 0.1.0

package/dist/chunks/unicorn.js

@@ -0,0 +1,2202 @@
+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 = void 0) {
+  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 module(ele, name, callback = () => 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];
+    }
+  };
+}
+function injectCssToDocument(doc, ...css) {
+  if (!(doc instanceof Document)) {
+    css.push(doc);
+    doc = document;
+  }
+  const styles = css.map((css2) => {
+    if (typeof css2 === "string") {
+      const style = new CSSStyleSheet();
+      style.replaceSync(css2);
+      return style;
+    }
+    return css2;
+  });
+  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) => window.alert(title);
+_AlertAdapter.confirm = async (title) => {
+  return new Promise((resolve) => {
+    const v = confirm(title);
+    resolve(v);
+  });
+};
+_AlertAdapter.deleteConfirm = async (title) => _AlertAdapter.confirm(title);
+_AlertAdapter.confirmText = () => "確認";
+_AlertAdapter.cancelText = () => "取消";
+_AlertAdapter.deleteText = () => "刪除";
+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);
+}
+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;
+}
+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);
+      });
+    });
+    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);
+}
+var sprintf = {};
+var hasRequiredSprintf;
+function requireSprintf() {
+  if (hasRequiredSprintf) return sprintf;
+  hasRequiredSprintf = 1;
+  (function(exports) {
+    !(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["sprintf"] = sprintf2;
+        exports["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") || {};
+  }
+}
+function useScriptImport(src, attrs = {}) {
+  const script = document.createElement("script");
+  script.src = 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) => {
+    href = resolveUrl(href);
+    return new Promise((resolve, reject) => {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = href;
+      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) => {
+      if (!importedSheets[href]) {
+        importedSheets[href] = simulateCssImport(href);
+      }
+      return importedSheets[href];
+    })
+  );
+  const styles = modules.map((module2) => module2.default);
+  return injectCssToDocument(...styles);
+}
+async function simulateCssImport(href) {
+  href = resolveUrl(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 useCheckboxesMultiSelect(selector, options = {}) {
+  const m = await import("./checkboxes-multi-select.js");
+  if (selector) {
+    m.CheckboxesMultiSelect.handle(selector, options);
+  }
+  return m;
+}
+async function useFieldCascadeSelect() {
+  const module2 = await import("./field-cascade-select.js");
+  await module2.ready;
+  return module2;
+}
+async function useFieldFileDrag() {
+  const module2 = await import("./field-file-drag.js");
+  await module2.ready;
+  return module2;
+}
+function useFieldFlatpickr() {
+  return import("./field-flatpickr.js");
+}
+function useFieldModalSelect() {
+  return import("./field-modal-select.js");
+}
+function useFieldModalTree() {
+  import("./field-modal-tree.js");
+}
+async function useFieldRepeatable() {
+  const module2 = await import("./field-repeatable.js");
+  await module2.ready;
+  return module2;
+}
+function useFieldSingleImageDrag() {
+  return import("./field-single-image-drag.js");
+}
+let formElement;
+async function useFormAsync(ele, options = {}) {
+  const { UnicornFormElement } = await import("./form.js");
+  formElement ??= UnicornFormElement;
+  return useForm(ele, options);
+}
+function useForm(ele, options = {}) {
+  if (ele == null) {
+    return new formElement(void 0, void 0, options);
+  }
+  const selector = typeof ele === "string" ? ele : void 0;
+  const el = selectOne(ele);
+  if (!el) {
+    throw new Error(`Form element of: ${selector} not found.`);
+  }
+  return module(
+    el,
+    "unicorn.form",
+    () => new formElement(selector, el, options)
+  );
+}
+async function useFormComponent(ele, options = {}) {
+  const form = await useFormAsync(ele, options);
+  await form?.initComponent();
+  return form;
+}
+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(
+    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;
+}
+async function useHttpClient(config) {
+  const { createHttpClient } = await import("./http-client.js");
+  return createHttpClient(config);
+}
+async function useIframeModal() {
+  const module2 = await import("./iframe-modal.js");
+  await module2.ready;
+  return module2;
+}
+async function useListDependent(element, dependent, options = {}) {
+  const module2 = await import("./list-dependent.js");
+  await module2.ready;
+  if (element) {
+    const { ListDependent } = module2;
+    return ListDependent.handle(element, dependent ?? void 0, options);
+  }
+  return module2;
+}
+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 module2 = await import("./s3-uploader.js");
+  if (!name) {
+    return module2;
+  }
+  const { get } = module2;
+  return get(name, options);
+}
+async function useS3MultipartUploader(options) {
+  const module2 = await import("./s3-multipart-uploader.js");
+  if (options != null) {
+    return new module2.S3MultipartUploader(options);
+  }
+  return module2;
+}
+async function useShowOn() {
+  const module2 = await import("./show-on.js");
+  await module2.ready;
+  return module2;
+}
+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(
+      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 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);
+};
+let instances = {};
+async function useWebDirective(name = "unicorn", options = {}) {
+  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 module2 = await import("./validation.js");
+  await module2.ready;
+  if (!selector) {
+    return module2;
+  }
+  return useFormValidationSync(selector);
+}
+function useFormValidationSync(selector) {
+  return getBoundedInstance(selector, "form.validation");
+}
+function useFieldValidationSync(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) => {
+  message = message || "Are you sure?";
+  return new Promise((resolve) => {
+    resolve(window.confirm(message));
+  });
+};
+AlertAdapter.confirmText = () => "OK";
+AlertAdapter.cancelText = () => "Cancel";
+AlertAdapter.deleteText = () => "Delete";
+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;
+  aliveHandle;
+  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__ */ Promise.withResolvers();
+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") {
+  ui.theme.renderMessage(messages, type);
+}
+function clearMessages() {
+  ui.theme.clearMessages();
+}
+function notify(messages, type = "info") {
+  ui.theme.renderMessage(messages, type);
+}
+function clearNotifies() {
+  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;
+  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) {
+    module(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";
+  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);
+          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 = void 0, value = void 0) {
+  if (!(ele instanceof HTMLElement)) {
+    value = name;
+    name = ele;
+    ele = document;
+  }
+  if (name === void 0) {
+    return getData(ele);
+  }
+  if (value === void 0) {
+    const res = getData(ele, name);
+    return res;
+  }
+  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 (!typeof this.registry.has(id)) {
+      if (def !== void 0) {
+        return def;
+      }
+      throw new Error(`Injectable: ${id.name} 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, callback) {
+    if (this[name]) {
+      throw new Error(`Macro: ${name} already exists.`);
+    }
+    this[name] = callback;
+    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() {
+  await import("./field-multi-uploader.js");
+}
+async function useTinymce(selector, options = {}) {
+  const module2 = await import("./tinymce.js");
+  if (selector) {
+    return module2.get(selector, options);
+  }
+  return module2;
+}
+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
+};
+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, handler) {
+  useUnicorn().macro(name, handler);
+}
+async function useLegacy(app2) {
+  app2 ??= useUnicorn();
+  pushUnicornToGlobal(app2);
+  const { useLegacyMethods } = await import("./legacy.js");
+  await useLegacyMethods(app2);
+  return app2;
+}
+export {
+  useBs5Tooltip 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,
+  createStack as a$,
+  useFormAsync as a0,
+  useGridAsync as a1,
+  useForm as a2,
+  useGrid as a3,
+  prepareAlpineDefer as a4,
+  mergeDeep as a5,
+  watchAttributes as a6,
+  injectCssToDocument as a7,
+  useImport as a8,
+  useCssImport as a9,
+  useCssIncludes as aA,
+  AlertAdapter as aB,
+  useUI as aC,
+  UnicornUI as aD,
+  useVueComponentField as aE,
+  addUriBase as aF,
+  UnicornSystemUri as aG,
+  UnicornAssetUri as aH,
+  addRoute as aI,
+  hasRoute as aJ,
+  addQuery as aK,
+  parseQuery as aL,
+  buildQuery as aM,
+  useFieldCascadeSelect as aN,
+  useFieldFileDrag as aO,
+  useFieldFlatpickr as aP,
+  useFieldModalSelect as aQ,
+  useFieldModalTree as aR,
+  useFieldRepeatable as aS,
+  useFieldSingleImageDrag as aT,
+  useFormComponent as aU,
+  useGridComponent as aV,
+  useIframeModal as aW,
+  useListDependent as aX,
+  useS3Uploader as aY,
+  useS3MultipartUploader as aZ,
+  useShowOn as a_,
+  data as aa,
+  forceArray as ab,
+  deleteConfirm as ac,
+  Mixin as ad,
+  EventMixin as ae,
+  createQueue as af,
+  trans as ag,
+  useUITheme as ah,
+  sleep as ai,
+  createUnicorn as aj,
+  createUnicornWithPlugins as ak,
+  useUnicorn as al,
+  useInject as am,
+  pushUnicornToGlobal as an,
+  useMacro as ao,
+  useLegacy as ap,
+  removeData as aq,
+  randomBytes as ar,
+  randomBytesString as as,
+  AttributeMutationObserver as at,
+  nextTick as au,
+  wait as av,
+  useLang as aw,
+  useScriptImport as ax,
+  doImport as ay,
+  useSeriesImport as az,
+  animateTo as b,
+  useUIBootstrap5 as b0,
+  useBs5KeepTab as b1,
+  useBs5ButtonRadio as b2,
+  useWebDirective as b3,
+  useUnicornPhpAdapter as b4,
+  UnicornPhpAdapter as b5,
+  renderMessage as c,
+  clearMessages as d,
+  clearNotifies as e,
+  initAlpineComponent as f,
+  useFormValidation as g,
+  addGlobalValidator as h,
+  isDebug as i,
+  useFieldValidationSync as j,
+  useFormValidationSync as k,
+  loadAlpine as l,
+  useStack as m,
+  notify as n,
+  useQueue as o,
+  prepareAlpine as p,
+  useSystemUri as q,
+  route as r,
+  useAssetUri as s,
+  domready as t,
+  useHttpClient as u,
+  selectOne as v,
+  selectAll as w,
+  getBoundedInstance as x,
+  getBoundedInstanceList as y,
+  module as z
+};
+//# sourceMappingURL=unicorn.js.map