@appbaseio/reactivesearch-vue 3.0.0-rc.4 → 3.0.0-rc.5.alpha.2

package/dist/es/initReactivesearch.js

@@ -1,6 +1,2294 @@
-import { createSSRApp } from 'vue';
-import { renderToString } from 'vue/server-renderer';
-import { getServerResults } from '@appbaseio/reactivecore/lib/utils/server';
+import { e as _asyncToGenerator, f as _regeneratorRuntime, g as _createForOfIteratorHelperLoose, _ as _extends } from './_rollupPluginBabelHelpers-dac426db.js';
+import { ssrUtils, initDirectivesForSSR, createVNode, ssrContextKey, createApp, warn, Fragment, Static, Comment, Text, mergeProps, createSSRApp } from 'vue';
+
+var _PatchFlagNames, _slotFlagsText;
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ * IMPORTANT: all calls of this function must be prefixed with
+ * \/\*#\_\_PURE\_\_\*\/
+ * So that rollup can tree-shake them if necessary.
+ */
+function makeMap(str, expectsLowerCase) {
+  var map = Object.create(null);
+  var list = str.split(',');
+  for (var i = 0; i < list.length; i++) {
+    map[list[i]] = true;
+  }
+  return expectsLowerCase ? function (val) {
+    return !!map[val.toLowerCase()];
+  } : function (val) {
+    return !!map[val];
+  };
+}
+
+/**
+ * dev only flag -> name mapping
+ */
+var PatchFlagNames = (_PatchFlagNames = {}, _PatchFlagNames[1 /* PatchFlags.TEXT */] = "TEXT", _PatchFlagNames[2 /* PatchFlags.CLASS */] = "CLASS", _PatchFlagNames[4 /* PatchFlags.STYLE */] = "STYLE", _PatchFlagNames[8 /* PatchFlags.PROPS */] = "PROPS", _PatchFlagNames[16 /* PatchFlags.FULL_PROPS */] = "FULL_PROPS", _PatchFlagNames[32 /* PatchFlags.HYDRATE_EVENTS */] = "HYDRATE_EVENTS", _PatchFlagNames[64 /* PatchFlags.STABLE_FRAGMENT */] = "STABLE_FRAGMENT", _PatchFlagNames[128 /* PatchFlags.KEYED_FRAGMENT */] = "KEYED_FRAGMENT", _PatchFlagNames[256 /* PatchFlags.UNKEYED_FRAGMENT */] = "UNKEYED_FRAGMENT", _PatchFlagNames[512 /* PatchFlags.NEED_PATCH */] = "NEED_PATCH", _PatchFlagNames[1024 /* PatchFlags.DYNAMIC_SLOTS */] = "DYNAMIC_SLOTS", _PatchFlagNames[2048 /* PatchFlags.DEV_ROOT_FRAGMENT */] = "DEV_ROOT_FRAGMENT", _PatchFlagNames[-1 /* PatchFlags.HOISTED */] = "HOISTED", _PatchFlagNames[-2 /* PatchFlags.BAIL */] = "BAIL", _PatchFlagNames);
+
+/**
+ * Dev only
+ */
+var slotFlagsText = (_slotFlagsText = {}, _slotFlagsText[1 /* SlotFlags.STABLE */] = 'STABLE', _slotFlagsText[2 /* SlotFlags.DYNAMIC */] = 'DYNAMIC', _slotFlagsText[3 /* SlotFlags.FORWARDED */] = 'FORWARDED', _slotFlagsText);
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    var res = {};
+    for (var i = 0; i < value.length; i++) {
+      var item = value[i];
+      var normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (var key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value)) {
+    return value;
+  } else if (isObject(value)) {
+    return value;
+  }
+}
+var listDelimiterRE = /;(?![^(]*\))/g;
+var propertyDelimiterRE = /:([^]+)/;
+var styleCommentRE = /\/\*[\s\S]*?\*\//g;
+function parseStringStyle(cssText) {
+  var ret = {};
+  cssText.replace(styleCommentRE, '').split(listDelimiterRE).forEach(function (item) {
+    if (item) {
+      var tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  var ret = '';
+  if (!styles || isString(styles)) {
+    return ret;
+  }
+  for (var key in styles) {
+    var value = styles[key];
+    var normalizedKey = key.startsWith("--") ? key : hyphenate(key);
+    if (isString(value) || typeof value === 'number') {
+      // only render valid values
+      ret += normalizedKey + ":" + value + ";";
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  var res = '';
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (var i = 0; i < value.length; i++) {
+      var normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + ' ';
+      }
+    }
+  } else if (isObject(value)) {
+    for (var name in value) {
+      if (value[name]) {
+        res += name + ' ';
+      }
+    }
+  }
+  return res.trim();
+}
+// https://developer.mozilla.org/en-US/docs/Web/SVG/Element
+var SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' + 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' + 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' + 'feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' + 'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' + 'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' + 'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' + 'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' + 'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' + 'text,textPath,title,tspan,unknown,use,view';
+var VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `(process.env.NODE_ENV !== 'production')` flag.
+ */
+var isSVGTag = /*#__PURE__*/makeMap(SVG_TAGS);
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `(process.env.NODE_ENV !== 'production')` flag.
+ */
+var isVoidTag = /*#__PURE__*/makeMap(VOID_TAGS);
+
+/**
+ * On the client we only need to offer special cases for boolean attributes that
+ * have different names from their corresponding dom properties:
+ * - itemscope -> N/A
+ * - allowfullscreen -> allowFullscreen
+ * - formnovalidate -> formNoValidate
+ * - ismap -> isMap
+ * - nomodule -> noModule
+ * - novalidate -> noValidate
+ * - readonly -> readOnly
+ */
+var specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly";
+/**
+ * The full list is needed during SSR to produce the correct initial markup.
+ */
+var isBooleanAttr = /*#__PURE__*/makeMap(specialBooleanAttrs + ",async,autofocus,autoplay,controls,default,defer,disabled,hidden," + "loop,open,required,reversed,scoped,seamless," + "checked,muted,multiple,selected");
+/**
+ * Boolean attributes should be included if the value is truthy or ''.
+ * e.g. `<select multiple>` compiles to `{ multiple: '' }`
+ */
+function includeBooleanAttr(value) {
+  return !!value || value === '';
+}
+var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
+var attrValidationCache = {};
+function isSSRSafeAttrName(name) {
+  if (attrValidationCache.hasOwnProperty(name)) {
+    return attrValidationCache[name];
+  }
+  var isUnsafe = unsafeAttrCharRE.test(name);
+  if (isUnsafe) {
+    console.error("unsafe attribute name: " + name);
+  }
+  return attrValidationCache[name] = !isUnsafe;
+}
+var propsToAttrMap = {
+  acceptCharset: 'accept-charset',
+  className: 'class',
+  htmlFor: 'for',
+  httpEquiv: 'http-equiv'
+};
+var escapeRE = /["'&<>]/;
+function escapeHtml(string) {
+  var str = '' + string;
+  var match = escapeRE.exec(str);
+  if (!match) {
+    return str;
+  }
+  var html = '';
+  var escaped;
+  var index;
+  var lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        // "
+        escaped = '&quot;';
+        break;
+      case 38:
+        // &
+        escaped = '&amp;';
+        break;
+      case 39:
+        // '
+        escaped = '&#39;';
+        break;
+      case 60:
+        // <
+        escaped = '&lt;';
+        break;
+      case 62:
+        // >
+        escaped = '&gt;';
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.slice(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escaped;
+  }
+  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+}
+// https://www.w3.org/TR/html52/syntax.html#comments
+var commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
+function escapeHtmlComment(src) {
+  return src.replace(commentStripRE, '');
+}
+var EMPTY_OBJ = process.env.NODE_ENV !== 'production' ? Object.freeze({}) : {};
+var EMPTY_ARR = process.env.NODE_ENV !== 'production' ? Object.freeze([]) : [];
+var NOOP = function NOOP() {};
+var onRE = /^on[^a-z]/;
+var isOn = function isOn(key) {
+  return onRE.test(key);
+};
+var isArray = Array.isArray;
+var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};
+var isString = function isString(val) {
+  return typeof val === 'string';
+};
+var isObject = function isObject(val) {
+  return val !== null && typeof val === 'object';
+};
+var isPromise = function isPromise(val) {
+  return isObject(val) && isFunction(val.then) && isFunction(val["catch"]);
+};
+var cacheStringFunction = function cacheStringFunction(fn) {
+  var cache = Object.create(null);
+  return function (str) {
+    var hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+var hyphenateRE = /\B([A-Z])/g;
+/**
+ * @private
+ */
+var hyphenate = cacheStringFunction(function (str) {
+  return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+
+var _ErrorTypeStrings;
+
+// leading comma for empty string ""
+var shouldIgnoreProp = makeMap(",key,ref,innerHTML,textContent,ref_key,ref_for");
+function ssrRenderAttrs(props, tag) {
+  var ret = '';
+  for (var key in props) {
+    if (shouldIgnoreProp(key) || isOn(key) || tag === 'textarea' && key === 'value') {
+      continue;
+    }
+    var value = props[key];
+    if (key === 'class') {
+      ret += " class=\"" + ssrRenderClass(value) + "\"";
+    } else if (key === 'style') {
+      ret += " style=\"" + ssrRenderStyle(value) + "\"";
+    } else {
+      ret += ssrRenderDynamicAttr(key, value, tag);
+    }
+  }
+  return ret;
+}
+// render an attr with dynamic (unknown) key.
+function ssrRenderDynamicAttr(key, value, tag) {
+  if (!isRenderableValue(value)) {
+    return "";
+  }
+  var attrKey = tag && (tag.indexOf('-') > 0 || isSVGTag(tag)) ? key // preserve raw name on custom elements and svg
+  : propsToAttrMap[key] || key.toLowerCase();
+  if (isBooleanAttr(attrKey)) {
+    return includeBooleanAttr(value) ? " " + attrKey : "";
+  } else if (isSSRSafeAttrName(attrKey)) {
+    return value === '' ? " " + attrKey : " " + attrKey + "=\"" + escapeHtml(value) + "\"";
+  } else {
+    console.warn("[@vue/server-renderer] Skipped rendering unsafe attribute name: " + attrKey);
+    return "";
+  }
+}
+function isRenderableValue(value) {
+  if (value == null) {
+    return false;
+  }
+  var type = typeof value;
+  return type === 'string' || type === 'number' || type === 'boolean';
+}
+function ssrRenderClass(raw) {
+  return escapeHtml(normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+  if (!raw) {
+    return '';
+  }
+  if (isString(raw)) {
+    return escapeHtml(raw);
+  }
+  var styles = normalizeStyle(raw);
+  return escapeHtml(stringifyStyle(styles));
+}
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+  parentPush('<!--teleport start-->');
+  var context = parentComponent.appContext.provides[ssrContextKey];
+  var teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+  var targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+  // record current index of the target buffer to handle nested teleports
+  // since the parent needs to be rendered before the child
+  var bufferIndex = targetBuffer.length;
+  var teleportContent;
+  if (disabled) {
+    contentRenderFn(parentPush);
+    teleportContent = "<!--teleport anchor-->";
+  } else {
+    var _createBuffer = createBuffer(),
+      getBuffer = _createBuffer.getBuffer,
+      push = _createBuffer.push;
+    contentRenderFn(push);
+    push("<!--teleport anchor-->");
+    teleportContent = getBuffer();
+  }
+  targetBuffer.splice(bufferIndex, 0, teleportContent);
+  parentPush('<!--teleport end-->');
+}
+Symbol(process.env.NODE_ENV !== 'production' ? 'iterate' : '');
+Symbol(process.env.NODE_ENV !== 'production' ? 'Map key iterate' : '');
+var ErrorTypeStrings = (_ErrorTypeStrings = {}, _ErrorTypeStrings["sp" /* LifecycleHooks.SERVER_PREFETCH */] = 'serverPrefetch hook', _ErrorTypeStrings["bc" /* LifecycleHooks.BEFORE_CREATE */] = 'beforeCreate hook', _ErrorTypeStrings["c" /* LifecycleHooks.CREATED */] = 'created hook', _ErrorTypeStrings["bm" /* LifecycleHooks.BEFORE_MOUNT */] = 'beforeMount hook', _ErrorTypeStrings["m" /* LifecycleHooks.MOUNTED */] = 'mounted hook', _ErrorTypeStrings["bu" /* LifecycleHooks.BEFORE_UPDATE */] = 'beforeUpdate hook', _ErrorTypeStrings["u" /* LifecycleHooks.UPDATED */] = 'updated', _ErrorTypeStrings["bum" /* LifecycleHooks.BEFORE_UNMOUNT */] = 'beforeUnmount hook', _ErrorTypeStrings["um" /* LifecycleHooks.UNMOUNTED */] = 'unmounted hook', _ErrorTypeStrings["a" /* LifecycleHooks.ACTIVATED */] = 'activated hook', _ErrorTypeStrings["da" /* LifecycleHooks.DEACTIVATED */] = 'deactivated hook', _ErrorTypeStrings["ec" /* LifecycleHooks.ERROR_CAPTURED */] = 'errorCaptured hook', _ErrorTypeStrings["rtc" /* LifecycleHooks.RENDER_TRACKED */] = 'renderTracked hook', _ErrorTypeStrings["rtg" /* LifecycleHooks.RENDER_TRIGGERED */] = 'renderTriggered hook', _ErrorTypeStrings[0 /* ErrorCodes.SETUP_FUNCTION */] = 'setup function', _ErrorTypeStrings[1 /* ErrorCodes.RENDER_FUNCTION */] = 'render function', _ErrorTypeStrings[2 /* ErrorCodes.WATCH_GETTER */] = 'watcher getter', _ErrorTypeStrings[3 /* ErrorCodes.WATCH_CALLBACK */] = 'watcher callback', _ErrorTypeStrings[4 /* ErrorCodes.WATCH_CLEANUP */] = 'watcher cleanup function', _ErrorTypeStrings[5 /* ErrorCodes.NATIVE_EVENT_HANDLER */] = 'native event handler', _ErrorTypeStrings[6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */] = 'component event handler', _ErrorTypeStrings[7 /* ErrorCodes.VNODE_HOOK */] = 'vnode hook', _ErrorTypeStrings[8 /* ErrorCodes.DIRECTIVE_HOOK */] = 'directive hook', _ErrorTypeStrings[9 /* ErrorCodes.TRANSITION_HOOK */] = 'transition hook', _ErrorTypeStrings[10 /* ErrorCodes.APP_ERROR_HANDLER */] = 'app errorHandler', _ErrorTypeStrings[11 /* ErrorCodes.APP_WARN_HANDLER */] = 'app warnHandler', _ErrorTypeStrings[12 /* ErrorCodes.FUNCTION_REF */] = 'ref function', _ErrorTypeStrings[13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */] = 'async component loader', _ErrorTypeStrings[14 /* ErrorCodes.SCHEDULER */] = 'scheduler flush. This is likely a Vue internals bug. ' + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core', _ErrorTypeStrings);
+function ssrCompile(template, instance) {
+  // TODO: this branch should now work in ESM builds, enable it in a minor
+  {
+    throw new Error("On-the-fly template compilation is not supported in the ESM build of " + "@vue/server-renderer. All templates must be pre-compiled into " + "render functions.");
+  }
+}
+var createComponentInstance = ssrUtils.createComponentInstance,
+  setCurrentRenderingInstance = ssrUtils.setCurrentRenderingInstance,
+  setupComponent = ssrUtils.setupComponent,
+  renderComponentRoot = ssrUtils.renderComponentRoot,
+  normalizeVNode = ssrUtils.normalizeVNode;
+// Each component has a buffer array.
+// A buffer array can contain one of the following:
+// - plain string
+// - A resolved buffer (recursive arrays of strings that can be unrolled
+//   synchronously)
+// - An async buffer (a Promise that resolves to a resolved buffer)
+function createBuffer() {
+  var appendable = false;
+  var buffer = [];
+  return {
+    getBuffer: function getBuffer() {
+      // Return static buffer and await on items during unroll stage
+      return buffer;
+    },
+    push: function push(item) {
+      var isStringItem = isString(item);
+      if (appendable && isStringItem) {
+        buffer[buffer.length - 1] += item;
+      } else {
+        buffer.push(item);
+      }
+      appendable = isStringItem;
+      if (isPromise(item) || isArray(item) && item.hasAsync) {
+        // promise, or child buffer with async, mark as async.
+        // this allows skipping unnecessary await ticks during unroll stage
+        buffer.hasAsync = true;
+      }
+    }
+  };
+}
+function renderComponentVNode(vnode, parentComponent, slotScopeId) {
+  if (parentComponent === void 0) {
+    parentComponent = null;
+  }
+  var instance = createComponentInstance(vnode, parentComponent, null);
+  var res = setupComponent(instance, true /* isSSR */);
+  var hasAsyncSetup = isPromise(res);
+  var prefetches = instance.sp; /* LifecycleHooks.SERVER_PREFETCH */
+  if (hasAsyncSetup || prefetches) {
+    var p = hasAsyncSetup ? res : Promise.resolve();
+    if (prefetches) {
+      p = p.then(function () {
+        return Promise.all(prefetches.map(function (prefetch) {
+          return prefetch.call(instance.proxy);
+        }));
+      })
+      // Note: error display is already done by the wrapped lifecycle hook function.
+      ["catch"](function () {});
+    }
+    return p.then(function () {
+      return renderComponentSubTree(instance, slotScopeId);
+    });
+  } else {
+    return renderComponentSubTree(instance, slotScopeId);
+  }
+}
+function renderComponentSubTree(instance, slotScopeId) {
+  var comp = instance.type;
+  var _createBuffer2 = createBuffer(),
+    getBuffer = _createBuffer2.getBuffer,
+    push = _createBuffer2.push;
+  if (isFunction(comp)) {
+    var root = renderComponentRoot(instance);
+    // #5817 scope ID attrs not falling through if functional component doesn't
+    // have props
+    if (!comp.props) {
+      for (var key in instance.attrs) {
+        if (key.startsWith("data-v-")) {
+          (root.props || (root.props = {}))[key] = "";
+        }
+      }
+    }
+    renderVNode(push, instance.subTree = root, instance, slotScopeId);
+  } else {
+    if ((!instance.render || instance.render === NOOP) && !instance.ssrRender && !comp.ssrRender && isString(comp.template)) {
+      comp.ssrRender = ssrCompile(comp.template);
+    }
+    // perf: enable caching of computed getters during render
+    // since there cannot be state mutations during render.
+    for (var _iterator = _createForOfIteratorHelperLoose(instance.scope.effects), _step; !(_step = _iterator()).done;) {
+      var e = _step.value;
+      if (e.computed) e.computed._cacheable = true;
+    }
+    var ssrRender = instance.ssrRender || comp.ssrRender;
+    if (ssrRender) {
+      // optimized
+      // resolve fallthrough attrs
+      var attrs = instance.inheritAttrs !== false ? instance.attrs : undefined;
+      var hasCloned = false;
+      var cur = instance;
+      while (true) {
+        var scopeId = cur.vnode.scopeId;
+        if (scopeId) {
+          if (!hasCloned) {
+            attrs = _extends({}, attrs);
+            hasCloned = true;
+          }
+          attrs[scopeId] = '';
+        }
+        var parent = cur.parent;
+        if (parent && parent.subTree && parent.subTree === cur.vnode) {
+          // parent is a non-SSR compiled component and is rendering this
+          // component as root. inherit its scopeId if present.
+          cur = parent;
+        } else {
+          break;
+        }
+      }
+      if (slotScopeId) {
+        if (!hasCloned) attrs = _extends({}, attrs);
+        attrs[slotScopeId.trim()] = '';
+      }
+      // set current rendering instance for asset resolution
+      var prev = setCurrentRenderingInstance(instance);
+      try {
+        ssrRender(instance.proxy, push, instance, attrs,
+        // compiler-optimized bindings
+        instance.props, instance.setupState, instance.data, instance.ctx);
+      } finally {
+        setCurrentRenderingInstance(prev);
+      }
+    } else if (instance.render && instance.render !== NOOP) {
+      renderVNode(push, instance.subTree = renderComponentRoot(instance), instance, slotScopeId);
+    } else {
+      var componentName = comp.name || comp.__file || "<Anonymous>";
+      warn("Component " + componentName + " is missing template or render function.");
+      push("<!---->");
+    }
+  }
+  return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent, slotScopeId) {
+  var type = vnode.type,
+    shapeFlag = vnode.shapeFlag,
+    children = vnode.children;
+  switch (type) {
+    case Text:
+      push(escapeHtml(children));
+      break;
+    case Comment:
+      push(children ? "<!--" + escapeHtmlComment(children) + "-->" : "<!---->");
+      break;
+    case Static:
+      push(children);
+      break;
+    case Fragment:
+      if (vnode.slotScopeIds) {
+        slotScopeId = (slotScopeId ? slotScopeId + ' ' : '') + vnode.slotScopeIds.join(' ');
+      }
+      push("<!--[-->"); // open
+      renderVNodeChildren(push, children, parentComponent, slotScopeId);
+      push("<!--]-->"); // close
+      break;
+    default:
+      if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) {
+        renderElementVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
+        push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+      } else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
+        renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
+        renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+      } else {
+        warn('[@vue/server-renderer] Invalid VNode type:', type, "(" + typeof type + ")");
+      }
+  }
+}
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+  for (var i = 0; i < children.length; i++) {
+    renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+  }
+}
+function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+  var tag = vnode.type;
+  var props = vnode.props,
+    children = vnode.children,
+    shapeFlag = vnode.shapeFlag,
+    scopeId = vnode.scopeId,
+    dirs = vnode.dirs;
+  var openTag = "<" + tag;
+  if (dirs) {
+    props = applySSRDirectives(vnode, props, dirs);
+  }
+  if (props) {
+    openTag += ssrRenderAttrs(props, tag);
+  }
+  if (scopeId) {
+    openTag += " " + scopeId;
+  }
+  // inherit parent chain scope id if this is the root node
+  var curParent = parentComponent;
+  var curVnode = vnode;
+  while (curParent && curVnode === curParent.subTree) {
+    curVnode = curParent.vnode;
+    if (curVnode.scopeId) {
+      openTag += " " + curVnode.scopeId;
+    }
+    curParent = curParent.parent;
+  }
+  if (slotScopeId) {
+    openTag += " " + slotScopeId;
+  }
+  push(openTag + ">");
+  if (!isVoidTag(tag)) {
+    var hasChildrenOverride = false;
+    if (props) {
+      if (props.innerHTML) {
+        hasChildrenOverride = true;
+        push(props.innerHTML);
+      } else if (props.textContent) {
+        hasChildrenOverride = true;
+        push(escapeHtml(props.textContent));
+      } else if (tag === 'textarea' && props.value) {
+        hasChildrenOverride = true;
+        push(escapeHtml(props.value));
+      }
+    }
+    if (!hasChildrenOverride) {
+      if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
+        push(escapeHtml(children));
+      } else if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
+        renderVNodeChildren(push, children, parentComponent, slotScopeId);
+      }
+    }
+    push("</" + tag + ">");
+  }
+}
+function applySSRDirectives(vnode, rawProps, dirs) {
+  var toMerge = [];
+  for (var i = 0; i < dirs.length; i++) {
+    var binding = dirs[i];
+    var getSSRProps = binding.dir.getSSRProps;
+    if (getSSRProps) {
+      var props = getSSRProps(binding, vnode);
+      if (props) toMerge.push(props);
+    }
+  }
+  return mergeProps.apply(void 0, [rawProps || {}].concat(toMerge));
+}
+function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+  var target = vnode.props && vnode.props.to;
+  var disabled = vnode.props && vnode.props.disabled;
+  if (!target) {
+    if (!disabled) {
+      warn("[@vue/server-renderer] Teleport is missing target prop.");
+    }
+    return [];
+  }
+  if (!isString(target)) {
+    warn("[@vue/server-renderer] Teleport target must be a query selector string.");
+    return [];
+  }
+  ssrRenderTeleport(push, function (push) {
+    renderVNodeChildren(push, vnode.children, parentComponent, slotScopeId);
+  }, target, disabled || disabled === '', parentComponent);
+}
+var isVNode$1 = ssrUtils.isVNode;
+function unrollBuffer$1(_x3) {
+  return _unrollBuffer$.apply(this, arguments);
+}
+function _unrollBuffer$() {
+  _unrollBuffer$ = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(buffer) {
+    var ret, i, item;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!buffer.hasAsync) {
+            _context3.next = 23;
+            break;
+          }
+          ret = '';
+          i = 0;
+        case 3:
+          if (!(i < buffer.length)) {
+            _context3.next = 20;
+            break;
+          }
+          item = buffer[i];
+          if (!isPromise(item)) {
+            _context3.next = 9;
+            break;
+          }
+          _context3.next = 8;
+          return item;
+        case 8:
+          item = _context3.sent;
+        case 9:
+          if (!isString(item)) {
+            _context3.next = 13;
+            break;
+          }
+          ret += item;
+          _context3.next = 17;
+          break;
+        case 13:
+          _context3.t0 = ret;
+          _context3.next = 16;
+          return unrollBuffer$1(item);
+        case 16:
+          ret = _context3.t0 += _context3.sent;
+        case 17:
+          i++;
+          _context3.next = 3;
+          break;
+        case 20:
+          return _context3.abrupt("return", ret);
+        case 23:
+          return _context3.abrupt("return", unrollBufferSync$1(buffer));
+        case 24:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _unrollBuffer$.apply(this, arguments);
+}
+function unrollBufferSync$1(buffer) {
+  var ret = '';
+  for (var i = 0; i < buffer.length; i++) {
+    var item = buffer[i];
+    if (isString(item)) {
+      ret += item;
+    } else {
+      // since this is a sync buffer, child buffers are never promises
+      ret += unrollBufferSync$1(item);
+    }
+  }
+  return ret;
+}
+function renderToString(_x4, _x5) {
+  return _renderToString.apply(this, arguments);
+}
+function _renderToString() {
+  _renderToString = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(input, context) {
+    var vnode, buffer, result, _iterator3, _step3, unwatch;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          if (context === void 0) {
+            context = {};
+          }
+          if (!isVNode$1(input)) {
+            _context4.next = 3;
+            break;
+          }
+          return _context4.abrupt("return", renderToString(createApp({
+            render: function render() {
+              return input;
+            }
+          }), context));
+        case 3:
+          // rendering an app
+          vnode = createVNode(input._component, input._props);
+          vnode.appContext = input._context;
+          // provide the ssr context to the tree
+          input.provide(ssrContextKey, context);
+          _context4.next = 8;
+          return renderComponentVNode(vnode);
+        case 8:
+          buffer = _context4.sent;
+          _context4.next = 11;
+          return unrollBuffer$1(buffer);
+        case 11:
+          result = _context4.sent;
+          _context4.next = 14;
+          return resolveTeleports(context);
+        case 14:
+          if (context.__watcherHandles) {
+            for (_iterator3 = _createForOfIteratorHelperLoose(context.__watcherHandles); !(_step3 = _iterator3()).done;) {
+              unwatch = _step3.value;
+              unwatch();
+            }
+          }
+          return _context4.abrupt("return", result);
+        case 16:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _renderToString.apply(this, arguments);
+}
+function resolveTeleports(_x6) {
+  return _resolveTeleports.apply(this, arguments);
+}
+function _resolveTeleports() {
+  _resolveTeleports = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(context) {
+    var key;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          if (!context.__teleportBuffers) {
+            _context5.next = 14;
+            break;
+          }
+          context.teleports = context.teleports || {};
+          _context5.t0 = _regeneratorRuntime().keys(context.__teleportBuffers);
+        case 3:
+          if ((_context5.t1 = _context5.t0()).done) {
+            _context5.next = 14;
+            break;
+          }
+          key = _context5.t1.value;
+          _context5.t2 = unrollBuffer$1;
+          _context5.next = 8;
+          return Promise.all([context.__teleportBuffers[key]]);
+        case 8:
+          _context5.t3 = _context5.sent;
+          _context5.next = 11;
+          return (0, _context5.t2)(_context5.t3);
+        case 11:
+          context.teleports[key] = _context5.sent;
+          _context5.next = 3;
+          break;
+        case 14:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _resolveTeleports.apply(this, arguments);
+}
+var isVNode = ssrUtils.isVNode;
+initDirectivesForSSR();
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+function _toPrimitive$1(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey$1(arg) {
+  var key = _toPrimitive$1(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey$1(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var componentTypes = {
+  reactiveList: 'REACTIVELIST',
+  // search components
+  dataSearch: 'DATASEARCH',
+  categorySearch: 'CATEGORYSEARCH',
+  searchBox: 'SEARCHBOX',
+  // list components
+  singleList: 'SINGLELIST',
+  multiList: 'MULTILIST',
+  singleDataList: 'SINGLEDATALIST',
+  tabDataList: 'TABDATALIST',
+  singleDropdownList: 'SINGLEDROPDOWNLIST',
+  multiDataList: 'MULTIDATALIST',
+  multiDropdownList: 'MULTIDROPDOWNLIST',
+  singleDropdownRange: 'SINGLEDROPDOWNRANGE',
+  treeList: 'TREELIST',
+  // basic components
+  numberBox: 'NUMBERBOX',
+  tagCloud: 'TAGCLOUD',
+  toggleButton: 'TOGGLEBUTTON',
+  reactiveComponent: 'REACTIVECOMPONENT',
+  // range components
+  datePicker: 'DATEPICKER',
+  dateRange: 'DATERANGE',
+  dynamicRangeSlider: 'DYNAMICRANGESLIDER',
+  multiDropdownRange: 'MULTIDROPDOWNRANGE',
+  singleRange: 'SINGLERANGE',
+  multiRange: 'MULTIRANGE',
+  rangeSlider: 'RANGESLIDER',
+  ratingsFilter: 'RATINGSFILTER',
+  rangeInput: 'RANGEINPUT',
+  // map components
+  geoDistanceDropdown: 'GEO_DISTANCE_DROPDOWN',
+  geoDistanceSlider: 'GEO_DISTANCE_SLIDER',
+  reactiveMap: 'REACTIVE_MAP',
+  // chart components
+  reactiveChart: 'REACTIVE_CHART'
+};
+var queryTypes = {
+  search: 'search',
+  term: 'term',
+  range: 'range',
+  geo: 'geo',
+  suggestion: 'suggestion'
+};
+var REMOVE_COMPONENT = 'REMOVE_COMPONENT';
+var PATCH_VALUE = 'PATCH_VALUE';
+var CLEAR_VALUES = 'CLEAR_VALUES';
+var SET_VALUE = 'SET_VALUE';
+var SET_VALUES = 'SET_VALUES';
+var RESET_TO_DEFAULT = 'RESET_TO_DEFAULT';
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+var dayjs_min = {
+  exports: {}
+};
+(function (module, exports) {
+  !function (t, e) {
+    module.exports = e();
+  }(commonjsGlobal, function () {
+    var t = 1e3,
+      e = 6e4,
+      n = 36e5,
+      r = "millisecond",
+      i = "second",
+      s = "minute",
+      u = "hour",
+      a = "day",
+      o = "week",
+      f = "month",
+      h = "quarter",
+      c = "year",
+      d = "date",
+      l = "Invalid Date",
+      $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,
+      y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,
+      M = {
+        name: "en",
+        weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+        months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+        ordinal: function ordinal(t) {
+          var e = ["th", "st", "nd", "rd"],
+            n = t % 100;
+          return "[" + t + (e[(n - 20) % 10] || e[n] || e[0]) + "]";
+        }
+      },
+      m = function m(t, e, n) {
+        var r = String(t);
+        return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
+      },
+      v = {
+        s: m,
+        z: function z(t) {
+          var e = -t.utcOffset(),
+            n = Math.abs(e),
+            r = Math.floor(n / 60),
+            i = n % 60;
+          return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
+        },
+        m: function t(e, n) {
+          if (e.date() < n.date()) return -t(n, e);
+          var r = 12 * (n.year() - e.year()) + (n.month() - e.month()),
+            i = e.clone().add(r, f),
+            s = n - i < 0,
+            u = e.clone().add(r + (s ? -1 : 1), f);
+          return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
+        },
+        a: function a(t) {
+          return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
+        },
+        p: function p(t) {
+          return {
+            M: f,
+            y: c,
+            w: o,
+            d: a,
+            D: d,
+            h: u,
+            m: s,
+            s: i,
+            ms: r,
+            Q: h
+          }[t] || String(t || "").toLowerCase().replace(/s$/, "");
+        },
+        u: function u(t) {
+          return void 0 === t;
+        }
+      },
+      g = "en",
+      D = {};
+    D[g] = M;
+    var p = function p(t) {
+        return t instanceof _;
+      },
+      S = function t(e, n, r) {
+        var i;
+        if (!e) return g;
+        if ("string" == typeof e) {
+          var s = e.toLowerCase();
+          D[s] && (i = s), n && (D[s] = n, i = s);
+          var u = e.split("-");
+          if (!i && u.length > 1) return t(u[0]);
+        } else {
+          var a = e.name;
+          D[a] = e, i = a;
+        }
+        return !r && i && (g = i), i || !r && g;
+      },
+      w = function w(t, e) {
+        if (p(t)) return t.clone();
+        var n = "object" == _typeof(e) ? e : {};
+        return n.date = t, n.args = arguments, new _(n);
+      },
+      O = v;
+    O.l = S, O.i = p, O.w = function (t, e) {
+      return w(t, {
+        locale: e.$L,
+        utc: e.$u,
+        x: e.$x,
+        $offset: e.$offset
+      });
+    };
+    var _ = function () {
+        function M(t) {
+          this.$L = S(t.locale, null, !0), this.parse(t);
+        }
+        var m = M.prototype;
+        return m.parse = function (t) {
+          this.$d = function (t) {
+            var e = t.date,
+              n = t.utc;
+            if (null === e) return new Date(NaN);
+            if (O.u(e)) return new Date();
+            if (e instanceof Date) return new Date(e);
+            if ("string" == typeof e && !/Z$/i.test(e)) {
+              var r = e.match($);
+              if (r) {
+                var i = r[2] - 1 || 0,
+                  s = (r[7] || "0").substring(0, 3);
+                return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
+              }
+            }
+            return new Date(e);
+          }(t), this.$x = t.x || {}, this.init();
+        }, m.init = function () {
+          var t = this.$d;
+          this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
+        }, m.$utils = function () {
+          return O;
+        }, m.isValid = function () {
+          return !(this.$d.toString() === l);
+        }, m.isSame = function (t, e) {
+          var n = w(t);
+          return this.startOf(e) <= n && n <= this.endOf(e);
+        }, m.isAfter = function (t, e) {
+          return w(t) < this.startOf(e);
+        }, m.isBefore = function (t, e) {
+          return this.endOf(e) < w(t);
+        }, m.$g = function (t, e, n) {
+          return O.u(t) ? this[e] : this.set(n, t);
+        }, m.unix = function () {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m.valueOf = function () {
+          return this.$d.getTime();
+        }, m.startOf = function (t, e) {
+          var n = this,
+            r = !!O.u(e) || e,
+            h = O.p(t),
+            l = function l(t, e) {
+              var i = O.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
+              return r ? i : i.endOf(a);
+            },
+            $ = function $(t, e) {
+              return O.w(n.toDate()[t].apply(n.toDate("s"), (r ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e)), n);
+            },
+            y = this.$W,
+            M = this.$M,
+            m = this.$D,
+            v = "set" + (this.$u ? "UTC" : "");
+          switch (h) {
+            case c:
+              return r ? l(1, 0) : l(31, 11);
+            case f:
+              return r ? l(1, M) : l(0, M + 1);
+            case o:
+              var g = this.$locale().weekStart || 0,
+                D = (y < g ? y + 7 : y) - g;
+              return l(r ? m - D : m + (6 - D), M);
+            case a:
+            case d:
+              return $(v + "Hours", 0);
+            case u:
+              return $(v + "Minutes", 1);
+            case s:
+              return $(v + "Seconds", 2);
+            case i:
+              return $(v + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, m.endOf = function (t) {
+          return this.startOf(t, !1);
+        }, m.$set = function (t, e) {
+          var n,
+            o = O.p(t),
+            h = "set" + (this.$u ? "UTC" : ""),
+            l = (n = {}, n[a] = h + "Date", n[d] = h + "Date", n[f] = h + "Month", n[c] = h + "FullYear", n[u] = h + "Hours", n[s] = h + "Minutes", n[i] = h + "Seconds", n[r] = h + "Milliseconds", n)[o],
+            $ = o === a ? this.$D + (e - this.$W) : e;
+          if (o === f || o === c) {
+            var y = this.clone().set(d, 1);
+            y.$d[l]($), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
+          } else l && this.$d[l]($);
+          return this.init(), this;
+        }, m.set = function (t, e) {
+          return this.clone().$set(t, e);
+        }, m.get = function (t) {
+          return this[O.p(t)]();
+        }, m.add = function (r, h) {
+          var d,
+            l = this;
+          r = Number(r);
+          var $ = O.p(h),
+            y = function y(t) {
+              var e = w(l);
+              return O.w(e.date(e.date() + Math.round(t * r)), l);
+            };
+          if ($ === f) return this.set(f, this.$M + r);
+          if ($ === c) return this.set(c, this.$y + r);
+          if ($ === a) return y(1);
+          if ($ === o) return y(7);
+          var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[$] || 1,
+            m = this.$d.getTime() + r * M;
+          return O.w(m, this);
+        }, m.subtract = function (t, e) {
+          return this.add(-1 * t, e);
+        }, m.format = function (t) {
+          var e = this,
+            n = this.$locale();
+          if (!this.isValid()) return n.invalidDate || l;
+          var r = t || "YYYY-MM-DDTHH:mm:ssZ",
+            i = O.z(this),
+            s = this.$H,
+            u = this.$m,
+            a = this.$M,
+            o = n.weekdays,
+            f = n.months,
+            h = function h(t, n, i, s) {
+              return t && (t[n] || t(e, r)) || i[n].slice(0, s);
+            },
+            c = function c(t) {
+              return O.s(s % 12 || 12, t, "0");
+            },
+            d = n.meridiem || function (t, e, n) {
+              var r = t < 12 ? "AM" : "PM";
+              return n ? r.toLowerCase() : r;
+            },
+            $ = {
+              YY: String(this.$y).slice(-2),
+              YYYY: this.$y,
+              M: a + 1,
+              MM: O.s(a + 1, 2, "0"),
+              MMM: h(n.monthsShort, a, f, 3),
+              MMMM: h(f, a),
+              D: this.$D,
+              DD: O.s(this.$D, 2, "0"),
+              d: String(this.$W),
+              dd: h(n.weekdaysMin, this.$W, o, 2),
+              ddd: h(n.weekdaysShort, this.$W, o, 3),
+              dddd: o[this.$W],
+              H: String(s),
+              HH: O.s(s, 2, "0"),
+              h: c(1),
+              hh: c(2),
+              a: d(s, u, !0),
+              A: d(s, u, !1),
+              m: String(u),
+              mm: O.s(u, 2, "0"),
+              s: String(this.$s),
+              ss: O.s(this.$s, 2, "0"),
+              SSS: O.s(this.$ms, 3, "0"),
+              Z: i
+            };
+          return r.replace(y, function (t, e) {
+            return e || $[t] || i.replace(":", "");
+          });
+        }, m.utcOffset = function () {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m.diff = function (r, d, l) {
+          var $,
+            y = O.p(d),
+            M = w(r),
+            m = (M.utcOffset() - this.utcOffset()) * e,
+            v = this - M,
+            g = O.m(this, M);
+          return g = ($ = {}, $[c] = g / 12, $[f] = g, $[h] = g / 3, $[o] = (v - m) / 6048e5, $[a] = (v - m) / 864e5, $[u] = v / n, $[s] = v / e, $[i] = v / t, $)[y] || v, l ? g : O.a(g);
+        }, m.daysInMonth = function () {
+          return this.endOf(f).$D;
+        }, m.$locale = function () {
+          return D[this.$L];
+        }, m.locale = function (t, e) {
+          if (!t) return this.$L;
+          var n = this.clone(),
+            r = S(t, e, !0);
+          return r && (n.$L = r), n;
+        }, m.clone = function () {
+          return O.w(this.$d, this);
+        }, m.toDate = function () {
+          return new Date(this.valueOf());
+        }, m.toJSON = function () {
+          return this.isValid() ? this.toISOString() : null;
+        }, m.toISOString = function () {
+          return this.$d.toISOString();
+        }, m.toString = function () {
+          return this.$d.toUTCString();
+        }, M;
+      }(),
+      T = _.prototype;
+    return w.prototype = T, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function (t) {
+      T[t[1]] = function (e) {
+        return this.$g(e, t[0], t[1]);
+      };
+    }), w.extend = function (t, e) {
+      return t.$i || (t(e, _, w), t.$i = !0), w;
+    }, w.locale = S, w.isDayjs = p, w.unix = function (t) {
+      return w(1e3 * t);
+    }, w.en = D[g], w.Ls = D, w.p = {}, w;
+  });
+})(dayjs_min);
+var dayjs_minExports = dayjs_min.exports;
+var dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
+var dateFormats = {
+  date: 'YYYY-MM-DD',
+  basic_date: 'YYYYMMDD',
+  basic_date_time: 'YYYYMMDD[T]HHmmss.SSSZ',
+  basic_date_time_no_millis: 'YYYYMMDD[T]HHmmssZ',
+  date_time_no_millis: 'YYYY-MM-DD[T]HH:mm:ssZ',
+  basic_time: 'HHmmss.SSSZ',
+  basic_time_no_millis: 'HHmmssZ',
+  epoch_millis: 'epoch_millis',
+  epoch_second: 'epoch_second'
+};
+var _componentTypeToDefau;
+function ownKeys$3(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$3(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function getOperation(conjunction) {
+  if (conjunction === 'and') {
+    return 'must';
+  }
+  if (conjunction === 'or') {
+    return 'should';
+  }
+  return 'must_not';
+}
+function createBoolQuery(operation, query) {
+  var resultQuery = null;
+  if (Array.isArray(query) && query.length || !Array.isArray(query) && query) {
+    resultQuery = {
+      bool: _defineProperty({}, operation, query)
+    };
+  }
+  if (operation === 'should' && resultQuery) {
+    resultQuery = {
+      bool: _objectSpread$3(_objectSpread$3({}, resultQuery.bool), {}, {
+        minimum_should_match: 1
+      })
+    };
+  }
+  return resultQuery;
+}
+function getQuery(react, queryList) {
+  var query = [];
+  Object.keys(react).forEach(function (conjunction) {
+    if (Array.isArray(react[conjunction])) {
+      var operation = getOperation(conjunction);
+      var queryArr = react[conjunction].map(function (comp) {
+        if (typeof comp !== 'string') {
+          // in this case, we have { <conjunction>: <> } objects inside the array
+          return getQuery(comp, queryList);
+        } else if (comp in queryList) {
+          if (queryList[comp] && Object.keys(queryList[comp]).length) {
+            return queryList[comp];
+          }
+        }
+        return null;
+      }).filter(function (item) {
+        return !!item;
+      });
+      var boolQuery = createBoolQuery(operation, queryArr);
+      if (boolQuery && Object.keys(boolQuery).length) {
+        query = [].concat(_toConsumableArray(query), [boolQuery]);
+      }
+    } else if (typeof react[conjunction] === 'string') {
+      var _operation = getOperation(conjunction);
+      var _boolQuery = createBoolQuery(_operation, queryList[react[conjunction]]);
+      if (_boolQuery && Object.keys(_boolQuery).length) {
+        query = [].concat(_toConsumableArray(query), [_boolQuery]);
+      }
+    } else if (_typeof(react[conjunction]) === 'object' && react[conjunction] !== null) {
+      var _boolQuery2 = getQuery(react[conjunction], queryList);
+      if (_boolQuery2 && Object.keys(_boolQuery2).length) {
+        query = [].concat(_toConsumableArray(query), [_boolQuery2]);
+      }
+    }
+  });
+  if (Array.isArray(query) && query.length) {
+    return {
+      bool: {
+        must: query
+      }
+    };
+  }
+  if (query && Object.keys(query).length) {
+    return query;
+  }
+  return null;
+}
+function getExternalQueryOptions(react, options, component) {
+  var queryOptions = {};
+  Object.keys(react).forEach(function (conjunction) {
+    if (Array.isArray(react[conjunction])) {
+      react[conjunction].forEach(function (comp) {
+        if (options[comp]) {
+          queryOptions = _objectSpread$3(_objectSpread$3({}, queryOptions), options[comp]);
+        }
+      });
+    } else if (typeof react[conjunction] === 'string') {
+      if (options[react[conjunction]]) {
+        queryOptions = _objectSpread$3(_objectSpread$3({}, queryOptions), options[react[conjunction]]);
+      }
+    } else if (_typeof(react[conjunction]) === 'object' && react[conjunction] !== null && !Array.isArray(react[conjunction])) {
+      queryOptions = _objectSpread$3(_objectSpread$3({}, queryOptions), getExternalQueryOptions(react[conjunction], options));
+    }
+  });
+  if (options[component]) {
+    queryOptions = _objectSpread$3(_objectSpread$3({}, queryOptions), options[component]);
+  }
+  return queryOptions;
+}
+function buildQuery(component, dependencyTree, queryList, queryOptions) {
+  var queryObj = null;
+  var options = null;
+  if (component in dependencyTree) {
+    queryObj = getQuery(dependencyTree[component], queryList);
+    options = getExternalQueryOptions(dependencyTree[component], queryOptions, component);
+  }
+  return {
+    queryObj: queryObj,
+    options: options
+  };
+}
+function formatDate(date, props) {
+  if (props.parseDate) {
+    // We would be passing an instance of dayjs instead of xdate below. Users need to know.
+    return props.parseDate(date, props);
+  }
+  switch (props.queryFormat) {
+    case 'epoch_millis':
+      return date.valueOf();
+    case 'epoch_second':
+      return Math.floor(date.valueOf() / 1000);
+    default:
+      {
+        if (dateFormats[props.queryFormat]) {
+          return date.format(dateFormats[props.queryFormat]);
+        }
+        return date.valueOf();
+      }
+  }
+}
+_componentTypeToDefau = {}, _defineProperty(_componentTypeToDefau, componentTypes.singleList, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiList, []), _defineProperty(_componentTypeToDefau, componentTypes.singleDataList, ''), _defineProperty(_componentTypeToDefau, componentTypes.singleDropdownList, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiDataList, []), _defineProperty(_componentTypeToDefau, componentTypes.multiDropdownList, []), _defineProperty(_componentTypeToDefau, componentTypes.tagCloud, ''), _defineProperty(_componentTypeToDefau, componentTypes.toggleButton, ''), _defineProperty(_componentTypeToDefau, componentTypes.singleDropdownRange, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiDropdownRange, []), _defineProperty(_componentTypeToDefau, componentTypes.singleRange, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiRange, []), _componentTypeToDefau;
+
+/* isValidDateRangeQueryFormat() checks if the queryFormat is one of the dateFormats
+	accepted by the elasticsearch or not. */
+function isValidDateRangeQueryFormat(queryFormat) {
+  return Object.keys(dateFormats).includes(queryFormat);
+}
+var _componentToTypeMap;
+function ownKeys$2(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$2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+var componentToTypeMap = (_componentToTypeMap = {}, _defineProperty(_componentToTypeMap, componentTypes.reactiveList, queryTypes.search), _defineProperty(_componentToTypeMap, componentTypes.dataSearch, queryTypes.search), _defineProperty(_componentToTypeMap, componentTypes.categorySearch, queryTypes.search), _defineProperty(_componentToTypeMap, componentTypes.searchBox, queryTypes.suggestion), _defineProperty(_componentToTypeMap, componentTypes.singleList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.multiList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.singleDataList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.singleDropdownList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.multiDataList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.multiDropdownList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.tagCloud, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.toggleButton, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.reactiveChart, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.treeList, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.numberBox, queryTypes.term), _defineProperty(_componentToTypeMap, componentTypes.datePicker, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.dateRange, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.dynamicRangeSlider, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.singleDropdownRange, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.multiDropdownRange, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.singleRange, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.multiRange, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.rangeSlider, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.ratingsFilter, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.rangeInput, queryTypes.range), _defineProperty(_componentToTypeMap, componentTypes.geoDistanceDropdown, queryTypes.geo), _defineProperty(_componentToTypeMap, componentTypes.geoDistanceSlider, queryTypes.geo), _defineProperty(_componentToTypeMap, componentTypes.reactiveMap, queryTypes.geo), _componentToTypeMap);
+var multiRangeComponents = [componentTypes.multiRange, componentTypes.multiDropdownRange];
+var dateRangeComponents = [componentTypes.dateRange, componentTypes.datePicker];
+var searchComponents = [componentTypes.categorySearch, componentTypes.dataSearch, componentTypes.searchBox];
+var listComponentsWithPagination = [componentTypes.singleList, componentTypes.multiList, componentTypes.singleDropdownList, componentTypes.multiDropdownList];
+var getNormalizedField = function getNormalizedField(field) {
+  if (field && !Array.isArray(field)) {
+    return [field];
+  }
+  return field;
+};
+var isInternalComponent = function isInternalComponent() {
+  var componentID = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return componentID.endsWith('__internal');
+};
+var getInternalComponentID = function getInternalComponentID() {
+  var componentID = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return "".concat(componentID, "__internal");
+};
+var getHistogramComponentID = function getHistogramComponentID() {
+  var componentID = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return "".concat(componentID, "__histogram__internal");
+};
+var isDRSRangeComponent = function isDRSRangeComponent() {
+  var componentID = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return componentID.endsWith('__range__internal');
+};
+var isSearchComponent = function isSearchComponent() {
+  var componentType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return searchComponents.includes(componentType);
+};
+var isComponentUsesLabelAsValue = function isComponentUsesLabelAsValue() {
+  var componentType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return componentType === componentTypes.multiDataList || componentType === componentTypes.singleDataList || componentType === componentTypes.tabDataList;
+};
+var hasPaginationSupport = function hasPaginationSupport() {
+  var componentType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return listComponentsWithPagination.includes(componentType);
+};
+var getRSQuery = function getRSQuery(componentId, props) {
+  var execute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  if (props && componentId) {
+    var queryType = props.type ? props.type : componentToTypeMap[props.componentType];
+    // dataField is a required field for components other than search
+    // TODO: Revisit this logic based on the Appbase version
+    // dataField is no longer a required field in RS API
+    if (!isSearchComponent(props.componentType) && !props.dataField) {
+      return null;
+    }
+    var endpoint;
+    if (props.endpoint instanceof Object) {
+      endpoint = props.endpoint;
+    }
+    return _objectSpread$2(_objectSpread$2({
+      id: componentId,
+      type: queryType || queryTypes.search,
+      dataField: getNormalizedField(props.dataField),
+      execute: execute,
+      react: props.react,
+      highlight: props.highlight,
+      highlightField: getNormalizedField(props.highlightField),
+      fuzziness: props.fuzziness,
+      searchOperators: props.searchOperators,
+      includeFields: props.includeFields,
+      excludeFields: props.excludeFields,
+      size: props.size,
+      aggregationSize: props.aggregationSize,
+      from: props.from || undefined,
+      // Need to maintain for RL
+      queryFormat: props.queryFormat,
+      sortBy: props.sortBy,
+      fieldWeights: getNormalizedField(props.fieldWeights),
+      includeNullValues: props.includeNullValues,
+      aggregationField: props.aggregationField || undefined,
+      categoryField: props.categoryField || undefined,
+      missingLabel: props.missingLabel || undefined,
+      showMissing: props.showMissing,
+      nestedField: props.nestedField || undefined,
+      interval: props.interval,
+      highlightConfig: props.customHighlight || props.highlightConfig,
+      customQuery: props.customQuery,
+      defaultQuery: props.defaultQuery,
+      value: props.value,
+      categoryValue: props.categoryValue || undefined,
+      after: props.after || undefined,
+      aggregations: props.aggregations || undefined,
+      enableSynonyms: props.enableSynonyms,
+      selectAllLabel: props.selectAllLabel,
+      pagination: props.pagination,
+      queryString: props.queryString,
+      distinctField: props.distinctField,
+      distinctFieldConfig: props.distinctFieldConfig,
+      index: props.index
+    }, queryType === queryTypes.suggestion ? _objectSpread$2({
+      enablePopularSuggestions: props.enablePopularSuggestions,
+      enableEndpointSuggestions: props.enableEndpointSuggestions,
+      enableRecentSuggestions: props.enableRecentSuggestions,
+      popularSuggestionsConfig: props.popularSuggestionsConfig,
+      recentSuggestionsConfig: props.recentSuggestionsConfig,
+      applyStopwords: props.applyStopwords,
+      customStopwords: props.customStopwords,
+      enablePredictiveSuggestions: props.enablePredictiveSuggestions,
+      featuredSuggestionsConfig: props.featuredSuggestionsConfig,
+      indexSuggestionsConfig: props.indexSuggestionsConfig,
+      enableFeaturedSuggestions: props.enableFeaturedSuggestions,
+      enableIndexSuggestions: props.enableIndexSuggestions
+    }, props.searchboxId ? {
+      searchboxId: props.searchboxId
+    } : {}) : {}), {}, {
+      calendarInterval: props.calendarInterval,
+      endpoint: endpoint,
+      range: props.range
+    });
+  }
+  return null;
+};
+var extractPropsFromState = function extractPropsFromState(store, component, customOptions) {
+  var componentProps = store.props[component];
+  if (!componentProps) {
+    return null;
+  }
+  var queryType = componentProps.type ? componentProps.type : componentToTypeMap[componentProps.componentType];
+  var calcValues = store.selectedValues[component];
+  var value = calcValues !== undefined && calcValues !== null ? calcValues.value : undefined;
+  var queryFormat = componentProps.queryFormat;
+  // calendarInterval only supported when using date types
+  var calendarInterval;
+  var interval = componentProps.interval;
+  var type = queryType;
+  var dataField = componentProps.dataField;
+  var aggregations = componentProps.aggregations;
+  var pagination; // pagination for `term` type of queries
+  var from = componentProps.from; // offset for RL
+  var range; // applicable for range components supporting histogram
+
+  // For term queries i.e list component `dataField` will be treated as aggregationField
+  if (queryType === queryTypes.term) {
+    // Only apply pagination prop for the components which supports it otherwise it can break the UI
+    if (componentProps.showLoadMore && hasPaginationSupport(componentProps.componentType)) {
+      pagination = true;
+    }
+    // Extract values from components that are type of objects
+    // This code handles the controlled behavior in list components for e.g ToggleButton
+    if (value != null && _typeof(value) === 'object' && value.value) {
+      value = value.value;
+    } else if (Array.isArray(value)) {
+      var parsedValue = [];
+      value.forEach(function (val) {
+        if (val != null && _typeof(val) === 'object' && val.value) {
+          parsedValue.push(val.value);
+        } else {
+          parsedValue.push(val);
+        }
+      });
+      value = parsedValue;
+    }
+  }
+  if (queryType === queryTypes.range) {
+    if (Array.isArray(value)) {
+      if (multiRangeComponents.includes(componentProps.componentType)) {
+        value = value.map(function (_ref) {
+          var start = _ref.start,
+            end = _ref.end;
+          return {
+            start: start,
+            end: end
+          };
+        });
+      } else {
+        value = {
+          start: value[0],
+          end: value[1]
+        };
+      }
+    } else if (componentProps.showHistogram) {
+      var internalComponentID = getInternalComponentID(component);
+      var internalComponentValue = store.internalValues[internalComponentID];
+      if (!internalComponentValue) {
+        // Handle dynamic range slider
+        var histogramComponentID = getHistogramComponentID(component);
+        internalComponentValue = store.internalValues[histogramComponentID];
+      }
+      if (internalComponentValue && Array.isArray(internalComponentValue.value)) {
+        value = {
+          start: internalComponentValue.value[0],
+          end: internalComponentValue.value[1]
+        };
+      }
+    }
+    if (isDRSRangeComponent(component)) {
+      aggregations = ['min', 'max'];
+    } else if (componentProps.showHistogram) {
+      aggregations = ['histogram'];
+    }
+
+    // handle number box, number box query changes based on the `queryFormat` value
+    if (componentProps.componentType === componentTypes.dynamicRangeSlider || componentProps.componentType === componentTypes.rangeSlider) {
+      calendarInterval = Object.keys(dateFormats).includes(queryFormat) ? componentProps.calendarInterval : undefined;
+
+      // Set value
+      if (value) {
+        if (isValidDateRangeQueryFormat(componentProps.queryFormat)) {
+          // check if date types are dealt with
+          value = {
+            start: formatDate(dayjs(new Date(value.start)), componentProps),
+            end: formatDate(dayjs(new Date(value.end)), componentProps)
+          };
+        } else {
+          value = {
+            start: parseFloat(value.start),
+            end: parseFloat(value.end)
+          };
+        }
+      }
+      var rangeValue;
+      if (componentProps.componentType === componentTypes.dynamicRangeSlider) {
+        rangeValue = store.aggregations["".concat(component, "__range__internal")];
+        if (componentProps.nestedField) {
+          rangeValue = rangeValue && store.aggregations["".concat(component, "__range__internal")][componentProps.nestedField].min ? {
+            start: store.aggregations["".concat(component, "__range__internal")][componentProps.nestedField].min.value,
+            end: store.aggregations["".concat(component, "__range__internal")][componentProps.nestedField].max.value
+          } // prettier-ignore
+          : null;
+        } else {
+          rangeValue = rangeValue && store.aggregations["".concat(component, "__range__internal")].min && store.aggregations["".concat(component, "__range__internal")].min.value ? {
+            start: store.aggregations["".concat(component, "__range__internal")].min.value,
+            end: store.aggregations["".concat(component, "__range__internal")].max.value
+          } // prettier-ignore
+          : null;
+        }
+      } else {
+        rangeValue = componentProps.range;
+      }
+      if (rangeValue) {
+        if (isValidDateRangeQueryFormat(componentProps.queryFormat)) {
+          // check if date types are dealt with
+          range = {
+            start: formatDate(dayjs(rangeValue.start), componentProps),
+            end: formatDate(dayjs(rangeValue.end), componentProps)
+          };
+        } else {
+          range = {
+            start: parseFloat(rangeValue.start),
+            end: parseFloat(rangeValue.end)
+          };
+        }
+      }
+    }
+
+    // handle date components
+    if (dateRangeComponents.includes(componentProps.componentType)) {
+      // Set value
+      if (value) {
+        if (isValidDateRangeQueryFormat(componentProps.queryFormat)) {
+          if (typeof value === 'string') {
+            value = {
+              // value would be an ISO Date string
+              start: formatDate(dayjs(value).subtract(24, 'hour'), componentProps),
+              end: formatDate(dayjs(value), componentProps)
+            };
+          } else if (Array.isArray(value)) {
+            value = value.map(function (val) {
+              return {
+                // value would be one of ISO Date string, number, native date
+                start: formatDate(dayjs(val).subtract(24, 'hour'), componentProps),
+                end: formatDate(dayjs(val), componentProps)
+              };
+            });
+          } else {
+            value = {
+              start: formatDate(dayjs(value.start).subtract(24, 'hour'), componentProps),
+              end: formatDate(dayjs(value.end), componentProps)
+            };
+          }
+        }
+      }
+    }
+  }
+  if (queryType === queryTypes.geo) {
+    // override the value extracted from selectedValues reducer
+    value = undefined;
+    var geoCalcValues = store.selectedValues[component] || store.internalValues[component] || store.internalValues[getInternalComponentID(component)];
+    if (geoCalcValues && geoCalcValues.meta) {
+      if (geoCalcValues.meta.distance && geoCalcValues.meta.coordinates) {
+        value = {
+          distance: geoCalcValues.meta.distance,
+          location: geoCalcValues.meta.coordinates
+        };
+        if (componentProps.unit) {
+          value.unit = componentProps.unit;
+        }
+      }
+      if (geoCalcValues.meta.mapBoxBounds && geoCalcValues.meta.mapBoxBounds.top_left && geoCalcValues.meta.mapBoxBounds.bottom_right) {
+        value = {
+          // Note: format will be reverse of what we're using now
+          geoBoundingBox: {
+            topLeft: "".concat(geoCalcValues.meta.mapBoxBounds.top_left[1], ", ").concat(geoCalcValues.meta.mapBoxBounds.top_left[0]),
+            bottomRight: "".concat(geoCalcValues.meta.mapBoxBounds.bottom_right[1], ", ").concat(geoCalcValues.meta.mapBoxBounds.bottom_right[0])
+          }
+        };
+      }
+    }
+  }
+  // handle number box, number box query changes based on the `queryFormat` value
+  if (componentProps.componentType === componentTypes.numberBox) {
+    if (queryFormat === 'exact') {
+      type = 'term';
+    } else {
+      type = 'range';
+      if (queryFormat === 'lte') {
+        value = {
+          end: value,
+          boost: 2.0
+        };
+      } else {
+        value = {
+          start: value,
+          boost: 2.0
+        };
+      }
+    }
+    // Remove query format
+    queryFormat = 'or';
+  }
+  // Fake dataField for ReactiveComponent
+  // TODO: Remove it after some time. The `dataField` is no longer required
+  if (componentProps.componentType === componentTypes.reactiveComponent) {
+    // Set the type to `term`
+    type = 'term';
+    dataField = 'reactive_component_field';
+    // Don't set value property for ReactiveComponent
+    // since it is driven by `defaultQuery` and `customQuery`
+    value = undefined;
+  }
+  // Assign default value as an empty string for search components so search relevancy can work
+  if (isSearchComponent(componentProps.componentType) && !value) {
+    value = '';
+  }
+
+  // Handle components which uses label instead of value as the selected value
+  if (isComponentUsesLabelAsValue(componentProps.componentType)) {
+    var data = componentProps.data,
+      selectAllLabel = componentProps.selectAllLabel;
+    var absValue = [];
+    if (value && Array.isArray(value)) {
+      absValue = value;
+    } else if (value && typeof value === 'string') {
+      absValue = [value];
+    }
+    var normalizedValue = [];
+    if (absValue.length) {
+      if (data && Array.isArray(data)) {
+        absValue.forEach(function (val) {
+          var dataItem = data.find(function (o) {
+            return o.label === val;
+          });
+          if (dataItem && dataItem.value) {
+            normalizedValue.push(dataItem.value);
+          }
+        });
+      }
+    }
+    if (selectAllLabel && absValue.length && absValue.includes(selectAllLabel)) {
+      normalizedValue = absValue;
+    }
+    if (normalizedValue.length) {
+      value = normalizedValue;
+    } else {
+      value = undefined;
+    }
+  }
+  if (componentProps.componentType === componentTypes.reactiveList) {
+    // We set selected page as the value in the redux store for RL.
+    // It's complex to change this logic in the component so changed it here.
+    if (value > 0) {
+      from = (value - 1) * (componentProps.size || 10);
+    }
+    value = undefined;
+  }
+  var queryValue = value || undefined;
+  if (componentProps.componentType === componentTypes.searchBox) {
+    if (Array.isArray(queryValue)) {
+      queryValue = undefined;
+    }
+  }
+  var endpoint;
+  if (componentProps.endpoint instanceof Object) {
+    endpoint = _objectSpread$2(_objectSpread$2({}, endpoint || {}), componentProps.endpoint);
+  }
+  return _objectSpread$2(_objectSpread$2({}, componentProps), {}, {
+    endpoint: endpoint,
+    calendarInterval: calendarInterval,
+    dataField: dataField,
+    queryFormat: queryFormat,
+    type: type,
+    aggregations: aggregations,
+    interval: interval,
+    react: store.dependencyTree ? store.dependencyTree[component] : undefined,
+    customQuery: store.customQueries ? store.customQueries[component] : undefined,
+    defaultQuery: store.defaultQueries ? store.defaultQueries[component] : undefined,
+    customHighlight: store.customHighlightOptions ? store.customHighlightOptions[component] : undefined,
+    categoryValue: store.internalValues[component] ? store.internalValues[component].category : undefined,
+    value: queryValue,
+    pagination: pagination,
+    from: from,
+    range: range
+  }, customOptions);
+};
+function flatReactProp(reactProp, componentID) {
+  var flattenReact = [];
+  var flatReact = function flatReact(react) {
+    if (react && Object.keys(react)) {
+      Object.keys(react).forEach(function (r) {
+        if (react[r]) {
+          if (typeof react[r] === 'string') {
+            flattenReact = [].concat(_toConsumableArray(flattenReact), [react[r]]);
+          } else if (Array.isArray(react[r])) {
+            flattenReact = [].concat(_toConsumableArray(flattenReact), _toConsumableArray(react[r]));
+          } else if (_typeof(react[r]) === 'object') {
+            flatReact(react[r]);
+          }
+        }
+      });
+    }
+  };
+  flatReact(reactProp);
+  // Remove cyclic dependencies
+  flattenReact = flattenReact.filter(function (react) {
+    return react !== componentID;
+  });
+  return flattenReact;
+}
+var getDependentQueries = function getDependentQueries(store, componentID) {
+  var orderOfQueries = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var finalQuery = {};
+  var react = flatReactProp(store.dependencyTree[componentID], componentID);
+  react.forEach(function (componentObject) {
+    var component = componentObject;
+    var customQuery = store.customQueries[component];
+    if (!isInternalComponent(component)) {
+      var calcValues = store.selectedValues[component] || store.internalValues[component];
+      // Only include queries for that component that has `customQuery` or `value` defined
+      if ((calcValues && calcValues.value || customQuery) && !finalQuery[component]) {
+        var execute = false;
+        if (Array.isArray(orderOfQueries) && orderOfQueries.includes(component)) {
+          execute = true;
+        }
+        var componentProps = store.props[component];
+        // build query
+        var dependentQuery = getRSQuery(component, extractPropsFromState(store, component, _objectSpread$2({}, componentProps && _objectSpread$2(_objectSpread$2({}, componentProps.componentType === componentTypes.searchBox ? _objectSpread$2(_objectSpread$2(_objectSpread$2({}, execute === false ? {
+          type: queryTypes.search
+        } : {}), calcValues.category ? {
+          categoryValue: calcValues.category
+        } : {
+          categoryValue: undefined
+        }), calcValues.value ? {
+          value: calcValues.value
+        } : {}) : {}), componentProps.componentType === componentTypes.categorySearch ? _objectSpread$2({}, calcValues.category ? {
+          categoryValue: calcValues.category
+        } : {
+          categoryValue: undefined
+        }) : {}))), execute);
+        if (dependentQuery) {
+          finalQuery[component] = dependentQuery;
+        }
+      }
+    }
+  });
+  return finalQuery;
+};
+var handleTransformResponse = function handleTransformResponse() {
+  var res = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var component = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  if (config.transformResponse && typeof config.transformResponse === 'function') {
+    return config.transformResponse(res, component);
+  }
+  return new Promise(function (resolve) {
+    return resolve(res);
+  });
+};
+var isPropertyDefined = function isPropertyDefined(property) {
+  return property !== undefined && property !== null;
+};
+var _excluded$1 = ["value"];
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function ownKeys$1(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$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function valueReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var action = arguments.length > 1 ? arguments[1] : undefined;
+  switch (action.type) {
+    case SET_VALUE:
+      {
+        var newState = {};
+        Object.keys(action.componentsToReset || {}).forEach(function (id) {
+          newState[id] = _objectSpread$1(_objectSpread$1({}, state[id]), {}, {
+            value: action.componentsToReset[id]
+          });
+        });
+        return _objectSpread$1(_objectSpread$1(_objectSpread$1({}, state), newState), {}, _defineProperty({}, action.component, {
+          value: action.value,
+          label: action.label || action.component,
+          showFilter: action.showFilter,
+          URLParams: action.URLParams,
+          componentType: action.componentType,
+          category: action.category,
+          meta: action.meta,
+          reference: action.reference
+        }));
+      }
+    case SET_VALUES:
+      {
+        var componentKeys = action.componentsValues ? Object.keys(action.componentsValues) : [];
+        if (componentKeys.length) {
+          var _newState = {};
+          componentKeys.forEach(function (component) {
+            var _action$componentsVal = action.componentsValues[component],
+              value = _action$componentsVal.value,
+              rest = _objectWithoutProperties(_action$componentsVal, _excluded$1);
+            _newState[component] = _objectSpread$1(_objectSpread$1({}, state[component]), {}, {
+              value: value
+            }, rest);
+          });
+          return _objectSpread$1(_objectSpread$1({}, state), _newState);
+        }
+        return state;
+      }
+    case PATCH_VALUE:
+      return _objectSpread$1(_objectSpread$1({}, state), {}, _defineProperty({}, action.component, _objectSpread$1(_objectSpread$1({}, state[action.component]), action.payload)));
+    case CLEAR_VALUES:
+      {
+        var nextState = {};
+        if (action.resetValues) {
+          Object.keys(action.resetValues).forEach(function (componentId) {
+            nextState[componentId] = _objectSpread$1(_objectSpread$1({}, state[componentId]), {}, {
+              value: action.resetValues[componentId]
+            });
+          });
+        }
+        // clearAllBlacklistComponents has more priority over reset values
+        if (Array.isArray(action.clearAllBlacklistComponents)) {
+          Object.keys(state).forEach(function (componentId) {
+            if (action.clearAllBlacklistComponents.includes(componentId)) {
+              nextState[componentId] = state[componentId];
+            }
+          });
+        }
+        return nextState;
+      }
+    case REMOVE_COMPONENT:
+      {
+        var _action$component = action.component;
+        state[_action$component];
+        var obj = _objectWithoutProperties(state, [_action$component].map(_toPropertyKey));
+        return obj;
+      }
+    case RESET_TO_DEFAULT:
+      return _objectSpread$1(_objectSpread$1({}, state), action.defaultValues);
+    default:
+      return state;
+  }
+}
+var _excluded = ["value"];
+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 getValue(state, id, defaultValue) {
+  if (state && state[id]) {
+    try {
+      // parsing for next.js - since it uses extra set of quotes to wrap params
+      var parsedValue = JSON.parse(state[id]);
+      return _objectSpread(_objectSpread({}, _typeof(parsedValue) === 'object' && parsedValue.value ? _objectSpread({
+        value: parsedValue.value
+      }, parsedValue.category ? {
+        category: parsedValue.category
+      } : {}) : {
+        value: parsedValue
+      }), {}, {
+        reference: 'URL'
+      });
+    } catch (error) {
+      // using react-dom-server for ssr
+      return {
+        value: state[id],
+        reference: 'URL'
+      };
+    }
+  }
+  return {
+    value: defaultValue,
+    reference: 'DEFAULT'
+  };
+}
+
+// parse query string
+// ref: https://stackoverflow.com/a/13896633/10822996
+function parseQuery(str) {
+  if (str instanceof Object) {
+    return str;
+  }
+  if (typeof str !== 'string' || str.length === 0) return {};
+  var s;
+  if (str.split('/?')[1]) {
+    s = str.split('/?')[1].split('&');
+  }
+  if (str.split('?')[1]) {
+    s = str.split('?')[1].split('&');
+  }
+  if (!s) return {};
+  var sLength = s.length;
+  var bit;
+  var query = {};
+  var first;
+  var second;
+  for (var i = 0; i < sLength; i += 1) {
+    bit = s[i].split('=');
+    first = decodeURIComponent(bit[0]);
+    // eslint-disable-next-line no-continue
+    if (first.length === 0) continue;
+    second = decodeURIComponent(bit[1]);
+    if (typeof query[first] === 'undefined') query[first] = second;else if (query[first] instanceof Array) query[first].push(second);else query[first] = [query[first], second];
+  }
+  return query;
+}
+var getServerResults = function getServerResults() {
+  var storeReference = null;
+  return function (App) {
+    var queryString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    var ssrRenderFunc = arguments.length > 2 ? arguments[2] : undefined;
+    try {
+      // parse the query String to respect url params in SSR
+      var parsedQueryString = parseQuery(queryString);
+      if (!storeReference) {
+        var newSelectedValues = {};
+        // callback function to collect SearchBase context
+        var contextCollector = function contextCollector(params) {
+          if (params.ctx) {
+            // store collected
+            storeReference = params.ctx;
+
+            // collect selected values from the URL query string
+            Object.keys(parsedQueryString).forEach(function (componentId) {
+              var _getValue = getValue(parsedQueryString, componentId, null),
+                value = _getValue.value,
+                reference = _getValue.reference;
+              if (value) {
+                newSelectedValues = valueReducer(newSelectedValues, {
+                  type: 'PATCH_VALUE',
+                  component: componentId,
+                  payload: {
+                    value: value,
+                    reference: reference
+                  }
+                });
+              }
+            });
+          }
+          return {
+            // send back to ReactiveBase to hydrate the store with values from queryParams(if present)
+            selectedValues: newSelectedValues
+          };
+        };
+
+        // render the app server-side to collect context and build initial state
+        // for hydration on client side
+        // in case of React, ssrRenderFunc === renderToString || renderToStaticMarkup
+        // in case of Vue, ssrRenderFunc === renderToString (import { renderToString } from 'vue/server-renderer')
+        var output = ssrRenderFunc(App({
+          contextCollector: contextCollector
+        }));
+        var promiseFunc;
+        if (!output.then) {
+          promiseFunc = Promise.resolve(promiseFunc);
+        } else {
+          promiseFunc = output;
+        }
+        return promiseFunc.then(function () {
+          if (storeReference) {
+            var extractedState = storeReference.getState();
+            var components = extractedState.components,
+              config = extractedState.config,
+              appbaseRef = extractedState.appbaseRef,
+              queryOptions = extractedState.queryOptions,
+              internalValues = extractedState.internalValues,
+              props = extractedState.props,
+              queryList = extractedState.queryList,
+              dependencyTree = extractedState.dependencyTree;
+            var queryLog = extractedState.queryLog;
+            var finalQuery = [];
+            var appbaseQuery = {}; // Use object to prevent duplicate query added by react prop
+            var orderOfQueries = [];
+            var hits = {};
+            var aggregations = {};
+            var state = _objectSpread({}, extractedState);
+
+            // Generate finalQuery for search
+            components.filter(function (t) {
+              return !t.endsWith('__internal');
+            }).forEach(function (componentId) {
+              // eslint-disable-next-line
+              var _buildQuery = buildQuery(componentId, dependencyTree, queryList, queryOptions),
+                queryObj = _buildQuery.queryObj,
+                options = _buildQuery.options;
+              if (!queryObj && !options) {
+                return;
+              }
+              var query = getRSQuery(componentId, extractPropsFromState(state, componentId, queryOptions && queryOptions[componentId] ? {
+                from: queryOptions[componentId].from
+              } : null));
+
+              // check if query or options are valid - non-empty
+              if (query && !!Object.keys(query).length) {
+                var currentQuery = query;
+                var dependentQueries = getDependentQueries(state, componentId, orderOfQueries);
+                var queryToLog = _objectSpread(_objectSpread({}, _defineProperty({}, componentId, currentQuery)), Object.keys(dependentQueries).reduce(function (acc, q) {
+                  return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, q, _objectSpread(_objectSpread({}, dependentQueries[q]), {}, {
+                    execute: false
+                  }, dependentQueries[q].type === queryTypes.suggestion ? {
+                    type: 'search'
+                  } : {})));
+                }, {}));
+                if ([queryTypes.range, queryTypes.term].includes(componentToTypeMap[props[componentId].componentType])) {
+                  // Avoid logging `value` for term type of components
+                  // eslint-disable-next-line
+                  var value = currentQuery.value,
+                    rest = _objectWithoutProperties(currentQuery, _excluded);
+                  queryToLog = _objectSpread(_objectSpread({}, _defineProperty({}, componentId, rest)), Object.keys(dependentQueries).reduce(function (acc, q) {
+                    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, q, _objectSpread(_objectSpread({}, dependentQueries[q]), {}, {
+                      execute: false
+                    }, dependentQueries[q].type === queryTypes.suggestion ? {
+                      type: 'search'
+                    } : {})));
+                  }, {}));
+                }
+                // if (!compareQueries(queryToLog, currentQuery, false)) {
+                orderOfQueries = [].concat(_toConsumableArray(orderOfQueries), [componentId]);
+                queryLog = _objectSpread(_objectSpread({}, queryLog), {}, _defineProperty({}, componentId, queryToLog));
+                // }
+
+                if (query) {
+                  // Apply dependent queries
+                  var dependentQueriesToAppend = getDependentQueries(state, componentId, orderOfQueries);
+                  appbaseQuery = _objectSpread(_objectSpread({}, appbaseQuery), _defineProperty({}, componentId, query));
+                  Object.keys(dependentQueriesToAppend).forEach(function (cId) {
+                    if (appbaseQuery[cId]) {
+                      appbaseQuery[cId + Math.random()] = dependentQueriesToAppend[cId];
+                    } else {
+                      appbaseQuery[cId] = dependentQueriesToAppend[cId];
+                    }
+                  });
+                }
+              }
+            });
+            var handleRSResponse = function handleRSResponse(res) {
+              var promotedResults = {};
+              var rawData = {};
+              var customData = {};
+              var allPromises = orderOfQueries.map(function (component) {
+                return new Promise(function (responseResolve, responseReject) {
+                  handleTransformResponse(res[component], config, component).then(function (response) {
+                    if (response) {
+                      if (response.promoted) {
+                        promotedResults[component] = response.promoted.map(function (promoted) {
+                          return _objectSpread(_objectSpread({}, promoted.doc), {}, {
+                            _position: promoted.position
+                          });
+                        });
+                      }
+                      rawData[component] = response;
+                      // Update custom data
+                      if (response.customData) {
+                        customData[component] = response.customData;
+                      }
+                      if (response.aggregations) {
+                        aggregations = _objectSpread(_objectSpread({}, aggregations), {}, _defineProperty({}, component, response.aggregations));
+                      }
+                      var hitsObj = response.hits || {};
+                      hits = _objectSpread(_objectSpread({}, hits), {}, _defineProperty({}, component, {
+                        hits: hitsObj.hits,
+                        total: _typeof(hitsObj.total) === 'object' ? hitsObj.total.value : hitsObj.total,
+                        time: response.took
+                      }));
+                      responseResolve();
+                    }
+                  })["catch"](function (err) {
+                    responseReject(err);
+                  });
+                });
+              });
+              return Promise.all(allPromises).then(function () {
+                state = {
+                  queryList: queryList,
+                  queryOptions: queryOptions,
+                  selectedValues: newSelectedValues,
+                  internalValues: internalValues,
+                  queryLog: queryLog,
+                  hits: hits,
+                  aggregations: aggregations,
+                  promotedResults: promotedResults,
+                  customData: customData,
+                  rawData: rawData,
+                  dependencyTree: dependencyTree
+                };
+                return Promise.resolve(JSON.parse(JSON.stringify(state)));
+              });
+            };
+            if (Object.keys(appbaseQuery).length) {
+              finalQuery = Object.values(appbaseQuery);
+              // Call RS API
+              var rsAPISettings = {};
+              if (config.analyticsConfig) {
+                rsAPISettings.recordAnalytics = isPropertyDefined(config.analyticsConfig.recordAnalytics) ? config.analyticsConfig.recordAnalytics : undefined;
+                rsAPISettings.userId = isPropertyDefined(config.analyticsConfig.userId) ? config.analyticsConfig.userId : undefined;
+                rsAPISettings.enableQueryRules = isPropertyDefined(config.analyticsConfig.enableQueryRules) ? config.analyticsConfig.enableQueryRules : undefined;
+                rsAPISettings.customEvents = isPropertyDefined(config.analyticsConfig.customEvents) ? config.analyticsConfig.customEvents : undefined;
+              }
+              return appbaseRef.reactiveSearchv3(finalQuery, rsAPISettings).then(function (res) {
+                return handleRSResponse(res);
+              })["catch"](function (err) {
+                return Promise.reject(err);
+              });
+            }
+            throw new Error('Could not compute server-side initial state of the app!');
+          } else {
+            return null;
+          }
+        })["catch"](Promise.reject);
+      }
+      return null;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+};
 
 function getServerState(App, queryString) {
   var renderFunction = renderToString;