{"version":3,"file":"997.js","mappings":"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","sources":["webpack://silverstripe-base/./node_modules/@motionone/easing/dist/cubic-bezier.es.js","webpack://silverstripe-base/./node_modules/@motionone/easing/dist/steps.es.js","webpack://silverstripe-base/./node_modules/@motionone/animation/dist/utils/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/gestures/in-view.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/utils/resolve-elements.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/utils/stagger.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/clamp.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-cubic-bezier.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-function.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-number.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/noop.es.js","webpack://silverstripe-base/./node_modules/selector-set/selector-set.next.js","webpack://silverstripe-base/./node_modules/delegated-events/dist/index.js","webpack://silverstripe-base/./node_modules/jump.js/dist/jump.module.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/defaults.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/time.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/stop-animation.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/controls.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-easing-generator.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-easing-list.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/mix.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/progress.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/offset.es.js","webpack://silverstripe-base/./node_modules/@motionone/animation/dist/Animation.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/interpolate.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/wrap.es.js","webpack://silverstripe-base/./node_modules/@motionone/types/dist/MotionValue.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/data.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/transforms.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/css-var.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/feature-detection.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/easing.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/get-style-name.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/style.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/animate-style.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/array.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/keyframes.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/get-unit.es.js","webpack://silverstripe-base/./node_modules/@motionone/utils/dist/is-string.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/utils/options.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/index.es.js","webpack://silverstripe-base/./node_modules/@motionone/dom/dist/animate/create-animate.es.js","webpack://silverstripe-base/./node_modules/motion/dist/animate.es.js","webpack://silverstripe-base/./node_modules/validate.js/validate.js","webpack://silverstripe-base/./node_modules/wretch/dist/addons/queryString.js","webpack://silverstripe-base/./node_modules/wretch/dist/constants.js","webpack://silverstripe-base/./node_modules/wretch/dist/utils.js","webpack://silverstripe-base/./node_modules/wretch/dist/config.js","webpack://silverstripe-base/./node_modules/wretch/dist/resolver.js","webpack://silverstripe-base/./node_modules/wretch/dist/middleware.js","webpack://silverstripe-base/./node_modules/wretch/dist/core.js","webpack://silverstripe-base/./node_modules/wretch/dist/index.js"],"sourcesContent":["import { noopReturn } from '@motionone/utils';\n\n/*\n  Bezier function generator\n\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) * t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noopReturn;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { clamp } from '@motionone/utils';\n\nconst steps = (steps, direction = \"end\") => (progress) => {\n    progress =\n        direction === \"end\"\n            ? Math.min(progress, 0.999)\n            : Math.max(progress, 0.001);\n    const expanded = progress * steps;\n    const rounded = direction === \"end\" ? Math.floor(expanded) : Math.ceil(expanded);\n    return clamp(0, 1, rounded / steps);\n};\n\nexport { steps };\n","import { cubicBezier, steps } from '@motionone/easing';\nimport { isFunction, isCubicBezier, noopReturn } from '@motionone/utils';\n\nconst namedEasings = {\n    ease: cubicBezier(0.25, 0.1, 0.25, 1.0),\n    \"ease-in\": cubicBezier(0.42, 0.0, 1.0, 1.0),\n    \"ease-in-out\": cubicBezier(0.42, 0.0, 0.58, 1.0),\n    \"ease-out\": cubicBezier(0.0, 0.0, 0.58, 1.0),\n};\nconst functionArgsRegex = /\\((.*?)\\)/;\nfunction getEasingFunction(definition) {\n    // If already an easing function, return\n    if (isFunction(definition))\n        return definition;\n    // If an easing curve definition, return bezier function\n    if (isCubicBezier(definition))\n        return cubicBezier(...definition);\n    // If we have a predefined easing function, return\n    const namedEasing = namedEasings[definition];\n    if (namedEasing)\n        return namedEasing;\n    // If this is a steps function, attempt to create easing curve\n    if (definition.startsWith(\"steps\")) {\n        const args = functionArgsRegex.exec(definition);\n        if (args) {\n            const argsArray = args[1].split(\",\");\n            return steps(parseFloat(argsArray[0]), argsArray[1].trim());\n        }\n    }\n    return noopReturn;\n}\n\nexport { getEasingFunction };\n","import { resolveElements } from '../utils/resolve-elements.es.js';\nimport { isFunction } from '@motionone/utils';\n\nconst thresholds = {\n    any: 0,\n    all: 1,\n};\nfunction inView(elementOrSelector, onStart, { root, margin: rootMargin, amount = \"any\" } = {}) {\n    /**\n     * If this browser doesn't support IntersectionObserver, return a dummy stop function.\n     * Default triggering of onStart is tricky - it could be used for starting/stopping\n     * videos, lazy loading content etc. We could provide an option to enable a fallback, or\n     * provide a fallback callback option.\n     */\n    if (typeof IntersectionObserver === \"undefined\") {\n        return () => { };\n    }\n    const elements = resolveElements(elementOrSelector);\n    const activeIntersections = new WeakMap();\n    const onIntersectionChange = (entries) => {\n        entries.forEach((entry) => {\n            const onEnd = activeIntersections.get(entry.target);\n            /**\n             * If there's no change to the intersection, we don't need to\n             * do anything here.\n             */\n            if (entry.isIntersecting === Boolean(onEnd))\n                return;\n            if (entry.isIntersecting) {\n                const newOnEnd = onStart(entry);\n                if (isFunction(newOnEnd)) {\n                    activeIntersections.set(entry.target, newOnEnd);\n                }\n                else {\n                    observer.unobserve(entry.target);\n                }\n            }\n            else if (onEnd) {\n                onEnd(entry);\n                activeIntersections.delete(entry.target);\n            }\n        });\n    };\n    const observer = new IntersectionObserver(onIntersectionChange, {\n        root,\n        rootMargin,\n        threshold: typeof amount === \"number\" ? amount : thresholds[amount],\n    });\n    elements.forEach((element) => observer.observe(element));\n    return () => observer.disconnect();\n}\n\nexport { inView };\n","function resolveElements(elements, selectorCache) {\n    var _a;\n    if (typeof elements === \"string\") {\n        if (selectorCache) {\n            (_a = selectorCache[elements]) !== null && _a !== void 0 ? _a : (selectorCache[elements] = document.querySelectorAll(elements));\n            elements = selectorCache[elements];\n        }\n        else {\n            elements = document.querySelectorAll(elements);\n        }\n    }\n    else if (elements instanceof Element) {\n        elements = [elements];\n    }\n    /**\n     * Return an empty array\n     */\n    return Array.from(elements || []);\n}\n\nexport { resolveElements };\n","import { isNumber, isFunction } from '@motionone/utils';\nimport { getEasingFunction } from '@motionone/animation';\n\nfunction stagger(duration = 0.1, { start = 0, from = 0, easing } = {}) {\n    return (i, total) => {\n        const fromIndex = isNumber(from) ? from : getFromIndex(from, total);\n        const distance = Math.abs(fromIndex - i);\n        let delay = duration * distance;\n        if (easing) {\n            const maxDelay = total * duration;\n            const easingFunction = getEasingFunction(easing);\n            delay = easingFunction(delay / maxDelay) * maxDelay;\n        }\n        return start + delay;\n    };\n}\nfunction getFromIndex(from, total) {\n    if (from === \"first\") {\n        return 0;\n    }\n    else {\n        const lastIndex = total - 1;\n        return from === \"last\" ? lastIndex : lastIndex / 2;\n    }\n}\nfunction resolveOption(option, i, total) {\n    return isFunction(option) ? option(i, total) : option;\n}\n\nexport { getFromIndex, resolveOption, stagger };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","import { isNumber } from './is-number.es.js';\n\nconst isCubicBezier = (easing) => Array.isArray(easing) && isNumber(easing[0]);\n\nexport { isCubicBezier };\n","const isFunction = (value) => typeof value === \"function\";\n\nexport { isFunction };\n","const isNumber = (value) => typeof value === \"number\";\n\nexport { isNumber };\n","const noop = () => { };\nconst noopReturn = (v) => v;\n\nexport { noop, noopReturn };\n","// Public: Create a new SelectorSet.\nexport default function SelectorSet() {\n  // Construct new SelectorSet if called as a function.\n  if (!(this instanceof SelectorSet)) {\n    return new SelectorSet();\n  }\n\n  // Public: Number of selectors added to the set\n  this.size = 0;\n\n  // Internal: Incrementing ID counter\n  this.uid = 0;\n\n  // Internal: Array of String selectors in the set\n  this.selectors = [];\n\n  // Internal: Map of selector ids to objects\n  this.selectorObjects = {};\n\n  // Internal: All Object index String names mapping to Index objects.\n  this.indexes = Object.create(this.indexes);\n\n  // Internal: Used Object index String names mapping to Index objects.\n  this.activeIndexes = [];\n}\n\n// Detect prefixed Element#matches function.\nvar docElem = window.document.documentElement;\nvar matches =\n  docElem.matches ||\n  docElem.webkitMatchesSelector ||\n  docElem.mozMatchesSelector ||\n  docElem.oMatchesSelector ||\n  docElem.msMatchesSelector;\n\n// Public: Check if element matches selector.\n//\n// Maybe overridden with custom Element.matches function.\n//\n// el       - An Element\n// selector - String CSS selector\n//\n// Returns true or false.\nSelectorSet.prototype.matchesSelector = function(el, selector) {\n  return matches.call(el, selector);\n};\n\n// Public: Find all elements in the context that match the selector.\n//\n// Maybe overridden with custom querySelectorAll function.\n//\n// selectors - String CSS selectors.\n// context   - Element context\n//\n// Returns non-live list of Elements.\nSelectorSet.prototype.querySelectorAll = function(selectors, context) {\n  return context.querySelectorAll(selectors);\n};\n\n// Public: Array of indexes.\n//\n// name     - Unique String name\n// selector - Function that takes a String selector and returns a String key\n//            or undefined if it can't be used by the index.\n// element  - Function that takes an Element and returns an Array of String\n//            keys that point to indexed values.\n//\nSelectorSet.prototype.indexes = [];\n\n// Index by element id\nvar idRe = /^#((?:[\\w\\u00c0-\\uFFFF\\-]|\\\\.)+)/g;\nSelectorSet.prototype.indexes.push({\n  name: 'ID',\n  selector: function matchIdSelector(sel) {\n    var m;\n    if ((m = sel.match(idRe))) {\n      return m[0].slice(1);\n    }\n  },\n  element: function getElementId(el) {\n    if (el.id) {\n      return [el.id];\n    }\n  }\n});\n\n// Index by all of its class names\nvar classRe = /^\\.((?:[\\w\\u00c0-\\uFFFF\\-]|\\\\.)+)/g;\nSelectorSet.prototype.indexes.push({\n  name: 'CLASS',\n  selector: function matchClassSelector(sel) {\n    var m;\n    if ((m = sel.match(classRe))) {\n      return m[0].slice(1);\n    }\n  },\n  element: function getElementClassNames(el) {\n    var className = el.className;\n    if (className) {\n      if (typeof className === 'string') {\n        return className.split(/\\s/);\n      } else if (typeof className === 'object' && 'baseVal' in className) {\n        // className is a SVGAnimatedString\n        // global SVGAnimatedString is not an exposed global in Opera 12\n        return className.baseVal.split(/\\s/);\n      }\n    }\n  }\n});\n\n// Index by tag/node name: `DIV`, `FORM`, `A`\nvar tagRe = /^((?:[\\w\\u00c0-\\uFFFF\\-]|\\\\.)+)/g;\nSelectorSet.prototype.indexes.push({\n  name: 'TAG',\n  selector: function matchTagSelector(sel) {\n    var m;\n    if ((m = sel.match(tagRe))) {\n      return m[0].toUpperCase();\n    }\n  },\n  element: function getElementTagName(el) {\n    return [el.nodeName.toUpperCase()];\n  }\n});\n\n// Default index just contains a single array of elements.\nSelectorSet.prototype.indexes['default'] = {\n  name: 'UNIVERSAL',\n  selector: function() {\n    return true;\n  },\n  element: function() {\n    return [true];\n  }\n};\n\n// Use ES Maps when supported\nvar Map;\nif (typeof window.Map === 'function') {\n  Map = window.Map;\n} else {\n  Map = (function() {\n    function Map() {\n      this.map = {};\n    }\n    Map.prototype.get = function(key) {\n      return this.map[key + ' '];\n    };\n    Map.prototype.set = function(key, value) {\n      this.map[key + ' '] = value;\n    };\n    return Map;\n  })();\n}\n\n// Regexps adopted from Sizzle\n//   https://github.com/jquery/sizzle/blob/1.7/sizzle.js\n//\nvar chunker = /((?:\\((?:\\([^()]+\\)|[^()]+)+\\)|\\[(?:\\[[^\\[\\]]*\\]|['\"][^'\"]*['\"]|[^\\[\\]'\"]+)+\\]|\\\\.|[^ >+~,(\\[\\\\]+)+|[>+~])(\\s*,\\s*)?((?:.|\\r|\\n)*)/g;\n\n// Internal: Get indexes for selector.\n//\n// selector - String CSS selector\n//\n// Returns Array of {index, key}.\nfunction parseSelectorIndexes(allIndexes, selector) {\n  allIndexes = allIndexes.slice(0).concat(allIndexes['default']);\n\n  var allIndexesLen = allIndexes.length,\n    i,\n    j,\n    m,\n    dup,\n    rest = selector,\n    key,\n    index,\n    indexes = [];\n\n  do {\n    chunker.exec('');\n    if ((m = chunker.exec(rest))) {\n      rest = m[3];\n      if (m[2] || !rest) {\n        for (i = 0; i < allIndexesLen; i++) {\n          index = allIndexes[i];\n          if ((key = index.selector(m[1]))) {\n            j = indexes.length;\n            dup = false;\n            while (j--) {\n              if (indexes[j].index === index && indexes[j].key === key) {\n                dup = true;\n                break;\n              }\n            }\n            if (!dup) {\n              indexes.push({ index: index, key: key });\n            }\n            break;\n          }\n        }\n      }\n    }\n  } while (m);\n\n  return indexes;\n}\n\n// Internal: Find first item in Array that is a prototype of `proto`.\n//\n// ary   - Array of objects\n// proto - Prototype of expected item in `ary`\n//\n// Returns object from `ary` if found. Otherwise returns undefined.\nfunction findByPrototype(ary, proto) {\n  var i, len, item;\n  for (i = 0, len = ary.length; i < len; i++) {\n    item = ary[i];\n    if (proto.isPrototypeOf(item)) {\n      return item;\n    }\n  }\n}\n\n// Public: Log when added selector falls under the default index.\n//\n// This API should not be considered stable. May change between\n// minor versions.\n//\n// obj - {selector, data} Object\n//\n//   SelectorSet.prototype.logDefaultIndexUsed = function(obj) {\n//     console.warn(obj.selector, \"could not be indexed\");\n//   };\n//\n// Returns nothing.\nSelectorSet.prototype.logDefaultIndexUsed = function() {};\n\n// Public: Add selector to set.\n//\n// selector - String CSS selector\n// data     - Optional data Object (default: undefined)\n//\n// Returns nothing.\nSelectorSet.prototype.add = function(selector, data) {\n  var obj,\n    i,\n    indexProto,\n    key,\n    index,\n    objs,\n    selectorIndexes,\n    selectorIndex,\n    indexes = this.activeIndexes,\n    selectors = this.selectors,\n    selectorObjects = this.selectorObjects;\n\n  if (typeof selector !== 'string') {\n    return;\n  }\n\n  obj = {\n    id: this.uid++,\n    selector: selector,\n    data: data\n  };\n  selectorObjects[obj.id] = obj;\n\n  selectorIndexes = parseSelectorIndexes(this.indexes, selector);\n  for (i = 0; i < selectorIndexes.length; i++) {\n    selectorIndex = selectorIndexes[i];\n    key = selectorIndex.key;\n    indexProto = selectorIndex.index;\n\n    index = findByPrototype(indexes, indexProto);\n    if (!index) {\n      index = Object.create(indexProto);\n      index.map = new Map();\n      indexes.push(index);\n    }\n\n    if (indexProto === this.indexes['default']) {\n      this.logDefaultIndexUsed(obj);\n    }\n    objs = index.map.get(key);\n    if (!objs) {\n      objs = [];\n      index.map.set(key, objs);\n    }\n    objs.push(obj);\n  }\n\n  this.size++;\n  selectors.push(selector);\n};\n\n// Public: Remove selector from set.\n//\n// selector - String CSS selector\n// data     - Optional data Object (default: undefined)\n//\n// Returns nothing.\nSelectorSet.prototype.remove = function(selector, data) {\n  if (typeof selector !== 'string') {\n    return;\n  }\n\n  var selectorIndexes,\n    selectorIndex,\n    i,\n    j,\n    k,\n    selIndex,\n    objs,\n    obj,\n    indexes = this.activeIndexes,\n    selectors = (this.selectors = []),\n    selectorObjects = this.selectorObjects,\n    removedIds = {},\n    removeAll = arguments.length === 1;\n\n  selectorIndexes = parseSelectorIndexes(this.indexes, selector);\n  for (i = 0; i < selectorIndexes.length; i++) {\n    selectorIndex = selectorIndexes[i];\n\n    j = indexes.length;\n    while (j--) {\n      selIndex = indexes[j];\n      if (selectorIndex.index.isPrototypeOf(selIndex)) {\n        objs = selIndex.map.get(selectorIndex.key);\n        if (objs) {\n          k = objs.length;\n          while (k--) {\n            obj = objs[k];\n            if (obj.selector === selector && (removeAll || obj.data === data)) {\n              objs.splice(k, 1);\n              removedIds[obj.id] = true;\n            }\n          }\n        }\n        break;\n      }\n    }\n  }\n\n  for (i in removedIds) {\n    delete selectorObjects[i];\n    this.size--;\n  }\n\n  for (i in selectorObjects) {\n    selectors.push(selectorObjects[i].selector);\n  }\n};\n\n// Sort by id property handler.\n//\n// a - Selector obj.\n// b - Selector obj.\n//\n// Returns Number.\nfunction sortById(a, b) {\n  return a.id - b.id;\n}\n\n// Public: Find all matching decendants of the context element.\n//\n// context - An Element\n//\n// Returns Array of {selector, data, elements} matches.\nSelectorSet.prototype.queryAll = function(context) {\n  if (!this.selectors.length) {\n    return [];\n  }\n\n  var matches = {},\n    results = [];\n  var els = this.querySelectorAll(this.selectors.join(', '), context);\n\n  var i, j, len, len2, el, m, match, obj;\n  for (i = 0, len = els.length; i < len; i++) {\n    el = els[i];\n    m = this.matches(el);\n    for (j = 0, len2 = m.length; j < len2; j++) {\n      obj = m[j];\n      if (!matches[obj.id]) {\n        match = {\n          id: obj.id,\n          selector: obj.selector,\n          data: obj.data,\n          elements: []\n        };\n        matches[obj.id] = match;\n        results.push(match);\n      } else {\n        match = matches[obj.id];\n      }\n      match.elements.push(el);\n    }\n  }\n\n  return results.sort(sortById);\n};\n\n// Public: Match element against all selectors in set.\n//\n// el - An Element\n//\n// Returns Array of {selector, data} matches.\nSelectorSet.prototype.matches = function(el) {\n  if (!el) {\n    return [];\n  }\n\n  var i, j, k, len, len2, len3, index, keys, objs, obj, id;\n  var indexes = this.activeIndexes,\n    matchedIds = {},\n    matches = [];\n\n  for (i = 0, len = indexes.length; i < len; i++) {\n    index = indexes[i];\n    keys = index.element(el);\n    if (keys) {\n      for (j = 0, len2 = keys.length; j < len2; j++) {\n        if ((objs = index.map.get(keys[j]))) {\n          for (k = 0, len3 = objs.length; k < len3; k++) {\n            obj = objs[k];\n            id = obj.id;\n            if (!matchedIds[id] && this.matchesSelector(el, obj.selector)) {\n              matchedIds[id] = true;\n              matches.push(obj);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return matches.sort(sortById);\n};\n","import SelectorSet from 'selector-set';\n\nvar bubbleEvents = {};\nvar captureEvents = {};\nvar propagationStopped = new WeakMap();\nvar immediatePropagationStopped = new WeakMap();\nvar currentTargets = new WeakMap();\nvar currentTargetDesc = Object.getOwnPropertyDescriptor(Event.prototype, 'currentTarget');\n\nfunction before(subject, verb, fn) {\n  var source = subject[verb];\n\n  subject[verb] = function () {\n    fn.apply(subject, arguments);\n    return source.apply(subject, arguments);\n  };\n\n  return subject;\n}\n\nfunction matches(selectors, target, reverse) {\n  var queue = [];\n  var node = target;\n\n  do {\n    if (node.nodeType !== 1) break;\n\n    var _matches = selectors.matches(node);\n\n    if (_matches.length) {\n      var matched = {\n        node: node,\n        observers: _matches\n      };\n\n      if (reverse) {\n        queue.unshift(matched);\n      } else {\n        queue.push(matched);\n      }\n    }\n  } while (node = node.parentElement);\n\n  return queue;\n}\n\nfunction trackPropagation() {\n  propagationStopped.set(this, true);\n}\n\nfunction trackImmediate() {\n  propagationStopped.set(this, true);\n  immediatePropagationStopped.set(this, true);\n}\n\nfunction getCurrentTarget() {\n  return currentTargets.get(this) || null;\n}\n\nfunction defineCurrentTarget(event, getter) {\n  if (!currentTargetDesc) return;\n  Object.defineProperty(event, 'currentTarget', {\n    configurable: true,\n    enumerable: true,\n    get: getter || currentTargetDesc.get\n  });\n}\n\nfunction canDispatch(event) {\n  try {\n    event.eventPhase;\n    return true;\n  } catch (_) {\n    return false;\n  }\n}\n\nfunction dispatch(event) {\n  if (!canDispatch(event)) return;\n  var events = event.eventPhase === 1 ? captureEvents : bubbleEvents;\n  var selectors = events[event.type];\n  if (!selectors) return;\n  var queue = matches(selectors, event.target, event.eventPhase === 1);\n  if (!queue.length) return;\n  before(event, 'stopPropagation', trackPropagation);\n  before(event, 'stopImmediatePropagation', trackImmediate);\n  defineCurrentTarget(event, getCurrentTarget);\n\n  for (var i = 0, len1 = queue.length; i < len1; i++) {\n    if (propagationStopped.get(event)) break;\n    var matched = queue[i];\n    currentTargets.set(event, matched.node);\n\n    for (var j = 0, len2 = matched.observers.length; j < len2; j++) {\n      if (immediatePropagationStopped.get(event)) break;\n      matched.observers[j].data.call(matched.node, event);\n    }\n  }\n\n  currentTargets[\"delete\"](event);\n  defineCurrentTarget(event);\n}\n\nfunction on(name, selector, fn) {\n  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  var capture = options.capture ? true : false;\n  var events = capture ? captureEvents : bubbleEvents;\n  var selectors = events[name];\n\n  if (!selectors) {\n    selectors = new SelectorSet();\n    events[name] = selectors;\n    document.addEventListener(name, dispatch, capture);\n  }\n\n  selectors.add(selector, fn);\n}\nfunction off(name, selector, fn) {\n  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  var capture = options.capture ? true : false;\n  var events = capture ? captureEvents : bubbleEvents;\n  var selectors = events[name];\n  if (!selectors) return;\n  selectors.remove(selector, fn);\n  if (selectors.size) return;\n  delete events[name];\n  document.removeEventListener(name, dispatch, capture);\n}\nfunction fire(target, name, detail) {\n  return target.dispatchEvent(new CustomEvent(name, {\n    bubbles: true,\n    cancelable: true,\n    detail: detail\n  }));\n}\n\nexport { fire, off, on };\n","// Robert Penner's easeInOutQuad\n\n// find the rest of his easing functions here: http://robertpenner.com/easing/\n// find them exported for ES6 consumption here: https://github.com/jaxgeller/ez.js\n\nvar easeInOutQuad = function easeInOutQuad(t, b, c, d) {\n  t /= d / 2;\n  if (t < 1) return c / 2 * t * t + b;\n  t--;\n  return -c / 2 * (t * (t - 2) - 1) + b;\n};\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar jumper = function jumper() {\n  // private variable cache\n  // no variables are created during a jump, preventing memory leaks\n\n  var element = void 0; // element to scroll to                   (node)\n\n  var start = void 0; // where scroll starts                    (px)\n  var stop = void 0; // where scroll stops                     (px)\n\n  var offset = void 0; // adjustment from the stop position      (px)\n  var easing = void 0; // easing function                        (function)\n  var a11y = void 0; // accessibility support flag             (boolean)\n\n  var distance = void 0; // distance of scroll                     (px)\n  var duration = void 0; // scroll duration                        (ms)\n\n  var timeStart = void 0; // time scroll started                    (ms)\n  var timeElapsed = void 0; // time spent scrolling thus far          (ms)\n\n  var next = void 0; // next scroll position                   (px)\n\n  var callback = void 0; // to call when done scrolling            (function)\n\n  // scroll position helper\n\n  function location() {\n    return window.scrollY || window.pageYOffset;\n  }\n\n  // element offset helper\n\n  function top(element) {\n    return element.getBoundingClientRect().top + start;\n  }\n\n  // rAF loop helper\n\n  function loop(timeCurrent) {\n    // store time scroll started, if not started already\n    if (!timeStart) {\n      timeStart = timeCurrent;\n    }\n\n    // determine time spent scrolling so far\n    timeElapsed = timeCurrent - timeStart;\n\n    // calculate next scroll position\n    next = easing(timeElapsed, start, distance, duration);\n\n    // scroll to it\n    window.scrollTo(0, next);\n\n    // check progress\n    timeElapsed < duration ? window.requestAnimationFrame(loop) // continue scroll loop\n    : done(); // scrolling is done\n  }\n\n  // scroll finished helper\n\n  function done() {\n    // account for rAF time rounding inaccuracies\n    window.scrollTo(0, start + distance);\n\n    // if scrolling to an element, and accessibility is enabled\n    if (element && a11y) {\n      // add tabindex indicating programmatic focus\n      element.setAttribute('tabindex', '-1');\n\n      // focus the element\n      element.focus();\n    }\n\n    // if it exists, fire the callback\n    if (typeof callback === 'function') {\n      callback();\n    }\n\n    // reset time for next jump\n    timeStart = false;\n  }\n\n  // API\n\n  function jump(target) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    // resolve options, or use defaults\n    duration = options.duration || 1000;\n    offset = options.offset || 0;\n    callback = options.callback; // \"undefined\" is a suitable default, and won't be called\n    easing = options.easing || easeInOutQuad;\n    a11y = options.a11y || false;\n\n    // cache starting position\n    start = location();\n\n    // resolve target\n    switch (typeof target === 'undefined' ? 'undefined' : _typeof(target)) {\n      // scroll from current position\n      case 'number':\n        element = undefined; // no element to scroll to\n        a11y = false; // make sure accessibility is off\n        stop = start + target;\n        break;\n\n      // scroll to element (node)\n      // bounding rect is relative to the viewport\n      case 'object':\n        element = target;\n        stop = top(element);\n        break;\n\n      // scroll to element (selector)\n      // bounding rect is relative to the viewport\n      case 'string':\n        element = document.querySelector(target);\n        stop = top(element);\n        break;\n    }\n\n    // resolve scroll distance, accounting for offset\n    distance = stop - start + offset;\n\n    // resolve duration\n    switch (_typeof(options.duration)) {\n      // number in ms\n      case 'number':\n        duration = options.duration;\n        break;\n\n      // function passed the distance of the scroll\n      case 'function':\n        duration = options.duration(distance);\n        break;\n    }\n\n    // start the loop\n    window.requestAnimationFrame(loop);\n  }\n\n  // expose only the jump method\n  return jump;\n};\n\n// export singleton\n\nvar singleton = jumper();\n\nexport default singleton;\n","const defaults = {\n    duration: 0.3,\n    delay: 0,\n    endDelay: 0,\n    repeat: 0,\n    easing: \"ease\",\n};\n\nexport { defaults };\n","const time = {\n    ms: (seconds) => seconds * 1000,\n    s: (milliseconds) => milliseconds / 1000,\n};\n\nexport { time };\n","function stopAnimation(animation, needsCommit = true) {\n    if (!animation || animation.playState === \"finished\")\n        return;\n    // Suppress error thrown by WAAPI\n    try {\n        if (animation.stop) {\n            animation.stop();\n        }\n        else {\n            needsCommit && animation.commitStyles();\n            animation.cancel();\n        }\n    }\n    catch (e) { }\n}\n\nexport { stopAnimation };\n","import { defaults, noop, time } from '@motionone/utils';\nimport { stopAnimation } from './stop-animation.es.js';\n\nconst createAnimation = (factory) => factory();\nconst withControls = (animationFactory, options, duration = defaults.duration) => {\n    return new Proxy({\n        animations: animationFactory.map(createAnimation).filter(Boolean),\n        duration,\n        options,\n    }, controls);\n};\n/**\n * TODO:\n * Currently this returns the first animation, ideally it would return\n * the first active animation.\n */\nconst getActiveAnimation = (state) => state.animations[0];\nconst controls = {\n    get: (target, key) => {\n        const activeAnimation = getActiveAnimation(target);\n        switch (key) {\n            case \"duration\":\n                return target.duration;\n            case \"currentTime\":\n                return time.s((activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) || 0);\n            case \"playbackRate\":\n            case \"playState\":\n                return activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key];\n            case \"finished\":\n                if (!target.finished) {\n                    target.finished = Promise.all(target.animations.map(selectFinished)).catch(noop);\n                }\n                return target.finished;\n            case \"stop\":\n                return () => {\n                    target.animations.forEach((animation) => stopAnimation(animation));\n                };\n            case \"forEachNative\":\n                /**\n                 * This is for internal use only, fire a callback for each\n                 * underlying animation.\n                 */\n                return (callback) => {\n                    target.animations.forEach((animation) => callback(animation, target));\n                };\n            default:\n                return typeof (activeAnimation === null || activeAnimation === void 0 ? void 0 : activeAnimation[key]) ===\n                    \"undefined\"\n                    ? undefined\n                    : () => target.animations.forEach((animation) => animation[key]());\n        }\n    },\n    set: (target, key, value) => {\n        switch (key) {\n            case \"currentTime\":\n                value = time.ms(value);\n            // Fall-through\n            case \"playbackRate\":\n                for (let i = 0; i < target.animations.length; i++) {\n                    target.animations[i][key] = value;\n                }\n                return true;\n        }\n        return false;\n    },\n};\nconst selectFinished = (animation) => animation.finished;\n\nexport { controls, withControls };\n","const isEasingGenerator = (easing) => typeof easing === \"object\" &&\n    Boolean(easing.createAnimation);\n\nexport { isEasingGenerator };\n","import { isNumber } from './is-number.es.js';\n\nconst isEasingList = (easing) => Array.isArray(easing) && !isNumber(easing[0]);\n\nexport { isEasingList };\n","const mix = (min, max, progress) => -progress * min + progress * max + min;\n\nexport { mix };\n","const progress = (min, max, value) => max - min === 0 ? 1 : (value - min) / (max - min);\n\nexport { progress };\n","import { mix } from './mix.es.js';\nimport { progress } from './progress.es.js';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mix(min, 1, offsetProgress));\n    }\n}\nfunction defaultOffset(length) {\n    const offset = [0];\n    fillOffset(offset, length - 1);\n    return offset;\n}\n\nexport { defaultOffset, fillOffset };\n","import { noopReturn, defaults, isEasingGenerator, isEasingList, interpolate } from '@motionone/utils';\nimport { getEasingFunction } from './utils/easing.es.js';\n\nclass Animation {\n    constructor(output, keyframes = [0, 1], { easing, duration: initialDuration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = \"normal\", autoplay = true, } = {}) {\n        this.startTime = null;\n        this.rate = 1;\n        this.t = 0;\n        this.cancelTimestamp = null;\n        this.easing = noopReturn;\n        this.duration = 0;\n        this.totalDuration = 0;\n        this.repeat = 0;\n        this.playState = \"idle\";\n        this.finished = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n        easing = easing || defaults.easing;\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            initialDuration = custom.duration || initialDuration;\n        }\n        this.repeat = repeat;\n        this.easing = isEasingList(easing) ? noopReturn : getEasingFunction(easing);\n        this.updateDuration(initialDuration);\n        const interpolate$1 = interpolate(keyframes, offset, isEasingList(easing) ? easing.map(getEasingFunction) : noopReturn);\n        this.tick = (timestamp) => {\n            var _a;\n            // TODO: Temporary fix for OptionsResolver typing\n            delay = delay;\n            let t = 0;\n            if (this.pauseTime !== undefined) {\n                t = this.pauseTime;\n            }\n            else {\n                t = (timestamp - this.startTime) * this.rate;\n            }\n            this.t = t;\n            // Convert to seconds\n            t /= 1000;\n            // Rebase on delay\n            t = Math.max(t - delay, 0);\n            /**\n             * If this animation has finished, set the current time\n             * to the total duration.\n             */\n            if (this.playState === \"finished\" && this.pauseTime === undefined) {\n                t = this.totalDuration;\n            }\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = t / this.duration;\n            // TODO progress += iterationStart\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            iterationProgress === 1 && currentIteration--;\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const iterationIsOdd = currentIteration % 2;\n            if (direction === \"reverse\" ||\n                (direction === \"alternate\" && iterationIsOdd) ||\n                (direction === \"alternate-reverse\" && !iterationIsOdd)) {\n                iterationProgress = 1 - iterationProgress;\n            }\n            const p = t >= this.totalDuration ? 1 : Math.min(iterationProgress, 1);\n            const latest = interpolate$1(this.easing(p));\n            output(latest);\n            const isAnimationFinished = this.pauseTime === undefined &&\n                (this.playState === \"finished\" || t >= this.totalDuration + endDelay);\n            if (isAnimationFinished) {\n                this.playState = \"finished\";\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, latest);\n            }\n            else if (this.playState !== \"idle\") {\n                this.frameRequestId = requestAnimationFrame(this.tick);\n            }\n        };\n        if (autoplay)\n            this.play();\n    }\n    play() {\n        const now = performance.now();\n        this.playState = \"running\";\n        if (this.pauseTime !== undefined) {\n            this.startTime = now - this.pauseTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = now;\n        }\n        this.cancelTimestamp = this.startTime;\n        this.pauseTime = undefined;\n        this.frameRequestId = requestAnimationFrame(this.tick);\n    }\n    pause() {\n        this.playState = \"paused\";\n        this.pauseTime = this.t;\n    }\n    finish() {\n        this.playState = \"finished\";\n        this.tick(0);\n    }\n    stop() {\n        var _a;\n        this.playState = \"idle\";\n        if (this.frameRequestId !== undefined) {\n            cancelAnimationFrame(this.frameRequestId);\n        }\n        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, false);\n    }\n    cancel() {\n        this.stop();\n        this.tick(this.cancelTimestamp);\n    }\n    reverse() {\n        this.rate *= -1;\n    }\n    commitStyles() { }\n    updateDuration(duration) {\n        this.duration = duration;\n        this.totalDuration = duration * (this.repeat + 1);\n    }\n    get currentTime() {\n        return this.t;\n    }\n    set currentTime(t) {\n        if (this.pauseTime !== undefined || this.rate === 0) {\n            this.pauseTime = t;\n        }\n        else {\n            this.startTime = performance.now() - t / this.rate;\n        }\n    }\n    get playbackRate() {\n        return this.rate;\n    }\n    set playbackRate(rate) {\n        this.rate = rate;\n    }\n}\n\nexport { Animation };\n","import { mix } from './mix.es.js';\nimport { noopReturn } from './noop.es.js';\nimport { fillOffset, defaultOffset } from './offset.es.js';\nimport { progress } from './progress.es.js';\nimport { getEasingForSegment } from './easing.es.js';\nimport { clamp } from './clamp.es.js';\n\nfunction interpolate(output, input = defaultOffset(output.length), easing = noopReturn) {\n    const length = output.length;\n    /**\n     * If the input length is lower than the output we\n     * fill the input to match. This currently assumes the input\n     * is an animation progress value so is a good candidate for\n     * moving outside the function.\n     */\n    const remainder = length - input.length;\n    remainder > 0 && fillOffset(input, remainder);\n    return (t) => {\n        let i = 0;\n        for (; i < length - 2; i++) {\n            if (t < input[i + 1])\n                break;\n        }\n        let progressInRange = clamp(0, 1, progress(input[i], input[i + 1], t));\n        const segmentEasing = getEasingForSegment(easing, i);\n        progressInRange = segmentEasing(progressInRange);\n        return mix(output[i], output[i + 1], progressInRange);\n    };\n}\n\nexport { interpolate };\n","import { isEasingList } from './is-easing-list.es.js';\nimport { wrap } from './wrap.es.js';\n\nfunction getEasingForSegment(easing, i) {\n    return isEasingList(easing) ? easing[wrap(0, easing.length, i)] : easing;\n}\n\nexport { getEasingForSegment };\n","const wrap = (min, max, v) => {\n    const rangeSize = max - min;\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\n};\n\nexport { wrap };\n","/**\n * The MotionValue tracks the state of a single animatable\n * value. Currently, updatedAt and current are unused. The\n * long term idea is to use this to minimise the number\n * of DOM reads, and to abstract the DOM interactions here.\n */\nclass MotionValue {\n    setAnimation(animation) {\n        this.animation = animation;\n        animation === null || animation === void 0 ? void 0 : animation.finished.then(() => this.clearAnimation()).catch(() => { });\n    }\n    clearAnimation() {\n        this.animation = this.generator = undefined;\n    }\n}\n\nexport { MotionValue };\n","import { MotionValue } from '@motionone/types';\n\nconst data = new WeakMap();\nfunction getAnimationData(element) {\n    if (!data.has(element)) {\n        data.set(element, {\n            transforms: [],\n            values: new Map(),\n        });\n    }\n    return data.get(element);\n}\nfunction getMotionValue(motionValues, name) {\n    if (!motionValues.has(name)) {\n        motionValues.set(name, new MotionValue());\n    }\n    return motionValues.get(name);\n}\n\nexport { getAnimationData, getMotionValue };\n","import { noopReturn, addUniqueItem } from '@motionone/utils';\nimport { getAnimationData } from '../data.es.js';\n\n/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nconst axes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nconst order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\nconst transformAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n};\nconst rotation = {\n    syntax: \"<angle>\",\n    initialValue: \"0deg\",\n    toDefaultUnit: (v) => v + \"deg\",\n};\nconst baseTransformProperties = {\n    translate: {\n        syntax: \"<length-percentage>\",\n        initialValue: \"0px\",\n        toDefaultUnit: (v) => v + \"px\",\n    },\n    rotate: rotation,\n    scale: {\n        syntax: \"<number>\",\n        initialValue: 1,\n        toDefaultUnit: noopReturn,\n    },\n    skew: rotation,\n};\nconst transformDefinitions = new Map();\nconst asTransformCssVar = (name) => `--motion-${name}`;\n/**\n * Generate a list of every possible transform key\n */\nconst transforms = [\"x\", \"y\", \"z\"];\norder.forEach((name) => {\n    axes.forEach((axis) => {\n        transforms.push(name + axis);\n        transformDefinitions.set(asTransformCssVar(name + axis), baseTransformProperties[name]);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nconst compareTransformOrder = (a, b) => transforms.indexOf(a) - transforms.indexOf(b);\n/**\n * Provide a quick way to check if a string is the name of a transform\n */\nconst transformLookup = new Set(transforms);\nconst isTransform = (name) => transformLookup.has(name);\nconst addTransformToElement = (element, name) => {\n    // Map x to translateX etc\n    if (transformAlias[name])\n        name = transformAlias[name];\n    const { transforms } = getAnimationData(element);\n    addUniqueItem(transforms, name);\n    /**\n     * TODO: An optimisation here could be to cache the transform in element data\n     * and only update if this has changed.\n     */\n    element.style.transform = buildTransformTemplate(transforms);\n};\nconst buildTransformTemplate = (transforms) => transforms\n    .sort(compareTransformOrder)\n    .reduce(transformListToString, \"\")\n    .trim();\nconst transformListToString = (template, name) => `${template} ${name}(var(${asTransformCssVar(name)}))`;\n\nexport { addTransformToElement, asTransformCssVar, axes, buildTransformTemplate, compareTransformOrder, isTransform, transformAlias, transformDefinitions };\n","import { transformDefinitions } from './transforms.es.js';\n\nconst isCssVar = (name) => name.startsWith(\"--\");\nconst registeredProperties = new Set();\nfunction registerCssVariable(name) {\n    if (registeredProperties.has(name))\n        return;\n    registeredProperties.add(name);\n    try {\n        const { syntax, initialValue } = transformDefinitions.has(name)\n            ? transformDefinitions.get(name)\n            : {};\n        CSS.registerProperty({\n            name,\n            inherits: false,\n            syntax,\n            initialValue,\n        });\n    }\n    catch (e) { }\n}\n\nexport { isCssVar, registerCssVariable, registeredProperties };\n","const testAnimation = (keyframes, options) => document.createElement(\"div\").animate(keyframes, options);\nconst featureTests = {\n    cssRegisterProperty: () => typeof CSS !== \"undefined\" &&\n        Object.hasOwnProperty.call(CSS, \"registerProperty\"),\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n    partialKeyframes: () => {\n        try {\n            testAnimation({ opacity: [1] });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n    finished: () => Boolean(testAnimation({ opacity: [0, 1] }, { duration: 0.001 }).finished),\n    linearEasing: () => {\n        try {\n            testAnimation({ opacity: 0 }, { easing: \"linear(0, 1)\" });\n        }\n        catch (e) {\n            return false;\n        }\n        return true;\n    },\n};\nconst results = {};\nconst supports = {};\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] =\n                featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","import { isFunction, defaults, isCubicBezier, progress } from '@motionone/utils';\nimport { supports } from './feature-detection.es.js';\n\n// Create a linear easing point for every x second\nconst resolution = 0.015;\nconst generateLinearEasingPoints = (easing, duration) => {\n    let points = \"\";\n    const numPoints = Math.round(duration / resolution);\n    for (let i = 0; i < numPoints; i++) {\n        points += easing(progress(0, numPoints - 1, i)) + \", \";\n    }\n    return points.substring(0, points.length - 2);\n};\nconst convertEasing = (easing, duration) => {\n    if (isFunction(easing)) {\n        return supports.linearEasing()\n            ? `linear(${generateLinearEasingPoints(easing, duration)})`\n            : defaults.easing;\n    }\n    else {\n        return isCubicBezier(easing) ? cubicBezierAsString(easing) : easing;\n    }\n};\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\n\nexport { convertEasing, cubicBezierAsString, generateLinearEasingPoints };\n","import { isTransform, asTransformCssVar, transformAlias } from './transforms.es.js';\n\nfunction getStyleName(key) {\n    if (transformAlias[key])\n        key = transformAlias[key];\n    return isTransform(key) ? asTransformCssVar(key) : key;\n}\n\nexport { getStyleName };\n","import { isCssVar } from './utils/css-var.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { transformDefinitions } from './utils/transforms.es.js';\n\nconst style = {\n    get: (element, name) => {\n        name = getStyleName(name);\n        let value = isCssVar(name)\n            ? element.style.getPropertyValue(name)\n            : getComputedStyle(element)[name];\n        // TODO Decide if value can be 0\n        if (!value && value !== 0) {\n            const definition = transformDefinitions.get(name);\n            if (definition)\n                value = definition.initialValue;\n        }\n        return value;\n    },\n    set: (element, name, value) => {\n        name = getStyleName(name);\n        if (isCssVar(name)) {\n            element.style.setProperty(name, value);\n        }\n        else {\n            element.style[name] = value;\n        }\n    },\n};\n\nexport { style };\n","import { getAnimationData, getMotionValue } from './data.es.js';\nimport { isCssVar, registerCssVariable } from './utils/css-var.es.js';\nimport { defaults, isEasingGenerator, isFunction, isEasingList, isNumber, time, noop } from '@motionone/utils';\nimport { isTransform, addTransformToElement, transformDefinitions } from './utils/transforms.es.js';\nimport { convertEasing } from './utils/easing.es.js';\nimport { supports } from './utils/feature-detection.es.js';\nimport { hydrateKeyframes, keyframesList } from './utils/keyframes.es.js';\nimport { style } from './style.es.js';\nimport { getStyleName } from './utils/get-style-name.es.js';\nimport { stopAnimation } from './utils/stop-animation.es.js';\nimport { getUnitConverter } from './utils/get-unit.es.js';\n\nfunction getDevToolsRecord() {\n    return window.__MOTION_DEV_TOOLS_RECORD;\n}\nfunction animateStyle(element, key, keyframesDefinition, options = {}, AnimationPolyfill) {\n    const record = getDevToolsRecord();\n    const isRecording = options.record !== false && record;\n    let animation;\n    let { duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, easing = defaults.easing, persist = false, direction, offset, allowWebkitAcceleration = false, autoplay = true, } = options;\n    const data = getAnimationData(element);\n    const valueIsTransform = isTransform(key);\n    let canAnimateNatively = supports.waapi();\n    /**\n     * If this is an individual transform, we need to map its\n     * key to a CSS variable and update the element's transform style\n     */\n    valueIsTransform && addTransformToElement(element, key);\n    const name = getStyleName(key);\n    const motionValue = getMotionValue(data.values, name);\n    /**\n     * Get definition of value, this will be used to convert numerical\n     * keyframes into the default value type.\n     */\n    const definition = transformDefinitions.get(name);\n    /**\n     * Stop the current animation, if any. Because this will trigger\n     * commitStyles (DOM writes) and we might later trigger DOM reads,\n     * this is fired now and we return a factory function to create\n     * the actual animation that can get called in batch,\n     */\n    stopAnimation(motionValue.animation, !(isEasingGenerator(easing) && motionValue.generator) &&\n        options.record !== false);\n    /**\n     * Batchable factory function containing all DOM reads.\n     */\n    return () => {\n        const readInitialValue = () => { var _a, _b; return (_b = (_a = style.get(element, name)) !== null && _a !== void 0 ? _a : definition === null || definition === void 0 ? void 0 : definition.initialValue) !== null && _b !== void 0 ? _b : 0; };\n        /**\n         * Replace null values with the previous keyframe value, or read\n         * it from the DOM if it's the first keyframe.\n         */\n        let keyframes = hydrateKeyframes(keyframesList(keyframesDefinition), readInitialValue);\n        /**\n         * Detect unit type of keyframes.\n         */\n        const toUnit = getUnitConverter(keyframes, definition);\n        if (isEasingGenerator(easing)) {\n            const custom = easing.createAnimation(keyframes, key !== \"opacity\", readInitialValue, name, motionValue);\n            easing = custom.easing;\n            keyframes = custom.keyframes || keyframes;\n            duration = custom.duration || duration;\n        }\n        /**\n         * If this is a CSS variable we need to register it with the browser\n         * before it can be animated natively. We also set it with setProperty\n         * rather than directly onto the element.style object.\n         */\n        if (isCssVar(name)) {\n            if (supports.cssRegisterProperty()) {\n                registerCssVariable(name);\n            }\n            else {\n                canAnimateNatively = false;\n            }\n        }\n        /**\n         * If we've been passed a custom easing function, and this browser\n         * does **not** support linear() easing, and the value is a transform\n         * (and thus a pure number) we can still support the custom easing\n         * by falling back to the animation polyfill.\n         */\n        if (valueIsTransform &&\n            !supports.linearEasing() &&\n            (isFunction(easing) || (isEasingList(easing) && easing.some(isFunction)))) {\n            canAnimateNatively = false;\n        }\n        /**\n         * If we can animate this value with WAAPI, do so.\n         */\n        if (canAnimateNatively) {\n            /**\n             * Convert numbers to default value types. Currently this only supports\n             * transforms but it could also support other value types.\n             */\n            if (definition) {\n                keyframes = keyframes.map((value) => isNumber(value) ? definition.toDefaultUnit(value) : value);\n            }\n            /**\n             * If this browser doesn't support partial/implicit keyframes we need to\n             * explicitly provide one.\n             */\n            if (keyframes.length === 1 &&\n                (!supports.partialKeyframes() || isRecording)) {\n                keyframes.unshift(readInitialValue());\n            }\n            const animationOptions = {\n                delay: time.ms(delay),\n                duration: time.ms(duration),\n                endDelay: time.ms(endDelay),\n                easing: !isEasingList(easing)\n                    ? convertEasing(easing, duration)\n                    : undefined,\n                direction,\n                iterations: repeat + 1,\n                fill: \"both\",\n            };\n            animation = element.animate({\n                [name]: keyframes,\n                offset,\n                easing: isEasingList(easing)\n                    ? easing.map((thisEasing) => convertEasing(thisEasing, duration))\n                    : undefined,\n            }, animationOptions);\n            /**\n             * Polyfill finished Promise in browsers that don't support it\n             */\n            if (!animation.finished) {\n                animation.finished = new Promise((resolve, reject) => {\n                    animation.onfinish = resolve;\n                    animation.oncancel = reject;\n                });\n            }\n            const target = keyframes[keyframes.length - 1];\n            animation.finished\n                .then(() => {\n                if (persist)\n                    return;\n                // Apply styles to target\n                style.set(element, name, target);\n                // Ensure fill modes don't persist\n                animation.cancel();\n            })\n                .catch(noop);\n            /**\n             * This forces Webkit to run animations on the main thread by exploiting\n             * this condition:\n             * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp?rev=281238#L1099\n             *\n             * This fixes Webkit's timing bugs, like accelerated animations falling\n             * out of sync with main thread animations and massive delays in starting\n             * accelerated animations in WKWebView.\n             */\n            if (!allowWebkitAcceleration)\n                animation.playbackRate = 1.000001;\n            /**\n             * If we can't animate the value natively then we can fallback to the numbers-only\n             * polyfill for transforms.\n             */\n        }\n        else if (AnimationPolyfill && valueIsTransform) {\n            /**\n             * If any keyframe is a string (because we measured it from the DOM), we need to convert\n             * it into a number before passing to the Animation polyfill.\n             */\n            keyframes = keyframes.map((value) => typeof value === \"string\" ? parseFloat(value) : value);\n            /**\n             * If we only have a single keyframe, we need to create an initial keyframe by reading\n             * the current value from the DOM.\n             */\n            if (keyframes.length === 1) {\n                keyframes.unshift(parseFloat(readInitialValue()));\n            }\n            animation = new AnimationPolyfill((latest) => {\n                style.set(element, name, toUnit ? toUnit(latest) : latest);\n            }, keyframes, Object.assign(Object.assign({}, options), { duration,\n                easing }));\n        }\n        else {\n            const target = keyframes[keyframes.length - 1];\n            style.set(element, name, definition && isNumber(target)\n                ? definition.toDefaultUnit(target)\n                : target);\n        }\n        if (isRecording) {\n            record(element, key, keyframes, {\n                duration,\n                delay: delay,\n                easing,\n                repeat,\n                offset,\n            }, \"motion-one\");\n        }\n        motionValue.setAnimation(animation);\n        if (animation && !autoplay)\n            animation.pause();\n        return animation;\n    };\n}\n\nexport { animateStyle };\n","function addUniqueItem(array, item) {\n    array.indexOf(item) === -1 && array.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n\nexport { addUniqueItem, removeItem };\n","function hydrateKeyframes(keyframes, readInitialValue) {\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] === null) {\n            keyframes[i] = i ? keyframes[i - 1] : readInitialValue();\n        }\n    }\n    return keyframes;\n}\nconst keyframesList = (keyframes) => Array.isArray(keyframes) ? keyframes : [keyframes];\n\nexport { hydrateKeyframes, keyframesList };\n","import { noopReturn, isString } from '@motionone/utils';\n\nfunction getUnitConverter(keyframes, definition) {\n    var _a;\n    let toUnit = (definition === null || definition === void 0 ? void 0 : definition.toDefaultUnit) || noopReturn;\n    const finalKeyframe = keyframes[keyframes.length - 1];\n    if (isString(finalKeyframe)) {\n        const unit = ((_a = finalKeyframe.match(/(-?[\\d.]+)([a-z%]*)/)) === null || _a === void 0 ? void 0 : _a[2]) || \"\";\n        if (unit)\n            toUnit = (value) => value + unit;\n    }\n    return toUnit;\n}\n\nexport { getUnitConverter };\n","const isString = (value) => typeof value === \"string\";\n\nexport { isString };\n","const getOptions = (options, key) => \n/**\n * TODO: Make test for this\n * Always return a new object otherwise delay is overwritten by results of stagger\n * and this results in no stagger\n */\noptions[key] ? Object.assign(Object.assign({}, options), options[key]) : Object.assign({}, options);\n\nexport { getOptions };\n","import { Animation } from '@motionone/animation';\nimport { createAnimate } from './create-animate.es.js';\n\nconst animate = createAnimate(Animation);\n\nexport { animate };\n","import { invariant } from 'hey-listen';\nimport { animateStyle } from './animate-style.es.js';\nimport { getOptions } from './utils/options.es.js';\nimport { resolveElements } from '../utils/resolve-elements.es.js';\nimport { withControls } from './utils/controls.es.js';\nimport { resolveOption } from '../utils/stagger.es.js';\n\nfunction createAnimate(AnimatePolyfill) {\n    return function animate(elements, keyframes, options = {}) {\n        elements = resolveElements(elements);\n        const numElements = elements.length;\n        invariant(Boolean(numElements), \"No valid element provided.\");\n        invariant(Boolean(keyframes), \"No keyframes defined.\");\n        /**\n         * Create and start new animations\n         */\n        const animationFactories = [];\n        for (let i = 0; i < numElements; i++) {\n            const element = elements[i];\n            for (const key in keyframes) {\n                const valueOptions = getOptions(options, key);\n                valueOptions.delay = resolveOption(valueOptions.delay, i, numElements);\n                const animation = animateStyle(element, key, keyframes[key], valueOptions, AnimatePolyfill);\n                animationFactories.push(animation);\n            }\n        }\n        return withControls(animationFactories, options, \n        /**\n         * TODO:\n         * If easing is set to spring or glide, duration will be dynamically\n         * generated. Ideally we would dynamically generate this from\n         * animation.effect.getComputedTiming().duration but this isn't\n         * supported in iOS13 or our number polyfill. Perhaps it's possible\n         * to Proxy animations returned from animateStyle that has duration\n         * as a getter.\n         */\n        options.duration);\n    };\n}\n\nexport { createAnimate };\n","import { animate as animate$1, withControls } from '@motionone/dom';\nimport { isFunction } from '@motionone/utils';\nimport { Animation } from '@motionone/animation';\n\nfunction animateProgress(target, options = {}) {\n    return withControls([\n        () => {\n            const animation = new Animation(target, [0, 1], options);\n            animation.finished.catch(() => { });\n            return animation;\n        },\n    ], options, options.duration);\n}\nfunction animate(target, keyframesOrOptions, options) {\n    const factory = isFunction(target) ? animateProgress : animate$1;\n    return factory(target, keyframesOrOptions, options);\n}\n\nexport { animate, animateProgress };\n","/*!\n * validate.js 0.13.1\n *\n * (c) 2013-2019 Nicklas Ansman, 2013 Wrapp\n * Validate.js may be freely distributed under the MIT license.\n * For all details and documentation:\n * http://validatejs.org/\n */\n\n(function(exports, module, define) {\n  \"use strict\";\n\n  // The main function that calls the validators specified by the constraints.\n  // The options are the following:\n  //   - format (string) - An option that controls how the returned value is formatted\n  //     * flat - Returns a flat array of just the error messages\n  //     * grouped - Returns the messages grouped by attribute (default)\n  //     * detailed - Returns an array of the raw validation data\n  //   - fullMessages (boolean) - If `true` (default) the attribute name is prepended to the error.\n  //\n  // Please note that the options are also passed to each validator.\n  var validate = function(attributes, constraints, options) {\n    options = v.extend({}, v.options, options);\n\n    var results = v.runValidations(attributes, constraints, options)\n      , attr\n      , validator;\n\n    if (results.some(function(r) { return v.isPromise(r.error); })) {\n      throw new Error(\"Use validate.async if you want support for promises\");\n    }\n    return validate.processValidationResults(results, options);\n  };\n\n  var v = validate;\n\n  // Copies over attributes from one or more sources to a single destination.\n  // Very much similar to underscore's extend.\n  // The first argument is the target object and the remaining arguments will be\n  // used as sources.\n  v.extend = function(obj) {\n    [].slice.call(arguments, 1).forEach(function(source) {\n      for (var attr in source) {\n        obj[attr] = source[attr];\n      }\n    });\n    return obj;\n  };\n\n  v.extend(validate, {\n    // This is the version of the library as a semver.\n    // The toString function will allow it to be coerced into a string\n    version: {\n      major: 0,\n      minor: 13,\n      patch: 1,\n      metadata: null,\n      toString: function() {\n        var version = v.format(\"%{major}.%{minor}.%{patch}\", v.version);\n        if (!v.isEmpty(v.version.metadata)) {\n          version += \"+\" + v.version.metadata;\n        }\n        return version;\n      }\n    },\n\n    // Below is the dependencies that are used in validate.js\n\n    // The constructor of the Promise implementation.\n    // If you are using Q.js, RSVP or any other A+ compatible implementation\n    // override this attribute to be the constructor of that promise.\n    // Since jQuery promises aren't A+ compatible they won't work.\n    Promise: typeof Promise !== \"undefined\" ? Promise : /* istanbul ignore next */ null,\n\n    EMPTY_STRING_REGEXP: /^\\s*$/,\n\n    // Runs the validators specified by the constraints object.\n    // Will return an array of the format:\n    //     [{attribute: \"<attribute name>\", error: \"<validation result>\"}, ...]\n    runValidations: function(attributes, constraints, options) {\n      var results = []\n        , attr\n        , validatorName\n        , value\n        , validators\n        , validator\n        , validatorOptions\n        , error;\n\n      if (v.isDomElement(attributes) || v.isJqueryElement(attributes)) {\n        attributes = v.collectFormValues(attributes);\n      }\n\n      // Loops through each constraints, finds the correct validator and run it.\n      for (attr in constraints) {\n        value = v.getDeepObjectValue(attributes, attr);\n        // This allows the constraints for an attribute to be a function.\n        // The function will be called with the value, attribute name, the complete dict of\n        // attributes as well as the options and constraints passed in.\n        // This is useful when you want to have different\n        // validations depending on the attribute value.\n        validators = v.result(constraints[attr], value, attributes, attr, options, constraints);\n\n        for (validatorName in validators) {\n          validator = v.validators[validatorName];\n\n          if (!validator) {\n            error = v.format(\"Unknown validator %{name}\", {name: validatorName});\n            throw new Error(error);\n          }\n\n          validatorOptions = validators[validatorName];\n          // This allows the options to be a function. The function will be\n          // called with the value, attribute name, the complete dict of\n          // attributes as well as the options and constraints passed in.\n          // This is useful when you want to have different\n          // validations depending on the attribute value.\n          validatorOptions = v.result(validatorOptions, value, attributes, attr, options, constraints);\n          if (!validatorOptions) {\n            continue;\n          }\n          results.push({\n            attribute: attr,\n            value: value,\n            validator: validatorName,\n            globalOptions: options,\n            attributes: attributes,\n            options: validatorOptions,\n            error: validator.call(validator,\n                value,\n                validatorOptions,\n                attr,\n                attributes,\n                options)\n          });\n        }\n      }\n\n      return results;\n    },\n\n    // Takes the output from runValidations and converts it to the correct\n    // output format.\n    processValidationResults: function(errors, options) {\n      errors = v.pruneEmptyErrors(errors, options);\n      errors = v.expandMultipleErrors(errors, options);\n      errors = v.convertErrorMessages(errors, options);\n\n      var format = options.format || \"grouped\";\n\n      if (typeof v.formatters[format] === 'function') {\n        errors = v.formatters[format](errors);\n      } else {\n        throw new Error(v.format(\"Unknown format %{format}\", options));\n      }\n\n      return v.isEmpty(errors) ? undefined : errors;\n    },\n\n    // Runs the validations with support for promises.\n    // This function will return a promise that is settled when all the\n    // validation promises have been completed.\n    // It can be called even if no validations returned a promise.\n    async: function(attributes, constraints, options) {\n      options = v.extend({}, v.async.options, options);\n\n      var WrapErrors = options.wrapErrors || function(errors) {\n        return errors;\n      };\n\n      // Removes unknown attributes\n      if (options.cleanAttributes !== false) {\n        attributes = v.cleanAttributes(attributes, constraints);\n      }\n\n      var results = v.runValidations(attributes, constraints, options);\n\n      return new v.Promise(function(resolve, reject) {\n        v.waitForResults(results).then(function() {\n          var errors = v.processValidationResults(results, options);\n          if (errors) {\n            reject(new WrapErrors(errors, options, attributes, constraints));\n          } else {\n            resolve(attributes);\n          }\n        }, function(err) {\n          reject(err);\n        });\n      });\n    },\n\n    single: function(value, constraints, options) {\n      options = v.extend({}, v.single.options, options, {\n        format: \"flat\",\n        fullMessages: false\n      });\n      return v({single: value}, {single: constraints}, options);\n    },\n\n    // Returns a promise that is resolved when all promises in the results array\n    // are settled. The promise returned from this function is always resolved,\n    // never rejected.\n    // This function modifies the input argument, it replaces the promises\n    // with the value returned from the promise.\n    waitForResults: function(results) {\n      // Create a sequence of all the results starting with a resolved promise.\n      return results.reduce(function(memo, result) {\n        // If this result isn't a promise skip it in the sequence.\n        if (!v.isPromise(result.error)) {\n          return memo;\n        }\n\n        return memo.then(function() {\n          return result.error.then(function(error) {\n            result.error = error || null;\n          });\n        });\n      }, new v.Promise(function(r) { r(); })); // A resolved promise\n    },\n\n    // If the given argument is a call: function the and: function return the value\n    // otherwise just return the value. Additional arguments will be passed as\n    // arguments to the function.\n    // Example:\n    // ```\n    // result('foo') // 'foo'\n    // result(Math.max, 1, 2) // 2\n    // ```\n    result: function(value) {\n      var args = [].slice.call(arguments, 1);\n      if (typeof value === 'function') {\n        value = value.apply(null, args);\n      }\n      return value;\n    },\n\n    // Checks if the value is a number. This function does not consider NaN a\n    // number like many other `isNumber` functions do.\n    isNumber: function(value) {\n      return typeof value === 'number' && !isNaN(value);\n    },\n\n    // Returns false if the object is not a function\n    isFunction: function(value) {\n      return typeof value === 'function';\n    },\n\n    // A simple check to verify that the value is an integer. Uses `isNumber`\n    // and a simple modulo check.\n    isInteger: function(value) {\n      return v.isNumber(value) && value % 1 === 0;\n    },\n\n    // Checks if the value is a boolean\n    isBoolean: function(value) {\n      return typeof value === 'boolean';\n    },\n\n    // Uses the `Object` function to check if the given argument is an object.\n    isObject: function(obj) {\n      return obj === Object(obj);\n    },\n\n    // Simply checks if the object is an instance of a date\n    isDate: function(obj) {\n      return obj instanceof Date;\n    },\n\n    // Returns false if the object is `null` of `undefined`\n    isDefined: function(obj) {\n      return obj !== null && obj !== undefined;\n    },\n\n    // Checks if the given argument is a promise. Anything with a `then`\n    // function is considered a promise.\n    isPromise: function(p) {\n      return !!p && v.isFunction(p.then);\n    },\n\n    isJqueryElement: function(o) {\n      return o && v.isString(o.jquery);\n    },\n\n    isDomElement: function(o) {\n      if (!o) {\n        return false;\n      }\n\n      if (!o.querySelectorAll || !o.querySelector) {\n        return false;\n      }\n\n      if (v.isObject(document) && o === document) {\n        return true;\n      }\n\n      // http://stackoverflow.com/a/384380/699304\n      /* istanbul ignore else */\n      if (typeof HTMLElement === \"object\") {\n        return o instanceof HTMLElement;\n      } else {\n        return o &&\n          typeof o === \"object\" &&\n          o !== null &&\n          o.nodeType === 1 &&\n          typeof o.nodeName === \"string\";\n      }\n    },\n\n    isEmpty: function(value) {\n      var attr;\n\n      // Null and undefined are empty\n      if (!v.isDefined(value)) {\n        return true;\n      }\n\n      // functions are non empty\n      if (v.isFunction(value)) {\n        return false;\n      }\n\n      // Whitespace only strings are empty\n      if (v.isString(value)) {\n        return v.EMPTY_STRING_REGEXP.test(value);\n      }\n\n      // For arrays we use the length property\n      if (v.isArray(value)) {\n        return value.length === 0;\n      }\n\n      // Dates have no attributes but aren't empty\n      if (v.isDate(value)) {\n        return false;\n      }\n\n      // If we find at least one property we consider it non empty\n      if (v.isObject(value)) {\n        for (attr in value) {\n          return false;\n        }\n        return true;\n      }\n\n      return false;\n    },\n\n    // Formats the specified strings with the given values like so:\n    // ```\n    // format(\"Foo: %{foo}\", {foo: \"bar\"}) // \"Foo bar\"\n    // ```\n    // If you want to write %{...} without having it replaced simply\n    // prefix it with % like this `Foo: %%{foo}` and it will be returned\n    // as `\"Foo: %{foo}\"`\n    format: v.extend(function(str, vals) {\n      if (!v.isString(str)) {\n        return str;\n      }\n      return str.replace(v.format.FORMAT_REGEXP, function(m0, m1, m2) {\n        if (m1 === '%') {\n          return \"%{\" + m2 + \"}\";\n        } else {\n          return String(vals[m2]);\n        }\n      });\n    }, {\n      // Finds %{key} style patterns in the given string\n      FORMAT_REGEXP: /(%?)%\\{([^\\}]+)\\}/g\n    }),\n\n    // \"Prettifies\" the given string.\n    // Prettifying means replacing [.\\_-] with spaces as well as splitting\n    // camel case words.\n    prettify: function(str) {\n      if (v.isNumber(str)) {\n        // If there are more than 2 decimals round it to two\n        if ((str * 100) % 1 === 0) {\n          return \"\" + str;\n        } else {\n          return parseFloat(Math.round(str * 100) / 100).toFixed(2);\n        }\n      }\n\n      if (v.isArray(str)) {\n        return str.map(function(s) { return v.prettify(s); }).join(\", \");\n      }\n\n      if (v.isObject(str)) {\n        if (!v.isDefined(str.toString)) {\n          return JSON.stringify(str);\n        }\n\n        return str.toString();\n      }\n\n      // Ensure the string is actually a string\n      str = \"\" + str;\n\n      return str\n        // Splits keys separated by periods\n        .replace(/([^\\s])\\.([^\\s])/g, '$1 $2')\n        // Removes backslashes\n        .replace(/\\\\+/g, '')\n        // Replaces - and - with space\n        .replace(/[_-]/g, ' ')\n        // Splits camel cased words\n        .replace(/([a-z])([A-Z])/g, function(m0, m1, m2) {\n          return \"\" + m1 + \" \" + m2.toLowerCase();\n        })\n        .toLowerCase();\n    },\n\n    stringifyValue: function(value, options) {\n      var prettify = options && options.prettify || v.prettify;\n      return prettify(value);\n    },\n\n    isString: function(value) {\n      return typeof value === 'string';\n    },\n\n    isArray: function(value) {\n      return {}.toString.call(value) === '[object Array]';\n    },\n\n    // Checks if the object is a hash, which is equivalent to an object that\n    // is neither an array nor a function.\n    isHash: function(value) {\n      return v.isObject(value) && !v.isArray(value) && !v.isFunction(value);\n    },\n\n    contains: function(obj, value) {\n      if (!v.isDefined(obj)) {\n        return false;\n      }\n      if (v.isArray(obj)) {\n        return obj.indexOf(value) !== -1;\n      }\n      return value in obj;\n    },\n\n    unique: function(array) {\n      if (!v.isArray(array)) {\n        return array;\n      }\n      return array.filter(function(el, index, array) {\n        return array.indexOf(el) == index;\n      });\n    },\n\n    forEachKeyInKeypath: function(object, keypath, callback) {\n      if (!v.isString(keypath)) {\n        return undefined;\n      }\n\n      var key = \"\"\n        , i\n        , escape = false;\n\n      for (i = 0; i < keypath.length; ++i) {\n        switch (keypath[i]) {\n          case '.':\n            if (escape) {\n              escape = false;\n              key += '.';\n            } else {\n              object = callback(object, key, false);\n              key = \"\";\n            }\n            break;\n\n          case '\\\\':\n            if (escape) {\n              escape = false;\n              key += '\\\\';\n            } else {\n              escape = true;\n            }\n            break;\n\n          default:\n            escape = false;\n            key += keypath[i];\n            break;\n        }\n      }\n\n      return callback(object, key, true);\n    },\n\n    getDeepObjectValue: function(obj, keypath) {\n      if (!v.isObject(obj)) {\n        return undefined;\n      }\n\n      return v.forEachKeyInKeypath(obj, keypath, function(obj, key) {\n        if (v.isObject(obj)) {\n          return obj[key];\n        }\n      });\n    },\n\n    // This returns an object with all the values of the form.\n    // It uses the input name as key and the value as value\n    // So for example this:\n    // <input type=\"text\" name=\"email\" value=\"foo@bar.com\" />\n    // would return:\n    // {email: \"foo@bar.com\"}\n    collectFormValues: function(form, options) {\n      var values = {}\n        , i\n        , j\n        , input\n        , inputs\n        , option\n        , value;\n\n      if (v.isJqueryElement(form)) {\n        form = form[0];\n      }\n\n      if (!form) {\n        return values;\n      }\n\n      options = options || {};\n\n      inputs = form.querySelectorAll(\"input[name], textarea[name]\");\n      for (i = 0; i < inputs.length; ++i) {\n        input = inputs.item(i);\n\n        if (v.isDefined(input.getAttribute(\"data-ignored\"))) {\n          continue;\n        }\n\n        var name = input.name.replace(/\\./g, \"\\\\\\\\.\");\n        value = v.sanitizeFormValue(input.value, options);\n        if (input.type === \"number\") {\n          value = value ? +value : null;\n        } else if (input.type === \"checkbox\") {\n          if (input.attributes.value) {\n            if (!input.checked) {\n              value = values[name] || null;\n            }\n          } else {\n            value = input.checked;\n          }\n        } else if (input.type === \"radio\") {\n          if (!input.checked) {\n            value = values[name] || null;\n          }\n        }\n        values[name] = value;\n      }\n\n      inputs = form.querySelectorAll(\"select[name]\");\n      for (i = 0; i < inputs.length; ++i) {\n        input = inputs.item(i);\n        if (v.isDefined(input.getAttribute(\"data-ignored\"))) {\n          continue;\n        }\n\n        if (input.multiple) {\n          value = [];\n          for (j in input.options) {\n            option = input.options[j];\n             if (option && option.selected) {\n              value.push(v.sanitizeFormValue(option.value, options));\n            }\n          }\n        } else {\n          var _val = typeof input.options[input.selectedIndex] !== 'undefined' ? input.options[input.selectedIndex].value : /* istanbul ignore next */ '';\n          value = v.sanitizeFormValue(_val, options);\n        }\n        values[input.name] = value;\n      }\n\n      return values;\n    },\n\n    sanitizeFormValue: function(value, options) {\n      if (options.trim && v.isString(value)) {\n        value = value.trim();\n      }\n\n      if (options.nullify !== false && value === \"\") {\n        return null;\n      }\n      return value;\n    },\n\n    capitalize: function(str) {\n      if (!v.isString(str)) {\n        return str;\n      }\n      return str[0].toUpperCase() + str.slice(1);\n    },\n\n    // Remove all errors who's error attribute is empty (null or undefined)\n    pruneEmptyErrors: function(errors) {\n      return errors.filter(function(error) {\n        return !v.isEmpty(error.error);\n      });\n    },\n\n    // In\n    // [{error: [\"err1\", \"err2\"], ...}]\n    // Out\n    // [{error: \"err1\", ...}, {error: \"err2\", ...}]\n    //\n    // All attributes in an error with multiple messages are duplicated\n    // when expanding the errors.\n    expandMultipleErrors: function(errors) {\n      var ret = [];\n      errors.forEach(function(error) {\n        // Removes errors without a message\n        if (v.isArray(error.error)) {\n          error.error.forEach(function(msg) {\n            ret.push(v.extend({}, error, {error: msg}));\n          });\n        } else {\n          ret.push(error);\n        }\n      });\n      return ret;\n    },\n\n    // Converts the error mesages by prepending the attribute name unless the\n    // message is prefixed by ^\n    convertErrorMessages: function(errors, options) {\n      options = options || {};\n\n      var ret = []\n        , prettify = options.prettify || v.prettify;\n      errors.forEach(function(errorInfo) {\n        var error = v.result(errorInfo.error,\n            errorInfo.value,\n            errorInfo.attribute,\n            errorInfo.options,\n            errorInfo.attributes,\n            errorInfo.globalOptions);\n\n        if (!v.isString(error)) {\n          ret.push(errorInfo);\n          return;\n        }\n\n        if (error[0] === '^') {\n          error = error.slice(1);\n        } else if (options.fullMessages !== false) {\n          error = v.capitalize(prettify(errorInfo.attribute)) + \" \" + error;\n        }\n        error = error.replace(/\\\\\\^/g, \"^\");\n        error = v.format(error, {\n          value: v.stringifyValue(errorInfo.value, options)\n        });\n        ret.push(v.extend({}, errorInfo, {error: error}));\n      });\n      return ret;\n    },\n\n    // In:\n    // [{attribute: \"<attributeName>\", ...}]\n    // Out:\n    // {\"<attributeName>\": [{attribute: \"<attributeName>\", ...}]}\n    groupErrorsByAttribute: function(errors) {\n      var ret = {};\n      errors.forEach(function(error) {\n        var list = ret[error.attribute];\n        if (list) {\n          list.push(error);\n        } else {\n          ret[error.attribute] = [error];\n        }\n      });\n      return ret;\n    },\n\n    // In:\n    // [{error: \"<message 1>\", ...}, {error: \"<message 2>\", ...}]\n    // Out:\n    // [\"<message 1>\", \"<message 2>\"]\n    flattenErrorsToArray: function(errors) {\n      return errors\n        .map(function(error) { return error.error; })\n        .filter(function(value, index, self) {\n          return self.indexOf(value) === index;\n        });\n    },\n\n    cleanAttributes: function(attributes, whitelist) {\n      function whitelistCreator(obj, key, last) {\n        if (v.isObject(obj[key])) {\n          return obj[key];\n        }\n        return (obj[key] = last ? true : {});\n      }\n\n      function buildObjectWhitelist(whitelist) {\n        var ow = {}\n          , lastObject\n          , attr;\n        for (attr in whitelist) {\n          if (!whitelist[attr]) {\n            continue;\n          }\n          v.forEachKeyInKeypath(ow, attr, whitelistCreator);\n        }\n        return ow;\n      }\n\n      function cleanRecursive(attributes, whitelist) {\n        if (!v.isObject(attributes)) {\n          return attributes;\n        }\n\n        var ret = v.extend({}, attributes)\n          , w\n          , attribute;\n\n        for (attribute in attributes) {\n          w = whitelist[attribute];\n\n          if (v.isObject(w)) {\n            ret[attribute] = cleanRecursive(ret[attribute], w);\n          } else if (!w) {\n            delete ret[attribute];\n          }\n        }\n        return ret;\n      }\n\n      if (!v.isObject(whitelist) || !v.isObject(attributes)) {\n        return {};\n      }\n\n      whitelist = buildObjectWhitelist(whitelist);\n      return cleanRecursive(attributes, whitelist);\n    },\n\n    exposeModule: function(validate, root, exports, module, define) {\n      if (exports) {\n        if (module && module.exports) {\n          exports = module.exports = validate;\n        }\n        exports.validate = validate;\n      } else {\n        root.validate = validate;\n        if (validate.isFunction(define) && define.amd) {\n          define([], function () { return validate; });\n        }\n      }\n    },\n\n    warn: function(msg) {\n      if (typeof console !== \"undefined\" && console.warn) {\n        console.warn(\"[validate.js] \" + msg);\n      }\n    },\n\n    error: function(msg) {\n      if (typeof console !== \"undefined\" && console.error) {\n        console.error(\"[validate.js] \" + msg);\n      }\n    }\n  });\n\n  validate.validators = {\n    // Presence validates that the value isn't empty\n    presence: function(value, options) {\n      options = v.extend({}, this.options, options);\n      if (options.allowEmpty !== false ? !v.isDefined(value) : v.isEmpty(value)) {\n        return options.message || this.message || \"can't be blank\";\n      }\n    },\n    length: function(value, options, attribute) {\n      // Empty values are allowed\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      options = v.extend({}, this.options, options);\n\n      var is = options.is\n        , maximum = options.maximum\n        , minimum = options.minimum\n        , tokenizer = options.tokenizer || function(val) { return val; }\n        , err\n        , errors = [];\n\n      value = tokenizer(value);\n      var length = value.length;\n      if(!v.isNumber(length)) {\n        return options.message || this.notValid || \"has an incorrect length\";\n      }\n\n      // Is checks\n      if (v.isNumber(is) && length !== is) {\n        err = options.wrongLength ||\n          this.wrongLength ||\n          \"is the wrong length (should be %{count} characters)\";\n        errors.push(v.format(err, {count: is}));\n      }\n\n      if (v.isNumber(minimum) && length < minimum) {\n        err = options.tooShort ||\n          this.tooShort ||\n          \"is too short (minimum is %{count} characters)\";\n        errors.push(v.format(err, {count: minimum}));\n      }\n\n      if (v.isNumber(maximum) && length > maximum) {\n        err = options.tooLong ||\n          this.tooLong ||\n          \"is too long (maximum is %{count} characters)\";\n        errors.push(v.format(err, {count: maximum}));\n      }\n\n      if (errors.length > 0) {\n        return options.message || errors;\n      }\n    },\n    numericality: function(value, options, attribute, attributes, globalOptions) {\n      // Empty values are fine\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      options = v.extend({}, this.options, options);\n\n      var errors = []\n        , name\n        , count\n        , checks = {\n            greaterThan:          function(v, c) { return v > c; },\n            greaterThanOrEqualTo: function(v, c) { return v >= c; },\n            equalTo:              function(v, c) { return v === c; },\n            lessThan:             function(v, c) { return v < c; },\n            lessThanOrEqualTo:    function(v, c) { return v <= c; },\n            divisibleBy:          function(v, c) { return v % c === 0; }\n          }\n        , prettify = options.prettify ||\n          (globalOptions && globalOptions.prettify) ||\n          v.prettify;\n\n      // Strict will check that it is a valid looking number\n      if (v.isString(value) && options.strict) {\n        var pattern = \"^-?(0|[1-9]\\\\d*)\";\n        if (!options.onlyInteger) {\n          pattern += \"(\\\\.\\\\d+)?\";\n        }\n        pattern += \"$\";\n\n        if (!(new RegExp(pattern).test(value))) {\n          return options.message ||\n            options.notValid ||\n            this.notValid ||\n            this.message ||\n            \"must be a valid number\";\n        }\n      }\n\n      // Coerce the value to a number unless we're being strict.\n      if (options.noStrings !== true && v.isString(value) && !v.isEmpty(value)) {\n        value = +value;\n      }\n\n      // If it's not a number we shouldn't continue since it will compare it.\n      if (!v.isNumber(value)) {\n        return options.message ||\n          options.notValid ||\n          this.notValid ||\n          this.message ||\n          \"is not a number\";\n      }\n\n      // Same logic as above, sort of. Don't bother with comparisons if this\n      // doesn't pass.\n      if (options.onlyInteger && !v.isInteger(value)) {\n        return options.message ||\n          options.notInteger ||\n          this.notInteger ||\n          this.message ||\n          \"must be an integer\";\n      }\n\n      for (name in checks) {\n        count = options[name];\n        if (v.isNumber(count) && !checks[name](value, count)) {\n          // This picks the default message if specified\n          // For example the greaterThan check uses the message from\n          // this.notGreaterThan so we capitalize the name and prepend \"not\"\n          var key = \"not\" + v.capitalize(name);\n          var msg = options[key] ||\n            this[key] ||\n            this.message ||\n            \"must be %{type} %{count}\";\n\n          errors.push(v.format(msg, {\n            count: count,\n            type: prettify(name)\n          }));\n        }\n      }\n\n      if (options.odd && value % 2 !== 1) {\n        errors.push(options.notOdd ||\n            this.notOdd ||\n            this.message ||\n            \"must be odd\");\n      }\n      if (options.even && value % 2 !== 0) {\n        errors.push(options.notEven ||\n            this.notEven ||\n            this.message ||\n            \"must be even\");\n      }\n\n      if (errors.length) {\n        return options.message || errors;\n      }\n    },\n    datetime: v.extend(function(value, options) {\n      if (!v.isFunction(this.parse) || !v.isFunction(this.format)) {\n        throw new Error(\"Both the parse and format functions needs to be set to use the datetime/date validator\");\n      }\n\n      // Empty values are fine\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      options = v.extend({}, this.options, options);\n\n      var err\n        , errors = []\n        , earliest = options.earliest ? this.parse(options.earliest, options) : NaN\n        , latest = options.latest ? this.parse(options.latest, options) : NaN;\n\n      value = this.parse(value, options);\n\n      // 86400000 is the number of milliseconds in a day, this is used to remove\n      // the time from the date\n      if (isNaN(value) || options.dateOnly && value % 86400000 !== 0) {\n        err = options.notValid ||\n          options.message ||\n          this.notValid ||\n          \"must be a valid date\";\n        return v.format(err, {value: arguments[0]});\n      }\n\n      if (!isNaN(earliest) && value < earliest) {\n        err = options.tooEarly ||\n          options.message ||\n          this.tooEarly ||\n          \"must be no earlier than %{date}\";\n        err = v.format(err, {\n          value: this.format(value, options),\n          date: this.format(earliest, options)\n        });\n        errors.push(err);\n      }\n\n      if (!isNaN(latest) && value > latest) {\n        err = options.tooLate ||\n          options.message ||\n          this.tooLate ||\n          \"must be no later than %{date}\";\n        err = v.format(err, {\n          date: this.format(latest, options),\n          value: this.format(value, options)\n        });\n        errors.push(err);\n      }\n\n      if (errors.length) {\n        return v.unique(errors);\n      }\n    }, {\n      parse: null,\n      format: null\n    }),\n    date: function(value, options) {\n      options = v.extend({}, options, {dateOnly: true});\n      return v.validators.datetime.call(v.validators.datetime, value, options);\n    },\n    format: function(value, options) {\n      if (v.isString(options) || (options instanceof RegExp)) {\n        options = {pattern: options};\n      }\n\n      options = v.extend({}, this.options, options);\n\n      var message = options.message || this.message || \"is invalid\"\n        , pattern = options.pattern\n        , match;\n\n      // Empty values are allowed\n      if (!v.isDefined(value)) {\n        return;\n      }\n      if (!v.isString(value)) {\n        return message;\n      }\n\n      if (v.isString(pattern)) {\n        pattern = new RegExp(options.pattern, options.flags);\n      }\n      match = pattern.exec(value);\n      if (!match || match[0].length != value.length) {\n        return message;\n      }\n    },\n    inclusion: function(value, options) {\n      // Empty values are fine\n      if (!v.isDefined(value)) {\n        return;\n      }\n      if (v.isArray(options)) {\n        options = {within: options};\n      }\n      options = v.extend({}, this.options, options);\n      if (v.contains(options.within, value)) {\n        return;\n      }\n      var message = options.message ||\n        this.message ||\n        \"^%{value} is not included in the list\";\n      return v.format(message, {value: value});\n    },\n    exclusion: function(value, options) {\n      // Empty values are fine\n      if (!v.isDefined(value)) {\n        return;\n      }\n      if (v.isArray(options)) {\n        options = {within: options};\n      }\n      options = v.extend({}, this.options, options);\n      if (!v.contains(options.within, value)) {\n        return;\n      }\n      var message = options.message || this.message || \"^%{value} is restricted\";\n      if (v.isString(options.within[value])) {\n        value = options.within[value];\n      }\n      return v.format(message, {value: value});\n    },\n    email: v.extend(function(value, options) {\n      options = v.extend({}, this.options, options);\n      var message = options.message || this.message || \"is not a valid email\";\n      // Empty values are fine\n      if (!v.isDefined(value)) {\n        return;\n      }\n      if (!v.isString(value)) {\n        return message;\n      }\n      if (!this.PATTERN.exec(value)) {\n        return message;\n      }\n    }, {\n      PATTERN: /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$/i\n    }),\n    equality: function(value, options, attribute, attributes, globalOptions) {\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      if (v.isString(options)) {\n        options = {attribute: options};\n      }\n      options = v.extend({}, this.options, options);\n      var message = options.message ||\n        this.message ||\n        \"is not equal to %{attribute}\";\n\n      if (v.isEmpty(options.attribute) || !v.isString(options.attribute)) {\n        throw new Error(\"The attribute must be a non empty string\");\n      }\n\n      var otherValue = v.getDeepObjectValue(attributes, options.attribute)\n        , comparator = options.comparator || function(v1, v2) {\n          return v1 === v2;\n        }\n        , prettify = options.prettify ||\n          (globalOptions && globalOptions.prettify) ||\n          v.prettify;\n\n      if (!comparator(value, otherValue, options, attribute, attributes)) {\n        return v.format(message, {attribute: prettify(options.attribute)});\n      }\n    },\n    // A URL validator that is used to validate URLs with the ability to\n    // restrict schemes and some domains.\n    url: function(value, options) {\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      options = v.extend({}, this.options, options);\n\n      var message = options.message || this.message || \"is not a valid url\"\n        , schemes = options.schemes || this.schemes || ['http', 'https']\n        , allowLocal = options.allowLocal || this.allowLocal || false\n        , allowDataUrl = options.allowDataUrl || this.allowDataUrl || false;\n      if (!v.isString(value)) {\n        return message;\n      }\n\n      // https://gist.github.com/dperini/729294\n      var regex =\n        \"^\" +\n        // protocol identifier\n        \"(?:(?:\" + schemes.join(\"|\") + \")://)\" +\n        // user:pass authentication\n        \"(?:\\\\S+(?::\\\\S*)?@)?\" +\n        \"(?:\";\n\n      var tld = \"(?:\\\\.(?:[a-z\\\\u00a1-\\\\uffff]{2,}))\";\n\n      if (allowLocal) {\n        tld += \"?\";\n      } else {\n        regex +=\n          // IP address exclusion\n          // private & local networks\n          \"(?!(?:10|127)(?:\\\\.\\\\d{1,3}){3})\" +\n          \"(?!(?:169\\\\.254|192\\\\.168)(?:\\\\.\\\\d{1,3}){2})\" +\n          \"(?!172\\\\.(?:1[6-9]|2\\\\d|3[0-1])(?:\\\\.\\\\d{1,3}){2})\";\n      }\n\n      regex +=\n          // IP address dotted notation octets\n          // excludes loopback network 0.0.0.0\n          // excludes reserved space >= 224.0.0.0\n          // excludes network & broacast addresses\n          // (first & last IP address of each class)\n          \"(?:[1-9]\\\\d?|1\\\\d\\\\d|2[01]\\\\d|22[0-3])\" +\n          \"(?:\\\\.(?:1?\\\\d{1,2}|2[0-4]\\\\d|25[0-5])){2}\" +\n          \"(?:\\\\.(?:[1-9]\\\\d?|1\\\\d\\\\d|2[0-4]\\\\d|25[0-4]))\" +\n        \"|\" +\n          // host name\n          \"(?:(?:[a-z\\\\u00a1-\\\\uffff0-9]-*)*[a-z\\\\u00a1-\\\\uffff0-9]+)\" +\n          // domain name\n          \"(?:\\\\.(?:[a-z\\\\u00a1-\\\\uffff0-9]-*)*[a-z\\\\u00a1-\\\\uffff0-9]+)*\" +\n          tld +\n        \")\" +\n        // port number\n        \"(?::\\\\d{2,5})?\" +\n        // resource path\n        \"(?:[/?#]\\\\S*)?\" +\n      \"$\";\n\n      if (allowDataUrl) {\n        // RFC 2397\n        var mediaType = \"\\\\w+\\\\/[-+.\\\\w]+(?:;[\\\\w=]+)*\";\n        var urlchar = \"[A-Za-z0-9-_.!~\\\\*'();\\\\/?:@&=+$,%]*\";\n        var dataurl = \"data:(?:\"+mediaType+\")?(?:;base64)?,\"+urlchar;\n        regex = \"(?:\"+regex+\")|(?:^\"+dataurl+\"$)\";\n      }\n\n      var PATTERN = new RegExp(regex, 'i');\n      if (!PATTERN.exec(value)) {\n        return message;\n      }\n    },\n    type: v.extend(function(value, originalOptions, attribute, attributes, globalOptions) {\n      if (v.isString(originalOptions)) {\n        originalOptions = {type: originalOptions};\n      }\n\n      if (!v.isDefined(value)) {\n        return;\n      }\n\n      var options = v.extend({}, this.options, originalOptions);\n\n      var type = options.type;\n      if (!v.isDefined(type)) {\n        throw new Error(\"No type was specified\");\n      }\n\n      var check;\n      if (v.isFunction(type)) {\n        check = type;\n      } else {\n        check = this.types[type];\n      }\n\n      if (!v.isFunction(check)) {\n        throw new Error(\"validate.validators.type.types.\" + type + \" must be a function.\");\n      }\n\n      if (!check(value, options, attribute, attributes, globalOptions)) {\n        var message = originalOptions.message ||\n          this.messages[type] ||\n          this.message ||\n          options.message ||\n          (v.isFunction(type) ? \"must be of the correct type\" : \"must be of type %{type}\");\n\n        if (v.isFunction(message)) {\n          message = message(value, originalOptions, attribute, attributes, globalOptions);\n        }\n\n        return v.format(message, {attribute: v.prettify(attribute), type: type});\n      }\n    }, {\n      types: {\n        object: function(value) {\n          return v.isObject(value) && !v.isArray(value);\n        },\n        array: v.isArray,\n        integer: v.isInteger,\n        number: v.isNumber,\n        string: v.isString,\n        date: v.isDate,\n        boolean: v.isBoolean\n      },\n      messages: {}\n    })\n  };\n\n  validate.formatters = {\n    detailed: function(errors) {return errors;},\n    flat: v.flattenErrorsToArray,\n    grouped: function(errors) {\n      var attr;\n\n      errors = v.groupErrorsByAttribute(errors);\n      for (attr in errors) {\n        errors[attr] = v.flattenErrorsToArray(errors[attr]);\n      }\n      return errors;\n    },\n    constraint: function(errors) {\n      var attr;\n      errors = v.groupErrorsByAttribute(errors);\n      for (attr in errors) {\n        errors[attr] = errors[attr].map(function(result) {\n          return result.validator;\n        }).sort();\n      }\n      return errors;\n    }\n  };\n\n  validate.exposeModule(validate, this, exports, module, define);\n}).call(this,\n        typeof exports !== 'undefined' ? /* istanbul ignore next */ exports : null,\n        typeof module !== 'undefined' ? /* istanbul ignore next */ module : null,\n        typeof define !== 'undefined' ? /* istanbul ignore next */ define : null);\n","function stringify(value) {\n    return typeof value !== \"undefined\" ? value : \"\";\n}\nconst appendQueryParams = (url, qp, replace, config) => {\n    let queryString;\n    if (typeof qp === \"string\") {\n        queryString = qp;\n    }\n    else {\n        const usp = config.polyfill(\"URLSearchParams\", true, true);\n        for (const key in qp) {\n            const value = qp[key];\n            if (qp[key] instanceof Array) {\n                for (const val of value)\n                    usp.append(key, stringify(val));\n            }\n            else {\n                usp.append(key, stringify(value));\n            }\n        }\n        queryString = usp.toString();\n    }\n    const split = url.split(\"?\");\n    if (!queryString)\n        return replace ? split[0] : url;\n    if (replace || split.length < 2)\n        return split[0] + \"?\" + queryString;\n    return url + \"&\" + queryString;\n};\n/**\n * Adds the ability to append query parameters from a javascript object.\n *\n * ```js\n * import QueryAddon from \"wretch/addons/queryString\"\n *\n * wretch().addon(QueryAddon)\n * ```\n */\nconst queryString = {\n    wretch: {\n        query(qp, replace = false) {\n            return { ...this, _url: appendQueryParams(this._url, qp, replace, this._config) };\n        }\n    }\n};\nexport default queryString;\n//# sourceMappingURL=queryString.js.map","export const JSON_MIME = \"application/json\";\nexport const CONTENT_TYPE_HEADER = \"Content-Type\";\nexport const FETCH_ERROR = Symbol();\nexport const CATCHER_FALLBACK = Symbol();\n//# sourceMappingURL=constants.js.map","import { CONTENT_TYPE_HEADER } from \"./constants.js\";\nexport function extractContentType(headers = {}) {\n    var _a;\n    return (_a = Object.entries(headers).find(([k]) => k.toLowerCase() === CONTENT_TYPE_HEADER.toLowerCase())) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function isLikelyJsonMime(value) {\n    return /^application\\/.*json.*/.test(value);\n}\nexport const mix = function (one, two, mergeArrays = false) {\n    return Object.entries(two).reduce((acc, [key, newValue]) => {\n        const value = one[key];\n        if (Array.isArray(value) && Array.isArray(newValue)) {\n            acc[key] = mergeArrays ? [...value, ...newValue] : newValue;\n        }\n        else if (typeof value === \"object\" && typeof newValue === \"object\") {\n            acc[key] = mix(value, newValue, mergeArrays);\n        }\n        else {\n            acc[key] = newValue;\n        }\n        return acc;\n    }, { ...one });\n};\n//# sourceMappingURL=utils.js.map","import { mix } from \"./utils.js\";\nconst config = {\n    // Default options\n    options: {},\n    // Error type\n    errorType: \"text\",\n    // Polyfills\n    polyfills: {\n    // fetch: null,\n    // FormData: null,\n    // URLSearchParams: null,\n    // performance: null,\n    // PerformanceObserver: null,\n    // AbortController: null\n    },\n    polyfill(p, doThrow = true, instance = false, ...args) {\n        const res = this.polyfills[p] ||\n            (typeof self !== \"undefined\" ? self[p] : null) ||\n            (typeof global !== \"undefined\" ? global[p] : null);\n        if (doThrow && !res)\n            throw new Error(p + \" is not defined\");\n        return instance && res ? new res(...args) : res;\n    }\n};\n/**\n * Sets the default fetch options that will be stored internally when instantiating wretch objects.\n *\n * ```js\n * import wretch from \"wretch\"\n *\n * wretch.options({ headers: { \"Accept\": \"application/json\" } });\n *\n * // The fetch request is sent with both headers.\n * wretch(\"...\", { headers: { \"X-Custom\": \"Header\" } }).get().res();\n * ```\n *\n * @param options Default options\n * @param replace If true, completely replaces the existing options instead of mixing in\n */\nexport function setOptions(options, replace = false) {\n    config.options = replace ? options : mix(config.options, options);\n}\n/**\n * Sets the default polyfills that will be stored internally when instantiating wretch objects.\n * Useful for browserless environments like `node.js`.\n *\n * Needed for libraries like [fetch-ponyfill](https://github.com/qubyte/fetch-ponyfill).\n *\n * ```js\n * import wretch from \"wretch\"\n *\n * wretch.polyfills({\n *   fetch: require(\"node-fetch\"),\n *   FormData: require(\"form-data\"),\n *   URLSearchParams: require(\"url\").URLSearchParams,\n * });\n *\n * // Uses the above polyfills.\n * wretch(\"...\").get().res();\n * ```\n *\n * @param polyfills An object containing the polyfills\n * @param replace If true, replaces the current polyfills instead of mixing in\n */\nexport function setPolyfills(polyfills, replace = false) {\n    config.polyfills = replace ? polyfills : mix(config.polyfills, polyfills);\n}\n/**\n * Sets the default method (text, json, …) used to parse the data contained in the response body in case of an HTTP error.\n * As with other static methods, it will affect wretch instances created after calling this function.\n *\n * _Note: if the response Content-Type header is set to \"application/json\", the body will be parsed as json regardless of the errorType._\n *\n * ```js\n * import wretch from \"wretch\"\n *\n * wretch.errorType(\"json\")\n *\n * wretch(\"http://server/which/returns/an/error/with/a/json/body\")\n *   .get()\n *   .res()\n *   .catch(error => {\n *     // error[errorType] (here, json) contains the parsed body\n *     console.log(error.json)\n *   })\n * ```\n *\n * If null, defaults to \"text\".\n */\nexport function setErrorType(errorType) {\n    config.errorType = errorType;\n}\nexport default config;\n//# sourceMappingURL=config.js.map","import { middlewareHelper } from \"./middleware.js\";\nimport { mix } from \"./utils.js\";\nimport { FETCH_ERROR, CATCHER_FALLBACK } from \"./constants.js\";\n/**\n * This class inheriting from Error is thrown when the fetch response is not \"ok\".\n * It extends Error and adds status, text and body fields.\n */\nexport class WretchError extends Error {\n}\nexport const resolver = (wretch) => {\n    const sharedState = Object.create(null);\n    wretch = wretch._addons.reduce((w, addon) => addon.beforeRequest &&\n        addon.beforeRequest(w, wretch._options, sharedState)\n        || w, wretch);\n    const { _url: url, _options: opts, _config: config, _catchers: _catchers, _resolvers: resolvers, _middlewares: middlewares, _addons: addons } = wretch;\n    const catchers = new Map(_catchers);\n    const finalOptions = mix(config.options, opts);\n    // The generated fetch request\n    let finalUrl = url;\n    const _fetchReq = middlewareHelper(middlewares)((url, options) => {\n        finalUrl = url;\n        return config.polyfill(\"fetch\")(url, options);\n    })(url, finalOptions);\n    // Throws on an http error\n    const referenceError = new Error();\n    const throwingPromise = _fetchReq\n        .catch(error => {\n        throw { [FETCH_ERROR]: error };\n    })\n        .then(response => {\n        if (!response.ok) {\n            const err = new WretchError();\n            // Enhance the error object\n            err[\"cause\"] = referenceError;\n            err.stack = err.stack + \"\\nCAUSE: \" + referenceError.stack;\n            err.response = response;\n            err.url = finalUrl;\n            if (response.type === \"opaque\") {\n                throw err;\n            }\n            return response.text().then((body) => {\n                var _a;\n                err.message = body;\n                if (config.errorType === \"json\" || ((_a = response.headers.get(\"Content-Type\")) === null || _a === void 0 ? void 0 : _a.split(\";\")[0]) === \"application/json\") {\n                    try {\n                        err.json = JSON.parse(body);\n                    }\n                    catch (e) { /* ignore */ }\n                }\n                err.text = body;\n                err[\"status\"] = response.status;\n                throw err;\n            });\n        }\n        return response;\n    });\n    // Wraps the Promise in order to dispatch the error to a matching catcher\n    const catchersWrapper = (promise) => {\n        return promise.catch(err => {\n            const fetchErrorFlag = err.hasOwnProperty(FETCH_ERROR);\n            const error = fetchErrorFlag ? err[FETCH_ERROR] : err;\n            const catcher = ((error === null || error === void 0 ? void 0 : error.status) && catchers.get(error.status)) ||\n                catchers.get(error === null || error === void 0 ? void 0 : error.name) || (fetchErrorFlag && catchers.has(FETCH_ERROR) && catchers.get(FETCH_ERROR));\n            if (catcher)\n                return catcher(error, wretch);\n            const catcherFallback = catchers.get(CATCHER_FALLBACK);\n            if (catcherFallback)\n                return catcherFallback(error, wretch);\n            throw error;\n        });\n    };\n    const bodyParser = funName => cb => funName ?\n        // If a callback is provided, then callback with the body result otherwise return the parsed body itself.\n        catchersWrapper(throwingPromise.then(_ => _ && _[funName]()).then(_ => cb ? cb(_) : _)) :\n        // No body parsing method - return the response\n        catchersWrapper(throwingPromise.then(_ => cb ? cb(_) : _));\n    const responseChain = {\n        _wretchReq: wretch,\n        _fetchReq,\n        _sharedState: sharedState,\n        res: bodyParser(null),\n        json: bodyParser(\"json\"),\n        blob: bodyParser(\"blob\"),\n        formData: bodyParser(\"formData\"),\n        arrayBuffer: bodyParser(\"arrayBuffer\"),\n        text: bodyParser(\"text\"),\n        error(errorId, cb) {\n            catchers.set(errorId, cb);\n            return this;\n        },\n        badRequest(cb) { return this.error(400, cb); },\n        unauthorized(cb) { return this.error(401, cb); },\n        forbidden(cb) { return this.error(403, cb); },\n        notFound(cb) { return this.error(404, cb); },\n        timeout(cb) { return this.error(408, cb); },\n        internalError(cb) { return this.error(500, cb); },\n        fetchError(cb) { return this.error(FETCH_ERROR, cb); },\n    };\n    const enhancedResponseChain = addons.reduce((chain, addon) => ({\n        ...chain,\n        ...addon.resolver\n    }), responseChain);\n    return resolvers.reduce((chain, r) => r(chain, wretch), enhancedResponseChain);\n};\n//# sourceMappingURL=resolver.js.map","/**\n * @private @internal\n */\nexport const middlewareHelper = (middlewares) => (fetchFunction) => {\n    return middlewares.reduceRight((acc, curr) => curr(acc), fetchFunction) || fetchFunction;\n};\n//# sourceMappingURL=middleware.js.map","import { mix, extractContentType, isLikelyJsonMime } from \"./utils.js\";\nimport { JSON_MIME, CONTENT_TYPE_HEADER, CATCHER_FALLBACK } from \"./constants.js\";\nimport { resolver } from \"./resolver.js\";\nimport config from \"./config.js\";\nexport const core = {\n    _url: \"\",\n    _options: {},\n    _config: config,\n    _catchers: new Map(),\n    _resolvers: [],\n    _deferred: [],\n    _middlewares: [],\n    _addons: [],\n    addon(addon) {\n        return { ...this, _addons: [...this._addons, addon], ...addon.wretch };\n    },\n    errorType(errorType) {\n        return {\n            ...this,\n            _config: {\n                ...this._config,\n                errorType\n            }\n        };\n    },\n    polyfills(polyfills, replace = false) {\n        return {\n            ...this,\n            _config: {\n                ...this._config,\n                polyfills: replace ? polyfills : mix(this._config.polyfills, polyfills)\n            }\n        };\n    },\n    url(_url, replace = false) {\n        if (replace)\n            return { ...this, _url };\n        const split = this._url.split(\"?\");\n        return {\n            ...this,\n            _url: split.length > 1 ?\n                split[0] + _url + \"?\" + split[1] :\n                this._url + _url\n        };\n    },\n    options(options, replace = false) {\n        return { ...this, _options: replace ? options : mix(this._options, options) };\n    },\n    headers(headerValues) {\n        return { ...this, _options: mix(this._options, { headers: headerValues || {} }) };\n    },\n    accept(headerValue) {\n        return this.headers({ Accept: headerValue });\n    },\n    content(headerValue) {\n        return this.headers({ [CONTENT_TYPE_HEADER]: headerValue });\n    },\n    auth(headerValue) {\n        return this.headers({ Authorization: headerValue });\n    },\n    catcher(errorId, catcher) {\n        const newMap = new Map(this._catchers);\n        newMap.set(errorId, catcher);\n        return { ...this, _catchers: newMap };\n    },\n    catcherFallback(catcher) {\n        return this.catcher(CATCHER_FALLBACK, catcher);\n    },\n    resolve(resolver, clear = false) {\n        return { ...this, _resolvers: clear ? [resolver] : [...this._resolvers, resolver] };\n    },\n    defer(callback, clear = false) {\n        return {\n            ...this,\n            _deferred: clear ? [callback] : [...this._deferred, callback]\n        };\n    },\n    middlewares(middlewares, clear = false) {\n        return {\n            ...this,\n            _middlewares: clear ? middlewares : [...this._middlewares, ...middlewares]\n        };\n    },\n    fetch(method = this._options.method, url = \"\", body = null) {\n        let base = this.url(url).options({ method });\n        // \"Jsonify\" the body if it is an object and if it is likely that the content type targets json.\n        const contentType = extractContentType(base._options.headers);\n        const jsonify = typeof body === \"object\" && (!base._options.headers || !contentType || isLikelyJsonMime(contentType));\n        base =\n            !body ? base :\n                jsonify ? base.json(body, contentType) :\n                    base.body(body);\n        return resolver(base\n            ._deferred\n            .reduce((acc, curr) => curr(acc, acc._url, acc._options), base));\n    },\n    get(url = \"\") {\n        return this.fetch(\"GET\", url);\n    },\n    delete(url = \"\") {\n        return this.fetch(\"DELETE\", url);\n    },\n    put(body, url = \"\") {\n        return this.fetch(\"PUT\", url, body);\n    },\n    post(body, url = \"\") {\n        return this.fetch(\"POST\", url, body);\n    },\n    patch(body, url = \"\") {\n        return this.fetch(\"PATCH\", url, body);\n    },\n    head(url = \"\") {\n        return this.fetch(\"HEAD\", url);\n    },\n    opts(url = \"\") {\n        return this.fetch(\"OPTIONS\", url);\n    },\n    body(contents) {\n        return { ...this, _options: { ...this._options, body: contents } };\n    },\n    json(jsObject, contentType) {\n        const currentContentType = extractContentType(this._options.headers);\n        return this.content(contentType ||\n            isLikelyJsonMime(currentContentType) && currentContentType ||\n            JSON_MIME).body(JSON.stringify(jsObject));\n    }\n};\n//# sourceMappingURL=core.js.map","import { setOptions, setErrorType, setPolyfills } from \"./config.js\";\nimport { core } from \"./core.js\";\nimport { WretchError } from \"./resolver.js\";\n/**\n * Creates a new wretch instance with a base url and base\n * [fetch options](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch).\n *\n * ```ts\n * import wretch from \"wretch\"\n *\n * // Reusable instance\n * const w = wretch(\"https://domain.com\", { mode: \"cors\" })\n * ```\n *\n * @param _url The base url\n * @param _options The base fetch options\n * @returns A fresh wretch instance\n */\nfunction factory(_url = \"\", _options = {}) {\n    return { ...core, _url, _options };\n}\nfactory[\"default\"] = factory;\n/** {@inheritDoc setOptions} */\nfactory.options = setOptions;\n/** {@inheritDoc setErrorType} */\nfactory.errorType = setErrorType;\n/** {@inheritDoc setPolyfills} */\nfactory.polyfills = setPolyfills;\nfactory.WretchError = WretchError;\nexport default factory;\n//# sourceMappingURL=index.js.map"],"names":["calcBezier","t","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","x","lowerBound","upperBound","currentX","currentT","i","Math","abs","binarySubdivide","steps","direction","progress","expanded","min","max","rounded","floor","ceil","namedEasings","ease","functionArgsRegex","getEasingFunction","definition","namedEasing","startsWith","args","exec","argsArray","split","parseFloat","trim","thresholds","any","all","inView","elementOrSelector","onStart","root","margin","rootMargin","amount","IntersectionObserver","elements","activeIntersections","WeakMap","observer","entries","forEach","entry","onEnd","get","target","isIntersecting","Boolean","newOnEnd","set","unobserve","delete","threshold","element","observe","disconnect","resolveElements","selectorCache","_a","document","querySelectorAll","Element","Array","from","stagger","duration","start","easing","total","fromIndex","lastIndex","getFromIndex","distance","delay","maxDelay","easingFunction","resolveOption","option","clamp","v","isCubicBezier","isArray","isFunction","value","isNumber","noop","noopReturn","SelectorSet","this","size","uid","selectors","selectorObjects","indexes","Object","create","activeIndexes","docElem","window","documentElement","matches","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","prototype","matchesSelector","el","selector","call","context","idRe","push","name","sel","m","match","slice","id","classRe","className","baseVal","Map","tagRe","toUpperCase","nodeName","map","key","chunker","parseSelectorIndexes","allIndexes","j","dup","index","allIndexesLen","concat","length","rest","findByPrototype","ary","proto","len","item","isPrototypeOf","sortById","a","b","logDefaultIndexUsed","add","data","obj","indexProto","objs","selectorIndexes","selectorIndex","remove","k","selIndex","removedIds","removeAll","arguments","splice","queryAll","len2","results","els","join","sort","len3","keys","matchedIds","bubbleEvents","captureEvents","propagationStopped","immediatePropagationStopped","currentTargets","currentTargetDesc","getOwnPropertyDescriptor","Event","before","subject","verb","fn","source","apply","trackPropagation","trackImmediate","getCurrentTarget","defineCurrentTarget","event","getter","defineProperty","configurable","enumerable","dispatch","eventPhase","_","canDispatch","type","queue","reverse","node","nodeType","_matches","matched","observers","unshift","parentElement","len1","on","capture","undefined","events","addEventListener","fire","detail","dispatchEvent","CustomEvent","bubbles","cancelable","easeInOutQuad","c","d","_typeof","Symbol","iterator","constructor","stop","offset","a11y","timeStart","timeElapsed","next","callback","top","getBoundingClientRect","loop","timeCurrent","scrollTo","requestAnimationFrame","setAttribute","focus","options","scrollY","pageYOffset","querySelector","jumper","defaults","endDelay","repeat","time","seconds","milliseconds","stopAnimation","animation","needsCommit","playState","commitStyles","cancel","e","createAnimation","factory","withControls","animationFactory","Proxy","animations","filter","controls","activeAnimation","finished","Promise","selectFinished","catch","isEasingGenerator","isEasingList","mix","fillOffset","remaining","offsetProgress","Animation","output","keyframes","initialDuration","autoplay","startTime","rate","cancelTimestamp","totalDuration","resolve","reject","custom","updateDuration","interpolate$1","input","defaultOffset","remainder","progressInRange","segmentEasing","rangeSize","wrap","getEasingForSegment","interpolate","tick","timestamp","pauseTime","currentIteration","iterationProgress","iterationIsOdd","p","latest","frameRequestId","play","now","performance","pause","finish","cancelAnimationFrame","currentTime","playbackRate","MotionValue","setAnimation","then","clearAnimation","generator","getAnimationData","has","transforms","values","axes","transformAlias","y","z","rotation","syntax","initialValue","toDefaultUnit","baseTransformProperties","translate","rotate","scale","skew","transformDefinitions","asTransformCssVar","axis","compareTransformOrder","indexOf","transformLookup","Set","isTransform","buildTransformTemplate","reduce","transformListToString","template","isCssVar","registeredProperties","testAnimation","createElement","animate","featureTests","cssRegisterProperty","CSS","hasOwnProperty","waapi","partialKeyframes","opacity","linearEasing","supports","convertEasing","points","numPoints","round","substring","generateLinearEasingPoints","cubicBezierAsString","getStyleName","style","getPropertyValue","getComputedStyle","setProperty","animateStyle","keyframesDefinition","AnimationPolyfill","record","__MOTION_DEV_TOOLS_RECORD","isRecording","persist","allowWebkitAcceleration","valueIsTransform","canAnimateNatively","array","transform","addTransformToElement","motionValue","motionValues","getMotionValue","readInitialValue","_b","hydrateKeyframes","keyframesList","toUnit","finalKeyframe","unit","getUnitConverter","registerProperty","inherits","registerCssVariable","some","animationOptions","iterations","fill","thisEasing","onfinish","oncancel","assign","getOptions","AnimatePolyfill","numElements","animationFactories","valueOptions","animateProgress","keyframesOrOptions","exports","module","define","validate","attributes","constraints","extend","runValidations","r","isPromise","error","Error","processValidationResults","attr","version","major","minor","patch","metadata","toString","format","isEmpty","EMPTY_STRING_REGEXP","validatorName","validators","validator","validatorOptions","isDomElement","isJqueryElement","collectFormValues","getDeepObjectValue","result","attribute","globalOptions","errors","pruneEmptyErrors","expandMultipleErrors","convertErrorMessages","formatters","async","WrapErrors","wrapErrors","cleanAttributes","waitForResults","err","single","fullMessages","memo","isNaN","isInteger","isBoolean","isObject","isDate","Date","isDefined","o","isString","jquery","HTMLElement","test","str","vals","replace","FORMAT_REGEXP","m0","m1","m2","String","prettify","toFixed","s","JSON","stringify","toLowerCase","stringifyValue","isHash","contains","unique","forEachKeyInKeypath","object","keypath","escape","form","inputs","getAttribute","sanitizeFormValue","checked","multiple","selected","_val","selectedIndex","nullify","capitalize","ret","msg","errorInfo","groupErrorsByAttribute","list","flattenErrorsToArray","self","whitelist","whitelistCreator","last","cleanRecursive","w","ow","buildObjectWhitelist","exposeModule","amd","warn","console","presence","allowEmpty","message","is","maximum","minimum","tokenizer","val","wrongLength","count","tooShort","tooLong","notValid","numericality","checks","greaterThan","greaterThanOrEqualTo","equalTo","lessThan","lessThanOrEqualTo","divisibleBy","strict","pattern","onlyInteger","RegExp","noStrings","notInteger","odd","notOdd","even","notEven","datetime","parse","earliest","NaN","dateOnly","tooEarly","date","tooLate","flags","inclusion","within","exclusion","email","PATTERN","equality","otherValue","comparator","v1","v2","url","schemes","allowLocal","allowDataUrl","regex","tld","originalOptions","check","types","messages","integer","number","string","boolean","detailed","flat","grouped","constraint","appendQueryParams","qp","config","queryString","usp","polyfill","append","wretch","query","_url","_config","CONTENT_TYPE_HEADER","FETCH_ERROR","CATCHER_FALLBACK","extractContentType","headers","find","isLikelyJsonMime","one","two","mergeArrays","acc","newValue","errorType","polyfills","doThrow","instance","res","global","WretchError","resolver","sharedState","_addons","addon","beforeRequest","_options","opts","_catchers","_resolvers","resolvers","_middlewares","middlewares","addons","catchers","finalOptions","finalUrl","_fetchReq","fetchFunction","reduceRight","curr","middlewareHelper","referenceError","throwingPromise","response","ok","stack","text","body","json","status","bodyParser","funName","cb","fetchErrorFlag","catcher","catcherFallback","responseChain","_wretchReq","_sharedState","blob","formData","arrayBuffer","errorId","badRequest","unauthorized","forbidden","notFound","timeout","internalError","fetchError","enhancedResponseChain","chain","core","_deferred","headerValues","accept","headerValue","Accept","content","auth","Authorization","newMap","clear","defer","fetch","method","base","contentType","jsonify","put","post","head","contents","jsObject","currentContentType"],"sourceRoot":""}