@everymatrix/player-transaction-history 0.0.163

package/dist/player-transaction-history.js

@@ -0,0 +1,4820 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.app = factory());
+}(this, (function () { 'use strict';
+
+    function noop$1() { }
+    function add_location(element, file, line, column, char) {
+        element.__svelte_meta = {
+            loc: { file, line, column, char }
+        };
+    }
+    function run(fn) {
+        return fn();
+    }
+    function blank_object() {
+        return Object.create(null);
+    }
+    function run_all(fns) {
+        fns.forEach(run);
+    }
+    function is_function(thing) {
+        return typeof thing === 'function';
+    }
+    function safe_not_equal(a, b) {
+        return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+    }
+    function is_empty(obj) {
+        return Object.keys(obj).length === 0;
+    }
+    function subscribe(store, ...callbacks) {
+        if (store == null) {
+            return noop$1;
+        }
+        const unsub = store.subscribe(...callbacks);
+        return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
+    }
+
+    function append(target, node) {
+        target.appendChild(node);
+    }
+    function insert(target, node, anchor) {
+        target.insertBefore(node, anchor || null);
+    }
+    function detach(node) {
+        node.parentNode.removeChild(node);
+    }
+    function element(name) {
+        return document.createElement(name);
+    }
+    function svg_element(name) {
+        return document.createElementNS('http://www.w3.org/2000/svg', name);
+    }
+    function text(data) {
+        return document.createTextNode(data);
+    }
+    function space() {
+        return text(' ');
+    }
+    function listen(node, event, handler, options) {
+        node.addEventListener(event, handler, options);
+        return () => node.removeEventListener(event, handler, options);
+    }
+    function attr(node, attribute, value) {
+        if (value == null)
+            node.removeAttribute(attribute);
+        else if (node.getAttribute(attribute) !== value)
+            node.setAttribute(attribute, value);
+    }
+    function children(element) {
+        return Array.from(element.childNodes);
+    }
+    function custom_event(type, detail) {
+        const e = document.createEvent('CustomEvent');
+        e.initCustomEvent(type, false, false, detail);
+        return e;
+    }
+    function attribute_to_object(attributes) {
+        const result = {};
+        for (const attribute of attributes) {
+            result[attribute.name] = attribute.value;
+        }
+        return result;
+    }
+
+    let current_component;
+    function set_current_component(component) {
+        current_component = component;
+    }
+
+    const dirty_components = [];
+    const binding_callbacks = [];
+    const render_callbacks = [];
+    const flush_callbacks = [];
+    const resolved_promise = Promise.resolve();
+    let update_scheduled = false;
+    function schedule_update() {
+        if (!update_scheduled) {
+            update_scheduled = true;
+            resolved_promise.then(flush);
+        }
+    }
+    function add_render_callback(fn) {
+        render_callbacks.push(fn);
+    }
+    let flushing = false;
+    const seen_callbacks = new Set();
+    function flush() {
+        if (flushing)
+            return;
+        flushing = true;
+        do {
+            // first, call beforeUpdate functions
+            // and update components
+            for (let i = 0; i < dirty_components.length; i += 1) {
+                const component = dirty_components[i];
+                set_current_component(component);
+                update(component.$$);
+            }
+            set_current_component(null);
+            dirty_components.length = 0;
+            while (binding_callbacks.length)
+                binding_callbacks.pop()();
+            // then, once components are updated, call
+            // afterUpdate functions. This may cause
+            // subsequent updates...
+            for (let i = 0; i < render_callbacks.length; i += 1) {
+                const callback = render_callbacks[i];
+                if (!seen_callbacks.has(callback)) {
+                    // ...so guard against infinite loops
+                    seen_callbacks.add(callback);
+                    callback();
+                }
+            }
+            render_callbacks.length = 0;
+        } while (dirty_components.length);
+        while (flush_callbacks.length) {
+            flush_callbacks.pop()();
+        }
+        update_scheduled = false;
+        flushing = false;
+        seen_callbacks.clear();
+    }
+    function update($$) {
+        if ($$.fragment !== null) {
+            $$.update();
+            run_all($$.before_update);
+            const dirty = $$.dirty;
+            $$.dirty = [-1];
+            $$.fragment && $$.fragment.p($$.ctx, dirty);
+            $$.after_update.forEach(add_render_callback);
+        }
+    }
+    const outroing = new Set();
+    function transition_in(block, local) {
+        if (block && block.i) {
+            outroing.delete(block);
+            block.i(local);
+        }
+    }
+
+    const globals = (typeof window !== 'undefined'
+        ? window
+        : typeof globalThis !== 'undefined'
+            ? globalThis
+            : global);
+    function mount_component(component, target, anchor, customElement) {
+        const { fragment, on_mount, on_destroy, after_update } = component.$$;
+        fragment && fragment.m(target, anchor);
+        if (!customElement) {
+            // onMount happens before the initial afterUpdate
+            add_render_callback(() => {
+                const new_on_destroy = on_mount.map(run).filter(is_function);
+                if (on_destroy) {
+                    on_destroy.push(...new_on_destroy);
+                }
+                else {
+                    // Edge case - component was destroyed immediately,
+                    // most likely as a result of a binding initialising
+                    run_all(new_on_destroy);
+                }
+                component.$$.on_mount = [];
+            });
+        }
+        after_update.forEach(add_render_callback);
+    }
+    function destroy_component(component, detaching) {
+        const $$ = component.$$;
+        if ($$.fragment !== null) {
+            run_all($$.on_destroy);
+            $$.fragment && $$.fragment.d(detaching);
+            // TODO null out other refs, including component.$$ (but need to
+            // preserve final state?)
+            $$.on_destroy = $$.fragment = null;
+            $$.ctx = [];
+        }
+    }
+    function make_dirty(component, i) {
+        if (component.$$.dirty[0] === -1) {
+            dirty_components.push(component);
+            schedule_update();
+            component.$$.dirty.fill(0);
+        }
+        component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
+    }
+    function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
+        const parent_component = current_component;
+        set_current_component(component);
+        const $$ = component.$$ = {
+            fragment: null,
+            ctx: null,
+            // state
+            props,
+            update: noop$1,
+            not_equal,
+            bound: blank_object(),
+            // lifecycle
+            on_mount: [],
+            on_destroy: [],
+            on_disconnect: [],
+            before_update: [],
+            after_update: [],
+            context: new Map(parent_component ? parent_component.$$.context : options.context || []),
+            // everything else
+            callbacks: blank_object(),
+            dirty,
+            skip_bound: false
+        };
+        let ready = false;
+        $$.ctx = instance
+            ? instance(component, options.props || {}, (i, ret, ...rest) => {
+                const value = rest.length ? rest[0] : ret;
+                if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+                    if (!$$.skip_bound && $$.bound[i])
+                        $$.bound[i](value);
+                    if (ready)
+                        make_dirty(component, i);
+                }
+                return ret;
+            })
+            : [];
+        $$.update();
+        ready = true;
+        run_all($$.before_update);
+        // `false` as a special case of no DOM component
+        $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
+        if (options.target) {
+            if (options.hydrate) {
+                const nodes = children(options.target);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                $$.fragment && $$.fragment.l(nodes);
+                nodes.forEach(detach);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                $$.fragment && $$.fragment.c();
+            }
+            if (options.intro)
+                transition_in(component.$$.fragment);
+            mount_component(component, options.target, options.anchor, options.customElement);
+            flush();
+        }
+        set_current_component(parent_component);
+    }
+    let SvelteElement;
+    if (typeof HTMLElement === 'function') {
+        SvelteElement = class extends HTMLElement {
+            constructor() {
+                super();
+                this.attachShadow({ mode: 'open' });
+            }
+            connectedCallback() {
+                const { on_mount } = this.$$;
+                this.$$.on_disconnect = on_mount.map(run).filter(is_function);
+                // @ts-ignore todo: improve typings
+                for (const key in this.$$.slotted) {
+                    // @ts-ignore todo: improve typings
+                    this.appendChild(this.$$.slotted[key]);
+                }
+            }
+            attributeChangedCallback(attr, _oldValue, newValue) {
+                this[attr] = newValue;
+            }
+            disconnectedCallback() {
+                run_all(this.$$.on_disconnect);
+            }
+            $destroy() {
+                destroy_component(this, 1);
+                this.$destroy = noop$1;
+            }
+            $on(type, callback) {
+                // TODO should this delegate to addEventListener?
+                const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
+                callbacks.push(callback);
+                return () => {
+                    const index = callbacks.indexOf(callback);
+                    if (index !== -1)
+                        callbacks.splice(index, 1);
+                };
+            }
+            $set($$props) {
+                if (this.$$set && !is_empty($$props)) {
+                    this.$$.skip_bound = true;
+                    this.$$set($$props);
+                    this.$$.skip_bound = false;
+                }
+            }
+        };
+    }
+
+    function dispatch_dev(type, detail) {
+        document.dispatchEvent(custom_event(type, Object.assign({ version: '3.37.0' }, detail)));
+    }
+    function append_dev(target, node) {
+        dispatch_dev('SvelteDOMInsert', { target, node });
+        append(target, node);
+    }
+    function insert_dev(target, node, anchor) {
+        dispatch_dev('SvelteDOMInsert', { target, node, anchor });
+        insert(target, node, anchor);
+    }
+    function detach_dev(node) {
+        dispatch_dev('SvelteDOMRemove', { node });
+        detach(node);
+    }
+    function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
+        const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
+        if (has_prevent_default)
+            modifiers.push('preventDefault');
+        if (has_stop_propagation)
+            modifiers.push('stopPropagation');
+        dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
+        const dispose = listen(node, event, handler, options);
+        return () => {
+            dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
+            dispose();
+        };
+    }
+    function attr_dev(node, attribute, value) {
+        attr(node, attribute, value);
+        if (value == null)
+            dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
+        else
+            dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
+    }
+    function validate_slots(name, slot, keys) {
+        for (const slot_key of Object.keys(slot)) {
+            if (!~keys.indexOf(slot_key)) {
+                console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
+            }
+        }
+    }
+
+    var global$1 =
+      (typeof globalThis !== 'undefined' && globalThis) ||
+      (typeof self !== 'undefined' && self) ||
+      (typeof global$1 !== 'undefined' && global$1);
+
+    var support = {
+      searchParams: 'URLSearchParams' in global$1,
+      iterable: 'Symbol' in global$1 && 'iterator' in Symbol,
+      blob:
+        'FileReader' in global$1 &&
+        'Blob' in global$1 &&
+        (function() {
+          try {
+            new Blob();
+            return true
+          } catch (e) {
+            return false
+          }
+        })(),
+      formData: 'FormData' in global$1,
+      arrayBuffer: 'ArrayBuffer' in global$1
+    };
+
+    function isDataView(obj) {
+      return obj && DataView.prototype.isPrototypeOf(obj)
+    }
+
+    if (support.arrayBuffer) {
+      var viewClasses = [
+        '[object Int8Array]',
+        '[object Uint8Array]',
+        '[object Uint8ClampedArray]',
+        '[object Int16Array]',
+        '[object Uint16Array]',
+        '[object Int32Array]',
+        '[object Uint32Array]',
+        '[object Float32Array]',
+        '[object Float64Array]'
+      ];
+
+      var isArrayBufferView =
+        ArrayBuffer.isView ||
+        function(obj) {
+          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+        };
+    }
+
+    function normalizeName(name) {
+      if (typeof name !== 'string') {
+        name = String(name);
+      }
+      if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name: "' + name + '"')
+      }
+      return name.toLowerCase()
+    }
+
+    function normalizeValue(value) {
+      if (typeof value !== 'string') {
+        value = String(value);
+      }
+      return value
+    }
+
+    // Build a destructive iterator for the value list
+    function iteratorFor(items) {
+      var iterator = {
+        next: function() {
+          var value = items.shift();
+          return {done: value === undefined, value: value}
+        }
+      };
+
+      if (support.iterable) {
+        iterator[Symbol.iterator] = function() {
+          return iterator
+        };
+      }
+
+      return iterator
+    }
+
+    function Headers(headers) {
+      this.map = {};
+
+      if (headers instanceof Headers) {
+        headers.forEach(function(value, name) {
+          this.append(name, value);
+        }, this);
+      } else if (Array.isArray(headers)) {
+        headers.forEach(function(header) {
+          this.append(header[0], header[1]);
+        }, this);
+      } else if (headers) {
+        Object.getOwnPropertyNames(headers).forEach(function(name) {
+          this.append(name, headers[name]);
+        }, this);
+      }
+    }
+
+    Headers.prototype.append = function(name, value) {
+      name = normalizeName(name);
+      value = normalizeValue(value);
+      var oldValue = this.map[name];
+      this.map[name] = oldValue ? oldValue + ', ' + value : value;
+    };
+
+    Headers.prototype['delete'] = function(name) {
+      delete this.map[normalizeName(name)];
+    };
+
+    Headers.prototype.get = function(name) {
+      name = normalizeName(name);
+      return this.has(name) ? this.map[name] : null
+    };
+
+    Headers.prototype.has = function(name) {
+      return this.map.hasOwnProperty(normalizeName(name))
+    };
+
+    Headers.prototype.set = function(name, value) {
+      this.map[normalizeName(name)] = normalizeValue(value);
+    };
+
+    Headers.prototype.forEach = function(callback, thisArg) {
+      for (var name in this.map) {
+        if (this.map.hasOwnProperty(name)) {
+          callback.call(thisArg, this.map[name], name, this);
+        }
+      }
+    };
+
+    Headers.prototype.keys = function() {
+      var items = [];
+      this.forEach(function(value, name) {
+        items.push(name);
+      });
+      return iteratorFor(items)
+    };
+
+    Headers.prototype.values = function() {
+      var items = [];
+      this.forEach(function(value) {
+        items.push(value);
+      });
+      return iteratorFor(items)
+    };
+
+    Headers.prototype.entries = function() {
+      var items = [];
+      this.forEach(function(value, name) {
+        items.push([name, value]);
+      });
+      return iteratorFor(items)
+    };
+
+    if (support.iterable) {
+      Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+    }
+
+    function consumed(body) {
+      if (body.bodyUsed) {
+        return Promise.reject(new TypeError('Already read'))
+      }
+      body.bodyUsed = true;
+    }
+
+    function fileReaderReady(reader) {
+      return new Promise(function(resolve, reject) {
+        reader.onload = function() {
+          resolve(reader.result);
+        };
+        reader.onerror = function() {
+          reject(reader.error);
+        };
+      })
+    }
+
+    function readBlobAsArrayBuffer(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      reader.readAsArrayBuffer(blob);
+      return promise
+    }
+
+    function readBlobAsText(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      reader.readAsText(blob);
+      return promise
+    }
+
+    function readArrayBufferAsText(buf) {
+      var view = new Uint8Array(buf);
+      var chars = new Array(view.length);
+
+      for (var i = 0; i < view.length; i++) {
+        chars[i] = String.fromCharCode(view[i]);
+      }
+      return chars.join('')
+    }
+
+    function bufferClone(buf) {
+      if (buf.slice) {
+        return buf.slice(0)
+      } else {
+        var view = new Uint8Array(buf.byteLength);
+        view.set(new Uint8Array(buf));
+        return view.buffer
+      }
+    }
+
+    function Body() {
+      this.bodyUsed = false;
+
+      this._initBody = function(body) {
+        /*
+          fetch-mock wraps the Response object in an ES6 Proxy to
+          provide useful test harness features such as flush. However, on
+          ES5 browsers without fetch or Proxy support pollyfills must be used;
+          the proxy-pollyfill is unable to proxy an attribute unless it exists
+          on the object before the Proxy is created. This change ensures
+          Response.bodyUsed exists on the instance, while maintaining the
+          semantic of setting Request.bodyUsed in the constructor before
+          _initBody is called.
+        */
+        this.bodyUsed = this.bodyUsed;
+        this._bodyInit = body;
+        if (!body) {
+          this._bodyText = '';
+        } else if (typeof body === 'string') {
+          this._bodyText = body;
+        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+          this._bodyBlob = body;
+        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+          this._bodyFormData = body;
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this._bodyText = body.toString();
+        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+          this._bodyArrayBuffer = bufferClone(body.buffer);
+          // IE 10-11 can't handle a DataView body.
+          this._bodyInit = new Blob([this._bodyArrayBuffer]);
+        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+          this._bodyArrayBuffer = bufferClone(body);
+        } else {
+          this._bodyText = body = Object.prototype.toString.call(body);
+        }
+
+        if (!this.headers.get('content-type')) {
+          if (typeof body === 'string') {
+            this.headers.set('content-type', 'text/plain;charset=UTF-8');
+          } else if (this._bodyBlob && this._bodyBlob.type) {
+            this.headers.set('content-type', this._bodyBlob.type);
+          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+          }
+        }
+      };
+
+      if (support.blob) {
+        this.blob = function() {
+          var rejected = consumed(this);
+          if (rejected) {
+            return rejected
+          }
+
+          if (this._bodyBlob) {
+            return Promise.resolve(this._bodyBlob)
+          } else if (this._bodyArrayBuffer) {
+            return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+          } else if (this._bodyFormData) {
+            throw new Error('could not read FormData body as blob')
+          } else {
+            return Promise.resolve(new Blob([this._bodyText]))
+          }
+        };
+
+        this.arrayBuffer = function() {
+          if (this._bodyArrayBuffer) {
+            var isConsumed = consumed(this);
+            if (isConsumed) {
+              return isConsumed
+            }
+            if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+              return Promise.resolve(
+                this._bodyArrayBuffer.buffer.slice(
+                  this._bodyArrayBuffer.byteOffset,
+                  this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+                )
+              )
+            } else {
+              return Promise.resolve(this._bodyArrayBuffer)
+            }
+          } else {
+            return this.blob().then(readBlobAsArrayBuffer)
+          }
+        };
+      }
+
+      this.text = function() {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return readBlobAsText(this._bodyBlob)
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as text')
+        } else {
+          return Promise.resolve(this._bodyText)
+        }
+      };
+
+      if (support.formData) {
+        this.formData = function() {
+          return this.text().then(decode)
+        };
+      }
+
+      this.json = function() {
+        return this.text().then(JSON.parse)
+      };
+
+      return this
+    }
+
+    // HTTP methods whose capitalization should be normalized
+    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+    function normalizeMethod(method) {
+      var upcased = method.toUpperCase();
+      return methods.indexOf(upcased) > -1 ? upcased : method
+    }
+
+    function Request(input, options) {
+      if (!(this instanceof Request)) {
+        throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+      }
+
+      options = options || {};
+      var body = options.body;
+
+      if (input instanceof Request) {
+        if (input.bodyUsed) {
+          throw new TypeError('Already read')
+        }
+        this.url = input.url;
+        this.credentials = input.credentials;
+        if (!options.headers) {
+          this.headers = new Headers(input.headers);
+        }
+        this.method = input.method;
+        this.mode = input.mode;
+        this.signal = input.signal;
+        if (!body && input._bodyInit != null) {
+          body = input._bodyInit;
+          input.bodyUsed = true;
+        }
+      } else {
+        this.url = String(input);
+      }
+
+      this.credentials = options.credentials || this.credentials || 'same-origin';
+      if (options.headers || !this.headers) {
+        this.headers = new Headers(options.headers);
+      }
+      this.method = normalizeMethod(options.method || this.method || 'GET');
+      this.mode = options.mode || this.mode || null;
+      this.signal = options.signal || this.signal;
+      this.referrer = null;
+
+      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+        throw new TypeError('Body not allowed for GET or HEAD requests')
+      }
+      this._initBody(body);
+
+      if (this.method === 'GET' || this.method === 'HEAD') {
+        if (options.cache === 'no-store' || options.cache === 'no-cache') {
+          // Search for a '_' parameter in the query string
+          var reParamSearch = /([?&])_=[^&]*/;
+          if (reParamSearch.test(this.url)) {
+            // If it already exists then set the value with the current time
+            this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+          } else {
+            // Otherwise add a new '_' parameter to the end with the current time
+            var reQueryString = /\?/;
+            this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+          }
+        }
+      }
+    }
+
+    Request.prototype.clone = function() {
+      return new Request(this, {body: this._bodyInit})
+    };
+
+    function decode(body) {
+      var form = new FormData();
+      body
+        .trim()
+        .split('&')
+        .forEach(function(bytes) {
+          if (bytes) {
+            var split = bytes.split('=');
+            var name = split.shift().replace(/\+/g, ' ');
+            var value = split.join('=').replace(/\+/g, ' ');
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+          }
+        });
+      return form
+    }
+
+    function parseHeaders(rawHeaders) {
+      var headers = new Headers();
+      // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+      // https://tools.ietf.org/html/rfc7230#section-3.2
+      var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+      // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+      // https://github.com/github/fetch/issues/748
+      // https://github.com/zloirock/core-js/issues/751
+      preProcessedHeaders
+        .split('\r')
+        .map(function(header) {
+          return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
+        })
+        .forEach(function(line) {
+          var parts = line.split(':');
+          var key = parts.shift().trim();
+          if (key) {
+            var value = parts.join(':').trim();
+            headers.append(key, value);
+          }
+        });
+      return headers
+    }
+
+    Body.call(Request.prototype);
+
+    function Response(bodyInit, options) {
+      if (!(this instanceof Response)) {
+        throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+      }
+      if (!options) {
+        options = {};
+      }
+
+      this.type = 'default';
+      this.status = options.status === undefined ? 200 : options.status;
+      this.ok = this.status >= 200 && this.status < 300;
+      this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
+      this.headers = new Headers(options.headers);
+      this.url = options.url || '';
+      this._initBody(bodyInit);
+    }
+
+    Body.call(Response.prototype);
+
+    Response.prototype.clone = function() {
+      return new Response(this._bodyInit, {
+        status: this.status,
+        statusText: this.statusText,
+        headers: new Headers(this.headers),
+        url: this.url
+      })
+    };
+
+    Response.error = function() {
+      var response = new Response(null, {status: 0, statusText: ''});
+      response.type = 'error';
+      return response
+    };
+
+    var redirectStatuses = [301, 302, 303, 307, 308];
+
+    Response.redirect = function(url, status) {
+      if (redirectStatuses.indexOf(status) === -1) {
+        throw new RangeError('Invalid status code')
+      }
+
+      return new Response(null, {status: status, headers: {location: url}})
+    };
+
+    var DOMException = global$1.DOMException;
+    try {
+      new DOMException();
+    } catch (err) {
+      DOMException = function(message, name) {
+        this.message = message;
+        this.name = name;
+        var error = Error(message);
+        this.stack = error.stack;
+      };
+      DOMException.prototype = Object.create(Error.prototype);
+      DOMException.prototype.constructor = DOMException;
+    }
+
+    function fetch$1(input, init) {
+      return new Promise(function(resolve, reject) {
+        var request = new Request(input, init);
+
+        if (request.signal && request.signal.aborted) {
+          return reject(new DOMException('Aborted', 'AbortError'))
+        }
+
+        var xhr = new XMLHttpRequest();
+
+        function abortXhr() {
+          xhr.abort();
+        }
+
+        xhr.onload = function() {
+          var options = {
+            status: xhr.status,
+            statusText: xhr.statusText,
+            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+          };
+          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+          var body = 'response' in xhr ? xhr.response : xhr.responseText;
+          setTimeout(function() {
+            resolve(new Response(body, options));
+          }, 0);
+        };
+
+        xhr.onerror = function() {
+          setTimeout(function() {
+            reject(new TypeError('Network request failed'));
+          }, 0);
+        };
+
+        xhr.ontimeout = function() {
+          setTimeout(function() {
+            reject(new TypeError('Network request failed'));
+          }, 0);
+        };
+
+        xhr.onabort = function() {
+          setTimeout(function() {
+            reject(new DOMException('Aborted', 'AbortError'));
+          }, 0);
+        };
+
+        function fixUrl(url) {
+          try {
+            return url === '' && global$1.location.href ? global$1.location.href : url
+          } catch (e) {
+            return url
+          }
+        }
+
+        xhr.open(request.method, fixUrl(request.url), true);
+
+        if (request.credentials === 'include') {
+          xhr.withCredentials = true;
+        } else if (request.credentials === 'omit') {
+          xhr.withCredentials = false;
+        }
+
+        if ('responseType' in xhr) {
+          if (support.blob) {
+            xhr.responseType = 'blob';
+          } else if (
+            support.arrayBuffer &&
+            request.headers.get('Content-Type') &&
+            request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
+          ) {
+            xhr.responseType = 'arraybuffer';
+          }
+        }
+
+        if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+          Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+            xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+          });
+        } else {
+          request.headers.forEach(function(value, name) {
+            xhr.setRequestHeader(name, value);
+          });
+        }
+
+        if (request.signal) {
+          request.signal.addEventListener('abort', abortXhr);
+
+          xhr.onreadystatechange = function() {
+            // DONE (success or failure)
+            if (xhr.readyState === 4) {
+              request.signal.removeEventListener('abort', abortXhr);
+            }
+          };
+        }
+
+        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+      })
+    }
+
+    fetch$1.polyfill = true;
+
+    if (!global$1.fetch) {
+      global$1.fetch = fetch$1;
+      global$1.Headers = Headers;
+      global$1.Request = Request;
+      global$1.Response = Response;
+    }
+
+    // the whatwg-fetch polyfill installs the fetch() function
+    // on the global object (window or self)
+    //
+    // Return that as the export for use in Webpack, Browserify etc.
+
+    self.fetch.bind(self);
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics$1 = function(d, b) {
+        extendStatics$1 = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics$1(d, b);
+    };
+
+    function __extends$1(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics$1(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray$1(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+
+    function createErrorClass(createImpl) {
+        var _super = function (instance) {
+            Error.call(instance);
+            instance.stack = new Error().stack;
+        };
+        var ctorFunc = createImpl(_super);
+        ctorFunc.prototype = Object.create(Error.prototype);
+        ctorFunc.prototype.constructor = ctorFunc;
+        return ctorFunc;
+    }
+
+    var UnsubscriptionError = createErrorClass(function (_super) {
+        return function UnsubscriptionErrorImpl(errors) {
+            _super(this);
+            this.message = errors
+                ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+                : '';
+            this.name = 'UnsubscriptionError';
+            this.errors = errors;
+        };
+    });
+
+    function arrRemove(arr, item) {
+        if (arr) {
+            var index = arr.indexOf(item);
+            0 <= index && arr.splice(index, 1);
+        }
+    }
+
+    var Subscription = (function () {
+        function Subscription(initialTeardown) {
+            this.initialTeardown = initialTeardown;
+            this.closed = false;
+            this._parentage = null;
+            this._teardowns = null;
+        }
+        Subscription.prototype.unsubscribe = function () {
+            var e_1, _a, e_2, _b;
+            var errors;
+            if (!this.closed) {
+                this.closed = true;
+                var _parentage = this._parentage;
+                if (_parentage) {
+                    this._parentage = null;
+                    if (Array.isArray(_parentage)) {
+                        try {
+                            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                                var parent_1 = _parentage_1_1.value;
+                                parent_1.remove(this);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    else {
+                        _parentage.remove(this);
+                    }
+                }
+                var initialTeardown = this.initialTeardown;
+                if (isFunction(initialTeardown)) {
+                    try {
+                        initialTeardown();
+                    }
+                    catch (e) {
+                        errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                    }
+                }
+                var _teardowns = this._teardowns;
+                if (_teardowns) {
+                    this._teardowns = null;
+                    try {
+                        for (var _teardowns_1 = __values(_teardowns), _teardowns_1_1 = _teardowns_1.next(); !_teardowns_1_1.done; _teardowns_1_1 = _teardowns_1.next()) {
+                            var teardown_1 = _teardowns_1_1.value;
+                            try {
+                                execTeardown(teardown_1);
+                            }
+                            catch (err) {
+                                errors = errors !== null && errors !== void 0 ? errors : [];
+                                if (err instanceof UnsubscriptionError) {
+                                    errors = __spreadArray$1(__spreadArray$1([], __read(errors)), __read(err.errors));
+                                }
+                                else {
+                                    errors.push(err);
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_teardowns_1_1 && !_teardowns_1_1.done && (_b = _teardowns_1.return)) _b.call(_teardowns_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                if (errors) {
+                    throw new UnsubscriptionError(errors);
+                }
+            }
+        };
+        Subscription.prototype.add = function (teardown) {
+            var _a;
+            if (teardown && teardown !== this) {
+                if (this.closed) {
+                    execTeardown(teardown);
+                }
+                else {
+                    if (teardown instanceof Subscription) {
+                        if (teardown.closed || teardown._hasParent(this)) {
+                            return;
+                        }
+                        teardown._addParent(this);
+                    }
+                    (this._teardowns = (_a = this._teardowns) !== null && _a !== void 0 ? _a : []).push(teardown);
+                }
+            }
+        };
+        Subscription.prototype._hasParent = function (parent) {
+            var _parentage = this._parentage;
+            return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+        };
+        Subscription.prototype._addParent = function (parent) {
+            var _parentage = this._parentage;
+            this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+        };
+        Subscription.prototype._removeParent = function (parent) {
+            var _parentage = this._parentage;
+            if (_parentage === parent) {
+                this._parentage = null;
+            }
+            else if (Array.isArray(_parentage)) {
+                arrRemove(_parentage, parent);
+            }
+        };
+        Subscription.prototype.remove = function (teardown) {
+            var _teardowns = this._teardowns;
+            _teardowns && arrRemove(_teardowns, teardown);
+            if (teardown instanceof Subscription) {
+                teardown._removeParent(this);
+            }
+        };
+        Subscription.EMPTY = (function () {
+            var empty = new Subscription();
+            empty.closed = true;
+            return empty;
+        })();
+        return Subscription;
+    }());
+    var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+    function isSubscription(value) {
+        return (value instanceof Subscription ||
+            (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+    }
+    function execTeardown(teardown) {
+        if (isFunction(teardown)) {
+            teardown();
+        }
+        else {
+            teardown.unsubscribe();
+        }
+    }
+
+    var config = {
+        onUnhandledError: null,
+        onStoppedNotification: null,
+        Promise: undefined,
+        useDeprecatedSynchronousErrorHandling: false,
+        useDeprecatedNextContext: false,
+    };
+
+    var timeoutProvider = {
+        setTimeout: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return (setTimeout).apply(void 0, __spreadArray$1([], __read(args)));
+        },
+        clearTimeout: function (handle) {
+            return (clearTimeout)(handle);
+        },
+        delegate: undefined,
+    };
+
+    function reportUnhandledError(err) {
+        timeoutProvider.setTimeout(function () {
+            {
+                throw err;
+            }
+        });
+    }
+
+    function noop() { }
+
+    function errorContext(cb) {
+        {
+            cb();
+        }
+    }
+
+    var Subscriber = (function (_super) {
+        __extends$1(Subscriber, _super);
+        function Subscriber(destination) {
+            var _this = _super.call(this) || this;
+            _this.isStopped = false;
+            if (destination) {
+                _this.destination = destination;
+                if (isSubscription(destination)) {
+                    destination.add(_this);
+                }
+            }
+            else {
+                _this.destination = EMPTY_OBSERVER;
+            }
+            return _this;
+        }
+        Subscriber.create = function (next, error, complete) {
+            return new SafeSubscriber(next, error, complete);
+        };
+        Subscriber.prototype.next = function (value) {
+            if (this.isStopped) ;
+            else {
+                this._next(value);
+            }
+        };
+        Subscriber.prototype.error = function (err) {
+            if (this.isStopped) ;
+            else {
+                this.isStopped = true;
+                this._error(err);
+            }
+        };
+        Subscriber.prototype.complete = function () {
+            if (this.isStopped) ;
+            else {
+                this.isStopped = true;
+                this._complete();
+            }
+        };
+        Subscriber.prototype.unsubscribe = function () {
+            if (!this.closed) {
+                this.isStopped = true;
+                _super.prototype.unsubscribe.call(this);
+                this.destination = null;
+            }
+        };
+        Subscriber.prototype._next = function (value) {
+            this.destination.next(value);
+        };
+        Subscriber.prototype._error = function (err) {
+            try {
+                this.destination.error(err);
+            }
+            finally {
+                this.unsubscribe();
+            }
+        };
+        Subscriber.prototype._complete = function () {
+            try {
+                this.destination.complete();
+            }
+            finally {
+                this.unsubscribe();
+            }
+        };
+        return Subscriber;
+    }(Subscription));
+    var SafeSubscriber = (function (_super) {
+        __extends$1(SafeSubscriber, _super);
+        function SafeSubscriber(observerOrNext, error, complete) {
+            var _this = _super.call(this) || this;
+            var next;
+            if (isFunction(observerOrNext)) {
+                next = observerOrNext;
+            }
+            else if (observerOrNext) {
+                (next = observerOrNext.next, error = observerOrNext.error, complete = observerOrNext.complete);
+                var context_1;
+                if (_this && config.useDeprecatedNextContext) {
+                    context_1 = Object.create(observerOrNext);
+                    context_1.unsubscribe = function () { return _this.unsubscribe(); };
+                }
+                else {
+                    context_1 = observerOrNext;
+                }
+                next = next === null || next === void 0 ? void 0 : next.bind(context_1);
+                error = error === null || error === void 0 ? void 0 : error.bind(context_1);
+                complete = complete === null || complete === void 0 ? void 0 : complete.bind(context_1);
+            }
+            _this.destination = {
+                next: next ? wrapForErrorHandling(next) : noop,
+                error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler),
+                complete: complete ? wrapForErrorHandling(complete) : noop,
+            };
+            return _this;
+        }
+        return SafeSubscriber;
+    }(Subscriber));
+    function wrapForErrorHandling(handler, instance) {
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            try {
+                handler.apply(void 0, __spreadArray$1([], __read(args)));
+            }
+            catch (err) {
+                {
+                    reportUnhandledError(err);
+                }
+            }
+        };
+    }
+    function defaultErrorHandler(err) {
+        throw err;
+    }
+    var EMPTY_OBSERVER = {
+        closed: true,
+        next: noop,
+        error: defaultErrorHandler,
+        complete: noop,
+    };
+
+    var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+    function identity(x) {
+        return x;
+    }
+
+    function pipeFromArray(fns) {
+        if (fns.length === 0) {
+            return identity;
+        }
+        if (fns.length === 1) {
+            return fns[0];
+        }
+        return function piped(input) {
+            return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+        };
+    }
+
+    var Observable = (function () {
+        function Observable(subscribe) {
+            if (subscribe) {
+                this._subscribe = subscribe;
+            }
+        }
+        Observable.prototype.lift = function (operator) {
+            var observable = new Observable();
+            observable.source = this;
+            observable.operator = operator;
+            return observable;
+        };
+        Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+            var _this = this;
+            var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+            errorContext(function () {
+                var _a = _this, operator = _a.operator, source = _a.source;
+                subscriber.add(operator
+                    ?
+                        operator.call(subscriber, source)
+                    : source
+                        ?
+                            _this._subscribe(subscriber)
+                        :
+                            _this._trySubscribe(subscriber));
+            });
+            return subscriber;
+        };
+        Observable.prototype._trySubscribe = function (sink) {
+            try {
+                return this._subscribe(sink);
+            }
+            catch (err) {
+                sink.error(err);
+            }
+        };
+        Observable.prototype.forEach = function (next, promiseCtor) {
+            var _this = this;
+            promiseCtor = getPromiseCtor(promiseCtor);
+            return new promiseCtor(function (resolve, reject) {
+                var subscription;
+                subscription = _this.subscribe(function (value) {
+                    try {
+                        next(value);
+                    }
+                    catch (err) {
+                        reject(err);
+                        subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+                    }
+                }, reject, resolve);
+            });
+        };
+        Observable.prototype._subscribe = function (subscriber) {
+            var _a;
+            return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+        };
+        Observable.prototype[observable] = function () {
+            return this;
+        };
+        Observable.prototype.pipe = function () {
+            var operations = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                operations[_i] = arguments[_i];
+            }
+            return pipeFromArray(operations)(this);
+        };
+        Observable.prototype.toPromise = function (promiseCtor) {
+            var _this = this;
+            promiseCtor = getPromiseCtor(promiseCtor);
+            return new promiseCtor(function (resolve, reject) {
+                var value;
+                _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+            });
+        };
+        Observable.create = function (subscribe) {
+            return new Observable(subscribe);
+        };
+        return Observable;
+    }());
+    function getPromiseCtor(promiseCtor) {
+        var _a;
+        return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+    }
+    function isObserver(value) {
+        return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+    }
+    function isSubscriber(value) {
+        return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+    }
+
+    var ObjectUnsubscribedError = createErrorClass(function (_super) {
+        return function ObjectUnsubscribedErrorImpl() {
+            _super(this);
+            this.name = 'ObjectUnsubscribedError';
+            this.message = 'object unsubscribed';
+        };
+    });
+
+    var Subject = (function (_super) {
+        __extends$1(Subject, _super);
+        function Subject() {
+            var _this = _super.call(this) || this;
+            _this.closed = false;
+            _this.observers = [];
+            _this.isStopped = false;
+            _this.hasError = false;
+            _this.thrownError = null;
+            return _this;
+        }
+        Subject.prototype.lift = function (operator) {
+            var subject = new AnonymousSubject(this, this);
+            subject.operator = operator;
+            return subject;
+        };
+        Subject.prototype._throwIfClosed = function () {
+            if (this.closed) {
+                throw new ObjectUnsubscribedError();
+            }
+        };
+        Subject.prototype.next = function (value) {
+            var _this = this;
+            errorContext(function () {
+                var e_1, _a;
+                _this._throwIfClosed();
+                if (!_this.isStopped) {
+                    var copy = _this.observers.slice();
+                    try {
+                        for (var copy_1 = __values(copy), copy_1_1 = copy_1.next(); !copy_1_1.done; copy_1_1 = copy_1.next()) {
+                            var observer = copy_1_1.value;
+                            observer.next(value);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (copy_1_1 && !copy_1_1.done && (_a = copy_1.return)) _a.call(copy_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            });
+        };
+        Subject.prototype.error = function (err) {
+            var _this = this;
+            errorContext(function () {
+                _this._throwIfClosed();
+                if (!_this.isStopped) {
+                    _this.hasError = _this.isStopped = true;
+                    _this.thrownError = err;
+                    var observers = _this.observers;
+                    while (observers.length) {
+                        observers.shift().error(err);
+                    }
+                }
+            });
+        };
+        Subject.prototype.complete = function () {
+            var _this = this;
+            errorContext(function () {
+                _this._throwIfClosed();
+                if (!_this.isStopped) {
+                    _this.isStopped = true;
+                    var observers = _this.observers;
+                    while (observers.length) {
+                        observers.shift().complete();
+                    }
+                }
+            });
+        };
+        Subject.prototype.unsubscribe = function () {
+            this.isStopped = this.closed = true;
+            this.observers = null;
+        };
+        Object.defineProperty(Subject.prototype, "observed", {
+            get: function () {
+                var _a;
+                return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Subject.prototype._trySubscribe = function (subscriber) {
+            this._throwIfClosed();
+            return _super.prototype._trySubscribe.call(this, subscriber);
+        };
+        Subject.prototype._subscribe = function (subscriber) {
+            this._throwIfClosed();
+            this._checkFinalizedStatuses(subscriber);
+            return this._innerSubscribe(subscriber);
+        };
+        Subject.prototype._innerSubscribe = function (subscriber) {
+            var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+            return hasError || isStopped
+                ? EMPTY_SUBSCRIPTION
+                : (observers.push(subscriber), new Subscription(function () { return arrRemove(observers, subscriber); }));
+        };
+        Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+            var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+            if (hasError) {
+                subscriber.error(thrownError);
+            }
+            else if (isStopped) {
+                subscriber.complete();
+            }
+        };
+        Subject.prototype.asObservable = function () {
+            var observable = new Observable();
+            observable.source = this;
+            return observable;
+        };
+        Subject.create = function (destination, source) {
+            return new AnonymousSubject(destination, source);
+        };
+        return Subject;
+    }(Observable));
+    var AnonymousSubject = (function (_super) {
+        __extends$1(AnonymousSubject, _super);
+        function AnonymousSubject(destination, source) {
+            var _this = _super.call(this) || this;
+            _this.destination = destination;
+            _this.source = source;
+            return _this;
+        }
+        AnonymousSubject.prototype.next = function (value) {
+            var _a, _b;
+            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        };
+        AnonymousSubject.prototype.error = function (err) {
+            var _a, _b;
+            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+        };
+        AnonymousSubject.prototype.complete = function () {
+            var _a, _b;
+            (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        AnonymousSubject.prototype._subscribe = function (subscriber) {
+            var _a, _b;
+            return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+        };
+        return AnonymousSubject;
+    }(Subject));
+
+    var dateTimestampProvider = {
+        now: function () {
+            return (dateTimestampProvider.delegate || Date).now();
+        },
+        delegate: undefined,
+    };
+
+    var ReplaySubject = (function (_super) {
+        __extends$1(ReplaySubject, _super);
+        function ReplaySubject(_bufferSize, _windowTime, _timestampProvider) {
+            if (_bufferSize === void 0) { _bufferSize = Infinity; }
+            if (_windowTime === void 0) { _windowTime = Infinity; }
+            if (_timestampProvider === void 0) { _timestampProvider = dateTimestampProvider; }
+            var _this = _super.call(this) || this;
+            _this._bufferSize = _bufferSize;
+            _this._windowTime = _windowTime;
+            _this._timestampProvider = _timestampProvider;
+            _this._buffer = [];
+            _this._infiniteTimeWindow = true;
+            _this._infiniteTimeWindow = _windowTime === Infinity;
+            _this._bufferSize = Math.max(1, _bufferSize);
+            _this._windowTime = Math.max(1, _windowTime);
+            return _this;
+        }
+        ReplaySubject.prototype.next = function (value) {
+            var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
+            if (!isStopped) {
+                _buffer.push(value);
+                !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+            }
+            this._trimBuffer();
+            _super.prototype.next.call(this, value);
+        };
+        ReplaySubject.prototype._subscribe = function (subscriber) {
+            this._throwIfClosed();
+            this._trimBuffer();
+            var subscription = this._innerSubscribe(subscriber);
+            var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
+            var copy = _buffer.slice();
+            for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+                subscriber.next(copy[i]);
+            }
+            this._checkFinalizedStatuses(subscriber);
+            return subscription;
+        };
+        ReplaySubject.prototype._trimBuffer = function () {
+            var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
+            var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+            _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+            if (!_infiniteTimeWindow) {
+                var now = _timestampProvider.now();
+                var last = 0;
+                for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+                    last = i;
+                }
+                last && _buffer.splice(0, last + 1);
+            }
+        };
+        return ReplaySubject;
+    }(Subject));
+
+    let topics = [];
+    let subjects = {};
+
+    /**
+     * @name topic
+     * @description A small wrapper over the rxjs to offer the topic method on top of it
+     * @param event [String] Event name
+     * @param step [String] How many values to be buffed for new subscribers - default 0
+     * @returns ReplaySubject
+     */
+
+    const topic = (event, step = 0) => {
+      if (topics.indexOf(event) == -1) {
+        let replaySubject = new ReplaySubject(step);
+
+        subjects[event] = replaySubject;
+
+        topics.push(event);
+      }
+
+      return subjects[event];
+    };
+
+    const subscriber_queue = [];
+    /**
+     * Creates a `Readable` store that allows reading by subscription.
+     * @param value initial value
+     * @param {StartStopNotifier}start start and stop notifications for subscriptions
+     */
+    function readable(value, start) {
+        return {
+            subscribe: writable(value, start).subscribe
+        };
+    }
+    /**
+     * Create a `Writable` store that allows both updating and reading by subscription.
+     * @param {*=}value initial value
+     * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+     */
+    function writable(value, start = noop$1) {
+        let stop;
+        const subscribers = [];
+        function set(new_value) {
+            if (safe_not_equal(value, new_value)) {
+                value = new_value;
+                if (stop) { // store is ready
+                    const run_queue = !subscriber_queue.length;
+                    for (let i = 0; i < subscribers.length; i += 1) {
+                        const s = subscribers[i];
+                        s[1]();
+                        subscriber_queue.push(s, value);
+                    }
+                    if (run_queue) {
+                        for (let i = 0; i < subscriber_queue.length; i += 2) {
+                            subscriber_queue[i][0](subscriber_queue[i + 1]);
+                        }
+                        subscriber_queue.length = 0;
+                    }
+                }
+            }
+        }
+        function update(fn) {
+            set(fn(value));
+        }
+        function subscribe(run, invalidate = noop$1) {
+            const subscriber = [run, invalidate];
+            subscribers.push(subscriber);
+            if (subscribers.length === 1) {
+                stop = start(set) || noop$1;
+            }
+            run(value);
+            return () => {
+                const index = subscribers.indexOf(subscriber);
+                if (index !== -1) {
+                    subscribers.splice(index, 1);
+                }
+                if (subscribers.length === 0) {
+                    stop();
+                    stop = null;
+                }
+            };
+        }
+        return { set, update, subscribe };
+    }
+    function derived(stores, fn, initial_value) {
+        const single = !Array.isArray(stores);
+        const stores_array = single
+            ? [stores]
+            : stores;
+        const auto = fn.length < 2;
+        return readable(initial_value, (set) => {
+            let inited = false;
+            const values = [];
+            let pending = 0;
+            let cleanup = noop$1;
+            const sync = () => {
+                if (pending) {
+                    return;
+                }
+                cleanup();
+                const result = fn(single ? values[0] : values, set);
+                if (auto) {
+                    set(result);
+                }
+                else {
+                    cleanup = is_function(result) ? result : noop$1;
+                }
+            };
+            const unsubscribers = stores_array.map((store, i) => subscribe(store, (value) => {
+                values[i] = value;
+                pending &= ~(1 << i);
+                if (inited) {
+                    sync();
+                }
+            }, () => {
+                pending |= (1 << i);
+            }));
+            inited = true;
+            sync();
+            return function stop() {
+                run_all(unsubscribers);
+                cleanup();
+            };
+        });
+    }
+
+    var isMergeableObject = function isMergeableObject(value) {
+    	return isNonNullObject(value)
+    		&& !isSpecial(value)
+    };
+
+    function isNonNullObject(value) {
+    	return !!value && typeof value === 'object'
+    }
+
+    function isSpecial(value) {
+    	var stringValue = Object.prototype.toString.call(value);
+
+    	return stringValue === '[object RegExp]'
+    		|| stringValue === '[object Date]'
+    		|| isReactElement(value)
+    }
+
+    // see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+    var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+    var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+    function isReactElement(value) {
+    	return value.$$typeof === REACT_ELEMENT_TYPE
+    }
+
+    function emptyTarget(val) {
+    	return Array.isArray(val) ? [] : {}
+    }
+
+    function cloneUnlessOtherwiseSpecified(value, options) {
+    	return (options.clone !== false && options.isMergeableObject(value))
+    		? deepmerge(emptyTarget(value), value, options)
+    		: value
+    }
+
+    function defaultArrayMerge(target, source, options) {
+    	return target.concat(source).map(function(element) {
+    		return cloneUnlessOtherwiseSpecified(element, options)
+    	})
+    }
+
+    function getMergeFunction(key, options) {
+    	if (!options.customMerge) {
+    		return deepmerge
+    	}
+    	var customMerge = options.customMerge(key);
+    	return typeof customMerge === 'function' ? customMerge : deepmerge
+    }
+
+    function getEnumerableOwnPropertySymbols(target) {
+    	return Object.getOwnPropertySymbols
+    		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+    			return target.propertyIsEnumerable(symbol)
+    		})
+    		: []
+    }
+
+    function getKeys(target) {
+    	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+    }
+
+    function propertyIsOnObject(object, property) {
+    	try {
+    		return property in object
+    	} catch(_) {
+    		return false
+    	}
+    }
+
+    // Protects from prototype poisoning and unexpected merging up the prototype chain.
+    function propertyIsUnsafe(target, key) {
+    	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+    		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+    			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+    }
+
+    function mergeObject(target, source, options) {
+    	var destination = {};
+    	if (options.isMergeableObject(target)) {
+    		getKeys(target).forEach(function(key) {
+    			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+    		});
+    	}
+    	getKeys(source).forEach(function(key) {
+    		if (propertyIsUnsafe(target, key)) {
+    			return
+    		}
+
+    		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+    			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+    		} else {
+    			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+    		}
+    	});
+    	return destination
+    }
+
+    function deepmerge(target, source, options) {
+    	options = options || {};
+    	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+    	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+    	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+    	// implementations can use it. The caller may not replace it.
+    	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+    	var sourceIsArray = Array.isArray(source);
+    	var targetIsArray = Array.isArray(target);
+    	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+    	if (!sourceAndTargetTypesMatch) {
+    		return cloneUnlessOtherwiseSpecified(source, options)
+    	} else if (sourceIsArray) {
+    		return options.arrayMerge(target, source, options)
+    	} else {
+    		return mergeObject(target, source, options)
+    	}
+    }
+
+    deepmerge.all = function deepmergeAll(array, options) {
+    	if (!Array.isArray(array)) {
+    		throw new Error('first argument should be an array')
+    	}
+
+    	return array.reduce(function(prev, next) {
+    		return deepmerge(prev, next, options)
+    	}, {})
+    };
+
+    var deepmerge_1 = deepmerge;
+
+    var cjs = deepmerge_1;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __spreadArray(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+
+    var ErrorKind;
+    (function (ErrorKind) {
+        /** Argument is unclosed (e.g. `{0`) */
+        ErrorKind[ErrorKind["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
+        /** Argument is empty (e.g. `{}`). */
+        ErrorKind[ErrorKind["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
+        /** Argument is malformed (e.g. `{foo!}``) */
+        ErrorKind[ErrorKind["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
+        /** Expect an argument type (e.g. `{foo,}`) */
+        ErrorKind[ErrorKind["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
+        /** Unsupported argument type (e.g. `{foo,foo}`) */
+        ErrorKind[ErrorKind["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
+        /** Expect an argument style (e.g. `{foo, number, }`) */
+        ErrorKind[ErrorKind["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
+        /** The number skeleton is invalid. */
+        ErrorKind[ErrorKind["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
+        /** The date time skeleton is invalid. */
+        ErrorKind[ErrorKind["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
+        /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */
+        ErrorKind[ErrorKind["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
+        /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */
+        ErrorKind[ErrorKind["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
+        /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */
+        ErrorKind[ErrorKind["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
+        /** Missing select argument options (e.g. `{foo, select}`) */
+        ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
+        /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */
+        ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
+        /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */
+        ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
+        /** Expecting a selector in `select` argument (e.g `{foo, select}`) */
+        ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
+        /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */
+        ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
+        /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */
+        ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
+        /**
+         * Expecting a message fragment after the `plural` or `selectordinal` selector
+         * (e.g. `{foo, plural, one}`)
+         */
+        ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
+        /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */
+        ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
+        /**
+         * Duplicate selectors in `plural` or `selectordinal` argument.
+         * (e.g. {foo, plural, one {#} one {#}})
+         */
+        ErrorKind[ErrorKind["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
+        /** Duplicate selectors in `select` argument.
+         * (e.g. {foo, select, apple {apple} apple {apple}})
+         */
+        ErrorKind[ErrorKind["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
+        /** Plural or select argument option must have `other` clause. */
+        ErrorKind[ErrorKind["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
+        /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */
+        ErrorKind[ErrorKind["INVALID_TAG"] = 23] = "INVALID_TAG";
+        /** The tag name is invalid. (e.g. `<123>foo</123>`) */
+        ErrorKind[ErrorKind["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
+        /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */
+        ErrorKind[ErrorKind["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
+        /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */
+        ErrorKind[ErrorKind["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
+    })(ErrorKind || (ErrorKind = {}));
+
+    var TYPE;
+    (function (TYPE) {
+        /**
+         * Raw text
+         */
+        TYPE[TYPE["literal"] = 0] = "literal";
+        /**
+         * Variable w/o any format, e.g `var` in `this is a {var}`
+         */
+        TYPE[TYPE["argument"] = 1] = "argument";
+        /**
+         * Variable w/ number format
+         */
+        TYPE[TYPE["number"] = 2] = "number";
+        /**
+         * Variable w/ date format
+         */
+        TYPE[TYPE["date"] = 3] = "date";
+        /**
+         * Variable w/ time format
+         */
+        TYPE[TYPE["time"] = 4] = "time";
+        /**
+         * Variable w/ select format
+         */
+        TYPE[TYPE["select"] = 5] = "select";
+        /**
+         * Variable w/ plural format
+         */
+        TYPE[TYPE["plural"] = 6] = "plural";
+        /**
+         * Only possible within plural argument.
+         * This is the `#` symbol that will be substituted with the count.
+         */
+        TYPE[TYPE["pound"] = 7] = "pound";
+        /**
+         * XML-like tag
+         */
+        TYPE[TYPE["tag"] = 8] = "tag";
+    })(TYPE || (TYPE = {}));
+    var SKELETON_TYPE;
+    (function (SKELETON_TYPE) {
+        SKELETON_TYPE[SKELETON_TYPE["number"] = 0] = "number";
+        SKELETON_TYPE[SKELETON_TYPE["dateTime"] = 1] = "dateTime";
+    })(SKELETON_TYPE || (SKELETON_TYPE = {}));
+    /**
+     * Type Guards
+     */
+    function isLiteralElement(el) {
+        return el.type === TYPE.literal;
+    }
+    function isArgumentElement(el) {
+        return el.type === TYPE.argument;
+    }
+    function isNumberElement(el) {
+        return el.type === TYPE.number;
+    }
+    function isDateElement(el) {
+        return el.type === TYPE.date;
+    }
+    function isTimeElement(el) {
+        return el.type === TYPE.time;
+    }
+    function isSelectElement(el) {
+        return el.type === TYPE.select;
+    }
+    function isPluralElement(el) {
+        return el.type === TYPE.plural;
+    }
+    function isPoundElement(el) {
+        return el.type === TYPE.pound;
+    }
+    function isTagElement(el) {
+        return el.type === TYPE.tag;
+    }
+    function isNumberSkeleton(el) {
+        return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.number);
+    }
+    function isDateTimeSkeleton(el) {
+        return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.dateTime);
+    }
+
+    // @generated from regex-gen.ts
+    var SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+
+    /**
+     * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+     * Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js
+     * with some tweaks
+     */
+    var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
+    /**
+     * Parse Date time skeleton into Intl.DateTimeFormatOptions
+     * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+     * @public
+     * @param skeleton skeleton string
+     */
+    function parseDateTimeSkeleton(skeleton) {
+        var result = {};
+        skeleton.replace(DATE_TIME_REGEX, function (match) {
+            var len = match.length;
+            switch (match[0]) {
+                // Era
+                case 'G':
+                    result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
+                    break;
+                // Year
+                case 'y':
+                    result.year = len === 2 ? '2-digit' : 'numeric';
+                    break;
+                case 'Y':
+                case 'u':
+                case 'U':
+                case 'r':
+                    throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');
+                // Quarter
+                case 'q':
+                case 'Q':
+                    throw new RangeError('`q/Q` (quarter) patterns are not supported');
+                // Month
+                case 'M':
+                case 'L':
+                    result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];
+                    break;
+                // Week
+                case 'w':
+                case 'W':
+                    throw new RangeError('`w/W` (week) patterns are not supported');
+                case 'd':
+                    result.day = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'D':
+                case 'F':
+                case 'g':
+                    throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');
+                // Weekday
+                case 'E':
+                    result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';
+                    break;
+                case 'e':
+                    if (len < 4) {
+                        throw new RangeError('`e..eee` (weekday) patterns are not supported');
+                    }
+                    result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
+                    break;
+                case 'c':
+                    if (len < 4) {
+                        throw new RangeError('`c..ccc` (weekday) patterns are not supported');
+                    }
+                    result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
+                    break;
+                // Period
+                case 'a': // AM, PM
+                    result.hour12 = true;
+                    break;
+                case 'b': // am, pm, noon, midnight
+                case 'B': // flexible day periods
+                    throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');
+                // Hour
+                case 'h':
+                    result.hourCycle = 'h12';
+                    result.hour = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'H':
+                    result.hourCycle = 'h23';
+                    result.hour = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'K':
+                    result.hourCycle = 'h11';
+                    result.hour = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'k':
+                    result.hourCycle = 'h24';
+                    result.hour = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'j':
+                case 'J':
+                case 'C':
+                    throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');
+                // Minute
+                case 'm':
+                    result.minute = ['numeric', '2-digit'][len - 1];
+                    break;
+                // Second
+                case 's':
+                    result.second = ['numeric', '2-digit'][len - 1];
+                    break;
+                case 'S':
+                case 'A':
+                    throw new RangeError('`S/A` (second) patterns are not supported, use `s` instead');
+                // Zone
+                case 'z': // 1..3, 4: specific non-location format
+                    result.timeZoneName = len < 4 ? 'short' : 'long';
+                    break;
+                case 'Z': // 1..3, 4, 5: The ISO8601 varios formats
+                case 'O': // 1, 4: miliseconds in day short, long
+                case 'v': // 1, 4: generic non-location format
+                case 'V': // 1, 2, 3, 4: time zone ID or city
+                case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
+                case 'x': // 1, 2, 3, 4: The ISO8601 varios formats
+                    throw new RangeError('`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead');
+            }
+            return '';
+        });
+        return result;
+    }
+
+    // @generated from regex-gen.ts
+    var WHITE_SPACE_REGEX = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i;
+
+    function parseNumberSkeletonFromString(skeleton) {
+        if (skeleton.length === 0) {
+            throw new Error('Number skeleton cannot be empty');
+        }
+        // Parse the skeleton
+        var stringTokens = skeleton
+            .split(WHITE_SPACE_REGEX)
+            .filter(function (x) { return x.length > 0; });
+        var tokens = [];
+        for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {
+            var stringToken = stringTokens_1[_i];
+            var stemAndOptions = stringToken.split('/');
+            if (stemAndOptions.length === 0) {
+                throw new Error('Invalid number skeleton');
+            }
+            var stem = stemAndOptions[0], options = stemAndOptions.slice(1);
+            for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
+                var option = options_1[_a];
+                if (option.length === 0) {
+                    throw new Error('Invalid number skeleton');
+                }
+            }
+            tokens.push({ stem: stem, options: options });
+        }
+        return tokens;
+    }
+    function icuUnitToEcma(unit) {
+        return unit.replace(/^(.*?)-/, '');
+    }
+    var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
+    var SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?$/g;
+    var INTEGER_WIDTH_REGEX = /(\*)(0+)|(#+)(0+)|(0+)/g;
+    var CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;
+    function parseSignificantPrecision(str) {
+        var result = {};
+        str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {
+            // @@@ case
+            if (typeof g2 !== 'string') {
+                result.minimumSignificantDigits = g1.length;
+                result.maximumSignificantDigits = g1.length;
+            }
+            // @@@+ case
+            else if (g2 === '+') {
+                result.minimumSignificantDigits = g1.length;
+            }
+            // .### case
+            else if (g1[0] === '#') {
+                result.maximumSignificantDigits = g1.length;
+            }
+            // .@@## or .@@@ case
+            else {
+                result.minimumSignificantDigits = g1.length;
+                result.maximumSignificantDigits =
+                    g1.length + (typeof g2 === 'string' ? g2.length : 0);
+            }
+            return '';
+        });
+        return result;
+    }
+    function parseSign(str) {
+        switch (str) {
+            case 'sign-auto':
+                return {
+                    signDisplay: 'auto',
+                };
+            case 'sign-accounting':
+            case '()':
+                return {
+                    currencySign: 'accounting',
+                };
+            case 'sign-always':
+            case '+!':
+                return {
+                    signDisplay: 'always',
+                };
+            case 'sign-accounting-always':
+            case '()!':
+                return {
+                    signDisplay: 'always',
+                    currencySign: 'accounting',
+                };
+            case 'sign-except-zero':
+            case '+?':
+                return {
+                    signDisplay: 'exceptZero',
+                };
+            case 'sign-accounting-except-zero':
+            case '()?':
+                return {
+                    signDisplay: 'exceptZero',
+                    currencySign: 'accounting',
+                };
+            case 'sign-never':
+            case '+_':
+                return {
+                    signDisplay: 'never',
+                };
+        }
+    }
+    function parseConciseScientificAndEngineeringStem(stem) {
+        // Engineering
+        var result;
+        if (stem[0] === 'E' && stem[1] === 'E') {
+            result = {
+                notation: 'engineering',
+            };
+            stem = stem.slice(2);
+        }
+        else if (stem[0] === 'E') {
+            result = {
+                notation: 'scientific',
+            };
+            stem = stem.slice(1);
+        }
+        if (result) {
+            var signDisplay = stem.slice(0, 2);
+            if (signDisplay === '+!') {
+                result.signDisplay = 'always';
+                stem = stem.slice(2);
+            }
+            else if (signDisplay === '+?') {
+                result.signDisplay = 'exceptZero';
+                stem = stem.slice(2);
+            }
+            if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {
+                throw new Error('Malformed concise eng/scientific notation');
+            }
+            result.minimumIntegerDigits = stem.length;
+        }
+        return result;
+    }
+    function parseNotationOptions(opt) {
+        var result = {};
+        var signOpts = parseSign(opt);
+        if (signOpts) {
+            return signOpts;
+        }
+        return result;
+    }
+    /**
+     * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options
+     */
+    function parseNumberSkeleton(tokens) {
+        var result = {};
+        for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+            var token = tokens_1[_i];
+            switch (token.stem) {
+                case 'percent':
+                case '%':
+                    result.style = 'percent';
+                    continue;
+                case '%x100':
+                    result.style = 'percent';
+                    result.scale = 100;
+                    continue;
+                case 'currency':
+                    result.style = 'currency';
+                    result.currency = token.options[0];
+                    continue;
+                case 'group-off':
+                case ',_':
+                    result.useGrouping = false;
+                    continue;
+                case 'precision-integer':
+                case '.':
+                    result.maximumFractionDigits = 0;
+                    continue;
+                case 'measure-unit':
+                case 'unit':
+                    result.style = 'unit';
+                    result.unit = icuUnitToEcma(token.options[0]);
+                    continue;
+                case 'compact-short':
+                case 'K':
+                    result.notation = 'compact';
+                    result.compactDisplay = 'short';
+                    continue;
+                case 'compact-long':
+                case 'KK':
+                    result.notation = 'compact';
+                    result.compactDisplay = 'long';
+                    continue;
+                case 'scientific':
+                    result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
+                    continue;
+                case 'engineering':
+                    result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
+                    continue;
+                case 'notation-simple':
+                    result.notation = 'standard';
+                    continue;
+                // https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h
+                case 'unit-width-narrow':
+                    result.currencyDisplay = 'narrowSymbol';
+                    result.unitDisplay = 'narrow';
+                    continue;
+                case 'unit-width-short':
+                    result.currencyDisplay = 'code';
+                    result.unitDisplay = 'short';
+                    continue;
+                case 'unit-width-full-name':
+                    result.currencyDisplay = 'name';
+                    result.unitDisplay = 'long';
+                    continue;
+                case 'unit-width-iso-code':
+                    result.currencyDisplay = 'symbol';
+                    continue;
+                case 'scale':
+                    result.scale = parseFloat(token.options[0]);
+                    continue;
+                // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
+                case 'integer-width':
+                    if (token.options.length > 1) {
+                        throw new RangeError('integer-width stems only accept a single optional option');
+                    }
+                    token.options[0].replace(INTEGER_WIDTH_REGEX, function (_, g1, g2, g3, g4, g5) {
+                        if (g1) {
+                            result.minimumIntegerDigits = g2.length;
+                        }
+                        else if (g3 && g4) {
+                            throw new Error('We currently do not support maximum integer digits');
+                        }
+                        else if (g5) {
+                            throw new Error('We currently do not support exact integer digits');
+                        }
+                        return '';
+                    });
+                    continue;
+            }
+            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width
+            if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {
+                result.minimumIntegerDigits = token.stem.length;
+                continue;
+            }
+            if (FRACTION_PRECISION_REGEX.test(token.stem)) {
+                // Precision
+                // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#fraction-precision
+                // precision-integer case
+                if (token.options.length > 1) {
+                    throw new RangeError('Fraction-precision stems only accept a single optional option');
+                }
+                token.stem.replace(FRACTION_PRECISION_REGEX, function (_, g1, g2, g3, g4, g5) {
+                    // .000* case (before ICU67 it was .000+)
+                    if (g2 === '*') {
+                        result.minimumFractionDigits = g1.length;
+                    }
+                    // .### case
+                    else if (g3 && g3[0] === '#') {
+                        result.maximumFractionDigits = g3.length;
+                    }
+                    // .00## case
+                    else if (g4 && g5) {
+                        result.minimumFractionDigits = g4.length;
+                        result.maximumFractionDigits = g4.length + g5.length;
+                    }
+                    else {
+                        result.minimumFractionDigits = g1.length;
+                        result.maximumFractionDigits = g1.length;
+                    }
+                    return '';
+                });
+                if (token.options.length) {
+                    result = __assign(__assign({}, result), parseSignificantPrecision(token.options[0]));
+                }
+                continue;
+            }
+            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#significant-digits-precision
+            if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
+                result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));
+                continue;
+            }
+            var signOpts = parseSign(token.stem);
+            if (signOpts) {
+                result = __assign(__assign({}, result), signOpts);
+            }
+            var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);
+            if (conciseScientificAndEngineeringOpts) {
+                result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);
+            }
+        }
+        return result;
+    }
+
+    var _a;
+    var SPACE_SEPARATOR_START_REGEX = new RegExp("^" + SPACE_SEPARATOR_REGEX.source + "*");
+    var SPACE_SEPARATOR_END_REGEX = new RegExp(SPACE_SEPARATOR_REGEX.source + "*$");
+    function createLocation(start, end) {
+        return { start: start, end: end };
+    }
+    // #region Ponyfills
+    // Consolidate these variables up top for easier toggling during debugging
+    var hasNativeStartsWith = !!String.prototype.startsWith;
+    var hasNativeFromCodePoint = !!String.fromCodePoint;
+    var hasNativeFromEntries = !!Object.fromEntries;
+    var hasNativeCodePointAt = !!String.prototype.codePointAt;
+    var hasTrimStart = !!String.prototype.trimStart;
+    var hasTrimEnd = !!String.prototype.trimEnd;
+    var hasNativeIsSafeInteger = !!Number.isSafeInteger;
+    var isSafeInteger = hasNativeIsSafeInteger
+        ? Number.isSafeInteger
+        : function (n) {
+            return (typeof n === 'number' &&
+                isFinite(n) &&
+                Math.floor(n) === n &&
+                Math.abs(n) <= 0x1fffffffffffff);
+        };
+    // IE11 does not support y and u.
+    var REGEX_SUPPORTS_U_AND_Y = true;
+    try {
+        var re = RE('([^\\p{White_Space}\\p{Pattern_Syntax}]*)', 'yu');
+        /**
+         * legacy Edge or Xbox One browser
+         * Unicode flag support: supported
+         * Pattern_Syntax support: not supported
+         * See https://github.com/formatjs/formatjs/issues/2822
+         */
+        REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec('a')) === null || _a === void 0 ? void 0 : _a[0]) === 'a';
+    }
+    catch (_) {
+        REGEX_SUPPORTS_U_AND_Y = false;
+    }
+    var startsWith = hasNativeStartsWith
+        ? // Native
+            function startsWith(s, search, position) {
+                return s.startsWith(search, position);
+            }
+        : // For IE11
+            function startsWith(s, search, position) {
+                return s.slice(position, position + search.length) === search;
+            };
+    var fromCodePoint = hasNativeFromCodePoint
+        ? String.fromCodePoint
+        : // IE11
+            function fromCodePoint() {
+                var codePoints = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    codePoints[_i] = arguments[_i];
+                }
+                var elements = '';
+                var length = codePoints.length;
+                var i = 0;
+                var code;
+                while (length > i) {
+                    code = codePoints[i++];
+                    if (code > 0x10ffff)
+                        throw RangeError(code + ' is not a valid code point');
+                    elements +=
+                        code < 0x10000
+                            ? String.fromCharCode(code)
+                            : String.fromCharCode(((code -= 0x10000) >> 10) + 0xd800, (code % 0x400) + 0xdc00);
+                }
+                return elements;
+            };
+    var fromEntries = 
+    // native
+    hasNativeFromEntries
+        ? Object.fromEntries
+        : // Ponyfill
+            function fromEntries(entries) {
+                var obj = {};
+                for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+                    var _a = entries_1[_i], k = _a[0], v = _a[1];
+                    obj[k] = v;
+                }
+                return obj;
+            };
+    var codePointAt = hasNativeCodePointAt
+        ? // Native
+            function codePointAt(s, index) {
+                return s.codePointAt(index);
+            }
+        : // IE 11
+            function codePointAt(s, index) {
+                var size = s.length;
+                if (index < 0 || index >= size) {
+                    return undefined;
+                }
+                var first = s.charCodeAt(index);
+                var second;
+                return first < 0xd800 ||
+                    first > 0xdbff ||
+                    index + 1 === size ||
+                    (second = s.charCodeAt(index + 1)) < 0xdc00 ||
+                    second > 0xdfff
+                    ? first
+                    : ((first - 0xd800) << 10) + (second - 0xdc00) + 0x10000;
+            };
+    var trimStart = hasTrimStart
+        ? // Native
+            function trimStart(s) {
+                return s.trimStart();
+            }
+        : // Ponyfill
+            function trimStart(s) {
+                return s.replace(SPACE_SEPARATOR_START_REGEX, '');
+            };
+    var trimEnd = hasTrimEnd
+        ? // Native
+            function trimEnd(s) {
+                return s.trimEnd();
+            }
+        : // Ponyfill
+            function trimEnd(s) {
+                return s.replace(SPACE_SEPARATOR_END_REGEX, '');
+            };
+    // Prevent minifier to translate new RegExp to literal form that might cause syntax error on IE11.
+    function RE(s, flag) {
+        return new RegExp(s, flag);
+    }
+    // #endregion
+    var matchIdentifierAtIndex;
+    if (REGEX_SUPPORTS_U_AND_Y) {
+        // Native
+        var IDENTIFIER_PREFIX_RE_1 = RE('([^\\p{White_Space}\\p{Pattern_Syntax}]*)', 'yu');
+        matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {
+            var _a;
+            IDENTIFIER_PREFIX_RE_1.lastIndex = index;
+            var match = IDENTIFIER_PREFIX_RE_1.exec(s);
+            return (_a = match[1]) !== null && _a !== void 0 ? _a : '';
+        };
+    }
+    else {
+        // IE11
+        matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {
+            var match = [];
+            while (true) {
+                var c = codePointAt(s, index);
+                if (c === undefined || _isWhiteSpace(c) || _isPatternSyntax(c)) {
+                    break;
+                }
+                match.push(c);
+                index += c >= 0x10000 ? 2 : 1;
+            }
+            return fromCodePoint.apply(void 0, match);
+        };
+    }
+    var Parser = /** @class */ (function () {
+        function Parser(message, options) {
+            if (options === void 0) { options = {}; }
+            this.message = message;
+            this.position = { offset: 0, line: 1, column: 1 };
+            this.ignoreTag = !!options.ignoreTag;
+            this.requiresOtherClause = !!options.requiresOtherClause;
+            this.shouldParseSkeletons = !!options.shouldParseSkeletons;
+        }
+        Parser.prototype.parse = function () {
+            if (this.offset() !== 0) {
+                throw Error('parser can only be used once');
+            }
+            return this.parseMessage(0, '', false);
+        };
+        Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {
+            var elements = [];
+            while (!this.isEOF()) {
+                var char = this.char();
+                if (char === 123 /* `{` */) {
+                    var result = this.parseArgument(nestingLevel, expectingCloseTag);
+                    if (result.err) {
+                        return result;
+                    }
+                    elements.push(result.val);
+                }
+                else if (char === 125 /* `}` */ && nestingLevel > 0) {
+                    break;
+                }
+                else if (char === 35 /* `#` */ &&
+                    (parentArgType === 'plural' || parentArgType === 'selectordinal')) {
+                    var position = this.clonePosition();
+                    this.bump();
+                    elements.push({
+                        type: TYPE.pound,
+                        location: createLocation(position, this.clonePosition()),
+                    });
+                }
+                else if (char === 60 /* `<` */ &&
+                    !this.ignoreTag &&
+                    this.peek() === 47 // char code for '/'
+                ) {
+                    if (expectingCloseTag) {
+                        break;
+                    }
+                    else {
+                        return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));
+                    }
+                }
+                else if (char === 60 /* `<` */ &&
+                    !this.ignoreTag &&
+                    _isAlpha(this.peek() || 0)) {
+                    var result = this.parseTag(nestingLevel, parentArgType);
+                    if (result.err) {
+                        return result;
+                    }
+                    elements.push(result.val);
+                }
+                else {
+                    var result = this.parseLiteral(nestingLevel, parentArgType);
+                    if (result.err) {
+                        return result;
+                    }
+                    elements.push(result.val);
+                }
+            }
+            return { val: elements, err: null };
+        };
+        /**
+         * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
+         * [custom element name][] except that a dash is NOT always mandatory and uppercase letters
+         * are accepted:
+         *
+         * ```
+         * tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
+         * tagName ::= [a-z] (PENChar)*
+         * PENChar ::=
+         *     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+         *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
+         *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+         * ```
+         *
+         * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+         * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
+         * since other tag-based engines like React allow it
+         */
+        Parser.prototype.parseTag = function (nestingLevel, parentArgType) {
+            var startPosition = this.clonePosition();
+            this.bump(); // `<`
+            var tagName = this.parseTagName();
+            this.bumpSpace();
+            if (this.bumpIf('/>')) {
+                // Self closing tag
+                return {
+                    val: {
+                        type: TYPE.literal,
+                        value: "<" + tagName + "/>",
+                        location: createLocation(startPosition, this.clonePosition()),
+                    },
+                    err: null,
+                };
+            }
+            else if (this.bumpIf('>')) {
+                var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
+                if (childrenResult.err) {
+                    return childrenResult;
+                }
+                var children = childrenResult.val;
+                // Expecting a close tag
+                var endTagStartPosition = this.clonePosition();
+                if (this.bumpIf('</')) {
+                    if (this.isEOF() || !_isAlpha(this.char())) {
+                        return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+                    }
+                    var closingTagNameStartPosition = this.clonePosition();
+                    var closingTagName = this.parseTagName();
+                    if (tagName !== closingTagName) {
+                        return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));
+                    }
+                    this.bumpSpace();
+                    if (!this.bumpIf('>')) {
+                        return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+                    }
+                    return {
+                        val: {
+                            type: TYPE.tag,
+                            value: tagName,
+                            children: children,
+                            location: createLocation(startPosition, this.clonePosition()),
+                        },
+                        err: null,
+                    };
+                }
+                else {
+                    return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));
+                }
+            }
+            else {
+                return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));
+            }
+        };
+        /**
+         * This method assumes that the caller has peeked ahead for the first tag character.
+         */
+        Parser.prototype.parseTagName = function () {
+            var startOffset = this.offset();
+            this.bump(); // the first tag name character
+            while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {
+                this.bump();
+            }
+            return this.message.slice(startOffset, this.offset());
+        };
+        Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {
+            var start = this.clonePosition();
+            var value = '';
+            while (true) {
+                var parseQuoteResult = this.tryParseQuote(parentArgType);
+                if (parseQuoteResult) {
+                    value += parseQuoteResult;
+                    continue;
+                }
+                var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
+                if (parseUnquotedResult) {
+                    value += parseUnquotedResult;
+                    continue;
+                }
+                var parseLeftAngleResult = this.tryParseLeftAngleBracket();
+                if (parseLeftAngleResult) {
+                    value += parseLeftAngleResult;
+                    continue;
+                }
+                break;
+            }
+            var location = createLocation(start, this.clonePosition());
+            return {
+                val: { type: TYPE.literal, value: value, location: location },
+                err: null,
+            };
+        };
+        Parser.prototype.tryParseLeftAngleBracket = function () {
+            if (!this.isEOF() &&
+                this.char() === 60 /* `<` */ &&
+                (this.ignoreTag ||
+                    // If at the opening tag or closing tag position, bail.
+                    !_isAlphaOrSlash(this.peek() || 0))) {
+                this.bump(); // `<`
+                return '<';
+            }
+            return null;
+        };
+        /**
+         * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
+         * a character that requires quoting (that is, "only where needed"), and works the same in
+         * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
+         */
+        Parser.prototype.tryParseQuote = function (parentArgType) {
+            if (this.isEOF() || this.char() !== 39 /* `'` */) {
+                return null;
+            }
+            // Parse escaped char following the apostrophe, or early return if there is no escaped char.
+            // Check if is valid escaped character
+            switch (this.peek()) {
+                case 39 /* `'` */:
+                    // double quote, should return as a single quote.
+                    this.bump();
+                    this.bump();
+                    return "'";
+                // '{', '<', '>', '}'
+                case 123:
+                case 60:
+                case 62:
+                case 125:
+                    break;
+                case 35: // '#'
+                    if (parentArgType === 'plural' || parentArgType === 'selectordinal') {
+                        break;
+                    }
+                    return null;
+                default:
+                    return null;
+            }
+            this.bump(); // apostrophe
+            var codePoints = [this.char()]; // escaped char
+            this.bump();
+            // read chars until the optional closing apostrophe is found
+            while (!this.isEOF()) {
+                var ch = this.char();
+                if (ch === 39 /* `'` */) {
+                    if (this.peek() === 39 /* `'` */) {
+                        codePoints.push(39);
+                        // Bump one more time because we need to skip 2 characters.
+                        this.bump();
+                    }
+                    else {
+                        // Optional closing apostrophe.
+                        this.bump();
+                        break;
+                    }
+                }
+                else {
+                    codePoints.push(ch);
+                }
+                this.bump();
+            }
+            return fromCodePoint.apply(void 0, codePoints);
+        };
+        Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {
+            if (this.isEOF()) {
+                return null;
+            }
+            var ch = this.char();
+            if (ch === 60 /* `<` */ ||
+                ch === 123 /* `{` */ ||
+                (ch === 35 /* `#` */ &&
+                    (parentArgType === 'plural' || parentArgType === 'selectordinal')) ||
+                (ch === 125 /* `}` */ && nestingLevel > 0)) {
+                return null;
+            }
+            else {
+                this.bump();
+                return fromCodePoint(ch);
+            }
+        };
+        Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {
+            var openingBracePosition = this.clonePosition();
+            this.bump(); // `{`
+            this.bumpSpace();
+            if (this.isEOF()) {
+                return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+            }
+            if (this.char() === 125 /* `}` */) {
+                this.bump();
+                return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+            }
+            // argument name
+            var value = this.parseIdentifierIfPossible().value;
+            if (!value) {
+                return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+            }
+            this.bumpSpace();
+            if (this.isEOF()) {
+                return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+            }
+            switch (this.char()) {
+                // Simple argument: `{name}`
+                case 125 /* `}` */: {
+                    this.bump(); // `}`
+                    return {
+                        val: {
+                            type: TYPE.argument,
+                            // value does not include the opening and closing braces.
+                            value: value,
+                            location: createLocation(openingBracePosition, this.clonePosition()),
+                        },
+                        err: null,
+                    };
+                }
+                // Argument with options: `{name, format, ...}`
+                case 44 /* `,` */: {
+                    this.bump(); // `,`
+                    this.bumpSpace();
+                    if (this.isEOF()) {
+                        return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+                    }
+                    return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
+                }
+                default:
+                    return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+            }
+        };
+        /**
+         * Advance the parser until the end of the identifier, if it is currently on
+         * an identifier character. Return an empty string otherwise.
+         */
+        Parser.prototype.parseIdentifierIfPossible = function () {
+            var startingPosition = this.clonePosition();
+            var startOffset = this.offset();
+            var value = matchIdentifierAtIndex(this.message, startOffset);
+            var endOffset = startOffset + value.length;
+            this.bumpTo(endOffset);
+            var endPosition = this.clonePosition();
+            var location = createLocation(startingPosition, endPosition);
+            return { value: value, location: location };
+        };
+        Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {
+            var _a;
+            // Parse this range:
+            // {name, type, style}
+            //        ^---^
+            var typeStartPosition = this.clonePosition();
+            var argType = this.parseIdentifierIfPossible().value;
+            var typeEndPosition = this.clonePosition();
+            switch (argType) {
+                case '':
+                    // Expecting a style string number, date, time, plural, selectordinal, or select.
+                    return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+                case 'number':
+                case 'date':
+                case 'time': {
+                    // Parse this range:
+                    // {name, number, style}
+                    //              ^-------^
+                    this.bumpSpace();
+                    var styleAndLocation = null;
+                    if (this.bumpIf(',')) {
+                        this.bumpSpace();
+                        var styleStartPosition = this.clonePosition();
+                        var result = this.parseSimpleArgStyleIfPossible();
+                        if (result.err) {
+                            return result;
+                        }
+                        var style = trimEnd(result.val);
+                        if (style.length === 0) {
+                            return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));
+                        }
+                        var styleLocation = createLocation(styleStartPosition, this.clonePosition());
+                        styleAndLocation = { style: style, styleLocation: styleLocation };
+                    }
+                    var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+                    if (argCloseResult.err) {
+                        return argCloseResult;
+                    }
+                    var location_1 = createLocation(openingBracePosition, this.clonePosition());
+                    // Extract style or skeleton
+                    if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, '::', 0)) {
+                        // Skeleton starts with `::`.
+                        var skeleton = trimStart(styleAndLocation.style.slice(2));
+                        if (argType === 'number') {
+                            var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
+                            if (result.err) {
+                                return result;
+                            }
+                            return {
+                                val: { type: TYPE.number, value: value, location: location_1, style: result.val },
+                                err: null,
+                            };
+                        }
+                        else {
+                            if (skeleton.length === 0) {
+                                return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);
+                            }
+                            var style = {
+                                type: SKELETON_TYPE.dateTime,
+                                pattern: skeleton,
+                                location: styleAndLocation.styleLocation,
+                                parsedOptions: this.shouldParseSkeletons
+                                    ? parseDateTimeSkeleton(skeleton)
+                                    : {},
+                            };
+                            var type = argType === 'date' ? TYPE.date : TYPE.time;
+                            return {
+                                val: { type: type, value: value, location: location_1, style: style },
+                                err: null,
+                            };
+                        }
+                    }
+                    // Regular style or no style.
+                    return {
+                        val: {
+                            type: argType === 'number'
+                                ? TYPE.number
+                                : argType === 'date'
+                                    ? TYPE.date
+                                    : TYPE.time,
+                            value: value,
+                            location: location_1,
+                            style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,
+                        },
+                        err: null,
+                    };
+                }
+                case 'plural':
+                case 'selectordinal':
+                case 'select': {
+                    // Parse this range:
+                    // {name, plural, options}
+                    //              ^---------^
+                    var typeEndPosition_1 = this.clonePosition();
+                    this.bumpSpace();
+                    if (!this.bumpIf(',')) {
+                        return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));
+                    }
+                    this.bumpSpace();
+                    // Parse offset:
+                    // {name, plural, offset:1, options}
+                    //                ^-----^
+                    //
+                    // or the first option:
+                    //
+                    // {name, plural, one {...} other {...}}
+                    //                ^--^
+                    var identifierAndLocation = this.parseIdentifierIfPossible();
+                    var pluralOffset = 0;
+                    if (argType !== 'select' && identifierAndLocation.value === 'offset') {
+                        if (!this.bumpIf(':')) {
+                            return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));
+                        }
+                        this.bumpSpace();
+                        var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
+                        if (result.err) {
+                            return result;
+                        }
+                        // Parse another identifier for option parsing
+                        this.bumpSpace();
+                        identifierAndLocation = this.parseIdentifierIfPossible();
+                        pluralOffset = result.val;
+                    }
+                    var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
+                    if (optionsResult.err) {
+                        return optionsResult;
+                    }
+                    var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+                    if (argCloseResult.err) {
+                        return argCloseResult;
+                    }
+                    var location_2 = createLocation(openingBracePosition, this.clonePosition());
+                    if (argType === 'select') {
+                        return {
+                            val: {
+                                type: TYPE.select,
+                                value: value,
+                                options: fromEntries(optionsResult.val),
+                                location: location_2,
+                            },
+                            err: null,
+                        };
+                    }
+                    else {
+                        return {
+                            val: {
+                                type: TYPE.plural,
+                                value: value,
+                                options: fromEntries(optionsResult.val),
+                                offset: pluralOffset,
+                                pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',
+                                location: location_2,
+                            },
+                            err: null,
+                        };
+                    }
+                }
+                default:
+                    return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+            }
+        };
+        Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {
+            // Parse: {value, number, ::currency/GBP }
+            //
+            if (this.isEOF() || this.char() !== 125 /* `}` */) {
+                return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+            }
+            this.bump(); // `}`
+            return { val: true, err: null };
+        };
+        /**
+         * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
+         */
+        Parser.prototype.parseSimpleArgStyleIfPossible = function () {
+            var nestedBraces = 0;
+            var startPosition = this.clonePosition();
+            while (!this.isEOF()) {
+                var ch = this.char();
+                switch (ch) {
+                    case 39 /* `'` */: {
+                        // Treat apostrophe as quoting but include it in the style part.
+                        // Find the end of the quoted literal text.
+                        this.bump();
+                        var apostrophePosition = this.clonePosition();
+                        if (!this.bumpUntil("'")) {
+                            return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));
+                        }
+                        this.bump();
+                        break;
+                    }
+                    case 123 /* `{` */: {
+                        nestedBraces += 1;
+                        this.bump();
+                        break;
+                    }
+                    case 125 /* `}` */: {
+                        if (nestedBraces > 0) {
+                            nestedBraces -= 1;
+                        }
+                        else {
+                            return {
+                                val: this.message.slice(startPosition.offset, this.offset()),
+                                err: null,
+                            };
+                        }
+                        break;
+                    }
+                    default:
+                        this.bump();
+                        break;
+                }
+            }
+            return {
+                val: this.message.slice(startPosition.offset, this.offset()),
+                err: null,
+            };
+        };
+        Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {
+            var tokens = [];
+            try {
+                tokens = parseNumberSkeletonFromString(skeleton);
+            }
+            catch (e) {
+                return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);
+            }
+            return {
+                val: {
+                    type: SKELETON_TYPE.number,
+                    tokens: tokens,
+                    location: location,
+                    parsedOptions: this.shouldParseSkeletons
+                        ? parseNumberSkeleton(tokens)
+                        : {},
+                },
+                err: null,
+            };
+        };
+        /**
+         * @param nesting_level The current nesting level of messages.
+         *     This can be positive when parsing message fragment in select or plural argument options.
+         * @param parent_arg_type The parent argument's type.
+         * @param parsed_first_identifier If provided, this is the first identifier-like selector of
+         *     the argument. It is a by-product of a previous parsing attempt.
+         * @param expecting_close_tag If true, this message is directly or indirectly nested inside
+         *     between a pair of opening and closing tags. The nested message will not parse beyond
+         *     the closing tag boundary.
+         */
+        Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
+            var _a;
+            var hasOtherClause = false;
+            var options = [];
+            var parsedSelectors = new Set();
+            var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;
+            // Parse:
+            // one {one apple}
+            // ^--^
+            while (true) {
+                if (selector.length === 0) {
+                    var startPosition = this.clonePosition();
+                    if (parentArgType !== 'select' && this.bumpIf('=')) {
+                        // Try parse `={number}` selector
+                        var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);
+                        if (result.err) {
+                            return result;
+                        }
+                        selectorLocation = createLocation(startPosition, this.clonePosition());
+                        selector = this.message.slice(startPosition.offset, this.offset());
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // Duplicate selector clauses
+                if (parsedSelectors.has(selector)) {
+                    return this.error(parentArgType === 'select'
+                        ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR
+                        : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);
+                }
+                if (selector === 'other') {
+                    hasOtherClause = true;
+                }
+                // Parse:
+                // one {one apple}
+                //     ^----------^
+                this.bumpSpace();
+                var openingBracePosition = this.clonePosition();
+                if (!this.bumpIf('{')) {
+                    return this.error(parentArgType === 'select'
+                        ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT
+                        : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));
+                }
+                var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
+                if (fragmentResult.err) {
+                    return fragmentResult;
+                }
+                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+                if (argCloseResult.err) {
+                    return argCloseResult;
+                }
+                options.push([
+                    selector,
+                    {
+                        value: fragmentResult.val,
+                        location: createLocation(openingBracePosition, this.clonePosition()),
+                    },
+                ]);
+                // Keep track of the existing selectors
+                parsedSelectors.add(selector);
+                // Prep next selector clause.
+                this.bumpSpace();
+                (_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);
+            }
+            if (options.length === 0) {
+                return this.error(parentArgType === 'select'
+                    ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR
+                    : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));
+            }
+            if (this.requiresOtherClause && !hasOtherClause) {
+                return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));
+            }
+            return { val: options, err: null };
+        };
+        Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {
+            var sign = 1;
+            var startingPosition = this.clonePosition();
+            if (this.bumpIf('+')) ;
+            else if (this.bumpIf('-')) {
+                sign = -1;
+            }
+            var hasDigits = false;
+            var decimal = 0;
+            while (!this.isEOF()) {
+                var ch = this.char();
+                if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {
+                    hasDigits = true;
+                    decimal = decimal * 10 + (ch - 48);
+                    this.bump();
+                }
+                else {
+                    break;
+                }
+            }
+            var location = createLocation(startingPosition, this.clonePosition());
+            if (!hasDigits) {
+                return this.error(expectNumberError, location);
+            }
+            decimal *= sign;
+            if (!isSafeInteger(decimal)) {
+                return this.error(invalidNumberError, location);
+            }
+            return { val: decimal, err: null };
+        };
+        Parser.prototype.offset = function () {
+            return this.position.offset;
+        };
+        Parser.prototype.isEOF = function () {
+            return this.offset() === this.message.length;
+        };
+        Parser.prototype.clonePosition = function () {
+            // This is much faster than `Object.assign` or spread.
+            return {
+                offset: this.position.offset,
+                line: this.position.line,
+                column: this.position.column,
+            };
+        };
+        /**
+         * Return the code point at the current position of the parser.
+         * Throws if the index is out of bound.
+         */
+        Parser.prototype.char = function () {
+            var offset = this.position.offset;
+            if (offset >= this.message.length) {
+                throw Error('out of bound');
+            }
+            var code = codePointAt(this.message, offset);
+            if (code === undefined) {
+                throw Error("Offset " + offset + " is at invalid UTF-16 code unit boundary");
+            }
+            return code;
+        };
+        Parser.prototype.error = function (kind, location) {
+            return {
+                val: null,
+                err: {
+                    kind: kind,
+                    message: this.message,
+                    location: location,
+                },
+            };
+        };
+        /** Bump the parser to the next UTF-16 code unit. */
+        Parser.prototype.bump = function () {
+            if (this.isEOF()) {
+                return;
+            }
+            var code = this.char();
+            if (code === 10 /* '\n' */) {
+                this.position.line += 1;
+                this.position.column = 1;
+                this.position.offset += 1;
+            }
+            else {
+                this.position.column += 1;
+                // 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.
+                this.position.offset += code < 0x10000 ? 1 : 2;
+            }
+        };
+        /**
+         * If the substring starting at the current position of the parser has
+         * the given prefix, then bump the parser to the character immediately
+         * following the prefix and return true. Otherwise, don't bump the parser
+         * and return false.
+         */
+        Parser.prototype.bumpIf = function (prefix) {
+            if (startsWith(this.message, prefix, this.offset())) {
+                for (var i = 0; i < prefix.length; i++) {
+                    this.bump();
+                }
+                return true;
+            }
+            return false;
+        };
+        /**
+         * Bump the parser until the pattern character is found and return `true`.
+         * Otherwise bump to the end of the file and return `false`.
+         */
+        Parser.prototype.bumpUntil = function (pattern) {
+            var currentOffset = this.offset();
+            var index = this.message.indexOf(pattern, currentOffset);
+            if (index >= 0) {
+                this.bumpTo(index);
+                return true;
+            }
+            else {
+                this.bumpTo(this.message.length);
+                return false;
+            }
+        };
+        /**
+         * Bump the parser to the target offset.
+         * If target offset is beyond the end of the input, bump the parser to the end of the input.
+         */
+        Parser.prototype.bumpTo = function (targetOffset) {
+            if (this.offset() > targetOffset) {
+                throw Error("targetOffset " + targetOffset + " must be greater than or equal to the current offset " + this.offset());
+            }
+            targetOffset = Math.min(targetOffset, this.message.length);
+            while (true) {
+                var offset = this.offset();
+                if (offset === targetOffset) {
+                    break;
+                }
+                if (offset > targetOffset) {
+                    throw Error("targetOffset " + targetOffset + " is at invalid UTF-16 code unit boundary");
+                }
+                this.bump();
+                if (this.isEOF()) {
+                    break;
+                }
+            }
+        };
+        /** advance the parser through all whitespace to the next non-whitespace code unit. */
+        Parser.prototype.bumpSpace = function () {
+            while (!this.isEOF() && _isWhiteSpace(this.char())) {
+                this.bump();
+            }
+        };
+        /**
+         * Peek at the *next* Unicode codepoint in the input without advancing the parser.
+         * If the input has been exhausted, then this returns null.
+         */
+        Parser.prototype.peek = function () {
+            if (this.isEOF()) {
+                return null;
+            }
+            var code = this.char();
+            var offset = this.offset();
+            var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));
+            return nextCode !== null && nextCode !== void 0 ? nextCode : null;
+        };
+        return Parser;
+    }());
+    /**
+     * This check if codepoint is alphabet (lower & uppercase)
+     * @param codepoint
+     * @returns
+     */
+    function _isAlpha(codepoint) {
+        return ((codepoint >= 97 && codepoint <= 122) ||
+            (codepoint >= 65 && codepoint <= 90));
+    }
+    function _isAlphaOrSlash(codepoint) {
+        return _isAlpha(codepoint) || codepoint === 47; /* '/' */
+    }
+    /** See `parseTag` function docs. */
+    function _isPotentialElementNameChar(c) {
+        return (c === 45 /* '-' */ ||
+            c === 46 /* '.' */ ||
+            (c >= 48 && c <= 57) /* 0..9 */ ||
+            c === 95 /* '_' */ ||
+            (c >= 97 && c <= 122) /** a..z */ ||
+            (c >= 65 && c <= 90) /* A..Z */ ||
+            c == 0xb7 ||
+            (c >= 0xc0 && c <= 0xd6) ||
+            (c >= 0xd8 && c <= 0xf6) ||
+            (c >= 0xf8 && c <= 0x37d) ||
+            (c >= 0x37f && c <= 0x1fff) ||
+            (c >= 0x200c && c <= 0x200d) ||
+            (c >= 0x203f && c <= 0x2040) ||
+            (c >= 0x2070 && c <= 0x218f) ||
+            (c >= 0x2c00 && c <= 0x2fef) ||
+            (c >= 0x3001 && c <= 0xd7ff) ||
+            (c >= 0xf900 && c <= 0xfdcf) ||
+            (c >= 0xfdf0 && c <= 0xfffd) ||
+            (c >= 0x10000 && c <= 0xeffff));
+    }
+    /**
+     * Code point equivalent of regex `\p{White_Space}`.
+     * From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
+     */
+    function _isWhiteSpace(c) {
+        return ((c >= 0x0009 && c <= 0x000d) ||
+            c === 0x0020 ||
+            c === 0x0085 ||
+            (c >= 0x200e && c <= 0x200f) ||
+            c === 0x2028 ||
+            c === 0x2029);
+    }
+    /**
+     * Code point equivalent of regex `\p{Pattern_Syntax}`.
+     * See https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
+     */
+    function _isPatternSyntax(c) {
+        return ((c >= 0x0021 && c <= 0x0023) ||
+            c === 0x0024 ||
+            (c >= 0x0025 && c <= 0x0027) ||
+            c === 0x0028 ||
+            c === 0x0029 ||
+            c === 0x002a ||
+            c === 0x002b ||
+            c === 0x002c ||
+            c === 0x002d ||
+            (c >= 0x002e && c <= 0x002f) ||
+            (c >= 0x003a && c <= 0x003b) ||
+            (c >= 0x003c && c <= 0x003e) ||
+            (c >= 0x003f && c <= 0x0040) ||
+            c === 0x005b ||
+            c === 0x005c ||
+            c === 0x005d ||
+            c === 0x005e ||
+            c === 0x0060 ||
+            c === 0x007b ||
+            c === 0x007c ||
+            c === 0x007d ||
+            c === 0x007e ||
+            c === 0x00a1 ||
+            (c >= 0x00a2 && c <= 0x00a5) ||
+            c === 0x00a6 ||
+            c === 0x00a7 ||
+            c === 0x00a9 ||
+            c === 0x00ab ||
+            c === 0x00ac ||
+            c === 0x00ae ||
+            c === 0x00b0 ||
+            c === 0x00b1 ||
+            c === 0x00b6 ||
+            c === 0x00bb ||
+            c === 0x00bf ||
+            c === 0x00d7 ||
+            c === 0x00f7 ||
+            (c >= 0x2010 && c <= 0x2015) ||
+            (c >= 0x2016 && c <= 0x2017) ||
+            c === 0x2018 ||
+            c === 0x2019 ||
+            c === 0x201a ||
+            (c >= 0x201b && c <= 0x201c) ||
+            c === 0x201d ||
+            c === 0x201e ||
+            c === 0x201f ||
+            (c >= 0x2020 && c <= 0x2027) ||
+            (c >= 0x2030 && c <= 0x2038) ||
+            c === 0x2039 ||
+            c === 0x203a ||
+            (c >= 0x203b && c <= 0x203e) ||
+            (c >= 0x2041 && c <= 0x2043) ||
+            c === 0x2044 ||
+            c === 0x2045 ||
+            c === 0x2046 ||
+            (c >= 0x2047 && c <= 0x2051) ||
+            c === 0x2052 ||
+            c === 0x2053 ||
+            (c >= 0x2055 && c <= 0x205e) ||
+            (c >= 0x2190 && c <= 0x2194) ||
+            (c >= 0x2195 && c <= 0x2199) ||
+            (c >= 0x219a && c <= 0x219b) ||
+            (c >= 0x219c && c <= 0x219f) ||
+            c === 0x21a0 ||
+            (c >= 0x21a1 && c <= 0x21a2) ||
+            c === 0x21a3 ||
+            (c >= 0x21a4 && c <= 0x21a5) ||
+            c === 0x21a6 ||
+            (c >= 0x21a7 && c <= 0x21ad) ||
+            c === 0x21ae ||
+            (c >= 0x21af && c <= 0x21cd) ||
+            (c >= 0x21ce && c <= 0x21cf) ||
+            (c >= 0x21d0 && c <= 0x21d1) ||
+            c === 0x21d2 ||
+            c === 0x21d3 ||
+            c === 0x21d4 ||
+            (c >= 0x21d5 && c <= 0x21f3) ||
+            (c >= 0x21f4 && c <= 0x22ff) ||
+            (c >= 0x2300 && c <= 0x2307) ||
+            c === 0x2308 ||
+            c === 0x2309 ||
+            c === 0x230a ||
+            c === 0x230b ||
+            (c >= 0x230c && c <= 0x231f) ||
+            (c >= 0x2320 && c <= 0x2321) ||
+            (c >= 0x2322 && c <= 0x2328) ||
+            c === 0x2329 ||
+            c === 0x232a ||
+            (c >= 0x232b && c <= 0x237b) ||
+            c === 0x237c ||
+            (c >= 0x237d && c <= 0x239a) ||
+            (c >= 0x239b && c <= 0x23b3) ||
+            (c >= 0x23b4 && c <= 0x23db) ||
+            (c >= 0x23dc && c <= 0x23e1) ||
+            (c >= 0x23e2 && c <= 0x2426) ||
+            (c >= 0x2427 && c <= 0x243f) ||
+            (c >= 0x2440 && c <= 0x244a) ||
+            (c >= 0x244b && c <= 0x245f) ||
+            (c >= 0x2500 && c <= 0x25b6) ||
+            c === 0x25b7 ||
+            (c >= 0x25b8 && c <= 0x25c0) ||
+            c === 0x25c1 ||
+            (c >= 0x25c2 && c <= 0x25f7) ||
+            (c >= 0x25f8 && c <= 0x25ff) ||
+            (c >= 0x2600 && c <= 0x266e) ||
+            c === 0x266f ||
+            (c >= 0x2670 && c <= 0x2767) ||
+            c === 0x2768 ||
+            c === 0x2769 ||
+            c === 0x276a ||
+            c === 0x276b ||
+            c === 0x276c ||
+            c === 0x276d ||
+            c === 0x276e ||
+            c === 0x276f ||
+            c === 0x2770 ||
+            c === 0x2771 ||
+            c === 0x2772 ||
+            c === 0x2773 ||
+            c === 0x2774 ||
+            c === 0x2775 ||
+            (c >= 0x2794 && c <= 0x27bf) ||
+            (c >= 0x27c0 && c <= 0x27c4) ||
+            c === 0x27c5 ||
+            c === 0x27c6 ||
+            (c >= 0x27c7 && c <= 0x27e5) ||
+            c === 0x27e6 ||
+            c === 0x27e7 ||
+            c === 0x27e8 ||
+            c === 0x27e9 ||
+            c === 0x27ea ||
+            c === 0x27eb ||
+            c === 0x27ec ||
+            c === 0x27ed ||
+            c === 0x27ee ||
+            c === 0x27ef ||
+            (c >= 0x27f0 && c <= 0x27ff) ||
+            (c >= 0x2800 && c <= 0x28ff) ||
+            (c >= 0x2900 && c <= 0x2982) ||
+            c === 0x2983 ||
+            c === 0x2984 ||
+            c === 0x2985 ||
+            c === 0x2986 ||
+            c === 0x2987 ||
+            c === 0x2988 ||
+            c === 0x2989 ||
+            c === 0x298a ||
+            c === 0x298b ||
+            c === 0x298c ||
+            c === 0x298d ||
+            c === 0x298e ||
+            c === 0x298f ||
+            c === 0x2990 ||
+            c === 0x2991 ||
+            c === 0x2992 ||
+            c === 0x2993 ||
+            c === 0x2994 ||
+            c === 0x2995 ||
+            c === 0x2996 ||
+            c === 0x2997 ||
+            c === 0x2998 ||
+            (c >= 0x2999 && c <= 0x29d7) ||
+            c === 0x29d8 ||
+            c === 0x29d9 ||
+            c === 0x29da ||
+            c === 0x29db ||
+            (c >= 0x29dc && c <= 0x29fb) ||
+            c === 0x29fc ||
+            c === 0x29fd ||
+            (c >= 0x29fe && c <= 0x2aff) ||
+            (c >= 0x2b00 && c <= 0x2b2f) ||
+            (c >= 0x2b30 && c <= 0x2b44) ||
+            (c >= 0x2b45 && c <= 0x2b46) ||
+            (c >= 0x2b47 && c <= 0x2b4c) ||
+            (c >= 0x2b4d && c <= 0x2b73) ||
+            (c >= 0x2b74 && c <= 0x2b75) ||
+            (c >= 0x2b76 && c <= 0x2b95) ||
+            c === 0x2b96 ||
+            (c >= 0x2b97 && c <= 0x2bff) ||
+            (c >= 0x2e00 && c <= 0x2e01) ||
+            c === 0x2e02 ||
+            c === 0x2e03 ||
+            c === 0x2e04 ||
+            c === 0x2e05 ||
+            (c >= 0x2e06 && c <= 0x2e08) ||
+            c === 0x2e09 ||
+            c === 0x2e0a ||
+            c === 0x2e0b ||
+            c === 0x2e0c ||
+            c === 0x2e0d ||
+            (c >= 0x2e0e && c <= 0x2e16) ||
+            c === 0x2e17 ||
+            (c >= 0x2e18 && c <= 0x2e19) ||
+            c === 0x2e1a ||
+            c === 0x2e1b ||
+            c === 0x2e1c ||
+            c === 0x2e1d ||
+            (c >= 0x2e1e && c <= 0x2e1f) ||
+            c === 0x2e20 ||
+            c === 0x2e21 ||
+            c === 0x2e22 ||
+            c === 0x2e23 ||
+            c === 0x2e24 ||
+            c === 0x2e25 ||
+            c === 0x2e26 ||
+            c === 0x2e27 ||
+            c === 0x2e28 ||
+            c === 0x2e29 ||
+            (c >= 0x2e2a && c <= 0x2e2e) ||
+            c === 0x2e2f ||
+            (c >= 0x2e30 && c <= 0x2e39) ||
+            (c >= 0x2e3a && c <= 0x2e3b) ||
+            (c >= 0x2e3c && c <= 0x2e3f) ||
+            c === 0x2e40 ||
+            c === 0x2e41 ||
+            c === 0x2e42 ||
+            (c >= 0x2e43 && c <= 0x2e4f) ||
+            (c >= 0x2e50 && c <= 0x2e51) ||
+            c === 0x2e52 ||
+            (c >= 0x2e53 && c <= 0x2e7f) ||
+            (c >= 0x3001 && c <= 0x3003) ||
+            c === 0x3008 ||
+            c === 0x3009 ||
+            c === 0x300a ||
+            c === 0x300b ||
+            c === 0x300c ||
+            c === 0x300d ||
+            c === 0x300e ||
+            c === 0x300f ||
+            c === 0x3010 ||
+            c === 0x3011 ||
+            (c >= 0x3012 && c <= 0x3013) ||
+            c === 0x3014 ||
+            c === 0x3015 ||
+            c === 0x3016 ||
+            c === 0x3017 ||
+            c === 0x3018 ||
+            c === 0x3019 ||
+            c === 0x301a ||
+            c === 0x301b ||
+            c === 0x301c ||
+            c === 0x301d ||
+            (c >= 0x301e && c <= 0x301f) ||
+            c === 0x3020 ||
+            c === 0x3030 ||
+            c === 0xfd3e ||
+            c === 0xfd3f ||
+            (c >= 0xfe45 && c <= 0xfe46));
+    }
+
+    function pruneLocation(els) {
+        els.forEach(function (el) {
+            delete el.location;
+            if (isSelectElement(el) || isPluralElement(el)) {
+                for (var k in el.options) {
+                    delete el.options[k].location;
+                    pruneLocation(el.options[k].value);
+                }
+            }
+            else if (isNumberElement(el) && isNumberSkeleton(el.style)) {
+                delete el.style.location;
+            }
+            else if ((isDateElement(el) || isTimeElement(el)) &&
+                isDateTimeSkeleton(el.style)) {
+                delete el.style.location;
+            }
+            else if (isTagElement(el)) {
+                pruneLocation(el.children);
+            }
+        });
+    }
+    function parse(message, opts) {
+        if (opts === void 0) { opts = {}; }
+        opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);
+        var result = new Parser(message, opts).parse();
+        if (result.err) {
+            var error = SyntaxError(ErrorKind[result.err.kind]);
+            // @ts-expect-error Assign to error object
+            error.location = result.err.location;
+            // @ts-expect-error Assign to error object
+            error.originalMessage = result.err.message;
+            throw error;
+        }
+        if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {
+            pruneLocation(result.val);
+        }
+        return result.val;
+    }
+
+    //
+    // Main
+    //
+    function memoize(fn, options) {
+        var cache = options && options.cache ? options.cache : cacheDefault;
+        var serializer = options && options.serializer ? options.serializer : serializerDefault;
+        var strategy = options && options.strategy ? options.strategy : strategyDefault;
+        return strategy(fn, {
+            cache: cache,
+            serializer: serializer,
+        });
+    }
+    //
+    // Strategy
+    //
+    function isPrimitive(value) {
+        return (value == null || typeof value === 'number' || typeof value === 'boolean'); // || typeof value === "string" 'unsafe' primitive for our needs
+    }
+    function monadic(fn, cache, serializer, arg) {
+        var cacheKey = isPrimitive(arg) ? arg : serializer(arg);
+        var computedValue = cache.get(cacheKey);
+        if (typeof computedValue === 'undefined') {
+            computedValue = fn.call(this, arg);
+            cache.set(cacheKey, computedValue);
+        }
+        return computedValue;
+    }
+    function variadic(fn, cache, serializer) {
+        var args = Array.prototype.slice.call(arguments, 3);
+        var cacheKey = serializer(args);
+        var computedValue = cache.get(cacheKey);
+        if (typeof computedValue === 'undefined') {
+            computedValue = fn.apply(this, args);
+            cache.set(cacheKey, computedValue);
+        }
+        return computedValue;
+    }
+    function assemble(fn, context, strategy, cache, serialize) {
+        return strategy.bind(context, fn, cache, serialize);
+    }
+    function strategyDefault(fn, options) {
+        var strategy = fn.length === 1 ? monadic : variadic;
+        return assemble(fn, this, strategy, options.cache.create(), options.serializer);
+    }
+    function strategyVariadic(fn, options) {
+        return assemble(fn, this, variadic, options.cache.create(), options.serializer);
+    }
+    function strategyMonadic(fn, options) {
+        return assemble(fn, this, monadic, options.cache.create(), options.serializer);
+    }
+    //
+    // Serializer
+    //
+    var serializerDefault = function () {
+        return JSON.stringify(arguments);
+    };
+    //
+    // Cache
+    //
+    function ObjectWithoutPrototypeCache() {
+        this.cache = Object.create(null);
+    }
+    ObjectWithoutPrototypeCache.prototype.has = function (key) {
+        return key in this.cache;
+    };
+    ObjectWithoutPrototypeCache.prototype.get = function (key) {
+        return this.cache[key];
+    };
+    ObjectWithoutPrototypeCache.prototype.set = function (key, value) {
+        this.cache[key] = value;
+    };
+    var cacheDefault = {
+        create: function create() {
+            // @ts-ignore
+            return new ObjectWithoutPrototypeCache();
+        },
+    };
+    var strategies = {
+        variadic: strategyVariadic,
+        monadic: strategyMonadic,
+    };
+
+    var ErrorCode;
+    (function (ErrorCode) {
+        // When we have a placeholder but no value to format
+        ErrorCode["MISSING_VALUE"] = "MISSING_VALUE";
+        // When value supplied is invalid
+        ErrorCode["INVALID_VALUE"] = "INVALID_VALUE";
+        // When we need specific Intl API but it's not available
+        ErrorCode["MISSING_INTL_API"] = "MISSING_INTL_API";
+    })(ErrorCode || (ErrorCode = {}));
+    var FormatError = /** @class */ (function (_super) {
+        __extends(FormatError, _super);
+        function FormatError(msg, code, originalMessage) {
+            var _this = _super.call(this, msg) || this;
+            _this.code = code;
+            _this.originalMessage = originalMessage;
+            return _this;
+        }
+        FormatError.prototype.toString = function () {
+            return "[formatjs Error: " + this.code + "] " + this.message;
+        };
+        return FormatError;
+    }(Error));
+    var InvalidValueError = /** @class */ (function (_super) {
+        __extends(InvalidValueError, _super);
+        function InvalidValueError(variableId, value, options, originalMessage) {
+            return _super.call(this, "Invalid values for \"" + variableId + "\": \"" + value + "\". Options are \"" + Object.keys(options).join('", "') + "\"", ErrorCode.INVALID_VALUE, originalMessage) || this;
+        }
+        return InvalidValueError;
+    }(FormatError));
+    var InvalidValueTypeError = /** @class */ (function (_super) {
+        __extends(InvalidValueTypeError, _super);
+        function InvalidValueTypeError(value, type, originalMessage) {
+            return _super.call(this, "Value for \"" + value + "\" must be of type " + type, ErrorCode.INVALID_VALUE, originalMessage) || this;
+        }
+        return InvalidValueTypeError;
+    }(FormatError));
+    var MissingValueError = /** @class */ (function (_super) {
+        __extends(MissingValueError, _super);
+        function MissingValueError(variableId, originalMessage) {
+            return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", ErrorCode.MISSING_VALUE, originalMessage) || this;
+        }
+        return MissingValueError;
+    }(FormatError));
+
+    var PART_TYPE;
+    (function (PART_TYPE) {
+        PART_TYPE[PART_TYPE["literal"] = 0] = "literal";
+        PART_TYPE[PART_TYPE["object"] = 1] = "object";
+    })(PART_TYPE || (PART_TYPE = {}));
+    function mergeLiteral(parts) {
+        if (parts.length < 2) {
+            return parts;
+        }
+        return parts.reduce(function (all, part) {
+            var lastPart = all[all.length - 1];
+            if (!lastPart ||
+                lastPart.type !== PART_TYPE.literal ||
+                part.type !== PART_TYPE.literal) {
+                all.push(part);
+            }
+            else {
+                lastPart.value += part.value;
+            }
+            return all;
+        }, []);
+    }
+    function isFormatXMLElementFn(el) {
+        return typeof el === 'function';
+    }
+    // TODO(skeleton): add skeleton support
+    function formatToParts(els, locales, formatters, formats, values, currentPluralValue, 
+    // For debugging
+    originalMessage) {
+        // Hot path for straight simple msg translations
+        if (els.length === 1 && isLiteralElement(els[0])) {
+            return [
+                {
+                    type: PART_TYPE.literal,
+                    value: els[0].value,
+                },
+            ];
+        }
+        var result = [];
+        for (var _i = 0, els_1 = els; _i < els_1.length; _i++) {
+            var el = els_1[_i];
+            // Exit early for string parts.
+            if (isLiteralElement(el)) {
+                result.push({
+                    type: PART_TYPE.literal,
+                    value: el.value,
+                });
+                continue;
+            }
+            // TODO: should this part be literal type?
+            // Replace `#` in plural rules with the actual numeric value.
+            if (isPoundElement(el)) {
+                if (typeof currentPluralValue === 'number') {
+                    result.push({
+                        type: PART_TYPE.literal,
+                        value: formatters.getNumberFormat(locales).format(currentPluralValue),
+                    });
+                }
+                continue;
+            }
+            var varName = el.value;
+            // Enforce that all required values are provided by the caller.
+            if (!(values && varName in values)) {
+                throw new MissingValueError(varName, originalMessage);
+            }
+            var value = values[varName];
+            if (isArgumentElement(el)) {
+                if (!value || typeof value === 'string' || typeof value === 'number') {
+                    value =
+                        typeof value === 'string' || typeof value === 'number'
+                            ? String(value)
+                            : '';
+                }
+                result.push({
+                    type: typeof value === 'string' ? PART_TYPE.literal : PART_TYPE.object,
+                    value: value,
+                });
+                continue;
+            }
+            // Recursively format plural and select parts' option — which can be a
+            // nested pattern structure. The choosing of the option to use is
+            // abstracted-by and delegated-to the part helper object.
+            if (isDateElement(el)) {
+                var style = typeof el.style === 'string'
+                    ? formats.date[el.style]
+                    : isDateTimeSkeleton(el.style)
+                        ? el.style.parsedOptions
+                        : undefined;
+                result.push({
+                    type: PART_TYPE.literal,
+                    value: formatters
+                        .getDateTimeFormat(locales, style)
+                        .format(value),
+                });
+                continue;
+            }
+            if (isTimeElement(el)) {
+                var style = typeof el.style === 'string'
+                    ? formats.time[el.style]
+                    : isDateTimeSkeleton(el.style)
+                        ? el.style.parsedOptions
+                        : undefined;
+                result.push({
+                    type: PART_TYPE.literal,
+                    value: formatters
+                        .getDateTimeFormat(locales, style)
+                        .format(value),
+                });
+                continue;
+            }
+            if (isNumberElement(el)) {
+                var style = typeof el.style === 'string'
+                    ? formats.number[el.style]
+                    : isNumberSkeleton(el.style)
+                        ? el.style.parsedOptions
+                        : undefined;
+                if (style && style.scale) {
+                    value =
+                        value *
+                            (style.scale || 1);
+                }
+                result.push({
+                    type: PART_TYPE.literal,
+                    value: formatters
+                        .getNumberFormat(locales, style)
+                        .format(value),
+                });
+                continue;
+            }
+            if (isTagElement(el)) {
+                var children = el.children, value_1 = el.value;
+                var formatFn = values[value_1];
+                if (!isFormatXMLElementFn(formatFn)) {
+                    throw new InvalidValueTypeError(value_1, 'function', originalMessage);
+                }
+                var parts = formatToParts(children, locales, formatters, formats, values, currentPluralValue);
+                var chunks = formatFn(parts.map(function (p) { return p.value; }));
+                if (!Array.isArray(chunks)) {
+                    chunks = [chunks];
+                }
+                result.push.apply(result, chunks.map(function (c) {
+                    return {
+                        type: typeof c === 'string' ? PART_TYPE.literal : PART_TYPE.object,
+                        value: c,
+                    };
+                }));
+            }
+            if (isSelectElement(el)) {
+                var opt = el.options[value] || el.options.other;
+                if (!opt) {
+                    throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+                }
+                result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));
+                continue;
+            }
+            if (isPluralElement(el)) {
+                var opt = el.options["=" + value];
+                if (!opt) {
+                    if (!Intl.PluralRules) {
+                        throw new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", ErrorCode.MISSING_INTL_API, originalMessage);
+                    }
+                    var rule = formatters
+                        .getPluralRules(locales, { type: el.pluralType })
+                        .select(value - (el.offset || 0));
+                    opt = el.options[rule] || el.options.other;
+                }
+                if (!opt) {
+                    throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+                }
+                result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));
+                continue;
+            }
+        }
+        return mergeLiteral(result);
+    }
+
+    /*
+    Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+    Copyrights licensed under the New BSD License.
+    See the accompanying LICENSE file for terms.
+    */
+    // -- MessageFormat --------------------------------------------------------
+    function mergeConfig(c1, c2) {
+        if (!c2) {
+            return c1;
+        }
+        return __assign(__assign(__assign({}, (c1 || {})), (c2 || {})), Object.keys(c1).reduce(function (all, k) {
+            all[k] = __assign(__assign({}, c1[k]), (c2[k] || {}));
+            return all;
+        }, {}));
+    }
+    function mergeConfigs(defaultConfig, configs) {
+        if (!configs) {
+            return defaultConfig;
+        }
+        return Object.keys(defaultConfig).reduce(function (all, k) {
+            all[k] = mergeConfig(defaultConfig[k], configs[k]);
+            return all;
+        }, __assign({}, defaultConfig));
+    }
+    function createFastMemoizeCache(store) {
+        return {
+            create: function () {
+                return {
+                    has: function (key) {
+                        return key in store;
+                    },
+                    get: function (key) {
+                        return store[key];
+                    },
+                    set: function (key, value) {
+                        store[key] = value;
+                    },
+                };
+            },
+        };
+    }
+    function createDefaultFormatters(cache) {
+        if (cache === void 0) { cache = {
+            number: {},
+            dateTime: {},
+            pluralRules: {},
+        }; }
+        return {
+            getNumberFormat: memoize(function () {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return new ((_a = Intl.NumberFormat).bind.apply(_a, __spreadArray([void 0], args)))();
+            }, {
+                cache: createFastMemoizeCache(cache.number),
+                strategy: strategies.variadic,
+            }),
+            getDateTimeFormat: memoize(function () {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return new ((_a = Intl.DateTimeFormat).bind.apply(_a, __spreadArray([void 0], args)))();
+            }, {
+                cache: createFastMemoizeCache(cache.dateTime),
+                strategy: strategies.variadic,
+            }),
+            getPluralRules: memoize(function () {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return new ((_a = Intl.PluralRules).bind.apply(_a, __spreadArray([void 0], args)))();
+            }, {
+                cache: createFastMemoizeCache(cache.pluralRules),
+                strategy: strategies.variadic,
+            }),
+        };
+    }
+    var IntlMessageFormat = /** @class */ (function () {
+        function IntlMessageFormat(message, locales, overrideFormats, opts) {
+            var _this = this;
+            if (locales === void 0) { locales = IntlMessageFormat.defaultLocale; }
+            this.formatterCache = {
+                number: {},
+                dateTime: {},
+                pluralRules: {},
+            };
+            this.format = function (values) {
+                var parts = _this.formatToParts(values);
+                // Hot path for straight simple msg translations
+                if (parts.length === 1) {
+                    return parts[0].value;
+                }
+                var result = parts.reduce(function (all, part) {
+                    if (!all.length ||
+                        part.type !== PART_TYPE.literal ||
+                        typeof all[all.length - 1] !== 'string') {
+                        all.push(part.value);
+                    }
+                    else {
+                        all[all.length - 1] += part.value;
+                    }
+                    return all;
+                }, []);
+                if (result.length <= 1) {
+                    return result[0] || '';
+                }
+                return result;
+            };
+            this.formatToParts = function (values) {
+                return formatToParts(_this.ast, _this.locales, _this.formatters, _this.formats, values, undefined, _this.message);
+            };
+            this.resolvedOptions = function () { return ({
+                locale: Intl.NumberFormat.supportedLocalesOf(_this.locales)[0],
+            }); };
+            this.getAst = function () { return _this.ast; };
+            if (typeof message === 'string') {
+                this.message = message;
+                if (!IntlMessageFormat.__parse) {
+                    throw new TypeError('IntlMessageFormat.__parse must be set to process `message` of type `string`');
+                }
+                // Parse string messages into an AST.
+                this.ast = IntlMessageFormat.__parse(message, {
+                    ignoreTag: opts === null || opts === void 0 ? void 0 : opts.ignoreTag,
+                });
+            }
+            else {
+                this.ast = message;
+            }
+            if (!Array.isArray(this.ast)) {
+                throw new TypeError('A message must be provided as a String or AST.');
+            }
+            // Creates a new object with the specified `formats` merged with the default
+            // formats.
+            this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);
+            // Defined first because it's used to build the format pattern.
+            this.locales = locales;
+            this.formatters =
+                (opts && opts.formatters) || createDefaultFormatters(this.formatterCache);
+        }
+        Object.defineProperty(IntlMessageFormat, "defaultLocale", {
+            get: function () {
+                if (!IntlMessageFormat.memoizedDefaultLocale) {
+                    IntlMessageFormat.memoizedDefaultLocale =
+                        new Intl.NumberFormat().resolvedOptions().locale;
+                }
+                return IntlMessageFormat.memoizedDefaultLocale;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        IntlMessageFormat.memoizedDefaultLocale = null;
+        IntlMessageFormat.__parse = parse;
+        // Default format options used as the prototype of the `formats` provided to the
+        // constructor. These are used when constructing the internal Intl.NumberFormat
+        // and Intl.DateTimeFormat instances.
+        IntlMessageFormat.formats = {
+            number: {
+                integer: {
+                    maximumFractionDigits: 0,
+                },
+                currency: {
+                    style: 'currency',
+                },
+                percent: {
+                    style: 'percent',
+                },
+            },
+            date: {
+                short: {
+                    month: 'numeric',
+                    day: 'numeric',
+                    year: '2-digit',
+                },
+                medium: {
+                    month: 'short',
+                    day: 'numeric',
+                    year: 'numeric',
+                },
+                long: {
+                    month: 'long',
+                    day: 'numeric',
+                    year: 'numeric',
+                },
+                full: {
+                    weekday: 'long',
+                    month: 'long',
+                    day: 'numeric',
+                    year: 'numeric',
+                },
+            },
+            time: {
+                short: {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                },
+                medium: {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                },
+                long: {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                    timeZoneName: 'short',
+                },
+                full: {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                    timeZoneName: 'short',
+                },
+            },
+        };
+        return IntlMessageFormat;
+    }());
+
+    const r={},i=(e,n,t)=>t?(n in r||(r[n]={}),e in r[n]||(r[n][e]=t),t):t,a=(e,n)=>{if(null==n)return;if(n in r&&e in r[n])return r[n][e];const t=E(n);for(let o=0;o<t.length;o++){const r=c(t[o],e);if(r)return i(e,n,r)}};let l;const s=writable({});function u(e){return e in l}function c(e,n){if(!u(e))return null;return function(e,n){if(n in e)return e[n];const t=n.split(".");let o=e;for(let e=0;e<t.length;e++)if("object"==typeof o){if(e>0){const n=t.slice(e,t.length).join(".");if(n in o){o=o[n];break}}o=o[t[e]];}else o=void 0;return o}(function(e){return l[e]||null}(e),n)}function m(e,...n){delete r[e],s.update((o=>(o[e]=cjs.all([o[e]||{},...n]),o)));}derived([s],(([e])=>Object.keys(e)));s.subscribe((e=>l=e));const d={};function g(e){return d[e]}function w(e){return E(e).some((e=>{var n;return null===(n=g(e))||void 0===n?void 0:n.size}))}function h(e,n){return Promise.all(n.map((n=>(function(e,n){d[e].delete(n),0===d[e].size&&delete d[e];}(e,n),n().then((e=>e.default||e)))))).then((n=>m(e,...n)))}const p={};function b(e){if(!w(e))return e in p?p[e]:void 0;const n=function(e){return E(e).map((e=>{const n=g(e);return [e,n?[...n]:[]]})).filter((([,e])=>e.length>0))}(e);return p[e]=Promise.all(n.map((([e,n])=>h(e,n)))).then((()=>{if(w(e))return b(e);delete p[e];})),p[e]}/*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */function v(e,n){var t={};for(var o in e)Object.prototype.hasOwnProperty.call(e,o)&&n.indexOf(o)<0&&(t[o]=e[o]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var r=0;for(o=Object.getOwnPropertySymbols(e);r<o.length;r++)n.indexOf(o[r])<0&&Object.prototype.propertyIsEnumerable.call(e,o[r])&&(t[o[r]]=e[o[r]]);}return t}const O={fallbackLocale:null,initialLocale:null,loadingDelay:200,formats:{number:{scientific:{notation:"scientific"},engineering:{notation:"engineering"},compactLong:{notation:"compact",compactDisplay:"long"},compactShort:{notation:"compact",compactDisplay:"short"}},date:{short:{month:"numeric",day:"numeric",year:"2-digit"},medium:{month:"short",day:"numeric",year:"numeric"},long:{month:"long",day:"numeric",year:"numeric"},full:{weekday:"long",month:"long",day:"numeric",year:"numeric"}},time:{short:{hour:"numeric",minute:"numeric"},medium:{hour:"numeric",minute:"numeric",second:"numeric"},long:{hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"},full:{hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"}}},warnOnMissingMessages:!0,ignoreTag:!0};function j(){return O}const k=writable(!1);let L;const T=writable(null);function x(e){return e.split("-").map(((e,n,t)=>t.slice(0,n+1).join("-"))).reverse()}function E(e,n=j().fallbackLocale){const t=x(e);return n?[...new Set([...t,...x(n)])]:t}function D(){return L}T.subscribe((e=>{L=e,"undefined"!=typeof window&&null!==e&&document.documentElement.setAttribute("lang",e);}));const M=T.set;T.set=e=>{if(function(e){if(null==e)return;const n=E(e);for(let e=0;e<n.length;e++){const t=n[e];if(u(t))return t}}(e)&&w(e)){const{loadingDelay:n}=j();let t;return "undefined"!=typeof window&&null!=D()&&n?t=window.setTimeout((()=>k.set(!0)),n):k.set(!0),b(e).then((()=>{M(e);})).finally((()=>{clearTimeout(t),k.set(!1);}))}return M(e)},T.update=e=>M(e(L));const Z=e=>{const n=Object.create(null);return t=>{const o=JSON.stringify(t);return o in n?n[o]:n[o]=e(t)}},C=(e,n)=>{const{formats:t}=j();if(e in t&&n in t[e])return t[e][n];throw new Error(`[svelte-i18n] Unknown "${n}" ${e} format.`)},G=Z((e=>{var{locale:n,format:t}=e,o=v(e,["locale","format"]);if(null==n)throw new Error('[svelte-i18n] A "locale" must be set to format numbers');return t&&(o=C("number",t)),new Intl.NumberFormat(n,o)})),J=Z((e=>{var{locale:n,format:t}=e,o=v(e,["locale","format"]);if(null==n)throw new Error('[svelte-i18n] A "locale" must be set to format dates');return t?o=C("date",t):0===Object.keys(o).length&&(o=C("date","short")),new Intl.DateTimeFormat(n,o)})),U=Z((e=>{var{locale:n,format:t}=e,o=v(e,["locale","format"]);if(null==n)throw new Error('[svelte-i18n] A "locale" must be set to format time values');return t?o=C("time",t):0===Object.keys(o).length&&(o=C("time","short")),new Intl.DateTimeFormat(n,o)})),_=(e={})=>{var{locale:n=D()}=e,t=v(e,["locale"]);return G(Object.assign({locale:n},t))},q=(e={})=>{var{locale:n=D()}=e,t=v(e,["locale"]);return J(Object.assign({locale:n},t))},B=(e={})=>{var{locale:n=D()}=e,t=v(e,["locale"]);return U(Object.assign({locale:n},t))},H=Z(((e,n=D())=>new IntlMessageFormat(e,n,j().formats,{ignoreTag:j().ignoreTag}))),K=(e,n={})=>{"object"==typeof e&&(e=(n=e).id);const{values:t,locale:o=D(),default:r}=n;if(null==o)throw new Error("[svelte-i18n] Cannot format a message without first setting the initial locale.");let i=a(e,o);if(i){if("string"!=typeof i)return console.warn(`[svelte-i18n] Message with id "${e}" must be of type "string", found: "${typeof i}". Gettin its value through the "$format" method is deprecated; use the "json" method instead.`),i}else j().warnOnMissingMessages&&console.warn(`[svelte-i18n] The message "${e}" was not found in "${E(o).join('", "')}".${w(D())?"\n\nNote: there are at least one loader still registered to this locale that wasn't executed.":""}`),i=r||e;if(!t)return i;let l=i;try{l=H(i,o).format(t);}catch(n){console.warn(`[svelte-i18n] Message "${e}" has syntax error:`,n.message);}return l},Q=(e,n)=>B(n).format(e),R=(e,n)=>q(n).format(e),V=(e,n)=>_(n).format(e),W=(e,n=D())=>a(e,n);derived([T,s],(()=>K));derived([T],(()=>Q));derived([T],(()=>R));derived([T],(()=>V));derived([T,s],(()=>W));
+
+    window.emWidgets = { topic };
+
+    /**
+     * @name getDevice
+     * @description A method that returns the type of the device
+     * @param {String} userAgent window.navigator.userAgent
+     * @returns {String} Android/iPhone/iPad/PC
+     */
+    const getDevice = (userAgent) => {
+      if (userAgent.toLowerCase().match(/android/i)) {
+        return 'Android';
+      }
+
+      if (userAgent.toLowerCase().match(/iphone/i)) {
+        return 'iPhone';
+      }
+
+      if (userAgent.toLowerCase().match(/ipad|ipod/i)) {
+        return 'iPad';
+      }
+
+      return 'PC';
+    };
+
+    /* src/PlayerTransactionHistory.svelte generated by Svelte v3.37.0 */
+
+    const { console: console_1 } = globals;
+    const file = "src/PlayerTransactionHistory.svelte";
+
+    // (36:2) {#if isMobile}
+    function create_if_block_1(ctx) {
+    	let div;
+    	let svg;
+    	let defs;
+    	let style;
+    	let t0;
+    	let g1;
+    	let g0;
+    	let path;
+    	let t1;
+    	let h2;
+    	let mounted;
+    	let dispose;
+
+    	const block = {
+    		c: function create() {
+    			div = element("div");
+    			svg = svg_element("svg");
+    			defs = svg_element("defs");
+    			style = svg_element("style");
+    			t0 = text(".aaa{fill:#d0046c;}");
+    			g1 = svg_element("g");
+    			g0 = svg_element("g");
+    			path = svg_element("path");
+    			t1 = space();
+    			h2 = element("h2");
+    			h2.textContent = "Transaction History";
+    			add_location(style, file, 37, 95, 1317);
+    			add_location(defs, file, 37, 89, 1311);
+    			attr_dev(path, "class", "aaa");
+    			attr_dev(path, "d", "M7.5,0,6.136,1.364,11.3,6.526H0V8.474H11.3L6.136,13.636,7.5,15,15,7.5Z");
+    			attr_dev(path, "transform", "translate(15 15) rotate(180)");
+    			add_location(path, file, 39, 10, 1446);
+    			attr_dev(g0, "transform", "translate(20 158)");
+    			add_location(g0, file, 38, 8, 1402);
+    			attr_dev(g1, "transform", "translate(-20 -158)");
+    			add_location(g1, file, 37, 136, 1358);
+    			attr_dev(svg, "xmlns", "http://www.w3.org/2000/svg");
+    			attr_dev(svg, "width", "15");
+    			attr_dev(svg, "height", "15");
+    			attr_dev(svg, "viewBox", "0 0 15 15");
+    			add_location(svg, file, 37, 6, 1228);
+    			attr_dev(h2, "class", "TransactionHistoryTitleMobile");
+    			add_location(h2, file, 42, 6, 1618);
+    			attr_dev(div, "class", "MenuReturnButton");
+    			add_location(div, file, 36, 4, 1159);
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, div, anchor);
+    			append_dev(div, svg);
+    			append_dev(svg, defs);
+    			append_dev(defs, style);
+    			append_dev(style, t0);
+    			append_dev(svg, g1);
+    			append_dev(g1, g0);
+    			append_dev(g0, path);
+    			append_dev(div, t1);
+    			append_dev(div, h2);
+
+    			if (!mounted) {
+    				dispose = listen_dev(div, "click", /*click_handler*/ ctx[7], false, false, false);
+    				mounted = true;
+    			}
+    		},
+    		p: noop$1,
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(div);
+    			mounted = false;
+    			dispose();
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_if_block_1.name,
+    		type: "if",
+    		source: "(36:2) {#if isMobile}",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    // (49:2) {:else}
+    function create_else_block(ctx) {
+    	let div;
+    	let iframe;
+    	let iframe_src_value;
+
+    	const block = {
+    		c: function create() {
+    			div = element("div");
+    			iframe = element("iframe");
+    			if (iframe.src !== (iframe_src_value = /*iframeUrl*/ ctx[1])) attr_dev(iframe, "src", iframe_src_value);
+    			attr_dev(iframe, "title", "Transaction History Iframe");
+    			add_location(iframe, file, 50, 6, 1935);
+    			attr_dev(div, "class", "TransactionHistoryIframeWrapper");
+    			add_location(div, file, 49, 4, 1883);
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, div, anchor);
+    			append_dev(div, iframe);
+    		},
+    		p: function update(ctx, dirty) {
+    			if (dirty & /*iframeUrl*/ 2 && iframe.src !== (iframe_src_value = /*iframeUrl*/ ctx[1])) {
+    				attr_dev(iframe, "src", iframe_src_value);
+    			}
+    		},
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(div);
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_else_block.name,
+    		type: "else",
+    		source: "(49:2) {:else}",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    // (47:2) {#if isLoading}
+    function create_if_block(ctx) {
+    	let p;
+
+    	const block = {
+    		c: function create() {
+    			p = element("p");
+    			p.textContent = "Loading, please wait ...";
+    			add_location(p, file, 47, 4, 1837);
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, p, anchor);
+    		},
+    		p: noop$1,
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(p);
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_if_block.name,
+    		type: "if",
+    		source: "(47:2) {#if isLoading}",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    function create_fragment(ctx) {
+    	let div;
+    	let t0;
+    	let h2;
+    	let t1;
+    	let t2;
+    	let if_block0 = /*isMobile*/ ctx[2] && create_if_block_1(ctx);
+
+    	function select_block_type(ctx, dirty) {
+    		if (/*isLoading*/ ctx[0]) return create_if_block;
+    		return create_else_block;
+    	}
+
+    	let current_block_type = select_block_type(ctx);
+    	let if_block1 = current_block_type(ctx);
+
+    	const block = {
+    		c: function create() {
+    			div = element("div");
+    			if (if_block0) if_block0.c();
+    			t0 = space();
+    			h2 = element("h2");
+    			t1 = text("Transaction History");
+    			t2 = space();
+    			if_block1.c();
+    			this.c = noop$1;
+    			attr_dev(h2, "class", "TransactionHistoryTitle " + (/*isMobile*/ ctx[2] ? "TransactionHistoryTitleNone" : ""));
+    			add_location(h2, file, 45, 2, 1706);
+
+    			attr_dev(div, "class", "TransactionHistoryWrapper " + (/*isMobile*/ ctx[2]
+    			? "TransactionHistoryWrapperMobile"
+    			: ""));
+
+    			add_location(div, file, 34, 0, 1046);
+    		},
+    		l: function claim(nodes) {
+    			throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, div, anchor);
+    			if (if_block0) if_block0.m(div, null);
+    			append_dev(div, t0);
+    			append_dev(div, h2);
+    			append_dev(h2, t1);
+    			append_dev(div, t2);
+    			if_block1.m(div, null);
+    		},
+    		p: function update(ctx, [dirty]) {
+    			if (/*isMobile*/ ctx[2]) if_block0.p(ctx, dirty);
+
+    			if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block1) {
+    				if_block1.p(ctx, dirty);
+    			} else {
+    				if_block1.d(1);
+    				if_block1 = current_block_type(ctx);
+
+    				if (if_block1) {
+    					if_block1.c();
+    					if_block1.m(div, null);
+    				}
+    			}
+    		},
+    		i: noop$1,
+    		o: noop$1,
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(div);
+    			if (if_block0) if_block0.d();
+    			if_block1.d();
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_fragment.name,
+    		type: "component",
+    		source: "",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    function instance($$self, $$props, $$invalidate) {
+    	let { $$slots: slots = {}, $$scope } = $$props;
+    	validate_slots("undefined", slots, []);
+    	let { endpoint = "" } = $$props;
+    	let { session = "" } = $$props;
+    	let { playerid = "" } = $$props;
+    	let userAgent = window.navigator.userAgent;
+    	let isMobile = getDevice(userAgent) === "PC" ? false : true;
+    	let isLoading = true;
+    	let iframeUrl = "";
+
+    	const toggleScreen = () => {
+    		window.postMessage({ type: "ReturnToMenu" }, window.location.href);
+    	};
+
+    	const getTransactionHistoryIframe = () => {
+    		let url = new URL(`${endpoint}/player/${playerid}/hostedcashier/customertransactionhistoryurl`);
+
+    		let options = {
+    			method: "GET",
+    			headers: {
+    				"playerId": playerid,
+    				"X-SessionId": session,
+    				"accept": "application/json"
+    			}
+    		};
+
+    		fetch(url, options).then(res => res.json()).then(
+    			data => {
+    				$$invalidate(0, isLoading = false);
+    				$$invalidate(1, iframeUrl = data.CashierUrl);
+    			},
+    			err => {
+    				console.error(err);
+    			}
+    		);
+    	};
+
+    	const writable_props = ["endpoint", "session", "playerid"];
+
+    	Object.keys($$props).forEach(key => {
+    		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console_1.warn(`<undefined> was created with unknown prop '${key}'`);
+    	});
+
+    	const click_handler = () => toggleScreen();
+
+    	$$self.$$set = $$props => {
+    		if ("endpoint" in $$props) $$invalidate(4, endpoint = $$props.endpoint);
+    		if ("session" in $$props) $$invalidate(5, session = $$props.session);
+    		if ("playerid" in $$props) $$invalidate(6, playerid = $$props.playerid);
+    	};
+
+    	$$self.$capture_state = () => ({
+    		getDevice,
+    		endpoint,
+    		session,
+    		playerid,
+    		userAgent,
+    		isMobile,
+    		isLoading,
+    		iframeUrl,
+    		toggleScreen,
+    		getTransactionHistoryIframe
+    	});
+
+    	$$self.$inject_state = $$props => {
+    		if ("endpoint" in $$props) $$invalidate(4, endpoint = $$props.endpoint);
+    		if ("session" in $$props) $$invalidate(5, session = $$props.session);
+    		if ("playerid" in $$props) $$invalidate(6, playerid = $$props.playerid);
+    		if ("userAgent" in $$props) userAgent = $$props.userAgent;
+    		if ("isMobile" in $$props) $$invalidate(2, isMobile = $$props.isMobile);
+    		if ("isLoading" in $$props) $$invalidate(0, isLoading = $$props.isLoading);
+    		if ("iframeUrl" in $$props) $$invalidate(1, iframeUrl = $$props.iframeUrl);
+    	};
+
+    	if ($$props && "$$inject" in $$props) {
+    		$$self.$inject_state($$props.$$inject);
+    	}
+
+    	$$self.$$.update = () => {
+    		if ($$self.$$.dirty & /*session, playerid, endpoint*/ 112) {
+    			session && playerid && endpoint && getTransactionHistoryIframe();
+    		}
+    	};
+
+    	return [
+    		isLoading,
+    		iframeUrl,
+    		isMobile,
+    		toggleScreen,
+    		endpoint,
+    		session,
+    		playerid,
+    		click_handler
+    	];
+    }
+
+    class PlayerTransactionHistory extends SvelteElement {
+    	constructor(options) {
+    		super();
+    		this.shadowRoot.innerHTML = `<style>.TransactionHistoryWrapper{color:#07072A;padding:50px 50px 30px 50px;max-width:100%}.TransactionHistoryWrapper.TransactionHistoryWrapperMobile{padding:20px 15px;max-width:unset}.MenuReturnButton{color:#D0046C;display:inline-flex;align-items:center;column-gap:10px;margin-bottom:30px}.MenuReturnButton svg{fill:#D0046C}.TransactionHistoryTitle{font-size:26px;color:#D0046C;font-weight:400}.TransactionHistoryTitleMobile{font-size:16px}.TransactionHistoryTitleNone{display:none}.TransactionHistoryIframeWrapper iframe{border:none;width:100%;height:85vh}</style>`;
+
+    		init(
+    			this,
+    			{
+    				target: this.shadowRoot,
+    				props: attribute_to_object(this.attributes),
+    				customElement: true
+    			},
+    			instance,
+    			create_fragment,
+    			safe_not_equal,
+    			{ endpoint: 4, session: 5, playerid: 6 }
+    		);
+
+    		if (options) {
+    			if (options.target) {
+    				insert_dev(options.target, this, options.anchor);
+    			}
+
+    			if (options.props) {
+    				this.$set(options.props);
+    				flush();
+    			}
+    		}
+    	}
+
+    	static get observedAttributes() {
+    		return ["endpoint", "session", "playerid"];
+    	}
+
+    	get endpoint() {
+    		return this.$$.ctx[4];
+    	}
+
+    	set endpoint(endpoint) {
+    		this.$set({ endpoint });
+    		flush();
+    	}
+
+    	get session() {
+    		return this.$$.ctx[5];
+    	}
+
+    	set session(session) {
+    		this.$set({ session });
+    		flush();
+    	}
+
+    	get playerid() {
+    		return this.$$.ctx[6];
+    	}
+
+    	set playerid(playerid) {
+    		this.$set({ playerid });
+    		flush();
+    	}
+    }
+
+    !customElements.get('player-transaction-history') && customElements.define('player-transaction-history', PlayerTransactionHistory);
+
+    return PlayerTransactionHistory;
+
+})));
+//# sourceMappingURL=player-transaction-history.js.map