if (!window.define) {
    const modules = {};
    window.__modules = modules;
    const modulePromises = {};

    const thisScriptSource = document.currentScript.getAttribute('src');
    const srcDir = thisScriptSource.substring(0, thisScriptSource.lastIndexOf('/'));

    const load = (id) => {
        if (modules[id]) return modules[id];
        if (modulePromises[id]) return modulePromises[id];
        return modulePromises[id] = new Promise((resolve, reject) => {
            const script = document.createElement('script');
            script.src = srcDir + '/' + id + '.js';
            script.onload = () => modules[id].then(resolve);
            script.onerror = err => reject(new Error('failed to load ' + id));
            script.dataset.id = id;
            document.head.append(script);
        });
    };

    const require = (ids, callback) => {
        Promise.all(ids.map(load)).then(items => {
            if (items.length === 1) callback(items[0]);
            else callback(items);
        });
    };
    window.require = require;

    require.context = (dir, useSubdirs) => {
        if ((dir === "../../images/emoji" || dir === "../images/emoji") && !useSubdirs) {
            const data = {"chunks.png":"f59b84127fa7b6c48b6c.png","eggbug-classic.png":"41454e429d62b5cb7963.png","eggbug.png":"17aa2d48956926005de9.png","sixty.png":"9a6014af31fb1ca65a1f.png","unyeah.png":"5cf84d596a2c422967de.png","yeah.png":"014b0a8cc35206ef151d.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        } else if ((dir === "../../images/plus-emoji" || dir === "../images/plus-emoji") && !useSubdirs) {
            const data = {"eggbug-asleep.png":"ebbf360236a95b62bdfc.png","eggbug-devious.png":"c4f3f2c6b9ffb85934e7.png","eggbug-heart-sob.png":"b59709333449a01e3e0a.png","eggbug-nervous.png":"d2753b632211c395538e.png","eggbug-pensive.png":"ae53a8b5de7c919100e6.png","eggbug-pleading.png":"11c5493261064ffa82c0.png","eggbug-relieved.png":"3633c116f0941d94d237.png","eggbug-shocked.png":"b25a9fdf230219087003.png","eggbug-smile-hearts.png":"d7ec7f057e6fb15a94cc.png","eggbug-sob.png":"9559ff8058a895328d76.png","eggbug-tuesday.png":"90058099e741e483208a.png","eggbug-uwu.png":"228d3a13bd5f7796b434.png","eggbug-wink.png":"3bc3a1c5272e2ceb8712.png","host-aww.png":"9bb403f3822c6457baf6.png","host-cry.png":"530f8cf75eac87716702.png","host-evil.png":"cb9a5640d7ef7b361a1a.png","host-frown.png":"99c7fbf98de865cc9726.png","host-joy.png":"53635f5fe850274b1a7d.png","host-love.png":"c45b6d8f9de20f725b98.png","host-nervous.png":"e5d55348f39c65a20148.png","host-plead.png":"fa883e2377fea8945237.png","host-shock.png":"bfa6d6316fd95ae76803.png","host-stare.png":"a09d966cd188c9ebaa4c.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        }
        throw new Error('not supported: require.context for ' + dir);
    };

    window.define = (imports, exec) => {
        if (typeof imports === 'function') {
            exec = imports;
            imports = [];
        }
        const id = document.currentScript.dataset.id
            ?? './' + document.currentScript.getAttribute('src').split('/').pop().replace(/\.js$/i, '');
        if (modules[id]) return;
        const exports = {};
        modules[id] = Promise.resolve().then(function() {
            const imported = [];
            for (const id of imports) {
                if (id === 'require') imported.push(Promise.resolve(require));
                else if (id === 'exports') imported.push(Promise.resolve(exports));
                else imported.push(load(id));
            }
            return Promise.all(imported);
        }).then(function(imported) {
            const result = exec.apply(window, imported);
            if (!('default' in exports)) exports.default = result;
            return exports;
        });
    };

    window.process = { env: { NODE_ENV: 'production' } };
}

define(['exports', './post-page'], (function (exports, postPage) { 'use strict';

  function _mergeNamespaces(n, m) {
    m.forEach(function (e) {
      e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
        if (k !== 'default' && !(k in n)) {
          var d = Object.getOwnPropertyDescriptor(e, k);
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: function () { return e[k]; }
          });
        }
      });
    });
    return Object.freeze(n);
  }

  const initReactI18next = {
    type: '3rdParty',
    init(instance) {
      postPage.setDefaults(instance.options.react);
      postPage.setI18n(instance);
    }
  };

  function _classCallCheck$1(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties$1(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }
  function _createClass$1(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
    Object.defineProperty(Constructor, "prototype", {
      writable: false
    });
    return Constructor;
  }

  var arr$1 = [];
  var each$1 = arr$1.forEach;
  var slice$1 = arr$1.slice;
  function defaults$1(obj) {
    each$1.call(slice$1.call(arguments, 1), function (source) {
      if (source) {
        for (var prop in source) {
          if (obj[prop] === undefined) obj[prop] = source[prop];
        }
      }
    });
    return obj;
  }
  function createClassOnDemand(ClassOrObject) {
    if (!ClassOrObject) return null;
    if (typeof ClassOrObject === 'function') return new ClassOrObject();
    return ClassOrObject;
  }

  function getDefaults$2() {
    return {
      handleEmptyResourcesAsFailed: true
    };
  }
  var Backend$1 = /*#__PURE__*/function () {
    function Backend(services) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      _classCallCheck$1(this, Backend);
      this.backends = [];
      this.type = 'backend';
      this.init(services, options);
    }
    _createClass$1(Backend, [{
      key: "init",
      value: function init(services) {
        var _this = this;
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var i18nextOptions = arguments.length > 2 ? arguments[2] : undefined;
        this.services = services;
        this.options = defaults$1(options, this.options || {}, getDefaults$2());
        this.options.backends && this.options.backends.forEach(function (b, i) {
          _this.backends[i] = _this.backends[i] || createClassOnDemand(b);
          _this.backends[i].init(services, _this.options.backendOptions && _this.options.backendOptions[i] || {}, i18nextOptions);
        });
      }
    }, {
      key: "read",
      value: function read(language, namespace, callback) {
        var _this2 = this;
        var bLen = this.backends.length;
        var loadPosition = function loadPosition(pos) {
          if (pos >= bLen) return callback(new Error('non of the backend loaded data;', true)); // failed pass retry flag
          var isLastBackend = pos === bLen - 1;
          var lengthCheckAmount = _this2.options.handleEmptyResourcesAsFailed && !isLastBackend ? 0 : -1;
          var backend = _this2.backends[pos];
          if (backend.read) {
            backend.read(language, namespace, function (err, data) {
              if (!err && data && Object.keys(data).length > lengthCheckAmount) {
                callback(null, data, pos);
                savePosition(pos - 1, data); // save one in front
              } else {
                loadPosition(pos + 1); // try load from next
              }
            });
          } else {
            loadPosition(pos + 1); // try load from next
          }
        };

        var savePosition = function savePosition(pos, data) {
          if (pos < 0) return;
          var backend = _this2.backends[pos];
          if (backend.save) {
            backend.save(language, namespace, data);
            savePosition(pos - 1, data);
          } else {
            savePosition(pos - 1, data);
          }
        };
        loadPosition(0);
      }
    }, {
      key: "create",
      value: function create(languages, namespace, key, fallbackValue, callback, options) {
        this.backends.forEach(function (b) {
          if (b.create) b.create(languages, namespace, key, fallbackValue, null, options);
        });
      }
    }]);
    return Backend;
  }();
  Backend$1.type = 'backend';

  function _typeof$2(obj) { "@babel/helpers - typeof"; return _typeof$2 = "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$2(obj); }
  var arr = [];
  var each = arr.forEach;
  var slice = arr.slice;
  function defaults(obj) {
    each.call(slice.call(arguments, 1), function (source) {
      if (source) {
        for (var prop in source) {
          if (obj[prop] === undefined) obj[prop] = source[prop];
        }
      }
    });
    return obj;
  }
  function hasXMLHttpRequest() {
    return typeof XMLHttpRequest === 'function' || (typeof XMLHttpRequest === "undefined" ? "undefined" : _typeof$2(XMLHttpRequest)) === 'object';
  }

  function isPromise(maybePromise) {
    return !!maybePromise && typeof maybePromise.then === 'function';
  }

  function makePromise(maybePromise) {
    if (isPromise(maybePromise)) {
      return maybePromise;
    }
    return Promise.resolve(maybePromise);
  }

  function commonjsRequire(path) {
  	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
  }

  var getFetch$1 = {exports: {}};

  var browserPonyfill = {exports: {}};

  var hasRequiredBrowserPonyfill;

  function requireBrowserPonyfill () {
  	if (hasRequiredBrowserPonyfill) return browserPonyfill.exports;
  	hasRequiredBrowserPonyfill = 1;
  	(function (module, exports) {
  		var global = typeof self !== 'undefined' ? self : postPage.commonjsGlobal;
  		var __self__ = (function () {
  		function F() {
  		this.fetch = false;
  		this.DOMException = global.DOMException;
  		}
  		F.prototype = global;
  		return new F();
  		})();
  		(function(self) {

  		((function (exports) {

  		  var support = {
  		    searchParams: 'URLSearchParams' in self,
  		    iterable: 'Symbol' in self && 'iterator' in Symbol,
  		    blob:
  		      'FileReader' in self &&
  		      'Blob' in self &&
  		      (function() {
  		        try {
  		          new Blob();
  		          return true
  		        } catch (e) {
  		          return false
  		        }
  		      })(),
  		    formData: 'FormData' in self,
  		    arrayBuffer: 'ArrayBuffer' in self
  		  };

  		  function isDataView(obj) {
  		    return obj && DataView.prototype.isPrototypeOf(obj)
  		  }

  		  if (support.arrayBuffer) {
  		    var viewClasses = [
  		      '[object Int8Array]',
  		      '[object Uint8Array]',
  		      '[object Uint8ClampedArray]',
  		      '[object Int16Array]',
  		      '[object Uint16Array]',
  		      '[object Int32Array]',
  		      '[object Uint32Array]',
  		      '[object Float32Array]',
  		      '[object Float64Array]'
  		    ];

  		    var isArrayBufferView =
  		      ArrayBuffer.isView ||
  		      function(obj) {
  		        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
  		      };
  		  }

  		  function normalizeName(name) {
  		    if (typeof name !== 'string') {
  		      name = String(name);
  		    }
  		    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
  		      throw new TypeError('Invalid character in header field name')
  		    }
  		    return name.toLowerCase()
  		  }

  		  function normalizeValue(value) {
  		    if (typeof value !== 'string') {
  		      value = String(value);
  		    }
  		    return value
  		  }

  		  // Build a destructive iterator for the value list
  		  function iteratorFor(items) {
  		    var iterator = {
  		      next: function() {
  		        var value = items.shift();
  		        return {done: value === undefined, value: value}
  		      }
  		    };

  		    if (support.iterable) {
  		      iterator[Symbol.iterator] = function() {
  		        return iterator
  		      };
  		    }

  		    return iterator
  		  }

  		  function Headers(headers) {
  		    this.map = {};

  		    if (headers instanceof Headers) {
  		      headers.forEach(function(value, name) {
  		        this.append(name, value);
  		      }, this);
  		    } else if (Array.isArray(headers)) {
  		      headers.forEach(function(header) {
  		        this.append(header[0], header[1]);
  		      }, this);
  		    } else if (headers) {
  		      Object.getOwnPropertyNames(headers).forEach(function(name) {
  		        this.append(name, headers[name]);
  		      }, this);
  		    }
  		  }

  		  Headers.prototype.append = function(name, value) {
  		    name = normalizeName(name);
  		    value = normalizeValue(value);
  		    var oldValue = this.map[name];
  		    this.map[name] = oldValue ? oldValue + ', ' + value : value;
  		  };

  		  Headers.prototype['delete'] = function(name) {
  		    delete this.map[normalizeName(name)];
  		  };

  		  Headers.prototype.get = function(name) {
  		    name = normalizeName(name);
  		    return this.has(name) ? this.map[name] : null
  		  };

  		  Headers.prototype.has = function(name) {
  		    return this.map.hasOwnProperty(normalizeName(name))
  		  };

  		  Headers.prototype.set = function(name, value) {
  		    this.map[normalizeName(name)] = normalizeValue(value);
  		  };

  		  Headers.prototype.forEach = function(callback, thisArg) {
  		    for (var name in this.map) {
  		      if (this.map.hasOwnProperty(name)) {
  		        callback.call(thisArg, this.map[name], name, this);
  		      }
  		    }
  		  };

  		  Headers.prototype.keys = function() {
  		    var items = [];
  		    this.forEach(function(value, name) {
  		      items.push(name);
  		    });
  		    return iteratorFor(items)
  		  };

  		  Headers.prototype.values = function() {
  		    var items = [];
  		    this.forEach(function(value) {
  		      items.push(value);
  		    });
  		    return iteratorFor(items)
  		  };

  		  Headers.prototype.entries = function() {
  		    var items = [];
  		    this.forEach(function(value, name) {
  		      items.push([name, value]);
  		    });
  		    return iteratorFor(items)
  		  };

  		  if (support.iterable) {
  		    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
  		  }

  		  function consumed(body) {
  		    if (body.bodyUsed) {
  		      return Promise.reject(new TypeError('Already read'))
  		    }
  		    body.bodyUsed = true;
  		  }

  		  function fileReaderReady(reader) {
  		    return new Promise(function(resolve, reject) {
  		      reader.onload = function() {
  		        resolve(reader.result);
  		      };
  		      reader.onerror = function() {
  		        reject(reader.error);
  		      };
  		    })
  		  }

  		  function readBlobAsArrayBuffer(blob) {
  		    var reader = new FileReader();
  		    var promise = fileReaderReady(reader);
  		    reader.readAsArrayBuffer(blob);
  		    return promise
  		  }

  		  function readBlobAsText(blob) {
  		    var reader = new FileReader();
  		    var promise = fileReaderReady(reader);
  		    reader.readAsText(blob);
  		    return promise
  		  }

  		  function readArrayBufferAsText(buf) {
  		    var view = new Uint8Array(buf);
  		    var chars = new Array(view.length);

  		    for (var i = 0; i < view.length; i++) {
  		      chars[i] = String.fromCharCode(view[i]);
  		    }
  		    return chars.join('')
  		  }

  		  function bufferClone(buf) {
  		    if (buf.slice) {
  		      return buf.slice(0)
  		    } else {
  		      var view = new Uint8Array(buf.byteLength);
  		      view.set(new Uint8Array(buf));
  		      return view.buffer
  		    }
  		  }

  		  function Body() {
  		    this.bodyUsed = false;

  		    this._initBody = function(body) {
  		      this._bodyInit = body;
  		      if (!body) {
  		        this._bodyText = '';
  		      } else if (typeof body === 'string') {
  		        this._bodyText = body;
  		      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
  		        this._bodyBlob = body;
  		      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
  		        this._bodyFormData = body;
  		      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
  		        this._bodyText = body.toString();
  		      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
  		        this._bodyArrayBuffer = bufferClone(body.buffer);
  		        // IE 10-11 can't handle a DataView body.
  		        this._bodyInit = new Blob([this._bodyArrayBuffer]);
  		      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
  		        this._bodyArrayBuffer = bufferClone(body);
  		      } else {
  		        this._bodyText = body = Object.prototype.toString.call(body);
  		      }

  		      if (!this.headers.get('content-type')) {
  		        if (typeof body === 'string') {
  		          this.headers.set('content-type', 'text/plain;charset=UTF-8');
  		        } else if (this._bodyBlob && this._bodyBlob.type) {
  		          this.headers.set('content-type', this._bodyBlob.type);
  		        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
  		          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
  		        }
  		      }
  		    };

  		    if (support.blob) {
  		      this.blob = function() {
  		        var rejected = consumed(this);
  		        if (rejected) {
  		          return rejected
  		        }

  		        if (this._bodyBlob) {
  		          return Promise.resolve(this._bodyBlob)
  		        } else if (this._bodyArrayBuffer) {
  		          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
  		        } else if (this._bodyFormData) {
  		          throw new Error('could not read FormData body as blob')
  		        } else {
  		          return Promise.resolve(new Blob([this._bodyText]))
  		        }
  		      };

  		      this.arrayBuffer = function() {
  		        if (this._bodyArrayBuffer) {
  		          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
  		        } else {
  		          return this.blob().then(readBlobAsArrayBuffer)
  		        }
  		      };
  		    }

  		    this.text = function() {
  		      var rejected = consumed(this);
  		      if (rejected) {
  		        return rejected
  		      }

  		      if (this._bodyBlob) {
  		        return readBlobAsText(this._bodyBlob)
  		      } else if (this._bodyArrayBuffer) {
  		        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
  		      } else if (this._bodyFormData) {
  		        throw new Error('could not read FormData body as text')
  		      } else {
  		        return Promise.resolve(this._bodyText)
  		      }
  		    };

  		    if (support.formData) {
  		      this.formData = function() {
  		        return this.text().then(decode)
  		      };
  		    }

  		    this.json = function() {
  		      return this.text().then(JSON.parse)
  		    };

  		    return this
  		  }

  		  // HTTP methods whose capitalization should be normalized
  		  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];

  		  function normalizeMethod(method) {
  		    var upcased = method.toUpperCase();
  		    return methods.indexOf(upcased) > -1 ? upcased : method
  		  }

  		  function Request(input, options) {
  		    options = options || {};
  		    var body = options.body;

  		    if (input instanceof Request) {
  		      if (input.bodyUsed) {
  		        throw new TypeError('Already read')
  		      }
  		      this.url = input.url;
  		      this.credentials = input.credentials;
  		      if (!options.headers) {
  		        this.headers = new Headers(input.headers);
  		      }
  		      this.method = input.method;
  		      this.mode = input.mode;
  		      this.signal = input.signal;
  		      if (!body && input._bodyInit != null) {
  		        body = input._bodyInit;
  		        input.bodyUsed = true;
  		      }
  		    } else {
  		      this.url = String(input);
  		    }

  		    this.credentials = options.credentials || this.credentials || 'same-origin';
  		    if (options.headers || !this.headers) {
  		      this.headers = new Headers(options.headers);
  		    }
  		    this.method = normalizeMethod(options.method || this.method || 'GET');
  		    this.mode = options.mode || this.mode || null;
  		    this.signal = options.signal || this.signal;
  		    this.referrer = null;

  		    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
  		      throw new TypeError('Body not allowed for GET or HEAD requests')
  		    }
  		    this._initBody(body);
  		  }

  		  Request.prototype.clone = function() {
  		    return new Request(this, {body: this._bodyInit})
  		  };

  		  function decode(body) {
  		    var form = new FormData();
  		    body
  		      .trim()
  		      .split('&')
  		      .forEach(function(bytes) {
  		        if (bytes) {
  		          var split = bytes.split('=');
  		          var name = split.shift().replace(/\+/g, ' ');
  		          var value = split.join('=').replace(/\+/g, ' ');
  		          form.append(decodeURIComponent(name), decodeURIComponent(value));
  		        }
  		      });
  		    return form
  		  }

  		  function parseHeaders(rawHeaders) {
  		    var headers = new Headers();
  		    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
  		    // https://tools.ietf.org/html/rfc7230#section-3.2
  		    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
  		    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
  		      var parts = line.split(':');
  		      var key = parts.shift().trim();
  		      if (key) {
  		        var value = parts.join(':').trim();
  		        headers.append(key, value);
  		      }
  		    });
  		    return headers
  		  }

  		  Body.call(Request.prototype);

  		  function Response(bodyInit, options) {
  		    if (!options) {
  		      options = {};
  		    }

  		    this.type = 'default';
  		    this.status = options.status === undefined ? 200 : options.status;
  		    this.ok = this.status >= 200 && this.status < 300;
  		    this.statusText = 'statusText' in options ? options.statusText : 'OK';
  		    this.headers = new Headers(options.headers);
  		    this.url = options.url || '';
  		    this._initBody(bodyInit);
  		  }

  		  Body.call(Response.prototype);

  		  Response.prototype.clone = function() {
  		    return new Response(this._bodyInit, {
  		      status: this.status,
  		      statusText: this.statusText,
  		      headers: new Headers(this.headers),
  		      url: this.url
  		    })
  		  };

  		  Response.error = function() {
  		    var response = new Response(null, {status: 0, statusText: ''});
  		    response.type = 'error';
  		    return response
  		  };

  		  var redirectStatuses = [301, 302, 303, 307, 308];

  		  Response.redirect = function(url, status) {
  		    if (redirectStatuses.indexOf(status) === -1) {
  		      throw new RangeError('Invalid status code')
  		    }

  		    return new Response(null, {status: status, headers: {location: url}})
  		  };

  		  exports.DOMException = self.DOMException;
  		  try {
  		    new exports.DOMException();
  		  } catch (err) {
  		    exports.DOMException = function(message, name) {
  		      this.message = message;
  		      this.name = name;
  		      var error = Error(message);
  		      this.stack = error.stack;
  		    };
  		    exports.DOMException.prototype = Object.create(Error.prototype);
  		    exports.DOMException.prototype.constructor = exports.DOMException;
  		  }

  		  function fetch(input, init) {
  		    return new Promise(function(resolve, reject) {
  		      var request = new Request(input, init);

  		      if (request.signal && request.signal.aborted) {
  		        return reject(new exports.DOMException('Aborted', 'AbortError'))
  		      }

  		      var xhr = new XMLHttpRequest();

  		      function abortXhr() {
  		        xhr.abort();
  		      }

  		      xhr.onload = function() {
  		        var options = {
  		          status: xhr.status,
  		          statusText: xhr.statusText,
  		          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
  		        };
  		        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
  		        var body = 'response' in xhr ? xhr.response : xhr.responseText;
  		        resolve(new Response(body, options));
  		      };

  		      xhr.onerror = function() {
  		        reject(new TypeError('Network request failed'));
  		      };

  		      xhr.ontimeout = function() {
  		        reject(new TypeError('Network request failed'));
  		      };

  		      xhr.onabort = function() {
  		        reject(new exports.DOMException('Aborted', 'AbortError'));
  		      };

  		      xhr.open(request.method, request.url, true);

  		      if (request.credentials === 'include') {
  		        xhr.withCredentials = true;
  		      } else if (request.credentials === 'omit') {
  		        xhr.withCredentials = false;
  		      }

  		      if ('responseType' in xhr && support.blob) {
  		        xhr.responseType = 'blob';
  		      }

  		      request.headers.forEach(function(value, name) {
  		        xhr.setRequestHeader(name, value);
  		      });

  		      if (request.signal) {
  		        request.signal.addEventListener('abort', abortXhr);

  		        xhr.onreadystatechange = function() {
  		          // DONE (success or failure)
  		          if (xhr.readyState === 4) {
  		            request.signal.removeEventListener('abort', abortXhr);
  		          }
  		        };
  		      }

  		      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
  		    })
  		  }

  		  fetch.polyfill = true;

  		  if (!self.fetch) {
  		    self.fetch = fetch;
  		    self.Headers = Headers;
  		    self.Request = Request;
  		    self.Response = Response;
  		  }

  		  exports.Headers = Headers;
  		  exports.Request = Request;
  		  exports.Response = Response;
  		  exports.fetch = fetch;

  		  Object.defineProperty(exports, '__esModule', { value: true });

  		  return exports;

  		}))({});
  		})(__self__);
  		__self__.fetch.ponyfill = true;
  		// Remove "polyfill" property added by whatwg-fetch
  		delete __self__.fetch.polyfill;
  		// Choose between native implementation (global) or custom implementation (__self__)
  		// var ctx = global.fetch ? global : __self__;
  		var ctx = __self__; // this line disable service worker support temporarily
  		exports = ctx.fetch; // To enable: import fetch from 'cross-fetch'
  		exports.default = ctx.fetch; // For TypeScript consumers without esModuleInterop.
  		exports.fetch = ctx.fetch; // To enable: import {fetch} from 'cross-fetch'
  		exports.Headers = ctx.Headers;
  		exports.Request = ctx.Request;
  		exports.Response = ctx.Response;
  		module.exports = exports; 
  	} (browserPonyfill, browserPonyfill.exports));
  	return browserPonyfill.exports;
  }

  (function (module, exports) {
  	var fetchApi;
  	if (typeof fetch === 'function') {
  	  if (typeof postPage.commonjsGlobal !== 'undefined' && postPage.commonjsGlobal.fetch) {
  	    fetchApi = postPage.commonjsGlobal.fetch;
  	  } else if (typeof window !== 'undefined' && window.fetch) {
  	    fetchApi = window.fetch;
  	  } else {
  	    fetchApi = fetch;
  	  }
  	}

  	if (typeof commonjsRequire !== 'undefined' && (typeof window === 'undefined' || typeof window.document === 'undefined')) {
  	  var f = fetchApi || requireBrowserPonyfill();
  	  if (f.default) f = f.default;
  	  exports.default = f;
  	  module.exports = exports.default;
  	} 
  } (getFetch$1, getFetch$1.exports));

  var getFetchExports = getFetch$1.exports;
  var getFetch = /*@__PURE__*/postPage.getDefaultExportFromCjs(getFetchExports);

  var fetchNode = /*#__PURE__*/_mergeNamespaces({
    __proto__: null,
    default: getFetch
  }, [getFetchExports]);

  function _typeof$1(obj) { "@babel/helpers - typeof"; return _typeof$1 = "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$1(obj); }
  var fetchApi;
  if (typeof fetch === 'function') {
    if (typeof global !== 'undefined' && global.fetch) {
      fetchApi = global.fetch;
    } else if (typeof window !== 'undefined' && window.fetch) {
      fetchApi = window.fetch;
    } else {
      fetchApi = fetch;
    }
  }
  var XmlHttpRequestApi;
  if (hasXMLHttpRequest()) {
    if (typeof global !== 'undefined' && global.XMLHttpRequest) {
      XmlHttpRequestApi = global.XMLHttpRequest;
    } else if (typeof window !== 'undefined' && window.XMLHttpRequest) {
      XmlHttpRequestApi = window.XMLHttpRequest;
    }
  }
  var ActiveXObjectApi;
  if (typeof ActiveXObject === 'function') {
    if (typeof global !== 'undefined' && global.ActiveXObject) {
      ActiveXObjectApi = global.ActiveXObject;
    } else if (typeof window !== 'undefined' && window.ActiveXObject) {
      ActiveXObjectApi = window.ActiveXObject;
    }
  }
  if (!fetchApi && fetchNode && !XmlHttpRequestApi && !ActiveXObjectApi) fetchApi = getFetch || fetchNode;
  if (typeof fetchApi !== 'function') fetchApi = undefined;
  var addQueryString = function addQueryString(url, params) {
    if (params && _typeof$1(params) === 'object') {
      var queryString = '';
      for (var paramName in params) {
        queryString += '&' + encodeURIComponent(paramName) + '=' + encodeURIComponent(params[paramName]);
      }
      if (!queryString) return url;
      url = url + (url.indexOf('?') !== -1 ? '&' : '?') + queryString.slice(1);
    }
    return url;
  };
  var fetchIt = function fetchIt(url, fetchOptions, callback) {
    fetchApi(url, fetchOptions).then(function (response) {
      if (!response.ok) return callback(response.statusText || 'Error', {
        status: response.status
      });
      response.text().then(function (data) {
        callback(null, {
          status: response.status,
          data: data
        });
      }).catch(callback);
    }).catch(callback);
  };
  var omitFetchOptions = false;

  var requestWithFetch = function requestWithFetch(options, url, payload, callback) {
    if (options.queryStringParams) {
      url = addQueryString(url, options.queryStringParams);
    }
    var headers = defaults({}, typeof options.customHeaders === 'function' ? options.customHeaders() : options.customHeaders);
    if (payload) headers['Content-Type'] = 'application/json';
    var reqOptions = typeof options.requestOptions === 'function' ? options.requestOptions(payload) : options.requestOptions;
    var fetchOptions = defaults({
      method: payload ? 'POST' : 'GET',
      body: payload ? options.stringify(payload) : undefined,
      headers: headers
    }, omitFetchOptions ? {} : reqOptions);
    try {
      fetchIt(url, fetchOptions, callback);
    } catch (e) {
      if (!reqOptions || Object.keys(reqOptions).length === 0 || !e.message || e.message.indexOf('not implemented') < 0) {
        return callback(e);
      }
      try {
        Object.keys(reqOptions).forEach(function (opt) {
          delete fetchOptions[opt];
        });
        fetchIt(url, fetchOptions, callback);
        omitFetchOptions = true;
      } catch (err) {
        callback(err);
      }
    }
  };

  var requestWithXmlHttpRequest = function requestWithXmlHttpRequest(options, url, payload, callback) {
    if (payload && _typeof$1(payload) === 'object') {
      payload = addQueryString('', payload).slice(1);
    }
    if (options.queryStringParams) {
      url = addQueryString(url, options.queryStringParams);
    }
    try {
      var x;
      if (XmlHttpRequestApi) {
        x = new XmlHttpRequestApi();
      } else {
        x = new ActiveXObjectApi('MSXML2.XMLHTTP.3.0');
      }
      x.open(payload ? 'POST' : 'GET', url, 1);
      if (!options.crossDomain) {
        x.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
      }
      x.withCredentials = !!options.withCredentials;
      if (payload) {
        x.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
      }
      if (x.overrideMimeType) {
        x.overrideMimeType('application/json');
      }
      var h = options.customHeaders;
      h = typeof h === 'function' ? h() : h;
      if (h) {
        for (var i in h) {
          x.setRequestHeader(i, h[i]);
        }
      }
      x.onreadystatechange = function () {
        x.readyState > 3 && callback(x.status >= 400 ? x.statusText : null, {
          status: x.status,
          data: x.responseText
        });
      };
      x.send(payload);
    } catch (e) {
      console && console.log(e);
    }
  };
  var request = function request(options, url, payload, callback) {
    if (typeof payload === 'function') {
      callback = payload;
      payload = undefined;
    }
    callback = callback || function () {};
    if (fetchApi && url.indexOf('file:') !== 0) {
      return requestWithFetch(options, url, payload, callback);
    }
    if (hasXMLHttpRequest() || typeof ActiveXObject === 'function') {
      return requestWithXmlHttpRequest(options, url, payload, callback);
    }
    callback(new Error('No fetch and no xhr implementation found!'));
  };

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
  function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  var getDefaults$1 = function getDefaults() {
    return {
      loadPath: '/locales/{{lng}}/{{ns}}.json',
      addPath: '/locales/add/{{lng}}/{{ns}}',
      allowMultiLoading: false,
      parse: function parse(data) {
        return JSON.parse(data);
      },
      stringify: JSON.stringify,
      parsePayload: function parsePayload(namespace, key, fallbackValue) {
        return _defineProperty$1({}, key, fallbackValue || '');
      },
      request: request,
      reloadInterval: typeof window !== 'undefined' ? false : 60 * 60 * 1000,
      customHeaders: {},
      queryStringParams: {},
      crossDomain: false,
      withCredentials: false,
      overrideMimeType: false,
      requestOptions: {
        mode: 'cors',
        credentials: 'same-origin',
        cache: 'default'
      }
    };
  };
  var Backend = function () {
    function Backend(services) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      _classCallCheck(this, Backend);
      this.services = services;
      this.options = options;
      this.allOptions = allOptions;
      this.type = 'backend';
      this.init(services, options, allOptions);
    }
    _createClass(Backend, [{
      key: "init",
      value: function init(services) {
        var _this = this;
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        this.services = services;
        this.options = defaults(options, this.options || {}, getDefaults$1());
        this.allOptions = allOptions;
        if (this.services && this.options.reloadInterval) {
          setInterval(function () {
            return _this.reload();
          }, this.options.reloadInterval);
        }
      }
    }, {
      key: "readMulti",
      value: function readMulti(languages, namespaces, callback) {
        this._readAny(languages, languages, namespaces, namespaces, callback);
      }
    }, {
      key: "read",
      value: function read(language, namespace, callback) {
        this._readAny([language], language, [namespace], namespace, callback);
      }
    }, {
      key: "_readAny",
      value: function _readAny(languages, loadUrlLanguages, namespaces, loadUrlNamespaces, callback) {
        var _this2 = this;
        var loadPath = this.options.loadPath;
        if (typeof this.options.loadPath === 'function') {
          loadPath = this.options.loadPath(languages, namespaces);
        }
        loadPath = makePromise(loadPath);
        loadPath.then(function (resolvedLoadPath) {
          if (!resolvedLoadPath) return callback(null, {});
          var url = _this2.services.interpolator.interpolate(resolvedLoadPath, {
            lng: languages.join('+'),
            ns: namespaces.join('+')
          });
          _this2.loadUrl(url, callback, loadUrlLanguages, loadUrlNamespaces);
        });
      }
    }, {
      key: "loadUrl",
      value: function loadUrl(url, callback, languages, namespaces) {
        var _this3 = this;
        this.options.request(this.options, url, undefined, function (err, res) {
          if (res && (res.status >= 500 && res.status < 600 || !res.status)) return callback('failed loading ' + url + '; status code: ' + res.status, true);
          if (res && res.status >= 400 && res.status < 500) return callback('failed loading ' + url + '; status code: ' + res.status, false);
          if (!res && err && err.message && err.message.indexOf('Failed to fetch') > -1) return callback('failed loading ' + url + ': ' + err.message, true);
          if (err) return callback(err, false);
          var ret, parseErr;
          try {
            if (typeof res.data === 'string') {
              ret = _this3.options.parse(res.data, languages, namespaces);
            } else {
              ret = res.data;
            }
          } catch (e) {
            parseErr = 'failed parsing ' + url + ' to json';
          }
          if (parseErr) return callback(parseErr, false);
          callback(null, ret);
        });
      }
    }, {
      key: "create",
      value: function create(languages, namespace, key, fallbackValue, callback) {
        var _this4 = this;
        if (!this.options.addPath) return;
        if (typeof languages === 'string') languages = [languages];
        var payload = this.options.parsePayload(namespace, key, fallbackValue);
        var finished = 0;
        var dataArray = [];
        var resArray = [];
        languages.forEach(function (lng) {
          var addPath = _this4.options.addPath;
          if (typeof _this4.options.addPath === 'function') {
            addPath = _this4.options.addPath(lng, namespace);
          }
          var url = _this4.services.interpolator.interpolate(addPath, {
            lng: lng,
            ns: namespace
          });
          _this4.options.request(_this4.options, url, payload, function (data, res) {
            finished += 1;
            dataArray.push(data);
            resArray.push(res);
            if (finished === languages.length) {
              if (callback) callback(dataArray, resArray);
            }
          });
        });
      }
    }, {
      key: "reload",
      value: function reload() {
        var _this5 = this;
        var _this$services = this.services,
          backendConnector = _this$services.backendConnector,
          languageUtils = _this$services.languageUtils,
          logger = _this$services.logger;
        var currentLanguage = backendConnector.language;
        if (currentLanguage && currentLanguage.toLowerCase() === 'cimode') return;

        var toLoad = [];
        var append = function append(lng) {
          var lngs = languageUtils.toResolveHierarchy(lng);
          lngs.forEach(function (l) {
            if (toLoad.indexOf(l) < 0) toLoad.push(l);
          });
        };
        append(currentLanguage);
        if (this.allOptions.preload) this.allOptions.preload.forEach(function (l) {
          return append(l);
        });
        toLoad.forEach(function (lng) {
          _this5.allOptions.ns.forEach(function (ns) {
            backendConnector.read(lng, ns, 'read', null, null, function (err, data) {
              if (err) logger.warn("loading namespace ".concat(ns, " for language ").concat(lng, " failed"), err);
              if (!err && data) logger.log("loaded namespace ".concat(ns, " for language ").concat(lng), data);
              backendConnector.loaded("".concat(lng, "|").concat(ns), err, data);
            });
          });
        });
      }
    }]);
    return Backend;
  }();
  Backend.type = 'backend';

  function _typeof(o) {
    "@babel/helpers - typeof";

    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
      return typeof o;
    } : function (o) {
      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
    }, _typeof(o);
  }

  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 _toPropertyKey(arg) {
    var key = _toPrimitive(arg, "string");
    return _typeof(key) === "symbol" ? key : String(key);
  }

  function _defineProperty(obj, key, value) {
    key = _toPropertyKey(key);
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }

  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; }
  /* eslint-disable max-classes-per-file */
  var Storage = /*#__PURE__*/function () {
    function Storage(options) {
      _classCallCheck$1(this, Storage);
      this.store = options.store;
    }
    _createClass$1(Storage, [{
      key: "setItem",
      value: function setItem(key, value) {
        if (this.store) {
          try {
            this.store.setItem(key, value);
          } catch (e) {
            // f.log('failed to set value for key "' + key + '" to localStorage.');
          }
        }
      }
    }, {
      key: "getItem",
      value: function getItem(key, value) {
        if (this.store) {
          try {
            return this.store.getItem(key, value);
          } catch (e) {
            // f.log('failed to get value for key "' + key + '" from localStorage.');
          }
        }
        return undefined;
      }
    }]);
    return Storage;
  }();
  function getDefaults() {
    return {
      prefix: 'i18next_res_',
      expirationTime: 7 * 24 * 60 * 60 * 1000,
      defaultVersion: undefined,
      versions: {},
      store: typeof window !== 'undefined' ? window.localStorage : null
    };
  }
  var Cache = /*#__PURE__*/function () {
    function Cache(services) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      _classCallCheck$1(this, Cache);
      this.init(services, options);
      this.type = 'backend';
    }
    _createClass$1(Cache, [{
      key: "init",
      value: function init(services) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        this.services = services;
        this.options = _objectSpread(_objectSpread(_objectSpread({}, getDefaults()), this.options), options);
        this.storage = new Storage(this.options);
      }
    }, {
      key: "read",
      value: function read(language, namespace, callback) {
        var nowMS = new Date().getTime();
        if (!this.storage.store) {
          return callback(null, null);
        }
        var local = this.storage.getItem("".concat(this.options.prefix).concat(language, "-").concat(namespace));
        if (local) {
          local = JSON.parse(local);
          var version = this.getVersion(language);
          if (
          // expiration field is mandatory, and should not be expired
          local.i18nStamp && local.i18nStamp + this.options.expirationTime > nowMS &&
          // there should be no language version set, or if it is, it should match the one in translation
          version === local.i18nVersion) {
            delete local.i18nVersion;
            delete local.i18nStamp;
            return callback(null, local);
          }
        }
        return callback(null, null);
      }
    }, {
      key: "save",
      value: function save(language, namespace, data) {
        if (this.storage.store) {
          data.i18nStamp = new Date().getTime();

          // language version (if set)
          var version = this.getVersion(language);
          if (version) {
            data.i18nVersion = version;
          }

          // save
          this.storage.setItem("".concat(this.options.prefix).concat(language, "-").concat(namespace), JSON.stringify(data));
        }
      }
    }, {
      key: "getVersion",
      value: function getVersion(language) {
        return this.options.versions[language] || this.options.defaultVersion;
      }
    }]);
    return Cache;
  }();
  Cache.type = 'backend';

  // @ts-expect-error there's some weird shit happening with declaration merging. i can't figure it out.
  postPage.instance.use(Backend$1)
      .use(initReactI18next)
      .init({
          backend: {
              backends: [Cache, Backend],
              backendOptions: [
                  {
                      expirationTime: 30 * 24 * 60 * 60 * 1000, // 30 days
                      defaultVersion: postPage.env.VERSION,
                  },
                  {
                      loadPath: "../.." + `/rc/locales/{{lng}}/{{ns}}.json?${postPage.env.VERSION}`,
                  },
              ],
          },
          lng: "en",
          fallbackLng: "en",
          debug: 'production' !== "production",
          interpolation: { escapeValue: true },
          // TODO: move server keys that are actually needed on the client to `client` namespace
          ns: ["client", "common", "server"],
          react: {
              useSuspense: false,
          },
      })
      .catch((e) => console.error(e));

  // ye olde hack to make common strings used in interpolation stick around
  // t("common:username", "username")
  // t("common:handle", "handle")
  // t("common:email", "e-mail")
  // t("common:password", "password")

  exports.default = postPage.instance;

}));