[elpa] externals/jinx a211c5fc00 3/3: Update commentary

[ELPA Syncer]

branch: externals/jinx
commit a211c5fc00c7e202ae8057fc63ee6c67d107e415
Author: Daniel Mendler <mail@daniel-mendler.de>
Commit: Daniel Mendler <mail@daniel-mendler.de>

    Update commentary
---
 README.org | 26 +++++++++++++-------------
 jinx.el    | 23 ++++++++++++-----------
 2 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/README.org b/README.org
index 5d709b76f1..87729d62dc 100644
--- a/README.org
+++ b/README.org
@@ -17,12 +17,12 @@ achieve high performance and low resource usage, without 
impacting your editing
 experience. Overall Jinx should just work out of the box without much
 intervention.
 
-Jinx highlights misspellings lazily only in the visible area of the window. 
Jinx
-binds directly to the native libenchant API, such that process communication
-with a backend Aspell process can be avoided. Libenchant is widely used as
-spell-checking API by text editors and supports 
[[https://nuspell.github.io/][Nuspell]], 
[[http://hunspell.github.io/][Hunspell]], [[http://aspell.net/][Aspell]] and a
-few lesser known backends. Jinx automatically compiles and loads the native
-module at startup.
+Jinx highlights misspellings lazily only in the visible part of the text. The
+window boundaries and text folding are taken into account. Jinx binds directly
+to the native libenchant API, such that process communication with a backend
+Aspell process can be avoided. Libenchant is widely used as spell-checking API
+by text editors and supports [[https://nuspell.github.io/][Nuspell]], 
[[http://hunspell.github.io/][Hunspell]], [[http://aspell.net/][Aspell]] and a 
few lesser known
+backends. Jinx automatically compiles and loads the native module at startup.
 
 Jinx supports multiple languages in a buffer at the same time via the
 =jinx-languages= customization variable. It offers flexible settings to ignore
@@ -64,17 +64,17 @@ key =C-u= is pressed, the entire buffer is spell-checked.
 
 - [[https://github.com/astoff/jit-spell][jit-spell]]: Jinx offers a similar UI 
as Augusto Stoffel's jit-spell package and
   borrows ideas from it. Jit-spell uses Ispell process communication instead of
-  a native API. It does not restrict the highlighting to the visible area. In 
my
+  a native API. It does not restrict the highlighting to the visible text. In 
my
   setup I observed an increase in load and latency as a consequence, in
   particular in combination with stealth locking and commands which trigger
   fontification eagerly like =consult-line= from my 
[[https://github.com/minad/consult][Consult]] package.
 
-- [[https://codeberg.org/ideasman42/emacs-spell-fu][spell-fu]]: The technique 
to spell-check only the visible region of the window
-  was inspired by Campbell Barton's spell-fu package. Spell-fu maintains the
-  dictionary itself via a hash table, which results in high memory usage for
-  languages with compound words or inflected word forms. In Jinx we avoid the
-  complexity of managing the dictionary and access the advanced spell-checker
-  algorithms (affixation, compound words, etc.) directly via libenchant.
+- [[https://codeberg.org/ideasman42/emacs-spell-fu][spell-fu]]: The technique 
to spell-check only the visible text was inspired by
+  Campbell Barton's spell-fu package. Spell-fu maintains the dictionary itself
+  via a hash table, which results in high memory usage for languages with
+  compound words or inflected word forms. In Jinx we avoid the complexity of
+  managing the dictionary and access the advanced spell-checker algorithms
+  directly via libenchant (affixation, compound words, etc.).
 
 * Contributions
 
diff --git a/jinx.el b/jinx.el
index 4b79276aa1..340fec9189 100644
--- a/jinx.el
+++ b/jinx.el
@@ -30,8 +30,9 @@
 ;; editing experience.  Overall Jinx should just work out of the box
 ;; without much intervention.
 ;;
-;; Jinx highlights misspellings lazily only in the visible area of the
-;; window.  Jinx binds directly to the native libenchant API, such
+;; Jinx highlights misspellings lazily only in the visible part of the
+;; text.  The window boundaries and text folding are taken into
+;; account.  Jinx binds directly to the native libenchant API, such
 ;; that process communication with a backend Aspell process can be
 ;; avoided.  Libenchant is widely used as spell-checking API by text
 ;; editors and supports Nuspell, Hunspell, Aspell and a few lesser
@@ -67,21 +68,21 @@
 ;;
 ;; (keymap-global-set "<remap> <ispell-word>" #'jinx-correct)
 ;;
-;; The technique to spell-check only the visible region of the window
-;; was inspired by Campbell Barton's spell-fu package.  Spell-fu
-;; maintains the dictionary itself via a hash table, which results in
-;; high memory usage for languages with compound words or inflected
-;; word forms.  In Jinx we avoid the complexity of managing the
-;; dictionary and access the advanced spell-checker algorithms
-;; (affixation, compound words, etc.)  directly via libenchant.
-;;
 ;; Jinx offers a similar UI as Augusto Stoffel's jit-spell package and
 ;; borrows ideas from it.  Jit-spell uses Ispell process communication
 ;; instead of a native API.  It does not restrict the highlighting to
-;; the visible area.  In my setup I observed an increase in load and
+;; the visible text.  In my setup I observed an increase in load and
 ;; latency as a consequence, in particular in combination with stealth
 ;; locking and commands which trigger fontification eagerly like
 ;; `consult-line' from my Consult package.
+;;
+;; The technique to spell-check only the visible text was inspired by
+;; Campbell Barton's spell-fu package.  Spell-fu maintains the
+;; dictionary itself via a hash table, which results in high memory
+;; usage for languages with compound words or inflected word forms.
+;; In Jinx we avoid the complexity of managing the dictionary and
+;; access the advanced spell-checker algorithms directly via
+;; libenchant (affixation, compound words, etc.).
 
 ;;; Code: