@buoy-gg/core 1.7.7 → 2.1.1

package/lib/commonjs/floatingMenu/dial/DialDevTools.web.js

@@ -0,0 +1,593 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DialMenu = DialMenu;
+var _react = require("react");
+var _floatingToolsReact = require("@buoy-gg/floating-tools-react");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * DialDevTools - Web renderer for the radial dial menu.
+ *
+ * Uses shared layout calculations, styling, and animation config from @buoy-gg/floating-tools-core.
+ * Platform-specific: CSS animations, mouse events, web JSX.
+ *
+ * Animation behavior matches mobile exactly - see docs/dial-animation-spec.md
+ *
+ * @platform React DOM Web (Vite, CRA, Next.js, Electron)
+ */
+
+// Inject CSS keyframes once on module load
+let keyframesInjected = false;
+function injectKeyframes() {
+  if (keyframesInjected || typeof document === 'undefined') return;
+  const style = document.createElement('style');
+  style.textContent = (0, _floatingToolsReact.getDialCSSKeyframesString)();
+  document.head.appendChild(style);
+  keyframesInjected = true;
+}
+
+// Easing functions
+const easeOutCubic = t => 1 - Math.pow(1 - t, 3);
+const easeInCubic = t => t * t * t;
+
+// =============================
+// Types
+// =============================
+
+// =============================
+// Dial Icon Component
+// =============================
+
+function DialIconItem({
+  icon,
+  index,
+  totalIcons,
+  position,
+  progress,
+  onPress
+}) {
+  const [isHovered, setIsHovered] = (0, _react.useState)(false);
+  const [isPressed, setIsPressed] = (0, _react.useState)(false);
+  const isEmpty = !icon.icon && icon.id.startsWith('empty-');
+  const {
+    icons: iconConfig
+  } = _floatingToolsReact.dialAnimationConfig;
+
+  // Get stagger input range for this icon
+  const staggerInputRange = (0, _floatingToolsReact.getIconStaggerInputRange)(index, totalIcons);
+
+  // Calculate this icon's individual progress based on the global progress
+  let iconProgress = 0;
+  if (progress <= staggerInputRange[1]) {
+    iconProgress = 0;
+  } else if (progress <= staggerInputRange[2]) {
+    iconProgress = (progress - staggerInputRange[1]) / (staggerInputRange[2] - staggerInputRange[1]);
+  } else {
+    iconProgress = 1;
+  }
+  iconProgress = Math.max(0, Math.min(1, iconProgress));
+  const iconSize = 60;
+  const pressedScale = iconConfig.pressIn.scale;
+  const hoveredScale = 1.1;
+  const scale = iconProgress * (isPressed ? pressedScale : isHovered ? hoveredScale : 1);
+
+  // Opacity interpolation
+  let opacity = 0;
+  if (iconProgress <= 0) {
+    opacity = 0;
+  } else if (iconProgress <= 0.3) {
+    opacity = iconProgress;
+  } else {
+    opacity = 0.3 + (iconProgress - 0.3) * (0.7 / 0.7);
+  }
+  const x = position.x * iconProgress;
+  const y = position.y * iconProgress;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("button", {
+    role: "menuitem",
+    "aria-label": isEmpty ? 'Empty slot' : icon.name,
+    "aria-disabled": isEmpty,
+    tabIndex: isEmpty ? -1 : 0,
+    onClick: isEmpty ? undefined : onPress,
+    onMouseEnter: () => !isEmpty && setIsHovered(true),
+    onMouseLeave: () => {
+      setIsHovered(false);
+      setIsPressed(false);
+    },
+    onMouseDown: () => !isEmpty && setIsPressed(true),
+    onMouseUp: () => setIsPressed(false),
+    style: {
+      position: 'absolute',
+      left: '50%',
+      top: '50%',
+      width: iconSize,
+      height: iconSize,
+      marginLeft: -iconSize / 2,
+      marginTop: -iconSize / 2,
+      display: 'flex',
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center',
+      cursor: isEmpty ? 'default' : 'pointer',
+      transform: `translate(${x}px, ${y}px) scale(${scale})`,
+      opacity,
+      transition: isHovered || isPressed ? 'transform 100ms ease' : 'none',
+      background: 'none',
+      border: 'none',
+      padding: 0
+    },
+    children: isEmpty ? /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      style: {
+        width: _floatingToolsReact.dialStyles.emptySlot.dotSize,
+        height: _floatingToolsReact.dialStyles.emptySlot.dotSize,
+        borderRadius: _floatingToolsReact.dialStyles.emptySlot.dotSize / 2,
+        backgroundColor: _floatingToolsReact.dialColors.emptyDotBackground,
+        border: `${_floatingToolsReact.dialStyles.emptySlot.borderWidth}px solid ${_floatingToolsReact.dialColors.emptyDotBorder}`
+      }
+    }) : /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        style: {
+          position: 'absolute',
+          width: `${_floatingToolsReact.dialStyles.icon.gradientBgSizePercent}%`,
+          height: `${_floatingToolsReact.dialStyles.icon.gradientBgSizePercent}%`,
+          borderRadius: _floatingToolsReact.dialStyles.icon.gradientBgBorderRadius,
+          backgroundColor: 'rgba(0, 0, 0, 0.2)',
+          opacity: _floatingToolsReact.dialStyles.icon.gradientBgOpacity
+        }
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        style: {
+          position: 'absolute',
+          width: `${_floatingToolsReact.dialStyles.icon.innerGlowSizePercent}%`,
+          height: `${_floatingToolsReact.dialStyles.icon.innerGlowSizePercent}%`,
+          borderRadius: _floatingToolsReact.dialStyles.icon.innerGlowBorderRadius,
+          backgroundColor: 'rgba(255, 255, 255, 0.02)',
+          opacity: _floatingToolsReact.dialStyles.icon.innerGlowOpacity
+        }
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        style: {
+          marginBottom: _floatingToolsReact.dialStyles.icon.wrapperMarginBottom,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          fontSize: 32,
+          filter: isHovered ? 'brightness(1.2)' : 'none'
+        },
+        children: icon.icon
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+        style: {
+          fontSize: _floatingToolsReact.dialStyles.icon.label.fontSize,
+          fontWeight: _floatingToolsReact.dialStyles.icon.label.fontWeight,
+          fontFamily: _floatingToolsReact.dialStyles.icon.label.fontFamily,
+          color: _floatingToolsReact.dialColors.iconLabel,
+          letterSpacing: _floatingToolsReact.dialStyles.icon.label.letterSpacing,
+          marginTop: _floatingToolsReact.dialStyles.icon.label.marginTop,
+          textTransform: 'uppercase'
+        },
+        children: icon.name
+      })]
+    })
+  });
+}
+
+// =============================
+// Main DialMenu Component
+// =============================
+
+function DialMenu({
+  icons,
+  onClose,
+  centerLabel = 'MENU',
+  onCenterPress
+}) {
+  // Animation values
+  const [backdropOpacity, setBackdropOpacity] = (0, _react.useState)(0);
+  const [dialScale, setDialScale] = (0, _react.useState)(0);
+  const [dialRotation, setDialRotation] = (0, _react.useState)(0);
+  const [centerButtonScale, setCenterButtonScale] = (0, _react.useState)(0);
+  const [iconProgress, setIconProgress] = (0, _react.useState)(0);
+  const [centerPulseScale, setCenterPulseScale] = (0, _react.useState)(1);
+
+  // UI state
+  const [isHoveringCenter, setIsHoveringCenter] = (0, _react.useState)(false);
+  const [triggerGlitch, setTriggerGlitch] = (0, _react.useState)(0);
+  const [isExiting, setIsExiting] = (0, _react.useState)(false);
+  const [entranceComplete, setEntranceComplete] = (0, _react.useState)(false);
+
+  // Refs
+  const animationRef = (0, _react.useRef)(null);
+  const glitchIntervalRef = (0, _react.useRef)(null);
+  const isClosingRef = (0, _react.useRef)(false);
+
+  // Config
+  const {
+    entrance,
+    exit,
+    continuous,
+    interaction
+  } = _floatingToolsReact.dialAnimationConfig;
+  const cssAnimations = (0, _floatingToolsReact.getDialCSSAnimationStyles)();
+
+  // Layout
+  const layout = (0, _react.useMemo)(() => (0, _floatingToolsReact.getDialLayout)({
+    screenWidth: window.innerWidth
+  }), []);
+  const gridRotations = (0, _react.useMemo)(() => (0, _floatingToolsReact.getGridLineRotations)(), []);
+  const positions = (0, _react.useMemo)(() => (0, _floatingToolsReact.getAllIconPositions)(_floatingToolsReact.MAX_DIAL_SLOTS, layout.iconRadius), [layout.iconRadius]);
+  const paddedIcons = (0, _react.useMemo)(() => {
+    const result = [...icons.slice(0, _floatingToolsReact.MAX_DIAL_SLOTS)];
+    while (result.length < _floatingToolsReact.MAX_DIAL_SLOTS) {
+      result.push({
+        id: `empty-${result.length}`,
+        name: '',
+        icon: null,
+        onPress: () => {}
+      });
+    }
+    return result;
+  }, [icons]);
+
+  // Inject keyframes
+  (0, _react.useEffect)(() => {
+    injectKeyframes();
+  }, []);
+
+  // ENTRANCE Animation - runs once on mount
+  (0, _react.useEffect)(() => {
+    // Capture config values at mount time
+    const backdropDuration = entrance.backdrop.duration;
+    const rotationDuration = entrance.dial.rotation.duration;
+    const centerButtonDelay = entrance.centerButton.delay;
+    const iconsDelay = entrance.icons.delay;
+    const iconsDuration = entrance.icons.duration;
+    const glitchInterval = continuous.glitch.interval;
+    const startTime = performance.now();
+    const animate = currentTime => {
+      const elapsed = currentTime - startTime;
+
+      // Backdrop (0-400ms)
+      setBackdropOpacity(Math.min(1, elapsed / backdropDuration));
+
+      // Dial scale with spring overshoot (~400ms)
+      const dialProgress = Math.min(1, elapsed / 400);
+      let springScale = easeOutCubic(dialProgress) * 1.1;
+      if (dialProgress > 0.7) {
+        springScale -= (dialProgress - 0.7) * 0.33;
+      }
+      if (dialProgress >= 1) springScale = 1;
+      setDialScale(Math.max(0, Math.min(1.05, springScale)));
+
+      // Dial rotation (0-800ms)
+      const rotProgress = Math.min(1, elapsed / rotationDuration);
+      setDialRotation(easeOutCubic(rotProgress) * 360);
+
+      // Center button (300ms delay)
+      if (elapsed >= centerButtonDelay) {
+        const centerProgress = Math.min(1, (elapsed - centerButtonDelay) / 300);
+        let centerSpring = easeOutCubic(centerProgress) * 1.15;
+        if (centerProgress > 0.6) {
+          centerSpring -= (centerProgress - 0.6) * 0.375;
+        }
+        if (centerProgress >= 1) centerSpring = 1;
+        setCenterButtonScale(Math.max(0, Math.min(1.05, centerSpring)));
+      }
+
+      // Icons (500ms delay, 600ms duration)
+      if (elapsed >= iconsDelay) {
+        const iconsProgress = Math.min(1, (elapsed - iconsDelay) / iconsDuration);
+        setIconProgress(easeOutCubic(iconsProgress));
+      }
+
+      // Continue or finish
+      const totalTime = iconsDelay + iconsDuration;
+      if (elapsed < totalTime) {
+        animationRef.current = requestAnimationFrame(animate);
+      } else {
+        // Finalize
+        setBackdropOpacity(1);
+        setDialScale(1);
+        setDialRotation(360);
+        setCenterButtonScale(1);
+        setIconProgress(1);
+        setEntranceComplete(true);
+      }
+    };
+    animationRef.current = requestAnimationFrame(animate);
+
+    // Glitch interval
+    glitchIntervalRef.current = setInterval(() => {
+      setTriggerGlitch(prev => prev + 1);
+    }, glitchInterval);
+    return () => {
+      if (animationRef.current) cancelAnimationFrame(animationRef.current);
+      if (glitchIntervalRef.current) clearInterval(glitchIntervalRef.current);
+    };
+  }, []);
+
+  // EXIT Animation
+  const handleClose = (0, _react.useCallback)(() => {
+    if (isClosingRef.current) return;
+    isClosingRef.current = true;
+    setIsExiting(true);
+    if (glitchIntervalRef.current) {
+      clearInterval(glitchIntervalRef.current);
+      glitchIntervalRef.current = null;
+    }
+    if (animationRef.current) {
+      cancelAnimationFrame(animationRef.current);
+    }
+    const startTime = performance.now();
+    const iconsDuration = exit.icons.duration;
+    const dialDuration = Math.max(exit.centerButton.duration, exit.dialScale.duration);
+    const backdropDuration = exit.backdrop.duration;
+    const animate = currentTime => {
+      const elapsed = currentTime - startTime;
+
+      // Step 1: Icons collapse (0 - 300ms)
+      if (elapsed < iconsDuration) {
+        const progress = easeInCubic(elapsed / iconsDuration);
+        setIconProgress(1 - progress);
+        animationRef.current = requestAnimationFrame(animate);
+        return;
+      }
+
+      // Step 2: Dial + Center scale down (300 - 550ms)
+      const step2Start = iconsDuration;
+      if (elapsed < step2Start + dialDuration) {
+        setIconProgress(0);
+        const progress = easeInCubic((elapsed - step2Start) / dialDuration);
+        setDialScale(1 - progress);
+        setCenterButtonScale(1 - progress);
+        animationRef.current = requestAnimationFrame(animate);
+        return;
+      }
+
+      // Step 3: Backdrop fade (550 - 750ms)
+      const step3Start = step2Start + dialDuration;
+      if (elapsed < step3Start + backdropDuration) {
+        setDialScale(0);
+        setCenterButtonScale(0);
+        const progress = (elapsed - step3Start) / backdropDuration;
+        setBackdropOpacity(1 - progress);
+        animationRef.current = requestAnimationFrame(animate);
+        return;
+      }
+
+      // Done
+      setBackdropOpacity(0);
+      onClose();
+    };
+    animationRef.current = requestAnimationFrame(animate);
+  }, [exit, onClose]);
+
+  // Document-level Escape key handler
+  (0, _react.useEffect)(() => {
+    const handleKeyDown = e => {
+      if (e.key === 'Escape') {
+        handleClose();
+      }
+    };
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, [handleClose]);
+
+  // Icon press handler
+  const handleIconPress = (0, _react.useCallback)(icon => {
+    if (icon.id.startsWith('empty-') || isClosingRef.current) return;
+
+    // Pulse animation
+    const [pulseIn, pulseOut] = interaction.iconSelect.pulse;
+    const startTime = performance.now();
+    const pulseDuration = 150;
+    const animatePulse = currentTime => {
+      const elapsed = currentTime - startTime;
+      if (elapsed < pulseDuration) {
+        const progress = easeOutCubic(elapsed / pulseDuration);
+        setCenterPulseScale(1 - (1 - pulseIn.scale) * progress);
+        requestAnimationFrame(animatePulse);
+      } else if (elapsed < pulseDuration * 2) {
+        const progress = easeOutCubic((elapsed - pulseDuration) / pulseDuration);
+        setCenterPulseScale(pulseIn.scale + (pulseOut.scale - pulseIn.scale) * progress);
+        requestAnimationFrame(animatePulse);
+      } else {
+        setCenterPulseScale(1);
+      }
+    };
+    requestAnimationFrame(animatePulse);
+
+    // Trigger action after delay
+    setTimeout(() => {
+      icon.onPress();
+      handleClose();
+    }, interaction.iconSelect.actionDelay);
+  }, [interaction.iconSelect, handleClose]);
+
+  // Computed values
+  const buttonContainerSize = layout.buttonSize * _floatingToolsReact.dialStyles.centerButton.containerRatio;
+  const buttonBorderSize = layout.buttonSize * _floatingToolsReact.dialStyles.centerButton.borderRatio;
+  const isAnimating = entranceComplete && !isExiting;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    role: "dialog",
+    "aria-label": "Dial Menu",
+    "aria-modal": "true",
+    style: {
+      position: 'fixed',
+      inset: 0,
+      zIndex: 10000,
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      role: "button",
+      "aria-label": "Close dial menu",
+      tabIndex: 0,
+      onClick: handleClose,
+      onKeyDown: e => e.key === 'Escape' && handleClose(),
+      style: {
+        position: 'absolute',
+        inset: 0,
+        backgroundColor: _floatingToolsReact.dialColors.dialBackdrop,
+        opacity: backdropOpacity
+      }
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      style: {
+        animation: isAnimating ? cssAnimations.floating : 'none'
+      },
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        style: {
+          animation: triggerGlitch > 0 && isAnimating ? cssAnimations.glitch : 'none'
+        },
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+          style: {
+            position: 'relative',
+            width: layout.circleSize,
+            height: layout.circleSize,
+            borderRadius: '50%',
+            backgroundColor: _floatingToolsReact.dialColors.dialBackground,
+            border: `${_floatingToolsReact.dialStyles.circle.borderWidth}px solid ${_floatingToolsReact.dialColors.dialBorder}`,
+            boxShadow: `0 0 ${_floatingToolsReact.dialStyles.circle.shadowRadius}px ${_floatingToolsReact.dialColors.dialShadow}`,
+            transform: `scale(${dialScale}) rotate(${dialRotation}deg)`,
+            opacity: dialScale > 0.01 ? 1 : 0,
+            overflow: 'hidden'
+          },
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+            style: {
+              position: 'absolute',
+              inset: 0,
+              borderRadius: '50%',
+              backgroundColor: _floatingToolsReact.dialColors.dialGradient1,
+              opacity: _floatingToolsReact.dialStyles.gradientLayers[0].opacity
+            }
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+            style: {
+              position: 'absolute',
+              inset: 0,
+              top: '30%',
+              left: '30%',
+              borderRadius: '50%',
+              backgroundColor: _floatingToolsReact.dialColors.dialGradient2,
+              opacity: _floatingToolsReact.dialStyles.gradientLayers[1].opacity
+            }
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+            style: {
+              position: 'absolute',
+              inset: 0,
+              top: '50%',
+              left: '50%',
+              borderRadius: '50%',
+              backgroundColor: _floatingToolsReact.dialColors.dialGradient3,
+              opacity: _floatingToolsReact.dialStyles.gradientLayers[2].opacity
+            }
+          }), gridRotations.map(deg => /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+            style: {
+              position: 'absolute',
+              top: '50%',
+              left: 0,
+              right: 0,
+              height: _floatingToolsReact.dialStyles.grid.lineHeight,
+              backgroundColor: _floatingToolsReact.dialColors.dialGridLine,
+              transform: `rotate(${deg}deg)`,
+              transformOrigin: 'center'
+            }
+          }, deg)), paddedIcons.map((icon, index) => /*#__PURE__*/(0, _jsxRuntime.jsx)(DialIconItem, {
+            icon: icon,
+            index: index,
+            totalIcons: paddedIcons.length,
+            position: positions[index],
+            progress: iconProgress,
+            onPress: () => handleIconPress(icon)
+          }, icon.id)), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+            style: {
+              position: 'absolute',
+              left: '50%',
+              top: '50%',
+              width: buttonContainerSize,
+              height: buttonContainerSize,
+              marginLeft: -buttonContainerSize / 2,
+              marginTop: -buttonContainerSize / 2,
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              backgroundColor: _floatingToolsReact.dialColors.dialBackground,
+              borderRadius: layout.buttonSize,
+              overflow: 'hidden',
+              transform: `scale(${centerButtonScale * centerPulseScale})`,
+              opacity: centerButtonScale > 0.01 ? 1 : 0
+            },
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+              style: {
+                position: 'absolute',
+                inset: 0,
+                backgroundColor: _floatingToolsReact.dialColors.dialGradient1,
+                opacity: 0.5,
+                borderRadius: layout.buttonSize
+              }
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+              style: {
+                position: 'absolute',
+                inset: 0,
+                top: '20%',
+                left: '20%',
+                backgroundColor: _floatingToolsReact.dialColors.dialGradient2,
+                opacity: 0.3,
+                borderRadius: layout.buttonSize
+              }
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+              style: {
+                position: 'absolute',
+                inset: 0,
+                top: '40%',
+                left: '40%',
+                backgroundColor: _floatingToolsReact.dialColors.dialGradient3,
+                opacity: 0.2,
+                borderRadius: layout.buttonSize
+              }
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+              style: {
+                width: buttonBorderSize,
+                height: buttonBorderSize,
+                borderRadius: layout.buttonSize * _floatingToolsReact.dialStyles.centerButton.borderRadiusRatio,
+                backgroundColor: _floatingToolsReact.dialColors.dialGridLine,
+                border: `${_floatingToolsReact.dialStyles.centerButton.borderWidth}px solid ${_floatingToolsReact.dialColors.dialBorder}`,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center'
+              },
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+                onClick: onCenterPress,
+                onMouseEnter: () => setIsHoveringCenter(true),
+                onMouseLeave: () => setIsHoveringCenter(false),
+                style: {
+                  width: layout.buttonSize,
+                  height: layout.buttonSize,
+                  borderRadius: layout.buttonSize / 2,
+                  display: 'flex',
+                  flexDirection: 'column',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  cursor: onCenterPress ? 'pointer' : 'default',
+                  transform: isHoveringCenter ? `scale(${interaction.centerHover.scale})` : 'scale(1)',
+                  transition: `transform ${interaction.centerHover.duration}ms ease`,
+                  animation: isAnimating && !isHoveringCenter ? cssAnimations.breathing : 'none'
+                },
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+                  style: {
+                    fontSize: _floatingToolsReact.dialStyles.centerButton.text.fontSize,
+                    fontWeight: _floatingToolsReact.dialStyles.centerButton.text.fontWeight,
+                    fontFamily: _floatingToolsReact.dialStyles.centerButton.text.fontFamily,
+                    color: _floatingToolsReact.dialColors.centerText,
+                    letterSpacing: _floatingToolsReact.dialStyles.centerButton.text.letterSpacing,
+                    textShadow: `0 0 4px ${_floatingToolsReact.dialColors.centerTextGlow}`,
+                    textTransform: 'uppercase'
+                  },
+                  children: centerLabel
+                })
+              })
+            })]
+          })]
+        })
+      }, triggerGlitch)
+    })]
+  });
+}