@faststore/core 3.0.20 → 3.0.21

package/.next/server/chunks/57.js

@@ -1 +1,434 @@
-"use strict";exports.id=57,exports.ids=[57],exports.modules={3057:e=>{var t,r=function(){function DataLoader(e,t){if("function"!=typeof e)throw TypeError("DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but got: "+e+".");this._batchLoadFn=e,this._maxBatchSize=function(e){if(!(!e||!1!==e.batch))return 1;var t=e&&e.maxBatchSize;if(void 0===t)return 1/0;if("number"!=typeof t||t<1)throw TypeError("maxBatchSize must be a positive number: "+t);return t}(t),this._batchScheduleFn=function(e){var t=e&&e.batchScheduleFn;if(void 0===t)return n;if("function"!=typeof t)throw TypeError("batchScheduleFn must be a function: "+t);return t}(t),this._cacheKeyFn=function(e){var t=e&&e.cacheKeyFn;if(void 0===t)return function(e){return e};if("function"!=typeof t)throw TypeError("cacheKeyFn must be a function: "+t);return t}(t),this._cacheMap=function(e){if(!(!e||!1!==e.cache))return null;var t=e&&e.cacheMap;if(void 0===t)return new Map;if(null!==t){var r=["get","set","delete","clear"].filter(function(e){return t&&"function"!=typeof t[e]});if(0!==r.length)throw TypeError("Custom cacheMap missing methods: "+r.join(", "))}return t}(t),this._batch=null}var e=DataLoader.prototype;return e.load=function(e){if(null==e)throw TypeError("The loader.load() function must be called with a value, but got: "+String(e)+".");var t=function(e){var t=e._batch;if(null!==t&&!t.hasDispatched&&t.keys.length<e._maxBatchSize&&(!t.cacheHits||t.cacheHits.length<e._maxBatchSize))return t;var r={hasDispatched:!1,keys:[],callbacks:[]};return e._batch=r,e._batchScheduleFn(function(){(function(e,t){if(t.hasDispatched=!0,0===t.keys.length){resolveCacheHits(t);return}var r=e._batchLoadFn(t.keys);if(!r||"function"!=typeof r.then)return failedDispatch(e,t,TypeError("DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise: "+String(r)+"."));r.then(function(e){if(!isArrayLike(e))throw TypeError("DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise of an Array: "+String(e)+".");if(e.length!==t.keys.length)throw TypeError("DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise of an Array of the same length as the Array of keys.\n\nKeys:\n"+String(t.keys)+"\n\nValues:\n"+String(e));resolveCacheHits(t);for(var r=0;r<t.callbacks.length;r++){var n=e[r];n instanceof Error?t.callbacks[r].reject(n):t.callbacks[r].resolve(n)}}).catch(function(r){failedDispatch(e,t,r)})})(e,r)}),r}(this),r=this._cacheMap,n=this._cacheKeyFn(e);if(r){var a=r.get(n);if(a){var c=t.cacheHits||(t.cacheHits=[]);return new Promise(function(e){c.push(function(){e(a)})})}}t.keys.push(e);var i=new Promise(function(e,r){t.callbacks.push({resolve:e,reject:r})});return r&&r.set(n,i),i},e.loadMany=function(e){if(!isArrayLike(e))throw TypeError("The loader.loadMany() function must be called with Array<key> but got: "+e+".");for(var t=[],r=0;r<e.length;r++)t.push(this.load(e[r]).catch(function(e){return e}));return Promise.all(t)},e.clear=function(e){var t=this._cacheMap;if(t){var r=this._cacheKeyFn(e);t.delete(r)}return this},e.clearAll=function(){var e=this._cacheMap;return e&&e.clear(),this},e.prime=function(e,t){var r=this._cacheMap;if(r){var n,a=this._cacheKeyFn(e);void 0===r.get(a)&&(t instanceof Error?(n=Promise.reject(t)).catch(function(){}):n=Promise.resolve(t),r.set(a,n))}return this},DataLoader}(),n="object"==typeof process&&"function"==typeof process.nextTick?function(e){t||(t=Promise.resolve()),t.then(function(){process.nextTick(e)})}:"function"==typeof setImmediate?function(e){setImmediate(e)}:function(e){setTimeout(e)};function failedDispatch(e,t,r){resolveCacheHits(t);for(var n=0;n<t.keys.length;n++)e.clear(t.keys[n]),t.callbacks[n].reject(r)}function resolveCacheHits(e){if(e.cacheHits)for(var t=0;t<e.cacheHits.length;t++)e.cacheHits[t]()}function isArrayLike(e){return"object"==typeof e&&null!==e&&"number"==typeof e.length&&(0===e.length||e.length>0&&Object.prototype.hasOwnProperty.call(e,e.length-1))}e.exports=r}};
+"use strict";
+exports.id = 57;
+exports.ids = [57];
+exports.modules = {
+
+/***/ 3057:
+/***/ ((module) => {
+
+
+
+/**
+ * Copyright (c) 2019-present, GraphQL Foundation
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+// A Function, which when given an Array of keys, returns a Promise of an Array
+// of values or Errors.
+// Optionally turn off batching or caching or provide a cache key function or a
+// custom cache instance.
+// If a custom cache is provided, it must be of this type (a subset of ES6 Map).
+
+/**
+ * A `DataLoader` creates a public API for loading data from a particular
+ * data back-end with unique keys such as the `id` column of a SQL table or
+ * document name in a MongoDB database, given a batch loading function.
+ *
+ * Each `DataLoader` instance contains a unique memoized cache. Use caution when
+ * used in long-lived applications or those which serve many users with
+ * different access permissions and consider creating a new instance per
+ * web request.
+ */
+var DataLoader =
+/*#__PURE__*/
+function () {
+  function DataLoader(batchLoadFn, options) {
+    if (typeof batchLoadFn !== 'function') {
+      throw new TypeError('DataLoader must be constructed with a function which accepts ' + ("Array<key> and returns Promise<Array<value>>, but got: " + batchLoadFn + "."));
+    }
+
+    this._batchLoadFn = batchLoadFn;
+    this._maxBatchSize = getValidMaxBatchSize(options);
+    this._batchScheduleFn = getValidBatchScheduleFn(options);
+    this._cacheKeyFn = getValidCacheKeyFn(options);
+    this._cacheMap = getValidCacheMap(options);
+    this._batch = null;
+  } // Private
+
+
+  var _proto = DataLoader.prototype;
+
+  /**
+   * Loads a key, returning a `Promise` for the value represented by that key.
+   */
+  _proto.load = function load(key) {
+    if (key === null || key === undefined) {
+      throw new TypeError('The loader.load() function must be called with a value, ' + ("but got: " + String(key) + "."));
+    }
+
+    var batch = getCurrentBatch(this);
+    var cacheMap = this._cacheMap;
+
+    var cacheKey = this._cacheKeyFn(key); // If caching and there is a cache-hit, return cached Promise.
+
+
+    if (cacheMap) {
+      var cachedPromise = cacheMap.get(cacheKey);
+
+      if (cachedPromise) {
+        var cacheHits = batch.cacheHits || (batch.cacheHits = []);
+        return new Promise(function (resolve) {
+          cacheHits.push(function () {
+            resolve(cachedPromise);
+          });
+        });
+      }
+    } // Otherwise, produce a new Promise for this key, and enqueue it to be
+    // dispatched along with the current batch.
+
+
+    batch.keys.push(key);
+    var promise = new Promise(function (resolve, reject) {
+      batch.callbacks.push({
+        resolve: resolve,
+        reject: reject
+      });
+    }); // If caching, cache this promise.
+
+    if (cacheMap) {
+      cacheMap.set(cacheKey, promise);
+    }
+
+    return promise;
+  }
+  /**
+   * Loads multiple keys, promising an array of values:
+   *
+   *     var [ a, b ] = await myLoader.loadMany([ 'a', 'b' ]);
+   *
+   * This is similar to the more verbose:
+   *
+   *     var [ a, b ] = await Promise.all([
+   *       myLoader.load('a'),
+   *       myLoader.load('b')
+   *     ]);
+   *
+   * However it is different in the case where any load fails. Where
+   * Promise.all() would reject, loadMany() always resolves, however each result
+   * is either a value or an Error instance.
+   *
+   *     var [ a, b, c ] = await myLoader.loadMany([ 'a', 'b', 'badkey' ]);
+   *     // c instanceof Error
+   *
+   */
+  ;
+
+  _proto.loadMany = function loadMany(keys) {
+    if (!isArrayLike(keys)) {
+      throw new TypeError('The loader.loadMany() function must be called with Array<key> ' + ("but got: " + keys + "."));
+    } // Support ArrayLike by using only minimal property access
+
+
+    var loadPromises = [];
+
+    for (var i = 0; i < keys.length; i++) {
+      loadPromises.push(this.load(keys[i])["catch"](function (error) {
+        return error;
+      }));
+    }
+
+    return Promise.all(loadPromises);
+  }
+  /**
+   * Clears the value at `key` from the cache, if it exists. Returns itself for
+   * method chaining.
+   */
+  ;
+
+  _proto.clear = function clear(key) {
+    var cacheMap = this._cacheMap;
+
+    if (cacheMap) {
+      var cacheKey = this._cacheKeyFn(key);
+
+      cacheMap["delete"](cacheKey);
+    }
+
+    return this;
+  }
+  /**
+   * Clears the entire cache. To be used when some event results in unknown
+   * invalidations across this particular `DataLoader`. Returns itself for
+   * method chaining.
+   */
+  ;
+
+  _proto.clearAll = function clearAll() {
+    var cacheMap = this._cacheMap;
+
+    if (cacheMap) {
+      cacheMap.clear();
+    }
+
+    return this;
+  }
+  /**
+   * Adds the provided key and value to the cache. If the key already
+   * exists, no change is made. Returns itself for method chaining.
+   *
+   * To prime the cache with an error at a key, provide an Error instance.
+   */
+  ;
+
+  _proto.prime = function prime(key, value) {
+    var cacheMap = this._cacheMap;
+
+    if (cacheMap) {
+      var cacheKey = this._cacheKeyFn(key); // Only add the key if it does not already exist.
+
+
+      if (cacheMap.get(cacheKey) === undefined) {
+        // Cache a rejected promise if the value is an Error, in order to match
+        // the behavior of load(key).
+        var promise;
+
+        if (value instanceof Error) {
+          promise = Promise.reject(value); // Since this is a case where an Error is intentionally being primed
+          // for a given key, we want to disable unhandled promise rejection.
+
+          promise["catch"](function () {});
+        } else {
+          promise = Promise.resolve(value);
+        }
+
+        cacheMap.set(cacheKey, promise);
+      }
+    }
+
+    return this;
+  };
+
+  return DataLoader;
+}(); // Private: Enqueue a Job to be executed after all "PromiseJobs" Jobs.
+//
+// ES6 JavaScript uses the concepts Job and JobQueue to schedule work to occur
+// after the current execution context has completed:
+// http://www.ecma-international.org/ecma-262/6.0/#sec-jobs-and-job-queues
+//
+// Node.js uses the `process.nextTick` mechanism to implement the concept of a
+// Job, maintaining a global FIFO JobQueue for all Jobs, which is flushed after
+// the current call stack ends.
+//
+// When calling `then` on a Promise, it enqueues a Job on a specific
+// "PromiseJobs" JobQueue which is flushed in Node as a single Job on the
+// global JobQueue.
+//
+// DataLoader batches all loads which occur in a single frame of execution, but
+// should include in the batch all loads which occur during the flushing of the
+// "PromiseJobs" JobQueue after that same execution frame.
+//
+// In order to avoid the DataLoader dispatch Job occuring before "PromiseJobs",
+// A Promise Job is created with the sole purpose of enqueuing a global Job,
+// ensuring that it always occurs after "PromiseJobs" ends.
+//
+// Node.js's job queue is unique. Browsers do not have an equivalent mechanism
+// for enqueuing a job to be performed after promise microtasks and before the
+// next macrotask. For browser environments, a macrotask is used (via
+// setImmediate or setTimeout) at a potential performance penalty.
+
+
+var enqueuePostPromiseJob = typeof process === 'object' && typeof process.nextTick === 'function' ? function (fn) {
+  if (!resolvedPromise) {
+    resolvedPromise = Promise.resolve();
+  }
+
+  resolvedPromise.then(function () {
+    process.nextTick(fn);
+  });
+} : typeof setImmediate === 'function' ? function (fn) {
+  setImmediate(fn);
+} : function (fn) {
+  setTimeout(fn);
+}; // Private: cached resolved Promise instance
+
+var resolvedPromise; // Private: Describes a batch of requests
+
+// Private: Either returns the current batch, or creates and schedules a
+// dispatch of a new batch for the given loader.
+function getCurrentBatch(loader) {
+  // If there is an existing batch which has not yet dispatched and is within
+  // the limit of the batch size, then return it.
+  var existingBatch = loader._batch;
+
+  if (existingBatch !== null && !existingBatch.hasDispatched && existingBatch.keys.length < loader._maxBatchSize && (!existingBatch.cacheHits || existingBatch.cacheHits.length < loader._maxBatchSize)) {
+    return existingBatch;
+  } // Otherwise, create a new batch for this loader.
+
+
+  var newBatch = {
+    hasDispatched: false,
+    keys: [],
+    callbacks: []
+  }; // Store it on the loader so it may be reused.
+
+  loader._batch = newBatch; // Then schedule a task to dispatch this batch of requests.
+
+  loader._batchScheduleFn(function () {
+    dispatchBatch(loader, newBatch);
+  });
+
+  return newBatch;
+}
+
+function dispatchBatch(loader, batch) {
+  // Mark this batch as having been dispatched.
+  batch.hasDispatched = true; // If there's nothing to load, resolve any cache hits and return early.
+
+  if (batch.keys.length === 0) {
+    resolveCacheHits(batch);
+    return;
+  } // Call the provided batchLoadFn for this loader with the batch's keys and
+  // with the loader as the `this` context.
+
+
+  var batchPromise = loader._batchLoadFn(batch.keys); // Assert the expected response from batchLoadFn
+
+
+  if (!batchPromise || typeof batchPromise.then !== 'function') {
+    return failedDispatch(loader, batch, new TypeError('DataLoader must be constructed with a function which accepts ' + 'Array<key> and returns Promise<Array<value>>, but the function did ' + ("not return a Promise: " + String(batchPromise) + ".")));
+  } // Await the resolution of the call to batchLoadFn.
+
+
+  batchPromise.then(function (values) {
+    // Assert the expected resolution from batchLoadFn.
+    if (!isArrayLike(values)) {
+      throw new TypeError('DataLoader must be constructed with a function which accepts ' + 'Array<key> and returns Promise<Array<value>>, but the function did ' + ("not return a Promise of an Array: " + String(values) + "."));
+    }
+
+    if (values.length !== batch.keys.length) {
+      throw new TypeError('DataLoader must be constructed with a function which accepts ' + 'Array<key> and returns Promise<Array<value>>, but the function did ' + 'not return a Promise of an Array of the same length as the Array ' + 'of keys.' + ("\n\nKeys:\n" + String(batch.keys)) + ("\n\nValues:\n" + String(values)));
+    } // Resolve all cache hits in the same micro-task as freshly loaded values.
+
+
+    resolveCacheHits(batch); // Step through values, resolving or rejecting each Promise in the batch.
+
+    for (var i = 0; i < batch.callbacks.length; i++) {
+      var value = values[i];
+
+      if (value instanceof Error) {
+        batch.callbacks[i].reject(value);
+      } else {
+        batch.callbacks[i].resolve(value);
+      }
+    }
+  })["catch"](function (error) {
+    failedDispatch(loader, batch, error);
+  });
+} // Private: do not cache individual loads if the entire batch dispatch fails,
+// but still reject each request so they do not hang.
+
+
+function failedDispatch(loader, batch, error) {
+  // Cache hits are resolved, even though the batch failed.
+  resolveCacheHits(batch);
+
+  for (var i = 0; i < batch.keys.length; i++) {
+    loader.clear(batch.keys[i]);
+    batch.callbacks[i].reject(error);
+  }
+} // Private: Resolves the Promises for any cache hits in this batch.
+
+
+function resolveCacheHits(batch) {
+  if (batch.cacheHits) {
+    for (var i = 0; i < batch.cacheHits.length; i++) {
+      batch.cacheHits[i]();
+    }
+  }
+} // Private: given the DataLoader's options, produce a valid max batch size.
+
+
+function getValidMaxBatchSize(options) {
+  var shouldBatch = !options || options.batch !== false;
+
+  if (!shouldBatch) {
+    return 1;
+  }
+
+  var maxBatchSize = options && options.maxBatchSize;
+
+  if (maxBatchSize === undefined) {
+    return Infinity;
+  }
+
+  if (typeof maxBatchSize !== 'number' || maxBatchSize < 1) {
+    throw new TypeError("maxBatchSize must be a positive number: " + maxBatchSize);
+  }
+
+  return maxBatchSize;
+} // Private
+
+
+function getValidBatchScheduleFn(options) {
+  var batchScheduleFn = options && options.batchScheduleFn;
+
+  if (batchScheduleFn === undefined) {
+    return enqueuePostPromiseJob;
+  }
+
+  if (typeof batchScheduleFn !== 'function') {
+    throw new TypeError("batchScheduleFn must be a function: " + batchScheduleFn);
+  }
+
+  return batchScheduleFn;
+} // Private: given the DataLoader's options, produce a cache key function.
+
+
+function getValidCacheKeyFn(options) {
+  var cacheKeyFn = options && options.cacheKeyFn;
+
+  if (cacheKeyFn === undefined) {
+    return function (key) {
+      return key;
+    };
+  }
+
+  if (typeof cacheKeyFn !== 'function') {
+    throw new TypeError("cacheKeyFn must be a function: " + cacheKeyFn);
+  }
+
+  return cacheKeyFn;
+} // Private: given the DataLoader's options, produce a CacheMap to be used.
+
+
+function getValidCacheMap(options) {
+  var shouldCache = !options || options.cache !== false;
+
+  if (!shouldCache) {
+    return null;
+  }
+
+  var cacheMap = options && options.cacheMap;
+
+  if (cacheMap === undefined) {
+    return new Map();
+  }
+
+  if (cacheMap !== null) {
+    var cacheFunctions = ['get', 'set', 'delete', 'clear'];
+    var missingFunctions = cacheFunctions.filter(function (fnName) {
+      return cacheMap && typeof cacheMap[fnName] !== 'function';
+    });
+
+    if (missingFunctions.length !== 0) {
+      throw new TypeError('Custom cacheMap missing methods: ' + missingFunctions.join(', '));
+    }
+  }
+
+  return cacheMap;
+} // Private
+
+
+function isArrayLike(x) {
+  return typeof x === 'object' && x !== null && typeof x.length === 'number' && (x.length === 0 || x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1));
+}
+
+module.exports = DataLoader;
+
+/***/ })
+
+};
+;

