@cerberus-design/react 0.22.0 → 0.24.0

package/dist/node_modules/.pnpm/@zag-js_accordion@1.29.1/node_modules/@zag-js/accordion/dist/index.js

@@ -0,0 +1,314 @@
+import { createAnatomy } from '../../../../../@zag-js_anatomy@1.29.1/node_modules/@zag-js/anatomy/dist/index.js';
+import { prevById, nextById, getEventKey, isSafari, dataAttr, queryAll } from '../../../../../@zag-js_dom-query@1.29.1/node_modules/@zag-js/dom-query/dist/index.js';
+import { warn, last, first, add, remove } from '../../../../../@zag-js_utils@1.29.1/node_modules/@zag-js/utils/dist/index.js';
+import { createMachine, createGuards } from '../../../../../@zag-js_core@1.29.1/node_modules/@zag-js/core/dist/index.js';
+import { createProps } from '../../../../../@zag-js_types@1.29.1/node_modules/@zag-js/types/dist/index.js';
+
+// src/accordion.anatomy.ts
+var anatomy = createAnatomy("accordion").parts("root", "item", "itemTrigger", "itemContent", "itemIndicator");
+var parts = anatomy.build();
+var getRootId = (ctx) => ctx.ids?.root ?? `accordion:${ctx.id}`;
+var getItemId = (ctx, value) => ctx.ids?.item?.(value) ?? `accordion:${ctx.id}:item:${value}`;
+var getItemContentId = (ctx, value) => ctx.ids?.itemContent?.(value) ?? `accordion:${ctx.id}:content:${value}`;
+var getItemTriggerId = (ctx, value) => ctx.ids?.itemTrigger?.(value) ?? `accordion:${ctx.id}:trigger:${value}`;
+var getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+var getTriggerEls = (ctx) => {
+  const ownerId = CSS.escape(getRootId(ctx));
+  const selector = `[aria-controls][data-ownedby='${ownerId}']:not([disabled])`;
+  return queryAll(getRootEl(ctx), selector);
+};
+var getFirstTriggerEl = (ctx) => first(getTriggerEls(ctx));
+var getLastTriggerEl = (ctx) => last(getTriggerEls(ctx));
+var getNextTriggerEl = (ctx, id) => nextById(getTriggerEls(ctx), getItemTriggerId(ctx, id));
+var getPrevTriggerEl = (ctx, id) => prevById(getTriggerEls(ctx), getItemTriggerId(ctx, id));
+
+// src/accordion.connect.ts
+function connect(service, normalize) {
+  const { send, context, prop, scope, computed } = service;
+  const focusedValue = context.get("focusedValue");
+  const value = context.get("value");
+  const multiple = prop("multiple");
+  function setValue(value2) {
+    let nextValue = value2;
+    if (!multiple && nextValue.length > 1) {
+      nextValue = [nextValue[0]];
+    }
+    send({ type: "VALUE.SET", value: nextValue });
+  }
+  function getItemState(props2) {
+    return {
+      expanded: value.includes(props2.value),
+      focused: focusedValue === props2.value,
+      disabled: Boolean(props2.disabled ?? prop("disabled"))
+    };
+  }
+  return {
+    focusedValue,
+    value,
+    setValue,
+    getItemState,
+    getRootProps() {
+      return normalize.element({
+        ...parts.root.attrs,
+        dir: prop("dir"),
+        id: getRootId(scope),
+        "data-orientation": prop("orientation")
+      });
+    },
+    getItemProps(props2) {
+      const itemState = getItemState(props2);
+      return normalize.element({
+        ...parts.item.attrs,
+        dir: prop("dir"),
+        id: getItemId(scope, props2.value),
+        "data-state": itemState.expanded ? "open" : "closed",
+        "data-focus": dataAttr(itemState.focused),
+        "data-disabled": dataAttr(itemState.disabled),
+        "data-orientation": prop("orientation")
+      });
+    },
+    getItemContentProps(props2) {
+      const itemState = getItemState(props2);
+      return normalize.element({
+        ...parts.itemContent.attrs,
+        dir: prop("dir"),
+        role: "region",
+        id: getItemContentId(scope, props2.value),
+        "aria-labelledby": getItemTriggerId(scope, props2.value),
+        hidden: !itemState.expanded,
+        "data-state": itemState.expanded ? "open" : "closed",
+        "data-disabled": dataAttr(itemState.disabled),
+        "data-focus": dataAttr(itemState.focused),
+        "data-orientation": prop("orientation")
+      });
+    },
+    getItemIndicatorProps(props2) {
+      const itemState = getItemState(props2);
+      return normalize.element({
+        ...parts.itemIndicator.attrs,
+        dir: prop("dir"),
+        "aria-hidden": true,
+        "data-state": itemState.expanded ? "open" : "closed",
+        "data-disabled": dataAttr(itemState.disabled),
+        "data-focus": dataAttr(itemState.focused),
+        "data-orientation": prop("orientation")
+      });
+    },
+    getItemTriggerProps(props2) {
+      const { value: value2 } = props2;
+      const itemState = getItemState(props2);
+      return normalize.button({
+        ...parts.itemTrigger.attrs,
+        type: "button",
+        dir: prop("dir"),
+        id: getItemTriggerId(scope, value2),
+        "aria-controls": getItemContentId(scope, value2),
+        "aria-expanded": itemState.expanded,
+        disabled: itemState.disabled,
+        "data-orientation": prop("orientation"),
+        "aria-disabled": itemState.disabled,
+        "data-state": itemState.expanded ? "open" : "closed",
+        "data-ownedby": getRootId(scope),
+        onFocus() {
+          if (itemState.disabled) return;
+          send({ type: "TRIGGER.FOCUS", value: value2 });
+        },
+        onBlur() {
+          if (itemState.disabled) return;
+          send({ type: "TRIGGER.BLUR" });
+        },
+        onClick(event) {
+          if (itemState.disabled) return;
+          if (isSafari()) {
+            event.currentTarget.focus();
+          }
+          send({ type: "TRIGGER.CLICK", value: value2 });
+        },
+        onKeyDown(event) {
+          if (event.defaultPrevented) return;
+          if (itemState.disabled) return;
+          const keyMap = {
+            ArrowDown() {
+              if (computed("isHorizontal")) return;
+              send({ type: "GOTO.NEXT", value: value2 });
+            },
+            ArrowUp() {
+              if (computed("isHorizontal")) return;
+              send({ type: "GOTO.PREV", value: value2 });
+            },
+            ArrowRight() {
+              if (!computed("isHorizontal")) return;
+              send({ type: "GOTO.NEXT", value: value2 });
+            },
+            ArrowLeft() {
+              if (!computed("isHorizontal")) return;
+              send({ type: "GOTO.PREV", value: value2 });
+            },
+            Home() {
+              send({ type: "GOTO.FIRST", value: value2 });
+            },
+            End() {
+              send({ type: "GOTO.LAST", value: value2 });
+            }
+          };
+          const key = getEventKey(event, {
+            dir: prop("dir"),
+            orientation: prop("orientation")
+          });
+          const exec = keyMap[key];
+          if (exec) {
+            exec(event);
+            event.preventDefault();
+          }
+        }
+      });
+    }
+  };
+}
+var { and, not } = createGuards();
+var machine = createMachine({
+  props({ props: props2 }) {
+    return {
+      collapsible: false,
+      multiple: false,
+      orientation: "vertical",
+      defaultValue: [],
+      ...props2
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ prop, bindable }) {
+    return {
+      focusedValue: bindable(() => ({
+        defaultValue: null,
+        sync: true,
+        onChange(value) {
+          prop("onFocusChange")?.({ value });
+        }
+      })),
+      value: bindable(() => ({
+        defaultValue: prop("defaultValue"),
+        value: prop("value"),
+        onChange(value) {
+          prop("onValueChange")?.({ value });
+        }
+      }))
+    };
+  },
+  computed: {
+    isHorizontal: ({ prop }) => prop("orientation") === "horizontal"
+  },
+  on: {
+    "VALUE.SET": {
+      actions: ["setValue"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        "TRIGGER.FOCUS": {
+          target: "focused",
+          actions: ["setFocusedValue"]
+        }
+      }
+    },
+    focused: {
+      on: {
+        "GOTO.NEXT": {
+          actions: ["focusNextTrigger"]
+        },
+        "GOTO.PREV": {
+          actions: ["focusPrevTrigger"]
+        },
+        "TRIGGER.CLICK": [
+          {
+            guard: and("isExpanded", "canToggle"),
+            actions: ["collapse"]
+          },
+          {
+            guard: not("isExpanded"),
+            actions: ["expand"]
+          }
+        ],
+        "GOTO.FIRST": {
+          actions: ["focusFirstTrigger"]
+        },
+        "GOTO.LAST": {
+          actions: ["focusLastTrigger"]
+        },
+        "TRIGGER.BLUR": {
+          target: "idle",
+          actions: ["clearFocusedValue"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      canToggle: ({ prop }) => !!prop("collapsible") || !!prop("multiple"),
+      isExpanded: ({ context, event }) => context.get("value").includes(event.value)
+    },
+    actions: {
+      collapse({ context, prop, event }) {
+        const next = prop("multiple") ? remove(context.get("value"), event.value) : [];
+        context.set("value", next);
+      },
+      expand({ context, prop, event }) {
+        const next = prop("multiple") ? add(context.get("value"), event.value) : [event.value];
+        context.set("value", next);
+      },
+      focusFirstTrigger({ scope }) {
+        getFirstTriggerEl(scope)?.focus();
+      },
+      focusLastTrigger({ scope }) {
+        getLastTriggerEl(scope)?.focus();
+      },
+      focusNextTrigger({ context, scope }) {
+        const focusedValue = context.get("focusedValue");
+        if (!focusedValue) return;
+        const triggerEl = getNextTriggerEl(scope, focusedValue);
+        triggerEl?.focus();
+      },
+      focusPrevTrigger({ context, scope }) {
+        const focusedValue = context.get("focusedValue");
+        if (!focusedValue) return;
+        const triggerEl = getPrevTriggerEl(scope, focusedValue);
+        triggerEl?.focus();
+      },
+      setFocusedValue({ context, event }) {
+        context.set("focusedValue", event.value);
+      },
+      clearFocusedValue({ context }) {
+        context.set("focusedValue", null);
+      },
+      setValue({ context, event }) {
+        context.set("value", event.value);
+      },
+      coarseValue({ context, prop }) {
+        if (!prop("multiple") && context.get("value").length > 1) {
+          warn(`The value of accordion should be a single value when multiple is false.`);
+          context.set("value", [context.get("value")[0]]);
+        }
+      }
+    }
+  }
+});
+createProps()([
+  "collapsible",
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "multiple",
+  "onFocusChange",
+  "onValueChange",
+  "orientation",
+  "value",
+  "defaultValue"
+]);
+createProps()(["value", "disabled"]);
+
+export { anatomy, connect, machine };

package/dist/node_modules/.pnpm/@zag-js_aria-hidden@1.29.1/node_modules/@zag-js/aria-hidden/dist/index.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index = require('../../../../../@zag-js_dom-query@1.29.1/node_modules/@zag-js/dom-query/dist/index.cjs');
+
+// src/walk-tree-outside.ts
+var counterMap = /* @__PURE__ */ new WeakMap();
+var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+var correctTargets = (parent, targets) => targets.map((target) => {
+  if (parent.contains(target)) return target;
+  const correctedTarget = unwrapHost(target);
+  if (correctedTarget && parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  console.error("[zag-js > ariaHidden] target", target, "in not contained inside", parent, ". Doing nothing");
+  return null;
+}).filter((x) => Boolean(x));
+var ignoreableNodes = /* @__PURE__ */ new Set(["script", "output", "status", "next-route-announcer"]);
+var isIgnoredNode = (node) => {
+  if (ignoreableNodes.has(node.localName)) return true;
+  if (node.role === "status") return true;
+  if (node.hasAttribute("aria-live")) return true;
+  return node.matches("[data-live-announcer]");
+};
+var walkTreeOutside = (originalTarget, props) => {
+  const { parentNode, markerName, controlAttribute, followControlledElements = true } = props;
+  const targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+  markerMap[markerName] || (markerMap[markerName] = /* @__PURE__ */ new WeakMap());
+  const markerCounter = markerMap[markerName];
+  const hiddenNodes = [];
+  const elementsToKeep = /* @__PURE__ */ new Set();
+  const elementsToStop = new Set(targets);
+  const keep = (el) => {
+    if (!el || elementsToKeep.has(el)) return;
+    elementsToKeep.add(el);
+    keep(el.parentNode);
+  };
+  targets.forEach((target) => {
+    keep(target);
+    if (followControlledElements && index.isHTMLElement(target)) {
+      index.findControlledElements(target, (controlledElement) => {
+        keep(controlledElement);
+      });
+    }
+  });
+  const deep = (parent) => {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    Array.prototype.forEach.call(parent.children, (node) => {
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        try {
+          if (isIgnoredNode(node)) return;
+          const attr = node.getAttribute(controlAttribute);
+          const alreadyHidden = attr === "true" ;
+          const counterValue = (counterMap.get(node) || 0) + 1;
+          const markerValue = (markerCounter.get(node) || 0) + 1;
+          counterMap.set(node, counterValue);
+          markerCounter.set(node, markerValue);
+          hiddenNodes.push(node);
+          if (counterValue === 1 && alreadyHidden) {
+            uncontrolledNodes.set(node, true);
+          }
+          if (markerValue === 1) {
+            node.setAttribute(markerName, "");
+          }
+          if (!alreadyHidden) {
+            node.setAttribute(controlAttribute, "true" );
+          }
+        } catch (e) {
+          console.error("[zag-js > ariaHidden] cannot operate on ", node, e);
+        }
+      }
+    });
+  };
+  deep(parentNode);
+  elementsToKeep.clear();
+  lockCount++;
+  return () => {
+    hiddenNodes.forEach((node) => {
+      const counterValue = counterMap.get(node) - 1;
+      const markerValue = markerCounter.get(node) - 1;
+      counterMap.set(node, counterValue);
+      markerCounter.set(node, markerValue);
+      if (!counterValue) {
+        if (!uncontrolledNodes.has(node)) {
+          node.removeAttribute(controlAttribute);
+        }
+        uncontrolledNodes.delete(node);
+      }
+      if (!markerValue) {
+        node.removeAttribute(markerName);
+      }
+    });
+    lockCount--;
+    if (!lockCount) {
+      counterMap = /* @__PURE__ */ new WeakMap();
+      counterMap = /* @__PURE__ */ new WeakMap();
+      uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+      markerMap = {};
+    }
+  };
+};
+
+// src/aria-hidden.ts
+var getParentNode = (originalTarget) => {
+  const target = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
+  return target.ownerDocument.body;
+};
+var hideOthers = (originalTarget, parentNode = getParentNode(originalTarget), markerName = "data-aria-hidden", followControlledElements = true) => {
+  if (!parentNode) return;
+  return walkTreeOutside(originalTarget, {
+    parentNode,
+    markerName,
+    controlAttribute: "aria-hidden",
+    followControlledElements
+  });
+};
+
+// src/index.ts
+var raf = (fn) => {
+  const frameId = requestAnimationFrame(() => fn());
+  return () => cancelAnimationFrame(frameId);
+};
+function ariaHidden(targetsOrFn, options = {}) {
+  const { defer = true } = options;
+  const func = defer ? raf : (v) => v();
+  const cleanups = [];
+  cleanups.push(
+    func(() => {
+      const targets = typeof targetsOrFn === "function" ? targetsOrFn() : targetsOrFn;
+      const elements = targets.filter(Boolean);
+      if (elements.length === 0) return;
+      cleanups.push(hideOthers(elements));
+    })
+  );
+  return () => {
+    cleanups.forEach((fn) => fn?.());
+  };
+}
+
+exports.ariaHidden = ariaHidden;

package/dist/node_modules/.pnpm/@zag-js_aria-hidden@1.29.1/node_modules/@zag-js/aria-hidden/dist/index.js

@@ -0,0 +1,144 @@
+import { isHTMLElement, findControlledElements } from '../../../../../@zag-js_dom-query@1.29.1/node_modules/@zag-js/dom-query/dist/index.js';
+
+// src/walk-tree-outside.ts
+var counterMap = /* @__PURE__ */ new WeakMap();
+var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+var correctTargets = (parent, targets) => targets.map((target) => {
+  if (parent.contains(target)) return target;
+  const correctedTarget = unwrapHost(target);
+  if (correctedTarget && parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  console.error("[zag-js > ariaHidden] target", target, "in not contained inside", parent, ". Doing nothing");
+  return null;
+}).filter((x) => Boolean(x));
+var ignoreableNodes = /* @__PURE__ */ new Set(["script", "output", "status", "next-route-announcer"]);
+var isIgnoredNode = (node) => {
+  if (ignoreableNodes.has(node.localName)) return true;
+  if (node.role === "status") return true;
+  if (node.hasAttribute("aria-live")) return true;
+  return node.matches("[data-live-announcer]");
+};
+var walkTreeOutside = (originalTarget, props) => {
+  const { parentNode, markerName, controlAttribute, followControlledElements = true } = props;
+  const targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+  markerMap[markerName] || (markerMap[markerName] = /* @__PURE__ */ new WeakMap());
+  const markerCounter = markerMap[markerName];
+  const hiddenNodes = [];
+  const elementsToKeep = /* @__PURE__ */ new Set();
+  const elementsToStop = new Set(targets);
+  const keep = (el) => {
+    if (!el || elementsToKeep.has(el)) return;
+    elementsToKeep.add(el);
+    keep(el.parentNode);
+  };
+  targets.forEach((target) => {
+    keep(target);
+    if (followControlledElements && isHTMLElement(target)) {
+      findControlledElements(target, (controlledElement) => {
+        keep(controlledElement);
+      });
+    }
+  });
+  const deep = (parent) => {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    Array.prototype.forEach.call(parent.children, (node) => {
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        try {
+          if (isIgnoredNode(node)) return;
+          const attr = node.getAttribute(controlAttribute);
+          const alreadyHidden = attr === "true" ;
+          const counterValue = (counterMap.get(node) || 0) + 1;
+          const markerValue = (markerCounter.get(node) || 0) + 1;
+          counterMap.set(node, counterValue);
+          markerCounter.set(node, markerValue);
+          hiddenNodes.push(node);
+          if (counterValue === 1 && alreadyHidden) {
+            uncontrolledNodes.set(node, true);
+          }
+          if (markerValue === 1) {
+            node.setAttribute(markerName, "");
+          }
+          if (!alreadyHidden) {
+            node.setAttribute(controlAttribute, "true" );
+          }
+        } catch (e) {
+          console.error("[zag-js > ariaHidden] cannot operate on ", node, e);
+        }
+      }
+    });
+  };
+  deep(parentNode);
+  elementsToKeep.clear();
+  lockCount++;
+  return () => {
+    hiddenNodes.forEach((node) => {
+      const counterValue = counterMap.get(node) - 1;
+      const markerValue = markerCounter.get(node) - 1;
+      counterMap.set(node, counterValue);
+      markerCounter.set(node, markerValue);
+      if (!counterValue) {
+        if (!uncontrolledNodes.has(node)) {
+          node.removeAttribute(controlAttribute);
+        }
+        uncontrolledNodes.delete(node);
+      }
+      if (!markerValue) {
+        node.removeAttribute(markerName);
+      }
+    });
+    lockCount--;
+    if (!lockCount) {
+      counterMap = /* @__PURE__ */ new WeakMap();
+      counterMap = /* @__PURE__ */ new WeakMap();
+      uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+      markerMap = {};
+    }
+  };
+};
+
+// src/aria-hidden.ts
+var getParentNode = (originalTarget) => {
+  const target = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
+  return target.ownerDocument.body;
+};
+var hideOthers = (originalTarget, parentNode = getParentNode(originalTarget), markerName = "data-aria-hidden", followControlledElements = true) => {
+  if (!parentNode) return;
+  return walkTreeOutside(originalTarget, {
+    parentNode,
+    markerName,
+    controlAttribute: "aria-hidden",
+    followControlledElements
+  });
+};
+
+// src/index.ts
+var raf = (fn) => {
+  const frameId = requestAnimationFrame(() => fn());
+  return () => cancelAnimationFrame(frameId);
+};
+function ariaHidden(targetsOrFn, options = {}) {
+  const { defer = true } = options;
+  const func = defer ? raf : (v) => v();
+  const cleanups = [];
+  cleanups.push(
+    func(() => {
+      const targets = typeof targetsOrFn === "function" ? targetsOrFn() : targetsOrFn;
+      const elements = targets.filter(Boolean);
+      if (elements.length === 0) return;
+      cleanups.push(hideOthers(elements));
+    })
+  );
+  return () => {
+    cleanups.forEach((fn) => fn?.());
+  };
+}
+
+export { ariaHidden };

package/dist/node_modules/.pnpm/@zag-js_auto-resize@1.29.1/node_modules/@zag-js/auto-resize/dist/index.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index = require('../../../../../@zag-js_dom-query@1.29.1/node_modules/@zag-js/dom-query/dist/index.cjs');
+
+var autoresizeTextarea = (el) => {
+  if (!el) return;
+  const style = index.getComputedStyle(el);
+  const win = index.getWindow(el);
+  const doc = index.getDocument(el);
+  const resize = () => {
+    requestAnimationFrame(() => {
+      el.style.height = "auto";
+      let newHeight;
+      if (style.boxSizing === "content-box") {
+        newHeight = el.scrollHeight - (parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));
+      } else {
+        newHeight = el.scrollHeight + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+      }
+      if (style.maxHeight !== "none" && newHeight > parseFloat(style.maxHeight)) {
+        if (style.overflowY === "hidden") {
+          el.style.overflowY = "scroll";
+        }
+        newHeight = parseFloat(style.maxHeight);
+      } else if (style.overflowY !== "hidden") {
+        el.style.overflowY = "hidden";
+      }
+      el.style.height = `${newHeight}px`;
+    });
+  };
+  el.addEventListener("input", resize);
+  el.form?.addEventListener("reset", resize);
+  const elementPrototype = Object.getPrototypeOf(el);
+  const descriptor = Object.getOwnPropertyDescriptor(elementPrototype, "value");
+  Object.defineProperty(el, "value", {
+    ...descriptor,
+    set() {
+      descriptor?.set?.apply(this, arguments);
+      resize();
+    }
+  });
+  const resizeObserver = new win.ResizeObserver(() => {
+    requestAnimationFrame(() => resize());
+  });
+  resizeObserver.observe(el);
+  const attrObserver = new win.MutationObserver(() => resize());
+  attrObserver.observe(el, { attributes: true, attributeFilter: ["rows", "placeholder"] });
+  doc.fonts?.addEventListener("loadingdone", resize);
+  return () => {
+    el.removeEventListener("input", resize);
+    el.form?.removeEventListener("reset", resize);
+    doc.fonts?.removeEventListener("loadingdone", resize);
+    resizeObserver.disconnect();
+    attrObserver.disconnect();
+  };
+};
+
+exports.autoresizeTextarea = autoresizeTextarea;