@mantou/gem 1.6.8 → 1.6.9

package/dist/gem.es.js

@@ -0,0 +1,3272 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _map, _firstItem, _lastItem, _delete, delete_fn, _stringify, _parse, _nextSibling, _parentElement, _inertStore, _a, _cacheCurrentKey, cacheCurrentKey_get, _urlParamsLang, urlParamsLang_get, _cacheLang, cacheLang_get, _isMain, isMain_get, _lang, lang_set;
+var Gem = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  [Symbol.toStringTag]: "Module",
+  get StoreListenerMap() {
+    return StoreListenerMap;
+  },
+  get createStore() {
+    return createStore;
+  },
+  get createStoreSet() {
+    return createStoreSet;
+  },
+  get updateStore() {
+    return updateStore;
+  },
+  get connect() {
+    return connect;
+  },
+  get disconnect() {
+    return disconnect;
+  },
+  get history() {
+    return history;
+  },
+  get basePathStore() {
+    return basePathStore;
+  },
+  get titleStore() {
+    return titleStore;
+  },
+  get html() {
+    return html;
+  },
+  get svg() {
+    return svg;
+  },
+  get render() {
+    return render;
+  },
+  get directive() {
+    return directive;
+  },
+  get TemplateResult() {
+    return TemplateResult;
+  },
+  get SVGTemplateResult() {
+    return SVGTemplateResult;
+  },
+  get repeat() {
+    return repeat;
+  },
+  get guard() {
+    return guard;
+  },
+  get ifDefined() {
+    return ifDefined;
+  },
+  get GemElement() {
+    return GemElement;
+  },
+  get defineAttribute() {
+    return defineAttribute;
+  },
+  get defineProperty() {
+    return defineProperty;
+  },
+  get defineRef() {
+    return defineRef;
+  },
+  get defineCSSState() {
+    return defineCSSState;
+  },
+  get nativeDefineElement() {
+    return nativeDefineElement;
+  },
+  get refobject() {
+    return refobject;
+  },
+  get attribute() {
+    return attribute;
+  },
+  get boolattribute() {
+    return boolattribute;
+  },
+  get numattribute() {
+    return numattribute;
+  },
+  get property() {
+    return property;
+  },
+  get state() {
+    return state;
+  },
+  get slot() {
+    return slot;
+  },
+  get part() {
+    return part;
+  },
+  get emitter() {
+    return emitter;
+  },
+  get globalemitter() {
+    return globalemitter;
+  },
+  get adoptedStyle() {
+    return adoptedStyle;
+  },
+  get connectStore() {
+    return connectStore;
+  },
+  get rootElement() {
+    return rootElement;
+  },
+  get customElement() {
+    return customElement;
+  },
+  get addMicrotask() {
+    return addMicrotask;
+  },
+  get addMicrotaskToStack() {
+    return addMicrotaskToStack;
+  },
+  get absoluteLocation() {
+    return absoluteLocation;
+  },
+  get LinkedList() {
+    return LinkedList;
+  },
+  get PropProxyMap() {
+    return PropProxyMap;
+  },
+  get QueryString() {
+    return QueryString;
+  },
+  get raw() {
+    return raw;
+  },
+  get css() {
+    return css;
+  },
+  get SheetToken() {
+    return SheetToken;
+  },
+  get useNativeCSSStyleSheet() {
+    return useNativeCSSStyleSheet;
+  },
+  get createCSSSheet() {
+    return createCSSSheet;
+  },
+  get randomStr() {
+    return randomStr;
+  },
+  get styled() {
+    return styled;
+  },
+  get camelToKebabCase() {
+    return camelToKebabCase;
+  },
+  get kebabToCamelCase() {
+    return kebabToCamelCase;
+  },
+  get cleanObject() {
+    return cleanObject;
+  },
+  get GemError() {
+    return GemError;
+  },
+  get isArrayChange() {
+    return isArrayChange;
+  },
+  get removeItems() {
+    return removeItems;
+  },
+  get styleMap() {
+    return styleMap;
+  },
+  get classMap() {
+    return classMap;
+  },
+  get partMap() {
+    return partMap;
+  },
+  get version() {
+    return version;
+  }
+});
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const directives = new WeakMap();
+const directive = (f) => (...args) => {
+  const d = f(...args);
+  directives.set(d, true);
+  return d;
+};
+const isDirective = (o) => {
+  return typeof o === "function" && directives.has(o);
+};
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const isCEPolyfill = typeof window !== "undefined" && window.customElements != null && window.customElements.polyfillWrapFlushCallback !== void 0;
+const reparentNodes = (container, start, end = null, before = null) => {
+  while (start !== end) {
+    const n = start.nextSibling;
+    container.insertBefore(start, before);
+    start = n;
+  }
+};
+const removeNodes = (container, start, end = null) => {
+  while (start !== end) {
+    const n = start.nextSibling;
+    container.removeChild(start);
+    start = n;
+  }
+};
+/**
+ * @license
+ * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const noChange = {};
+const nothing = {};
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const marker = `{{lit-${String(Math.random()).slice(2)}}}`;
+const nodeMarker = `<!--${marker}-->`;
+const markerRegex = new RegExp(`${marker}|${nodeMarker}`);
+const boundAttributeSuffix = "$lit$";
+class Template {
+  constructor(result, element) {
+    this.parts = [];
+    this.element = element;
+    const nodesToRemove = [];
+    const stack = [];
+    const walker = document.createTreeWalker(element.content, 133, null, false);
+    let lastPartIndex = 0;
+    let index = -1;
+    let partIndex = 0;
+    const { strings, values: { length } } = result;
+    while (partIndex < length) {
+      const node = walker.nextNode();
+      if (node === null) {
+        walker.currentNode = stack.pop();
+        continue;
+      }
+      index++;
+      if (node.nodeType === 1) {
+        if (node.hasAttributes()) {
+          const attributes = node.attributes;
+          const { length: length2 } = attributes;
+          let count = 0;
+          for (let i = 0; i < length2; i++) {
+            if (endsWith(attributes[i].name, boundAttributeSuffix)) {
+              count++;
+            }
+          }
+          while (count-- > 0) {
+            const stringForPart = strings[partIndex];
+            const name = lastAttributeNameRegex.exec(stringForPart)[2];
+            const attributeLookupName = name.toLowerCase() + boundAttributeSuffix;
+            const attributeValue = node.getAttribute(attributeLookupName);
+            node.removeAttribute(attributeLookupName);
+            const statics = attributeValue.split(markerRegex);
+            this.parts.push({ type: "attribute", index, name, strings: statics });
+            partIndex += statics.length - 1;
+          }
+        }
+        if (node.tagName === "TEMPLATE") {
+          stack.push(node);
+          walker.currentNode = node.content;
+        }
+      } else if (node.nodeType === 3) {
+        const data = node.data;
+        if (data.indexOf(marker) >= 0) {
+          const parent = node.parentNode;
+          const strings2 = data.split(markerRegex);
+          const lastIndex = strings2.length - 1;
+          for (let i = 0; i < lastIndex; i++) {
+            let insert;
+            let s = strings2[i];
+            if (s === "") {
+              insert = createMarker();
+            } else {
+              const match = lastAttributeNameRegex.exec(s);
+              if (match !== null && endsWith(match[2], boundAttributeSuffix)) {
+                s = s.slice(0, match.index) + match[1] + match[2].slice(0, -boundAttributeSuffix.length) + match[3];
+              }
+              insert = document.createTextNode(s);
+            }
+            parent.insertBefore(insert, node);
+            this.parts.push({ type: "node", index: ++index });
+          }
+          if (strings2[lastIndex] === "") {
+            parent.insertBefore(createMarker(), node);
+            nodesToRemove.push(node);
+          } else {
+            node.data = strings2[lastIndex];
+          }
+          partIndex += lastIndex;
+        }
+      } else if (node.nodeType === 8) {
+        if (node.data === marker) {
+          const parent = node.parentNode;
+          if (node.previousSibling === null || index === lastPartIndex) {
+            index++;
+            parent.insertBefore(createMarker(), node);
+          }
+          lastPartIndex = index;
+          this.parts.push({ type: "node", index });
+          if (node.nextSibling === null) {
+            node.data = "";
+          } else {
+            nodesToRemove.push(node);
+            index--;
+          }
+          partIndex++;
+        } else {
+          let i = -1;
+          while ((i = node.data.indexOf(marker, i + 1)) !== -1) {
+            this.parts.push({ type: "node", index: -1 });
+            partIndex++;
+          }
+        }
+      }
+    }
+    for (const n of nodesToRemove) {
+      n.parentNode.removeChild(n);
+    }
+  }
+}
+const endsWith = (str, suffix) => {
+  const index = str.length - suffix.length;
+  return index >= 0 && str.slice(index) === suffix;
+};
+const isTemplatePartActive = (part2) => part2.index !== -1;
+const createMarker = () => document.createComment("");
+const lastAttributeNameRegex = /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+class TemplateInstance {
+  constructor(template, processor, options) {
+    this.__parts = [];
+    this.template = template;
+    this.processor = processor;
+    this.options = options;
+  }
+  update(values) {
+    let i = 0;
+    for (const part2 of this.__parts) {
+      if (part2 !== void 0) {
+        part2.setValue(values[i]);
+      }
+      i++;
+    }
+    for (const part2 of this.__parts) {
+      if (part2 !== void 0) {
+        part2.commit();
+      }
+    }
+  }
+  _clone() {
+    const fragment = isCEPolyfill ? this.template.element.content.cloneNode(true) : document.importNode(this.template.element.content, true);
+    const stack = [];
+    const parts2 = this.template.parts;
+    const walker = document.createTreeWalker(fragment, 133, null, false);
+    let partIndex = 0;
+    let nodeIndex = 0;
+    let part2;
+    let node = walker.nextNode();
+    while (partIndex < parts2.length) {
+      part2 = parts2[partIndex];
+      if (!isTemplatePartActive(part2)) {
+        this.__parts.push(void 0);
+        partIndex++;
+        continue;
+      }
+      while (nodeIndex < part2.index) {
+        nodeIndex++;
+        if (node.nodeName === "TEMPLATE") {
+          stack.push(node);
+          walker.currentNode = node.content;
+        }
+        if ((node = walker.nextNode()) === null) {
+          walker.currentNode = stack.pop();
+          node = walker.nextNode();
+        }
+      }
+      if (part2.type === "node") {
+        const part3 = this.processor.handleTextExpression(this.options);
+        part3.insertAfterNode(node.previousSibling);
+        this.__parts.push(part3);
+      } else {
+        this.__parts.push(...this.processor.handleAttributeExpressions(node, part2.name, part2.strings, this.options));
+      }
+      partIndex++;
+    }
+    if (isCEPolyfill) {
+      document.adoptNode(fragment);
+      customElements.upgrade(fragment);
+    }
+    return fragment;
+  }
+}
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const policy = window.trustedTypes && trustedTypes.createPolicy("lit-html", { createHTML: (s) => s });
+const commentMarker = ` ${marker} `;
+class TemplateResult {
+  constructor(strings, values, type, processor) {
+    this.strings = strings;
+    this.values = values;
+    this.type = type;
+    this.processor = processor;
+  }
+  getHTML() {
+    const l = this.strings.length - 1;
+    let html2 = "";
+    let isCommentBinding = false;
+    for (let i = 0; i < l; i++) {
+      const s = this.strings[i];
+      const commentOpen = s.lastIndexOf("<!--");
+      isCommentBinding = (commentOpen > -1 || isCommentBinding) && s.indexOf("-->", commentOpen + 1) === -1;
+      const attributeMatch = lastAttributeNameRegex.exec(s);
+      if (attributeMatch === null) {
+        html2 += s + (isCommentBinding ? commentMarker : nodeMarker);
+      } else {
+        html2 += s.substr(0, attributeMatch.index) + attributeMatch[1] + attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] + marker;
+      }
+    }
+    html2 += this.strings[l];
+    return html2;
+  }
+  getTemplateElement() {
+    const template = document.createElement("template");
+    let value = this.getHTML();
+    if (policy !== void 0) {
+      value = policy.createHTML(value);
+    }
+    template.innerHTML = value;
+    return template;
+  }
+}
+class SVGTemplateResult extends TemplateResult {
+  getHTML() {
+    return `<svg>${super.getHTML()}</svg>`;
+  }
+  getTemplateElement() {
+    const template = super.getTemplateElement();
+    const content = template.content;
+    const svgElement = content.firstChild;
+    content.removeChild(svgElement);
+    reparentNodes(content, svgElement.firstChild);
+    return template;
+  }
+}
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const isPrimitive = (value) => {
+  return value === null || !(typeof value === "object" || typeof value === "function");
+};
+const isIterable = (value) => {
+  return Array.isArray(value) || !!(value && value[Symbol.iterator]);
+};
+class AttributeCommitter {
+  constructor(element, name, strings) {
+    this.dirty = true;
+    this.element = element;
+    this.name = name;
+    this.strings = strings;
+    this.parts = [];
+    for (let i = 0; i < strings.length - 1; i++) {
+      this.parts[i] = this._createPart();
+    }
+  }
+  _createPart() {
+    return new AttributePart(this);
+  }
+  _getValue() {
+    const strings = this.strings;
+    const l = strings.length - 1;
+    const parts2 = this.parts;
+    if (l === 1 && strings[0] === "" && strings[1] === "") {
+      const v = parts2[0].value;
+      if (typeof v === "symbol") {
+        return String(v);
+      }
+      if (typeof v === "string" || !isIterable(v)) {
+        return v;
+      }
+    }
+    let text = "";
+    for (let i = 0; i < l; i++) {
+      text += strings[i];
+      const part2 = parts2[i];
+      if (part2 !== void 0) {
+        const v = part2.value;
+        if (isPrimitive(v) || !isIterable(v)) {
+          text += typeof v === "string" ? v : String(v);
+        } else {
+          for (const t of v) {
+            text += typeof t === "string" ? t : String(t);
+          }
+        }
+      }
+    }
+    text += strings[l];
+    return text;
+  }
+  commit() {
+    if (this.dirty) {
+      this.dirty = false;
+      this.element.setAttribute(this.name, this._getValue());
+    }
+  }
+}
+class AttributePart {
+  constructor(committer) {
+    this.value = void 0;
+    this.committer = committer;
+  }
+  setValue(value) {
+    if (value !== noChange && (!isPrimitive(value) || value !== this.value)) {
+      this.value = value;
+      if (!isDirective(value)) {
+        this.committer.dirty = true;
+      }
+    }
+  }
+  commit() {
+    while (isDirective(this.value)) {
+      const directive2 = this.value;
+      this.value = noChange;
+      directive2(this);
+    }
+    if (this.value === noChange) {
+      return;
+    }
+    this.committer.commit();
+  }
+}
+class NodePart {
+  constructor(options) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    this.options = options;
+  }
+  appendInto(container) {
+    this.startNode = container.appendChild(createMarker());
+    this.endNode = container.appendChild(createMarker());
+  }
+  insertAfterNode(ref) {
+    this.startNode = ref;
+    this.endNode = ref.nextSibling;
+  }
+  appendIntoPart(part2) {
+    part2.__insert(this.startNode = createMarker());
+    part2.__insert(this.endNode = createMarker());
+  }
+  insertAfterPart(ref) {
+    ref.__insert(this.startNode = createMarker());
+    this.endNode = ref.endNode;
+    ref.endNode = this.startNode;
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    if (this.startNode.parentNode === null) {
+      return;
+    }
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    const value = this.__pendingValue;
+    if (value === noChange) {
+      return;
+    }
+    if (isPrimitive(value)) {
+      if (value !== this.value) {
+        this.__commitText(value);
+      }
+    } else if (value instanceof TemplateResult) {
+      this.__commitTemplateResult(value);
+    } else if (value instanceof Node) {
+      this.__commitNode(value);
+    } else if (isIterable(value)) {
+      this.__commitIterable(value);
+    } else if (value === nothing) {
+      this.value = nothing;
+      this.clear();
+    } else {
+      this.__commitText(value);
+    }
+  }
+  __insert(node) {
+    this.endNode.parentNode.insertBefore(node, this.endNode);
+  }
+  __commitNode(value) {
+    if (this.value === value) {
+      return;
+    }
+    this.clear();
+    this.__insert(value);
+    this.value = value;
+  }
+  __commitText(value) {
+    const node = this.startNode.nextSibling;
+    value = value == null ? "" : value;
+    const valueAsString = typeof value === "string" ? value : String(value);
+    if (node === this.endNode.previousSibling && node.nodeType === 3) {
+      node.data = valueAsString;
+    } else {
+      this.__commitNode(document.createTextNode(valueAsString));
+    }
+    this.value = value;
+  }
+  __commitTemplateResult(value) {
+    const template = this.options.templateFactory(value);
+    if (this.value instanceof TemplateInstance && this.value.template === template) {
+      this.value.update(value.values);
+    } else {
+      const instance = new TemplateInstance(template, value.processor, this.options);
+      const fragment = instance._clone();
+      instance.update(value.values);
+      this.__commitNode(fragment);
+      this.value = instance;
+    }
+  }
+  __commitIterable(value) {
+    if (!Array.isArray(this.value)) {
+      this.value = [];
+      this.clear();
+    }
+    const itemParts = this.value;
+    let partIndex = 0;
+    let itemPart;
+    for (const item of value) {
+      itemPart = itemParts[partIndex];
+      if (itemPart === void 0) {
+        itemPart = new NodePart(this.options);
+        itemParts.push(itemPart);
+        if (partIndex === 0) {
+          itemPart.appendIntoPart(this);
+        } else {
+          itemPart.insertAfterPart(itemParts[partIndex - 1]);
+        }
+      }
+      itemPart.setValue(item);
+      itemPart.commit();
+      partIndex++;
+    }
+    if (partIndex < itemParts.length) {
+      itemParts.length = partIndex;
+      this.clear(itemPart && itemPart.endNode);
+    }
+  }
+  clear(startNode = this.startNode) {
+    removeNodes(this.startNode.parentNode, startNode.nextSibling, this.endNode);
+  }
+}
+class BooleanAttributePart {
+  constructor(element, name, strings) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    if (strings.length !== 2 || strings[0] !== "" || strings[1] !== "") {
+      throw new Error("Boolean attributes can only contain a single expression");
+    }
+    this.element = element;
+    this.name = name;
+    this.strings = strings;
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    if (this.__pendingValue === noChange) {
+      return;
+    }
+    const value = !!this.__pendingValue;
+    if (this.value !== value) {
+      if (value) {
+        this.element.setAttribute(this.name, "");
+      } else {
+        this.element.removeAttribute(this.name);
+      }
+      this.value = value;
+    }
+    this.__pendingValue = noChange;
+  }
+}
+class PropertyCommitter extends AttributeCommitter {
+  constructor(element, name, strings) {
+    super(element, name, strings);
+    this.single = strings.length === 2 && strings[0] === "" && strings[1] === "";
+  }
+  _createPart() {
+    return new PropertyPart(this);
+  }
+  _getValue() {
+    if (this.single) {
+      return this.parts[0].value;
+    }
+    return super._getValue();
+  }
+  commit() {
+    if (this.dirty) {
+      this.dirty = false;
+      this.element[this.name] = this._getValue();
+    }
+  }
+}
+class PropertyPart extends AttributePart {
+}
+let eventOptionsSupported = false;
+(() => {
+  try {
+    const options = {
+      get capture() {
+        eventOptionsSupported = true;
+        return false;
+      }
+    };
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (_e) {
+  }
+})();
+class EventPart {
+  constructor(element, eventName, eventContext) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    this.element = element;
+    this.eventName = eventName;
+    this.eventContext = eventContext;
+    this.__boundHandleEvent = (e) => this.handleEvent(e);
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    if (this.__pendingValue === noChange) {
+      return;
+    }
+    const newListener = this.__pendingValue;
+    const oldListener = this.value;
+    const shouldRemoveListener = newListener == null || oldListener != null && (newListener.capture !== oldListener.capture || newListener.once !== oldListener.once || newListener.passive !== oldListener.passive);
+    const shouldAddListener = newListener != null && (oldListener == null || shouldRemoveListener);
+    if (shouldRemoveListener) {
+      this.element.removeEventListener(this.eventName, this.__boundHandleEvent, this.__options);
+    }
+    if (shouldAddListener) {
+      this.__options = getOptions(newListener);
+      this.element.addEventListener(this.eventName, this.__boundHandleEvent, this.__options);
+    }
+    this.value = newListener;
+    this.__pendingValue = noChange;
+  }
+  handleEvent(event) {
+    if (typeof this.value === "function") {
+      this.value.call(this.eventContext || this.element, event);
+    } else {
+      this.value.handleEvent(event);
+    }
+  }
+}
+const getOptions = (o) => o && (eventOptionsSupported ? { capture: o.capture, passive: o.passive, once: o.once } : o.capture);
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+class DefaultTemplateProcessor {
+  handleAttributeExpressions(element, name, strings, options) {
+    const prefix = name[0];
+    if (prefix === ".") {
+      const committer2 = new PropertyCommitter(element, name.slice(1), strings);
+      return committer2.parts;
+    }
+    if (prefix === "@") {
+      return [new EventPart(element, name.slice(1), options.eventContext)];
+    }
+    if (prefix === "?") {
+      return [new BooleanAttributePart(element, name.slice(1), strings)];
+    }
+    const committer = new AttributeCommitter(element, name, strings);
+    return committer.parts;
+  }
+  handleTextExpression(options) {
+    return new NodePart(options);
+  }
+}
+const defaultTemplateProcessor = new DefaultTemplateProcessor();
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+function templateFactory(result) {
+  let templateCache = templateCaches.get(result.type);
+  if (templateCache === void 0) {
+    templateCache = {
+      stringsArray: new WeakMap(),
+      keyString: new Map()
+    };
+    templateCaches.set(result.type, templateCache);
+  }
+  let template = templateCache.stringsArray.get(result.strings);
+  if (template !== void 0) {
+    return template;
+  }
+  const key2 = result.strings.join(marker);
+  template = templateCache.keyString.get(key2);
+  if (template === void 0) {
+    template = new Template(result, result.getTemplateElement());
+    templateCache.keyString.set(key2, template);
+  }
+  templateCache.stringsArray.set(result.strings, template);
+  return template;
+}
+const templateCaches = new Map();
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const parts = new WeakMap();
+const render = (result, container, options) => {
+  let part2 = parts.get(container);
+  if (part2 === void 0) {
+    removeNodes(container, container.firstChild);
+    parts.set(container, part2 = new NodePart(Object.assign({ templateFactory }, options)));
+    part2.appendInto(container);
+  }
+  part2.setValue(result);
+  part2.commit();
+};
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+if (typeof window !== "undefined") {
+  (window["litHtmlVersions"] || (window["litHtmlVersions"] = [])).push("1.4.1");
+}
+const html = (strings, ...values) => new TemplateResult(strings, values, "html", defaultTemplateProcessor);
+const svg = (strings, ...values) => new SVGTemplateResult(strings, values, "svg", defaultTemplateProcessor);
+const microtaskSet = new Set();
+function addMicrotask(func) {
+  if (typeof func !== "function")
+    return;
+  if (!microtaskSet.size) {
+    globalThis.queueMicrotask(() => {
+      microtaskSet.forEach((func2) => func2());
+      microtaskSet.clear();
+    });
+  }
+  microtaskSet.delete(func);
+  microtaskSet.add(func);
+}
+const microtaskStack = [];
+function execMicrotaskStack() {
+  for (let i = microtaskStack.length - 1; i >= 0; i--) {
+    microtaskStack[i]();
+  }
+  microtaskStack.length = 0;
+}
+function addMicrotaskToStack(func) {
+  if (!microtaskStack.length) {
+    addMicrotask(execMicrotaskStack);
+  }
+  microtaskStack.push(func);
+}
+function absoluteLocation(currentPath = "", relativePath = "") {
+  const { pathname, search, hash } = new URL(relativePath, location.origin + currentPath);
+  return pathname + search + hash;
+}
+class LinkedList extends (globalThis.EventTarget || Object) {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _delete);
+    __privateAdd(this, _map, void 0);
+    __privateAdd(this, _firstItem, void 0);
+    __privateAdd(this, _lastItem, void 0);
+    __privateSet(this, _map, new Map());
+  }
+  get size() {
+    return __privateGet(this, _map).size;
+  }
+  add(value) {
+    if (!__privateGet(this, _lastItem)) {
+      this.dispatchEvent(new CustomEvent("start"));
+    }
+    const item = __privateMethod(this, _delete, delete_fn).call(this, value) || { value };
+    item.prev = __privateGet(this, _lastItem);
+    if (item.prev) {
+      item.prev.next = item;
+    }
+    item.next = void 0;
+    __privateSet(this, _lastItem, item);
+    if (!__privateGet(this, _firstItem)) {
+      __privateSet(this, _firstItem, item);
+    }
+    __privateGet(this, _map).set(value, item);
+  }
+  delete(value) {
+    const deleteItem = __privateMethod(this, _delete, delete_fn).call(this, value);
+    if (!__privateGet(this, _firstItem)) {
+      this.dispatchEvent(new CustomEvent("end"));
+    }
+    return deleteItem;
+  }
+  get() {
+    const firstItem = __privateGet(this, _firstItem);
+    if (!firstItem)
+      return;
+    __privateMethod(this, _delete, delete_fn).call(this, firstItem.value);
+    return firstItem.value;
+  }
+}
+_map = new WeakMap();
+_firstItem = new WeakMap();
+_lastItem = new WeakMap();
+_delete = new WeakSet();
+delete_fn = function(value) {
+  const existItem = __privateGet(this, _map).get(value);
+  if (existItem) {
+    if (existItem.prev) {
+      existItem.prev.next = existItem.next;
+    } else {
+      __privateSet(this, _firstItem, existItem.next);
+    }
+    if (existItem.next) {
+      existItem.next.prev = existItem.prev;
+    } else {
+      __privateSet(this, _lastItem, existItem.prev);
+    }
+    __privateGet(this, _map).delete(value);
+  }
+  return existItem;
+};
+class PropProxyMap extends WeakMap {
+  get(ele) {
+    let proxy = super.get(ele);
+    if (!proxy) {
+      proxy = {};
+      this.set(ele, proxy);
+    }
+    return proxy;
+  }
+}
+class QueryString extends URLSearchParams {
+  constructor(param) {
+    super(param);
+    __privateAdd(this, _stringify, (value) => typeof value === "string" ? value : JSON.stringify(value));
+    __privateAdd(this, _parse, (value) => {
+      if (!value)
+        return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return null;
+      }
+    });
+  }
+  concat(param) {
+    let query;
+    if (typeof param === "string") {
+      query = Object.fromEntries(new URLSearchParams(param).entries());
+    } else {
+      query = param;
+    }
+    Object.entries(query).forEach(([key2, value]) => {
+      this.append(key2, __privateGet(this, _stringify).call(this, value));
+    });
+  }
+  setAny(key2, value) {
+    if (Array.isArray(value)) {
+      this.delete(key2);
+      value.forEach((e) => this.append(key2, __privateGet(this, _stringify).call(this, e)));
+    } else {
+      const v = __privateGet(this, _stringify).call(this, value);
+      v ? this.set(key2, v) : this.delete(key2);
+    }
+  }
+  getAny(key2) {
+    return this.getAnyAll(key2)[0];
+  }
+  getAnyAll(key2) {
+    return this.getAll(key2).filter((e) => e !== "").map((e) => __privateGet(this, _parse).call(this, e));
+  }
+  toString() {
+    const string = super.toString();
+    return string ? `?${string}` : "";
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+_stringify = new WeakMap();
+_parse = new WeakMap();
+function raw(arr, ...args) {
+  return arr.reduce((prev, current, index) => {
+    var _a2;
+    return prev + ((_a2 = args[index - 1]) != null ? _a2 : "") + current;
+  });
+}
+function css(arr, ...args) {
+  return raw(arr, ...args);
+}
+const SheetToken = Symbol("sheet token");
+let useNativeCSSStyleSheet = true;
+let CSSStyleSheet = window.CSSStyleSheet;
+try {
+  new CSSStyleSheet();
+} catch {
+  useNativeCSSStyleSheet = false;
+  CSSStyleSheet = class {
+    constructor() {
+      this.media = { mediaText: "" };
+      this.style = "";
+      this.replaceSync = (style) => this.style = style;
+    }
+  };
+}
+function createCSSSheet(rules, mediaQuery2 = "") {
+  const styleSheet = new CSSStyleSheet();
+  const sheet = {};
+  styleSheet.media.mediaText = mediaQuery2;
+  let style = "";
+  if (typeof rules === "string") {
+    style = rules;
+  } else {
+    Object.keys(rules).forEach((key2) => {
+      sheet[key2] = `${key2}-${randomStr()}`;
+      style += rules[key2].styledContent.replace(/&/g, sheet[key2]);
+    });
+  }
+  styleSheet.replaceSync(style);
+  sheet[SheetToken] = styleSheet;
+  return sheet;
+}
+function randomStr(number = 5, origin = "0123456789abcdefghijklmnopqrstuvwxyz") {
+  const len = origin.length;
+  let str = "";
+  for (let i = 0; i < number; i++) {
+    str += origin[Math.floor(Math.random() * len)];
+  }
+  return str;
+}
+const nestingRuleRegExp = new RegExp("&.*{((.|\n)*)}", "g");
+function flatStyled(style, type) {
+  const nestingRules = [];
+  let styledContent = `& {${style.replace(nestingRuleRegExp, (substr) => {
+    nestingRules.push(substr);
+    return "";
+  })}}` + nestingRules.join("");
+  styledContent = styledContent.replace(/&/g, type === "class" ? ".&" : "#&");
+  return { styledContent, type };
+}
+const styled = {
+  class: (arr, ...args) => {
+    const style = raw(arr, ...args);
+    return flatStyled(style, "class");
+  },
+  id: (arr, ...args) => {
+    const style = raw(arr, ...args);
+    return flatStyled(style, "id");
+  },
+  keyframes: (arr, ...args) => {
+    const keyframesContent = raw(arr, ...args);
+    const styledContent = `@keyframes & {${keyframesContent}}`;
+    return { styledContent, type: "keyframes" };
+  }
+};
+function camelToKebabCase(str) {
+  return str.replace(/[A-Z]/g, ($1) => "-" + $1.toLowerCase());
+}
+function kebabToCamelCase(str) {
+  return str.replace(/-(.)/g, (_substr, $1) => $1.toUpperCase());
+}
+function cleanObject(o) {
+  Object.keys(o).forEach((key2) => {
+    const k = key2;
+    delete o[k];
+  });
+  return o;
+}
+class GemError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.message = `gem: ${this.message}`;
+  }
+}
+function isArrayChange(newValues, oldValues) {
+  const length = newValues.length;
+  if (oldValues.length !== length)
+    return true;
+  for (let i = 0; i < length; i++) {
+    if (newValues[i] !== oldValues[i])
+      return true;
+  }
+  return false;
+}
+function removeItems(target, items) {
+  const set = new Set(items);
+  return target.filter((e) => {
+    if (set.has(e)) {
+      set.delete(e);
+      return false;
+    }
+    return true;
+  });
+}
+function styleMap(object) {
+  let styleString = "";
+  for (const key2 in object) {
+    if (object[key2] !== void 0) {
+      styleString += `${camelToKebabCase(key2)}:${object[key2]};`;
+    }
+  }
+  return styleString;
+}
+function classMap(obj) {
+  let classList = " ";
+  for (const className in obj) {
+    if (obj[className]) {
+      classList += `${className} `;
+    }
+  }
+  return classList;
+}
+const partMap = classMap;
+const StoreListenerMap = new WeakMap();
+function createStore(originStore) {
+  if (StoreListenerMap.has(originStore)) {
+    throw new GemError("argument error");
+  }
+  StoreListenerMap.set(originStore, new Set());
+  return originStore;
+}
+function createStoreSet(originStoreSet) {
+  const keys = Object.keys(originStoreSet);
+  keys.forEach((key2) => {
+    createStore(originStoreSet[key2]);
+  });
+  return originStoreSet;
+}
+function updateStore(store2, value) {
+  Object.assign(store2, value);
+  const listeners = StoreListenerMap.get(store2);
+  listeners == null ? void 0 : listeners.forEach((func) => {
+    addMicrotask(func);
+  });
+}
+function connect(store2, func) {
+  const listeners = StoreListenerMap.get(store2);
+  listeners == null ? void 0 : listeners.add(func);
+}
+function disconnect(store2, func) {
+  const listeners = StoreListenerMap.get(store2);
+  listeners == null ? void 0 : listeners.delete(func);
+}
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const createAndInsertPart = (containerPart, beforePart) => {
+  const container = containerPart.startNode.parentNode;
+  const beforeNode = beforePart === void 0 ? containerPart.endNode : beforePart.startNode;
+  const startNode = container.insertBefore(createMarker(), beforeNode);
+  container.insertBefore(createMarker(), beforeNode);
+  const newPart = new NodePart(containerPart.options);
+  newPart.insertAfterNode(startNode);
+  return newPart;
+};
+const updatePart = (part2, value) => {
+  part2.setValue(value);
+  part2.commit();
+  return part2;
+};
+const insertPartBefore = (containerPart, part2, ref) => {
+  const container = containerPart.startNode.parentNode;
+  const beforeNode = ref ? ref.startNode : containerPart.endNode;
+  const endNode = part2.endNode.nextSibling;
+  if (endNode !== beforeNode) {
+    reparentNodes(container, part2.startNode, endNode, beforeNode);
+  }
+};
+const removePart = (part2) => {
+  removeNodes(part2.startNode.parentNode, part2.startNode, part2.endNode.nextSibling);
+};
+const generateMap = (list, start, end) => {
+  const map = new Map();
+  for (let i = start; i <= end; i++) {
+    map.set(list[i], i);
+  }
+  return map;
+};
+const partListCache = new WeakMap();
+const keyListCache = new WeakMap();
+const repeat = directive((items, keyFnOrTemplate, template) => {
+  let keyFn;
+  if (template === void 0) {
+    template = keyFnOrTemplate;
+  } else if (keyFnOrTemplate !== void 0) {
+    keyFn = keyFnOrTemplate;
+  }
+  return (containerPart) => {
+    if (!(containerPart instanceof NodePart)) {
+      throw new Error("repeat can only be used in text bindings");
+    }
+    const oldParts = partListCache.get(containerPart) || [];
+    const oldKeys = keyListCache.get(containerPart) || [];
+    const newParts = [];
+    const newValues = [];
+    const newKeys = [];
+    let index = 0;
+    for (const item of items) {
+      newKeys[index] = keyFn ? keyFn(item, index) : index;
+      newValues[index] = template(item, index);
+      index++;
+    }
+    let newKeyToIndexMap;
+    let oldKeyToIndexMap;
+    let oldHead = 0;
+    let oldTail = oldParts.length - 1;
+    let newHead = 0;
+    let newTail = newValues.length - 1;
+    while (oldHead <= oldTail && newHead <= newTail) {
+      if (oldParts[oldHead] === null) {
+        oldHead++;
+      } else if (oldParts[oldTail] === null) {
+        oldTail--;
+      } else if (oldKeys[oldHead] === newKeys[newHead]) {
+        newParts[newHead] = updatePart(oldParts[oldHead], newValues[newHead]);
+        oldHead++;
+        newHead++;
+      } else if (oldKeys[oldTail] === newKeys[newTail]) {
+        newParts[newTail] = updatePart(oldParts[oldTail], newValues[newTail]);
+        oldTail--;
+        newTail--;
+      } else if (oldKeys[oldHead] === newKeys[newTail]) {
+        newParts[newTail] = updatePart(oldParts[oldHead], newValues[newTail]);
+        insertPartBefore(containerPart, oldParts[oldHead], newParts[newTail + 1]);
+        oldHead++;
+        newTail--;
+      } else if (oldKeys[oldTail] === newKeys[newHead]) {
+        newParts[newHead] = updatePart(oldParts[oldTail], newValues[newHead]);
+        insertPartBefore(containerPart, oldParts[oldTail], oldParts[oldHead]);
+        oldTail--;
+        newHead++;
+      } else {
+        if (newKeyToIndexMap === void 0) {
+          newKeyToIndexMap = generateMap(newKeys, newHead, newTail);
+          oldKeyToIndexMap = generateMap(oldKeys, oldHead, oldTail);
+        }
+        if (!newKeyToIndexMap.has(oldKeys[oldHead])) {
+          removePart(oldParts[oldHead]);
+          oldHead++;
+        } else if (!newKeyToIndexMap.has(oldKeys[oldTail])) {
+          removePart(oldParts[oldTail]);
+          oldTail--;
+        } else {
+          const oldIndex = oldKeyToIndexMap.get(newKeys[newHead]);
+          const oldPart = oldIndex !== void 0 ? oldParts[oldIndex] : null;
+          if (oldPart === null) {
+            const newPart = createAndInsertPart(containerPart, oldParts[oldHead]);
+            updatePart(newPart, newValues[newHead]);
+            newParts[newHead] = newPart;
+          } else {
+            newParts[newHead] = updatePart(oldPart, newValues[newHead]);
+            insertPartBefore(containerPart, oldPart, oldParts[oldHead]);
+            oldParts[oldIndex] = null;
+          }
+          newHead++;
+        }
+      }
+    }
+    while (newHead <= newTail) {
+      const newPart = createAndInsertPart(containerPart, newParts[newTail + 1]);
+      updatePart(newPart, newValues[newHead]);
+      newParts[newHead++] = newPart;
+    }
+    while (oldHead <= oldTail) {
+      const oldPart = oldParts[oldHead++];
+      if (oldPart !== null) {
+        removePart(oldPart);
+      }
+    }
+    partListCache.set(containerPart, newParts);
+    keyListCache.set(containerPart, newKeys);
+  };
+});
+/**
+ * @license
+ * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const previousValues$1 = new WeakMap();
+const guard = directive((value, f) => (part2) => {
+  const previousValue = previousValues$1.get(part2);
+  if (Array.isArray(value)) {
+    if (Array.isArray(previousValue) && previousValue.length === value.length && value.every((v, i) => v === previousValue[i])) {
+      return;
+    }
+  } else if (previousValue === value && (value !== void 0 || previousValues$1.has(part2))) {
+    return;
+  }
+  part2.setValue(f());
+  previousValues$1.set(part2, Array.isArray(value) ? Array.from(value) : value);
+});
+/**
+ * @license
+ * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+const previousValues = new WeakMap();
+const ifDefined = directive((value) => (part2) => {
+  const previousValue = previousValues.get(part2);
+  if (value === void 0 && part2 instanceof AttributePart) {
+    if (previousValue !== void 0 || !previousValues.has(part2)) {
+      const name = part2.committer.name;
+      part2.committer.element.removeAttribute(name);
+    }
+  } else if (value !== previousValue) {
+    part2.setValue(value);
+  }
+  previousValues.set(part2, value);
+});
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _renderRoot, _internals, _isAppendReason, _isAsync, _effectList, _momeList, _unmountCallback, _exec, _execEffect, _execMemo, _initEffect, _render, _shouldUpdate, _updateCallback, _update, _updated, _connectedCallback;
+function emptyFunction() {
+}
+function execCallback(fun) {
+  typeof fun === "function" && fun();
+}
+const asyncRenderTaskList = new LinkedList();
+const tick = (timeStamp = performance.now()) => {
+  if (performance.now() > timeStamp + 16)
+    return requestAnimationFrame(tick);
+  const task = asyncRenderTaskList.get();
+  if (task) {
+    task();
+    tick(timeStamp);
+  }
+};
+asyncRenderTaskList.addEventListener("start", () => addMicrotask(tick));
+const initSymbol = Symbol("init");
+const updateSymbol = Symbol("update");
+class GemElement extends HTMLElement {
+  constructor({ isAsync, isLight, delegatesFocus } = {}) {
+    super();
+    __privateAdd$1(this, _renderRoot, void 0);
+    __privateAdd$1(this, _internals, void 0);
+    __privateAdd$1(this, _isAppendReason, void 0);
+    __privateAdd$1(this, _isAsync, void 0);
+    __privateAdd$1(this, _effectList, void 0);
+    __privateAdd$1(this, _momeList, void 0);
+    __privateAdd$1(this, _unmountCallback, void 0);
+    this.setState = (payload) => {
+      if (!this.state)
+        throw new GemError("`state` not initialized");
+      Object.assign(this.state, payload);
+      addMicrotask(__privateGet$1(this, _update));
+    };
+    __privateAdd$1(this, _exec, (list) => {
+      list == null ? void 0 : list.forEach((effectItem) => {
+        const { callback, getDep, values, preCallback } = effectItem;
+        const newValues = getDep == null ? void 0 : getDep();
+        if (!getDep || !values || isArrayChange(values, newValues)) {
+          execCallback(preCallback);
+          effectItem.preCallback = callback(newValues, values);
+          effectItem.values = newValues;
+        }
+      });
+    });
+    __privateAdd$1(this, _execEffect, () => {
+      __privateGet$1(this, _exec).call(this, __privateGet$1(this, _effectList));
+    });
+    __privateAdd$1(this, _execMemo, () => {
+      __privateGet$1(this, _exec).call(this, __privateGet$1(this, _momeList));
+    });
+    this.effect = (callback, getDep) => {
+      if (!__privateGet$1(this, _effectList))
+        __privateSet$1(this, _effectList, []);
+      const effectItem = {
+        callback,
+        getDep,
+        values: void 0,
+        initialized: !!this.isConnected
+      };
+      if (this.isConnected) {
+        effectItem.values = getDep == null ? void 0 : getDep();
+        effectItem.preCallback = callback(effectItem.values);
+      }
+      __privateGet$1(this, _effectList).push(effectItem);
+    };
+    this.memo = (callback, getDep) => {
+      if (!__privateGet$1(this, _momeList))
+        __privateSet$1(this, _momeList, []);
+      __privateGet$1(this, _momeList).push({
+        callback,
+        getDep,
+        values: [Symbol()],
+        initialized: this.isConnected
+      });
+    };
+    __privateAdd$1(this, _initEffect, () => {
+      var _a2;
+      (_a2 = __privateGet$1(this, _effectList)) == null ? void 0 : _a2.forEach((effectItem) => {
+        const { callback, getDep, initialized } = effectItem;
+        if (!initialized) {
+          effectItem.values = getDep == null ? void 0 : getDep();
+          effectItem.preCallback = callback(effectItem.values);
+          effectItem.initialized = true;
+        }
+      });
+    });
+    __privateAdd$1(this, _render, () => {
+      var _a2, _b;
+      __privateGet$1(this, _execMemo).call(this);
+      const styles = useNativeCSSStyleSheet ? "" : html`${(_b = (_a2 = this.shadowRoot) == null ? void 0 : _a2.adoptedStyleSheets) == null ? void 0 : _b.map((e) => html`
+              <style media=${e.media.mediaText}>
+                ${e.style}
+              </style>
+            `)}`;
+      if (this.render)
+        return html`${this.render()}${styles}`;
+      return __privateGet$1(this, _renderRoot) === this ? void 0 : html`<slot></slot>${styles}`;
+    });
+    __privateAdd$1(this, _shouldUpdate, () => {
+      return this.shouldUpdate ? this.shouldUpdate() : true;
+    });
+    __privateAdd$1(this, _updateCallback, () => {
+      if (this.isConnected && __privateGet$1(this, _shouldUpdate).call(this)) {
+        const temp = __privateGet$1(this, _render).call(this);
+        temp !== void 0 && render(temp, __privateGet$1(this, _renderRoot));
+        addMicrotask(__privateGet$1(this, _updated));
+        addMicrotask(__privateGet$1(this, _execEffect));
+      }
+    });
+    __privateAdd$1(this, _update, () => {
+      if (__privateGet$1(this, _isAsync)) {
+        asyncRenderTaskList.add(__privateGet$1(this, _updateCallback));
+      } else {
+        __privateGet$1(this, _updateCallback).call(this);
+      }
+    });
+    this.update = () => {
+      addMicrotask(__privateGet$1(this, _update));
+    };
+    __privateAdd$1(this, _updated, () => {
+      var _a2;
+      (_a2 = this.updated) == null ? void 0 : _a2.call(this);
+    });
+    __privateAdd$1(this, _connectedCallback, () => {
+      var _a2, _b, _c;
+      if (__privateGet$1(this, _isAppendReason)) {
+        __privateSet$1(this, _isAppendReason, false);
+        return;
+      }
+      (_a2 = this.willMount) == null ? void 0 : _a2.call(this);
+      const { observedStores, rootElement: rootElement2 } = this.constructor;
+      observedStores == null ? void 0 : observedStores.forEach((store2) => {
+        connect(store2, __privateGet$1(this, _update));
+      });
+      const temp = __privateGet$1(this, _render).call(this);
+      temp !== void 0 && render(temp, __privateGet$1(this, _renderRoot));
+      __privateSet$1(this, _unmountCallback, (_b = this.mounted) == null ? void 0 : _b.call(this));
+      __privateGet$1(this, _initEffect).call(this);
+      if (rootElement2 && ((_c = this.getRootNode().host) == null ? void 0 : _c.tagName) !== rootElement2.toUpperCase()) {
+        throw new GemError(`not allow current root type`);
+      }
+    });
+    addMicrotask(() => this[initSymbol] = false);
+    this[initSymbol] = true;
+    this[updateSymbol] = () => {
+      if (this.isConnected) {
+        addMicrotask(__privateGet$1(this, _update));
+      }
+    };
+    __privateSet$1(this, _isAsync, isAsync);
+    __privateSet$1(this, _renderRoot, isLight ? this : this.attachShadow({ mode: "open", delegatesFocus }));
+    const { adoptedStyleSheets } = new.target;
+    if (adoptedStyleSheets) {
+      const sheets = adoptedStyleSheets.map((item) => item[SheetToken] || item);
+      if (this.shadowRoot) {
+        this.shadowRoot.adoptedStyleSheets = sheets;
+      } else {
+        this.effect(() => {
+          const root = this.getRootNode();
+          if (!useNativeCSSStyleSheet) {
+            const ele = root === document ? document.body : root;
+            ele._sheets = ele._sheets || {};
+            sheets.forEach(({ style, media }) => {
+              if (ele._sheets[style]) {
+                ele._sheets[style].count++;
+              } else {
+                const s = document.createElement("style");
+                s.innerHTML = style;
+                s.media = media.mediaText;
+                ele.append(s);
+                ele._sheets[style] = { ele: s, count: 1 };
+              }
+            });
+            return () => {
+              sheets.forEach(({ style }) => {
+                ele._sheets[style].count--;
+                if (!ele._sheets[style].count) {
+                  delete ele._sheets[style];
+                }
+              });
+            };
+          } else {
+            root.adoptedStyleSheets = [...root.adoptedStyleSheets, ...sheets];
+            return () => {
+              root.adoptedStyleSheets = removeItems(root.adoptedStyleSheets, sheets);
+            };
+          }
+        }, () => []);
+      }
+    }
+  }
+  get internals() {
+    if (!__privateGet$1(this, _internals)) {
+      const getCustomStateSet = () => {
+        const getV = (v) => v.replace(/-/g, "");
+        return {
+          has: (v) => getV(v) in this.dataset,
+          add: (v) => {
+            this.dataset[getV(v)] = "";
+          },
+          delete: (v) => delete this.dataset[getV(v)]
+        };
+      };
+      if (!this.attachInternals) {
+        this.attachInternals = () => {
+          return { states: getCustomStateSet() };
+        };
+      }
+      __privateSet$1(this, _internals, this.attachInternals());
+      if (!__privateGet$1(this, _internals).states) {
+        __privateGet$1(this, _internals).states = getCustomStateSet();
+      }
+    }
+    return __privateGet$1(this, _internals);
+  }
+  attributeChangedCallback() {
+    if (this.isConnected) {
+      addMicrotask(__privateGet$1(this, _update));
+    }
+  }
+  closestElement(constructorOrTag) {
+    const isConstructor = typeof constructorOrTag === "function";
+    const tagName = typeof constructorOrTag === "string" && constructorOrTag.toUpperCase();
+    const getRootElement = (ele) => {
+      const rootEle = ele.parentElement || ele.getRootNode().host;
+      if (!rootEle)
+        return null;
+      if (isConstructor) {
+        if (rootEle.constructor === constructorOrTag) {
+          return rootEle;
+        }
+      } else if (rootEle.tagName === tagName) {
+        return rootEle;
+      }
+      return getRootElement(rootEle);
+    };
+    return getRootElement(this);
+  }
+  connectedCallback() {
+    if (__privateGet$1(this, _isAsync)) {
+      asyncRenderTaskList.add(__privateGet$1(this, _connectedCallback));
+    } else {
+      __privateGet$1(this, _connectedCallback).call(this);
+    }
+  }
+  disconnectedCallback() {
+    var _a2, _b, _c;
+    if (this.isConnected) {
+      __privateSet$1(this, _isAppendReason, true);
+      return;
+    }
+    const { observedStores } = this.constructor;
+    observedStores == null ? void 0 : observedStores.forEach((store2) => {
+      disconnect(store2, __privateGet$1(this, _update));
+    });
+    execCallback(__privateGet$1(this, _unmountCallback));
+    (_a2 = this.unmounted) == null ? void 0 : _a2.call(this);
+    (_b = __privateGet$1(this, _effectList)) == null ? void 0 : _b.forEach((effectItem) => {
+      execCallback(effectItem.preCallback);
+    });
+    __privateSet$1(this, _momeList, (_c = __privateGet$1(this, _momeList)) == null ? void 0 : _c.filter(({ initialized }) => !initialized));
+  }
+}
+_renderRoot = new WeakMap();
+_internals = new WeakMap();
+_isAppendReason = new WeakMap();
+_isAsync = new WeakMap();
+_effectList = new WeakMap();
+_momeList = new WeakMap();
+_unmountCallback = new WeakMap();
+_exec = new WeakMap();
+_execEffect = new WeakMap();
+_execMemo = new WeakMap();
+_initEffect = new WeakMap();
+_render = new WeakMap();
+_shouldUpdate = new WeakMap();
+_updateCallback = new WeakMap();
+_update = new WeakMap();
+_updated = new WeakMap();
+_connectedCallback = new WeakMap();
+const gemElementProxyMap = new PropProxyMap();
+function defineAttribute(target, prop, attr) {
+  const { booleanAttributes, numberAttributes } = target.constructor;
+  Object.defineProperty(target, prop, {
+    configurable: true,
+    get() {
+      if (!(initSymbol in this))
+        return;
+      const that = this;
+      const value = that.getAttribute(attr);
+      if (booleanAttributes == null ? void 0 : booleanAttributes.has(attr)) {
+        return value === null ? false : true;
+      }
+      if (numberAttributes == null ? void 0 : numberAttributes.has(attr)) {
+        return Number(value);
+      }
+      return value || "";
+    },
+    set(v) {
+      const that = this;
+      const proxy = gemElementProxyMap.get(this);
+      const hasSet = proxy[prop];
+      const value = that.getAttribute(attr);
+      if (this[initSymbol] && value !== null && !hasSet)
+        return;
+      proxy[prop] = true;
+      const isBool = booleanAttributes == null ? void 0 : booleanAttributes.has(attr);
+      if (v === null || v === void 0) {
+        that.removeAttribute(attr);
+      } else if (isBool) {
+        that.toggleAttribute(attr, !!v);
+      } else {
+        if (value !== String(v))
+          that.setAttribute(attr, String(v));
+      }
+    }
+  });
+}
+const isEventHandleSymbol = Symbol("event handle");
+function defineProperty(target, prop, event, eventOptions) {
+  Object.defineProperty(target, prop, {
+    configurable: true,
+    get() {
+      const value = gemElementProxyMap.get(this)[prop];
+      if (value || !event) {
+        return value;
+      } else {
+        this[prop] = emptyFunction;
+        return this[prop];
+      }
+    },
+    set(v) {
+      const that = this;
+      const proxy = gemElementProxyMap.get(that);
+      if (v !== proxy[prop]) {
+        if (event) {
+          proxy[prop] = (v == null ? void 0 : v[isEventHandleSymbol]) ? v : (detail, options) => {
+            const evt = new CustomEvent(event, __spreadProps(__spreadValues(__spreadValues({}, options), eventOptions), { detail }));
+            that.dispatchEvent(evt);
+            v(detail, options);
+          };
+          proxy[prop][isEventHandleSymbol] = true;
+        } else {
+          proxy[prop] = v;
+          this[updateSymbol]();
+        }
+      }
+    }
+  });
+}
+function defineRef(target, prop, ref) {
+  Object.defineProperty(target, prop, {
+    configurable: true,
+    get() {
+      const proxy = gemElementProxyMap.get(this);
+      let refobject2 = proxy[prop];
+      if (!refobject2) {
+        const that = this;
+        const ele = that.shadowRoot || that;
+        refobject2 = {
+          get ref() {
+            return ref;
+          },
+          get element() {
+            const gemReflects = [...ele.querySelectorAll("gem-reflect")].map((e) => e.target);
+            for (const e of [ele, ...gemReflects]) {
+              const result = e.querySelector(`[ref=${ref}]`);
+              if (result)
+                return result;
+            }
+          }
+        };
+        proxy[prop] = refobject2;
+      }
+      return refobject2;
+    }
+  });
+}
+function defineCSSState(target, prop, state2) {
+  Object.defineProperty(target, prop, {
+    configurable: true,
+    get() {
+      var _a2;
+      const that = this;
+      const { states } = that.internals;
+      return (_a2 = states.has) == null ? void 0 : _a2.call(states, state2);
+    },
+    set(v) {
+      const that = this;
+      const { states } = that.internals;
+      if (v) {
+        states.add(state2);
+      } else {
+        states.delete(state2);
+      }
+    }
+  });
+}
+const nativeDefineElement = customElements.define.bind(customElements);
+customElements.define = (name, cls, options) => {
+  if (cls.prototype instanceof GemElement) {
+    const { observedAttributes, observedPropertys, defineEvents, defineCSSStates, defineRefs } = cls;
+    observedAttributes == null ? void 0 : observedAttributes.forEach((attr) => defineAttribute(cls.prototype, kebabToCamelCase(attr), attr));
+    observedPropertys == null ? void 0 : observedPropertys.forEach((prop) => defineProperty(cls.prototype, prop));
+    defineEvents == null ? void 0 : defineEvents.forEach((event) => defineProperty(cls.prototype, kebabToCamelCase(event), event));
+    defineCSSStates == null ? void 0 : defineCSSStates.forEach((state2) => defineCSSState(cls.prototype, kebabToCamelCase(state2), `--${state2}`));
+    defineRefs == null ? void 0 : defineRefs.forEach((ref) => defineRef(cls.prototype, kebabToCamelCase(ref), ref));
+  }
+  nativeDefineElement(name, cls, options);
+};
+function pushStaticField(target, field, member, isSet = false) {
+  const cls = target.constructor;
+  const current = cls[field];
+  if (!cls.hasOwnProperty(field)) {
+    Object.defineProperty(cls, field, {
+      value: isSet ? new Set(current) : current ? Array.from(current) : []
+    });
+  }
+  cls[field][isSet ? "add" : "push"](member);
+}
+function refobject(target, prop) {
+  const ref = `${camelToKebabCase(prop)}-${randomStr()}`;
+  pushStaticField(target, "defineRefs", ref);
+  defineRef(target, prop, ref);
+}
+function defineAttr(target, prop, attr) {
+  pushStaticField(target, "observedAttributes", attr);
+  defineAttribute(target, prop, attr);
+}
+function attribute(target, prop) {
+  defineAttr(target, prop, camelToKebabCase(prop));
+}
+function boolattribute(target, prop) {
+  const attr = camelToKebabCase(prop);
+  pushStaticField(target, "booleanAttributes", attr, true);
+  defineAttr(target, prop, attr);
+}
+function numattribute(target, prop) {
+  const attr = camelToKebabCase(prop);
+  pushStaticField(target, "numberAttributes", attr, true);
+  defineAttr(target, prop, attr);
+}
+function property(target, prop) {
+  pushStaticField(target, "observedPropertys", prop);
+  defineProperty(target, prop);
+}
+function state(target, prop) {
+  const attr = camelToKebabCase(prop);
+  pushStaticField(target, "defineCSSStates", attr);
+  defineCSSState(target, prop, `--${attr}`);
+}
+function slot(target, prop) {
+  const attr = camelToKebabCase(target[prop] || prop);
+  target[prop] = attr;
+  pushStaticField(target instanceof GemElement ? target : target.prototype, "defineSlots", attr);
+}
+function part(target, prop) {
+  const attr = camelToKebabCase(target[prop] || prop);
+  target[prop] = attr;
+  pushStaticField(target instanceof GemElement ? target : target.prototype, "defineParts", attr);
+}
+function emitter(target, prop) {
+  defineEmitter(target, prop);
+}
+function globalemitter(target, prop) {
+  defineEmitter(target, prop, { bubbles: true, composed: true });
+}
+function defineEmitter(target, prop, options) {
+  const event = camelToKebabCase(prop);
+  pushStaticField(target, "defineEvents", event);
+  defineProperty(target, prop, event, options);
+}
+function adoptedStyle(style) {
+  return function(cls) {
+    const con = cls;
+    pushStaticField(con.prototype, "adoptedStyleSheets", style);
+  };
+}
+function connectStore(store2) {
+  return function(cls) {
+    const con = cls;
+    pushStaticField(con.prototype, "observedStores", store2);
+  };
+}
+function rootElement(rootType) {
+  return function(cls) {
+    const con = cls;
+    con.rootElement = rootType;
+  };
+}
+function customElement(name) {
+  return function(cls) {
+    nativeDefineElement(name, cls);
+  };
+}
+const history = window.history;
+const location$1 = window.location;
+const pushState = history.pushState.bind(history);
+const replaceState = history.replaceState.bind(history);
+let key = 0;
+const getKey = () => `${performance.now()}-${++key}`;
+const store = createStore({
+  $hasCloseHandle: false,
+  $hasOpenHandle: false,
+  $hasShouldCloseHandle: false,
+  $key: ""
+});
+const paramsMap = new Map();
+function validData({ $key, $hasCloseHandle, $hasOpenHandle, $hasShouldCloseHandle } = {}) {
+  if (store.$key === $key)
+    return;
+  if ($key)
+    throw new GemError("`$key` is not allowed");
+  if ($hasCloseHandle)
+    throw new GemError("`$hasCloseHandle` is not allowed");
+  if ($hasOpenHandle)
+    throw new GemError("`$hasOpenHandle` is not allowed");
+  if ($hasShouldCloseHandle)
+    throw new GemError("`$hasShouldCloseHandle` is not allowed");
+}
+function getUrlbarPath(internalPath) {
+  return history.basePath ? history.basePath + internalPath : internalPath;
+}
+function getInternalPath(urlbarPath) {
+  if (urlbarPath === history.basePath)
+    return "/";
+  return urlbarPath.replace(new RegExp(`^${history.basePath}/`), "/");
+}
+function initParams(params) {
+  const current = paramsMap.get(store.$key) || {};
+  const path = params.path ? absoluteLocation(current.path, params.path) : getInternalPath(location$1.pathname);
+  const query = new QueryString(params.query || (params.path ? "" : location$1.search));
+  const pathChanged = params.path && params.path !== current.path || params.query && String(params.query) !== String(current.query);
+  const title = params.title || (pathChanged ? "" : document.title);
+  const statusChanged = params.close || params.data || params.open || params.shouldClose;
+  const hash = params.hash || (!pathChanged && statusChanged ? decodeURIComponent(location$1.hash) : "");
+  return __spreadProps(__spreadValues({}, params), { title, path, query, hash });
+}
+function updateHistory(type, p) {
+  validData(p.data);
+  const params = initParams(p);
+  const { title, path, query, hash, close, open: open2, shouldClose, data } = params;
+  const state2 = __spreadValues({
+    $hasCloseHandle: !!close,
+    $hasOpenHandle: !!open2,
+    $hasShouldCloseHandle: !!shouldClose,
+    $key: getKey()
+  }, data);
+  paramsMap.set(state2.$key, params);
+  updateStore(cleanObject(store), state2);
+  const url = getUrlbarPath(path) + new QueryString(query) + hash;
+  const prevHave = decodeURIComponent(location$1.hash);
+  (type === "push" ? pushState : replaceState)(state2, title, url);
+  if (prevHave !== hash)
+    window.dispatchEvent(new CustomEvent("hashchange"));
+}
+function updateHistoryByNative(type, data, title, originUrl) {
+  validData(data);
+  const state2 = __spreadValues({
+    $key: getKey()
+  }, data || {});
+  const { pathname, search, hash } = new URL(originUrl, location$1.origin + location$1.pathname);
+  const params = initParams({ path: pathname, query: new QueryString(search), hash, title, data });
+  paramsMap.set(state2.$key, params);
+  updateStore(cleanObject(store), state2);
+  const url = getUrlbarPath(pathname) + params.query + hash;
+  const prevHash = location$1.hash;
+  (type === "push" ? pushState : replaceState)(state2, title, url);
+  if (prevHash !== hash)
+    window.dispatchEvent(new CustomEvent("hashchange"));
+}
+const basePathStore = createStore({
+  basePath: ""
+});
+window.addEventListener("hashchange", ({ isTrusted }) => {
+  if (isTrusted) {
+    history.replace({ hash: decodeURIComponent(location$1.hash) });
+  }
+});
+Object.defineProperties(history, {
+  basePath: {
+    get() {
+      return basePathStore.basePath;
+    },
+    set(basePath) {
+      updateStore(basePathStore, { basePath });
+      Object.assign(paramsMap.get(store.$key), { path: getInternalPath(location$1.pathname) });
+    }
+  },
+  getParams: {
+    value: function() {
+      return paramsMap.get(store.$key);
+    }
+  },
+  updateParams: {
+    value: function(params) {
+      Object.assign(paramsMap.get(store.$key), params);
+      updateStore(store, {});
+    }
+  },
+  store: {
+    value: store
+  },
+  push: {
+    value: function(params) {
+      history.pushState(params, "");
+    }
+  },
+  pushIgnoreCloseHandle: {
+    value: function(params) {
+      var _a2, _b;
+      if (store.$hasCloseHandle) {
+        (_b = (_a2 = paramsMap.get(store.$key)) == null ? void 0 : _a2.close) == null ? void 0 : _b.call(_a2);
+        history.replace(params);
+      } else {
+        history.push(params);
+      }
+    }
+  },
+  replace: {
+    value: function(params) {
+      updateHistory("replace", params);
+    }
+  }
+});
+history.pushState = function(data, title, path) {
+  if (path) {
+    updateHistoryByNative("push", data, title, path);
+  } else {
+    updateHistory("push", data);
+  }
+};
+history.replaceState = function(data, title, path) {
+  updateHistoryByNative("replace", data, title, path);
+};
+if (!history.state) {
+  const { pathname, search, hash } = location$1;
+  history.replace({ path: pathname, query: search, hash });
+} else if (history.state.$hasCloseHandle) {
+  updateStore(store, history.state);
+  const params = initParams({ title: document.title });
+  paramsMap.set(store.$key, params);
+  history.back();
+} else {
+  const params = initParams({ title: document.title, hash: location$1.hash });
+  updateStore(store, __spreadValues({
+    $key: getKey()
+  }, history.state || {}));
+  paramsMap.set(store.$key, params);
+}
+const titleStore = createStore({ title: "" });
+connect(titleStore, () => {
+  const params = paramsMap.get(store.$key);
+  if (params) {
+    params.title = titleStore.title;
+  }
+});
+connect(store, () => {
+  const { title } = history.getParams();
+  if (title !== titleStore.title) {
+    updateStore(titleStore, { title });
+  }
+});
+let navigating = false;
+window.addEventListener("popstate", (event) => {
+  var _a2, _b;
+  const newState = event.state;
+  if (!(newState == null ? void 0 : newState.$key)) {
+    return;
+  }
+  if (navigating) {
+    navigating = false;
+    return;
+  }
+  if (!paramsMap.has(newState.$key)) {
+    const { pathname, search, hash } = location$1;
+    paramsMap.set(newState.$key, {
+      path: pathname,
+      query: new QueryString(search),
+      hash,
+      title: document.title,
+      data: newState
+    });
+  }
+  const prevState = store;
+  if (parseFloat(newState.$key) > parseFloat(prevState.$key) && newState.$hasOpenHandle) {
+    (_b = (_a2 = paramsMap.get(newState.$key)) == null ? void 0 : _a2.open) == null ? void 0 : _b.call(_a2);
+  } else if (prevState.$hasCloseHandle) {
+    const prevParams = paramsMap.get(prevState.$key);
+    const closeHandle = prevParams == null ? void 0 : prevParams.close;
+    const shouldCloseHandle = prevParams == null ? void 0 : prevParams.shouldClose;
+    const notAllowClose = shouldCloseHandle && !shouldCloseHandle();
+    if (notAllowClose) {
+      navigating = true;
+      history.forward();
+      return;
+    } else {
+      if (closeHandle) {
+        closeHandle();
+      } else if (newState.$hasCloseHandle) {
+        navigating = true;
+        history.back();
+      }
+    }
+  }
+  updateStore(cleanObject(store), newState);
+});
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$6(target, key2, result);
+  return result;
+};
+var __accessCheck2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet2 = (obj, member, getter) => {
+  __accessCheck2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet2 = (obj, member, value, setter) => {
+  __accessCheck2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _lastLoader, _updateLocationStore, _setContent;
+class ParamsRegExp extends RegExp {
+  constructor(pattern) {
+    const namePosition = {};
+    let i = 0;
+    super(`^${pattern.replace(/:([^/$]+)/g, (_m, name) => {
+      namePosition[name] = i++;
+      return `([^/]+)`;
+    }).replace("*", ".*")}$`, "i");
+    this.namePosition = namePosition;
+  }
+}
+function matchPath(pattern, path) {
+  const reg = new ParamsRegExp(pattern);
+  const matchResult = path.match(reg) || `${path}/`.match(reg);
+  if (!matchResult)
+    return null;
+  const params = {};
+  if (matchResult) {
+    Object.keys(reg.namePosition).forEach((name) => {
+      params[name] = matchResult[reg.namePosition[name] + 1];
+    });
+  }
+  return params;
+}
+function createPath(route, options) {
+  let path = route.pattern;
+  const params = options == null ? void 0 : options.params;
+  if (params) {
+    Object.keys(params).forEach((key2) => {
+      path = path.replace(new RegExp(`:${key2}`, "g"), params[key2]);
+    });
+  }
+  return path;
+}
+function createHistoryParams(route, options) {
+  const path = createPath(route, options);
+  return __spreadValues({
+    path
+  }, options);
+}
+let GemRouteElement = class extends GemElement {
+  constructor({ isLight, routes } = {}) {
+    super({ isLight });
+    this.currentParams = {};
+    __privateAdd2(this, _lastLoader, void 0);
+    this.state = {
+      content: void 0
+    };
+    __privateAdd2(this, _updateLocationStore, () => {
+      if (this.locationStore) {
+        const { path, query, data } = history.getParams();
+        updateStore(this.locationStore, {
+          path,
+          params: this.currentParams,
+          query,
+          data
+        });
+      }
+    });
+    __privateAdd2(this, _setContent, (route, params, content) => {
+      __privateSet2(this, _lastLoader, void 0);
+      this.currentRoute = route;
+      this.currentParams = params;
+      this.setState({ content });
+      this.routechange(this.currentRoute);
+      const title = route == null ? void 0 : route.title;
+      if (title)
+        updateStore(titleStore, { title });
+      __privateGet2(this, _updateLocationStore).call(this);
+    });
+    this.routes = routes;
+  }
+  mounted() {
+    this.effect(([key2, path], old) => {
+      if (old && key2 === old[0] && path === old[1]) {
+        __privateGet2(this, _updateLocationStore).call(this);
+        return;
+      }
+      const { route, params = {} } = GemRouteElement.findRoute(this.routes, path);
+      const { redirect, content, getContent } = route || {};
+      if (redirect) {
+        history.replace({ path: redirect });
+        return;
+      }
+      const contentOrLoader = content || (getContent == null ? void 0 : getContent(params));
+      if (contentOrLoader instanceof Promise) {
+        this.loading(route);
+        __privateSet2(this, _lastLoader, contentOrLoader);
+        const isSomeLoader = () => __privateGet2(this, _lastLoader) === contentOrLoader;
+        contentOrLoader.then((content2) => {
+          if (isSomeLoader())
+            __privateGet2(this, _setContent).call(this, route, params, content2);
+        }).catch((err) => {
+          if (isSomeLoader())
+            this.error(err);
+        });
+        return;
+      }
+      __privateGet2(this, _setContent).call(this, route, params, contentOrLoader);
+    }, () => {
+      const { path } = history.getParams();
+      return [this.key, path, location.search];
+    });
+  }
+  shouldUpdate() {
+    if (this.inert)
+      return false;
+    return true;
+  }
+  render() {
+    const { content } = this.state;
+    if (!this.shadowRoot)
+      return html`${content}`;
+    return html`
+      <style>
+        :host,
+        :not(:defined) {
+          display: contents;
+        }
+      </style>
+      ${content != null ? content : html`<slot></slot>`}
+    `;
+  }
+};
+_lastLoader = new WeakMap();
+_updateLocationStore = new WeakMap();
+_setContent = new WeakMap();
+GemRouteElement.createLocationStore = () => {
+  const { path, query, data } = history.getParams();
+  return createStore({ path, query, data, params: {} });
+};
+GemRouteElement.findRoute = (target = [], path) => {
+  let defaultRoute = null;
+  let routes;
+  if (target instanceof Array) {
+    routes = target;
+  } else {
+    routes = Object.values(target);
+  }
+  for (const route of routes) {
+    if (route.pattern === "*") {
+      defaultRoute = route;
+    } else {
+      const params = matchPath(route.pattern, path);
+      if (params) {
+        return { route, params };
+      }
+    }
+  }
+  return { route: defaultRoute };
+};
+__decorateClass$6([
+  property
+], GemRouteElement.prototype, "routes", 2);
+__decorateClass$6([
+  property
+], GemRouteElement.prototype, "locationStore", 2);
+__decorateClass$6([
+  property
+], GemRouteElement.prototype, "key", 2);
+__decorateClass$6([
+  emitter
+], GemRouteElement.prototype, "routechange", 2);
+__decorateClass$6([
+  emitter
+], GemRouteElement.prototype, "loading", 2);
+__decorateClass$6([
+  emitter
+], GemRouteElement.prototype, "error", 2);
+GemRouteElement = __decorateClass$6([
+  connectStore(history.store),
+  customElement("gem-route")
+], GemRouteElement);
+let GemLightRouteElement = class extends GemRouteElement {
+  constructor(options = {}) {
+    super(__spreadProps(__spreadValues({}, options), { isLight: true }));
+  }
+};
+GemLightRouteElement = __decorateClass$6([
+  customElement("gem-light-route")
+], GemLightRouteElement);
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$5(target, key2, result);
+  return result;
+};
+let GemLinkElement = class extends GemElement {
+  constructor() {
+    super();
+    this.clickHandle = async (e) => {
+      var _a2;
+      const pathInfo = this.getPathInfo();
+      if (!pathInfo)
+        return;
+      if (this.isExternal(pathInfo)) {
+        switch (this.target) {
+          case "_self":
+            window.location.href = pathInfo;
+            return;
+          case "_parent":
+            window.parent.location.href = pathInfo;
+            return;
+          case "_top":
+            window.top.location.href = pathInfo;
+            return;
+          default:
+            window.open(pathInfo);
+            return;
+        }
+      }
+      const { path, query, hash } = history.getParams();
+      if (path + query + hash === pathInfo) {
+        return;
+      }
+      e.stopPropagation();
+      await ((_a2 = this.prepare) == null ? void 0 : _a2.call(this));
+      if (this.route) {
+        history.pushIgnoreCloseHandle(__spreadProps(__spreadValues({}, createHistoryParams(this.route, this.options)), {
+          title: this.route.title || this.docTitle
+        }));
+      } else if (this.href) {
+        const { pathname, search, hash: hash2 } = new URL(pathInfo, location.origin);
+        history.pushIgnoreCloseHandle({
+          path: pathname,
+          query: search,
+          hash: hash2,
+          title: this.docTitle
+        });
+      } else {
+        history.pushIgnoreCloseHandle({ path: this.path, query: this.query, hash: this.hash, title: this.docTitle });
+      }
+    };
+    this.preventDefault = (e) => {
+      e.preventDefault();
+    };
+    this.addEventListener("click", this.clickHandle);
+  }
+  getPathInfo() {
+    var _a2, _b;
+    if (this.route) {
+      const queryProp = ((_a2 = this.options) == null ? void 0 : _a2.query) || "";
+      const hashProp = ((_b = this.options) == null ? void 0 : _b.hash) || "";
+      return createPath(this.route, this.options) + queryProp + hashProp;
+    } else {
+      const url = this.href || this.path + this.query + this.hash;
+      const { path, query } = history.getParams();
+      if (url.startsWith("#")) {
+        return `${path}${query}${url}`;
+      } else if (url.startsWith("?")) {
+        return `${path}${url}`;
+      } else if (url.startsWith(".")) {
+        return absoluteLocation(path, url);
+      } else {
+        return url;
+      }
+    }
+  }
+  isExternal(pathInfo) {
+    return !pathInfo.startsWith("/");
+  }
+  render(pathInfo = this.getPathInfo()) {
+    return html`
+      <style>
+        :host {
+          /* link default style */
+          cursor: pointer;
+          color: blue;
+          text-decoration: underline;
+        }
+        a {
+          all: unset;
+          display: contents;
+        }
+        a:visited {
+          color: unset;
+        }
+      </style>
+      <a
+        part=${this.link}
+        @click=${this.preventDefault}
+        href=${ifDefined(this.hint === "off" ? void 0 : this.isExternal(pathInfo) ? pathInfo : new URL(history.basePath + pathInfo, location.origin).toString())}
+      >
+        <slot></slot>
+      </a>
+    `;
+  }
+};
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "href", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "target", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "path", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "query", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "hash", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "docTitle", 2);
+__decorateClass$5([
+  attribute
+], GemLinkElement.prototype, "hint", 2);
+__decorateClass$5([
+  property
+], GemLinkElement.prototype, "route", 2);
+__decorateClass$5([
+  property
+], GemLinkElement.prototype, "options", 2);
+__decorateClass$5([
+  property
+], GemLinkElement.prototype, "prepare", 2);
+__decorateClass$5([
+  part
+], GemLinkElement.prototype, "link", 2);
+GemLinkElement = __decorateClass$5([
+  customElement("gem-link"),
+  connectStore(basePathStore)
+], GemLinkElement);
+let GemActiveLinkElement = class extends GemLinkElement {
+  render() {
+    const { path, query, hash } = history.getParams();
+    const isMatchPattern = this.pattern && matchPath(this.pattern, path);
+    const pathInfo = this.getPathInfo();
+    if (isMatchPattern || path + query + hash === pathInfo) {
+      this.active = true;
+    } else {
+      this.active = false;
+    }
+    return super.render(pathInfo);
+  }
+};
+__decorateClass$5([
+  attribute
+], GemActiveLinkElement.prototype, "pattern", 2);
+__decorateClass$5([
+  state
+], GemActiveLinkElement.prototype, "active", 2);
+GemActiveLinkElement = __decorateClass$5([
+  customElement("gem-active-link"),
+  connectStore(history.store)
+], GemActiveLinkElement);
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$4(target, key2, result);
+  return result;
+};
+let GemTitleElement = class extends GemElement {
+  static setTitle(title) {
+    updateStore(titleStore, { title });
+  }
+  static updateTitle(str = "", suffix = "") {
+    const { title } = titleStore;
+    if (title && title !== GemTitleElement.defaultTitle) {
+      GemTitleElement.title = title;
+      document.title = GemTitleElement.title + suffix;
+    } else if (str) {
+      GemTitleElement.title = str;
+      document.title = GemTitleElement.title + suffix;
+    } else {
+      GemTitleElement.title = GemTitleElement.defaultTitle;
+      document.title = GemTitleElement.title;
+    }
+  }
+  constructor() {
+    super();
+    new MutationObserver(() => this.update()).observe(this, { childList: true, characterData: true, subtree: true });
+  }
+  render() {
+    GemTitleElement.updateTitle(this.textContent || "", this.suffix);
+    if (this.hidden) {
+      return html``;
+    }
+    return html`${GemTitleElement.title}`;
+  }
+};
+GemTitleElement.title = document.title;
+GemTitleElement.defaultTitle = document.title;
+GemTitleElement.defaultSuffix = ` - ${document.title}`;
+__decorateClass$4([
+  attribute
+], GemTitleElement.prototype, "suffix", 2);
+GemTitleElement = __decorateClass$4([
+  connectStore(titleStore),
+  customElement("gem-title")
+], GemTitleElement);
+connect(titleStore, GemTitleElement.updateTitle);
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$3(target, key2, result);
+  return result;
+};
+const eleCache = new Map();
+let GemUseElement = class extends GemElement {
+  getContent() {
+    const ele = this.element || (this.selector ? (this.root || document).querySelector(this.selector) : null);
+    if (typeof ele === "string") {
+      let temp = eleCache.get(ele);
+      if (!temp) {
+        temp = document.createElement("template");
+        temp.innerHTML = ele;
+        eleCache.set(ele, temp);
+      }
+      return temp.content.cloneNode(true);
+    } else if (ele instanceof HTMLTemplateElement) {
+      return ele.content.cloneNode(true);
+    } else {
+      return ele == null ? void 0 : ele.cloneNode(true);
+    }
+  }
+  render() {
+    return html`
+      <style>
+        :host {
+          position: relative;
+        }
+        :host(:not([hidden])) {
+          display: inline-flex;
+          align-items: center;
+        }
+        svg {
+          width: 100%;
+          height: 100%;
+        }
+      </style>
+      ${this.getContent()}
+      <slot></slot>
+    `;
+  }
+};
+__decorateClass$3([
+  attribute
+], GemUseElement.prototype, "selector", 2);
+__decorateClass$3([
+  property
+], GemUseElement.prototype, "root", 2);
+__decorateClass$3([
+  property
+], GemUseElement.prototype, "element", 2);
+__decorateClass$3([
+  state
+], GemUseElement.prototype, "active", 2);
+GemUseElement = __decorateClass$3([
+  customElement("gem-use")
+], GemUseElement);
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$2(target, key2, result);
+  return result;
+};
+let GemUnsafeElement = class extends GemElement {
+  constructor() {
+    super();
+    this.effect(() => {
+      if (this.shadowRoot) {
+        this.shadowRoot.innerHTML = `
+            <style>
+              :host {
+                display: contents;
+              }
+              ${this.contentcss}
+            </style>
+            ${this.content}
+          `;
+      }
+    }, () => [this.content, this.contentcss]);
+  }
+  render() {
+    return void 0;
+  }
+};
+__decorateClass$2([
+  attribute
+], GemUnsafeElement.prototype, "content", 2);
+__decorateClass$2([
+  attribute
+], GemUnsafeElement.prototype, "contentcss", 2);
+GemUnsafeElement = __decorateClass$2([
+  customElement("gem-unsafe")
+], GemUnsafeElement);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp$1(target, key2, result);
+  return result;
+};
+document.querySelectorAll("[data-reflect]").forEach((e) => e.remove());
+let GemReflectElement = class extends GemElement {
+  constructor() {
+    super({ isLight: true });
+    this.target = document.head;
+    this.hidden = true;
+    this.effect(() => {
+      const childNodes = [...this.childNodes];
+      childNodes.forEach((node) => {
+        if (node instanceof HTMLElement) {
+          node.dataset.reflect = "";
+        }
+        this.target.append(node);
+      });
+      return () => {
+        childNodes.forEach((node) => node.remove());
+      };
+    }, () => [this.target]);
+  }
+};
+__decorateClass$1([
+  property
+], GemReflectElement.prototype, "target", 2);
+GemReflectElement = __decorateClass$1([
+  customElement("gem-reflect")
+], GemReflectElement);
+const open = Symbol("open mark");
+function createModalClass(options) {
+  var _a2;
+  return _a2 = class extends GemElement {
+    constructor() {
+      super();
+      this.label = "";
+      this.internals.role = "alertdialog";
+      this.internals.ariaModal = "true";
+    }
+    static get isOpen() {
+      return this.store[open];
+    }
+    static get observedStores() {
+      return [history.store, this.store];
+    }
+    static open(opts) {
+      const instance = new this();
+      this.instance = instance;
+      this.inertStore = [...document.body.children].filter((e) => !e.inert);
+      this.inertStore.forEach((e) => e.inert = true);
+      document.body.append(instance);
+      const changeStore = () => updateStore(this.store, __spreadValues({ [open]: true }, opts));
+      setTimeout(() => {
+        changeStore();
+        history.push({
+          title: instance.label,
+          open: changeStore,
+          close: this.closeHandle.bind(this),
+          shouldClose: this.shouldClose.bind(this)
+        });
+      }, 100);
+    }
+    static close() {
+      history.back();
+    }
+    static closeHandle() {
+      var _a3;
+      this.inertStore.forEach((e) => e.inert = false);
+      (_a3 = this.instance) == null ? void 0 : _a3.remove();
+      updateStore(this.store, __spreadValues({ [open]: false }, options));
+    }
+    static shouldClose() {
+      return true;
+    }
+  }, _a2.inertStore = [], _a2.instance = null, _a2.store = createStore(__spreadValues({
+    [open]: false
+  }, options)), _a2;
+}
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp2(target, key2, result);
+  return result;
+};
+let DialogBaseElement = (_a = class extends GemElement {
+  constructor() {
+    super();
+    __privateAdd(this, _nextSibling, void 0);
+    __privateAdd(this, _parentElement, void 0);
+    __privateAdd(this, _inertStore, void 0);
+    this.inert = true;
+    __privateSet(this, _inertStore, []);
+    this.closeHandle = () => {
+      var _a2;
+      this.inert = true;
+      __privateGet(this, _inertStore).forEach((e) => e.inert = false);
+      if (__privateGet(this, _nextSibling)) {
+        __privateGet(this, _nextSibling).before(this);
+      } else if (__privateGet(this, _parentElement)) {
+        (_a2 = __privateGet(this, _parentElement)) == null ? void 0 : _a2.appendChild(this);
+      }
+      this.dispatchEvent(new CustomEvent("close"));
+      this.opened = false;
+    };
+    this.openHandle = () => {
+      this.hidden = false;
+      this.inert = false;
+      __privateSet(this, _nextSibling, this.nextSibling);
+      __privateSet(this, _parentElement, this.parentElement || this.getRootNode());
+      __privateSet(this, _inertStore, [...document.body.children].filter((e) => !e.inert));
+      __privateGet(this, _inertStore).forEach((e) => e.inert = true);
+      document.body.append(this);
+      this.dispatchEvent(new CustomEvent("open"));
+      this.opened = true;
+    };
+    this.open = () => {
+      if (this.opened)
+        return;
+      this.openHandle();
+      history.push({
+        title: this.label,
+        open: this.openHandle,
+        close: this.closeHandle,
+        shouldClose: this.shouldClose
+      });
+    };
+    this.close = () => {
+      history.back();
+    };
+    this.forceClose = () => {
+      this.opened = false;
+      setTimeout(this.close, 100);
+    };
+    this.internals.role = "dialog";
+    this.internals.ariaModal = "true";
+  }
+  shouldClose() {
+    return true;
+  }
+}, _nextSibling = new WeakMap(), _parentElement = new WeakMap(), _inertStore = new WeakMap(), _a);
+__decorateClass([
+  attribute
+], DialogBaseElement.prototype, "label", 2);
+__decorateClass([
+  state
+], DialogBaseElement.prototype, "opened", 2);
+DialogBaseElement = __decorateClass([
+  connectStore(history.store)
+], DialogBaseElement);
+const themeStoreMap = new WeakMap();
+function getThemeStore(theme) {
+  return themeStoreMap.get(theme);
+}
+const themePropMap = new WeakMap();
+function getThemeProp(theme) {
+  return themePropMap.get(theme);
+}
+function replaceStyle(style, theme) {
+  const themeStore = themeStoreMap.get(theme);
+  const themeProp = themePropMap.get(theme);
+  const rules = Object.keys(themeStore).reduce((prev, key2) => {
+    if (!themeStore[key2])
+      return prev;
+    return prev + `${themeProp[key2]}:${themeStore[key2]};`;
+  }, "");
+  style.textContent = `:root, :host {${rules}}`;
+}
+function createTheme(themeObj) {
+  const salt = randomStr();
+  const style = document.createElement("style");
+  const themeStore = createStore(themeObj);
+  const theme = {};
+  const themeProp = {};
+  themePropMap.set(theme, themeProp);
+  themeStoreMap.set(theme, themeStore);
+  Object.keys(themeStore).forEach((key2) => {
+    themeProp[key2] = `--${camelToKebabCase(key2)}-${salt}`;
+    theme[key2] = `var(${themeProp[key2]})`;
+  });
+  const replace = () => replaceStyle(style, theme);
+  connect(themeStore, replace);
+  replace();
+  (document.head || document.documentElement).append(style);
+  return theme;
+}
+function updateTheme(theme, newThemeObj) {
+  const store2 = getThemeStore(theme);
+  updateStore(store2, newThemeObj);
+}
+const splitReg = /\$\d(?:<[^>]*>)?/;
+const matchReg = /\$(\d)(<([^>]*)>)?/g;
+const matchStrIndex = 3;
+function splice(rawValue, ...rest) {
+  const templateArr = rawValue.split(splitReg);
+  const values = [];
+  let result;
+  while (result = matchReg.exec(rawValue)) {
+    const str = result[matchStrIndex];
+    const index = Number(result[1]) - 1;
+    const arg = rest[index];
+    values.push(typeof arg === "string" ? arg : arg(str));
+  }
+  return html(templateArr, ...values);
+}
+const modules = new Set();
+const _I18n = class {
+  constructor(options) {
+    __privateAdd(this, _cacheCurrentKey);
+    __privateAdd(this, _urlParamsLang);
+    __privateAdd(this, _cacheLang);
+    __privateAdd(this, _isMain);
+    __privateAdd(this, _lang);
+    this.cachePrefix = "gem-i18n";
+    if (!options.resources[options.fallbackLanguage]) {
+      throw new GemError("i18n: fallbackLanguage invalid");
+    }
+    this.store = createStore(this);
+    Object.assign(this, options);
+    let currentLanguage = __privateGet(this, _urlParamsLang, urlParamsLang_get) || this.currentLanguage || __privateGet(this, _cacheLang, cacheLang_get);
+    const ele = document.querySelector(`[type*=${this.cachePrefix}]`);
+    if (ele) {
+      try {
+        const prerenderData = JSON.parse(ele.textContent || "");
+        currentLanguage = prerenderData.currentLanguage;
+        this.resources[prerenderData.currentLanguage] = prerenderData.currentLanguagePack;
+      } catch {
+      }
+    }
+    if (currentLanguage) {
+      __privateSet(this, _lang, currentLanguage, lang_set);
+      this.setLanguage(currentLanguage);
+    } else {
+      this.resetLanguage();
+    }
+  }
+  get(s, ...rest) {
+    const currentLanguagePack = this.resources[this.currentLanguage];
+    const fallbackLanguagePack = this.resources[this.fallbackLanguage];
+    const msg = currentLanguagePack[s] || fallbackLanguagePack[s];
+    const rawValue = (msg == null ? void 0 : msg.message) || msg || `[${s}]`;
+    if (!rest.length)
+      return rawValue;
+    return splice(rawValue, ...rest);
+  }
+  detectLanguage() {
+    const availableLangs = Object.keys(this.resources);
+    const uiLangs = navigator.languages.map((lang) => lang.replace(/-(.*)/, ($1) => $1.toUpperCase()));
+    for (const lang of uiLangs) {
+      const matched = availableLangs.find((e) => e === lang || lang.startsWith(`${e}-`));
+      if (matched)
+        return matched;
+    }
+    return this.fallbackLanguage;
+  }
+  async setLanguage(lang) {
+    if (__privateGet(this, _isMain, isMain_get)) {
+      modules.forEach(async (i18n) => await i18n.setLanguage(lang));
+    }
+    let pack;
+    const data = this.resources[lang];
+    if (!data) {
+      console.warn(`${this.cachePrefix}: not found \`${lang}\``);
+      return this.resetLanguage();
+    }
+    if (typeof data === "string") {
+      const prefix = `${this.cachePrefix}:`;
+      const localKey = `${prefix}${data}`;
+      const localPackString = localStorage.getItem(localKey);
+      const fetchPack = async () => {
+        const pack2 = await (await fetch(data)).json();
+        if (this.cache) {
+          for (let i = 0; i < localStorage.length; i++) {
+            const key2 = localStorage.key(i);
+            if (key2.startsWith(prefix)) {
+              localStorage.removeItem(key2);
+            }
+          }
+          localStorage.setItem(localKey, JSON.stringify(pack2));
+        }
+        return pack2;
+      };
+      if (localPackString) {
+        try {
+          pack = JSON.parse(localPackString);
+        } catch (e) {
+          pack = await fetchPack();
+        }
+      } else {
+        pack = await fetchPack();
+      }
+    } else {
+      pack = data;
+    }
+    this.resources[lang] = pack;
+    updateStore(this.store, {});
+    if (lang !== this.currentLanguage) {
+      __privateSet(this, _lang, lang, lang_set);
+    }
+    if (this.cache === true) {
+      this.setCache();
+    }
+    return lang;
+  }
+  resetLanguage() {
+    if (__privateGet(this, _isMain, isMain_get)) {
+      modules.forEach((i18n) => i18n.resetLanguage());
+    }
+    __privateSet(this, _lang, this.fallbackLanguage, lang_set);
+    if (this.cache) {
+      localStorage.removeItem(__privateGet(this, _cacheCurrentKey, cacheCurrentKey_get));
+    }
+    return this.setLanguage(this.detectLanguage());
+  }
+  setCache() {
+    if (__privateGet(this, _isMain, isMain_get)) {
+      modules.forEach((i18n) => i18n.setCache());
+    }
+    localStorage.setItem(__privateGet(this, _cacheCurrentKey, cacheCurrentKey_get), this.currentLanguage);
+  }
+  createSubModule(name, resources) {
+    const module = new _I18n({
+      resources,
+      cachePrefix: `${this.cachePrefix}-${name}`,
+      currentLanguage: this.currentLanguage,
+      fallbackLanguage: this.fallbackLanguage,
+      cache: this.cache
+    });
+    modules.add(module);
+    return module;
+  }
+  toJSON() {
+    return {
+      currentLanguage: this.currentLanguage,
+      currentLanguagePack: this.resources[this.currentLanguage]
+    };
+  }
+};
+let I18n = _I18n;
+_cacheCurrentKey = new WeakSet();
+cacheCurrentKey_get = function() {
+  return `${this.cachePrefix}:current`;
+};
+_urlParamsLang = new WeakSet();
+urlParamsLang_get = function() {
+  const { hostname, pathname, search } = location;
+  const parts2 = hostname.split(".");
+  switch (this.urlParamsType) {
+    case "ccTLD":
+      return parts2.pop();
+    case "gTLD":
+      return parts2.shift();
+    case "path":
+      return pathname.split("/")[1];
+    default:
+      const fragment = this.urlParamsName && new URLSearchParams(search).get(this.urlParamsName) || "";
+      return fragment in this.resources ? fragment : "";
+  }
+};
+_cacheLang = new WeakSet();
+cacheLang_get = function() {
+  return this.cache && localStorage.getItem(__privateGet(this, _cacheCurrentKey, cacheCurrentKey_get)) || "";
+};
+_isMain = new WeakSet();
+isMain_get = function() {
+  return !modules.has(this);
+};
+_lang = new WeakSet();
+lang_set = function(lang) {
+  var _a2;
+  if (__privateGet(this, _isMain, isMain_get)) {
+    document.documentElement.lang = lang;
+  }
+  this.currentLanguage = lang;
+  (_a2 = this.onChange) == null ? void 0 : _a2.call(this, lang);
+};
+const defaultReq = {
+  credentials: "include",
+  mode: "cors"
+};
+async function request(uri, options = {}) {
+  const res = await fetch(uri, __spreadValues(__spreadValues({}, defaultReq), options));
+  if (res.status === 0)
+    throw new Error("Request fail");
+  if (res.status >= 500)
+    throw new Error(res.statusText);
+  if (res.status >= 400)
+    throw new Error(await res.text() || res.statusText);
+  return await res.json();
+}
+const TypedArray = Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array()));
+function serializationBody(body) {
+  if (body instanceof FormData || body instanceof Blob || body instanceof TypedArray || body instanceof URLSearchParams || body instanceof ReadableStream || body instanceof ArrayBuffer) {
+    return body;
+  }
+  if (typeof body === "object") {
+    return JSON.stringify(body);
+  }
+  return body;
+}
+function get(url, params) {
+  const { origin, pathname, search } = new URL(url, location.origin);
+  const query = new URLSearchParams(params).toString();
+  return request(`${origin}${pathname}${search ? `${search}&` : query ? "?" : ""}${query}`, {
+    method: "GET"
+  });
+}
+function del(url) {
+  return request(url, { method: "DELETE" });
+}
+function put(url, body) {
+  return request(url, { method: "PUT", body: serializationBody(body) });
+}
+function post(url, body) {
+  return request(url, { method: "POST", body: serializationBody(body) });
+}
+const matche = (query) => window.matchMedia(query).matches;
+const mediaQuery = {
+  PRINT: "print",
+  get isPrint() {
+    return matche(this.PRINT);
+  },
+  HOVER: "(hover: hover)",
+  get isHover() {
+    return matche(this.HOVER);
+  },
+  PHONE: "(min-width: 319px) and (max-width: 480px)",
+  get isPhone() {
+    return matche(this.PHONE);
+  },
+  LAPTOP: "(min-width: 1023px) and (max-width: 1280px) and (orientation: landscape)",
+  get isLaptop() {
+    return matche(this.LAPTOP);
+  },
+  DESKTOP: "(min-width: 1279px) and (orientation: landscape)",
+  get isDesktop() {
+    return matche(this.DESKTOP);
+  },
+  WIDTHSCREEN: "(min-width: 1919px) and (orientation: landscape)",
+  get isWidthScreen() {
+    return matche(this.WIDTHSCREEN);
+  },
+  PHONE_LANDSCAPE: "(min-width: 479px) and (max-width: 767px) and (orientation: landscape)",
+  get isPhoneLandscape() {
+    return matche(this.PHONE_LANDSCAPE);
+  },
+  TABLET: "(min-width: 768px) and (max-width: 1024px)",
+  get isTablet() {
+    return matche(this.TABLET);
+  },
+  SMALL_PHONE: "(min-width: 319px) and (max-width: 480px) and (max-height: 640px)",
+  get isSmallPhone() {
+    return matche(this.SMALL_PHONE);
+  },
+  WATCH: "(max-width: 319px)",
+  get isWatch() {
+    return matche(this.WATCH);
+  },
+  SHORT: "(min-width: 479px) and (max-height: 320px)",
+  get isShort() {
+    return matche(this.SHORT);
+  },
+  PWA: "(display-mode: standalone)",
+  get isPWA() {
+    return matche(this.PWA);
+  },
+  MOTION_REDUCE: "(prefers-reduced-motion: reduce)",
+  get isMotionReduce() {
+    return matche(this.MOTION_REDUCE);
+  },
+  DATA_REDUCE: "(prefers-reduced-data: reduce)",
+  get isDataReduce() {
+    return matche(this.DATA_REDUCE);
+  }
+};
+const version = "1.6.5";
+if (window.__GEM_DEVTOOLS__HOOK__) {
+  Object.assign(window.__GEM_DEVTOOLS__HOOK__, __spreadValues({}, Gem));
+}
+export { DialogBaseElement, GemActiveLinkElement, GemElement, GemError, GemLightRouteElement, GemLinkElement, GemReflectElement, GemRouteElement, GemTitleElement, GemUnsafeElement, GemUseElement, I18n, LinkedList, PropProxyMap, QueryString, SVGTemplateResult, SheetToken, StoreListenerMap, TemplateResult, absoluteLocation, addMicrotask, addMicrotaskToStack, adoptedStyle, attribute, basePathStore, boolattribute, camelToKebabCase, classMap, cleanObject, connect, connectStore, createCSSSheet, createHistoryParams, createModalClass, createPath, createStore, createStoreSet, createTheme, css, customElement, defineAttribute, defineCSSState, defineProperty, defineRef, del, directive, disconnect, emitter, get, getThemeProp, getThemeStore, globalemitter, guard, history, html, ifDefined, isArrayChange, kebabToCamelCase, matchPath, mediaQuery, nativeDefineElement, numattribute, part, partMap, post, property, put, randomStr, raw, refobject, removeItems, render, repeat, request, rootElement, slot, splice, state, styleMap, styled, svg, titleStore, updateStore, updateTheme, useNativeCSSStyleSheet, version };