diff --git a/resources/js/espells.umd.js b/resources/js/espells.umd.js
new file mode 100644
index 0000000..40e5ce6
--- /dev/null
+++ b/resources/js/espells.umd.js
@@ -0,0 +1,3536 @@
+ var espells = (() => {
+ 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() {
+ try {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+ } catch (e) {
+ throw mod = 0, e;
+ }
+ };
+ 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
+ ));
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+ // node_modules/iterare/lib/concat.js
+ var require_concat = __commonJS({
+ "node_modules/iterare/lib/concat.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var ConcatIterator = class {
+ constructor(toConcat) {
+ this.toConcat = toConcat;
+ }
+ next() {
+ if (this.toConcat.length === 0) {
+ return { done: true };
+ }
+ const result = this.toConcat[0].next();
+ if (!result.done) {
+ return result;
+ }
+ this.toConcat.shift();
+ return this.next();
+ }
+ };
+ exports.ConcatIterator = ConcatIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/filter.js
+ var require_filter = __commonJS({
+ "node_modules/iterare/lib/filter.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var FilterIterator = class {
+ constructor(source, predicate) {
+ this.source = source;
+ this.predicate = predicate;
+ }
+ next() {
+ let result;
+ do {
+ result = this.source.next();
+ } while (!result.done && !this.predicate(result.value));
+ return result;
+ }
+ };
+ exports.FilterIterator = FilterIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/utils.js
+ var require_utils = __commonJS({
+ "node_modules/iterare/lib/utils.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ function isIterator(candidate) {
+ return typeof candidate === "object" && candidate !== null && typeof candidate.next === "function";
+ }
+ exports.isIterator = isIterator;
+ function isIterable(candidate) {
+ return typeof candidate === "object" && candidate !== null && typeof candidate[Symbol.iterator] === "function";
+ }
+ exports.isIterable = isIterable;
+ function toIterator(collection) {
+ if (isIterator(collection)) {
+ return collection;
+ }
+ if (isIterable(collection)) {
+ return collection[Symbol.iterator]();
+ }
+ throw new Error("Passed collection is neither an Iterator nor an Iterable");
+ }
+ exports.toIterator = toIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/flatten.js
+ var require_flatten = __commonJS({
+ "node_modules/iterare/lib/flatten.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var utils_1 = require_utils();
+ var FlattenIterator = class {
+ constructor(outer) {
+ this.outer = outer;
+ }
+ next() {
+ if (this.inner) {
+ const result = this.inner.next();
+ if (!result.done) {
+ return result;
+ }
+ this.inner = void 0;
+ }
+ const { value, done } = this.outer.next();
+ if (utils_1.isIterable(value)) {
+ this.inner = value[Symbol.iterator]();
+ return this.next();
+ }
+ return { value, done };
+ }
+ };
+ exports.FlattenIterator = FlattenIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/map.js
+ var require_map = __commonJS({
+ "node_modules/iterare/lib/map.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var MapIterator = class {
+ constructor(source, iteratee) {
+ this.source = source;
+ this.iteratee = iteratee;
+ }
+ next() {
+ const { value, done } = this.source.next();
+ return { value: !done && this.iteratee(value), done };
+ }
+ };
+ exports.MapIterator = MapIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/slice.js
+ var require_slice = __commonJS({
+ "node_modules/iterare/lib/slice.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var SliceIterator = class {
+ /**
+ * @param {Iterator<T>} source Source Iterator
+ * @param {number} start Zero-based positive start index, inclusive
+ * @param {number} end Zero-based positive end index, exclusive, defaults to end of iterator
+ */
+ constructor(source, start, end = Infinity) {
+ this.source = source;
+ this.start = start;
+ this.end = end;
+ this.i = 0;
+ }
+ next() {
+ while (this.i < this.start) {
+ const result = this.source.next();
+ if (result.done) {
+ return result;
+ }
+ this.i++;
+ }
+ this.i++;
+ if (this.i >= this.end) {
+ return { done: true };
+ }
+ return this.source.next();
+ }
+ };
+ exports.SliceIterator = SliceIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/zip.js
+ var require_zip = __commonJS({
+ "node_modules/iterare/lib/zip.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var ZipIterator = class {
+ constructor(a, b) {
+ this.a = a;
+ this.b = b;
+ }
+ next() {
+ const a = this.a.next();
+ if (a.done) {
+ return { done: true };
+ }
+ const b = this.b.next();
+ if (b.done) {
+ return { done: true };
+ }
+ return { value: [a.value, b.value], done: false };
+ }
+ };
+ exports.ZipIterator = ZipIterator;
+ }
+ });
+
+ // node_modules/iterare/lib/iterate.js
+ var require_iterate = __commonJS({
+ "node_modules/iterare/lib/iterate.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var concat_1 = require_concat();
+ var filter_1 = require_filter();
+ var flatten_1 = require_flatten();
+ var map_1 = require_map();
+ var slice_1 = require_slice();
+ var utils_1 = require_utils();
+ var zip_1 = require_zip();
+ var IteratorWithOperators = class _IteratorWithOperators {
+ /**
+ * @param source Iterator to wrap
+ */
+ constructor(source) {
+ this.source = source;
+ }
+ /**
+ * Returns a `{ value, done }` object that adheres to the Iterator protocol
+ */
+ next() {
+ return this.source.next();
+ }
+ /**
+ * The presence of this method makes the Iterator itself Iterable.
+ * This makes it possible to pass it to `for of` and Iterable-accepting functions like `Array.from()`
+ */
+ [Symbol.iterator]() {
+ return this;
+ }
+ /**
+ * Returns a new Iterator by running each element thru iteratee
+ */
+ map(iteratee) {
+ return new _IteratorWithOperators(new map_1.MapIterator(this.source, iteratee));
+ }
+ filter(predicate) {
+ return new _IteratorWithOperators(new filter_1.FilterIterator(this.source, predicate));
+ }
+ /**
+ * Returns a new Iterator concatenating the Iterator with an additional Iterator or Iterable
+ */
+ concat(collection) {
+ return new _IteratorWithOperators(new concat_1.ConcatIterator([this.source, utils_1.toIterator(collection)]));
+ }
+ /**
+ * Returns a new Iterator that emits slice of the source with n elements taken from the beginning
+ *
+ * @param limit The number of elements to take.
+ */
+ take(limit2) {
+ return new _IteratorWithOperators(new slice_1.SliceIterator(this.source, 0, limit2 + 1));
+ }
+ /**
+ * Returns a new Iterator that emits slice of the source with n elements dropped from the beginning
+ *
+ * @param n The number of elements to drop.
+ */
+ drop(n) {
+ return new _IteratorWithOperators(new slice_1.SliceIterator(this.source, n, Infinity));
+ }
+ /**
+ * Returns a new Iterator that emits a slice of the source
+ *
+ * @param {number} start Zero-based positive start index, inclusive
+ * @param {number} end Zero-based positive end index, exclusive, defaults to end of iterator
+ */
+ slice(start, end = Infinity) {
+ return new _IteratorWithOperators(new slice_1.SliceIterator(this.source, start, end));
+ }
+ /**
+ * Returns a new Iterator that flattens items emitted by the Iterator a single level deep
+ */
+ flatten() {
+ return new _IteratorWithOperators(new flatten_1.FlattenIterator(this.source));
+ }
+ reduce(iteratee, accumulator) {
+ let result;
+ if (accumulator === void 0) {
+ result = this.source.next();
+ if (result.done) {
+ throw new TypeError("Reduce of empty Iterator with no initial value");
+ }
+ accumulator = result.value;
+ }
+ while (true) {
+ result = this.source.next();
+ if (result.done) {
+ break;
+ }
+ accumulator = iteratee(accumulator, result.value);
+ }
+ return accumulator;
+ }
+ find(predicate) {
+ let result;
+ while (true) {
+ result = this.source.next();
+ if (result.done) {
+ return void 0;
+ }
+ if (predicate(result.value)) {
+ return result.value;
+ }
+ }
+ }
+ /**
+ * Iterates and checks if `value` is emitted by the Iterator
+ *
+ * @param value The value to search
+ */
+ includes(value) {
+ let result;
+ do {
+ result = this.source.next();
+ if (!result.done && result.value === value) {
+ return true;
+ }
+ } while (!result.done);
+ return false;
+ }
+ /**
+ * Iterates and checks if `predicate` returns truthy for any element emitted by the Iterator
+ */
+ some(predicate) {
+ let result;
+ do {
+ result = this.source.next();
+ if (!result.done && predicate(result.value)) {
+ return true;
+ }
+ } while (!result.done);
+ return false;
+ }
+ /**
+ * Iterates and checks if `predicate` returns truthy for all elements emitted by the Iterator
+ */
+ every(predicate) {
+ let result;
+ do {
+ result = this.source.next();
+ if (!result.done && !predicate(result.value)) {
+ return false;
+ }
+ } while (!result.done);
+ return true;
+ }
+ /**
+ * Iterates and invokes `iteratee` for every element emitted by the Iterator
+ */
+ forEach(iteratee) {
+ let result;
+ while (true) {
+ result = this.source.next();
+ if (result.done) {
+ break;
+ }
+ iteratee(result.value);
+ }
+ }
+ /**
+ * Iterates and joins all elements emitted by the Iterator together as a string separated by an optional separator
+ */
+ join(separator = ",") {
+ let joined = "";
+ let result;
+ while (true) {
+ result = this.source.next();
+ if (result.done) {
+ break;
+ }
+ joined += separator + result.value;
+ }
+ return joined.substr(separator.length);
+ }
+ /**
+ * Iterates and returns all items emitted by the Iterator as an array.
+ * Equivalent to passing the Iterator to `Array.from()`
+ */
+ toArray() {
+ return Array.from(this);
+ }
+ /**
+ * Iterates and returns all items emitted by the Iterator as an ES6 Set.
+ * Equivalent to passing the Iterator to `new Set()`
+ */
+ toSet() {
+ const set = /* @__PURE__ */ new Set();
+ while (true) {
+ const { value, done } = this.next();
+ if (done) {
+ return set;
+ }
+ set.add(value);
+ }
+ }
+ /**
+ * Iterates and returns all `[key, value]` paris emitted by the Iterator as an ES6 Map.
+ * Equivalent to passing the Iterator to `new Map()`
+ */
+ toMap() {
+ return new Map(this);
+ }
+ };
+ exports.IteratorWithOperators = IteratorWithOperators;
+ function iterate12(collection) {
+ return new IteratorWithOperators(utils_1.toIterator(collection));
+ }
+ exports.iterate = iterate12;
+ function zip(a, b) {
+ return new IteratorWithOperators(new zip_1.ZipIterator(utils_1.toIterator(a), utils_1.toIterator(b)));
+ }
+ exports.zip = zip;
+ exports.default = iterate12;
+ }
+ });
+
+ // node_modules/iterare/lib/index.js
+ var require_lib = __commonJS({
+ "node_modules/iterare/lib/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var iterate_1 = require_iterate();
+ exports.iterate = iterate_1.iterate;
+ exports.zip = iterate_1.zip;
+ exports.default = iterate_1.iterate;
+ }
+ });
+
+ // node_modules/espells/lib/index.js
+ var index_exports = {};
+ __export(index_exports, {
+ Espells: () => Espells
+ });
+ var import_iterare11 = __toESM(require_lib(), 1);
+
+ // node_modules/espells/lib/aff/index.js
+ var import_iterare4 = __toESM(require_lib(), 1);
+
+ // node_modules/espells/lib/constants.js
+ var CONSTANTS = {
+ /**
+ * A record of deprecated names that map to their proper name. Used in
+ * the {@link Aff} `.aff` parser.
+ */
+ SYNONYMS: {
+ PSEUDOROOT: "NEEDAFFIX",
+ COMPOUNDLAST: "COMPOUNDEND"
+ },
+ /**
+ * `RegExp` used to split a string of flags in "long" format, i.e. each
+ * flag is two characters.
+ */
+ FLAG_LONG_REGEX: /(..)(..)*/,
+ /**
+ * `RegExp` used to parse phoneme table rules.
+ *
+ * Groups:
+ *
+ * 1. Letters
+ * 2. Optional
+ * 3. Lookahead
+ * 4. Flags
+ * 5. Priority
+ */
+ PHONET_RULE_REGEX: /^(\p{L}+)(?:\((\p{L}+)\))?(-+)?([\^$<]*)(\d)?$/u,
+ /**
+ * `RegExp` used by the {@link Dic} `.dic` parser to determine if a line
+ * should be skipped.
+ */
+ DIC_SKIP_REGEX: /^\d+(\s+|$)|^\t|^\s*$/u,
+ /**
Diff truncated. 3043 more lines not shown.