package/.next/server/chunks/574.js

@@ -0,0 +1,145 @@
+"use strict";
+exports.id = 574;
+exports.ids = [574];
+exports.modules = {
+
+/***/ 3574:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ search)
+});
+
+// EXTERNAL MODULE: ./faststore.config.js
+var faststore_config = __webpack_require__(7183);
+var faststore_config_default = /*#__PURE__*/__webpack_require__.n(faststore_config);
+;// CONCATENATED MODULE: ./src/utils/getCookie.ts
+function getCookie(name) {
+  const cookieString = decodeURIComponent(document.cookie);
+  const cookies = cookieString.split(';');
+
+  for (const cookie of cookies) {
+    const [cookieName, cookieValue] = cookie.trim().split('=');
+
+    if (cookieName === name) {
+      return cookieValue;
+    }
+  }
+
+  return undefined; // Cookie not found
+}
+;// CONCATENATED MODULE: ./src/sdk/analytics/platform/vtex/search.ts
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * More info at: https://www.notion.so/vtexhandbook/Event-API-Documentation-48eee26730cf4d7f80f8fd7262231f84
+ */
+
+
+const THIRTY_MINUTES_S = 30 * 60;
+const ONE_YEAR_S = 365 * 24 * 3600;
+
+const randomUUID = () => typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : (Math.random() * 1e6).toFixed(0);
+
+const createCookie = (key, expiresSecond) => {
+  // Setting the domain attribute specifies which host can receive it; we need it to make the cookies available on the `secure` subdomain.
+  // Although https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie mentioned leading dot (.) is not needed and ignored. I couldn't set the cookies without it.
+  const urlDomain = `.${new URL((faststore_config_default()).storeUrl).hostname}`;
+  return () => {
+    const isExpired = getCookie(key) === undefined;
+
+    if (isExpired) {
+      const value = randomUUID();
+      document.cookie = `${key}=${value}; max-age=${expiresSecond}; domain=${urlDomain}; path=/;`; // Setting the `path=/` makes the cookie accessible on any path of the domain/subdomain
+
+      return value;
+    }
+
+    return getCookie(key);
+  };
+};
+
+const user = {
+  anonymous: createCookie('vtex-faststore-anonymous', ONE_YEAR_S),
+  session: createCookie('vtex-faststore-session', THIRTY_MINUTES_S)
+};
+
+const sendEvent = options => fetch(`https://sp.vtex.com/event-api/v1/${(faststore_config_default()).api.storeId}/event`, {
+  method: 'POST',
+  body: JSON.stringify(_objectSpread(_objectSpread({}, options), {}, {
+    userAgent: navigator.userAgent,
+    anonymous: user.anonymous(),
+    session: user.session()
+  })),
+  headers: {
+    'content-type': 'application/json'
+  }
+});
+
+const isFullTextSearch = url => typeof url.searchParams.get('q') === 'string' && /^\/s(\/)?$/g.test(url.pathname);
+
+const handleEvent = event => {
+  switch (event.name) {
+    case 'search_select_item':
+      {
+        const url = new URL(event.params.url);
+
+        if (!isFullTextSearch(url)) {
+          return;
+        }
+
+        for (const item of event.params.items ?? []) {
+          const productId = item.item_id ?? item.item_variant;
+          const position = item.index;
+
+          if (productId && position) {
+            sendEvent({
+              type: 'search.click',
+              productId,
+              position,
+              url: url.href,
+              text: url.searchParams.get('q') ?? '<empty>'
+            });
+          }
+        }
+
+        break;
+      }
+
+    case 'intelligent_search_query':
+      {
+        sendEvent({
+          type: 'search.query',
+          url: event.params.url,
+          text: event.params.term,
+          misspelled: event.params.isTermMisspelled,
+          match: event.params.totalCount,
+          operator: event.params.logicalOperator,
+          locale: event.params.locale
+        });
+        break;
+      }
+
+    default:
+  }
+};
+
+setInterval(() => sendEvent({
+  type: 'session.ping'
+}), 60 * 1e3
+/* One minute */
+);
+/* harmony default export */ const search = (handleEvent);
+
+/***/ })
+
+};
+;