@bobfrankston/rmfmail 1.0.676 → 1.0.678

package/client/compose/compose.bundle.js

@@ -1,12 +1,35 @@
+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 __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+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
+));
 
 // client/lib/api-client.js
 var api_client_exports = {};
@@ -524,10 +547,10 @@ async function createTinyMceEditor(container2, opts = {}) {
       // All free / OSS plugins bundled in the jsDelivr tinymce@6 script.
       // No premium plugins listed — listing one without an API key
       // triggers TinyMCE's upsell dialog on every load.
-      plugins: "paste lists link table code image searchreplace autolink wordcount emoticons charmap insertdatetime quickbars nonbreaking directionality",
+      plugins: "paste lists advlist link table code codesample image searchreplace autolink wordcount emoticons charmap insertdatetime quickbars nonbreaking directionality help",
       toolbar: [
         "undo redo | bold italic underline strikethrough | forecolor backcolor",
-        "bullist numlist outdent indent | link table image code | emoticons charmap"
+        "bullist numlist outdent indent | link table image code codesample | emoticons charmap | help"
       ].join(" | "),
       // Include "tools" so wordcount and searchreplace are reachable.
       menubar: "file edit view insert format tools",
@@ -685,7 +708,8 @@ async function createTinyMceEditor(container2, opts = {}) {
     },
     off(event, handler) {
       editor2.off(event, handler);
-    }
+    },
+    nativeEditor: editor2
   };
 }
 var init_rmf_tiny = __esm({
@@ -694,6 +718,1213 @@ var init_rmf_tiny = __esm({
   }
 });
 
+// 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(doc) {
+      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 = doc.toString("utf8");
+      var lines = [];
+      var last = 0;
+      var index = aff.indexOf("\n");
+      var parts;
+      var line;
+      var ruleType;
+      var count;
+      var remove;
+      var add;
+      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);
+            remove = parts[2];
+            add = parts[3].split("/");
+            source = parts[4];
+            entry = {
+              add: "",
+              remove: "",
+              match: "",
+              continuation: parse(flags, add[1])
+            };
+            if (add && add[0] !== "0") {
+              entry.add = add[0];
+            }
+            try {
+              if (remove !== "0") {
+                entry.remove = ruleType === "SFX" ? end(remove) : remove;
+              }
+              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 = add;
+    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 add(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 = add;
+    var NO_CODES = [];
+    function add(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 = remove;
+    function remove(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 add = 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) {
+        add(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 = add;
+    function add(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 = add;
+    function add(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 = NSpell2;
+    var proto = NSpell2.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 NSpell2(aff, dic) {
+      var index = -1;
+      var dictionaries;
+      if (!(this instanceof NSpell2)) {
+        return new NSpell2(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);
+          }
+        }
+      }
+    }
+  }
+});
+
+// client/compose/spellcheck.js
+var spellcheck_exports = {};
+__export(spellcheck_exports, {
+  wireSpellcheck: () => wireSpellcheck
+});
+async function getSpell() {
+  if (spellPromise)
+    return spellPromise;
+  spellPromise = (async () => {
+    const [affRes, dicRes] = await Promise.all([
+      fetch("../lib/dict/en.aff"),
+      fetch("../lib/dict/en.dic")
+    ]);
+    if (!affRes.ok || !dicRes.ok) {
+      throw new Error(`spellcheck: dict fetch failed (aff=${affRes.status} dic=${dicRes.status})`);
+    }
+    const [aff, dic] = await Promise.all([affRes.text(), dicRes.text()]);
+    const sp = new import_nspell.default({ aff, dic });
+    try {
+      const raw = localStorage.getItem(USER_DICT_KEY);
+      if (raw)
+        for (const w of JSON.parse(raw))
+          sp.add(w);
+    } catch {
+    }
+    return sp;
+  })();
+  return spellPromise;
+}
+function addToUserDict(word, sp) {
+  try {
+    const raw = localStorage.getItem(USER_DICT_KEY);
+    const arr = raw ? JSON.parse(raw) : [];
+    if (arr.includes(word))
+      return;
+    arr.push(word);
+    localStorage.setItem(USER_DICT_KEY, JSON.stringify(arr));
+  } catch {
+  }
+  sp.add(word);
+}
+function wordAtPoint(doc, x, y) {
+  const anyDoc = doc;
+  let caretNode = null;
+  let caretOffset = 0;
+  if (typeof anyDoc.caretRangeFromPoint === "function") {
+    const r = anyDoc.caretRangeFromPoint(x, y);
+    if (!r)
+      return null;
+    caretNode = r.startContainer;
+    caretOffset = r.startOffset;
+  } else if (typeof anyDoc.caretPositionFromPoint === "function") {
+    const p = anyDoc.caretPositionFromPoint(x, y);
+    if (!p)
+      return null;
+    caretNode = p.offsetNode;
+    caretOffset = p.offset;
+  } else {
+    return null;
+  }
+  if (!caretNode || caretNode.nodeType !== Node.TEXT_NODE)
+    return null;
+  const text = caretNode.data;
+  const isWordChar = (ch) => /[\p{L}\p{N}'’\-]/u.test(ch);
+  let start = caretOffset;
+  let end = caretOffset;
+  while (start > 0 && isWordChar(text[start - 1]))
+    start--;
+  while (end < text.length && isWordChar(text[end]))
+    end++;
+  if (start === end)
+    return null;
+  let word = text.slice(start, end);
+  while (word.length && /^['’\-]/.test(word)) {
+    word = word.slice(1);
+    start++;
+  }
+  while (word.length && /['’\-]$/.test(word)) {
+    word = word.slice(0, -1);
+    end--;
+  }
+  if (!word)
+    return null;
+  const range = doc.createRange();
+  range.setStart(caretNode, start);
+  range.setEnd(caretNode, end);
+  return { word, range };
+}
+function showSuggestionsMenu(parentDoc, x, y, items) {
+  parentDoc.getElementById("mailx-spell-menu")?.remove();
+  const menu = parentDoc.createElement("div");
+  menu.id = "mailx-spell-menu";
+  menu.style.cssText = `
+        position: fixed;
+        left: ${x}px; top: ${y}px;
+        z-index: 10000;
+        background: var(--color-bg, #fff);
+        color: var(--color-text, #222);
+        border: 1px solid var(--color-border, #ccc);
+        border-radius: 6px;
+        box-shadow: 0 4px 16px rgba(0,0,0,0.18);
+        padding: 4px 0;
+        font: 13px system-ui, sans-serif;
+        min-width: 160px;
+        max-width: 320px;
+    `;
+  for (const it of items) {
+    if (it.label === "---") {
+      const sep = parentDoc.createElement("div");
+      sep.style.cssText = "border-top:1px solid var(--color-border,#ddd); margin: 4px 0;";
+      menu.appendChild(sep);
+      continue;
+    }
+    const btn = parentDoc.createElement("button");
+    btn.type = "button";
+    btn.textContent = it.label;
+    btn.style.cssText = `
+            display: block; width: 100%; text-align: left;
+            padding: 5px 12px; border: none; background: none;
+            color: inherit; cursor: pointer; font: inherit;
+            ${it.emphasized ? "font-weight: 600;" : ""}
+        `;
+    btn.addEventListener("mouseenter", () => {
+      btn.style.background = "var(--color-bg-hover, #eef)";
+    });
+    btn.addEventListener("mouseleave", () => {
+      btn.style.background = "none";
+    });
+    btn.addEventListener("click", () => {
+      try {
+        it.action();
+      } finally {
+        menu.remove();
+      }
+    });
+    menu.appendChild(btn);
+  }
+  parentDoc.body.appendChild(menu);
+  const r = menu.getBoundingClientRect();
+  if (r.right > window.innerWidth)
+    menu.style.left = `${Math.max(8, window.innerWidth - r.width - 8)}px`;
+  if (r.bottom > window.innerHeight)
+    menu.style.top = `${Math.max(8, window.innerHeight - r.height - 8)}px`;
+  const dismiss2 = (e) => {
+    if (e.type === "keydown" && e.key !== "Escape")
+      return;
+    if (e.type === "mousedown" && menu.contains(e.target))
+      return;
+    menu.remove();
+    parentDoc.removeEventListener("mousedown", dismiss2, true);
+    parentDoc.removeEventListener("keydown", dismiss2, true);
+  };
+  setTimeout(() => {
+    parentDoc.addEventListener("mousedown", dismiss2, true);
+    parentDoc.addEventListener("keydown", dismiss2, true);
+  }, 0);
+}
+function replaceRange(doc, range, replacement) {
+  const sel = doc.getSelection();
+  if (!sel)
+    return;
+  sel.removeAllRanges();
+  sel.addRange(range);
+  try {
+    if (!doc.execCommand("insertText", false, replacement)) {
+      range.deleteContents();
+      range.insertNode(doc.createTextNode(replacement));
+    }
+  } catch {
+    range.deleteContents();
+    range.insertNode(doc.createTextNode(replacement));
+  }
+}
+function wireSpellcheck(editor2) {
+  if (editor2.__mailxSpellWired)
+    return;
+  editor2.__mailxSpellWired = true;
+  const iframeDoc = editor2.getDoc?.() || null;
+  if (!iframeDoc)
+    return;
+  iframeDoc.addEventListener("contextmenu", (ev) => {
+    const e = ev;
+    const iframeEl = editor2.iframeElement;
+    if (!iframeEl)
+      return;
+    const found = wordAtPoint(iframeDoc, e.clientX, e.clientY);
+    if (!found)
+      return;
+    getSpell().then((sp) => {
+      if (sp.correct(found.word))
+        return;
+      const sugs = sp.suggest(found.word).slice(0, 7);
+      const iframeRect = iframeEl.getBoundingClientRect();
+      const menuX = iframeRect.left + e.clientX;
+      const menuY = iframeRect.top + e.clientY;
+      const items = [];
+      if (sugs.length === 0) {
+        items.push({ label: "(no suggestions)", action: () => {
+        } });
+      } else {
+        for (const s of sugs) {
+          items.push({
+            label: s,
+            emphasized: true,
+            action: () => replaceRange(iframeDoc, found.range, s)
+          });
+        }
+      }
+      items.push({ label: "---", action: () => {
+      } });
+      items.push({
+        label: `Add "${found.word}" to dictionary`,
+        action: () => addToUserDict(found.word, sp)
+      });
+      items.push({
+        label: "Ignore (this session)",
+        action: () => sp.add(found.word)
+      });
+      showSuggestionsMenu(document, menuX, menuY, items);
+    }).catch((err) => {
+      console.error("[spellcheck] dict load failed:", err);
+      return;
+    });
+    e.preventDefault();
+    e.stopPropagation();
+  }, true);
+}
+var import_nspell, USER_DICT_KEY, spellPromise;
+var init_spellcheck = __esm({
+  "client/compose/spellcheck.js"() {
+    "use strict";
+    import_nspell = __toESM(require_lib(), 1);
+    USER_DICT_KEY = "mailx-user-dict";
+    spellPromise = null;
+  }
+});
+
 // client/compose/ghost-text.js
 var ghost_text_exports = {};
 __export(ghost_text_exports, {
@@ -1714,7 +2945,16 @@ async function tryEditor(type) {
   container.classList.remove("editor-tiptap", "editor-quill", "editor-tinymce");
   container.classList.add(`editor-${type}`);
   try {
-    return await createEditor(container, type);
+    const ed = await createEditor(container, type);
+    if (type === "tinymce" && ed && ed.nativeEditor) {
+      const native = ed.nativeEditor;
+      const attach = () => {
+        Promise.resolve().then(() => (init_spellcheck(), spellcheck_exports)).then((m) => m.wireSpellcheck(native)).catch((e) => console.error("[compose] spellcheck wire failed:", e));
+      };
+      if (native.initialized) attach();
+      else native.on("init", attach);
+    }
+    return ed;
   } catch (e) {
     logClientEvent("compose-editor-create-failed", { type, error: String(e?.message || e) });
     return null;
@@ -2873,4 +4113,14 @@ document.addEventListener("keydown", (e) => {
     }
   }
 });
+/*! Bundled license information:
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/
 //# sourceMappingURL=compose.bundle.js.map