vviinn-widgets 2.4.2 → 2.4.3

package/dist/cjs/index-34d20028.js

@@ -0,0 +1,3222 @@
+'use strict';
+
+const imageSearch_store = require('./imageSearch.store-076370bf.js');
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+const REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+var byteToHex = [];
+
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify$1(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+function v4(options, buf, offset) {
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (var i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return stringify$1(rnds);
+}
+
+/**
+ * Check if we're required to add a port number.
+ *
+ * @see https://url.spec.whatwg.org/#default-port
+ * @param {Number|String} port Port number we need to check
+ * @param {String} protocol Protocol we need to check against.
+ * @returns {Boolean} Is it a default port for the given protocol
+ * @api private
+ */
+var requiresPort = function required(port, protocol) {
+  protocol = protocol.split(':')[0];
+  port = +port;
+
+  if (!port) return false;
+
+  switch (protocol) {
+    case 'http':
+    case 'ws':
+    return port !== 80;
+
+    case 'https':
+    case 'wss':
+    return port !== 443;
+
+    case 'ftp':
+    return port !== 21;
+
+    case 'gopher':
+    return port !== 70;
+
+    case 'file':
+    return false;
+  }
+
+  return port !== 0;
+};
+
+var has = Object.prototype.hasOwnProperty
+  , undef;
+
+/**
+ * Decode a URI encoded string.
+ *
+ * @param {String} input The URI encoded string.
+ * @returns {String|Null} The decoded string.
+ * @api private
+ */
+function decode$1(input) {
+  try {
+    return decodeURIComponent(input.replace(/\+/g, ' '));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Attempts to encode a given input.
+ *
+ * @param {String} input The string that needs to be encoded.
+ * @returns {String|Null} The encoded string.
+ * @api private
+ */
+function encode(input) {
+  try {
+    return encodeURIComponent(input);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Simple query string parser.
+ *
+ * @param {String} query The query string that needs to be parsed.
+ * @returns {Object}
+ * @api public
+ */
+function querystring(query) {
+  var parser = /([^=?#&]+)=?([^&]*)/g
+    , result = {}
+    , part;
+
+  while (part = parser.exec(query)) {
+    var key = decode$1(part[1])
+      , value = decode$1(part[2]);
+
+    //
+    // Prevent overriding of existing properties. This ensures that build-in
+    // methods like `toString` or __proto__ are not overriden by malicious
+    // querystrings.
+    //
+    // In the case if failed decoding, we want to omit the key/value pairs
+    // from the result.
+    //
+    if (key === null || value === null || key in result) continue;
+    result[key] = value;
+  }
+
+  return result;
+}
+
+/**
+ * Transform a query string to an object.
+ *
+ * @param {Object} obj Object that should be transformed.
+ * @param {String} prefix Optional prefix.
+ * @returns {String}
+ * @api public
+ */
+function querystringify(obj, prefix) {
+  prefix = prefix || '';
+
+  var pairs = []
+    , value
+    , key;
+
+  //
+  // Optionally prefix with a '?' if needed
+  //
+  if ('string' !== typeof prefix) prefix = '?';
+
+  for (key in obj) {
+    if (has.call(obj, key)) {
+      value = obj[key];
+
+      //
+      // Edge cases where we actually want to encode the value to an empty
+      // string instead of the stringified value.
+      //
+      if (!value && (value === null || value === undef || isNaN(value))) {
+        value = '';
+      }
+
+      key = encode(key);
+      value = encode(value);
+
+      //
+      // If we failed to encode the strings, we should bail out as we don't
+      // want to add invalid strings to the query.
+      //
+      if (key === null || value === null) continue;
+      pairs.push(key +'='+ value);
+    }
+  }
+
+  return pairs.length ? prefix + pairs.join('&') : '';
+}
+
+//
+// Expose the module.
+//
+var stringify = querystringify;
+var parse = querystring;
+
+var querystringify_1 = {
+	stringify: stringify,
+	parse: parse
+};
+
+var controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/
+  , CRHTLF = /[\n\r\t]/g
+  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//
+  , port = /:\d+$/
+  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i
+  , windowsDriveLetter = /^[a-zA-Z]:/;
+
+/**
+ * Remove control characters and whitespace from the beginning of a string.
+ *
+ * @param {Object|String} str String to trim.
+ * @returns {String} A new string representing `str` stripped of control
+ *     characters and whitespace from its beginning.
+ * @public
+ */
+function trimLeft(str) {
+  return (str ? str : '').toString().replace(controlOrWhitespace, '');
+}
+
+/**
+ * These are the parse rules for the URL parser, it informs the parser
+ * about:
+ *
+ * 0. The char it Needs to parse, if it's a string it should be done using
+ *    indexOf, RegExp using exec and NaN means set as current value.
+ * 1. The property we should set when parsing this value.
+ * 2. Indication if it's backwards or forward parsing, when set as number it's
+ *    the value of extra chars that should be split off.
+ * 3. Inherit from location if non existing in the parser.
+ * 4. `toLowerCase` the resulting value.
+ */
+var rules = [
+  ['#', 'hash'],                        // Extract from the back.
+  ['?', 'query'],                       // Extract from the back.
+  function sanitize(address, url) {     // Sanitize what is left of the address
+    return isSpecial(url.protocol) ? address.replace(/\\/g, '/') : address;
+  },
+  ['/', 'pathname'],                    // Extract from the back.
+  ['@', 'auth', 1],                     // Extract from the front.
+  [NaN, 'host', undefined, 1, 1],       // Set left over value.
+  [/:(\d*)$/, 'port', undefined, 1],    // RegExp the back.
+  [NaN, 'hostname', undefined, 1, 1]    // Set left over.
+];
+
+/**
+ * These properties should not be copied or inherited from. This is only needed
+ * for all non blob URL's as a blob URL does not include a hash, only the
+ * origin.
+ *
+ * @type {Object}
+ * @private
+ */
+var ignore = { hash: 1, query: 1 };
+
+/**
+ * The location object differs when your code is loaded through a normal page,
+ * Worker or through a worker using a blob. And with the blobble begins the
+ * trouble as the location object will contain the URL of the blob, not the
+ * location of the page where our code is loaded in. The actual origin is
+ * encoded in the `pathname` so we can thankfully generate a good "default"
+ * location from it so we can generate proper relative URL's again.
+ *
+ * @param {Object|String} loc Optional default location object.
+ * @returns {Object} lolcation object.
+ * @public
+ */
+function lolcation(loc) {
+  var globalVar;
+
+  if (typeof window !== 'undefined') globalVar = window;
+  else if (typeof imageSearch_store.commonjsGlobal !== 'undefined') globalVar = imageSearch_store.commonjsGlobal;
+  else if (typeof self !== 'undefined') globalVar = self;
+  else globalVar = {};
+
+  var location = globalVar.location || {};
+  loc = loc || location;
+
+  var finaldestination = {}
+    , type = typeof loc
+    , key;
+
+  if ('blob:' === loc.protocol) {
+    finaldestination = new Url(unescape(loc.pathname), {});
+  } else if ('string' === type) {
+    finaldestination = new Url(loc, {});
+    for (key in ignore) delete finaldestination[key];
+  } else if ('object' === type) {
+    for (key in loc) {
+      if (key in ignore) continue;
+      finaldestination[key] = loc[key];
+    }
+
+    if (finaldestination.slashes === undefined) {
+      finaldestination.slashes = slashes.test(loc.href);
+    }
+  }
+
+  return finaldestination;
+}
+
+/**
+ * Check whether a protocol scheme is special.
+ *
+ * @param {String} The protocol scheme of the URL
+ * @return {Boolean} `true` if the protocol scheme is special, else `false`
+ * @private
+ */
+function isSpecial(scheme) {
+  return (
+    scheme === 'file:' ||
+    scheme === 'ftp:' ||
+    scheme === 'http:' ||
+    scheme === 'https:' ||
+    scheme === 'ws:' ||
+    scheme === 'wss:'
+  );
+}
+
+/**
+ * @typedef ProtocolExtract
+ * @type Object
+ * @property {String} protocol Protocol matched in the URL, in lowercase.
+ * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`.
+ * @property {String} rest Rest of the URL that is not part of the protocol.
+ */
+
+/**
+ * Extract protocol information from a URL with/without double slash ("//").
+ *
+ * @param {String} address URL we want to extract from.
+ * @param {Object} location
+ * @return {ProtocolExtract} Extracted information.
+ * @private
+ */
+function extractProtocol(address, location) {
+  address = trimLeft(address);
+  address = address.replace(CRHTLF, '');
+  location = location || {};
+
+  var match = protocolre.exec(address);
+  var protocol = match[1] ? match[1].toLowerCase() : '';
+  var forwardSlashes = !!match[2];
+  var otherSlashes = !!match[3];
+  var slashesCount = 0;
+  var rest;
+
+  if (forwardSlashes) {
+    if (otherSlashes) {
+      rest = match[2] + match[3] + match[4];
+      slashesCount = match[2].length + match[3].length;
+    } else {
+      rest = match[2] + match[4];
+      slashesCount = match[2].length;
+    }
+  } else {
+    if (otherSlashes) {
+      rest = match[3] + match[4];
+      slashesCount = match[3].length;
+    } else {
+      rest = match[4];
+    }
+  }
+
+  if (protocol === 'file:') {
+    if (slashesCount >= 2) {
+      rest = rest.slice(2);
+    }
+  } else if (isSpecial(protocol)) {
+    rest = match[4];
+  } else if (protocol) {
+    if (forwardSlashes) {
+      rest = rest.slice(2);
+    }
+  } else if (slashesCount >= 2 && isSpecial(location.protocol)) {
+    rest = match[4];
+  }
+
+  return {
+    protocol: protocol,
+    slashes: forwardSlashes || isSpecial(protocol),
+    slashesCount: slashesCount,
+    rest: rest
+  };
+}
+
+/**
+ * Resolve a relative URL pathname against a base URL pathname.
+ *
+ * @param {String} relative Pathname of the relative URL.
+ * @param {String} base Pathname of the base URL.
+ * @return {String} Resolved pathname.
+ * @private
+ */
+function resolve(relative, base) {
+  if (relative === '') return base;
+
+  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))
+    , i = path.length
+    , last = path[i - 1]
+    , unshift = false
+    , up = 0;
+
+  while (i--) {
+    if (path[i] === '.') {
+      path.splice(i, 1);
+    } else if (path[i] === '..') {
+      path.splice(i, 1);
+      up++;
+    } else if (up) {
+      if (i === 0) unshift = true;
+      path.splice(i, 1);
+      up--;
+    }
+  }
+
+  if (unshift) path.unshift('');
+  if (last === '.' || last === '..') path.push('');
+
+  return path.join('/');
+}
+
+/**
+ * The actual URL instance. Instead of returning an object we've opted-in to
+ * create an actual constructor as it's much more memory efficient and
+ * faster and it pleases my OCD.
+ *
+ * It is worth noting that we should not use `URL` as class name to prevent
+ * clashes with the global URL instance that got introduced in browsers.
+ *
+ * @constructor
+ * @param {String} address URL we want to parse.
+ * @param {Object|String} [location] Location defaults for relative paths.
+ * @param {Boolean|Function} [parser] Parser for the query string.
+ * @private
+ */
+function Url(address, location, parser) {
+  address = trimLeft(address);
+  address = address.replace(CRHTLF, '');
+
+  if (!(this instanceof Url)) {
+    return new Url(address, location, parser);
+  }
+
+  var relative, extracted, parse, instruction, index, key
+    , instructions = rules.slice()
+    , type = typeof location
+    , url = this
+    , i = 0;
+
+  //
+  // The following if statements allows this module two have compatibility with
+  // 2 different API:
+  //
+  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments
+  //    where the boolean indicates that the query string should also be parsed.
+  //
+  // 2. The `URL` interface of the browser which accepts a URL, object as
+  //    arguments. The supplied object will be used as default values / fall-back
+  //    for relative paths.
+  //
+  if ('object' !== type && 'string' !== type) {
+    parser = location;
+    location = null;
+  }
+
+  if (parser && 'function' !== typeof parser) parser = querystringify_1.parse;
+
+  location = lolcation(location);
+
+  //
+  // Extract protocol information before running the instructions.
+  //
+  extracted = extractProtocol(address || '', location);
+  relative = !extracted.protocol && !extracted.slashes;
+  url.slashes = extracted.slashes || relative && location.slashes;
+  url.protocol = extracted.protocol || location.protocol || '';
+  address = extracted.rest;
+
+  //
+  // When the authority component is absent the URL starts with a path
+  // component.
+  //
+  if (
+    extracted.protocol === 'file:' && (
+      extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) ||
+    (!extracted.slashes &&
+      (extracted.protocol ||
+        extracted.slashesCount < 2 ||
+        !isSpecial(url.protocol)))
+  ) {
+    instructions[3] = [/(.*)/, 'pathname'];
+  }
+
+  for (; i < instructions.length; i++) {
+    instruction = instructions[i];
+
+    if (typeof instruction === 'function') {
+      address = instruction(address, url);
+      continue;
+    }
+
+    parse = instruction[0];
+    key = instruction[1];
+
+    if (parse !== parse) {
+      url[key] = address;
+    } else if ('string' === typeof parse) {
+      index = parse === '@'
+        ? address.lastIndexOf(parse)
+        : address.indexOf(parse);
+
+      if (~index) {
+        if ('number' === typeof instruction[2]) {
+          url[key] = address.slice(0, index);
+          address = address.slice(index + instruction[2]);
+        } else {
+          url[key] = address.slice(index);
+          address = address.slice(0, index);
+        }
+      }
+    } else if ((index = parse.exec(address))) {
+      url[key] = index[1];
+      address = address.slice(0, index.index);
+    }
+
+    url[key] = url[key] || (
+      relative && instruction[3] ? location[key] || '' : ''
+    );
+
+    //
+    // Hostname, host and protocol should be lowercased so they can be used to
+    // create a proper `origin`.
+    //
+    if (instruction[4]) url[key] = url[key].toLowerCase();
+  }
+
+  //
+  // Also parse the supplied query string in to an object. If we're supplied
+  // with a custom parser as function use that instead of the default build-in
+  // parser.
+  //
+  if (parser) url.query = parser(url.query);
+
+  //
+  // If the URL is relative, resolve the pathname against the base URL.
+  //
+  if (
+      relative
+    && location.slashes
+    && url.pathname.charAt(0) !== '/'
+    && (url.pathname !== '' || location.pathname !== '')
+  ) {
+    url.pathname = resolve(url.pathname, location.pathname);
+  }
+
+  //
+  // Default to a / for pathname if none exists. This normalizes the URL
+  // to always have a /
+  //
+  if (url.pathname.charAt(0) !== '/' && isSpecial(url.protocol)) {
+    url.pathname = '/' + url.pathname;
+  }
+
+  //
+  // We should not add port numbers if they are already the default port number
+  // for a given protocol. As the host also contains the port number we're going
+  // override it with the hostname which contains no port number.
+  //
+  if (!requiresPort(url.port, url.protocol)) {
+    url.host = url.hostname;
+    url.port = '';
+  }
+
+  //
+  // Parse down the `auth` for the username and password.
+  //
+  url.username = url.password = '';
+
+  if (url.auth) {
+    index = url.auth.indexOf(':');
+
+    if (~index) {
+      url.username = url.auth.slice(0, index);
+      url.username = encodeURIComponent(decodeURIComponent(url.username));
+
+      url.password = url.auth.slice(index + 1);
+      url.password = encodeURIComponent(decodeURIComponent(url.password));
+    } else {
+      url.username = encodeURIComponent(decodeURIComponent(url.auth));
+    }
+
+    url.auth = url.password ? url.username +':'+ url.password : url.username;
+  }
+
+  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host
+    ? url.protocol +'//'+ url.host
+    : 'null';
+
+  //
+  // The href is just the compiled result.
+  //
+  url.href = url.toString();
+}
+
+/**
+ * This is convenience method for changing properties in the URL instance to
+ * insure that they all propagate correctly.
+ *
+ * @param {String} part          Property we need to adjust.
+ * @param {Mixed} value          The newly assigned value.
+ * @param {Boolean|Function} fn  When setting the query, it will be the function
+ *                               used to parse the query.
+ *                               When setting the protocol, double slash will be
+ *                               removed from the final url if it is true.
+ * @returns {URL} URL instance for chaining.
+ * @public
+ */
+function set(part, value, fn) {
+  var url = this;
+
+  switch (part) {
+    case 'query':
+      if ('string' === typeof value && value.length) {
+        value = (fn || querystringify_1.parse)(value);
+      }
+
+      url[part] = value;
+      break;
+
+    case 'port':
+      url[part] = value;
+
+      if (!requiresPort(value, url.protocol)) {
+        url.host = url.hostname;
+        url[part] = '';
+      } else if (value) {
+        url.host = url.hostname +':'+ value;
+      }
+
+      break;
+
+    case 'hostname':
+      url[part] = value;
+
+      if (url.port) value += ':'+ url.port;
+      url.host = value;
+      break;
+
+    case 'host':
+      url[part] = value;
+
+      if (port.test(value)) {
+        value = value.split(':');
+        url.port = value.pop();
+        url.hostname = value.join(':');
+      } else {
+        url.hostname = value;
+        url.port = '';
+      }
+
+      break;
+
+    case 'protocol':
+      url.protocol = value.toLowerCase();
+      url.slashes = !fn;
+      break;
+
+    case 'pathname':
+    case 'hash':
+      if (value) {
+        var char = part === 'pathname' ? '/' : '#';
+        url[part] = value.charAt(0) !== char ? char + value : value;
+      } else {
+        url[part] = value;
+      }
+      break;
+
+    case 'username':
+    case 'password':
+      url[part] = encodeURIComponent(value);
+      break;
+
+    case 'auth':
+      var index = value.indexOf(':');
+
+      if (~index) {
+        url.username = value.slice(0, index);
+        url.username = encodeURIComponent(decodeURIComponent(url.username));
+
+        url.password = value.slice(index + 1);
+        url.password = encodeURIComponent(decodeURIComponent(url.password));
+      } else {
+        url.username = encodeURIComponent(decodeURIComponent(value));
+      }
+  }
+
+  for (var i = 0; i < rules.length; i++) {
+    var ins = rules[i];
+
+    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
+  }
+
+  url.auth = url.password ? url.username +':'+ url.password : url.username;
+
+  url.origin = url.protocol !== 'file:' && isSpecial(url.protocol) && url.host
+    ? url.protocol +'//'+ url.host
+    : 'null';
+
+  url.href = url.toString();
+
+  return url;
+}
+
+/**
+ * Transform the properties back in to a valid and full URL string.
+ *
+ * @param {Function} stringify Optional query stringify function.
+ * @returns {String} Compiled version of the URL.
+ * @public
+ */
+function toString(stringify) {
+  if (!stringify || 'function' !== typeof stringify) stringify = querystringify_1.stringify;
+
+  var query
+    , url = this
+    , host = url.host
+    , protocol = url.protocol;
+
+  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';
+
+  var result =
+    protocol +
+    ((url.protocol && url.slashes) || isSpecial(url.protocol) ? '//' : '');
+
+  if (url.username) {
+    result += url.username;
+    if (url.password) result += ':'+ url.password;
+    result += '@';
+  } else if (url.password) {
+    result += ':'+ url.password;
+    result += '@';
+  } else if (
+    url.protocol !== 'file:' &&
+    isSpecial(url.protocol) &&
+    !host &&
+    url.pathname !== '/'
+  ) {
+    //
+    // Add back the empty userinfo, otherwise the original invalid URL
+    // might be transformed into a valid one with `url.pathname` as host.
+    //
+    result += '@';
+  }
+
+  //
+  // Trailing colon is removed from `url.host` when it is parsed. If it still
+  // ends with a colon, then add back the trailing colon that was removed. This
+  // prevents an invalid URL from being transformed into a valid one.
+  //
+  if (host[host.length - 1] === ':' || (port.test(url.hostname) && !url.port)) {
+    host += ':';
+  }
+
+  result += host + url.pathname;
+
+  query = 'object' === typeof url.query ? stringify(url.query) : url.query;
+  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;
+
+  if (url.hash) result += url.hash;
+
+  return result;
+}
+
+Url.prototype = { set: set, toString: toString };
+
+//
+// Expose the URL parser and some additional properties that might be useful for
+// others or testing.
+//
+Url.extractProtocol = extractProtocol;
+Url.location = lolcation;
+Url.trimLeft = trimLeft;
+Url.qs = querystringify_1;
+
+var urlParse = Url;
+
+var rxjsStub = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = exports.mergeMap = exports.of = exports.from = exports.Observable = void 0;
+var Observable = (function () {
+    function Observable(promise) {
+        this.promise = promise;
+    }
+    Observable.prototype.toPromise = function () {
+        return this.promise;
+    };
+    Observable.prototype.pipe = function (callback) {
+        return new Observable(this.promise.then(callback));
+    };
+    return Observable;
+}());
+exports.Observable = Observable;
+function from(promise) {
+    return new Observable(promise);
+}
+exports.from = from;
+function of(value) {
+    return new Observable(Promise.resolve(value));
+}
+exports.of = of;
+function mergeMap(callback) {
+    return function (value) { return callback(value).toPromise(); };
+}
+exports.mergeMap = mergeMap;
+function map(callback) {
+    return callback;
+}
+exports.map = map;
+//# sourceMappingURL=rxjsStub.js.map
+});
+
+var global =
+  (typeof globalThis !== 'undefined' && globalThis) ||
+  (typeof self !== 'undefined' && self) ||
+  (typeof global !== 'undefined' && global);
+
+var support = {
+  searchParams: 'URLSearchParams' in global,
+  iterable: 'Symbol' in global && 'iterator' in Symbol,
+  blob:
+    'FileReader' in global &&
+    'Blob' in global &&
+    (function() {
+      try {
+        new Blob();
+        return true
+      } catch (e) {
+        return false
+      }
+    })(),
+  formData: 'FormData' in global,
+  arrayBuffer: 'ArrayBuffer' in global
+};
+
+function isDataView(obj) {
+  return obj && DataView.prototype.isPrototypeOf(obj)
+}
+
+if (support.arrayBuffer) {
+  var viewClasses = [
+    '[object Int8Array]',
+    '[object Uint8Array]',
+    '[object Uint8ClampedArray]',
+    '[object Int16Array]',
+    '[object Uint16Array]',
+    '[object Int32Array]',
+    '[object Uint32Array]',
+    '[object Float32Array]',
+    '[object Float64Array]'
+  ];
+
+  var isArrayBufferView =
+    ArrayBuffer.isView ||
+    function(obj) {
+      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+    };
+}
+
+function normalizeName(name) {
+  if (typeof name !== 'string') {
+    name = String(name);
+  }
+  if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+    throw new TypeError('Invalid character in header field name: "' + name + '"')
+  }
+  return name.toLowerCase()
+}
+
+function normalizeValue(value) {
+  if (typeof value !== 'string') {
+    value = String(value);
+  }
+  return value
+}
+
+// Build a destructive iterator for the value list
+function iteratorFor(items) {
+  var iterator = {
+    next: function() {
+      var value = items.shift();
+      return {done: value === undefined, value: value}
+    }
+  };
+
+  if (support.iterable) {
+    iterator[Symbol.iterator] = function() {
+      return iterator
+    };
+  }
+
+  return iterator
+}
+
+function Headers(headers) {
+  this.map = {};
+
+  if (headers instanceof Headers) {
+    headers.forEach(function(value, name) {
+      this.append(name, value);
+    }, this);
+  } else if (Array.isArray(headers)) {
+    headers.forEach(function(header) {
+      this.append(header[0], header[1]);
+    }, this);
+  } else if (headers) {
+    Object.getOwnPropertyNames(headers).forEach(function(name) {
+      this.append(name, headers[name]);
+    }, this);
+  }
+}
+
+Headers.prototype.append = function(name, value) {
+  name = normalizeName(name);
+  value = normalizeValue(value);
+  var oldValue = this.map[name];
+  this.map[name] = oldValue ? oldValue + ', ' + value : value;
+};
+
+Headers.prototype['delete'] = function(name) {
+  delete this.map[normalizeName(name)];
+};
+
+Headers.prototype.get = function(name) {
+  name = normalizeName(name);
+  return this.has(name) ? this.map[name] : null
+};
+
+Headers.prototype.has = function(name) {
+  return this.map.hasOwnProperty(normalizeName(name))
+};
+
+Headers.prototype.set = function(name, value) {
+  this.map[normalizeName(name)] = normalizeValue(value);
+};
+
+Headers.prototype.forEach = function(callback, thisArg) {
+  for (var name in this.map) {
+    if (this.map.hasOwnProperty(name)) {
+      callback.call(thisArg, this.map[name], name, this);
+    }
+  }
+};
+
+Headers.prototype.keys = function() {
+  var items = [];
+  this.forEach(function(value, name) {
+    items.push(name);
+  });
+  return iteratorFor(items)
+};
+
+Headers.prototype.values = function() {
+  var items = [];
+  this.forEach(function(value) {
+    items.push(value);
+  });
+  return iteratorFor(items)
+};
+
+Headers.prototype.entries = function() {
+  var items = [];
+  this.forEach(function(value, name) {
+    items.push([name, value]);
+  });
+  return iteratorFor(items)
+};
+
+if (support.iterable) {
+  Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+}
+
+function consumed(body) {
+  if (body.bodyUsed) {
+    return Promise.reject(new TypeError('Already read'))
+  }
+  body.bodyUsed = true;
+}
+
+function fileReaderReady(reader) {
+  return new Promise(function(resolve, reject) {
+    reader.onload = function() {
+      resolve(reader.result);
+    };
+    reader.onerror = function() {
+      reject(reader.error);
+    };
+  })
+}
+
+function readBlobAsArrayBuffer(blob) {
+  var reader = new FileReader();
+  var promise = fileReaderReady(reader);
+  reader.readAsArrayBuffer(blob);
+  return promise
+}
+
+function readBlobAsText(blob) {
+  var reader = new FileReader();
+  var promise = fileReaderReady(reader);
+  reader.readAsText(blob);
+  return promise
+}
+
+function readArrayBufferAsText(buf) {
+  var view = new Uint8Array(buf);
+  var chars = new Array(view.length);
+
+  for (var i = 0; i < view.length; i++) {
+    chars[i] = String.fromCharCode(view[i]);
+  }
+  return chars.join('')
+}
+
+function bufferClone(buf) {
+  if (buf.slice) {
+    return buf.slice(0)
+  } else {
+    var view = new Uint8Array(buf.byteLength);
+    view.set(new Uint8Array(buf));
+    return view.buffer
+  }
+}
+
+function Body() {
+  this.bodyUsed = false;
+
+  this._initBody = function(body) {
+    /*
+      fetch-mock wraps the Response object in an ES6 Proxy to
+      provide useful test harness features such as flush. However, on
+      ES5 browsers without fetch or Proxy support pollyfills must be used;
+      the proxy-pollyfill is unable to proxy an attribute unless it exists
+      on the object before the Proxy is created. This change ensures
+      Response.bodyUsed exists on the instance, while maintaining the
+      semantic of setting Request.bodyUsed in the constructor before
+      _initBody is called.
+    */
+    this.bodyUsed = this.bodyUsed;
+    this._bodyInit = body;
+    if (!body) {
+      this._bodyText = '';
+    } else if (typeof body === 'string') {
+      this._bodyText = body;
+    } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+      this._bodyBlob = body;
+    } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+      this._bodyFormData = body;
+    } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+      this._bodyText = body.toString();
+    } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+      this._bodyArrayBuffer = bufferClone(body.buffer);
+      // IE 10-11 can't handle a DataView body.
+      this._bodyInit = new Blob([this._bodyArrayBuffer]);
+    } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+      this._bodyArrayBuffer = bufferClone(body);
+    } else {
+      this._bodyText = body = Object.prototype.toString.call(body);
+    }
+
+    if (!this.headers.get('content-type')) {
+      if (typeof body === 'string') {
+        this.headers.set('content-type', 'text/plain;charset=UTF-8');
+      } else if (this._bodyBlob && this._bodyBlob.type) {
+        this.headers.set('content-type', this._bodyBlob.type);
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+      }
+    }
+  };
+
+  if (support.blob) {
+    this.blob = function() {
+      var rejected = consumed(this);
+      if (rejected) {
+        return rejected
+      }
+
+      if (this._bodyBlob) {
+        return Promise.resolve(this._bodyBlob)
+      } else if (this._bodyArrayBuffer) {
+        return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+      } else if (this._bodyFormData) {
+        throw new Error('could not read FormData body as blob')
+      } else {
+        return Promise.resolve(new Blob([this._bodyText]))
+      }
+    };
+
+    this.arrayBuffer = function() {
+      if (this._bodyArrayBuffer) {
+        var isConsumed = consumed(this);
+        if (isConsumed) {
+          return isConsumed
+        }
+        if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+          return Promise.resolve(
+            this._bodyArrayBuffer.buffer.slice(
+              this._bodyArrayBuffer.byteOffset,
+              this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+            )
+          )
+        } else {
+          return Promise.resolve(this._bodyArrayBuffer)
+        }
+      } else {
+        return this.blob().then(readBlobAsArrayBuffer)
+      }
+    };
+  }
+
+  this.text = function() {
+    var rejected = consumed(this);
+    if (rejected) {
+      return rejected
+    }
+
+    if (this._bodyBlob) {
+      return readBlobAsText(this._bodyBlob)
+    } else if (this._bodyArrayBuffer) {
+      return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+    } else if (this._bodyFormData) {
+      throw new Error('could not read FormData body as text')
+    } else {
+      return Promise.resolve(this._bodyText)
+    }
+  };
+
+  if (support.formData) {
+    this.formData = function() {
+      return this.text().then(decode)
+    };
+  }
+
+  this.json = function() {
+    return this.text().then(JSON.parse)
+  };
+
+  return this
+}
+
+// HTTP methods whose capitalization should be normalized
+var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+function normalizeMethod(method) {
+  var upcased = method.toUpperCase();
+  return methods.indexOf(upcased) > -1 ? upcased : method
+}
+
+function Request(input, options) {
+  if (!(this instanceof Request)) {
+    throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+  }
+
+  options = options || {};
+  var body = options.body;
+
+  if (input instanceof Request) {
+    if (input.bodyUsed) {
+      throw new TypeError('Already read')
+    }
+    this.url = input.url;
+    this.credentials = input.credentials;
+    if (!options.headers) {
+      this.headers = new Headers(input.headers);
+    }
+    this.method = input.method;
+    this.mode = input.mode;
+    this.signal = input.signal;
+    if (!body && input._bodyInit != null) {
+      body = input._bodyInit;
+      input.bodyUsed = true;
+    }
+  } else {
+    this.url = String(input);
+  }
+
+  this.credentials = options.credentials || this.credentials || 'same-origin';
+  if (options.headers || !this.headers) {
+    this.headers = new Headers(options.headers);
+  }
+  this.method = normalizeMethod(options.method || this.method || 'GET');
+  this.mode = options.mode || this.mode || null;
+  this.signal = options.signal || this.signal;
+  this.referrer = null;
+
+  if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+    throw new TypeError('Body not allowed for GET or HEAD requests')
+  }
+  this._initBody(body);
+
+  if (this.method === 'GET' || this.method === 'HEAD') {
+    if (options.cache === 'no-store' || options.cache === 'no-cache') {
+      // Search for a '_' parameter in the query string
+      var reParamSearch = /([?&])_=[^&]*/;
+      if (reParamSearch.test(this.url)) {
+        // If it already exists then set the value with the current time
+        this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+      } else {
+        // Otherwise add a new '_' parameter to the end with the current time
+        var reQueryString = /\?/;
+        this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+      }
+    }
+  }
+}
+
+Request.prototype.clone = function() {
+  return new Request(this, {body: this._bodyInit})
+};
+
+function decode(body) {
+  var form = new FormData();
+  body
+    .trim()
+    .split('&')
+    .forEach(function(bytes) {
+      if (bytes) {
+        var split = bytes.split('=');
+        var name = split.shift().replace(/\+/g, ' ');
+        var value = split.join('=').replace(/\+/g, ' ');
+        form.append(decodeURIComponent(name), decodeURIComponent(value));
+      }
+    });
+  return form
+}
+
+function parseHeaders(rawHeaders) {
+  var headers = new Headers();
+  // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+  // https://tools.ietf.org/html/rfc7230#section-3.2
+  var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+  // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+  // https://github.com/github/fetch/issues/748
+  // https://github.com/zloirock/core-js/issues/751
+  preProcessedHeaders
+    .split('\r')
+    .map(function(header) {
+      return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
+    })
+    .forEach(function(line) {
+      var parts = line.split(':');
+      var key = parts.shift().trim();
+      if (key) {
+        var value = parts.join(':').trim();
+        headers.append(key, value);
+      }
+    });
+  return headers
+}
+
+Body.call(Request.prototype);
+
+function Response(bodyInit, options) {
+  if (!(this instanceof Response)) {
+    throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+  }
+  if (!options) {
+    options = {};
+  }
+
+  this.type = 'default';
+  this.status = options.status === undefined ? 200 : options.status;
+  this.ok = this.status >= 200 && this.status < 300;
+  this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
+  this.headers = new Headers(options.headers);
+  this.url = options.url || '';
+  this._initBody(bodyInit);
+}
+
+Body.call(Response.prototype);
+
+Response.prototype.clone = function() {
+  return new Response(this._bodyInit, {
+    status: this.status,
+    statusText: this.statusText,
+    headers: new Headers(this.headers),
+    url: this.url
+  })
+};
+
+Response.error = function() {
+  var response = new Response(null, {status: 0, statusText: ''});
+  response.type = 'error';
+  return response
+};
+
+var redirectStatuses = [301, 302, 303, 307, 308];
+
+Response.redirect = function(url, status) {
+  if (redirectStatuses.indexOf(status) === -1) {
+    throw new RangeError('Invalid status code')
+  }
+
+  return new Response(null, {status: status, headers: {location: url}})
+};
+
+var DOMException = global.DOMException;
+try {
+  new DOMException();
+} catch (err) {
+  DOMException = function(message, name) {
+    this.message = message;
+    this.name = name;
+    var error = Error(message);
+    this.stack = error.stack;
+  };
+  DOMException.prototype = Object.create(Error.prototype);
+  DOMException.prototype.constructor = DOMException;
+}
+
+function fetch$1(input, init) {
+  return new Promise(function(resolve, reject) {
+    var request = new Request(input, init);
+
+    if (request.signal && request.signal.aborted) {
+      return reject(new DOMException('Aborted', 'AbortError'))
+    }
+
+    var xhr = new XMLHttpRequest();
+
+    function abortXhr() {
+      xhr.abort();
+    }
+
+    xhr.onload = function() {
+      var options = {
+        status: xhr.status,
+        statusText: xhr.statusText,
+        headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+      };
+      options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+      var body = 'response' in xhr ? xhr.response : xhr.responseText;
+      setTimeout(function() {
+        resolve(new Response(body, options));
+      }, 0);
+    };
+
+    xhr.onerror = function() {
+      setTimeout(function() {
+        reject(new TypeError('Network request failed'));
+      }, 0);
+    };
+
+    xhr.ontimeout = function() {
+      setTimeout(function() {
+        reject(new TypeError('Network request failed'));
+      }, 0);
+    };
+
+    xhr.onabort = function() {
+      setTimeout(function() {
+        reject(new DOMException('Aborted', 'AbortError'));
+      }, 0);
+    };
+
+    function fixUrl(url) {
+      try {
+        return url === '' && global.location.href ? global.location.href : url
+      } catch (e) {
+        return url
+      }
+    }
+
+    xhr.open(request.method, fixUrl(request.url), true);
+
+    if (request.credentials === 'include') {
+      xhr.withCredentials = true;
+    } else if (request.credentials === 'omit') {
+      xhr.withCredentials = false;
+    }
+
+    if ('responseType' in xhr) {
+      if (support.blob) {
+        xhr.responseType = 'blob';
+      } else if (
+        support.arrayBuffer &&
+        request.headers.get('Content-Type') &&
+        request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
+      ) {
+        xhr.responseType = 'arraybuffer';
+      }
+    }
+
+    if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+      Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+        xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+      });
+    } else {
+      request.headers.forEach(function(value, name) {
+        xhr.setRequestHeader(name, value);
+      });
+    }
+
+    if (request.signal) {
+      request.signal.addEventListener('abort', abortXhr);
+
+      xhr.onreadystatechange = function() {
+        // DONE (success or failure)
+        if (xhr.readyState === 4) {
+          request.signal.removeEventListener('abort', abortXhr);
+        }
+      };
+    }
+
+    xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+  })
+}
+
+fetch$1.polyfill = true;
+
+if (!global.fetch) {
+  global.fetch = fetch$1;
+  global.Headers = Headers;
+  global.Request = Request;
+  global.Response = Response;
+}
+
+var isomorphicFetch = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsomorphicFetchHttpLibrary = void 0;
+
+
+
+var IsomorphicFetchHttpLibrary = (function () {
+    function IsomorphicFetchHttpLibrary() {
+    }
+    IsomorphicFetchHttpLibrary.prototype.send = function (request) {
+        var method = request.getHttpMethod().toString();
+        var body = request.getBody();
+        var resultPromise = fetch(request.getUrl(), {
+            method: method,
+            body: body,
+            headers: request.getHeaders(),
+            credentials: "same-origin"
+        }).then(function (resp) {
+            var headers = {};
+            resp.headers.forEach(function (value, name) {
+                headers[name] = value;
+            });
+            var body = {
+                text: function () { return resp.text(); },
+                binary: function () { return resp.blob(); }
+            };
+            return new http.ResponseContext(resp.status, headers, body);
+        });
+        return (0, rxjsStub.from)(resultPromise);
+    };
+    return IsomorphicFetchHttpLibrary;
+}());
+exports.IsomorphicFetchHttpLibrary = IsomorphicFetchHttpLibrary;
+//# sourceMappingURL=isomorphic-fetch.js.map
+});
+
+var http = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapHttpLibrary = exports.ResponseContext = exports.SelfDecodingBody = exports.RequestContext = exports.HttpException = exports.HttpMethod = void 0;
+
+
+__exportStar(isomorphicFetch, exports);
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["CONNECT"] = "CONNECT";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["TRACE"] = "TRACE";
+    HttpMethod["PATCH"] = "PATCH";
+})(exports.HttpMethod || (exports.HttpMethod = {}));
+var HttpException = (function (_super) {
+    __extends(HttpException, _super);
+    function HttpException(msg) {
+        return _super.call(this, msg) || this;
+    }
+    return HttpException;
+}(Error));
+exports.HttpException = HttpException;
+var RequestContext = (function () {
+    function RequestContext(url, httpMethod) {
+        this.httpMethod = httpMethod;
+        this.headers = {};
+        this.body = undefined;
+        this.url = new urlParse(url, true);
+    }
+    RequestContext.prototype.getUrl = function () {
+        return this.url.toString();
+    };
+    RequestContext.prototype.setUrl = function (url) {
+        this.url = new urlParse(url, true);
+    };
+    RequestContext.prototype.setBody = function (body) {
+        this.body = body;
+    };
+    RequestContext.prototype.getHttpMethod = function () {
+        return this.httpMethod;
+    };
+    RequestContext.prototype.getHeaders = function () {
+        return this.headers;
+    };
+    RequestContext.prototype.getBody = function () {
+        return this.body;
+    };
+    RequestContext.prototype.setQueryParam = function (name, value) {
+        var queryObj = this.url.query;
+        queryObj[name] = value;
+        this.url.set("query", queryObj);
+    };
+    RequestContext.prototype.addCookie = function (name, value) {
+        if (!this.headers["Cookie"]) {
+            this.headers["Cookie"] = "";
+        }
+        this.headers["Cookie"] += name + "=" + value + "; ";
+    };
+    RequestContext.prototype.setHeaderParam = function (key, value) {
+        this.headers[key] = value;
+    };
+    return RequestContext;
+}());
+exports.RequestContext = RequestContext;
+var SelfDecodingBody = (function () {
+    function SelfDecodingBody(dataSource) {
+        this.dataSource = dataSource;
+    }
+    SelfDecodingBody.prototype.binary = function () {
+        return this.dataSource;
+    };
+    SelfDecodingBody.prototype.text = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.dataSource];
+                    case 1:
+                        data = _a.sent();
+                        if (data.text) {
+                            return [2, data.text()];
+                        }
+                        return [2, new Promise(function (resolve, reject) {
+                                var reader = new FileReader();
+                                reader.addEventListener("load", function () { return resolve(reader.result); });
+                                reader.addEventListener("error", function () { return reject(reader.error); });
+                                reader.readAsText(data);
+                            })];
+                }
+            });
+        });
+    };
+    return SelfDecodingBody;
+}());
+exports.SelfDecodingBody = SelfDecodingBody;
+var ResponseContext = (function () {
+    function ResponseContext(httpStatusCode, headers, body) {
+        this.httpStatusCode = httpStatusCode;
+        this.headers = headers;
+        this.body = body;
+    }
+    ResponseContext.prototype.getParsedHeader = function (headerName) {
+        var result = {};
+        if (!this.headers[headerName]) {
+            return result;
+        }
+        var parameters = this.headers[headerName].split(";");
+        for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
+            var parameter = parameters_1[_i];
+            var _a = parameter.split("=", 2), key = _a[0], value = _a[1];
+            key = key.toLowerCase().trim();
+            if (value === undefined) {
+                result[""] = key;
+            }
+            else {
+                value = value.trim();
+                if (value.startsWith('"') && value.endsWith('"')) {
+                    value = value.substring(1, value.length - 1);
+                }
+                result[key] = value;
+            }
+        }
+        return result;
+    };
+    ResponseContext.prototype.getBodyAsFile = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, fileName, contentType;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.body.binary()];
+                    case 1:
+                        data = _a.sent();
+                        fileName = this.getParsedHeader("content-disposition")["filename"] || "";
+                        contentType = this.headers["content-type"] || "";
+                        try {
+                            return [2, new File([data], fileName, { type: contentType })];
+                        }
+                        catch (error) {
+                            return [2, Object.assign(data, {
+                                    name: fileName,
+                                    type: contentType
+                                })];
+                        }
+                        return [2];
+                }
+            });
+        });
+    };
+    ResponseContext.prototype.getBodyAsAny = function () {
+        try {
+            return this.body.text();
+        }
+        catch (_a) { }
+        try {
+            return this.body.binary();
+        }
+        catch (_b) { }
+        return Promise.resolve(undefined);
+    };
+    return ResponseContext;
+}());
+exports.ResponseContext = ResponseContext;
+function wrapHttpLibrary(promiseHttpLibrary) {
+    return {
+        send: function (request) {
+            return (0, rxjsStub.from)(promiseHttpLibrary.send(request));
+        }
+    };
+}
+exports.wrapHttpLibrary = wrapHttpLibrary;
+//# sourceMappingURL=http.js.map
+});
+
+var auth = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __awaiter = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureAuthMethods = exports.BearerAuthAuthentication = void 0;
+var BearerAuthAuthentication = (function () {
+    function BearerAuthAuthentication(tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+    BearerAuthAuthentication.prototype.getName = function () {
+        return "bearerAuth";
+    };
+    BearerAuthAuthentication.prototype.applySecurityAuthentication = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _b = (_a = context).setHeaderParam;
+                        _c = ["Authorization"];
+                        _d = "Bearer ";
+                        return [4, this.tokenProvider.getToken()];
+                    case 1:
+                        _b.apply(_a, _c.concat([_d + (_e.sent())]));
+                        return [2];
+                }
+            });
+        });
+    };
+    return BearerAuthAuthentication;
+}());
+exports.BearerAuthAuthentication = BearerAuthAuthentication;
+function configureAuthMethods(config) {
+    var authMethods = {};
+    if (!config) {
+        return authMethods;
+    }
+    authMethods["default"] = config["default"];
+    if (config["bearerAuth"]) {
+        authMethods["bearerAuth"] = new BearerAuthAuthentication(config["bearerAuth"]["tokenProvider"]);
+    }
+    return authMethods;
+}
+exports.configureAuthMethods = configureAuthMethods;
+//# sourceMappingURL=auth.js.map
+});
+
+var ErrorObject_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorObject = void 0;
+var ErrorObject = (function () {
+    function ErrorObject() {
+    }
+    ErrorObject.getAttributeTypeMap = function () {
+        return ErrorObject.attributeTypeMap;
+    };
+    ErrorObject.discriminator = undefined;
+    ErrorObject.attributeTypeMap = [
+        {
+            "name": "domain",
+            "baseName": "domain",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "reason",
+            "baseName": "reason",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "message",
+            "baseName": "message",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "location",
+            "baseName": "location",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "location_type",
+            "baseName": "location_type",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "extended_help",
+            "baseName": "extended_help",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "send_report",
+            "baseName": "send_report",
+            "type": "string",
+            "format": ""
+        }
+    ];
+    return ErrorObject;
+}());
+exports.ErrorObject = ErrorObject;
+//# sourceMappingURL=ErrorObject.js.map
+});
+
+var ErrorResponse_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorResponse = void 0;
+var ErrorResponse = (function () {
+    function ErrorResponse() {
+    }
+    ErrorResponse.getAttributeTypeMap = function () {
+        return ErrorResponse.attributeTypeMap;
+    };
+    ErrorResponse.discriminator = undefined;
+    ErrorResponse.attributeTypeMap = [
+        {
+            "name": "code",
+            "baseName": "code",
+            "type": "number",
+            "format": ""
+        },
+        {
+            "name": "message",
+            "baseName": "message",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "errors",
+            "baseName": "errors",
+            "type": "Array<ErrorObject>",
+            "format": ""
+        }
+    ];
+    return ErrorResponse;
+}());
+exports.ErrorResponse = ErrorResponse;
+//# sourceMappingURL=ErrorResponse.js.map
+});
+
+var Event_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+var Event = (function () {
+    function Event() {
+        this.typ = "Event";
+    }
+    Event.getAttributeTypeMap = function () {
+        return Event.attributeTypeMap;
+    };
+    Event.discriminator = "typ";
+    Event.attributeTypeMap = [
+        {
+            "name": "session_id",
+            "baseName": "session_id",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "typ",
+            "baseName": "typ",
+            "type": "string",
+            "format": ""
+        }
+    ];
+    return Event;
+}());
+exports.Event = Event;
+//# sourceMappingURL=Event.js.map
+});
+
+var EventConfirmation_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventConfirmation = void 0;
+var EventConfirmation = (function () {
+    function EventConfirmation() {
+    }
+    EventConfirmation.getAttributeTypeMap = function () {
+        return EventConfirmation.attributeTypeMap;
+    };
+    EventConfirmation.discriminator = undefined;
+    EventConfirmation.attributeTypeMap = [
+        {
+            "name": "status",
+            "baseName": "status",
+            "type": "EventConfirmationStatusEnum",
+            "format": ""
+        }
+    ];
+    return EventConfirmation;
+}());
+exports.EventConfirmation = EventConfirmation;
+//# sourceMappingURL=EventConfirmation.js.map
+});
+
+var FilterAction = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=FilterAction.js.map
+});
+
+var FilterEvent_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterEvent = void 0;
+
+var FilterEvent = (function (_super) {
+    __extends(FilterEvent, _super);
+    function FilterEvent() {
+        var _this = _super.call(this) || this;
+        _this.typ = "FilterEvent";
+        return _this;
+    }
+    FilterEvent.getAttributeTypeMap = function () {
+        return _super.getAttributeTypeMap.call(this).concat(FilterEvent.attributeTypeMap);
+    };
+    FilterEvent.discriminator = undefined;
+    FilterEvent.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "action",
+            "baseName": "action",
+            "type": "FilterAction",
+            "format": ""
+        },
+        {
+            "name": "kind",
+            "baseName": "kind",
+            "type": "FilterKind",
+            "format": ""
+        }
+    ];
+    return FilterEvent;
+}(Event_1.Event));
+exports.FilterEvent = FilterEvent;
+//# sourceMappingURL=FilterEvent.js.map
+});
+
+var FilterEventAllOf_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterEventAllOf = void 0;
+var FilterEventAllOf = (function () {
+    function FilterEventAllOf() {
+    }
+    FilterEventAllOf.getAttributeTypeMap = function () {
+        return FilterEventAllOf.attributeTypeMap;
+    };
+    FilterEventAllOf.discriminator = undefined;
+    FilterEventAllOf.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "action",
+            "baseName": "action",
+            "type": "FilterAction",
+            "format": ""
+        },
+        {
+            "name": "kind",
+            "baseName": "kind",
+            "type": "FilterKind",
+            "format": ""
+        }
+    ];
+    return FilterEventAllOf;
+}());
+exports.FilterEventAllOf = FilterEventAllOf;
+//# sourceMappingURL=FilterEventAllOf.js.map
+});
+
+var FilterKind = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=FilterKind.js.map
+});
+
+var ProductClickEvent_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductClickEvent = void 0;
+
+var ProductClickEvent = (function (_super) {
+    __extends(ProductClickEvent, _super);
+    function ProductClickEvent() {
+        var _this = _super.call(this) || this;
+        _this.typ = "ProductClickEvent";
+        return _this;
+    }
+    ProductClickEvent.getAttributeTypeMap = function () {
+        return _super.getAttributeTypeMap.call(this).concat(ProductClickEvent.attributeTypeMap);
+    };
+    ProductClickEvent.discriminator = undefined;
+    ProductClickEvent.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "product",
+            "baseName": "product",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "rank",
+            "baseName": "rank",
+            "type": "number",
+            "format": ""
+        }
+    ];
+    return ProductClickEvent;
+}(Event_1.Event));
+exports.ProductClickEvent = ProductClickEvent;
+//# sourceMappingURL=ProductClickEvent.js.map
+});
+
+var ProductViewEvent_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductViewEvent = void 0;
+
+var ProductViewEvent = (function (_super) {
+    __extends(ProductViewEvent, _super);
+    function ProductViewEvent() {
+        var _this = _super.call(this) || this;
+        _this.typ = "ProductViewEvent";
+        return _this;
+    }
+    ProductViewEvent.getAttributeTypeMap = function () {
+        return _super.getAttributeTypeMap.call(this).concat(ProductViewEvent.attributeTypeMap);
+    };
+    ProductViewEvent.discriminator = undefined;
+    ProductViewEvent.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "product",
+            "baseName": "product",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "rank",
+            "baseName": "rank",
+            "type": "number",
+            "format": ""
+        }
+    ];
+    return ProductViewEvent;
+}(Event_1.Event));
+exports.ProductViewEvent = ProductViewEvent;
+//# sourceMappingURL=ProductViewEvent.js.map
+});
+
+var ProductViewEventAllOf_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductViewEventAllOf = void 0;
+var ProductViewEventAllOf = (function () {
+    function ProductViewEventAllOf() {
+    }
+    ProductViewEventAllOf.getAttributeTypeMap = function () {
+        return ProductViewEventAllOf.attributeTypeMap;
+    };
+    ProductViewEventAllOf.discriminator = undefined;
+    ProductViewEventAllOf.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "product",
+            "baseName": "product",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "rank",
+            "baseName": "rank",
+            "type": "number",
+            "format": ""
+        }
+    ];
+    return ProductViewEventAllOf;
+}());
+exports.ProductViewEventAllOf = ProductViewEventAllOf;
+//# sourceMappingURL=ProductViewEventAllOf.js.map
+});
+
+var SearchArea = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SearchArea.js.map
+});
+
+var SearchEvent_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchEvent = void 0;
+
+var SearchEvent = (function (_super) {
+    __extends(SearchEvent, _super);
+    function SearchEvent() {
+        var _this = _super.call(this) || this;
+        _this.typ = "SearchEvent";
+        return _this;
+    }
+    SearchEvent.getAttributeTypeMap = function () {
+        return _super.getAttributeTypeMap.call(this).concat(SearchEvent.attributeTypeMap);
+    };
+    SearchEvent.discriminator = undefined;
+    SearchEvent.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "source",
+            "baseName": "source",
+            "type": "SearchImageSource",
+            "format": ""
+        },
+        {
+            "name": "search_area",
+            "baseName": "search_area",
+            "type": "SearchArea",
+            "format": ""
+        }
+    ];
+    return SearchEvent;
+}(Event_1.Event));
+exports.SearchEvent = SearchEvent;
+//# sourceMappingURL=SearchEvent.js.map
+});
+
+var SearchEventAllOf_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchEventAllOf = void 0;
+var SearchEventAllOf = (function () {
+    function SearchEventAllOf() {
+    }
+    SearchEventAllOf.getAttributeTypeMap = function () {
+        return SearchEventAllOf.attributeTypeMap;
+    };
+    SearchEventAllOf.discriminator = undefined;
+    SearchEventAllOf.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "source",
+            "baseName": "source",
+            "type": "SearchImageSource",
+            "format": ""
+        },
+        {
+            "name": "search_area",
+            "baseName": "search_area",
+            "type": "SearchArea",
+            "format": ""
+        }
+    ];
+    return SearchEventAllOf;
+}());
+exports.SearchEventAllOf = SearchEventAllOf;
+//# sourceMappingURL=SearchEventAllOf.js.map
+});
+
+var SearchImageSource = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SearchImageSource.js.map
+});
+
+var Widget = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Widget.js.map
+});
+
+var WidgetAction = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=WidgetAction.js.map
+});
+
+var WidgetEvent_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetEvent = void 0;
+
+var WidgetEvent = (function (_super) {
+    __extends(WidgetEvent, _super);
+    function WidgetEvent() {
+        var _this = _super.call(this) || this;
+        _this.typ = "WidgetEvent";
+        return _this;
+    }
+    WidgetEvent.getAttributeTypeMap = function () {
+        return _super.getAttributeTypeMap.call(this).concat(WidgetEvent.attributeTypeMap);
+    };
+    WidgetEvent.discriminator = undefined;
+    WidgetEvent.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "action",
+            "baseName": "action",
+            "type": "WidgetAction",
+            "format": ""
+        }
+    ];
+    return WidgetEvent;
+}(Event_1.Event));
+exports.WidgetEvent = WidgetEvent;
+//# sourceMappingURL=WidgetEvent.js.map
+});
+
+var WidgetEventAllOf_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetEventAllOf = void 0;
+var WidgetEventAllOf = (function () {
+    function WidgetEventAllOf() {
+    }
+    WidgetEventAllOf.getAttributeTypeMap = function () {
+        return WidgetEventAllOf.attributeTypeMap;
+    };
+    WidgetEventAllOf.discriminator = undefined;
+    WidgetEventAllOf.attributeTypeMap = [
+        {
+            "name": "widget",
+            "baseName": "widget",
+            "type": "Widget",
+            "format": ""
+        },
+        {
+            "name": "action",
+            "baseName": "action",
+            "type": "WidgetAction",
+            "format": ""
+        }
+    ];
+    return WidgetEventAllOf;
+}());
+exports.WidgetEventAllOf = WidgetEventAllOf;
+//# sourceMappingURL=WidgetEventAllOf.js.map
+});
+
+var all = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __createBinding = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(ErrorObject_1, exports);
+__exportStar(ErrorResponse_1, exports);
+__exportStar(Event_1, exports);
+__exportStar(EventConfirmation_1, exports);
+__exportStar(FilterAction, exports);
+__exportStar(FilterEvent_1, exports);
+__exportStar(FilterEventAllOf_1, exports);
+__exportStar(FilterKind, exports);
+__exportStar(ProductClickEvent_1, exports);
+__exportStar(ProductViewEvent_1, exports);
+__exportStar(ProductViewEventAllOf_1, exports);
+__exportStar(SearchArea, exports);
+__exportStar(SearchEvent_1, exports);
+__exportStar(SearchEventAllOf_1, exports);
+__exportStar(SearchImageSource, exports);
+__exportStar(Widget, exports);
+__exportStar(WidgetAction, exports);
+__exportStar(WidgetEvent_1, exports);
+__exportStar(WidgetEventAllOf_1, exports);
+//# sourceMappingURL=all.js.map
+});
+
+var middleware = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseMiddlewareWrapper = void 0;
+
+var PromiseMiddlewareWrapper = (function () {
+    function PromiseMiddlewareWrapper(middleware) {
+        this.middleware = middleware;
+    }
+    PromiseMiddlewareWrapper.prototype.pre = function (context) {
+        return (0, rxjsStub.from)(this.middleware.pre(context));
+    };
+    PromiseMiddlewareWrapper.prototype.post = function (context) {
+        return (0, rxjsStub.from)(this.middleware.post(context));
+    };
+    return PromiseMiddlewareWrapper;
+}());
+exports.PromiseMiddlewareWrapper = PromiseMiddlewareWrapper;
+//# sourceMappingURL=middleware.js.map
+});
+
+var servers = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servers = exports.server2 = exports.server1 = exports.ServerConfiguration = void 0;
+
+var ServerConfiguration = (function () {
+    function ServerConfiguration(url, variableConfiguration) {
+        this.url = url;
+        this.variableConfiguration = variableConfiguration;
+    }
+    ServerConfiguration.prototype.setVariables = function (variableConfiguration) {
+        Object.assign(this.variableConfiguration, variableConfiguration);
+    };
+    ServerConfiguration.prototype.getConfiguration = function () {
+        return this.variableConfiguration;
+    };
+    ServerConfiguration.prototype.getUrl = function () {
+        var replacedUrl = this.url;
+        for (var key in this.variableConfiguration) {
+            var re = new RegExp("{" + key + "}", "g");
+            replacedUrl = replacedUrl.replace(re, this.variableConfiguration[key]);
+        }
+        return replacedUrl;
+    };
+    ServerConfiguration.prototype.makeRequestContext = function (endpoint, httpMethod) {
+        return new http.RequestContext(this.getUrl() + endpoint, httpMethod);
+    };
+    return ServerConfiguration;
+}());
+exports.ServerConfiguration = ServerConfiguration;
+exports.server1 = new ServerConfiguration("https://tracking.vviinn.com", {});
+exports.server2 = new ServerConfiguration("https://tracking.stage.vviinn.com", {});
+exports.servers = [exports.server1, exports.server2];
+//# sourceMappingURL=servers.js.map
+});
+
+var configuration = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfiguration = void 0;
+
+
+
+
+function createConfiguration(conf) {
+    if (conf === void 0) { conf = {}; }
+    var configuration = {
+        baseServer: conf.baseServer !== undefined ? conf.baseServer : servers.server1,
+        httpApi: conf.httpApi || new isomorphicFetch.IsomorphicFetchHttpLibrary(),
+        middleware: conf.middleware || [],
+        authMethods: (0, auth.configureAuthMethods)(conf.authMethods)
+    };
+    if (conf.promiseMiddleware) {
+        conf.promiseMiddleware.forEach(function (m) { return configuration.middleware.push(new middleware.PromiseMiddlewareWrapper(m)); });
+    }
+    return configuration;
+}
+exports.createConfiguration = createConfiguration;
+//# sourceMappingURL=configuration.js.map
+});
+
+var exception = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiException = void 0;
+var ApiException = (function (_super) {
+    __extends(ApiException, _super);
+    function ApiException(code, message, body, headers) {
+        var _this = _super.call(this, "HTTP-Code: " + code + "\nMessage: " + message + "\nBody: " + JSON.stringify(body) + "\nHeaders: " +
+            JSON.stringify(headers)) || this;
+        _this.code = code;
+        _this.body = body;
+        _this.headers = headers;
+        return _this;
+    }
+    return ApiException;
+}(Error));
+exports.ApiException = ApiException;
+//# sourceMappingURL=exception.js.map
+});
+
+var baseapi = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredError = exports.BaseAPIRequestFactory = exports.COLLECTION_FORMATS = void 0;
+exports.COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+var BaseAPIRequestFactory = (function () {
+    function BaseAPIRequestFactory(configuration) {
+        this.configuration = configuration;
+    }
+    return BaseAPIRequestFactory;
+}());
+exports.BaseAPIRequestFactory = BaseAPIRequestFactory;
+var RequiredError = (function (_super) {
+    __extends(RequiredError, _super);
+    function RequiredError(api, method, field) {
+        var _this = _super.call(this, "Required parameter " + field + " was null or undefined when calling " + api + "." + method + ".") || this;
+        _this.api = api;
+        _this.method = method;
+        _this.field = field;
+        _this.name = "RequiredError";
+        return _this;
+    }
+    return RequiredError;
+}(Error));
+exports.RequiredError = RequiredError;
+//# sourceMappingURL=baseapi.js.map
+});
+
+var ObjectSerializer_1 = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __createBinding = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectSerializer = void 0;
+__exportStar(ErrorObject_1, exports);
+__exportStar(ErrorResponse_1, exports);
+__exportStar(Event_1, exports);
+__exportStar(EventConfirmation_1, exports);
+__exportStar(FilterAction, exports);
+__exportStar(FilterEvent_1, exports);
+__exportStar(FilterEventAllOf_1, exports);
+__exportStar(FilterKind, exports);
+__exportStar(ProductClickEvent_1, exports);
+__exportStar(ProductViewEvent_1, exports);
+__exportStar(ProductViewEventAllOf_1, exports);
+__exportStar(SearchArea, exports);
+__exportStar(SearchEvent_1, exports);
+__exportStar(SearchEventAllOf_1, exports);
+__exportStar(SearchImageSource, exports);
+__exportStar(Widget, exports);
+__exportStar(WidgetAction, exports);
+__exportStar(WidgetEvent_1, exports);
+__exportStar(WidgetEventAllOf_1, exports);
+var ErrorObject_1$1 = ErrorObject_1;
+var ErrorResponse_1$1 = ErrorResponse_1;
+var Event_1$1 = Event_1;
+var EventConfirmation_1$1 = EventConfirmation_1;
+var FilterEvent_1$1 = FilterEvent_1;
+var FilterEventAllOf_1$1 = FilterEventAllOf_1;
+var ProductClickEvent_1$1 = ProductClickEvent_1;
+var ProductViewEvent_1$1 = ProductViewEvent_1;
+var ProductViewEventAllOf_1$1 = ProductViewEventAllOf_1;
+var SearchEvent_1$1 = SearchEvent_1;
+var SearchEventAllOf_1$1 = SearchEventAllOf_1;
+var WidgetEvent_1$1 = WidgetEvent_1;
+var WidgetEventAllOf_1$1 = WidgetEventAllOf_1;
+var primitives = [
+    "string",
+    "boolean",
+    "double",
+    "integer",
+    "long",
+    "float",
+    "number",
+    "any"
+];
+var supportedMediaTypes = {
+    "application/json": Infinity,
+    "application/octet-stream": 0,
+    "application/x-www-form-urlencoded": 0
+};
+var enumsMap = new Set([
+    "EventConfirmationStatusEnum",
+    "FilterAction",
+    "FilterKind",
+    "SearchArea",
+    "SearchImageSource",
+    "Widget",
+    "WidgetAction",
+]);
+var typeMap = {
+    "ErrorObject": ErrorObject_1$1.ErrorObject,
+    "ErrorResponse": ErrorResponse_1$1.ErrorResponse,
+    "Event": Event_1$1.Event,
+    "EventConfirmation": EventConfirmation_1$1.EventConfirmation,
+    "FilterEvent": FilterEvent_1$1.FilterEvent,
+    "FilterEventAllOf": FilterEventAllOf_1$1.FilterEventAllOf,
+    "ProductClickEvent": ProductClickEvent_1$1.ProductClickEvent,
+    "ProductViewEvent": ProductViewEvent_1$1.ProductViewEvent,
+    "ProductViewEventAllOf": ProductViewEventAllOf_1$1.ProductViewEventAllOf,
+    "SearchEvent": SearchEvent_1$1.SearchEvent,
+    "SearchEventAllOf": SearchEventAllOf_1$1.SearchEventAllOf,
+    "WidgetEvent": WidgetEvent_1$1.WidgetEvent,
+    "WidgetEventAllOf": WidgetEventAllOf_1$1.WidgetEventAllOf,
+};
+var ObjectSerializer = (function () {
+    function ObjectSerializer() {
+    }
+    ObjectSerializer.findCorrectType = function (data, expectedType) {
+        if (data == undefined) {
+            return expectedType;
+        }
+        else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        }
+        else if (expectedType === "Date") {
+            return expectedType;
+        }
+        else {
+            if (enumsMap.has(expectedType)) {
+                return expectedType;
+            }
+            if (!typeMap[expectedType]) {
+                return expectedType;
+            }
+            var discriminatorProperty = typeMap[expectedType].discriminator;
+            if (discriminatorProperty == null) {
+                return expectedType;
+            }
+            else {
+                if (data[discriminatorProperty]) {
+                    var discriminatorType = data[discriminatorProperty];
+                    if (typeMap[discriminatorType]) {
+                        return discriminatorType;
+                    }
+                    else {
+                        return expectedType;
+                    }
+                }
+                else {
+                    return expectedType;
+                }
+            }
+        }
+    };
+    ObjectSerializer.serialize = function (data, type, format) {
+        if (data == undefined) {
+            return data;
+        }
+        else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (type.lastIndexOf("Array<", 0) === 0) {
+            var subType = type.replace("Array<", "");
+            subType = subType.substring(0, subType.length - 1);
+            var transformedData = [];
+            for (var index in data) {
+                var date = data[index];
+                transformedData.push(ObjectSerializer.serialize(date, subType, format));
+            }
+            return transformedData;
+        }
+        else if (type === "Date") {
+            if (format == "date") {
+                var month = data.getMonth() + 1;
+                month = month < 10 ? "0" + month.toString() : month.toString();
+                var day = data.getDate();
+                day = day < 10 ? "0" + day.toString() : day.toString();
+                return data.getFullYear() + "-" + month + "-" + day;
+            }
+            else {
+                return data.toISOString();
+            }
+        }
+        else {
+            if (enumsMap.has(type)) {
+                return data;
+            }
+            if (!typeMap[type]) {
+                return data;
+            }
+            type = this.findCorrectType(data, type);
+            var attributeTypes = typeMap[type].getAttributeTypeMap();
+            var instance = {};
+            for (var index in attributeTypes) {
+                var attributeType = attributeTypes[index];
+                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type, attributeType.format);
+            }
+            return instance;
+        }
+    };
+    ObjectSerializer.deserialize = function (data, type, format) {
+        type = ObjectSerializer.findCorrectType(data, type);
+        if (data == undefined) {
+            return data;
+        }
+        else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (type.lastIndexOf("Array<", 0) === 0) {
+            var subType = type.replace("Array<", "");
+            subType = subType.substring(0, subType.length - 1);
+            var transformedData = [];
+            for (var index in data) {
+                var date = data[index];
+                transformedData.push(ObjectSerializer.deserialize(date, subType, format));
+            }
+            return transformedData;
+        }
+        else if (type === "Date") {
+            return new Date(data);
+        }
+        else {
+            if (enumsMap.has(type)) {
+                return data;
+            }
+            if (!typeMap[type]) {
+                return data;
+            }
+            var instance = new typeMap[type]();
+            var attributeTypes = typeMap[type].getAttributeTypeMap();
+            for (var index in attributeTypes) {
+                var attributeType = attributeTypes[index];
+                instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format);
+            }
+            return instance;
+        }
+    };
+    ObjectSerializer.normalizeMediaType = function (mediaType) {
+        if (mediaType === undefined) {
+            return undefined;
+        }
+        return mediaType.split(";")[0].trim().toLowerCase();
+    };
+    ObjectSerializer.getPreferredMediaType = function (mediaTypes) {
+        if (!mediaTypes) {
+            return "application/json";
+        }
+        var normalMediaTypes = mediaTypes.map(this.normalizeMediaType);
+        var selectedMediaType = undefined;
+        var selectedRank = -Infinity;
+        for (var _i = 0, normalMediaTypes_1 = normalMediaTypes; _i < normalMediaTypes_1.length; _i++) {
+            var mediaType = normalMediaTypes_1[_i];
+            if (supportedMediaTypes[mediaType] > selectedRank) {
+                selectedMediaType = mediaType;
+                selectedRank = supportedMediaTypes[mediaType];
+            }
+        }
+        if (selectedMediaType === undefined) {
+            throw new Error("None of the given media types are supported: " + mediaTypes.join(", "));
+        }
+        return selectedMediaType;
+    };
+    ObjectSerializer.stringify = function (data, mediaType) {
+        if (mediaType === "application/json") {
+            return JSON.stringify(data);
+        }
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify.");
+    };
+    ObjectSerializer.parse = function (rawData, mediaType) {
+        if (mediaType === undefined) {
+            throw new Error("Cannot parse content. No Content-Type defined.");
+        }
+        if (mediaType === "application/json") {
+            return JSON.parse(rawData);
+        }
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
+    };
+    return ObjectSerializer;
+}());
+exports.ObjectSerializer = ObjectSerializer;
+//# sourceMappingURL=ObjectSerializer.js.map
+});
+
+var util = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConsumeForm = exports.isCodeInRange = void 0;
+function isCodeInRange(codeRange, code) {
+    if (codeRange === "0") {
+        return true;
+    }
+    if (codeRange == code.toString()) {
+        return true;
+    }
+    else {
+        var codeString = code.toString();
+        if (codeString.length != codeRange.length) {
+            return false;
+        }
+        for (var i = 0; i < codeString.length; i++) {
+            if (codeRange.charAt(i) != "X" && codeRange.charAt(i) != codeString.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.isCodeInRange = isCodeInRange;
+function canConsumeForm(contentTypes) {
+    return contentTypes.indexOf('multipart/form-data') !== -1;
+}
+exports.canConsumeForm = canConsumeForm;
+//# sourceMappingURL=util.js.map
+});
+
+var DefaultApi = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __extends = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultApiResponseProcessor = exports.DefaultApiRequestFactory = void 0;
+
+
+
+
+
+var DefaultApiRequestFactory = (function (_super) {
+    __extends(DefaultApiRequestFactory, _super);
+    function DefaultApiRequestFactory() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DefaultApiRequestFactory.prototype.trackEvent = function (product_view_event___product_click_event___widget_event___filter_event___search_event, _options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var _config, localVarPath, requestContext, contentType, serializedBody, authMethod, defaultAuth;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _config = _options || this.configuration;
+                        localVarPath = '/event';
+                        requestContext = _config.baseServer.makeRequestContext(localVarPath, http.HttpMethod.POST);
+                        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
+                        contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                            "application/json"
+                        ]);
+                        requestContext.setHeaderParam("Content-Type", contentType);
+                        serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(product_view_event___product_click_event___widget_event___filter_event___search_event, "ProductViewEvent | ProductClickEvent | WidgetEvent | FilterEvent | SearchEvent", ""), contentType);
+                        requestContext.setBody(serializedBody);
+                        authMethod = _config.authMethods["bearerAuth"];
+                        if (!(authMethod === null || authMethod === void 0 ? void 0 : authMethod.applySecurityAuthentication)) return [3, 2];
+                        return [4, (authMethod === null || authMethod === void 0 ? void 0 : authMethod.applySecurityAuthentication(requestContext))];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        defaultAuth = ((_a = _options === null || _options === void 0 ? void 0 : _options.authMethods) === null || _a === void 0 ? void 0 : _a.default) || ((_c = (_b = this.configuration) === null || _b === void 0 ? void 0 : _b.authMethods) === null || _c === void 0 ? void 0 : _c.default);
+                        if (!(defaultAuth === null || defaultAuth === void 0 ? void 0 : defaultAuth.applySecurityAuthentication)) return [3, 4];
+                        return [4, (defaultAuth === null || defaultAuth === void 0 ? void 0 : defaultAuth.applySecurityAuthentication(requestContext))];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4: return [2, requestContext];
+                }
+            });
+        });
+    };
+    return DefaultApiRequestFactory;
+}(baseapi.BaseAPIRequestFactory));
+exports.DefaultApiRequestFactory = DefaultApiRequestFactory;
+var DefaultApiResponseProcessor = (function () {
+    function DefaultApiResponseProcessor() {
+    }
+    DefaultApiResponseProcessor.prototype.trackEvent = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contentType, body, _a, _b, _c, _d, body, _e, _f, _g, _h, body, _j, _k, _l, _m, _o, _p;
+            return __generator(this, function (_q) {
+                switch (_q.label) {
+                    case 0:
+                        contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+                        if (!(0, util.isCodeInRange)("200", response.httpStatusCode)) return [3, 2];
+                        _b = (_a = ObjectSerializer_1.ObjectSerializer).deserialize;
+                        _d = (_c = ObjectSerializer_1.ObjectSerializer).parse;
+                        return [4, response.body.text()];
+                    case 1:
+                        body = _b.apply(_a, [_d.apply(_c, [_q.sent(), contentType]),
+                            "EventConfirmation", ""]);
+                        return [2, body];
+                    case 2:
+                        if (!(0, util.isCodeInRange)("502", response.httpStatusCode)) return [3, 4];
+                        _f = (_e = ObjectSerializer_1.ObjectSerializer).deserialize;
+                        _h = (_g = ObjectSerializer_1.ObjectSerializer).parse;
+                        return [4, response.body.text()];
+                    case 3:
+                        body = _f.apply(_e, [_h.apply(_g, [_q.sent(), contentType]),
+                            "ErrorResponse", ""]);
+                        throw new exception.ApiException(502, "an error occurred", body, response.headers);
+                    case 4:
+                        if (!(response.httpStatusCode >= 200 && response.httpStatusCode <= 299)) return [3, 6];
+                        _k = (_j = ObjectSerializer_1.ObjectSerializer).deserialize;
+                        _m = (_l = ObjectSerializer_1.ObjectSerializer).parse;
+                        return [4, response.body.text()];
+                    case 5:
+                        body = _k.apply(_j, [_m.apply(_l, [_q.sent(), contentType]),
+                            "EventConfirmation", ""]);
+                        return [2, body];
+                    case 6:
+                        _o = exception.ApiException.bind;
+                        _p = [void 0, response.httpStatusCode, "Unknown API Status Code!"];
+                        return [4, response.getBodyAsAny()];
+                    case 7: throw new (_o.apply(exception.ApiException, _p.concat([_q.sent(), response.headers])))();
+                }
+            });
+        });
+    };
+    return DefaultApiResponseProcessor;
+}());
+exports.DefaultApiResponseProcessor = DefaultApiResponseProcessor;
+//# sourceMappingURL=DefaultApi.js.map
+});
+
+var ObservableAPI = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableDefaultApi = void 0;
+
+var rxjsStub_2 = rxjsStub;
+
+var ObservableDefaultApi = (function () {
+    function ObservableDefaultApi(configuration, requestFactory, responseProcessor) {
+        this.configuration = configuration;
+        this.requestFactory = requestFactory || new DefaultApi.DefaultApiRequestFactory(configuration);
+        this.responseProcessor = responseProcessor || new DefaultApi.DefaultApiResponseProcessor();
+    }
+    ObservableDefaultApi.prototype.trackEvent = function (product_view_event___product_click_event___widget_event___filter_event___search_event, _options) {
+        var _this = this;
+        var requestContextPromise = this.requestFactory.trackEvent(product_view_event___product_click_event___widget_event___filter_event___search_event, _options);
+        var middlewarePreObservable = (0, rxjsStub.from)(requestContextPromise);
+        var _loop_1 = function (middleware) {
+            middlewarePreObservable = middlewarePreObservable.pipe((0, rxjsStub_2.mergeMap)(function (ctx) { return middleware.pre(ctx); }));
+        };
+        for (var _i = 0, _a = this.configuration.middleware; _i < _a.length; _i++) {
+            var middleware = _a[_i];
+            _loop_1(middleware);
+        }
+        return middlewarePreObservable.pipe((0, rxjsStub_2.mergeMap)(function (ctx) { return _this.configuration.httpApi.send(ctx); })).
+            pipe((0, rxjsStub_2.mergeMap)(function (response) {
+            var middlewarePostObservable = (0, rxjsStub.of)(response);
+            var _loop_2 = function (middleware) {
+                middlewarePostObservable = middlewarePostObservable.pipe((0, rxjsStub_2.mergeMap)(function (rsp) { return middleware.post(rsp); }));
+            };
+            for (var _i = 0, _a = _this.configuration.middleware; _i < _a.length; _i++) {
+                var middleware = _a[_i];
+                _loop_2(middleware);
+            }
+            return middlewarePostObservable.pipe((0, rxjsStub_2.map)(function (rsp) { return _this.responseProcessor.trackEvent(rsp); }));
+        }));
+    };
+    return ObservableDefaultApi;
+}());
+exports.ObservableDefaultApi = ObservableDefaultApi;
+//# sourceMappingURL=ObservableAPI.js.map
+});
+
+var PromiseAPI = imageSearch_store.createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseDefaultApi = void 0;
+
+var PromiseDefaultApi = (function () {
+    function PromiseDefaultApi(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI.ObservableDefaultApi(configuration, requestFactory, responseProcessor);
+    }
+    PromiseDefaultApi.prototype.trackEvent = function (product_view_event___product_click_event___widget_event___filter_event___search_event, _options) {
+        var result = this.api.trackEvent(product_view_event___product_click_event___widget_event___filter_event___search_event, _options);
+        return result.toPromise();
+    };
+    return PromiseDefaultApi;
+}());
+exports.PromiseDefaultApi = PromiseDefaultApi;
+//# sourceMappingURL=PromiseAPI.js.map
+});
+
+var dist = imageSearch_store.createCommonjsModule(function (module, exports) {
+var __createBinding = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (imageSearch_store.commonjsGlobal && imageSearch_store.commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultApi = exports.createConfiguration = void 0;
+__exportStar(http, exports);
+__exportStar(auth, exports);
+__exportStar(all, exports);
+
+Object.defineProperty(exports, "createConfiguration", { enumerable: true, get: function () { return configuration.createConfiguration; } });
+__exportStar(exception, exports);
+__exportStar(servers, exports);
+
+Object.defineProperty(exports, "DefaultApi", { enumerable: true, get: function () { return PromiseAPI.PromiseDefaultApi; } });
+//# sourceMappingURL=index.js.map
+});
+
+const STAGE_SERVER_IDENTIFIER = "stage";
+const getTrackingServerByApiPath = (apiPath) => isProductionPath(apiPath) ? dist.servers[0] : dist.servers[1];
+const isProductionPath = (apiPath) => !apiPath.includes(STAGE_SERVER_IDENTIFIER);
+// TODO find way to utilize this function when we will use several openApi clients
+const createBearerAuth = (token) => {
+  const provider = {
+    getToken: () => {
+      return new Promise((resolve) => resolve(token));
+    },
+  };
+  const bearerConf = {
+    tokenProvider: provider,
+  };
+  return {
+    bearerAuth: bearerConf,
+  };
+};
+const createTrackingApi = (apiPath, token) => {
+  const baseServer = getTrackingServerByApiPath(apiPath);
+  const authMethods = createBearerAuth(token);
+  const configuration = {
+    baseServer,
+    authMethods,
+  };
+  return new dist.DefaultApi(dist.createConfiguration(configuration));
+};
+
+const createTrackingEvent = (widget) => (eventData) => {
+  return Object.assign(Object.assign({}, eventData), widget);
+};
+
+const PRODUCT_VIEW_EVENT_TYPE = "product_view_event";
+const FILTER_EVENT_EVENT_TYPE = "filter_event";
+const SEARCH_EVENT_EVENT_TYPE = "search_event";
+const WIDGET_EVENT_EVENT_TYPE = "widget_event";
+
+const filterEvent = {
+  widget: "VPS",
+  typ: FILTER_EVENT_EVENT_TYPE,
+};
+
+const vprProductView = {
+  widget: "VPR",
+  typ: PRODUCT_VIEW_EVENT_TYPE,
+};
+const vpsProductView = {
+  widget: "VPS",
+  typ: PRODUCT_VIEW_EVENT_TYPE,
+};
+
+const searchEvent = {
+  widget: "VPS",
+  typ: SEARCH_EVENT_EVENT_TYPE,
+};
+
+const vprWidget = {
+  widget: "VPR",
+  typ: WIDGET_EVENT_EVENT_TYPE,
+};
+const vpsWidget = {
+  widget: "VPS",
+  typ: WIDGET_EVENT_EVENT_TYPE,
+};
+
+const createProductViewVprEvent = createTrackingEvent(vprProductView);
+const createProductViewVpsEvent = createTrackingEvent(vpsProductView);
+const createWidgetVprEvent = createTrackingEvent(vprWidget);
+const createWidgetVpsEvent = createTrackingEvent(vpsWidget);
+const createSearchEvent = createTrackingEvent(searchEvent);
+const createFilterEvent = createTrackingEvent(filterEvent);
+
+exports.createFilterEvent = createFilterEvent;
+exports.createProductViewVprEvent = createProductViewVprEvent;
+exports.createProductViewVpsEvent = createProductViewVpsEvent;
+exports.createSearchEvent = createSearchEvent;
+exports.createTrackingApi = createTrackingApi;
+exports.createWidgetVprEvent = createWidgetVprEvent;
+exports.createWidgetVpsEvent = createWidgetVpsEvent;
+exports.v4 = v4;