{"version":3,"file":"5715f51d95291fb02519e3e7d659cf1b564dc6cb-136f2bf2fb18c099c84f.js","mappings":"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","sources":["webpack://my-gatsby-site/./node_modules/window-scroll-manager/index.js","webpack://my-gatsby-site/./node_modules/react-plx/dist/esm/index.js","webpack://my-gatsby-site/./node_modules/bezier-easing/src/index.js"],"sourcesContent":["'use strict';\n\n(function() {\n  var instance = null;\n  var instancesCount = 0;\n  var ticking = false;\n\n  var EVENT_NAME = 'window-scroll';\n\n  var isWindowDefined = typeof window !== 'undefined';\n\n  // ------------------------------------------------\n  // Passive events support detection\n  // ------------------------------------------------\n  function detectPassiveEvents() {\n    if (isWindowDefined && typeof window.addEventListener === 'function') {\n      var passive = false;\n      var options = Object.defineProperty({}, 'passive', {\n        get: function() { passive = true; }\n      });\n      // note: have to set and remove a no-op listener instead of null\n      // (which was used previously), because Edge v15 throws an error\n      // when providing a null callback.\n      // https://github.com/rafrex/detect-passive-events/pull/3\n      var noop = function() {};\n      window.addEventListener('TEST_PASSIVE_EVENT_SUPPORT', noop, options);\n      window.removeEventListener('TEST_PASSIVE_EVENT_SUPPORT', noop, options);\n\n      return passive;\n    }\n\n    return false;\n  }\n\n  var supportsPassiveEvents = detectPassiveEvents();\n\n  // ------------------------------------------------\n  // Custom Event detection\n  // ------------------------------------------------\n  var supportsCustomEvents = isWindowDefined && typeof window.CustomEvent === 'function';\n\n  // ------------------------------------------------\n  // Scroll manager\n  // ------------------------------------------------\n  function ScrollManager() {\n    if (typeof window === 'undefined') {\n      // Silently return null if it is used on server\n      return null;\n    }\n\n    // Increase reference count\n    instancesCount++;\n\n    // If singleton instance exists, return it rather than creating a new one\n    if (instance) {\n      return instance;\n    }\n\n    // Save singleton instance\n    instance = this;\n\n    // Bind handlers\n    this.handleScroll = this.handleScroll.bind(this);\n\n    // Use passive listener when supported with fallback to capture option\n    this.eventListenerOptions = supportsPassiveEvents ? { passive: true } : true;\n\n    // Add scroll listener\n    window.addEventListener('scroll', this.handleScroll, this.eventListenerOptions);\n  }\n\n  ScrollManager.prototype.removeListener = function() {\n    instancesCount--;\n\n    // There is not components listening to our event\n    if (instancesCount === 0) {\n      this.destroy();\n    }\n  };\n\n  ScrollManager.prototype.destroy = function() {\n    // Remove event listener\n    window.removeEventListener('scroll', this.handleScroll, this.eventListenerOptions);\n\n    // Clear singleton instance and count\n    instance = null;\n    instancesCount = 0;\n  };\n\n  ScrollManager.prototype.getScrollPosition = function() {\n    // Get scroll position, with IE fallback\n    var scrollPositionY = window.scrollY || document.documentElement.scrollTop;\n    var scrollPositionX = window.scrollX || document.documentElement.scrollLeft;\n\n    // Disable overscrolling in safari\n    if (scrollPositionY < 0) {\n      scrollPositionY = 0;\n    }\n    if (scrollPositionX < 0) {\n      scrollPositionX = 0;\n    }\n\n    return {\n      // Alias for scrollPositionY for backwards compatibility\n      scrollPosition: scrollPositionY,\n      scrollPositionY: scrollPositionY,\n      scrollPositionX: scrollPositionX\n    };\n  };\n\n  ScrollManager.prototype.handleScroll = function() {\n    // Fire the event only once per requestAnimationFrame\n    if (!ticking) {\n      ticking = true;\n\n      var event;\n\n      if (supportsCustomEvents) {\n        event = new CustomEvent(EVENT_NAME, {\n          detail: this.getScrollPosition()\n        });\n      } else {\n        event = document.createEvent('CustomEvent');\n        event.initCustomEvent(EVENT_NAME, false, false, this.getScrollPosition());\n      }\n\n      window.dispatchEvent(event);\n\n      window.requestAnimationFrame(function() {\n        ticking = false;\n      });\n    }\n  };\n\n  if (typeof module !== 'undefined' && module.exports) {\n    ScrollManager.default = ScrollManager;\n    module.exports = ScrollManager;\n  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) { // eslint-disable-line no-undef\n    // register as 'window-scroll-manager', consistent with npm package name\n    define('window-scroll-manager', [], function() { // eslint-disable-line no-undef\n      return ScrollManager;\n    });\n  } else {\n    window.ScrollManager = ScrollManager;\n  }\n}).call(this);\n","var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport React, { useCallback, useEffect, useMemo, useRef, useState, } from \"react\";\nimport BezierEasing from \"bezier-easing\";\n// @ts-ignore\nimport ScrollManager from \"window-scroll-manager\";\n// ------------ Constants\n// Regex that checks for numbers in string\n// formatted as \"{number}{unit}\" where unit is \"px\", \"vh\", \"%\" or none\nconst START_END_DURATION_REGEX = /^-?\\d+(\\.\\d+)?(px|vh|%)?$/;\nconst DEFAULT_UNIT = \"px\";\nconst DEFAULT_ANGLE_UNIT = \"deg\";\nconst ANGLE_PROPERTIES = [\"rotate\", \"rotateX\", \"rotateY\", \"rotateZ\", \"skew\", \"skewX\", \"skewY\", \"skewZ\", \"hueRotate\"];\nconst EASINGS = {\n    ease: [0.25, 0.1, 0.25, 1.0],\n    easeIn: [0.42, 0.0, 1.0, 1.0],\n    easeOut: [0.0, 0.0, 0.58, 1.0],\n    easeInOut: [0.42, 0.0, 0.58, 1.0],\n    easeInSine: [0.47, 0, 0.745, 0.715],\n    easeOutSine: [0.39, 0.575, 0.565, 1],\n    easeInOutSine: [0.445, 0.05, 0.55, 0.95],\n    easeInQuad: [0.55, 0.085, 0.68, 0.53],\n    easeOutQuad: [0.25, 0.46, 0.45, 0.94],\n    easeInOutQuad: [0.455, 0.03, 0.515, 0.955],\n    easeInCubic: [0.55, 0.055, 0.675, 0.19],\n    easeOutCubic: [0.215, 0.61, 0.355, 1],\n    easeInOutCubic: [0.645, 0.045, 0.355, 1],\n    easeInQuart: [0.895, 0.03, 0.685, 0.22],\n    easeOutQuart: [0.165, 0.84, 0.44, 1],\n    easeInOutQuart: [0.77, 0, 0.175, 1],\n    easeInQuint: [0.755, 0.05, 0.855, 0.06],\n    easeOutQuint: [0.23, 1, 0.32, 1],\n    easeInOutQuint: [0.86, 0, 0.07, 1],\n    easeInExpo: [0.95, 0.05, 0.795, 0.035],\n    easeOutExpo: [0.19, 1, 0.22, 1],\n    easeInOutExpo: [1, 0, 0, 1],\n    easeInCirc: [0.6, 0.04, 0.98, 0.335],\n    easeOutCirc: [0.075, 0.82, 0.165, 1],\n    easeInOutCirc: [0.785, 0.135, 0.15, 0.86],\n};\n// Color regex\n// 0 - 199 | 200 - 249 | 250 - 255\nconst REGEX_0_255 = \"(1?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\";\n// 0.0 - 1.9999...\nconst REGEX_0_1 = \"([01](\\\\.\\\\d+)?)\";\n// 00 - FF\nconst REGEX_TWO_HEX_DIGITS = \"([a-f\\\\d]{2})\";\nconst HEX_REGEX = new RegExp(`^#${REGEX_TWO_HEX_DIGITS}${REGEX_TWO_HEX_DIGITS}${REGEX_TWO_HEX_DIGITS}$`, \"i\");\nconst RGB_REGEX = new RegExp(`^rgb\\\\(${REGEX_0_255},${REGEX_0_255},${REGEX_0_255}\\\\)$`, \"i\");\nconst RGBA_REGEX = new RegExp(`^rgba\\\\(${REGEX_0_255},${REGEX_0_255},${REGEX_0_255},${REGEX_0_1}\\\\)$`, \"i\");\nconst SCROLL_OFFSET = 50;\nconst RESIZE_DEBOUNCE_TIMEOUT = 150;\n// CSS transform map\nconst TRANSFORM_MAP = {\n    rotate: (value, unit = DEFAULT_ANGLE_UNIT) => `rotate(${value}${unit})`,\n    rotateX: (value, unit = DEFAULT_ANGLE_UNIT) => `rotateX(${value}${unit})`,\n    rotateY: (value, unit = DEFAULT_ANGLE_UNIT) => `rotateY(${value}${unit})`,\n    rotateZ: (value, unit = DEFAULT_ANGLE_UNIT) => `rotateZ(${value}${unit})`,\n    scale: (value) => `scale(${value})`,\n    scaleX: (value) => `scaleX(${value})`,\n    scaleY: (value) => `scaleY(${value})`,\n    scaleZ: (value) => `scaleZ(${value})`,\n    skew: (value, unit = DEFAULT_UNIT) => `skew(${value}${unit})`,\n    skewX: (value, unit = DEFAULT_UNIT) => `skewX(${value}${unit})`,\n    skewY: (value, unit = DEFAULT_UNIT) => `skewY(${value}${unit})`,\n    skewZ: (value, unit = DEFAULT_UNIT) => `skewZ(${value}${unit})`,\n    translateX: (value, unit = DEFAULT_UNIT) => `translateX(${value}${unit})`,\n    translateY: (value, unit = DEFAULT_UNIT) => `translateY(${value}${unit})`,\n    translateZ: (value, unit = DEFAULT_UNIT) => `translateZ(${value}${unit})`,\n};\n// Order of CSS transforms matters\nconst ORDER_OF_TRANSFORMS = [\n    \"translateX\",\n    \"translateY\",\n    \"translateZ\",\n    \"skew\",\n    \"skewX\",\n    \"skewY\",\n    \"skewZ\",\n    \"rotate\",\n    \"rotateX\",\n    \"rotateY\",\n    \"rotateZ\",\n    \"scale\",\n    \"scaleX\",\n    \"scaleY\",\n    \"scaleZ\",\n];\n// CSS properties that use color values\nconst COLOR_PROPERTIES = [\n    \"backgroundColor\",\n    \"borderBottomColor\",\n    \"borderColor\",\n    \"borderLeftColor\",\n    \"borderRightColor\",\n    \"borderTopColor\",\n    \"color\",\n    \"fill\",\n    \"stroke\",\n];\n// CSS filter map\n// blur()\n// brightness()\n// contrast()\n// grayscale()\n// hue-rotate()\n// invert()\n// opacity() // use opacityFilter\n// saturate()\n// sepia()\n// Not supported\n// drop-shadow()\n// url()\nconst FILTER_MAP = {\n    blur: (value, unit = DEFAULT_UNIT) => `blur(${value}${unit})`,\n    brightness: (value) => `brightness(${value})`,\n    contrast: (value) => `contrast(${value})`,\n    grayscale: (value) => `grayscale(${value})`,\n    hueRotate: (value, unit = DEFAULT_ANGLE_UNIT) => `hue-rotate(${value}${unit})`,\n    invert: (value) => `invert(${value})`,\n    opacityFilter: (value) => `opacity(${value})`,\n    saturate: (value) => `saturate(${value})`,\n    sepia: (value) => `sepia(${value})`,\n};\nconst FILTER_PROPERTIES = [\n    \"blur\",\n    \"brightness\",\n    \"contrast\",\n    \"grayscale\",\n    \"hueRotate\",\n    \"invert\",\n    \"opacityFilter\",\n    \"saturate\",\n    \"sepia\",\n];\n// ------------ Helpers\n// Get element's top offset\nfunction getElementTop(el) {\n    let top = 0;\n    let element = el;\n    do {\n        top += element.offsetTop || 0;\n        element = element.offsetParent;\n    } while (element);\n    return top;\n}\n// Returns CSS unit\nfunction getUnit(property, unit) {\n    let propertyUnit = unit || DEFAULT_UNIT;\n    if (ANGLE_PROPERTIES.indexOf(property) >= 0) {\n        propertyUnit = unit || DEFAULT_ANGLE_UNIT;\n    }\n    return propertyUnit;\n}\n// Takes string value (in px/vh/%) and returns number\nfunction getValueInPx(value, maxScroll) {\n    var _a;\n    const floatValue = parseFloat(value);\n    const unit = ((_a = value.match(START_END_DURATION_REGEX)) === null || _a === void 0 ? void 0 : _a[2]) || null;\n    const vh = window.innerHeight / 100;\n    let valueInPx;\n    switch (unit) {\n        case \"vh\":\n            valueInPx = vh * floatValue;\n            break;\n        case \"%\":\n            valueInPx = (maxScroll * floatValue) / 100;\n            break;\n        default:\n            valueInPx = floatValue;\n    }\n    return valueInPx;\n}\n// Takes start/end/duration props\n// and return number (in pixels) based on prop type (number, string, dom element)\nfunction convertPropToPixels(propName, propValue, maxScroll, offset = 0) {\n    let propValueInPx = propValue;\n    const isElement = propValue instanceof HTMLElement;\n    const keyCodes = {\n        ZERO: 48,\n        NINE: 57,\n    };\n    if (typeof propValue === \"number\") {\n        propValueInPx = propValue;\n    }\n    else if (START_END_DURATION_REGEX.test(propValue)) {\n        propValueInPx = getValueInPx(propValue, maxScroll);\n    }\n    else if (isElement ||\n        (typeof propValue === \"string\" &&\n            (propValue.charCodeAt(0) < keyCodes.ZERO || propValue.charCodeAt(0) > keyCodes.NINE))) {\n        const element = isElement ? propValue : document.querySelector(propValue);\n        if (!element) {\n            console.warn(`Plx, ERROR: ${propName} selector matches no elements: \"${propValue}\"`);\n            return null;\n        }\n        if (propName === \"start\" || propName === \"end\") {\n            // START or END\n            // Element enters the viewport\n            propValueInPx = getElementTop(element) - window.innerHeight;\n        }\n        else if (propName === \"duration\") {\n            // DURATION\n            // Height of the element\n            propValueInPx = element.offsetHeight;\n        }\n    }\n    else {\n        console.warn(`Plx, ERROR: \"${propValue}\" is not a valid ${propName} value, check documentation`);\n        return null;\n    }\n    // Transform offset to px\n    let offsetInPx = 0;\n    if (typeof offset === \"number\") {\n        offsetInPx = offset;\n    }\n    else if (START_END_DURATION_REGEX.test(offset)) {\n        offsetInPx = getValueInPx(offset, maxScroll);\n    }\n    // Add offset\n    propValueInPx += offsetInPx;\n    if (propValueInPx < 0) {\n        propValueInPx = 0;\n    }\n    return propValueInPx;\n}\n// Converts color in hex format into object { r, g, b, a }\nfunction hexToObject(hex) {\n    // Convert #abc to #aabbcc\n    const color = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;\n    const result = HEX_REGEX.exec(color);\n    // Safety check, if color is in the wrong format\n    if (!result) {\n        console.warn(`Plx, ERROR: hex color is not in the right format: \"${hex}\"`);\n        return null;\n    }\n    // All color functions are returning { r, g, b, a } object\n    return {\n        r: parseInt(result[1], 16),\n        g: parseInt(result[2], 16),\n        b: parseInt(result[3], 16),\n        a: 1,\n    };\n}\n// Converts color in rgb format into object { r, g, b, a }\nfunction rgbToObject(rgb) {\n    const isRgba = rgb.toLowerCase().indexOf(\"rgba\") === 0;\n    const color = rgb.replace(/ /g, \"\");\n    const result = isRgba ? RGBA_REGEX.exec(color) : RGB_REGEX.exec(color);\n    // Safety check, if color is in the wrong format\n    if (!result) {\n        console.warn(`Plx, ERROR: rgb or rgba color is not in the right format: \"${rgb}\"`);\n        return null;\n    }\n    // All color functions are returning { r, g, b, a } object\n    return {\n        r: parseInt(result[1], 10),\n        g: parseInt(result[2], 10),\n        b: parseInt(result[3], 10),\n        a: isRgba ? parseFloat(result[4]) : 1,\n    };\n}\n// Calculates the current value for parallax-ing property\nfunction parallax(scrollPosition, start, duration, startValue, endValue, easing) {\n    // Safety check, if \"startValue\" is in the wrong format\n    if (typeof startValue !== \"number\") {\n        console.warn(`Plx, ERROR: startValue is not a number (type: \"${typeof endValue}\", value: \"${endValue}\")`);\n        return 0;\n    }\n    // Safety check, if \"endValue\" is in the wrong format\n    if (typeof endValue !== \"number\") {\n        console.warn(`Plx, ERROR: endValue is not a number (type: \"${typeof endValue}\", value: \"${endValue}\")`);\n        return 0;\n    }\n    // Safety check, if \"duration\" is in the wrong format\n    if (typeof duration !== \"number\" || duration === 0) {\n        console.warn(`Plx, ERROR: duration is zero or not a number (type: \"${typeof duration}\", value: \"${duration}\")`);\n        return 0;\n    }\n    let min = startValue;\n    let max = endValue;\n    const invert = startValue > endValue;\n    if (invert) {\n        min = endValue;\n        max = startValue;\n    }\n    let percentage = (scrollPosition - start) / duration;\n    if (percentage > 1) {\n        percentage = 1;\n    }\n    else if (percentage < 0) {\n        percentage = 0;\n    }\n    // Apply easing\n    if (easing) {\n        if (Array.isArray(easing)) {\n            percentage = BezierEasing(easing[0], easing[1], easing[2], easing[3])(percentage);\n        }\n        else if (typeof easing === \"string\" && EASINGS[easing]) {\n            percentage = BezierEasing(EASINGS[easing][0], EASINGS[easing][1], EASINGS[easing][2], EASINGS[easing][3])(percentage);\n        }\n        else if (typeof easing === \"function\") {\n            percentage = easing(percentage);\n        }\n    }\n    let value = percentage * (max - min);\n    if (invert) {\n        value = max - value;\n    }\n    else {\n        value += min;\n    }\n    // Rounding to 4 decimals (.toFixed(4) returns a string)\n    return Math.floor(value * 10000) / 10000;\n}\n// Calculates current value for color parallax\nfunction colorParallax(scrollPosition, start, duration, startValue, endValue, easing) {\n    let startObject = null;\n    let endObject = null;\n    if (typeof startValue === \"string\") {\n        if (startValue[0].toLowerCase() === \"r\") {\n            startObject = rgbToObject(startValue);\n        }\n        else {\n            startObject = hexToObject(startValue);\n        }\n    }\n    if (typeof endValue === \"string\") {\n        if (endValue[0].toLowerCase() === \"r\") {\n            endObject = rgbToObject(endValue);\n        }\n        else {\n            endObject = hexToObject(endValue);\n        }\n    }\n    if (startObject && endObject) {\n        const r = parallax(scrollPosition, start, duration, startObject.r, endObject.r, easing);\n        const g = parallax(scrollPosition, start, duration, startObject.g, endObject.g, easing);\n        const b = parallax(scrollPosition, start, duration, startObject.b, endObject.b, easing);\n        const a = parallax(scrollPosition, start, duration, startObject.a, endObject.a, easing);\n        return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${a})`;\n    }\n    return \"\";\n}\n// Applies property parallax to the style object\nfunction applyPropertyToStyle(scrollPosition, propertyData, startPosition, duration, style, transforms, filters, easing) {\n    const { startValue, endValue, property, unit } = propertyData;\n    // If property is one of the color properties\n    // Use it's parallax method\n    const isColor = COLOR_PROPERTIES.indexOf(property) > -1;\n    const parallaxMethod = isColor ? colorParallax : parallax;\n    // Get new CSS value\n    const value = parallaxMethod(scrollPosition, startPosition, duration, startValue, endValue, easing);\n    // Get transform function\n    const transformMethod = TRANSFORM_MAP[property];\n    const filterMethod = FILTER_MAP[property];\n    const newStyle = style;\n    if (transformMethod) {\n        // Get CSS unit\n        const propertyUnit = getUnit(property, unit);\n        // Transforms, apply value to transform function\n        transforms[property] = transformMethod(value, propertyUnit);\n    }\n    else if (filterMethod) {\n        // Get CSS unit\n        const propertyUnit = getUnit(property, unit);\n        // Filters, apply value to filter function\n        filters[property] = filterMethod(value, propertyUnit);\n    }\n    else {\n        // All other properties\n        newStyle[property] = value;\n        // Add unit if it is passed\n        if (unit) {\n            newStyle[property] += unit;\n        }\n    }\n}\n// Returns CSS classes based on animation state\nfunction getClasses(lastSegmentScrolledBy, isInSegment, parallaxData) {\n    let cssClasses = \"\";\n    if (lastSegmentScrolledBy === null) {\n        cssClasses = \"Plx--above\";\n    }\n    else if (lastSegmentScrolledBy === parallaxData.length - 1 && !isInSegment) {\n        cssClasses = \"Plx--below\";\n    }\n    else if (lastSegmentScrolledBy !== null && isInSegment) {\n        const segmentName = parallaxData[lastSegmentScrolledBy].name || lastSegmentScrolledBy;\n        cssClasses = `Plx--active Plx--in Plx--in-${segmentName}`;\n    }\n    else if (lastSegmentScrolledBy !== null && !isInSegment) {\n        const segmentName = parallaxData[lastSegmentScrolledBy].name || lastSegmentScrolledBy;\n        const nextSegmentName = parallaxData[lastSegmentScrolledBy + 1].name || lastSegmentScrolledBy + 1;\n        cssClasses = `Plx--active Plx--between Plx--between-${segmentName}-and-${nextSegmentName}`;\n    }\n    return cssClasses;\n}\n// Checks if class contains 'active'\nfunction checkIsActive(classes) {\n    return classes.indexOf(\"Plx--active\") > -1;\n}\n// Main update function\n// Returns new state object based on props and scroll position\nfunction updateDOM(scrollPosition, props, showElement, propsUsedInParallax, plxStyleRef, plxStateClassesRef, elementRef) {\n    const { animateWhenNotInViewport, disabled, freeze, parallaxData, className, onPlxEnd, onPlxStart, style } = props;\n    const plxStyle = plxStyleRef.current;\n    const plxStateClasses = plxStateClassesRef.current;\n    const element = elementRef.current;\n    // Do nothing if animation is disabled, frozen\n    // or if element is not rendered yet\n    if ((freeze && showElement) || !element || disabled) {\n        return;\n    }\n    // Check if element is in viewport\n    // Small offset is added to prevent page jumping\n    if (!animateWhenNotInViewport) {\n        const rect = element.getBoundingClientRect();\n        const isTopAboveBottomEdge = rect.top < window.innerHeight + SCROLL_OFFSET;\n        const isBottomBelowTopEdge = rect.top + rect.height > -SCROLL_OFFSET;\n        if (!isTopAboveBottomEdge || !isBottomBelowTopEdge) {\n            return;\n        }\n    }\n    // Style to be applied to our element\n    let newStyle = {};\n    const transforms = {};\n    const filters = {};\n    const appliedProperties = [];\n    const segments = [];\n    let isInSegment = false;\n    let lastSegmentScrolledBy = null;\n    const bodyHeight = document.documentElement.scrollHeight || document.body.scrollHeight;\n    const maxScroll = bodyHeight - window.innerHeight;\n    for (let i = 0; i < parallaxData.length; i++) {\n        const { duration, easing, endOffset, properties, startOffset } = parallaxData[i];\n        const start = parallaxData[i].start === \"self\" ? element : parallaxData[i].start;\n        const end = parallaxData[i].end === \"self\" ? element : parallaxData[i].end;\n        const startInPx = convertPropToPixels(\"start\", start, maxScroll, startOffset);\n        let durationInPx;\n        let endInPx;\n        // End has higher priority than duration\n        if (typeof end !== \"undefined\") {\n            endInPx = convertPropToPixels(\"end\", end, maxScroll, endOffset);\n            durationInPx = endInPx - startInPx;\n        }\n        else {\n            durationInPx = convertPropToPixels(\"duration\", duration, maxScroll);\n            endInPx = startInPx + durationInPx;\n        }\n        // If segment is below scroll position skip it\n        if (scrollPosition < startInPx) {\n            break;\n        }\n        const isScrolledByStart = scrollPosition >= startInPx;\n        if (isScrolledByStart) {\n            lastSegmentScrolledBy = i;\n        }\n        // If active segment exists, apply his properties\n        if (scrollPosition >= startInPx && scrollPosition <= endInPx) {\n            isInSegment = true;\n            properties.forEach((propertyData) => {\n                const { property } = propertyData;\n                // Save which properties are applied to the active segment\n                // So they are not re-applied for other segments\n                appliedProperties.push(property);\n                // Apply property style\n                applyPropertyToStyle(scrollPosition, propertyData, startInPx, durationInPx, newStyle, transforms, filters, easing);\n            });\n        }\n        else {\n            // Push non active segments above the scroll position to separate array\n            // This way \"durationInPx\" and \"startInPx\" are not calculated again\n            // and segments below scroll position are skipped in the next step\n            segments.push({\n                easing,\n                durationInPx,\n                properties,\n                startInPx,\n            });\n        }\n    }\n    // These are only segments that are completely above scroll position\n    segments.forEach((data) => {\n        const { easing, durationInPx, properties, startInPx } = data;\n        properties.forEach((propertyData) => {\n            const { property } = propertyData;\n            // Skip property that was changed for active segment\n            if (appliedProperties.indexOf(property) > -1) {\n                return;\n            }\n            // These styles that are the ones changed by segments\n            // that are above active segment\n            applyPropertyToStyle(scrollPosition, propertyData, startInPx, durationInPx, newStyle, transforms, filters, easing);\n        });\n    });\n    // Sort transforms by ORDER_OF_TRANSFORMS\n    // as order of CSS transforms matters\n    const transformsOrdered = [];\n    ORDER_OF_TRANSFORMS.forEach((transformKey) => {\n        if (transforms[transformKey]) {\n            transformsOrdered.push(transforms[transformKey]);\n        }\n    });\n    // Concat transforms and add webkit prefix\n    newStyle.transform = transformsOrdered.join(\" \");\n    newStyle.webkitTransform = newStyle.transform;\n    const filtersArray = [];\n    FILTER_PROPERTIES.forEach((filterKey) => {\n        if (filters[filterKey]) {\n            filtersArray.push(filters[filterKey]);\n        }\n    });\n    // Concat filters and add webkit prefix\n    newStyle.filter = filtersArray.join(\" \");\n    newStyle.webkitFilter = newStyle.filter;\n    // \"Stupid\" check if style should be updated\n    if (JSON.stringify(plxStyle) !== JSON.stringify(newStyle)) {\n        // Set styles\n        requestAnimationFrame(() => {\n            // Add user styles\n            for (const property in style) {\n                // @ts-ignore\n                element.style[property] = style[property];\n            }\n            // Add parallax styles\n            propsUsedInParallax.forEach((property) => {\n                // @ts-ignore\n                element.style[property] = typeof newStyle[property] === \"undefined\" ? \"\" : newStyle[property];\n            });\n        });\n        plxStyleRef.current = newStyle;\n    }\n    // Adding state classes\n    const newPlxStateClasses = getClasses(lastSegmentScrolledBy, isInSegment, parallaxData);\n    if (newPlxStateClasses !== plxStateClasses) {\n        const newClassName = `${className} Plx ${newPlxStateClasses}`;\n        if (newClassName !== element.className) {\n            const wasActive = checkIsActive(element.className);\n            const isActive = checkIsActive(newClassName);\n            element.className = newClassName;\n            // Callbacks\n            if (!wasActive && isActive) {\n                onPlxStart === null || onPlxStart === void 0 ? void 0 : onPlxStart();\n            }\n            else if (wasActive && !isActive) {\n                onPlxEnd === null || onPlxEnd === void 0 ? void 0 : onPlxEnd();\n            }\n        }\n        // Cache plx classes\n        plxStateClassesRef.current = newPlxStateClasses;\n    }\n}\nconst Plx = (props) => {\n    const { animateWhenNotInViewport = false, children, className = \"\", disabled = false, freeze = false, parallaxData, style = {}, onPlxStart, onPlxEnd, tagName: ElementTag = \"div\" } = props, elementProps = __rest(props, [\"animateWhenNotInViewport\", \"children\", \"className\", \"disabled\", \"freeze\", \"parallaxData\", \"style\", \"onPlxStart\", \"onPlxEnd\", \"tagName\"]);\n    const scrollManager = useRef();\n    const resizeTimeout = useRef();\n    const element = useRef(null);\n    const plxStyle = useRef({});\n    const plxStyleClasses = useRef(\"\");\n    const [showElement, setShowElement] = useState(false);\n    // Get properties that are used in a parallax effect\n    const propsUsedInParallax = useMemo(() => {\n        const properties = [];\n        parallaxData.forEach((segment) => {\n            segment.properties.forEach(({ property }) => {\n                const transformMethod = TRANSFORM_MAP[property];\n                const filterMethod = FILTER_MAP[property];\n                if (transformMethod) {\n                    if (!properties.includes(\"transform\")) {\n                        properties.push(\"transform\", \"webkitTransform\");\n                    }\n                }\n                else if (filterMethod) {\n                    if (!properties.includes(\"filter\")) {\n                        properties.push(\"filter\", \"webkitFilter\");\n                    }\n                }\n                else {\n                    if (!properties.includes(property)) {\n                        properties.push(property);\n                    }\n                }\n            });\n        });\n        return properties;\n    }, [parallaxData]);\n    // Set will-change property\n    useEffect(() => {\n        if (element.current) {\n            element.current.style.willChange = propsUsedInParallax\n                .map((str) => {\n                return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`).replace(\"webkit\", \"-webkit\");\n            })\n                .join(\",\");\n        }\n    }, [element, propsUsedInParallax]);\n    const update = useCallback((scrollPosition = null) => {\n        const currentScrollPosition = scrollPosition === null ? scrollManager.current.getScrollPosition().scrollPositionY : scrollPosition;\n        updateDOM(currentScrollPosition, props, showElement, propsUsedInParallax, plxStyle, plxStyleClasses, element);\n    }, [props]);\n    // Window resize\n    const handleResize = useCallback(() => {\n        clearTimeout(resizeTimeout.current);\n        resizeTimeout.current = setTimeout(() => {\n            update();\n        }, RESIZE_DEBOUNCE_TIMEOUT);\n    }, [props]);\n    useEffect(() => {\n        if (scrollManager.current) {\n            if (disabled) {\n                // When disabled leave only user styles\n                propsUsedInParallax.forEach((property) => {\n                    if (element.current) {\n                        // @ts-ignore\n                        element.current.style[property] = \"\";\n                    }\n                });\n            }\n            else {\n                update();\n            }\n        }\n    }, [disabled]);\n    // Window scroll\n    const handleScrollChange = useCallback((e) => {\n        update(e.detail.scrollPositionY);\n    }, [props]);\n    useEffect(() => {\n        // Get scroll manager singleton\n        scrollManager.current = new ScrollManager();\n        // Add listeners\n        window.addEventListener(\"window-scroll\", handleScrollChange);\n        window.addEventListener(\"resize\", handleResize);\n        update();\n        setShowElement(true);\n        return () => {\n            clearTimeout(resizeTimeout.current);\n            window.removeEventListener(\"window-scroll\", handleScrollChange);\n            window.removeEventListener(\"resize\", handleResize);\n            scrollManager.current.removeListener();\n        };\n    }, [props]);\n    // Update DOM on props change\n    useEffect(() => {\n        update();\n    }, []);\n    let elementStyle = style;\n    if (!disabled) {\n        elementStyle = Object.assign(Object.assign({}, style), { \n            // Hide element before until it is rendered\n            // This prevents jumps if page is scrolled and then refreshed\n            visibility: showElement ? undefined : \"hidden\" });\n    }\n    return (React.createElement(ElementTag, Object.assign({}, elementProps, { className: `${className} Plx`, style: elementStyle, ref: element }), children));\n};\nexport default Plx;\n","/**\n * https://github.com/gre/bezier-easing\n * BezierEasing - use bezier curve for transition easing function\n * by Gaëtan Renaudeau 2014 - 2015 – MIT License\n */\n\n// These values are established by empiricism with tests (tradeoff: performance VS precision)\nvar NEWTON_ITERATIONS = 4;\nvar NEWTON_MIN_SLOPE = 0.001;\nvar SUBDIVISION_PRECISION = 0.0000001;\nvar SUBDIVISION_MAX_ITERATIONS = 10;\n\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\n\nvar float32ArraySupported = typeof Float32Array === 'function';\n\nfunction A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }\nfunction B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }\nfunction C (aA1)      { return 3.0 * aA1; }\n\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nfunction calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }\n\n// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.\nfunction getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }\n\nfunction binarySubdivide (aX, aA, aB, mX1, mX2) {\n  var currentX, currentT, i = 0;\n  do {\n    currentT = aA + (aB - aA) / 2.0;\n    currentX = calcBezier(currentT, mX1, mX2) - aX;\n    if (currentX > 0.0) {\n      aB = currentT;\n    } else {\n      aA = currentT;\n    }\n  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n  return currentT;\n}\n\nfunction newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {\n for (var i = 0; i < NEWTON_ITERATIONS; ++i) {\n   var currentSlope = getSlope(aGuessT, mX1, mX2);\n   if (currentSlope === 0.0) {\n     return aGuessT;\n   }\n   var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n   aGuessT -= currentX / currentSlope;\n }\n return aGuessT;\n}\n\nfunction LinearEasing (x) {\n  return x;\n}\n\nmodule.exports = function bezier (mX1, mY1, mX2, mY2) {\n  if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {\n    throw new Error('bezier x values must be in [0, 1] range');\n  }\n\n  if (mX1 === mY1 && mX2 === mY2) {\n    return LinearEasing;\n  }\n\n  // Precompute samples table\n  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n  for (var i = 0; i < kSplineTableSize; ++i) {\n    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n  }\n\n  function getTForX (aX) {\n    var intervalStart = 0.0;\n    var currentSample = 1;\n    var lastSample = kSplineTableSize - 1;\n\n    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n      intervalStart += kSampleStepSize;\n    }\n    --currentSample;\n\n    // Interpolate to provide an initial guess for t\n    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n    var guessForT = intervalStart + dist * kSampleStepSize;\n\n    var initialSlope = getSlope(guessForT, mX1, mX2);\n    if (initialSlope >= NEWTON_MIN_SLOPE) {\n      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n    } else if (initialSlope === 0.0) {\n      return guessForT;\n    } else {\n      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n    }\n  }\n\n  return function BezierEasing (x) {\n    // Because JavaScript number are imprecise, we should guarantee the extremes are right.\n    if (x === 0) {\n      return 0;\n    }\n    if (x === 1) {\n      return 1;\n    }\n    return calcBezier(getTForX(x), mY1, mY2);\n  };\n};\n"],"names":["instance","instancesCount","ticking","EVENT_NAME","isWindowDefined","window","supportsPassiveEvents","addEventListener","passive","options","Object","defineProperty","get","noop","removeEventListener","detectPassiveEvents","supportsCustomEvents","CustomEvent","ScrollManager","this","handleScroll","bind","eventListenerOptions","prototype","removeListener","destroy","getScrollPosition","scrollPositionY","scrollY","document","documentElement","scrollTop","scrollPositionX","scrollX","scrollLeft","scrollPosition","event","detail","createEvent","initCustomEvent","dispatchEvent","requestAnimationFrame","module","exports","default","call","__rest","s","e","t","p","hasOwnProperty","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","START_END_DURATION_REGEX","DEFAULT_UNIT","DEFAULT_ANGLE_UNIT","ANGLE_PROPERTIES","EASINGS","ease","easeIn","easeOut","easeInOut","easeInSine","easeOutSine","easeInOutSine","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","REGEX_0_255","REGEX_TWO_HEX_DIGITS","HEX_REGEX","RegExp","RGB_REGEX","RGBA_REGEX","TRANSFORM_MAP","rotate","value","unit","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","skew","skewX","skewY","skewZ","translateX","translateY","translateZ","ORDER_OF_TRANSFORMS","COLOR_PROPERTIES","FILTER_MAP","blur","brightness","contrast","grayscale","hueRotate","invert","opacityFilter","saturate","sepia","FILTER_PROPERTIES","getUnit","property","propertyUnit","getValueInPx","maxScroll","_a","floatValue","parseFloat","match","vh","innerHeight","valueInPx","convertPropToPixels","propName","propValue","offset","propValueInPx","isElement","HTMLElement","keyCodes","test","charCodeAt","console","warn","element","querySelector","el","top","offsetTop","offsetParent","getElementTop","offsetHeight","offsetInPx","hexToObject","hex","color","result","exec","r","parseInt","g","b","a","rgbToObject","rgb","isRgba","toLowerCase","replace","parallax","start","duration","startValue","endValue","easing","min","max","percentage","Array","isArray","Math","floor","colorParallax","startObject","endObject","round","applyPropertyToStyle","propertyData","startPosition","style","transforms","filters","transformMethod","filterMethod","newStyle","checkIsActive","classes","props","animateWhenNotInViewport","children","className","disabled","freeze","parallaxData","onPlxStart","onPlxEnd","tagName","ElementTag","elementProps","scrollManager","useRef","resizeTimeout","plxStyle","plxStyleClasses","showElement","setShowElement","useState","propsUsedInParallax","useMemo","properties","forEach","segment","includes","push","useEffect","current","willChange","map","str","letter","join","update","useCallback","plxStyleRef","plxStateClassesRef","elementRef","plxStateClasses","rect","getBoundingClientRect","isTopAboveBottomEdge","isBottomBelowTopEdge","height","appliedProperties","segments","isInSegment","lastSegmentScrolledBy","scrollHeight","body","endOffset","startOffset","end","startInPx","durationInPx","endInPx","data","transformsOrdered","transformKey","transform","webkitTransform","filtersArray","filterKey","filter","webkitFilter","JSON","stringify","newPlxStateClasses","cssClasses","name","getClasses","newClassName","wasActive","isActive","updateDOM","handleResize","clearTimeout","setTimeout","handleScrollChange","elementStyle","assign","visibility","undefined","ref","kSampleStepSize","float32ArraySupported","Float32Array","A","aA1","aA2","B","C","calcBezier","aT","getSlope","LinearEasing","x","mX1","mY1","mX2","mY2","Error","sampleValues","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","abs","binarySubdivide"],"sourceRoot":""}