@helsenorge/designsystem-react 12.12.2 → 12.12.3

package/lib/use-animate.js

@@ -0,0 +1,382 @@
+import { c as calcGeneratorDuration, m as maxGeneratorDuration, a as millisecondsToSeconds, b as isEasingArray, r as resolveElements, d as mixNumber, e as removeItem, f as isMotionValue, g as defaultOffset, h as fillOffset, j as isGenerator, s as secondsToMilliseconds, k as invariant, p as progress, V as VisualElement, l as createBox, n as isSVGElement, S as SVGVisualElement, H as HTMLVisualElement, v as visualElementStore, o as animateSingleValue, q as animateTarget, t as spring, G as GroupPlaybackControls, u as useConstant } from "./SVGVisualElement.js";
+import { useEffect } from "react";
+function useUnmountEffect(callback) {
+  return useEffect(() => () => callback(), []);
+}
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+  const generator = createGenerator({ ...options, keyframes: [0, scale] });
+  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+  return {
+    type: "keyframes",
+    ease: (progress2) => {
+      return generator.next(duration * progress2).value / scale;
+    },
+    duration: millisecondsToSeconds(duration)
+  };
+}
+const wrap = (min, max, v) => {
+  const rangeSize = max - min;
+  return ((v - min) % rangeSize + rangeSize) % rangeSize + min;
+};
+function getEasingForSegment(easing, i) {
+  return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;
+}
+function isDOMKeyframes(keyframes) {
+  return typeof keyframes === "object" && !Array.isArray(keyframes);
+}
+function resolveSubjects(subject, keyframes, scope, selectorCache) {
+  if (typeof subject === "string" && isDOMKeyframes(keyframes)) {
+    return resolveElements(subject, scope, selectorCache);
+  } else if (subject instanceof NodeList) {
+    return Array.from(subject);
+  } else if (Array.isArray(subject)) {
+    return subject;
+  } else {
+    return [subject];
+  }
+}
+function calculateRepeatDuration(duration, repeat, _repeatDelay) {
+  return duration * (repeat + 1);
+}
+function calcNextTime(current, next, prev, labels) {
+  var _a;
+  if (typeof next === "number") {
+    return next;
+  } else if (next.startsWith("-") || next.startsWith("+")) {
+    return Math.max(0, current + parseFloat(next));
+  } else if (next === "<") {
+    return prev;
+  } else {
+    return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;
+  }
+}
+function eraseKeyframes(sequence, startTime, endTime) {
+  for (let i = 0; i < sequence.length; i++) {
+    const keyframe = sequence[i];
+    if (keyframe.at > startTime && keyframe.at < endTime) {
+      removeItem(sequence, keyframe);
+      i--;
+    }
+  }
+}
+function addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {
+  eraseKeyframes(sequence, startTime, endTime);
+  for (let i = 0; i < keyframes.length; i++) {
+    sequence.push({
+      value: keyframes[i],
+      at: mixNumber(startTime, endTime, offset[i]),
+      easing: getEasingForSegment(easing, i)
+    });
+  }
+}
+function normalizeTimes(times, repeat) {
+  for (let i = 0; i < times.length; i++) {
+    times[i] = times[i] / (repeat + 1);
+  }
+}
+function compareByTime(a, b) {
+  if (a.at === b.at) {
+    if (a.value === null)
+      return 1;
+    if (b.value === null)
+      return -1;
+    return 0;
+  } else {
+    return a.at - b.at;
+  }
+}
+const defaultSegmentEasing = "easeInOut";
+const MAX_REPEAT = 20;
+function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...sequenceTransition } = {}, scope, generators) {
+  const defaultDuration = defaultTransition.duration || 0.3;
+  const animationDefinitions = /* @__PURE__ */ new Map();
+  const sequences = /* @__PURE__ */ new Map();
+  const elementCache = {};
+  const timeLabels = /* @__PURE__ */ new Map();
+  let prevTime = 0;
+  let currentTime = 0;
+  let totalDuration = 0;
+  for (let i = 0; i < sequence.length; i++) {
+    const segment = sequence[i];
+    if (typeof segment === "string") {
+      timeLabels.set(segment, currentTime);
+      continue;
+    } else if (!Array.isArray(segment)) {
+      timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));
+      continue;
+    }
+    let [subject, keyframes, transition = {}] = segment;
+    if (transition.at !== void 0) {
+      currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);
+    }
+    let maxDuration = 0;
+    const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numSubjects = 0) => {
+      const valueKeyframesAsList = keyframesAsList(valueKeyframes);
+      const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = "keyframes", repeat, repeatType, repeatDelay = 0, ...remainingTransition } = valueTransition;
+      let { ease = defaultTransition.ease || "easeOut", duration } = valueTransition;
+      const calculatedDelay = typeof delay === "function" ? delay(elementIndex, numSubjects) : delay;
+      const numKeyframes = valueKeyframesAsList.length;
+      const createGenerator = isGenerator(type) ? type : generators === null || generators === void 0 ? void 0 : generators[type];
+      if (numKeyframes <= 2 && createGenerator) {
+        let absoluteDelta = 100;
+        if (numKeyframes === 2 && isNumberKeyframesArray(valueKeyframesAsList)) {
+          const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];
+          absoluteDelta = Math.abs(delta);
+        }
+        const springTransition = { ...remainingTransition };
+        if (duration !== void 0) {
+          springTransition.duration = secondsToMilliseconds(duration);
+        }
+        const springEasing = createGeneratorEasing(springTransition, absoluteDelta, createGenerator);
+        ease = springEasing.ease;
+        duration = springEasing.duration;
+      }
+      duration !== null && duration !== void 0 ? duration : duration = defaultDuration;
+      const startTime = currentTime + calculatedDelay;
+      if (times.length === 1 && times[0] === 0) {
+        times[1] = 1;
+      }
+      const remainder = times.length - valueKeyframesAsList.length;
+      remainder > 0 && fillOffset(times, remainder);
+      valueKeyframesAsList.length === 1 && valueKeyframesAsList.unshift(null);
+      if (repeat) {
+        invariant(repeat < MAX_REPEAT, "Repeat count too high, must be less than 20");
+        duration = calculateRepeatDuration(duration, repeat);
+        const originalKeyframes = [...valueKeyframesAsList];
+        const originalTimes = [...times];
+        ease = Array.isArray(ease) ? [...ease] : [ease];
+        const originalEase = [...ease];
+        for (let repeatIndex = 0; repeatIndex < repeat; repeatIndex++) {
+          valueKeyframesAsList.push(...originalKeyframes);
+          for (let keyframeIndex = 0; keyframeIndex < originalKeyframes.length; keyframeIndex++) {
+            times.push(originalTimes[keyframeIndex] + (repeatIndex + 1));
+            ease.push(keyframeIndex === 0 ? "linear" : getEasingForSegment(originalEase, keyframeIndex - 1));
+          }
+        }
+        normalizeTimes(times, repeat);
+      }
+      const targetTime = startTime + duration;
+      addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);
+      maxDuration = Math.max(calculatedDelay + duration, maxDuration);
+      totalDuration = Math.max(targetTime, totalDuration);
+    };
+    if (isMotionValue(subject)) {
+      const subjectSequence = getSubjectSequence(subject, sequences);
+      resolveValueSequence(keyframes, transition, getValueSequence("default", subjectSequence));
+    } else {
+      const subjects = resolveSubjects(subject, keyframes, scope, elementCache);
+      const numSubjects = subjects.length;
+      for (let subjectIndex = 0; subjectIndex < numSubjects; subjectIndex++) {
+        keyframes = keyframes;
+        transition = transition;
+        const thisSubject = subjects[subjectIndex];
+        const subjectSequence = getSubjectSequence(thisSubject, sequences);
+        for (const key in keyframes) {
+          resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), subjectIndex, numSubjects);
+        }
+      }
+    }
+    prevTime = currentTime;
+    currentTime += maxDuration;
+  }
+  sequences.forEach((valueSequences, element) => {
+    for (const key in valueSequences) {
+      const valueSequence = valueSequences[key];
+      valueSequence.sort(compareByTime);
+      const keyframes = [];
+      const valueOffset = [];
+      const valueEasing = [];
+      for (let i = 0; i < valueSequence.length; i++) {
+        const { at, value, easing } = valueSequence[i];
+        keyframes.push(value);
+        valueOffset.push(progress(0, totalDuration, at));
+        valueEasing.push(easing || "easeOut");
+      }
+      if (valueOffset[0] !== 0) {
+        valueOffset.unshift(0);
+        keyframes.unshift(keyframes[0]);
+        valueEasing.unshift(defaultSegmentEasing);
+      }
+      if (valueOffset[valueOffset.length - 1] !== 1) {
+        valueOffset.push(1);
+        keyframes.push(null);
+      }
+      if (!animationDefinitions.has(element)) {
+        animationDefinitions.set(element, {
+          keyframes: {},
+          transition: {}
+        });
+      }
+      const definition = animationDefinitions.get(element);
+      definition.keyframes[key] = keyframes;
+      definition.transition[key] = {
+        ...defaultTransition,
+        duration: totalDuration,
+        ease: valueEasing,
+        times: valueOffset,
+        ...sequenceTransition
+      };
+    }
+  });
+  return animationDefinitions;
+}
+function getSubjectSequence(subject, sequences) {
+  !sequences.has(subject) && sequences.set(subject, {});
+  return sequences.get(subject);
+}
+function getValueSequence(name, sequences) {
+  if (!sequences[name])
+    sequences[name] = [];
+  return sequences[name];
+}
+function keyframesAsList(keyframes) {
+  return Array.isArray(keyframes) ? keyframes : [keyframes];
+}
+function getValueTransition(transition, key) {
+  return transition && transition[key] ? {
+    ...transition,
+    ...transition[key]
+  } : { ...transition };
+}
+const isNumber = (keyframe) => typeof keyframe === "number";
+const isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);
+function isObjectKey(key, object) {
+  return key in object;
+}
+class ObjectVisualElement extends VisualElement {
+  constructor() {
+    super(...arguments);
+    this.type = "object";
+  }
+  readValueFromInstance(instance, key) {
+    if (isObjectKey(key, instance)) {
+      const value = instance[key];
+      if (typeof value === "string" || typeof value === "number") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  getBaseTargetFromProps() {
+    return void 0;
+  }
+  removeValueFromRenderState(key, renderState) {
+    delete renderState.output[key];
+  }
+  measureInstanceViewportBox() {
+    return createBox();
+  }
+  build(renderState, latestValues) {
+    Object.assign(renderState.output, latestValues);
+  }
+  renderInstance(instance, { output }) {
+    Object.assign(instance, output);
+  }
+  sortInstanceNodePosition() {
+    return 0;
+  }
+}
+function createDOMVisualElement(element) {
+  const options = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        transform: {},
+        transformOrigin: {},
+        style: {},
+        vars: {},
+        attrs: {}
+      },
+      latestValues: {}
+    }
+  };
+  const node = isSVGElement(element) ? new SVGVisualElement(options) : new HTMLVisualElement(options);
+  node.mount(element);
+  visualElementStore.set(element, node);
+}
+function createObjectVisualElement(subject) {
+  const options = {
+    presenceContext: null,
+    props: {},
+    visualState: {
+      renderState: {
+        output: {}
+      },
+      latestValues: {}
+    }
+  };
+  const node = new ObjectVisualElement(options);
+  node.mount(subject);
+  visualElementStore.set(subject, node);
+}
+function isSingleValue(subject, keyframes) {
+  return isMotionValue(subject) || typeof subject === "number" || typeof subject === "string" && !isDOMKeyframes(keyframes);
+}
+function animateSubject(subject, keyframes, options, scope) {
+  const animations = [];
+  if (isSingleValue(subject, keyframes)) {
+    animations.push(animateSingleValue(subject, isDOMKeyframes(keyframes) ? keyframes.default || keyframes : keyframes, options ? options.default || options : options));
+  } else {
+    const subjects = resolveSubjects(subject, keyframes, scope);
+    const numSubjects = subjects.length;
+    invariant(Boolean(numSubjects), "No valid elements provided.");
+    for (let i = 0; i < numSubjects; i++) {
+      const thisSubject = subjects[i];
+      const createVisualElement = thisSubject instanceof Element ? createDOMVisualElement : createObjectVisualElement;
+      if (!visualElementStore.has(thisSubject)) {
+        createVisualElement(thisSubject);
+      }
+      const visualElement = visualElementStore.get(thisSubject);
+      const transition = { ...options };
+      if ("delay" in transition && typeof transition.delay === "function") {
+        transition.delay = transition.delay(i, numSubjects);
+      }
+      animations.push(...animateTarget(visualElement, { ...keyframes, transition }, {}));
+    }
+  }
+  return animations;
+}
+function animateSequence(sequence, options, scope) {
+  const animations = [];
+  const animationDefinitions = createAnimationsFromSequence(sequence, options, scope, { spring });
+  animationDefinitions.forEach(({ keyframes, transition }, subject) => {
+    animations.push(...animateSubject(subject, keyframes, transition));
+  });
+  return animations;
+}
+function isSequence(value) {
+  return Array.isArray(value) && value.some(Array.isArray);
+}
+function createScopedAnimate(scope) {
+  function scopedAnimate(subjectOrSequence, optionsOrKeyframes, options) {
+    let animations = [];
+    if (isSequence(subjectOrSequence)) {
+      animations = animateSequence(subjectOrSequence, optionsOrKeyframes, scope);
+    } else {
+      animations = animateSubject(subjectOrSequence, optionsOrKeyframes, options, scope);
+    }
+    const animation = new GroupPlaybackControls(animations);
+    if (scope) {
+      scope.animations.push(animation);
+    }
+    return animation;
+  }
+  return scopedAnimate;
+}
+function useAnimate() {
+  const scope = useConstant(() => ({
+    current: null,
+    // Will be hydrated by React
+    animations: []
+  }));
+  const animate = useConstant(() => createScopedAnimate(scope));
+  useUnmountEffect(() => {
+    scope.animations.forEach((animation) => animation.stop());
+  });
+  return [scope, animate];
+}
+export {
+  useAnimate as u
+};
+//# sourceMappingURL=use-animate.js.map

package/lib/use-animate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-animate.js","sources":["../../../node_modules/motion/dist/es/framer-motion/dist/es/utils/use-unmount-effect.mjs","../../../node_modules/motion/dist/es/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/utils/wrap.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/easing/utils/get-easing-for-segment.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/utils/is-dom-keyframes.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/animate/resolve-subjects.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/utils/calc-repeat-duration.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/utils/calc-time.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/utils/edit.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/utils/normalize-times.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/utils/sort.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/sequence/create.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/render/object/ObjectVisualElement.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/utils/create-visual-element.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/animate/subject.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/animate/sequence.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/animate/index.mjs","../../../node_modules/motion/dist/es/framer-motion/dist/es/animation/hooks/use-animate.mjs"],"sourcesContent":["import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(() => () => callback(), []);\n}\n\nexport { useUnmountEffect };\n","import '../../../../../../motion-utils/dist/es/errors.mjs';\nimport { millisecondsToSeconds } from '../../../../../../motion-utils/dist/es/time-conversion.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n","const wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nexport { wrap };\n","import { wrap } from '../../utils/wrap.mjs';\nimport { isEasingArray } from './is-easing-array.mjs';\n\nfunction getEasingForSegment(easing, i) {\n    return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;\n}\n\nexport { getEasingForSegment };\n","function isDOMKeyframes(keyframes) {\n    return typeof keyframes === \"object\" && !Array.isArray(keyframes);\n}\n\nexport { isDOMKeyframes };\n","import '../../../../../motion-utils/dist/es/errors.mjs';\nimport { resolveElements } from '../../../../../motion-dom/dist/es/utils/resolve-elements.mjs';\nimport { isDOMKeyframes } from '../utils/is-dom-keyframes.mjs';\n\nfunction resolveSubjects(subject, keyframes, scope, selectorCache) {\n    if (typeof subject === \"string\" && isDOMKeyframes(keyframes)) {\n        return resolveElements(subject, scope, selectorCache);\n    }\n    else if (subject instanceof NodeList) {\n        return Array.from(subject);\n    }\n    else if (Array.isArray(subject)) {\n        return subject;\n    }\n    else {\n        return [subject];\n    }\n}\n\nexport { resolveSubjects };\n","function calculateRepeatDuration(duration, repeat, _repeatDelay) {\n    return duration * (repeat + 1);\n}\n\nexport { calculateRepeatDuration };\n","/**\n * Given a absolute or relative time definition and current/prev time state of the sequence,\n * calculate an absolute time for the next keyframes.\n */\nfunction calcNextTime(current, next, prev, labels) {\n    var _a;\n    if (typeof next === \"number\") {\n        return next;\n    }\n    else if (next.startsWith(\"-\") || next.startsWith(\"+\")) {\n        return Math.max(0, current + parseFloat(next));\n    }\n    else if (next === \"<\") {\n        return prev;\n    }\n    else {\n        return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;\n    }\n}\n\nexport { calcNextTime };\n","import { getEasingForSegment } from '../../../easing/utils/get-easing-for-segment.mjs';\nimport { removeItem } from '../../../utils/array.mjs';\nimport { mixNumber } from '../../../utils/mix/number.mjs';\n\nfunction eraseKeyframes(sequence, startTime, endTime) {\n    for (let i = 0; i < sequence.length; i++) {\n        const keyframe = sequence[i];\n        if (keyframe.at > startTime && keyframe.at < endTime) {\n            removeItem(sequence, keyframe);\n            // If we remove this item we have to push the pointer back one\n            i--;\n        }\n    }\n}\nfunction addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {\n    /**\n     * Erase every existing value between currentTime and targetTime,\n     * this will essentially splice this timeline into any currently\n     * defined ones.\n     */\n    eraseKeyframes(sequence, startTime, endTime);\n    for (let i = 0; i < keyframes.length; i++) {\n        sequence.push({\n            value: keyframes[i],\n            at: mixNumber(startTime, endTime, offset[i]),\n            easing: getEasingForSegment(easing, i),\n        });\n    }\n}\n\nexport { addKeyframes, eraseKeyframes };\n","/**\n * Take an array of times that represent repeated keyframes. For instance\n * if we have original times of [0, 0.5, 1] then our repeated times will\n * be [0, 0.5, 1, 1, 1.5, 2]. Loop over the times and scale them back\n * down to a 0-1 scale.\n */\nfunction normalizeTimes(times, repeat) {\n    for (let i = 0; i < times.length; i++) {\n        times[i] = times[i] / (repeat + 1);\n    }\n}\n\nexport { normalizeTimes };\n","function compareByTime(a, b) {\n    if (a.at === b.at) {\n        if (a.value === null)\n            return 1;\n        if (b.value === null)\n            return -1;\n        return 0;\n    }\n    else {\n        return a.at - b.at;\n    }\n}\n\nexport { compareByTime };\n","import { invariant } from '../../../../../motion-utils/dist/es/errors.mjs';\nimport { progress } from '../../../../../motion-utils/dist/es/progress.mjs';\nimport { secondsToMilliseconds } from '../../../../../motion-utils/dist/es/time-conversion.mjs';\nimport { createGeneratorEasing } from '../../../../../motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs';\nimport { isGenerator } from '../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.mjs';\nimport { getEasingForSegment } from '../../easing/utils/get-easing-for-segment.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { fillOffset } from '../../utils/offsets/fill.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { resolveSubjects } from '../animate/resolve-subjects.mjs';\nimport { calculateRepeatDuration } from './utils/calc-repeat-duration.mjs';\nimport { calcNextTime } from './utils/calc-time.mjs';\nimport { addKeyframes } from './utils/edit.mjs';\nimport { normalizeTimes } from './utils/normalize-times.mjs';\nimport { compareByTime } from './utils/sort.mjs';\n\nconst defaultSegmentEasing = \"easeInOut\";\nconst MAX_REPEAT = 20;\nfunction createAnimationsFromSequence(sequence, { defaultTransition = {}, ...sequenceTransition } = {}, scope, generators) {\n    const defaultDuration = defaultTransition.duration || 0.3;\n    const animationDefinitions = new Map();\n    const sequences = new Map();\n    const elementCache = {};\n    const timeLabels = new Map();\n    let prevTime = 0;\n    let currentTime = 0;\n    let totalDuration = 0;\n    /**\n     * Build the timeline by mapping over the sequence array and converting\n     * the definitions into keyframes and offsets with absolute time values.\n     * These will later get converted into relative offsets in a second pass.\n     */\n    for (let i = 0; i < sequence.length; i++) {\n        const segment = sequence[i];\n        /**\n         * If this is a timeline label, mark it and skip the rest of this iteration.\n         */\n        if (typeof segment === \"string\") {\n            timeLabels.set(segment, currentTime);\n            continue;\n        }\n        else if (!Array.isArray(segment)) {\n            timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));\n            continue;\n        }\n        let [subject, keyframes, transition = {}] = segment;\n        /**\n         * If a relative or absolute time value has been specified we need to resolve\n         * it in relation to the currentTime.\n         */\n        if (transition.at !== undefined) {\n            currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);\n        }\n        /**\n         * Keep track of the maximum duration in this definition. This will be\n         * applied to currentTime once the definition has been parsed.\n         */\n        let maxDuration = 0;\n        const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numSubjects = 0) => {\n            const valueKeyframesAsList = keyframesAsList(valueKeyframes);\n            const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = \"keyframes\", repeat, repeatType, repeatDelay = 0, ...remainingTransition } = valueTransition;\n            let { ease = defaultTransition.ease || \"easeOut\", duration } = valueTransition;\n            /**\n             * Resolve stagger() if defined.\n             */\n            const calculatedDelay = typeof delay === \"function\"\n                ? delay(elementIndex, numSubjects)\n                : delay;\n            /**\n             * If this animation should and can use a spring, generate a spring easing function.\n             */\n            const numKeyframes = valueKeyframesAsList.length;\n            const createGenerator = isGenerator(type)\n                ? type\n                : generators === null || generators === void 0 ? void 0 : generators[type];\n            if (numKeyframes <= 2 && createGenerator) {\n                /**\n                 * As we're creating an easing function from a spring,\n                 * ideally we want to generate it using the real distance\n                 * between the two keyframes. However this isn't always\n                 * possible - in these situations we use 0-100.\n                 */\n                let absoluteDelta = 100;\n                if (numKeyframes === 2 &&\n                    isNumberKeyframesArray(valueKeyframesAsList)) {\n                    const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];\n                    absoluteDelta = Math.abs(delta);\n                }\n                const springTransition = { ...remainingTransition };\n                if (duration !== undefined) {\n                    springTransition.duration = secondsToMilliseconds(duration);\n                }\n                const springEasing = createGeneratorEasing(springTransition, absoluteDelta, createGenerator);\n                ease = springEasing.ease;\n                duration = springEasing.duration;\n            }\n            duration !== null && duration !== void 0 ? duration : (duration = defaultDuration);\n            const startTime = currentTime + calculatedDelay;\n            /**\n             * If there's only one time offset of 0, fill in a second with length 1\n             */\n            if (times.length === 1 && times[0] === 0) {\n                times[1] = 1;\n            }\n            /**\n             * Fill out if offset if fewer offsets than keyframes\n             */\n            const remainder = times.length - valueKeyframesAsList.length;\n            remainder > 0 && fillOffset(times, remainder);\n            /**\n             * If only one value has been set, ie [1], push a null to the start of\n             * the keyframe array. This will let us mark a keyframe at this point\n             * that will later be hydrated with the previous value.\n             */\n            valueKeyframesAsList.length === 1 &&\n                valueKeyframesAsList.unshift(null);\n            /**\n             * Handle repeat options\n             */\n            if (repeat) {\n                invariant(repeat < MAX_REPEAT, \"Repeat count too high, must be less than 20\");\n                duration = calculateRepeatDuration(duration, repeat);\n                const originalKeyframes = [...valueKeyframesAsList];\n                const originalTimes = [...times];\n                ease = Array.isArray(ease) ? [...ease] : [ease];\n                const originalEase = [...ease];\n                for (let repeatIndex = 0; repeatIndex < repeat; repeatIndex++) {\n                    valueKeyframesAsList.push(...originalKeyframes);\n                    for (let keyframeIndex = 0; keyframeIndex < originalKeyframes.length; keyframeIndex++) {\n                        times.push(originalTimes[keyframeIndex] + (repeatIndex + 1));\n                        ease.push(keyframeIndex === 0\n                            ? \"linear\"\n                            : getEasingForSegment(originalEase, keyframeIndex - 1));\n                    }\n                }\n                normalizeTimes(times, repeat);\n            }\n            const targetTime = startTime + duration;\n            /**\n             * Add keyframes, mapping offsets to absolute time.\n             */\n            addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);\n            maxDuration = Math.max(calculatedDelay + duration, maxDuration);\n            totalDuration = Math.max(targetTime, totalDuration);\n        };\n        if (isMotionValue(subject)) {\n            const subjectSequence = getSubjectSequence(subject, sequences);\n            resolveValueSequence(keyframes, transition, getValueSequence(\"default\", subjectSequence));\n        }\n        else {\n            const subjects = resolveSubjects(subject, keyframes, scope, elementCache);\n            const numSubjects = subjects.length;\n            /**\n             * For every element in this segment, process the defined values.\n             */\n            for (let subjectIndex = 0; subjectIndex < numSubjects; subjectIndex++) {\n                /**\n                 * Cast necessary, but we know these are of this type\n                 */\n                keyframes = keyframes;\n                transition = transition;\n                const thisSubject = subjects[subjectIndex];\n                const subjectSequence = getSubjectSequence(thisSubject, sequences);\n                for (const key in keyframes) {\n                    resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), subjectIndex, numSubjects);\n                }\n            }\n        }\n        prevTime = currentTime;\n        currentTime += maxDuration;\n    }\n    /**\n     * For every element and value combination create a new animation.\n     */\n    sequences.forEach((valueSequences, element) => {\n        for (const key in valueSequences) {\n            const valueSequence = valueSequences[key];\n            /**\n             * Arrange all the keyframes in ascending time order.\n             */\n            valueSequence.sort(compareByTime);\n            const keyframes = [];\n            const valueOffset = [];\n            const valueEasing = [];\n            /**\n             * For each keyframe, translate absolute times into\n             * relative offsets based on the total duration of the timeline.\n             */\n            for (let i = 0; i < valueSequence.length; i++) {\n                const { at, value, easing } = valueSequence[i];\n                keyframes.push(value);\n                valueOffset.push(progress(0, totalDuration, at));\n                valueEasing.push(easing || \"easeOut\");\n            }\n            /**\n             * If the first keyframe doesn't land on offset: 0\n             * provide one by duplicating the initial keyframe. This ensures\n             * it snaps to the first keyframe when the animation starts.\n             */\n            if (valueOffset[0] !== 0) {\n                valueOffset.unshift(0);\n                keyframes.unshift(keyframes[0]);\n                valueEasing.unshift(defaultSegmentEasing);\n            }\n            /**\n             * If the last keyframe doesn't land on offset: 1\n             * provide one with a null wildcard value. This will ensure it\n             * stays static until the end of the animation.\n             */\n            if (valueOffset[valueOffset.length - 1] !== 1) {\n                valueOffset.push(1);\n                keyframes.push(null);\n            }\n            if (!animationDefinitions.has(element)) {\n                animationDefinitions.set(element, {\n                    keyframes: {},\n                    transition: {},\n                });\n            }\n            const definition = animationDefinitions.get(element);\n            definition.keyframes[key] = keyframes;\n            definition.transition[key] = {\n                ...defaultTransition,\n                duration: totalDuration,\n                ease: valueEasing,\n                times: valueOffset,\n                ...sequenceTransition,\n            };\n        }\n    });\n    return animationDefinitions;\n}\nfunction getSubjectSequence(subject, sequences) {\n    !sequences.has(subject) && sequences.set(subject, {});\n    return sequences.get(subject);\n}\nfunction getValueSequence(name, sequences) {\n    if (!sequences[name])\n        sequences[name] = [];\n    return sequences[name];\n}\nfunction keyframesAsList(keyframes) {\n    return Array.isArray(keyframes) ? keyframes : [keyframes];\n}\nfunction getValueTransition(transition, key) {\n    return transition && transition[key]\n        ? {\n            ...transition,\n            ...transition[key],\n        }\n        : { ...transition };\n}\nconst isNumber = (keyframe) => typeof keyframe === \"number\";\nconst isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);\n\nexport { createAnimationsFromSequence, getValueTransition };\n","import { createBox } from '../../projection/geometry/models.mjs';\nimport { VisualElement } from '../VisualElement.mjs';\n\nfunction isObjectKey(key, object) {\n    return key in object;\n}\nclass ObjectVisualElement extends VisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"object\";\n    }\n    readValueFromInstance(instance, key) {\n        if (isObjectKey(key, instance)) {\n            const value = instance[key];\n            if (typeof value === \"string\" || typeof value === \"number\") {\n                return value;\n            }\n        }\n        return undefined;\n    }\n    getBaseTargetFromProps() {\n        return undefined;\n    }\n    removeValueFromRenderState(key, renderState) {\n        delete renderState.output[key];\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    build(renderState, latestValues) {\n        Object.assign(renderState.output, latestValues);\n    }\n    renderInstance(instance, { output }) {\n        Object.assign(instance, output);\n    }\n    sortInstanceNodePosition() {\n        return 0;\n    }\n}\n\nexport { ObjectVisualElement };\n","import { isSVGElement } from '../../render/dom/utils/is-svg-element.mjs';\nimport { SVGVisualElement } from '../../render/svg/SVGVisualElement.mjs';\nimport { HTMLVisualElement } from '../../render/html/HTMLVisualElement.mjs';\nimport { visualElementStore } from '../../render/store.mjs';\nimport { ObjectVisualElement } from '../../render/object/ObjectVisualElement.mjs';\n\nfunction createDOMVisualElement(element) {\n    const options = {\n        presenceContext: null,\n        props: {},\n        visualState: {\n            renderState: {\n                transform: {},\n                transformOrigin: {},\n                style: {},\n                vars: {},\n                attrs: {},\n            },\n            latestValues: {},\n        },\n    };\n    const node = isSVGElement(element)\n        ? new SVGVisualElement(options)\n        : new HTMLVisualElement(options);\n    node.mount(element);\n    visualElementStore.set(element, node);\n}\nfunction createObjectVisualElement(subject) {\n    const options = {\n        presenceContext: null,\n        props: {},\n        visualState: {\n            renderState: {\n                output: {},\n            },\n            latestValues: {},\n        },\n    };\n    const node = new ObjectVisualElement(options);\n    node.mount(subject);\n    visualElementStore.set(subject, node);\n}\n\nexport { createDOMVisualElement, createObjectVisualElement };\n","import { invariant } from '../../../../../motion-utils/dist/es/errors.mjs';\nimport { visualElementStore } from '../../render/store.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { animateTarget } from '../interfaces/visual-element-target.mjs';\nimport { createDOMVisualElement, createObjectVisualElement } from '../utils/create-visual-element.mjs';\nimport { isDOMKeyframes } from '../utils/is-dom-keyframes.mjs';\nimport { resolveSubjects } from './resolve-subjects.mjs';\nimport { animateSingleValue } from './single-value.mjs';\n\nfunction isSingleValue(subject, keyframes) {\n    return (isMotionValue(subject) ||\n        typeof subject === \"number\" ||\n        (typeof subject === \"string\" && !isDOMKeyframes(keyframes)));\n}\n/**\n * Implementation\n */\nfunction animateSubject(subject, keyframes, options, scope) {\n    const animations = [];\n    if (isSingleValue(subject, keyframes)) {\n        animations.push(animateSingleValue(subject, isDOMKeyframes(keyframes)\n            ? keyframes.default || keyframes\n            : keyframes, options ? options.default || options : options));\n    }\n    else {\n        const subjects = resolveSubjects(subject, keyframes, scope);\n        const numSubjects = subjects.length;\n        invariant(Boolean(numSubjects), \"No valid elements provided.\");\n        for (let i = 0; i < numSubjects; i++) {\n            const thisSubject = subjects[i];\n            const createVisualElement = thisSubject instanceof Element\n                ? createDOMVisualElement\n                : createObjectVisualElement;\n            if (!visualElementStore.has(thisSubject)) {\n                createVisualElement(thisSubject);\n            }\n            const visualElement = visualElementStore.get(thisSubject);\n            const transition = { ...options };\n            /**\n             * Resolve stagger function if provided.\n             */\n            if (\"delay\" in transition &&\n                typeof transition.delay === \"function\") {\n                transition.delay = transition.delay(i, numSubjects);\n            }\n            animations.push(...animateTarget(visualElement, { ...keyframes, transition }, {}));\n        }\n    }\n    return animations;\n}\n\nexport { animateSubject };\n","import { spring } from '../generators/spring/index.mjs';\nimport { createAnimationsFromSequence } from '../sequence/create.mjs';\nimport { animateSubject } from './subject.mjs';\n\nfunction animateSequence(sequence, options, scope) {\n    const animations = [];\n    const animationDefinitions = createAnimationsFromSequence(sequence, options, scope, { spring });\n    animationDefinitions.forEach(({ keyframes, transition }, subject) => {\n        animations.push(...animateSubject(subject, keyframes, transition));\n    });\n    return animations;\n}\n\nexport { animateSequence };\n","import { GroupPlaybackControls } from '../../../../../motion-dom/dist/es/animation/controls/Group.mjs';\nimport '../../../../../motion-utils/dist/es/errors.mjs';\nimport { animateSequence } from './sequence.mjs';\nimport { animateSubject } from './subject.mjs';\n\nfunction isSequence(value) {\n    return Array.isArray(value) && value.some(Array.isArray);\n}\n/**\n * Creates an animation function that is optionally scoped\n * to a specific element.\n */\nfunction createScopedAnimate(scope) {\n    /**\n     * Implementation\n     */\n    function scopedAnimate(subjectOrSequence, optionsOrKeyframes, options) {\n        let animations = [];\n        if (isSequence(subjectOrSequence)) {\n            animations = animateSequence(subjectOrSequence, optionsOrKeyframes, scope);\n        }\n        else {\n            animations = animateSubject(subjectOrSequence, optionsOrKeyframes, options, scope);\n        }\n        const animation = new GroupPlaybackControls(animations);\n        if (scope) {\n            scope.animations.push(animation);\n        }\n        return animation;\n    }\n    return scopedAnimate;\n}\nconst animate = createScopedAnimate();\n\nexport { animate, createScopedAnimate };\n","import { useConstant } from '../../utils/use-constant.mjs';\nimport { useUnmountEffect } from '../../utils/use-unmount-effect.mjs';\nimport { createScopedAnimate } from '../animate/index.mjs';\n\nfunction useAnimate() {\n    const scope = useConstant(() => ({\n        current: null, // Will be hydrated by React\n        animations: [],\n    }));\n    const animate = useConstant(() => createScopedAnimate(scope));\n    useUnmountEffect(() => {\n        scope.animations.forEach((animation) => animation.stop());\n    });\n    return [scope, animate];\n}\n\nexport { useAnimate };\n"],"names":["progress"],"mappings":";;AAEA,SAAS,iBAAiB,UAAU;AAChC,SAAO,UAAU,MAAM,MAAM,SAAQ,GAAI,CAAA,CAAE;AAC/C;ACGA,SAAS,sBAAsB,SAAS,QAAQ,KAAK,iBAAiB;AAClE,QAAM,YAAY,gBAAgB,EAAE,GAAG,SAAS,WAAW,CAAC,GAAG,KAAK,GAAG;AACvE,QAAM,WAAW,KAAK,IAAI,sBAAsB,SAAS,GAAG,oBAAoB;AAChF,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,CAACA,cAAa;AAChB,aAAO,UAAU,KAAK,WAAWA,SAAQ,EAAE,QAAQ;AAAA,IACvD;AAAA,IACA,UAAU,sBAAsB,QAAQ;AAAA,EAChD;AACA;ACjBA,MAAM,OAAO,CAAC,KAAK,KAAK,MAAM;AAC1B,QAAM,YAAY,MAAM;AACxB,WAAW,IAAI,OAAO,YAAa,aAAa,YAAa;AACjE;ACAA,SAAS,oBAAoB,QAAQ,GAAG;AACpC,SAAO,cAAc,MAAM,IAAI,OAAO,KAAK,GAAG,OAAO,QAAQ,CAAC,CAAC,IAAI;AACvE;ACLA,SAAS,eAAe,WAAW;AAC/B,SAAO,OAAO,cAAc,YAAY,CAAC,MAAM,QAAQ,SAAS;AACpE;ACEA,SAAS,gBAAgB,SAAS,WAAW,OAAO,eAAe;AAC/D,MAAI,OAAO,YAAY,YAAY,eAAe,SAAS,GAAG;AAC1D,WAAO,gBAAgB,SAAS,OAAO,aAAa;AAAA,EACxD,WACS,mBAAmB,UAAU;AAClC,WAAO,MAAM,KAAK,OAAO;AAAA,EAC7B,WACS,MAAM,QAAQ,OAAO,GAAG;AAC7B,WAAO;AAAA,EACX,OACK;AACD,WAAO,CAAC,OAAO;AAAA,EACnB;AACJ;ACjBA,SAAS,wBAAwB,UAAU,QAAQ,cAAc;AAC7D,SAAO,YAAY,SAAS;AAChC;ACEA,SAAS,aAAa,SAAS,MAAM,MAAM,QAAQ;AAC/C,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC1B,WAAO;AAAA,EACX,WACS,KAAK,WAAW,GAAG,KAAK,KAAK,WAAW,GAAG,GAAG;AACnD,WAAO,KAAK,IAAI,GAAG,UAAU,WAAW,IAAI,CAAC;AAAA,EACjD,WACS,SAAS,KAAK;AACnB,WAAO;AAAA,EACX,OACK;AACD,YAAQ,KAAK,OAAO,IAAI,IAAI,OAAO,QAAQ,OAAO,SAAS,KAAK;AAAA,EACpE;AACJ;ACdA,SAAS,eAAe,UAAU,WAAW,SAAS;AAClD,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACtC,UAAM,WAAW,SAAS,CAAC;AAC3B,QAAI,SAAS,KAAK,aAAa,SAAS,KAAK,SAAS;AAClD,iBAAW,UAAU,QAAQ;AAE7B;AAAA,IACJ;AAAA,EACJ;AACJ;AACA,SAAS,aAAa,UAAU,WAAW,QAAQ,QAAQ,WAAW,SAAS;AAM3E,iBAAe,UAAU,WAAW,OAAO;AAC3C,WAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,aAAS,KAAK;AAAA,MACV,OAAO,UAAU,CAAC;AAAA,MAClB,IAAI,UAAU,WAAW,SAAS,OAAO,CAAC,CAAC;AAAA,MAC3C,QAAQ,oBAAoB,QAAQ,CAAC;AAAA,IACjD,CAAS;AAAA,EACL;AACJ;ACtBA,SAAS,eAAe,OAAO,QAAQ;AACnC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,UAAM,CAAC,IAAI,MAAM,CAAC,KAAK,SAAS;AAAA,EACpC;AACJ;ACVA,SAAS,cAAc,GAAG,GAAG;AACzB,MAAI,EAAE,OAAO,EAAE,IAAI;AACf,QAAI,EAAE,UAAU;AACZ,aAAO;AACX,QAAI,EAAE,UAAU;AACZ,aAAO;AACX,WAAO;AAAA,EACX,OACK;AACD,WAAO,EAAE,KAAK,EAAE;AAAA,EACpB;AACJ;ACKA,MAAM,uBAAuB;AAC7B,MAAM,aAAa;AACnB,SAAS,6BAA6B,UAAU,EAAE,oBAAoB,CAAA,GAAI,GAAG,uBAAuB,CAAA,GAAI,OAAO,YAAY;AACvH,QAAM,kBAAkB,kBAAkB,YAAY;AACtD,QAAM,uBAAuB,oBAAI,IAAG;AACpC,QAAM,YAAY,oBAAI,IAAG;AACzB,QAAM,eAAe,CAAA;AACrB,QAAM,aAAa,oBAAI,IAAG;AAC1B,MAAI,WAAW;AACf,MAAI,cAAc;AAClB,MAAI,gBAAgB;AAMpB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACtC,UAAM,UAAU,SAAS,CAAC;AAI1B,QAAI,OAAO,YAAY,UAAU;AAC7B,iBAAW,IAAI,SAAS,WAAW;AACnC;AAAA,IACJ,WACS,CAAC,MAAM,QAAQ,OAAO,GAAG;AAC9B,iBAAW,IAAI,QAAQ,MAAM,aAAa,aAAa,QAAQ,IAAI,UAAU,UAAU,CAAC;AACxF;AAAA,IACJ;AACA,QAAI,CAAC,SAAS,WAAW,aAAa,CAAA,CAAE,IAAI;AAK5C,QAAI,WAAW,OAAO,QAAW;AAC7B,oBAAc,aAAa,aAAa,WAAW,IAAI,UAAU,UAAU;AAAA,IAC/E;AAKA,QAAI,cAAc;AAClB,UAAM,uBAAuB,CAAC,gBAAgB,iBAAiB,eAAe,eAAe,GAAG,cAAc,MAAM;AAChH,YAAM,uBAAuB,gBAAgB,cAAc;AAC3D,YAAM,EAAE,QAAQ,GAAG,QAAQ,cAAc,oBAAoB,GAAG,OAAO,aAAa,QAAQ,YAAY,cAAc,GAAG,GAAG,oBAAmB,IAAK;AACpJ,UAAI,EAAE,OAAO,kBAAkB,QAAQ,WAAW,SAAQ,IAAK;AAI/D,YAAM,kBAAkB,OAAO,UAAU,aACnC,MAAM,cAAc,WAAW,IAC/B;AAIN,YAAM,eAAe,qBAAqB;AAC1C,YAAM,kBAAkB,YAAY,IAAI,IAClC,OACA,eAAe,QAAQ,eAAe,SAAS,SAAS,WAAW,IAAI;AAC7E,UAAI,gBAAgB,KAAK,iBAAiB;AAOtC,YAAI,gBAAgB;AACpB,YAAI,iBAAiB,KACjB,uBAAuB,oBAAoB,GAAG;AAC9C,gBAAM,QAAQ,qBAAqB,CAAC,IAAI,qBAAqB,CAAC;AAC9D,0BAAgB,KAAK,IAAI,KAAK;AAAA,QAClC;AACA,cAAM,mBAAmB,EAAE,GAAG,oBAAmB;AACjD,YAAI,aAAa,QAAW;AACxB,2BAAiB,WAAW,sBAAsB,QAAQ;AAAA,QAC9D;AACA,cAAM,eAAe,sBAAsB,kBAAkB,eAAe,eAAe;AAC3F,eAAO,aAAa;AACpB,mBAAW,aAAa;AAAA,MAC5B;AACA,mBAAa,QAAQ,aAAa,SAAS,WAAY,WAAW;AAClE,YAAM,YAAY,cAAc;AAIhC,UAAI,MAAM,WAAW,KAAK,MAAM,CAAC,MAAM,GAAG;AACtC,cAAM,CAAC,IAAI;AAAA,MACf;AAIA,YAAM,YAAY,MAAM,SAAS,qBAAqB;AACtD,kBAAY,KAAK,WAAW,OAAO,SAAS;AAM5C,2BAAqB,WAAW,KAC5B,qBAAqB,QAAQ,IAAI;AAIrC,UAAI,QAAQ;AACR,kBAAU,SAAS,YAAY,6CAA6C;AAC5E,mBAAW,wBAAwB,UAAU,MAAM;AACnD,cAAM,oBAAoB,CAAC,GAAG,oBAAoB;AAClD,cAAM,gBAAgB,CAAC,GAAG,KAAK;AAC/B,eAAO,MAAM,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI;AAC9C,cAAM,eAAe,CAAC,GAAG,IAAI;AAC7B,iBAAS,cAAc,GAAG,cAAc,QAAQ,eAAe;AAC3D,+BAAqB,KAAK,GAAG,iBAAiB;AAC9C,mBAAS,gBAAgB,GAAG,gBAAgB,kBAAkB,QAAQ,iBAAiB;AACnF,kBAAM,KAAK,cAAc,aAAa,KAAK,cAAc,EAAE;AAC3D,iBAAK,KAAK,kBAAkB,IACtB,WACA,oBAAoB,cAAc,gBAAgB,CAAC,CAAC;AAAA,UAC9D;AAAA,QACJ;AACA,uBAAe,OAAO,MAAM;AAAA,MAChC;AACA,YAAM,aAAa,YAAY;AAI/B,mBAAa,eAAe,sBAAsB,MAAM,OAAO,WAAW,UAAU;AACpF,oBAAc,KAAK,IAAI,kBAAkB,UAAU,WAAW;AAC9D,sBAAgB,KAAK,IAAI,YAAY,aAAa;AAAA,IACtD;AACA,QAAI,cAAc,OAAO,GAAG;AACxB,YAAM,kBAAkB,mBAAmB,SAAS,SAAS;AAC7D,2BAAqB,WAAW,YAAY,iBAAiB,WAAW,eAAe,CAAC;AAAA,IAC5F,OACK;AACD,YAAM,WAAW,gBAAgB,SAAS,WAAW,OAAO,YAAY;AACxE,YAAM,cAAc,SAAS;AAI7B,eAAS,eAAe,GAAG,eAAe,aAAa,gBAAgB;AAInE,oBAAY;AACZ,qBAAa;AACb,cAAM,cAAc,SAAS,YAAY;AACzC,cAAM,kBAAkB,mBAAmB,aAAa,SAAS;AACjE,mBAAW,OAAO,WAAW;AACzB,+BAAqB,UAAU,GAAG,GAAG,mBAAmB,YAAY,GAAG,GAAG,iBAAiB,KAAK,eAAe,GAAG,cAAc,WAAW;AAAA,QAC/I;AAAA,MACJ;AAAA,IACJ;AACA,eAAW;AACX,mBAAe;AAAA,EACnB;AAIA,YAAU,QAAQ,CAAC,gBAAgB,YAAY;AAC3C,eAAW,OAAO,gBAAgB;AAC9B,YAAM,gBAAgB,eAAe,GAAG;AAIxC,oBAAc,KAAK,aAAa;AAChC,YAAM,YAAY,CAAA;AAClB,YAAM,cAAc,CAAA;AACpB,YAAM,cAAc,CAAA;AAKpB,eAAS,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;AAC3C,cAAM,EAAE,IAAI,OAAO,OAAM,IAAK,cAAc,CAAC;AAC7C,kBAAU,KAAK,KAAK;AACpB,oBAAY,KAAK,SAAS,GAAG,eAAe,EAAE,CAAC;AAC/C,oBAAY,KAAK,UAAU,SAAS;AAAA,MACxC;AAMA,UAAI,YAAY,CAAC,MAAM,GAAG;AACtB,oBAAY,QAAQ,CAAC;AACrB,kBAAU,QAAQ,UAAU,CAAC,CAAC;AAC9B,oBAAY,QAAQ,oBAAoB;AAAA,MAC5C;AAMA,UAAI,YAAY,YAAY,SAAS,CAAC,MAAM,GAAG;AAC3C,oBAAY,KAAK,CAAC;AAClB,kBAAU,KAAK,IAAI;AAAA,MACvB;AACA,UAAI,CAAC,qBAAqB,IAAI,OAAO,GAAG;AACpC,6BAAqB,IAAI,SAAS;AAAA,UAC9B,WAAW,CAAA;AAAA,UACX,YAAY,CAAA;AAAA,QAChC,CAAiB;AAAA,MACL;AACA,YAAM,aAAa,qBAAqB,IAAI,OAAO;AACnD,iBAAW,UAAU,GAAG,IAAI;AAC5B,iBAAW,WAAW,GAAG,IAAI;AAAA,QACzB,GAAG;AAAA,QACH,UAAU;AAAA,QACV,MAAM;AAAA,QACN,OAAO;AAAA,QACP,GAAG;AAAA,MACnB;AAAA,IACQ;AAAA,EACJ,CAAC;AACD,SAAO;AACX;AACA,SAAS,mBAAmB,SAAS,WAAW;AAC5C,GAAC,UAAU,IAAI,OAAO,KAAK,UAAU,IAAI,SAAS,EAAE;AACpD,SAAO,UAAU,IAAI,OAAO;AAChC;AACA,SAAS,iBAAiB,MAAM,WAAW;AACvC,MAAI,CAAC,UAAU,IAAI;AACf,cAAU,IAAI,IAAI,CAAA;AACtB,SAAO,UAAU,IAAI;AACzB;AACA,SAAS,gBAAgB,WAAW;AAChC,SAAO,MAAM,QAAQ,SAAS,IAAI,YAAY,CAAC,SAAS;AAC5D;AACA,SAAS,mBAAmB,YAAY,KAAK;AACzC,SAAO,cAAc,WAAW,GAAG,IAC7B;AAAA,IACE,GAAG;AAAA,IACH,GAAG,WAAW,GAAG;AAAA,EAC7B,IACU,EAAE,GAAG,WAAU;AACzB;AACA,MAAM,WAAW,CAAC,aAAa,OAAO,aAAa;AACnD,MAAM,yBAAyB,CAAC,cAAc,UAAU,MAAM,QAAQ;AC1PtE,SAAS,YAAY,KAAK,QAAQ;AAC9B,SAAO,OAAO;AAClB;AACA,MAAM,4BAA4B,cAAc;AAAA,EAC5C,cAAc;AACV,UAAM,GAAG,SAAS;AAClB,SAAK,OAAO;AAAA,EAChB;AAAA,EACA,sBAAsB,UAAU,KAAK;AACjC,QAAI,YAAY,KAAK,QAAQ,GAAG;AAC5B,YAAM,QAAQ,SAAS,GAAG;AAC1B,UAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU;AACxD,eAAO;AAAA,MACX;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA,EACA,yBAAyB;AACrB,WAAO;AAAA,EACX;AAAA,EACA,2BAA2B,KAAK,aAAa;AACzC,WAAO,YAAY,OAAO,GAAG;AAAA,EACjC;AAAA,EACA,6BAA6B;AACzB,WAAO,UAAS;AAAA,EACpB;AAAA,EACA,MAAM,aAAa,cAAc;AAC7B,WAAO,OAAO,YAAY,QAAQ,YAAY;AAAA,EAClD;AAAA,EACA,eAAe,UAAU,EAAE,UAAU;AACjC,WAAO,OAAO,UAAU,MAAM;AAAA,EAClC;AAAA,EACA,2BAA2B;AACvB,WAAO;AAAA,EACX;AACJ;AChCA,SAAS,uBAAuB,SAAS;AACrC,QAAM,UAAU;AAAA,IACZ,iBAAiB;AAAA,IACjB,OAAO,CAAA;AAAA,IACP,aAAa;AAAA,MACT,aAAa;AAAA,QACT,WAAW,CAAA;AAAA,QACX,iBAAiB,CAAA;AAAA,QACjB,OAAO,CAAA;AAAA,QACP,MAAM,CAAA;AAAA,QACN,OAAO,CAAA;AAAA,MACvB;AAAA,MACY,cAAc,CAAA;AAAA,IAC1B;AAAA,EACA;AACI,QAAM,OAAO,aAAa,OAAO,IAC3B,IAAI,iBAAiB,OAAO,IAC5B,IAAI,kBAAkB,OAAO;AACnC,OAAK,MAAM,OAAO;AAClB,qBAAmB,IAAI,SAAS,IAAI;AACxC;AACA,SAAS,0BAA0B,SAAS;AACxC,QAAM,UAAU;AAAA,IACZ,iBAAiB;AAAA,IACjB,OAAO,CAAA;AAAA,IACP,aAAa;AAAA,MACT,aAAa;AAAA,QACT,QAAQ,CAAA;AAAA,MACxB;AAAA,MACY,cAAc,CAAA;AAAA,IAC1B;AAAA,EACA;AACI,QAAM,OAAO,IAAI,oBAAoB,OAAO;AAC5C,OAAK,MAAM,OAAO;AAClB,qBAAmB,IAAI,SAAS,IAAI;AACxC;AChCA,SAAS,cAAc,SAAS,WAAW;AACvC,SAAQ,cAAc,OAAO,KACzB,OAAO,YAAY,YAClB,OAAO,YAAY,YAAY,CAAC,eAAe,SAAS;AACjE;AAIA,SAAS,eAAe,SAAS,WAAW,SAAS,OAAO;AACxD,QAAM,aAAa,CAAA;AACnB,MAAI,cAAc,SAAS,SAAS,GAAG;AACnC,eAAW,KAAK,mBAAmB,SAAS,eAAe,SAAS,IAC9D,UAAU,WAAW,YACrB,WAAW,UAAU,QAAQ,WAAW,UAAU,OAAO,CAAC;AAAA,EACpE,OACK;AACD,UAAM,WAAW,gBAAgB,SAAS,WAAW,KAAK;AAC1D,UAAM,cAAc,SAAS;AAC7B,cAAU,QAAQ,WAAW,GAAG,6BAA6B;AAC7D,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAClC,YAAM,cAAc,SAAS,CAAC;AAC9B,YAAM,sBAAsB,uBAAuB,UAC7C,yBACA;AACN,UAAI,CAAC,mBAAmB,IAAI,WAAW,GAAG;AACtC,4BAAoB,WAAW;AAAA,MACnC;AACA,YAAM,gBAAgB,mBAAmB,IAAI,WAAW;AACxD,YAAM,aAAa,EAAE,GAAG,QAAO;AAI/B,UAAI,WAAW,cACX,OAAO,WAAW,UAAU,YAAY;AACxC,mBAAW,QAAQ,WAAW,MAAM,GAAG,WAAW;AAAA,MACtD;AACA,iBAAW,KAAK,GAAG,cAAc,eAAe,EAAE,GAAG,WAAW,cAAc,CAAA,CAAE,CAAC;AAAA,IACrF;AAAA,EACJ;AACA,SAAO;AACX;AC7CA,SAAS,gBAAgB,UAAU,SAAS,OAAO;AAC/C,QAAM,aAAa,CAAA;AACnB,QAAM,uBAAuB,6BAA6B,UAAU,SAAS,OAAO,EAAE,QAAQ;AAC9F,uBAAqB,QAAQ,CAAC,EAAE,WAAW,WAAU,GAAI,YAAY;AACjE,eAAW,KAAK,GAAG,eAAe,SAAS,WAAW,UAAU,CAAC;AAAA,EACrE,CAAC;AACD,SAAO;AACX;ACNA,SAAS,WAAW,OAAO;AACvB,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,KAAK,MAAM,OAAO;AAC3D;AAKA,SAAS,oBAAoB,OAAO;AAIhC,WAAS,cAAc,mBAAmB,oBAAoB,SAAS;AACnE,QAAI,aAAa,CAAA;AACjB,QAAI,WAAW,iBAAiB,GAAG;AAC/B,mBAAa,gBAAgB,mBAAmB,oBAAoB,KAAK;AAAA,IAC7E,OACK;AACD,mBAAa,eAAe,mBAAmB,oBAAoB,SAAS,KAAK;AAAA,IACrF;AACA,UAAM,YAAY,IAAI,sBAAsB,UAAU;AACtD,QAAI,OAAO;AACP,YAAM,WAAW,KAAK,SAAS;AAAA,IACnC;AACA,WAAO;AAAA,EACX;AACA,SAAO;AACX;AC3BA,SAAS,aAAa;AAClB,QAAM,QAAQ,YAAY,OAAO;AAAA,IAC7B,SAAS;AAAA;AAAA,IACT,YAAY,CAAA;AAAA,EACpB,EAAM;AACF,QAAM,UAAU,YAAY,MAAM,oBAAoB,KAAK,CAAC;AAC5D,mBAAiB,MAAM;AACnB,UAAM,WAAW,QAAQ,CAAC,cAAc,UAAU,MAAM;AAAA,EAC5D,CAAC;AACD,SAAO,CAAC,OAAO,OAAO;AAC1B;","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]}

package/lib/utils/accessibility.d.ts

@@ -0,0 +1,23 @@
+import { AriaAttributes } from 'react';
+interface AriaLabelAttributesConfig {
+    label?: string;
+    id?: string;
+    fallbackId?: string;
+    prefer?: 'id' | 'label';
+}
+export type AriaLabelAttributes = Pick<AriaAttributes, 'aria-label' | 'aria-labelledby'>;
+export declare const getAriaLabelAttributes: (config: AriaLabelAttributesConfig) => AriaLabelAttributes | undefined;
+export interface ErrorAriaProps {
+    error?: boolean;
+    'aria-describedby'?: string;
+    errorText?: string;
+    errorTextId?: string;
+}
+/**
+ * Get IDs to be used with aria-describedby in form components like <Input />
+ * @param props Props from form component
+ * @param errorTextUuid Unique ID of the form component's error text
+ * @returns Element IDs or undefined if there is no aria-description
+ */
+export declare const getAriaDescribedBy: (props: ErrorAriaProps, errorTextUuid: string) => string | undefined;
+export {};

package/lib/utils/accessibility.js

@@ -0,0 +1,40 @@
+const getAriaLabelAttributes = (config) => {
+  const { label, id, fallbackId, prefer = "id" } = config;
+  if (id && prefer === "id") {
+    return {
+      "aria-labelledby": id
+    };
+  }
+  if (label) {
+    return {
+      "aria-label": label
+    };
+  }
+  if (id) {
+    return {
+      "aria-labelledby": id
+    };
+  }
+  if (fallbackId) {
+    return {
+      "aria-labelledby": fallbackId
+    };
+  }
+};
+const getAriaDescribedBy = (props, errorTextUuid) => {
+  const ariaDescribedBy = props["aria-describedby"];
+  const hasErrorText = !!(props.errorText || props.error && props.errorTextId);
+  const errorTextId = hasErrorText ? errorTextUuid : void 0;
+  if (ariaDescribedBy && !errorTextId) {
+    return ariaDescribedBy;
+  } else if (!ariaDescribedBy && errorTextId) {
+    return errorTextId;
+  } else if (ariaDescribedBy && errorTextId) {
+    return ariaDescribedBy + " " + errorTextId;
+  }
+};
+export {
+  getAriaDescribedBy,
+  getAriaLabelAttributes
+};
+//# sourceMappingURL=accessibility.js.map

package/lib/utils/accessibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility.js","sources":["../../src/utils/accessibility.ts"],"sourcesContent":["import { AriaAttributes } from 'react';\n\ninterface AriaLabelAttributesConfig {\n  label?: string;\n  id?: string;\n  fallbackId?: string;\n  prefer?: 'id' | 'label';\n}\n\nexport type AriaLabelAttributes = Pick<AriaAttributes, 'aria-label' | 'aria-labelledby'>;\n\nexport const getAriaLabelAttributes = (config: AriaLabelAttributesConfig): AriaLabelAttributes | undefined => {\n  const { label, id, fallbackId, prefer = 'id' } = config;\n\n  if (id && prefer === 'id') {\n    return {\n      'aria-labelledby': id,\n    };\n  }\n\n  if (label) {\n    return {\n      'aria-label': label,\n    };\n  }\n\n  if (id) {\n    return {\n      'aria-labelledby': id,\n    };\n  }\n\n  if (fallbackId) {\n    return {\n      'aria-labelledby': fallbackId,\n    };\n  }\n};\n\nexport interface ErrorAriaProps {\n  error?: boolean;\n  'aria-describedby'?: string;\n  errorText?: string;\n  errorTextId?: string;\n}\n\n/**\n * Get IDs to be used with aria-describedby in form components like <Input />\n * @param props Props from form component\n * @param errorTextUuid Unique ID of the form component's error text\n * @returns Element IDs or undefined if there is no aria-description\n */\nexport const getAriaDescribedBy = (props: ErrorAriaProps, errorTextUuid: string): string | undefined => {\n  const ariaDescribedBy: string | undefined = props['aria-describedby'];\n  const hasErrorText: boolean = !!(props.errorText || (props.error && props.errorTextId));\n  const errorTextId: string | undefined = hasErrorText ? errorTextUuid : undefined;\n\n  if (ariaDescribedBy && !errorTextId) {\n    return ariaDescribedBy;\n  } else if (!ariaDescribedBy && errorTextId) {\n    return errorTextId;\n  } else if (ariaDescribedBy && errorTextId) {\n    return ariaDescribedBy + ' ' + errorTextId;\n  }\n};\n"],"names":[],"mappings":"AAWO,MAAM,yBAAyB,CAAC,WAAuE;AAC5G,QAAM,EAAE,OAAO,IAAI,YAAY,SAAS,SAAS;AAEjD,MAAI,MAAM,WAAW,MAAM;AACzB,WAAO;AAAA,MACL,mBAAmB;AAAA,IAAA;AAAA,EAEvB;AAEA,MAAI,OAAO;AACT,WAAO;AAAA,MACL,cAAc;AAAA,IAAA;AAAA,EAElB;AAEA,MAAI,IAAI;AACN,WAAO;AAAA,MACL,mBAAmB;AAAA,IAAA;AAAA,EAEvB;AAEA,MAAI,YAAY;AACd,WAAO;AAAA,MACL,mBAAmB;AAAA,IAAA;AAAA,EAEvB;AACF;AAeO,MAAM,qBAAqB,CAAC,OAAuB,kBAA8C;AACtG,QAAM,kBAAsC,MAAM,kBAAkB;AACpE,QAAM,eAAwB,CAAC,EAAE,MAAM,aAAc,MAAM,SAAS,MAAM;AAC1E,QAAM,cAAkC,eAAe,gBAAgB;AAEvE,MAAI,mBAAmB,CAAC,aAAa;AACnC,WAAO;AAAA,EACT,WAAW,CAAC,mBAAmB,aAAa;AAC1C,WAAO;AAAA,EACT,WAAW,mBAAmB,aAAa;AACzC,WAAO,kBAAkB,MAAM;AAAA,EACjC;AACF;"}

package/lib/utils/component.d.ts

@@ -0,0 +1,4 @@
+import { default as React, PropsWithChildren } from 'react';
+export declare const isComponent: <T>(element: unknown, type: React.ForwardRefExoticComponent<T> | React.FunctionComponent<T>) => element is React.ReactElement<T>;
+export declare const isComponentWithChildren: <T>(element: unknown) => element is React.ReactElement<PropsWithChildren<T>>;
+export declare function isComponentWithDisplayName<T>(element: React.ReactNode, displayName: string): element is React.ReactElement<T>;

package/lib/utils/component.js

@@ -0,0 +1,16 @@
+import React__default from "react";
+const isComponent = (element, type) => React__default.isValidElement(element) && element.type === type;
+const isComponentWithChildren = (element) => React__default.isValidElement(element);
+function isComponentWithDisplayName(element, displayName) {
+  if (!React__default.isValidElement(element) || typeof element.type === "string") {
+    return false;
+  }
+  const componentType = element.type;
+  return componentType.displayName === displayName;
+}
+export {
+  isComponent,
+  isComponentWithChildren,
+  isComponentWithDisplayName
+};
+//# sourceMappingURL=component.js.map

package/lib/utils/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sources":["../../src/utils/component.ts"],"sourcesContent":["import React, { PropsWithChildren } from 'react';\n\nexport const isComponent = <T>(\n  element: unknown,\n  type: React.ForwardRefExoticComponent<T> | React.FunctionComponent<T>\n): element is React.ReactElement<T> => React.isValidElement<T>(element) && (element as React.ReactElement).type === type;\n\nexport const isComponentWithChildren = <T>(element: unknown): element is React.ReactElement<PropsWithChildren<T>> =>\n  React.isValidElement<PropsWithChildren<T>>(element);\n\nexport function isComponentWithDisplayName<T>(element: React.ReactNode, displayName: string): element is React.ReactElement<T> {\n  if (!React.isValidElement(element) || typeof element.type === 'string') {\n    return false;\n  }\n\n  const componentType = element.type as React.ComponentType<T> & { displayName?: string };\n\n  return componentType.displayName === displayName;\n}\n"],"names":["React"],"mappings":";AAEO,MAAM,cAAc,CACzB,SACA,SACqCA,eAAM,eAAkB,OAAO,KAAM,QAA+B,SAAS;AAE7G,MAAM,0BAA0B,CAAI,YACzCA,eAAM,eAAqC,OAAO;AAE7C,SAAS,2BAA8B,SAA0B,aAAuD;AAC7H,MAAI,CAACA,eAAM,eAAe,OAAO,KAAK,OAAO,QAAQ,SAAS,UAAU;AACtE,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB,QAAQ;AAE9B,SAAO,cAAc,gBAAgB;AACvC;"}

package/lib/utils/debounce.d.ts

@@ -0,0 +1,6 @@
+/**
+ * debounce limits time a function can be executed
+ * @param func function to debounce
+ * @param wait wait for x time
+ */
+export declare function debounce<A = unknown, R = void>(func: (args?: A) => R, wait: number): [(args?: A) => Promise<R>, () => void];

package/lib/utils/debounce.js

@@ -0,0 +1,19 @@
+function debounce(func, wait) {
+  let timeout;
+  const debouncedFunc = (args) => new Promise((resolve) => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      resolve(func(args));
+    }, wait);
+  });
+  const teardown = () => {
+    if (timeout) clearTimeout(timeout);
+  };
+  return [debouncedFunc, teardown];
+}
+export {
+  debounce
+};
+//# sourceMappingURL=debounce.js.map

