@inshapardaz/likhari-react 0.1.21 → 0.1.22-dev.218

package/dist/normalization/urduNormalize.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Urdu character normalisation, ported from urduhack's `normalization/character.py`
+ * (MIT licence, https://github.com/urduhack/urduhack). The mapping replaces
+ * Arabic and presentation-form letters with the standard Urdu letter, and
+ * the tables below keep the same entries and order as the original, so the
+ * output matches it character for character.
+ */
+/** Replaces Arabic and presentation-form letters with standard Urdu letters, character by character. */
+export declare function normalizeUrduCharacters(text: string): string;
+export declare function removeUrduDiacritics(text: string): string;
+/** Converts Urdu digits to English digits, or the reverse. */
+export declare function replaceUrduDigits(text: string, to: 'english' | 'urdu'): string;
+export interface UrduNormalizationOptions {
+    /** Remove harakat. Off by default, since they are meaningful in poetry and religious text. */
+    removeDiacritics?: boolean;
+    /** Digit style to convert to; 'keep' (the default) leaves digits as they are. */
+    digits?: 'keep' | 'english' | 'urdu';
+}
+/**
+ * The normalisation urduhack's `normalize` applies, with the diacritic and
+ * digit steps made optional. Character mapping always runs.
+ */
+export declare function normalizeUrdu(text: string, options?: UrduNormalizationOptions): string;
+//# sourceMappingURL=urduNormalize.d.ts.map

package/dist/normalization/urduNormalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urduNormalize.d.ts","sourceRoot":"","sources":["../../src/normalization/urduNormalize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8EH,wGAAwG;AACxG,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,CAS9E;AAED,MAAM,WAAW,wBAAwB;IACvC,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,wBAA6B,GAAG,MAAM,CAK1F"}

package/dist/normalization/urduNormalize.js

@@ -0,0 +1,116 @@
+/**
+ * Urdu character normalisation, ported from urduhack's `normalization/character.py`
+ * (MIT licence, https://github.com/urduhack/urduhack). The mapping replaces
+ * Arabic and presentation-form letters with the standard Urdu letter, and
+ * the tables below keep the same entries and order as the original, so the
+ * output matches it character for character.
+ */
+const CORRECT_URDU_CHARACTERS = {
+    "آ": ["ﺁ", "ﺂ"],
+    "أ": ["ﺃ"],
+    "ا": ["ﺍ", "ﺎ"],
+    "ب": ["ﺏ", "ﺐ", "ﺑ", "ﺒ"],
+    "پ": ["ﭖ", "ﭘ", "ﭙ"],
+    "ت": ["ﺕ", "ﺖ", "ﺗ", "ﺘ"],
+    "ٹ": ["ﭦ", "ﭧ", "ﭨ", "ﭩ"],
+    "ث": ["ﺛ", "ﺜ", "ﺚ"],
+    "ج": ["ﺝ", "ﺞ", "ﺟ", "ﺠ"],
+    "ح": ["ﺡ", "ﺣ", "ﺤ", "ﺢ"],
+    "خ": ["ﺧ", "ﺨ", "ﺦ"],
+    "د": ["ﺩ", "ﺪ"],
+    "ذ": ["ﺬ", "ﺫ"],
+    "ر": ["ﺭ", "ﺮ"],
+    "ز": ["ﺯ", "ﺰ"],
+    "س": ["ﺱ", "ﺲ", "ﺳ", "ﺴ"],
+    "ش": ["ﺵ", "ﺶ", "ﺷ", "ﺸ"],
+    "ص": ["ﺹ", "ﺺ", "ﺻ", "ﺼ"],
+    "ض": ["ﺽ", "ﺾ", "ﺿ", "ﻀ"],
+    "ط": ["ﻃ", "ﻄ"],
+    "ظ": ["ﻅ", "ﻇ", "ﻈ"],
+    "ع": ["ﻉ", "ﻊ", "ﻋ", "ﻌ"],
+    "غ": ["ﻍ", "ﻏ", "ﻐ"],
+    "ف": ["ﻑ", "ﻒ", "ﻓ", "ﻔ"],
+    "ق": ["ﻕ", "ﻖ", "ﻗ", "ﻘ"],
+    "ل": ["ﻝ", "ﻞ", "ﻟ", "ﻠ"],
+    "م": ["ﻡ", "ﻢ", "ﻣ", "ﻤ"],
+    "ن": ["ﻥ", "ﻦ", "ﻧ", "ﻨ"],
+    "چ": ["ﭺ", "ﭻ", "ﭼ", "ﭽ"],
+    "ڈ": ["ﮈ", "ﮉ"],
+    "ڑ": ["ﮍ", "ﮌ"],
+    "ژ": ["ﮋ"],
+    "ک": ["ﮎ", "ﮏ", "ﮐ", "ﮑ", "ﻛ", "ك"],
+    "گ": ["ﮒ", "ﮓ", "ﮔ", "ﮕ"],
+    "ں": ["ﮞ", "ﮟ"],
+    "و": ["ﻮ", "ﻭ", "ﻮ"],
+    "ؤ": ["ﺅ"],
+    "ھ": ["ﮪ", "ﮬ", "ﮭ", "ﻬ", "ﻫ", "ﮫ"],
+    "ہ": ["ﻩ", "ﮦ", "ﻪ", "ﮧ", "ﮩ", "ﮨ", "ه"],
+    "ۂ": [],
+    "ۃ": ["ة"],
+    "ء": ["ﺀ"],
+    "ی": ["ﯼ", "ى", "ﯽ", "ﻰ", "ﻱ", "ﻲ", "ﯾ", "ﯿ", "ي"],
+    "ئ": ["ﺋ", "ﺌ"],
+    "ے": ["ﮮ", "ﮯ", "ﻳ", "ﻴ"],
+    "ۓ": [],
+    "۰": ["٠"],
+    "۱": ["١"],
+    "۲": ["٢"],
+    "۳": ["٣"],
+    "۴": ["٤"],
+    "۵": ["٥"],
+    "۶": ["٦"],
+    "۷": ["٧"],
+    "۸": ["٨"],
+    "۹": ["٩"],
+    "۔": [],
+    "؟": [],
+    "٫": [],
+    "،": [],
+    "لا": ["ﻻ", "ﻼ"],
+    "": ["ـ"],
+};
+const TRANSLATOR = new Map();
+for (const [key, values] of Object.entries(CORRECT_URDU_CHARACTERS)) {
+    for (const value of values)
+        TRANSLATOR.set(value, key);
+}
+/** Combining diacritics (harakat and similar), as urduhack's URDU_DIACRITICS. */
+const DIACRITICS = new Set(['َ', 'ً', 'ٰ', 'ِ', 'ُ', 'ٍ']);
+const ENGLISH_DIGITS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+const URDU_DIGITS = ['۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹'];
+/** Replaces Arabic and presentation-form letters with standard Urdu letters, character by character. */
+export function normalizeUrduCharacters(text) {
+    let out = '';
+    for (const char of text)
+        out += TRANSLATOR.get(char) ?? char;
+    return out;
+}
+export function removeUrduDiacritics(text) {
+    let out = '';
+    for (const char of text)
+        if (!DIACRITICS.has(char))
+            out += char;
+    return out;
+}
+/** Converts Urdu digits to English digits, or the reverse. */
+export function replaceUrduDigits(text, to) {
+    const from = to === 'english' ? URDU_DIGITS : ENGLISH_DIGITS;
+    const target = to === 'english' ? ENGLISH_DIGITS : URDU_DIGITS;
+    let out = '';
+    for (const char of text) {
+        const index = from.indexOf(char);
+        out += index === -1 ? char : target[index];
+    }
+    return out;
+}
+/**
+ * The normalisation urduhack's `normalize` applies, with the diacritic and
+ * digit steps made optional. Character mapping always runs.
+ */
+export function normalizeUrdu(text, options = {}) {
+    let out = options.removeDiacritics ? removeUrduDiacritics(text) : text;
+    out = normalizeUrduCharacters(out);
+    if (options.digits === 'english' || options.digits === 'urdu')
+        out = replaceUrduDigits(out, options.digits);
+    return out;
+}

package/dist/spellcheck/SpellHighlightPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Underlines misspelled words the way the browser does, without changing the
+ * document: ranges are set on the rendered text through the CSS Custom
+ * Highlight API. Checking is debounced so typing stays smooth. In browsers
+ * without the API, nothing is underlined.
+ */
+export declare function SpellHighlightPlugin(): null;
+//# sourceMappingURL=SpellHighlightPlugin.d.ts.map

package/dist/spellcheck/SpellHighlightPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpellHighlightPlugin.d.ts","sourceRoot":"","sources":["../../src/spellcheck/SpellHighlightPlugin.tsx"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wBAAgB,oBAAoB,SAkDnC"}

package/dist/spellcheck/SpellHighlightPlugin.js

@@ -0,0 +1,60 @@
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $collectMisspellings } from './spellcheckActions.js';
+import { getSpeller } from './spellDictionaries.js';
+import { onSpellWordsChange } from './userWords.js';
+/** The CSS Custom Highlight name; editor.css styles it as a red wavy underline. */
+const HIGHLIGHT = 'likhari-spelling';
+const DEBOUNCE_MS = 300;
+/**
+ * Underlines misspelled words the way the browser does, without changing the
+ * document: ranges are set on the rendered text through the CSS Custom
+ * Highlight API. Checking is debounced so typing stays smooth. In browsers
+ * without the API, nothing is underlined.
+ */
+export function SpellHighlightPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        if (typeof CSS === 'undefined' || !('highlights' in CSS))
+            return;
+        let checkers = null;
+        let timer;
+        let active = true;
+        const paint = () => {
+            if (!active || !checkers)
+                return;
+            const found = editor.getEditorState().read(() => $collectMisspellings(checkers));
+            const ranges = [];
+            for (const misspelling of found) {
+                for (const segment of misspelling.segments) {
+                    const text = editor.getElementByKey(segment.key)?.firstChild;
+                    if (!text || text.nodeType !== Node.TEXT_NODE)
+                        continue;
+                    const range = document.createRange();
+                    range.setStart(text, segment.start);
+                    range.setEnd(text, segment.end);
+                    ranges.push(range);
+                }
+            }
+            CSS.highlights.set(HIGHLIGHT, new Highlight(...ranges));
+        };
+        const schedule = () => {
+            clearTimeout(timer);
+            timer = setTimeout(paint, DEBOUNCE_MS);
+        };
+        const unregister = editor.registerUpdateListener(schedule);
+        const unsubscribe = onSpellWordsChange(schedule);
+        Promise.all([getSpeller('en'), getSpeller('ur')]).then(async ([en, ur]) => {
+            checkers = { ltr: en ? await en : undefined, rtl: ur ? await ur : undefined };
+            schedule();
+        });
+        return () => {
+            active = false;
+            clearTimeout(timer);
+            unregister();
+            unsubscribe();
+            CSS.highlights.delete(HIGHLIGHT);
+        };
+    }, [editor]);
+    return null;
+}

