@opentiny/tiny-robot 0.1.0-alpha.0

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/input/vue.js

@@ -0,0 +1,263 @@
+import { __spreadProps as w, __spreadValues as M } from "../chunk-G2ADBYYC.js";
+import { textLength as T, handleTextareaMouseUp as z, handleTextareaMouseDown as C, inputStyle as v, handleLeaveTextarea as F, handleEnterTextarea as N, getDisplayOnlyText as L, setInputDomValue as B, handleCompositionUpdate as E, handleCompositionStart as P, calculateNodeStyling as _, getSuffixVisible as A, calcIconOffset as U, watchFormSelect as W, handleChange as $, setShowMoreBtn as H, getInput as j, clear as k, showBox as K, getDisplayedMaskValue as Y, hiddenPassword as Z, handleEnterDisplayOnlyContent as q, hasSelection as G, handlePasswordVisible as J, handleCompositionEnd as Q, setNativeInputValue as R, calcTextareaHeight as X, updateIconOffset as p, resizeTextarea as ee, handleInput as ae, handleFocus as le, handleBlur as te, select as ie, focus as ne, blur as oe } from "./index.js";
+import se from "../tall-storage/vue-storage-box.js";
+import { on as de, off as ue } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+const Ie = [
+  "blur",
+  "showBox",
+  "clear",
+  "focus",
+  "state",
+  "select",
+  "getInput",
+  "handleBlur",
+  "handleInput",
+  "handleFocus",
+  "handleChange",
+  "calcIconOffset",
+  "resizeTextarea",
+  "getSuffixVisible",
+  "updateIconOffset",
+  "calcTextareaHeight",
+  "setNativeInputValue",
+  "calculateNodeStyling",
+  "handleCompositionEnd",
+  "handlePasswordVisible",
+  "handleCompositionStart",
+  "handleCompositionUpdate",
+  "addMemory",
+  "searchMemory",
+  "selectedMemory",
+  "storageData",
+  "isMemoryStorage",
+  "hasSelection",
+  "handleEnterDisplayOnlyContent",
+  "hiddenPassword",
+  "inputStyle",
+  "handleEnterTextarea",
+  "handleLeaveTextarea",
+  "handleTextareaMouseDown",
+  "handleTextareaMouseUp"
+], re = ({
+  reactive: t,
+  computed: e,
+  mode: o,
+  props: a,
+  parent: l,
+  constants: d,
+  api: s,
+  vm: r,
+  designConfig: n
+}) => {
+  const i = t({
+    mode: o,
+    maskSymbol: d.MASKSYMBOL,
+    focused: !1,
+    hovering: !1,
+    isComposing: !1,
+    passwordVisible: !1,
+    maskValueVisible: !1,
+    boxVisibility: !1,
+    textareaCalcStyle: {},
+    checkedLabel: "",
+    enteredTextarea: !1,
+    sheetvalue: a.modelValue,
+    inputSize: e(() => a.size || i.formItemSize || (l.tinyForm || {}).size),
+    inputSizeMf: e(() => a.size || i.formItemSize || (l.tinyForm || {}).size),
+    showClear: e(
+      () => {
+        var f;
+        return a.clearable && !i.inputDisabled && !a.readonly && i.nativeInputValue && (!((f = n == null ? void 0 : n.options) != null && f.isCloseIconHide) || i.focused || i.hovering);
+      }
+    ),
+    textareaHeight: r.theme === "saas" ? "28px" : "30px",
+    upperLimit: e(() => l.$attrs.maxlength),
+    textLength: e(() => T(a.modelValue)),
+    inputExceed: e(() => i.isWordLimitVisible && i.textLength > i.upperLimit),
+    formItemSize: e(() => (l.formItem || {}).formItemSize),
+    validateIcon: e(() => d.VALIDATE_ICON[i.validateState]),
+    showWordLimit: e(() => a.showWordLimit && l.$attrs.maxlength),
+    inputDisabled: e(
+      () => a.disabled || (l.tinyForm || {}).disabled || i.isDisplayOnly || (l.tinyForm || {}).displayOnly
+    ),
+    validateState: e(() => l.formItem ? l.formItem.validateState : ""),
+    inputStyle: e(() => s.inputStyle()),
+    textareaStyle: e(() => w(M({}, i.textareaCalcStyle), {
+      resize: a.resize,
+      textAlign: a.textAlign
+    })),
+    needStatusIcon: e(() => l.tinyForm ? l.tinyForm.statusIcon : !1),
+    showPwdVisible: e(
+      () => a.showPassword && !i.inputDisabled && !a.readonly && (!!i.nativeInputValue || i.focused)
+    ),
+    nativeInputValue: e(
+      () => a.modelValue === null || a.modelValue === void 0 ? "" : String(a.modelValue)
+    ),
+    tooltipConfig: e(() => l.tinyForm ? l.tinyForm.tooltipConfig : {}),
+    isWordLimitVisible: e(
+      () => (a.showWordLimit && l.$attrs.maxlength || a.counter) && (l.type === "text" || l.type === "textarea") && !i.inputDisabled && !a.readonly && !a.showPassword
+    ),
+    isDisplayOnly: e(
+      () => (a.displayOnly || (l.tinyForm || {}).displayOnly) && ["text", "textarea", "password", "number"].includes(a.type)
+    ),
+    displayOnlyTooltip: "",
+    showMoreBtn: !1,
+    showDisplayOnlyBox: !1,
+    timer: null,
+    hiddenPassword: e(() => s.hiddenPassword()),
+    displayedMaskValue: e(() => s.getDisplayedMaskValue()),
+    displayOnlyText: e(() => s.getDisplayOnlyText()),
+    isDragging: !1
+  });
+  return i;
+}, he = ({
+  api: t,
+  state: e,
+  dispatch: o,
+  broadcast: a,
+  emit: l,
+  vm: d,
+  props: s,
+  parent: r,
+  nextTick: n
+}) => {
+  Object.assign(t, {
+    state: e,
+    dispatch: o,
+    broadcast: a,
+    showBox: K(e),
+    clear: k(l),
+    getInput: j(d),
+    setShowMoreBtn: H({ state: e, vm: d }),
+    handleChange: $(l),
+    watchFormSelect: W({ emit: l, props: s, state: e }),
+    calcIconOffset: U({ vm: d, parent: r }),
+    getSuffixVisible: A({ parent: r, props: s, state: e }),
+    calculateNodeStyling: _(),
+    handleCompositionStart: P(e),
+    handleCompositionUpdate: E(e),
+    setInputDomValue: B({ state: e, props: s, nextTick: n, vm: d }),
+    getDisplayOnlyText: L({ parent: r, props: s, state: e }),
+    handleEnterTextarea: N({ api: t, state: e, props: s, nextTick: n }),
+    handleLeaveTextarea: F({ api: t, state: e, props: s, nextTick: n, vm: d }),
+    inputStyle: v({ props: s }),
+    handleTextareaMouseDown: C({ state: e }),
+    handleTextareaMouseUp: z({ state: e, api: t })
+  });
+}, ye = ({
+  storages: t,
+  api: e,
+  componentName: o,
+  props: a,
+  emit: l,
+  eventName: d,
+  nextTick: s,
+  parent: r,
+  state: n,
+  vm: i,
+  mode: f,
+  constants: h
+}) => {
+  const { storageData: m, isMemoryStorage: x, addMemory: y, searchMemory: I, selectedMemory: g } = t;
+  return Object.assign(e, {
+    addMemory: y,
+    storageData: m,
+    searchMemory: I,
+    selectedMemory: g,
+    isMemoryStorage: x,
+    blur: oe(e),
+    focus: ne(e),
+    select: ie(e),
+    handleBlur: te({
+      api: e,
+      componentName: o,
+      emit: l,
+      eventName: d.blur,
+      props: a,
+      state: n,
+      vm: i
+    }),
+    handleFocus: le({ api: e, emit: l, state: n }),
+    handleInput: ae({ api: e, emit: l, nextTick: s, state: n }),
+    resizeTextarea: ee({ api: e, parent: r, vm: i, state: n, props: a }),
+    updateIconOffset: p(e),
+    calcTextareaHeight: X({
+      api: e,
+      hiddenTextarea: null,
+      props: a,
+      state: n,
+      mode: f,
+      constants: h
+    }),
+    setNativeInputValue: R({ api: e, state: n }),
+    handleCompositionEnd: Q({ api: e, state: n }),
+    handlePasswordVisible: J({ api: e, nextTick: s, state: n }),
+    hasSelection: G(e),
+    handleEnterDisplayOnlyContent: q({ state: n, props: a }),
+    hiddenPassword: Z({ state: n, props: a }),
+    getDisplayedMaskValue: Y({ state: n })
+  });
+}, fe = ({
+  watch: t,
+  state: e,
+  api: o,
+  props: a,
+  nextTick: l,
+  emit: d,
+  componentName: s,
+  eventName: r
+}) => {
+  t(
+    () => a.modelValue,
+    (n) => {
+      e.mode === "mobile" && (e.sheetvalue = n, d("update:modelValue", n)), l(o.resizeTextarea), a.validateEvent && o.dispatch(s, r.change, [n]), a.type === "textarea" && a.popupMore && e.isDisplayOnly && o.setShowMoreBtn(), o.setInputDomValue();
+    }
+  ), t(() => e.maskValueVisible, o.setInputDomValue), t(() => e.inputDisabled, o.setInputDomValue), t(
+    () => a.mask,
+    () => {
+      o.setInputDomValue("mask");
+    }
+  ), t(
+    () => a.size,
+    () => l(o.resizeTextarea),
+    { immediate: !0 }
+  ), t(
+    () => e.nativeInputValue,
+    () => {
+      o.setNativeInputValue();
+    }
+  ), t(
+    () => a.type,
+    () => {
+      l(() => {
+        o.setNativeInputValue(), o.resizeTextarea(), o.updateIconOffset();
+      });
+    }
+  ), t(
+    () => e.isDisplayOnly,
+    () => {
+      l(() => {
+        o.setNativeInputValue(), o.resizeTextarea(), o.updateIconOffset();
+      });
+    }
+  ), t(
+    () => e.sheetvalue,
+    (n) => o.watchFormSelect(n),
+    { immediate: !0 }
+  );
+}, Se = (t, { computed: e, onMounted: o, onBeforeUnmount: a, onUpdated: l, reactive: d, toRefs: s, watch: r, inject: n }, { vm: i, refs: f, parent: h, emit: m, constants: x, nextTick: y, broadcast: I, dispatch: g, mode: S, designConfig: D }) => {
+  const u = {}, V = x.COMPONENT_NAME.FormItem, b = { change: "form.change", blur: "form.blur" }, c = re({ reactive: d, computed: e, mode: S, props: t, parent: h, constants: x, api: u, vm: i, designConfig: D });
+  he({ api: u, state: c, dispatch: g, broadcast: I, emit: m, props: t, parent: h, vm: i, nextTick: y });
+  const O = se({ api: u, props: t, reactive: d, toRefs: s });
+  return h.tinyForm = h.tinyForm || n("form", null), ye({ api: u, storages: O, componentName: V, emit: m, eventName: b, props: t, state: c, nextTick: y, parent: h, vm: i, mode: S, constants: x }), fe({ watch: r, state: c, api: u, props: t, nextTick: y, emit: m, componentName: V, eventName: b }), o(() => {
+    u.setNativeInputValue(), u.resizeTextarea(), u.updateIconOffset(), u.setInputDomValue(), g("Select", "input-mounted", i.$el), g("Tooltip", "tooltip-update", i.$el), t.type === "textarea" && t.popupMore && c.isDisplayOnly && (u.setShowMoreBtn(!0), de(window, "resize", u.setShowMoreBtn)), i.$attrs.autofocus && u.focus();
+  }), a(() => {
+    t.type === "textarea" && t.popupMore && c.isDisplayOnly && ue(window, "resize", u.setShowMoreBtn);
+  }), l(() => {
+    y(u.updateIconOffset);
+  }), u;
+};
+export {
+  Ie as api,
+  Se as renderless
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tall-storage/index.js

@@ -0,0 +1,63 @@
+import { KEY_CODE as i } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+const h = (t) => (t && t.preventDefault ? t.preventDefault() : window.event.returnValue = !1, !1), y = ({ emit: t, state: e }) => (r) => {
+  e.hoverValue = "", t("selected", r);
+}, d = ({ emit: t, props: e, state: r }) => () => {
+  const l = window.event.keyCode, a = e.localstorageData.indexOf(r.hoverValue), o = e.localstorageData.length - 1;
+  if (l === i.ArrowUp && e.isMemoryStorage)
+    return a > 0 && a <= o ? r.hoverValue = e.localstorageData[a - 1] : r.hoverValue = e.localstorageData[o], !1;
+  if (l === i.ArrowDown && e.isMemoryStorage)
+    return a >= 0 && a < o ? r.hoverValue = e.localstorageData[a + 1] : r.hoverValue = e.localstorageData[0], !1;
+  l === i.NumpadEnter && e.isMemoryStorage && r.hoverValue && r.hoverValue.length > 0 && t("selected", r.hoverValue);
+}, g = (t, e = 5) => {
+  const r = t.length;
+  let l = [], a = {};
+  for (let o = 0, n = 1; n <= e && !(o < 0 || o >= r || (a[t[o]] ? n = n - 1 : (a[t[o]] = !0, l.push(t[o])), n === r)); n++)
+    o++;
+  return l;
+}, f = (t, e) => {
+  if (typeof t == "string")
+    try {
+      const r = JSON.parse(t);
+      return !!(typeof r == "object" && r && (!e || r.constructor === e));
+    } catch {
+      return !1;
+    }
+}, u = (t, e, r = 5) => {
+  if (typeof e == "string") {
+    const l = localStorage.getItem(t), a = f(l, Array);
+    let o = "";
+    if (l && a) {
+      let n = JSON.parse(localStorage.getItem(t));
+      n.unshift(e), n = g(n, r), o = JSON.stringify(n);
+    } else l === null || l === e ? o = JSON.stringify([e]) : o = JSON.stringify([e, l]);
+    localStorage.setItem(t, o);
+  }
+}, S = (t) => (e) => {
+  t.name && (e != null && e.trim()) && u(t.name, e, t.memorySpace);
+}, D = ({ props: t, state: e }) => (r) => {
+  if (!t.name)
+    return;
+  const l = localStorage.getItem(t.name);
+  let a = [], o = !0;
+  if (f(l)) {
+    const n = JSON.parse(l);
+    if (!r)
+      a = JSON.parse(l);
+    else
+      for (let s = 0, c = n.length; s < c; s++)
+        n[s].includes(r) && a.push(n[s]);
+    a.length === 0 && (o = !1);
+  } else
+    l === null ? o = !1 : a.push(l);
+  e.storageData = a, e.isMemoryStorage = o;
+}, w = ({ api: t, state: e }) => (r) => {
+  t.getInput().value = r, t.handleInput({ target: { value: r } }), t.handleChange({ target: { value: r } }), e.isMemoryStorage = !1;
+};
+export {
+  S as addMemory,
+  d as keydown,
+  h as mousedown,
+  D as searchMemory,
+  y as selectItem,
+  w as selectedMemory
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tall-storage/vue-storage-box.js

@@ -0,0 +1,16 @@
+import { __spreadProps as s, __spreadValues as m } from "../chunk-G2ADBYYC.js";
+import { selectedMemory as d, searchMemory as y, addMemory as M } from "./index.js";
+var c = ({ api: a, props: r, reactive: o, toRefs: t }) => {
+  const e = o({
+    storageData: [],
+    isMemoryStorage: !1
+  });
+  return s(m({}, t(e)), {
+    addMemory: M(r),
+    searchMemory: y({ props: r, state: e }),
+    selectedMemory: d({ api: a, state: e })
+  });
+};
+export {
+  c as default
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tall-storage/vue.js

@@ -0,0 +1,23 @@
+import { keydown as a, selectItem as c, mousedown as u } from "./index.js";
+import { off as w, on as l } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+const k = ["state", "mousedown", "selectItem"], f = (t, { onUnmounted: s, reactive: r, watch: m }, { emit: n }) => {
+  const e = r({
+    hoverValue: ""
+  }), o = {
+    state: e,
+    mousedown: u,
+    selectItem: c({ emit: n, state: e }),
+    keydown: a({ emit: n, props: t, state: e })
+  };
+  return m(
+    () => t.isMemoryStorage,
+    (d) => !d && (e.hoverValue = ""),
+    { immediate: !0 }
+  ), s(() => {
+    e.hoverValue = "", w(document, "keydown", o.keydown);
+  }), l(document, "keydown", o.keydown), o;
+};
+export {
+  k as api,
+  f as renderless
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tooltip/index.js

@@ -0,0 +1,77 @@
+import { debounce as d, on as r, addClass as f, removeClass as a, off as c } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+const m = ({ api: e, state: o, props: t }) => (n) => {
+  const s = n && n.type === "mouseenter" ? 200 : 0;
+  if (t.visible === "auto") {
+    const { clientWidth: u, scrollWidth: i } = o.referenceElm;
+    if (i <= u)
+      return;
+  }
+  e.setExpectedState(!0), e.handleShowPopper(s);
+}, h = (e) => () => {
+  e.setExpectedState(!1), e.debounceClose();
+}, b = ({ api: e, state: o }) => () => {
+  o.focusing = !0, e.show();
+}, g = ({ api: e, state: o }) => () => {
+  o.focusing = !1, e.hide();
+}, w = ({ api: e, state: o }) => () => {
+  o.focusing = !1, e.show();
+}, y = ({ props: e, state: o }) => (t) => {
+  !o.expectedState || e.manual || (clearTimeout(o.timeout), o.timeout = window.setTimeout(() => {
+    o.showPopper = !0;
+  }, e.openDelay || t), e.hideAfter > 0 && (o.timeoutPending = window.setTimeout(() => {
+    o.showPopper = !1;
+  }, e.hideAfter)));
+}, P = ({ api: e, props: o, state: t }) => () => {
+  o.enterable && t.expectedState || o.manual || (clearTimeout(t.timeout), t.timeoutPending && clearTimeout(t.timeoutPending), t.showPopper = !1, o.disabled && e.doDestroy());
+}, E = ({ props: e, api: o, state: t, popperVmRef: n }) => (l) => {
+  if (e.manual)
+    return;
+  const s = t.referenceElm, u = n.popper;
+  !u || !s || u.contains(l.target) || s.contains(l.target) || t.showPopper && (o.setExpectedState(!1), o.debounceClose());
+}, x = ({ state: e }) => (o) => {
+  e.expectedState === !1 && clearTimeout(e.timeoutPending), e.expectedState = o;
+}, C = ({ state: e, api: o, vm: t }) => () => {
+  const n = e.referenceElm;
+  e.showPopper = !1, n && n.nodeType === 1 && (c(document, "click", o.handleDocumentClick), c(n, "mouseenter", o.show), c(n, "mouseleave", o.hide), c(n, "focus", o.focusHandler), c(n, "blur", o.handleBlur), c(n, "click", o.removeFocusing)), t.popperVM && (typeof t.popperVM.$destroy == "function" && t.popperVM.$destroy(), t.popperVM = null);
+}, S = ({ api: e, props: o }) => d(o.closeDelay, () => {
+  e.handleClosePopper();
+}), T = (e) => (o) => {
+  o ? f(e.referenceElm, "focusing") : a(e.referenceElm, "focusing");
+}, $ = ({ slots: e, api: o }) => () => {
+  if (!e.default || !e.default().length) {
+    o.handleFocus();
+    return;
+  }
+  let t = e.default()[0];
+  t = t.elm || t.el, t && t.focus ? t.focus() : o.handleFocus();
+}, D = ({ api: e, state: o, vm: t }) => (n) => {
+  let l = null;
+  t.$el.nodeType === 8 ? l = n : t.$el.nodeType === 1 && (l = t.$el), !(!l || l.nodeType === 8 || o.referenceElm) && (o.referenceElm = l, l.setAttribute("aria-describedby", o.tooltipId), l.setAttribute("tabindex", o.tabindex.toString()), r(document, "click", e.handleDocumentClick), r(l, "mouseenter", e.show), r(l, "mouseleave", e.hide), r(l, "focus", e.focusHandler), r(l, "blur", e.handleBlur), r(l, "click", e.removeFocusing));
+}, k = ({ state: e, popperVmRef: o }) => (t) => {
+  for (let n of t)
+    n.type === "attributes" && n.attributeName === "x-placement" && (e.xPlacement = o.popper.getAttribute("x-placement") || "bottom");
+}, F = ({ vm: e, nextTick: o, popperVmRef: t }) => (n) => {
+  o(() => e.bindEvent(n));
+  let l = e.popperVM;
+  e.$refs.popper ? t.popper = e.$refs.popper : t.popper = l.$el, o(() => {
+    e.modelValue && e.updatePopper();
+  });
+};
+export {
+  D as bindEvent,
+  F as bindPopper,
+  S as debounceClose,
+  C as destroyed,
+  $ as focusHandler,
+  g as handleBlur,
+  P as handleClosePopper,
+  E as handleDocumentClick,
+  b as handleFocus,
+  y as handleShowPopper,
+  h as hide,
+  k as observeCallback,
+  w as removeFocusing,
+  x as setExpectedState,
+  m as show,
+  T as watchFocusing
+};

package/dist/node_modules/.pnpm/@opentiny_vue-renderless@3.22.0/node_modules/@opentiny/vue-renderless/tooltip/vue.js

@@ -0,0 +1,90 @@
+import { observeCallback as y, handleDocumentClick as k, focusHandler as D, bindEvent as H, handleClosePopper as B, handleShowPopper as O, setExpectedState as $, debounceClose as M, handleFocus as V, handleBlur as j, removeFocusing as A, watchFocusing as I, bindPopper as J, destroyed as L, hide as R, show as W } from "./index.js";
+import { guid as q } from "../../../../../@opentiny_utils@3.22.0/node_modules/@opentiny/utils/dist/index.es.js";
+import { userPopper as z } from "../../../../../@opentiny_vue-hooks@3.22.0/node_modules/@opentiny/vue-hooks/dist/src/vue-popper.js";
+const U = [
+  "state",
+  "bindEvent",
+  "hide",
+  "show",
+  "doDestroy",
+  "handleFocus",
+  "debounceClose",
+  "handleShowPopper",
+  "handleClosePopper",
+  "setExpectedState",
+  "updatePopper",
+  "focusHandler"
+], G = ({ reactive: t, showPopper: a, popperElm: d, referenceElm: r, props: i, inject: p, popperJS: l, currentPlacement: c }) => t({
+  popperJS: l,
+  showPopper: a,
+  popperElm: d,
+  referenceElm: r,
+  currentPlacement: c,
+  timeout: null,
+  focusing: !1,
+  expectedState: void 0,
+  tooltipId: q("tiny-tooltip-", 4),
+  tabindex: i.tabindex,
+  xPlacement: "bottom",
+  showContent: p("showContent", null),
+  tipsMaxWidth: p("tips-max-width", null)
+}), X = (t, {
+  watch: a,
+  toRefs: d,
+  reactive: r,
+  onBeforeUnmount: i,
+  onDeactivated: p,
+  onMounted: l,
+  onUnmounted: c,
+  inject: f
+}, { vm: n, emit: m, slots: b, nextTick: u, parent: w }) => {
+  const e = {}, s = {}, P = { emit: m, props: t, nextTick: u, toRefs: d, reactive: r, parent: w.$parent, vm: n, popperVmRef: s };
+  Object.assign(P, { slots: b, onBeforeUnmount: i, onDeactivated: p, watch: a });
+  const { showPopper: C, updatePopper: g, popperElm: v, referenceElm: S, doDestroy: x, popperJS: E, currentPlacement: F } = z(
+    P
+  ), o = G({
+    reactive: r,
+    showPopper: C,
+    popperElm: v,
+    referenceElm: S,
+    props: t,
+    inject: f,
+    popperJS: E,
+    currentPlacement: F
+  });
+  return Object.assign(e, {
+    state: o,
+    doDestroy: x,
+    updatePopper: g,
+    show: W({ api: e, state: o, props: t }),
+    hide: R(e),
+    destroyed: L({ state: o, api: e, vm: n }),
+    bindPopper: J({ vm: n, nextTick: u, popperVmRef: s }),
+    watchFocusing: I(o),
+    removeFocusing: A({ api: e, state: o }),
+    handleBlur: j({ api: e, state: o }),
+    handleFocus: V({ api: e, state: o }),
+    debounceClose: M({ api: e, props: t }),
+    setExpectedState: $({ state: o }),
+    handleShowPopper: O({ props: t, state: o }),
+    handleClosePopper: B({ api: e, props: t, state: o }),
+    bindEvent: H({ api: e, state: o, vm: n }),
+    focusHandler: D({ slots: b, api: e }),
+    handleDocumentClick: k({ props: t, api: e, state: o, popperVmRef: s }),
+    observeCallback: y({ state: o, popperVmRef: s })
+  }), a(() => o.focusing, e.watchFocusing), a(
+    () => t.modelValue,
+    (h) => u(() => t.manual && (o.showPopper = h))
+  ), l(() => {
+    if (e.bindPopper(), t.genArrowByHtml) {
+      const h = { attributes: !0, childList: !1, subtree: !1 };
+      e.observer = new MutationObserver(e.observeCallback), e.observer.observe(s.popper, h);
+    }
+  }), n.$on("tooltip-update", e.bindPopper), c(() => {
+    e.destroyed(), e.observer && e.observer.disconnect(), n.$off("tooltip-update");
+  }), e;
+};
+export {
+  U as api,
+  X as renderless
+};