package/lib/utils/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.js","sources":["../../src/utils/debounce.ts"],"sourcesContent":["/**\n * debounce limits time a function can be executed\n * @param func function to debounce\n * @param wait wait for x time\n */\n\nexport function debounce<A = unknown, R = void>(func: (args?: A) => R, wait: number): [(args?: A) => Promise<R>, () => void] {\n  let timeout: ReturnType<typeof setTimeout> | null;\n\n  const debouncedFunc = (args?: A): Promise<R> =>\n    new Promise(resolve => {\n      if (timeout) {\n        clearTimeout(timeout);\n      }\n\n      timeout = setTimeout((): void => {\n        resolve(func(args));\n      }, wait);\n    });\n\n  const teardown = (): void => {\n    if (timeout) clearTimeout(timeout);\n  };\n\n  return [debouncedFunc, teardown];\n}\n"],"names":[],"mappings":"AAMO,SAAS,SAAgC,MAAuB,MAAsD;AAC3H,MAAI;AAEJ,QAAM,gBAAgB,CAAC,SACrB,IAAI,QAAQ,CAAA,YAAW;AACrB,QAAI,SAAS;AACX,mBAAa,OAAO;AAAA,IACtB;AAEA,cAAU,WAAW,MAAY;AAC/B,cAAQ,KAAK,IAAI,CAAC;AAAA,IACpB,GAAG,IAAI;AAAA,EACT,CAAC;AAEH,QAAM,WAAW,MAAY;AAC3B,QAAI,sBAAsB,OAAO;AAAA,EACnC;AAEA,SAAO,CAAC,eAAe,QAAQ;AACjC;"}