package/dist/spellcheck/spellDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spellDictionaries.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellDictionaries.ts"],"names":[],"mappings":"AAEA,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,cAAc,CAAC;AAEzD,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACjC;AAED,KAAK,MAAM,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;AAmB3C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAGpG;AAED,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAS3E;AAED,gEAAgE;AAChE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AASD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMhD;AAED,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,EAAE,CAEzE"}
+{"version":3,"file":"spellDictionaries.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellDictionaries.ts"],"names":[],"mappings":"AAGA,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,cAAc,CAAC;AAEzD,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACjC;AAED,KAAK,MAAM,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;AAmB3C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAGpG;AAED,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAe3E;AAED,gEAAgE;AAChE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AASD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMhD;AAED,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,EAAE,CAEzE"}

package/dist/spellcheck/spellDictionaries.js

@@ -1,4 +1,5 @@
 import nspell from 'nspell';
+import { isAcceptedWord } from './userWords.js';
 const loaders = new Map();
 const spellers = new Map();
 async function fetchText(url) {
@@ -38,7 +39,13 @@ export function getSpeller(language) {
         return null;
     let speller = spellers.get(language);
     if (!speller) {
-        speller = loader().then(({ aff, dic }) => nspell(aff, dic));
+        speller = loader()
+            .then(({ aff, dic }) => nspell(aff, dic))
+            .then((base) => ({
+            // Words the user added or ignored count as correct, whatever the dictionary says.
+            correct: (word) => isAcceptedWord(language, word) || base.correct(word),
+            suggest: (word) => base.suggest(word),
+        }));
         spellers.set(language, speller);
     }
     return speller;

package/dist/spellcheck/spellcheckActions.d.ts

@@ -0,0 +1,21 @@
+import { type FindMatch } from '../find/findReplaceActions.js';
+import { type Speller } from './spellDictionaries.js';
+/** The checker for each text direction: English for LTR blocks, Urdu for RTL. */
+export interface Checkers {
+    ltr?: Speller;
+    rtl?: Speller;
+}
+/** The part of a misspelled word that falls inside one text node. */
+export interface Segment {
+    key: string;
+    start: number;
+    end: number;
+}
+export interface Misspelling {
+    word: string;
+    match: FindMatch;
+    segments: Segment[];
+}
+/** Every word in the document its block's checker does not recognise. */
+export declare function $collectMisspellings(checkers: Checkers): Misspelling[];
+//# sourceMappingURL=spellcheckActions.d.ts.map

package/dist/spellcheck/spellcheckActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spellcheckActions.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellcheckActions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,CAmBtE"}

package/dist/spellcheck/spellcheckActions.js

@@ -0,0 +1,38 @@
+import { $textGroups, $locate } from '../find/findReplaceActions.js';
+import { wordsIn } from './spellDictionaries.js';
+/** Every word in the document its block's checker does not recognise. */
+export function $collectMisspellings(checkers) {
+    const found = [];
+    for (const group of $textGroups()) {
+        const direction = group[0].getParentOrThrow().getDirection();
+        const speller = direction === 'rtl' ? checkers.rtl : checkers.ltr;
+        if (!speller)
+            continue;
+        const text = group.map((node) => node.getTextContent()).join('');
+        for (const span of wordsIn(text)) {
+            if (speller.correct(span.word))
+                continue;
+            const start = $locate(group, span.start, false);
+            const end = $locate(group, span.end, true);
+            found.push({
+                word: span.word,
+                match: { anchorKey: start.key, anchorOffset: start.offset, focusKey: end.key, focusOffset: end.offset },
+                segments: segmentsOf(group, span.start, span.end),
+            });
+        }
+    }
+    return found;
+}
+function segmentsOf(group, start, end) {
+    const segments = [];
+    let offset = 0;
+    for (const node of group) {
+        const length = node.getTextContent().length;
+        const from = Math.max(start, offset);
+        const to = Math.min(end, offset + length);
+        if (to > from)
+            segments.push({ key: node.getKey(), start: from - offset, end: to - offset });
+        offset += length;
+    }
+    return segments;
+}

package/dist/spellcheck/spellingMenu.d.ts

@@ -0,0 +1,15 @@
+import type { FindMatch } from '../find/findReplaceActions.js';
+/** A word under the pointer, as a Lexical range, with the direction of its block. */
+export interface WordAtPoint {
+    word: string;
+    direction: 'ltr' | 'rtl';
+    match: FindMatch;
+}
+/** The DOM text node and offset under a viewport point, or null if the point is not on text. */
+export declare function textPointAt(x: number, y: number): {
+    node: Node;
+    offset: number;
+} | null;
+/** The whole word around an offset in a Lexical text node. Must run inside an editor read or update. */
+export declare function $wordAtDomPoint(domText: Node, offset: number): WordAtPoint | null;
+//# sourceMappingURL=spellingMenu.d.ts.map

package/dist/spellcheck/spellingMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spellingMenu.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellingMenu.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,qFAAqF;AACrF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;IACzB,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAUvF;AAED,wGAAwG;AACxG,wBAAgB,eAAe,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAWjF"}

package/dist/spellcheck/spellingMenu.js

@@ -0,0 +1,27 @@
+import { $getNearestNodeFromDOMNode, $isTextNode } from 'lexical';
+import { wordsIn } from './spellDictionaries.js';
+/** The DOM text node and offset under a viewport point, or null if the point is not on text. */
+export function textPointAt(x, y) {
+    const doc = document;
+    if (doc.caretPositionFromPoint) {
+        const position = doc.caretPositionFromPoint(x, y);
+        return position && position.offsetNode.nodeType === Node.TEXT_NODE ? { node: position.offsetNode, offset: position.offset } : null;
+    }
+    const range = doc.caretRangeFromPoint?.(x, y);
+    return range && range.startContainer.nodeType === Node.TEXT_NODE ? { node: range.startContainer, offset: range.startOffset } : null;
+}
+/** The whole word around an offset in a Lexical text node. Must run inside an editor read or update. */
+export function $wordAtDomPoint(domText, offset) {
+    const node = $getNearestNodeFromDOMNode(domText);
+    if (!$isTextNode(node))
+        return null;
+    const text = node.getTextContent();
+    const span = wordsIn(text).find((s) => offset >= s.start && offset <= s.end);
+    if (!span)
+        return null;
+    return {
+        word: span.word,
+        direction: node.getParentOrThrow().getDirection() === 'rtl' ? 'rtl' : 'ltr',
+        match: { anchorKey: node.getKey(), anchorOffset: span.start, focusKey: node.getKey(), focusOffset: span.end },
+    };
+}

package/dist/spellcheck/userWords.d.ts

@@ -0,0 +1,39 @@
+import type { SpellLanguage } from './spellDictionaries.js';
+/**
+ * Where words the user has added to the dictionary are kept. Like the
+ * auto-correct stores: the host can pass several, and words are added to the
+ * first one that accepts writes.
+ */
+export interface UserWordStore {
+    readonly id: string;
+    readonly readOnly?: boolean;
+    load(language: SpellLanguage): Promise<string[]>;
+    append?(language: SpellLanguage, word: string): Promise<void>;
+}
+/** Words added to the dictionary, kept in this browser's localStorage. */
+export declare function localStorageUserWordStore(options?: {
+    key?: string;
+}): UserWordStore;
+/**
+ * Words served by an API. `load` calls `GET {url}?language=xx` and expects a JSON
+ * array of strings; `append` calls `POST {url}` with `{ language, word }`.
+ */
+export declare function apiUserWordStore(options: {
+    id?: string;
+    url: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}): UserWordStore;
+/** Calls `listener` whenever accepted or ignored words change. Returns an unsubscribe function. */
+export declare function onSpellWordsChange(listener: () => void): () => void;
+/** Whether the speller should treat the word as correct: it is in the user's dictionary or ignored this session. */
+export declare function isAcceptedWord(language: SpellLanguage, word: string): boolean;
+/** Loads the user's words for each language from the stores (in order). */
+export declare function loadUserWords(stores: UserWordStore[]): Promise<void>;
+/** Adds a word to the first store that accepts writes. Returns false if none does. */
+export declare function addUserWord(stores: UserWordStore[], language: SpellLanguage, word: string): Promise<boolean>;
+/** Loads the session's ignored words. Call once at startup. */
+export declare function restoreIgnoredWords(): void;
+/** Ignores a word for the rest of this browser session (kept in sessionStorage). */
+export declare function ignoreWord(language: SpellLanguage, word: string): void;
+//# sourceMappingURL=userWords.d.ts.map

package/dist/spellcheck/userWords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userWords.d.ts","sourceRoot":"","sources":["../../src/spellcheck/userWords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACjD,MAAM,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAoBD,0EAA0E;AAC1E,wBAAgB,yBAAyB,CAAC,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,aAAa,CAoBvF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,GAAG,aAAa,CAmBhB;AAWD,mGAAmG;AACnG,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAGnE;AAED,oHAAoH;AACpH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7E;AAED,2EAA2E;AAC3E,wBAAsB,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1E;AAED,sFAAsF;AACtF,wBAAsB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlH;AAWD,+DAA+D;AAC/D,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAUtE"}

package/dist/spellcheck/userWords.js

@@ -0,0 +1,132 @@
+const LOCAL_KEY = 'likhari-user-words';
+const SESSION_KEY = 'likhari-spell-ignore';
+const LANGUAGES = ['en', 'ur', 'pa-shahmukhi'];
+function readStored(key) {
+    try {
+        const parsed = JSON.parse(localStorage.getItem(key) ?? '[]');
+        return Array.isArray(parsed) ? parsed.filter((e) => typeof e?.word === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Words added to the dictionary, kept in this browser's localStorage. */
+export function localStorageUserWordStore(options = {}) {
+    const key = options.key ?? LOCAL_KEY;
+    return {
+        id: 'local-storage',
+        async load(language) {
+            return readStored(key)
+                .filter((e) => e.language === language)
+                .map((e) => e.word);
+        },
+        async append(language, word) {
+            const all = readStored(key);
+            if (all.some((e) => e.language === language && e.word === word))
+                return;
+            all.push({ language, word });
+            try {
+                localStorage.setItem(key, JSON.stringify(all));
+            }
+            catch {
+                // Storage full or disabled: the word stays for this session only.
+            }
+        },
+    };
+}
+/**
+ * Words served by an API. `load` calls `GET {url}?language=xx` and expects a JSON
+ * array of strings; `append` calls `POST {url}` with `{ language, word }`.
+ */
+export function apiUserWordStore(options) {
+    const doFetch = options.fetch ?? fetch;
+    return {
+        id: options.id ?? 'api',
+        async load(language) {
+            const response = await doFetch(`${options.url}?language=${encodeURIComponent(language)}`, { headers: options.headers });
+            if (!response.ok)
+                throw new Error(`User word API failed: ${response.status}`);
+            const data = await response.json();
+            return Array.isArray(data) ? data.filter((w) => typeof w === 'string') : [];
+        },
+        async append(language, word) {
+            const response = await doFetch(options.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...options.headers },
+                body: JSON.stringify({ language, word }),
+            });
+            if (!response.ok)
+                throw new Error(`User word API rejected the word: ${response.status}`);
+        },
+    };
+}
+// Words the user accepted (kept in their store), and words ignored for this session.
+const accepted = new Map(LANGUAGES.map((l) => [l, new Set()]));
+const ignored = new Map(LANGUAGES.map((l) => [l, new Set()]));
+const listeners = new Set();
+function notify() {
+    for (const listener of listeners)
+        listener();
+}
+/** Calls `listener` whenever accepted or ignored words change. Returns an unsubscribe function. */
+export function onSpellWordsChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+/** Whether the speller should treat the word as correct: it is in the user's dictionary or ignored this session. */
+export function isAcceptedWord(language, word) {
+    return accepted.get(language)?.has(word) === true || ignored.get(language)?.has(word) === true;
+}
+/** Loads the user's words for each language from the stores (in order). */
+export async function loadUserWords(stores) {
+    for (const language of LANGUAGES) {
+        const set = accepted.get(language);
+        set.clear();
+        const results = await Promise.allSettled(stores.map((store) => store.load(language)));
+        for (const result of results)
+            if (result.status === 'fulfilled')
+                for (const word of result.value)
+                    set.add(word);
+    }
+    notify();
+}
+/** Adds a word to the first store that accepts writes. Returns false if none does. */
+export async function addUserWord(stores, language, word) {
+    const writable = stores.find((store) => !store.readOnly && store.append);
+    if (!writable?.append)
+        return false;
+    await writable.append(language, word);
+    accepted.get(language)?.add(word);
+    notify();
+    return true;
+}
+function readIgnored() {
+    try {
+        const parsed = JSON.parse(sessionStorage.getItem(SESSION_KEY) ?? '[]');
+        return Array.isArray(parsed) ? parsed.filter((e) => typeof e?.word === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Loads the session's ignored words. Call once at startup. */
+export function restoreIgnoredWords() {
+    for (const { language, word } of readIgnored())
+        ignored.get(language)?.add(word);
+    notify();
+}
+/** Ignores a word for the rest of this browser session (kept in sessionStorage). */
+export function ignoreWord(language, word) {
+    ignored.get(language)?.add(word);
+    const all = readIgnored();
+    if (!all.some((e) => e.language === language && e.word === word))
+        all.push({ language, word });
+    try {
+        sessionStorage.setItem(SESSION_KEY, JSON.stringify(all));
+    }
+    catch {
+        // Session storage unavailable: the word is ignored until the page reloads.
+    }
+    notify();
+}
+restoreIgnoredWords();