☰

honkoku-toolbox

日本の古典籍を翻刻する際の便利ツール

  1. // ==UserScript==
  2. // @name            honkoku-toolbox
  3. // @name:en         Honkoku Tools
  4. // @name:ja         翻刻ツールボックス
  5. // @name:zh         翻刻工具箱
  6. // @name:ko         翻刻道具箱子
  7. // @namespace       https://mkpo.li/
  8. // @version         0.9.3
  9. // @author          monkey
  10. // @description:en  Convenient tools for transcribing Japanese classical texts
  11. // @description:ja  日本の古典籍をデジタル翻刻する際の便利ツール
  12. // @description:zh  日本古籍數字化翻印用的便利工具集成
  13. // @description:ko  日本古典文獻을 디지털化할 때 便利한 道具
  14. // @license         MIT
  15. // @icon            data:image/png;base64,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
  16. // @match           https://honkoku.org/app/*
  17. // @match           https://ja.wikisource.org/w/index.php?title=*&action=*
  18. // @grant           GM.getValue
  19. // @grant           GM.setValue
  20. // @grant           GM_addStyle
  21. // @description 日本の古典籍を翻刻する際の便利ツール
  22. // ==/UserScript==
  23.  
  24. (e=>{if(typeof GM_addStyle=="function"){GM_addStyle(e);return}const t=document.createElement("style");t.textContent=e,document.head.append(t)})(' .CodeMirror.display-variant-highlight .highlight-variant,.editor-wrapper.display-variant-highlight .token .char.highlight-variant{color:#ff9800;font-weight:700}button.svelte-1ewjpur{width:2em;height:2em;border:1px solid #bbb;background-color:#fff;cursor:pointer;display:flex;align-items:center;justify-content:center;white-space:nowrap;background-color:#ffffff85;-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px)}button.svelte-1ewjpur:hover{background-color:#eee;border-color:#000}button.active.svelte-1ewjpur{background-color:#eee}.variants.svelte-1ewjpur{display:flex;flex-direction:column;gap:0}.variants.svelte-1ewjpur button:where(.svelte-1ewjpur){font-family:"Noto Serif Hentaigana",UniHentaiKana,serif;border-radius:2em;box-shadow:0 0 5px 1px #bbb}.variants.svelte-1ewjpur button:where(.svelte-1ewjpur):hover{background-color:#eee}.float-menu.svelte-1rgb4pt{writing-mode:vertical-rl;position:fixed;bottom:0;left:50%;transform:translate(-50%);background-color:#fbfbfb;z-index:100;padding:.5em;font-size:.85rem;border-radius:.5em;box-shadow:4px 4px 1em #0003;display:grid;grid-template-columns:auto 1fr;-webkit-user-select:none;user-select:none;cursor:move}button.svelte-18a6ijc{padding:.5em .1em;border:1px solid #bbb;background-color:#fff;cursor:pointer;display:flex;align-items:center;justify-content:center;white-space:nowrap;font-family:inherit}button.svelte-18a6ijc:hover{background-color:#eee}[data-color=black].svelte-18a6ijc{color:#000}[data-color=green].svelte-18a6ijc{color:#00a800}[data-color=blue].svelte-18a6ijc{color:#009dff}[data-color=red].svelte-18a6ijc{color:#ff3e00}[data-color=pink].svelte-18a6ijc{color:#f0d}[data-color=gray].svelte-18a6ijc{color:#888}[data-color=orange].svelte-18a6ijc{color:#ff9500}.kana-table.svelte-1c61vln{padding:.25em;display:grid;grid-template-columns:repeat(5,1fr);gap:.25em}button.svelte-1c61vln{font-family:"Noto Serif Hentaigana",UniHentaiKana,serif}h2.svelte-1c61vln{margin:0;border:none;font-size:1.25em;font-family:inherit;width:100%;text-align:center;font-weight:700}.menu-content-container.svelte-1c61vln{display:flex;flex-direction:column;font-family:"Noto Serif Hentaigana",UniHentaiKana,serif}.show-button.svelte-1c61vln{position:fixed;right:0;top:40%;height:3rem;transform:translateY(-50%);background-color:#fff;padding:.5em;border-radius:.5em 0 0 .5em;display:flex;align-items:center;justify-content:center;box-shadow:0 0 1em #0003;transition:transform .1s ease-in-out;border:1px solid #ccc;color:#ff36a4}.show-button.svelte-1c61vln:hover{transform:translateY(-50%) scale(1.1)}.kana.svelte-1c61vln{font-size:2em}.panel.svelte-1c61vln{display:flex;flex-direction:row;gap:.25em;padding:.25em}button.svelte-1m4k62d{padding:.5em .1em;border:1px solid #bbb;background-color:#fff;cursor:pointer;display:flex;align-items:center;justify-content:center;white-space:nowrap;background-color:#ffffff85;-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);font-family:Jigmo,Jigmo2,Jigmo3,HanaMinA,HanaMinB,serif}button.svelte-1m4k62d:hover{background-color:#eee;border-color:#000}button.active.svelte-1m4k62d{background-color:#eee}button.selected.svelte-1m4k62d{background-color:#fff0cc}.type.selected.svelte-1m4k62d{border-color:#765300}.variants.svelte-1m4k62d{display:flex;flex-direction:column;gap:0;box-shadow:0 0 5px 1px #bbb}.variants.svelte-1m4k62d button:where(.svelte-1m4k62d){width:2em}.variants.svelte-1m4k62d button:where(.svelte-1m4k62d):hover{background-color:#eee}h2.svelte-9lvbl8{margin:0;border:none;font-size:1.25em;font-family:inherit;width:100%;text-align:center;font-weight:700}.menu-content-container.svelte-9lvbl8{display:flex;flex-direction:column;gap:.25em;align-items:stretch;justify-content:center;font-family:"Noto Serif Hentaigana",UniHentaiKana,serif}.show-button.svelte-9lvbl8{position:fixed;right:0;top:60%;height:3rem;transform:translateY(-50%);background-color:#fff;padding:.5em;border-radius:.5em 0 0 .5em;display:flex;align-items:center;justify-content:center;box-shadow:0 0 1em #0003;transition:transform .1s ease-in-out;border:1px solid #ccc;font-family:serif;color:#0f03f8}.show-button.svelte-9lvbl8:hover{transform:translateY(-50%) scale(1.1)}.icon.svelte-9lvbl8{font-size:2em}.panel.svelte-9lvbl8{display:grid;grid-template-columns:repeat(5,1fr);gap:.25em;max-width:20em}label.svelte-9lvbl8{display:flex;align-items:center;justify-content:center;gap:.5em}hr.svelte-9lvbl8{border:1px solid #ccc;margin:0 .5em;height:100%}select.svelte-9lvbl8{width:100%;padding:.5em;border:1px solid #ccc;border-radius:.5em}input[type=text].svelte-h6zyeb,select.svelte-h6zyeb{height:3em}.panel.svelte-1l9kdai{border:1px solid #ccc;padding:.25em;border-radius:5px;display:flex;gap:0;flex-wrap:wrap;border:none}.panel.svelte-1l9kdai>h3:where(.svelte-1l9kdai){background-color:#f5f5f5;padding:.25em 0;border:1px solid #ccc;margin:.25em 0}.show-button.svelte-1l9kdai{position:fixed;right:0;top:50%;height:3rem;transform:translateY(-50%);background-color:#fff;padding:.5em;border-radius:.5em 0 0 .5em;display:flex;align-items:center;justify-content:center;box-shadow:0 0 1em #0003;transition:transform .1s ease-in-out;border:1px solid #ccc}.show-button.svelte-1l9kdai:hover{transform:translateY(-50%) scale(1.1)}.show-button.svelte-1l9kdai img:where(.svelte-1l9kdai){width:2em;height:2em}.panel.svelte-1l9kdai button:where(.svelte-1l9kdai){margin:.25em 0} ');
  25.  
  26. (function () {
  27.   'use strict';
  28.  
  29.   var __defProp = Object.defineProperty;
  30.   var __typeError = (msg) => {
  31.     throw TypeError(msg);
  32.   };
  33.   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  34.   var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  35.   var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
  36.   var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
  37.   var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
  38.   var _text, _segments, _selectedText;
  39.   const DEV = false;
  40.   var is_array = Array.isArray;
  41.   var array_from = Array.from;
  42.   var define_property = Object.defineProperty;
  43.   var get_descriptor = Object.getOwnPropertyDescriptor;
  44.   var get_descriptors = Object.getOwnPropertyDescriptors;
  45.   var object_prototype = Object.prototype;
  46.   var array_prototype = Array.prototype;
  47.   var get_prototype_of = Object.getPrototypeOf;
  48.   const noop = () => {
  49.   };
  50.   function run_all(arr) {
  51.     for (var i2 = 0; i2 < arr.length; i2++) {
  52.       arr[i2]();
  53.     }
  54.   }
  55.   const DERIVED = 1 << 1;
  56.   const EFFECT = 1 << 2;
  57.   const RENDER_EFFECT = 1 << 3;
  58.   const BLOCK_EFFECT = 1 << 4;
  59.   const BRANCH_EFFECT = 1 << 5;
  60.   const ROOT_EFFECT = 1 << 6;
  61.   const UNOWNED = 1 << 7;
  62.   const DISCONNECTED = 1 << 8;
  63.   const CLEAN = 1 << 9;
  64.   const DIRTY = 1 << 10;
  65.   const MAYBE_DIRTY = 1 << 11;
  66.   const INERT = 1 << 12;
  67.   const DESTROYED = 1 << 13;
  68.   const EFFECT_RAN = 1 << 14;
  69.   const EFFECT_TRANSPARENT = 1 << 15;
  70.   const LEGACY_DERIVED_PROP = 1 << 16;
  71.   const HEAD_EFFECT = 1 << 18;
  72.   const EFFECT_HAS_DERIVED = 1 << 19;
  73.   const STATE_SYMBOL = Symbol("$state");
  74.   const LOADING_ATTR_SYMBOL = Symbol("");
  75.   function equals(value) {
  76.     return value === this.v;
  77.   }
  78.   function safe_not_equal(a2, b) {
  79.     return a2 != a2 ? b == b : a2 !== b || a2 !== null && typeof a2 === "object" || typeof a2 === "function";
  80.   }
  81.   function safe_equals(value) {
  82.     return !safe_not_equal(value, this.v);
  83.   }
  84.   function effect_in_teardown(rune) {
  85.     {
  86.       throw new Error("effect_in_teardown");
  87.     }
  88.   }
  89.   function effect_in_unowned_derived() {
  90.     {
  91.       throw new Error("effect_in_unowned_derived");
  92.     }
  93.   }
  94.   function effect_orphan(rune) {
  95.     {
  96.       throw new Error("effect_orphan");
  97.     }
  98.   }
  99.   function effect_update_depth_exceeded() {
  100.     {
  101.       throw new Error("effect_update_depth_exceeded");
  102.     }
  103.   }
  104.   function props_invalid_value(key) {
  105.     {
  106.       throw new Error("props_invalid_value");
  107.     }
  108.   }
  109.   function state_descriptors_fixed() {
  110.     {
  111.       throw new Error("state_descriptors_fixed");
  112.     }
  113.   }
  114.   function state_prototype_fixed() {
  115.     {
  116.       throw new Error("state_prototype_fixed");
  117.     }
  118.   }
  119.   function state_unsafe_local_read() {
  120.     {
  121.       throw new Error("state_unsafe_local_read");
  122.     }
  123.   }
  124.   function state_unsafe_mutation() {
  125.     {
  126.       throw new Error("state_unsafe_mutation");
  127.     }
  128.   }
  129.   function source(v) {
  130.     return {
  131.       f: 0,
  132.       // TODO ideally we could skip this altogether, but it causes type errors
  133.       v,
  134.       reactions: null,
  135.       equals,
  136.       version: 0
  137.     };
  138.   }
  139.   function state(v) {
  140.     return /* @__PURE__ */ push_derived_source(source(v));
  141.   }
  142.   // @__NO_SIDE_EFFECTS__
  143.   function mutable_source(initial_value, immutable = false) {
  144.     var _a;
  145.     const s2 = source(initial_value);
  146.     if (!immutable) {
  147.       s2.equals = safe_equals;
  148.     }
  149.     if (component_context !== null && component_context.l !== null) {
  150.       ((_a = component_context.l).s ?? (_a.s = [])).push(s2);
  151.     }
  152.     return s2;
  153.   }
  154.   // @__NO_SIDE_EFFECTS__
  155.   function push_derived_source(source2) {
  156.     if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
  157.       if (derived_sources === null) {
  158.         set_derived_sources([source2]);
  159.       } else {
  160.         derived_sources.push(source2);
  161.       }
  162.     }
  163.     return source2;
  164.   }
  165.   function set(source2, value) {
  166.     if (active_reaction !== null && is_runes() && (active_reaction.f & DERIVED) !== 0 && // If the source was created locally within the current derived, then
  167.     // we allow the mutation.
  168.     (derived_sources === null || !derived_sources.includes(source2))) {
  169.       state_unsafe_mutation();
  170.     }
  171.     if (!source2.equals(value)) {
  172.       source2.v = value;
  173.       source2.version = increment_version();
  174.       mark_reactions(source2, DIRTY);
  175.       if (is_runes() && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & BRANCH_EFFECT) === 0) {
  176.         if (new_deps !== null && new_deps.includes(source2)) {
  177.           set_signal_status(active_effect, DIRTY);
  178.           schedule_effect(active_effect);
  179.         } else {
  180.           if (untracked_writes === null) {
  181.             set_untracked_writes([source2]);
  182.           } else {
  183.             untracked_writes.push(source2);
  184.           }
  185.         }
  186.       }
  187.     }
  188.     return value;
  189.   }
  190.   function mark_reactions(signal, status) {
  191.     var reactions = signal.reactions;
  192.     if (reactions === null) return;
  193.     var runes = is_runes();
  194.     var length = reactions.length;
  195.     for (var i2 = 0; i2 < length; i2++) {
  196.       var reaction = reactions[i2];
  197.       var flags = reaction.f;
  198.       if ((flags & DIRTY) !== 0) continue;
  199.       if (!runes && reaction === active_effect) continue;
  200.       set_signal_status(reaction, status);
  201.       if ((flags & (CLEAN | UNOWNED)) !== 0) {
  202.         if ((flags & DERIVED) !== 0) {
  203.           mark_reactions(
  204.             /** @type {Derived} */
  205.             reaction,
  206.             MAYBE_DIRTY
  207.           );
  208.         } else {
  209.           schedule_effect(
  210.             /** @type {Effect} */
  211.             reaction
  212.           );
  213.         }
  214.       }
  215.     }
  216.   }
  217.   const EACH_ITEM_REACTIVE = 1;
  218.   const EACH_INDEX_REACTIVE = 1 << 1;
  219.   const EACH_IS_CONTROLLED = 1 << 2;
  220.   const EACH_IS_ANIMATED = 1 << 3;
  221.   const EACH_ITEM_IMMUTABLE = 1 << 4;
  222.   const PROPS_IS_IMMUTABLE = 1;
  223.   const PROPS_IS_RUNES = 1 << 1;
  224.   const PROPS_IS_UPDATED = 1 << 2;
  225.   const PROPS_IS_BINDABLE = 1 << 3;
  226.   const PROPS_IS_LAZY_INITIAL = 1 << 4;
  227.   const TEMPLATE_FRAGMENT = 1;
  228.   const TEMPLATE_USE_IMPORT_NODE = 1 << 1;
  229.   const UNINITIALIZED = Symbol();
  230.   let hydrating = false;
  231.   function proxy(value, parent = null, prev) {
  232.     if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
  233.       return value;
  234.     }
  235.     const prototype = get_prototype_of(value);
  236.     if (prototype !== object_prototype && prototype !== array_prototype) {
  237.       return value;
  238.     }
  239.     var sources = /* @__PURE__ */ new Map();
  240.     var is_proxied_array = is_array(value);
  241.     var version = source(0);
  242.     if (is_proxied_array) {
  243.       sources.set("length", source(
  244.         /** @type {any[]} */
  245.         value.length
  246.       ));
  247.     }
  248.     var metadata;
  249.     return new Proxy(
  250.       /** @type {any} */
  251.       value,
  252.       {
  253.         defineProperty(_, prop2, descriptor) {
  254.           if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
  255.             state_descriptors_fixed();
  256.           }
  257.           var s2 = sources.get(prop2);
  258.           if (s2 === void 0) {
  259.             s2 = source(descriptor.value);
  260.             sources.set(prop2, s2);
  261.           } else {
  262.             set(s2, proxy(descriptor.value, metadata));
  263.           }
  264.           return true;
  265.         },
  266.         deleteProperty(target, prop2) {
  267.           var s2 = sources.get(prop2);
  268.           if (s2 === void 0) {
  269.             if (prop2 in target) {
  270.               sources.set(prop2, source(UNINITIALIZED));
  271.             }
  272.           } else {
  273.             set(s2, UNINITIALIZED);
  274.             update_version(version);
  275.           }
  276.           return true;
  277.         },
  278.         get(target, prop2, receiver) {
  279.           var _a;
  280.           if (prop2 === STATE_SYMBOL) {
  281.             return value;
  282.           }
  283.           var s2 = sources.get(prop2);
  284.           var exists = prop2 in target;
  285.           if (s2 === void 0 && (!exists || ((_a = get_descriptor(target, prop2)) == null ? void 0 : _a.writable))) {
  286.             s2 = source(proxy(exists ? target[prop2] : UNINITIALIZED, metadata));
  287.             sources.set(prop2, s2);
  288.           }
  289.           if (s2 !== void 0) {
  290.             var v = get(s2);
  291.             return v === UNINITIALIZED ? void 0 : v;
  292.           }
  293.           return Reflect.get(target, prop2, receiver);
  294.         },
  295.         getOwnPropertyDescriptor(target, prop2) {
  296.           var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
  297.           if (descriptor && "value" in descriptor) {
  298.             var s2 = sources.get(prop2);
  299.             if (s2) descriptor.value = get(s2);
  300.           } else if (descriptor === void 0) {
  301.             var source2 = sources.get(prop2);
  302.             var value2 = source2 == null ? void 0 : source2.v;
  303.             if (source2 !== void 0 && value2 !== UNINITIALIZED) {
  304.               return {
  305.                 enumerable: true,
  306.                 configurable: true,
  307.                 value: value2,
  308.                 writable: true
  309.               };
  310.             }
  311.           }
  312.           return descriptor;
  313.         },
  314.         has(target, prop2) {
  315.           var _a;
  316.           if (prop2 === STATE_SYMBOL) {
  317.             return true;
  318.           }
  319.           var s2 = sources.get(prop2);
  320.           var has = s2 !== void 0 && s2.v !== UNINITIALIZED || Reflect.has(target, prop2);
  321.           if (s2 !== void 0 || active_effect !== null && (!has || ((_a = get_descriptor(target, prop2)) == null ? void 0 : _a.writable))) {
  322.             if (s2 === void 0) {
  323.               s2 = source(has ? proxy(target[prop2], metadata) : UNINITIALIZED);
  324.               sources.set(prop2, s2);
  325.             }
  326.             var value2 = get(s2);
  327.             if (value2 === UNINITIALIZED) {
  328.               return false;
  329.             }
  330.           }
  331.           return has;
  332.         },
  333.         set(target, prop2, value2, receiver) {
  334.           var _a;
  335.           var s2 = sources.get(prop2);
  336.           var has = prop2 in target;
  337.           if (is_proxied_array && prop2 === "length") {
  338.             for (var i2 = value2; i2 < /** @type {Source<number>} */
  339.             s2.v; i2 += 1) {
  340.               var other_s = sources.get(i2 + "");
  341.               if (other_s !== void 0) {
  342.                 set(other_s, UNINITIALIZED);
  343.               } else if (i2 in target) {
  344.                 other_s = source(UNINITIALIZED);
  345.                 sources.set(i2 + "", other_s);
  346.               }
  347.             }
  348.           }
  349.           if (s2 === void 0) {
  350.             if (!has || ((_a = get_descriptor(target, prop2)) == null ? void 0 : _a.writable)) {
  351.               s2 = source(void 0);
  352.               set(s2, proxy(value2, metadata));
  353.               sources.set(prop2, s2);
  354.             }
  355.           } else {
  356.             has = s2.v !== UNINITIALIZED;
  357.             set(s2, proxy(value2, metadata));
  358.           }
  359.           var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
  360.           if (descriptor == null ? void 0 : descriptor.set) {
  361.             descriptor.set.call(receiver, value2);
  362.           }
  363.           if (!has) {
  364.             if (is_proxied_array && typeof prop2 === "string") {
  365.               var ls = (
  366.                 /** @type {Source<number>} */
  367.                 sources.get("length")
  368.               );
  369.               var n2 = Number(prop2);
  370.               if (Number.isInteger(n2) && n2 >= ls.v) {
  371.                 set(ls, n2 + 1);
  372.               }
  373.             }
  374.             update_version(version);
  375.           }
  376.           return true;
  377.         },
  378.         ownKeys(target) {
  379.           get(version);
  380.           var own_keys = Reflect.ownKeys(target).filter((key2) => {
  381.             var source3 = sources.get(key2);
  382.             return source3 === void 0 || source3.v !== UNINITIALIZED;
  383.           });
  384.           for (var [key, source2] of sources) {
  385.             if (source2.v !== UNINITIALIZED && !(key in target)) {
  386.               own_keys.push(key);
  387.             }
  388.           }
  389.           return own_keys;
  390.         },
  391.         setPrototypeOf() {
  392.           state_prototype_fixed();
  393.         }
  394.       }
  395.     );
  396.   }
  397.   function update_version(signal, d2 = 1) {
  398.     set(signal, signal.v + d2);
  399.   }
  400.   function get_proxied_value(value) {
  401.     if (value !== null && typeof value === "object" && STATE_SYMBOL in value) {
  402.       return value[STATE_SYMBOL];
  403.     }
  404.     return value;
  405.   }
  406.   function is(a2, b) {
  407.     return Object.is(get_proxied_value(a2), get_proxied_value(b));
  408.   }
  409.   var $window;
  410.   var first_child_getter;
  411.   var next_sibling_getter;
  412.   function init_operations() {
  413.     if ($window !== void 0) {
  414.       return;
  415.     }
  416.     $window = window;
  417.     var element_prototype = Element.prototype;
  418.     var node_prototype = Node.prototype;
  419.     first_child_getter = get_descriptor(node_prototype, "firstChild").get;
  420.     next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
  421.     element_prototype.__click = void 0;
  422.     element_prototype.__className = "";
  423.     element_prototype.__attributes = null;
  424.     element_prototype.__e = void 0;
  425.     Text.prototype.__t = void 0;
  426.   }
  427.   function create_text(value = "") {
  428.     return document.createTextNode(value);
  429.   }
  430.   // @__NO_SIDE_EFFECTS__
  431.   function get_first_child(node) {
  432.     return first_child_getter.call(node);
  433.   }
  434.   // @__NO_SIDE_EFFECTS__
  435.   function get_next_sibling(node) {
  436.     return next_sibling_getter.call(node);
  437.   }
  438.   function child(node) {
  439.     {
  440.       return /* @__PURE__ */ get_first_child(node);
  441.     }
  442.   }
  443.   function first_child(fragment, is_text) {
  444.     {
  445.       var first = (
  446.         /** @type {DocumentFragment} */
  447.         /* @__PURE__ */ get_first_child(
  448.           /** @type {Node} */
  449.           fragment
  450.         )
  451.       );
  452.       if (first instanceof Comment && first.data === "") return /* @__PURE__ */ get_next_sibling(first);
  453.       return first;
  454.     }
  455.   }
  456.   function sibling(node, count = 1, is_text = false) {
  457.     let next_sibling = node;
  458.     while (count--) {
  459.       next_sibling = /** @type {TemplateNode} */
  460.       /* @__PURE__ */ get_next_sibling(next_sibling);
  461.     }
  462.     {
  463.       return next_sibling;
  464.     }
  465.   }
  466.   function clear_text_content(node) {
  467.     node.textContent = "";
  468.   }
  469.   function validate_effect(rune) {
  470.     if (active_effect === null && active_reaction === null) {
  471.       effect_orphan();
  472.     }
  473.     if (active_reaction !== null && (active_reaction.f & UNOWNED) !== 0) {
  474.       effect_in_unowned_derived();
  475.     }
  476.     if (is_destroying_effect) {
  477.       effect_in_teardown();
  478.     }
  479.   }
  480.   function push_effect(effect3, parent_effect) {
  481.     var parent_last = parent_effect.last;
  482.     if (parent_last === null) {
  483.       parent_effect.last = parent_effect.first = effect3;
  484.     } else {
  485.       parent_last.next = effect3;
  486.       effect3.prev = parent_last;
  487.       parent_effect.last = effect3;
  488.     }
  489.   }
  490.   function create_effect(type, fn2, sync, push2 = true) {
  491.     var is_root = (type & ROOT_EFFECT) !== 0;
  492.     var parent_effect = active_effect;
  493.     var effect3 = {
  494.       ctx: component_context,
  495.       deps: null,
  496.       nodes_start: null,
  497.       nodes_end: null,
  498.       f: type | DIRTY,
  499.       first: null,
  500.       fn: fn2,
  501.       last: null,
  502.       next: null,
  503.       parent: is_root ? null : parent_effect,
  504.       prev: null,
  505.       teardown: null,
  506.       transitions: null,
  507.       version: 0
  508.     };
  509.     if (sync) {
  510.       var previously_flushing_effect = is_flushing_effect;
  511.       try {
  512.         set_is_flushing_effect(true);
  513.         update_effect(effect3);
  514.         effect3.f |= EFFECT_RAN;
  515.       } catch (e2) {
  516.         destroy_effect(effect3);
  517.         throw e2;
  518.       } finally {
  519.         set_is_flushing_effect(previously_flushing_effect);
  520.       }
  521.     } else if (fn2 !== null) {
  522.       schedule_effect(effect3);
  523.     }
  524.     var inert = sync && effect3.deps === null && effect3.first === null && effect3.nodes_start === null && effect3.teardown === null && (effect3.f & EFFECT_HAS_DERIVED) === 0;
  525.     if (!inert && !is_root && push2) {
  526.       if (parent_effect !== null) {
  527.         push_effect(effect3, parent_effect);
  528.       }
  529.       if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
  530.         var derived2 = (
  531.           /** @type {Derived} */
  532.           active_reaction
  533.         );
  534.         (derived2.children ?? (derived2.children = [])).push(effect3);
  535.       }
  536.     }
  537.     return effect3;
  538.   }
  539.   function user_effect(fn2) {
  540.     validate_effect();
  541.     var defer = active_effect !== null && (active_effect.f & RENDER_EFFECT) !== 0 && // TODO do we actually need this? removing them changes nothing
  542.     component_context !== null && !component_context.m;
  543.     if (defer) {
  544.       var context = (
  545.         /** @type {ComponentContext} */
  546.         component_context
  547.       );
  548.       (context.e ?? (context.e = [])).push({
  549.         fn: fn2,
  550.         effect: active_effect,
  551.         reaction: active_reaction
  552.       });
  553.     } else {
  554.       var signal = effect$3(fn2);
  555.       return signal;
  556.     }
  557.   }
  558.   function effect_root(fn2) {
  559.     const effect3 = create_effect(ROOT_EFFECT, fn2, true);
  560.     return () => {
  561.       destroy_effect(effect3);
  562.     };
  563.   }
  564.   function effect$3(fn2) {
  565.     return create_effect(EFFECT, fn2, false);
  566.   }
  567.   function render_effect(fn2) {
  568.     return create_effect(RENDER_EFFECT, fn2, true);
  569.   }
  570.   function template_effect(fn2) {
  571.     return render_effect(fn2);
  572.   }
  573.   function block(fn2, flags = 0) {
  574.     return create_effect(RENDER_EFFECT | BLOCK_EFFECT | flags, fn2, true);
  575.   }
  576.   function branch(fn2, push2 = true) {
  577.     return create_effect(RENDER_EFFECT | BRANCH_EFFECT, fn2, true, push2);
  578.   }
  579.   function execute_effect_teardown(effect3) {
  580.     var teardown = effect3.teardown;
  581.     if (teardown !== null) {
  582.       const previously_destroying_effect = is_destroying_effect;
  583.       const previous_reaction = active_reaction;
  584.       set_is_destroying_effect(true);
  585.       set_active_reaction(null);
  586.       try {
  587.         teardown.call(null);
  588.       } finally {
  589.         set_is_destroying_effect(previously_destroying_effect);
  590.         set_active_reaction(previous_reaction);
  591.       }
  592.     }
  593.   }
  594.   function destroy_effect(effect3, remove_dom = true) {
  595.     var removed = false;
  596.     if ((remove_dom || (effect3.f & HEAD_EFFECT) !== 0) && effect3.nodes_start !== null) {
  597.       var node = effect3.nodes_start;
  598.       var end2 = effect3.nodes_end;
  599.       while (node !== null) {
  600.         var next = node === end2 ? null : (
  601.           /** @type {TemplateNode} */
  602.           /* @__PURE__ */ get_next_sibling(node)
  603.         );
  604.         node.remove();
  605.         node = next;
  606.       }
  607.       removed = true;
  608.     }
  609.     destroy_effect_children(effect3, remove_dom && !removed);
  610.     remove_reactions(effect3, 0);
  611.     set_signal_status(effect3, DESTROYED);
  612.     var transitions = effect3.transitions;
  613.     if (transitions !== null) {
  614.       for (const transition of transitions) {
  615.         transition.stop();
  616.       }
  617.     }
  618.     execute_effect_teardown(effect3);
  619.     var parent = effect3.parent;
  620.     if (parent !== null && parent.first !== null) {
  621.       unlink_effect(effect3);
  622.     }
  623.     effect3.next = effect3.prev = effect3.teardown = effect3.ctx = effect3.deps = effect3.parent = effect3.fn = effect3.nodes_start = effect3.nodes_end = null;
  624.   }
  625.   function unlink_effect(effect3) {
  626.     var parent = effect3.parent;
  627.     var prev = effect3.prev;
  628.     var next = effect3.next;
  629.     if (prev !== null) prev.next = next;
  630.     if (next !== null) next.prev = prev;
  631.     if (parent !== null) {
  632.       if (parent.first === effect3) parent.first = next;
  633.       if (parent.last === effect3) parent.last = prev;
  634.     }
  635.   }
  636.   function pause_effect(effect3, callback) {
  637.     var transitions = [];
  638.     pause_children(effect3, transitions, true);
  639.     run_out_transitions(transitions, () => {
  640.       destroy_effect(effect3);
  641.       if (callback) callback();
  642.     });
  643.   }
  644.   function run_out_transitions(transitions, fn2) {
  645.     var remaining = transitions.length;
  646.     if (remaining > 0) {
  647.       var check = () => --remaining || fn2();
  648.       for (var transition of transitions) {
  649.         transition.out(check);
  650.       }
  651.     } else {
  652.       fn2();
  653.     }
  654.   }
  655.   function pause_children(effect3, transitions, local) {
  656.     if ((effect3.f & INERT) !== 0) return;
  657.     effect3.f ^= INERT;
  658.     if (effect3.transitions !== null) {
  659.       for (const transition of effect3.transitions) {
  660.         if (transition.is_global || local) {
  661.           transitions.push(transition);
  662.         }
  663.       }
  664.     }
  665.     var child2 = effect3.first;
  666.     while (child2 !== null) {
  667.       var sibling2 = child2.next;
  668.       var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
  669.       pause_children(child2, transitions, transparent ? local : false);
  670.       child2 = sibling2;
  671.     }
  672.   }
  673.   function resume_effect(effect3) {
  674.     resume_children(effect3, true);
  675.   }
  676.   function resume_children(effect3, local) {
  677.     if ((effect3.f & INERT) === 0) return;
  678.     effect3.f ^= INERT;
  679.     if (check_dirtiness(effect3)) {
  680.       update_effect(effect3);
  681.     }
  682.     var child2 = effect3.first;
  683.     while (child2 !== null) {
  684.       var sibling2 = child2.next;
  685.       var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
  686.       resume_children(child2, transparent ? local : false);
  687.       child2 = sibling2;
  688.     }
  689.     if (effect3.transitions !== null) {
  690.       for (const transition of effect3.transitions) {
  691.         if (transition.is_global || local) {
  692.           transition.in();
  693.         }
  694.       }
  695.     }
  696.   }
  697.   let is_micro_task_queued$1 = false;
  698.   let current_queued_micro_tasks = [];
  699.   function process_micro_tasks() {
  700.     is_micro_task_queued$1 = false;
  701.     const tasks = current_queued_micro_tasks.slice();
  702.     current_queued_micro_tasks = [];
  703.     run_all(tasks);
  704.   }
  705.   function queue_micro_task(fn2) {
  706.     if (!is_micro_task_queued$1) {
  707.       is_micro_task_queued$1 = true;
  708.       queueMicrotask(process_micro_tasks);
  709.     }
  710.     current_queued_micro_tasks.push(fn2);
  711.   }
  712.   // @__NO_SIDE_EFFECTS__
  713.   function derived(fn2) {
  714.     let flags = DERIVED | DIRTY;
  715.     if (active_effect === null) {
  716.       flags |= UNOWNED;
  717.     } else {
  718.       active_effect.f |= EFFECT_HAS_DERIVED;
  719.     }
  720.     const signal = {
  721.       children: null,
  722.       deps: null,
  723.       equals,
  724.       f: flags,
  725.       fn: fn2,
  726.       reactions: null,
  727.       v: (
  728.         /** @type {V} */
  729.         null
  730.       ),
  731.       version: 0,
  732.       parent: active_effect
  733.     };
  734.     if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
  735.       var derived2 = (
  736.         /** @type {Derived} */
  737.         active_reaction
  738.       );
  739.       (derived2.children ?? (derived2.children = [])).push(signal);
  740.     }
  741.     return signal;
  742.   }
  743.   // @__NO_SIDE_EFFECTS__
  744.   function derived_safe_equal(fn2) {
  745.     const signal = /* @__PURE__ */ derived(fn2);
  746.     signal.equals = safe_equals;
  747.     return signal;
  748.   }
  749.   function destroy_derived_children(derived2) {
  750.     var children = derived2.children;
  751.     if (children !== null) {
  752.       derived2.children = null;
  753.       for (var i2 = 0; i2 < children.length; i2 += 1) {
  754.         var child2 = children[i2];
  755.         if ((child2.f & DERIVED) !== 0) {
  756.           destroy_derived(
  757.             /** @type {Derived} */
  758.             child2
  759.           );
  760.         } else {
  761.           destroy_effect(
  762.             /** @type {Effect} */
  763.             child2
  764.           );
  765.         }
  766.       }
  767.     }
  768.   }
  769.   function update_derived(derived2) {
  770.     var value;
  771.     var prev_active_effect = active_effect;
  772.     set_active_effect(derived2.parent);
  773.     {
  774.       try {
  775.         destroy_derived_children(derived2);
  776.         value = update_reaction(derived2);
  777.       } finally {
  778.         set_active_effect(prev_active_effect);
  779.       }
  780.     }
  781.     var status = (skip_reaction || (derived2.f & UNOWNED) !== 0) && derived2.deps !== null ? MAYBE_DIRTY : CLEAN;
  782.     set_signal_status(derived2, status);
  783.     if (!derived2.equals(value)) {
  784.       derived2.v = value;
  785.       derived2.version = increment_version();
  786.     }
  787.   }
  788.   function destroy_derived(signal) {
  789.     destroy_derived_children(signal);
  790.     remove_reactions(signal, 0);
  791.     set_signal_status(signal, DESTROYED);
  792.     signal.children = signal.deps = signal.reactions = // @ts-expect-error `signal.fn` cannot be `null` while the signal is alive
  793.     signal.fn = null;
  794.   }
  795.   function lifecycle_outside_component(name) {
  796.     {
  797.       throw new Error("lifecycle_outside_component");
  798.     }
  799.   }
  800.   let is_micro_task_queued = false;
  801.   let is_flushing_effect = false;
  802.   let is_destroying_effect = false;
  803.   function set_is_flushing_effect(value) {
  804.     is_flushing_effect = value;
  805.   }
  806.   function set_is_destroying_effect(value) {
  807.     is_destroying_effect = value;
  808.   }
  809.   let queued_root_effects = [];
  810.   let flush_count = 0;
  811.   let active_reaction = null;
  812.   function set_active_reaction(reaction) {
  813.     active_reaction = reaction;
  814.   }
  815.   let active_effect = null;
  816.   function set_active_effect(effect3) {
  817.     active_effect = effect3;
  818.   }
  819.   let derived_sources = null;
  820.   function set_derived_sources(sources) {
  821.     derived_sources = sources;
  822.   }
  823.   let new_deps = null;
  824.   let skipped_deps = 0;
  825.   let untracked_writes = null;
  826.   function set_untracked_writes(value) {
  827.     untracked_writes = value;
  828.   }
  829.   let current_version = 0;
  830.   let skip_reaction = false;
  831.   let component_context = null;
  832.   function increment_version() {
  833.     return ++current_version;
  834.   }
  835.   function is_runes() {
  836.     return component_context !== null && component_context.l === null;
  837.   }
  838.   function check_dirtiness(reaction) {
  839.     var _a, _b;
  840.     var flags = reaction.f;
  841.     if ((flags & DIRTY) !== 0) {
  842.       return true;
  843.     }
  844.     if ((flags & MAYBE_DIRTY) !== 0) {
  845.       var dependencies = reaction.deps;
  846.       var is_unowned = (flags & UNOWNED) !== 0;
  847.       if (dependencies !== null) {
  848.         var i2;
  849.         if ((flags & DISCONNECTED) !== 0) {
  850.           for (i2 = 0; i2 < dependencies.length; i2++) {
  851.             ((_a = dependencies[i2]).reactions ?? (_a.reactions = [])).push(reaction);
  852.           }
  853.           reaction.f ^= DISCONNECTED;
  854.         }
  855.         for (i2 = 0; i2 < dependencies.length; i2++) {
  856.           var dependency = dependencies[i2];
  857.           if (check_dirtiness(
  858.             /** @type {Derived} */
  859.             dependency
  860.           )) {
  861.             update_derived(
  862.               /** @type {Derived} */
  863.               dependency
  864.             );
  865.           }
  866.           if (is_unowned && active_effect !== null && !skip_reaction && !((_b = dependency == null ? void 0 : dependency.reactions) == null ? void 0 : _b.includes(reaction))) {
  867.             (dependency.reactions ?? (dependency.reactions = [])).push(reaction);
  868.           }
  869.           if (dependency.version > reaction.version) {
  870.             return true;
  871.           }
  872.         }
  873.       }
  874.       if (!is_unowned) {
  875.         set_signal_status(reaction, CLEAN);
  876.       }
  877.     }
  878.     return false;
  879.   }
  880.   function handle_error(error, effect3, component_context2) {
  881.     {
  882.       throw error;
  883.     }
  884.   }
  885.   function update_reaction(reaction) {
  886.     var _a;
  887.     var previous_deps = new_deps;
  888.     var previous_skipped_deps = skipped_deps;
  889.     var previous_untracked_writes = untracked_writes;
  890.     var previous_reaction = active_reaction;
  891.     var previous_skip_reaction = skip_reaction;
  892.     var prev_derived_sources = derived_sources;
  893.     new_deps = /** @type {null | Value[]} */
  894.     null;
  895.     skipped_deps = 0;
  896.     untracked_writes = null;
  897.     active_reaction = (reaction.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
  898.     skip_reaction = !is_flushing_effect && (reaction.f & UNOWNED) !== 0;
  899.     derived_sources = null;
  900.     try {
  901.       var result = (
  902.         /** @type {Function} */
  903.         (0, reaction.fn)()
  904.       );
  905.       var deps = reaction.deps;
  906.       if (new_deps !== null) {
  907.         var i2;
  908.         remove_reactions(reaction, skipped_deps);
  909.         if (deps !== null && skipped_deps > 0) {
  910.           deps.length = skipped_deps + new_deps.length;
  911.           for (i2 = 0; i2 < new_deps.length; i2++) {
  912.             deps[skipped_deps + i2] = new_deps[i2];
  913.           }
  914.         } else {
  915.           reaction.deps = deps = new_deps;
  916.         }
  917.         if (!skip_reaction) {
  918.           for (i2 = skipped_deps; i2 < deps.length; i2++) {
  919.             ((_a = deps[i2]).reactions ?? (_a.reactions = [])).push(reaction);
  920.           }
  921.         }
  922.       } else if (deps !== null && skipped_deps < deps.length) {
  923.         remove_reactions(reaction, skipped_deps);
  924.         deps.length = skipped_deps;
  925.       }
  926.       return result;
  927.     } finally {
  928.       new_deps = previous_deps;
  929.       skipped_deps = previous_skipped_deps;
  930.       untracked_writes = previous_untracked_writes;
  931.       active_reaction = previous_reaction;
  932.       skip_reaction = previous_skip_reaction;
  933.       derived_sources = prev_derived_sources;
  934.     }
  935.   }
  936.   function remove_reaction(signal, dependency) {
  937.     let reactions = dependency.reactions;
  938.     if (reactions !== null) {
  939.       var index2 = reactions.indexOf(signal);
  940.       if (index2 !== -1) {
  941.         var new_length = reactions.length - 1;
  942.         if (new_length === 0) {
  943.           reactions = dependency.reactions = null;
  944.         } else {
  945.           reactions[index2] = reactions[new_length];
  946.           reactions.pop();
  947.         }
  948.       }
  949.     }
  950.     if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
  951.     // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
  952.     // allows us to skip the expensive work of disconnecting and immediately reconnecting it
  953.     (new_deps === null || !new_deps.includes(dependency))) {
  954.       set_signal_status(dependency, MAYBE_DIRTY);
  955.       if ((dependency.f & (UNOWNED | DISCONNECTED)) === 0) {
  956.         dependency.f ^= DISCONNECTED;
  957.       }
  958.       remove_reactions(
  959.         /** @type {Derived} **/
  960.         dependency,
  961.         0
  962.       );
  963.     }
  964.   }
  965.   function remove_reactions(signal, start_index) {
  966.     var dependencies = signal.deps;
  967.     if (dependencies === null) return;
  968.     for (var i2 = start_index; i2 < dependencies.length; i2++) {
  969.       remove_reaction(signal, dependencies[i2]);
  970.     }
  971.   }
  972.   function destroy_effect_children(signal, remove_dom = false) {
  973.     var effect3 = signal.first;
  974.     signal.first = signal.last = null;
  975.     while (effect3 !== null) {
  976.       var next = effect3.next;
  977.       destroy_effect(effect3, remove_dom);
  978.       effect3 = next;
  979.     }
  980.   }
  981.   function update_effect(effect3) {
  982.     var flags = effect3.f;
  983.     if ((flags & DESTROYED) !== 0) {
  984.       return;
  985.     }
  986.     set_signal_status(effect3, CLEAN);
  987.     var previous_effect = active_effect;
  988.     var previous_component_context = component_context;
  989.     active_effect = effect3;
  990.     component_context = effect3.ctx;
  991.     try {
  992.       if ((flags & BLOCK_EFFECT) === 0) {
  993.         destroy_effect_children(effect3);
  994.       }
  995.       execute_effect_teardown(effect3);
  996.       var teardown = update_reaction(effect3);
  997.       effect3.teardown = typeof teardown === "function" ? teardown : null;
  998.       effect3.version = current_version;
  999.       if (DEV) ;
  1000.     } catch (error) {
  1001.       handle_error(
  1002.         /** @type {Error} */
  1003.         error
  1004.       );
  1005.     } finally {
  1006.       active_effect = previous_effect;
  1007.       component_context = previous_component_context;
  1008.     }
  1009.   }
  1010.   function infinite_loop_guard() {
  1011.     if (flush_count > 1e3) {
  1012.       flush_count = 0;
  1013.       {
  1014.         effect_update_depth_exceeded();
  1015.       }
  1016.     }
  1017.     flush_count++;
  1018.   }
  1019.   function flush_queued_root_effects(root_effects) {
  1020.     var length = root_effects.length;
  1021.     if (length === 0) {
  1022.       return;
  1023.     }
  1024.     infinite_loop_guard();
  1025.     var previously_flushing_effect = is_flushing_effect;
  1026.     is_flushing_effect = true;
  1027.     try {
  1028.       for (var i2 = 0; i2 < length; i2++) {
  1029.         var effect3 = root_effects[i2];
  1030.         if ((effect3.f & CLEAN) === 0) {
  1031.           effect3.f ^= CLEAN;
  1032.         }
  1033.         var collected_effects = [];
  1034.         process_effects(effect3, collected_effects);
  1035.         flush_queued_effects(collected_effects);
  1036.       }
  1037.     } finally {
  1038.       is_flushing_effect = previously_flushing_effect;
  1039.     }
  1040.   }
  1041.   function flush_queued_effects(effects) {
  1042.     var length = effects.length;
  1043.     if (length === 0) return;
  1044.     for (var i2 = 0; i2 < length; i2++) {
  1045.       var effect3 = effects[i2];
  1046.       if ((effect3.f & (DESTROYED | INERT)) === 0 && check_dirtiness(effect3)) {
  1047.         update_effect(effect3);
  1048.         if (effect3.deps === null && effect3.first === null && effect3.nodes_start === null) {
  1049.           if (effect3.teardown === null) {
  1050.             unlink_effect(effect3);
  1051.           } else {
  1052.             effect3.fn = null;
  1053.           }
  1054.         }
  1055.       }
  1056.     }
  1057.   }
  1058.   function process_deferred() {
  1059.     is_micro_task_queued = false;
  1060.     if (flush_count > 1001) {
  1061.       return;
  1062.     }
  1063.     const previous_queued_root_effects = queued_root_effects;
  1064.     queued_root_effects = [];
  1065.     flush_queued_root_effects(previous_queued_root_effects);
  1066.     if (!is_micro_task_queued) {
  1067.       flush_count = 0;
  1068.     }
  1069.   }
  1070.   function schedule_effect(signal) {
  1071.     {
  1072.       if (!is_micro_task_queued) {
  1073.         is_micro_task_queued = true;
  1074.         queueMicrotask(process_deferred);
  1075.       }
  1076.     }
  1077.     var effect3 = signal;
  1078.     while (effect3.parent !== null) {
  1079.       effect3 = effect3.parent;
  1080.       var flags = effect3.f;
  1081.       if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
  1082.         if ((flags & CLEAN) === 0) return;
  1083.         effect3.f ^= CLEAN;
  1084.       }
  1085.     }
  1086.     queued_root_effects.push(effect3);
  1087.   }
  1088.   function process_effects(effect3, collected_effects) {
  1089.     var current_effect = effect3.first;
  1090.     var effects = [];
  1091.     main_loop: while (current_effect !== null) {
  1092.       var flags = current_effect.f;
  1093.       var is_branch = (flags & BRANCH_EFFECT) !== 0;
  1094.       var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
  1095.       if (!is_skippable_branch && (flags & INERT) === 0) {
  1096.         if ((flags & RENDER_EFFECT) !== 0) {
  1097.           if (is_branch) {
  1098.             current_effect.f ^= CLEAN;
  1099.           } else if (check_dirtiness(current_effect)) {
  1100.             update_effect(current_effect);
  1101.           }
  1102.           var child2 = current_effect.first;
  1103.           if (child2 !== null) {
  1104.             current_effect = child2;
  1105.             continue;
  1106.           }
  1107.         } else if ((flags & EFFECT) !== 0) {
  1108.           effects.push(current_effect);
  1109.         }
  1110.       }
  1111.       var sibling2 = current_effect.next;
  1112.       if (sibling2 === null) {
  1113.         let parent = current_effect.parent;
  1114.         while (parent !== null) {
  1115.           if (effect3 === parent) {
  1116.             break main_loop;
  1117.           }
  1118.           var parent_sibling = parent.next;
  1119.           if (parent_sibling !== null) {
  1120.             current_effect = parent_sibling;
  1121.             continue main_loop;
  1122.           }
  1123.           parent = parent.parent;
  1124.         }
  1125.       }
  1126.       current_effect = sibling2;
  1127.     }
  1128.     for (var i2 = 0; i2 < effects.length; i2++) {
  1129.       child2 = effects[i2];
  1130.       collected_effects.push(child2);
  1131.       process_effects(child2, collected_effects);
  1132.     }
  1133.   }
  1134.   function get(signal) {
  1135.     var flags = signal.f;
  1136.     if ((flags & DESTROYED) !== 0) {
  1137.       return signal.v;
  1138.     }
  1139.     if (active_reaction !== null) {
  1140.       if (derived_sources !== null && derived_sources.includes(signal)) {
  1141.         state_unsafe_local_read();
  1142.       }
  1143.       var deps = active_reaction.deps;
  1144.       if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
  1145.         skipped_deps++;
  1146.       } else if (new_deps === null) {
  1147.         new_deps = [signal];
  1148.       } else {
  1149.         new_deps.push(signal);
  1150.       }
  1151.       if (untracked_writes !== null && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & BRANCH_EFFECT) === 0 && untracked_writes.includes(signal)) {
  1152.         set_signal_status(active_effect, DIRTY);
  1153.         schedule_effect(active_effect);
  1154.       }
  1155.     }
  1156.     if ((flags & DERIVED) !== 0) {
  1157.       var derived2 = (
  1158.         /** @type {Derived} */
  1159.         signal
  1160.       );
  1161.       if (check_dirtiness(derived2)) {
  1162.         update_derived(derived2);
  1163.       }
  1164.     }
  1165.     return signal.v;
  1166.   }
  1167.   function untrack(fn2) {
  1168.     const previous_reaction = active_reaction;
  1169.     try {
  1170.       active_reaction = null;
  1171.       return fn2();
  1172.     } finally {
  1173.       active_reaction = previous_reaction;
  1174.     }
  1175.   }
  1176.   const STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
  1177.   function set_signal_status(signal, status) {
  1178.     signal.f = signal.f & STATUS_MASK | status;
  1179.   }
  1180.   function getContext(key) {
  1181.     const context_map = get_or_init_context_map();
  1182.     const result = (
  1183.       /** @type {T} */
  1184.       context_map.get(key)
  1185.     );
  1186.     return result;
  1187.   }
  1188.   function setContext(key, context) {
  1189.     const context_map = get_or_init_context_map();
  1190.     context_map.set(key, context);
  1191.     return context;
  1192.   }
  1193.   function get_or_init_context_map(name) {
  1194.     if (component_context === null) {
  1195.       lifecycle_outside_component();
  1196.     }
  1197.     return component_context.c ?? (component_context.c = new Map(get_parent_context(component_context) || void 0));
  1198.   }
  1199.   function get_parent_context(component_context2) {
  1200.     let parent = component_context2.p;
  1201.     while (parent !== null) {
  1202.       const context_map = parent.c;
  1203.       if (context_map !== null) {
  1204.         return context_map;
  1205.       }
  1206.       parent = parent.p;
  1207.     }
  1208.     return null;
  1209.   }
  1210.   function push(props, runes = false, fn2) {
  1211.     component_context = {
  1212.       p: component_context,
  1213.       c: null,
  1214.       e: null,
  1215.       m: false,
  1216.       s: props,
  1217.       x: null,
  1218.       l: null
  1219.     };
  1220.     if (!runes) {
  1221.       component_context.l = {
  1222.         s: null,
  1223.         u: null,
  1224.         r1: [],
  1225.         r2: source(false)
  1226.       };
  1227.     }
  1228.   }
  1229.   function pop(component) {
  1230.     const context_stack_item = component_context;
  1231.     if (context_stack_item !== null) {
  1232.       const component_effects = context_stack_item.e;
  1233.       if (component_effects !== null) {
  1234.         var previous_effect = active_effect;
  1235.         var previous_reaction = active_reaction;
  1236.         context_stack_item.e = null;
  1237.         try {
  1238.           for (var i2 = 0; i2 < component_effects.length; i2++) {
  1239.             var component_effect = component_effects[i2];
  1240.             set_active_effect(component_effect.effect);
  1241.             set_active_reaction(component_effect.reaction);
  1242.             effect$3(component_effect.fn);
  1243.           }
  1244.         } finally {
  1245.           set_active_effect(previous_effect);
  1246.           set_active_reaction(previous_reaction);
  1247.         }
  1248.       }
  1249.       component_context = context_stack_item.p;
  1250.       context_stack_item.m = true;
  1251.     }
  1252.     return (
  1253.       /** @type {T} */
  1254.       {}
  1255.     );
  1256.   }
  1257.   const all_registered_events = /* @__PURE__ */ new Set();
  1258.   const root_event_handles = /* @__PURE__ */ new Set();
  1259.   function delegate(events) {
  1260.     for (var i2 = 0; i2 < events.length; i2++) {
  1261.       all_registered_events.add(events[i2]);
  1262.     }
  1263.     for (var fn2 of root_event_handles) {
  1264.       fn2(events);
  1265.     }
  1266.   }
  1267.   function handle_event_propagation(event) {
  1268.     var _a;
  1269.     var handler_element = this;
  1270.     var owner_document = (
  1271.       /** @type {Node} */
  1272.       handler_element.ownerDocument
  1273.     );
  1274.     var event_name = event.type;
  1275.     var path = ((_a = event.composedPath) == null ? void 0 : _a.call(event)) || [];
  1276.     var current_target = (
  1277.       /** @type {null | Element} */
  1278.       path[0] || event.target
  1279.     );
  1280.     var path_idx = 0;
  1281.     var handled_at = event.__root;
  1282.     if (handled_at) {
  1283.       var at_idx = path.indexOf(handled_at);
  1284.       if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
  1285.       window)) {
  1286.         event.__root = handler_element;
  1287.         return;
  1288.       }
  1289.       var handler_idx = path.indexOf(handler_element);
  1290.       if (handler_idx === -1) {
  1291.         return;
  1292.       }
  1293.       if (at_idx <= handler_idx) {
  1294.         path_idx = at_idx;
  1295.       }
  1296.     }
  1297.     current_target = /** @type {Element} */
  1298.     path[path_idx] || event.target;
  1299.     if (current_target === handler_element) return;
  1300.     define_property(event, "currentTarget", {
  1301.       configurable: true,
  1302.       get() {
  1303.         return current_target || owner_document;
  1304.       }
  1305.     });
  1306.     try {
  1307.       var throw_error;
  1308.       var other_errors = [];
  1309.       while (current_target !== null) {
  1310.         var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
  1311.         current_target.host || null;
  1312.         try {
  1313.           var delegated = current_target["__" + event_name];
  1314.           if (delegated !== void 0 && !/** @type {any} */
  1315.           current_target.disabled) {
  1316.             if (is_array(delegated)) {
  1317.               var [fn2, ...data] = delegated;
  1318.               fn2.apply(current_target, [event, ...data]);
  1319.             } else {
  1320.               delegated.call(current_target, event);
  1321.             }
  1322.           }
  1323.         } catch (error) {
  1324.           if (throw_error) {
  1325.             other_errors.push(error);
  1326.           } else {
  1327.             throw_error = error;
  1328.           }
  1329.         }
  1330.         if (event.cancelBubble || parent_element === handler_element || parent_element === null) {
  1331.           break;
  1332.         }
  1333.         current_target = parent_element;
  1334.       }
  1335.       if (throw_error) {
  1336.         for (let error of other_errors) {
  1337.           queueMicrotask(() => {
  1338.             throw error;
  1339.           });
  1340.         }
  1341.         throw throw_error;
  1342.       }
  1343.     } finally {
  1344.       event.__root = handler_element;
  1345.       delete event.currentTarget;
  1346.     }
  1347.   }
  1348.   function create_fragment_from_html(html) {
  1349.     var elem = document.createElement("template");
  1350.     elem.innerHTML = html;
  1351.     return elem.content;
  1352.   }
  1353.   function assign_nodes(start2, end2) {
  1354.     var effect3 = (
  1355.       /** @type {Effect} */
  1356.       active_effect
  1357.     );
  1358.     if (effect3.nodes_start === null) {
  1359.       effect3.nodes_start = start2;
  1360.       effect3.nodes_end = end2;
  1361.     }
  1362.   }
  1363.   // @__NO_SIDE_EFFECTS__
  1364.   function template(content, flags) {
  1365.     var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
  1366.     var use_import_node = (flags & TEMPLATE_USE_IMPORT_NODE) !== 0;
  1367.     var node;
  1368.     var has_start = !content.startsWith("<!>");
  1369.     return () => {
  1370.       if (node === void 0) {
  1371.         node = create_fragment_from_html(has_start ? content : "<!>" + content);
  1372.         if (!is_fragment) node = /** @type {Node} */
  1373.         /* @__PURE__ */ get_first_child(node);
  1374.       }
  1375.       var clone = (
  1376.         /** @type {TemplateNode} */
  1377.         use_import_node ? document.importNode(node, true) : node.cloneNode(true)
  1378.       );
  1379.       if (is_fragment) {
  1380.         var start2 = (
  1381.           /** @type {TemplateNode} */
  1382.           /* @__PURE__ */ get_first_child(clone)
  1383.         );
  1384.         var end2 = (
  1385.           /** @type {TemplateNode} */
  1386.           clone.lastChild
  1387.         );
  1388.         assign_nodes(start2, end2);
  1389.       } else {
  1390.         assign_nodes(clone, clone);
  1391.       }
  1392.       return clone;
  1393.     };
  1394.   }
  1395.   function comment() {
  1396.     var frag = document.createDocumentFragment();
  1397.     var start2 = document.createComment("");
  1398.     var anchor = create_text();
  1399.     frag.append(start2, anchor);
  1400.     assign_nodes(start2, anchor);
  1401.     return frag;
  1402.   }
  1403.   function append(anchor, dom) {
  1404.     if (anchor === null) {
  1405.       return;
  1406.     }
  1407.     anchor.before(
  1408.       /** @type {Node} */
  1409.       dom
  1410.     );
  1411.   }
  1412.   const PASSIVE_EVENTS = ["touchstart", "touchmove"];
  1413.   function is_passive_event(name) {
  1414.     return PASSIVE_EVENTS.includes(name);
  1415.   }
  1416.   function set_text(text, value) {
  1417.     var str = value == null ? "" : typeof value === "object" ? value + "" : value;
  1418.     if (str !== (text.__t ?? (text.__t = text.nodeValue))) {
  1419.       text.__t = str;
  1420.       text.nodeValue = str == null ? "" : str + "";
  1421.     }
  1422.   }
  1423.   function mount(component, options) {
  1424.     return _mount(component, options);
  1425.   }
  1426.   const document_listeners = /* @__PURE__ */ new Map();
  1427.   function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
  1428.     init_operations();
  1429.     var registered_events = /* @__PURE__ */ new Set();
  1430.     var event_handle = (events2) => {
  1431.       for (var i2 = 0; i2 < events2.length; i2++) {
  1432.         var event_name = events2[i2];
  1433.         if (registered_events.has(event_name)) continue;
  1434.         registered_events.add(event_name);
  1435.         var passive2 = is_passive_event(event_name);
  1436.         target.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
  1437.         var n2 = document_listeners.get(event_name);
  1438.         if (n2 === void 0) {
  1439.           document.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
  1440.           document_listeners.set(event_name, 1);
  1441.         } else {
  1442.           document_listeners.set(event_name, n2 + 1);
  1443.         }
  1444.       }
  1445.     };
  1446.     event_handle(array_from(all_registered_events));
  1447.     root_event_handles.add(event_handle);
  1448.     var component = void 0;
  1449.     var unmount = effect_root(() => {
  1450.       var anchor_node = anchor ?? target.appendChild(create_text());
  1451.       branch(() => {
  1452.         if (context) {
  1453.           push({});
  1454.           var ctx = (
  1455.             /** @type {ComponentContext} */
  1456.             component_context
  1457.           );
  1458.           ctx.c = context;
  1459.         }
  1460.         if (events) {
  1461.           props.$$events = events;
  1462.         }
  1463.         component = Component(anchor_node, props) || {};
  1464.         if (context) {
  1465.           pop();
  1466.         }
  1467.       });
  1468.       return () => {
  1469.         var _a;
  1470.         for (var event_name of registered_events) {
  1471.           target.removeEventListener(event_name, handle_event_propagation);
  1472.           var n2 = (
  1473.             /** @type {number} */
  1474.             document_listeners.get(event_name)
  1475.           );
  1476.           if (--n2 === 0) {
  1477.             document.removeEventListener(event_name, handle_event_propagation);
  1478.             document_listeners.delete(event_name);
  1479.           } else {
  1480.             document_listeners.set(event_name, n2);
  1481.           }
  1482.         }
  1483.         root_event_handles.delete(event_handle);
  1484.         mounted_components.delete(component);
  1485.         if (anchor_node !== anchor) {
  1486.           (_a = anchor_node.parentNode) == null ? void 0 : _a.removeChild(anchor_node);
  1487.         }
  1488.       };
  1489.     });
  1490.     mounted_components.set(component, unmount);
  1491.     return component;
  1492.   }
  1493.   let mounted_components = /* @__PURE__ */ new WeakMap();
  1494.   function if_block(node, get_condition, consequent_fn, alternate_fn = null, elseif = false) {
  1495.     var anchor = node;
  1496.     var consequent_effect = null;
  1497.     var alternate_effect = null;
  1498.     var condition = null;
  1499.     var flags = elseif ? EFFECT_TRANSPARENT : 0;
  1500.     block(() => {
  1501.       if (condition === (condition = !!get_condition())) return;
  1502.       if (condition) {
  1503.         if (consequent_effect) {
  1504.           resume_effect(consequent_effect);
  1505.         } else {
  1506.           consequent_effect = branch(() => consequent_fn(anchor));
  1507.         }
  1508.         if (alternate_effect) {
  1509.           pause_effect(alternate_effect, () => {
  1510.             alternate_effect = null;
  1511.           });
  1512.         }
  1513.       } else {
  1514.         if (alternate_effect) {
  1515.           resume_effect(alternate_effect);
  1516.         } else if (alternate_fn) {
  1517.           alternate_effect = branch(() => alternate_fn(anchor));
  1518.         }
  1519.         if (consequent_effect) {
  1520.           pause_effect(consequent_effect, () => {
  1521.             consequent_effect = null;
  1522.           });
  1523.         }
  1524.       }
  1525.     }, flags);
  1526.   }
  1527.   let current_each_item = null;
  1528.   function index(_, i2) {
  1529.     return i2;
  1530.   }
  1531.   function pause_effects(state2, items, controlled_anchor, items_map) {
  1532.     var transitions = [];
  1533.     var length = items.length;
  1534.     for (var i2 = 0; i2 < length; i2++) {
  1535.       pause_children(items[i2].e, transitions, true);
  1536.     }
  1537.     var is_controlled = length > 0 && transitions.length === 0 && controlled_anchor !== null;
  1538.     if (is_controlled) {
  1539.       var parent_node = (
  1540.         /** @type {Element} */
  1541.         /** @type {Element} */
  1542.         controlled_anchor.parentNode
  1543.       );
  1544.       clear_text_content(parent_node);
  1545.       parent_node.append(
  1546.         /** @type {Element} */
  1547.         controlled_anchor
  1548.       );
  1549.       items_map.clear();
  1550.       link(state2, items[0].prev, items[length - 1].next);
  1551.     }
  1552.     run_out_transitions(transitions, () => {
  1553.       for (var i3 = 0; i3 < length; i3++) {
  1554.         var item = items[i3];
  1555.         if (!is_controlled) {
  1556.           items_map.delete(item.k);
  1557.           link(state2, item.prev, item.next);
  1558.         }
  1559.         destroy_effect(item.e, !is_controlled);
  1560.       }
  1561.     });
  1562.   }
  1563.   function each(node, flags, get_collection, get_key, render_fn, fallback_fn = null) {
  1564.     var anchor = node;
  1565.     var state2 = { flags, items: /* @__PURE__ */ new Map(), first: null };
  1566.     var is_controlled = (flags & EACH_IS_CONTROLLED) !== 0;
  1567.     if (is_controlled) {
  1568.       var parent_node = (
  1569.         /** @type {Element} */
  1570.         node
  1571.       );
  1572.       anchor = parent_node.appendChild(create_text());
  1573.     }
  1574.     var fallback = null;
  1575.     block(() => {
  1576.       var collection = get_collection();
  1577.       var array = is_array(collection) ? collection : collection == null ? [] : array_from(collection);
  1578.       var length = array.length;
  1579.       {
  1580.         reconcile(array, state2, anchor, render_fn, flags, get_key);
  1581.       }
  1582.       if (fallback_fn !== null) {
  1583.         if (length === 0) {
  1584.           if (fallback) {
  1585.             resume_effect(fallback);
  1586.           } else {
  1587.             fallback = branch(() => fallback_fn(anchor));
  1588.           }
  1589.         } else if (fallback !== null) {
  1590.           pause_effect(fallback, () => {
  1591.             fallback = null;
  1592.           });
  1593.         }
  1594.       }
  1595.     });
  1596.   }
  1597.   function reconcile(array, state2, anchor, render_fn, flags, get_key) {
  1598.     var _a, _b, _c, _d;
  1599.     var is_animated = (flags & EACH_IS_ANIMATED) !== 0;
  1600.     var should_update = (flags & (EACH_ITEM_REACTIVE | EACH_INDEX_REACTIVE)) !== 0;
  1601.     var length = array.length;
  1602.     var items = state2.items;
  1603.     var first = state2.first;
  1604.     var current = first;
  1605.     var seen;
  1606.     var prev = null;
  1607.     var to_animate;
  1608.     var matched = [];
  1609.     var stashed = [];
  1610.     var value;
  1611.     var key;
  1612.     var item;
  1613.     var i2;
  1614.     if (is_animated) {
  1615.       for (i2 = 0; i2 < length; i2 += 1) {
  1616.         value = array[i2];
  1617.         key = get_key(value, i2);
  1618.         item = items.get(key);
  1619.         if (item !== void 0) {
  1620.           (_a = item.a) == null ? void 0 : _a.measure();
  1621.           (to_animate ?? (to_animate = /* @__PURE__ */ new Set())).add(item);
  1622.         }
  1623.       }
  1624.     }
  1625.     for (i2 = 0; i2 < length; i2 += 1) {
  1626.       value = array[i2];
  1627.       key = get_key(value, i2);
  1628.       item = items.get(key);
  1629.       if (item === void 0) {
  1630.         var child_anchor = current ? (
  1631.           /** @type {TemplateNode} */
  1632.           current.e.nodes_start
  1633.         ) : anchor;
  1634.         prev = create_item(
  1635.           child_anchor,
  1636.           state2,
  1637.           prev,
  1638.           prev === null ? state2.first : prev.next,
  1639.           value,
  1640.           key,
  1641.           i2,
  1642.           render_fn,
  1643.           flags
  1644.         );
  1645.         items.set(key, prev);
  1646.         matched = [];
  1647.         stashed = [];
  1648.         current = prev.next;
  1649.         continue;
  1650.       }
  1651.       if (should_update) {
  1652.         update_item(item, value, i2, flags);
  1653.       }
  1654.       if ((item.e.f & INERT) !== 0) {
  1655.         resume_effect(item.e);
  1656.         if (is_animated) {
  1657.           (_b = item.a) == null ? void 0 : _b.unfix();
  1658.           (to_animate ?? (to_animate = /* @__PURE__ */ new Set())).delete(item);
  1659.         }
  1660.       }
  1661.       if (item !== current) {
  1662.         if (seen !== void 0 && seen.has(item)) {
  1663.           if (matched.length < stashed.length) {
  1664.             var start2 = stashed[0];
  1665.             var j;
  1666.             prev = start2.prev;
  1667.             var a2 = matched[0];
  1668.             var b = matched[matched.length - 1];
  1669.             for (j = 0; j < matched.length; j += 1) {
  1670.               move(matched[j], start2, anchor);
  1671.             }
  1672.             for (j = 0; j < stashed.length; j += 1) {
  1673.               seen.delete(stashed[j]);
  1674.             }
  1675.             link(state2, a2.prev, b.next);
  1676.             link(state2, prev, a2);
  1677.             link(state2, b, start2);
  1678.             current = start2;
  1679.             prev = b;
  1680.             i2 -= 1;
  1681.             matched = [];
  1682.             stashed = [];
  1683.           } else {
  1684.             seen.delete(item);
  1685.             move(item, current, anchor);
  1686.             link(state2, item.prev, item.next);
  1687.             link(state2, item, prev === null ? state2.first : prev.next);
  1688.             link(state2, prev, item);
  1689.             prev = item;
  1690.           }
  1691.           continue;
  1692.         }
  1693.         matched = [];
  1694.         stashed = [];
  1695.         while (current !== null && current.k !== key) {
  1696.           if ((current.e.f & INERT) === 0) {
  1697.             (seen ?? (seen = /* @__PURE__ */ new Set())).add(current);
  1698.           }
  1699.           stashed.push(current);
  1700.           current = current.next;
  1701.         }
  1702.         if (current === null) {
  1703.           continue;
  1704.         }
  1705.         item = current;
  1706.       }
  1707.       matched.push(item);
  1708.       prev = item;
  1709.       current = item.next;
  1710.     }
  1711.     if (current !== null || seen !== void 0) {
  1712.       var to_destroy = seen === void 0 ? [] : array_from(seen);
  1713.       while (current !== null) {
  1714.         if ((current.e.f & INERT) === 0) {
  1715.           to_destroy.push(current);
  1716.         }
  1717.         current = current.next;
  1718.       }
  1719.       var destroy_length = to_destroy.length;
  1720.       if (destroy_length > 0) {
  1721.         var controlled_anchor = (flags & EACH_IS_CONTROLLED) !== 0 && length === 0 ? anchor : null;
  1722.         if (is_animated) {
  1723.           for (i2 = 0; i2 < destroy_length; i2 += 1) {
  1724.             (_c = to_destroy[i2].a) == null ? void 0 : _c.measure();
  1725.           }
  1726.           for (i2 = 0; i2 < destroy_length; i2 += 1) {
  1727.             (_d = to_destroy[i2].a) == null ? void 0 : _d.fix();
  1728.           }
  1729.         }
  1730.         pause_effects(state2, to_destroy, controlled_anchor, items);
  1731.       }
  1732.     }
  1733.     if (is_animated) {
  1734.       queue_micro_task(() => {
  1735.         var _a2;
  1736.         if (to_animate === void 0) return;
  1737.         for (item of to_animate) {
  1738.           (_a2 = item.a) == null ? void 0 : _a2.apply();
  1739.         }
  1740.       });
  1741.     }
  1742.     active_effect.first = state2.first && state2.first.e;
  1743.     active_effect.last = prev && prev.e;
  1744.   }
  1745.   function update_item(item, value, index2, type) {
  1746.     if ((type & EACH_ITEM_REACTIVE) !== 0) {
  1747.       set(item.v, value);
  1748.     }
  1749.     if ((type & EACH_INDEX_REACTIVE) !== 0) {
  1750.       set(
  1751.         /** @type {Value<number>} */
  1752.         item.i,
  1753.         index2
  1754.       );
  1755.     } else {
  1756.       item.i = index2;
  1757.     }
  1758.   }
  1759.   function create_item(anchor, state2, prev, next, value, key, index2, render_fn, flags) {
  1760.     var previous_each_item = current_each_item;
  1761.     try {
  1762.       var reactive = (flags & EACH_ITEM_REACTIVE) !== 0;
  1763.       var mutable = (flags & EACH_ITEM_IMMUTABLE) === 0;
  1764.       var v = reactive ? mutable ? /* @__PURE__ */ mutable_source(value) : source(value) : value;
  1765.       var i2 = (flags & EACH_INDEX_REACTIVE) === 0 ? index2 : source(index2);
  1766.       var item = {
  1767.         i: i2,
  1768.         v,
  1769.         k: key,
  1770.         a: null,
  1771.         // @ts-expect-error
  1772.         e: null,
  1773.         prev,
  1774.         next
  1775.       };
  1776.       current_each_item = item;
  1777.       item.e = branch(() => render_fn(anchor, v, i2), hydrating);
  1778.       item.e.prev = prev && prev.e;
  1779.       item.e.next = next && next.e;
  1780.       if (prev === null) {
  1781.         state2.first = item;
  1782.       } else {
  1783.         prev.next = item;
  1784.         prev.e.next = item.e;
  1785.       }
  1786.       if (next !== null) {
  1787.         next.prev = item;
  1788.         next.e.prev = item.e;
  1789.       }
  1790.       return item;
  1791.     } finally {
  1792.       current_each_item = previous_each_item;
  1793.     }
  1794.   }
  1795.   function move(item, next, anchor) {
  1796.     var end2 = item.next ? (
  1797.       /** @type {TemplateNode} */
  1798.       item.next.e.nodes_start
  1799.     ) : anchor;
  1800.     var dest = next ? (
  1801.       /** @type {TemplateNode} */
  1802.       next.e.nodes_start
  1803.     ) : anchor;
  1804.     var node = (
  1805.       /** @type {TemplateNode} */
  1806.       item.e.nodes_start
  1807.     );
  1808.     while (node !== end2) {
  1809.       var next_node = (
  1810.         /** @type {TemplateNode} */
  1811.         /* @__PURE__ */ get_next_sibling(node)
  1812.       );
  1813.       dest.before(node);
  1814.       node = next_node;
  1815.     }
  1816.   }
  1817.   function link(state2, prev, next) {
  1818.     if (prev === null) {
  1819.       state2.first = next;
  1820.     } else {
  1821.       prev.next = next;
  1822.       prev.e.next = next && next.e;
  1823.     }
  1824.     if (next !== null) {
  1825.       next.prev = prev;
  1826.       next.e.prev = prev && prev.e;
  1827.     }
  1828.   }
  1829.   function snippet(node, get_snippet, ...args) {
  1830.     var anchor = node;
  1831.     var snippet2 = noop;
  1832.     var snippet_effect;
  1833.     block(() => {
  1834.       if (snippet2 === (snippet2 = get_snippet())) return;
  1835.       if (snippet_effect) {
  1836.         destroy_effect(snippet_effect);
  1837.         snippet_effect = null;
  1838.       }
  1839.       snippet_effect = branch(() => (
  1840.         /** @type {SnippetFn} */
  1841.         snippet2(anchor, ...args)
  1842.       ));
  1843.     }, EFFECT_TRANSPARENT);
  1844.   }
  1845.   function action(dom, action2, get_value) {
  1846.     effect$3(() => {
  1847.       var payload = untrack(() => action2(dom, get_value == null ? void 0 : get_value()) || {});
  1848.       if (payload == null ? void 0 : payload.destroy) {
  1849.         return () => (
  1850.           /** @type {Function} */
  1851.           payload.destroy()
  1852.         );
  1853.       }
  1854.     });
  1855.   }
  1856.   let listening_to_form_reset = false;
  1857.   function add_form_reset_listener() {
  1858.     if (!listening_to_form_reset) {
  1859.       listening_to_form_reset = true;
  1860.       document.addEventListener(
  1861.         "reset",
  1862.         (evt) => {
  1863.           Promise.resolve().then(() => {
  1864.             var _a;
  1865.             if (!evt.defaultPrevented) {
  1866.               for (
  1867.                 const e2 of
  1868.                 /**@type {HTMLFormElement} */
  1869.                 evt.target.elements
  1870.               ) {
  1871.                 (_a = e2.__on_r) == null ? void 0 : _a.call(e2);
  1872.               }
  1873.             }
  1874.           });
  1875.         },
  1876.         // In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
  1877.         { capture: true }
  1878.       );
  1879.     }
  1880.   }
  1881.   function set_attribute(element, attribute, value, skip_warning) {
  1882.     var attributes = element.__attributes ?? (element.__attributes = {});
  1883.     if (attributes[attribute] === (attributes[attribute] = value)) return;
  1884.     if (attribute === "loading") {
  1885.       element[LOADING_ATTR_SYMBOL] = value;
  1886.     }
  1887.     if (value == null) {
  1888.       element.removeAttribute(attribute);
  1889.     } else if (typeof value !== "string" && get_setters(element).includes(attribute)) {
  1890.       element[attribute] = value;
  1891.     } else {
  1892.       element.setAttribute(attribute, value);
  1893.     }
  1894.   }
  1895.   var setters_cache = /* @__PURE__ */ new Map();
  1896.   function get_setters(element) {
  1897.     var setters = setters_cache.get(element.nodeName);
  1898.     if (setters) return setters;
  1899.     setters_cache.set(element.nodeName, setters = []);
  1900.     var descriptors;
  1901.     var proto = get_prototype_of(element);
  1902.     while (proto.constructor.name !== "Element") {
  1903.       descriptors = get_descriptors(proto);
  1904.       for (var key in descriptors) {
  1905.         if (descriptors[key].set) {
  1906.           setters.push(key);
  1907.         }
  1908.       }
  1909.       proto = get_prototype_of(proto);
  1910.     }
  1911.     return setters;
  1912.   }
  1913.   function toggle_class(dom, class_name, value) {
  1914.     if (value) {
  1915.       if (dom.classList.contains(class_name)) return;
  1916.       dom.classList.add(class_name);
  1917.     } else {
  1918.       if (!dom.classList.contains(class_name)) return;
  1919.       dom.classList.remove(class_name);
  1920.     }
  1921.   }
  1922.   function listen_to_event_and_reset_event(element, event, handler, on_reset = handler) {
  1923.     element.addEventListener(event, handler);
  1924.     const prev = element.__on_r;
  1925.     if (prev) {
  1926.       element.__on_r = () => {
  1927.         prev();
  1928.         on_reset();
  1929.       };
  1930.     } else {
  1931.       element.__on_r = on_reset;
  1932.     }
  1933.     add_form_reset_listener();
  1934.   }
  1935.   function bind_value(input, get2, set2 = get2) {
  1936.     var runes = is_runes();
  1937.     listen_to_event_and_reset_event(input, "input", () => {
  1938.       var value = is_numberlike_input(input) ? to_number(input.value) : input.value;
  1939.       set2(value);
  1940.       if (runes && value !== (value = get2())) {
  1941.         input.value = value ?? "";
  1942.       }
  1943.     });
  1944.     render_effect(() => {
  1945.       var value = get2();
  1946.       if (is_numberlike_input(input) && value === to_number(input.value)) {
  1947.         return;
  1948.       }
  1949.       if (input.type === "date" && !value && !input.value) {
  1950.         return;
  1951.       }
  1952.       input.value = value ?? "";
  1953.     });
  1954.   }
  1955.   function bind_checked(input, get2, set2 = get2) {
  1956.     listen_to_event_and_reset_event(input, "change", () => {
  1957.       var value = input.checked;
  1958.       set2(value);
  1959.     });
  1960.     if (get2() == void 0) {
  1961.       set2(false);
  1962.     }
  1963.     render_effect(() => {
  1964.       var value = get2();
  1965.       input.checked = Boolean(value);
  1966.     });
  1967.   }
  1968.   function is_numberlike_input(input) {
  1969.     var type = input.type;
  1970.     return type === "number" || type === "range";
  1971.   }
  1972.   function to_number(value) {
  1973.     return value === "" ? null : +value;
  1974.   }
  1975.   function select_option(select, value, mounting) {
  1976.     if (select.multiple) {
  1977.       return select_options(select, value);
  1978.     }
  1979.     for (var option of select.options) {
  1980.       var option_value = get_option_value(option);
  1981.       if (is(option_value, value)) {
  1982.         option.selected = true;
  1983.         return;
  1984.       }
  1985.     }
  1986.     if (!mounting || value !== void 0) {
  1987.       select.selectedIndex = -1;
  1988.     }
  1989.   }
  1990.   function init_select(select, get_value) {
  1991.     effect$3(() => {
  1992.       var observer = new MutationObserver(() => {
  1993.         var value = select.__value;
  1994.         select_option(select, value);
  1995.       });
  1996.       observer.observe(select, {
  1997.         // Listen to option element changes
  1998.         childList: true,
  1999.         subtree: true,
  2000.         // because of <optgroup>
  2001.         // Listen to option element value attribute changes
  2002.         // (doesn't get notified of select value changes,
  2003.         // because that property is not reflected as an attribute)
  2004.         attributes: true,
  2005.         attributeFilter: ["value"]
  2006.       });
  2007.       return () => {
  2008.         observer.disconnect();
  2009.       };
  2010.     });
  2011.   }
  2012.   function bind_select_value(select, get2, set2 = get2) {
  2013.     var mounting = true;
  2014.     listen_to_event_and_reset_event(select, "change", () => {
  2015.       var value;
  2016.       if (select.multiple) {
  2017.         value = [].map.call(select.querySelectorAll(":checked"), get_option_value);
  2018.       } else {
  2019.         var selected_option = select.querySelector(":checked");
  2020.         value = selected_option && get_option_value(selected_option);
  2021.       }
  2022.       set2(value);
  2023.     });
  2024.     effect$3(() => {
  2025.       var value = get2();
  2026.       select_option(select, value, mounting);
  2027.       if (mounting && value === void 0) {
  2028.         var selected_option = select.querySelector(":checked");
  2029.         if (selected_option !== null) {
  2030.           value = get_option_value(selected_option);
  2031.           set2(value);
  2032.         }
  2033.       }
  2034.       select.__value = value;
  2035.       mounting = false;
  2036.     });
  2037.     init_select(select);
  2038.   }
  2039.   function select_options(select, value) {
  2040.     for (var option of select.options) {
  2041.       option.selected = ~value.indexOf(get_option_value(option));
  2042.     }
  2043.   }
  2044.   function get_option_value(option) {
  2045.     if ("__value" in option) {
  2046.       return option.__value;
  2047.     } else {
  2048.       return option.value;
  2049.     }
  2050.   }
  2051.   function is_bound_this(bound_value, element_or_component) {
  2052.     return bound_value === element_or_component || (bound_value == null ? void 0 : bound_value[STATE_SYMBOL]) === element_or_component;
  2053.   }
  2054.   function bind_this(element_or_component = {}, update, get_value, get_parts) {
  2055.     effect$3(() => {
  2056.       var old_parts;
  2057.       var parts;
  2058.       render_effect(() => {
  2059.         old_parts = parts;
  2060.         parts = [];
  2061.         untrack(() => {
  2062.           if (element_or_component !== get_value(...parts)) {
  2063.             update(element_or_component, ...parts);
  2064.             if (old_parts && is_bound_this(get_value(...old_parts), element_or_component)) {
  2065.               update(null, ...old_parts);
  2066.             }
  2067.           }
  2068.         });
  2069.       });
  2070.       return () => {
  2071.         queue_micro_task(() => {
  2072.           if (parts && is_bound_this(get_value(...parts), element_or_component)) {
  2073.             update(null, ...parts);
  2074.           }
  2075.         });
  2076.       };
  2077.     });
  2078.     return element_or_component;
  2079.   }
  2080.   function prop(props, key, flags, fallback) {
  2081.     var _a;
  2082.     var immutable = (flags & PROPS_IS_IMMUTABLE) !== 0;
  2083.     var runes = (flags & PROPS_IS_RUNES) !== 0;
  2084.     var bindable = (flags & PROPS_IS_BINDABLE) !== 0;
  2085.     var lazy = (flags & PROPS_IS_LAZY_INITIAL) !== 0;
  2086.     var prop_value = (
  2087.       /** @type {V} */
  2088.       props[key]
  2089.     );
  2090.     var setter = (_a = get_descriptor(props, key)) == null ? void 0 : _a.set;
  2091.     var fallback_value = (
  2092.       /** @type {V} */
  2093.       fallback
  2094.     );
  2095.     var fallback_dirty = true;
  2096.     var fallback_used = false;
  2097.     var get_fallback = () => {
  2098.       fallback_used = true;
  2099.       if (fallback_dirty) {
  2100.         fallback_dirty = false;
  2101.         if (lazy) {
  2102.           fallback_value = untrack(
  2103.             /** @type {() => V} */
  2104.             fallback
  2105.           );
  2106.         } else {
  2107.           fallback_value = /** @type {V} */
  2108.           fallback;
  2109.         }
  2110.       }
  2111.       return fallback_value;
  2112.     };
  2113.     if (prop_value === void 0 && fallback !== void 0) {
  2114.       if (setter && runes) {
  2115.         props_invalid_value();
  2116.       }
  2117.       prop_value = get_fallback();
  2118.       if (setter) setter(prop_value);
  2119.     }
  2120.     var getter;
  2121.     if (runes) {
  2122.       getter = () => {
  2123.         var value = (
  2124.           /** @type {V} */
  2125.           props[key]
  2126.         );
  2127.         if (value === void 0) return get_fallback();
  2128.         fallback_dirty = true;
  2129.         fallback_used = false;
  2130.         return value;
  2131.       };
  2132.     } else {
  2133.       var derived_getter = (immutable ? derived : derived_safe_equal)(
  2134.         () => (
  2135.           /** @type {V} */
  2136.           props[key]
  2137.         )
  2138.       );
  2139.       derived_getter.f |= LEGACY_DERIVED_PROP;
  2140.       getter = () => {
  2141.         var value = get(derived_getter);
  2142.         if (value !== void 0) fallback_value = /** @type {V} */
  2143.         void 0;
  2144.         return value === void 0 ? fallback_value : value;
  2145.       };
  2146.     }
  2147.     if ((flags & PROPS_IS_UPDATED) === 0) {
  2148.       return getter;
  2149.     }
  2150.     if (setter) {
  2151.       var legacy_parent = props.$$legacy;
  2152.       return function(value, mutation) {
  2153.         if (arguments.length > 0) {
  2154.           if (!runes || !mutation || legacy_parent) {
  2155.             setter(mutation ? getter() : value);
  2156.           }
  2157.           return value;
  2158.         } else {
  2159.           return getter();
  2160.         }
  2161.       };
  2162.     }
  2163.     var from_child = false;
  2164.     var inner_current_value = /* @__PURE__ */ mutable_source(prop_value);
  2165.     var current_value = /* @__PURE__ */ derived(() => {
  2166.       var parent_value = getter();
  2167.       var child_value = get(inner_current_value);
  2168.       if (from_child) {
  2169.         from_child = false;
  2170.         return child_value;
  2171.       }
  2172.       return inner_current_value.v = parent_value;
  2173.     });
  2174.     if (!immutable) current_value.equals = safe_equals;
  2175.     return function(value, mutation) {
  2176.       var current = get(current_value);
  2177.       if (arguments.length > 0) {
  2178.         const new_value = mutation ? get(current_value) : runes && bindable ? proxy(value) : value;
  2179.         if (!current_value.equals(new_value)) {
  2180.           from_child = true;
  2181.           set(inner_current_value, new_value);
  2182.           if (fallback_used && fallback_value !== void 0) {
  2183.             fallback_value = new_value;
  2184.           }
  2185.           get(current_value);
  2186.         }
  2187.         return value;
  2188.       }
  2189.       return current;
  2190.     };
  2191.   }
  2192.   function onMount(fn2) {
  2193.     if (component_context === null) {
  2194.       lifecycle_outside_component();
  2195.     }
  2196.     if (component_context.l !== null) {
  2197.       init_update_callbacks(component_context).m.push(fn2);
  2198.     } else {
  2199.       user_effect(() => {
  2200.         const cleanup = untrack(fn2);
  2201.         if (typeof cleanup === "function") return (
  2202.           /** @type {() => void} */
  2203.           cleanup
  2204.         );
  2205.       });
  2206.     }
  2207.   }
  2208.   function init_update_callbacks(context) {
  2209.     var l = (
  2210.       /** @type {ComponentContextLegacy} */
  2211.       context.l
  2212.     );
  2213.     return l.u ?? (l.u = { a: [], b: [], m: [] });
  2214.   }
  2215.   const PUBLIC_VERSION = "5";
  2216.   if (typeof window !== "undefined")
  2217.     (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION);
  2218.   const segmenter = new Intl.Segmenter();
  2219.   function segment(text) {
  2220.     return [...segmenter.segment(text)].map(({ segment: segment2 }) => segment2);
  2221.   }
  2222.   class Editor {
  2223.     constructor() {
  2224.       __privateAdd(this, _text, state(""));
  2225.       __privateAdd(this, _segments, /* @__PURE__ */ derived(() => segment(get(__privateGet(this, _text)))));
  2226.       __privateAdd(this, _selectedText, state(""));
  2227.     }
  2228.     /**
  2229.      * The text of the editor.
  2230.      *
  2231.      * This value is a reactive `$state()` and read-only.
  2232.      */
  2233.     get text() {
  2234.       return get(__privateGet(this, _text));
  2235.     }
  2236.     /**
  2237.      * @internal must be set by the editor implementation during text change
  2238.      */
  2239.     set text(text) {
  2240.       set(__privateGet(this, _text), proxy(text));
  2241.     }
  2242.     get segments() {
  2243.       return get(__privateGet(this, _segments));
  2244.     }
  2245.     /**
  2246.      * The text that is currently selected in the editor.
  2247.      *
  2248.      * This value is a reactive `$state()` and read-only.
  2249.      *
  2250.      * If there is no selection, this will be an empty string (`""`).
  2251.      *
  2252.      * For CodeMirror, if there are multiple selections, it will be
  2253.      * separated by `editor.codeMirror.doc.lineSeparator()`
  2254.      * (by default `editor.codeMirror.doc.lineSep || "\n"`).
  2255.      */
  2256.     get selectedText() {
  2257.       return get(__privateGet(this, _selectedText));
  2258.     }
  2259.     /**
  2260.      * @internal must be set by the editor implementation during selection change
  2261.      */
  2262.     set selectedText(selectedText) {
  2263.       set(__privateGet(this, _selectedText), proxy(selectedText));
  2264.     }
  2265.   }
  2266.   _text = new WeakMap();
  2267.   _segments = new WeakMap();
  2268.   _selectedText = new WeakMap();
  2269.   class KojiEditor extends Editor {
  2270.     constructor(wrapper) {
  2271.       super();
  2272.       __publicField(this, "wrapper");
  2273.       __publicField(this, "editor");
  2274.       this.wrapper = wrapper;
  2275.       if (!this.wrapper.__vue__) {
  2276.         throw new Error("KojiEditor: wrapper is not a Vue component");
  2277.       }
  2278.       this.editor = this.wrapper.__vue__.editor;
  2279.       this.editor.watch("selection", () => {
  2280.         this.selectedText = this.editor.selectedText;
  2281.       });
  2282.       this.editor.watch("requestedSrc", () => {
  2283.         this.text = this.editor.value;
  2284.       });
  2285.     }
  2286.     insertAtCursor(textToInsert) {
  2287.       this.editor.insertOrReplace(textToInsert);
  2288.     }
  2289.     replaceSelection(replacer) {
  2290.       this.editor.insertOrReplace(replacer(this.selectedText ?? ""));
  2291.     }
  2292.     markText(text) {
  2293.       const allChars = this.wrapper.querySelectorAll(".token .char");
  2294.       for (const char of allChars) {
  2295.         if (char.textContent === text) {
  2296.           char.classList.add("highlight-variant");
  2297.         }
  2298.       }
  2299.     }
  2300.     toggleClass(className, enabled) {
  2301.       if (enabled === void 0) {
  2302.         this.wrapper.classList.toggle(className);
  2303.       } else if (enabled) {
  2304.         this.wrapper.classList.add(className);
  2305.       } else {
  2306.         this.wrapper.classList.remove(className);
  2307.       }
  2308.     }
  2309.   }
  2310.   class CodeMirrorEditor extends Editor {
  2311.     constructor(codeMirror) {
  2312.       super();
  2313.       this.codeMirror = codeMirror;
  2314.       if (!codeMirror) {
  2315.         throw new Error("[honkoku-toolbox] CodeMirrorEditor is not valid");
  2316.       }
  2317.       this.codeMirror = codeMirror;
  2318.       this.codeMirror.on("cursorActivity", () => {
  2319.         this.selectedText = this.codeMirror.getSelection();
  2320.       });
  2321.       this.codeMirror.on("change", () => {
  2322.         this.text = this.codeMirror.getValue();
  2323.       });
  2324.     }
  2325.     insertAtCursor(textToInsert) {
  2326.       if (this.codeMirror.somethingSelected()) {
  2327.         this.replaceSelection((_) => textToInsert);
  2328.       } else {
  2329.         const cursor = this.codeMirror.getCursor();
  2330.         this.codeMirror.replaceRange(textToInsert, cursor);
  2331.       }
  2332.     }
  2333.     replaceSelection(replacer) {
  2334.       const replacedText = replacer(this.selectedText ?? "");
  2335.       this.codeMirror.replaceSelection(replacedText);
  2336.     }
  2337.     markText(substr) {
  2338.       if (!substr || !this.text.includes(substr)) return;
  2339.       const textClusters = segment(this.text);
  2340.       const substrClusters = segment(substr);
  2341.       const clusterCodeUnitIndices = [0];
  2342.       for (let i2 = 0; i2 < textClusters.length; (i2 += 1) - 1) {
  2343.         clusterCodeUnitIndices.push(clusterCodeUnitIndices[i2] + textClusters[i2].length);
  2344.       }
  2345.       const occurrences = [];
  2346.       for (let i2 = 0; i2 <= textClusters.length - substrClusters.length; (i2 += 1) - 1) {
  2347.         let match = true;
  2348.         for (let j = 0; j < substrClusters.length; (j += 1) - 1) {
  2349.           if (textClusters[i2 + j] !== substrClusters[j]) {
  2350.             match = false;
  2351.             break;
  2352.           }
  2353.         }
  2354.         if (match) {
  2355.           const startIndex = clusterCodeUnitIndices[i2];
  2356.           const endIndex = clusterCodeUnitIndices[i2 + substrClusters.length];
  2357.           occurrences.push({ startIndex, endIndex });
  2358.         }
  2359.       }
  2360.       for (const occurrence of occurrences) {
  2361.         const textPosStart = this.codeMirror.posFromIndex(occurrence.startIndex);
  2362.         const textPosEnd = this.codeMirror.posFromIndex(occurrence.endIndex);
  2363.         this.codeMirror.markText(textPosStart, textPosEnd, { className: "highlight-variant" });
  2364.       }
  2365.     }
  2366.     toggleClass(className, enabled) {
  2367.       if (enabled === void 0) {
  2368.         this.codeMirror.getWrapperElement().classList.toggle(className);
  2369.       } else if (enabled) {
  2370.         this.codeMirror.getWrapperElement().classList.add(className);
  2371.       } else {
  2372.         this.codeMirror.getWrapperElement().classList.remove(className);
  2373.       }
  2374.     }
  2375.   }
  2376.   var top = "top";
  2377.   var bottom = "bottom";
  2378.   var right = "right";
  2379.   var left = "left";
  2380.   var auto = "auto";
  2381.   var basePlacements = [top, bottom, right, left];
  2382.   var start = "start";
  2383.   var end = "end";
  2384.   var clippingParents = "clippingParents";
  2385.   var viewport = "viewport";
  2386.   var popper = "popper";
  2387.   var reference = "reference";
  2388.   var variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) {
  2389.     return acc.concat([placement + "-" + start, placement + "-" + end]);
  2390.   }, []);
  2391.   var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
  2392.     return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
  2393.   }, []);
  2394.   var beforeRead = "beforeRead";
  2395.   var read = "read";
  2396.   var afterRead = "afterRead";
  2397.   var beforeMain = "beforeMain";
  2398.   var main = "main";
  2399.   var afterMain = "afterMain";
  2400.   var beforeWrite = "beforeWrite";
  2401.   var write = "write";
  2402.   var afterWrite = "afterWrite";
  2403.   var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
  2404.   function getNodeName(element) {
  2405.     return element ? (element.nodeName || "").toLowerCase() : null;
  2406.   }
  2407.   function getWindow(node) {
  2408.     if (node == null) {
  2409.       return window;
  2410.     }
  2411.     if (node.toString() !== "[object Window]") {
  2412.       var ownerDocument = node.ownerDocument;
  2413.       return ownerDocument ? ownerDocument.defaultView || window : window;
  2414.     }
  2415.     return node;
  2416.   }
  2417.   function isElement$1(node) {
  2418.     var OwnElement = getWindow(node).Element;
  2419.     return node instanceof OwnElement || node instanceof Element;
  2420.   }
  2421.   function isHTMLElement(node) {
  2422.     var OwnElement = getWindow(node).HTMLElement;
  2423.     return node instanceof OwnElement || node instanceof HTMLElement;
  2424.   }
  2425.   function isShadowRoot(node) {
  2426.     if (typeof ShadowRoot === "undefined") {
  2427.       return false;
  2428.     }
  2429.     var OwnElement = getWindow(node).ShadowRoot;
  2430.     return node instanceof OwnElement || node instanceof ShadowRoot;
  2431.   }
  2432.   function applyStyles(_ref) {
  2433.     var state2 = _ref.state;
  2434.     Object.keys(state2.elements).forEach(function(name) {
  2435.       var style = state2.styles[name] || {};
  2436.       var attributes = state2.attributes[name] || {};
  2437.       var element = state2.elements[name];
  2438.       if (!isHTMLElement(element) || !getNodeName(element)) {
  2439.         return;
  2440.       }
  2441.       Object.assign(element.style, style);
  2442.       Object.keys(attributes).forEach(function(name2) {
  2443.         var value = attributes[name2];
  2444.         if (value === false) {
  2445.           element.removeAttribute(name2);
  2446.         } else {
  2447.           element.setAttribute(name2, value === true ? "" : value);
  2448.         }
  2449.       });
  2450.     });
  2451.   }
  2452.   function effect$2(_ref2) {
  2453.     var state2 = _ref2.state;
  2454.     var initialStyles = {
  2455.       popper: {
  2456.         position: state2.options.strategy,
  2457.         left: "0",
  2458.         top: "0",
  2459.         margin: "0"
  2460.       },
  2461.       arrow: {
  2462.         position: "absolute"
  2463.       },
  2464.       reference: {}
  2465.     };
  2466.     Object.assign(state2.elements.popper.style, initialStyles.popper);
  2467.     state2.styles = initialStyles;
  2468.     if (state2.elements.arrow) {
  2469.       Object.assign(state2.elements.arrow.style, initialStyles.arrow);
  2470.     }
  2471.     return function() {
  2472.       Object.keys(state2.elements).forEach(function(name) {
  2473.         var element = state2.elements[name];
  2474.         var attributes = state2.attributes[name] || {};
  2475.         var styleProperties = Object.keys(state2.styles.hasOwnProperty(name) ? state2.styles[name] : initialStyles[name]);
  2476.         var style = styleProperties.reduce(function(style2, property) {
  2477.           style2[property] = "";
  2478.           return style2;
  2479.         }, {});
  2480.         if (!isHTMLElement(element) || !getNodeName(element)) {
  2481.           return;
  2482.         }
  2483.         Object.assign(element.style, style);
  2484.         Object.keys(attributes).forEach(function(attribute) {
  2485.           element.removeAttribute(attribute);
  2486.         });
  2487.       });
  2488.     };
  2489.   }
  2490.   const applyStyles$1 = {
  2491.     name: "applyStyles",
  2492.     enabled: true,
  2493.     phase: "write",
  2494.     fn: applyStyles,
  2495.     effect: effect$2,
  2496.     requires: ["computeStyles"]
  2497.   };
  2498.   function getBasePlacement$1(placement) {
  2499.     return placement.split("-")[0];
  2500.   }
  2501.   var max = Math.max;
  2502.   var min = Math.min;
  2503.   var round = Math.round;
  2504.   function getUAString() {
  2505.     var uaData = navigator.userAgentData;
  2506.     if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
  2507.       return uaData.brands.map(function(item) {
  2508.         return item.brand + "/" + item.version;
  2509.       }).join(" ");
  2510.     }
  2511.     return navigator.userAgent;
  2512.   }
  2513.   function isLayoutViewport() {
  2514.     return !/^((?!chrome|android).)*safari/i.test(getUAString());
  2515.   }
  2516.   function getBoundingClientRect(element, includeScale, isFixedStrategy) {
  2517.     if (includeScale === void 0) {
  2518.       includeScale = false;
  2519.     }
  2520.     if (isFixedStrategy === void 0) {
  2521.       isFixedStrategy = false;
  2522.     }
  2523.     var clientRect = element.getBoundingClientRect();
  2524.     var scaleX = 1;
  2525.     var scaleY = 1;
  2526.     if (includeScale && isHTMLElement(element)) {
  2527.       scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
  2528.       scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
  2529.     }
  2530.     var _ref = isElement$1(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
  2531.     var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
  2532.     var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
  2533.     var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
  2534.     var width = clientRect.width / scaleX;
  2535.     var height = clientRect.height / scaleY;
  2536.     return {
  2537.       width,
  2538.       height,
  2539.       top: y,
  2540.       right: x + width,
  2541.       bottom: y + height,
  2542.       left: x,
  2543.       x,
  2544.       y
  2545.     };
  2546.   }
  2547.   function getLayoutRect(element) {
  2548.     var clientRect = getBoundingClientRect(element);
  2549.     var width = element.offsetWidth;
  2550.     var height = element.offsetHeight;
  2551.     if (Math.abs(clientRect.width - width) <= 1) {
  2552.       width = clientRect.width;
  2553.     }
  2554.     if (Math.abs(clientRect.height - height) <= 1) {
  2555.       height = clientRect.height;
  2556.     }
  2557.     return {
  2558.       x: element.offsetLeft,
  2559.       y: element.offsetTop,
  2560.       width,
  2561.       height
  2562.     };
  2563.   }
  2564.   function contains(parent, child2) {
  2565.     var rootNode = child2.getRootNode && child2.getRootNode();
  2566.     if (parent.contains(child2)) {
  2567.       return true;
  2568.     } else if (rootNode && isShadowRoot(rootNode)) {
  2569.       var next = child2;
  2570.       do {
  2571.         if (next && parent.isSameNode(next)) {
  2572.           return true;
  2573.         }
  2574.         next = next.parentNode || next.host;
  2575.       } while (next);
  2576.     }
  2577.     return false;
  2578.   }
  2579.   function getComputedStyle(element) {
  2580.     return getWindow(element).getComputedStyle(element);
  2581.   }
  2582.   function isTableElement(element) {
  2583.     return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
  2584.   }
  2585.   function getDocumentElement(element) {
  2586.     return ((isElement$1(element) ? element.ownerDocument : (
  2587.       // $FlowFixMe[prop-missing]
  2588.       element.document
  2589.     )) || window.document).documentElement;
  2590.   }
  2591.   function getParentNode(element) {
  2592.     if (getNodeName(element) === "html") {
  2593.       return element;
  2594.     }
  2595.     return (
  2596.       // this is a quicker (but less type safe) way to save quite some bytes from the bundle
  2597.       // $FlowFixMe[incompatible-return]
  2598.       // $FlowFixMe[prop-missing]
  2599.       element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
  2600.       element.parentNode || // DOM Element detected
  2601.       (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
  2602.       // $FlowFixMe[incompatible-call]: HTMLElement is a Node
  2603.       getDocumentElement(element)
  2604.     );
  2605.   }
  2606.   function getTrueOffsetParent(element) {
  2607.     if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
  2608.     getComputedStyle(element).position === "fixed") {
  2609.       return null;
  2610.     }
  2611.     return element.offsetParent;
  2612.   }
  2613.   function getContainingBlock(element) {
  2614.     var isFirefox = /firefox/i.test(getUAString());
  2615.     var isIE = /Trident/i.test(getUAString());
  2616.     if (isIE && isHTMLElement(element)) {
  2617.       var elementCss = getComputedStyle(element);
  2618.       if (elementCss.position === "fixed") {
  2619.         return null;
  2620.       }
  2621.     }
  2622.     var currentNode = getParentNode(element);
  2623.     if (isShadowRoot(currentNode)) {
  2624.       currentNode = currentNode.host;
  2625.     }
  2626.     while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
  2627.       var css = getComputedStyle(currentNode);
  2628.       if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
  2629.         return currentNode;
  2630.       } else {
  2631.         currentNode = currentNode.parentNode;
  2632.       }
  2633.     }
  2634.     return null;
  2635.   }
  2636.   function getOffsetParent(element) {
  2637.     var window2 = getWindow(element);
  2638.     var offsetParent = getTrueOffsetParent(element);
  2639.     while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
  2640.       offsetParent = getTrueOffsetParent(offsetParent);
  2641.     }
  2642.     if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static")) {
  2643.       return window2;
  2644.     }
  2645.     return offsetParent || getContainingBlock(element) || window2;
  2646.   }
  2647.   function getMainAxisFromPlacement(placement) {
  2648.     return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
  2649.   }
  2650.   function within(min$1, value, max$1) {
  2651.     return max(min$1, min(value, max$1));
  2652.   }
  2653.   function withinMaxClamp(min2, value, max2) {
  2654.     var v = within(min2, value, max2);
  2655.     return v > max2 ? max2 : v;
  2656.   }
  2657.   function getFreshSideObject() {
  2658.     return {
  2659.       top: 0,
  2660.       right: 0,
  2661.       bottom: 0,
  2662.       left: 0
  2663.     };
  2664.   }
  2665.   function mergePaddingObject(paddingObject) {
  2666.     return Object.assign({}, getFreshSideObject(), paddingObject);
  2667.   }
  2668.   function expandToHashMap(value, keys) {
  2669.     return keys.reduce(function(hashMap, key) {
  2670.       hashMap[key] = value;
  2671.       return hashMap;
  2672.     }, {});
  2673.   }
  2674.   var toPaddingObject = function toPaddingObject2(padding, state2) {
  2675.     padding = typeof padding === "function" ? padding(Object.assign({}, state2.rects, {
  2676.       placement: state2.placement
  2677.     })) : padding;
  2678.     return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
  2679.   };
  2680.   function arrow(_ref) {
  2681.     var _state$modifiersData$;
  2682.     var state2 = _ref.state, name = _ref.name, options = _ref.options;
  2683.     var arrowElement = state2.elements.arrow;
  2684.     var popperOffsets2 = state2.modifiersData.popperOffsets;
  2685.     var basePlacement = getBasePlacement$1(state2.placement);
  2686.     var axis = getMainAxisFromPlacement(basePlacement);
  2687.     var isVertical = [left, right].indexOf(basePlacement) >= 0;
  2688.     var len = isVertical ? "height" : "width";
  2689.     if (!arrowElement || !popperOffsets2) {
  2690.       return;
  2691.     }
  2692.     var paddingObject = toPaddingObject(options.padding, state2);
  2693.     var arrowRect = getLayoutRect(arrowElement);
  2694.     var minProp = axis === "y" ? top : left;
  2695.     var maxProp = axis === "y" ? bottom : right;
  2696.     var endDiff = state2.rects.reference[len] + state2.rects.reference[axis] - popperOffsets2[axis] - state2.rects.popper[len];
  2697.     var startDiff = popperOffsets2[axis] - state2.rects.reference[axis];
  2698.     var arrowOffsetParent = getOffsetParent(arrowElement);
  2699.     var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
  2700.     var centerToReference = endDiff / 2 - startDiff / 2;
  2701.     var min2 = paddingObject[minProp];
  2702.     var max2 = clientSize - arrowRect[len] - paddingObject[maxProp];
  2703.     var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
  2704.     var offset2 = within(min2, center, max2);
  2705.     var axisProp = axis;
  2706.     state2.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
  2707.   }
  2708.   function effect$1(_ref2) {
  2709.     var state2 = _ref2.state, options = _ref2.options;
  2710.     var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
  2711.     if (arrowElement == null) {
  2712.       return;
  2713.     }
  2714.     if (typeof arrowElement === "string") {
  2715.       arrowElement = state2.elements.popper.querySelector(arrowElement);
  2716.       if (!arrowElement) {
  2717.         return;
  2718.       }
  2719.     }
  2720.     if (!contains(state2.elements.popper, arrowElement)) {
  2721.       return;
  2722.     }
  2723.     state2.elements.arrow = arrowElement;
  2724.   }
  2725.   const arrow$1 = {
  2726.     name: "arrow",
  2727.     enabled: true,
  2728.     phase: "main",
  2729.     fn: arrow,
  2730.     effect: effect$1,
  2731.     requires: ["popperOffsets"],
  2732.     requiresIfExists: ["preventOverflow"]
  2733.   };
  2734.   function getVariation(placement) {
  2735.     return placement.split("-")[1];
  2736.   }
  2737.   var unsetSides = {
  2738.     top: "auto",
  2739.     right: "auto",
  2740.     bottom: "auto",
  2741.     left: "auto"
  2742.   };
  2743.   function roundOffsetsByDPR(_ref, win) {
  2744.     var x = _ref.x, y = _ref.y;
  2745.     var dpr = win.devicePixelRatio || 1;
  2746.     return {
  2747.       x: round(x * dpr) / dpr || 0,
  2748.       y: round(y * dpr) / dpr || 0
  2749.     };
  2750.   }
  2751.   function mapToStyles(_ref2) {
  2752.     var _Object$assign2;
  2753.     var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
  2754.     var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
  2755.     var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
  2756.       x,
  2757.       y
  2758.     }) : {
  2759.       x,
  2760.       y
  2761.     };
  2762.     x = _ref3.x;
  2763.     y = _ref3.y;
  2764.     var hasX = offsets.hasOwnProperty("x");
  2765.     var hasY = offsets.hasOwnProperty("y");
  2766.     var sideX = left;
  2767.     var sideY = top;
  2768.     var win = window;
  2769.     if (adaptive) {
  2770.       var offsetParent = getOffsetParent(popper2);
  2771.       var heightProp = "clientHeight";
  2772.       var widthProp = "clientWidth";
  2773.       if (offsetParent === getWindow(popper2)) {
  2774.         offsetParent = getDocumentElement(popper2);
  2775.         if (getComputedStyle(offsetParent).position !== "static" && position === "absolute") {
  2776.           heightProp = "scrollHeight";
  2777.           widthProp = "scrollWidth";
  2778.         }
  2779.       }
  2780.       offsetParent = offsetParent;
  2781.       if (placement === top || (placement === left || placement === right) && variation === end) {
  2782.         sideY = bottom;
  2783.         var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
  2784.           // $FlowFixMe[prop-missing]
  2785.           offsetParent[heightProp]
  2786.         );
  2787.         y -= offsetY - popperRect.height;
  2788.         y *= gpuAcceleration ? 1 : -1;
  2789.       }
  2790.       if (placement === left || (placement === top || placement === bottom) && variation === end) {
  2791.         sideX = right;
  2792.         var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
  2793.           // $FlowFixMe[prop-missing]
  2794.           offsetParent[widthProp]
  2795.         );
  2796.         x -= offsetX - popperRect.width;
  2797.         x *= gpuAcceleration ? 1 : -1;
  2798.       }
  2799.     }
  2800.     var commonStyles = Object.assign({
  2801.       position
  2802.     }, adaptive && unsetSides);
  2803.     var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
  2804.       x,
  2805.       y
  2806.     }, getWindow(popper2)) : {
  2807.       x,
  2808.       y
  2809.     };
  2810.     x = _ref4.x;
  2811.     y = _ref4.y;
  2812.     if (gpuAcceleration) {
  2813.       var _Object$assign;
  2814.       return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
  2815.     }
  2816.     return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
  2817.   }
  2818.   function computeStyles(_ref5) {
  2819.     var state2 = _ref5.state, options = _ref5.options;
  2820.     var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
  2821.     var commonStyles = {
  2822.       placement: getBasePlacement$1(state2.placement),
  2823.       variation: getVariation(state2.placement),
  2824.       popper: state2.elements.popper,
  2825.       popperRect: state2.rects.popper,
  2826.       gpuAcceleration,
  2827.       isFixed: state2.options.strategy === "fixed"
  2828.     };
  2829.     if (state2.modifiersData.popperOffsets != null) {
  2830.       state2.styles.popper = Object.assign({}, state2.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
  2831.         offsets: state2.modifiersData.popperOffsets,
  2832.         position: state2.options.strategy,
  2833.         adaptive,
  2834.         roundOffsets
  2835.       })));
  2836.     }
  2837.     if (state2.modifiersData.arrow != null) {
  2838.       state2.styles.arrow = Object.assign({}, state2.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
  2839.         offsets: state2.modifiersData.arrow,
  2840.         position: "absolute",
  2841.         adaptive: false,
  2842.         roundOffsets
  2843.       })));
  2844.     }
  2845.     state2.attributes.popper = Object.assign({}, state2.attributes.popper, {
  2846.       "data-popper-placement": state2.placement
  2847.     });
  2848.   }
  2849.   const computeStyles$1 = {
  2850.     name: "computeStyles",
  2851.     enabled: true,
  2852.     phase: "beforeWrite",
  2853.     fn: computeStyles,
  2854.     data: {}
  2855.   };
  2856.   var passive = {
  2857.     passive: true
  2858.   };
  2859.   function effect(_ref) {
  2860.     var state2 = _ref.state, instance = _ref.instance, options = _ref.options;
  2861.     var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
  2862.     var window2 = getWindow(state2.elements.popper);
  2863.     var scrollParents = [].concat(state2.scrollParents.reference, state2.scrollParents.popper);
  2864.     if (scroll) {
  2865.       scrollParents.forEach(function(scrollParent) {
  2866.         scrollParent.addEventListener("scroll", instance.update, passive);
  2867.       });
  2868.     }
  2869.     if (resize) {
  2870.       window2.addEventListener("resize", instance.update, passive);
  2871.     }
  2872.     return function() {
  2873.       if (scroll) {
  2874.         scrollParents.forEach(function(scrollParent) {
  2875.           scrollParent.removeEventListener("scroll", instance.update, passive);
  2876.         });
  2877.       }
  2878.       if (resize) {
  2879.         window2.removeEventListener("resize", instance.update, passive);
  2880.       }
  2881.     };
  2882.   }
  2883.   const eventListeners = {
  2884.     name: "eventListeners",
  2885.     enabled: true,
  2886.     phase: "write",
  2887.     fn: function fn() {
  2888.     },
  2889.     effect,
  2890.     data: {}
  2891.   };
  2892.   var hash$1 = {
  2893.     left: "right",
  2894.     right: "left",
  2895.     bottom: "top",
  2896.     top: "bottom"
  2897.   };
  2898.   function getOppositePlacement(placement) {
  2899.     return placement.replace(/left|right|bottom|top/g, function(matched) {
  2900.       return hash$1[matched];
  2901.     });
  2902.   }
  2903.   var hash = {
  2904.     start: "end",
  2905.     end: "start"
  2906.   };
  2907.   function getOppositeVariationPlacement(placement) {
  2908.     return placement.replace(/start|end/g, function(matched) {
  2909.       return hash[matched];
  2910.     });
  2911.   }
  2912.   function getWindowScroll(node) {
  2913.     var win = getWindow(node);
  2914.     var scrollLeft = win.pageXOffset;
  2915.     var scrollTop = win.pageYOffset;
  2916.     return {
  2917.       scrollLeft,
  2918.       scrollTop
  2919.     };
  2920.   }
  2921.   function getWindowScrollBarX(element) {
  2922.     return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
  2923.   }
  2924.   function getViewportRect(element, strategy) {
  2925.     var win = getWindow(element);
  2926.     var html = getDocumentElement(element);
  2927.     var visualViewport = win.visualViewport;
  2928.     var width = html.clientWidth;
  2929.     var height = html.clientHeight;
  2930.     var x = 0;
  2931.     var y = 0;
  2932.     if (visualViewport) {
  2933.       width = visualViewport.width;
  2934.       height = visualViewport.height;
  2935.       var layoutViewport = isLayoutViewport();
  2936.       if (layoutViewport || !layoutViewport && strategy === "fixed") {
  2937.         x = visualViewport.offsetLeft;
  2938.         y = visualViewport.offsetTop;
  2939.       }
  2940.     }
  2941.     return {
  2942.       width,
  2943.       height,
  2944.       x: x + getWindowScrollBarX(element),
  2945.       y
  2946.     };
  2947.   }
  2948.   function getDocumentRect(element) {
  2949.     var _element$ownerDocumen;
  2950.     var html = getDocumentElement(element);
  2951.     var winScroll = getWindowScroll(element);
  2952.     var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
  2953.     var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
  2954.     var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
  2955.     var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
  2956.     var y = -winScroll.scrollTop;
  2957.     if (getComputedStyle(body || html).direction === "rtl") {
  2958.       x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
  2959.     }
  2960.     return {
  2961.       width,
  2962.       height,
  2963.       x,
  2964.       y
  2965.     };
  2966.   }
  2967.   function isScrollParent(element) {
  2968.     var _getComputedStyle = getComputedStyle(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
  2969.     return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
  2970.   }
  2971.   function getScrollParent(node) {
  2972.     if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
  2973.       return node.ownerDocument.body;
  2974.     }
  2975.     if (isHTMLElement(node) && isScrollParent(node)) {
  2976.       return node;
  2977.     }
  2978.     return getScrollParent(getParentNode(node));
  2979.   }
  2980.   function listScrollParents(element, list) {
  2981.     var _element$ownerDocumen;
  2982.     if (list === void 0) {
  2983.       list = [];
  2984.     }
  2985.     var scrollParent = getScrollParent(element);
  2986.     var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
  2987.     var win = getWindow(scrollParent);
  2988.     var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
  2989.     var updatedList = list.concat(target);
  2990.     return isBody ? updatedList : (
  2991.       // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
  2992.       updatedList.concat(listScrollParents(getParentNode(target)))
  2993.     );
  2994.   }
  2995.   function rectToClientRect(rect) {
  2996.     return Object.assign({}, rect, {
  2997.       left: rect.x,
  2998.       top: rect.y,
  2999.       right: rect.x + rect.width,
  3000.       bottom: rect.y + rect.height
  3001.     });
  3002.   }
  3003.   function getInnerBoundingClientRect(element, strategy) {
  3004.     var rect = getBoundingClientRect(element, false, strategy === "fixed");
  3005.     rect.top = rect.top + element.clientTop;
  3006.     rect.left = rect.left + element.clientLeft;
  3007.     rect.bottom = rect.top + element.clientHeight;
  3008.     rect.right = rect.left + element.clientWidth;
  3009.     rect.width = element.clientWidth;
  3010.     rect.height = element.clientHeight;
  3011.     rect.x = rect.left;
  3012.     rect.y = rect.top;
  3013.     return rect;
  3014.   }
  3015.   function getClientRectFromMixedType(element, clippingParent, strategy) {
  3016.     return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement$1(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
  3017.   }
  3018.   function getClippingParents(element) {
  3019.     var clippingParents2 = listScrollParents(getParentNode(element));
  3020.     var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle(element).position) >= 0;
  3021.     var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
  3022.     if (!isElement$1(clipperElement)) {
  3023.       return [];
  3024.     }
  3025.     return clippingParents2.filter(function(clippingParent) {
  3026.       return isElement$1(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
  3027.     });
  3028.   }
  3029.   function getClippingRect(element, boundary, rootBoundary, strategy) {
  3030.     var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
  3031.     var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
  3032.     var firstClippingParent = clippingParents2[0];
  3033.     var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
  3034.       var rect = getClientRectFromMixedType(element, clippingParent, strategy);
  3035.       accRect.top = max(rect.top, accRect.top);
  3036.       accRect.right = min(rect.right, accRect.right);
  3037.       accRect.bottom = min(rect.bottom, accRect.bottom);
  3038.       accRect.left = max(rect.left, accRect.left);
  3039.       return accRect;
  3040.     }, getClientRectFromMixedType(element, firstClippingParent, strategy));
  3041.     clippingRect.width = clippingRect.right - clippingRect.left;
  3042.     clippingRect.height = clippingRect.bottom - clippingRect.top;
  3043.     clippingRect.x = clippingRect.left;
  3044.     clippingRect.y = clippingRect.top;
  3045.     return clippingRect;
  3046.   }
  3047.   function computeOffsets(_ref) {
  3048.     var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
  3049.     var basePlacement = placement ? getBasePlacement$1(placement) : null;
  3050.     var variation = placement ? getVariation(placement) : null;
  3051.     var commonX = reference2.x + reference2.width / 2 - element.width / 2;
  3052.     var commonY = reference2.y + reference2.height / 2 - element.height / 2;
  3053.     var offsets;
  3054.     switch (basePlacement) {
  3055.       case top:
  3056.         offsets = {
  3057.           x: commonX,
  3058.           y: reference2.y - element.height
  3059.         };
  3060.         break;
  3061.       case bottom:
  3062.         offsets = {
  3063.           x: commonX,
  3064.           y: reference2.y + reference2.height
  3065.         };
  3066.         break;
  3067.       case right:
  3068.         offsets = {
  3069.           x: reference2.x + reference2.width,
  3070.           y: commonY
  3071.         };
  3072.         break;
  3073.       case left:
  3074.         offsets = {
  3075.           x: reference2.x - element.width,
  3076.           y: commonY
  3077.         };
  3078.         break;
  3079.       default:
  3080.         offsets = {
  3081.           x: reference2.x,
  3082.           y: reference2.y
  3083.         };
  3084.     }
  3085.     var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
  3086.     if (mainAxis != null) {
  3087.       var len = mainAxis === "y" ? "height" : "width";
  3088.       switch (variation) {
  3089.         case start:
  3090.           offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
  3091.           break;
  3092.         case end:
  3093.           offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
  3094.           break;
  3095.       }
  3096.     }
  3097.     return offsets;
  3098.   }
  3099.   function detectOverflow(state2, options) {
  3100.     if (options === void 0) {
  3101.       options = {};
  3102.     }
  3103.     var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state2.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state2.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
  3104.     var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
  3105.     var altContext = elementContext === popper ? reference : popper;
  3106.     var popperRect = state2.rects.popper;
  3107.     var element = state2.elements[altBoundary ? altContext : elementContext];
  3108.     var clippingClientRect = getClippingRect(isElement$1(element) ? element : element.contextElement || getDocumentElement(state2.elements.popper), boundary, rootBoundary, strategy);
  3109.     var referenceClientRect = getBoundingClientRect(state2.elements.reference);
  3110.     var popperOffsets2 = computeOffsets({
  3111.       reference: referenceClientRect,
  3112.       element: popperRect,
  3113.       strategy: "absolute",
  3114.       placement
  3115.     });
  3116.     var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
  3117.     var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
  3118.     var overflowOffsets = {
  3119.       top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
  3120.       bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
  3121.       left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
  3122.       right: elementClientRect.right - clippingClientRect.right + paddingObject.right
  3123.     };
  3124.     var offsetData = state2.modifiersData.offset;
  3125.     if (elementContext === popper && offsetData) {
  3126.       var offset2 = offsetData[placement];
  3127.       Object.keys(overflowOffsets).forEach(function(key) {
  3128.         var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
  3129.         var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
  3130.         overflowOffsets[key] += offset2[axis] * multiply;
  3131.       });
  3132.     }
  3133.     return overflowOffsets;
  3134.   }
  3135.   function computeAutoPlacement(state2, options) {
  3136.     if (options === void 0) {
  3137.       options = {};
  3138.     }
  3139.     var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
  3140.     var variation = getVariation(placement);
  3141.     var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
  3142.       return getVariation(placement2) === variation;
  3143.     }) : basePlacements;
  3144.     var allowedPlacements = placements$1.filter(function(placement2) {
  3145.       return allowedAutoPlacements.indexOf(placement2) >= 0;
  3146.     });
  3147.     if (allowedPlacements.length === 0) {
  3148.       allowedPlacements = placements$1;
  3149.     }
  3150.     var overflows = allowedPlacements.reduce(function(acc, placement2) {
  3151.       acc[placement2] = detectOverflow(state2, {
  3152.         placement: placement2,
  3153.         boundary,
  3154.         rootBoundary,
  3155.         padding
  3156.       })[getBasePlacement$1(placement2)];
  3157.       return acc;
  3158.     }, {});
  3159.     return Object.keys(overflows).sort(function(a2, b) {
  3160.       return overflows[a2] - overflows[b];
  3161.     });
  3162.   }
  3163.   function getExpandedFallbackPlacements(placement) {
  3164.     if (getBasePlacement$1(placement) === auto) {
  3165.       return [];
  3166.     }
  3167.     var oppositePlacement = getOppositePlacement(placement);
  3168.     return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
  3169.   }
  3170.   function flip(_ref) {
  3171.     var state2 = _ref.state, options = _ref.options, name = _ref.name;
  3172.     if (state2.modifiersData[name]._skip) {
  3173.       return;
  3174.     }
  3175.     var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
  3176.     var preferredPlacement = state2.options.placement;
  3177.     var basePlacement = getBasePlacement$1(preferredPlacement);
  3178.     var isBasePlacement = basePlacement === preferredPlacement;
  3179.     var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
  3180.     var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
  3181.       return acc.concat(getBasePlacement$1(placement2) === auto ? computeAutoPlacement(state2, {
  3182.         placement: placement2,
  3183.         boundary,
  3184.         rootBoundary,
  3185.         padding,
  3186.         flipVariations,
  3187.         allowedAutoPlacements
  3188.       }) : placement2);
  3189.     }, []);
  3190.     var referenceRect = state2.rects.reference;
  3191.     var popperRect = state2.rects.popper;
  3192.     var checksMap = /* @__PURE__ */ new Map();
  3193.     var makeFallbackChecks = true;
  3194.     var firstFittingPlacement = placements2[0];
  3195.     for (var i2 = 0; i2 < placements2.length; i2++) {
  3196.       var placement = placements2[i2];
  3197.       var _basePlacement = getBasePlacement$1(placement);
  3198.       var isStartVariation = getVariation(placement) === start;
  3199.       var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
  3200.       var len = isVertical ? "width" : "height";
  3201.       var overflow = detectOverflow(state2, {
  3202.         placement,
  3203.         boundary,
  3204.         rootBoundary,
  3205.         altBoundary,
  3206.         padding
  3207.       });
  3208.       var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
  3209.       if (referenceRect[len] > popperRect[len]) {
  3210.         mainVariationSide = getOppositePlacement(mainVariationSide);
  3211.       }
  3212.       var altVariationSide = getOppositePlacement(mainVariationSide);
  3213.       var checks = [];
  3214.       if (checkMainAxis) {
  3215.         checks.push(overflow[_basePlacement] <= 0);
  3216.       }
  3217.       if (checkAltAxis) {
  3218.         checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
  3219.       }
  3220.       if (checks.every(function(check) {
  3221.         return check;
  3222.       })) {
  3223.         firstFittingPlacement = placement;
  3224.         makeFallbackChecks = false;
  3225.         break;
  3226.       }
  3227.       checksMap.set(placement, checks);
  3228.     }
  3229.     if (makeFallbackChecks) {
  3230.       var numberOfChecks = flipVariations ? 3 : 1;
  3231.       var _loop = function _loop2(_i2) {
  3232.         var fittingPlacement = placements2.find(function(placement2) {
  3233.           var checks2 = checksMap.get(placement2);
  3234.           if (checks2) {
  3235.             return checks2.slice(0, _i2).every(function(check) {
  3236.               return check;
  3237.             });
  3238.           }
  3239.         });
  3240.         if (fittingPlacement) {
  3241.           firstFittingPlacement = fittingPlacement;
  3242.           return "break";
  3243.         }
  3244.       };
  3245.       for (var _i = numberOfChecks; _i > 0; _i--) {
  3246.         var _ret = _loop(_i);
  3247.         if (_ret === "break") break;
  3248.       }
  3249.     }
  3250.     if (state2.placement !== firstFittingPlacement) {
  3251.       state2.modifiersData[name]._skip = true;
  3252.       state2.placement = firstFittingPlacement;
  3253.       state2.reset = true;
  3254.     }
  3255.   }
  3256.   const flip$1 = {
  3257.     name: "flip",
  3258.     enabled: true,
  3259.     phase: "main",
  3260.     fn: flip,
  3261.     requiresIfExists: ["offset"],
  3262.     data: {
  3263.       _skip: false
  3264.     }
  3265.   };
  3266.   function getSideOffsets(overflow, rect, preventedOffsets) {
  3267.     if (preventedOffsets === void 0) {
  3268.       preventedOffsets = {
  3269.         x: 0,
  3270.         y: 0
  3271.       };
  3272.     }
  3273.     return {
  3274.       top: overflow.top - rect.height - preventedOffsets.y,
  3275.       right: overflow.right - rect.width + preventedOffsets.x,
  3276.       bottom: overflow.bottom - rect.height + preventedOffsets.y,
  3277.       left: overflow.left - rect.width - preventedOffsets.x
  3278.     };
  3279.   }
  3280.   function isAnySideFullyClipped(overflow) {
  3281.     return [top, right, bottom, left].some(function(side) {
  3282.       return overflow[side] >= 0;
  3283.     });
  3284.   }
  3285.   function hide(_ref) {
  3286.     var state2 = _ref.state, name = _ref.name;
  3287.     var referenceRect = state2.rects.reference;
  3288.     var popperRect = state2.rects.popper;
  3289.     var preventedOffsets = state2.modifiersData.preventOverflow;
  3290.     var referenceOverflow = detectOverflow(state2, {
  3291.       elementContext: "reference"
  3292.     });
  3293.     var popperAltOverflow = detectOverflow(state2, {
  3294.       altBoundary: true
  3295.     });
  3296.     var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
  3297.     var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
  3298.     var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
  3299.     var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
  3300.     state2.modifiersData[name] = {
  3301.       referenceClippingOffsets,
  3302.       popperEscapeOffsets,
  3303.       isReferenceHidden,
  3304.       hasPopperEscaped
  3305.     };
  3306.     state2.attributes.popper = Object.assign({}, state2.attributes.popper, {
  3307.       "data-popper-reference-hidden": isReferenceHidden,
  3308.       "data-popper-escaped": hasPopperEscaped
  3309.     });
  3310.   }
  3311.   const hide$1 = {
  3312.     name: "hide",
  3313.     enabled: true,
  3314.     phase: "main",
  3315.     requiresIfExists: ["preventOverflow"],
  3316.     fn: hide
  3317.   };
  3318.   function distanceAndSkiddingToXY(placement, rects, offset2) {
  3319.     var basePlacement = getBasePlacement$1(placement);
  3320.     var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
  3321.     var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
  3322.       placement
  3323.     })) : offset2, skidding = _ref[0], distance = _ref[1];
  3324.     skidding = skidding || 0;
  3325.     distance = (distance || 0) * invertDistance;
  3326.     return [left, right].indexOf(basePlacement) >= 0 ? {
  3327.       x: distance,
  3328.       y: skidding
  3329.     } : {
  3330.       x: skidding,
  3331.       y: distance
  3332.     };
  3333.   }
  3334.   function offset(_ref2) {
  3335.     var state2 = _ref2.state, options = _ref2.options, name = _ref2.name;
  3336.     var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
  3337.     var data = placements.reduce(function(acc, placement) {
  3338.       acc[placement] = distanceAndSkiddingToXY(placement, state2.rects, offset2);
  3339.       return acc;
  3340.     }, {});
  3341.     var _data$state$placement = data[state2.placement], x = _data$state$placement.x, y = _data$state$placement.y;
  3342.     if (state2.modifiersData.popperOffsets != null) {
  3343.       state2.modifiersData.popperOffsets.x += x;
  3344.       state2.modifiersData.popperOffsets.y += y;
  3345.     }
  3346.     state2.modifiersData[name] = data;
  3347.   }
  3348.   const offset$1 = {
  3349.     name: "offset",
  3350.     enabled: true,
  3351.     phase: "main",
  3352.     requires: ["popperOffsets"],
  3353.     fn: offset
  3354.   };
  3355.   function popperOffsets(_ref) {
  3356.     var state2 = _ref.state, name = _ref.name;
  3357.     state2.modifiersData[name] = computeOffsets({
  3358.       reference: state2.rects.reference,
  3359.       element: state2.rects.popper,
  3360.       strategy: "absolute",
  3361.       placement: state2.placement
  3362.     });
  3363.   }
  3364.   const popperOffsets$1 = {
  3365.     name: "popperOffsets",
  3366.     enabled: true,
  3367.     phase: "read",
  3368.     fn: popperOffsets,
  3369.     data: {}
  3370.   };
  3371.   function getAltAxis(axis) {
  3372.     return axis === "x" ? "y" : "x";
  3373.   }
  3374.   function preventOverflow(_ref) {
  3375.     var state2 = _ref.state, options = _ref.options, name = _ref.name;
  3376.     var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
  3377.     var overflow = detectOverflow(state2, {
  3378.       boundary,
  3379.       rootBoundary,
  3380.       padding,
  3381.       altBoundary
  3382.     });
  3383.     var basePlacement = getBasePlacement$1(state2.placement);
  3384.     var variation = getVariation(state2.placement);
  3385.     var isBasePlacement = !variation;
  3386.     var mainAxis = getMainAxisFromPlacement(basePlacement);
  3387.     var altAxis = getAltAxis(mainAxis);
  3388.     var popperOffsets2 = state2.modifiersData.popperOffsets;
  3389.     var referenceRect = state2.rects.reference;
  3390.     var popperRect = state2.rects.popper;
  3391.     var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state2.rects, {
  3392.       placement: state2.placement
  3393.     })) : tetherOffset;
  3394.     var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
  3395.       mainAxis: tetherOffsetValue,
  3396.       altAxis: tetherOffsetValue
  3397.     } : Object.assign({
  3398.       mainAxis: 0,
  3399.       altAxis: 0
  3400.     }, tetherOffsetValue);
  3401.     var offsetModifierState = state2.modifiersData.offset ? state2.modifiersData.offset[state2.placement] : null;
  3402.     var data = {
  3403.       x: 0,
  3404.       y: 0
  3405.     };
  3406.     if (!popperOffsets2) {
  3407.       return;
  3408.     }
  3409.     if (checkMainAxis) {
  3410.       var _offsetModifierState$;
  3411.       var mainSide = mainAxis === "y" ? top : left;
  3412.       var altSide = mainAxis === "y" ? bottom : right;
  3413.       var len = mainAxis === "y" ? "height" : "width";
  3414.       var offset2 = popperOffsets2[mainAxis];
  3415.       var min$1 = offset2 + overflow[mainSide];
  3416.       var max$1 = offset2 - overflow[altSide];
  3417.       var additive = tether ? -popperRect[len] / 2 : 0;
  3418.       var minLen = variation === start ? referenceRect[len] : popperRect[len];
  3419.       var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
  3420.       var arrowElement = state2.elements.arrow;
  3421.       var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
  3422.         width: 0,
  3423.         height: 0
  3424.       };
  3425.       var arrowPaddingObject = state2.modifiersData["arrow#persistent"] ? state2.modifiersData["arrow#persistent"].padding : getFreshSideObject();
  3426.       var arrowPaddingMin = arrowPaddingObject[mainSide];
  3427.       var arrowPaddingMax = arrowPaddingObject[altSide];
  3428.       var arrowLen = within(0, referenceRect[len], arrowRect[len]);
  3429.       var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
  3430.       var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
  3431.       var arrowOffsetParent = state2.elements.arrow && getOffsetParent(state2.elements.arrow);
  3432.       var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
  3433.       var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
  3434.       var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
  3435.       var tetherMax = offset2 + maxOffset - offsetModifierValue;
  3436.       var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
  3437.       popperOffsets2[mainAxis] = preventedOffset;
  3438.       data[mainAxis] = preventedOffset - offset2;
  3439.     }
  3440.     if (checkAltAxis) {
  3441.       var _offsetModifierState$2;
  3442.       var _mainSide = mainAxis === "x" ? top : left;
  3443.       var _altSide = mainAxis === "x" ? bottom : right;
  3444.       var _offset = popperOffsets2[altAxis];
  3445.       var _len = altAxis === "y" ? "height" : "width";
  3446.       var _min = _offset + overflow[_mainSide];
  3447.       var _max = _offset - overflow[_altSide];
  3448.       var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
  3449.       var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
  3450.       var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
  3451.       var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
  3452.       var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
  3453.       popperOffsets2[altAxis] = _preventedOffset;
  3454.       data[altAxis] = _preventedOffset - _offset;
  3455.     }
  3456.     state2.modifiersData[name] = data;
  3457.   }
  3458.   const preventOverflow$1 = {
  3459.     name: "preventOverflow",
  3460.     enabled: true,
  3461.     phase: "main",
  3462.     fn: preventOverflow,
  3463.     requiresIfExists: ["offset"]
  3464.   };
  3465.   function getHTMLElementScroll(element) {
  3466.     return {
  3467.       scrollLeft: element.scrollLeft,
  3468.       scrollTop: element.scrollTop
  3469.     };
  3470.   }
  3471.   function getNodeScroll(node) {
  3472.     if (node === getWindow(node) || !isHTMLElement(node)) {
  3473.       return getWindowScroll(node);
  3474.     } else {
  3475.       return getHTMLElementScroll(node);
  3476.     }
  3477.   }
  3478.   function isElementScaled(element) {
  3479.     var rect = element.getBoundingClientRect();
  3480.     var scaleX = round(rect.width) / element.offsetWidth || 1;
  3481.     var scaleY = round(rect.height) / element.offsetHeight || 1;
  3482.     return scaleX !== 1 || scaleY !== 1;
  3483.   }
  3484.   function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
  3485.     if (isFixed === void 0) {
  3486.       isFixed = false;
  3487.     }
  3488.     var isOffsetParentAnElement = isHTMLElement(offsetParent);
  3489.     var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
  3490.     var documentElement = getDocumentElement(offsetParent);
  3491.     var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
  3492.     var scroll = {
  3493.       scrollLeft: 0,
  3494.       scrollTop: 0
  3495.     };
  3496.     var offsets = {
  3497.       x: 0,
  3498.       y: 0
  3499.     };
  3500.     if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
  3501.       if (getNodeName(offsetParent) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
  3502.       isScrollParent(documentElement)) {
  3503.         scroll = getNodeScroll(offsetParent);
  3504.       }
  3505.       if (isHTMLElement(offsetParent)) {
  3506.         offsets = getBoundingClientRect(offsetParent, true);
  3507.         offsets.x += offsetParent.clientLeft;
  3508.         offsets.y += offsetParent.clientTop;
  3509.       } else if (documentElement) {
  3510.         offsets.x = getWindowScrollBarX(documentElement);
  3511.       }
  3512.     }
  3513.     return {
  3514.       x: rect.left + scroll.scrollLeft - offsets.x,
  3515.       y: rect.top + scroll.scrollTop - offsets.y,
  3516.       width: rect.width,
  3517.       height: rect.height
  3518.     };
  3519.   }
  3520.   function order(modifiers) {
  3521.     var map = /* @__PURE__ */ new Map();
  3522.     var visited = /* @__PURE__ */ new Set();
  3523.     var result = [];
  3524.     modifiers.forEach(function(modifier) {
  3525.       map.set(modifier.name, modifier);
  3526.     });
  3527.     function sort(modifier) {
  3528.       visited.add(modifier.name);
  3529.       var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
  3530.       requires.forEach(function(dep) {
  3531.         if (!visited.has(dep)) {
  3532.           var depModifier = map.get(dep);
  3533.           if (depModifier) {
  3534.             sort(depModifier);
  3535.           }
  3536.         }
  3537.       });
  3538.       result.push(modifier);
  3539.     }
  3540.     modifiers.forEach(function(modifier) {
  3541.       if (!visited.has(modifier.name)) {
  3542.         sort(modifier);
  3543.       }
  3544.     });
  3545.     return result;
  3546.   }
  3547.   function orderModifiers(modifiers) {
  3548.     var orderedModifiers = order(modifiers);
  3549.     return modifierPhases.reduce(function(acc, phase) {
  3550.       return acc.concat(orderedModifiers.filter(function(modifier) {
  3551.         return modifier.phase === phase;
  3552.       }));
  3553.     }, []);
  3554.   }
  3555.   function debounce$1(fn2) {
  3556.     var pending;
  3557.     return function() {
  3558.       if (!pending) {
  3559.         pending = new Promise(function(resolve) {
  3560.           Promise.resolve().then(function() {
  3561.             pending = void 0;
  3562.             resolve(fn2());
  3563.           });
  3564.         });
  3565.       }
  3566.       return pending;
  3567.     };
  3568.   }
  3569.   function mergeByName(modifiers) {
  3570.     var merged = modifiers.reduce(function(merged2, current) {
  3571.       var existing = merged2[current.name];
  3572.       merged2[current.name] = existing ? Object.assign({}, existing, current, {
  3573.         options: Object.assign({}, existing.options, current.options),
  3574.         data: Object.assign({}, existing.data, current.data)
  3575.       }) : current;
  3576.       return merged2;
  3577.     }, {});
  3578.     return Object.keys(merged).map(function(key) {
  3579.       return merged[key];
  3580.     });
  3581.   }
  3582.   var DEFAULT_OPTIONS = {
  3583.     placement: "bottom",
  3584.     modifiers: [],
  3585.     strategy: "absolute"
  3586.   };
  3587.   function areValidElements() {
  3588.     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
  3589.       args[_key] = arguments[_key];
  3590.     }
  3591.     return !args.some(function(element) {
  3592.       return !(element && typeof element.getBoundingClientRect === "function");
  3593.     });
  3594.   }
  3595.   function popperGenerator(generatorOptions) {
  3596.     if (generatorOptions === void 0) {
  3597.       generatorOptions = {};
  3598.     }
  3599.     var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
  3600.     return function createPopper2(reference2, popper2, options) {
  3601.       if (options === void 0) {
  3602.         options = defaultOptions;
  3603.       }
  3604.       var state2 = {
  3605.         placement: "bottom",
  3606.         orderedModifiers: [],
  3607.         options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
  3608.         modifiersData: {},
  3609.         elements: {
  3610.           reference: reference2,
  3611.           popper: popper2
  3612.         },
  3613.         attributes: {},
  3614.         styles: {}
  3615.       };
  3616.       var effectCleanupFns = [];
  3617.       var isDestroyed = false;
  3618.       var instance = {
  3619.         state: state2,
  3620.         setOptions: function setOptions(setOptionsAction) {
  3621.           var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state2.options) : setOptionsAction;
  3622.           cleanupModifierEffects();
  3623.           state2.options = Object.assign({}, defaultOptions, state2.options, options2);
  3624.           state2.scrollParents = {
  3625.             reference: isElement$1(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
  3626.             popper: listScrollParents(popper2)
  3627.           };
  3628.           var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state2.options.modifiers)));
  3629.           state2.orderedModifiers = orderedModifiers.filter(function(m) {
  3630.             return m.enabled;
  3631.           });
  3632.           runModifierEffects();
  3633.           return instance.update();
  3634.         },
  3635.         // Sync update – it will always be executed, even if not necessary. This
  3636.         // is useful for low frequency updates where sync behavior simplifies the
  3637.         // logic.
  3638.         // For high frequency updates (e.g. `resize` and `scroll` events), always
  3639.         // prefer the async Popper#update method
  3640.         forceUpdate: function forceUpdate() {
  3641.           if (isDestroyed) {
  3642.             return;
  3643.           }
  3644.           var _state$elements = state2.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
  3645.           if (!areValidElements(reference3, popper3)) {
  3646.             return;
  3647.           }
  3648.           state2.rects = {
  3649.             reference: getCompositeRect(reference3, getOffsetParent(popper3), state2.options.strategy === "fixed"),
  3650.             popper: getLayoutRect(popper3)
  3651.           };
  3652.           state2.reset = false;
  3653.           state2.placement = state2.options.placement;
  3654.           state2.orderedModifiers.forEach(function(modifier) {
  3655.             return state2.modifiersData[modifier.name] = Object.assign({}, modifier.data);
  3656.           });
  3657.           for (var index2 = 0; index2 < state2.orderedModifiers.length; index2++) {
  3658.             if (state2.reset === true) {
  3659.               state2.reset = false;
  3660.               index2 = -1;
  3661.               continue;
  3662.             }
  3663.             var _state$orderedModifie = state2.orderedModifiers[index2], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
  3664.             if (typeof fn2 === "function") {
  3665.               state2 = fn2({
  3666.                 state: state2,
  3667.                 options: _options,
  3668.                 name,
  3669.                 instance
  3670.               }) || state2;
  3671.             }
  3672.           }
  3673.         },
  3674.         // Async and optimistically optimized update – it will not be executed if
  3675.         // not necessary (debounced to run at most once-per-tick)
  3676.         update: debounce$1(function() {
  3677.           return new Promise(function(resolve) {
  3678.             instance.forceUpdate();
  3679.             resolve(state2);
  3680.           });
  3681.         }),
  3682.         destroy: function destroy() {
  3683.           cleanupModifierEffects();
  3684.           isDestroyed = true;
  3685.         }
  3686.       };
  3687.       if (!areValidElements(reference2, popper2)) {
  3688.         return instance;
  3689.       }
  3690.       instance.setOptions(options).then(function(state3) {
  3691.         if (!isDestroyed && options.onFirstUpdate) {
  3692.           options.onFirstUpdate(state3);
  3693.         }
  3694.       });
  3695.       function runModifierEffects() {
  3696.         state2.orderedModifiers.forEach(function(_ref) {
  3697.           var name = _ref.name, _ref$options = _ref.options, options2 = _ref$options === void 0 ? {} : _ref$options, effect3 = _ref.effect;
  3698.           if (typeof effect3 === "function") {
  3699.             var cleanupFn = effect3({
  3700.               state: state2,
  3701.               name,
  3702.               instance,
  3703.               options: options2
  3704.             });
  3705.             var noopFn = function noopFn2() {
  3706.             };
  3707.             effectCleanupFns.push(cleanupFn || noopFn);
  3708.           }
  3709.         });
  3710.       }
  3711.       function cleanupModifierEffects() {
  3712.         effectCleanupFns.forEach(function(fn2) {
  3713.           return fn2();
  3714.         });
  3715.         effectCleanupFns = [];
  3716.       }
  3717.       return instance;
  3718.     };
  3719.   }
  3720.   var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
  3721.   var createPopper = /* @__PURE__ */ popperGenerator({
  3722.     defaultModifiers
  3723.   });
  3724.   var BOX_CLASS = "tippy-box";
  3725.   var CONTENT_CLASS = "tippy-content";
  3726.   var BACKDROP_CLASS = "tippy-backdrop";
  3727.   var ARROW_CLASS = "tippy-arrow";
  3728.   var SVG_ARROW_CLASS = "tippy-svg-arrow";
  3729.   var TOUCH_OPTIONS = {
  3730.     passive: true,
  3731.     capture: true
  3732.   };
  3733.   var TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO2() {
  3734.     return document.body;
  3735.   };
  3736.   function getValueAtIndexOrReturn(value, index2, defaultValue) {
  3737.     if (Array.isArray(value)) {
  3738.       var v = value[index2];
  3739.       return v == null ? Array.isArray(defaultValue) ? defaultValue[index2] : defaultValue : v;
  3740.     }
  3741.     return value;
  3742.   }
  3743.   function isType(value, type) {
  3744.     var str = {}.toString.call(value);
  3745.     return str.indexOf("[object") === 0 && str.indexOf(type + "]") > -1;
  3746.   }
  3747.   function invokeWithArgsOrReturn(value, args) {
  3748.     return typeof value === "function" ? value.apply(void 0, args) : value;
  3749.   }
  3750.   function debounce(fn5, ms) {
  3751.     if (ms === 0) {
  3752.       return fn5;
  3753.     }
  3754.     var timeout;
  3755.     return function(arg) {
  3756.       clearTimeout(timeout);
  3757.       timeout = setTimeout(function() {
  3758.         fn5(arg);
  3759.       }, ms);
  3760.     };
  3761.   }
  3762.   function splitBySpaces(value) {
  3763.     return value.split(/\s+/).filter(Boolean);
  3764.   }
  3765.   function normalizeToArray(value) {
  3766.     return [].concat(value);
  3767.   }
  3768.   function pushIfUnique(arr, value) {
  3769.     if (arr.indexOf(value) === -1) {
  3770.       arr.push(value);
  3771.     }
  3772.   }
  3773.   function unique(arr) {
  3774.     return arr.filter(function(item, index2) {
  3775.       return arr.indexOf(item) === index2;
  3776.     });
  3777.   }
  3778.   function getBasePlacement(placement) {
  3779.     return placement.split("-")[0];
  3780.   }
  3781.   function arrayFrom(value) {
  3782.     return [].slice.call(value);
  3783.   }
  3784.   function removeUndefinedProps(obj) {
  3785.     return Object.keys(obj).reduce(function(acc, key) {
  3786.       if (obj[key] !== void 0) {
  3787.         acc[key] = obj[key];
  3788.       }
  3789.       return acc;
  3790.     }, {});
  3791.   }
  3792.   function div() {
  3793.     return document.createElement("div");
  3794.   }
  3795.   function isElement(value) {
  3796.     return ["Element", "Fragment"].some(function(type) {
  3797.       return isType(value, type);
  3798.     });
  3799.   }
  3800.   function isNodeList(value) {
  3801.     return isType(value, "NodeList");
  3802.   }
  3803.   function isMouseEvent(value) {
  3804.     return isType(value, "MouseEvent");
  3805.   }
  3806.   function isReferenceElement(value) {
  3807.     return !!(value && value._tippy && value._tippy.reference === value);
  3808.   }
  3809.   function getArrayOfElements(value) {
  3810.     if (isElement(value)) {
  3811.       return [value];
  3812.     }
  3813.     if (isNodeList(value)) {
  3814.       return arrayFrom(value);
  3815.     }
  3816.     if (Array.isArray(value)) {
  3817.       return value;
  3818.     }
  3819.     return arrayFrom(document.querySelectorAll(value));
  3820.   }
  3821.   function setTransitionDuration(els, value) {
  3822.     els.forEach(function(el) {
  3823.       if (el) {
  3824.         el.style.transitionDuration = value + "ms";
  3825.       }
  3826.     });
  3827.   }
  3828.   function setVisibilityState(els, state2) {
  3829.     els.forEach(function(el) {
  3830.       if (el) {
  3831.         el.setAttribute("data-state", state2);
  3832.       }
  3833.     });
  3834.   }
  3835.   function getOwnerDocument(elementOrElements) {
  3836.     var _element$ownerDocumen;
  3837.     var _normalizeToArray = normalizeToArray(elementOrElements), element = _normalizeToArray[0];
  3838.     return element != null && (_element$ownerDocumen = element.ownerDocument) != null && _element$ownerDocumen.body ? element.ownerDocument : document;
  3839.   }
  3840.   function isCursorOutsideInteractiveBorder(popperTreeData, event) {
  3841.     var clientX = event.clientX, clientY = event.clientY;
  3842.     return popperTreeData.every(function(_ref) {
  3843.       var popperRect = _ref.popperRect, popperState = _ref.popperState, props = _ref.props;
  3844.       var interactiveBorder = props.interactiveBorder;
  3845.       var basePlacement = getBasePlacement(popperState.placement);
  3846.       var offsetData = popperState.modifiersData.offset;
  3847.       if (!offsetData) {
  3848.         return true;
  3849.       }
  3850.       var topDistance = basePlacement === "bottom" ? offsetData.top.y : 0;
  3851.       var bottomDistance = basePlacement === "top" ? offsetData.bottom.y : 0;
  3852.       var leftDistance = basePlacement === "right" ? offsetData.left.x : 0;
  3853.       var rightDistance = basePlacement === "left" ? offsetData.right.x : 0;
  3854.       var exceedsTop = popperRect.top - clientY + topDistance > interactiveBorder;
  3855.       var exceedsBottom = clientY - popperRect.bottom - bottomDistance > interactiveBorder;
  3856.       var exceedsLeft = popperRect.left - clientX + leftDistance > interactiveBorder;
  3857.       var exceedsRight = clientX - popperRect.right - rightDistance > interactiveBorder;
  3858.       return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;
  3859.     });
  3860.   }
  3861.   function updateTransitionEndListener(box, action2, listener) {
  3862.     var method = action2 + "EventListener";
  3863.     ["transitionend", "webkitTransitionEnd"].forEach(function(event) {
  3864.       box[method](event, listener);
  3865.     });
  3866.   }
  3867.   function actualContains(parent, child2) {
  3868.     var target = child2;
  3869.     while (target) {
  3870.       var _target$getRootNode;
  3871.       if (parent.contains(target)) {
  3872.         return true;
  3873.       }
  3874.       target = target.getRootNode == null ? void 0 : (_target$getRootNode = target.getRootNode()) == null ? void 0 : _target$getRootNode.host;
  3875.     }
  3876.     return false;
  3877.   }
  3878.   var currentInput = {
  3879.     isTouch: false
  3880.   };
  3881.   var lastMouseMoveTime = 0;
  3882.   function onDocumentTouchStart() {
  3883.     if (currentInput.isTouch) {
  3884.       return;
  3885.     }
  3886.     currentInput.isTouch = true;
  3887.     if (window.performance) {
  3888.       document.addEventListener("mousemove", onDocumentMouseMove);
  3889.     }
  3890.   }
  3891.   function onDocumentMouseMove() {
  3892.     var now = performance.now();
  3893.     if (now - lastMouseMoveTime < 20) {
  3894.       currentInput.isTouch = false;
  3895.       document.removeEventListener("mousemove", onDocumentMouseMove);
  3896.     }
  3897.     lastMouseMoveTime = now;
  3898.   }
  3899.   function onWindowBlur() {
  3900.     var activeElement = document.activeElement;
  3901.     if (isReferenceElement(activeElement)) {
  3902.       var instance = activeElement._tippy;
  3903.       if (activeElement.blur && !instance.state.isVisible) {
  3904.         activeElement.blur();
  3905.       }
  3906.     }
  3907.   }
  3908.   function bindGlobalEventListeners() {
  3909.     document.addEventListener("touchstart", onDocumentTouchStart, TOUCH_OPTIONS);
  3910.     window.addEventListener("blur", onWindowBlur);
  3911.   }
  3912.   var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
  3913.   var isIE11 = isBrowser ? (
  3914.     // @ts-ignore
  3915.     !!window.msCrypto
  3916.   ) : false;
  3917.   var pluginProps = {
  3918.     animateFill: false,
  3919.     followCursor: false,
  3920.     inlinePositioning: false,
  3921.     sticky: false
  3922.   };
  3923.   var renderProps = {
  3924.     allowHTML: false,
  3925.     animation: "fade",
  3926.     arrow: true,
  3927.     content: "",
  3928.     inertia: false,
  3929.     maxWidth: 350,
  3930.     role: "tooltip",
  3931.     theme: "",
  3932.     zIndex: 9999
  3933.   };
  3934.   var defaultProps = Object.assign({
  3935.     appendTo: TIPPY_DEFAULT_APPEND_TO,
  3936.     aria: {
  3937.       content: "auto",
  3938.       expanded: "auto"
  3939.     },
  3940.     delay: 0,
  3941.     duration: [300, 250],
  3942.     getReferenceClientRect: null,
  3943.     hideOnClick: true,
  3944.     ignoreAttributes: false,
  3945.     interactive: false,
  3946.     interactiveBorder: 2,
  3947.     interactiveDebounce: 0,
  3948.     moveTransition: "",
  3949.     offset: [0, 10],
  3950.     onAfterUpdate: function onAfterUpdate() {
  3951.     },
  3952.     onBeforeUpdate: function onBeforeUpdate() {
  3953.     },
  3954.     onCreate: function onCreate() {
  3955.     },
  3956.     onDestroy: function onDestroy() {
  3957.     },
  3958.     onHidden: function onHidden() {
  3959.     },
  3960.     onHide: function onHide() {
  3961.     },
  3962.     onMount: function onMount2() {
  3963.     },
  3964.     onShow: function onShow() {
  3965.     },
  3966.     onShown: function onShown() {
  3967.     },
  3968.     onTrigger: function onTrigger() {
  3969.     },
  3970.     onUntrigger: function onUntrigger() {
  3971.     },
  3972.     onClickOutside: function onClickOutside() {
  3973.     },
  3974.     placement: "top",
  3975.     plugins: [],
  3976.     popperOptions: {},
  3977.     render: null,
  3978.     showOnCreate: false,
  3979.     touch: true,
  3980.     trigger: "mouseenter focus",
  3981.     triggerTarget: null
  3982.   }, pluginProps, renderProps);
  3983.   var defaultKeys = Object.keys(defaultProps);
  3984.   var setDefaultProps = function setDefaultProps2(partialProps) {
  3985.     var keys = Object.keys(partialProps);
  3986.     keys.forEach(function(key) {
  3987.       defaultProps[key] = partialProps[key];
  3988.     });
  3989.   };
  3990.   function getExtendedPassedProps(passedProps) {
  3991.     var plugins = passedProps.plugins || [];
  3992.     var pluginProps2 = plugins.reduce(function(acc, plugin) {
  3993.       var name = plugin.name, defaultValue = plugin.defaultValue;
  3994.       if (name) {
  3995.         var _name;
  3996.         acc[name] = passedProps[name] !== void 0 ? passedProps[name] : (_name = defaultProps[name]) != null ? _name : defaultValue;
  3997.       }
  3998.       return acc;
  3999.     }, {});
  4000.     return Object.assign({}, passedProps, pluginProps2);
  4001.   }
  4002.   function getDataAttributeProps(reference2, plugins) {
  4003.     var propKeys = plugins ? Object.keys(getExtendedPassedProps(Object.assign({}, defaultProps, {
  4004.       plugins
  4005.     }))) : defaultKeys;
  4006.     var props = propKeys.reduce(function(acc, key) {
  4007.       var valueAsString = (reference2.getAttribute("data-tippy-" + key) || "").trim();
  4008.       if (!valueAsString) {
  4009.         return acc;
  4010.       }
  4011.       if (key === "content") {
  4012.         acc[key] = valueAsString;
  4013.       } else {
  4014.         try {
  4015.           acc[key] = JSON.parse(valueAsString);
  4016.         } catch (e2) {
  4017.           acc[key] = valueAsString;
  4018.         }
  4019.       }
  4020.       return acc;
  4021.     }, {});
  4022.     return props;
  4023.   }
  4024.   function evaluateProps(reference2, props) {
  4025.     var out = Object.assign({}, props, {
  4026.       content: invokeWithArgsOrReturn(props.content, [reference2])
  4027.     }, props.ignoreAttributes ? {} : getDataAttributeProps(reference2, props.plugins));
  4028.     out.aria = Object.assign({}, defaultProps.aria, out.aria);
  4029.     out.aria = {
  4030.       expanded: out.aria.expanded === "auto" ? props.interactive : out.aria.expanded,
  4031.       content: out.aria.content === "auto" ? props.interactive ? null : "describedby" : out.aria.content
  4032.     };
  4033.     return out;
  4034.   }
  4035.   var innerHTML = function innerHTML2() {
  4036.     return "innerHTML";
  4037.   };
  4038.   function dangerouslySetInnerHTML(element, html) {
  4039.     element[innerHTML()] = html;
  4040.   }
  4041.   function createArrowElement(value) {
  4042.     var arrow2 = div();
  4043.     if (value === true) {
  4044.       arrow2.className = ARROW_CLASS;
  4045.     } else {
  4046.       arrow2.className = SVG_ARROW_CLASS;
  4047.       if (isElement(value)) {
  4048.         arrow2.appendChild(value);
  4049.       } else {
  4050.         dangerouslySetInnerHTML(arrow2, value);
  4051.       }
  4052.     }
  4053.     return arrow2;
  4054.   }
  4055.   function setContent(content, props) {
  4056.     if (isElement(props.content)) {
  4057.       dangerouslySetInnerHTML(content, "");
  4058.       content.appendChild(props.content);
  4059.     } else if (typeof props.content !== "function") {
  4060.       if (props.allowHTML) {
  4061.         dangerouslySetInnerHTML(content, props.content);
  4062.       } else {
  4063.         content.textContent = props.content;
  4064.       }
  4065.     }
  4066.   }
  4067.   function getChildren(popper2) {
  4068.     var box = popper2.firstElementChild;
  4069.     var boxChildren = arrayFrom(box.children);
  4070.     return {
  4071.       box,
  4072.       content: boxChildren.find(function(node) {
  4073.         return node.classList.contains(CONTENT_CLASS);
  4074.       }),
  4075.       arrow: boxChildren.find(function(node) {
  4076.         return node.classList.contains(ARROW_CLASS) || node.classList.contains(SVG_ARROW_CLASS);
  4077.       }),
  4078.       backdrop: boxChildren.find(function(node) {
  4079.         return node.classList.contains(BACKDROP_CLASS);
  4080.       })
  4081.     };
  4082.   }
  4083.   function render(instance) {
  4084.     var popper2 = div();
  4085.     var box = div();
  4086.     box.className = BOX_CLASS;
  4087.     box.setAttribute("data-state", "hidden");
  4088.     box.setAttribute("tabindex", "-1");
  4089.     var content = div();
  4090.     content.className = CONTENT_CLASS;
  4091.     content.setAttribute("data-state", "hidden");
  4092.     setContent(content, instance.props);
  4093.     popper2.appendChild(box);
  4094.     box.appendChild(content);
  4095.     onUpdate(instance.props, instance.props);
  4096.     function onUpdate(prevProps, nextProps) {
  4097.       var _getChildren = getChildren(popper2), box2 = _getChildren.box, content2 = _getChildren.content, arrow2 = _getChildren.arrow;
  4098.       if (nextProps.theme) {
  4099.         box2.setAttribute("data-theme", nextProps.theme);
  4100.       } else {
  4101.         box2.removeAttribute("data-theme");
  4102.       }
  4103.       if (typeof nextProps.animation === "string") {
  4104.         box2.setAttribute("data-animation", nextProps.animation);
  4105.       } else {
  4106.         box2.removeAttribute("data-animation");
  4107.       }
  4108.       if (nextProps.inertia) {
  4109.         box2.setAttribute("data-inertia", "");
  4110.       } else {
  4111.         box2.removeAttribute("data-inertia");
  4112.       }
  4113.       box2.style.maxWidth = typeof nextProps.maxWidth === "number" ? nextProps.maxWidth + "px" : nextProps.maxWidth;
  4114.       if (nextProps.role) {
  4115.         box2.setAttribute("role", nextProps.role);
  4116.       } else {
  4117.         box2.removeAttribute("role");
  4118.       }
  4119.       if (prevProps.content !== nextProps.content || prevProps.allowHTML !== nextProps.allowHTML) {
  4120.         setContent(content2, instance.props);
  4121.       }
  4122.       if (nextProps.arrow) {
  4123.         if (!arrow2) {
  4124.           box2.appendChild(createArrowElement(nextProps.arrow));
  4125.         } else if (prevProps.arrow !== nextProps.arrow) {
  4126.           box2.removeChild(arrow2);
  4127.           box2.appendChild(createArrowElement(nextProps.arrow));
  4128.         }
  4129.       } else if (arrow2) {
  4130.         box2.removeChild(arrow2);
  4131.       }
  4132.     }
  4133.     return {
  4134.       popper: popper2,
  4135.       onUpdate
  4136.     };
  4137.   }
  4138.   render.$$tippy = true;
  4139.   var idCounter = 1;
  4140.   var mouseMoveListeners = [];
  4141.   var mountedInstances = [];
  4142.   function createTippy(reference2, passedProps) {
  4143.     var props = evaluateProps(reference2, Object.assign({}, defaultProps, getExtendedPassedProps(removeUndefinedProps(passedProps))));
  4144.     var showTimeout;
  4145.     var hideTimeout;
  4146.     var scheduleHideAnimationFrame;
  4147.     var isVisibleFromClick = false;
  4148.     var didHideDueToDocumentMouseDown = false;
  4149.     var didTouchMove = false;
  4150.     var ignoreOnFirstUpdate = false;
  4151.     var lastTriggerEvent;
  4152.     var currentTransitionEndListener;
  4153.     var onFirstUpdate;
  4154.     var listeners = [];
  4155.     var debouncedOnMouseMove = debounce(onMouseMove, props.interactiveDebounce);
  4156.     var currentTarget;
  4157.     var id = idCounter++;
  4158.     var popperInstance = null;
  4159.     var plugins = unique(props.plugins);
  4160.     var state2 = {
  4161.       // Is the instance currently enabled?
  4162.       isEnabled: true,
  4163.       // Is the tippy currently showing and not transitioning out?
  4164.       isVisible: false,
  4165.       // Has the instance been destroyed?
  4166.       isDestroyed: false,
  4167.       // Is the tippy currently mounted to the DOM?
  4168.       isMounted: false,
  4169.       // Has the tippy finished transitioning in?
  4170.       isShown: false
  4171.     };
  4172.     var instance = {
  4173.       // properties
  4174.       id,
  4175.       reference: reference2,
  4176.       popper: div(),
  4177.       popperInstance,
  4178.       props,
  4179.       state: state2,
  4180.       plugins,
  4181.       // methods
  4182.       clearDelayTimeouts,
  4183.       setProps,
  4184.       setContent: setContent2,
  4185.       show,
  4186.       hide: hide2,
  4187.       hideWithInteractivity,
  4188.       enable,
  4189.       disable,
  4190.       unmount,
  4191.       destroy
  4192.     };
  4193.     if (!props.render) {
  4194.       return instance;
  4195.     }
  4196.     var _props$render = props.render(instance), popper2 = _props$render.popper, onUpdate = _props$render.onUpdate;
  4197.     popper2.setAttribute("data-tippy-root", "");
  4198.     popper2.id = "tippy-" + instance.id;
  4199.     instance.popper = popper2;
  4200.     reference2._tippy = instance;
  4201.     popper2._tippy = instance;
  4202.     var pluginsHooks = plugins.map(function(plugin) {
  4203.       return plugin.fn(instance);
  4204.     });
  4205.     var hasAriaExpanded = reference2.hasAttribute("aria-expanded");
  4206.     addListeners();
  4207.     handleAriaExpandedAttribute();
  4208.     handleStyles();
  4209.     invokeHook("onCreate", [instance]);
  4210.     if (props.showOnCreate) {
  4211.       scheduleShow();
  4212.     }
  4213.     popper2.addEventListener("mouseenter", function() {
  4214.       if (instance.props.interactive && instance.state.isVisible) {
  4215.         instance.clearDelayTimeouts();
  4216.       }
  4217.     });
  4218.     popper2.addEventListener("mouseleave", function() {
  4219.       if (instance.props.interactive && instance.props.trigger.indexOf("mouseenter") >= 0) {
  4220.         getDocument().addEventListener("mousemove", debouncedOnMouseMove);
  4221.       }
  4222.     });
  4223.     return instance;
  4224.     function getNormalizedTouchSettings() {
  4225.       var touch = instance.props.touch;
  4226.       return Array.isArray(touch) ? touch : [touch, 0];
  4227.     }
  4228.     function getIsCustomTouchBehavior() {
  4229.       return getNormalizedTouchSettings()[0] === "hold";
  4230.     }
  4231.     function getIsDefaultRenderFn() {
  4232.       var _instance$props$rende;
  4233.       return !!((_instance$props$rende = instance.props.render) != null && _instance$props$rende.$$tippy);
  4234.     }
  4235.     function getCurrentTarget() {
  4236.       return currentTarget || reference2;
  4237.     }
  4238.     function getDocument() {
  4239.       var parent = getCurrentTarget().parentNode;
  4240.       return parent ? getOwnerDocument(parent) : document;
  4241.     }
  4242.     function getDefaultTemplateChildren() {
  4243.       return getChildren(popper2);
  4244.     }
  4245.     function getDelay(isShow) {
  4246.       if (instance.state.isMounted && !instance.state.isVisible || currentInput.isTouch || lastTriggerEvent && lastTriggerEvent.type === "focus") {
  4247.         return 0;
  4248.       }
  4249.       return getValueAtIndexOrReturn(instance.props.delay, isShow ? 0 : 1, defaultProps.delay);
  4250.     }
  4251.     function handleStyles(fromHide) {
  4252.       if (fromHide === void 0) {
  4253.         fromHide = false;
  4254.       }
  4255.       popper2.style.pointerEvents = instance.props.interactive && !fromHide ? "" : "none";
  4256.       popper2.style.zIndex = "" + instance.props.zIndex;
  4257.     }
  4258.     function invokeHook(hook, args, shouldInvokePropsHook) {
  4259.       if (shouldInvokePropsHook === void 0) {
  4260.         shouldInvokePropsHook = true;
  4261.       }
  4262.       pluginsHooks.forEach(function(pluginHooks) {
  4263.         if (pluginHooks[hook]) {
  4264.           pluginHooks[hook].apply(pluginHooks, args);
  4265.         }
  4266.       });
  4267.       if (shouldInvokePropsHook) {
  4268.         var _instance$props;
  4269.         (_instance$props = instance.props)[hook].apply(_instance$props, args);
  4270.       }
  4271.     }
  4272.     function handleAriaContentAttribute() {
  4273.       var aria = instance.props.aria;
  4274.       if (!aria.content) {
  4275.         return;
  4276.       }
  4277.       var attr = "aria-" + aria.content;
  4278.       var id2 = popper2.id;
  4279.       var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
  4280.       nodes.forEach(function(node) {
  4281.         var currentValue = node.getAttribute(attr);
  4282.         if (instance.state.isVisible) {
  4283.           node.setAttribute(attr, currentValue ? currentValue + " " + id2 : id2);
  4284.         } else {
  4285.           var nextValue = currentValue && currentValue.replace(id2, "").trim();
  4286.           if (nextValue) {
  4287.             node.setAttribute(attr, nextValue);
  4288.           } else {
  4289.             node.removeAttribute(attr);
  4290.           }
  4291.         }
  4292.       });
  4293.     }
  4294.     function handleAriaExpandedAttribute() {
  4295.       if (hasAriaExpanded || !instance.props.aria.expanded) {
  4296.         return;
  4297.       }
  4298.       var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
  4299.       nodes.forEach(function(node) {
  4300.         if (instance.props.interactive) {
  4301.           node.setAttribute("aria-expanded", instance.state.isVisible && node === getCurrentTarget() ? "true" : "false");
  4302.         } else {
  4303.           node.removeAttribute("aria-expanded");
  4304.         }
  4305.       });
  4306.     }
  4307.     function cleanupInteractiveMouseListeners() {
  4308.       getDocument().removeEventListener("mousemove", debouncedOnMouseMove);
  4309.       mouseMoveListeners = mouseMoveListeners.filter(function(listener) {
  4310.         return listener !== debouncedOnMouseMove;
  4311.       });
  4312.     }
  4313.     function onDocumentPress(event) {
  4314.       if (currentInput.isTouch) {
  4315.         if (didTouchMove || event.type === "mousedown") {
  4316.           return;
  4317.         }
  4318.       }
  4319.       var actualTarget = event.composedPath && event.composedPath()[0] || event.target;
  4320.       if (instance.props.interactive && actualContains(popper2, actualTarget)) {
  4321.         return;
  4322.       }
  4323.       if (normalizeToArray(instance.props.triggerTarget || reference2).some(function(el) {
  4324.         return actualContains(el, actualTarget);
  4325.       })) {
  4326.         if (currentInput.isTouch) {
  4327.           return;
  4328.         }
  4329.         if (instance.state.isVisible && instance.props.trigger.indexOf("click") >= 0) {
  4330.           return;
  4331.         }
  4332.       } else {
  4333.         invokeHook("onClickOutside", [instance, event]);
  4334.       }
  4335.       if (instance.props.hideOnClick === true) {
  4336.         instance.clearDelayTimeouts();
  4337.         instance.hide();
  4338.         didHideDueToDocumentMouseDown = true;
  4339.         setTimeout(function() {
  4340.           didHideDueToDocumentMouseDown = false;
  4341.         });
  4342.         if (!instance.state.isMounted) {
  4343.           removeDocumentPress();
  4344.         }
  4345.       }
  4346.     }
  4347.     function onTouchMove() {
  4348.       didTouchMove = true;
  4349.     }
  4350.     function onTouchStart() {
  4351.       didTouchMove = false;
  4352.     }
  4353.     function addDocumentPress() {
  4354.       var doc = getDocument();
  4355.       doc.addEventListener("mousedown", onDocumentPress, true);
  4356.       doc.addEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
  4357.       doc.addEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
  4358.       doc.addEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
  4359.     }
  4360.     function removeDocumentPress() {
  4361.       var doc = getDocument();
  4362.       doc.removeEventListener("mousedown", onDocumentPress, true);
  4363.       doc.removeEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
  4364.       doc.removeEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
  4365.       doc.removeEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
  4366.     }
  4367.     function onTransitionedOut(duration, callback) {
  4368.       onTransitionEnd(duration, function() {
  4369.         if (!instance.state.isVisible && popper2.parentNode && popper2.parentNode.contains(popper2)) {
  4370.           callback();
  4371.         }
  4372.       });
  4373.     }
  4374.     function onTransitionedIn(duration, callback) {
  4375.       onTransitionEnd(duration, callback);
  4376.     }
  4377.     function onTransitionEnd(duration, callback) {
  4378.       var box = getDefaultTemplateChildren().box;
  4379.       function listener(event) {
  4380.         if (event.target === box) {
  4381.           updateTransitionEndListener(box, "remove", listener);
  4382.           callback();
  4383.         }
  4384.       }
  4385.       if (duration === 0) {
  4386.         return callback();
  4387.       }
  4388.       updateTransitionEndListener(box, "remove", currentTransitionEndListener);
  4389.       updateTransitionEndListener(box, "add", listener);
  4390.       currentTransitionEndListener = listener;
  4391.     }
  4392.     function on(eventType, handler, options) {
  4393.       if (options === void 0) {
  4394.         options = false;
  4395.       }
  4396.       var nodes = normalizeToArray(instance.props.triggerTarget || reference2);
  4397.       nodes.forEach(function(node) {
  4398.         node.addEventListener(eventType, handler, options);
  4399.         listeners.push({
  4400.           node,
  4401.           eventType,
  4402.           handler,
  4403.           options
  4404.         });
  4405.       });
  4406.     }
  4407.     function addListeners() {
  4408.       if (getIsCustomTouchBehavior()) {
  4409.         on("touchstart", onTrigger2, {
  4410.           passive: true
  4411.         });
  4412.         on("touchend", onMouseLeave, {
  4413.           passive: true
  4414.         });
  4415.       }
  4416.       splitBySpaces(instance.props.trigger).forEach(function(eventType) {
  4417.         if (eventType === "manual") {
  4418.           return;
  4419.         }
  4420.         on(eventType, onTrigger2);
  4421.         switch (eventType) {
  4422.           case "mouseenter":
  4423.             on("mouseleave", onMouseLeave);
  4424.             break;
  4425.           case "focus":
  4426.             on(isIE11 ? "focusout" : "blur", onBlurOrFocusOut);
  4427.             break;
  4428.           case "focusin":
  4429.             on("focusout", onBlurOrFocusOut);
  4430.             break;
  4431.         }
  4432.       });
  4433.     }
  4434.     function removeListeners() {
  4435.       listeners.forEach(function(_ref) {
  4436.         var node = _ref.node, eventType = _ref.eventType, handler = _ref.handler, options = _ref.options;
  4437.         node.removeEventListener(eventType, handler, options);
  4438.       });
  4439.       listeners = [];
  4440.     }
  4441.     function onTrigger2(event) {
  4442.       var _lastTriggerEvent;
  4443.       var shouldScheduleClickHide = false;
  4444.       if (!instance.state.isEnabled || isEventListenerStopped(event) || didHideDueToDocumentMouseDown) {
  4445.         return;
  4446.       }
  4447.       var wasFocused = ((_lastTriggerEvent = lastTriggerEvent) == null ? void 0 : _lastTriggerEvent.type) === "focus";
  4448.       lastTriggerEvent = event;
  4449.       currentTarget = event.currentTarget;
  4450.       handleAriaExpandedAttribute();
  4451.       if (!instance.state.isVisible && isMouseEvent(event)) {
  4452.         mouseMoveListeners.forEach(function(listener) {
  4453.           return listener(event);
  4454.         });
  4455.       }
  4456.       if (event.type === "click" && (instance.props.trigger.indexOf("mouseenter") < 0 || isVisibleFromClick) && instance.props.hideOnClick !== false && instance.state.isVisible) {
  4457.         shouldScheduleClickHide = true;
  4458.       } else {
  4459.         scheduleShow(event);
  4460.       }
  4461.       if (event.type === "click") {
  4462.         isVisibleFromClick = !shouldScheduleClickHide;
  4463.       }
  4464.       if (shouldScheduleClickHide && !wasFocused) {
  4465.         scheduleHide(event);
  4466.       }
  4467.     }
  4468.     function onMouseMove(event) {
  4469.       var target = event.target;
  4470.       var isCursorOverReferenceOrPopper = getCurrentTarget().contains(target) || popper2.contains(target);
  4471.       if (event.type === "mousemove" && isCursorOverReferenceOrPopper) {
  4472.         return;
  4473.       }
  4474.       var popperTreeData = getNestedPopperTree().concat(popper2).map(function(popper22) {
  4475.         var _instance$popperInsta;
  4476.         var instance2 = popper22._tippy;
  4477.         var state22 = (_instance$popperInsta = instance2.popperInstance) == null ? void 0 : _instance$popperInsta.state;
  4478.         if (state22) {
  4479.           return {
  4480.             popperRect: popper22.getBoundingClientRect(),
  4481.             popperState: state22,
  4482.             props
  4483.           };
  4484.         }
  4485.         return null;
  4486.       }).filter(Boolean);
  4487.       if (isCursorOutsideInteractiveBorder(popperTreeData, event)) {
  4488.         cleanupInteractiveMouseListeners();
  4489.         scheduleHide(event);
  4490.       }
  4491.     }
  4492.     function onMouseLeave(event) {
  4493.       var shouldBail = isEventListenerStopped(event) || instance.props.trigger.indexOf("click") >= 0 && isVisibleFromClick;
  4494.       if (shouldBail) {
  4495.         return;
  4496.       }
  4497.       if (instance.props.interactive) {
  4498.         instance.hideWithInteractivity(event);
  4499.         return;
  4500.       }
  4501.       scheduleHide(event);
  4502.     }
  4503.     function onBlurOrFocusOut(event) {
  4504.       if (instance.props.trigger.indexOf("focusin") < 0 && event.target !== getCurrentTarget()) {
  4505.         return;
  4506.       }
  4507.       if (instance.props.interactive && event.relatedTarget && popper2.contains(event.relatedTarget)) {
  4508.         return;
  4509.       }
  4510.       scheduleHide(event);
  4511.     }
  4512.     function isEventListenerStopped(event) {
  4513.       return currentInput.isTouch ? getIsCustomTouchBehavior() !== event.type.indexOf("touch") >= 0 : false;
  4514.     }
  4515.     function createPopperInstance() {
  4516.       destroyPopperInstance();
  4517.       var _instance$props2 = instance.props, popperOptions = _instance$props2.popperOptions, placement = _instance$props2.placement, offset2 = _instance$props2.offset, getReferenceClientRect = _instance$props2.getReferenceClientRect, moveTransition = _instance$props2.moveTransition;
  4518.       var arrow2 = getIsDefaultRenderFn() ? getChildren(popper2).arrow : null;
  4519.       var computedReference = getReferenceClientRect ? {
  4520.         getBoundingClientRect: getReferenceClientRect,
  4521.         contextElement: getReferenceClientRect.contextElement || getCurrentTarget()
  4522.       } : reference2;
  4523.       var tippyModifier = {
  4524.         name: "$$tippy",
  4525.         enabled: true,
  4526.         phase: "beforeWrite",
  4527.         requires: ["computeStyles"],
  4528.         fn: function fn5(_ref2) {
  4529.           var state22 = _ref2.state;
  4530.           if (getIsDefaultRenderFn()) {
  4531.             var _getDefaultTemplateCh = getDefaultTemplateChildren(), box = _getDefaultTemplateCh.box;
  4532.             ["placement", "reference-hidden", "escaped"].forEach(function(attr) {
  4533.               if (attr === "placement") {
  4534.                 box.setAttribute("data-placement", state22.placement);
  4535.               } else {
  4536.                 if (state22.attributes.popper["data-popper-" + attr]) {
  4537.                   box.setAttribute("data-" + attr, "");
  4538.                 } else {
  4539.                   box.removeAttribute("data-" + attr);
  4540.                 }
  4541.               }
  4542.             });
  4543.             state22.attributes.popper = {};
  4544.           }
  4545.         }
  4546.       };
  4547.       var modifiers = [{
  4548.         name: "offset",
  4549.         options: {
  4550.           offset: offset2
  4551.         }
  4552.       }, {
  4553.         name: "preventOverflow",
  4554.         options: {
  4555.           padding: {
  4556.             top: 2,
  4557.             bottom: 2,
  4558.             left: 5,
  4559.             right: 5
  4560.           }
  4561.         }
  4562.       }, {
  4563.         name: "flip",
  4564.         options: {
  4565.           padding: 5
  4566.         }
  4567.       }, {
  4568.         name: "computeStyles",
  4569.         options: {
  4570.           adaptive: !moveTransition
  4571.         }
  4572.       }, tippyModifier];
  4573.       if (getIsDefaultRenderFn() && arrow2) {
  4574.         modifiers.push({
  4575.           name: "arrow",
  4576.           options: {
  4577.             element: arrow2,
  4578.             padding: 3
  4579.           }
  4580.         });
  4581.       }
  4582.       modifiers.push.apply(modifiers, (popperOptions == null ? void 0 : popperOptions.modifiers) || []);
  4583.       instance.popperInstance = createPopper(computedReference, popper2, Object.assign({}, popperOptions, {
  4584.         placement,
  4585.         onFirstUpdate,
  4586.         modifiers
  4587.       }));
  4588.     }
  4589.     function destroyPopperInstance() {
  4590.       if (instance.popperInstance) {
  4591.         instance.popperInstance.destroy();
  4592.         instance.popperInstance = null;
  4593.       }
  4594.     }
  4595.     function mount2() {
  4596.       var appendTo = instance.props.appendTo;
  4597.       var parentNode;
  4598.       var node = getCurrentTarget();
  4599.       if (instance.props.interactive && appendTo === TIPPY_DEFAULT_APPEND_TO || appendTo === "parent") {
  4600.         parentNode = node.parentNode;
  4601.       } else {
  4602.         parentNode = invokeWithArgsOrReturn(appendTo, [node]);
  4603.       }
  4604.       if (!parentNode.contains(popper2)) {
  4605.         parentNode.appendChild(popper2);
  4606.       }
  4607.       instance.state.isMounted = true;
  4608.       createPopperInstance();
  4609.     }
  4610.     function getNestedPopperTree() {
  4611.       return arrayFrom(popper2.querySelectorAll("[data-tippy-root]"));
  4612.     }
  4613.     function scheduleShow(event) {
  4614.       instance.clearDelayTimeouts();
  4615.       if (event) {
  4616.         invokeHook("onTrigger", [instance, event]);
  4617.       }
  4618.       addDocumentPress();
  4619.       var delay = getDelay(true);
  4620.       var _getNormalizedTouchSe = getNormalizedTouchSettings(), touchValue = _getNormalizedTouchSe[0], touchDelay = _getNormalizedTouchSe[1];
  4621.       if (currentInput.isTouch && touchValue === "hold" && touchDelay) {
  4622.         delay = touchDelay;
  4623.       }
  4624.       if (delay) {
  4625.         showTimeout = setTimeout(function() {
  4626.           instance.show();
  4627.         }, delay);
  4628.       } else {
  4629.         instance.show();
  4630.       }
  4631.     }
  4632.     function scheduleHide(event) {
  4633.       instance.clearDelayTimeouts();
  4634.       invokeHook("onUntrigger", [instance, event]);
  4635.       if (!instance.state.isVisible) {
  4636.         removeDocumentPress();
  4637.         return;
  4638.       }
  4639.       if (instance.props.trigger.indexOf("mouseenter") >= 0 && instance.props.trigger.indexOf("click") >= 0 && ["mouseleave", "mousemove"].indexOf(event.type) >= 0 && isVisibleFromClick) {
  4640.         return;
  4641.       }
  4642.       var delay = getDelay(false);
  4643.       if (delay) {
  4644.         hideTimeout = setTimeout(function() {
  4645.           if (instance.state.isVisible) {
  4646.             instance.hide();
  4647.           }
  4648.         }, delay);
  4649.       } else {
  4650.         scheduleHideAnimationFrame = requestAnimationFrame(function() {
  4651.           instance.hide();
  4652.         });
  4653.       }
  4654.     }
  4655.     function enable() {
  4656.       instance.state.isEnabled = true;
  4657.     }
  4658.     function disable() {
  4659.       instance.hide();
  4660.       instance.state.isEnabled = false;
  4661.     }
  4662.     function clearDelayTimeouts() {
  4663.       clearTimeout(showTimeout);
  4664.       clearTimeout(hideTimeout);
  4665.       cancelAnimationFrame(scheduleHideAnimationFrame);
  4666.     }
  4667.     function setProps(partialProps) {
  4668.       if (instance.state.isDestroyed) {
  4669.         return;
  4670.       }
  4671.       invokeHook("onBeforeUpdate", [instance, partialProps]);
  4672.       removeListeners();
  4673.       var prevProps = instance.props;
  4674.       var nextProps = evaluateProps(reference2, Object.assign({}, prevProps, removeUndefinedProps(partialProps), {
  4675.         ignoreAttributes: true
  4676.       }));
  4677.       instance.props = nextProps;
  4678.       addListeners();
  4679.       if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) {
  4680.         cleanupInteractiveMouseListeners();
  4681.         debouncedOnMouseMove = debounce(onMouseMove, nextProps.interactiveDebounce);
  4682.       }
  4683.       if (prevProps.triggerTarget && !nextProps.triggerTarget) {
  4684.         normalizeToArray(prevProps.triggerTarget).forEach(function(node) {
  4685.           node.removeAttribute("aria-expanded");
  4686.         });
  4687.       } else if (nextProps.triggerTarget) {
  4688.         reference2.removeAttribute("aria-expanded");
  4689.       }
  4690.       handleAriaExpandedAttribute();
  4691.       handleStyles();
  4692.       if (onUpdate) {
  4693.         onUpdate(prevProps, nextProps);
  4694.       }
  4695.       if (instance.popperInstance) {
  4696.         createPopperInstance();
  4697.         getNestedPopperTree().forEach(function(nestedPopper) {
  4698.           requestAnimationFrame(nestedPopper._tippy.popperInstance.forceUpdate);
  4699.         });
  4700.       }
  4701.       invokeHook("onAfterUpdate", [instance, partialProps]);
  4702.     }
  4703.     function setContent2(content) {
  4704.       instance.setProps({
  4705.         content
  4706.       });
  4707.     }
  4708.     function show() {
  4709.       var isAlreadyVisible = instance.state.isVisible;
  4710.       var isDestroyed = instance.state.isDestroyed;
  4711.       var isDisabled = !instance.state.isEnabled;
  4712.       var isTouchAndTouchDisabled = currentInput.isTouch && !instance.props.touch;
  4713.       var duration = getValueAtIndexOrReturn(instance.props.duration, 0, defaultProps.duration);
  4714.       if (isAlreadyVisible || isDestroyed || isDisabled || isTouchAndTouchDisabled) {
  4715.         return;
  4716.       }
  4717.       if (getCurrentTarget().hasAttribute("disabled")) {
  4718.         return;
  4719.       }
  4720.       invokeHook("onShow", [instance], false);
  4721.       if (instance.props.onShow(instance) === false) {
  4722.         return;
  4723.       }
  4724.       instance.state.isVisible = true;
  4725.       if (getIsDefaultRenderFn()) {
  4726.         popper2.style.visibility = "visible";
  4727.       }
  4728.       handleStyles();
  4729.       addDocumentPress();
  4730.       if (!instance.state.isMounted) {
  4731.         popper2.style.transition = "none";
  4732.       }
  4733.       if (getIsDefaultRenderFn()) {
  4734.         var _getDefaultTemplateCh2 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh2.box, content = _getDefaultTemplateCh2.content;
  4735.         setTransitionDuration([box, content], 0);
  4736.       }
  4737.       onFirstUpdate = function onFirstUpdate2() {
  4738.         var _instance$popperInsta2;
  4739.         if (!instance.state.isVisible || ignoreOnFirstUpdate) {
  4740.           return;
  4741.         }
  4742.         ignoreOnFirstUpdate = true;
  4743.         void popper2.offsetHeight;
  4744.         popper2.style.transition = instance.props.moveTransition;
  4745.         if (getIsDefaultRenderFn() && instance.props.animation) {
  4746.           var _getDefaultTemplateCh3 = getDefaultTemplateChildren(), _box = _getDefaultTemplateCh3.box, _content = _getDefaultTemplateCh3.content;
  4747.           setTransitionDuration([_box, _content], duration);
  4748.           setVisibilityState([_box, _content], "visible");
  4749.         }
  4750.         handleAriaContentAttribute();
  4751.         handleAriaExpandedAttribute();
  4752.         pushIfUnique(mountedInstances, instance);
  4753.         (_instance$popperInsta2 = instance.popperInstance) == null ? void 0 : _instance$popperInsta2.forceUpdate();
  4754.         invokeHook("onMount", [instance]);
  4755.         if (instance.props.animation && getIsDefaultRenderFn()) {
  4756.           onTransitionedIn(duration, function() {
  4757.             instance.state.isShown = true;
  4758.             invokeHook("onShown", [instance]);
  4759.           });
  4760.         }
  4761.       };
  4762.       mount2();
  4763.     }
  4764.     function hide2() {
  4765.       var isAlreadyHidden = !instance.state.isVisible;
  4766.       var isDestroyed = instance.state.isDestroyed;
  4767.       var isDisabled = !instance.state.isEnabled;
  4768.       var duration = getValueAtIndexOrReturn(instance.props.duration, 1, defaultProps.duration);
  4769.       if (isAlreadyHidden || isDestroyed || isDisabled) {
  4770.         return;
  4771.       }
  4772.       invokeHook("onHide", [instance], false);
  4773.       if (instance.props.onHide(instance) === false) {
  4774.         return;
  4775.       }
  4776.       instance.state.isVisible = false;
  4777.       instance.state.isShown = false;
  4778.       ignoreOnFirstUpdate = false;
  4779.       isVisibleFromClick = false;
  4780.       if (getIsDefaultRenderFn()) {
  4781.         popper2.style.visibility = "hidden";
  4782.       }
  4783.       cleanupInteractiveMouseListeners();
  4784.       removeDocumentPress();
  4785.       handleStyles(true);
  4786.       if (getIsDefaultRenderFn()) {
  4787.         var _getDefaultTemplateCh4 = getDefaultTemplateChildren(), box = _getDefaultTemplateCh4.box, content = _getDefaultTemplateCh4.content;
  4788.         if (instance.props.animation) {
  4789.           setTransitionDuration([box, content], duration);
  4790.           setVisibilityState([box, content], "hidden");
  4791.         }
  4792.       }
  4793.       handleAriaContentAttribute();
  4794.       handleAriaExpandedAttribute();
  4795.       if (instance.props.animation) {
  4796.         if (getIsDefaultRenderFn()) {
  4797.           onTransitionedOut(duration, instance.unmount);
  4798.         }
  4799.       } else {
  4800.         instance.unmount();
  4801.       }
  4802.     }
  4803.     function hideWithInteractivity(event) {
  4804.       getDocument().addEventListener("mousemove", debouncedOnMouseMove);
  4805.       pushIfUnique(mouseMoveListeners, debouncedOnMouseMove);
  4806.       debouncedOnMouseMove(event);
  4807.     }
  4808.     function unmount() {
  4809.       if (instance.state.isVisible) {
  4810.         instance.hide();
  4811.       }
  4812.       if (!instance.state.isMounted) {
  4813.         return;
  4814.       }
  4815.       destroyPopperInstance();
  4816.       getNestedPopperTree().forEach(function(nestedPopper) {
  4817.         nestedPopper._tippy.unmount();
  4818.       });
  4819.       if (popper2.parentNode) {
  4820.         popper2.parentNode.removeChild(popper2);
  4821.       }
  4822.       mountedInstances = mountedInstances.filter(function(i2) {
  4823.         return i2 !== instance;
  4824.       });
  4825.       instance.state.isMounted = false;
  4826.       invokeHook("onHidden", [instance]);
  4827.     }
  4828.     function destroy() {
  4829.       if (instance.state.isDestroyed) {
  4830.         return;
  4831.       }
  4832.       instance.clearDelayTimeouts();
  4833.       instance.unmount();
  4834.       removeListeners();
  4835.       delete reference2._tippy;
  4836.       instance.state.isDestroyed = true;
  4837.       invokeHook("onDestroy", [instance]);
  4838.     }
  4839.   }
  4840.   function tippy(targets, optionalProps) {
  4841.     if (optionalProps === void 0) {
  4842.       optionalProps = {};
  4843.     }
  4844.     var plugins = defaultProps.plugins.concat(optionalProps.plugins || []);
  4845.     bindGlobalEventListeners();
  4846.     var passedProps = Object.assign({}, optionalProps, {
  4847.       plugins
  4848.     });
  4849.     var elements = getArrayOfElements(targets);
  4850.     var instances = elements.reduce(function(acc, reference2) {
  4851.       var instance = reference2 && createTippy(reference2, passedProps);
  4852.       if (instance) {
  4853.         acc.push(instance);
  4854.       }
  4855.       return acc;
  4856.     }, []);
  4857.     return isElement(targets) ? instances[0] : instances;
  4858.   }
  4859.   tippy.defaultProps = defaultProps;
  4860.   tippy.setDefaultProps = setDefaultProps;
  4861.   tippy.currentInput = currentInput;
  4862.   Object.assign({}, applyStyles$1, {
  4863.     effect: function effect2(_ref) {
  4864.       var state2 = _ref.state;
  4865.       var initialStyles = {
  4866.         popper: {
  4867.           position: state2.options.strategy,
  4868.           left: "0",
  4869.           top: "0",
  4870.           margin: "0"
  4871.         },
  4872.         arrow: {
  4873.           position: "absolute"
  4874.         },
  4875.         reference: {}
  4876.       };
  4877.       Object.assign(state2.elements.popper.style, initialStyles.popper);
  4878.       state2.styles = initialStyles;
  4879.       if (state2.elements.arrow) {
  4880.         Object.assign(state2.elements.arrow.style, initialStyles.arrow);
  4881.       }
  4882.     }
  4883.   });
  4884.   tippy.setDefaultProps({
  4885.     render
  4886.   });
  4887.   var on_click$5 = (_, editor, $$props) => {
  4888.     editor == null ? void 0 : editor.insertAtCursor($$props.display);
  4889.   };
  4890.   var root_1$1 = /* @__PURE__ */ template(`<button class="svelte-1ewjpur"> </button>`);
  4891.   var root$4 = /* @__PURE__ */ template(`<button class="svelte-1ewjpur"> </button> <div class="variants svelte-1ewjpur"></div>`, 1);
  4892.   function KanaButton($$anchor, $$props) {
  4893.     push($$props, true);
  4894.     let instance;
  4895.     let button;
  4896.     let variantsContainer;
  4897.     let active = state(false);
  4898.     onMount(() => {
  4899.       instance = tippy(button, {
  4900.         content: variantsContainer,
  4901.         theme: "kana",
  4902.         interactive: true,
  4903.         offset: [0, 0],
  4904.         placement: "right",
  4905.         onShow: () => {
  4906.           set(active, true);
  4907.         },
  4908.         onHide: () => {
  4909.           set(active, false);
  4910.         }
  4911.       });
  4912.     });
  4913.     const editor = getContext("editor");
  4914.     var fragment = root$4();
  4915.     var button_1 = first_child(fragment);
  4916.     bind_this(button_1, ($$value) => button = $$value, () => button);
  4917.     button_1.__click = [on_click$5, editor, $$props];
  4918.     var text = child(button_1);
  4919.     var div2 = sibling(button_1, 2);
  4920.     bind_this(div2, ($$value) => variantsContainer = $$value, () => variantsContainer);
  4921.     each(div2, 21, () => $$props.variants, index, ($$anchor2, variant) => {
  4922.       var button_2 = root_1$1();
  4923.       button_2.__click = () => {
  4924.         if (editor) {
  4925.           editor.insertAtCursor(get(variant));
  4926.         }
  4927.         instance.hide();
  4928.       };
  4929.       var text_1 = child(button_2);
  4930.       template_effect(() => set_text(text_1, get(variant)));
  4931.       append($$anchor2, button_2);
  4932.     });
  4933.     template_effect(() => {
  4934.       toggle_class(button_1, "active", get(active));
  4935.       set_text(text, $$props.display);
  4936.     });
  4937.     append($$anchor, fragment);
  4938.     pop();
  4939.   }
  4940.   delegate(["click"]);
  4941.   var e = { dragStart: true }, t = (e2, t2, n2) => Math.min(Math.max(e2, t2), n2), n = (e2) => "string" == typeof e2, r = ([e2, t2], n2, r2) => {
  4942.     const o2 = (e3, t3) => 0 === t3 ? 0 : Math.ceil(e3 / t3) * t3;
  4943.     return [o2(n2, e2), o2(r2, t2)];
  4944.   };
  4945.   var o = (e2, t2) => e2.some((e3) => t2.some((t3) => e3.contains(t3)));
  4946.   function i(e2, t2) {
  4947.     if (void 0 === e2) return;
  4948.     if (s(e2)) return e2.getBoundingClientRect();
  4949.     if ("object" == typeof e2) {
  4950.       const { top: t3 = 0, left: n3 = 0, right: r2 = 0, bottom: o2 = 0 } = e2;
  4951.       return { top: t3, right: window.innerWidth - r2, bottom: window.innerHeight - o2, left: n3 };
  4952.     }
  4953.     if ("parent" === e2) return t2.parentNode.getBoundingClientRect();
  4954.     const n2 = document.querySelector(e2);
  4955.     if (null === n2) throw new Error("The selector provided for bound doesn't exists in the document.");
  4956.     return n2.getBoundingClientRect();
  4957.   }
  4958.   var a = (e2, t2, n2) => e2.style.setProperty(t2, n2), s = (e2) => e2 instanceof HTMLElement, d = (d2, l = {}) => {
  4959.     let c, u, { bounds: f, axis: g = "both", gpuAcceleration: h = true, legacyTranslate: p = true, transform: m, applyUserSelectHack: w = true, disabled: y = false, ignoreMultitouch: b = false, recomputeBounds: v = e, grid: x, position: E, cancel: S, handle: A, defaultClass: C = "neodrag", defaultClassDragging: N = "neodrag-dragging", defaultClassDragged: D = "neodrag-dragged", defaultPosition: M = { x: 0, y: 0 }, onDragStart: B, onDrag: $, onDragEnd: R } = l, H = false, L = 0, T = 0, X = 0, Y = 0, q = 0, P = 0, { x: k, y: z } = E ? { x: (E == null ? void 0 : E.x) ?? 0, y: (E == null ? void 0 : E.y) ?? 0 } : M;
  4960.     V(k, z);
  4961.     let I, U, W, j, F, G = "", J = !!E;
  4962.     v = { ...e, ...v };
  4963.     let K = /* @__PURE__ */ new Set();
  4964.     const O = document.body.style, Q = d2.classList;
  4965.     function V(e2 = L, t2 = T) {
  4966.       if (!m) {
  4967.         if (p) {
  4968.           let n2 = `${+e2}px, ${+t2}px`;
  4969.           return a(d2, "transform", h ? `translate3d(${n2}, 0)` : `translate(${n2})`);
  4970.         }
  4971.         return a(d2, "translate", `${+e2}px ${+t2}px ${h ? "1px" : ""}`);
  4972.       }
  4973.       const r2 = m({ offsetX: e2, offsetY: t2, rootNode: d2 });
  4974.       n(r2) && a(d2, "transform", r2);
  4975.     }
  4976.     const Z = (e2, t2) => {
  4977.       const n2 = { offsetX: L, offsetY: T, rootNode: d2, currentNode: F };
  4978.       d2.dispatchEvent(new CustomEvent(e2, { detail: n2 })), t2 == null ? void 0 : t2(n2);
  4979.     };
  4980.     const _ = addEventListener;
  4981.     _("pointerdown", te, false), _("pointerup", ne, false), _("pointermove", re, false), a(d2, "touch-action", "none");
  4982.     const ee = () => {
  4983.       let e2 = d2.offsetWidth / U.width;
  4984.       return isNaN(e2) && (e2 = 1), e2;
  4985.     };
  4986.     function te(e2) {
  4987.       if (y) return;
  4988.       if (2 === e2.button) return;
  4989.       if (K.add(e2.pointerId), b && K.size > 1) return e2.preventDefault();
  4990.       if (v.dragStart && (I = i(f, d2)), n(A) && n(S) && A === S) throw new Error("`handle` selector can't be same as `cancel` selector");
  4991.       if (Q.add(C), W = function(e3, t3) {
  4992.         if (!e3) return [t3];
  4993.         if (s(e3)) return [e3];
  4994.         if (Array.isArray(e3)) return e3;
  4995.         const n2 = t3.querySelectorAll(e3);
  4996.         if (null === n2) throw new Error("Selector passed for `handle` option should be child of the element on which the action is applied");
  4997.         return Array.from(n2.values());
  4998.       }(A, d2), j = function(e3, t3) {
  4999.         if (!e3) return [];
  5000.         if (s(e3)) return [e3];
  5001.         if (Array.isArray(e3)) return e3;
  5002.         const n2 = t3.querySelectorAll(e3);
  5003.         if (null === n2) throw new Error("Selector passed for `cancel` option should be child of the element on which the action is applied");
  5004.         return Array.from(n2.values());
  5005.       }(S, d2), c = /(both|x)/.test(g), u = /(both|y)/.test(g), o(j, W)) throw new Error("Element being dragged can't be a child of the element on which `cancel` is applied");
  5006.       const t2 = e2.composedPath()[0];
  5007.       if (!W.some((e3) => {
  5008.         var _a;
  5009.         return e3.contains(t2) || ((_a = e3.shadowRoot) == null ? void 0 : _a.contains(t2));
  5010.       }) || o(j, [t2])) return;
  5011.       F = 1 === W.length ? d2 : W.find((e3) => e3.contains(t2)), H = true, U = d2.getBoundingClientRect(), w && (G = O.userSelect, O.userSelect = "none"), Z("neodrag:start", B);
  5012.       const { clientX: r2, clientY: a2 } = e2, l2 = ee();
  5013.       c && (X = r2 - k / l2), u && (Y = a2 - z / l2), I && (q = r2 - U.left, P = a2 - U.top);
  5014.     }
  5015.     function ne(e2) {
  5016.       K.delete(e2.pointerId), H && (v.dragEnd && (I = i(f, d2)), Q.remove(N), Q.add(D), w && (O.userSelect = G), Z("neodrag:end", R), c && (X = L), u && (Y = T), H = false);
  5017.     }
  5018.     function re(e2) {
  5019.       if (!H || b && K.size > 1) return;
  5020.       v.drag && (I = i(f, d2)), Q.add(N), e2.preventDefault(), U = d2.getBoundingClientRect();
  5021.       let n2 = e2.clientX, o2 = e2.clientY;
  5022.       const a2 = ee();
  5023.       if (I) {
  5024.         const e3 = { left: I.left + q, top: I.top + P, right: I.right + q - U.width, bottom: I.bottom + P - U.height };
  5025.         n2 = t(n2, e3.left, e3.right), o2 = t(o2, e3.top, e3.bottom);
  5026.       }
  5027.       if (Array.isArray(x)) {
  5028.         let [e3, t2] = x;
  5029.         if (isNaN(+e3) || e3 < 0) throw new Error("1st argument of `grid` must be a valid positive number");
  5030.         if (isNaN(+t2) || t2 < 0) throw new Error("2nd argument of `grid` must be a valid positive number");
  5031.         let i2 = n2 - X, s2 = o2 - Y;
  5032.         [i2, s2] = r([e3 / a2, t2 / a2], i2, s2), n2 = X + i2, o2 = Y + s2;
  5033.       }
  5034.       c && (L = Math.round((n2 - X) * a2)), u && (T = Math.round((o2 - Y) * a2)), k = L, z = T, Z("neodrag", $), V();
  5035.     }
  5036.     return { destroy: () => {
  5037.       const e2 = removeEventListener;
  5038.       e2("pointerdown", te, false), e2("pointerup", ne, false), e2("pointermove", re, false);
  5039.     }, update: (t2) => {
  5040.       var _a, _b;
  5041.       g = t2.axis || "both", y = t2.disabled ?? false, b = t2.ignoreMultitouch ?? false, A = t2.handle, f = t2.bounds, v = t2.recomputeBounds ?? e, S = t2.cancel, w = t2.applyUserSelectHack ?? true, x = t2.grid, h = t2.gpuAcceleration ?? true, p = t2.legacyTranslate ?? true, m = t2.transform;
  5042.       const n2 = Q.contains(D);
  5043.       Q.remove(C, D), C = t2.defaultClass ?? "neodrag", N = t2.defaultClassDragging ?? "neodrag-dragging", D = t2.defaultClassDragged ?? "neodrag-dragged", Q.add(C), n2 && Q.add(D), J && (k = L = ((_a = t2.position) == null ? void 0 : _a.x) ?? L, z = T = ((_b = t2.position) == null ? void 0 : _b.y) ?? T, V());
  5044.     } };
  5045.   };
  5046.   var on_dblclick = (_, shown) => shown(false);
  5047.   var root$3 = /* @__PURE__ */ template(`<div class="float-menu svelte-1rgb4pt" role="dialog" title="ドラッグして移動、ダブルクリックして隠す"><!></div>`);
  5048.   function FloatDialog($$anchor, $$props) {
  5049.     push($$props, true);
  5050.     let shown = prop($$props, "shown", 15, false);
  5051.     var div2 = root$3();
  5052.     div2.__dblclick = [on_dblclick, shown];
  5053.     var node = child(div2);
  5054.     snippet(node, () => $$props.children);
  5055.     action(div2, ($$node) => d($$node));
  5056.     append($$anchor, div2);
  5057.     pop();
  5058.   }
  5059.   delegate(["dblclick"]);
  5060.   var on_click$4 = (e2, editor, $$props) => {
  5061.     e2.stopPropagation();
  5062.     if (editor) {
  5063.       if ($$props.text instanceof Function) {
  5064.         editor.replaceSelection($$props.text);
  5065.       } else {
  5066.         editor.insertAtCursor($$props.text);
  5067.       }
  5068.     }
  5069.   };
  5070.   var root$2 = /* @__PURE__ */ template(`<button class="svelte-18a6ijc"> </button>`);
  5071.   function InsertButton($$anchor, $$props) {
  5072.     push($$props, true);
  5073.     let color = prop($$props, "color", 3, "black"), display = prop($$props, "display", 19, () => $$props.text instanceof Function ? $$props.text("…") : $$props.text);
  5074.     const editor = getContext("editor");
  5075.     var button = root$2();
  5076.     button.__click = [on_click$4, editor, $$props];
  5077.     button.__contextmenu = function(...$$args) {
  5078.       var _a;
  5079.       (_a = $$props.oncontextmenu) == null ? void 0 : _a.apply(this, $$args);
  5080.     };
  5081.     var text_1 = child(button);
  5082.     template_effect(() => {
  5083.       set_attribute(button, "data-color", color());
  5084.       set_attribute(button, "title", $$props.title);
  5085.       set_text(text_1, display());
  5086.     });
  5087.     append($$anchor, button);
  5088.     pop();
  5089.   }
  5090.   delegate(["click", "contextmenu"]);
  5091.   var root_4$2 = /* @__PURE__ */ template(`<div class="row"><!></div>`);
  5092.   var root_5 = /* @__PURE__ */ template(`<div class="row"></div>`);
  5093.   var root_2$3 = /* @__PURE__ */ template(`<div class="menu-content-container svelte-1c61vln"><h2 class="svelte-1c61vln">變體假名</h2> <div class="kana-table svelte-1c61vln"></div> <div class="panel svelte-1c61vln"><!> <!> <div style="flex-grow: 1"></div> <!> <!></div></div>`);
  5094.   var on_click$3 = (_, shown) => set(shown, true);
  5095.   var root_6$1 = /* @__PURE__ */ template(`<button class="show-button svelte-1c61vln" title="變體假名パネルを開く"><div class="kana svelte-1c61vln">𛀂</div></button>`);
  5096.   function VariantKana($$anchor, $$props) {
  5097.     push($$props, true);
  5098.     setContext("editor", $$props.editor);
  5099.     let shown = state(false);
  5100.     const KANA_TABLE = [
  5101.       ["あ", ["𛀂", "𛀅", "𛀃", "𛀄"]],
  5102.       ["い", ["𛀆", "𛀇", "𛀈", "𛀉"]],
  5103.       ["う", ["𛀊", "𛀋", "𛀌", "𛀍", "𛀎"]],
  5104.       [
  5105.         "え",
  5106.         ["𛀁", "𛀏", "𛀐", "𛀑", "𛀒", "𛀓"]
  5107.       ],
  5108.       ["お", ["𛀔", "𛀕", "𛀖"]],
  5109.       [
  5110.         "か",
  5111.         [
  5112.           "𛀗",
  5113.           "𛀘",
  5114.           "𛀙",
  5115.           "𛀚",
  5116.           "𛀛",
  5117.           "𛀢",
  5118.           "𛀜",
  5119.           "𛀝",
  5120.           "𛀞",
  5121.           "𛀟",
  5122.           "𛀠",
  5123.           "𛀡"
  5124.         ]
  5125.       ],
  5126.       [
  5127.         "き",
  5128.         [
  5129.           "𛀣",
  5130.           "𛀤",
  5131.           "𛀥",
  5132.           "𛀦",
  5133.           "𛀻",
  5134.           "𛀧",
  5135.           "𛀨",
  5136.           "𛀩",
  5137.           "𛀪"
  5138.         ]
  5139.       ],
  5140.       [
  5141.         "く",
  5142.         ["𛀫", "𛀬", "𛀭", "𛀮", "𛀯", "𛀰", "𛀱"]
  5143.       ],
  5144.       [
  5145.         "け",
  5146.         ["𛀳", "𛀲", "𛀢", "𛀴", "𛀵", "𛀶", "𛀷"]
  5147.       ],
  5148.       ["こ", ["𛀸", "𛂘", "𛀹", "𛀻", "𛀺"]],
  5149.       [
  5150.         "さ",
  5151.         [
  5152.           "𛀼",
  5153.           "𛀽",
  5154.           "𛀾",
  5155.           "𛀿",
  5156.           "𛁀",
  5157.           "𛁁",
  5158.           "𛁂",
  5159.           "𛁃"
  5160.         ]
  5161.       ],
  5162.       [
  5163.         "し",
  5164.         ["𛁄", "𛁅", "𛁆", "𛁇", "𛁈", "𛁉"]
  5165.       ],
  5166.       [
  5167.         "す",
  5168.         [
  5169.           "𛁊",
  5170.           "𛁋",
  5171.           "𛁌",
  5172.           "𛁍",
  5173.           "𛁎",
  5174.           "𛁏",
  5175.           "𛁐",
  5176.           "𛁑"
  5177.         ]
  5178.       ],
  5179.       ["せ", ["𛁒", "𛁓", "𛁔", "𛁕", "𛁖"]],
  5180.       [
  5181.         "そ",
  5182.         ["𛁗", "𛁘", "𛁙", "𛁚", "𛁛", "𛁜", "𛁝"]
  5183.       ],
  5184.       ["た", ["𛁞", "𛁟", "𛁠", "𛁡"]],
  5185.       [
  5186.         "ち",
  5187.         ["𛁢", "𛁣", "𛁤", "𛁥", "𛁦", "𛁧", "𛁨"]
  5188.       ],
  5189.       ["つ", ["𛁩", "𛁪", "𛁫", "𛁬", "𛁭"]],
  5190.       [
  5191.         "て",
  5192.         [
  5193.           "𛁮",
  5194.           "𛁯",
  5195.           "𛁰",
  5196.           "𛁱",
  5197.           "𛁲",
  5198.           "𛁳",
  5199.           "𛁴",
  5200.           "𛁵",
  5201.           "𛁶",
  5202.           "𛂎"
  5203.         ]
  5204.       ],
  5205.       [
  5206.         "と",
  5207.         [
  5208.           "𛁷",
  5209.           "𛁸",
  5210.           "𛁹",
  5211.           "𛁺",
  5212.           "𛁻",
  5213.           "𛁼",
  5214.           "𛁽",
  5215.           "𛁭"
  5216.         ]
  5217.       ],
  5218.       [
  5219.         "な",
  5220.         [
  5221.           "𛁾",
  5222.           "𛁿",
  5223.           "𛂀",
  5224.           "𛂁",
  5225.           "𛂂",
  5226.           "𛂃",
  5227.           "𛂄",
  5228.           "𛂅",
  5229.           "𛂆"
  5230.         ]
  5231.       ],
  5232.       [
  5233.         "に",
  5234.         [
  5235.           "𛂇",
  5236.           "𛂈",
  5237.           "𛂉",
  5238.           "𛂊",
  5239.           "𛂋",
  5240.           "𛂌",
  5241.           "𛂍",
  5242.           "𛂎"
  5243.         ]
  5244.       ],
  5245.       ["ぬ", ["𛂏", "𛂐", "𛂑"]],
  5246.       [
  5247.         "ね",
  5248.         ["𛂒", "𛂓", "𛂔", "𛂕", "𛂖", "𛂗", "𛂘"]
  5249.       ],
  5250.       ["の", ["𛂙", "𛂚", "𛂛", "𛂜", "𛂝"]],
  5251.       [
  5252.         "は",
  5253.         [
  5254.           "𛂞",
  5255.           "𛂟",
  5256.           "𛂠",
  5257.           "𛂡",
  5258.           "𛂢",
  5259.           "𛂣",
  5260.           "𛂤",
  5261.           "𛂥",
  5262.           "𛂦",
  5263.           "𛂧",
  5264.           "𛂨"
  5265.         ]
  5266.       ],
  5267.       [
  5268.         "ひ",
  5269.         ["𛂩", "𛂪", "𛂫", "𛂬", "𛂭", "𛂮", "𛂯"]
  5270.       ],
  5271.       ["ふ", ["𛂰", "𛂱", "𛂲"]],
  5272.       [
  5273.         "へ",
  5274.         ["𛂳", "𛂴", "𛂵", "𛂶", "𛂷", "𛂸", "𛂹"]
  5275.       ],
  5276.       [
  5277.         "ほ",
  5278.         [
  5279.           "𛂺",
  5280.           "𛂻",
  5281.           "𛂼",
  5282.           "𛂽",
  5283.           "𛂾",
  5284.           "𛂿",
  5285.           "𛃀",
  5286.           "𛃁"
  5287.         ]
  5288.       ],
  5289.       [
  5290.         "ま",
  5291.         [
  5292.           "𛃂",
  5293.           "𛃃",
  5294.           "𛃄",
  5295.           "𛃅",
  5296.           "𛃆",
  5297.           "𛃇",
  5298.           "𛃈",
  5299.           "𛃖"
  5300.         ]
  5301.       ],
  5302.       [
  5303.         "み",
  5304.         ["𛃉", "𛃊", "𛃋", "𛃌", "𛃍", "𛃎", "𛃏"]
  5305.       ],
  5306.       [
  5307.         "む",
  5308.         ["𛃐", "𛃑", "𛃒", "𛃓", "𛄝", "𛄞"]
  5309.       ],
  5310.       ["め", ["𛃔", "𛃕", "𛃖"]],
  5311.       [
  5312.         "も",
  5313.         [
  5314.           "𛃗",
  5315.           "𛃘",
  5316.           "𛃙",
  5317.           "𛃚",
  5318.           "𛃛",
  5319.           "𛃜",
  5320.           "𛄝",
  5321.           "𛄞"
  5322.         ]
  5323.       ],
  5324.       [
  5325.         "や",
  5326.         ["𛃝", "𛃞", "𛃟", "𛃠", "𛃡", "𛃢"]
  5327.       ],
  5328.       null,
  5329.       ["ゆ", ["𛃣", "𛃤", "𛃥", "𛃦"]],
  5330.       null,
  5331.       [
  5332.         "よ",
  5333.         ["𛃧", "𛃨", "𛃩", "𛃪", "𛃫", "𛃬"]
  5334.       ],
  5335.       ["ら", ["𛃭", "𛃮", "𛃯", "𛃰"]],
  5336.       [
  5337.         "り",
  5338.         ["𛃱", "𛃲", "𛃳", "𛃴", "𛃵", "𛃶", "𛃷"]
  5339.       ],
  5340.       [
  5341.         "る",
  5342.         ["𛃸", "𛃹", "𛃺", "𛃻", "𛃼", "𛃽"]
  5343.       ],
  5344.       ["れ", ["𛃾", "𛃿", "𛄀", "𛄁"]],
  5345.       [
  5346.         "ろ",
  5347.         ["𛄂", "𛄃", "𛄄", "𛄅", "𛄆", "𛄇"]
  5348.       ],
  5349.       ["わ", ["𛄈", "𛄉", "𛄊", "𛄋", "𛄌"]],
  5350.       ["ゐ", ["𛄍", "𛄎", "𛄏", "𛄐", "𛄑"]],
  5351.       null,
  5352.       ["ゑ", ["𛄒", "𛄓", "𛄔", "𛄕"]],
  5353.       [
  5354.         "を",
  5355.         [
  5356.           "𛄖",
  5357.           "𛄗",
  5358.           "𛄘",
  5359.           "𛄙",
  5360.           "𛄚",
  5361.           "𛄛",
  5362.           "𛄜",
  5363.           "𛀅"
  5364.         ]
  5365.       ],
  5366.       ["ん", ["𛄝", "𛄞"]],
  5367.       null,
  5368.       null,
  5369.       null,
  5370.       null
  5371.     ];
  5372.     var fragment = comment();
  5373.     var node = first_child(fragment);
  5374.     if_block(
  5375.       node,
  5376.       () => get(shown),
  5377.       ($$anchor2) => {
  5378.         FloatDialog($$anchor2, {
  5379.           get shown() {
  5380.             return get(shown);
  5381.           },
  5382.           set shown($$value) {
  5383.             set(shown, proxy($$value));
  5384.           },
  5385.           children: ($$anchor3, $$slotProps) => {
  5386.             var div2 = root_2$3();
  5387.             var div_1 = sibling(child(div2), 2);
  5388.             each(div_1, 21, () => KANA_TABLE, index, ($$anchor4, k) => {
  5389.               var fragment_2 = comment();
  5390.               var node_1 = first_child(fragment_2);
  5391.               if_block(
  5392.                 node_1,
  5393.                 () => get(k),
  5394.                 ($$anchor5) => {
  5395.                   var div_2 = root_4$2();
  5396.                   const computed_const = /* @__PURE__ */ derived(() => {
  5397.                     const [kana, variants] = get(k);
  5398.                     return { kana, variants };
  5399.                   });
  5400.                   var node_2 = child(div_2);
  5401.                   KanaButton(node_2, {
  5402.                     get display() {
  5403.                       return get(computed_const).kana;
  5404.                     },
  5405.                     get variants() {
  5406.                       return get(computed_const).variants;
  5407.                     }
  5408.                   });
  5409.                   append($$anchor5, div_2);
  5410.                 },
  5411.                 ($$anchor5) => {
  5412.                   var div_3 = root_5();
  5413.                   append($$anchor5, div_3);
  5414.                 }
  5415.               );
  5416.               append($$anchor4, fragment_2);
  5417.             });
  5418.             var div_4 = sibling(div_1, 2);
  5419.             var node_3 = child(div_4);
  5420.             InsertButton(node_3, {
  5421.               color: "green",
  5422.               display: "◌゙",
  5423.               text: "゙",
  5424.               title: "濁点"
  5425.             });
  5426.             var node_4 = sibling(node_3, 2);
  5427.             InsertButton(node_4, {
  5428.               color: "green",
  5429.               display: "◌゚",
  5430.               text: "゚",
  5431.               title: "半濁点"
  5432.             });
  5433.             var node_5 = sibling(node_4, 4);
  5434.             InsertButton(node_5, {
  5435.               color: "green",
  5436.               display: "子",
  5437.               text: "子",
  5438.               title: "「ネ」の異体字（漢字で代用）"
  5439.             });
  5440.             var node_6 = sibling(node_5, 2);
  5441.             InsertButton(node_6, {
  5442.               color: "green",
  5443.               display: "井",
  5444.               text: "井",
  5445.               title: "「井」の異体字（漢字で代用）"
  5446.             });
  5447.             append($$anchor3, div2);
  5448.           },
  5449.           $$slots: { default: true }
  5450.         });
  5451.       },
  5452.       ($$anchor2) => {
  5453.         var button = root_6$1();
  5454.         button.__click = [on_click$3, shown];
  5455.         append($$anchor2, button);
  5456.       }
  5457.     );
  5458.     append($$anchor, fragment);
  5459.     pop();
  5460.   }
  5461.   delegate(["click"]);
  5462.   const GROUPED_VARIANTS = {
  5463.     "者→者": [
  5464.       ["者", ["者", "者︀"]],
  5465.       ["諸", ["諸", "諸︀"]],
  5466.       ["著", ["著", "著︀"]],
  5467.       ["箸", [null, "箸󠄁"]],
  5468.       ["緒", ["緖", "緖"]],
  5469.       ["暑", ["暑", "暑︀"]],
  5470.       ["渚", ["渚", "渚︀"]],
  5471.       ["煮", ["煮", "煮︀"]],
  5472.       ["署", ["署", "署︀"]],
  5473.       ["猪", ["猪", "猪︀"]],
  5474.       ["都", ["都", "都︀"]],
  5475.       ["賭", [null, "賭󠄁"]],
  5476.       ["儲", [null, "儲󠄁"]],
  5477.       ["曙", [null, "曙󠄁"]],
  5478.       ["偖", [null, "偖󠄀"]],
  5479.       ["堵", [null, "堵󠄁"]],
  5480.       ["奢", ["奢", "奢︀"]],
  5481.       ["屠", ["屠", "屠︀"]],
  5482.       ["楮", [null, "楮󠄀"]],
  5483.       ["躇", [null, "躇󠄀"]],
  5484.       ["闍", [null, "闍󠄀"]]
  5485.     ],
  5486.     "毎→每": [
  5487.       ["毎", ["每", null]],
  5488.       ["侮", ["侮", "侮︀"]],
  5489.       ["悔", ["悔", "悔︀"]],
  5490.       ["敏", ["敏", "敏︀"]],
  5491.       ["梅", ["梅", "梅︀"]],
  5492.       ["海", ["海", "海︀"]],
  5493.       ["繁", ["繁", "繁︀"]]
  5494.     ],
  5495.     "礻→示": [
  5496.       ["神", ["神", "神︀"]],
  5497.       ["祥", ["祥", "祥︀"]],
  5498.       ["福", ["福", "福︀"]],
  5499.       ["視", ["視", "視︀"]],
  5500.       ["社", ["社", "社︀"]],
  5501.       ["祉", ["祉", "祉︀"]],
  5502.       ["祈", ["祈", "祈︀"]],
  5503.       ["祐", ["祐", "祐︀"]],
  5504.       ["祖", ["祖", "祖︀"]],
  5505.       ["祝", ["祝", "祝︀"]],
  5506.       ["禍", ["禍", "禍︀"]],
  5507.       ["禎", ["禎", "禎︀"]]
  5508.     ],
  5509.     "真→眞": [
  5510.       ["直", ["直", "直︁"]],
  5511.       ["真", ["眞", "眞"]],
  5512.       ["顛", ["顚", "顚"]]
  5513.     ],
  5514.     "开→幵": [
  5515.       ["研", ["硏", "硏"]],
  5516.       ["妍", ["姸", "姸"]],
  5517.       ["笄", ["筓", "筓"]]
  5518.     ],
  5519.     "并→幷": [
  5520.       ["并", ["幷", "幷"]],
  5521.       ["併", ["倂", "倂"]],
  5522.       ["胼", ["腁", "腁"]],
  5523.       ["駢", ["騈", "騈"]],
  5524.       ["迸", ["逬", "逬"]],
  5525.       ["瓶", ["甁", "甁"]],
  5526.       ["屏", ["屛", "屛"]],
  5527.       ["塀", ["塀", "塀︀"]]
  5528.     ],
  5529.     "𢀳→皀": [
  5530.       ["即", ["卽", "卽"]],
  5531.       ["節", ["節", "節︀"]],
  5532.       ["既", ["旣", "旣"]],
  5533.       ["郷", ["鄕", "鄕"]],
  5534.       ["慨", ["慨", "慨︀"]],
  5535.       ["概", ["槪", "槪"]],
  5536.       ["㮣", ["槩", "槩"]]
  5537.     ],
  5538.     "曽→曾": [
  5539.       ["曽", ["曾", "曾"]],
  5540.       ["僧", ["僧", "僧︀"]],
  5541.       ["層", ["層", "層︀"]],
  5542.       ["憎", ["憎", "憎︀"]],
  5543.       ["贈", ["贈", "贈︀"]],
  5544.       ["増", ["增", "增"]]
  5545.     ],
  5546.     "黒→黑": [
  5547.       ["黒", ["黑", "黑"]],
  5548.       ["墨", ["墨", "墨︀"]],
  5549.       ["薫", ["薰", "薰"]]
  5550.     ],
  5551.     "東→柬": [
  5552.       ["練", ["練", "練︁"]],
  5553.       ["錬", ["鍊", "鍊"]],
  5554.       ["欄", ["欄", "欄︀"]]
  5555.     ],
  5556.     "⺈→刀": [
  5557.       ["免", ["免", "免︀"]],
  5558.       // ["逸", ["逸", null]],
  5559.       // ["晩", ["晚", null]],
  5560.       // ["勉", ["勉", null]],
  5561.       ["絶", ["絕", "絕"]]
  5562.     ],
  5563.     "廿→艹": [
  5564.       ["漢", ["漢", "漢︀"]],
  5565.       ["難", ["難", "難︀"]],
  5566.       ["勤", ["勤", "勤︀"]],
  5567.       ["嘆", ["嘆", "嘆︀"]]
  5568.     ],
  5569.     "兑→兌": [
  5570.       ["兑", ["兌", "兌"]],
  5571.       ["悦", ["悅", "悅"]],
  5572.       ["説", ["說", "說"]],
  5573.       ["脱", ["脫", "脫"]],
  5574.       ["鋭", ["銳", "銳"]],
  5575.       ["閲", ["閱", "閱"]]
  5576.     ],
  5577.     "戸→戶": [
  5578.       ["戸", ["戶", "戶"]],
  5579.       ["戻", ["戾", "戾"]],
  5580.       ["涙", ["淚", "淚"]]
  5581.     ],
  5582.     "豕→豖": [["琢", ["琢", "琢︀"]]],
  5583.     "卑→卑": [
  5584.       ["卑", ["卑", "卑︀"]],
  5585.       ["碑", ["碑", "碑︀"]]
  5586.     ],
  5587.     "匂→匃": [
  5588.       ["喝", ["喝", "喝︀"]],
  5589.       ["褐", ["褐", "褐︀"]],
  5590.       ["謁", ["謁", "謁︀"]],
  5591.       ["掲", ["揭", "揭"]],
  5592.       ["渇", ["渴", "渴"]]
  5593.     ],
  5594.     "大→犬": [
  5595.       ["器", ["器", "器︀"]],
  5596.       ["突", ["突", "突︀"]],
  5597.       ["臭", ["臭", "臭︀"]],
  5598.       ["戻", ["戾", "戾"]],
  5599.       ["涙", ["淚", "淚"]],
  5600.       ["類", ["類", "類︀"]]
  5601.     ],
  5602.     "㇏→乀󠄀": [
  5603.       ["又", ["又󠄂", "又󠄂"]],
  5604.       ["交", ["交󠄁", "交󠄁"]],
  5605.       ["文", [null, "文󠄁"]],
  5606.       ["史", [null, "史󠄁"]]
  5607.     ],
  5608.     "冫⇆𰀪": [
  5609.       ["羽", ["羽", "羽󠄀"]],
  5610.       ["習", [null, "習󠄁"]],
  5611.       ["冬", ["冬", "冬󠄀"]]
  5612.     ],
  5613.     "亡→亡󠄁": [["亡", [null, "亡󠄁"]]],
  5614.     "丷→八": [
  5615.       ["遂", [null, "遂󠄂"]],
  5616.       ["半", [null, "半󠄁"]],
  5617.       ["肖", [null, "肖󠄁"]],
  5618.       ["酋", [null, "酋󠄁"]],
  5619.       ["益", ["益", "益︀"]]
  5620.     ],
  5621.     "己→巳": [
  5622.       ["記", [null, "記󠄂"]],
  5623.       ["起", [null, "起󠄁"]]
  5624.     ],
  5625.     "丶→丩": [["並", ["並", "並︀"]]],
  5626.     "辶→辶󠄀": [["近", [null, "近󠄁"]]],
  5627.     "爫→爪": [["採", [null, "採󠄁"]]],
  5628.     "月→丹": [
  5629.       ["丹", [null, "丹󠄁"]],
  5630.       ["青", ["靑", "靑"]],
  5631.       ["精", [null, "精󠄀"]],
  5632.       ["晴", [null, "晴󠄀"]],
  5633.       ["睛", [null, "睛󠄀"]]
  5634.     ],
  5635.     "𫩏→中": [
  5636.       ["告", ["吿", "吿"]],
  5637.       ["舎", ["舍", "舍"]],
  5638.       ["周", ["周", "周︀"]]
  5639.     ],
  5640.     "人→入": [
  5641.       ["全", [null, "全󠄁"]],
  5642.       ["内", ["內", "內"]]
  5643.     ]
  5644.   };
  5645.   var root_2$2 = /* @__PURE__ */ template(`<button class="svelte-1m4k62d"> </button>`);
  5646.   var root$1 = /* @__PURE__ */ template(`<button class="type svelte-1m4k62d"> </button> <div class="variants svelte-1m4k62d"></div>`, 1);
  5647.   function InsertButtonVariantKanji($$anchor, $$props) {
  5648.     push($$props, true);
  5649.     let instance;
  5650.     let button;
  5651.     let variantsContainer;
  5652.     let active = state(false);
  5653.     onMount(() => {
  5654.       instance = tippy(button, {
  5655.         content: variantsContainer,
  5656.         theme: "kana",
  5657.         interactive: true,
  5658.         offset: [0, 0],
  5659.         placement: "auto",
  5660.         onShow: () => {
  5661.           set(active, true);
  5662.         },
  5663.         onHide: () => {
  5664.           set(active, false);
  5665.         }
  5666.       });
  5667.     });
  5668.     const editor = getContext("editor");
  5669.     var fragment = root$1();
  5670.     var button_1 = first_child(fragment);
  5671.     bind_this(button_1, ($$value) => button = $$value, () => button);
  5672.     const class_directive = /* @__PURE__ */ derived(() => $$props.variants.some(([display, _v]) => $$props.selection.includes(display)));
  5673.     template_effect(() => toggle_class(button_1, "selected", get(class_directive)));
  5674.     var text = child(button_1);
  5675.     var div2 = sibling(button_1, 2);
  5676.     bind_this(div2, ($$value) => variantsContainer = $$value, () => variantsContainer);
  5677.     const $$array = () => $$props.variants;
  5678.     each(div2, 21, $$array, index, ($$anchor2, $$item) => {
  5679.       let display = () => get($$item)[0];
  5680.       let variant = () => get($$item)[1];
  5681.       var fragment_1 = comment();
  5682.       var node = first_child(fragment_1);
  5683.       if_block(node, variant, ($$anchor3) => {
  5684.         var button_2 = root_2$2();
  5685.         button_2.__click = () => {
  5686.           if (editor) {
  5687.             editor.insertAtCursor(variant());
  5688.           }
  5689.           instance == null ? void 0 : instance.hide();
  5690.         };
  5691.         const class_directive_1 = /* @__PURE__ */ derived(() => $$props.selection.includes(display()));
  5692.         template_effect(() => toggle_class(button_2, "selected", get(class_directive_1)));
  5693.         var text_1 = child(button_2);
  5694.         template_effect(() => set_text(text_1, `${display() ?? ""}→${variant() ?? ""}`));
  5695.         append($$anchor3, button_2);
  5696.       });
  5697.       append($$anchor2, fragment_1);
  5698.     });
  5699.     template_effect(() => {
  5700.       toggle_class(button_1, "active", get(active));
  5701.       set_text(text, $$props.display);
  5702.     });
  5703.     append($$anchor, fragment);
  5704.     pop();
  5705.   }
  5706.   delegate(["click"]);
  5707.   const preferences = (() => {
  5708.     let highlight = state(localStorage.getItem("highlight-variant-kanji") === "true");
  5709.     return {
  5710.       get highlight() {
  5711.         return get(highlight);
  5712.       },
  5713.       set highlight(value) {
  5714.         set(highlight, proxy(value));
  5715.         localStorage.setItem("highlight-variant-kanji", value.toString());
  5716.       }
  5717.     };
  5718.   })();
  5719.   var root_4$1 = /* @__PURE__ */ template(`<hr class="svelte-9lvbl8"> <div class="panel svelte-9lvbl8"></div>`, 1);
  5720.   var root_2$1 = /* @__PURE__ */ template(`<div class="menu-content-container svelte-9lvbl8"><h2 class="svelte-9lvbl8">異體漢字</h2> <label class="svelte-9lvbl8"><input type="checkbox" name="highlight"> <span>異體字をハイライト</span></label> <select class="svelte-9lvbl8"><option>異体字セレクタのみ</option><option>CJK互換漢字のみ</option><option>CJK互換漢字優先</option></select> <div class="panel svelte-9lvbl8"><!> <!></div> <!></div>`);
  5721.   var on_click$2 = (_, shown) => set(shown, true);
  5722.   var root_6 = /* @__PURE__ */ template(`<button class="show-button svelte-9lvbl8" title="變體假名パネルを開く"><div class="icon svelte-9lvbl8">異</div></button>`);
  5723.   function VariantKanji($$anchor, $$props) {
  5724.     push($$props, true);
  5725.     setContext("editor", $$props.editor);
  5726.     let shown = state(false);
  5727.     const VARIANTS = [
  5728.       {
  5729.         traditional: "敎",
  5730.         simplified: "教",
  5731.         color: "blue"
  5732.       }
  5733.     ];
  5734.     let inputMode = state(proxy($$props.editor instanceof KojiEditor ? "compatibility-first" : "variant-selector-only"));
  5735.     function selectVariant(compatibility, variantSelector) {
  5736.       switch (get(inputMode)) {
  5737.         case "compatibility-only":
  5738.           return compatibility || null;
  5739.         case "variant-selector-only":
  5740.           return variantSelector || null;
  5741.         case "compatibility-first":
  5742.           return compatibility || variantSelector;
  5743.       }
  5744.     }
  5745.     user_effect(() => {
  5746.       for (const { simplified } of VARIANTS) {
  5747.         if ($$props.editor.segments.includes(simplified)) {
  5748.           $$props.editor.markText(simplified);
  5749.         }
  5750.       }
  5751.       for (const [_key, variants] of Object.entries(GROUPED_VARIANTS)) {
  5752.         for (const [display, _variant] of variants) {
  5753.           if ($$props.editor.segments.includes(display)) {
  5754.             $$props.editor.markText(display);
  5755.           }
  5756.         }
  5757.       }
  5758.     });
  5759.     user_effect(() => {
  5760.       $$props.editor.toggleClass("display-variant-highlight", preferences.highlight);
  5761.     });
  5762.     let selectedVariants = /* @__PURE__ */ derived(() => [
  5763.       ...[...Object.values(GROUPED_VARIANTS)].flat(),
  5764.       ...VARIANTS.map(({ traditional, simplified }) => [simplified, traditional])
  5765.     ].filter(([key, variants]) => segment($$props.editor.selectedText).includes(key)).map(([key, variants]) => [
  5766.       key,
  5767.       selectVariant(variants[0], variants[1])
  5768.     ]).filter(([_, variant]) => variant));
  5769.     var fragment = comment();
  5770.     var node = first_child(fragment);
  5771.     if_block(
  5772.       node,
  5773.       () => get(shown),
  5774.       ($$anchor2) => {
  5775.         FloatDialog($$anchor2, {
  5776.           get shown() {
  5777.             return get(shown);
  5778.           },
  5779.           set shown($$value) {
  5780.             set(shown, proxy($$value));
  5781.           },
  5782.           children: ($$anchor3, $$slotProps) => {
  5783.             var div2 = root_2$1();
  5784.             var label = sibling(child(div2), 2);
  5785.             var input = child(label);
  5786.             var select = sibling(label, 2);
  5787.             var option = child(select);
  5788.             option.value = null == (option.__value = "variant-selector-only") ? "" : "variant-selector-only";
  5789.             var option_1 = sibling(option);
  5790.             option_1.value = null == (option_1.__value = "compatibility-only") ? "" : "compatibility-only";
  5791.             var option_2 = sibling(option_1);
  5792.             option_2.value = null == (option_2.__value = "compatibility-first") ? "" : "compatibility-first";
  5793.             var div_1 = sibling(select, 2);
  5794.             var node_1 = child(div_1);
  5795.             each(node_1, 17, () => Object.entries(GROUPED_VARIANTS), index, ($$anchor4, $$item) => {
  5796.               let key = () => get($$item)[0];
  5797.               let variants = () => get($$item)[1];
  5798.               var variants_1 = /* @__PURE__ */ derived(() => variants().map(([
  5799.                 display,
  5800.                 [compatibility, variantSelector]
  5801.               ]) => [
  5802.                 display,
  5803.                 selectVariant(compatibility, variantSelector)
  5804.               ]));
  5805.               InsertButtonVariantKanji($$anchor4, {
  5806.                 get display() {
  5807.                   return key();
  5808.                 },
  5809.                 get variants() {
  5810.                   return get(variants_1);
  5811.                 },
  5812.                 get selection() {
  5813.                   return $$props.editor.selectedText;
  5814.                 }
  5815.               });
  5816.             });
  5817.             var node_2 = sibling(node_1, 2);
  5818.             var variants_2 = /* @__PURE__ */ derived(() => VARIANTS.map(({ traditional, simplified }) => [simplified, traditional]));
  5819.             InsertButtonVariantKanji(node_2, {
  5820.               display: "其ノ他",
  5821.               get variants() {
  5822.                 return get(variants_2);
  5823.               },
  5824.               get selection() {
  5825.                 return $$props.editor.selectedText;
  5826.               }
  5827.             });
  5828.             var node_3 = sibling(div_1, 2);
  5829.             if_block(node_3, () => get(selectedVariants).length > 0, ($$anchor4) => {
  5830.               var fragment_3 = root_4$1();
  5831.               var div_2 = sibling(first_child(fragment_3), 2);
  5832.               each(div_2, 21, () => get(selectedVariants), index, ($$anchor5, $$item) => {
  5833.                 let key = () => get($$item)[0];
  5834.                 let variant = () => get($$item)[1];
  5835.                 var display_1 = /* @__PURE__ */ derived(() => `${key()}→${variant()}`);
  5836.                 var title = /* @__PURE__ */ derived(() => `「${key()}」の異體字`);
  5837.                 InsertButton($$anchor5, {
  5838.                   color: "orange",
  5839.                   get display() {
  5840.                     return get(display_1);
  5841.                   },
  5842.                   text: (selectedText) => segment(selectedText).map((segment2) => segment2 === key() ? variant() : segment2).join(""),
  5843.                   get title() {
  5844.                     return get(title);
  5845.                   }
  5846.                 });
  5847.               });
  5848.               append($$anchor4, fragment_3);
  5849.             });
  5850.             bind_checked(input, () => preferences.highlight, ($$value) => preferences.highlight = $$value);
  5851.             bind_select_value(select, () => get(inputMode), ($$value) => set(inputMode, $$value));
  5852.             append($$anchor3, div2);
  5853.           },
  5854.           $$slots: { default: true }
  5855.         });
  5856.       },
  5857.       ($$anchor2) => {
  5858.         var button = root_6();
  5859.         button.__click = [on_click$2, shown];
  5860.         append($$anchor2, button);
  5861.       }
  5862.     );
  5863.     append($$anchor, fragment);
  5864.     pop();
  5865.   }
  5866.   delegate(["click"]);
  5867.   var _GM = /* @__PURE__ */ (() => typeof GM != "undefined" ? GM : void 0)();
  5868.   var on_click$1 = (_, textValue, $$props, colorValue, displayValue, editing) => {
  5869.     var _a, _b;
  5870.     if (get(textValue)) {
  5871.       (_a = $$props.onedit) == null ? void 0 : _a.call($$props, get(colorValue), get(textValue), get(displayValue));
  5872.       set(editing, false);
  5873.     } else {
  5874.       (_b = $$props.ondelete) == null ? void 0 : _b.call($$props);
  5875.     }
  5876.   };
  5877.   var root = /* @__PURE__ */ template(`<input type="text" title="入力文字（必須、空欄で削除）" class="svelte-h6zyeb"> <input type="text" title="表示文字" class="svelte-h6zyeb"> <select title="文字色" class="svelte-h6zyeb"><option>black</option><option>green</option><option>blue</option><option>red</option><option>pink</option><option>gray</option></select> <button>OK</button>`, 1);
  5878.   function InsertButtonEdit($$anchor, $$props) {
  5879.     push($$props, true);
  5880.     let color = prop($$props, "color", 3, "black"), display = prop($$props, "display", 19, () => $$props.text);
  5881.     let editing = state(false);
  5882.     let textValue = state(proxy($$props.text));
  5883.     let displayValue = state(proxy(display()));
  5884.     let colorValue = state(proxy(color()));
  5885.     var fragment = root();
  5886.     var input = first_child(fragment);
  5887.     var input_1 = sibling(input, 2);
  5888.     var select = sibling(input_1, 2);
  5889.     var option = child(select);
  5890.     option.value = null == (option.__value = "black") ? "" : "black";
  5891.     var option_1 = sibling(option);
  5892.     option_1.value = null == (option_1.__value = "green") ? "" : "green";
  5893.     var option_2 = sibling(option_1);
  5894.     option_2.value = null == (option_2.__value = "blue") ? "" : "blue";
  5895.     var option_3 = sibling(option_2);
  5896.     option_3.value = null == (option_3.__value = "red") ? "" : "red";
  5897.     var option_4 = sibling(option_3);
  5898.     option_4.value = null == (option_4.__value = "pink") ? "" : "pink";
  5899.     var option_5 = sibling(option_4);
  5900.     option_5.value = null == (option_5.__value = "gray") ? "" : "gray";
  5901.     var button = sibling(select, 2);
  5902.     button.__click = [
  5903.       on_click$1,
  5904.       textValue,
  5905.       $$props,
  5906.       colorValue,
  5907.       displayValue,
  5908.       editing
  5909.     ];
  5910.     bind_value(input, () => get(textValue), ($$value) => set(textValue, $$value));
  5911.     bind_value(input_1, () => get(displayValue), ($$value) => set(displayValue, $$value));
  5912.     bind_select_value(select, () => get(colorValue), ($$value) => set(colorValue, $$value));
  5913.     append($$anchor, fragment);
  5914.     pop();
  5915.   }
  5916.   delegate(["click"]);
  5917.   function CustomInsertButton($$anchor, $$props) {
  5918.     push($$props, true);
  5919.     let color = prop($$props, "color", 3, "black"), display = prop($$props, "display", 19, () => $$props.text);
  5920.     let editing = state(false);
  5921.     proxy($$props.text);
  5922.     var fragment = comment();
  5923.     var node = first_child(fragment);
  5924.     if_block(
  5925.       node,
  5926.       () => get(editing),
  5927.       ($$anchor2) => {
  5928.         InsertButtonEdit($$anchor2, {
  5929.           get color() {
  5930.             return color();
  5931.           },
  5932.           get text() {
  5933.             return $$props.text;
  5934.           },
  5935.           get display() {
  5936.             return display();
  5937.           },
  5938.           onedit: (color2, text, display2) => {
  5939.             var _a;
  5940.             (_a = $$props.onedit) == null ? void 0 : _a.call($$props, color2, text, display2);
  5941.             set(editing, false);
  5942.           },
  5943.           ondelete: () => {
  5944.             var _a;
  5945.             (_a = $$props.ondelete) == null ? void 0 : _a.call($$props);
  5946.             set(editing, false);
  5947.           }
  5948.         });
  5949.       },
  5950.       ($$anchor2) => {
  5951.         InsertButton($$anchor2, {
  5952.           get color() {
  5953.             return color();
  5954.           },
  5955.           get text() {
  5956.             return $$props.text;
  5957.           },
  5958.           get display() {
  5959.             return display();
  5960.           },
  5961.           oncontextmenu: (e2) => {
  5962.             e2.preventDefault();
  5963.             set(editing, true);
  5964.           }
  5965.         });
  5966.       }
  5967.     );
  5968.     append($$anchor, fragment);
  5969.     pop();
  5970.   }
  5971.   var root_3 = /* @__PURE__ */ template(`<div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">頁注</h3> <!> <!> <!> <!> <!> <!> <!></div> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">音注</h3> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!></div> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">返点</h3> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!></div> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">註釋</h3> <!> <!> <!></div>`, 1);
  5972.   var root_4 = /* @__PURE__ */ template(`<div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">傍点</h3> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <h3 class="svelte-1l9kdai">ルビー</h3> <!> <h3 class="svelte-1l9kdai">註釋</h3> <!> <!></div>`);
  5973.   var on_click = (_, editingCustom) => {
  5974.     set(editingCustom, !get(editingCustom));
  5975.   };
  5976.   var root_2 = /* @__PURE__ */ template(`<div class="panels"><!> <!> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">記号</h3> <!> <!> <!> <!> <!> <!> <!> <!> <!></div> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">踊字</h3> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!> <!></div> <div class="panel svelte-1l9kdai"><h3 class="svelte-1l9kdai">合字</h3> <!> <!> <!> <!> <!> <!> <!> <!> <h3 class="svelte-1l9kdai">其他</h3> <button class="svelte-1l9kdai">カスタム</button> <!></div></div>`);
  5977.   var on_click_1 = (_, shown) => set(shown, true);
  5978.   var root_8 = /* @__PURE__ */ template(`<button class="show-button svelte-1l9kdai" title="翻刻ツールボックスを開く"><img alt="Honkoku" class="svelte-1l9kdai"></button>`);
  5979.   function MainMenu($$anchor, $$props) {
  5980.     push($$props, true);
  5981.     setContext("editor", $$props.editor);
  5982.     let shown = state(false);
  5983.     let editingCustom = state(false);
  5984.     let customButtons = state(proxy([]));
  5985.     let customText = state("");
  5986.     let customColor = "black";
  5987.     let customDisplay = state("");
  5988.     user_effect(() => {
  5989.       set(customDisplay, proxy(get(customText)));
  5990.     });
  5991.     (async () => {
  5992.       set(customButtons, proxy(JSON.parse(await _GM.getValue("customButtons", "[]"))));
  5993.     })();
  5994.     user_effect(() => {
  5995.       _GM.setValue("customButtons", JSON.stringify(get(customButtons))).then();
  5996.     });
  5997.     user_effect(() => {
  5998.       if (get(editingCustom)) {
  5999.         set(customText, proxy($$props.editor.selectedText));
  6000.       }
  6001.     });
  6002.     var fragment = comment();
  6003.     var node = first_child(fragment);
  6004.     if_block(
  6005.       node,
  6006.       () => get(shown),
  6007.       ($$anchor2) => {
  6008.         FloatDialog($$anchor2, {
  6009.           get shown() {
  6010.             return get(shown);
  6011.           },
  6012.           set shown($$value) {
  6013.             set(shown, proxy($$value));
  6014.           },
  6015.           children: ($$anchor3, $$slotProps) => {
  6016.             var div2 = root_2();
  6017.             var node_1 = child(div2);
  6018.             if_block(node_1, () => $$props.platform === "honkoku", ($$anchor4) => {
  6019.               var fragment_2 = root_3();
  6020.               var div_1 = first_child(fragment_2);
  6021.               var node_2 = sibling(child(div_1), 2);
  6022.               InsertButton(node_2, { color: "green", text: "【左頁】" });
  6023.               var node_3 = sibling(node_2, 2);
  6024.               InsertButton(node_3, { color: "green", text: "【左丁】" });
  6025.               var node_4 = sibling(node_3, 2);
  6026.               InsertButton(node_4, { color: "green", text: "【右頁】" });
  6027.               var node_5 = sibling(node_4, 2);
  6028.               InsertButton(node_5, { color: "green", text: "【右丁】" });
  6029.               var node_6 = sibling(node_5, 2);
  6030.               InsertButton(node_6, { color: "red", text: "【上段】" });
  6031.               var node_7 = sibling(node_6, 2);
  6032.               InsertButton(node_7, { color: "red", text: "【中段】" });
  6033.               var node_8 = sibling(node_7, 2);
  6034.               InsertButton(node_8, { color: "red", text: "【下段】" });
  6035.               var div_2 = sibling(div_1, 2);
  6036.               var node_9 = sibling(child(div_2), 2);
  6037.               InsertButton(node_9, { color: "gray", text: (t2) => `￣${t2}` });
  6038.               var node_10 = sibling(node_9, 2);
  6039.               InsertButton(node_10, { color: "green", text: "￣ハ", display: "ハ" });
  6040.               var node_11 = sibling(node_10, 2);
  6041.               InsertButton(node_11, { color: "green", text: "￣モ", display: "モ" });
  6042.               var node_12 = sibling(node_11, 2);
  6043.               InsertButton(node_12, { color: "green", text: "￣ヲ", display: "ヲ" });
  6044.               var node_13 = sibling(node_12, 2);
  6045.               InsertButton(node_13, { color: "green", text: "￣ヲバ", display: "ヲバ" });
  6046.               var node_14 = sibling(node_13, 2);
  6047.               InsertButton(node_14, { color: "green", text: "￣カ", display: "カ" });
  6048.               var node_15 = sibling(node_14, 2);
  6049.               InsertButton(node_15, { color: "green", text: "￣ガ", display: "ガ" });
  6050.               var node_16 = sibling(node_15, 2);
  6051.               InsertButton(node_16, { color: "green", text: "￣ノ", display: "ノ" });
  6052.               var node_17 = sibling(node_16, 2);
  6053.               InsertButton(node_17, { color: "green", text: "￣ニ", display: "ニ" });
  6054.               var node_18 = sibling(node_17, 2);
  6055.               InsertButton(node_18, { color: "green", text: "￣ヘ", display: "ヘ" });
  6056.               var node_19 = sibling(node_18, 2);
  6057.               InsertButton(node_19, { color: "green", text: "￣ノミ", display: "ノミ" });
  6058.               var node_20 = sibling(node_19, 2);
  6059.               InsertButton(node_20, { color: "green", text: "￣ト", display: "ト" });
  6060.               var node_21 = sibling(node_20, 2);
  6061.               InsertButton(node_21, { color: "blue", text: "￣ス", display: "ス" });
  6062.               var node_22 = sibling(node_21, 2);
  6063.               InsertButton(node_22, { color: "blue", text: "￣スル", display: "ス" });
  6064.               var node_23 = sibling(node_22, 2);
  6065.               InsertButton(node_23, { color: "blue", text: "￣タル", display: "タル" });
  6066.               var node_24 = sibling(node_23, 2);
  6067.               InsertButton(node_24, { color: "blue", text: "￣タリ", display: "タリ" });
  6068.               var node_25 = sibling(node_24, 2);
  6069.               InsertButton(node_25, { color: "blue", text: "￣ナリ", display: "ナリ" });
  6070.               var node_26 = sibling(node_25, 2);
  6071.               InsertButton(node_26, { color: "blue", text: "￣ナル", display: "ナル" });
  6072.               var node_27 = sibling(node_26, 2);
  6073.               InsertButton(node_27, { color: "red", text: "￣レバ", display: "レバ" });
  6074.               var div_3 = sibling(div_2, 2);
  6075.               var node_28 = sibling(child(div_3), 2);
  6076.               InsertButton(node_28, { color: "red", text: "＿レ", display: "レ" });
  6077.               var node_29 = sibling(node_28, 2);
  6078.               InsertButton(node_29, { color: "blue", text: "＿一", display: "一" });
  6079.               var node_30 = sibling(node_29, 2);
  6080.               InsertButton(node_30, { color: "blue", text: "＿二", display: "二" });
  6081.               var node_31 = sibling(node_30, 2);
  6082.               InsertButton(node_31, { color: "blue", text: "＿三", display: "三" });
  6083.               var node_32 = sibling(node_31, 2);
  6084.               InsertButton(node_32, { color: "blue", text: "＿四", display: "四" });
  6085.               var node_33 = sibling(node_32, 2);
  6086.               InsertButton(node_33, { color: "green", text: "＿上", display: "上" });
  6087.               var node_34 = sibling(node_33, 2);
  6088.               InsertButton(node_34, { color: "green", text: "＿中", display: "中" });
  6089.               var node_35 = sibling(node_34, 2);
  6090.               InsertButton(node_35, { color: "green", text: "＿下", display: "下" });
  6091.               var node_36 = sibling(node_35, 2);
  6092.               InsertButton(node_36, { color: "pink", text: "＿甲", display: "甲" });
  6093.               var node_37 = sibling(node_36, 2);
  6094.               InsertButton(node_37, { color: "pink", text: "＿乙", display: "乙" });
  6095.               var node_38 = sibling(node_37, 2);
  6096.               InsertButton(node_38, { color: "pink", text: "＿丙", display: "丙" });
  6097.               var node_39 = sibling(node_38, 2);
  6098.               InsertButton(node_39, { color: "pink", text: "＿丁", display: "丁" });
  6099.               var node_40 = sibling(node_39, 2);
  6100.               InsertButton(node_40, { color: "pink", text: "＿天", display: "天" });
  6101.               var node_41 = sibling(node_40, 2);
  6102.               InsertButton(node_41, { color: "pink", text: "＿地", display: "地" });
  6103.               var node_42 = sibling(node_41, 2);
  6104.               InsertButton(node_42, { color: "pink", text: "＿人", display: "人" });
  6105.               var node_43 = sibling(node_42, 2);
  6106.               InsertButton(node_43, { color: "red", text: "＿一レ", display: "一レ" });
  6107.               var node_44 = sibling(node_43, 2);
  6108.               InsertButton(node_44, { color: "red", text: "＿二レ", display: "二レ" });
  6109.               var node_45 = sibling(node_44, 2);
  6110.               InsertButton(node_45, { color: "red", text: "＿三レ", display: "三レ" });
  6111.               var node_46 = sibling(node_45, 2);
  6112.               InsertButton(node_46, { color: "red", text: "＿四レ", display: "四レ" });
  6113.               var node_47 = sibling(node_46, 2);
  6114.               InsertButton(node_47, { color: "red", text: "＿上レ", display: "上レ" });
  6115.               var div_4 = sibling(div_3, 2);
  6116.               var node_48 = sibling(child(div_4), 2);
  6117.               InsertButton(node_48, {
  6118.                 color: "pink",
  6119.                 text: (t2) => `／${t2}（）`,
  6120.                 display: "ルビー"
  6121.               });
  6122.               var node_49 = sibling(node_48, 2);
  6123.               InsertButton(node_49, {
  6124.                 color: "blue",
  6125.                 text: (t2) => `《割書：${t2}｜》`,
  6126.                 display: "割注"
  6127.               });
  6128.               var node_50 = sibling(node_49, 2);
  6129.               InsertButton(node_50, {
  6130.                 color: "red",
  6131.                 text: (t2) => `【${t2}】`,
  6132.                 display: "注釈"
  6133.               });
  6134.               append($$anchor4, fragment_2);
  6135.             });
  6136.             var node_51 = sibling(node_1, 2);
  6137.             if_block(node_51, () => $$props.platform === "wikisource", ($$anchor4) => {
  6138.               var div_5 = root_4();
  6139.               var node_52 = sibling(child(div_5), 2);
  6140.               InsertButton(node_52, {
  6141.                 color: "green",
  6142.                 text: (t2) => `{{傍点|style=filled sesame|${t2}}}`,
  6143.                 display: "﹅",
  6144.                 title: "傍点（黒ゴマ）"
  6145.               });
  6146.               var node_53 = sibling(node_52, 2);
  6147.               InsertButton(node_53, {
  6148.                 color: "green",
  6149.                 text: (t2) => `{{傍点|style=open sesame|${t2}}}`,
  6150.                 display: "﹆",
  6151.                 title: "傍点（白ゴマ）"
  6152.               });
  6153.               var node_54 = sibling(node_53, 2);
  6154.               InsertButton(node_54, {
  6155.                 color: "green",
  6156.                 text: (t2) => `{{傍点|style=filled dot|${t2}}}`,
  6157.                 display: "•",
  6158.                 title: "傍点（黒点）"
  6159.               });
  6160.               var node_55 = sibling(node_54, 2);
  6161.               InsertButton(node_55, {
  6162.                 color: "green",
  6163.                 text: (t2) => `{{傍点|style=open dot|${t2}}}`,
  6164.                 display: "◦",
  6165.                 title: "傍点（白点）"
  6166.               });
  6167.               var node_56 = sibling(node_55, 2);
  6168.               InsertButton(node_56, {
  6169.                 color: "green",
  6170.                 text: (t2) => `{{傍点|style=filled circle|${t2}}}`,
  6171.                 display: "●",
  6172.                 title: "傍点（黒丸）"
  6173.               });
  6174.               var node_57 = sibling(node_56, 2);
  6175.               InsertButton(node_57, {
  6176.                 color: "green",
  6177.                 text: (t2) => `{{傍点|style=open circle|${t2}}}`,
  6178.                 display: "○",
  6179.                 title: "傍点（白丸）"
  6180.               });
  6181.               var node_58 = sibling(node_57, 2);
  6182.               InsertButton(node_58, {
  6183.                 color: "green",
  6184.                 text: (t2) => `{{傍点|style=filled double-circle|${t2}}}`,
  6185.                 display: "◉",
  6186.                 title: "傍点（黒二重丸）"
  6187.               });
  6188.               var node_59 = sibling(node_58, 2);
  6189.               InsertButton(node_59, {
  6190.                 color: "green",
  6191.                 text: (t2) => `{{傍点|style=open double-circle|${t2}}}`,
  6192.                 display: "◎",
  6193.                 title: "傍点（白二重丸）"
  6194.               });
  6195.               var node_60 = sibling(node_59, 2);
  6196.               InsertButton(node_60, {
  6197.                 color: "green",
  6198.                 text: (t2) => `{{傍点|style=filled triangle|${t2}}}`,
  6199.                 display: "▲",
  6200.                 title: "傍点（黒三角）"
  6201.               });
  6202.               var node_61 = sibling(node_60, 2);
  6203.               InsertButton(node_61, {
  6204.                 color: "green",
  6205.                 text: (t2) => `{{傍点|style=open triangle|${t2}}}`,
  6206.                 display: "△",
  6207.                 title: "傍点（白三角）"
  6208.               });
  6209.               var node_62 = sibling(node_61, 4);
  6210.               InsertButton(node_62, {
  6211.                 color: "pink",
  6212.                 text: (t2) => `{{ruby|${t2}|}}`,
  6213.                 display: "ルビ"
  6214.               });
  6215.               var node_63 = sibling(node_62, 4);
  6216.               InsertButton(node_63, {
  6217.                 color: "green",
  6218.                 text: (t2) => `<ref>${t2}</ref>`,
  6219.                 display: "註釋"
  6220.               });
  6221.               var node_64 = sibling(node_63, 2);
  6222.               InsertButton(node_64, {
  6223.                 color: "green",
  6224.                 text: (t2) => `{{分註|${t2}|}}`,
  6225.                 display: "分註",
  6226.                 title: "分註（割註）"
  6227.               });
  6228.               append($$anchor4, div_5);
  6229.             });
  6230.             var div_6 = sibling(node_51, 2);
  6231.             var node_65 = sibling(child(div_6), 2);
  6232.             InsertButton(node_65, { color: "green", text: "—", title: "emダッシュ" });
  6233.             var node_66 = sibling(node_65, 2);
  6234.             InsertButton(node_66, { color: "green", text: "…", title: "省略号" });
  6235.             var node_67 = sibling(node_66, 2);
  6236.             InsertButton(node_67, { color: "green", text: "、", title: "読点" });
  6237.             var node_68 = sibling(node_67, 2);
  6238.             InsertButton(node_68, { color: "green", text: "，", title: "カンマ" });
  6239.             var node_69 = sibling(node_68, 2);
  6240.             InsertButton(node_69, { color: "green", text: "。", title: "句点" });
  6241.             var node_70 = sibling(node_69, 2);
  6242.             InsertButton(node_70, { color: "green", text: "-", title: "ハイフン" });
  6243.             var node_71 = sibling(node_70, 2);
  6244.             InsertButton(node_71, {
  6245.               color: "green",
  6246.               text: " ",
  6247.               display: "␣",
  6248.               title: "半角スペース"
  6249.             });
  6250.             var node_72 = sibling(node_71, 2);
  6251.             InsertButton(node_72, {
  6252.               color: "green",
  6253.               text: "　",
  6254.               display: "▢",
  6255.               title: "全角スペース"
  6256.             });
  6257.             var node_73 = sibling(node_72, 2);
  6258.             InsertButton(node_73, { color: "green", text: "◯", title: "全角丸" });
  6259.             var div_7 = sibling(div_6, 2);
  6260.             var node_74 = sibling(child(div_7), 2);
  6261.             InsertButton(node_74, { color: "green", text: "々", title: "同の字点" });
  6262.             var node_75 = sibling(node_74, 2);
  6263.             InsertButton(node_75, {
  6264.               color: "green",
  6265.               text: "ゝ",
  6266.               title: "一の字点（ひらがな）"
  6267.             });
  6268.             var node_76 = sibling(node_75, 2);
  6269.             InsertButton(node_76, {
  6270.               color: "green",
  6271.               text: "ゞ",
  6272.               title: "一の字点（ひらがな、濁点付き）"
  6273.             });
  6274.             var node_77 = sibling(node_76, 2);
  6275.             InsertButton(node_77, {
  6276.               color: "green",
  6277.               text: "ヽ",
  6278.               title: "一の字点（カタカナ）"
  6279.             });
  6280.             var node_78 = sibling(node_77, 2);
  6281.             InsertButton(node_78, {
  6282.               color: "green",
  6283.               text: "ヾ",
  6284.               title: "一の字点（カタカナ、濁点付き）"
  6285.             });
  6286.             var node_79 = sibling(node_78, 2);
  6287.             InsertButton(node_79, { color: "green", text: "〻", title: "二の字点" });
  6288.             var node_80 = sibling(node_79, 2);
  6289.             InsertButton(node_80, { color: "green", text: "〳", title: "くの字点上" });
  6290.             var node_81 = sibling(node_80, 2);
  6291.             InsertButton(node_81, {
  6292.               color: "green",
  6293.               text: "〴",
  6294.               title: "くの字点上（濁点付き）"
  6295.             });
  6296.             var node_82 = sibling(node_81, 2);
  6297.             InsertButton(node_82, { color: "green", text: "〵", title: "くの字点下" });
  6298.             var node_83 = sibling(node_82, 2);
  6299.             InsertButton(node_83, {
  6300.               color: "green",
  6301.               text: "〱",
  6302.               title: "くの字点（濁点付き）"
  6303.             });
  6304.             var node_84 = sibling(node_83, 2);
  6305.             InsertButton(node_84, {
  6306.               color: "green",
  6307.               text: "〲",
  6308.               title: "くの字点（濁点付き）"
  6309.             });
  6310.             var div_8 = sibling(div_7, 2);
  6311.             var node_85 = sibling(child(div_8), 2);
  6312.             InsertButton(node_85, { color: "green", text: "〆", title: "締め" });
  6313.             var node_86 = sibling(node_85, 2);
  6314.             InsertButton(node_86, { color: "green", text: " ͡と", title: "「こと」" });
  6315.             var node_87 = sibling(node_86, 2);
  6316.             InsertButton(node_87, { color: "green", text: "ゟ", title: "「より」" });
  6317.             var node_88 = sibling(node_87, 2);
  6318.             InsertButton(node_88, { color: "green", text: "𬼂", title: "「也」" });
  6319.             var node_89 = sibling(node_88, 2);
  6320.             InsertButton(node_89, { color: "green", text: "𬻿", title: "「也」" });
  6321.             var node_90 = sibling(node_89, 2);
  6322.             InsertButton(node_90, { color: "green", text: "ヿ", title: "「コト」" });
  6323.             var node_91 = sibling(node_90, 2);
  6324.             InsertButton(node_91, { color: "green", text: "𪜈", title: "「トモ」" });
  6325.             var node_92 = sibling(node_91, 2);
  6326.             InsertButton(node_92, { color: "green", text: "𬼀", title: "「タメ」" });
  6327.             var button = sibling(node_92, 4);
  6328.             button.__click = [on_click, editingCustom];
  6329.             var node_93 = sibling(button, 2);
  6330.             if_block(
  6331.               node_93,
  6332.               () => get(editingCustom),
  6333.               ($$anchor4) => {
  6334.                 InsertButtonEdit($$anchor4, {
  6335.                   get color() {
  6336.                     return customColor;
  6337.                   },
  6338.                   get text() {
  6339.                     return get(customText);
  6340.                   },
  6341.                   get display() {
  6342.                     return get(customDisplay);
  6343.                   },
  6344.                   onedit: (color, text, display) => {
  6345.                     get(customButtons).push({
  6346.                       text,
  6347.                       color,
  6348.                       display: !display || display === text ? void 0 : display
  6349.                     });
  6350.                     _GM.setValue("customButtons", JSON.stringify(get(customButtons)));
  6351.                     set(editingCustom, false);
  6352.                   }
  6353.                 });
  6354.               },
  6355.               ($$anchor4) => {
  6356.                 var fragment_4 = comment();
  6357.                 var node_94 = first_child(fragment_4);
  6358.                 each(node_94, 17, () => get(customButtons), index, ($$anchor5, $$item, i2) => {
  6359.                   let text = () => get($$item).text;
  6360.                   let display = () => get($$item).display;
  6361.                   let color = () => get($$item).color;
  6362.                   CustomInsertButton($$anchor5, {
  6363.                     get color() {
  6364.                       return color();
  6365.                     },
  6366.                     get text() {
  6367.                       return text();
  6368.                     },
  6369.                     get display() {
  6370.                       return display();
  6371.                     },
  6372.                     onedit: (color2, text2, display2) => {
  6373.                       get(customButtons)[i2] = {
  6374.                         color: color2,
  6375.                         text: text2,
  6376.                         display: !display2 || display2 === text2 ? void 0 : display2
  6377.                       };
  6378.                     },
  6379.                     ondelete: () => {
  6380.                       get(customButtons).splice(i2, 1);
  6381.                     }
  6382.                   });
  6383.                 });
  6384.                 append($$anchor4, fragment_4);
  6385.               }
  6386.             );
  6387.             append($$anchor3, div2);
  6388.           },
  6389.           $$slots: { default: true }
  6390.         });
  6391.       },
  6392.       ($$anchor2) => {
  6393.         var button_1 = root_8();
  6394.         button_1.__click = [on_click_1, shown];
  6395.         var img = child(button_1);
  6396.         set_attribute(img, "src", "data:image/png;base64,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");
  6397.         append($$anchor2, button_1);
  6398.       }
  6399.     );
  6400.     append($$anchor, fragment);
  6401.     pop();
  6402.   }
  6403.   delegate(["click"]);
  6404.   var root_1 = /* @__PURE__ */ template(`<!> <!> <!>`, 1);
  6405.   function App($$anchor, $$props) {
  6406.     push($$props, true);
  6407.     const url = new URL(window.location.href);
  6408.     const platform = (() => {
  6409.       if (url.host.includes("honkoku.org")) return "honkoku";
  6410.       if (url.host.includes("wikisource.org")) return "wikisource";
  6411.       return void 0;
  6412.     })();
  6413.     console.info("[honkoku-toolbox] platform: ", platform);
  6414.     let editor = state(void 0);
  6415.     const MAX_RETRIES = 10;
  6416.     setTimeout(
  6417.       () => {
  6418.         if (!platform) {
  6419.           throw new Error("[honkoku-toolbox] Unsupported platform");
  6420.         }
  6421.         if (platform === "honkoku") {
  6422.           let kojiWrapper;
  6423.           const wrappers = document.getElementsByClassName("editor-wrapper");
  6424.           if (wrappers.length > 0) {
  6425.             kojiWrapper = wrappers[0];
  6426.           }
  6427.           if (!kojiWrapper) {
  6428.             let retries = 0;
  6429.             const interval = setInterval(
  6430.               () => {
  6431.                 const wrappers2 = document.getElementsByClassName("editor-wrapper");
  6432.                 if (wrappers2.length > 0) {
  6433.                   kojiWrapper = wrappers2[0];
  6434.                   set(editor, proxy(new KojiEditor(kojiWrapper)));
  6435.                   console.log("[honkoku-toolbox] KojiEditor initialized: ", get(editor));
  6436.                   clearInterval(interval);
  6437.                 }
  6438.                 if (retries > MAX_RETRIES) {
  6439.                   clearInterval(interval);
  6440.                 }
  6441.                 retries += 1;
  6442.               },
  6443.               500
  6444.             );
  6445.           } else {
  6446.             set(editor, proxy(new KojiEditor(kojiWrapper)));
  6447.             console.log("[honkoku-toolbox] KojiEditor initialized: ", get(editor));
  6448.           }
  6449.           return;
  6450.         }
  6451.         if (platform === "wikisource") {
  6452.           let cm;
  6453.           const codeMirrorDivs = document.getElementsByClassName("CodeMirror");
  6454.           if (codeMirrorDivs.length > 0) {
  6455.             const codeMirror = codeMirrorDivs[0];
  6456.             cm = codeMirror.CodeMirror;
  6457.             set(editor, proxy(new CodeMirrorEditor(cm)));
  6458.             console.info("[honkoku-toolbox] CodeMirrorEditor initialized: ", get(editor));
  6459.           } else {
  6460.             let retries = 0;
  6461.             const interval = setInterval(
  6462.               () => {
  6463.                 const codeMirrorDivs2 = document.getElementsByClassName("CodeMirror");
  6464.                 if (codeMirrorDivs2.length > 0) {
  6465.                   const codeMirror = codeMirrorDivs2[0];
  6466.                   cm = codeMirror.CodeMirror;
  6467.                   set(editor, proxy(new CodeMirrorEditor(cm)));
  6468.                   console.info("[honkoku-toolbox] CodeMirrorEditor initialized: ", get(editor));
  6469.                   clearInterval(interval);
  6470.                 } else {
  6471.                   if (retries > MAX_RETRIES) {
  6472.                     clearInterval(interval);
  6473.                   }
  6474.                   retries += 1;
  6475.                 }
  6476.               },
  6477.               500
  6478.             );
  6479.           }
  6480.         }
  6481.       },
  6482.       500
  6483.     );
  6484.     var fragment = comment();
  6485.     var node = first_child(fragment);
  6486.     if_block(node, () => get(editor) && platform, ($$anchor2) => {
  6487.       var fragment_1 = root_1();
  6488.       var node_1 = first_child(fragment_1);
  6489.       VariantKana(node_1, {
  6490.         get editor() {
  6491.           return get(editor);
  6492.         }
  6493.       });
  6494.       var node_2 = sibling(node_1, 2);
  6495.       MainMenu(node_2, {
  6496.         get editor() {
  6497.           return get(editor);
  6498.         },
  6499.         platform
  6500.       });
  6501.       var node_3 = sibling(node_2, 2);
  6502.       VariantKanji(node_3, {
  6503.         get editor() {
  6504.           return get(editor);
  6505.         }
  6506.       });
  6507.       append($$anchor2, fragment_1);
  6508.     });
  6509.     append($$anchor, fragment);
  6510.     pop();
  6511.   }
  6512.   mount(App, {
  6513.     target: (() => {
  6514.       const app2 = document.createElement("div");
  6515.       document.body.append(app2);
  6516.       return app2;
  6517.     })()
  6518.   });
  6519.  
  6520. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址