package/lib/utils/deepContains.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determines whether a given container node contains a specific element, traversing through shadow DOM boundaries if necessary.
+ * This function extends the behavior of `Node.contains` to support scenarios involving shadow DOM.
+ *
+ * @param container - The container node to check, typically the document or a specific DOM element.
+ * @param element - The target node to verify if it is contained within the container.
+ * @returns `true` if the container node contains the target node, including through shadow DOM boundaries; otherwise, `false`.
+ */
+export declare function deepContains(container: Node, element: Node | null): boolean;

package/lib/utils/deepContains.js

@@ -0,0 +1,19 @@
+function deepContains(container, element) {
+  let node = element;
+  while (node) {
+    if (node === container) {
+      return true;
+    }
+    const rootNode = node.getRootNode();
+    if (rootNode instanceof ShadowRoot) {
+      node = rootNode.host;
+    } else {
+      node = node.parentNode;
+    }
+  }
+  return false;
+}
+export {
+  deepContains
+};
+//# sourceMappingURL=deepContains.js.map

package/lib/utils/deepContains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepContains.js","sources":["../../src/utils/deepContains.ts"],"sourcesContent":["/**\n * Determines whether a given container node contains a specific element, traversing through shadow DOM boundaries if necessary.\n * This function extends the behavior of `Node.contains` to support scenarios involving shadow DOM.\n *\n * @param container - The container node to check, typically the document or a specific DOM element.\n * @param element - The target node to verify if it is contained within the container.\n * @returns `true` if the container node contains the target node, including through shadow DOM boundaries; otherwise, `false`.\n */\nexport function deepContains(container: Node, element: Node | null): boolean {\n  let node = element;\n  while (node) {\n    if (node === container) {\n      return true;\n    }\n    // Step out of shadow roots if necessary\n    const rootNode = node.getRootNode();\n    if (rootNode instanceof ShadowRoot) {\n      node = rootNode.host;\n    } else {\n      node = node.parentNode;\n    }\n  }\n  return false;\n}\n"],"names":[],"mappings":"AAQO,SAAS,aAAa,WAAiB,SAA+B;AAC3E,MAAI,OAAO;AACX,SAAO,MAAM;AACX,QAAI,SAAS,WAAW;AACtB,aAAO;AAAA,IACT;AAEA,UAAM,WAAW,KAAK,YAAA;AACtB,QAAI,oBAAoB,YAAY;AAClC,aAAO,SAAS;AAAA,IAClB,OAAO;AACL,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AACA,SAAO;AACT;"}

package/lib/utils/device.d.ts

@@ -0,0 +1 @@
+export declare const isTouchDevice: () => boolean;

package/lib/utils/device.js

@@ -0,0 +1,7 @@
+const isTouchDevice = () => {
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+};
+export {
+  isTouchDevice
+};
+//# sourceMappingURL=device.js.map

package/lib/utils/device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.js","sources":["../../src/utils/device.ts"],"sourcesContent":["export const isTouchDevice = (): boolean => {\n  return 'ontouchstart' in window || navigator.maxTouchPoints > 0;\n};\n"],"names":[],"mappings":"AAAO,MAAM,gBAAgB,MAAe;AAC1C,SAAO,kBAAkB,UAAU,UAAU,iBAAiB;AAChE;"}