{"version":3,"sources":["webpack:///./node_modules/vue-matomo/dist/vue-matomo.js","webpack:///./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack:///./node_modules/vue-class-component/dist/vue-class-component.esm.js","webpack:///./node_modules/vue-property-decorator/lib/vue-property-decorator.js","webpack:///./node_modules/tinycolor2/tinycolor.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/vue-base64-file-upload/index.js"],"names":["e","r","module","exports","window","t","o","n","i","l","call","m","c","d","Object","defineProperty","enumerable","get","Symbol","toStringTag","value","__esModule","create","bind","default","prototype","hasOwnProperty","p","s","Piwik","getAsyncTracker","Promise","document","createElement","async","defer","src","head","getElementsByTagName","appendChild","onload","onerror","resolve","href","u","a","debug","disableCookies","requireCookieConsent","enableHeartBeatTimer","enableLinkTracking","heartBeatTimerInterval","requireConsent","trackInitialView","trackSiteSearch","trackerFileName","trackerUrl","trackerScriptUrl","userId","cookieDomain","domains","preInitActions","keyword","category","resultsCount","console","router","fullPath","meta","analyticsIgnore","title","setReferrerUrl","setCustomUrl","trackPageView","Number","version","split","config","globalProperties","$piwik","$matomo","provide","currentRoute","afterEach","Date","now","setInterval","clearInterval","Error","concat","arguments","length","assign","host","siteId","f","_paq","push","forEach","then","catch","target","error","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","options","_compiled","functional","_scopeId","context","this","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","_typeof","obj","iterator","constructor","_defineProperty","key","configurable","writable","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","Array","isArray","arr2","iter","toString","from","TypeError","reflectionIsSupported","Reflect","defineMetadata","getOwnMetadataKeys","copyReflectionMetadata","to","forwardMetadata","getOwnPropertyNames","propertyKey","metaKeys","metaKey","metadata","getOwnMetadata","fakeArray","__proto__","hasProto","createDecorator","factory","index","Ctor","__decorators__","undefined","isPrimitive","type","collectDataFromConstructor","vm","Component","originalInit","_init","_this","keys","props","set","data","plainData","$internalHooks","componentFactory","name","_componentTag","proto","indexOf","descriptor","getOwnPropertyDescriptor","methods","mixins","computed","decorators","fn","superProto","getPrototypeOf","Super","Extended","extend","forwardStaticMembers","shouldIgnore","callee","caller","Original","extendedDescriptor","superDescriptor","registerHooks","apply","reflectMetadataIsSupported","getMetadata","applyMetadata","Prop","componentOptions","k","Ref","refKey","cache","$refs","Math","trimLeft","trimRight","tinyCounter","mathRound","round","mathMin","min","mathMax","max","mathRandom","random","tinycolor","color","opts","rgb","inputToRGB","_originalInput","_r","_g","g","_b","b","_a","_roundA","_format","format","_gradientType","gradientType","_ok","ok","_tc_id","v","stringInputToObject","isValidCSSUnit","rgbToRgb","String","substr","convertToPercentage","hsvToRgb","hslToRgb","boundAlpha","bound01","rgbToHsl","hue2rgb","q","rgbToHsv","floor","mod","rgbToHex","allow3Char","hex","pad2","charAt","join","rgbaToHex","allow4Char","convertDecimalToHex","rgbaToArgbHex","desaturate","amount","hsl","toHsl","clamp01","saturate","greyscale","lighten","brighten","toRgb","darken","spin","hue","complement","triad","tetrad","splitcomplement","analogous","results","slices","part","ret","monochromatic","hsv","toHsv","modification","isDark","getBrightness","isLight","isValid","getOriginalInput","getFormat","getAlpha","getLuminance","RsRGB","GsRGB","BsRGB","R","G","B","pow","setAlpha","toHsvString","toHslString","toHex","toHexString","toHex8","toHex8String","toRgbString","toPercentageRgb","toPercentageRgbString","toName","hexNames","toFilter","secondColor","hex8String","secondHex8String","formatSet","formattedString","hasAlpha","needsAlphaFormat","clone","_applyModification","args","slice","_applyCombination","fromRatio","newColor","equals","color1","color2","mix","rgb1","rgb2","rgba","readability","c1","c2","isReadable","wcag2","wcag2Parms","out","validateWCAG2Parms","level","size","mostReadable","baseColor","colorList","includeFallbackColors","bestColor","bestScore","names","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","flip","flipped","parseFloat","isNaN","isOnePointZero","processPercent","isPercentage","parseInt","abs","val","parseIntFromHex","convertHexToDecimal","matchers","CSS_INTEGER","CSS_NUMBER","CSS_UNIT","PERMISSIVE_MATCH3","PERMISSIVE_MATCH4","RegExp","hsla","hsva","hex3","hex6","hex4","hex8","exec","replace","toLowerCase","match","named","parms","toUpperCase","__decorate","desc","decorate","FileReader","imageClass","inputClass","accept","maxSize","disablePreview","Boolean","fileName","placeholder","defaultPreview","file","preview","visiblePreview","wrapperStyles","fileInputStyles","textInputStyles","previewImage","onChange","files","dataTransfer","$emit","reader","dataURI","result","readAsDataURL","template"],"mappings":"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","file":"js/chunk-vendors~1c3a2c3f.5a982aaa.js","sourcesContent":["!function(e,r){if(\"object\"==typeof exports&&\"object\"==typeof module)module.exports=r();else if(\"function\"==typeof define&&define.amd)define([],r);else{var t=r();for(var o in t)(\"object\"==typeof exports?exports:e)[o]=t[o]}}(window,(function(){return function(e){var r={};function t(o){if(r[o])return r[o].exports;var n=r[o]={i:o,l:!1,exports:{}};return e[o].call(n.exports,n,n.exports,t),n.l=!0,n.exports}return t.m=e,t.c=r,t.d=function(e,r,o){t.o(e,r)||Object.defineProperty(e,r,{enumerable:!0,get:o})},t.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},t.t=function(e,r){if(1&r&&(e=t(e)),8&r)return e;if(4&r&&\"object\"==typeof e&&e&&e.__esModule)return e;var o=Object.create(null);if(t.r(o),Object.defineProperty(o,\"default\",{enumerable:!0,value:e}),2&r&&\"string\"!=typeof e)for(var n in e)t.d(o,n,function(r){return e[r]}.bind(null,n));return o},t.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(r,\"a\",r),r},t.o=function(e,r){return Object.prototype.hasOwnProperty.call(e,r)},t.p=\"\",t(t.s=0)}([function(e,r,t){\"use strict\";function o(){return window.Piwik.getAsyncTracker()}function n(e){return new Promise((function(r,t){var o=document.createElement(\"script\");o.async=!0,o.defer=!0,o.src=e,(document.head||document.getElementsByTagName(\"head\")[0]).appendChild(o),o.onload=r,o.onerror=t}))}function i(e,r){return e.resolve(r).href}t.r(r),t.d(r,\"matomoKey\",(function(){return u})),t.d(r,\"default\",(function(){return d}));var a={debug:!1,disableCookies:!1,requireCookieConsent:!1,enableHeartBeatTimer:!1,enableLinkTracking:!0,heartBeatTimerInterval:15,requireConsent:!1,trackInitialView:!0,trackSiteSearch:!1,trackerFileName:\"matomo\",trackerUrl:void 0,trackerScriptUrl:void 0,userId:void 0,cookieDomain:void 0,domains:void 0,preInitActions:[]},u=\"Matomo\";function c(e,r,t){if(\"function\"==typeof e.trackSiteSearch){var n=e.trackSiteSearch(r);if(n)return void function(e,r){var t=r.keyword,n=r.category,i=r.resultsCount,a=o();e.debug&&console.debug(\"[vue-matomo] Site Search \"+t),a.trackSiteSearch(t,n,i)}(e,n)}!function(e,r,t){var n,a,u,c=o();if(e.router){if(a=i(e.router,r.fullPath),u=t&&t.fullPath?i(e.router,t.fullPath):void 0,r.meta.analyticsIgnore)return void(e.debug&&console.debug(\"[vue-matomo] Ignoring \"+a));e.debug&&console.debug(\"[vue-matomo] Tracking \"+a),n=r.meta.title||a}u&&c.setReferrerUrl(u);a&&c.setCustomUrl(a);c.trackPageView(n)}(e,r,t)}function s(e,r){var t=o();if(Number(e.version.split(\".\")[0])>2?(e.config.globalProperties.$piwik=t,e.config.globalProperties.$matomo=t,e.provide(u,t)):(e.prototype.$piwik=t,e.prototype.$matomo=t),r.trackInitialView&&r.router){var n=r.router.currentRoute.value?r.router.currentRoute.value:r.router.currentRoute;c(r,n)}r.router&&r.router.afterEach((function(e,o){c(r,e,o),r.enableLinkTracking&&t.enableLinkTracking()}))}function l(){return new Promise((function(e,r){var t=Date.now(),o=setInterval((function(){if(window.Piwik)return clearInterval(o),e();if(Date.now()>=t+3e3)throw clearInterval(o),new Error(\"[vue-matomo]: window.Piwik undefined after waiting for \".concat(3e3,\"ms\"))}),50)}))}function d(e){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},t=Object.assign({},a,r),o=t.host,i=t.siteId,u=t.trackerFileName,c=t.trackerUrl,d=t.trackerScriptUrl,f=d||\"\".concat(o,\"/\").concat(u,\".js\"),p=c||\"\".concat(o,\"/\").concat(u,\".php\");window._paq=window._paq||[],window._paq.push([\"setTrackerUrl\",p]),window._paq.push([\"setSiteId\",i]),t.requireConsent&&window._paq.push([\"requireConsent\"]),t.userId&&window._paq.push([\"setUserId\",t.userId]),t.enableLinkTracking&&window._paq.push([\"enableLinkTracking\"]),t.disableCookies&&window._paq.push([\"disableCookies\"]),t.requireCookieConsent&&window._paq.push([\"requireCookieConsent\"]),t.enableHeartBeatTimer&&window._paq.push([\"enableHeartBeatTimer\",t.heartBeatTimerInterval]),t.cookieDomain&&window._paq.push([\"setCookieDomain\",t.cookieDomain]),t.domains&&window._paq.push([\"setDomains\",t.domains]),t.preInitActions.forEach((function(e){return window._paq.push(e)})),n(f).then((function(){return l()})).then((function(){return s(e,t)})).catch((function(e){if(e.target)return console.error(\"[vue-matomo] An error occurred trying to load \".concat(e.target.src,\". \")+\"If the file exists you may have an ad- or trackingblocker enabled.\");console.error(e)}))}}])}));","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n  scriptExports,\n  render,\n  staticRenderFns,\n  functionalTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier, /* server only */\n  shadowMode /* vue-cli only */\n) {\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (render) {\n    options.render = render\n    options.staticRenderFns = staticRenderFns\n    options._compiled = true\n  }\n\n  // functional template\n  if (functionalTemplate) {\n    options.functional = true\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = 'data-v-' + scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) { // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = shadowMode\n      ? function () {\n        injectStyles.call(\n          this,\n          (options.functional ? this.parent : this).$root.$options.shadowRoot\n        )\n      }\n      : injectStyles\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // for template-only hot-reload because in that case the render fn doesn't\n      // go through the normalizer\n      options._injectStyles = hook\n      // register for functional component in vue file\n      var originalRender = options.render\n      options.render = function renderWithStyleInjection (h, context) {\n        hook.call(context)\n        return originalRender(h, context)\n      }\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate\n      options.beforeCreate = existing\n        ? [].concat(existing, hook)\n        : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n","/**\n  * vue-class-component v7.2.6\n  * (c) 2015-present Evan You\n  * @license MIT\n  */\nimport Vue from 'vue';\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\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\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  }\n}\n\nfunction _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\n// The rational behind the verbose Reflect-feature check below is the fact that there are polyfills\n// which add an implementation for Reflect.defineMetadata but not for Reflect.getOwnMetadataKeys.\n// Without this check consumers will encounter hard to track down runtime errors.\nfunction reflectionIsSupported() {\n  return typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;\n}\nfunction copyReflectionMetadata(to, from) {\n  forwardMetadata(to, from);\n  Object.getOwnPropertyNames(from.prototype).forEach(function (key) {\n    forwardMetadata(to.prototype, from.prototype, key);\n  });\n  Object.getOwnPropertyNames(from).forEach(function (key) {\n    forwardMetadata(to, from, key);\n  });\n}\n\nfunction forwardMetadata(to, from, propertyKey) {\n  var metaKeys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);\n  metaKeys.forEach(function (metaKey) {\n    var metadata = propertyKey ? Reflect.getOwnMetadata(metaKey, from, propertyKey) : Reflect.getOwnMetadata(metaKey, from);\n\n    if (propertyKey) {\n      Reflect.defineMetadata(metaKey, metadata, to, propertyKey);\n    } else {\n      Reflect.defineMetadata(metaKey, metadata, to);\n    }\n  });\n}\n\nvar fakeArray = {\n  __proto__: []\n};\nvar hasProto = fakeArray instanceof Array;\nfunction createDecorator(factory) {\n  return function (target, key, index) {\n    var Ctor = typeof target === 'function' ? target : target.constructor;\n\n    if (!Ctor.__decorators__) {\n      Ctor.__decorators__ = [];\n    }\n\n    if (typeof index !== 'number') {\n      index = undefined;\n    }\n\n    Ctor.__decorators__.push(function (options) {\n      return factory(options, key, index);\n    });\n  };\n}\nfunction mixins() {\n  for (var _len = arguments.length, Ctors = new Array(_len), _key = 0; _key < _len; _key++) {\n    Ctors[_key] = arguments[_key];\n  }\n\n  return Vue.extend({\n    mixins: Ctors\n  });\n}\nfunction isPrimitive(value) {\n  var type = _typeof(value);\n\n  return value == null || type !== 'object' && type !== 'function';\n}\nfunction warn(message) {\n  if (typeof console !== 'undefined') {\n    console.warn('[vue-class-component] ' + message);\n  }\n}\n\nfunction collectDataFromConstructor(vm, Component) {\n  // override _init to prevent to init as Vue instance\n  var originalInit = Component.prototype._init;\n\n  Component.prototype._init = function () {\n    var _this = this;\n\n    // proxy to actual vm\n    var keys = Object.getOwnPropertyNames(vm); // 2.2.0 compat (props are no longer exposed as self properties)\n\n    if (vm.$options.props) {\n      for (var key in vm.$options.props) {\n        if (!vm.hasOwnProperty(key)) {\n          keys.push(key);\n        }\n      }\n    }\n\n    keys.forEach(function (key) {\n      Object.defineProperty(_this, key, {\n        get: function get() {\n          return vm[key];\n        },\n        set: function set(value) {\n          vm[key] = value;\n        },\n        configurable: true\n      });\n    });\n  }; // should be acquired class property values\n\n\n  var data = new Component(); // restore original _init to avoid memory leak (#209)\n\n  Component.prototype._init = originalInit; // create plain data object\n\n  var plainData = {};\n  Object.keys(data).forEach(function (key) {\n    if (data[key] !== undefined) {\n      plainData[key] = data[key];\n    }\n  });\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (!(Component.prototype instanceof Vue) && Object.keys(plainData).length > 0) {\n      warn('Component class must inherit Vue or its descendant class ' + 'when class property is used.');\n    }\n  }\n\n  return plainData;\n}\n\nvar $internalHooks = ['data', 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeDestroy', 'destroyed', 'beforeUpdate', 'updated', 'activated', 'deactivated', 'render', 'errorCaptured', 'serverPrefetch' // 2.6\n];\nfunction componentFactory(Component) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  options.name = options.name || Component._componentTag || Component.name; // prototype props.\n\n  var proto = Component.prototype;\n  Object.getOwnPropertyNames(proto).forEach(function (key) {\n    if (key === 'constructor') {\n      return;\n    } // hooks\n\n\n    if ($internalHooks.indexOf(key) > -1) {\n      options[key] = proto[key];\n      return;\n    }\n\n    var descriptor = Object.getOwnPropertyDescriptor(proto, key);\n\n    if (descriptor.value !== void 0) {\n      // methods\n      if (typeof descriptor.value === 'function') {\n        (options.methods || (options.methods = {}))[key] = descriptor.value;\n      } else {\n        // typescript decorated data\n        (options.mixins || (options.mixins = [])).push({\n          data: function data() {\n            return _defineProperty({}, key, descriptor.value);\n          }\n        });\n      }\n    } else if (descriptor.get || descriptor.set) {\n      // computed properties\n      (options.computed || (options.computed = {}))[key] = {\n        get: descriptor.get,\n        set: descriptor.set\n      };\n    }\n  });\n  (options.mixins || (options.mixins = [])).push({\n    data: function data() {\n      return collectDataFromConstructor(this, Component);\n    }\n  }); // decorate options\n\n  var decorators = Component.__decorators__;\n\n  if (decorators) {\n    decorators.forEach(function (fn) {\n      return fn(options);\n    });\n    delete Component.__decorators__;\n  } // find super\n\n\n  var superProto = Object.getPrototypeOf(Component.prototype);\n  var Super = superProto instanceof Vue ? superProto.constructor : Vue;\n  var Extended = Super.extend(options);\n  forwardStaticMembers(Extended, Component, Super);\n\n  if (reflectionIsSupported()) {\n    copyReflectionMetadata(Extended, Component);\n  }\n\n  return Extended;\n}\nvar reservedPropertyNames = [// Unique id\n'cid', // Super Vue constructor\n'super', // Component options that will be used by the component\n'options', 'superOptions', 'extendOptions', 'sealedOptions', // Private assets\n'component', 'directive', 'filter'];\nvar shouldIgnore = {\n  prototype: true,\n  arguments: true,\n  callee: true,\n  caller: true\n};\n\nfunction forwardStaticMembers(Extended, Original, Super) {\n  // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable\n  Object.getOwnPropertyNames(Original).forEach(function (key) {\n    // Skip the properties that should not be overwritten\n    if (shouldIgnore[key]) {\n      return;\n    } // Some browsers does not allow reconfigure built-in properties\n\n\n    var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);\n\n    if (extendedDescriptor && !extendedDescriptor.configurable) {\n      return;\n    }\n\n    var descriptor = Object.getOwnPropertyDescriptor(Original, key); // If the user agent does not support `__proto__` or its family (IE <= 10),\n    // the sub class properties may be inherited properties from the super class in TypeScript.\n    // We need to exclude such properties to prevent to overwrite\n    // the component options object which stored on the extended constructor (See #192).\n    // If the value is a referenced value (object or function),\n    // we can check equality of them and exclude it if they have the same reference.\n    // If it is a primitive value, it will be forwarded for safety.\n\n    if (!hasProto) {\n      // Only `cid` is explicitly exluded from property forwarding\n      // because we cannot detect whether it is a inherited property or not\n      // on the no `__proto__` environment even though the property is reserved.\n      if (key === 'cid') {\n        return;\n      }\n\n      var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);\n\n      if (!isPrimitive(descriptor.value) && superDescriptor && superDescriptor.value === descriptor.value) {\n        return;\n      }\n    } // Warn if the users manually declare reserved properties\n\n\n    if (process.env.NODE_ENV !== 'production' && reservedPropertyNames.indexOf(key) >= 0) {\n      warn(\"Static property name '\".concat(key, \"' declared on class '\").concat(Original.name, \"' \") + 'conflicts with reserved property name of Vue internal. ' + 'It may cause unexpected behavior of the component. Consider renaming the property.');\n    }\n\n    Object.defineProperty(Extended, key, descriptor);\n  });\n}\n\nfunction Component(options) {\n  if (typeof options === 'function') {\n    return componentFactory(options);\n  }\n\n  return function (Component) {\n    return componentFactory(Component, options);\n  };\n}\n\nComponent.registerHooks = function registerHooks(keys) {\n  $internalHooks.push.apply($internalHooks, _toConsumableArray(keys));\n};\n\nexport default Component;\nexport { createDecorator, mixins };\n","/** vue-property-decorator verson 8.5.1 MIT LICENSE copyright 2020 kaorun343 */\n/// <reference types='reflect-metadata'/>\n'use strict';\nimport Vue from 'vue';\nimport Component, { createDecorator, mixins } from 'vue-class-component';\nexport { Component, Vue, mixins as Mixins };\n/** Used for keying reactive provide/inject properties */\nvar reactiveInjectKey = '__reactiveInject__';\n/**\n * decorator of an inject\n * @param from key\n * @return PropertyDecorator\n */\nexport function Inject(options) {\n    return createDecorator(function (componentOptions, key) {\n        if (typeof componentOptions.inject === 'undefined') {\n            componentOptions.inject = {};\n        }\n        if (!Array.isArray(componentOptions.inject)) {\n            componentOptions.inject[key] = options || key;\n        }\n    });\n}\n/**\n * decorator of a reactive inject\n * @param from key\n * @return PropertyDecorator\n */\nexport function InjectReactive(options) {\n    return createDecorator(function (componentOptions, key) {\n        if (typeof componentOptions.inject === 'undefined') {\n            componentOptions.inject = {};\n        }\n        if (!Array.isArray(componentOptions.inject)) {\n            var fromKey_1 = !!options ? options.from || options : key;\n            var defaultVal_1 = (!!options && options.default) || undefined;\n            if (!componentOptions.computed)\n                componentOptions.computed = {};\n            componentOptions.computed[key] = function () {\n                var obj = this[reactiveInjectKey];\n                return obj ? obj[fromKey_1] : defaultVal_1;\n            };\n            componentOptions.inject[reactiveInjectKey] = reactiveInjectKey;\n        }\n    });\n}\nfunction produceProvide(original) {\n    var provide = function () {\n        var _this = this;\n        var rv = typeof original === 'function' ? original.call(this) : original;\n        rv = Object.create(rv || null);\n        // set reactive services (propagates previous services if necessary)\n        rv[reactiveInjectKey] = this[reactiveInjectKey] || {};\n        for (var i in provide.managed) {\n            rv[provide.managed[i]] = this[i];\n        }\n        var _loop_1 = function (i) {\n            rv[provide.managedReactive[i]] = this_1[i]; // Duplicates the behavior of `@Provide`\n            Object.defineProperty(rv[reactiveInjectKey], provide.managedReactive[i], {\n                enumerable: true,\n                get: function () { return _this[i]; },\n            });\n        };\n        var this_1 = this;\n        for (var i in provide.managedReactive) {\n            _loop_1(i);\n        }\n        return rv;\n    };\n    provide.managed = {};\n    provide.managedReactive = {};\n    return provide;\n}\nfunction needToProduceProvide(original) {\n    return (typeof original !== 'function' ||\n        (!original.managed && !original.managedReactive));\n}\n/**\n * decorator of a provide\n * @param key key\n * @return PropertyDecorator | void\n */\nexport function Provide(key) {\n    return createDecorator(function (componentOptions, k) {\n        var provide = componentOptions.provide;\n        if (needToProduceProvide(provide)) {\n            provide = componentOptions.provide = produceProvide(provide);\n        }\n        provide.managed[k] = key || k;\n    });\n}\n/**\n * decorator of a reactive provide\n * @param key key\n * @return PropertyDecorator | void\n */\nexport function ProvideReactive(key) {\n    return createDecorator(function (componentOptions, k) {\n        var provide = componentOptions.provide;\n        // inject parent reactive services (if any)\n        if (!Array.isArray(componentOptions.inject)) {\n            componentOptions.inject = componentOptions.inject || {};\n            componentOptions.inject[reactiveInjectKey] = {\n                from: reactiveInjectKey,\n                default: {},\n            };\n        }\n        if (needToProduceProvide(provide)) {\n            provide = componentOptions.provide = produceProvide(provide);\n        }\n        provide.managedReactive[k] = key || k;\n    });\n}\n/** @see {@link https://github.com/vuejs/vue-class-component/blob/master/src/reflect.ts} */\nvar reflectMetadataIsSupported = typeof Reflect !== 'undefined' && typeof Reflect.getMetadata !== 'undefined';\nfunction applyMetadata(options, target, key) {\n    if (reflectMetadataIsSupported) {\n        if (!Array.isArray(options) &&\n            typeof options !== 'function' &&\n            typeof options.type === 'undefined') {\n            var type = Reflect.getMetadata('design:type', target, key);\n            if (type !== Object) {\n                options.type = type;\n            }\n        }\n    }\n}\n/**\n * decorator of model\n * @param  event event name\n * @param options options\n * @return PropertyDecorator\n */\nexport function Model(event, options) {\n    if (options === void 0) { options = {}; }\n    return function (target, key) {\n        applyMetadata(options, target, key);\n        createDecorator(function (componentOptions, k) {\n            ;\n            (componentOptions.props || (componentOptions.props = {}))[k] = options;\n            componentOptions.model = { prop: k, event: event || k };\n        })(target, key);\n    };\n}\n/**\n * decorator of a prop\n * @param  options the options for the prop\n * @return PropertyDecorator | void\n */\nexport function Prop(options) {\n    if (options === void 0) { options = {}; }\n    return function (target, key) {\n        applyMetadata(options, target, key);\n        createDecorator(function (componentOptions, k) {\n            ;\n            (componentOptions.props || (componentOptions.props = {}))[k] = options;\n        })(target, key);\n    };\n}\n/**\n * decorator of a synced prop\n * @param propName the name to interface with from outside, must be different from decorated property\n * @param options the options for the synced prop\n * @return PropertyDecorator | void\n */\nexport function PropSync(propName, options) {\n    if (options === void 0) { options = {}; }\n    // @ts-ignore\n    return function (target, key) {\n        applyMetadata(options, target, key);\n        createDecorator(function (componentOptions, k) {\n            ;\n            (componentOptions.props || (componentOptions.props = {}))[propName] = options;\n            (componentOptions.computed || (componentOptions.computed = {}))[k] = {\n                get: function () {\n                    return this[propName];\n                },\n                set: function (value) {\n                    // @ts-ignore\n                    this.$emit(\"update:\" + propName, value);\n                },\n            };\n        })(target, key);\n    };\n}\n/**\n * decorator of a watch function\n * @param  path the path or the expression to observe\n * @param  WatchOption\n * @return MethodDecorator\n */\nexport function Watch(path, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.deep, deep = _a === void 0 ? false : _a, _b = options.immediate, immediate = _b === void 0 ? false : _b;\n    return createDecorator(function (componentOptions, handler) {\n        if (typeof componentOptions.watch !== 'object') {\n            componentOptions.watch = Object.create(null);\n        }\n        var watch = componentOptions.watch;\n        if (typeof watch[path] === 'object' && !Array.isArray(watch[path])) {\n            watch[path] = [watch[path]];\n        }\n        else if (typeof watch[path] === 'undefined') {\n            watch[path] = [];\n        }\n        watch[path].push({ handler: handler, deep: deep, immediate: immediate });\n    });\n}\n// Code copied from Vue/src/shared/util.js\nvar hyphenateRE = /\\B([A-Z])/g;\nvar hyphenate = function (str) { return str.replace(hyphenateRE, '-$1').toLowerCase(); };\n/**\n * decorator of an event-emitter function\n * @param  event The name of the event\n * @return MethodDecorator\n */\nexport function Emit(event) {\n    return function (_target, propertyKey, descriptor) {\n        var key = hyphenate(propertyKey);\n        var original = descriptor.value;\n        descriptor.value = function emitter() {\n            var _this = this;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var emit = function (returnValue) {\n                var emitName = event || key;\n                if (returnValue === undefined) {\n                    if (args.length === 0) {\n                        _this.$emit(emitName);\n                    }\n                    else if (args.length === 1) {\n                        _this.$emit(emitName, args[0]);\n                    }\n                    else {\n                        _this.$emit.apply(_this, [emitName].concat(args));\n                    }\n                }\n                else {\n                    if (args.length === 0) {\n                        _this.$emit(emitName, returnValue);\n                    }\n                    else if (args.length === 1) {\n                        _this.$emit(emitName, returnValue, args[0]);\n                    }\n                    else {\n                        _this.$emit.apply(_this, [emitName, returnValue].concat(args));\n                    }\n                }\n            };\n            var returnValue = original.apply(this, args);\n            if (isPromise(returnValue)) {\n                returnValue.then(emit);\n            }\n            else {\n                emit(returnValue);\n            }\n            return returnValue;\n        };\n    };\n}\n/**\n * decorator of a ref prop\n * @param refKey the ref key defined in template\n */\nexport function Ref(refKey) {\n    return createDecorator(function (options, key) {\n        options.computed = options.computed || {};\n        options.computed[key] = {\n            cache: false,\n            get: function () {\n                return this.$refs[refKey || key];\n            },\n        };\n    });\n}\nfunction isPromise(obj) {\n    return obj instanceof Promise || (obj && typeof obj.then === 'function');\n}\n","// TinyColor v1.4.2\n// https://github.com/bgrins/TinyColor\n// Brian Grinstead, MIT License\n\n(function(Math) {\n\nvar trimLeft = /^\\s+/,\n    trimRight = /\\s+$/,\n    tinyCounter = 0,\n    mathRound = Math.round,\n    mathMin = Math.min,\n    mathMax = Math.max,\n    mathRandom = Math.random;\n\nfunction tinycolor (color, opts) {\n\n    color = (color) ? color : '';\n    opts = opts || { };\n\n    // If input is already a tinycolor, return itself\n    if (color instanceof tinycolor) {\n       return color;\n    }\n    // If we are called as a function, call using new instead\n    if (!(this instanceof tinycolor)) {\n        return new tinycolor(color, opts);\n    }\n\n    var rgb = inputToRGB(color);\n    this._originalInput = color,\n    this._r = rgb.r,\n    this._g = rgb.g,\n    this._b = rgb.b,\n    this._a = rgb.a,\n    this._roundA = mathRound(100*this._a) / 100,\n    this._format = opts.format || rgb.format;\n    this._gradientType = opts.gradientType;\n\n    // Don't let the range of [0,255] come back in [0,1].\n    // Potentially lose a little bit of precision here, but will fix issues where\n    // .5 gets interpreted as half of the total, instead of half of 1\n    // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n    if (this._r < 1) { this._r = mathRound(this._r); }\n    if (this._g < 1) { this._g = mathRound(this._g); }\n    if (this._b < 1) { this._b = mathRound(this._b); }\n\n    this._ok = rgb.ok;\n    this._tc_id = tinyCounter++;\n}\n\ntinycolor.prototype = {\n    isDark: function() {\n        return this.getBrightness() < 128;\n    },\n    isLight: function() {\n        return !this.isDark();\n    },\n    isValid: function() {\n        return this._ok;\n    },\n    getOriginalInput: function() {\n      return this._originalInput;\n    },\n    getFormat: function() {\n        return this._format;\n    },\n    getAlpha: function() {\n        return this._a;\n    },\n    getBrightness: function() {\n        //http://www.w3.org/TR/AERT#color-contrast\n        var rgb = this.toRgb();\n        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    },\n    getLuminance: function() {\n        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n        var rgb = this.toRgb();\n        var RsRGB, GsRGB, BsRGB, R, G, B;\n        RsRGB = rgb.r/255;\n        GsRGB = rgb.g/255;\n        BsRGB = rgb.b/255;\n\n        if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}\n        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}\n        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}\n        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);\n    },\n    setAlpha: function(value) {\n        this._a = boundAlpha(value);\n        this._roundA = mathRound(100*this._a) / 100;\n        return this;\n    },\n    toHsv: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };\n    },\n    toHsvString: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);\n        return (this._a == 1) ?\n          \"hsv(\"  + h + \", \" + s + \"%, \" + v + \"%)\" :\n          \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \"+ this._roundA + \")\";\n    },\n    toHsl: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };\n    },\n    toHslString: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);\n        return (this._a == 1) ?\n          \"hsl(\"  + h + \", \" + s + \"%, \" + l + \"%)\" :\n          \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \"+ this._roundA + \")\";\n    },\n    toHex: function(allow3Char) {\n        return rgbToHex(this._r, this._g, this._b, allow3Char);\n    },\n    toHexString: function(allow3Char) {\n        return '#' + this.toHex(allow3Char);\n    },\n    toHex8: function(allow4Char) {\n        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);\n    },\n    toHex8String: function(allow4Char) {\n        return '#' + this.toHex8(allow4Char);\n    },\n    toRgb: function() {\n        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };\n    },\n    toRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \")\" :\n          \"rgba(\" + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \", \" + this._roundA + \")\";\n    },\n    toPercentageRgb: function() {\n        return { r: mathRound(bound01(this._r, 255) * 100) + \"%\", g: mathRound(bound01(this._g, 255) * 100) + \"%\", b: mathRound(bound01(this._b, 255) * 100) + \"%\", a: this._a };\n    },\n    toPercentageRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%)\" :\n          \"rgba(\" + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%, \" + this._roundA + \")\";\n    },\n    toName: function() {\n        if (this._a === 0) {\n            return \"transparent\";\n        }\n\n        if (this._a < 1) {\n            return false;\n        }\n\n        return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;\n    },\n    toFilter: function(secondColor) {\n        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);\n        var secondHex8String = hex8String;\n        var gradientType = this._gradientType ? \"GradientType = 1, \" : \"\";\n\n        if (secondColor) {\n            var s = tinycolor(secondColor);\n            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);\n        }\n\n        return \"progid:DXImageTransform.Microsoft.gradient(\"+gradientType+\"startColorstr=\"+hex8String+\",endColorstr=\"+secondHex8String+\")\";\n    },\n    toString: function(format) {\n        var formatSet = !!format;\n        format = format || this._format;\n\n        var formattedString = false;\n        var hasAlpha = this._a < 1 && this._a >= 0;\n        var needsAlphaFormat = !formatSet && hasAlpha && (format === \"hex\" || format === \"hex6\" || format === \"hex3\" || format === \"hex4\" || format === \"hex8\" || format === \"name\");\n\n        if (needsAlphaFormat) {\n            // Special case for \"transparent\", all other non-alpha formats\n            // will return rgba when there is transparency.\n            if (format === \"name\" && this._a === 0) {\n                return this.toName();\n            }\n            return this.toRgbString();\n        }\n        if (format === \"rgb\") {\n            formattedString = this.toRgbString();\n        }\n        if (format === \"prgb\") {\n            formattedString = this.toPercentageRgbString();\n        }\n        if (format === \"hex\" || format === \"hex6\") {\n            formattedString = this.toHexString();\n        }\n        if (format === \"hex3\") {\n            formattedString = this.toHexString(true);\n        }\n        if (format === \"hex4\") {\n            formattedString = this.toHex8String(true);\n        }\n        if (format === \"hex8\") {\n            formattedString = this.toHex8String();\n        }\n        if (format === \"name\") {\n            formattedString = this.toName();\n        }\n        if (format === \"hsl\") {\n            formattedString = this.toHslString();\n        }\n        if (format === \"hsv\") {\n            formattedString = this.toHsvString();\n        }\n\n        return formattedString || this.toHexString();\n    },\n    clone: function() {\n        return tinycolor(this.toString());\n    },\n\n    _applyModification: function(fn, args) {\n        var color = fn.apply(null, [this].concat([].slice.call(args)));\n        this._r = color._r;\n        this._g = color._g;\n        this._b = color._b;\n        this.setAlpha(color._a);\n        return this;\n    },\n    lighten: function() {\n        return this._applyModification(lighten, arguments);\n    },\n    brighten: function() {\n        return this._applyModification(brighten, arguments);\n    },\n    darken: function() {\n        return this._applyModification(darken, arguments);\n    },\n    desaturate: function() {\n        return this._applyModification(desaturate, arguments);\n    },\n    saturate: function() {\n        return this._applyModification(saturate, arguments);\n    },\n    greyscale: function() {\n        return this._applyModification(greyscale, arguments);\n    },\n    spin: function() {\n        return this._applyModification(spin, arguments);\n    },\n\n    _applyCombination: function(fn, args) {\n        return fn.apply(null, [this].concat([].slice.call(args)));\n    },\n    analogous: function() {\n        return this._applyCombination(analogous, arguments);\n    },\n    complement: function() {\n        return this._applyCombination(complement, arguments);\n    },\n    monochromatic: function() {\n        return this._applyCombination(monochromatic, arguments);\n    },\n    splitcomplement: function() {\n        return this._applyCombination(splitcomplement, arguments);\n    },\n    triad: function() {\n        return this._applyCombination(triad, arguments);\n    },\n    tetrad: function() {\n        return this._applyCombination(tetrad, arguments);\n    }\n};\n\n// If input is an object, force 1 into \"1.0\" to handle ratios properly\n// String input requires \"1.0\" as input, so 1 will be treated as 1\ntinycolor.fromRatio = function(color, opts) {\n    if (typeof color == \"object\") {\n        var newColor = {};\n        for (var i in color) {\n            if (color.hasOwnProperty(i)) {\n                if (i === \"a\") {\n                    newColor[i] = color[i];\n                }\n                else {\n                    newColor[i] = convertToPercentage(color[i]);\n                }\n            }\n        }\n        color = newColor;\n    }\n\n    return tinycolor(color, opts);\n};\n\n// Given a string or object, convert that input to RGB\n// Possible string inputs:\n//\n//     \"red\"\n//     \"#f00\" or \"f00\"\n//     \"#ff0000\" or \"ff0000\"\n//     \"#ff000000\" or \"ff000000\"\n//     \"rgb 255 0 0\" or \"rgb (255, 0, 0)\"\n//     \"rgb 1.0 0 0\" or \"rgb (1, 0, 0)\"\n//     \"rgba (255, 0, 0, 1)\" or \"rgba 255, 0, 0, 1\"\n//     \"rgba (1.0, 0, 0, 1)\" or \"rgba 1.0, 0, 0, 1\"\n//     \"hsl(0, 100%, 50%)\" or \"hsl 0 100% 50%\"\n//     \"hsla(0, 100%, 50%, 1)\" or \"hsla 0 100% 50%, 1\"\n//     \"hsv(0, 100%, 100%)\" or \"hsv 0 100% 100%\"\n//\nfunction inputToRGB(color) {\n\n    var rgb = { r: 0, g: 0, b: 0 };\n    var a = 1;\n    var s = null;\n    var v = null;\n    var l = null;\n    var ok = false;\n    var format = false;\n\n    if (typeof color == \"string\") {\n        color = stringInputToObject(color);\n    }\n\n    if (typeof color == \"object\") {\n        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {\n            rgb = rgbToRgb(color.r, color.g, color.b);\n            ok = true;\n            format = String(color.r).substr(-1) === \"%\" ? \"prgb\" : \"rgb\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {\n            s = convertToPercentage(color.s);\n            v = convertToPercentage(color.v);\n            rgb = hsvToRgb(color.h, s, v);\n            ok = true;\n            format = \"hsv\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {\n            s = convertToPercentage(color.s);\n            l = convertToPercentage(color.l);\n            rgb = hslToRgb(color.h, s, l);\n            ok = true;\n            format = \"hsl\";\n        }\n\n        if (color.hasOwnProperty(\"a\")) {\n            a = color.a;\n        }\n    }\n\n    a = boundAlpha(a);\n\n    return {\n        ok: ok,\n        format: color.format || format,\n        r: mathMin(255, mathMax(rgb.r, 0)),\n        g: mathMin(255, mathMax(rgb.g, 0)),\n        b: mathMin(255, mathMax(rgb.b, 0)),\n        a: a\n    };\n}\n\n\n// Conversion Functions\n// --------------------\n\n// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:\n// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>\n\n// `rgbToRgb`\n// Handle bounds / percentage checking to conform to CSS color spec\n// <http://www.w3.org/TR/css3-color/>\n// *Assumes:* r, g, b in [0, 255] or [0, 1]\n// *Returns:* { r, g, b } in [0, 255]\nfunction rgbToRgb(r, g, b){\n    return {\n        r: bound01(r, 255) * 255,\n        g: bound01(g, 255) * 255,\n        b: bound01(b, 255) * 255\n    };\n}\n\n// `rgbToHsl`\n// Converts an RGB color value to HSL.\n// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]\n// *Returns:* { h, s, l } in [0,1]\nfunction rgbToHsl(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, l = (max + min) / 2;\n\n    if(max == min) {\n        h = s = 0; // achromatic\n    }\n    else {\n        var d = max - min;\n        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n\n        h /= 6;\n    }\n\n    return { h: h, s: s, l: l };\n}\n\n// `hslToRgb`\n// Converts an HSL color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\nfunction hslToRgb(h, s, l) {\n    var r, g, b;\n\n    h = bound01(h, 360);\n    s = bound01(s, 100);\n    l = bound01(l, 100);\n\n    function hue2rgb(p, q, t) {\n        if(t < 0) t += 1;\n        if(t > 1) t -= 1;\n        if(t < 1/6) return p + (q - p) * 6 * t;\n        if(t < 1/2) return q;\n        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;\n        return p;\n    }\n\n    if(s === 0) {\n        r = g = b = l; // achromatic\n    }\n    else {\n        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n        var p = 2 * l - q;\n        r = hue2rgb(p, q, h + 1/3);\n        g = hue2rgb(p, q, h);\n        b = hue2rgb(p, q, h - 1/3);\n    }\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHsv`\n// Converts an RGB color value to HSV\n// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]\n// *Returns:* { h, s, v } in [0,1]\nfunction rgbToHsv(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, v = max;\n\n    var d = max - min;\n    s = max === 0 ? 0 : d / max;\n\n    if(max == min) {\n        h = 0; // achromatic\n    }\n    else {\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n        h /= 6;\n    }\n    return { h: h, s: s, v: v };\n}\n\n// `hsvToRgb`\n// Converts an HSV color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\n function hsvToRgb(h, s, v) {\n\n    h = bound01(h, 360) * 6;\n    s = bound01(s, 100);\n    v = bound01(v, 100);\n\n    var i = Math.floor(h),\n        f = h - i,\n        p = v * (1 - s),\n        q = v * (1 - f * s),\n        t = v * (1 - (1 - f) * s),\n        mod = i % 6,\n        r = [v, q, p, p, t, v][mod],\n        g = [t, v, v, q, p, p][mod],\n        b = [p, p, t, v, v, q][mod];\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHex`\n// Converts an RGB color to hex\n// Assumes r, g, and b are contained in the set [0, 255]\n// Returns a 3 or 6 character hex\nfunction rgbToHex(r, g, b, allow3Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    // Return a 3 character hex if possible\n    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToHex`\n// Converts an RGBA color plus alpha transparency to hex\n// Assumes r, g, b are contained in the set [0, 255] and\n// a in [0, 1]. Returns a 4 or 8 character rgba hex\nfunction rgbaToHex(r, g, b, a, allow4Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16)),\n        pad2(convertDecimalToHex(a))\n    ];\n\n    // Return a 4 character hex if possible\n    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToArgbHex`\n// Converts an RGBA color to an ARGB Hex8 string\n// Rarely used, but required for \"toFilter()\"\nfunction rgbaToArgbHex(r, g, b, a) {\n\n    var hex = [\n        pad2(convertDecimalToHex(a)),\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    return hex.join(\"\");\n}\n\n// `equals`\n// Can be called with any tinycolor input\ntinycolor.equals = function (color1, color2) {\n    if (!color1 || !color2) { return false; }\n    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();\n};\n\ntinycolor.random = function() {\n    return tinycolor.fromRatio({\n        r: mathRandom(),\n        g: mathRandom(),\n        b: mathRandom()\n    });\n};\n\n\n// Modification Functions\n// ----------------------\n// Thanks to less.js for some of the basics here\n// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>\n\nfunction desaturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s -= amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction saturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s += amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction greyscale(color) {\n    return tinycolor(color).desaturate(100);\n}\n\nfunction lighten (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l += amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\nfunction brighten(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var rgb = tinycolor(color).toRgb();\n    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));\n    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));\n    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));\n    return tinycolor(rgb);\n}\n\nfunction darken (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l -= amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\n// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n// Values outside of this range will be wrapped into this range.\nfunction spin(color, amount) {\n    var hsl = tinycolor(color).toHsl();\n    var hue = (hsl.h + amount) % 360;\n    hsl.h = hue < 0 ? 360 + hue : hue;\n    return tinycolor(hsl);\n}\n\n// Combination Functions\n// ---------------------\n// Thanks to jQuery xColor for some of the ideas behind these\n// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>\n\nfunction complement(color) {\n    var hsl = tinycolor(color).toHsl();\n    hsl.h = (hsl.h + 180) % 360;\n    return tinycolor(hsl);\n}\n\nfunction triad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction tetrad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction splitcomplement(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),\n        tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})\n    ];\n}\n\nfunction analogous(color, results, slices) {\n    results = results || 6;\n    slices = slices || 30;\n\n    var hsl = tinycolor(color).toHsl();\n    var part = 360 / slices;\n    var ret = [tinycolor(color)];\n\n    for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {\n        hsl.h = (hsl.h + part) % 360;\n        ret.push(tinycolor(hsl));\n    }\n    return ret;\n}\n\nfunction monochromatic(color, results) {\n    results = results || 6;\n    var hsv = tinycolor(color).toHsv();\n    var h = hsv.h, s = hsv.s, v = hsv.v;\n    var ret = [];\n    var modification = 1 / results;\n\n    while (results--) {\n        ret.push(tinycolor({ h: h, s: s, v: v}));\n        v = (v + modification) % 1;\n    }\n\n    return ret;\n}\n\n// Utility Functions\n// ---------------------\n\ntinycolor.mix = function(color1, color2, amount) {\n    amount = (amount === 0) ? 0 : (amount || 50);\n\n    var rgb1 = tinycolor(color1).toRgb();\n    var rgb2 = tinycolor(color2).toRgb();\n\n    var p = amount / 100;\n\n    var rgba = {\n        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,\n        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,\n        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,\n        a: ((rgb2.a - rgb1.a) * p) + rgb1.a\n    };\n\n    return tinycolor(rgba);\n};\n\n\n// Readability Functions\n// ---------------------\n// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)\n\n// `contrast`\n// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)\ntinycolor.readability = function(color1, color2) {\n    var c1 = tinycolor(color1);\n    var c2 = tinycolor(color2);\n    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);\n};\n\n// `isReadable`\n// Ensure that foreground and background color combinations meet WCAG2 guidelines.\n// The third argument is an optional Object.\n//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';\n//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.\n// If the entire object is absent, isReadable defaults to {level:\"AA\",size:\"small\"}.\n\n// *Example*\n//    tinycolor.isReadable(\"#000\", \"#111\") => false\n//    tinycolor.isReadable(\"#000\", \"#111\",{level:\"AA\",size:\"large\"}) => false\ntinycolor.isReadable = function(color1, color2, wcag2) {\n    var readability = tinycolor.readability(color1, color2);\n    var wcag2Parms, out;\n\n    out = false;\n\n    wcag2Parms = validateWCAG2Parms(wcag2);\n    switch (wcag2Parms.level + wcag2Parms.size) {\n        case \"AAsmall\":\n        case \"AAAlarge\":\n            out = readability >= 4.5;\n            break;\n        case \"AAlarge\":\n            out = readability >= 3;\n            break;\n        case \"AAAsmall\":\n            out = readability >= 7;\n            break;\n    }\n    return out;\n\n};\n\n// `mostReadable`\n// Given a base color and a list of possible foreground or background\n// colors for that base, returns the most readable color.\n// Optionally returns Black or White if the most readable color is unreadable.\n// *Example*\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:false}).toHexString(); // \"#112255\"\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:true}).toHexString();  // \"#ffffff\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"large\"}).toHexString(); // \"#faf3f3\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"small\"}).toHexString(); // \"#ffffff\"\ntinycolor.mostReadable = function(baseColor, colorList, args) {\n    var bestColor = null;\n    var bestScore = 0;\n    var readability;\n    var includeFallbackColors, level, size ;\n    args = args || {};\n    includeFallbackColors = args.includeFallbackColors ;\n    level = args.level;\n    size = args.size;\n\n    for (var i= 0; i < colorList.length ; i++) {\n        readability = tinycolor.readability(baseColor, colorList[i]);\n        if (readability > bestScore) {\n            bestScore = readability;\n            bestColor = tinycolor(colorList[i]);\n        }\n    }\n\n    if (tinycolor.isReadable(baseColor, bestColor, {\"level\":level,\"size\":size}) || !includeFallbackColors) {\n        return bestColor;\n    }\n    else {\n        args.includeFallbackColors=false;\n        return tinycolor.mostReadable(baseColor,[\"#fff\", \"#000\"],args);\n    }\n};\n\n\n// Big List of Colors\n// ------------------\n// <http://www.w3.org/TR/css3-color/#svg-color>\nvar names = tinycolor.names = {\n    aliceblue: \"f0f8ff\",\n    antiquewhite: \"faebd7\",\n    aqua: \"0ff\",\n    aquamarine: \"7fffd4\",\n    azure: \"f0ffff\",\n    beige: \"f5f5dc\",\n    bisque: \"ffe4c4\",\n    black: \"000\",\n    blanchedalmond: \"ffebcd\",\n    blue: \"00f\",\n    blueviolet: \"8a2be2\",\n    brown: \"a52a2a\",\n    burlywood: \"deb887\",\n    burntsienna: \"ea7e5d\",\n    cadetblue: \"5f9ea0\",\n    chartreuse: \"7fff00\",\n    chocolate: \"d2691e\",\n    coral: \"ff7f50\",\n    cornflowerblue: \"6495ed\",\n    cornsilk: \"fff8dc\",\n    crimson: \"dc143c\",\n    cyan: \"0ff\",\n    darkblue: \"00008b\",\n    darkcyan: \"008b8b\",\n    darkgoldenrod: \"b8860b\",\n    darkgray: \"a9a9a9\",\n    darkgreen: \"006400\",\n    darkgrey: \"a9a9a9\",\n    darkkhaki: \"bdb76b\",\n    darkmagenta: \"8b008b\",\n    darkolivegreen: \"556b2f\",\n    darkorange: \"ff8c00\",\n    darkorchid: \"9932cc\",\n    darkred: \"8b0000\",\n    darksalmon: \"e9967a\",\n    darkseagreen: \"8fbc8f\",\n    darkslateblue: \"483d8b\",\n    darkslategray: \"2f4f4f\",\n    darkslategrey: \"2f4f4f\",\n    darkturquoise: \"00ced1\",\n    darkviolet: \"9400d3\",\n    deeppink: \"ff1493\",\n    deepskyblue: \"00bfff\",\n    dimgray: \"696969\",\n    dimgrey: \"696969\",\n    dodgerblue: \"1e90ff\",\n    firebrick: \"b22222\",\n    floralwhite: \"fffaf0\",\n    forestgreen: \"228b22\",\n    fuchsia: \"f0f\",\n    gainsboro: \"dcdcdc\",\n    ghostwhite: \"f8f8ff\",\n    gold: \"ffd700\",\n    goldenrod: \"daa520\",\n    gray: \"808080\",\n    green: \"008000\",\n    greenyellow: \"adff2f\",\n    grey: \"808080\",\n    honeydew: \"f0fff0\",\n    hotpink: \"ff69b4\",\n    indianred: \"cd5c5c\",\n    indigo: \"4b0082\",\n    ivory: \"fffff0\",\n    khaki: \"f0e68c\",\n    lavender: \"e6e6fa\",\n    lavenderblush: \"fff0f5\",\n    lawngreen: \"7cfc00\",\n    lemonchiffon: \"fffacd\",\n    lightblue: \"add8e6\",\n    lightcoral: \"f08080\",\n    lightcyan: \"e0ffff\",\n    lightgoldenrodyellow: \"fafad2\",\n    lightgray: \"d3d3d3\",\n    lightgreen: \"90ee90\",\n    lightgrey: \"d3d3d3\",\n    lightpink: \"ffb6c1\",\n    lightsalmon: \"ffa07a\",\n    lightseagreen: \"20b2aa\",\n    lightskyblue: \"87cefa\",\n    lightslategray: \"789\",\n    lightslategrey: \"789\",\n    lightsteelblue: \"b0c4de\",\n    lightyellow: \"ffffe0\",\n    lime: \"0f0\",\n    limegreen: \"32cd32\",\n    linen: \"faf0e6\",\n    magenta: \"f0f\",\n    maroon: \"800000\",\n    mediumaquamarine: \"66cdaa\",\n    mediumblue: \"0000cd\",\n    mediumorchid: \"ba55d3\",\n    mediumpurple: \"9370db\",\n    mediumseagreen: \"3cb371\",\n    mediumslateblue: \"7b68ee\",\n    mediumspringgreen: \"00fa9a\",\n    mediumturquoise: \"48d1cc\",\n    mediumvioletred: \"c71585\",\n    midnightblue: \"191970\",\n    mintcream: \"f5fffa\",\n    mistyrose: \"ffe4e1\",\n    moccasin: \"ffe4b5\",\n    navajowhite: \"ffdead\",\n    navy: \"000080\",\n    oldlace: \"fdf5e6\",\n    olive: \"808000\",\n    olivedrab: \"6b8e23\",\n    orange: \"ffa500\",\n    orangered: \"ff4500\",\n    orchid: \"da70d6\",\n    palegoldenrod: \"eee8aa\",\n    palegreen: \"98fb98\",\n    paleturquoise: \"afeeee\",\n    palevioletred: \"db7093\",\n    papayawhip: \"ffefd5\",\n    peachpuff: \"ffdab9\",\n    peru: \"cd853f\",\n    pink: \"ffc0cb\",\n    plum: \"dda0dd\",\n    powderblue: \"b0e0e6\",\n    purple: \"800080\",\n    rebeccapurple: \"663399\",\n    red: \"f00\",\n    rosybrown: \"bc8f8f\",\n    royalblue: \"4169e1\",\n    saddlebrown: \"8b4513\",\n    salmon: \"fa8072\",\n    sandybrown: \"f4a460\",\n    seagreen: \"2e8b57\",\n    seashell: \"fff5ee\",\n    sienna: \"a0522d\",\n    silver: \"c0c0c0\",\n    skyblue: \"87ceeb\",\n    slateblue: \"6a5acd\",\n    slategray: \"708090\",\n    slategrey: \"708090\",\n    snow: \"fffafa\",\n    springgreen: \"00ff7f\",\n    steelblue: \"4682b4\",\n    tan: \"d2b48c\",\n    teal: \"008080\",\n    thistle: \"d8bfd8\",\n    tomato: \"ff6347\",\n    turquoise: \"40e0d0\",\n    violet: \"ee82ee\",\n    wheat: \"f5deb3\",\n    white: \"fff\",\n    whitesmoke: \"f5f5f5\",\n    yellow: \"ff0\",\n    yellowgreen: \"9acd32\"\n};\n\n// Make it easy to access colors via `hexNames[hex]`\nvar hexNames = tinycolor.hexNames = flip(names);\n\n\n// Utilities\n// ---------\n\n// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`\nfunction flip(o) {\n    var flipped = { };\n    for (var i in o) {\n        if (o.hasOwnProperty(i)) {\n            flipped[o[i]] = i;\n        }\n    }\n    return flipped;\n}\n\n// Return a valid alpha value [0,1] with all invalid values being set to 1\nfunction boundAlpha(a) {\n    a = parseFloat(a);\n\n    if (isNaN(a) || a < 0 || a > 1) {\n        a = 1;\n    }\n\n    return a;\n}\n\n// Take input from [0, n] and return it as [0, 1]\nfunction bound01(n, max) {\n    if (isOnePointZero(n)) { n = \"100%\"; }\n\n    var processPercent = isPercentage(n);\n    n = mathMin(max, mathMax(0, parseFloat(n)));\n\n    // Automatically convert percentage into number\n    if (processPercent) {\n        n = parseInt(n * max, 10) / 100;\n    }\n\n    // Handle floating point rounding errors\n    if ((Math.abs(n - max) < 0.000001)) {\n        return 1;\n    }\n\n    // Convert into [0, 1] range if it isn't already\n    return (n % max) / parseFloat(max);\n}\n\n// Force a number between 0 and 1\nfunction clamp01(val) {\n    return mathMin(1, mathMax(0, val));\n}\n\n// Parse a base-16 hex value into a base-10 integer\nfunction parseIntFromHex(val) {\n    return parseInt(val, 16);\n}\n\n// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1\n// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>\nfunction isOnePointZero(n) {\n    return typeof n == \"string\" && n.indexOf('.') != -1 && parseFloat(n) === 1;\n}\n\n// Check to see if string passed in is a percentage\nfunction isPercentage(n) {\n    return typeof n === \"string\" && n.indexOf('%') != -1;\n}\n\n// Force a hex value to have 2 characters\nfunction pad2(c) {\n    return c.length == 1 ? '0' + c : '' + c;\n}\n\n// Replace a decimal with it's percentage value\nfunction convertToPercentage(n) {\n    if (n <= 1) {\n        n = (n * 100) + \"%\";\n    }\n\n    return n;\n}\n\n// Converts a decimal to a hex value\nfunction convertDecimalToHex(d) {\n    return Math.round(parseFloat(d) * 255).toString(16);\n}\n// Converts a hex value to a decimal\nfunction convertHexToDecimal(h) {\n    return (parseIntFromHex(h) / 255);\n}\n\nvar matchers = (function() {\n\n    // <http://www.w3.org/TR/css3-values/#integers>\n    var CSS_INTEGER = \"[-\\\\+]?\\\\d+%?\";\n\n    // <http://www.w3.org/TR/css3-values/#number-value>\n    var CSS_NUMBER = \"[-\\\\+]?\\\\d*\\\\.\\\\d+%?\";\n\n    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.\n    var CSS_UNIT = \"(?:\" + CSS_NUMBER + \")|(?:\" + CSS_INTEGER + \")\";\n\n    // Actual matching.\n    // Parentheses and commas are optional, but not required.\n    // Whitespace can take the place of commas or opening paren\n    var PERMISSIVE_MATCH3 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    var PERMISSIVE_MATCH4 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n\n    return {\n        CSS_UNIT: new RegExp(CSS_UNIT),\n        rgb: new RegExp(\"rgb\" + PERMISSIVE_MATCH3),\n        rgba: new RegExp(\"rgba\" + PERMISSIVE_MATCH4),\n        hsl: new RegExp(\"hsl\" + PERMISSIVE_MATCH3),\n        hsla: new RegExp(\"hsla\" + PERMISSIVE_MATCH4),\n        hsv: new RegExp(\"hsv\" + PERMISSIVE_MATCH3),\n        hsva: new RegExp(\"hsva\" + PERMISSIVE_MATCH4),\n        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/\n    };\n})();\n\n// `isValidCSSUnit`\n// Take in a single string / number and check to see if it looks like a CSS unit\n// (see `matchers` above for definition).\nfunction isValidCSSUnit(color) {\n    return !!matchers.CSS_UNIT.exec(color);\n}\n\n// `stringInputToObject`\n// Permissive string parsing.  Take in a number of formats, and output an object\n// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`\nfunction stringInputToObject(color) {\n\n    color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();\n    var named = false;\n    if (names[color]) {\n        color = names[color];\n        named = true;\n    }\n    else if (color == 'transparent') {\n        return { r: 0, g: 0, b: 0, a: 0, format: \"name\" };\n    }\n\n    // Try to match string input using regular expressions.\n    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]\n    // Just return an object and let the conversion functions handle that.\n    // This way the result will be the same whether the tinycolor is initialized with string or object.\n    var match;\n    if ((match = matchers.rgb.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3] };\n    }\n    if ((match = matchers.rgba.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsl.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3] };\n    }\n    if ((match = matchers.hsla.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsv.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3] };\n    }\n    if ((match = matchers.hsva.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3], a: match[4] };\n    }\n    if ((match = matchers.hex8.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            a: convertHexToDecimal(match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex6.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n    if ((match = matchers.hex4.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            a: convertHexToDecimal(match[4] + '' + match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex3.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n\n    return false;\n}\n\nfunction validateWCAG2Parms(parms) {\n    // return valid WCAG2 parms for isReadable.\n    // If input parms are invalid, return {\"level\":\"AA\", \"size\":\"small\"}\n    var level, size;\n    parms = parms || {\"level\":\"AA\", \"size\":\"small\"};\n    level = (parms.level || \"AA\").toUpperCase();\n    size = (parms.size || \"small\").toLowerCase();\n    if (level !== \"AA\" && level !== \"AAA\") {\n        level = \"AA\";\n    }\n    if (size !== \"small\" && size !== \"large\") {\n        size = \"small\";\n    }\n    return {\"level\":level, \"size\":size};\n}\n\n// Node: Export function\nif (typeof module !== \"undefined\" && module.exports) {\n    module.exports = tinycolor;\n}\n// AMD/requirejs: Define the module\nelse if (typeof define === 'function' && define.amd) {\n    define(function () {return tinycolor;});\n}\n// Browser: Expose to window\nelse {\n    window.tinycolor = tinycolor;\n}\n\n})(Math);\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nif (!window.FileReader) {\n  console.error('Your browser does not support FileReader API!');\n}\n\nexports.default = {\n  name: 'vue-base64-file-upload',\n\n  props: {\n    imageClass: {\n      type: String,\n      default: ''\n    },\n    inputClass: {\n      type: String,\n      default: ''\n    },\n    accept: {\n      type: String,\n      default: 'image/png,image/gif,image/jpeg'\n    },\n    maxSize: {\n      type: Number,\n      default: 10 // megabytes\n    },\n    disablePreview: {\n      type: Boolean,\n      default: false\n    },\n    fileName: {\n      type: String,\n      default: ''\n    },\n    placeholder: {\n      type: String,\n      default: 'Click here to upload image'\n    },\n    defaultPreview: {\n      type: String,\n      default: ''\n    }\n  },\n\n  data: function data() {\n    return {\n      file: null,\n      preview: null,\n      visiblePreview: false\n    };\n  },\n\n\n  computed: {\n    wrapperStyles: function wrapperStyles() {\n      return {\n        'position': 'relative',\n        'width': '100%'\n      };\n    },\n    fileInputStyles: function fileInputStyles() {\n      return {\n        'width': '100%',\n        'position': 'absolute',\n        'top': 0,\n        'left': 0,\n        'right': 0,\n        'bottom': 0,\n        'opacity': 0,\n        'overflow': 'hidden',\n        'outline': 'none',\n        'cursor': 'pointer'\n      };\n    },\n    textInputStyles: function textInputStyles() {\n      return {\n        'width': '100%',\n        'cursor': 'pointer'\n      };\n    },\n    previewImage: function previewImage() {\n      return this.preview || this.defaultPreview;\n    }\n  },\n\n  methods: {\n    onChange: function onChange(e) {\n      var _this = this;\n\n      var files = e.target.files || e.dataTransfer.files;\n\n      if (!files.length) {\n        return;\n      }\n\n      var file = files[0];\n      var size = file.size && file.size / Math.pow(1000, 2);\n\n      // check file max size\n      if (size > this.maxSize) {\n        this.$emit('size-exceeded', size);\n        return;\n      }\n\n      // update file\n      this.file = file;\n      this.$emit('file', file);\n\n      var reader = new FileReader();\n\n      reader.onload = function (e) {\n        var dataURI = e.target.result;\n\n        if (dataURI) {\n          _this.$emit('load', dataURI);\n\n          _this.preview = dataURI;\n        }\n      };\n\n      // read blob url from file data\n      reader.readAsDataURL(file);\n    }\n  },\n\n  template: '\\n    <div class=\"vue-base64-file-upload\">\\n      <img\\n        v-show=\"previewImage && !disablePreview\"\\n        :src=\"previewImage\"\\n        :class=\"imageClass\" />\\n      <div class=\"vue-base64-file-upload-wrapper\" :style=\"wrapperStyles\">\\n        <input\\n          type=\"file\"\\n          @change=\"onChange\"\\n          :style=\"fileInputStyles\"\\n          :accept=accept />\\n        <input\\n          type=\"text\"\\n          :class=\"inputClass\"\\n          :style=\"textInputStyles\"\\n          :value=\"fileName || file && file.name\"\\n          :placeholder=\"placeholder\"\\n          disabled />\\n      </div>\\n    </div>\\n  '\n};\n"],"sourceRoot":""}