{"version":3,"sources":["webpack:///../node_modules/@ux/slider/dist/es/slider.js","webpack:///../node_modules/@ux/panel/dist/es/panel.js","webpack:///./domain/constants/imageAspectRatio.ts","webpack:///./presentation/utils/imageAspectRatioPercentage.ts","webpack:///./presentation/utils/createImageUrl.ts"],"names":["_isPlaceholder","a","_curry1","fn","f1","arguments","length","apply","this","_curry2","f2","b","_b","_a","_arity","n","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","Error","curryN","_curryN","received","combined","argsIdx","left","combinedIdx","result","_curry3","f3","c","_c","_isArray","Array","isArray","val","Object","prototype","toString","call","_isTransformer","obj","_dispatchable","methodNames","xf","args","slice","pop","idx","transducer","_xfBase","max","_isString","x","_isArrayLike","nodeType","hasOwnProperty","XWrap","f","acc","bind","thisObj","_iterableReduce","iter","step","next","done","value","_methodReduce","methodName","symIterator","Symbol","iterator","_reduce","list","_xwrap","len","_arrayReduce","reduce","TypeError","XMap","input","_xmap","_has","prop","_isArguments","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","item","keys","nIdx","ks","checkArgsLength","map","functor","key","_map","_isInteger","Number","isInteger","nth","offset","charAt","paths","pathsArray","p","path","pathAr","always","values","props","vals","_pipe","g","_checkForMethod","methodname","tail","fromIndex","toIndex","Infinity","pipe","cond","pairs","pair","_objectAssign$1","assign","target","output","source","nextKey","_isNumber","NaN","merge","l","r","negate","stylesheet","theme","isMinSm","isMinMd","isMinLg","children","itemsInViewport","hasScroll","spacing","flexBasis","calculateFlexBasis","peak","default","X","A","listStyle","display","flexWrap","justifyContent","position","flexGrow","flexShrink","flexDirection","inner","scrollSnapType","WebkitOverflowScrolling","MsOverflowStyle","scrollbarColor","overflowX","scrollBehavior","scrollSnapAlign","minWidth","scrollTablet","maxWidth","mergeArrays","getVisibleLimit","Slider","ownerProps","visibleItems","enhance","styles","sliderRef","onScroll","createElement","Fragment","fluid","style","ref","className","ad","i","undefined","_defineProperty","defineProperty","enumerable","configurable","writable","_curvatureMap","Kind","_curvatureMap$1","roundAllBorders","borderRadius","topLeftRadius","topRightRadius","bottomLeftRadius","bottomRightRadius","curvatureMap","OFF","WEAK","STRONG","Panel","border","_ref","palette","curvature","radius","root","width","color","grey10","overflow","backgroundColor","borderless","borderWidth","getPanelColorway","kind","against","HIGHLIGHT","highlightContrast","PRIMARY","PRIMARY_GRADIENT","primaryContrast","DARK","grey04","getColor","borderColor","ALERT","red01","WARNING","yellow01","NEUTRAL","LIGHT","grey02","highlight","primary","getBorderColor","curvatureMap$1","colorway","stylesheet$1","enhance$1","ImageAspectRatio","imageAspectRatioPercentage","ratio","W16H9","W4H3","W1H1","W32H9","W64H9","W3H4","W9H16","W9H32","hasIllustration","isNotNilOrEmpty","media","currentLanguage","createPaintbrushUrl","illustration","urlLanguageParse","imageUrl"],"mappings":"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","file":"pex-static/90/6.c54e27a6f5d8958aca14.chunk.js","sourcesContent":["import React from 'react';\nimport { withProps } from '@team-griffin/rehook';\nimport { puree } from '@ux/pure-enhance';\nimport cssSides, { Side } from '@team-griffin/css-sides';\nimport { useTheme, gu2px } from '@ux/theme-utils';\nimport { percentage } from '@ux/style-utils';\nimport { useStyles } from '@team-griffin/stylr';\nimport { Container } from '@ux/grid';\nimport { withBreakpointsHook } from '@ux/responsive';\nimport { Helmet } from 'react-helmet';\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.F\n * @example\n *\n *      R.T(); //=> true\n */\nvar T = function () {\n  return true;\n};\n\nfunction _isPlaceholder(a) {\n  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nfunction _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n}\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nfunction _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n\n      case 1:\n        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n          return fn(a, _b);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b);\n        }) : fn(a, b);\n    }\n  };\n}\n\nfunction _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.apply(this, arguments);\n      };\n\n    case 1:\n      return function (a0) {\n        return fn.apply(this, arguments);\n      };\n\n    case 2:\n      return function (a0, a1) {\n        return fn.apply(this, arguments);\n      };\n\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.apply(this, arguments);\n      };\n\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.apply(this, arguments);\n      };\n\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.apply(this, arguments);\n      };\n\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.apply(this, arguments);\n      };\n\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.apply(this, arguments);\n      };\n\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.apply(this, arguments);\n      };\n\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.apply(this, arguments);\n      };\n\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.apply(this, arguments);\n      };\n\n    default:\n      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n}\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nfunction _curryN(length, received, fn) {\n  return function () {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n\n      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n\n      combined[combinedIdx] = result;\n\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n\n      combinedIdx += 1;\n    }\n\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n}\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      const sumArgs = (...args) => R.sum(args);\n *\n *      const curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\nvar curryN =\n/*#__PURE__*/\n_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n\n  return _arity(length, _curryN(length, [], fn));\n});\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nfunction _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n\n      case 1:\n        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        });\n\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _curry1(function (_c) {\n          return fn(a, b, _c);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {\n          return fn(_a, _b, c);\n        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b, c);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b, c);\n        }) : _isPlaceholder(c) ? _curry1(function (_c) {\n          return fn(a, b, _c);\n        }) : fn(a, b, c);\n    }\n  };\n}\n\n/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nvar _isArray = Array.isArray || function _isArray(val) {\n  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};\n\nfunction _isTransformer(obj) {\n  return obj != null && typeof obj['@@transducer/step'] === 'function';\n}\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer [xf] to return a new transformer (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\n\nfunction _dispatchable(methodNames, xf, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n\n    var args = Array.prototype.slice.call(arguments, 0);\n    var obj = args.pop();\n\n    if (!_isArray(obj)) {\n      var idx = 0;\n\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, args);\n        }\n\n        idx += 1;\n      }\n\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n\n    return fn.apply(this, arguments);\n  };\n}\n\nvar _xfBase = {\n  init: function () {\n    return this.xf['@@transducer/init']();\n  },\n  result: function (result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n\n/**\n * Returns the larger of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.maxBy, R.min\n * @example\n *\n *      R.max(789, 123); //=> 789\n *      R.max('a', 'b'); //=> 'b'\n */\n\nvar max =\n/*#__PURE__*/\n_curry2(function max(a, b) {\n  return b > a ? b : a;\n});\n\nfunction _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n\n  return result;\n}\n\nfunction _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      _isArrayLike([]); //=> true\n *      _isArrayLike(true); //=> false\n *      _isArrayLike({}); //=> false\n *      _isArrayLike({length: 10}); //=> false\n *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\n\nvar _isArrayLike =\n/*#__PURE__*/\n_curry1(function isArrayLike(x) {\n  if (_isArray(x)) {\n    return true;\n  }\n\n  if (!x) {\n    return false;\n  }\n\n  if (typeof x !== 'object') {\n    return false;\n  }\n\n  if (_isString(x)) {\n    return false;\n  }\n\n  if (x.nodeType === 1) {\n    return !!x.length;\n  }\n\n  if (x.length === 0) {\n    return true;\n  }\n\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n\n  return false;\n});\n\nvar XWrap =\n/*#__PURE__*/\nfunction () {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n\n  XWrap.prototype['@@transducer/init'] = function () {\n    throw new Error('init not implemented on XWrap');\n  };\n\n  XWrap.prototype['@@transducer/result'] = function (acc) {\n    return acc;\n  };\n\n  XWrap.prototype['@@transducer/step'] = function (acc, x) {\n    return this.f(acc, x);\n  };\n\n  return XWrap;\n}();\n\nfunction _xwrap(fn) {\n  return new XWrap(fn);\n}\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      const log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\nvar bind =\n/*#__PURE__*/\n_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\n\nfunction _arrayReduce(xf, acc, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    acc = xf['@@transducer/step'](acc, list[idx]);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    idx += 1;\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n  var step = iter.next();\n\n  while (!step.done) {\n    acc = xf['@@transducer/step'](acc, step.value);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    step = iter.next();\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _methodReduce(xf, acc, obj, methodName) {\n  return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\nfunction _reduce(fn, acc, list) {\n  if (typeof fn === 'function') {\n    fn = _xwrap(fn);\n  }\n\n  if (_isArrayLike(list)) {\n    return _arrayReduce(fn, acc, list);\n  }\n\n  if (typeof list['fantasy-land/reduce'] === 'function') {\n    return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n  }\n\n  if (list[symIterator] != null) {\n    return _iterableReduce(fn, acc, list[symIterator]());\n  }\n\n  if (typeof list.next === 'function') {\n    return _iterableReduce(fn, acc, list);\n  }\n\n  if (typeof list.reduce === 'function') {\n    return _methodReduce(fn, acc, list, 'reduce');\n  }\n\n  throw new TypeError('reduce: list must be array or iterable');\n}\n\nvar XMap =\n/*#__PURE__*/\nfunction () {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XMap.prototype['@@transducer/step'] = function (result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return XMap;\n}();\n\nvar _xmap =\n/*#__PURE__*/\n_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\n\nfunction _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar toString = Object.prototype.toString;\n\nvar _isArguments =\n/*#__PURE__*/\nfunction () {\n  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n    return toString.call(x) === '[object Arguments]';\n  } : function _isArguments(x) {\n    return _has('callee', x);\n  };\n}();\n\nvar hasEnumBug = !\n/*#__PURE__*/\n{\n  toString: null\n}.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug\n\nvar hasArgsEnumBug =\n/*#__PURE__*/\nfunction () {\n\n  return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (list[idx] === item) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n};\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @see R.keysIn, R.values\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\n\n\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n}) :\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  if (Object(obj) !== obj) {\n    return [];\n  }\n\n  var prop, nIdx;\n  var ks = [];\n\n  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n\n  for (prop in obj) {\n    if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n      ks[ks.length] = prop;\n    }\n  }\n\n  if (hasEnumBug) {\n    nIdx = nonEnumerableProps.length - 1;\n\n    while (nIdx >= 0) {\n      prop = nonEnumerableProps[nIdx];\n\n      if (_has(prop, obj) && !contains(ks, prop)) {\n        ks[ks.length] = prop;\n      }\n\n      nIdx -= 1;\n    }\n  }\n\n  return ks;\n});\n\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => (a -> b) -> f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @see R.transduce, R.addIndex\n * @example\n *\n *      const double = x => x * 2;\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\n\nvar map =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {\n  switch (Object.prototype.toString.call(functor)) {\n    case '[object Function]':\n      return curryN(functor.length, function () {\n        return fn.call(this, functor.apply(this, arguments));\n      });\n\n    case '[object Object]':\n      return _reduce(function (acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n\n    default:\n      return _map(fn, functor);\n  }\n}));\n\n/**\n * Determine if the passed argument is an integer.\n *\n * @private\n * @param {*} n\n * @category Type\n * @return {Boolean}\n */\nvar _isInteger = Number.isInteger || function _isInteger(n) {\n  return n << 0 === n;\n};\n\n/**\n * Returns the nth element of the given list or string. If n is negative the\n * element at index length + n is returned.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> a | Undefined\n * @sig Number -> String -> String\n * @param {Number} offset\n * @param {*} list\n * @return {*}\n * @example\n *\n *      const list = ['foo', 'bar', 'baz', 'quux'];\n *      R.nth(1, list); //=> 'bar'\n *      R.nth(-1, list); //=> 'quux'\n *      R.nth(-99, list); //=> undefined\n *\n *      R.nth(2, 'abc'); //=> 'c'\n *      R.nth(3, 'abc'); //=> ''\n * @symb R.nth(-1, [a, b, c]) = c\n * @symb R.nth(0, [a, b, c]) = a\n * @symb R.nth(1, [a, b, c]) = b\n */\n\nvar nth =\n/*#__PURE__*/\n_curry2(function nth(offset, list) {\n  var idx = offset < 0 ? list.length + offset : offset;\n  return _isString(list) ? list.charAt(idx) : list[idx];\n});\n\n/**\n * Retrieves the values at given paths of an object.\n *\n * @func\n * @memberOf R\n * @since v0.27.0\n * @category Object\n * @typedefn Idx = [String | Int]\n * @sig [Idx] -> {a} -> [a | Undefined]\n * @param {Array} pathsArray The array of paths to be fetched.\n * @param {Object} obj The object to retrieve the nested properties from.\n * @return {Array} A list consisting of values at paths specified by \"pathsArray\".\n * @see R.path\n * @example\n *\n *      R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]\n *      R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]\n */\n\nvar paths =\n/*#__PURE__*/\n_curry2(function paths(pathsArray, obj) {\n  return pathsArray.map(function (paths) {\n    var val = obj;\n    var idx = 0;\n    var p;\n\n    while (idx < paths.length) {\n      if (val == null) {\n        return;\n      }\n\n      p = paths[idx];\n      val = _isInteger(p) ? nth(p, val) : val[p];\n      idx += 1;\n    }\n\n    return val;\n  });\n});\n\n/**\n * Retrieve the value at a given path.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> a | Undefined\n * @param {Array} path The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path`.\n * @see R.prop, R.nth\n * @example\n *\n *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n *      R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1\n *      R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2\n */\n\nvar path =\n/*#__PURE__*/\n_curry2(function path(pathAr, obj) {\n  return paths([pathAr], obj)[0];\n});\n\n/**\n * Returns a function that when supplied an object returns the indicated\n * property of that object, if it exists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig Idx -> {s: a} -> a | Undefined\n * @param {String|Number} p The property name or array index\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path, R.nth\n * @example\n *\n *      R.prop('x', {x: 100}); //=> 100\n *      R.prop('x', {}); //=> undefined\n *      R.prop(0, [100]); //=> 100\n *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4\n */\n\nvar prop =\n/*#__PURE__*/\n_curry2(function prop(p, obj) {\n  return path([p], obj);\n});\n\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to shortcut the iteration.\n *\n * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function\n * is *(value, acc)*.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present. When\n * doing so, it is up to the user to handle the [`R.reduced`](#reduced)\n * shortcuting, as this is not implemented by `reduce`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex, R.reduceRight\n * @example\n *\n *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10\n *      //          -               -10\n *      //         / \\              / \\\n *      //        -   4           -6   4\n *      //       / \\              / \\\n *      //      -   3   ==>     -3   3\n *      //     / \\              / \\\n *      //    -   2           -1   2\n *      //   / \\              / \\\n *      //  0   1            0   1\n *\n * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)\n */\n\nvar reduce =\n/*#__PURE__*/\n_curry3(_reduce);\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      const t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\n\nvar always =\n/*#__PURE__*/\n_curry1(function always(val) {\n  return function () {\n    return val;\n  };\n});\n\n/**\n * Returns a list of all the enumerable own properties of the supplied object.\n * Note that the order of the output array is not guaranteed across different\n * JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own properties.\n * @see R.valuesIn, R.keys\n * @example\n *\n *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n */\n\nvar values =\n/*#__PURE__*/\n_curry1(function values(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var vals = [];\n  var idx = 0;\n\n  while (idx < len) {\n    vals[idx] = obj[props[idx]];\n    idx += 1;\n  }\n\n  return vals;\n});\n\nfunction _pipe(f, g) {\n  return function () {\n    return g.call(this, f.apply(this, arguments));\n  };\n}\n\n/**\n * This checks whether a function has a [methodname] function. If it isn't an\n * array it will execute that function otherwise it will default to the ramda\n * implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\n\nfunction _checkForMethod(methodname, fn) {\n  return function () {\n    var length = arguments.length;\n\n    if (length === 0) {\n      return fn();\n    }\n\n    var obj = arguments[length - 1];\n    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n  };\n}\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * Dispatches to the `slice` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\n\nvar slice =\n/*#__PURE__*/\n_curry3(\n/*#__PURE__*/\n_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * Dispatches to the `slice` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.head, R.init, R.last\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\n\nvar tail =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_checkForMethod('tail',\n/*#__PURE__*/\nslice(1, Infinity)));\n\n/**\n * Performs left-to-right function composition. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * **Note:** The result of pipe is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      const f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))\n */\n\nfunction pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n\n  return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}\n\n/**\n * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.\n * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments\n * to `fn` are applied to each of the predicates in turn until one returns a\n * \"truthy\" value, at which point `fn` returns the result of applying its\n * arguments to the corresponding transformer. If none of the predicates\n * matches, `fn` returns undefined.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Logic\n * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n * @param {Array} pairs A list of [predicate, transformer]\n * @return {Function}\n * @see R.ifElse, R.unless, R.when\n * @example\n *\n *      const fn = R.cond([\n *        [R.equals(0),   R.always('water freezes at 0°C')],\n *        [R.equals(100), R.always('water boils at 100°C')],\n *        [R.T,           temp => 'nothing special happens at ' + temp + '°C']\n *      ]);\n *      fn(0); //=> 'water freezes at 0°C'\n *      fn(50); //=> 'nothing special happens at 50°C'\n *      fn(100); //=> 'water boils at 100°C'\n */\n\nvar cond =\n/*#__PURE__*/\n_curry1(function cond(pairs) {\n  var arity = reduce(max, 0, map(function (pair) {\n    return pair[0].length;\n  }, pairs));\n  return _arity(arity, function () {\n    var idx = 0;\n\n    while (idx < pairs.length) {\n      if (pairs[idx][0].apply(this, arguments)) {\n        return pairs[idx][1].apply(this, arguments);\n      }\n\n      idx += 1;\n    }\n  });\n});\n\nfunction _objectAssign(target) {\n  if (target == null) {\n    throw new TypeError('Cannot convert undefined or null to object');\n  }\n\n  var output = Object(target);\n  var idx = 1;\n  var length = arguments.length;\n\n  while (idx < length) {\n    var source = arguments[idx];\n\n    if (source != null) {\n      for (var nextKey in source) {\n        if (_has(nextKey, source)) {\n          output[nextKey] = source[nextKey];\n        }\n      }\n    }\n\n    idx += 1;\n  }\n\n  return output;\n}\n\nvar _objectAssign$1 = typeof Object.assign === 'function' ? Object.assign : _objectAssign;\n\nfunction _isNumber(x) {\n  return Object.prototype.toString.call(x) === '[object Number]';\n}\n\n/**\n * Returns the number of elements in the array by returning `list.length`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [a] -> Number\n * @param {Array} list The array to inspect.\n * @return {Number} The length of the array.\n * @example\n *\n *      R.length([]); //=> 0\n *      R.length([1, 2, 3]); //=> 3\n */\n\nvar length =\n/*#__PURE__*/\n_curry1(function length(list) {\n  return list != null && _isNumber(list.length) ? list.length : NaN;\n});\n\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @deprecated since v0.26.0\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const withDefaults = R.merge({x: 0, y: 0});\n *      withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.merge(a, b) = {...a, ...b}\n */\n\nvar merge =\n/*#__PURE__*/\n_curry2(function merge(l, r) {\n  return _objectAssign$1({}, l, r);\n});\n\n/**\n * Negates its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number}\n * @example\n *\n *      R.negate(42); //=> -42\n */\n\nvar negate =\n/*#__PURE__*/\n_curry1(function negate(n) {\n  return -n;\n});\n\nconst calculateFlexBasis = (itemsInViewport, hasScroll, length, isMinLg) => {\n  // simple, show 1 at a time\n  if (itemsInViewport === 1) {\n    return percentage(100);\n  } // We don't need to scroll\n\n\n  if (!hasScroll) {\n    // do we only have 2 cards and are on desktop? use a 4-column basis\n    if (length === 2 && isMinLg) {\n      return percentage(4 / 12 * 100);\n    } // otherwise fill the container with equal width items\n\n\n    return percentage(100 / length);\n  } // we have items off screen, so give them width based on how many\n  // should be in the viewport at once\n\n\n  return percentage(100 / itemsInViewport);\n};\nvar stylesheet = (props => {\n  const {\n    theme\n  } = useTheme();\n  const {\n    isMinSm,\n    isMinMd,\n    isMinLg,\n    children,\n    itemsInViewport,\n    hasScroll\n  } = props;\n  const {\n    spacing\n  } = theme;\n  const length$1 = pipe(length, max(1))(children);\n  const flexBasis = calculateFlexBasis(itemsInViewport, hasScroll, length$1, isMinLg); // optional spacing for peaking extra items\n\n  const peak = hasScroll ? gu2px(1, spacing) : 0;\n  return useStyles({\n    default: {\n      list: { ...cssSides('padding', Side.X, 0),\n        ...cssSides('margin', Side.A, 0),\n        listStyle: 'none',\n        display: 'flex',\n        flexWrap: 'nowrap',\n        justifyContent: 'center'\n      },\n      item: {\n        position: 'relative',\n        ...cssSides('padding', Side.X, gu2px(0.5, spacing)),\n        flexGrow: 0,\n        flexShrink: 0,\n        flexBasis: `calc(${flexBasis} - ${peak}px)`,\n        display: 'flex',\n        flexDirection: 'column'\n      }\n    },\n    hasScroll: {\n      inner: { ...cssSides('margin', Side.X, negate(gu2px(1, spacing)))\n      },\n      list: { ...cssSides('padding', Side.X, gu2px(2, spacing)),\n        scrollSnapType: 'x mandatory',\n        WebkitOverflowScrolling: 'touch',\n        //@ts-ignore\n        MsOverflowStyle: '-ms-autohiding-scrollbar',\n        scrollbarColor: 'transparent transparent',\n        overflowX: 'scroll',\n        scrollBehavior: 'smooth',\n        justifyContent: 'flex-start'\n      },\n      item: {\n        // peak items either side on mobile\n        //@ts-ignore\n        scrollSnapAlign: 'center'\n      },\n      offset: {\n        minWidth: gu2px(1, spacing)\n      }\n    },\n    scrollTablet: {\n      item: {\n        //@ts-ignore\n        scrollSnapAlign: 'start'\n      }\n    },\n    isMinMd: {\n      item: {\n        flexBasis: flexBasis,\n        maxWidth: percentage(50)\n      }\n    },\n    isMinLg: {\n      item: {\n        maxWidth: percentage(33.333)\n      }\n    }\n  }, [{\n    isMinSm\n  }, {\n    isMinMd\n  }, {\n    isMinLg\n  }, {\n    hasScroll\n  }, {\n    scrollTablet: isMinSm && hasScroll\n  }]);\n});\n\nconst mergeArrays = pipe(merge, values);\nconst getVisibleLimit = cond([[prop('isMinXl'), always(4)], [prop('isMinLg'), always(3)], [prop('isMinMd'), always(2)], [prop('isMinSm'), always(1)], [T, always(0)]]);\nconst enhance = puree('Slider')(withBreakpointsHook, withProps(ownerProps => {\n  // xs => xl (visible items per breakpoint)\n  //@ts-ignore\n  const visibleItems = mergeArrays([1, 2, 3, 3, 4], ownerProps.visibleItems);\n  const activeVisibleIndex = getVisibleLimit(withBreakpointsHook(ownerProps));\n  const itemsInViewport = visibleItems[activeVisibleIndex]; //@ts-ignore\n\n  const hasScroll = ownerProps.children.length > itemsInViewport;\n  return {\n    itemsInViewport,\n    hasScroll\n  };\n}), //@ts-ignore\nwithProps(props => stylesheet(props)));\n\nconst PureSlider = ({\n  styles,\n  children,\n  sliderRef,\n  onScroll,\n  hasScroll\n}) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Helmet, null, /*#__PURE__*/React.createElement(\"style\", {\n  key: \"ux_slider\"\n}, `.slider::-webkit-scrollbar {\n          display: none;\n        }`)), /*#__PURE__*/React.createElement(Container, {\n  fluid: hasScroll\n}, /*#__PURE__*/React.createElement(\"div\", {\n  style: styles.inner\n}, /*#__PURE__*/React.createElement(\"ul\", {\n  ref: sliderRef,\n  onScroll: onScroll,\n  style: styles.list,\n  className: \"slider\"\n}, children.map(function (ad, i) {\n  return /*#__PURE__*/React.createElement(\"li\", {\n    key: i,\n    style: styles.item\n  }, children[i]);\n}, undefined), /*#__PURE__*/React.createElement(\"li\", {\n  style: styles.offset\n})))));\n\nvar Slider = enhance(PureSlider); // eslint-disable-next-line no-underscore-dangle\n\nexport default Slider;\n","import React from 'react';\nimport { puree } from '@ux/pure-enhance';\nimport { defaultProps, withProps } from '@team-griffin/rehook';\nimport { useStyles } from '@team-griffin/stylr';\nimport { Curvature, useTheme, gu2px, Colorway } from '@ux/theme-utils';\nimport longhand from '@team-griffin/css-longhand';\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nvar roundAllBorders = function roundAllBorders(borderRadius) {\n  return longhand('border', {\n    topLeftRadius: borderRadius,\n    topRightRadius: borderRadius,\n    bottomLeftRadius: borderRadius,\n    bottomRightRadius: borderRadius\n  });\n};\n\nvar _curvatureMap;\nvar curvatureMap = (_curvatureMap = {}, _defineProperty(_curvatureMap, Curvature.OFF, 0), _defineProperty(_curvatureMap, Curvature.WEAK, 1), _defineProperty(_curvatureMap, Curvature.STRONG, 3), _curvatureMap);\nvar stylesheet = (function (_ref) {\n  var border = _ref.border,\n      style = _ref.style;\n\n  var _useTheme = useTheme(),\n      theme = _useTheme.theme;\n\n  var palette = theme.palette,\n      curvature = theme.curvature,\n      spacing = theme.spacing;\n  var radius = gu2px(curvatureMap[curvature], spacing);\n  return useStyles({\n    default: {\n      root: Object.assign(Object.assign(Object.assign(Object.assign({}, longhand('border', {\n        width: 1,\n        style: 'solid',\n        color: palette.grey10\n      })), roundAllBorders(radius)), {\n        overflow: 'hidden',\n        backgroundColor: '#fff'\n      }), style)\n    },\n    borderless: {\n      root: {\n        borderWidth: 0\n      }\n    }\n  }, [{\n    borderless: border === false\n  }, {\n    style: style\n  }]);\n});\n\nvar enhance = puree('Panel')(defaultProps({\n  style: {},\n  border: true\n}), withProps(function (props) {\n  return stylesheet(props);\n}));\nvar PurePanel = function PurePanel(_ref) {\n  var children = _ref.children,\n      styles = _ref.styles;\n  return React.createElement(\"div\", {\n    style: styles.root\n  }, children);\n};\nvar Panel = enhance(PurePanel); // eslint-disable-next-line no-underscore-dangle\n\nvar Kind;\n\n(function (Kind) {\n  Kind[\"NEUTRAL\"] = \"NEUTRAL\";\n  Kind[\"PRIMARY\"] = \"PRIMARY\";\n  Kind[\"HIGHLIGHT\"] = \"HIGHLIGHT\";\n  Kind[\"WARNING\"] = \"WARNING\";\n  Kind[\"ALERT\"] = \"ALERT\";\n})(Kind || (Kind = {}));\n\nvar _curvatureMap$1;\n\nvar getColor = function getColor(against, palette) {\n  if (against === Colorway.HIGHLIGHT) {\n    return palette.highlightContrast;\n  }\n\n  if (against === Colorway.PRIMARY || against === Colorway.PRIMARY_GRADIENT) {\n    return palette.primaryContrast;\n  }\n\n  if (against === Colorway.DARK) {\n    return '#fff';\n  }\n\n  return palette.grey04;\n};\n\nvar getBorderColor = function getBorderColor(kind, against, palette) {\n  if (kind === Kind.ALERT) {\n    return palette.red01;\n  }\n\n  if (kind === Kind.WARNING) {\n    return palette.yellow01;\n  }\n\n  if (kind === Kind.NEUTRAL) {\n    if (against === Colorway.LIGHT || against === Colorway.NEUTRAL) {\n      return palette.grey02;\n    }\n\n    return '#fff';\n  }\n\n  if (kind === Kind.HIGHLIGHT) {\n    if (against === Colorway.HIGHLIGHT) {\n      return palette.highlightContrast;\n    }\n\n    return palette.highlight;\n  }\n\n  if (kind === Kind.PRIMARY) {\n    if (against === Colorway.PRIMARY || against === Colorway.PRIMARY_GRADIENT) {\n      return palette.primaryContrast;\n    }\n\n    return palette.primary;\n  }\n\n  return palette.primary;\n};\n\nvar getPanelColorway = function getPanelColorway(kind, against, palette) {\n  var color = getColor(against, palette);\n  var borderColor = getBorderColor(kind, against, palette);\n  return {\n    color: color,\n    borderColor: borderColor\n  };\n};\n\nvar curvatureMap$1 = (_curvatureMap$1 = {}, _defineProperty(_curvatureMap$1, Curvature.OFF, 0), _defineProperty(_curvatureMap$1, Curvature.WEAK, 0.25), _defineProperty(_curvatureMap$1, Curvature.STRONG, 2), _curvatureMap$1);\nvar stylesheet$1 = (function (_ref) {\n  var kind = _ref.kind,\n      against = _ref.against,\n      style = _ref.style;\n\n  var _useTheme = useTheme(),\n      theme = _useTheme.theme;\n\n  var palette = theme.palette,\n      curvature = theme.curvature,\n      spacing = theme.spacing;\n  var radius = gu2px(curvatureMap$1[curvature], spacing);\n  var colorway = getPanelColorway(kind, against, palette);\n  return useStyles({\n    default: {\n      root: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, longhand('border', {\n        width: 2,\n        style: 'solid'\n      })), roundAllBorders(radius)), {\n        overflow: 'hidden'\n      }), colorway), style)\n    }\n  });\n});\n\nvar enhance$1 = puree('InnerPanel')(defaultProps({\n  style: {},\n  kind: Kind.PRIMARY,\n  against: Colorway.LIGHT\n}), withProps(function (props) {\n  return stylesheet$1(props);\n}));\n\nvar PureInnerPanel = function PureInnerPanel(_ref) {\n  var children = _ref.children,\n      styles = _ref.styles;\n  return React.createElement(\"div\", {\n    style: styles.root\n  }, children);\n};\n\nvar InnerPanel = enhance$1(PureInnerPanel);\n\nexport default Panel;\nexport { InnerPanel, Kind, Panel };\n","export enum ImageAspectRatio {\n  W16H9 = '16:9',\n  W4H3 = '4:3',\n  W1H1 = '1:1',\n  W32H9 = '32:9',\n  W64H9 = '64:9',\n  W3H4 = '3:4',\n  W9H16 = '9:16',\n  W9H32 = '9:32',\n}\n","import { ImageAspectRatio } from 'domain/constants/imageAspectRatio';\n\nexport const imageAspectRatioPercentage = (ratio: ImageAspectRatio | undefined) => {\n  if (ratio == null) {\n    return '56.25%';\n  }\n  const map: { [key in ImageAspectRatio]: number } = {\n    [ImageAspectRatio.W16H9]: 56.25,\n    [ImageAspectRatio.W4H3]: 75,\n    [ImageAspectRatio.W1H1]: 100,\n    [ImageAspectRatio.W32H9]: 28.125,\n    [ImageAspectRatio.W64H9]: 14.0625,\n    [ImageAspectRatio.W3H4]: 133.3333,\n    [ImageAspectRatio.W9H16]: 177.7778,\n    [ImageAspectRatio.W9H32]: 355.5556,\n  };\n  return `${map[ratio] || 56.25}%`;\n};\n","// /*\n// createImageUrl(\n//   {\n//     illustration: ?String,\n//     imageUrl: ?String,\n//   },\n//   theme,\n//   currentLanguage,\n// );\n\n//   Returns a painbtrush URL if an illustration is provided,\n//   otherwise returns a static imageUrl\n// */\n\nimport { createPaintbrushUrl } from '@ux/illustrations';\nimport { isNotNilOrEmpty } from '@team-griffin/capra';\nimport * as r from 'ramda';\nimport urlLanguageParse from 'presentation/utils/urlLanguageParse';\nimport { Theme } from '@ux/theme-utils';\n\nconst hasIllustration = r.propSatisfies(isNotNilOrEmpty, 'illustration');\n\nexport default (\n  media: {\n    illustration: string | undefined;\n    imageUrl: string | undefined;\n  },\n  theme: Theme,\n  currentLanguage?: string,\n) =>\n  r.ifElse(\n    hasIllustration,\n    () =>\n      createPaintbrushUrl(\n        media.illustration ?? '',\n        // @ts-ignore: mismatching types after upgrade\n        theme,\n      ),\n    () => urlLanguageParse(media.imageUrl ?? '', currentLanguage ?? ''),\n  )(media);\n"],"sourceRoot":""}