{"version":3,"file":"polyfills.0a69e.js","mappings":"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","sources":["webpack://@rocket.chat/livechat/webpack/bootstrap","webpack://@rocket.chat/livechat/webpack/runtime/global","webpack://@rocket.chat/livechat/./node_modules/whatwg-fetch/fetch.js","webpack://@rocket.chat/livechat/../node_modules/get-css-data/dist/get-css-data.esm.js","webpack://@rocket.chat/livechat/../node_modules/balanced-match/index.js","webpack://@rocket.chat/livechat/../src/parse-css.js","webpack://@rocket.chat/livechat/../src/parse-vars.js","webpack://@rocket.chat/livechat/../src/stringify-css.js","webpack://@rocket.chat/livechat/../src/walk-css.js","webpack://@rocket.chat/livechat/../src/transform-css.js","webpack://@rocket.chat/livechat/../src/index.js","webpack://@rocket.chat/livechat/./src/polyfills.js"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","/* eslint-disable no-prototype-builtins */\nvar g =\n  (typeof globalThis !== 'undefined' && globalThis) ||\n  (typeof self !== 'undefined' && self) ||\n  // eslint-disable-next-line no-undef\n  (typeof global !== 'undefined' && global) ||\n  {}\n\nvar support = {\n  searchParams: 'URLSearchParams' in g,\n  iterable: 'Symbol' in g && 'iterator' in Symbol,\n  blob:\n    'FileReader' in g &&\n    'Blob' in g &&\n    (function() {\n      try {\n        new Blob()\n        return true\n      } catch (e) {\n        return false\n      }\n    })(),\n  formData: 'FormData' in g,\n  arrayBuffer: 'ArrayBuffer' in g\n}\n\nfunction isDataView(obj) {\n  return obj && DataView.prototype.isPrototypeOf(obj)\n}\n\nif (support.arrayBuffer) {\n  var viewClasses = [\n    '[object Int8Array]',\n    '[object Uint8Array]',\n    '[object Uint8ClampedArray]',\n    '[object Int16Array]',\n    '[object Uint16Array]',\n    '[object Int32Array]',\n    '[object Uint32Array]',\n    '[object Float32Array]',\n    '[object Float64Array]'\n  ]\n\n  var isArrayBufferView =\n    ArrayBuffer.isView ||\n    function(obj) {\n      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n    }\n}\n\nfunction normalizeName(name) {\n  if (typeof name !== 'string') {\n    name = String(name)\n  }\n  if (/[^a-z0-9\\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {\n    throw new TypeError('Invalid character in header field name: \"' + name + '\"')\n  }\n  return name.toLowerCase()\n}\n\nfunction normalizeValue(value) {\n  if (typeof value !== 'string') {\n    value = String(value)\n  }\n  return value\n}\n\n// Build a destructive iterator for the value list\nfunction iteratorFor(items) {\n  var iterator = {\n    next: function() {\n      var value = items.shift()\n      return {done: value === undefined, value: value}\n    }\n  }\n\n  if (support.iterable) {\n    iterator[Symbol.iterator] = function() {\n      return iterator\n    }\n  }\n\n  return iterator\n}\n\nexport function Headers(headers) {\n  this.map = {}\n\n  if (headers instanceof Headers) {\n    headers.forEach(function(value, name) {\n      this.append(name, value)\n    }, this)\n  } else if (Array.isArray(headers)) {\n    headers.forEach(function(header) {\n      if (header.length != 2) {\n        throw new TypeError('Headers constructor: expected name/value pair to be length 2, found' + header.length)\n      }\n      this.append(header[0], header[1])\n    }, this)\n  } else if (headers) {\n    Object.getOwnPropertyNames(headers).forEach(function(name) {\n      this.append(name, headers[name])\n    }, this)\n  }\n}\n\nHeaders.prototype.append = function(name, value) {\n  name = normalizeName(name)\n  value = normalizeValue(value)\n  var oldValue = this.map[name]\n  this.map[name] = oldValue ? oldValue + ', ' + value : value\n}\n\nHeaders.prototype['delete'] = function(name) {\n  delete this.map[normalizeName(name)]\n}\n\nHeaders.prototype.get = function(name) {\n  name = normalizeName(name)\n  return this.has(name) ? this.map[name] : null\n}\n\nHeaders.prototype.has = function(name) {\n  return this.map.hasOwnProperty(normalizeName(name))\n}\n\nHeaders.prototype.set = function(name, value) {\n  this.map[normalizeName(name)] = normalizeValue(value)\n}\n\nHeaders.prototype.forEach = function(callback, thisArg) {\n  for (var name in this.map) {\n    if (this.map.hasOwnProperty(name)) {\n      callback.call(thisArg, this.map[name], name, this)\n    }\n  }\n}\n\nHeaders.prototype.keys = function() {\n  var items = []\n  this.forEach(function(value, name) {\n    items.push(name)\n  })\n  return iteratorFor(items)\n}\n\nHeaders.prototype.values = function() {\n  var items = []\n  this.forEach(function(value) {\n    items.push(value)\n  })\n  return iteratorFor(items)\n}\n\nHeaders.prototype.entries = function() {\n  var items = []\n  this.forEach(function(value, name) {\n    items.push([name, value])\n  })\n  return iteratorFor(items)\n}\n\nif (support.iterable) {\n  Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n}\n\nfunction consumed(body) {\n  if (body._noBody) return\n  if (body.bodyUsed) {\n    return Promise.reject(new TypeError('Already read'))\n  }\n  body.bodyUsed = true\n}\n\nfunction fileReaderReady(reader) {\n  return new Promise(function(resolve, reject) {\n    reader.onload = function() {\n      resolve(reader.result)\n    }\n    reader.onerror = function() {\n      reject(reader.error)\n    }\n  })\n}\n\nfunction readBlobAsArrayBuffer(blob) {\n  var reader = new FileReader()\n  var promise = fileReaderReady(reader)\n  reader.readAsArrayBuffer(blob)\n  return promise\n}\n\nfunction readBlobAsText(blob) {\n  var reader = new FileReader()\n  var promise = fileReaderReady(reader)\n  var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type)\n  var encoding = match ? match[1] : 'utf-8'\n  reader.readAsText(blob, encoding)\n  return promise\n}\n\nfunction readArrayBufferAsText(buf) {\n  var view = new Uint8Array(buf)\n  var chars = new Array(view.length)\n\n  for (var i = 0; i < view.length; i++) {\n    chars[i] = String.fromCharCode(view[i])\n  }\n  return chars.join('')\n}\n\nfunction bufferClone(buf) {\n  if (buf.slice) {\n    return buf.slice(0)\n  } else {\n    var view = new Uint8Array(buf.byteLength)\n    view.set(new Uint8Array(buf))\n    return view.buffer\n  }\n}\n\nfunction Body() {\n  this.bodyUsed = false\n\n  this._initBody = function(body) {\n    /*\n      fetch-mock wraps the Response object in an ES6 Proxy to\n      provide useful test harness features such as flush. However, on\n      ES5 browsers without fetch or Proxy support pollyfills must be used;\n      the proxy-pollyfill is unable to proxy an attribute unless it exists\n      on the object before the Proxy is created. This change ensures\n      Response.bodyUsed exists on the instance, while maintaining the\n      semantic of setting Request.bodyUsed in the constructor before\n      _initBody is called.\n    */\n    // eslint-disable-next-line no-self-assign\n    this.bodyUsed = this.bodyUsed\n    this._bodyInit = body\n    if (!body) {\n      this._noBody = true;\n      this._bodyText = ''\n    } else if (typeof body === 'string') {\n      this._bodyText = body\n    } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n      this._bodyBlob = body\n    } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n      this._bodyFormData = body\n    } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n      this._bodyText = body.toString()\n    } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n      this._bodyArrayBuffer = bufferClone(body.buffer)\n      // IE 10-11 can't handle a DataView body.\n      this._bodyInit = new Blob([this._bodyArrayBuffer])\n    } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n      this._bodyArrayBuffer = bufferClone(body)\n    } else {\n      this._bodyText = body = Object.prototype.toString.call(body)\n    }\n\n    if (!this.headers.get('content-type')) {\n      if (typeof body === 'string') {\n        this.headers.set('content-type', 'text/plain;charset=UTF-8')\n      } else if (this._bodyBlob && this._bodyBlob.type) {\n        this.headers.set('content-type', this._bodyBlob.type)\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n      }\n    }\n  }\n\n  if (support.blob) {\n    this.blob = function() {\n      var rejected = consumed(this)\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return Promise.resolve(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as blob')\n      } else {\n        return Promise.resolve(new Blob([this._bodyText]))\n      }\n    }\n  }\n\n  this.arrayBuffer = function() {\n    if (this._bodyArrayBuffer) {\n      var isConsumed = consumed(this)\n      if (isConsumed) {\n        return isConsumed\n      } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {\n        return Promise.resolve(\n          this._bodyArrayBuffer.buffer.slice(\n            this._bodyArrayBuffer.byteOffset,\n            this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength\n          )\n        )\n      } else {\n        return Promise.resolve(this._bodyArrayBuffer)\n      }\n    } else if (support.blob) {\n      return this.blob().then(readBlobAsArrayBuffer)\n    } else {\n      throw new Error('could not read as ArrayBuffer')\n    }\n  }\n\n  this.text = function() {\n    var rejected = consumed(this)\n    if (rejected) {\n      return rejected\n    }\n\n    if (this._bodyBlob) {\n      return readBlobAsText(this._bodyBlob)\n    } else if (this._bodyArrayBuffer) {\n      return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n    } else if (this._bodyFormData) {\n      throw new Error('could not read FormData body as text')\n    } else {\n      return Promise.resolve(this._bodyText)\n    }\n  }\n\n  if (support.formData) {\n    this.formData = function() {\n      return this.text().then(decode)\n    }\n  }\n\n  this.json = function() {\n    return this.text().then(JSON.parse)\n  }\n\n  return this\n}\n\n// HTTP methods whose capitalization should be normalized\nvar methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE']\n\nfunction normalizeMethod(method) {\n  var upcased = method.toUpperCase()\n  return methods.indexOf(upcased) > -1 ? upcased : method\n}\n\nexport function Request(input, options) {\n  if (!(this instanceof Request)) {\n    throw new TypeError('Please use the \"new\" operator, this DOM object constructor cannot be called as a function.')\n  }\n\n  options = options || {}\n  var body = options.body\n\n  if (input instanceof Request) {\n    if (input.bodyUsed) {\n      throw new TypeError('Already read')\n    }\n    this.url = input.url\n    this.credentials = input.credentials\n    if (!options.headers) {\n      this.headers = new Headers(input.headers)\n    }\n    this.method = input.method\n    this.mode = input.mode\n    this.signal = input.signal\n    if (!body && input._bodyInit != null) {\n      body = input._bodyInit\n      input.bodyUsed = true\n    }\n  } else {\n    this.url = String(input)\n  }\n\n  this.credentials = options.credentials || this.credentials || 'same-origin'\n  if (options.headers || !this.headers) {\n    this.headers = new Headers(options.headers)\n  }\n  this.method = normalizeMethod(options.method || this.method || 'GET')\n  this.mode = options.mode || this.mode || null\n  this.signal = options.signal || this.signal || (function () {\n    if ('AbortController' in g) {\n      var ctrl = new AbortController();\n      return ctrl.signal;\n    }\n  }());\n  this.referrer = null\n\n  if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n    throw new TypeError('Body not allowed for GET or HEAD requests')\n  }\n  this._initBody(body)\n\n  if (this.method === 'GET' || this.method === 'HEAD') {\n    if (options.cache === 'no-store' || options.cache === 'no-cache') {\n      // Search for a '_' parameter in the query string\n      var reParamSearch = /([?&])_=[^&]*/\n      if (reParamSearch.test(this.url)) {\n        // If it already exists then set the value with the current time\n        this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime())\n      } else {\n        // Otherwise add a new '_' parameter to the end with the current time\n        var reQueryString = /\\?/\n        this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime()\n      }\n    }\n  }\n}\n\nRequest.prototype.clone = function() {\n  return new Request(this, {body: this._bodyInit})\n}\n\nfunction decode(body) {\n  var form = new FormData()\n  body\n    .trim()\n    .split('&')\n    .forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n  return form\n}\n\nfunction parseHeaders(rawHeaders) {\n  var headers = new Headers()\n  // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n  // https://tools.ietf.org/html/rfc7230#section-3.2\n  var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ')\n  // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill\n  // https://github.com/github/fetch/issues/748\n  // https://github.com/zloirock/core-js/issues/751\n  preProcessedHeaders\n    .split('\\r')\n    .map(function(header) {\n      return header.indexOf('\\n') === 0 ? header.substr(1, header.length) : header\n    })\n    .forEach(function(line) {\n      var parts = line.split(':')\n      var key = parts.shift().trim()\n      if (key) {\n        var value = parts.join(':').trim()\n        try {\n          headers.append(key, value)\n        } catch (error) {\n          console.warn('Response ' + error.message)\n        }\n      }\n    })\n  return headers\n}\n\nBody.call(Request.prototype)\n\nexport function Response(bodyInit, options) {\n  if (!(this instanceof Response)) {\n    throw new TypeError('Please use the \"new\" operator, this DOM object constructor cannot be called as a function.')\n  }\n  if (!options) {\n    options = {}\n  }\n\n  this.type = 'default'\n  this.status = options.status === undefined ? 200 : options.status\n  if (this.status < 200 || this.status > 599) {\n    throw new RangeError(\"Failed to construct 'Response': The status provided (0) is outside the range [200, 599].\")\n  }\n  this.ok = this.status >= 200 && this.status < 300\n  this.statusText = options.statusText === undefined ? '' : '' + options.statusText\n  this.headers = new Headers(options.headers)\n  this.url = options.url || ''\n  this._initBody(bodyInit)\n}\n\nBody.call(Response.prototype)\n\nResponse.prototype.clone = function() {\n  return new Response(this._bodyInit, {\n    status: this.status,\n    statusText: this.statusText,\n    headers: new Headers(this.headers),\n    url: this.url\n  })\n}\n\nResponse.error = function() {\n  var response = new Response(null, {status: 200, statusText: ''})\n  response.ok = false\n  response.status = 0\n  response.type = 'error'\n  return response\n}\n\nvar redirectStatuses = [301, 302, 303, 307, 308]\n\nResponse.redirect = function(url, status) {\n  if (redirectStatuses.indexOf(status) === -1) {\n    throw new RangeError('Invalid status code')\n  }\n\n  return new Response(null, {status: status, headers: {location: url}})\n}\n\nexport var DOMException = g.DOMException\ntry {\n  new DOMException()\n} catch (err) {\n  DOMException = function(message, name) {\n    this.message = message\n    this.name = name\n    var error = Error(message)\n    this.stack = error.stack\n  }\n  DOMException.prototype = Object.create(Error.prototype)\n  DOMException.prototype.constructor = DOMException\n}\n\nexport function fetch(input, init) {\n  return new Promise(function(resolve, reject) {\n    var request = new Request(input, init)\n\n    if (request.signal && request.signal.aborted) {\n      return reject(new DOMException('Aborted', 'AbortError'))\n    }\n\n    var xhr = new XMLHttpRequest()\n\n    function abortXhr() {\n      xhr.abort()\n    }\n\n    xhr.onload = function() {\n      var options = {\n        statusText: xhr.statusText,\n        headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n      }\n      // This check if specifically for when a user fetches a file locally from the file system\n      // Only if the status is out of a normal range\n      if (request.url.indexOf('file://') === 0 && (xhr.status < 200 || xhr.status > 599)) {\n        options.status = 200;\n      } else {\n        options.status = xhr.status;\n      }\n      options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')\n      var body = 'response' in xhr ? xhr.response : xhr.responseText\n      setTimeout(function() {\n        resolve(new Response(body, options))\n      }, 0)\n    }\n\n    xhr.onerror = function() {\n      setTimeout(function() {\n        reject(new TypeError('Network request failed'))\n      }, 0)\n    }\n\n    xhr.ontimeout = function() {\n      setTimeout(function() {\n        reject(new TypeError('Network request timed out'))\n      }, 0)\n    }\n\n    xhr.onabort = function() {\n      setTimeout(function() {\n        reject(new DOMException('Aborted', 'AbortError'))\n      }, 0)\n    }\n\n    function fixUrl(url) {\n      try {\n        return url === '' && g.location.href ? g.location.href : url\n      } catch (e) {\n        return url\n      }\n    }\n\n    xhr.open(request.method, fixUrl(request.url), true)\n\n    if (request.credentials === 'include') {\n      xhr.withCredentials = true\n    } else if (request.credentials === 'omit') {\n      xhr.withCredentials = false\n    }\n\n    if ('responseType' in xhr) {\n      if (support.blob) {\n        xhr.responseType = 'blob'\n      } else if (\n        support.arrayBuffer\n      ) {\n        xhr.responseType = 'arraybuffer'\n      }\n    }\n\n    if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || (g.Headers && init.headers instanceof g.Headers))) {\n      var names = [];\n      Object.getOwnPropertyNames(init.headers).forEach(function(name) {\n        names.push(normalizeName(name))\n        xhr.setRequestHeader(name, normalizeValue(init.headers[name]))\n      })\n      request.headers.forEach(function(value, name) {\n        if (names.indexOf(name) === -1) {\n          xhr.setRequestHeader(name, value)\n        }\n      })\n    } else {\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value)\n      })\n    }\n\n    if (request.signal) {\n      request.signal.addEventListener('abort', abortXhr)\n\n      xhr.onreadystatechange = function() {\n        // DONE (success or failure)\n        if (xhr.readyState === 4) {\n          request.signal.removeEventListener('abort', abortXhr)\n        }\n      }\n    }\n\n    xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n  })\n}\n\nfetch.polyfill = true\n\nif (!g.fetch) {\n  g.fetch = fetch\n  g.Headers = Headers\n  g.Request = Request\n  g.Response = Response\n}\n","/*!\n * get-css-data\n * v2.1.0\n * https://github.com/jhildenbiddle/get-css-data\n * (c) 2018-2022 John Hildenbiddle <http://hildenbiddle.com>\n * MIT license\n */\nfunction getUrls(urls) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var settings = {\n        mimeType: options.mimeType || null,\n        onBeforeSend: options.onBeforeSend || Function.prototype,\n        onSuccess: options.onSuccess || Function.prototype,\n        onError: options.onError || Function.prototype,\n        onComplete: options.onComplete || Function.prototype\n    };\n    var urlArray = Array.isArray(urls) ? urls : [ urls ];\n    var urlQueue = Array.apply(null, Array(urlArray.length)).map((function(x) {\n        return null;\n    }));\n    function isValidCss(text) {\n        var isString = typeof text === \"string\";\n        var isHTML = isString && text.trim().charAt(0) === \"<\";\n        return isString && !isHTML;\n    }\n    function onError(xhr, urlIndex) {\n        settings.onError(xhr, urlArray[urlIndex], urlIndex);\n    }\n    function onSuccess(responseText, urlIndex) {\n        var returnVal = settings.onSuccess(responseText, urlArray[urlIndex], urlIndex);\n        responseText = returnVal === false ? \"\" : returnVal || responseText;\n        urlQueue[urlIndex] = responseText;\n        if (urlQueue.indexOf(null) === -1) {\n            settings.onComplete(urlQueue);\n        }\n    }\n    var parser = document.createElement(\"a\");\n    urlArray.forEach((function(url, i) {\n        parser.setAttribute(\"href\", url);\n        parser.href = String(parser.href);\n        var isIElte9 = Boolean(document.all && !window.atob);\n        var isIElte9CORS = isIElte9 && parser.host.split(\":\")[0] !== location.host.split(\":\")[0];\n        if (isIElte9CORS) {\n            var isSameProtocol = parser.protocol === location.protocol;\n            if (isSameProtocol) {\n                var xdr = new XDomainRequest;\n                xdr.open(\"GET\", url);\n                xdr.timeout = 0;\n                xdr.onprogress = Function.prototype;\n                xdr.ontimeout = Function.prototype;\n                xdr.onload = function() {\n                    var text = xdr.responseText;\n                    if (isValidCss(text)) {\n                        onSuccess(text, i);\n                    } else {\n                        onError(xdr, i);\n                    }\n                };\n                xdr.onerror = function(err) {\n                    onError(xdr, i);\n                };\n                setTimeout((function() {\n                    xdr.send();\n                }), 0);\n            } else {\n                console.warn(\"Internet Explorer 9 Cross-Origin (CORS) requests must use the same protocol (\".concat(url, \")\"));\n                onError(null, i);\n            }\n        } else {\n            var xhr = new XMLHttpRequest;\n            xhr.open(\"GET\", url);\n            if (settings.mimeType && xhr.overrideMimeType) {\n                xhr.overrideMimeType(settings.mimeType);\n            }\n            settings.onBeforeSend(xhr, url, i);\n            xhr.onreadystatechange = function() {\n                if (xhr.readyState === 4) {\n                    var text = xhr.responseText;\n                    if (xhr.status < 400 && isValidCss(text)) {\n                        onSuccess(text, i);\n                    } else if (xhr.status === 0 && isValidCss(text)) {\n                        onSuccess(text, i);\n                    } else {\n                        onError(xhr, i);\n                    }\n                }\n            };\n            xhr.send();\n        }\n    }));\n}\n\n/**\n * Gets CSS data from <style> and <link> nodes (including @imports), then\n * returns data in order processed by DOM. Allows specifying nodes to\n * include/exclude and filtering CSS data using RegEx.\n *\n * @preserve\n * @param {object}   [options] The options object\n * @param {object}   [options.rootElement=document] Root element to traverse for\n *                   <link> and <style> nodes.\n * @param {string}   [options.include] CSS selector matching <link> and <style>\n *                   nodes to include\n * @param {string}   [options.exclude] CSS selector matching <link> and <style>\n *                   nodes to exclude\n * @param {object}   [options.filter] Regular expression used to filter node CSS\n *                   data. Each block of CSS data is tested against the filter,\n *                   and only matching data is included.\n * @param {boolean}  [options.skipDisabled=true] Determines if disabled\n *                   stylesheets will be skipped while collecting CSS data.\n * @param {boolean}  [options.useCSSOM=false] Determines if CSS data will be\n *                   collected from a stylesheet's runtime values instead of its\n *                   text content. This is required to get accurate CSS data\n *                   when a stylesheet has been modified using the deleteRule()\n *                   or insertRule() methods because these modifications will\n *                   not be reflected in the stylesheet's text content.\n * @param {function} [options.onBeforeSend] Callback before XHR is sent. Passes\n *                   1) the XHR object, 2) source node reference, and 3) the\n *                   source URL as arguments.\n * @param {function} [options.onSuccess] Callback on each CSS node read. Passes\n *                   1) CSS text, 2) source node reference, and 3) the source\n *                   URL as arguments.\n * @param {function} [options.onError] Callback on each error. Passes 1) the XHR\n *                   object for inspection, 2) soure node reference, and 3) the\n *                   source URL that failed (either a <link> href or an @import)\n *                   as arguments\n * @param {function} [options.onComplete] Callback after all nodes have been\n *                   processed. Passes 1) concatenated CSS text, 2) an array of\n *                   CSS text in DOM order, and 3) an array of nodes in DOM\n *                   order as arguments.\n *\n * @example\n *\n *   getCssData({\n *     rootElement : document,\n *     include     : 'style,link[rel=\"stylesheet\"]',\n *     exclude     : '[href=\"skip.css\"]',\n *     filter      : /red/,\n *     skipDisabled: true,\n *     useCSSOM    : false,\n *     onBeforeSend(xhr, node, url) {\n *       // ...\n *     }\n *     onSuccess(cssText, node, url) {\n *       // ...\n *     }\n *     onError(xhr, node, url) {\n *       // ...\n *     },\n *     onComplete(cssText, cssArray, nodeArray) {\n *       // ...\n *     }\n *   });\n */ function getCssData(options) {\n    var regex = {\n        cssComments: /\\/\\*[\\s\\S]+?\\*\\//g,\n        cssImports: /(?:@import\\s*)(?:url\\(\\s*)?(?:['\"])([^'\"]*)(?:['\"])(?:\\s*\\))?(?:[^;]*;)/g\n    };\n    var settings = {\n        rootElement: options.rootElement || document,\n        include: options.include || 'style,link[rel=\"stylesheet\"]',\n        exclude: options.exclude || null,\n        filter: options.filter || null,\n        skipDisabled: options.skipDisabled !== false,\n        useCSSOM: options.useCSSOM || false,\n        onBeforeSend: options.onBeforeSend || Function.prototype,\n        onSuccess: options.onSuccess || Function.prototype,\n        onError: options.onError || Function.prototype,\n        onComplete: options.onComplete || Function.prototype\n    };\n    var sourceNodes = Array.apply(null, settings.rootElement.querySelectorAll(settings.include)).filter((function(node) {\n        return !matchesSelector(node, settings.exclude);\n    }));\n    var cssArray = Array.apply(null, Array(sourceNodes.length)).map((function(x) {\n        return null;\n    }));\n    function handleComplete() {\n        var isComplete = cssArray.indexOf(null) === -1;\n        if (isComplete) {\n            cssArray.reduce((function(skipIndices, value, i) {\n                if (value === \"\") {\n                    skipIndices.push(i);\n                }\n                return skipIndices;\n            }), []).reverse().forEach((function(skipIndex) {\n                return [ sourceNodes, cssArray ].forEach((function(arr) {\n                    return arr.splice(skipIndex, 1);\n                }));\n            }));\n            var cssText = cssArray.join(\"\");\n            settings.onComplete(cssText, cssArray, sourceNodes);\n        }\n    }\n    function handleSuccess(cssText, cssIndex, node, sourceUrl) {\n        var returnVal = settings.onSuccess(cssText, node, sourceUrl);\n        cssText = returnVal !== undefined && Boolean(returnVal) === false ? \"\" : returnVal || cssText;\n        resolveImports(cssText, node, sourceUrl, (function(resolvedCssText, errorData) {\n            if (cssArray[cssIndex] === null) {\n                errorData.forEach((function(data) {\n                    return settings.onError(data.xhr, node, data.url);\n                }));\n                if (!settings.filter || settings.filter.test(resolvedCssText)) {\n                    cssArray[cssIndex] = resolvedCssText;\n                } else {\n                    cssArray[cssIndex] = \"\";\n                }\n                handleComplete();\n            }\n        }));\n    }\n    function parseImportData(cssText, baseUrl) {\n        var ignoreRules = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n        var importData = {};\n        importData.rules = (cssText.replace(regex.cssComments, \"\").match(regex.cssImports) || []).filter((function(rule) {\n            return ignoreRules.indexOf(rule) === -1;\n        }));\n        importData.urls = importData.rules.map((function(rule) {\n            return rule.replace(regex.cssImports, \"$1\");\n        }));\n        importData.absoluteUrls = importData.urls.map((function(url) {\n            return getFullUrl(url, baseUrl);\n        }));\n        importData.absoluteRules = importData.rules.map((function(rule, i) {\n            var oldUrl = importData.urls[i];\n            var newUrl = getFullUrl(importData.absoluteUrls[i], baseUrl);\n            return rule.replace(oldUrl, newUrl);\n        }));\n        return importData;\n    }\n    function resolveImports(cssText, node, baseUrl, callbackFn) {\n        var __errorData = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];\n        var __errorRules = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];\n        var importData = parseImportData(cssText, baseUrl, __errorRules);\n        if (importData.rules.length) {\n            getUrls(importData.absoluteUrls, {\n                onBeforeSend: function onBeforeSend(xhr, url, urlIndex) {\n                    settings.onBeforeSend(xhr, node, url);\n                },\n                onSuccess: function onSuccess(cssText, url, urlIndex) {\n                    var returnVal = settings.onSuccess(cssText, node, url);\n                    cssText = returnVal === false ? \"\" : returnVal || cssText;\n                    var responseImportData = parseImportData(cssText, url, __errorRules);\n                    responseImportData.rules.forEach((function(rule, i) {\n                        cssText = cssText.replace(rule, responseImportData.absoluteRules[i]);\n                    }));\n                    return cssText;\n                },\n                onError: function onError(xhr, url, urlIndex) {\n                    __errorData.push({\n                        xhr: xhr,\n                        url: url\n                    });\n                    __errorRules.push(importData.rules[urlIndex]);\n                    resolveImports(cssText, node, baseUrl, callbackFn, __errorData, __errorRules);\n                },\n                onComplete: function onComplete(responseArray) {\n                    responseArray.forEach((function(importText, i) {\n                        cssText = cssText.replace(importData.rules[i], importText);\n                    }));\n                    resolveImports(cssText, node, baseUrl, callbackFn, __errorData, __errorRules);\n                }\n            });\n        } else {\n            callbackFn(cssText, __errorData);\n        }\n    }\n    if (sourceNodes.length) {\n        sourceNodes.forEach((function(node, i) {\n            var linkHref = node.getAttribute(\"href\");\n            var linkRel = node.getAttribute(\"rel\");\n            var isLink = node.nodeName.toLowerCase() === \"link\" && linkHref && linkRel && linkRel.toLowerCase().indexOf(\"stylesheet\") !== -1;\n            var isSkip = settings.skipDisabled === false ? false : node.disabled;\n            var isStyle = node.nodeName.toLowerCase() === \"style\";\n            if (isLink && !isSkip) {\n                var isURIScheme = linkHref.indexOf(\"data:text/css\") !== -1;\n                if (isURIScheme) {\n                    var cssText = decodeURIComponent(linkHref.substring(linkHref.indexOf(\",\") + 1));\n                    if (settings.useCSSOM) {\n                        cssText = Array.apply(null, node.sheet.cssRules).map((function(rule) {\n                            return rule.cssText;\n                        })).join(\"\");\n                    }\n                    handleSuccess(cssText, i, node, location.href);\n                } else {\n                    getUrls(linkHref, {\n                        mimeType: \"text/css\",\n                        onBeforeSend: function onBeforeSend(xhr, url, urlIndex) {\n                            settings.onBeforeSend(xhr, node, url);\n                        },\n                        onSuccess: function onSuccess(cssText, url, urlIndex) {\n                            var sourceUrl = getFullUrl(linkHref);\n                            handleSuccess(cssText, i, node, sourceUrl);\n                        },\n                        onError: function onError(xhr, url, urlIndex) {\n                            cssArray[i] = \"\";\n                            settings.onError(xhr, node, url);\n                            handleComplete();\n                        }\n                    });\n                }\n            } else if (isStyle && !isSkip) {\n                var _cssText = node.textContent;\n                if (settings.useCSSOM) {\n                    _cssText = Array.apply(null, node.sheet.cssRules).map((function(rule) {\n                        return rule.cssText;\n                    })).join(\"\");\n                }\n                handleSuccess(_cssText, i, node, location.href);\n            } else {\n                cssArray[i] = \"\";\n                handleComplete();\n            }\n        }));\n    } else {\n        settings.onComplete(\"\", []);\n    }\n}\n\nfunction getFullUrl(url, base) {\n    var d = document.implementation.createHTMLDocument(\"\");\n    var b = d.createElement(\"base\");\n    var a = d.createElement(\"a\");\n    d.head.appendChild(b);\n    d.body.appendChild(a);\n    b.href = base || document.baseURI || (document.querySelector(\"base\") || {}).href || location.href;\n    a.href = url;\n    return a.href;\n}\n\nfunction matchesSelector(elm, selector) {\n    var matches = elm.matches || elm.matchesSelector || elm.webkitMatchesSelector || elm.mozMatchesSelector || elm.msMatchesSelector || elm.oMatchesSelector;\n    return matches.call(elm, selector);\n}\n\nexport { getCssData as default };\n//# sourceMappingURL=get-css-data.esm.js.map\n","'use strict';\nmodule.exports = balanced;\nfunction balanced(a, b, str) {\n  if (a instanceof RegExp) a = maybeMatch(a, str);\n  if (b instanceof RegExp) b = maybeMatch(b, str);\n\n  var r = range(a, b, str);\n\n  return r && {\n    start: r[0],\n    end: r[1],\n    pre: str.slice(0, r[0]),\n    body: str.slice(r[0] + a.length, r[1]),\n    post: str.slice(r[1] + b.length)\n  };\n}\n\nfunction maybeMatch(reg, str) {\n  var m = str.match(reg);\n  return m ? m[0] : null;\n}\n\nbalanced.range = range;\nfunction range(a, b, str) {\n  var begs, beg, left, right, result;\n  var ai = str.indexOf(a);\n  var bi = str.indexOf(b, ai + 1);\n  var i = ai;\n\n  if (ai >= 0 && bi > 0) {\n    if(a===b) {\n      return [ai, bi];\n    }\n    begs = [];\n    left = str.length;\n\n    while (i >= 0 && !result) {\n      if (i == ai) {\n        begs.push(i);\n        ai = str.indexOf(a, i + 1);\n      } else if (begs.length == 1) {\n        result = [ begs.pop(), bi ];\n      } else {\n        beg = begs.pop();\n        if (beg < left) {\n          left = beg;\n          right = bi;\n        }\n\n        bi = str.indexOf(b, i + 1);\n      }\n\n      i = ai < bi && ai >= 0 ? ai : bi;\n    }\n\n    if (begs.length) {\n      result = [ left, right ];\n    }\n  }\n\n  return result;\n}\n","/**\n * Based on css parser/compiler by NxChg\n * https://github.com/NxtChg/pieces/tree/master/js/css_parser\n */\n\n\n// Dependencies\n// =============================================================================\nimport balanced from 'balanced-match';\n\n\n// Functions\n// =============================================================================\n/**\n * Parses CSS string and generates AST object\n *\n * @param {string}  css The CSS string to be converted to an AST\n * @param {object}  [options] Options object\n * @param {boolean} [options.preserveStatic=true] Determines if CSS\n *                  declarations that do not reference a custom property will\n *                  be preserved in the transformed CSS\n * @param {boolean} [options.removeComments=false] Remove comments from returned\n *                  object\n * @returns {object}\n */\nfunction parseCss(css, options = {}) {\n    const defaults = {\n        preserveStatic: true,\n        removeComments: false\n    };\n    const settings = Object.assign({}, defaults, options);\n    const errors   = [];\n\n    // Errors\n    // -------------------------------------------------------------------------\n    function error(msg) {\n        throw new Error(`CSS parse error: ${msg}`);\n    }\n\n    // RegEx\n    // -------------------------------------------------------------------------\n    // Match regexp and return captures\n    function match(re) {\n        const m = re.exec(css);\n\n        if (m) {\n            css = css.slice(m[0].length);\n\n            return m;\n        }\n    }\n\n    function open() {\n        return match(/^{\\s*/);\n    }\n\n    function close() {\n        return match(/^}/);\n    }\n\n    function whitespace() {\n        match(/^\\s*/);\n    }\n\n    // Comments\n    // -------------------------------------------------------------------------\n    function comment() {\n        whitespace();\n\n        if (css[0] !== '/' || css[1] !== '*') {\n            return;\n        }\n\n        let i = 2;\n\n        while (css[i] && (css[i] !== '*' || css[i + 1] !== '/')) {\n            i++;\n        }\n\n        if (!css[i]) {\n            return error('end of comment is missing');\n        }\n\n        const str = css.slice(2, i);\n\n        css = css.slice(i + 2);\n\n        return {\n            type   : 'comment',\n            comment: str\n        };\n    }\n\n    function comments() {\n        const cmnts = [];\n        let c;\n\n        while ((c = comment())) {\n            cmnts.push(c);\n        }\n\n        return settings.removeComments ? [] : cmnts;\n    }\n\n    // Selector\n    // -------------------------------------------------------------------------\n    function selector() {\n        whitespace();\n\n        while (css[0] === '}') {\n            error('extra closing bracket');\n        }\n\n        // Match selector\n        const m = match(/^((\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'|[^{])+)/);\n\n        if (m) {\n            let selector = m[0].trim();\n            let selectorItems;\n\n            const hasComment = /\\/\\*/.test(selector);\n\n            if (hasComment) {\n                // Remove comments\n                selector = selector.replace(/\\/\\*([^*]|[\\r\\n]|(\\*+([^*/]|[\\r\\n])))*\\*\\/+/g, '');\n            }\n\n            const hasCommaInQuotes = /[\"']\\w*,\\w*[\"']/.test(selector);\n\n            if (hasCommaInQuotes) {\n                // Replace comma in comma-separated lists with marker\n                selector = selector.replace(/\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'/g, function(m) {\n                    return m.replace(/,/g, '\\u200C');\n                });\n            }\n\n            const hasMultipleSelectors = /,/.test(selector);\n\n            // Create array of selectors\n            if (hasMultipleSelectors) {\n                // From comma-separated list\n                selectorItems = selector.split(/\\s*(?![^(]*\\)),\\s*/);\n            }\n            else {\n                selectorItems = [selector];\n            }\n\n            if (hasCommaInQuotes) {\n                // Restore comma in comma-separated lists\n                selectorItems = selectorItems.map(function(s) {\n                    return s.replace(/\\u200C/g, ',');\n                });\n            }\n\n            return selectorItems;\n        }\n    }\n\n    // Declarations\n    // -------------------------------------------------------------------------\n    function declaration() {\n        // Nested @ rule(s)\n        if (css[0] === '@') {\n            return at_rule();\n        }\n\n        match(/^([;\\s]*)+/); // ignore empty declarations + whitespace\n\n        const comment_regexp = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n        let prop = match(/^(\\*?[-#/*\\\\\\w.]+(\\[[0-9a-z_-]+\\])?)\\s*/);\n\n        if (!prop) {\n            return;\n        }\n\n        prop = prop[0].trim();\n\n        if (!match(/^:\\s*/)) {\n            return error('property missing \\':\\'');\n        }\n\n        // Quotes regex repeats verbatim inside and outside parentheses\n        const val = match(/^((?:\\/\\*.*?\\*\\/|'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\((\\s*'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|[^)]*?)\\s*\\)|[^};])+)/);\n        const ret = {\n            type    : 'declaration',\n            property: prop.replace(comment_regexp, ''),\n            value   : val ? val[0].replace(comment_regexp, '').trim() : ''\n        };\n\n        match(/^[;\\s]*/);\n\n        return ret;\n    }\n\n    function declarations() {\n        if (!open()) {\n            return error('missing \\'{\\'');\n        }\n\n        let d;\n        let decls = comments();\n\n        while ((d = declaration())) {\n            decls.push(d);\n            decls = decls.concat(comments());\n        }\n\n        if (!close()) {\n            return error('missing \\'}\\'');\n        }\n\n        return decls;\n    }\n\n    // Keyframes\n    // -------------------------------------------------------------------------\n    function keyframe() {\n        whitespace();\n\n        const vals = [];\n        let m;\n\n        while ((m = match(/^((\\d+\\.\\d+|\\.\\d+|\\d+)%?|[a-z]+)\\s*/))) {\n            vals.push(m[1]);\n            match(/^,\\s*/);\n        }\n\n        if (vals.length) {\n            return {\n                type        : 'keyframe',\n                values      : vals,\n                declarations: declarations()\n            };\n        }\n    }\n\n    function at_keyframes() {\n        let m = match(/^@([-\\w]+)?keyframes\\s*/);\n\n        if (!m) {\n            return;\n        }\n\n        const vendor = m[1];\n\n        m = match(/^([-\\w]+)\\s*/);\n\n        if (!m) {\n            return error('@keyframes missing name');\n        }\n\n        const name = m[1];\n\n        if (!open()) {\n            return error('@keyframes missing \\'{\\'');\n        }\n\n        let frame;\n        let frames = comments();\n\n        while ((frame = keyframe())) {\n            frames.push(frame);\n            frames = frames.concat(comments());\n        }\n\n        if (!close()) {\n            return error('@keyframes missing \\'}\\'');\n        }\n\n        return {\n            type     : 'keyframes',\n            name     : name,\n            vendor   : vendor,\n            keyframes: frames\n        };\n    }\n\n    // @ Rules\n    // -------------------------------------------------------------------------\n    function at_page() {\n        const m = match(/^@page */);\n        if (m) {\n            const sel = selector() || [];\n            return { type: 'page', selectors: sel, declarations: declarations() };\n        }\n    }\n    function at_page_margin_box() {\n        const m = match(/@(top|bottom|left|right)-(left|center|right|top|middle|bottom)-?(corner)?\\s*/);\n        if (m) {\n            const name = `${m[1]}-${m[2]}` + (m[3] ? `-${m[3]}` : '');\n            return { type: 'page-margin-box', name, declarations: declarations() };\n        }\n    }\n    function at_fontface() {\n        const m = match(/^@font-face\\s*/);\n        if (m) { return { type: 'font-face', declarations: declarations() }; }\n    }\n    function at_supports() {\n        const m = match(/^@supports *([^{]+)/);\n        if (m) { return { type: 'supports', supports: m[1].trim(), rules: rules() }; }\n    }\n    function at_host() {\n        const m = match(/^@host\\s*/);\n        if (m) { return { type: 'host', rules: rules() }; }\n    }\n    function at_media() {\n        const m = match(/^@media([^{]+)*/);\n        if (m) { return { type: 'media', media: (m[1] || '').trim(), rules: rules() }; }\n    }\n    function at_custom_m() {\n        const m = match(/^@custom-media\\s+(--[^\\s]+)\\s*([^{;]+);/);\n        if (m) { return { type: 'custom-media', name: m[1].trim(), media: m[2].trim() }; }\n    }\n    function at_document() {\n        const m = match(/^@([-\\w]+)?document *([^{]+)/);\n        if (m) { return { type: 'document', document: m[2].trim(), vendor: m[1] ? m[1].trim() : null, rules: rules() }; }\n    }\n    function at_x() {\n        const m = match(/^@(import|charset|namespace)\\s*([^;]+);/);\n        if (m) { return { type: m[1], name: m[2].trim() }; }\n    }\n    function at_rule() {\n        whitespace();\n\n        if (css[0] === '@') {\n            const ret =\n                at_x() ||\n                at_fontface() ||\n                at_media() ||\n                at_keyframes() ||\n                at_supports() ||\n                at_document() ||\n                at_custom_m() ||\n                at_host() ||\n                at_page() ||\n                at_page_margin_box(); // Must be last\n\n            if (ret && !settings.preserveStatic) {\n                let hasVarFunc = false;\n\n                // @page, @font-face\n                if (ret.declarations) {\n                    hasVarFunc = ret.declarations.some(decl => /var\\(/.test(decl.value));\n                }\n                // @keyframes, @media, @supports, etc.\n                else {\n                    const arr = ret.keyframes || ret.rules || [];\n\n                    hasVarFunc = arr.some(obj => (obj.declarations || []).some(decl => /var\\(/.test(decl.value)));\n                }\n\n                return hasVarFunc ? ret : {};\n            }\n\n            return ret;\n        }\n    }\n\n    // Rules\n    // -------------------------------------------------------------------------\n    function rule() {\n        if (!settings.preserveStatic) {\n            const balancedMatch = balanced('{', '}', css);\n\n            // Skip rulset if it does not contain a root/host variable\n            // declaration or a variable function value\n            if (balancedMatch) {\n                const hasVarDecl = /:(?:root|host)(?![.:#(])/.test(balancedMatch.pre) && /--\\S*\\s*:/.test(balancedMatch.body);\n                const hasVarFunc = /var\\(/.test(balancedMatch.body);\n\n                if (!hasVarDecl && !hasVarFunc) {\n                    css = css.slice(balancedMatch.end + 1);\n\n                    return {};\n                }\n            }\n        }\n\n        const sel   = selector() || [];\n        const decls = settings.preserveStatic ? declarations() : declarations().filter(decl => {\n            const hasVarDecl = sel.some(s => /:(?:root|host)(?![.:#(])/.test(s)) && /^--\\S/.test(decl.property);\n            const hasVarFunc = /var\\(/.test(decl.value);\n\n            return hasVarDecl || hasVarFunc;\n        });\n\n        if (!sel.length) {\n            error('selector missing');\n        }\n\n        return {\n            type        : 'rule',\n            selectors   : sel,\n            declarations: decls\n        };\n    }\n\n    function rules(core) {\n        if (!core && !open()) {\n            return error('missing \\'{\\'');\n        }\n\n        let node;\n        let rules = comments();\n\n        while (css.length && (core || css[0] !== '}') && (node = at_rule() || rule())) {\n            if (node.type) {\n                rules.push(node);\n            }\n\n            rules = rules.concat(comments());\n        }\n\n        if (!core && !close()) {\n            return error('missing \\'}\\'');\n        }\n\n        return rules;\n    }\n\n    return {\n        type: 'stylesheet',\n        stylesheet: {\n            rules: rules(true),\n            errors: errors\n        }\n    };\n}\n\n\n// Exports\n// =============================================================================\nexport default parseCss;\n","// Dependencies\n// =============================================================================\nimport parseCss from './parse-css';\n\n\n// Functions\n// =============================================================================\n/**\n * Description\n *\n * @param {object|string} cssData CSS data to parse\n * @param {object} [options] Options object\n * @param {object} [options.store={}] CSS variable definitions to include during\n *     transformation. Can be used to add new override exisitng definitions.\n * @param {function} [options.onWarning] Callback on each transformation\n *     warning. Passes 1) warningMessage as an argument.\n * @returns {object}\n */\nfunction parseVars(cssData, options = {}) {\n    const defaults = {\n        parseHost: false,\n        store    : {},\n        onWarning() {}\n    };\n    const settings           = Object.assign({}, defaults, options);\n    const reVarDeclSelectors = new RegExp(`:${ settings.parseHost ? 'host' : 'root' }$`);\n\n    // Convert CSS string to AST\n    if (typeof cssData === 'string') {\n        cssData = parseCss(cssData, settings);\n    }\n\n    // Define variables\n    cssData.stylesheet.rules.forEach(function(rule) {\n        const varNameIndices = [];\n\n        if (rule.type !== 'rule' || !rule.selectors.some(s => reVarDeclSelectors.test(s))) {\n            return;\n        }\n\n        rule.declarations.forEach(function(decl, i) {\n            const prop  = decl.property;\n            const value = decl.value;\n\n            if (prop && prop.indexOf('--') === 0) {\n                settings.store[prop] = value;\n                varNameIndices.push(i);\n            }\n        });\n    });\n\n    // Return variable store\n    return settings.store;\n}\n\n\n// Exports\n// =============================================================================\nexport default parseVars;\n","/**\n * Based on css parser/compiler by NxChg\n * https://github.com/NxtChg/pieces/tree/master/js/css_parser\n */\n\n\n// Functions\n// =============================================================================\n/**\n * Compiles CSS AST to string\n *\n * @param {object}   tree CSS AST object\n * @param {string}   [delim=''] CSS rule delimiter\n * @param {function} cb Function to be called before each node is processed\n * @returns {string}\n */\nfunction stringifyCss(tree, delim = '', cb) {\n    const renderMethods = {\n        charset(node) {\n            return '@charset ' + node.name + ';';\n        },\n        comment(node) {\n            // Preserve ponyfill marker comments\n            return node.comment.indexOf('__CSSVARSPONYFILL') === 0 ? '/*' + node.comment + '*/' : '';\n        },\n        'custom-media'(node) {\n            return '@custom-media ' + node.name + ' ' + node.media + ';';\n        },\n        declaration(node) {\n            return node.property + ':' + node.value + ';';\n        },\n        document(node) {\n            return '@' + (node.vendor || '') + 'document ' + node.document + '{' + visit(node.rules) + '}';\n        },\n        'font-face'(node) {\n            return '@font-face' + '{' + visit(node.declarations) + '}';\n        },\n        host(node) {\n            return '@host' + '{' + visit(node.rules) + '}';\n        },\n        import(node) {\n            // FIXED\n            return '@import ' + node.name + ';';\n        },\n        keyframe(node) {\n            return node.values.join(',') + '{' + visit(node.declarations) + '}';\n        },\n        keyframes(node) {\n            return '@' + (node.vendor || '') + 'keyframes ' + node.name + '{' + visit(node.keyframes) + '}';\n        },\n        media(node) {\n            return '@media ' + node.media + '{' + visit(node.rules) + '}';\n        },\n        namespace(node) {\n            return '@namespace ' + node.name + ';';\n        },\n        page(node) {\n            return '@page ' + (node.selectors.length ? node.selectors.join(', ') : '') + '{' + visit(node.declarations) + '}';\n        },\n        'page-margin-box'(node) {\n            return '@' + node.name + '{' + visit(node.declarations) + '}';\n        },\n        rule(node) {\n            const decls = node.declarations;\n\n            if (decls.length) {\n                return node.selectors.join(',') + '{' + visit(decls) + '}';\n            }\n        },\n        supports(node) {\n            // FIXED\n            return '@supports ' + node.supports + '{' + visit(node.rules) + '}';\n        }\n    };\n\n    function visit(nodes) {\n        let buf = '';\n\n        for (let i = 0; i < nodes.length; i++) {\n            const n = nodes[i];\n\n            if (cb) {\n                cb(n);\n            }\n\n            const txt = renderMethods[n.type](n);\n\n            if (txt) {\n                buf += txt;\n\n                if (txt.length && n.selectors) {\n                    buf += delim;\n                }\n            }\n        }\n\n        return buf;\n    }\n\n    return visit(tree.stylesheet.rules);\n}\n\n\n// Exports\n// =============================================================================\nexport default stringifyCss;\n","/**\n * Based on rework-visit by reworkcss\n * https://github.com/reworkcss/rework-visit\n */\n\n\n// Functions\n// =============================================================================\n/**\n * Visit `node` declarations recursively and invoke `fn(declarations, node)`.\n *\n * @param {object} node\n * @param {function} fn\n */\nfunction walkCss(node, fn){\n    node.rules.forEach(function(rule){\n        // @media etc\n        if (rule.rules) {\n            walkCss(rule, fn);\n\n            return;\n        }\n\n        // keyframes\n        if (rule.keyframes) {\n            rule.keyframes.forEach(function(keyframe){\n                if (keyframe.type === 'keyframe') {\n                    fn(keyframe.declarations, rule);\n                }\n            });\n\n            return;\n        }\n\n        // @charset, @import etc\n        if (!rule.declarations) {\n            return;\n        }\n\n        fn(rule.declarations, node);\n    });\n}\n\n\n// Exports\n// =============================================================================\nexport default walkCss;\n","/**\n * Based on rework-vars by reworkcss\n * https://github.com/reworkcss/rework-vars\n */\n\n\n// Dependencies\n// =============================================================================\nimport balanced     from 'balanced-match';\nimport parseCss     from './parse-css';\nimport stringifyCss from './stringify-css';\nimport walkCss      from './walk-css';\n\n\n// Constants & Variables\n// =============================================================================\nconst VAR_PROP_IDENTIFIER = '--';\nconst VAR_FUNC_IDENTIFIER = 'var';\n\n\n// Functions\n// =============================================================================\n/**\n * Transforms W3C-style CSS variables to static values and returns an updated\n * CSS string.\n *\n * @param {object}   cssData CSS text or AST\n * @param {object}   [options] Options object\n * @param {boolean}  [options.preserveStatic=true] Determines if CSS\n *                   declarations that do not reference a custom property will\n *                   be preserved in the transformed CSS\n * @param {boolean}  [options.preserveVars=false] Determines if CSS custom\n *                   property declarations will be preserved in the transformed\n *                   CSS\n * @param {object}   [options.variables={}] CSS variable definitions to include\n *                   during transformation. Can be used to add new override\n *                   exisitng definitions.\n * @param {function} [options.onWarning] Callback on each transformation\n *                   warning. Passes 1) warningMessage as an argument.\n * @returns {string}\n */\nfunction transformCss(cssData, options = {}) {\n    const defaults = {\n        preserveStatic: true,\n        preserveVars  : false,\n        variables     : {},\n        onWarning() {}\n    };\n    const settings = Object.assign({}, defaults, options);\n\n    // Convert CSS string to AST\n    if (typeof cssData === 'string') {\n        cssData = parseCss(cssData, settings);\n    }\n\n    // Resolve variables\n    walkCss(cssData.stylesheet, function(declarations, node) {\n        for (let i = 0; i < declarations.length; i++) {\n            const decl  = declarations[i];\n            const type  = decl.type;\n            const prop  = decl.property;\n            const value = decl.value;\n\n            // Skip comments\n            if (type !== 'declaration') {\n                continue;\n            }\n\n            // Remove custom property declarations\n            if (!settings.preserveVars && prop && prop.indexOf(VAR_PROP_IDENTIFIER) === 0) {\n                declarations.splice(i, 1);\n                i--;\n                continue;\n            }\n\n            // Transform custom property functions\n            if (value.indexOf(VAR_FUNC_IDENTIFIER + '(') !== -1) {\n                let resolvedValue = resolveValue(value, settings);\n\n                if (resolvedValue !== decl.value) {\n                    // Fix nested calc\n                    resolvedValue = fixNestedCalc(resolvedValue);\n\n                    // Overwrite value\n                    if (!settings.preserveVars) {\n                        decl.value = resolvedValue;\n                    }\n                    // Insert new rule with resolved value\n                    else {\n                        declarations.splice(i, 0, {\n                            type    : type,\n                            property: prop,\n                            value   : resolvedValue\n                        });\n\n                        // Skip ahead of preserved declaration\n                        i++;\n                    }\n                }\n            }\n        }\n    });\n\n    // Return CSS string\n    return stringifyCss(cssData);\n}\n\n\n// Functions (Private)\n// =============================================================================\n/**\n * Removes nested calc keywords for legacy browser compatibility.\n * Example: calc(1 + calc(2 + calc(3 + 3))) => calc(1 + (2 + (3 + 3)))\n *\n * @param {value} string\n */\nfunction fixNestedCalc(value) {\n    const reCalcVal = /calc\\(([^)]+)\\)/g;\n\n    (value.match(reCalcVal) || []).forEach(match => {\n        const newVal = `calc${match.split('calc').join('')}`;\n        value = value.replace(match, newVal);\n    });\n\n    return value;\n}\n\n/**\n * Resolves CSS var() function(s) with `settings.variables` or fallback\n * value(s). Returns original `value` if unable to resolve.\n *\n * @param {string} value String containing CSS var() functions to resolve\n * @param {object} settings Settings object passed from transformCss()\n * @param {string} [__recursiveFallback] Fallback when unable to resolve CSS\n *                 var() function to a `settings.variables` or fallback value.\n *                 Allows restoring original var() function from recursive\n *                 resolveValue() calls.\n * @return {string} CSS value with var() function(s) resolved to\n *                  `settings.variables` or fallback value.\n *\n * @example\n *\n *   resolveValue('10px var(--x) 30px', {'--x':'20px'}, {...settings});\n *   // => '10px 20px 30px'\n *\n *   resolveValue('10px', {}, {...settings});\n *   // => '10px'\n */\nfunction resolveValue(value, settings = {}, __recursiveFallback) {\n    if (value.indexOf('var(') === -1) {\n        return value;\n    }\n\n    const valueData = balanced('(', ')', value);\n\n    /**\n     * Resolves contents of CSS custom property function\n     *\n     * @param {string} value String containing contents of CSS var() function\n     * @returns {string}\n     *\n     * @example\n     *\n     *   resolveFunc('--x, var(--y, green)')\n     *   // => obj['--x'] or obj['--y'] or 'green'\n     *\n     *   resolveFunc('--fail')\n     *   // => 'var(--fail)' when obj['--fail'] does not exist\n     */\n    function resolveFunc(value) {\n        const name               = value.split(',')[0].replace(/[\\s\\n\\t]/g, '');\n        const fallback           = (value.match(/(?:\\s*,\\s*){1}(.*)?/) || [])[1];\n        const match              = Object.prototype.hasOwnProperty.call(settings.variables, name) ? String(settings.variables[name]) : undefined;\n        const replacement        = match || (fallback ? String(fallback) : undefined);\n        const unresolvedFallback = __recursiveFallback || value;\n\n        if (!match) {\n            settings.onWarning(`variable \"${name}\" is undefined`);\n        }\n\n        if (replacement && replacement !== 'undefined' && replacement.length > 0) {\n            return resolveValue(replacement, settings, unresolvedFallback);\n        }\n        else {\n            return `var(${unresolvedFallback})`;\n        }\n    }\n\n    // No balanced brace data\n    if (!valueData) {\n        if (value.indexOf('var(') !== -1) {\n            settings.onWarning(`missing closing \")\" in the value \"${value}\"`);\n        }\n\n        return value;\n    }\n    // Balanced brace data is var() function\n    else if (valueData.pre.slice(-3) === 'var') {\n        const isEmptyVarFunc = valueData.body.trim().length === 0;\n\n        if (isEmptyVarFunc) {\n            settings.onWarning('var() must contain a non-whitespace string');\n\n            return value;\n        }\n        else {\n            return (\n                valueData.pre.slice(0,-3)\n                + resolveFunc(valueData.body)\n                + resolveValue(valueData.post, settings)\n            );\n        }\n    }\n    // Balanced brace data is NOT var() function\n    else {\n        return (\n            valueData.pre\n            + `(${resolveValue(valueData.body, settings)})`\n            + resolveValue(valueData.post, settings)\n        );\n    }\n}\n\n\n// Exports\n// =============================================================================\nexport default transformCss;\n","// Dependencies\n// =============================================================================\nimport getCssData   from 'get-css-data';\nimport parseCss     from './parse-css';\nimport parseVars    from './parse-vars';\nimport stringifyCss from './stringify-css';\nimport transformCss from './transform-css';\n\n\n// Constants & Variables\n// =============================================================================\nconst isBrowser       = typeof window !== 'undefined';\nconst isNativeSupport = isBrowser && window.CSS && window.CSS.supports && window.CSS.supports('(--a: 0)');\n\nconst counters = {\n    group: 0,\n    job  : 0\n};\nconst defaults = {\n    // Targets\n    rootElement   : isBrowser ? document : null,\n    shadowDOM     : false,\n    // Sources\n    include       : 'style,link[rel=stylesheet]',\n    exclude       : '',\n    variables     : {},    // cssVars, transformCss\n    // Options\n    onlyLegacy    : true,  // cssVars\n    preserveStatic: true,  // parseCSS\n    preserveVars  : false, // transformCss\n    silent        : false, // cssVars\n    updateDOM     : true,  // cssVars\n    updateURLs    : true,  // cssVars\n    watch         : null,  // cssVars\n    // Callbacks\n    onBeforeSend() {},     // cssVars\n    onError() {},          // cssVars\n    onWarning() {},        // transformCss\n    onSuccess() {},        // cssVars\n    onComplete() {},       // cssVars\n    onFinally() {}         // cssVars\n};\nconst regex = {\n    // CSS comments\n    cssComments: /\\/\\*[\\s\\S]+?\\*\\//g,\n    // CSS keyframes\n    // Ex: @keyframes & @-VENDOR-keyframes\n    cssKeyframes: /@(?:-\\w*-)?keyframes/,\n    // CSS media queries\n    // Ex: @media (min-width: 640px) { ... }\n    cssMediaQueries: /@media[^{]+\\{([\\s\\S]+?})\\s*}/g,\n    // CSS Urls\n    // Ex: url('path/to/file')\n    cssUrls: /url\\((?!['\"]?(?:data|http|\\/\\/):)['\"]?([^'\")]*)['\"]?\\)/g,\n    // CSS root/host rules\n    // Ex: :root { ... } or :host { ... }\n    cssVarDeclRules: /(?::(?:root|host)(?![.:#(])[\\s,]*[^{]*{\\s*[^}]*})/g,\n    // CSS variable declarations (e.g. --color: red;)\n    cssVarDecls: /(?:[\\s;]*)(-{2}\\w[\\w-]*)(?:\\s*:\\s*)([^;]*);/g,\n    // CSS variable function (e.g. var(--color))\n    cssVarFunc: /var\\(\\s*--[\\w-]/,\n    // CSS variable root/host declarations and var() function values\n    cssVars: /(?:(?::(?:root|host)(?![.:#(])[\\s,]*[^{]*{\\s*[^;]*;*\\s*)|(?:var\\(\\s*))(--[^:)]+)(?:\\s*[:)])/\n};\nconst variableStore = {\n    // Parsed DOM values (from <link> and <style> nodes)\n    dom : {},\n    // Temporary storage for each job\n    job : {},\n    // Persisted options.variables values\n    user: {}\n};\n\n// Flag used to prevent successive ponyfill calls from stacking\nlet cssVarsIsRunning = false;\n\n// Mutation observer reference created via options.watch\nlet cssVarsObserver = null;\n\n// Count used to detect manual removal of [data-cssvars=\"src\"] nodes\nlet cssVarsSrcNodeCount = 0;\n\n// Debounce timer used with options.watch\nlet debounceTimer = null;\n\n// Flag used to indicate if document-level custom property values have been\n// parsed, stored, and ready for use with options.shadowDOM\nlet isShadowDOMReady = false;\n\n\n// Functions\n// =============================================================================\n/**\n * Fetches, parses, and transforms CSS custom properties from specified\n * <style> and <link> elements into static values, then appends a new <style>\n * element with static values to the DOM to provide CSS custom property\n * compatibility for legacy browsers. Also provides a single interface for\n * live updates of runtime values in both modern and legacy browsers.\n *\n * @preserve\n * @param {object}   [options] Options object\n * @param {object}   [options.rootElement=document] Root element to traverse for\n *                   <link> and <style> nodes\n * @param {boolean}  [options.shadowDOM=false] Determines if shadow DOM <link>\n *                   and <style> nodes will be processed.\n * @param {string}   [options.include=\"style,link[rel=stylesheet]\"] CSS selector\n *                   matching <link re=\"stylesheet\"> and <style> nodes to\n *                   process\n * @param {string}   [options.exclude] CSS selector matching <link\n *                   rel=\"stylehseet\"> and <style> nodes to exclude from those\n *                   matches by options.include\n * @param {object}   [options.variables] A map of custom property name/value\n *                   pairs. Property names can omit or include the leading\n *                   double-hyphen (—), and values specified will override\n *                   previous values\n * @param {boolean}  [options.onlyLegacy=true] Determines if the ponyfill will\n *                   only generate legacy-compatible CSS in browsers that lack\n *                   native support (i.e., legacy browsers)\n * @param {boolean}  [options.preserveStatic=true] Determines if CSS\n *                   declarations that do not reference a custom property will\n *                   be preserved in the transformed CSS\n * @param {boolean}  [options.preserveVars=false] Determines if CSS custom\n *                   property declarations will be preserved in the transformed\n *                   CSS\n * @param {boolean}  [options.silent=false] Determines if warning and error\n *                   messages will be displayed on the console\n * @param {boolean}  [options.updateDOM=true] Determines if the ponyfill will\n *                   update the DOM after processing CSS custom properties\n * @param {boolean}  [options.updateURLs=true] Determines if relative url()\n *                   paths will be converted to absolute urls in external CSS\n * @param {boolean}  [options.watch=false] Determines if a MutationObserver will\n *                   be created that will execute the ponyfill when a <link> or\n *                   <style> DOM mutation is observed\n * @param {function} [options.onBeforeSend] Callback before XHR is sent. Passes\n *                   1) the XHR object, 2) source node reference, and 3) the\n *                   source URL as arguments\n * @param {function} [options.onError] Callback after a CSS parsing error has\n *                   occurred or an XHR request has failed. Passes 1) an error\n *                   message, and 2) source node reference, 3) xhr, and 4 url as\n *                   arguments.\n * @param {function} [options.onWarning] Callback after each CSS parsing warning\n *                   has occurred. Passes 1) a warning message as an argument.\n * @param {function} [options.onSuccess] Callback after CSS data has been\n *                   collected from each node and before CSS custom properties\n *                   have been transformed. Allows modifying the CSS data before\n *                   it is transformed by returning any string value (or false\n *                   to skip). Passes 1) CSS text, 2) source node reference, and\n *                   3) the source URL as arguments.\n * @param {function} [options.onComplete] Callback after all CSS has been\n *                   processed, legacy-compatible CSS has been generated, and\n *                   (optionally) the DOM has been updated. Passes 1) a CSS\n *                   string with CSS variable values resolved, 2) an array of\n *                   output <style> node references that have been appended to\n *                   the DOM, 3) an object containing all custom properies names\n *                   and values, and 4) the ponyfill execution time in\n *                   milliseconds.\n * @param {function} [options.onFinally] Callback in modern and legacy browsers\n *                   after the ponyfill has finished all tasks. Passes 1) a\n *                   boolean indicating if the last ponyfill call resulted in a\n *                   style change, 2) a boolean indicating if the current\n *                   browser provides native support for CSS custom properties,\n *                   and 3) the ponyfill execution time in milliseconds.\n * @example\n *\n *   cssVars({\n *     rootElement   : document,\n *     shadowDOM     : false,\n *     include       : 'style,link[rel=\"stylesheet\"]',\n *     exclude       : '',\n *     variables     : {},\n *     onlyLegacy    : true,\n *     preserveStatic: true,\n *     preserveVars  : false,\n *     silent        : false,\n *     updateDOM     : true,\n *     updateURLs    : true,\n *     watch         : false,\n *     onBeforeSend(xhr, node, url) {},\n *     onError(message, node, xhr, url) {},\n *     onWarning(message) {},\n *     onSuccess(cssText, node, url) {},\n *     onComplete(cssText, styleNode, cssVariables, benchmark) {},\n *     onFinally(hasChanged, hasNativeSupport, benchmark)\n *   });\n */\nfunction cssVars(options = {}) {\n    const msgPrefix = 'cssVars(): ';\n    const settings  = Object.assign({}, defaults, options);\n\n    function handleError(message, sourceNode, xhr, url) {\n        /* istanbul ignore next */\n        if (!settings.silent && window.console) {\n            // eslint-disable-next-line\n            console.error(`${msgPrefix}${message}\\n`, sourceNode);\n        }\n\n        settings.onError(message, sourceNode, xhr, url);\n    }\n\n    function handleWarning(message) {\n        /* istanbul ignore next */\n        if (!settings.silent && window.console) {\n            // eslint-disable-next-line\n            console.warn(`${msgPrefix}${message}`);\n        }\n\n        settings.onWarning(message);\n    }\n\n    function handleFinally(hasChanged) {\n        settings.onFinally(\n            Boolean(hasChanged),\n            isNativeSupport,\n            getTimeStamp() - settings.__benchmark\n        );\n    }\n\n    // Exit if non-browser environment (e.g. Node)\n    if (!isBrowser) {\n        return;\n    }\n\n    // Add / recreate MutationObserver\n    if (settings.watch) {\n        settings.watch = defaults.watch;\n        addMutationObserver(settings);\n        cssVars(settings);\n        return;\n    }\n    // Disconnect existing MutationObserver\n    else if (settings.watch === false && cssVarsObserver) {\n        cssVarsObserver.disconnect();\n        cssVarsObserver = null;\n    }\n\n    // If benchmark key is not availalbe, this is a non-recursive call\n    if (!settings.__benchmark) {\n        // Check flag and debounce to prevent successive call from stacking\n        if (cssVarsIsRunning === settings.rootElement) {\n            cssVarsDebounced(options);\n            return;\n        }\n\n        const srcNodes = [].slice.call(settings.rootElement.querySelectorAll('[data-cssvars]:not([data-cssvars=\"out\"])'));\n\n        // Store benchmark start time\n        settings.__benchmark = getTimeStamp();\n\n        // Exclude previously processed elements\n        settings.exclude = [\n            // 1. When the ponyfill is called by the MutationObserver, all\n            //    previously processed nodes are exluded except those that have\n            //    had their out/skip/src values cleared by the MutationObserver.\n            // 2. When the ponyfill is called directly, only output nodes are\n            //    excluded. This allows the ponyfill to update skip/src nodes\n            //    after a previously processed link/style node has been removed.\n            cssVarsObserver ? '[data-cssvars]:not([data-cssvars=\"\"])' : '[data-cssvars=\"out\"]',\n            'link[disabled]:not([data-cssvars])',\n            settings.exclude\n        ].filter(selector => selector).join(',');\n\n        // Fix malformed custom property names (e.g. \"color\" or \"-color\")\n        settings.variables = fixVarNames(settings.variables);\n\n        // Reset previously processed <style> nodes if textContent has changed\n        srcNodes.forEach(srcNode => {\n            const hasStyleCache = srcNode.nodeName.toLowerCase() === 'style' && srcNode.__cssVars.text;\n            const hasStyleChanged = hasStyleCache && srcNode.textContent !== srcNode.__cssVars.text;\n\n            if (hasStyleCache && hasStyleChanged) {\n                srcNode.sheet && (srcNode.sheet.disabled = false);\n                srcNode.setAttribute('data-cssvars', '');\n            }\n        });\n\n        // Direct call preparation (i.e. non-MutationObserver call)\n        if (!cssVarsObserver) {\n            const outNodes = [].slice.call(settings.rootElement.querySelectorAll('[data-cssvars=\"out\"]'));\n\n            // Remove orphaned output nodes\n            outNodes.forEach(outNode => {\n                const dataGroup = outNode.getAttribute('data-cssvars-group');\n                const srcNode   = dataGroup ? settings.rootElement.querySelector(`[data-cssvars=\"src\"][data-cssvars-group=\"${dataGroup}\"]`) : null;\n\n                if (!srcNode) {\n                    outNode.parentNode.removeChild(outNode);\n                }\n            });\n\n            // Handle removed source nodes\n            if (cssVarsSrcNodeCount && (srcNodes.length < cssVarsSrcNodeCount)) {\n                // Update source node count\n                cssVarsSrcNodeCount = srcNodes.length;\n\n                // Reset variableStore\n                variableStore.dom = {};\n            }\n        }\n    }\n\n    // Verify readyState to ensure all <link> and <style> nodes are available\n    if (document.readyState !== 'loading') {\n        // Native support\n        if (isNativeSupport && settings.onlyLegacy) {\n            let hasVarChange = false;\n\n            // Apply settings.variables\n            if (settings.updateDOM) {\n                const targetElm = settings.rootElement.host || (settings.rootElement === document ? document.documentElement : settings.rootElement);\n\n                // Set variables using native methods\n                Object.keys(settings.variables).forEach(key => {\n                    const varValue = settings.variables[key];\n\n                    hasVarChange = hasVarChange || varValue !== getComputedStyle(targetElm).getPropertyValue(key);\n                    targetElm.style.setProperty(key, varValue);\n                });\n            }\n\n            handleFinally(hasVarChange);\n        }\n        // Ponyfill: Handle rootElement set to a shadow host or root\n        else if (!isShadowDOMReady && (settings.shadowDOM || settings.rootElement.shadowRoot || settings.rootElement.host)) {\n            // Get all document-level CSS\n            getCssData({\n                rootElement : defaults.rootElement,\n                include     : defaults.include,\n                exclude     : settings.exclude,\n                skipDisabled: false,\n                onSuccess(cssText, node, url) {\n                    const isUserDisabled = (node.sheet || {}).disabled && !node.__cssVars;\n\n                    if (isUserDisabled) {\n                        return false;\n                    }\n\n                    cssText = cssText\n                        .replace(regex.cssComments, '')\n                        .replace(regex.cssMediaQueries, '');\n\n                    cssText = (cssText.match(regex.cssVarDeclRules) || []).join('');\n\n                    // Return only matching :root {...} blocks\n                    return cssText || false;\n                },\n                onComplete(cssText, cssArray, nodeArray) {\n                    // Parse variables and store in variableStore. This step\n                    // ensures that variableStore contains all document-level\n                    // custom property values for subsequent ponyfill calls.\n                    parseVars(cssText, {\n                        store    : variableStore.dom,\n                        onWarning: handleWarning\n                    });\n\n                    isShadowDOMReady = true;\n\n                    // Call the ponyfill again to process the rootElement\n                    // initially specified. Values stored in variableStore will\n                    // be used to transform values in shadow host/root elements.\n                    cssVars(settings);\n                }\n            });\n        }\n        // Ponyfill: Process CSS\n        else {\n            // Set flag to prevent successive call from stacking. Using the\n            // rootElement insead of `true` allows simultaneous ponyfill calls\n            // using different rootElement values (e.g. document and one-or-more\n            // shadowDOM nodes).\n            cssVarsIsRunning = settings.rootElement;\n\n            getCssData({\n                rootElement : settings.rootElement,\n                include     : settings.include,\n                exclude     : settings.exclude,\n                skipDisabled: false,\n                onBeforeSend: settings.onBeforeSend,\n                onError(xhr, node, url) {\n                    const responseUrl = xhr.responseURL || getFullUrl(url, location.href);\n                    const statusText  = xhr.statusText ? `(${xhr.statusText})` : 'Unspecified Error' + (xhr.status === 0 ? ' (possibly CORS related)' : '');\n                    const errorMsg    = `CSS XHR Error: ${responseUrl} ${xhr.status} ${statusText}`;\n\n                    handleError(errorMsg, node, xhr, responseUrl);\n                },\n                onSuccess(cssText, node, url) {\n                    const isUserDisabled = (node.sheet || {}).disabled && !node.__cssVars;\n\n                    if (isUserDisabled) {\n                        return false;\n                    }\n\n                    const isLink        = node.nodeName.toLowerCase() === 'link';\n                    const isStyleImport = node.nodeName.toLowerCase() === 'style' && cssText !== node.textContent;\n                    const returnVal     = settings.onSuccess(cssText, node, url);\n\n                    // Use callback return value if provided (skip CSS if false)\n                    cssText = returnVal !== undefined && Boolean(returnVal) === false ? '' : returnVal || cssText;\n\n                    // Convert relative url(...) values to absolute\n                    if (settings.updateURLs && (isLink || isStyleImport)) {\n                        cssText = fixRelativeCssUrls(cssText, url);\n                    }\n\n                    return cssText;\n                },\n                onComplete(cssText, cssArray, nodeArray = []) {\n                    const currentVars = Object.assign({}, variableStore.dom, variableStore.user);\n\n                    let hasVarChange = false;\n\n                    // Reset temporary variable store\n                    variableStore.job = {};\n\n                    // Parse CSS and variables\n                    nodeArray.forEach((node, i) => {\n                        const nodeCSS = cssArray[i];\n\n                        // Node data cache\n                        node.__cssVars = node.__cssVars || {};\n                        node.__cssVars.text = nodeCSS;\n\n                        // Only process CSS contains a custom property\n                        // declarations or function\n                        if (regex.cssVars.test(nodeCSS)) {\n                            try {\n                                const cssTree = parseCss(nodeCSS, {\n                                    preserveStatic: settings.preserveStatic,\n                                    removeComments: true\n                                });\n\n                                // Parse variables\n                                parseVars(cssTree, {\n                                    parseHost: Boolean(settings.rootElement.host),\n                                    store    : variableStore.dom,\n                                    onWarning: handleWarning\n                                });\n\n                                // Cache data\n                                node.__cssVars.tree = cssTree;\n                            }\n                            catch(err) {\n                                handleError(err.message, node);\n                            }\n                        }\n                    });\n\n                    // Merge DOM values with job values\n                    Object.assign(variableStore.job, variableStore.dom);\n\n                    if (settings.updateDOM) {\n                        // Persist user values\n                        Object.assign(variableStore.user, settings.variables);\n\n                        // Merge persisted user values with job values\n                        Object.assign(variableStore.job, variableStore.user);\n                    }\n                    else {\n                        // Merge persisted and non-persisted user values with job values\n                        Object.assign(variableStore.job, variableStore.user, settings.variables);\n\n                        // Update currentVars with non-persisted user values\n                        Object.assign(currentVars, settings.variables);\n                    }\n\n                    // Detect new variable declaration or changed value\n                    hasVarChange =\n                        // Ponyfill has been called before with updateDOM\n                        counters.job > 0 &&\n                        // New/Change\n                        Boolean(\n                            // New declaration\n                            (Object.keys(variableStore.job).length > Object.keys(currentVars).length) ||\n                            // Changed declaration value\n                            Boolean(\n                                // Previous declarations exist\n                                Object.keys(currentVars).length &&\n                                // At least one job value does has changed\n                                Object.keys(variableStore.job).some(key => variableStore.job[key] !== currentVars[key])\n                            )\n                        );\n\n                    // New variable declaration or modified value detected\n                    if (hasVarChange) {\n                        resetCssNodes(settings.rootElement);\n                        cssVars(settings);\n                    }\n                    // No variable changes detected\n                    else {\n                        const outCssArray  = [];\n                        const outNodeArray = [];\n\n                        let hasKeyframesWithVars = false;\n\n                        // Increment job\n                        if (settings.updateDOM) {\n                            counters.job++;\n                        }\n\n                        nodeArray.forEach((node, i) => {\n                            let isSkip = !node.__cssVars.tree;\n\n                            if (node.__cssVars.tree) {\n                                try {\n                                    transformCss(node.__cssVars.tree, Object.assign({}, settings, {\n                                        variables: variableStore.job,\n                                        onWarning: handleWarning\n                                    }));\n\n                                    const outCss = stringifyCss(node.__cssVars.tree);\n\n                                    if (settings.updateDOM) {\n                                        const nodeCSS       = cssArray[i];\n                                        const hasCSSVarFunc = regex.cssVarFunc.test(nodeCSS);\n\n                                        if (!node.getAttribute('data-cssvars')) {\n                                            node.setAttribute('data-cssvars', 'src');\n                                        }\n\n                                        if (outCss.length && hasCSSVarFunc) {\n                                            const dataGroup      = node.getAttribute('data-cssvars-group') || ++counters.group;\n                                            const outCssNoSpaces = outCss.replace(/\\s/g,'');\n                                            const outNode        = settings.rootElement.querySelector(`[data-cssvars=\"out\"][data-cssvars-group=\"${dataGroup}\"]`) || document.createElement('style');\n\n                                            hasKeyframesWithVars = hasKeyframesWithVars || regex.cssKeyframes.test(outCss);\n\n                                            // Disable source stylesheet\n                                            if (settings.preserveStatic) {\n                                                node.sheet && (node.sheet.disabled = true);\n                                            }\n\n                                            if (!outNode.hasAttribute('data-cssvars')) {\n                                                outNode.setAttribute('data-cssvars', 'out');\n                                            }\n\n                                            // Non-transformed CSS\n                                            if (outCssNoSpaces === node.textContent.replace(/\\s/g,'')) {\n                                                isSkip = true;\n\n                                                if (outNode && outNode.parentNode) {\n                                                    node.removeAttribute('data-cssvars-group');\n                                                    outNode.parentNode.removeChild(outNode);\n                                                }\n                                            }\n                                            // Transformed CSS\n                                            else if (outCssNoSpaces !== outNode.textContent.replace(/\\s/g,'')) {\n                                                [node, outNode].forEach(n => {\n                                                    n.setAttribute('data-cssvars-job', counters.job);\n                                                    n.setAttribute('data-cssvars-group', dataGroup);\n                                                });\n                                                outNode.textContent = outCss;\n                                                outCssArray.push(outCss);\n                                                outNodeArray.push(outNode);\n\n                                                if (!outNode.parentNode) {\n                                                    node.parentNode.insertBefore(outNode, node.nextSibling);\n                                                }\n                                            }\n                                        }\n                                    }\n                                    else {\n                                        if (node.textContent.replace(/\\s/g,'') !== outCss) {\n                                            outCssArray.push(outCss);\n                                        }\n                                    }\n                                }\n                                catch(err) {\n                                    handleError(err.message, node);\n                                }\n                            }\n\n                            if (isSkip) {\n                                node.setAttribute('data-cssvars', 'skip');\n                            }\n\n                            if (!node.hasAttribute('data-cssvars-job')) {\n                                node.setAttribute('data-cssvars-job', counters.job);\n                            }\n                        });\n\n                        // Update source node count\n                        cssVarsSrcNodeCount = settings.rootElement.querySelectorAll('[data-cssvars]:not([data-cssvars=\"out\"])').length;\n\n                        // Process shadow DOM\n                        if (settings.shadowDOM) {\n                            const elms = []\n                                .concat(settings.rootElement)\n                                .concat([].slice.call(settings.rootElement.querySelectorAll('*')));\n\n                            // Iterates over all elements in rootElement and calls\n                            // cssVars on each shadowRoot, passing document-level\n                            // custom properties as options.variables.\n                            for (let i = 0, elm; (elm = elms[i]); ++i) {\n                                if (elm.shadowRoot && elm.shadowRoot.querySelector('style')) {\n                                    const shadowSettings = Object.assign({}, settings, {\n                                        rootElement: elm.shadowRoot\n                                    });\n\n                                    cssVars(shadowSettings);\n                                }\n                            }\n                        }\n\n                        // Fix keyframes\n                        if (settings.updateDOM && hasKeyframesWithVars) {\n                            fixKeyframes(settings.rootElement);\n                        }\n\n                        // Reset running flag. Must be done before onComplete\n                        // callback to avoid a callback error preventing the\n                        // flag from being reset after the callback.\n                        cssVarsIsRunning = false;\n\n                        // Callbacks\n                        settings.onComplete(\n                            outCssArray.join(''),\n                            outNodeArray,\n                            JSON.parse(JSON.stringify(variableStore.job)),\n                            getTimeStamp() - settings.__benchmark\n                        );\n\n                        handleFinally(outNodeArray.length);\n                    }\n                }\n            });\n        }\n    }\n    // Delay function until DOMContentLoaded event is fired\n    /* istanbul ignore next */\n    else {\n        document.addEventListener('DOMContentLoaded', function init(evt) {\n            cssVars(options);\n\n            document.removeEventListener('DOMContentLoaded', init);\n        });\n    }\n}\n\n// Ponyfill reset\ncssVars.reset = function() {\n    // Reset counters\n    counters.job = 0;\n    counters.group = 0;\n\n    // Reset running flag\n    cssVarsIsRunning = false;\n\n    // Disconnect MutationObserver\n    if (cssVarsObserver) {\n        cssVarsObserver.disconnect();\n        cssVarsObserver = null;\n    }\n\n    // Reset source node count\n    cssVarsSrcNodeCount = 0;\n\n    // Reset debounce timer\n    debounceTimer = null;\n\n    // Reset shadowDOM ready flag\n    isShadowDOMReady = false;\n\n    // Reset variable storage\n    for (const prop in variableStore) {\n        variableStore[prop] = {};\n    }\n};\n\n\n// Functions (Private)\n// =============================================================================\n/**\n * Creates mutation observer that executes the ponyfill when a <link> or <style>\n * DOM mutation is observed.\n *\n * @param {object} settings\n */\nfunction addMutationObserver(settings) {\n    function isDisabled(node) {\n        const isDisabledAttr  = isLink(node) && node.hasAttribute('disabled');\n        const isDisabledSheet = (node.sheet || {}).disabled;\n\n        return isDisabledAttr || isDisabledSheet;\n    }\n    function isLink(node) {\n        const isStylesheet = node.nodeName.toLowerCase() === 'link' && (node.getAttribute('rel') || '').indexOf('stylesheet') !== -1;\n\n        return isStylesheet;\n    }\n    function isStyle(node) {\n        return node.nodeName.toLowerCase() === 'style';\n    }\n    function isValidAttributeMutation(mutation) {\n        let isValid = false;\n\n        if (mutation.type === 'attributes' && isLink(mutation.target) && !isDisabled(mutation.target)) {\n            const isEnabledMutation = mutation.attributeName === 'disabled';\n            const isHrefMutation = mutation.attributeName === 'href';\n            const isSkipNode = mutation.target.getAttribute('data-cssvars') === 'skip';\n            const isSrcNode = mutation.target.getAttribute('data-cssvars') === 'src';\n\n            // Enabled\n            if (isEnabledMutation) {\n                isValid = !isSkipNode && !isSrcNode;\n            }\n            // Href\n            else if (isHrefMutation) {\n                if (isSkipNode) {\n                    mutation.target.setAttribute('data-cssvars', '');\n                }\n                else if (isSrcNode) {\n                    resetCssNodes(settings.rootElement, true);\n                }\n\n                isValid = true;\n            }\n        }\n\n        return isValid;\n    }\n    function isValidStyleTextMutation(mutation) {\n        let isValid = false;\n\n        if (mutation.type === 'childList') {\n            const isStyleElm = isStyle(mutation.target);\n            const isOutNode = mutation.target.getAttribute('data-cssvars') === 'out';\n\n            isValid = isStyleElm && !isOutNode;\n        }\n\n        return isValid;\n    }\n    function isValidAddMutation(mutation) {\n        let isValid = false;\n\n        if (mutation.type === 'childList') {\n            isValid = [].slice.call(mutation.addedNodes).some(node => {\n                const isElm           = node.nodeType === 1;\n                const hasAttr         = isElm && node.hasAttribute('data-cssvars');\n                const isStyleWithVars = isStyle(node) && regex.cssVars.test(node.textContent);\n                const isValid         = !hasAttr && (isLink(node) || isStyleWithVars);\n\n                return isValid && !isDisabled(node);\n            });\n        }\n\n        return isValid;\n    }\n    function isValidRemoveMutation(mutation) {\n        let isValid = false;\n\n        if (mutation.type === 'childList') {\n            isValid = [].slice.call(mutation.removedNodes).some(node => {\n                const isElm     = node.nodeType === 1;\n                const isOutNode = isElm && node.getAttribute('data-cssvars') === 'out';\n                const isSrcNode = isElm && node.getAttribute('data-cssvars') === 'src';\n                const isValid   = isSrcNode;\n\n                if (isSrcNode || isOutNode) {\n                    const dataGroup  = node.getAttribute('data-cssvars-group');\n                    const orphanNode = settings.rootElement.querySelector(`[data-cssvars-group=\"${dataGroup}\"]`);\n\n                    if (isSrcNode) {\n                        resetCssNodes(settings.rootElement, true);\n                    }\n\n                    if (orphanNode) {\n                        orphanNode.parentNode.removeChild(orphanNode);\n                    }\n                }\n\n                return isValid;\n            });\n        }\n\n        return isValid;\n    }\n\n    if (!window.MutationObserver) {\n        return;\n    }\n\n    if (cssVarsObserver) {\n        cssVarsObserver.disconnect();\n        cssVarsObserver = null;\n    }\n\n    cssVarsObserver = new MutationObserver(function(mutations) {\n        const hasValidMutation = mutations.some((mutation) => {\n            return (\n                isValidAttributeMutation(mutation) ||\n                isValidStyleTextMutation(mutation) ||\n                isValidAddMutation(mutation) ||\n                isValidRemoveMutation(mutation)\n            );\n        });\n\n        if (hasValidMutation) {\n            cssVars(settings);\n        }\n    });\n\n    cssVarsObserver.observe(document.documentElement, {\n        attributes     : true,\n        attributeFilter: ['disabled', 'href'],\n        childList      : true,\n        subtree        : true\n    });\n}\n\n/**\n * Debounces cssVars() calls\n *\n * @param {object} settings\n */\nfunction cssVarsDebounced(settings, delay = 100) {\n    clearTimeout(debounceTimer);\n    debounceTimer = setTimeout(function() {\n        settings.__benchmark = null;\n        cssVars(settings);\n    }, delay);\n}\n\n/**\n * Fixes issue with keyframe properties set using CSS custom property not being\n * applied properly in some legacy (IE) and modern (Safari) browsers.\n *\n * @param {object} rootElement\n */\nfunction fixKeyframes(rootElement) {\n    const animationNameProp = [\n        'animation-name',\n        '-moz-animation-name',\n        '-webkit-animation-name'\n    ].filter(prop => getComputedStyle(document.body)[prop])[0];\n\n    if (animationNameProp) {\n        const allNodes      = [].slice.call(rootElement.querySelectorAll('*'));\n        const keyframeNodes = [];\n        const nameMarker    = '__CSSVARSPONYFILL-KEYFRAMES__';\n\n        // Modify animation name\n        for (let i = 0, len = allNodes.length; i < len; i++) {\n            const node          = allNodes[i];\n            const animationName = getComputedStyle(node)[animationNameProp];\n\n            if (animationName !== 'none') {\n                node.style[animationNameProp] += nameMarker;\n                keyframeNodes.push(node);\n            }\n        }\n\n        // Force reflow\n        void document.body.offsetHeight;\n\n        // Restore animation name\n        for (let i = 0, len = keyframeNodes.length; i < len; i++) {\n            const nodeStyle = keyframeNodes[i].style;\n\n            nodeStyle[animationNameProp] = nodeStyle[animationNameProp].replace(nameMarker, '');\n        }\n    }\n}\n\n/**\n * Convert relative CSS url(...) values to absolute based on baseUrl\n *\n * @param {string} cssText\n * @param {string} baseUrl\n * @returns {string}\n */\nfunction fixRelativeCssUrls(cssText, baseUrl) {\n    const cssUrls = cssText\n        // Remove comments\n        .replace(regex.cssComments, '')\n        // Match url(...) values\n        .match(regex.cssUrls) || [];\n\n    cssUrls.forEach(cssUrl => {\n        const oldUrl = cssUrl.replace(regex.cssUrls, '$1');\n        const newUrl = getFullUrl(oldUrl, baseUrl);\n\n        cssText = cssText.replace(cssUrl, cssUrl.replace(oldUrl, newUrl));\n    });\n\n    return cssText;\n}\n\n/**\n * Converts all object property names to leading '--' style\n *\n * @param {object} varObj Object containing CSS custom property name:value pairs\n * @returns {object}\n */\nfunction fixVarNames(varObj = {}) {\n    const reLeadingHyphens = /^-{2}/;\n\n    return Object.keys(varObj).reduce((obj, value) => {\n        const key = reLeadingHyphens.test(value) ? value : `--${value.replace(/^-+/, '')}`;\n\n        obj[key] = varObj[value];\n\n        return obj;\n    }, {});\n}\n\n/**\n * Returns fully qualified URL from relative URL and (optional) base URL\n *\n * @param   {string} url\n * @param   {string} [base=location.href]\n * @returns {string}\n */\nfunction getFullUrl(url, base = location.href) {\n    const d = document.implementation.createHTMLDocument('');\n    const b = d.createElement('base');\n    const a = d.createElement('a');\n\n    d.head.appendChild(b);\n    d.body.appendChild(a);\n    b.href = base;\n    a.href = url;\n\n    return a.href;\n}\n\n/**\n * Returns a time stamp in milliseconds\n *\n * @returns {number}\n */\nfunction getTimeStamp() {\n    return isBrowser && (window.performance || {}).now ? window.performance.now() : new Date().getTime();\n}\n\nfunction resetCssNodes(rootElement, resetDOMVariableStore = false) {\n    const resetNodes = [].slice.call(rootElement.querySelectorAll('[data-cssvars=\"skip\"],[data-cssvars=\"src\"]'));\n\n    resetNodes.forEach(node => node.setAttribute('data-cssvars', ''));\n\n    if (resetDOMVariableStore) {\n        variableStore.dom = {};\n    }\n}\n\n\n// Export\n// =============================================================================\nexport default cssVars;\n","import 'whatwg-fetch';\nimport cssVars from 'css-vars-ponyfill';\n\nif (typeof window.CSS === 'undefined' || typeof CSS.supports !== 'function' || !CSS.supports('--foo: bar')) {\n\tcssVars();\n}\n"],"names":["__webpack_require__","g","globalThis","this","Function","e","window","self","global","support","Symbol","Blob","viewClasses","isArrayBufferView","ArrayBuffer","isView","obj","indexOf","Object","prototype","toString","call","normalizeName","name","String","test","TypeError","toLowerCase","normalizeValue","value","iteratorFor","items","iterator","next","shift","done","undefined","Headers","headers","map","forEach","append","Array","isArray","header","length","getOwnPropertyNames","consumed","body","_noBody","bodyUsed","Promise","reject","fileReaderReady","reader","resolve","onload","result","onerror","error","readBlobAsArrayBuffer","blob","FileReader","promise","readAsArrayBuffer","bufferClone","buf","slice","view","Uint8Array","byteLength","set","buffer","Body","_initBody","_bodyInit","_bodyText","isPrototypeOf","_bodyBlob","FormData","_bodyFormData","URLSearchParams","DataView","_bodyArrayBuffer","get","type","rejected","Error","arrayBuffer","byteOffset","then","text","match","encoding","exec","readAsText","chars","i","fromCharCode","join","readArrayBufferAsText","formData","decode","json","JSON","parse","oldValue","has","hasOwnProperty","callback","thisArg","keys","push","values","entries","methods","Request","input","options","method","upcased","url","credentials","mode","signal","toUpperCase","AbortController","referrer","cache","reParamSearch","replace","Date","getTime","form","trim","split","bytes","decodeURIComponent","Response","bodyInit","status","RangeError","ok","statusText","clone","response","redirectStatuses","redirect","location","DOMException","err","message","stack","create","constructor","fetch","init","request","aborted","xhr","XMLHttpRequest","abortXhr","abort","rawHeaders","getAllResponseHeaders","substr","line","parts","key","console","warn","responseURL","responseText","setTimeout","ontimeout","onabort","open","href","fixUrl","withCredentials","responseType","_typeof","names","setRequestHeader","addEventListener","onreadystatechange","readyState","removeEventListener","send","getUrls","urls","arguments","settings","mimeType","onBeforeSend","onSuccess","onError","onComplete","urlArray","urlQueue","apply","x","isValidCss","isString","isHTML","charAt","urlIndex","returnVal","parser","document","createElement","setAttribute","Boolean","all","atob","host","protocol","xdr","XDomainRequest","timeout","onprogress","concat","overrideMimeType","polyfill","balancedMatch","balanced","a","b","str","RegExp","maybeMatch","r","range","start","end","pre","post","reg","m","begs","beg","left","right","ai","bi","pop","parseCss","css","_extends","preserveStatic","removeComments","msg","re","close","whitespace","comment","comments","c","cmnts","selector","selectorItems","_selector","hasCommaInQuotes","s","declaration","at_rule","comment_regexp","prop","val","ret","property","declarations","d","decls","keyframe","vals","at_x","at_fontface","media","rules","at_media","vendor","frame","frames","keyframes","at_keyframes","supports","at_supports","at_document","at_custom_m","at_host","selectors","at_page","at_page_margin_box","some","decl","rule","balancedMatch$1","hasVarDecl","hasVarFunc","sel","filter","core","node","stylesheet","errors","parseVars","cssData","parseHost","store","onWarning","reVarDeclSelectors","stringifyCss","tree","delim","cb","renderMethods","charset","visit","import","namespace","page","nodes","n","txt","walkCss","fn","transformCss","preserveVars","variables","VAR_FUNC_IDENTIFIER","resolvedValue","resolveValue","fixNestedCalc","splice","newVal","__recursiveFallback","valueData","fallback","replacement","unresolvedFallback","resolveFunc","isBrowser","isNativeSupport","CSS","counters","group","job","defaults","rootElement","shadowDOM","include","exclude","onlyLegacy","silent","updateDOM","updateURLs","watch","onFinally","regex","cssComments","cssKeyframes","cssMediaQueries","cssUrls","cssVarDeclRules","cssVarDecls","cssVarFunc","cssVars","variableStore","dom","user","cssVarsIsRunning","cssVarsObserver","cssVarsSrcNodeCount","debounceTimer","isShadowDOMReady","msgPrefix","handleError","sourceNode","handleWarning","handleFinally","hasChanged","getTimeStamp","__benchmark","isDisabled","isDisabledAttr","isLink","hasAttribute","isDisabledSheet","sheet","disabled","nodeName","getAttribute","isStyle","MutationObserver","disconnect","mutations","mutation","isValid","target","isEnabledMutation","attributeName","isHrefMutation","isSkipNode","isSrcNode","resetCssNodes","isValidAttributeMutation","isStyleElm","isOutNode","isValidStyleTextMutation","addedNodes","hasAttr","nodeType","isStyleWithVars","textContent","isValidAddMutation","removedNodes","isElm","dataGroup","orphanNode","querySelector","parentNode","removeChild","isValidRemoveMutation","observe","documentElement","attributes","attributeFilter","childList","subtree","addMutationObserver","delay","clearTimeout","cssVarsDebounced","srcNodes","querySelectorAll","varObj","reLeadingHyphens","reduce","fixVarNames","srcNode","hasStyleCache","__cssVars","hasStyleChanged","outNode","hasVarChange","targetElm","varValue","getComputedStyle","getPropertyValue","style","setProperty","shadowRoot","getCssData","skipDisabled","cssText","cssArray","nodeArray","responseUrl","getFullUrl","isStyleImport","baseUrl","cssUrl","oldUrl","newUrl","fixRelativeCssUrls","currentVars","nodeCSS","cssTree","outCssArray","outNodeArray","hasKeyframesWithVars","isSkip","outCss","hasCSSVarFunc","outCssNoSpaces","removeAttribute","insertBefore","nextSibling","elm","elms","animationNameProp","allNodes","keyframeNodes","nameMarker","len","offsetHeight","_i","_len","nodeStyle","fixKeyframes","stringify","evt","base","implementation","createHTMLDocument","head","appendChild","performance","now","resetDOMVariableStore","reset"],"sourceRoot":""}