chore: add mobile app

frontend-admin/node_modules/css-in-js-utils/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+### 3.0.2
+* added new unitless properties
+
+### 3.0.0
+* `assignStyle` now correctly merges array values without duplicates where the last occurence always wins in order
+
+### 2.0.0
+* improve `assignStyle` to replace arrays
+
+### 1.0.3
+* performance improvements
+
+### 1.0.2
+* added `resolveArrayValue` and `assignStyle`
+
+### 1.0.1
+* added `cssifyDeclaration` and `cssifyObject`
+
+### 1.0.0
+Initial version

frontend-admin/node_modules/css-in-js-utils/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Robin Frischmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frontend-admin/node_modules/css-in-js-utils/README.md

@@ -0,0 +1,242 @@
+# CSS-in-JS Utilities
+A library that provides useful utilities functions for CSS-in-JS solutions.<br>
+They are intended to be used by CSS-in-JS library authors rather used directly.
+<br>
+
+<img alt="TravisCI" src="https://travis-ci.org/rofrischmann/css-in-js-utils.svg?branch=master"> <img alt="Test Coverage"  src="https://api.codeclimate.com/v1/badges/2964ee833f8d2104cac6/test_coverage" /> <img alt="npm downloads" src="https://img.shields.io/npm/dm/css-in-js-utils.svg"> <img alt="npm version" src="https://badge.fury.io/js/css-in-js-utils.svg"> <img alt="gzipped size" src="https://img.shields.io/bundlephobia/minzip/css-in-js-utils.svg?colorB=4c1&label=gzipped%20size">
+
+## Installation
+```sh
+yarn add css-in-js-utils
+```
+
+## Why?
+By now I have authored and collaborated on many different libraries and found I would rewrite the very same utility functions every time. That's why this repository is hosting small utilities especially built for CSS-in-JS solutions and tools. Even if there are tons of different libraries already, they all basically use the same mechanisms and utilities.
+
+## Utilities
+* [`assignStyle(base, ...extend)`](#assignstylebase-extend)
+* [`camelCaseProperty(property)`](#camelcasepropertyproperty)
+* [`cssifyDeclaration(property, value)`](#cssifydeclarationproperty-value)
+* [`cssifyObject(object)`](#cssifyobjectobject)
+* [`hyphenateProperty(property)`](#hyphenatepropertyproperty)
+* [`isPrefixedProperty(property)`](#isprefixedpropertyproperty)
+* [`isPrefixedValue(value)`](#isprefixedvaluevalue)
+* [`isUnitlessProperty(property)`](#isunitlesspropertyproperty)
+* [`normalizeProperty(property)`](#normalizepropertyproperty)
+* [`resolveArrayValue(property, value)`](#resolvearrayvalueproperty-value)
+* [`unprefixProperty(property)`](#unprefixpropertyproperty)
+* [`unprefixValue(value)`](#unprefixvaluevalue)
+
+------
+
+### `assignStyle(base, ...extend)`
+Merges deep style objects similar to `Object.assign`.<br>
+It also merges array values into a single array whithout creating duplicates. The last occurence of every item wins.
+
+```javascript
+import { assignStyle } from 'css-in-js-utils'
+
+assignStyle(
+  { color: 'red', backgroundColor: 'black' },
+  { color: 'blue' }
+)
+// => { color: 'blue', backgroundColor: 'black' }
+
+assignStyle(
+  {
+    color: 'red',
+    ':hover': {
+      backgroundColor: 'black'
+    }
+  },
+  { 
+    ':hover': {
+      backgroundColor: 'blue'
+    }
+  }
+)
+// => { color: 'red', ':hover': { backgroundColor: 'blue' }}
+```
+
+------
+
+### `camelCaseProperty(property)`
+Converts the `property` to camelCase.
+
+```javascript
+import { camelCaseProperty } from 'css-in-js-utils'
+
+camelCaseProperty('padding-top')
+// => 'paddingTop'
+
+camelCaseProperty('-webkit-transition')
+// => 'WebkitTransition'
+```
+
+------
+
+### `cssifyDeclaration(property, value)`
+Generates a CSS declaration (`property`:`value`) string.
+
+```javascript
+import { cssifyDeclaration } from 'css-in-js-utils'
+
+cssifyDeclaration('paddingTop', '400px')
+// => 'padding-top:400px'
+
+cssifyDeclaration('WebkitFlex', 3)
+// => '-webkit-flex:3'
+```
+
+------
+
+### `cssifyObject(object)`
+Generates a CSS string using all key-property pairs in `object`.
+It automatically removes declarations with value types other than `number` and `string`.
+
+```javascript
+import { cssifyObject } from 'css-in-js-utils'
+
+cssifyObject({
+  paddingTop: '400px',
+  paddingBottom: undefined,
+  WebkitFlex: 3,
+  _anyKey: [1, 2, 4]
+})
+// => 'padding-top:400px;-webkit-flex:3'
+```
+
+------
+
+### `hyphenateProperty(property)`
+Converts the `property` to hyphen-case.
+> Directly mirrors [hyphenate-style-name](https://github.com/rexxars/hyphenate-style-name).
+
+```javascript
+import { hyphenateProperty } from 'css-in-js-utils'
+
+hyphenateProperty('paddingTop')
+// => 'padding-top'
+
+hyphenateProperty('WebkitTransition')
+// => '-webkit-transition'
+```
+
+------
+
+### `isPrefixedProperty(property)`
+Checks if a `property` includes a vendor prefix.
+
+```javascript
+import { isPrefixedProperty } from 'css-in-js-utils'
+
+isPrefixedProperty('paddingTop')
+// => false
+
+isPrefixedProperty('WebkitTransition')
+// => true
+```
+
+------
+### `isPrefixedValue(value)`
+Checks if a `value` includes vendor prefixes.
+
+```javascript
+import { isPrefixedValue } from 'css-in-js-utils'
+
+isPrefixedValue('200px')
+isPrefixedValue(200)
+// => false
+
+isPrefixedValue('-webkit-calc(100% - 50px)')
+// => true
+```
+
+------
+
+### `isUnitlessProperty(property)`
+Checks if a `property` accepts unitless values.
+
+```javascript
+import { isUnitlessProperty } from 'css-in-js-utils'
+
+isUnitlessProperty('width')
+// => false
+
+isUnitlessProperty('flexGrow')
+isUnitlessProperty('lineHeight')
+isUnitlessProperty('line-height')
+// => true
+```
+
+------
+
+### `normalizeProperty(property)`
+Normalizes the `property` by unprefixing **and** camelCasing it.
+> Uses the [`camelCaseProperty`](#camelcasepropertyproperty) and [`unprefixProperty`](#unprefixpropertyproperty)-methods.
+
+```javascript
+import { normalizeProperty } from 'css-in-js-utils'
+
+normalizeProperty('-webkit-transition-delay')
+// => 'transitionDelay'
+```
+
+------
+
+### `resolveArrayValue(property, value)`
+Concatenates array values to single CSS value.
+> Uses the [`hyphenateProperty`](#hyphenatepropertyproperty)-method.
+
+
+```javascript
+import { resolveArrayValue } from 'css-in-js-utils'
+
+resolveArrayValue('display', [ '-webkit-flex', 'flex' ])
+// => '-webkit-flex;display:flex'
+
+resolveArrayValue('paddingTop', [ 'calc(100% - 50px)', '100px' ])
+// => 'calc(100% - 50px);padding-top:100px'
+```
+
+------
+
+### `unprefixProperty(property)`
+Removes the vendor prefix (if set) from the `property`.
+
+```javascript
+import { unprefixProperty } from 'css-in-js-utils'
+
+unprefixProperty('WebkitTransition')
+// => 'transition'
+
+unprefixProperty('transitionDelay')
+// => 'transitionDelay'
+```
+
+------
+
+### `unprefixValue(value)`
+Removes all vendor prefixes (if any) from the `value`.
+
+```javascript
+import { unprefixValue } from 'css-in-js-utils'
+
+unprefixValue('-webkit-calc(-moz-calc(100% - 50px)/2)')
+// => 'calc(calc(100% - 50px)/2)'
+
+unprefixValue('100px')
+// => '100px'
+```
+
+## Direct Import
+Every utility function may be imported directly to save bundle size.
+
+```javascript
+import camelCaseProperty from 'css-in-js-utils/lib/camelCaseProperty'
+```
+
+## License
+css-in-js-utils is licensed under the [MIT License](http://opensource.org/licenses/MIT).<br>
+Documentation is licensed under [Creative Common License](http://creativecommons.org/licenses/by/4.0/).<br>
+Created with ♥ by [@rofrischmann](http://rofrischmann.de).

frontend-admin/node_modules/css-in-js-utils/es/assignStyle.d.ts

@@ -0,0 +1,5 @@
+declare type StyleObject = {
+    [key: string]: string | number | StyleObject | (string | number | StyleObject)[];
+};
+export default function assignStyle(base: StyleObject, ...extendingStyles: StyleObject[]): StyleObject;
+export {};

frontend-admin/node_modules/css-in-js-utils/es/assignStyle.js

@@ -0,0 +1,51 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function filterUniqueArray(arr) {
+  return arr.filter(function (val, index) {
+    return arr.lastIndexOf(val) === index;
+  });
+}
+
+export default function assignStyle(base) {
+  for (var i = 0, len = arguments.length <= 1 ? 0 : arguments.length - 1; i < len; ++i) {
+    var style = i + 1 < 1 || arguments.length <= i + 1 ? undefined : arguments[i + 1];
+
+    for (var property in style) {
+      var value = style[property];
+      var baseValue = base[property];
+
+      if (baseValue && value) {
+        if (Array.isArray(baseValue)) {
+          base[property] = filterUniqueArray(baseValue.concat(value));
+          continue;
+        }
+
+        if (Array.isArray(value)) {
+          base[property] = filterUniqueArray([baseValue].concat(_toConsumableArray(value)));
+          continue;
+        }
+
+        if (_typeof(value) === 'object') {
+          base[property] = assignStyle({}, baseValue, value);
+          continue;
+        }
+      }
+
+      base[property] = value;
+    }
+  }
+
+  return base;
+}

frontend-admin/node_modules/css-in-js-utils/es/camelCaseProperty.d.ts

@@ -0,0 +1 @@
+export default function camelCaseProperty(property: string): string;

frontend-admin/node_modules/css-in-js-utils/es/camelCaseProperty.js

@@ -0,0 +1,17 @@
+var DASH = /-([a-z])/g;
+var MS = /^Ms/g;
+var cache = {};
+
+function toUpper(match) {
+  return match[1].toUpperCase();
+}
+
+export default function camelCaseProperty(property) {
+  if (cache.hasOwnProperty(property)) {
+    return cache[property];
+  }
+
+  var camelProp = property.replace(DASH, toUpper).replace(MS, 'ms');
+  cache[property] = camelProp;
+  return camelProp;
+}

frontend-admin/node_modules/css-in-js-utils/es/coverage/lcov-report/prettify.js

@@ -0,0 +1,993 @@
+"use strict";
+
+window.PR_SHOULD_USE_CONTINUATION = true;
+
+(function () {
+  var h = ['break,continue,do,else,for,if,return,while'];
+  var u = [h, 'auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile'];
+  var p = [u, 'catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof'];
+  var l = [p, 'alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where'];
+  var x = [p, 'abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient'];
+  var R = [x, 'as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var'];
+  var r = 'all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes';
+  var w = [p, 'debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN'];
+  var s = 'caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END';
+  var I = [h, 'and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None'];
+  var f = [h, 'alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END'];
+  var H = [h, 'case,done,elif,esac,eval,fi,function,in,local,set,then,until'];
+  var A = [l, R, w, s + I, f, H];
+  var e = /^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/;
+  var C = 'str';
+  var z = 'kwd';
+  var j = 'com';
+  var O = 'typ';
+  var G = 'lit';
+  var L = 'pun';
+  var F = 'pln';
+  var m = 'tag';
+  var E = 'dec';
+  var J = 'src';
+  var P = 'atn';
+  var n = 'atv';
+  var N = 'nocode';
+  var M = '(?:^^\\.?|[+-]|\\!|\\!=|\\!==|\\#|\\%|\\%=|&|&&|&&=|&=|\\(|\\*|\\*=|\\+=|\\,|\\-=|\\->|\\/|\\/=|:|::|\\;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\\?|\\@|\\[|\\^|\\^=|\\^\\^|\\^\\^=|\\{|\\||\\|=|\\|\\||\\|\\|=|\\~|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*';
+
+  function k(Z) {
+    var ad = 0;
+    var S = false;
+    var ac = false;
+
+    for (var V = 0, U = Z.length; V < U; ++V) {
+      var ae = Z[V];
+
+      if (ae.ignoreCase) {
+        ac = true;
+      } else {
+        if (/[a-z]/i.test(ae.source.replace(/\\u[0-9a-f]{4}|\\x[0-9a-f]{2}|\\[^ux]/gi, ''))) {
+          S = true;
+          ac = false;
+          break;
+        }
+      }
+    }
+
+    var Y = {
+      b: 8,
+      t: 9,
+      n: 10,
+      v: 11,
+      f: 12,
+      r: 13
+    };
+
+    function ab(ah) {
+      var ag = ah.charCodeAt(0);
+
+      if (ag !== 92) {
+        return ag;
+      }
+
+      var af = ah.charAt(1);
+      ag = Y[af];
+
+      if (ag) {
+        return ag;
+      } else {
+        if ('0' <= af && af <= '7') {
+          return parseInt(ah.substring(1), 8);
+        } else {
+          if (af === 'u' || af === 'x') {
+            return parseInt(ah.substring(2), 16);
+          } else {
+            return ah.charCodeAt(1);
+          }
+        }
+      }
+    }
+
+    function T(af) {
+      if (af < 32) {
+        return (af < 16 ? '\\x0' : '\\x') + af.toString(16);
+      }
+
+      var ag = String.fromCharCode(af);
+
+      if (ag === '\\' || ag === '-' || ag === '[' || ag === ']') {
+        ag = '\\' + ag;
+      }
+
+      return ag;
+    }
+
+    function X(am) {
+      var aq = am.substring(1, am.length - 1).match(new RegExp("\\\\u[0-9A-Fa-f]{4}|\\\\x[0-9A-Fa-f]{2}|\\\\[0-3][0-7]{0,2}|\\\\[0-7]{1,2}|\\\\[\\s\\S]|-|[^-\\\\]", 'g'));
+      var ak = [];
+      var af = [];
+      var ao = aq[0] === '^';
+
+      for (var ar = ao ? 1 : 0, aj = aq.length; ar < aj; ++ar) {
+        var ah = aq[ar];
+
+        if (/\\[bdsw]/i.test(ah)) {
+          ak.push(ah);
+        } else {
+          var ag = ab(ah);
+          var al;
+
+          if (ar + 2 < aj && '-' === aq[ar + 1]) {
+            al = ab(aq[ar + 2]);
+            ar += 2;
+          } else {
+            al = ag;
+          }
+
+          af.push([ag, al]);
+
+          if (!(al < 65 || ag > 122)) {
+            if (!(al < 65 || ag > 90)) {
+              af.push([Math.max(65, ag) | 32, Math.min(al, 90) | 32]);
+            }
+
+            if (!(al < 97 || ag > 122)) {
+              af.push([Math.max(97, ag) & ~32, Math.min(al, 122) & ~32]);
+            }
+          }
+        }
+      }
+
+      af.sort(function (av, au) {
+        return av[0] - au[0] || au[1] - av[1];
+      });
+      var ai = [];
+      var ap = [NaN, NaN];
+
+      for (var ar = 0; ar < af.length; ++ar) {
+        var at = af[ar];
+
+        if (at[0] <= ap[1] + 1) {
+          ap[1] = Math.max(ap[1], at[1]);
+        } else {
+          ai.push(ap = at);
+        }
+      }
+
+      var an = ['['];
+
+      if (ao) {
+        an.push('^');
+      }
+
+      an.push.apply(an, ak);
+
+      for (var ar = 0; ar < ai.length; ++ar) {
+        var at = ai[ar];
+        an.push(T(at[0]));
+
+        if (at[1] > at[0]) {
+          if (at[1] + 1 > at[0]) {
+            an.push('-');
+          }
+
+          an.push(T(at[1]));
+        }
+      }
+
+      an.push(']');
+      return an.join('');
+    }
+
+    function W(al) {
+      var aj = al.source.match(new RegExp("(?:\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]|\\\\u[A-Fa-f0-9]{4}|\\\\x[A-Fa-f0-9]{2}|\\\\[0-9]+|\\\\[^ux0-9]|\\(\\?[:!=]|[\\(\\)\\^]|[^\\x5B\\x5C\\(\\)\\^]+)", 'g'));
+      var ah = aj.length;
+      var an = [];
+
+      for (var ak = 0, am = 0; ak < ah; ++ak) {
+        var ag = aj[ak];
+
+        if (ag === '(') {
+          ++am;
+        } else {
+          if ('\\' === ag.charAt(0)) {
+            var af = +ag.substring(1);
+
+            if (af && af <= am) {
+              an[af] = -1;
+            }
+          }
+        }
+      }
+
+      for (var ak = 1; ak < an.length; ++ak) {
+        if (-1 === an[ak]) {
+          an[ak] = ++ad;
+        }
+      }
+
+      for (var ak = 0, am = 0; ak < ah; ++ak) {
+        var ag = aj[ak];
+
+        if (ag === '(') {
+          ++am;
+
+          if (an[am] === undefined) {
+            aj[ak] = '(?:';
+          }
+        } else {
+          if ('\\' === ag.charAt(0)) {
+            var af = +ag.substring(1);
+
+            if (af && af <= am) {
+              aj[ak] = '\\' + an[am];
+            }
+          }
+        }
+      }
+
+      for (var ak = 0, am = 0; ak < ah; ++ak) {
+        if ('^' === aj[ak] && '^' !== aj[ak + 1]) {
+          aj[ak] = '';
+        }
+      }
+
+      if (al.ignoreCase && S) {
+        for (var ak = 0; ak < ah; ++ak) {
+          var ag = aj[ak];
+          var ai = ag.charAt(0);
+
+          if (ag.length >= 2 && ai === '[') {
+            aj[ak] = X(ag);
+          } else {
+            if (ai !== '\\') {
+              aj[ak] = ag.replace(/[a-zA-Z]/g, function (ao) {
+                var ap = ao.charCodeAt(0);
+                return '[' + String.fromCharCode(ap & ~32, ap | 32) + ']';
+              });
+            }
+          }
+        }
+      }
+
+      return aj.join('');
+    }
+
+    var aa = [];
+
+    for (var V = 0, U = Z.length; V < U; ++V) {
+      var ae = Z[V];
+
+      if (ae.global || ae.multiline) {
+        throw new Error('' + ae);
+      }
+
+      aa.push('(?:' + W(ae) + ')');
+    }
+
+    return new RegExp(aa.join('|'), ac ? 'gi' : 'g');
+  }
+
+  function a(V) {
+    var U = /(?:^|\s)nocode(?:\s|$)/;
+    var X = [];
+    var T = 0;
+    var Z = [];
+    var W = 0;
+    var S;
+
+    if (V.currentStyle) {
+      S = V.currentStyle.whiteSpace;
+    } else {
+      if (window.getComputedStyle) {
+        S = document.defaultView.getComputedStyle(V, null).getPropertyValue('white-space');
+      }
+    }
+
+    var Y = S && 'pre' === S.substring(0, 3);
+
+    function aa(ab) {
+      switch (ab.nodeType) {
+        case 1:
+          if (U.test(ab.className)) {
+            return;
+          }
+
+          for (var ae = ab.firstChild; ae; ae = ae.nextSibling) {
+            aa(ae);
+          }
+
+          var ad = ab.nodeName;
+
+          if ('BR' === ad || 'LI' === ad) {
+            X[W] = '\n';
+            Z[W << 1] = T++;
+            Z[W++ << 1 | 1] = ab;
+          }
+
+          break;
+
+        case 3:
+        case 4:
+          var ac = ab.nodeValue;
+
+          if (ac.length) {
+            if (!Y) {
+              ac = ac.replace(/[ \t\r\n]+/g, ' ');
+            } else {
+              ac = ac.replace(/\r\n?/g, '\n');
+            }
+
+            X[W] = ac;
+            Z[W << 1] = T;
+            T += ac.length;
+            Z[W++ << 1 | 1] = ab;
+          }
+
+          break;
+      }
+    }
+
+    aa(V);
+    return {
+      sourceCode: X.join('').replace(/\n$/, ''),
+      spans: Z
+    };
+  }
+
+  function B(S, U, W, T) {
+    if (!U) {
+      return;
+    }
+
+    var V = {
+      sourceCode: U,
+      basePos: S
+    };
+    W(V);
+    T.push.apply(T, V.decorations);
+  }
+
+  var v = /\S/;
+
+  function o(S) {
+    var V = undefined;
+
+    for (var U = S.firstChild; U; U = U.nextSibling) {
+      var T = U.nodeType;
+      V = T === 1 ? V ? S : U : T === 3 ? v.test(U.nodeValue) ? S : V : V;
+    }
+
+    return V === S ? undefined : V;
+  }
+
+  function g(U, T) {
+    var S = {};
+    var V;
+
+    (function () {
+      var ad = U.concat(T);
+      var ah = [];
+      var ag = {};
+
+      for (var ab = 0, Z = ad.length; ab < Z; ++ab) {
+        var Y = ad[ab];
+        var ac = Y[3];
+
+        if (ac) {
+          for (var ae = ac.length; --ae >= 0;) {
+            S[ac.charAt(ae)] = Y;
+          }
+        }
+
+        var af = Y[1];
+        var aa = '' + af;
+
+        if (!ag.hasOwnProperty(aa)) {
+          ah.push(af);
+          ag[aa] = null;
+        }
+      }
+
+      ah.push(/[\0-\uffff]/);
+      V = k(ah);
+    })();
+
+    var X = T.length;
+
+    var W = function W(ah) {
+      var Z = ah.sourceCode,
+          Y = ah.basePos;
+      var ad = [Y, F];
+      var af = 0;
+      var an = Z.match(V) || [];
+      var aj = {};
+
+      for (var ae = 0, aq = an.length; ae < aq; ++ae) {
+        var ag = an[ae];
+        var ap = aj[ag];
+        var ai = void 0;
+        var am;
+
+        if (typeof ap === 'string') {
+          am = false;
+        } else {
+          var aa = S[ag.charAt(0)];
+
+          if (aa) {
+            ai = ag.match(aa[1]);
+            ap = aa[0];
+          } else {
+            for (var ao = 0; ao < X; ++ao) {
+              aa = T[ao];
+              ai = ag.match(aa[1]);
+
+              if (ai) {
+                ap = aa[0];
+                break;
+              }
+            }
+
+            if (!ai) {
+              ap = F;
+            }
+          }
+
+          am = ap.length >= 5 && 'lang-' === ap.substring(0, 5);
+
+          if (am && !(ai && typeof ai[1] === 'string')) {
+            am = false;
+            ap = J;
+          }
+
+          if (!am) {
+            aj[ag] = ap;
+          }
+        }
+
+        var ab = af;
+        af += ag.length;
+
+        if (!am) {
+          ad.push(Y + ab, ap);
+        } else {
+          var al = ai[1];
+          var ak = ag.indexOf(al);
+          var ac = ak + al.length;
+
+          if (ai[2]) {
+            ac = ag.length - ai[2].length;
+            ak = ac - al.length;
+          }
+
+          var ar = ap.substring(5);
+          B(Y + ab, ag.substring(0, ak), W, ad);
+          B(Y + ab + ak, al, q(ar, al), ad);
+          B(Y + ab + ac, ag.substring(ac), W, ad);
+        }
+      }
+
+      ah.decorations = ad;
+    };
+
+    return W;
+  }
+
+  function i(T) {
+    var W = [],
+        S = [];
+
+    if (T.tripleQuotedStrings) {
+      W.push([C, /^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/, null, '\'"']);
+    } else {
+      if (T.multiLineStrings) {
+        W.push([C, /^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/, null, '\'"`']);
+      } else {
+        W.push([C, /^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/, null, '"\'']);
+      }
+    }
+
+    if (T.verbatimStrings) {
+      S.push([C, /^@\"(?:[^\"]|\"\")*(?:\"|$)/, null]);
+    }
+
+    var Y = T.hashComments;
+
+    if (Y) {
+      if (T.cStyleComments) {
+        if (Y > 1) {
+          W.push([j, /^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/, null, '#']);
+        } else {
+          W.push([j, /^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\r\n]*)/, null, '#']);
+        }
+
+        S.push([C, /^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/, null]);
+      } else {
+        W.push([j, /^#[^\r\n]*/, null, '#']);
+      }
+    }
+
+    if (T.cStyleComments) {
+      S.push([j, /^\/\/[^\r\n]*/, null]);
+      S.push([j, /^\/\*[\s\S]*?(?:\*\/|$)/, null]);
+    }
+
+    if (T.regexLiterals) {
+      var X = '/(?=[^/*])(?:[^/\\x5B\\x5C]|\\x5C[\\s\\S]|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+/';
+      S.push(['lang-regex', new RegExp('^' + M + '(' + X + ')')]);
+    }
+
+    var V = T.types;
+
+    if (V) {
+      S.push([O, V]);
+    }
+
+    var U = ('' + T.keywords).replace(/^ | $/g, '');
+
+    if (U.length) {
+      S.push([z, new RegExp('^(?:' + U.replace(/[\s,]+/g, '|') + ')\\b'), null]);
+    }
+
+    W.push([F, /^\s+/, null, ' \r\n\t\xA0']);
+    S.push([G, /^@[a-z_$][a-z_$@0-9]*/i, null], [O, /^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/, null], [F, /^[a-z_$][a-z_$@0-9]*/i, null], [G, new RegExp('^(?:0x[a-f0-9]+|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)(?:e[+\\-]?\\d+)?)[a-z]*', 'i'), null, '0123456789'], [F, /^\\[\s\S]?/, null], [L, /^.[^\s\w\.$@\'\"\`\/\#\\]*/, null]);
+    return g(W, S);
+  }
+
+  var K = i({
+    keywords: A,
+    hashComments: true,
+    cStyleComments: true,
+    multiLineStrings: true,
+    regexLiterals: true
+  });
+
+  function Q(V, ag) {
+    var U = /(?:^|\s)nocode(?:\s|$)/;
+    var ab = /\r\n?|\n/;
+    var ac = V.ownerDocument;
+    var S;
+
+    if (V.currentStyle) {
+      S = V.currentStyle.whiteSpace;
+    } else {
+      if (window.getComputedStyle) {
+        S = ac.defaultView.getComputedStyle(V, null).getPropertyValue('white-space');
+      }
+    }
+
+    var Z = S && 'pre' === S.substring(0, 3);
+    var af = ac.createElement('LI');
+
+    while (V.firstChild) {
+      af.appendChild(V.firstChild);
+    }
+
+    var W = [af];
+
+    function ae(al) {
+      switch (al.nodeType) {
+        case 1:
+          if (U.test(al.className)) {
+            break;
+          }
+
+          if ('BR' === al.nodeName) {
+            ad(al);
+
+            if (al.parentNode) {
+              al.parentNode.removeChild(al);
+            }
+          } else {
+            for (var an = al.firstChild; an; an = an.nextSibling) {
+              ae(an);
+            }
+          }
+
+          break;
+
+        case 3:
+        case 4:
+          if (Z) {
+            var am = al.nodeValue;
+            var aj = am.match(ab);
+
+            if (aj) {
+              var ai = am.substring(0, aj.index);
+              al.nodeValue = ai;
+              var ah = am.substring(aj.index + aj[0].length);
+
+              if (ah) {
+                var ak = al.parentNode;
+                ak.insertBefore(ac.createTextNode(ah), al.nextSibling);
+              }
+
+              ad(al);
+
+              if (!ai) {
+                al.parentNode.removeChild(al);
+              }
+            }
+          }
+
+          break;
+      }
+    }
+
+    function ad(ak) {
+      while (!ak.nextSibling) {
+        ak = ak.parentNode;
+
+        if (!ak) {
+          return;
+        }
+      }
+
+      function ai(al, ar) {
+        var aq = ar ? al.cloneNode(false) : al;
+        var ao = al.parentNode;
+
+        if (ao) {
+          var ap = ai(ao, 1);
+          var an = al.nextSibling;
+          ap.appendChild(aq);
+
+          for (var am = an; am; am = an) {
+            an = am.nextSibling;
+            ap.appendChild(am);
+          }
+        }
+
+        return aq;
+      }
+
+      var ah = ai(ak.nextSibling, 0);
+
+      for (var aj; (aj = ah.parentNode) && aj.nodeType === 1;) {
+        ah = aj;
+      }
+
+      W.push(ah);
+    }
+
+    for (var Y = 0; Y < W.length; ++Y) {
+      ae(W[Y]);
+    }
+
+    if (ag === (ag | 0)) {
+      W[0].setAttribute('value', ag);
+    }
+
+    var aa = ac.createElement('OL');
+    aa.className = 'linenums';
+    var X = Math.max(0, ag - 1 | 0) || 0;
+
+    for (var Y = 0, T = W.length; Y < T; ++Y) {
+      af = W[Y];
+      af.className = 'L' + (Y + X) % 10;
+
+      if (!af.firstChild) {
+        af.appendChild(ac.createTextNode('\xA0'));
+      }
+
+      aa.appendChild(af);
+    }
+
+    V.appendChild(aa);
+  }
+
+  function D(ac) {
+    var aj = /\bMSIE\b/.test(navigator.userAgent);
+    var am = /\n/g;
+    var al = ac.sourceCode;
+    var an = al.length;
+    var V = 0;
+    var aa = ac.spans;
+    var T = aa.length;
+    var ah = 0;
+    var X = ac.decorations;
+    var Y = X.length;
+    var Z = 0;
+    X[Y] = an;
+    var ar, aq;
+
+    for (aq = ar = 0; aq < Y;) {
+      if (X[aq] !== X[aq + 2]) {
+        X[ar++] = X[aq++];
+        X[ar++] = X[aq++];
+      } else {
+        aq += 2;
+      }
+    }
+
+    Y = ar;
+
+    for (aq = ar = 0; aq < Y;) {
+      var at = X[aq];
+      var ab = X[aq + 1];
+      var W = aq + 2;
+
+      while (W + 2 <= Y && X[W + 1] === ab) {
+        W += 2;
+      }
+
+      X[ar++] = at;
+      X[ar++] = ab;
+      aq = W;
+    }
+
+    Y = X.length = ar;
+    var ae = null;
+
+    while (ah < T) {
+      var af = aa[ah];
+      var S = aa[ah + 2] || an;
+      var ag = X[Z];
+      var ap = X[Z + 2] || an;
+      var W = Math.min(S, ap);
+      var ak = aa[ah + 1];
+      var U;
+
+      if (ak.nodeType !== 1 && (U = al.substring(V, W))) {
+        if (aj) {
+          U = U.replace(am, '\r');
+        }
+
+        ak.nodeValue = U;
+        var ai = ak.ownerDocument;
+        var ao = ai.createElement('SPAN');
+        ao.className = X[Z + 1];
+        var ad = ak.parentNode;
+        ad.replaceChild(ao, ak);
+        ao.appendChild(ak);
+
+        if (V < S) {
+          aa[ah + 1] = ak = ai.createTextNode(al.substring(W, S));
+          ad.insertBefore(ak, ao.nextSibling);
+        }
+      }
+
+      V = W;
+
+      if (V >= S) {
+        ah += 2;
+      }
+
+      if (V >= ap) {
+        Z += 2;
+      }
+    }
+  }
+
+  var t = {};
+
+  function c(U, V) {
+    for (var S = V.length; --S >= 0;) {
+      var T = V[S];
+
+      if (!t.hasOwnProperty(T)) {
+        t[T] = U;
+      } else {
+        if (window.console) {
+          console.warn('cannot override language handler %s', T);
+        }
+      }
+    }
+  }
+
+  function q(T, S) {
+    if (!(T && t.hasOwnProperty(T))) {
+      T = /^\s*</.test(S) ? 'default-markup' : 'default-code';
+    }
+
+    return t[T];
+  }
+
+  c(K, ['default-code']);
+  c(g([], [[F, /^[^<?]+/], [E, /^<!\w[^>]*(?:>|$)/], [j, /^<\!--[\s\S]*?(?:-\->|$)/], ['lang-', /^<\?([\s\S]+?)(?:\?>|$)/], ['lang-', /^<%([\s\S]+?)(?:%>|$)/], [L, /^(?:<[%?]|[%?]>)/], ['lang-', /^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i], ['lang-js', /^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i], ['lang-css', /^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i], ['lang-in.tag', /^(<\/?[a-z][^<>]*>)/i]]), ['default-markup', 'htm', 'html', 'mxml', 'xhtml', 'xml', 'xsl']);
+  c(g([[F, /^[\s]+/, null, ' \t\r\n'], [n, /^(?:\"[^\"]*\"?|\'[^\']*\'?)/, null, '"\'']], [[m, /^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i], [P, /^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i], ['lang-uq.val', /^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/], [L, /^[=<>\/]+/], ['lang-js', /^on\w+\s*=\s*\"([^\"]+)\"/i], ['lang-js', /^on\w+\s*=\s*\'([^\']+)\'/i], ['lang-js', /^on\w+\s*=\s*([^\"\'>\s]+)/i], ['lang-css', /^style\s*=\s*\"([^\"]+)\"/i], ['lang-css', /^style\s*=\s*\'([^\']+)\'/i], ['lang-css', /^style\s*=\s*([^\"\'>\s]+)/i]]), ['in.tag']);
+  c(g([], [[n, /^[\s\S]+/]]), ['uq.val']);
+  c(i({
+    keywords: l,
+    hashComments: true,
+    cStyleComments: true,
+    types: e
+  }), ['c', 'cc', 'cpp', 'cxx', 'cyc', 'm']);
+  c(i({
+    keywords: 'null,true,false'
+  }), ['json']);
+  c(i({
+    keywords: R,
+    hashComments: true,
+    cStyleComments: true,
+    verbatimStrings: true,
+    types: e
+  }), ['cs']);
+  c(i({
+    keywords: x,
+    cStyleComments: true
+  }), ['java']);
+  c(i({
+    keywords: H,
+    hashComments: true,
+    multiLineStrings: true
+  }), ['bsh', 'csh', 'sh']);
+  c(i({
+    keywords: I,
+    hashComments: true,
+    multiLineStrings: true,
+    tripleQuotedStrings: true
+  }), ['cv', 'py']);
+  c(i({
+    keywords: s,
+    hashComments: true,
+    multiLineStrings: true,
+    regexLiterals: true
+  }), ['perl', 'pl', 'pm']);
+  c(i({
+    keywords: f,
+    hashComments: true,
+    multiLineStrings: true,
+    regexLiterals: true
+  }), ['rb']);
+  c(i({
+    keywords: w,
+    cStyleComments: true,
+    regexLiterals: true
+  }), ['js']);
+  c(i({
+    keywords: r,
+    hashComments: 3,
+    cStyleComments: true,
+    multilineStrings: true,
+    tripleQuotedStrings: true,
+    regexLiterals: true
+  }), ['coffee']);
+  c(g([], [[C, /^[\s\S]+/]]), ['regex']);
+
+  function d(V) {
+    var U = V.langExtension;
+
+    try {
+      var S = a(V.sourceNode);
+      var T = S.sourceCode;
+      V.sourceCode = T;
+      V.spans = S.spans;
+      V.basePos = 0;
+      q(U, T)(V);
+      D(V);
+    } catch (W) {
+      if ('console' in window) {
+        console.log(W && W.stack ? W.stack : W);
+      }
+    }
+  }
+
+  function y(W, V, U) {
+    var S = document.createElement('PRE');
+    S.innerHTML = W;
+
+    if (U) {
+      Q(S, U);
+    }
+
+    var T = {
+      langExtension: V,
+      numberLines: U,
+      sourceNode: S
+    };
+    d(T);
+    return S.innerHTML;
+  }
+
+  function b(ad) {
+    function Y(af) {
+      return document.getElementsByTagName(af);
+    }
+
+    var ac = [Y('pre'), Y('code'), Y('xmp')];
+    var T = [];
+
+    for (var aa = 0; aa < ac.length; ++aa) {
+      for (var Z = 0, V = ac[aa].length; Z < V; ++Z) {
+        T.push(ac[aa][Z]);
+      }
+    }
+
+    ac = null;
+    var W = Date;
+
+    if (!W.now) {
+      W = {
+        now: function now() {
+          return +new Date();
+        }
+      };
+    }
+
+    var X = 0;
+    var S;
+    var ab = /\blang(?:uage)?-([\w.]+)(?!\S)/;
+    var ae = /\bprettyprint\b/;
+
+    function U() {
+      var ag = window.PR_SHOULD_USE_CONTINUATION ? W.now() + 250 : Infinity;
+
+      for (; X < T.length && W.now() < ag; X++) {
+        var aj = T[X];
+        var ai = aj.className;
+
+        if (ai.indexOf('prettyprint') >= 0) {
+          var ah = ai.match(ab);
+          var am;
+
+          if (!ah && (am = o(aj)) && 'CODE' === am.tagName) {
+            ah = am.className.match(ab);
+          }
+
+          if (ah) {
+            ah = ah[1];
+          }
+
+          var al = false;
+
+          for (var ak = aj.parentNode; ak; ak = ak.parentNode) {
+            if ((ak.tagName === 'pre' || ak.tagName === 'code' || ak.tagName === 'xmp') && ak.className && ak.className.indexOf('prettyprint') >= 0) {
+              al = true;
+              break;
+            }
+          }
+
+          if (!al) {
+            var af = aj.className.match(/\blinenums\b(?::(\d+))?/);
+            af = af ? af[1] && af[1].length ? +af[1] : true : false;
+
+            if (af) {
+              Q(aj, af);
+            }
+
+            S = {
+              langExtension: ah,
+              sourceNode: aj,
+              numberLines: af
+            };
+            d(S);
+          }
+        }
+      }
+
+      if (X < T.length) {
+        setTimeout(U, 250);
+      } else {
+        if (ad) {
+          ad();
+        }
+      }
+    }
+
+    U();
+  }
+
+  window.prettyPrintOne = y;
+  window.prettyPrint = b;
+  window.PR = {
+    createSimpleLexer: g,
+    registerLangHandler: c,
+    sourceDecorator: i,
+    PR_ATTRIB_NAME: P,
+    PR_ATTRIB_VALUE: n,
+    PR_COMMENT: j,
+    PR_DECLARATION: E,
+    PR_KEYWORD: z,
+    PR_LITERAL: G,
+    PR_NOCODE: N,
+    PR_PLAIN: F,
+    PR_PUNCTUATION: L,
+    PR_SOURCE: J,
+    PR_STRING: C,
+    PR_TAG: m,
+    PR_TYPE: O
+  };
+})();
+
+PR.registerLangHandler(PR.createSimpleLexer([], [[PR.PR_DECLARATION, /^<!\w[^>]*(?:>|$)/], [PR.PR_COMMENT, /^<\!--[\s\S]*?(?:-\->|$)/], [PR.PR_PUNCTUATION, /^(?:<[%?]|[%?]>)/], ['lang-', /^<\?([\s\S]+?)(?:\?>|$)/], ['lang-', /^<%([\s\S]+?)(?:%>|$)/], ['lang-', /^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i], ['lang-handlebars', /^<script\b[^>]*type\s*=\s*['"]?text\/x-handlebars-template['"]?\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i], ['lang-js', /^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i], ['lang-css', /^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i], ['lang-in.tag', /^(<\/?[a-z][^<>]*>)/i], [PR.PR_DECLARATION, /^{{[#^>/]?\s*[\w.][^}]*}}/], [PR.PR_DECLARATION, /^{{&?\s*[\w.][^}]*}}/], [PR.PR_DECLARATION, /^{{{>?\s*[\w.][^}]*}}}/], [PR.PR_COMMENT, /^{{![^}]*}}/]]), ['handlebars', 'hbs']);
+PR.registerLangHandler(PR.createSimpleLexer([[PR.PR_PLAIN, /^[ \t\r\n\f]+/, null, ' \t\r\n\f']], [[PR.PR_STRING, /^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/, null], [PR.PR_STRING, /^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/, null], ['lang-css-str', /^url\(([^\)\"\']*)\)/i], [PR.PR_KEYWORD, /^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i, null], ['lang-css-kw', /^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i], [PR.PR_COMMENT, /^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//], [PR.PR_COMMENT, /^(?:<!--|-->)/], [PR.PR_LITERAL, /^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i], [PR.PR_LITERAL, /^#(?:[0-9a-f]{3}){1,2}/i], [PR.PR_PLAIN, /^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i], [PR.PR_PUNCTUATION, /^[^\s\w\'\"]+/]]), ['css']);
+PR.registerLangHandler(PR.createSimpleLexer([], [[PR.PR_KEYWORD, /^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]]), ['css-kw']);
+PR.registerLangHandler(PR.createSimpleLexer([], [[PR.PR_STRING, /^[^\)\"\']+/]]), ['css-str']);

frontend-admin/node_modules/css-in-js-utils/es/coverage/lcov-report/sorter.d.ts

@@ -0,0 +1 @@
+declare function addSorting(): void;

frontend-admin/node_modules/css-in-js-utils/es/coverage/lcov-report/sorter.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var addSorting = function () {
+  'use strict';
+
+  var cols,
+      currentSort = {
+    index: 0,
+    desc: false
+  }; // returns the summary table element
+
+  function getTable() {
+    return document.querySelector('.coverage-summary');
+  } // returns the thead element of the summary table
+
+
+  function getTableHeader() {
+    return getTable().querySelector('thead tr');
+  } // returns the tbody element of the summary table
+
+
+  function getTableBody() {
+    return getTable().querySelector('tbody');
+  } // returns the th element for nth column
+
+
+  function getNthColumn(n) {
+    return getTableHeader().querySelectorAll('th')[n];
+  } // loads all columns
+
+
+  function loadColumns() {
+    var colNodes = getTableHeader().querySelectorAll('th'),
+        colNode,
+        cols = [],
+        col,
+        i;
+
+    for (i = 0; i < colNodes.length; i += 1) {
+      colNode = colNodes[i];
+      col = {
+        key: colNode.getAttribute('data-col'),
+        sortable: !colNode.getAttribute('data-nosort'),
+        type: colNode.getAttribute('data-type') || 'string'
+      };
+      cols.push(col);
+
+      if (col.sortable) {
+        col.defaultDescSort = col.type === 'number';
+        colNode.innerHTML = colNode.innerHTML + '<span class="sorter"></span>';
+      }
+    }
+
+    return cols;
+  } // attaches a data attribute to every tr element with an object
+  // of data values keyed by column name
+
+
+  function loadRowData(tableRow) {
+    var tableCols = tableRow.querySelectorAll('td'),
+        colNode,
+        col,
+        data = {},
+        i,
+        val;
+
+    for (i = 0; i < tableCols.length; i += 1) {
+      colNode = tableCols[i];
+      col = cols[i];
+      val = colNode.getAttribute('data-value');
+
+      if (col.type === 'number') {
+        val = Number(val);
+      }
+
+      data[col.key] = val;
+    }
+
+    return data;
+  } // loads all row data
+
+
+  function loadData() {
+    var rows = getTableBody().querySelectorAll('tr'),
+        i;
+
+    for (i = 0; i < rows.length; i += 1) {
+      rows[i].data = loadRowData(rows[i]);
+    }
+  } // sorts the table using the data for the ith column
+
+
+  function sortByIndex(index, desc) {
+    var key = cols[index].key,
+        sorter = function sorter(a, b) {
+      a = a.data[key];
+      b = b.data[key];
+      return a < b ? -1 : a > b ? 1 : 0;
+    },
+        finalSorter = sorter,
+        tableBody = document.querySelector('.coverage-summary tbody'),
+        rowNodes = tableBody.querySelectorAll('tr'),
+        rows = [],
+        i;
+
+    if (desc) {
+      finalSorter = function finalSorter(a, b) {
+        return -1 * sorter(a, b);
+      };
+    }
+
+    for (i = 0; i < rowNodes.length; i += 1) {
+      rows.push(rowNodes[i]);
+      tableBody.removeChild(rowNodes[i]);
+    }
+
+    rows.sort(finalSorter);
+
+    for (i = 0; i < rows.length; i += 1) {
+      tableBody.appendChild(rows[i]);
+    }
+  } // removes sort indicators for current column being sorted
+
+
+  function removeSortIndicators() {
+    var col = getNthColumn(currentSort.index),
+        cls = col.className;
+    cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+    col.className = cls;
+  } // adds sort indicators for current column being sorted
+
+
+  function addSortIndicators() {
+    getNthColumn(currentSort.index).className += currentSort.desc ? ' sorted-desc' : ' sorted';
+  } // adds event listeners for all sorter widgets
+
+
+  function enableUI() {
+    var i,
+        el,
+        ithSorter = function ithSorter(i) {
+      var col = cols[i];
+      return function () {
+        var desc = col.defaultDescSort;
+
+        if (currentSort.index === i) {
+          desc = !currentSort.desc;
+        }
+
+        sortByIndex(i, desc);
+        removeSortIndicators();
+        currentSort.index = i;
+        currentSort.desc = desc;
+        addSortIndicators();
+      };
+    };
+
+    for (i = 0; i < cols.length; i += 1) {
+      if (cols[i].sortable) {
+        // add the click event handler on the th so users
+        // dont have to click on those tiny arrows
+        el = getNthColumn(i).querySelector('.sorter').parentElement;
+
+        if (el.addEventListener) {
+          el.addEventListener('click', ithSorter(i));
+        } else {
+          el.attachEvent('onclick', ithSorter(i));
+        }
+      }
+    }
+  } // adds sorting functionality to the UI
+
+
+  return function () {
+    if (!getTable()) {
+      return;
+    }
+
+    cols = loadColumns();
+    loadData(cols);
+    addSortIndicators();
+    enableUI();
+  };
+}();
+
+window.addEventListener('load', addSorting);

frontend-admin/node_modules/css-in-js-utils/es/cssifyDeclaration.d.ts

@@ -0,0 +1 @@
+export default function cssifyDeclaration(property: string, value: string | number): string;

frontend-admin/node_modules/css-in-js-utils/es/cssifyDeclaration.js

@@ -0,0 +1,4 @@
+import hyphenateProperty from './hyphenateProperty';
+export default function cssifyDeclaration(property, value) {
+  return hyphenateProperty(property) + ':' + value;
+}

frontend-admin/node_modules/css-in-js-utils/es/cssifyObject.d.ts

@@ -0,0 +1,4 @@
+export declare type StyleObject = {
+    [key: string]: string | number | StyleObject | (string | number | StyleObject)[];
+};
+export default function cssifyObject(style: StyleObject): string;

frontend-admin/node_modules/css-in-js-utils/es/cssifyObject.js

@@ -0,0 +1,22 @@
+import cssifyDeclaration from './cssifyDeclaration';
+export default function cssifyObject(style) {
+  var css = '';
+
+  for (var property in style) {
+    var value = style[property];
+
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      continue;
+    } // prevents the semicolon after
+    // the last rule declaration
+
+
+    if (css) {
+      css += ';';
+    }
+
+    css += cssifyDeclaration(property, value);
+  }
+
+  return css;
+}

frontend-admin/node_modules/css-in-js-utils/es/hyphenateProperty.d.ts

@@ -0,0 +1 @@
+export default function hyphenateProperty(property: string | number): string;

frontend-admin/node_modules/css-in-js-utils/es/hyphenateProperty.js

@@ -0,0 +1,4 @@
+import hyphenateStyleName from 'hyphenate-style-name';
+export default function hyphenateProperty(property) {
+  return hyphenateStyleName(property);
+}

frontend-admin/node_modules/css-in-js-utils/es/index.d.ts

@@ -0,0 +1,13 @@
+import assignStyle from './assignStyle';
+import camelCaseProperty from './camelCaseProperty';
+import cssifyDeclaration from './cssifyDeclaration';
+import cssifyObject from './cssifyObject';
+import hyphenateProperty from './hyphenateProperty';
+import isPrefixedProperty from './isPrefixedProperty';
+import isPrefixedValue from './isPrefixedValue';
+import isUnitlessProperty from './isUnitlessProperty';
+import normalizeProperty from './normalizeProperty';
+import resolveArrayValue from './resolveArrayValue';
+import unprefixProperty from './unprefixProperty';
+import unprefixValue from './unprefixValue';
+export { assignStyle, camelCaseProperty, cssifyDeclaration, cssifyObject, hyphenateProperty, isPrefixedProperty, isPrefixedValue, isUnitlessProperty, normalizeProperty, resolveArrayValue, unprefixProperty, unprefixValue, };

frontend-admin/node_modules/css-in-js-utils/es/index.js

@@ -0,0 +1,13 @@
+import assignStyle from './assignStyle';
+import camelCaseProperty from './camelCaseProperty';
+import cssifyDeclaration from './cssifyDeclaration';
+import cssifyObject from './cssifyObject';
+import hyphenateProperty from './hyphenateProperty';
+import isPrefixedProperty from './isPrefixedProperty';
+import isPrefixedValue from './isPrefixedValue';
+import isUnitlessProperty from './isUnitlessProperty';
+import normalizeProperty from './normalizeProperty';
+import resolveArrayValue from './resolveArrayValue';
+import unprefixProperty from './unprefixProperty';
+import unprefixValue from './unprefixValue';
+export { assignStyle, camelCaseProperty, cssifyDeclaration, cssifyObject, hyphenateProperty, isPrefixedProperty, isPrefixedValue, isUnitlessProperty, normalizeProperty, resolveArrayValue, unprefixProperty, unprefixValue };

frontend-admin/node_modules/css-in-js-utils/es/isPrefixedProperty.d.ts

@@ -0,0 +1 @@
+export default function isPrefixedProperty(property: string): boolean;

frontend-admin/node_modules/css-in-js-utils/es/isPrefixedProperty.js

@@ -0,0 +1,4 @@
+var RE = /^(Webkit|Moz|O|ms)/;
+export default function isPrefixedProperty(property) {
+  return RE.test(property);
+}

frontend-admin/node_modules/css-in-js-utils/es/isPrefixedValue.d.ts

@@ -0,0 +1 @@
+export default function isPrefixedValue(value: string): boolean;

frontend-admin/node_modules/css-in-js-utils/es/isPrefixedValue.js

@@ -0,0 +1,4 @@
+var RE = /-webkit-|-moz-|-ms-/;
+export default function isPrefixedValue(value) {
+  return typeof value === 'string' && RE.test(value);
+}

frontend-admin/node_modules/css-in-js-utils/es/isUnitlessProperty.d.ts

@@ -0,0 +1 @@
+export default function isUnitlessProperty(property: string): boolean;

frontend-admin/node_modules/css-in-js-utils/es/isUnitlessProperty.js

@@ -0,0 +1,48 @@
+import hyphenateProperty from './hyphenateProperty';
+var unitlessProperties = {
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  fontWeight: true,
+  lineHeight: true,
+  opacity: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+var prefixedUnitlessProperties = ['animationIterationCount', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridColumn', 'gridColumnEnd', 'gridColumnStart', 'gridRow', 'gridRowEnd', 'gridRowStart', 'lineClamp', 'order'];
+var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
+
+function getPrefixedProperty(prefix, property) {
+  return prefix + property.charAt(0).toUpperCase() + property.slice(1);
+} // add all prefixed properties to the unitless properties
+
+
+for (var i = 0, len = prefixedUnitlessProperties.length; i < len; ++i) {
+  var property = prefixedUnitlessProperties[i];
+  unitlessProperties[property] = true;
+
+  for (var j = 0, jLen = prefixes.length; j < jLen; ++j) {
+    unitlessProperties[getPrefixedProperty(prefixes[j], property)] = true;
+  }
+} // add all hypenated properties as well
+
+
+for (var _property in unitlessProperties) {
+  unitlessProperties[hyphenateProperty(_property)] = true;
+}
+
+export default function isUnitlessProperty(property) {
+  return unitlessProperties.hasOwnProperty(property);
+}

frontend-admin/node_modules/css-in-js-utils/es/normalizeProperty.d.ts

@@ -0,0 +1 @@
+export default function normalizeProperty(property: string): string;

frontend-admin/node_modules/css-in-js-utils/es/normalizeProperty.js

@@ -0,0 +1,5 @@
+import camelCaseProperty from './camelCaseProperty';
+import unprefixProperty from './unprefixProperty';
+export default function normalizeProperty(property) {
+  return unprefixProperty(camelCaseProperty(property));
+}

frontend-admin/node_modules/css-in-js-utils/es/resolveArrayValue.d.ts

@@ -0,0 +1 @@
+export default function resolveArrayValue(property: string, value: string[]): string;

frontend-admin/node_modules/css-in-js-utils/es/resolveArrayValue.js

@@ -0,0 +1,4 @@
+import hyphenateProperty from './hyphenateProperty';
+export default function resolveArrayValue(property, value) {
+  return value.join(';' + hyphenateProperty(property) + ':');
+}

frontend-admin/node_modules/css-in-js-utils/es/unprefixProperty.d.ts

@@ -0,0 +1 @@
+export default function unprefixProperty(property: string): string;

frontend-admin/node_modules/css-in-js-utils/es/unprefixProperty.js

@@ -0,0 +1,5 @@
+var RE = /^(ms|Webkit|Moz|O)/;
+export default function unprefixProperty(property) {
+  var propertyWithoutPrefix = property.replace(RE, '');
+  return propertyWithoutPrefix.charAt(0).toLowerCase() + propertyWithoutPrefix.slice(1);
+}

frontend-admin/node_modules/css-in-js-utils/es/unprefixValue.d.ts

@@ -0,0 +1 @@
+export default function unprefixValue(value: string | string[]): string | string[];

frontend-admin/node_modules/css-in-js-utils/es/unprefixValue.js

@@ -0,0 +1,8 @@
+var RE = /(-ms-|-webkit-|-moz-|-o-)/g;
+export default function unprefixValue(value) {
+  if (typeof value === 'string') {
+    return value.replace(RE, '');
+  }
+
+  return value;
+}

frontend-admin/node_modules/css-in-js-utils/lib/assignStyle.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = assignStyle;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function filterUniqueArray(arr) {
+  return arr.filter(function (val, index) {
+    return arr.lastIndexOf(val) === index;
+  });
+}
+
+function assignStyle(base) {
+  for (var i = 0, len = arguments.length <= 1 ? 0 : arguments.length - 1; i < len; ++i) {
+    var style = i + 1 < 1 || arguments.length <= i + 1 ? undefined : arguments[i + 1];
+
+    for (var property in style) {
+      var value = style[property];
+      var baseValue = base[property];
+
+      if (baseValue && value) {
+        if (Array.isArray(baseValue)) {
+          base[property] = filterUniqueArray(baseValue.concat(value));
+          continue;
+        }
+
+        if (Array.isArray(value)) {
+          base[property] = filterUniqueArray([baseValue].concat(_toConsumableArray(value)));
+          continue;
+        }
+
+        if (_typeof(value) === 'object') {
+          base[property] = assignStyle({}, baseValue, value);
+          continue;
+        }
+      }
+
+      base[property] = value;
+    }
+  }
+
+  return base;
+}

frontend-admin/node_modules/css-in-js-utils/lib/camelCaseProperty.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = camelCaseProperty;
+var DASH = /-([a-z])/g;
+var MS = /^Ms/g;
+var cache = {};
+
+function toUpper(match) {
+  return match[1].toUpperCase();
+}
+
+function camelCaseProperty(property) {
+  if (cache.hasOwnProperty(property)) {
+    return cache[property];
+  }
+
+  var camelProp = property.replace(DASH, toUpper).replace(MS, 'ms');
+  cache[property] = camelProp;
+  return camelProp;
+}

frontend-admin/node_modules/css-in-js-utils/lib/cssifyDeclaration.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = cssifyDeclaration;
+
+var _hyphenateProperty = require("./hyphenateProperty");
+
+var _hyphenateProperty2 = _interopRequireDefault(_hyphenateProperty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function cssifyDeclaration(property, value) {
+  return (0, _hyphenateProperty2["default"])(property) + ':' + value;
+}

frontend-admin/node_modules/css-in-js-utils/lib/cssifyObject.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = cssifyObject;
+
+var _cssifyDeclaration = require("./cssifyDeclaration");
+
+var _cssifyDeclaration2 = _interopRequireDefault(_cssifyDeclaration);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function cssifyObject(style) {
+  var css = '';
+
+  for (var property in style) {
+    var value = style[property];
+
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      continue;
+    } // prevents the semicolon after
+    // the last rule declaration
+
+
+    if (css) {
+      css += ';';
+    }
+
+    css += (0, _cssifyDeclaration2["default"])(property, value);
+  }
+
+  return css;
+}

frontend-admin/node_modules/css-in-js-utils/lib/hyphenateProperty.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = hyphenateProperty;
+
+var _hyphenateStyleName = require("hyphenate-style-name");
+
+var _hyphenateStyleName2 = _interopRequireDefault(_hyphenateStyleName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function hyphenateProperty(property) {
+  return (0, _hyphenateStyleName2["default"])(property);
+}

frontend-admin/node_modules/css-in-js-utils/lib/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unprefixValue = exports.unprefixProperty = exports.resolveArrayValue = exports.normalizeProperty = exports.isUnitlessProperty = exports.isPrefixedValue = exports.isPrefixedProperty = exports.hyphenateProperty = exports.cssifyObject = exports.cssifyDeclaration = exports.camelCaseProperty = exports.assignStyle = undefined;
+
+var _assignStyle = require("./assignStyle");
+
+var _assignStyle2 = _interopRequireDefault(_assignStyle);
+
+var _camelCaseProperty = require("./camelCaseProperty");
+
+var _camelCaseProperty2 = _interopRequireDefault(_camelCaseProperty);
+
+var _cssifyDeclaration = require("./cssifyDeclaration");
+
+var _cssifyDeclaration2 = _interopRequireDefault(_cssifyDeclaration);
+
+var _cssifyObject = require("./cssifyObject");
+
+var _cssifyObject2 = _interopRequireDefault(_cssifyObject);
+
+var _hyphenateProperty = require("./hyphenateProperty");
+
+var _hyphenateProperty2 = _interopRequireDefault(_hyphenateProperty);
+
+var _isPrefixedProperty = require("./isPrefixedProperty");
+
+var _isPrefixedProperty2 = _interopRequireDefault(_isPrefixedProperty);
+
+var _isPrefixedValue = require("./isPrefixedValue");
+
+var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+
+var _isUnitlessProperty = require("./isUnitlessProperty");
+
+var _isUnitlessProperty2 = _interopRequireDefault(_isUnitlessProperty);
+
+var _normalizeProperty = require("./normalizeProperty");
+
+var _normalizeProperty2 = _interopRequireDefault(_normalizeProperty);
+
+var _resolveArrayValue = require("./resolveArrayValue");
+
+var _resolveArrayValue2 = _interopRequireDefault(_resolveArrayValue);
+
+var _unprefixProperty = require("./unprefixProperty");
+
+var _unprefixProperty2 = _interopRequireDefault(_unprefixProperty);
+
+var _unprefixValue = require("./unprefixValue");
+
+var _unprefixValue2 = _interopRequireDefault(_unprefixValue);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+exports.assignStyle = _assignStyle2["default"];
+exports.camelCaseProperty = _camelCaseProperty2["default"];
+exports.cssifyDeclaration = _cssifyDeclaration2["default"];
+exports.cssifyObject = _cssifyObject2["default"];
+exports.hyphenateProperty = _hyphenateProperty2["default"];
+exports.isPrefixedProperty = _isPrefixedProperty2["default"];
+exports.isPrefixedValue = _isPrefixedValue2["default"];
+exports.isUnitlessProperty = _isUnitlessProperty2["default"];
+exports.normalizeProperty = _normalizeProperty2["default"];
+exports.resolveArrayValue = _resolveArrayValue2["default"];
+exports.unprefixProperty = _unprefixProperty2["default"];
+exports.unprefixValue = _unprefixValue2["default"];

frontend-admin/node_modules/css-in-js-utils/lib/isPrefixedProperty.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isPrefixedProperty;
+var RE = /^(Webkit|Moz|O|ms)/;
+
+function isPrefixedProperty(property) {
+  return RE.test(property);
+}

frontend-admin/node_modules/css-in-js-utils/lib/isPrefixedValue.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isPrefixedValue;
+var RE = /-webkit-|-moz-|-ms-/;
+
+function isPrefixedValue(value) {
+  return typeof value === 'string' && RE.test(value);
+}

frontend-admin/node_modules/css-in-js-utils/lib/isUnitlessProperty.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = isUnitlessProperty;
+
+var _hyphenateProperty = require("./hyphenateProperty");
+
+var _hyphenateProperty2 = _interopRequireDefault(_hyphenateProperty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var unitlessProperties = {
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  fontWeight: true,
+  lineHeight: true,
+  opacity: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+var prefixedUnitlessProperties = ['animationIterationCount', 'boxFlex', 'boxFlexGroup', 'boxOrdinalGroup', 'columnCount', 'flex', 'flexGrow', 'flexPositive', 'flexShrink', 'flexNegative', 'flexOrder', 'gridColumn', 'gridColumnEnd', 'gridColumnStart', 'gridRow', 'gridRowEnd', 'gridRowStart', 'lineClamp', 'order'];
+var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
+
+function getPrefixedProperty(prefix, property) {
+  return prefix + property.charAt(0).toUpperCase() + property.slice(1);
+} // add all prefixed properties to the unitless properties
+
+
+for (var i = 0, len = prefixedUnitlessProperties.length; i < len; ++i) {
+  var property = prefixedUnitlessProperties[i];
+  unitlessProperties[property] = true;
+
+  for (var j = 0, jLen = prefixes.length; j < jLen; ++j) {
+    unitlessProperties[getPrefixedProperty(prefixes[j], property)] = true;
+  }
+} // add all hypenated properties as well
+
+
+for (var _property in unitlessProperties) {
+  unitlessProperties[(0, _hyphenateProperty2["default"])(_property)] = true;
+}
+
+function isUnitlessProperty(property) {
+  return unitlessProperties.hasOwnProperty(property);
+}

frontend-admin/node_modules/css-in-js-utils/lib/normalizeProperty.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = normalizeProperty;
+
+var _camelCaseProperty = require("./camelCaseProperty");
+
+var _camelCaseProperty2 = _interopRequireDefault(_camelCaseProperty);
+
+var _unprefixProperty = require("./unprefixProperty");
+
+var _unprefixProperty2 = _interopRequireDefault(_unprefixProperty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function normalizeProperty(property) {
+  return (0, _unprefixProperty2["default"])((0, _camelCaseProperty2["default"])(property));
+}

frontend-admin/node_modules/css-in-js-utils/lib/resolveArrayValue.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = resolveArrayValue;
+
+var _hyphenateProperty = require("./hyphenateProperty");
+
+var _hyphenateProperty2 = _interopRequireDefault(_hyphenateProperty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function resolveArrayValue(property, value) {
+  return value.join(';' + (0, _hyphenateProperty2["default"])(property) + ':');
+}

frontend-admin/node_modules/css-in-js-utils/lib/unprefixProperty.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = unprefixProperty;
+var RE = /^(ms|Webkit|Moz|O)/;
+
+function unprefixProperty(property) {
+  var propertyWithoutPrefix = property.replace(RE, '');
+  return propertyWithoutPrefix.charAt(0).toLowerCase() + propertyWithoutPrefix.slice(1);
+}

frontend-admin/node_modules/css-in-js-utils/lib/unprefixValue.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = unprefixValue;
+var RE = /(-ms-|-webkit-|-moz-|-o-)/g;
+
+function unprefixValue(value) {
+  if (typeof value === 'string') {
+    return value.replace(RE, '');
+  }
+
+  return value;
+}

frontend-admin/node_modules/css-in-js-utils/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "css-in-js-utils",
+  "version": "3.1.0",
+  "description": "Useful utility functions for CSS in JS solutions",
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "types": "es/index.d.ts",
+  "jsnext:main": "es/index.js",
+  "sideEffects": false,
+  "files": [
+    "lib/**",
+    "es/**"
+  ],
+  "keywords": [
+    "css",
+    "cssinjs",
+    "utils",
+    "small"
+  ],
+  "repository": "https://github.com/robinweser/css-in-js-utils.git",
+  "author": "robinweser <contact@weser.io>",
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn run clean && yarn build:es && yarn build:lib",
+    "build:lib": "cross-env BABEL_ENV=commonjs babel modules --extensions '.ts' --ignore 'modules/__tests__','**/*.d.ts' --out-dir lib",
+    "build:es": "tsc && babel es --out-dir es",
+    "clean": "rimraf es lib coverage",
+    "check": "yarn lint && yarn test:coverage",
+    "format": "prettier --write \"modules/**/*.{js,ts}\"",
+    "lint": "eslint 'modules/**/*.{js,ts}'",
+    "release": "git pull --rebase && yarn run check && yarn build && npm publish",
+    "test": "cross-env BABEL_ENV=commonjs jest",
+    "test:coverage": "cross-env BABEL_ENV=commonjs jest --coverage",
+    "watch": "yarn test -- --watch"
+  },
+  "jest": {
+    "moduleDirectories": [
+      "node_modules",
+      "modules"
+    ]
+  },
+  "dependencies": {
+    "hyphenate-style-name": "^1.0.3"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.8.4",
+    "@babel/core": "^7.9.0",
+    "@babel/preset-env": "^7.9.5",
+    "@babel/preset-typescript": "^7.9.0",
+    "@types/jest": "^25.2.1",
+    "@typescript-eslint/eslint-plugin": "^2.26.0",
+    "@typescript-eslint/parser": "^2.26.0",
+    "babel-jest": "^25.2.6",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+    "cross-env": "^7.0.2",
+    "eslint": "^6.8.0",
+    "eslint-config-airbnb-base": "^14.1.0",
+    "eslint-plugin-import": "^2.20.2",
+    "jest": "^25.2.6",
+    "prettier": "^1.7.4",
+    "rimraf": "^2.6.1",
+    "typescript": "^3.8.3"
+  }
+}