litura-app 0.3.7 → 0.4.2

package/public/app.js

@@ -1,4 +1,1000 @@
 (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/is-buffer/index.js
+  var require_is_buffer = __commonJS({
+    "node_modules/is-buffer/index.js"(exports, module) {
+      module.exports = function isBuffer(obj) {
+        return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+      };
+    }
+  });
+
+  // node_modules/nspell/lib/util/rule-codes.js
+  var require_rule_codes = __commonJS({
+    "node_modules/nspell/lib/util/rule-codes.js"(exports, module) {
+      "use strict";
+      module.exports = ruleCodes;
+      var NO_CODES = [];
+      function ruleCodes(flags, value) {
+        var index = 0;
+        var result;
+        if (!value) return NO_CODES;
+        if (flags.FLAG === "long") {
+          result = new Array(Math.ceil(value.length / 2));
+          while (index < value.length) {
+            result[index / 2] = value.slice(index, index + 2);
+            index += 2;
+          }
+          return result;
+        }
+        return value.split(flags.FLAG === "num" ? "," : "");
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/affix.js
+  var require_affix = __commonJS({
+    "node_modules/nspell/lib/util/affix.js"(exports, module) {
+      "use strict";
+      var parse = require_rule_codes();
+      module.exports = affix;
+      var push = [].push;
+      var alphabet = "etaoinshrdlcumwfgypbvkjxqz".split("");
+      var whiteSpaceExpression = /\s+/;
+      var defaultKeyboardLayout = [
+        "qwertzuop",
+        "yxcvbnm",
+        "qaw",
+        "say",
+        "wse",
+        "dsx",
+        "sy",
+        "edr",
+        "fdc",
+        "dx",
+        "rft",
+        "gfv",
+        "fc",
+        "tgz",
+        "hgb",
+        "gv",
+        "zhu",
+        "jhn",
+        "hb",
+        "uji",
+        "kjm",
+        "jn",
+        "iko",
+        "lkm"
+      ];
+      function affix(doc2) {
+        var rules = /* @__PURE__ */ Object.create(null);
+        var compoundRuleCodes = /* @__PURE__ */ Object.create(null);
+        var flags = /* @__PURE__ */ Object.create(null);
+        var replacementTable = [];
+        var conversion = { in: [], out: [] };
+        var compoundRules = [];
+        var aff = doc2.toString("utf8");
+        var lines = [];
+        var last = 0;
+        var index = aff.indexOf("\n");
+        var parts;
+        var line;
+        var ruleType;
+        var count;
+        var remove2;
+        var add2;
+        var source;
+        var entry;
+        var position;
+        var rule;
+        var value;
+        var offset;
+        var character;
+        flags.KEY = [];
+        while (index > -1) {
+          pushLine(aff.slice(last, index));
+          last = index + 1;
+          index = aff.indexOf("\n", last);
+        }
+        pushLine(aff.slice(last));
+        index = -1;
+        while (++index < lines.length) {
+          line = lines[index];
+          parts = line.split(whiteSpaceExpression);
+          ruleType = parts[0];
+          if (ruleType === "REP") {
+            count = index + parseInt(parts[1], 10);
+            while (++index <= count) {
+              parts = lines[index].split(whiteSpaceExpression);
+              replacementTable.push([parts[1], parts[2]]);
+            }
+            index--;
+          } else if (ruleType === "ICONV" || ruleType === "OCONV") {
+            count = index + parseInt(parts[1], 10);
+            entry = conversion[ruleType === "ICONV" ? "in" : "out"];
+            while (++index <= count) {
+              parts = lines[index].split(whiteSpaceExpression);
+              entry.push([new RegExp(parts[1], "g"), parts[2]]);
+            }
+            index--;
+          } else if (ruleType === "COMPOUNDRULE") {
+            count = index + parseInt(parts[1], 10);
+            while (++index <= count) {
+              rule = lines[index].split(whiteSpaceExpression)[1];
+              position = -1;
+              compoundRules.push(rule);
+              while (++position < rule.length) {
+                compoundRuleCodes[rule.charAt(position)] = [];
+              }
+            }
+            index--;
+          } else if (ruleType === "PFX" || ruleType === "SFX") {
+            count = index + parseInt(parts[3], 10);
+            rule = {
+              type: ruleType,
+              combineable: parts[2] === "Y",
+              entries: []
+            };
+            rules[parts[1]] = rule;
+            while (++index <= count) {
+              parts = lines[index].split(whiteSpaceExpression);
+              remove2 = parts[2];
+              add2 = parts[3].split("/");
+              source = parts[4];
+              entry = {
+                add: "",
+                remove: "",
+                match: "",
+                continuation: parse(flags, add2[1])
+              };
+              if (add2 && add2[0] !== "0") {
+                entry.add = add2[0];
+              }
+              try {
+                if (remove2 !== "0") {
+                  entry.remove = ruleType === "SFX" ? end(remove2) : remove2;
+                }
+                if (source && source !== ".") {
+                  entry.match = ruleType === "SFX" ? end(source) : start(source);
+                }
+              } catch (_) {
+                entry = null;
+              }
+              if (entry) {
+                rule.entries.push(entry);
+              }
+            }
+            index--;
+          } else if (ruleType === "TRY") {
+            source = parts[1];
+            offset = -1;
+            value = [];
+            while (++offset < source.length) {
+              character = source.charAt(offset);
+              if (character.toLowerCase() === character) {
+                value.push(character);
+              }
+            }
+            offset = -1;
+            while (++offset < alphabet.length) {
+              if (source.indexOf(alphabet[offset]) < 0) {
+                value.push(alphabet[offset]);
+              }
+            }
+            flags[ruleType] = value;
+          } else if (ruleType === "KEY") {
+            push.apply(flags[ruleType], parts[1].split("|"));
+          } else if (ruleType === "COMPOUNDMIN") {
+            flags[ruleType] = Number(parts[1]);
+          } else if (ruleType === "ONLYINCOMPOUND") {
+            flags[ruleType] = parts[1];
+            compoundRuleCodes[parts[1]] = [];
+          } else if (ruleType === "FLAG" || ruleType === "KEEPCASE" || ruleType === "NOSUGGEST" || ruleType === "WORDCHARS") {
+            flags[ruleType] = parts[1];
+          } else {
+            flags[ruleType] = parts[1];
+          }
+        }
+        if (isNaN(flags.COMPOUNDMIN)) {
+          flags.COMPOUNDMIN = 3;
+        }
+        if (!flags.KEY.length) {
+          flags.KEY = defaultKeyboardLayout;
+        }
+        if (!flags.TRY) {
+          flags.TRY = alphabet.concat();
+        }
+        if (!flags.KEEPCASE) {
+          flags.KEEPCASE = false;
+        }
+        return {
+          compoundRuleCodes,
+          replacementTable,
+          conversion,
+          compoundRules,
+          rules,
+          flags
+        };
+        function pushLine(line2) {
+          line2 = line2.trim();
+          if (line2 && line2.charCodeAt(0) !== 35) {
+            lines.push(line2);
+          }
+        }
+      }
+      function end(source) {
+        return new RegExp(source + "$");
+      }
+      function start(source) {
+        return new RegExp("^" + source);
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/normalize.js
+  var require_normalize = __commonJS({
+    "node_modules/nspell/lib/util/normalize.js"(exports, module) {
+      "use strict";
+      module.exports = normalize;
+      function normalize(value, patterns) {
+        var index = -1;
+        while (++index < patterns.length) {
+          value = value.replace(patterns[index][0], patterns[index][1]);
+        }
+        return value;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/flag.js
+  var require_flag = __commonJS({
+    "node_modules/nspell/lib/util/flag.js"(exports, module) {
+      "use strict";
+      module.exports = flag;
+      function flag(values, value, flags) {
+        return flags && value in values && flags.indexOf(values[value]) > -1;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/exact.js
+  var require_exact = __commonJS({
+    "node_modules/nspell/lib/util/exact.js"(exports, module) {
+      "use strict";
+      var flag = require_flag();
+      module.exports = exact;
+      function exact(context, value) {
+        var index = -1;
+        if (context.data[value]) {
+          return !flag(context.flags, "ONLYINCOMPOUND", context.data[value]);
+        }
+        if (value.length >= context.flags.COMPOUNDMIN) {
+          while (++index < context.compoundRules.length) {
+            if (context.compoundRules[index].test(value)) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/form.js
+  var require_form = __commonJS({
+    "node_modules/nspell/lib/util/form.js"(exports, module) {
+      "use strict";
+      var normalize = require_normalize();
+      var exact = require_exact();
+      var flag = require_flag();
+      module.exports = form;
+      function form(context, value, all) {
+        var normal = value.trim();
+        var alternative;
+        if (!normal) {
+          return null;
+        }
+        normal = normalize(normal, context.conversion.in);
+        if (exact(context, normal)) {
+          if (!all && flag(context.flags, "FORBIDDENWORD", context.data[normal])) {
+            return null;
+          }
+          return normal;
+        }
+        if (normal.toUpperCase() === normal) {
+          alternative = normal.charAt(0) + normal.slice(1).toLowerCase();
+          if (ignore(context.flags, context.data[alternative], all)) {
+            return null;
+          }
+          if (exact(context, alternative)) {
+            return alternative;
+          }
+        }
+        alternative = normal.toLowerCase();
+        if (alternative !== normal) {
+          if (ignore(context.flags, context.data[alternative], all)) {
+            return null;
+          }
+          if (exact(context, alternative)) {
+            return alternative;
+          }
+        }
+        return null;
+      }
+      function ignore(flags, dict, all) {
+        return flag(flags, "KEEPCASE", dict) || all || flag(flags, "FORBIDDENWORD", dict);
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/correct.js
+  var require_correct = __commonJS({
+    "node_modules/nspell/lib/correct.js"(exports, module) {
+      "use strict";
+      var form = require_form();
+      module.exports = correct;
+      function correct(value) {
+        return Boolean(form(this, value));
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/casing.js
+  var require_casing = __commonJS({
+    "node_modules/nspell/lib/util/casing.js"(exports, module) {
+      "use strict";
+      module.exports = casing;
+      function casing(value) {
+        var head = exact(value.charAt(0));
+        var rest = value.slice(1);
+        if (!rest) {
+          return head;
+        }
+        rest = exact(rest);
+        if (head === rest) {
+          return head;
+        }
+        if (head === "u" && rest === "l") {
+          return "s";
+        }
+        return null;
+      }
+      function exact(value) {
+        return value === value.toLowerCase() ? "l" : value === value.toUpperCase() ? "u" : null;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/suggest.js
+  var require_suggest = __commonJS({
+    "node_modules/nspell/lib/suggest.js"(exports, module) {
+      "use strict";
+      var casing = require_casing();
+      var normalize = require_normalize();
+      var flag = require_flag();
+      var form = require_form();
+      module.exports = suggest;
+      var push = [].push;
+      function suggest(value) {
+        var self = this;
+        var charAdded = {};
+        var suggestions = [];
+        var weighted = {};
+        var memory;
+        var replacement;
+        var edits = [];
+        var values;
+        var index;
+        var offset;
+        var position;
+        var count;
+        var otherOffset;
+        var otherCharacter;
+        var character;
+        var group;
+        var before;
+        var after;
+        var upper;
+        var insensitive;
+        var firstLevel;
+        var previous;
+        var next;
+        var nextCharacter;
+        var max;
+        var distance;
+        var size;
+        var normalized;
+        var suggestion;
+        var currentCase;
+        value = normalize(value.trim(), self.conversion.in);
+        if (!value || self.correct(value)) {
+          return [];
+        }
+        currentCase = casing(value);
+        index = -1;
+        while (++index < self.replacementTable.length) {
+          replacement = self.replacementTable[index];
+          offset = value.indexOf(replacement[0]);
+          while (offset > -1) {
+            edits.push(value.replace(replacement[0], replacement[1]));
+            offset = value.indexOf(replacement[0], offset + 1);
+          }
+        }
+        index = -1;
+        while (++index < value.length) {
+          character = value.charAt(index);
+          before = value.slice(0, index);
+          after = value.slice(index + 1);
+          insensitive = character.toLowerCase();
+          upper = insensitive !== character;
+          charAdded = {};
+          offset = -1;
+          while (++offset < self.flags.KEY.length) {
+            group = self.flags.KEY[offset];
+            position = group.indexOf(insensitive);
+            if (position < 0) {
+              continue;
+            }
+            otherOffset = -1;
+            while (++otherOffset < group.length) {
+              if (otherOffset !== position) {
+                otherCharacter = group.charAt(otherOffset);
+                if (charAdded[otherCharacter]) {
+                  continue;
+                }
+                charAdded[otherCharacter] = true;
+                if (upper) {
+                  otherCharacter = otherCharacter.toUpperCase();
+                }
+                edits.push(before + otherCharacter + after);
+              }
+            }
+          }
+        }
+        index = -1;
+        nextCharacter = value.charAt(0);
+        values = [""];
+        max = 1;
+        distance = 0;
+        while (++index < value.length) {
+          character = nextCharacter;
+          nextCharacter = value.charAt(index + 1);
+          before = value.slice(0, index);
+          replacement = character === nextCharacter ? "" : character + character;
+          offset = -1;
+          count = values.length;
+          while (++offset < count) {
+            if (offset <= max) {
+              values.push(values[offset] + replacement);
+            }
+            values[offset] += character;
+          }
+          if (++distance < 3) {
+            max = values.length;
+          }
+        }
+        push.apply(edits, values);
+        values = [value];
+        replacement = value.toLowerCase();
+        if (value === replacement || currentCase === null) {
+          values.push(value.charAt(0).toUpperCase() + replacement.slice(1));
+        }
+        replacement = value.toUpperCase();
+        if (value !== replacement) {
+          values.push(replacement);
+        }
+        memory = {
+          state: {},
+          weighted,
+          suggestions
+        };
+        firstLevel = generate(self, memory, values, edits);
+        previous = 0;
+        max = Math.min(firstLevel.length, Math.pow(Math.max(15 - value.length, 3), 3));
+        size = Math.max(Math.pow(10 - value.length, 3), 1);
+        while (!suggestions.length && previous < max) {
+          next = previous + size;
+          generate(self, memory, firstLevel.slice(previous, next));
+          previous = next;
+        }
+        suggestions.sort(sort);
+        values = [];
+        normalized = [];
+        index = -1;
+        while (++index < suggestions.length) {
+          suggestion = normalize(suggestions[index], self.conversion.out);
+          replacement = suggestion.toLowerCase();
+          if (normalized.indexOf(replacement) < 0) {
+            values.push(suggestion);
+            normalized.push(replacement);
+          }
+        }
+        return values;
+        function sort(a, b) {
+          return sortWeight(a, b) || sortCasing(a, b) || sortAlpha(a, b);
+        }
+        function sortWeight(a, b) {
+          return weighted[a] === weighted[b] ? 0 : weighted[a] > weighted[b] ? -1 : 1;
+        }
+        function sortCasing(a, b) {
+          var leftCasing = casing(a);
+          var rightCasing = casing(b);
+          return leftCasing === rightCasing ? 0 : leftCasing === currentCase ? -1 : rightCasing === currentCase ? 1 : void 0;
+        }
+        function sortAlpha(a, b) {
+          return a.localeCompare(b);
+        }
+      }
+      function generate(context, memory, words, edits) {
+        var characters = context.flags.TRY;
+        var data = context.data;
+        var flags = context.flags;
+        var result = [];
+        var index = -1;
+        var word;
+        var before;
+        var character;
+        var nextCharacter;
+        var nextAfter;
+        var nextNextAfter;
+        var nextUpper;
+        var currentCase;
+        var position;
+        var after;
+        var upper;
+        var inject;
+        var offset;
+        if (edits) {
+          while (++index < edits.length) {
+            check(edits[index], true);
+          }
+        }
+        index = -1;
+        while (++index < words.length) {
+          word = words[index];
+          before = "";
+          character = "";
+          nextCharacter = word.charAt(0);
+          nextAfter = word;
+          nextNextAfter = word.slice(1);
+          nextUpper = nextCharacter.toLowerCase() !== nextCharacter;
+          currentCase = casing(word);
+          position = -1;
+          while (++position <= word.length) {
+            before += character;
+            after = nextAfter;
+            nextAfter = nextNextAfter;
+            nextNextAfter = nextAfter.slice(1);
+            character = nextCharacter;
+            nextCharacter = word.charAt(position + 1);
+            upper = nextUpper;
+            if (nextCharacter) {
+              nextUpper = nextCharacter.toLowerCase() !== nextCharacter;
+            }
+            if (nextAfter && upper !== nextUpper) {
+              check(before + switchCase(nextAfter));
+              check(
+                before + switchCase(nextCharacter) + switchCase(character) + nextNextAfter
+              );
+            }
+            check(before + nextAfter);
+            if (nextAfter) {
+              check(before + nextCharacter + character + nextNextAfter);
+            }
+            offset = -1;
+            while (++offset < characters.length) {
+              inject = characters[offset];
+              if (upper && inject !== inject.toUpperCase()) {
+                if (currentCase !== "s") {
+                  check(before + inject + after);
+                  check(before + inject + nextAfter);
+                }
+                inject = inject.toUpperCase();
+                check(before + inject + after);
+                check(before + inject + nextAfter);
+              } else {
+                check(before + inject + after);
+                check(before + inject + nextAfter);
+              }
+            }
+          }
+        }
+        return result;
+        function check(value, double) {
+          var state = memory.state[value];
+          var corrected;
+          if (state !== Boolean(state)) {
+            result.push(value);
+            corrected = form(context, value);
+            state = corrected && !flag(flags, "NOSUGGEST", data[corrected]);
+            memory.state[value] = state;
+            if (state) {
+              memory.weighted[value] = double ? 10 : 0;
+              memory.suggestions.push(value);
+            }
+          }
+          if (state) {
+            memory.weighted[value]++;
+          }
+        }
+        function switchCase(fragment) {
+          var first = fragment.charAt(0);
+          return (first.toLowerCase() === first ? first.toUpperCase() : first.toLowerCase()) + fragment.slice(1);
+        }
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/spell.js
+  var require_spell = __commonJS({
+    "node_modules/nspell/lib/spell.js"(exports, module) {
+      "use strict";
+      var form = require_form();
+      var flag = require_flag();
+      module.exports = spell;
+      function spell(word) {
+        var self = this;
+        var value = form(self, word, true);
+        return {
+          correct: self.correct(word),
+          forbidden: Boolean(
+            value && flag(self.flags, "FORBIDDENWORD", self.data[value])
+          ),
+          warn: Boolean(value && flag(self.flags, "WARN", self.data[value]))
+        };
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/apply.js
+  var require_apply = __commonJS({
+    "node_modules/nspell/lib/util/apply.js"(exports, module) {
+      "use strict";
+      module.exports = apply;
+      function apply(value, rule, rules, words) {
+        var index = -1;
+        var entry;
+        var next;
+        var continuationRule;
+        var continuation;
+        var position;
+        while (++index < rule.entries.length) {
+          entry = rule.entries[index];
+          continuation = entry.continuation;
+          position = -1;
+          if (!entry.match || entry.match.test(value)) {
+            next = entry.remove ? value.replace(entry.remove, "") : value;
+            next = rule.type === "SFX" ? next + entry.add : entry.add + next;
+            words.push(next);
+            if (continuation && continuation.length) {
+              while (++position < continuation.length) {
+                continuationRule = rules[continuation[position]];
+                if (continuationRule) {
+                  apply(next, continuationRule, rules, words);
+                }
+              }
+            }
+          }
+        }
+        return words;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/add.js
+  var require_add = __commonJS({
+    "node_modules/nspell/lib/util/add.js"(exports, module) {
+      "use strict";
+      var apply = require_apply();
+      module.exports = add2;
+      var push = [].push;
+      var NO_RULES = [];
+      function addRules(dict, word, rules) {
+        var curr = dict[word];
+        if (word in dict) {
+          if (curr === NO_RULES) {
+            dict[word] = rules.concat();
+          } else {
+            push.apply(curr, rules);
+          }
+        } else {
+          dict[word] = rules.concat();
+        }
+      }
+      function add2(dict, word, codes, options) {
+        var position = -1;
+        var rule;
+        var offset;
+        var subposition;
+        var suboffset;
+        var combined;
+        var newWords;
+        var otherNewWords;
+        if (!("NEEDAFFIX" in options.flags) || codes.indexOf(options.flags.NEEDAFFIX) < 0) {
+          addRules(dict, word, codes);
+        }
+        while (++position < codes.length) {
+          rule = options.rules[codes[position]];
+          if (codes[position] in options.compoundRuleCodes) {
+            options.compoundRuleCodes[codes[position]].push(word);
+          }
+          if (rule) {
+            newWords = apply(word, rule, options.rules, []);
+            offset = -1;
+            while (++offset < newWords.length) {
+              if (!(newWords[offset] in dict)) {
+                dict[newWords[offset]] = NO_RULES;
+              }
+              if (rule.combineable) {
+                subposition = position;
+                while (++subposition < codes.length) {
+                  combined = options.rules[codes[subposition]];
+                  if (combined && combined.combineable && rule.type !== combined.type) {
+                    otherNewWords = apply(
+                      newWords[offset],
+                      combined,
+                      options.rules,
+                      []
+                    );
+                    suboffset = -1;
+                    while (++suboffset < otherNewWords.length) {
+                      if (!(otherNewWords[suboffset] in dict)) {
+                        dict[otherNewWords[suboffset]] = NO_RULES;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/add.js
+  var require_add2 = __commonJS({
+    "node_modules/nspell/lib/add.js"(exports, module) {
+      "use strict";
+      var push = require_add();
+      module.exports = add2;
+      var NO_CODES = [];
+      function add2(value, model) {
+        var self = this;
+        push(self.data, value, self.data[model] || NO_CODES, self);
+        return self;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/remove.js
+  var require_remove = __commonJS({
+    "node_modules/nspell/lib/remove.js"(exports, module) {
+      "use strict";
+      module.exports = remove2;
+      function remove2(value) {
+        var self = this;
+        delete self.data[value];
+        return self;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/word-characters.js
+  var require_word_characters = __commonJS({
+    "node_modules/nspell/lib/word-characters.js"(exports, module) {
+      "use strict";
+      module.exports = wordCharacters;
+      function wordCharacters() {
+        return this.flags.WORDCHARS || null;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/util/dictionary.js
+  var require_dictionary = __commonJS({
+    "node_modules/nspell/lib/util/dictionary.js"(exports, module) {
+      "use strict";
+      var parseCodes = require_rule_codes();
+      var add2 = require_add();
+      module.exports = parse;
+      var whiteSpaceExpression = /\s/g;
+      function parse(buf, options, dict) {
+        var value = buf.toString("utf8");
+        var last = value.indexOf("\n") + 1;
+        var index = value.indexOf("\n", last);
+        while (index > -1) {
+          if (value.charCodeAt(last) !== 9) {
+            parseLine(value.slice(last, index), options, dict);
+          }
+          last = index + 1;
+          index = value.indexOf("\n", last);
+        }
+        parseLine(value.slice(last), options, dict);
+      }
+      function parseLine(line, options, dict) {
+        var slashOffset = line.indexOf("/");
+        var hashOffset = line.indexOf("#");
+        var codes = "";
+        var word;
+        var result;
+        while (slashOffset > -1 && line.charCodeAt(slashOffset - 1) === 92) {
+          line = line.slice(0, slashOffset - 1) + line.slice(slashOffset);
+          slashOffset = line.indexOf("/", slashOffset);
+        }
+        if (hashOffset > -1) {
+          if (slashOffset > -1 && slashOffset < hashOffset) {
+            word = line.slice(0, slashOffset);
+            whiteSpaceExpression.lastIndex = slashOffset + 1;
+            result = whiteSpaceExpression.exec(line);
+            codes = line.slice(slashOffset + 1, result ? result.index : void 0);
+          } else {
+            word = line.slice(0, hashOffset);
+          }
+        } else if (slashOffset > -1) {
+          word = line.slice(0, slashOffset);
+          codes = line.slice(slashOffset + 1);
+        } else {
+          word = line;
+        }
+        word = word.trim();
+        if (word) {
+          add2(dict, word, parseCodes(options.flags, codes.trim()), options);
+        }
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/dictionary.js
+  var require_dictionary2 = __commonJS({
+    "node_modules/nspell/lib/dictionary.js"(exports, module) {
+      "use strict";
+      var parse = require_dictionary();
+      module.exports = add2;
+      function add2(buf) {
+        var self = this;
+        var index = -1;
+        var rule;
+        var source;
+        var character;
+        var offset;
+        parse(buf, self, self.data);
+        while (++index < self.compoundRules.length) {
+          rule = self.compoundRules[index];
+          source = "";
+          offset = -1;
+          while (++offset < rule.length) {
+            character = rule.charAt(offset);
+            source += self.compoundRuleCodes[character].length ? "(?:" + self.compoundRuleCodes[character].join("|") + ")" : character;
+          }
+          self.compoundRules[index] = new RegExp(source, "i");
+        }
+        return self;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/personal.js
+  var require_personal = __commonJS({
+    "node_modules/nspell/lib/personal.js"(exports, module) {
+      "use strict";
+      module.exports = add2;
+      function add2(buf) {
+        var self = this;
+        var lines = buf.toString("utf8").split("\n");
+        var index = -1;
+        var line;
+        var forbidden;
+        var word;
+        var flag;
+        if (self.flags.FORBIDDENWORD === void 0) self.flags.FORBIDDENWORD = false;
+        flag = self.flags.FORBIDDENWORD;
+        while (++index < lines.length) {
+          line = lines[index].trim();
+          if (!line) {
+            continue;
+          }
+          line = line.split("/");
+          word = line[0];
+          forbidden = word.charAt(0) === "*";
+          if (forbidden) {
+            word = word.slice(1);
+          }
+          self.add(word, line[1]);
+          if (forbidden) {
+            self.data[word].push(flag);
+          }
+        }
+        return self;
+      }
+    }
+  });
+
+  // node_modules/nspell/lib/index.js
+  var require_lib = __commonJS({
+    "node_modules/nspell/lib/index.js"(exports, module) {
+      "use strict";
+      var buffer = require_is_buffer();
+      var affix = require_affix();
+      module.exports = NSpell;
+      var proto = NSpell.prototype;
+      proto.correct = require_correct();
+      proto.suggest = require_suggest();
+      proto.spell = require_spell();
+      proto.add = require_add2();
+      proto.remove = require_remove();
+      proto.wordCharacters = require_word_characters();
+      proto.dictionary = require_dictionary2();
+      proto.personal = require_personal();
+      function NSpell(aff, dic) {
+        var index = -1;
+        var dictionaries;
+        if (!(this instanceof NSpell)) {
+          return new NSpell(aff, dic);
+        }
+        if (typeof aff === "string" || buffer(aff)) {
+          if (typeof dic === "string" || buffer(dic)) {
+            dictionaries = [{ dic }];
+          }
+        } else if (aff) {
+          if ("length" in aff) {
+            dictionaries = aff;
+            aff = aff[0] && aff[0].aff;
+          } else {
+            if (aff.dic) {
+              dictionaries = [aff];
+            }
+            aff = aff.aff;
+          }
+        }
+        if (!aff) {
+          throw new Error("Missing `aff` in dictionary");
+        }
+        aff = affix(aff);
+        this.data = /* @__PURE__ */ Object.create(null);
+        this.compoundRuleCodes = aff.compoundRuleCodes;
+        this.replacementTable = aff.replacementTable;
+        this.conversion = aff.conversion;
+        this.compoundRules = aff.compoundRules;
+        this.rules = aff.rules;
+        this.flags = aff.flags;
+        if (dictionaries) {
+          while (++index < dictionaries.length) {
+            if (dictionaries[index].dic) {
+              this.dictionary(dictionaries[index].dic);
+            }
+          }
+        }
+      }
+    }
+  });
+
   // node_modules/@marijn/find-cluster-break/src/index.js
   var rangeFrom = [];
   var rangeTo = [];
@@ -16935,6 +17931,20 @@
     return ["pending", "applied", "kept"].includes(edit.state) && Number.isInteger(edit.from) && Number.isInteger(edit.to) && edit.from >= 0 && edit.to >= edit.from && edit.to <= document2.length && document2.slice(edit.from, edit.to) === expected;
   }
 
+  // spellcheck.js
+  var import_nspell = __toESM(require_lib(), 1);
+  var cached = null;
+  function loadSpellDictionary() {
+    return cached ??= Promise.all([
+      fetch("/dictionary/en.aff").then((res) => res.text()),
+      fetch("/dictionary/en.dic").then((res) => res.text())
+    ]).then(([aff, dic]) => (0, import_nspell.default)(aff, dic));
+  }
+  function spellingMarkers(text, spell) {
+    if (!spell || !isLatinScript(text)) return [];
+    return [...text.matchAll(WORD_RE)].filter((match) => match[0].length > 1 && !/^[A-Z]+$/.test(match[0]) && !spell.correct(match[0])).map((match) => ({ from: match.index, to: match.index + match[0].length, quote: match[0] }));
+  }
+
   // node_modules/@codemirror/search/dist/index.js
   var basicNormalize = typeof String.prototype.normalize == "function" ? (x) => x.normalize("NFKD") : (x) => x;
   var SearchCursor = class {
@@ -17127,21 +18137,21 @@
       return this.from + this.text.length;
     }
     static get(doc2, from, to) {
-      let cached = flattened.get(doc2);
-      if (!cached || cached.from >= to || cached.to <= from) {
+      let cached2 = flattened.get(doc2);
+      if (!cached2 || cached2.from >= to || cached2.to <= from) {
         let flat = new _FlattenedDoc(from, doc2.sliceString(from, to));
         flattened.set(doc2, flat);
         return flat;
       }
-      if (cached.from == from && cached.to == to)
-        return cached;
-      let { text, from: cachedFrom } = cached;
+      if (cached2.from == from && cached2.to == to)
+        return cached2;
+      let { text, from: cachedFrom } = cached2;
       if (cachedFrom > from) {
         text = doc2.sliceString(from, cachedFrom) + text;
         cachedFrom = from;
       }
-      if (cached.to < to)
-        text += doc2.sliceString(cached.to, to);
+      if (cached2.to < to)
+        text += doc2.sliceString(cached2.to, to);
       flattened.set(doc2, new _FlattenedDoc(cachedFrom, text));
       return new _FlattenedDoc(from, text.slice(from - cachedFrom, to - cachedFrom));
     }
@@ -18165,8 +19175,8 @@
       empty2.hidden = matched.length > 0;
       if (count) count.textContent = !state.options.length ? "" : matched.length > shown.length ? `Showing ${shown.length} of ${matched.length}` : "";
     }
-    function reposition() {
-      if (!popover.matches(":popover-open")) return;
+    function reposition(force) {
+      if (!force && !popover.matches(":popover-open")) return;
       const box = trigger.getBoundingClientRect();
       const width = Math.max(box.width, 260);
       popover.style.left = `${Math.min(box.left, window.innerWidth - width - 8)}px`;
@@ -18174,7 +19184,9 @@
       popover.style.width = `${width}px`;
     }
     state.reposition = reposition;
-    trigger.addEventListener("click", reposition);
+    popover.addEventListener("beforetoggle", (event) => {
+      if (event.newState === "open") reposition(true);
+    });
     popover.addEventListener("toggle", (event) => {
       if (event.newState !== "open") return;
       search.value = "";
@@ -18486,6 +19498,24 @@
       attributes: { "data-style-from": String(marker.from), title: "Possible stock wording \u2014 click to explore" }
     }).range(marker.from, marker.to)), true))
   });
+  var spellChecker = null;
+  var refreshSpellFx = StateEffect.define();
+  function visibleSpellMarkers(text) {
+    return spellingMarkers(text, spellChecker);
+  }
+  var spellMarkerField = StateField.define({
+    create: (state) => visibleSpellMarkers(state.doc.toString()),
+    update: (markers, tr) => {
+      for (const effect of tr.effects) {
+        if (effect.is(refreshSpellFx)) return visibleSpellMarkers(tr.newDoc.toString());
+      }
+      return tr.docChanged ? visibleSpellMarkers(tr.newDoc.toString()) : markers;
+    },
+    provide: (field) => EditorView.decorations.from(field, (markers) => Decoration.set(markers.map((marker) => Decoration.mark({
+      class: "cm-spell-marker",
+      attributes: { "data-spell-from": String(marker.from), title: "Possible misspelling \u2014 click for suggestions" }
+    }).range(marker.from, marker.to)), true))
+  });
   var setReviewFx = StateEffect.define();
   var addReviewFx = StateEffect.define();
   var dropReviewFx = StateEffect.define();
@@ -18536,6 +19566,33 @@
     },
     provide: (field) => EditorView.decorations.from(field)
   });
+  var setVariantTargetFx = StateEffect.define();
+  var variantTargetField = StateField.define({
+    create: () => Decoration.none,
+    update(decorations2, tr) {
+      for (const effect of tr.effects) {
+        if (effect.is(setVariantTargetFx)) {
+          return effect.value ? Decoration.set([Decoration.mark({ class: "cm-variant-target" }).range(effect.value.from, effect.value.to)]) : Decoration.none;
+        }
+      }
+      if (!tr.docChanged) return decorations2;
+      const edited = [];
+      tr.changes.iterChangedRanges((_fromA, _toA, fromB, toB) => edited.push([fromB, toB]));
+      return decorations2.map(tr.changes).update({
+        filter: (from, to) => !edited.some(([a, b]) => a < to && b > from)
+      });
+    },
+    provide: (field) => EditorView.decorations.from(field)
+  });
+  function markVariantTarget(target) {
+    try {
+      workView.dispatch({ effects: setVariantTargetFx.of(target ? { from: target.from, to: target.to } : null) });
+    } catch {
+    }
+  }
+  function syncVariantTarget() {
+    if (!document.querySelector(".chat-variants:not(.is-spent):not(.is-loading)")) markVariantTarget(null);
+  }
   function findingRange(id) {
     if (id === -1) return localFinding && chatEditMatches(localFinding, workView.state.doc.toString()) ? { from: localFinding.from, to: localFinding.to } : null;
     let found = null;
@@ -18594,8 +19651,6 @@
       if (localFinding) keepStyleMarker(localFinding);
       return;
     }
-    clearTimeout(appliedHideTimers.get(id));
-    appliedHideTimers.delete(id);
     const finding = reviewFindings.find((item) => item.id === id);
     const document2 = workView.state.doc.toString();
     const range = findingRange(id);
@@ -18608,7 +19663,7 @@
     if (card) {
       railAnchors.delete(card);
       railHomes.delete(card);
-      card.remove();
+      fadeRemove(card);
     }
     findingCards.delete(id);
     workView.dispatch({ effects: dropReviewFx.of(id) });
@@ -18617,6 +19672,7 @@
     else clearPlainPreview();
     refocusAfterRemoval(id);
     saveFindings();
+    syncVariantTarget();
     syncReviewLabel();
     workView.focus();
     if (decision) showEditFeedback("Kept as is", () => {
@@ -18649,6 +19705,7 @@
     reviewFindings = [];
     checkedSentences.clear();
     workView.dispatch({ effects: setReviewFx.of([]) });
+    markVariantTarget(null);
     docStorage.removeItem("wa-findings");
     syncReviewLabel();
   }
@@ -18765,16 +19822,16 @@
     updateBadge.title = command2;
   });
   async function refreshUpdate({ force = false } = {}) {
-    let cached = null;
+    let cached2 = null;
     try {
-      cached = JSON.parse(localStorage.getItem("wa-update") || "null");
+      cached2 = JSON.parse(localStorage.getItem("wa-update") || "null");
     } catch {
     }
-    const check = updateCheckOn && (force || !(cached && Date.now() - cached.at < UPDATE_INTERVAL));
+    const check = updateCheckOn && (force || !(cached2 && Date.now() - cached2.at < UPDATE_INTERVAL));
     try {
       const info = await api(`/api/version${check ? "?check=1" : ""}`);
       if (info.latest) localStorage.setItem("wa-update", JSON.stringify({ latest: info.latest, at: Date.now() }));
-      renderUpdate({ ...info, latest: info.latest ?? (updateCheckOn ? cached?.latest : void 0) });
+      renderUpdate({ ...info, latest: info.latest ?? (updateCheckOn ? cached2?.latest : void 0) });
     } catch {
     }
   }
@@ -18885,7 +19942,7 @@
     if (card) {
       railAnchors.delete(card);
       railHomes.delete(card);
-      card.remove();
+      fadeRemove(card);
       findingCards.delete(-1);
     }
     localFinding = null;
@@ -18987,7 +20044,7 @@
     suggestTimer = null;
     const view = workView;
     const state = view.state;
-    if (state.readOnly || loadingDocument || savePaused || !view.hasFocus || document.hidden || view.composing) return;
+    if (state.readOnly || loadingDocument || savePaused || !manual && !view.hasFocus || document.hidden || view.composing) return;
     if (!manual && !autoSuggestOn) return;
     if (!atParagraphEnd(state)) {
       if (manual) setReviewStatus("Place the caret at the end of a paragraph to request a continuation.", void 0, "suggest");
@@ -19003,11 +20060,11 @@
     if (/^\s*\/idea(?:\s|$)/i.test(line.text)) return;
     const version = suggestVersion;
     if (manual && !await ensureAgent()) return;
-    if (version !== suggestVersion || !view.hasFocus || !currentAgent()) return;
+    if (version !== suggestVersion || !manual && !view.hasFocus || !currentAgent()) return;
     const agent = currentAgent();
     const job = startJob({ background: !manual });
     suggestAbort = job;
-    const isCurrent = () => suggestAbort === job && !job.signal.aborted && version === suggestVersion && !loadingDocument && !savePaused && !document.hidden && view.hasFocus && !view.composing && !view.state.readOnly && (manual || autoSuggestOn) && view.state.doc === state.doc && view.state.selection.eq(state.selection) && JSON.stringify(currentAgent()) === JSON.stringify(agent);
+    const isCurrent = () => suggestAbort === job && !job.signal.aborted && version === suggestVersion && !loadingDocument && !savePaused && !document.hidden && (manual || view.hasFocus) && !view.composing && !view.state.readOnly && (manual || autoSuggestOn) && view.state.doc === state.doc && view.state.selection.eq(state.selection) && JSON.stringify(currentAgent()) === JSON.stringify(agent);
     if (manual) setReviewStatus("Suggesting\u2026", void 0, "suggest");
     try {
       const res = await fetch("/suggest", {
@@ -19016,7 +20073,8 @@
         body: JSON.stringify({
           document: doc2,
           cursor: pos,
-          agent
+          agent,
+          manual
         }),
         signal: job.signal
       });
@@ -19098,9 +20156,38 @@
     return node;
   }
   var chatAtBottom = () => chatStream.scrollHeight - chatStream.scrollTop - chatStream.clientHeight < 48;
-  function chatScroll(stick) {
-    chatStream.scrollTop = chatStream.scrollHeight;
+  var reduceMotion = () => window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  function chatScroll(stick, smooth = false) {
     void stick;
+    const top2 = chatStream.scrollHeight;
+    if (smooth && !reduceMotion()) {
+      try {
+        chatStream.scrollTo({ top: top2, behavior: "smooth" });
+        return;
+      } catch {
+      }
+    }
+    chatStream.scrollTop = top2;
+  }
+  function scrollToNode(node, block2 = "nearest") {
+    if (!node?.isConnected) return;
+    try {
+      node.scrollIntoView({ block: block2, behavior: reduceMotion() ? "auto" : "smooth" });
+    } catch {
+      try {
+        node.scrollIntoView();
+      } catch {
+      }
+    }
+  }
+  function fadeRemove(node, ms = 160) {
+    if (!node?.isConnected) return;
+    if (reduceMotion()) {
+      node.remove();
+      return;
+    }
+    node.classList.add("is-leaving");
+    setTimeout(() => node.remove(), ms);
   }
   function saveChat() {
     docStorage.setItem("wa-chat", JSON.stringify({ document: workView.state.doc.toString(), messages: chatHistory.slice(-20) }));
@@ -19176,7 +20263,12 @@ ${message.content}`;
       syncChatEditCards();
       undo2.focus();
     });
-    const undo2 = button("Undo", () => {
+    const undoFoot = chatEl("div", "variant-undo-row");
+    undoFoot.hidden = true;
+    const undo2 = chatEl("button", "chat-again", "Undo");
+    undo2.type = "button";
+    undo2.title = "Put the passage back as it was";
+    undo2.addEventListener("click", () => {
       if (edit.state === "kept") {
         edit.state = "pending";
         saveChat();
@@ -19184,6 +20276,7 @@ ${message.content}`;
         apply.focus();
       } else changeChatEdit(edit, true);
     });
+    undoFoot.append(undo2);
     const refresh = button("Request new edit", () => {
       if (edit.state === "unlocated") {
         chatInput.value = `Prepare an edit for the passage I select. Previous suggestion: ${edit.label}`;
@@ -19196,24 +20289,28 @@ ${message.content}`;
     const status = chatEl("p", "chat-edit-status");
     status.setAttribute("role", "status");
     actions.prepend(status);
-    card.append(actions);
-    chatEditCards.set(edit, { card, preview, apply, keep, undo: undo2, refresh, status });
+    card.append(actions, undoFoot);
+    chatEditCards.set(edit, { card, actions, preview, apply, keep, undo: undo2, undoFoot, refresh, status });
     syncChatEditCard(edit, chatEditCards.get(edit));
     return card;
   }
   function syncChatEditCard(edit, ui) {
     const valid = chatEditMatches(edit, workView.state.doc.toString());
     const pending = edit.state === "pending" && valid;
+    const showUndo = valid && ["applied", "kept"].includes(edit.state);
+    const appliedNow = valid && edit.state === "applied";
     ui.preview.hidden = ui.apply.hidden = ui.keep.hidden = !pending;
-    ui.undo.hidden = !valid || !["applied", "kept"].includes(edit.state);
+    ui.undo.hidden = !showUndo;
+    ui.undoFoot.hidden = !showUndo;
+    ui.card.classList.toggle("is-applied", appliedNow);
+    ui.actions.hidden = appliedNow;
     ui.refresh.hidden = valid;
     ui.refresh.textContent = edit.state === "unlocated" ? "Choose passage" : "Request new edit";
     ui.preview.textContent = plainPreview?.edit === edit ? "End preview" : "Preview";
     ui.preview.setAttribute("aria-pressed", String(plainPreview?.edit === edit));
     ui.apply.disabled = ui.undo.disabled = workView.state.readOnly || loadingDocument || savePaused;
-    ui.status.textContent = !valid ? edit.state === "unlocated" ? "Select the intended passage and request this edit again." : "" : edit.state === "applied" ? "Applied" : edit.state === "kept" ? "Original kept" : "";
+    ui.status.textContent = !valid ? edit.state === "unlocated" ? "Select the intended passage and request this edit again." : "" : edit.state === "kept" ? "Original kept" : "";
     ui.status.hidden = !ui.status.textContent;
-    ui.status.classList.toggle("is-ok", valid && edit.state === "applied");
   }
   function syncChatEditCards() {
     for (const [edit, ui] of chatEditCards) {
@@ -19249,35 +20346,11 @@ ${message.content}`;
   var rail = document.getElementById("rail");
   var railAnchors = /* @__PURE__ */ new Map();
   var railHomes = /* @__PURE__ */ new Map();
-  var RAIL_WIDTH = 300;
-  var RAIL_GUTTER = 24;
   var railOn = false;
   function syncRail() {
-    const margin = parseFloat(getComputedStyle(workView.contentDOM).paddingRight) || 0;
-    const fits = margin >= RAIL_WIDTH + RAIL_GUTTER;
-    if (fits) {
-      const box = workView.contentDOM.getBoundingClientRect();
-      const pane = document.getElementById("pane-work").getBoundingClientRect();
-      rail.style.left = `${box.right - margin - pane.left + RAIL_GUTTER}px`;
-    }
-    if (fits === railOn) return;
-    railOn = fits;
-    rail.hidden = !fits;
-    const focused = focusedFindingId;
-    for (const node of railAnchors.keys()) {
-      if (!node.isConnected) continue;
-      node.style.top = "";
-      node.style.visibility = "";
-      if (fits) {
-        node.style.display = "";
-        rail.append(node);
-      } else {
-        placeHome(node);
-        const nodeId = Number(node.dataset?.findingId);
-        node.style.display = focused === null || nodeId === focused ? "" : "none";
-      }
-    }
-    if (!fits) chatScroll(true);
+    railOn = false;
+    if (!rail.hidden) rail.hidden = true;
+    return;
   }
   function placeHome(node) {
     const home = railHomes.get(node) ?? chatStream;
@@ -19287,9 +20360,7 @@ ${message.content}`;
   function railAdd(node, anchor, home = chatStream) {
     railAnchors.set(node, anchor);
     railHomes.set(node, home);
-    syncRail();
-    if (railOn) rail.append(node);
-    else placeHome(node);
+    placeHome(node);
     layoutRail();
     return node;
   }
@@ -19320,19 +20391,11 @@ ${message.content}`;
     chatClear.title = open ? "Close \u2014 nothing is discarded" : "Show the conversation";
     if (open) {
       chatClear.hidden = false;
-      chatScroll(true);
+      chatScroll(true, true);
       return;
     }
     chatStream.hidden = true;
-    detach();
-    for (const card of findingCards.values()) {
-      const kept = card.querySelector(".chat-variants:has(.variant-card.is-applied)");
-      if (kept) streamAppend(kept);
-    }
-    discardFindingCards();
-    for (const stale of document.querySelectorAll(".chat-variants")) {
-      if (!stale.querySelector(".variant-card.is-applied")) stale.remove();
-    }
+    clearPlainPreview();
     chatClear.hidden = chatStream.children.length === 0;
     layoutRail();
   }
@@ -19458,6 +20521,35 @@ ${message.content}`;
     markBubble.replaceChildren(actions);
     placeBubble(x, y);
   }
+  function showContinueBubble(x, y) {
+    bubbleMode = "continue";
+    const actions = chatEl("div", "mark-bubble-actions");
+    actions.append(bubbleButton("Continue", () => {
+      workView.focus();
+      cancelSuggestion();
+      ghostClear(workView);
+      void suggestFetch(true);
+    }));
+    markBubble.replaceChildren(actions);
+    placeBubble(x, y);
+  }
+  function showSpellBubble(marker, x, y) {
+    bubbleMode = "spell";
+    const actions = chatEl("div", "mark-bubble-actions");
+    const replace2 = (suggestion) => {
+      if (workView.state.sliceDoc(marker.from, marker.to) !== marker.quote) return;
+      workView.dispatch({ changes: { from: marker.from, to: marker.to, insert: suggestion }, userEvent: "input.spellfix" });
+    };
+    for (const suggestion of (spellChecker?.suggest(marker.quote) ?? []).slice(0, 5)) {
+      actions.append(bubbleButton(suggestion, () => replace2(suggestion)));
+    }
+    actions.append(bubbleButton("Ignore", () => {
+      spellChecker?.add(marker.quote);
+      workView.dispatch({ effects: refreshSpellFx.of(null) });
+    }));
+    markBubble.replaceChildren(actions);
+    placeBubble(x, y);
+  }
   var PlainVariantWidget = class extends WidgetType {
     constructor(text, block2) {
       super();
@@ -19533,6 +20625,7 @@ ${message.content}`;
   }
   function applyText(text, target, wrap = null, card = null) {
     if (!replacementTarget(workView.state.doc.toString(), target) || workView.state.readOnly) {
+      markVariantTarget(null);
       chatAdd(chatEl("div", "chat-error", "The draft changed since this answer. Select the passage and request new options."));
       return;
     }
@@ -19544,6 +20637,7 @@ ${message.content}`;
       selection: { anchor: range.from + text.length },
       effects: [
         setPlainVariantFx.of(null),
+        setVariantTargetFx.of(null),
         setFlashFx.of({ from: range.from, to: range.from + text.length })
       ]
     });
@@ -19564,77 +20658,41 @@ ${message.content}`;
     if (card) card.classList.add("is-applied");
     if (wrap) {
       wrap.classList.add("is-spent");
-      for (const sibling of wrap.querySelectorAll(".variant-card")) {
-        if (sibling !== card) sibling.hidden = true;
-      }
-      const foot = wrap.querySelector(".variant-foot");
-      if (foot) foot.hidden = true;
-      const soloHint = wrap.querySelector(":scope > .variant-hint");
-      if (soloHint) soloHint.hidden = true;
       attachUndo(card, text, target);
       const hostCard = wrap.closest(".chat-card");
       if (hostCard && findingCards.has(Number(hostCard.dataset.findingId))) {
-        railAnchors.set(hostCard, () => target.from);
+        const findingId = Number(hostCard.dataset.findingId);
+        for (const sibling of wrap.querySelectorAll(".variant-card")) {
+          if (sibling !== card) sibling.hidden = true;
+        }
+        const foot = wrap.querySelector(".variant-foot");
+        if (foot) foot.hidden = true;
+        const soloHint = wrap.querySelector(":scope > .variant-hint");
+        if (soloHint) soloHint.hidden = true;
+        hostCard.querySelector(".finding-actions")?.remove();
+        railAnchors.delete(hostCard);
+        railHomes.delete(hostCard);
+        if (findingId === -1) localFinding = null;
+        else {
+          reviewFindings = reviewFindings.filter((finding) => finding.id !== findingId);
+          try {
+            workView.dispatch({ effects: dropReviewFx.of(findingId) });
+          } catch {
+          }
+          if (focusedFindingId === findingId) {
+            focusedFindingId = null;
+            syncActiveCard();
+          }
+        }
+        saveFindings();
+        syncReviewLabel();
+        syncStyleScore();
         layoutRail();
-        scheduleAppliedHide(hostCard, Number(hostCard.dataset.findingId));
       } else {
         setChatOpen(true);
       }
     }
   }
-  var APPLIED_HIDE_MS = 6e3;
-  var appliedHideTimers = /* @__PURE__ */ new Map();
-  function scheduleAppliedHide(hostCard, id) {
-    clearTimeout(appliedHideTimers.get(id));
-    appliedHideTimers.set(id, setTimeout(() => {
-      const card = findingCards.get(id);
-      if (!card || !card.isConnected) {
-        appliedHideTimers.delete(id);
-        return;
-      }
-      if (card.matches(":hover") || card.contains(document.activeElement)) {
-        scheduleAppliedHide(card, id);
-        return;
-      }
-      appliedHideTimers.delete(id);
-      resolveFinding(id);
-    }, APPLIED_HIDE_MS));
-  }
-  function resolveFinding(id) {
-    clearTimeout(appliedHideTimers.get(id));
-    appliedHideTimers.delete(id);
-    if (id === -1) {
-      removeLocalFinding();
-      saveFindings();
-      syncReviewLabel();
-      syncStyleScore();
-      updateFindingNav();
-      layoutRail();
-      return;
-    }
-    reviewFindings = reviewFindings.filter((finding) => finding.id !== id);
-    const card = findingCards.get(id);
-    if (card) {
-      railAnchors.delete(card);
-      railHomes.delete(card);
-      card.remove();
-    }
-    findingCards.delete(id);
-    try {
-      workView.dispatch({ effects: dropReviewFx.of(id) });
-    } catch {
-    }
-    if (focusedFindingId === id) {
-      focusedFindingId = null;
-      syncActiveCard();
-    }
-    saveFindings();
-    syncReviewLabel();
-    syncStyleScore();
-    updateFindingNav();
-    layoutRail();
-    if (chatStream.children.length === 0) setChatOpen(false);
-  }
   function attachUndo(card, text, target) {
     if (!card) return;
     let row = card.querySelector(".variant-undo-row");
@@ -19644,11 +20702,6 @@ ${message.content}`;
       undo3.type = "button";
       undo3.title = "Put the passage back as it was";
       undo3.addEventListener("click", () => {
-        const host = undo3.closest(".chat-card");
-        if (host?.dataset.findingId !== void 0 && host.dataset.findingId !== "") {
-          clearTimeout(appliedHideTimers.get(Number(host.dataset.findingId)));
-          appliedHideTimers.delete(Number(host.dataset.findingId));
-        }
         const at = Number(undo3.dataset.from);
         const { applied, previous } = undo3.dataset;
         if (!undo3.isConnected || undo3.dataset.stale || workView.state.sliceDoc(at, at + applied.length) !== applied) {
@@ -19660,13 +20713,14 @@ ${message.content}`;
         save();
         const spentWrap = undo3.closest(".chat-variants");
         const hostCard = undo3.closest(".chat-card");
-        spentWrap?.remove();
-        if (hostCard && hostCard.dataset.findingId && !hostCard.querySelector(".chat-variants")) {
+        fadeRemove(spentWrap);
+        syncVariantTarget();
+        if (hostCard && hostCard.dataset.findingId && !hostCard.querySelector(".chat-variants:not(.is-leaving)")) {
           const hostId = Number(hostCard.dataset.findingId);
           railAnchors.delete(hostCard);
           railHomes.delete(hostCard);
           findingCards.delete(hostId);
-          hostCard.remove();
+          fadeRemove(hostCard);
           refocusAfterRemoval(hostId);
         }
         layoutRail();
@@ -19698,13 +20752,8 @@ ${message.content}`;
           return findingRange(id)?.from ?? null;
         });
       }
-      if (!railOn && card.isConnected && card.parentElement === chatStream) {
-        card.style.display = focused === null || isFocused ? "" : "none";
-      } else {
-        card.style.display = "";
-      }
+      card.style.display = "";
     }
-    updateFindingNav();
     layoutRail();
   }
   function refocusAfterRemoval(removedId) {
@@ -19719,19 +20768,6 @@ ${message.content}`;
     card.dataset.findingId = String(finding.id);
     card.addEventListener("mouseenter", () => markFor(finding.id)?.classList.add("is-hot"));
     card.addEventListener("mouseleave", () => markFor(finding.id)?.classList.remove("is-hot"));
-    const nav2 = chatEl("div", "finding-nav");
-    const prev = chatEl("button", "finding-nav-btn", "\u2039");
-    prev.type = "button";
-    prev.title = "Previous finding (Shift+F8)";
-    prev.setAttribute("aria-label", "Previous finding");
-    prev.addEventListener("click", () => jumpToNextFinding(-1));
-    const count = chatEl("span", "finding-nav-count", "");
-    const next = chatEl("button", "finding-nav-btn", "\u203A");
-    next.type = "button";
-    next.title = "Next finding (F8)";
-    next.setAttribute("aria-label", "Next finding");
-    next.addEventListener("click", () => jumpToNextFinding(1));
-    nav2.append(prev, count, next);
     const dismiss = chatEl("button", "chat-card-dismiss", "Keep as is");
     dismiss.type = "button";
     dismiss.title = "Keep this wording and dismiss the finding";
@@ -19741,12 +20777,10 @@ ${message.content}`;
       dismissFinding(finding.id);
     });
     card.append(
-      nav2,
       chatEl("strong", "", finding.pattern),
       chatEl("span", "", finding.reason),
       chatEl("small", "", finding.fix)
     );
-    if (finding.id === -1) nav2.hidden = true;
     const offer = chatEl("button", "chat-offer", "Options");
     offer.type = "button";
     offer.addEventListener("click", () => {
@@ -19775,18 +20809,8 @@ ${message.content}`;
     if (finding.id === -1) dismiss.textContent = "Keep here";
     const variantsBox = chatEl("div", "finding-variants");
     card.append(actions, variantsBox);
-    updateFindingNav();
     return card;
   }
-  function updateFindingNav() {
-    const live = reviewFindings.map((finding) => ({ finding, range: findingRange(finding.id) })).filter((item) => item.range).sort((a, b) => a.range.from - b.range.from || a.finding.id - b.finding.id);
-    for (const [id, card] of findingCards) {
-      const count = card.querySelector(".finding-nav-count");
-      if (!count) continue;
-      const index = live.findIndex((item) => item.finding.id === id);
-      count.textContent = live.length ? `${index >= 0 ? index + 1 : "\u2013"} of ${live.length}` : "";
-    }
-  }
   function variantCards(variants, instruction, target, card = null) {
     const doc2 = workView.state.doc.toString();
     const ordered = isLatinScript(doc2) ? variants.map((text) => ({ text, score: styleScore(doc2.slice(0, target.from) + text + doc2.slice(target.to)).score })).sort((a, b) => a.score - b.score).map((item) => item.text) : variants.slice();
@@ -19799,9 +20823,8 @@ ${message.content}`;
       item.tabIndex = 0;
       item.setAttribute("role", "button");
       item.setAttribute("aria-label", `Apply option ${index + 1}`);
-      const label = chatEl("div", "variant-label", `Option ${index + 1}`);
       const body = chatEl("div", "variant-text", text);
-      item.append(label, body);
+      item.append(body);
       const previewIt = () => {
         if (wrap.classList.contains("is-spent")) return;
         if (!replacementTarget(workView.state.doc.toString(), target)) return;
@@ -19892,8 +20915,8 @@ ${message.content}`;
     layoutRail();
   }
   function retireStaleVariants(except) {
-    for (const stale of document.querySelectorAll(".chat-variants:not(.is-spent):not(.is-loading)")) {
-      if (stale !== except) stale.remove();
+    for (const stale of document.querySelectorAll(".chat-variants:not(.is-spent):not(.is-loading):not(.is-leaving)")) {
+      if (stale !== except) fadeRemove(stale);
     }
     layoutRail();
   }
@@ -19901,6 +20924,7 @@ ${message.content}`;
     const wrap = variantCards(variants, instruction, target);
     retireStaleVariants(wrap);
     chatAdd(wrap);
+    markVariantTarget(target);
     try {
       workView.dispatch({ effects: EditorView.scrollIntoView(target.from, { y: "center" }) });
     } catch {
@@ -19916,6 +20940,7 @@ ${message.content}`;
     if (!await ensureAgent()) return;
     if (!replacementTarget(workView.state.doc.toString(), target)) return;
     clearPlainPreview();
+    markVariantTarget(null);
     const inCard = !!(card && card.isConnected && card.querySelector(".finding-variants"));
     const box = inCard ? card.querySelector(".finding-variants") : null;
     if (inCard) {
@@ -19955,6 +20980,8 @@ ${message.content}`;
           done.textContent = "Options";
         }
         layoutRail();
+        markVariantTarget(target);
+        scrollToNode(wrap);
         try {
           workView.dispatch({ effects: EditorView.scrollIntoView(target.from, { y: "center" }) });
         } catch {
@@ -19967,21 +20994,25 @@ ${message.content}`;
           placeholder2.remove();
           chatAdd(wrap);
         }
+        markVariantTarget(target);
       }
     } catch (error) {
       if (error.name === "AbortError") {
         placeholder2.remove();
         if (card) restoreFindingCard(card);
         else layoutRail();
+        syncVariantTarget();
         return;
       }
       console.error("[/rewrite]", error);
       placeholder2.remove();
+      syncVariantTarget();
       if (!inCard) restoreFindingCard(card);
       const err = errorCard(modelError(error), () => requestVariants(instruction, target, card));
       if (inCard) {
         box.append(err);
         restoreFindingCard(card);
+        scrollToNode(err);
       } else chatAdd(err);
     } finally {
       finishJob(job);
@@ -20136,10 +21167,6 @@ Editing direction: ${activeFinding.fix}`,
     chatInput.closest(".chat-composer")?.classList.toggle("is-busy", busy);
     chatInput.placeholder = busy ? "Working\u2026" : basePlaceholder();
   }
-  document.getElementById("chat-rewrite").addEventListener("click", () => {
-    const range = attachedRange();
-    if (range) requestVariants(chatInput.value.trim() || "Make this passage clearer. Preserve meaning, facts and voice.");
-  });
   chatSendButton.addEventListener("click", () => {
     if ([...jobs].some((job) => !job.background)) {
       stopJobs();
@@ -20255,27 +21282,24 @@ Editing direction: ${activeFinding.fix}`,
     },
     // The attached passage. Survives losing focus, unlike a native selection —
     // that is the only job this mark has for a plain selection, which carries
-    // no marking of its own.
+    // no marking of its own. A background wash: underlines belong to errors
+    // (dictionary, typos) and are never used for working states.
     ".cm-attached": {
       background: "var(--attached-tint)",
       borderRadius: "3px",
       boxShadow: "0 0 0 2px var(--attached-tint)"
     },
-    // A finding already carries its own warm band. The attachment still needs a
-    // visible mark of its own — transparent here meant an open finding showed
-    // nothing of the working state — so it draws a blue underline over the band
-    // instead of a second fill. Tracking the live position is unchanged: that is
-    // what lets an edit end the attachment.
+    // Over a finding two washes would merge into one unreadable stain, so the
+    // attachment keeps a thin accent edge here on top of its wash — the single
+    // outlined exception, and only over findings. Tracking the live position
+    // is unchanged: that is what lets an edit end the attachment.
     ".cm-attached.cm-attached-finding": {
-      background: "transparent",
-      borderRadius: "2px",
-      boxShadow: "inset 0 -2px 0 var(--accent)"
+      background: "var(--attached-tint)",
+      borderRadius: "3px",
+      boxShadow: "0 0 0 2px var(--attached-tint), 0 0 0 3.5px var(--accent)"
     },
-    // A quiet amber band, not a spell-checker's wavy red and not a blue
-    // selection. Findings run over whole clauses here, and a wave under three
-    // lines of prose reads as an error the writer must clear rather than a
-    // remark they may weigh. Blue stays reserved for what the writer does:
-    // selection, attachment, suggestion.
+    // Model findings read as a background band. The wavy underline is reserved
+    // for errors (local dictionary, typos) — findings never underline.
     ".cm-slop": {
       background: "var(--remark-tint)",
       borderRadius: "2px",
@@ -20284,14 +21308,23 @@ Editing direction: ${activeFinding.fix}`,
       transition: "background .12s ease"
     },
     ".cm-slop:hover": { background: "var(--remark-tint-hover)" },
-    // Hover preview of a variant: a plain white sheet over the passage, no
-    // colours. The attached tint stays underneath for the passage itself; this
-    // replace decoration only shows while a card is hovered or focused.
+    // The passage whose variants are currently open: a dashed accent outline
+    // with a faint wash — the only dashed mark in the draft, reading as
+    // "deciding here". Paints over the attachment wash when they coincide;
+    // hover previews paint over everything while they last.
+    ".cm-variant-target": {
+      background: "color-mix(in srgb, var(--accent) 8%, transparent)",
+      borderRadius: "3px",
+      outline: "1.5px dashed var(--accent)",
+      outlineOffset: "3px"
+    },
+    // Hover preview of a variant: the same white sheet, but dashed — a sketch
+    // of the text, not the text. Only shows while a card is hovered or focused.
     ".cm-variant-plain": {
       background: "var(--overlay)",
       borderRadius: "2px",
       boxShadow: "0 0 0 2px var(--overlay)",
-      borderBottom: "1px solid var(--border-strong)"
+      border: "1px dashed var(--accent)"
     },
     // Slightly dim the content while /idea is streaming
     "&.streaming .cm-content": { opacity: "0.8" },
@@ -20354,12 +21387,23 @@ Editing direction: ${activeFinding.fix}`,
         ])),
         // Standard text-editing and history keymaps
         keymap.of([...searchKeymap, ...historyKeymap, ...defaultKeymap]),
-        EditorView.contentAttributes.of({ "aria-label": "Draft editor", "aria-describedby": "suggest-shortcut" }),
+        // Native spellcheck: free red squiggly + right-click suggestions from
+        // the OS/browser dictionary. Autocorrect/autocapitalize stay off — a
+        // silent rewrite is not what "quick fix" means here.
+        EditorView.contentAttributes.of({
+          "aria-label": "Draft editor",
+          "aria-describedby": "suggest-shortcut",
+          spellcheck: "true",
+          autocorrect: "off",
+          autocapitalize: "off"
+        }),
         // Ghost text state + decoration provider
         ghostField,
         reviewField,
         styleMarkerField,
+        spellMarkerField,
         attachField,
+        variantTargetField,
         variantPlainField,
         flashField,
         // Read-only compartment — toggled during /idea streaming
@@ -20389,9 +21433,16 @@ Editing direction: ${activeFinding.fix}`,
             const at = { x: event.clientX, y: event.clientY };
             const mark = event.target.closest?.(".cm-slop");
             if (!mark) {
+              const spellLocal = event.target.closest?.(".cm-spell-marker");
+              const spellMarker = spellLocal && view.state.field(spellMarkerField).find((item) => item.from === Number(spellLocal.dataset.spellFrom));
+              if (spellMarker) {
+                showSpellBubble(spellMarker, at.x, at.y);
+                return false;
+              }
               const local = event.target.closest?.(".cm-style-marker");
               const marker = local && view.state.field(styleMarkerField).find((item) => item.from === Number(local.dataset.styleFrom));
               if (marker) selectStyleMarker(marker);
+              else if (atParagraphEnd(view.state)) showContinueBubble(at.x, at.y);
               return false;
             }
             const finding = reviewFindings.find((item) => item.id === Number(mark.dataset.slopId));
@@ -20471,6 +21522,11 @@ Editing direction: ${activeFinding.fix}`,
     }),
     parent: editorWrap
   });
+  loadSpellDictionary().then((spell) => {
+    spellChecker = spell;
+    workView.dispatch({ effects: refreshSpellFx.of(null) });
+  }).catch(() => {
+  });
   new ResizeObserver(() => {
     chatHeight = Math.round(chatPanel.getBoundingClientRect().height) + 48;
     document.documentElement.style.setProperty("--chat-height", `${chatHeight}px`);
@@ -20675,8 +21731,8 @@ Editing direction: ${activeFinding.fix}`,
       documentName = current.path.split(/[\\/]/).pop();
       diskText = current.text;
       diskRevision = current.revision;
-      const cached = docStorage.getItem("wa-working");
-      workView.dispatch({ changes: { from: 0, to: workView.state.doc.length, insert: cached ?? current.text } });
+      const cached2 = docStorage.getItem("wa-working");
+      workView.dispatch({ changes: { from: 0, to: workView.state.doc.length, insert: cached2 ?? current.text } });
       loadingDocument = false;
       editorSetReadonly(workView, false);
       for (const paragraph of reviewParagraphs(workView.state.doc.toString())) checkedSentences.add(paragraph.key);
@@ -20691,7 +21747,7 @@ Editing direction: ${activeFinding.fix}`,
       restoreFindings();
       restoreChat();
       syncStyleScore();
-      if (cached !== null && cached !== current.text) promptDiskDrift(current);
+      if (cached2 !== null && cached2 !== current.text) promptDiskDrift(current);
       else {
         saveStatus.textContent = "";
         saveStatus.title = "";
@@ -20916,3 +21972,13 @@ Editing direction: ${activeFinding.fix}`,
   workView.focus();
   syncStyleScore();
 })();
+/*! Bundled license information:
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/