text: (function(undefined) {
  // Detection from https://raw.githubusercontent.com/Financial-Times/polyfill-service/master/packages/polyfill-library/polyfills/DOMTokenList/detect.js
  var detect =
  'DOMTokenList' in this &&
  (function(x) {
  return 'classList' in x ? !x.classList.toggle('x', false) && !x.className : true;
  })(document.createElement('x'));
  
  if (detect) return;
  
  // Polyfill from https://raw.githubusercontent.com/Financial-Times/polyfill-service/master/packages/polyfill-library/polyfills/DOMTokenList/polyfill.js
  (function(global) {
  var nativeImpl = 'DOMTokenList' in global && global.DOMTokenList;
  
  if (
  !nativeImpl ||
  (!!document.createElementNS &&
  !!document.createElementNS('http://www.w3.org/2000/svg', 'svg') &&
  !(document.createElementNS('http://www.w3.org/2000/svg', 'svg').classList instanceof DOMTokenList))
  ) {
  global.DOMTokenList = (function() {
  // eslint-disable-line no-unused-vars
  var dpSupport = true;
  var defineGetter = function(object, name, fn, configurable) {
  if (Object.defineProperty)
  Object.defineProperty(object, name, {
  configurable: false === dpSupport ? true : !!configurable,
  get: fn,
  });
  else object.__defineGetter__(name, fn);
  };
  
  /** Ensure the browser allows Object.defineProperty to be used on native JavaScript objects. */
  try {
  defineGetter({}, 'support');
  } catch (e) {
  dpSupport = false;
  }
  
  var _DOMTokenList = function(el, prop) {
  var that = this;
  var tokens = [];
  var tokenMap = {};
  var length = 0;
  var maxLength = 0;
  var addIndexGetter = function(i) {
  defineGetter(
  that,
  i,
  function() {
  preop();
  return tokens[i];
  },
  false
  );
  };
  var reindex = function() {
  /** Define getter functions for array-like access to the tokenList's contents. */
  if (length >= maxLength)
  for (; maxLength < length; ++maxLength) {
  addIndexGetter(maxLength);
  }
  };
  
  /** Helper function called at the start of each class method. Internal use only. */
  var preop = function() {
  var error;
  var i;
  var args = arguments;
  var rSpace = /\s+/;
  
  /** Validate the token/s passed to an instance method, if any. */
  if (args.length)
  for (i = 0; i < args.length; ++i)
  if (rSpace.test(args[i])) {
  error = new SyntaxError('String "' + args[i] + '" ' + 'contains' + ' an invalid character');
  error.code = 5;
  error.name = 'InvalidCharacterError';
  throw error;
  }
  
  /** Split the new value apart by whitespace*/
  if (typeof el[prop] === 'object') {
  tokens = ('' + el[prop].baseVal).replace(/^\s+|\s+$/g, '').split(rSpace);
  } else {
  tokens = ('' + el[prop]).replace(/^\s+|\s+$/g, '').split(rSpace);
  }
  
  /** Avoid treating blank strings as single-item token lists */
  if ('' === tokens[0]) tokens = [];
  
  /** Repopulate the internal token lists */
  tokenMap = {};
  for (i = 0; i < tokens.length; ++i) tokenMap[tokens[i]] = true;
  length = tokens.length;
  reindex();
  };
  
  /** Populate our internal token list if the targeted attribute of the subject element isn't empty. */
  preop();
  
  /** Return the number of tokens in the underlying string. Read-only. */
  defineGetter(that, 'length', function() {
  preop();
  return length;
  });
  
  /** Override the default toString/toLocaleString methods to return a space-delimited list of tokens when typecast. */
  that.toLocaleString = that.toString = function() {
  preop();
  return tokens.join(' ');
  };
  
  that.item = function(idx) {
  preop();
  return tokens[idx];
  };
  
  that.contains = function(token) {
  preop();
  return !!tokenMap[token];
  };
  
  that.add = function() {
  preop.apply(that, (args = arguments));
  
  for (var args, token, i = 0, l = args.length; i < l; ++i) {
  token = args[i];
  if (!tokenMap[token]) {
  tokens.push(token);
  tokenMap[token] = true;
  }
  }
  
  /** Update the targeted attribute of the attached element if the token list's changed. */
  if (length !== tokens.length) {
  length = tokens.length >>> 0;
  if (typeof el[prop] === 'object') {
  el[prop].baseVal = tokens.join(' ');
  } else {
  el[prop] = tokens.join(' ');
  }
  reindex();
  }
  };
  
  that.remove = function() {
  preop.apply(that, (args = arguments));
  
  /** Build a hash of token names to compare against when recollecting our token list. */
  for (var args, ignore = {}, i = 0, t = []; i < args.length; ++i) {
  ignore[args[i]] = true;
  delete tokenMap[args[i]];
  }
  
  /** Run through our tokens list and reassign only those that aren't defined in the hash declared above. */
  for (i = 0; i < tokens.length; ++i) if (!ignore[tokens[i]]) t.push(tokens[i]);
  
  tokens = t;
  length = t.length >>> 0;
  
  /** Update the targeted attribute of the attached element. */
  if (typeof el[prop] === 'object') {
  el[prop].baseVal = tokens.join(' ');
  } else {
  el[prop] = tokens.join(' ');
  }
  reindex();
  };
  
  that.toggle = function(token, force) {
  preop.apply(that, [token]);
  
  /** Token state's being forced. */
  if (undefined !== force) {
  if (force) {
  that.add(token);
  return true;
  } else {
  that.remove(token);
  return false;
  }
  }
  
  /** Token already exists in tokenList. Remove it, and return FALSE. */
  if (tokenMap[token]) {
  that.remove(token);
  return false;
  }
  
  /** Otherwise, add the token and return TRUE. */
  that.add(token);
  return true;
  };
  
  return that;
  };
  
  return _DOMTokenList;
  })();
  }
  
  // Add second argument to native DOMTokenList.toggle() if necessary
  (function() {
  var e = document.createElement('span');
  if (!('classList' in e)) return;
  e.classList.toggle('x', false);
  if (!e.classList.contains('x')) return;
  e.classList.constructor.prototype.toggle = function toggle(token /*, force*/) {
  var force = arguments[1];
  if (force === undefined) {
  var add = !this.contains(token);
  this[add ? 'add' : 'remove'](token);
  return add;
  }
  force = !!force;
  this[force ? 'add' : 'remove'](token);
  return force;
  };
  })();
  
  // Add multiple arguments to native DOMTokenList.add() if necessary
  (function() {
  var e = document.createElement('span');
  if (!('classList' in e)) return;
  e.classList.add('a', 'b');
  if (e.classList.contains('b')) return;
  var native = e.classList.constructor.prototype.add;
  e.classList.constructor.prototype.add = function() {
  var args = arguments;
  var l = arguments.length;
  for (var i = 0; i < l; i++) {
  native.call(this, args[i]);
  }
  };
  })();
  
  // Add multiple arguments to native DOMTokenList.remove() if necessary
  (function() {
  var e = document.createElement('span');
  if (!('classList' in e)) return;
  e.classList.add('a');
  e.classList.add('b');
  e.classList.remove('a', 'b');
  if (!e.classList.contains('b')) return;
  var native = e.classList.constructor.prototype.remove;
  e.classList.constructor.prototype.remove = function() {
  var args = arguments;
  var l = arguments.length;
  for (var i = 0; i < l; i++) {
  native.call(this, args[i]);
  }
  };
  })();
  })(this);
  }.call(('object' === typeof window && window) || ('object' === typeof self && self) || ('object' === typeof global && global) || {}));
  