diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,43 @@
 *Megaparsec follows [SemVer](https://semver.org/).*
 
+## Megaparsec 9.8.2
+
+* Fixed tab expansion in the rendering of the offending line so that it
+  takes into account the display width of the preceding characters.
+  Previously a tab that followed a wide or zero-width character was expanded
+  to the wrong number of spaces, which made the position marker `^`
+  misaligned or missing.
+* Fixed the regression introduced by the fix for the [issue
+  412](https://github.com/mrkkrp/megaparsec/issues/412) which caused `(<|>)`
+  to report a parse error at the position where the alternation started even
+  when both of its branches had failed ahead of that position (which can
+  happen because of `try`). Such an error mentioned a position that did not
+  correspond to the unexpected item it reported and lost all expected items.
+  In that case the longest match is now preferred again.
+* Fixed `takeP` reporting that it had consumed input when asked to take zero
+  (or a negative number of) tokens. Since it consumes nothing in that case,
+  it now signals that fact, so that e.g. the second branch of `(<|>)` is
+  still tried after it.
+* Fixed column calculation for `ByteString` streams (strict and lazy) so
+  that it agrees with the way the offending line is rendered. Previously the
+  byte `0xad` was counted as one column even though it is displayed as a
+  zero-width soft hyphen, which could shift the position marker `^` or make
+  it disappear altogether.
+* Updated the character width data used by `Text.Megaparsec.Unicode` to
+  Unicode 17.0.0. The previous data was extracted from Unicode 12.0.0 and
+  was moreover incomplete: it did not know about the CJK ideograph
+  extensions G through I, about any of the emoji added since, or about most
+  combining marks, including all of the variation selectors and everything
+  outside of the Latin, Cyrillic, Hebrew, and Arabic scripts. As a result
+  the position marker `^` did not line up with the offending line for input
+  containing such characters.
+* `isWideChar` now returns `False` for the few characters that are Wide
+  according to their East Asian Width but are also combining marks, such as
+  `U+302A`. They occupy no columns of their own, which `charLength` and
+  `isZeroWidthChar` already reported.
+* The position marker `^` is no longer omitted when the offending line turns
+  out to be shorter than the column of the parse error.
+
 ## Megaparsec 9.8.1
 
 * Fixed the regression introduced by the fix for the [issue
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@
     * [Megaparsec vs Parsec](#megaparsec-vs-parsec)
     * [Megaparsec vs Trifecta](#megaparsec-vs-trifecta)
     * [Megaparsec vs Earley](#megaparsec-vs-earley)
+    * [Megaparsec vs Flatparse](#megaparsec-vs-flatparse)
 * [Related packages](#related-packages)
 * [Prominent projects that use Megaparsec](#prominent-projects-that-use-megaparsec)
 * [Links to announcements and blog posts](#links-to-announcements-and-blog-posts)
@@ -27,56 +28,55 @@
 * [License](#license)
 
 This is an industrial-strength monadic parser combinator library. Megaparsec
-is a feature-rich package that tries to find a nice balance between speed,
-flexibility, and quality of parse errors.
+is a feature-rich package that strikes a nice balance between speed,
+flexibility, and the quality of parse errors.
 
 ## Features
 
-The project provides flexible solutions to satisfy common parsing needs. The
-section describes them shortly. If you're looking for comprehensive
+The project provides flexible solutions for common parsing needs. This
+section describes them briefly. If you're looking for comprehensive
 documentation, see the [section about documentation](#documentation).
 
 ### Core features
 
-The package is built around `MonadParsec`, an MTL-style monad transformer.
-Most features work with all instances of `MonadParsec`. One can achieve
-various effects combining monad transformers, i.e. building a monadic stack.
-Since the common monad transformers like `WriterT`, `StateT`, `ReaderT` and
-others are instances of the `MonadParsec` type class, one can also wrap
-`ParsecT` *in* these monads, achieving, for example, backtracking state.
+The package is built around `MonadParsec`, an MTL-style type class. Most
+features work with all instances of `MonadParsec`. You can achieve various
+effects by combining monad transformers, i.e. by building a monadic stack.
+Since the common monad transformers like `WriterT`, `StateT`, and `ReaderT`
+are instances of the `MonadParsec` type class, you can also wrap `ParsecT`
+*in* these monads, achieving, for example, backtracking state.
 
-On the other hand `ParsecT` is an instance of many type classes as well. The
-most useful ones are `Monad`, `Applicative`, `Alternative`, and
-`MonadParsec`.
+`ParsecT` is also an instance of many type classes itself. The most useful
+ones are `Monad`, `Applicative`, `Alternative`, and `MonadParsec`.
 
 Megaparsec includes all functionality that is typically available in
 Parsec-like libraries and also features some special combinators:
 
 * `parseError` allows us to end parsing and report an arbitrary parse error.
-* `withRecovery` can be used to recover from parse errors “on-the-fly” and
-  continue parsing. Once parsing is finished, several parse errors may be
-  reported or ignored altogether.
+* `withRecovery` can be used to recover from parse errors “on the fly” and
+  continue parsing. Once parsing is finished, the collected parse errors may
+  be reported or ignored altogether.
 * `observing` makes it possible to “observe” parse errors without ending
   parsing.
 
-In addition to that, Megaparsec features high-performance combinators
-similar to those found in [Attoparsec][attoparsec]:
+In addition, Megaparsec features high-performance combinators similar to
+those found in [Attoparsec][attoparsec]:
 
 * `tokens` makes it easy to parse several tokens in a row (`string` and
-  `string'` are built on top of this primitive). This is about 100 times
-  faster than matching a string token by token. `tokens` returns “chunk” of
-  original input, meaning that if you parse `Text`, it'll return `Text`
-  without repacking.
-* `takeWhile` and `takeWhile1` are about 150 times faster than approaches
-  involving `many`, `manyTill` and other similar combinators.
-* `takeP` allows us to grab n tokens from the stream and returns them as a
+  `string'` are built on top of this primitive). It is about 100 times
+  faster than matching a string token by token. `tokens` returns a “chunk”
+  of the original input, meaning that if you parse `Text`, it'll return
+  `Text` without repacking.
+* `takeWhileP` and `takeWhile1P` are about 150 times faster than approaches
+  involving `many`, `manyTill`, and other similar combinators.
+* `takeP` allows us to grab `n` tokens from the stream and returns them as a
   “chunk” of the stream.
 
 Megaparsec is about as fast as Attoparsec if you write your parser carefully
 (see also [the section about performance](#performance)).
 
 The library can currently work with the following types of input stream
-out-of-the-box:
+out of the box:
 
 * `String = [Char]`
 * `ByteString` (strict and lazy)
@@ -90,20 +90,19 @@
 * Megaparsec has typed error messages and the ability to signal custom parse
   errors that better suit the user's domain of interest.
 
-* Since version 8, the location of parse errors can independent of current
-  offset in the input stream. It is useful when you want a parse error to
-  point to a particular position after performing some checks.
+* The location of a parse error can be independent of the current offset in
+  the input stream. This is useful when you want a parse error to point to a
+  particular position after performing some checks.
 
-* Instead of a single parse error Megaparsec produces so-called
-  `ParseErrorBundle` data type that helps to manage multi-error messages and
-  pretty-print them. Since version 8, reporting multiple parse errors at
-  once has become easier.
+* Instead of a single parse error, Megaparsec produces a `ParseErrorBundle`
+  data type that helps manage multi-error messages and pretty-print them,
+  making it easy to report multiple parse errors at once.
 
 ### External lexers
 
 Megaparsec works well with streams of tokens produced by tools like Alex.
-The design of the `Stream` type class has been changed significantly in the
-recent versions, but user can still work with custom streams of tokens.
+The design of the `Stream` type class has changed significantly in recent
+versions, but you can still work with custom streams of tokens.
 
 ### Character and binary parsing
 
@@ -119,13 +118,13 @@
 “fixes” its particularly inflexible `Text.Parsec.Token`.
 
 [`Text.Megaparsec.Char.Lexer`][tm-char-lexer] is intended to be imported
-using a qualified import, it's not included in [`Text.Megaparsec`][tm]. The
-module doesn't impose how you should write your parser, but certain
-approaches may be more elegant than others. An especially important theme is
-parsing of white space, comments, and indentation.
+qualified, and it's not included in [`Text.Megaparsec`][tm]. The module
+doesn't impose how you should write your parser, but certain approaches may
+be more elegant than others. An especially important theme is the parsing of
+white space, comments, and indentation.
 
-The design of the module allows one quickly solve simple tasks and doesn't
-get in the way when the need to implement something less standard arises.
+The design of the module lets you solve simple tasks quickly and doesn't get
+in the way when you need to implement something less standard.
 
 [`Text.Megaparsec.Byte.Lexer`][tm-byte-lexer] is also available for users
 who wish to parse binary data.
@@ -138,8 +137,7 @@
 ## Tutorials
 
 You can find the most complete Megaparsec tutorial [here][the-tutorial]. It
-should provide sufficient guidance to help you start with your parsing
-tasks.
+should provide enough guidance to get you started with your parsing tasks.
 
 ## Performance
 
@@ -170,38 +168,37 @@
 
 ## Comparison with other solutions
 
-There are quite a few libraries that can be used for parsing in Haskell,
-let's compare Megaparsec with some of them.
+There are quite a few libraries that can be used for parsing in Haskell.
+Let's compare Megaparsec with some of them.
 
 ### Megaparsec vs Attoparsec
 
 [Attoparsec][attoparsec] is another prominent Haskell library for parsing.
 Although both libraries deal with parsing, it's usually easy to decide which
-you will need in particular project:
+one you need for a particular project:
 
-* *Attoparsec* is sometimes faster but not that feature-rich. It should be
-  used when you want to process large amounts of data where performance
-  matters more than quality of error messages.
+* *Attoparsec* is sometimes faster but not as feature-rich. It should be used
+  when you want to process large amounts of data and performance matters more
+  than the quality of error messages.
 
-* *Megaparsec* is good for parsing of source code or other human-readable
-  texts. It has better error messages and it's implemented as a monad
-  transformer.
+* *Megaparsec* is good for parsing source code or other human-readable text.
+  It has better error messages and is implemented as a monad transformer.
 
-So, if you work with something human-readable where the size of input data
-is moderate, it makes sense to go with Megaparsec, otherwise Attoparsec may
-be a better choice.
+In short, if you work with something human-readable where the size of the
+input data is moderate, it makes sense to go with Megaparsec; otherwise
+Attoparsec may be a better choice.
 
 ### Megaparsec vs Parsec
 
 Since Megaparsec is a fork of [Parsec][parsec], we are bound to list the
 main differences between the two libraries:
 
-* Better error messages. Megaparsec has typed error messages and custom
-  error messages, it can also report multiple parse errors at once.
+* Better error messages. Megaparsec has typed and custom error messages, and
+  it can also report multiple parse errors at once.
 
-* Megaparsec can show the line on which parse error happened as part of
-  parse error. This makes it a lot easier to figure out where the error
-  happened.
+* Megaparsec can include the line on which a parse error happened as part of
+  the parse error. This makes it a lot easier to figure out where the error
+  occurred.
 
 * Some quirks and bugs of Parsec are fixed.
 
@@ -215,17 +212,16 @@
 * Megaparsec can recover from parse errors “on the fly” and continue
   parsing.
 
-* Megaparsec allows us to conditionally process parse errors inside a
-  running parser. In particular, it's possible to define regions in which
-  parse errors, should they happen, will get a “context tag”, e.g. we could
-  build a context stack like “in function definition foo”, “in expression
-  x”, etc.
+* Megaparsec allows us to conditionally process parse errors inside a running
+  parser. In particular, it's possible to define regions in which parse
+  errors, should they happen, get a “context tag”. This lets us build a
+  context stack like “in function definition foo”, “in expression x”, etc.
 
-* Megaparsec is faster and supports efficient operations `tokens`,
-  `takeWhileP`, `takeWhile1P`, `takeP`, like Attoparsec.
+* Like Attoparsec, Megaparsec is faster and supports the efficient operations
+  `tokens`, `takeWhileP`, `takeWhile1P`, and `takeP`.
 
-If you want to see a detailed change log, `CHANGELOG.md` may be helpful.
-Also see [this original announcement][original-announcement] for another
+If you want to see a detailed change log, `CHANGELOG.md` may be helpful. Also
+see [this original announcement][original-announcement] for another
 comparison.
 
 ### Megaparsec vs Trifecta
@@ -234,43 +230,67 @@
 messages. These are the common reasons why Trifecta may be problematic to
 use:
 
-* Complicated, doesn't have any tutorials available, and documentation
+* It is complicated, has no tutorials available, and its documentation
   doesn't help much.
 
 * Trifecta can parse `String` and `ByteString` natively, but not `Text`.
 
-* Depends on `lens`, which is a very heavy dependency. If you're not into
+* It depends on `lens`, which is a very heavy dependency. If you're not into
   `lens`, you may not like the API.
 
-[Idris][idris] has switched from Trifecta to Megaparsec which allowed it to
+[Idris][idris] switched from Trifecta to Megaparsec, which allowed it to
 [have better error messages and fewer dependencies][idris-testimony].
 
 ### Megaparsec vs Earley
 
 [Earley][earley] is a newer library that allows us to safely parse
-context-free grammars (CFG). Megaparsec is a lower-level library compared to
+context-free grammars (CFGs). Megaparsec is a lower-level library compared to
 Earley, but there are still enough reasons to choose it:
 
 * Megaparsec is faster.
 
-* Your grammar may be not context-free or you may want introduce some sort
-  of state to the parsing process. Almost all non-trivial parsers require
-  state. Even if your grammar is context-free, state may allow for
+* Your grammar may not be context-free, or you may want to introduce some
+  sort of state into the parsing process. Almost all non-trivial parsers
+  require state. Even if your grammar is context-free, state may allow for
   additional niceties. Earley does not support that.
 
-* Megaparsec's error messages are more flexible allowing to include
+* Megaparsec's error messages are more flexible, allowing you to include
   arbitrary data in them, return multiple error messages, mark regions that
-  affect any error that happens in those regions, etc.
+  affect any error that happens within them, etc.
 
 In other words, Megaparsec is less safe but also more powerful.
 
+### Megaparsec vs Flatparse
+
+[Flatparse][flatparse] is a newer library that focuses squarely on raw
+parsing speed. On microbenchmarks it can be several times faster than both
+Megaparsec and Attoparsec, and it produces considerably smaller object code.
+It achieves this by making a number of trade-offs:
+
+* Flatparse works only with strict `ByteString`. It does not support `Text`,
+  `String`, lazy input, or incremental parsing, whereas Megaparsec works with
+  all of these and with custom token streams via the `Stream` type class.
+
+* Flatparse provides only a low-level interface to error handling and source
+  positions. Megaparsec has typed, custom, and multi-error messages out of
+  the box, along with error recovery and context-tagged regions.
+
+* Flatparse distinguishes recoverable failures from unrecoverable errors and
+  leaves grammar and error propagation largely up to you, so it sits at a
+  lower level of abstraction than Megaparsec.
+
+In short, if you need the absolute best performance and are willing to work
+at a lower level with `ByteString` only, Flatparse is worth a look.
+Megaparsec is the better choice when you value error messages, flexibility,
+and support for a variety of input streams.
+
 ## Related packages
 
 The following packages are designed to be used with Megaparsec (open a PR if
 you want to add something to the list):
 
 * [`hspec-megaparsec`](https://hackage.haskell.org/package/hspec-megaparsec)—utilities
-  for testing Megaparsec parsers with with
+  for testing Megaparsec parsers with
   [Hspec](https://hackage.haskell.org/package/hspec).
 * [`replace-megaparsec`](https://hackage.haskell.org/package/replace-megaparsec)—Stream
   editing and find-and-replace with Megaparsec.
@@ -283,13 +303,22 @@
   Megaparsec.
 * [`parser-combinators`](https://hackage.haskell.org/package/parser-combinators)—provides permutation and expression parsers [previously bundled with Megaparsec](https://markkarpov.com/post/megaparsec-7.html#parsercombinators-grows-megaparsec-shrinks).
 * [`faster-megaparsec`](https://hackage.haskell.org/package/faster-megaparsec)—speeds up parsing
-  by trying a simple `MonadParsec` instance and falls back to `ParsecT` to report errors.
+  by trying a simple `MonadParsec` instance and falling back to `ParsecT` to report errors.
+* [`parsers-megaparsec`](https://hackage.haskell.org/package/parsers-megaparsec)—provides
+  instances of the [`parsers`](https://hackage.haskell.org/package/parsers)
+  type classes (`Parsing`, `CharParsing`, `LookAheadParsing`, and
+  `TokenParsing`) for Megaparsec.
+* [`headed-megaparsec`](https://hackage.haskell.org/package/headed-megaparsec)—helps
+  produce more informative parsers by distinguishing a parser's “head” from
+  its “body”.
+* [`htoml-megaparsec`](https://hackage.haskell.org/package/htoml-megaparsec)—a
+  parser for [TOML](https://toml.io) files built with Megaparsec.
 
 ## Prominent projects that use Megaparsec
 
 Some prominent projects that use Megaparsec:
 
-* [Idris](https://github.com/idris-lang/Idris-dev)—a general-purpose
+* [Idris](https://github.com/idris-lang/Idris2)—a general-purpose
   functional programming language with dependent types
 * [Dhall](https://github.com/dhall-lang/dhall-haskell)—an advanced
   configuration language
@@ -301,8 +330,8 @@
 
 ## Links to announcements and blog posts
 
-Here are some blog posts mainly announcing new features of the project and
-describing what sort of things are now possible:
+Here are some blog posts, mainly announcing new features of the project and
+describing what sort of things they make possible:
 
 * [Megaparsec 8](https://markkarpov.com/post/megaparsec-8.html)
 * [Megaparsec 7](https://markkarpov.com/post/megaparsec-7.html)
@@ -315,8 +344,8 @@
 
 ## Contribution
 
-Issues (bugs, feature requests or otherwise feedback) may be reported in
-[the GitHub issue tracker for this
+Issues (bugs, feature requests, or other feedback) may be reported in [the
+GitHub issue tracker for this
 project](https://github.com/mrkkrp/megaparsec/issues).
 
 Pull requests are also welcome. If you would like to contribute to the
@@ -344,9 +373,8 @@
 [parsec]: https://hackage.haskell.org/package/parsec
 [trifecta]: https://hackage.haskell.org/package/trifecta
 [earley]: https://hackage.haskell.org/package/Earley
+[flatparse]: https://hackage.haskell.org/package/flatparse
 [idris]: https://www.idris-lang.org/
-[idris-testimony]: https://twitter.com/edwinbrady/status/950084043282010117?s=09
+[idris-testimony]: https://x.com/edwinbrady/status/950084043282010117
 
-[parsers-bench]: https://github.com/mrkkrp/parsers-bench
-[fast-parser]: https://markkarpov.com/megaparsec/writing-a-fast-parser.html
 [original-announcement]: https://mail.haskell.org/pipermail/haskell-cafe/2015-September/121530.html
diff --git a/Text/Megaparsec.hs b/Text/Megaparsec.hs
--- a/Text/Megaparsec.hs
+++ b/Text/Megaparsec.hs
@@ -23,8 +23,8 @@
 -- at the tutorial <https://markkarpov.com/tutorial/megaparsec.html>.
 --
 -- In addition to the "Text.Megaparsec" module, which exports and re-exports
--- almost everything that you may need, we advise to import
--- "Text.Megaparsec.Char" if you plan to work with a stream of 'Char' tokens
+-- almost everything that you may need, we advise importing
+-- "Text.Megaparsec.Char" if you plan to work with a stream of 'Char' tokens,
 -- or "Text.Megaparsec.Byte" if you intend to parse binary data.
 --
 -- It is common to start working with the library by defining a type synonym
@@ -36,9 +36,9 @@
 -- > Custom error component    Input stream type
 --
 -- Then you can write type signatures like @Parser 'Int'@—for a parser that
--- returns an 'Int' for example.
+-- returns an 'Int', for example.
 --
--- Similarly (since it's known to cause confusion), you should use
+-- Similarly (since it's known to cause confusion), you should use the
 -- 'ParseErrorBundle' type parametrized like this:
 --
 -- > ParseErrorBundle Text Void
@@ -47,7 +47,7 @@
 -- >  Input stream type    Custom error component (the same you used in Parser)
 --
 -- Megaparsec uses some type-level machinery to provide flexibility without
--- compromising on type safety. Thus type signatures are sometimes necessary
+-- compromising on type safety. Thus, type signatures are sometimes necessary
 -- to avoid ambiguous types. If you're seeing an error message that reads
 -- like “Type variable @e0@ is ambiguous …”, you need to give an explicit
 -- signature to your parser to resolve the ambiguity. It's a good idea to
@@ -131,7 +131,7 @@
 -- Note that we re-export monadic combinators from
 -- "Control.Monad.Combinators" because these are more efficient than
 -- 'Applicative'-based ones (†). Thus 'many' and 'some' may clash with the
--- functions from "Control.Applicative". You need to hide the functions like
+-- functions from "Control.Applicative". You need to hide those functions like
 -- this:
 --
 -- > import Control.Applicative hiding (many, some)
@@ -152,7 +152,7 @@
 -- Other modules of interest are:
 --
 --     * "Control.Monad.Combinators.Expr" for parsing of expressions.
---     * "Control.Applicative.Permutations" for parsing of permutations
+--     * "Control.Applicative.Permutations" for parsing of permutation
 --       phrases.
 
 ----------------------------------------------------------------------------
@@ -196,8 +196,8 @@
 -- will fail.
 --
 -- The function is supposed to be useful for lightweight parsing, where
--- error messages (and thus file names) are not important and entire input
--- should be consumed. For example, it can be used for parsing of a single
+-- error messages (and thus file names) are not important and the entire
+-- input should be consumed. For example, it can be used for parsing a single
 -- number according to a specification of its format.
 parseMaybe :: (Ord e, Stream s) => Parsec e s a -> s -> Maybe a
 parseMaybe p s =
@@ -241,8 +241,8 @@
   Either (ParseErrorBundle s e) a
 runParser p name s = snd $ runParser' p (initialState name s)
 
--- | The function is similar to 'runParser' with the difference that it
--- accepts and returns the parser state. This allows us e.g. to specify
+-- | The function is similar to 'runParser', with the difference that it
+-- accepts and returns the parser state. This allows us, e.g., to specify an
 -- arbitrary textual position at the beginning of parsing. This is the most
 -- general way to run a parser over the 'Identity' monad.
 --
@@ -304,10 +304,10 @@
 
 -- $parse-errors
 --
--- The most general function to fail and end parsing is 'parseError'. These
--- are built on top of it. The section also includes functions starting with
--- the @register@ prefix which allow users to register “delayed”
--- 'ParseError's.
+-- The most general function to fail and end parsing is 'parseError'. The
+-- others are built on top of it. This section also includes functions
+-- starting with the @register@ prefix, which allow users to register
+-- “delayed” 'ParseError's.
 
 -- | Stop parsing and report a trivial 'ParseError'.
 --
@@ -338,8 +338,8 @@
   parseError (FancyError o xs)
 {-# INLINE fancyFailure #-}
 
--- | The parser @'unexpected' item@ fails with an error message telling
--- about unexpected item @item@ without consuming any input.
+-- | The parser @'unexpected' item@ fails with an error message telling the
+-- user about the unexpected item @item@ without consuming any input.
 --
 -- > unexpected item = failure (Just item) Set.empty
 unexpected :: (MonadParsec e s m) => ErrorItem (Token s) -> m a
@@ -359,8 +359,8 @@
 -- | Specify how to process 'ParseError's that happen inside of this
 -- wrapper. This applies to both normal and delayed 'ParseError's.
 --
--- As a side-effect of the implementation the inner computation will start
--- with an empty collection of delayed errors and they will be updated and
+-- As a side effect of the implementation, the inner computation will start
+-- with an empty collection of delayed errors, and they will be updated and
 -- “restored” on the way out of 'region'.
 --
 -- @since 5.3.0
@@ -568,10 +568,10 @@
 (<?>) = flip label
 {-# INLINE (<?>) #-}
 
--- | Return both the result of a parse and a chunk of input that was
+-- | Return both the result of a parse and the chunk of input that was
 -- consumed during parsing. This relies on the change of the 'stateOffset'
 -- value to evaluate how many tokens were consumed. If you mess with it
--- manually in the argument parser, prepare for troubles.
+-- manually in the argument parser, prepare for trouble.
 --
 -- @since 5.3.0
 match :: (MonadParsec e s m) => m a -> m (Tokens s, a)
@@ -620,9 +620,9 @@
 setInput s = updateParserState (\(State _ o pst de) -> State s o pst de)
 {-# INLINE setInput #-}
 
--- | Return the current source position. This function /is not cheap/, do
--- not call it e.g. on matching of every token, that's a bad idea. Still you
--- can use it to get 'SourcePos' to attach to things that you parse.
+-- | Return the current source position. This function /is not cheap/, so do
+-- not call it, e.g., on matching of every token—that's a bad idea. Still,
+-- you can use it to get a 'SourcePos' to attach to things that you parse.
 --
 -- The function works under the assumption that we move in the input stream
 -- only forwards and never backwards, which is always true unless the user
diff --git a/Text/Megaparsec/Byte.hs b/Text/Megaparsec/Byte.hs
--- a/Text/Megaparsec/Byte.hs
+++ b/Text/Megaparsec/Byte.hs
@@ -143,18 +143,18 @@
 letterChar = satisfy (isLetter . toChar) <?> "letter"
 {-# INLINE letterChar #-}
 
--- | Parse an alphabetic or digit characters.
+-- | Parse an alphabetic or digit character.
 alphaNumChar :: (MonadParsec e s m, Token s ~ Word8) => m (Token s)
 alphaNumChar = satisfy (isAlphaNum . toChar) <?> "alphanumeric character"
 {-# INLINE alphaNumChar #-}
 
--- | Parse a printable character: letter, number, mark, punctuation, symbol
+-- | Parse a printable character: letter, number, mark, punctuation, symbol,
 -- or space.
 printChar :: (MonadParsec e s m, Token s ~ Word8) => m (Token s)
 printChar = satisfy (isPrint . toChar) <?> "printable character"
 {-# INLINE printChar #-}
 
--- | Parse an ASCII digit, i.e between “0” and “9”.
+-- | Parse an ASCII digit, i.e. between “0” and “9”.
 digitChar :: (MonadParsec e s m, Token s ~ Word8) => m (Token s)
 digitChar = satisfy isDigit' <?> "digit"
   where
diff --git a/Text/Megaparsec/Byte/Binary.hs b/Text/Megaparsec/Byte/Binary.hs
--- a/Text/Megaparsec/Byte/Binary.hs
+++ b/Text/Megaparsec/Byte/Binary.hs
@@ -50,7 +50,7 @@
 import Data.Word
 import Text.Megaparsec
 
--- | Data types that can be converted to little- or big- endian numbers.
+-- | Data types that can be converted to little- or big-endian numbers.
 class BinaryChunk chunk where
   convertChunkBE :: (Bits a, Num a) => chunk -> a
   convertChunkLE :: (Bits a, Num a) => chunk -> a
@@ -132,18 +132,18 @@
 
 -- | Parse a little-endian 'Word64'.
 word64le :: (MonadParsec e s m, BinaryChunk (Tokens s)) => m Word64
-word64le = anyLE (Just "little-endian 64 word")
+word64le = anyLE (Just "little-endian 64 bit word")
 {-# INLINE word64le #-}
 
 -- | Parse a big-endian 'Word64'.
 word64be :: (MonadParsec e s m, BinaryChunk (Tokens s)) => m Word64
-word64be = anyBE (Just "big-endian 64 word")
+word64be = anyBE (Just "big-endian 64 bit word")
 {-# INLINE word64be #-}
 
 ----------------------------------------------------------------------------
 -- Parsing signed values
 
--- | Parse a 'Int8'.
+-- | Parse an 'Int8'.
 int8 :: (MonadParsec e s m, BinaryChunk (Tokens s)) => m Int8
 int8 = anyBE (Just "8 bit int")
 {-# INLINE int8 #-}
@@ -170,12 +170,12 @@
 
 -- | Parse a little-endian 'Int64'.
 int64le :: (MonadParsec e s m, BinaryChunk (Tokens s)) => m Int64
-int64le = anyLE (Just "little-endian 64 int")
+int64le = anyLE (Just "little-endian 64 bit int")
 {-# INLINE int64le #-}
 
 -- | Parse a big-endian 'Int64'.
 int64be :: (MonadParsec e s m, BinaryChunk (Tokens s)) => m Int64
-int64be = anyBE (Just "big-endian 64 int")
+int64be = anyBE (Just "big-endian 64 bit int")
 {-# INLINE int64be #-}
 
 --------------------------------------------------------------------------------
diff --git a/Text/Megaparsec/Byte/Lexer.hs b/Text/Megaparsec/Byte/Lexer.hs
--- a/Text/Megaparsec/Byte/Lexer.hs
+++ b/Text/Megaparsec/Byte/Lexer.hs
@@ -53,10 +53,10 @@
 ----------------------------------------------------------------------------
 -- White space
 
--- | Given a comment prefix this function returns a parser that skips line
+-- | Given a comment prefix, this function returns a parser that skips line
 -- comments. Note that it stops just before the newline character but
--- doesn't consume the newline. Newline is either supposed to be consumed by
--- 'space' parser or picked up manually.
+-- doesn't consume the newline. The newline is supposed to be either consumed
+-- by the 'space' parser or picked up manually.
 skipLineComment ::
   (MonadParsec e s m, Token s ~ Word8) =>
   -- | Line comment prefix
@@ -66,7 +66,7 @@
   B.string prefix *> void (takeWhileP (Just "character") (/= 10))
 {-# INLINEABLE skipLineComment #-}
 
--- | @'skipBlockComment' start end@ skips non-nested block comment starting
+-- | @'skipBlockComment' start end@ skips a non-nested block comment starting
 -- with @start@ and ending with @end@.
 skipBlockComment ::
   (MonadParsec e s m) =>
@@ -81,7 +81,7 @@
     n = B.string end
 {-# INLINEABLE skipBlockComment #-}
 
--- | @'skipBlockCommentNested' start end@ skips possibly nested block
+-- | @'skipBlockCommentNested' start end@ skips a possibly nested block
 -- comment starting with @start@ and ending with @end@.
 --
 -- @since 5.0.0
@@ -129,7 +129,7 @@
 -- | Parse an integer in the binary representation. The binary number is
 -- expected to be a non-empty sequence of zeroes “0” and ones “1”.
 --
--- You could of course parse some prefix before the actual number:
+-- You could, of course, parse some prefix before the actual number:
 --
 -- > binary = char 48 >> char' 98 >> L.binary
 --
@@ -151,12 +151,12 @@
 {-# INLINEABLE binary #-}
 
 -- | Parse an integer in the octal representation. The format of the octal
--- number is expected to be according to the Haskell report except for the
--- fact that this parser doesn't parse “0o” or “0O” prefix. It is a
--- responsibility of the programmer to parse correct prefix before parsing
--- the number itself.
+-- number is expected to be according to the Haskell report, except for the
+-- fact that this parser doesn't parse the “0o” or “0O” prefix. It is the
+-- responsibility of the programmer to parse the correct prefix before
+-- parsing the number itself.
 --
--- For example you can make it conform to the Haskell report like this:
+-- For example, you can make it conform to the Haskell report like this:
 --
 -- > octal = char 48 >> char' 111 >> L.octal
 --
@@ -176,12 +176,12 @@
 {-# INLINEABLE octal #-}
 
 -- | Parse an integer in the hexadecimal representation. The format of the
--- hexadecimal number is expected to be according to the Haskell report
--- except for the fact that this parser doesn't parse “0x” or “0X” prefix.
--- It is a responsibility of the programmer to parse correct prefix before
--- parsing the number itself.
+-- hexadecimal number is expected to be according to the Haskell report,
+-- except for the fact that this parser doesn't parse the “0x” or “0X”
+-- prefix. It is the responsibility of the programmer to parse the correct
+-- prefix before parsing the number itself.
 --
--- For example you can make it conform to the Haskell report like this:
+-- For example, you can make it conform to the Haskell report like this:
 --
 -- > hexadecimal = char 48 >> char' 120 >> L.hexadecimal
 --
@@ -207,14 +207,14 @@
 {-# INLINEABLE hexadecimal #-}
 
 -- | Parse a floating point value as a 'Scientific' number. 'Scientific' is
--- great for parsing of arbitrary precision numbers coming from an untrusted
--- source. See documentation in "Data.Scientific" for more information.
+-- great for parsing arbitrary-precision numbers coming from an untrusted
+-- source. See the documentation in "Data.Scientific" for more information.
 --
 -- The parser can be used to parse integers or floating point values. Use
 -- functions like 'Data.Scientific.floatingOrInteger' from "Data.Scientific"
 -- to test and extract integer or real values.
 --
--- This function does not parse sign, if you need to parse signed numbers,
+-- This function does not parse a sign; if you need to parse signed numbers,
 -- see 'signed'.
 scientific ::
   forall e s m.
@@ -232,7 +232,7 @@
 -- | Parse a floating point number according to the syntax for floating
 -- point literals described in the Haskell report.
 --
--- This function does not parse sign, if you need to parse signed numbers,
+-- This function does not parse a sign; if you need to parse signed numbers,
 -- see 'signed'.
 --
 -- __Note__: in versions /6.0.0/–/6.1.1/ this function accepted plain integers.
@@ -273,13 +273,13 @@
   (+ e') <$> signed (return ()) decimal_
 {-# INLINE exponent_ #-}
 
--- | @'signed' space p@ parser parses an optional sign character (“+” or
--- “-”), then if there is a sign it consumes optional white space (using
--- @space@ parser), then it runs parser @p@ which should return a number.
--- Sign of the number is changed according to the previously parsed sign
+-- | @'signed' space p@ parses an optional sign character (“+” or “-”), then,
+-- if there is a sign, it consumes optional white space (using the @space@
+-- parser), then it runs the parser @p@, which should return a number. The
+-- sign of the number is changed according to the previously parsed sign
 -- character.
 --
--- For example, to parse signed integer you can write:
+-- For example, to parse a signed integer you can write:
 --
 -- > lexeme        = L.lexeme spaceConsumer
 -- > integer       = lexeme L.decimal
diff --git a/Text/Megaparsec/Char.hs b/Text/Megaparsec/Char.hs
--- a/Text/Megaparsec/Char.hs
+++ b/Text/Megaparsec/Char.hs
@@ -158,7 +158,7 @@
 letterChar = satisfy isLetter <?> "letter"
 {-# INLINE letterChar #-}
 
--- | Parse an alphabetic or numeric digit Unicode characters.
+-- | Parse an alphabetic or numeric digit Unicode character.
 --
 -- Note that the numeric digits outside the ASCII range are parsed by this
 -- parser but not by 'digitChar'. Such digits may be part of identifiers but
@@ -168,12 +168,12 @@
 {-# INLINE alphaNumChar #-}
 
 -- | Parse a printable Unicode character: letter, number, mark, punctuation,
--- symbol or space.
+-- symbol, or space.
 printChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)
 printChar = satisfy isPrint <?> "printable character"
 {-# INLINE printChar #-}
 
--- | Parse an ASCII digit, i.e between “0” and “9”.
+-- | Parse an ASCII digit, i.e. between “0” and “9”.
 digitChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)
 digitChar = satisfy isDigit <?> "digit"
 {-# INLINE digitChar #-}
@@ -211,18 +211,18 @@
 {-# INLINE numberChar #-}
 
 -- | Parse a Unicode punctuation character, including various kinds of
--- connectors, brackets and quotes.
+-- connectors, brackets, and quotes.
 punctuationChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)
 punctuationChar = satisfy isPunctuation <?> "punctuation"
 {-# INLINE punctuationChar #-}
 
--- | Parse a Unicode symbol characters, including mathematical and currency
+-- | Parse a Unicode symbol character, including mathematical and currency
 -- symbols.
 symbolChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)
 symbolChar = satisfy isSymbol <?> "symbol"
 {-# INLINE symbolChar #-}
 
--- | Parse a Unicode space and separator characters.
+-- | Parse a Unicode space or separator character.
 separatorChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)
 separatorChar = satisfy isSeparator <?> "separator"
 {-# INLINE separatorChar #-}
@@ -239,8 +239,8 @@
 latin1Char = satisfy isLatin1 <?> "Latin-1 character"
 {-# INLINE latin1Char #-}
 
--- | @'charCategory' cat@ parses character in Unicode General Category
--- @cat@, see 'Data.Char.GeneralCategory'.
+-- | @'charCategory' cat@ parses a character in the Unicode General Category
+-- @cat@; see 'Data.Char.GeneralCategory'.
 charCategory ::
   (MonadParsec e s m, Token s ~ Char) =>
   GeneralCategory ->
@@ -248,7 +248,7 @@
 charCategory cat = satisfy ((== cat) . generalCategory) <?> categoryName cat
 {-# INLINE charCategory #-}
 
--- | Return the human-readable name of Unicode General Category.
+-- | Return the human-readable name of a Unicode General Category.
 categoryName :: GeneralCategory -> String
 categoryName = \case
   UppercaseLetter -> "uppercase letter"
diff --git a/Text/Megaparsec/Char/Lexer.hs b/Text/Megaparsec/Char/Lexer.hs
--- a/Text/Megaparsec/Char/Lexer.hs
+++ b/Text/Megaparsec/Char/Lexer.hs
@@ -83,10 +83,10 @@
 ----------------------------------------------------------------------------
 -- White space
 
--- | Given a comment prefix this function returns a parser that skips line
+-- | Given a comment prefix, this function returns a parser that skips line
 -- comments. Note that it stops just before the newline character but
--- doesn't consume the newline. Newline is either supposed to be consumed by
--- 'space' parser or picked up manually.
+-- doesn't consume the newline. The newline is supposed to be either consumed
+-- by the 'space' parser or picked up manually.
 skipLineComment ::
   (MonadParsec e s m, Token s ~ Char) =>
   -- | Line comment prefix
@@ -96,7 +96,7 @@
   C.string prefix *> void (takeWhileP (Just "character") (/= '\n'))
 {-# INLINEABLE skipLineComment #-}
 
--- | @'skipBlockComment' start end@ skips non-nested block comment starting
+-- | @'skipBlockComment' start end@ skips a non-nested block comment starting
 -- with @start@ and ending with @end@.
 skipBlockComment ::
   (MonadParsec e s m) =>
@@ -111,7 +111,7 @@
     n = C.string end
 {-# INLINEABLE skipBlockComment #-}
 
--- | @'skipBlockCommentNested' start end@ skips possibly nested block
+-- | @'skipBlockCommentNested' start end@ skips a possibly nested block
 -- comment starting with @start@ and ending with @end@.
 --
 -- @since 5.0.0
@@ -143,8 +143,8 @@
 indentLevel = sourceColumn <$> getSourcePos
 {-# INLINE indentLevel #-}
 
--- | Fail reporting incorrect indentation error. The error has attached
--- information:
+-- | Fail, reporting an incorrect indentation error. The error has the
+-- following attached information:
 --
 --     * Desired ordering between reference level and actual level
 --     * Reference indentation level
@@ -166,15 +166,16 @@
 {-# INLINEABLE incorrectIndent #-}
 
 -- | @'indentGuard' spaceConsumer ord ref@ first consumes all white space
--- (indentation) with @spaceConsumer@ parser, then it checks the column
--- position. Ordering between current indentation level and the reference
--- indentation level @ref@ should be @ord@, otherwise the parser fails. On
--- success the current column position is returned.
+-- (indentation) with the @spaceConsumer@ parser, then it checks the column
+-- position. The ordering between the current indentation level and the
+-- reference indentation level @ref@ should be @ord@, otherwise the parser
+-- fails. On success the current column position is returned.
 --
 -- When you want to parse a block of indentation, first run this parser with
 -- arguments like @'indentGuard' spaceConsumer 'GT' 'pos1'@—this will make
--- sure you have some indentation. Use returned value to check indentation
--- on every subsequent line according to syntax of your language.
+-- sure you have some indentation. Use the returned value to check
+-- indentation on every subsequent line according to the syntax of your
+-- language.
 indentGuard ::
   (TraversableStream s, MonadParsec e s m) =>
   -- | How to consume indentation (white space)
@@ -194,7 +195,7 @@
 {-# INLINEABLE indentGuard #-}
 
 -- | Parse a non-indented construction. This ensures that there is no
--- indentation before actual data. Useful, for example, as a wrapper for
+-- indentation before the actual data. Useful, for example, as a wrapper for
 -- top-level function definitions.
 --
 -- @since 4.3.0
@@ -208,8 +209,7 @@
 nonIndented sc p = indentGuard sc EQ pos1 *> p
 {-# INLINEABLE nonIndented #-}
 
--- | Behaviors for parsing of indented tokens. This is used in
--- 'indentBlock', which see.
+-- | Behaviors for parsing of indented tokens. This is used in 'indentBlock'.
 --
 -- @since 4.3.0
 data IndentOpt m a b
@@ -226,7 +226,7 @@
 
 -- | Parse a “reference” token and a number of other tokens that have a
 -- greater (but the same for all of them) level of indentation than that of
--- the “reference” token. The reference token can influence parsing, see
+-- the “reference” token. The reference token can influence parsing; see
 -- 'IndentOpt' for more information.
 --
 -- __Note__: the first argument of this function /must/ consume newlines
@@ -265,7 +265,7 @@
       f (x : xs)
 {-# INLINEABLE indentBlock #-}
 
--- | Grab indented items. This is a helper for 'indentBlock', it's not a
+-- | Grab indented items. This is a helper for 'indentBlock'; it's not a
 -- part of the public API.
 indentedItems ::
   (TraversableStream s, MonadParsec e s m) =>
@@ -293,10 +293,10 @@
             | otherwise -> incorrectIndent EQ lvl pos
 
 -- | Create a parser that supports line-folding. The first argument is used
--- to consume white space between components of line fold, thus it /must/
+-- to consume white space between components of a line fold, thus it /must/
 -- consume newlines in order to work properly. The second argument is a
 -- callback that receives a custom space-consuming parser as an argument.
--- This parser should be used after separate components of line fold that
+-- This parser should be used after separate components of the line fold that
 -- can be put on different lines.
 --
 -- An example should clarify the usage pattern:
@@ -357,8 +357,8 @@
 --
 -- If you need to parse signed integers, see the 'signed' combinator.
 --
--- __Note__: before the version /6.0.0/ the function returned 'Integer',
--- i.e. it wasn't polymorphic in its return type.
+-- __Note__: before version /6.0.0/ the function returned 'Integer', i.e. it
+-- wasn't polymorphic in its return type.
 --
 -- __Warning__: this function does not perform range checks.
 decimal :: (MonadParsec e s m, Token s ~ Char, Num a) => m a
@@ -379,7 +379,7 @@
 -- | Parse an integer in binary representation. The binary number is
 -- expected to be a non-empty sequence of zeroes “0” and ones “1”.
 --
--- You could of course parse some prefix before the actual number:
+-- You could, of course, parse some prefix before the actual number:
 --
 -- > binary = char '0' >> char' 'b' >> L.binary
 --
@@ -401,12 +401,12 @@
 {-# INLINEABLE binary #-}
 
 -- | Parse an integer in the octal representation. The format of the octal
--- number is expected to be according to the Haskell report except for the
--- fact that this parser doesn't parse “0o” or “0O” prefix. It is a
--- responsibility of the programmer to parse correct prefix before parsing
--- the number itself.
+-- number is expected to be according to the Haskell report, except for the
+-- fact that this parser doesn't parse the “0o” or “0O” prefix. It is the
+-- responsibility of the programmer to parse the correct prefix before
+-- parsing the number itself.
 --
--- For example you can make it conform to the Haskell report like this:
+-- For example, you can make it conform to the Haskell report like this:
 --
 -- > octal = char '0' >> char' 'o' >> L.octal
 --
@@ -428,12 +428,12 @@
 {-# INLINEABLE octal #-}
 
 -- | Parse an integer in the hexadecimal representation. The format of the
--- hexadecimal number is expected to be according to the Haskell report
--- except for the fact that this parser doesn't parse “0x” or “0X” prefix.
--- It is a responsibility of the programmer to parse correct prefix before
--- parsing the number itself.
+-- hexadecimal number is expected to be according to the Haskell report,
+-- except for the fact that this parser doesn't parse the “0x” or “0X”
+-- prefix. It is the responsibility of the programmer to parse the correct
+-- prefix before parsing the number itself.
 --
--- For example you can make it conform to the Haskell report like this:
+-- For example, you can make it conform to the Haskell report like this:
 --
 -- > hexadecimal = char '0' >> char' 'x' >> L.hexadecimal
 --
@@ -455,14 +455,14 @@
 {-# INLINEABLE hexadecimal #-}
 
 -- | Parse a floating point value as a 'Scientific' number. 'Scientific' is
--- great for parsing of arbitrary precision numbers coming from an untrusted
--- source. See documentation in "Data.Scientific" for more information.
+-- great for parsing arbitrary-precision numbers coming from an untrusted
+-- source. See the documentation in "Data.Scientific" for more information.
 --
 -- The parser can be used to parse integers or floating point values. Use
 -- functions like 'Data.Scientific.floatingOrInteger' from "Data.Scientific"
 -- to test and extract integer or real values.
 --
--- This function does not parse sign, if you need to parse signed numbers,
+-- This function does not parse a sign; if you need to parse signed numbers,
 -- see 'signed'.
 --
 -- @since 5.0.0
@@ -482,7 +482,7 @@
 -- | Parse a floating point number according to the syntax for floating
 -- point literals described in the Haskell report.
 --
--- This function does not parse sign, if you need to parse signed numbers,
+-- This function does not parse a sign; if you need to parse signed numbers,
 -- see 'signed'.
 --
 -- __Note__: before version /6.0.0/ the function returned 'Double', i.e. it
@@ -527,13 +527,13 @@
   (+ e') <$> signed (return ()) decimal_
 {-# INLINE exponent_ #-}
 
--- | @'signed' space p@ parses an optional sign character (“+” or “-”), then
--- if there is a sign it consumes optional white space (using the @space@
--- parser), then it runs the parser @p@ which should return a number. Sign
--- of the number is changed according to the previously parsed sign
+-- | @'signed' space p@ parses an optional sign character (“+” or “-”), then,
+-- if there is a sign, it consumes optional white space (using the @space@
+-- parser), then it runs the parser @p@, which should return a number. The
+-- sign of the number is changed according to the previously parsed sign
 -- character.
 --
--- For example, to parse signed integer you can write:
+-- For example, to parse a signed integer you can write:
 --
 -- > lexeme        = L.lexeme spaceConsumer
 -- > integer       = lexeme L.decimal
diff --git a/Text/Megaparsec/Class.hs b/Text/Megaparsec/Class.hs
--- a/Text/Megaparsec/Class.hs
+++ b/Text/Megaparsec/Class.hs
@@ -16,8 +16,8 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- Definition of 'MonadParsec'—type class describing monads that implement
--- the full set of primitive parsers.
+-- Definition of 'MonadParsec'—the type class describing monads that
+-- implement the full set of primitive parsers.
 --
 -- @since 6.5.0
 module Text.Megaparsec.Class
@@ -61,7 +61,7 @@
   label :: String -> m a -> m a
 
   -- | @'hidden' p@ behaves just like parser @p@, but it doesn't show any
-  -- “expected” tokens in error message when @p@ fails.
+  -- “expected” tokens in the error message when @p@ fails.
   --
   -- Please use 'hidden' instead of the old @'label' ""@ idiom.
   hidden :: m a -> m a
@@ -71,7 +71,7 @@
   -- backtracks the parser state when @p@ fails (either consuming input or
   -- not).
   --
-  -- This combinator is used whenever arbitrary look ahead is needed. Since
+  -- This combinator is used whenever arbitrary lookahead is needed. Since
   -- it pretends that it hasn't consumed any input when @p@ fails, the
   -- ('A.<|>') combinator will try its second alternative even if the first
   -- parser failed while consuming input.
@@ -107,11 +107,11 @@
   -- alternatives are complex, composite parsers.
   try :: m a -> m a
 
-  -- | If @p@ in @'lookAhead' p@ succeeds (either consuming input or not)
-  -- the whole parser behaves like @p@ succeeded without consuming anything
-  -- (parser state is not updated as well). If @p@ fails, 'lookAhead' has no
-  -- effect, i.e. it will fail consuming input if @p@ fails consuming input.
-  -- Combine with 'try' if this is undesirable.
+  -- | If @p@ in @'lookAhead' p@ succeeds (either consuming input or not),
+  -- the whole parser behaves as if @p@ succeeded without consuming anything
+  -- (the parser state is not updated either). If @p@ fails, 'lookAhead' has
+  -- no effect, i.e. it will fail consuming input if @p@ fails consuming
+  -- input. Combine with 'try' if this is undesirable.
   lookAhead :: m a -> m a
 
   -- | @'notFollowedBy' p@ only succeeds when the parser @p@ fails. This
@@ -126,8 +126,8 @@
   -- to the point where the next object starts.
   --
   -- Note that if @r@ fails, the original error message is reported as if
-  -- without 'withRecovery'. In no way can the recovering parser @r@ influence
-  -- error messages.
+  -- 'withRecovery' had not been used. In no way can the recovering parser @r@
+  -- influence error messages.
   --
   -- @since 4.4.0
   withRecovery ::
@@ -139,10 +139,10 @@
     m a
 
   -- | @'observing' p@ allows us to “observe” failure of the @p@ parser,
-  -- should it happen, without actually ending parsing but instead getting
-  -- the 'ParseError' in 'Left'. On success parsed value is returned in
+  -- should it happen, without actually ending parsing, but instead getting
+  -- the 'ParseError' in 'Left'. On success, the parsed value is returned in
   -- 'Right' as usual. Note that this primitive just allows you to observe
-  -- parse errors as they happen, it does not backtrack or change how the
+  -- parse errors as they happen; it does not backtrack or change how the
   -- @p@ parser works in any way.
   --
   -- @since 5.1.0
@@ -156,7 +156,7 @@
 
   -- | The parser @'token' test expected@ accepts tokens for which the
   -- matching function @test@ returns 'Just' results. If 'Nothing' is
-  -- returned the @expected@ set is used to report the items that were
+  -- returned, the @expected@ set is used to report the items that were
   -- expected.
   --
   -- For example, the 'Text.Megaparsec.satisfy' parser is implemented as:
@@ -165,7 +165,7 @@
   -- >   where
   -- >     testToken x = if f x then Just x else Nothing
   --
-  -- __Note__: type signature of this primitive was changed in the version
+  -- __Note__: the type signature of this primitive was changed in version
   -- /7.0.0/.
   token ::
     -- | Matching function for the token to parse
@@ -179,15 +179,15 @@
   -- given and parsed chunks after a candidate chunk of correct length is
   -- fetched from the stream.
   --
-  -- This can be used for example to write 'Text.Megaparsec.chunk':
+  -- This can be used, for example, to write 'Text.Megaparsec.chunk':
   --
   -- > chunk = tokens (==)
   --
-  -- Note that beginning from Megaparsec 4.4.0, this is an auto-backtracking
+  -- Note that beginning with Megaparsec 4.4.0, this is an auto-backtracking
   -- primitive, which means that if it fails, it never consumes any input.
   -- This is done to make its consumption model match how error messages for
-  -- this primitive are reported (which becomes an important thing as user
-  -- gets more control with primitives like 'withRecovery'):
+  -- this primitive are reported (which becomes important as the user gets
+  -- more control with primitives like 'withRecovery'):
   --
   -- >>> parseTest (string "abc") "abd"
   -- 1:1:
@@ -217,7 +217,7 @@
   --
   -- @since 6.0.0
   takeWhileP ::
-    -- | Name for a single token in the row
+    -- | Name for a single token in the resulting chunk
     Maybe String ->
     -- | Predicate to use to test tokens
     (Token s -> Bool) ->
@@ -237,7 +237,7 @@
   --
   -- @since 6.0.0
   takeWhile1P ::
-    -- | Name for a single token in the row
+    -- | Name for a single token in the resulting chunk
     Maybe String ->
     -- | Predicate to use to test tokens
     (Token s -> Bool) ->
@@ -245,22 +245,23 @@
     m (Tokens s)
 
   -- | Extract the specified number of tokens from the input stream and
-  -- return them packed as a chunk of stream. If there are not enough tokens
-  -- in the stream, a parse error will be signaled. It's guaranteed that if
-  -- the parser succeeds, the requested number of tokens will be returned.
+  -- return them packed as a chunk of the stream. If there are not enough
+  -- tokens in the stream, a parse error will be signaled. It's guaranteed
+  -- that if the parser succeeds, the requested number of tokens will be
+  -- returned.
   --
   -- The parser is roughly equivalent to:
   --
   -- > takeP (Just "foo") n = count n (anySingle <?> "foo")
   -- > takeP Nothing      n = count n anySingle
   --
-  -- Note that if the combinator fails due to insufficient number of tokens
-  -- in the input stream, it backtracks automatically. No 'try' is necessary
-  -- with 'takeP'.
+  -- Note that if the combinator fails due to an insufficient number of
+  -- tokens in the input stream, it backtracks automatically. No 'try' is
+  -- necessary with 'takeP'.
   --
   -- @since 6.0.0
   takeP ::
-    -- | Name for a single token in the row
+    -- | Name for a single token in the resulting chunk
     Maybe String ->
     -- | How many tokens to extract
     Int ->
diff --git a/Text/Megaparsec/Common.hs b/Text/Megaparsec/Common.hs
--- a/Text/Megaparsec/Common.hs
+++ b/Text/Megaparsec/Common.hs
@@ -10,7 +10,7 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- Common token combinators. This module is not public, the functions from
+-- Common token combinators. This module is not public; the functions from
 -- it are re-exported in "Text.Megaparsec.Byte" and "Text.Megaparsec.Char".
 --
 -- @since 7.0.0
@@ -29,8 +29,8 @@
 string = chunk
 {-# INLINE string #-}
 
--- | The same as 'string', but case-insensitive. On success returns string
--- cased as the parsed input.
+-- | The same as 'string', but case-insensitive. On success returns the
+-- string cased as the parsed input.
 --
 -- >>> parseTest (string' "foobar") "foObAr"
 -- "foObAr"
diff --git a/Text/Megaparsec/Debug.hs b/Text/Megaparsec/Debug.hs
--- a/Text/Megaparsec/Debug.hs
+++ b/Text/Megaparsec/Debug.hs
@@ -46,18 +46,18 @@
 --
 -- @since 9.3.0
 class (MonadParsec e s m) => MonadParsecDbg e s m where
-  -- | @'dbg' label p@ parser works exactly like @p@, but when it's evaluated
-  -- it prints information useful for debugging. The @label@ is only used to
-  -- refer to this parser in the debugging output. This combinator uses the
-  -- 'trace' function from "Debug.Trace" under the hood.
+  -- | The @'dbg' label p@ parser works exactly like @p@, but when it's
+  -- evaluated it prints information useful for debugging. The @label@ is only
+  -- used to refer to this parser in the debugging output. This combinator
+  -- uses the 'trace' function from "Debug.Trace" under the hood.
   --
-  -- Typical usage is to wrap every sub-parser in misbehaving parser with
-  -- 'dbg' assigning meaningful labels. Then give it a shot and go through the
-  -- print-out. As of current version, this combinator prints all available
-  -- information except for /hints/, which are probably only interesting to
-  -- the maintainer of Megaparsec itself and may be quite verbose to output in
-  -- general. Let me know if you would like to be able to see hints in the
-  -- debugging output.
+  -- Typical usage is to wrap every sub-parser of a misbehaving parser with
+  -- 'dbg', assigning meaningful labels. Then give it a shot and go through
+  -- the print-out. As of the current version, this combinator prints all
+  -- available information except for /hints/, which are probably only
+  -- interesting to the maintainer of Megaparsec itself and may be quite
+  -- verbose to output in general. Let me know if you would like to be able to
+  -- see hints in the debugging output.
   --
   -- The output itself is pretty self-explanatory, although the following
   -- abbreviations should be clarified (they are derived from the low-level
@@ -68,9 +68,9 @@
   --     * @EOK@—“empty OK”. The parser succeeded without consuming input.
   --     * @EERR@—“empty error”. The parser failed without consuming input.
   --
-  -- __Note__: up until the version /9.3.0/ this was a non-polymorphic
-  -- function that worked only in 'ParsecT'. It was first introduced in the
-  -- version /7.0.0/.
+  -- __Note__: up until version /9.3.0/ this was a non-polymorphic function
+  -- that worked only in 'ParsecT'. It was first introduced in version
+  -- /7.0.0/.
   dbg ::
     (Show a) =>
     -- | Debugging label
@@ -144,8 +144,8 @@
   where
   dbg str wma = S.WriterT $ dbgWithComment "LOG" str $ S.runWriterT wma
 
--- | @RWST@ works like @StateT@ inside a @WriterT@: subparser's log and its
--- final state is printed:
+-- | @RWST@ works like @StateT@ inside a @WriterT@: the subparser's log and
+-- its final state are printed:
 --
 -- >>> p = tell [0] >> modify succ >> dbg "a" (single 'a' >> tell [1] >> modify succ)
 -- >>> parseTest (runRWST p () 0) "a"
@@ -164,8 +164,8 @@
     ((a, st), w) <- first unComment . unComment <$> dbg str smth
     pure (a, st, w)
 
--- | @RWST@ works like @StateT@ inside a @WriterT@: subparser's log and its
--- final state is printed:
+-- | @RWST@ works like @StateT@ inside a @WriterT@: the subparser's log and
+-- its final state are printed:
 --
 -- >>> p = tell [0] >> modify succ >> dbg "a" (single 'a' >> tell [1] >> modify succ)
 -- >>> parseTest (runRWST p () 0) "a"
@@ -189,7 +189,7 @@
 
 -- | @'dbgWithComment' label_a label_c m@ traces the first component of the
 -- result produced by @m@ with @label_a@ and the second component with
--- @label_b@.
+-- @label_c@.
 dbgWithComment ::
   (MonadParsecDbg e s m, Show a, Show c) =>
   -- | Debugging label (for @a@)
@@ -294,12 +294,12 @@
       let (h, r) = splitAt 40 (showTokens pxy ne)
        in if null r then h else h ++ " <…>"
 
--- | Calculate number of consumed tokens given 'State' of parser before and
--- after parsing.
+-- | Calculate the number of consumed tokens given the 'State' of the parser
+-- before and after parsing.
 streamDelta ::
-  -- | State of parser before consumption
+  -- | State of the parser before consumption
   State s e ->
-  -- | State of parser after consumption
+  -- | State of the parser after consumption
   State s e ->
   -- | Number of consumed tokens
   Int
diff --git a/Text/Megaparsec/Error.hs b/Text/Megaparsec/Error.hs
--- a/Text/Megaparsec/Error.hs
+++ b/Text/Megaparsec/Error.hs
@@ -72,7 +72,7 @@
 ----------------------------------------------------------------------------
 -- Parse error type
 
--- | A data type that is used to represent “unexpected\/expected” items in
+-- | A data type that is used to represent “unexpected\/expected” items in a
 -- 'ParseError'. It is parametrized over the token type @t@.
 --
 -- @since 5.0.0
@@ -87,13 +87,13 @@
 
 instance (NFData t) => NFData (ErrorItem t)
 
--- | Additional error data, extendable by user. When no custom data is
+-- | Additional error data, extendable by the user. When no custom data is
 -- necessary, the type is typically indexed by 'Void' to “cancel” the
 -- 'ErrorCustom' constructor.
 --
 -- @since 6.0.0
 data ErrorFancy e
-  = -- | 'fail' has been used in parser monad
+  = -- | 'fail' has been used in the parser monad
     ErrorFail String
   | -- | Incorrect indentation error: desired ordering between reference
     -- level and actual level, reference indentation level, actual
@@ -123,11 +123,11 @@
     -- constructor includes the offset of error, unexpected token (if any),
     -- and expected tokens.
     --
-    -- Type of the first argument was changed in the version /7.0.0/.
+    -- The type of the first argument was changed in version /7.0.0/.
     TrivialError Int (Maybe (ErrorItem (Token s))) (Set (ErrorItem (Token s)))
   | -- | Fancy, custom errors.
     --
-    -- Type of the first argument was changed in the version /7.0.0/.
+    -- The type of the first argument was changed in version /7.0.0/.
     FancyError Int (Set (ErrorFancy e))
   deriving (Generic)
 
@@ -205,11 +205,11 @@
 setErrorOffset o (TrivialError _ u p) = TrivialError o u p
 setErrorOffset o (FancyError _ x) = FancyError o x
 
--- | Merge two error data structures into one joining their collections of
--- message items and preferring the longest match. In other words, earlier
--- error message is discarded. This may seem counter-intuitive, but
+-- | Merge two error data structures into one, joining their collections of
+-- message items and preferring the longest match. In other words, the
+-- earlier error message is discarded. This may seem counter-intuitive, but
 -- 'mergeError' is only used to merge error messages of alternative branches
--- of parsing and in this case longest match should be preferred.
+-- of parsing, and in this case the longest match should be preferred.
 mergeError ::
   (Stream s, Ord e) =>
   ParseError s e ->
@@ -242,7 +242,7 @@
     n (Just x) (Just y) = Just (max x y)
 {-# INLINE mergeError #-}
 
--- | A non-empty collection of 'ParseError's equipped with 'PosState' that
+-- | A non-empty collection of 'ParseError's equipped with a 'PosState' that
 -- allows us to pretty-print the errors efficiently and correctly.
 --
 -- @since 7.0.0
@@ -333,8 +333,8 @@
   -- | Pretty-print a component of 'ParseError'.
   showErrorComponent :: a -> String
 
-  -- | Length of the error component in characters, used for highlighting of
-  -- parse errors in input string.
+  -- | Length of the error component in characters, used for highlighting
+  -- parse errors in the input string.
   --
   -- @since 7.0.0
   errorComponentLen :: a -> Int
@@ -408,14 +408,12 @@
           case msline of
             Nothing -> ""
             Just sline ->
-              let rpadding =
-                    if pointerLen > 0
-                      then replicate rpshift ' '
-                      else ""
+              let rpadding = replicate rpshift ' '
                   pointerLen =
-                    if rpshift + elen > slineLen
-                      then slineLen - rpshift + 1
-                      else max 1 elen
+                    max 1 $
+                      if rpshift + elen > slineLen
+                        then slineLen - rpshift + 1
+                        else elen
                   pointer = replicate pointerLen '^'
                   lineNumber = (show . unPos . sourceLine) epos
                   padding = replicate (length lineNumber + 1) ' '
diff --git a/Text/Megaparsec/Error/Builder.hs b/Text/Megaparsec/Error/Builder.hs
--- a/Text/Megaparsec/Error/Builder.hs
+++ b/Text/Megaparsec/Error/Builder.hs
@@ -124,8 +124,8 @@
 utok :: Token s -> ET s
 utok = unexp . Tokens . nes
 
--- | Construct an “unexpected tokens” error component. Empty chunk produces
--- 'EndOfInput'.
+-- | Construct an “unexpected tokens” error component. An empty chunk
+-- produces 'EndOfInput'.
 utoks :: forall s. (Stream s) => Tokens s -> ET s
 utoks = unexp . canonicalizeTokens (Proxy :: Proxy s)
 
@@ -144,7 +144,7 @@
 etok :: Token s -> ET s
 etok = expe . Tokens . nes
 
--- | Construct an “expected tokens” error component. Empty chunk produces
+-- | Construct an “expected tokens” error component. An empty chunk produces
 -- 'EndOfInput'.
 etoks :: forall s. (Stream s) => Tokens s -> ET s
 etoks = expe . canonicalizeTokens (Proxy :: Proxy s)
diff --git a/Text/Megaparsec/Internal.hs b/Text/Megaparsec/Internal.hs
--- a/Text/Megaparsec/Internal.hs
+++ b/Text/Megaparsec/Internal.hs
@@ -71,10 +71,10 @@
 ----------------------------------------------------------------------------
 -- Data types
 
--- | 'Hints' represent a collection of 'ErrorItem's to be included into
--- 'ParseError' (when it's a 'TrivialError') as “expected” message items
--- when a parser fails without consuming input right after successful parser
--- that produced the hints.
+-- | 'Hints' represent a collection of 'ErrorItem's to be included in a
+-- 'ParseError' (when it's a 'TrivialError') as “expected” message items when
+-- a parser fails without consuming input right after a successful parser that
+-- produced the hints.
 --
 -- For example, without hints you could get:
 --
@@ -99,8 +99,8 @@
 
 -- | All information available after parsing. This includes consumption of
 -- input, success (with the returned value) or failure (with the parse
--- error), and parser state at the end of parsing. 'Reply' can also be used
--- to resume parsing.
+-- error), and the parser state at the end of parsing. 'Reply' can also be
+-- used to resume parsing.
 --
 -- See also: 'Consumption', 'Result'.
 data Reply e s a = Reply (State s e) Consumption (Result s e a)
@@ -110,7 +110,7 @@
 --
 -- See also: 'Result', 'Reply'.
 data Consumption
-  = -- | Some part of input stream was consumed
+  = -- | Some part of the input stream was consumed
     Consumed
   | -- | No input was consumed
     NotConsumed
@@ -126,8 +126,8 @@
     Error (ParseError s e)
   deriving (Functor)
 
--- | @'ParsecT' e s m a@ is a parser with custom data component of error
--- @e@, stream type @s@, underlying monad @m@ and return type @a@.
+-- | @'ParsecT' e s m a@ is a parser with custom error data component @e@,
+-- stream type @s@, underlying monad @m@, and return type @a@.
 newtype ParsecT e s m a = ParsecT
   { unParser ::
       forall b.
@@ -336,7 +336,7 @@
 --
 -- > v >> mzero = mzero
 --
--- However the following holds:
+-- However, the following holds:
 --
 -- > try v >> mzero = mzero
 instance (Ord e, Stream s) => MonadPlus (ParsecT e s m) where
@@ -364,24 +364,12 @@
    in unParser m s cok cerr eok meerr
   where
     combineErrors altOffset e1 e2 = case (e1, e2) of
-      (TrivialError o1 u1 p1, TrivialError o2 u2 p2) ->
-        -- When merging alternative errors, if one is ahead due to try, we
-        -- bring both to the alternative position and union their expected
-        -- tokens.
-        if o1 > altOffset || o2 > altOffset
-          then
-            -- At least one error is ahead, normalize to alt position. Only
-            -- include expected tokens from errors at the alt position.
-            let p1' = if o1 == altOffset then p1 else E.empty
-                p2' = if o2 == altOffset then p2 else E.empty
-                -- Use the unexpected from the error at alt position, or the
-                -- furthest.
-                unexp = case (o1 `compare` altOffset, o2 `compare` altOffset) of
-                  (EQ, _) -> u1
-                  (_, EQ) -> u2
-                  _ -> if o1 >= o2 then u1 else u2
-             in TrivialError altOffset unexp (E.union p1' p2')
-          else e2 <> e1
+      (TrivialError o1 u1 p1, TrivialError o2 _ _)
+        | o1 == altOffset && o2 > altOffset ->
+            TrivialError altOffset u1 p1
+      (TrivialError o1 _ _, TrivialError o2 u2 p2)
+        | o2 == altOffset && o1 > altOffset ->
+            TrivialError altOffset u2 p2
       _ -> e2 <> e1
 {-# INLINE pPlus #-}
 
@@ -617,7 +605,7 @@
   Maybe String ->
   Int ->
   ParsecT e s m (Tokens s)
-pTakeP ml n' = ParsecT $ \s@(State input o pst de) cok _ _ eerr ->
+pTakeP ml n' = ParsecT $ \s@(State input o pst de) cok _ eok eerr ->
   let n = max 0 n'
       pxy = Proxy :: Proxy s
       el = Label <$> (ml >>= NE.nonEmpty)
@@ -627,12 +615,19 @@
           eerr (TrivialError o (pure EndOfInput) ps) s
         Just (ts, input') ->
           let len = chunkLength pxy ts
+              st = State input' (o + len) pst de
            in if len /= n
                 then
                   eerr
                     (TrivialError (o + len) (pure EndOfInput) ps)
                     (State input o pst de)
-                else cok ts (State input' (o + len) pst de) mempty
+                else
+                  -- NOTE When nothing has been taken we must report that no
+                  -- input has been consumed, otherwise e.g. ('<|>') would
+                  -- not try its second branch after this parser.
+                  if chunkEmpty pxy ts
+                    then eok ts st mempty
+                    else cok ts st mempty
 {-# INLINE pTakeP #-}
 
 pGetParserState :: (Stream s) => ParsecT e s m (State s e)
@@ -653,7 +648,7 @@
 -- | Convert a 'ParseError' record into 'Hints'.
 toHints ::
   (Stream s) =>
-  -- | Current offset in input stream
+  -- | Current offset in the input stream
   Int ->
   -- | Parse error to convert
   ParseError s e ->
@@ -670,10 +665,11 @@
   FancyError _ _ -> mempty
 {-# INLINE toHints #-}
 
--- | @'withHints' hs c@ makes “error” continuation @c@ use given hints @hs@.
+-- | @'withHints' hs c@ makes the “error” continuation @c@ use the given
+-- hints @hs@.
 --
--- __Note__ that if resulting continuation gets 'ParseError' that has custom
--- data in it, hints are ignored.
+-- __Note__ that if the resulting continuation gets a 'ParseError' that has
+-- custom data in it, the hints are ignored.
 withHints ::
   (Stream s) =>
   -- | Hints to use
@@ -691,8 +687,8 @@
     _ -> c e
 {-# INLINE withHints #-}
 
--- | @'accHints' hs c@ results in “OK” continuation that will add given
--- hints @hs@ to third argument of original continuation @c@.
+-- | @'accHints' hs c@ results in an “OK” continuation that will add the given
+-- hints @hs@ to the third argument of the original continuation @c@.
 accHints ::
   (Stream s) =>
   -- | 'Hints' to add
diff --git a/Text/Megaparsec/Lexer.hs b/Text/Megaparsec/Lexer.hs
--- a/Text/Megaparsec/Lexer.hs
+++ b/Text/Megaparsec/Lexer.hs
@@ -2,7 +2,7 @@
 {-# LANGUAGE Safe #-}
 
 -- |
--- Module      :  Text.Megaparsec.Common
+-- Module      :  Text.Megaparsec.Lexer
 -- Copyright   :  © 2018–present Megaparsec contributors
 -- License     :  FreeBSD
 --
@@ -10,7 +10,7 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- Common token combinators. This module is not public, the functions from
+-- Common token combinators. This module is not public; the functions from
 -- it are re-exported in "Text.Megaparsec.Byte" and "Text.Megaparsec.Char".
 --
 -- @since 7.0.0
@@ -38,9 +38,9 @@
 --
 -- @sc@ is used to parse blocks of space characters. You can use
 -- 'Text.Megaparsec.Char.space1' from "Text.Megaparsec.Char" for this
--- purpose as well as your own parser (if you don't want to automatically
+-- purpose, as well as your own parser (if you don't want to automatically
 -- consume newlines, for example). Make sure that the parser does not
--- succeed on the empty input though. In an earlier version of the library
+-- succeed on empty input though. In an earlier version of the library,
 -- 'Text.Megaparsec.Char.spaceChar' was recommended, but now parsers based
 -- on 'takeWhile1P' are preferred because of their speed.
 --
@@ -51,8 +51,8 @@
 -- @skipBlockComment@ or @skipBlockCommentNested@ if you don't need anything
 -- special.
 --
--- If you don't want to allow a kind of comment, simply pass 'empty' which
--- will fail instantly when parsing of that sort of comment is attempted and
+-- If you don't want to allow a kind of comment, simply pass 'empty', which
+-- will fail instantly when parsing of that sort of comment is attempted, and
 -- 'space' will just move on or finish depending on whether there is more
 -- white space for it to consume.
 space ::
@@ -79,9 +79,9 @@
 -- > integer = lexeme L.decimal
 lexeme ::
   (MonadParsec e s m) =>
-  -- | How to consume white space after lexeme
+  -- | How to consume white space after the lexeme
   m () ->
-  -- | How to parse actual lexeme
+  -- | How to parse the actual lexeme
   m a ->
   m a
 lexeme spc p = p <* spc
@@ -103,7 +103,7 @@
 -- > dot       = symbol "."
 symbol ::
   (MonadParsec e s m) =>
-  -- | How to consume white space after lexeme
+  -- | How to consume white space after the lexeme
   m () ->
   -- | Symbol to parse
   Tokens s ->
@@ -115,7 +115,7 @@
 -- working with case-insensitive languages.
 symbol' ::
   (MonadParsec e s m, CI.FoldCase (Tokens s)) =>
-  -- | How to consume white space after lexeme
+  -- | How to consume white space after the lexeme
   m () ->
   -- | Symbol to parse (case-insensitive)
   Tokens s ->
diff --git a/Text/Megaparsec/Pos.hs b/Text/Megaparsec/Pos.hs
--- a/Text/Megaparsec/Pos.hs
+++ b/Text/Megaparsec/Pos.hs
@@ -12,8 +12,8 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- Textual source position. The position includes name of file, line number,
--- and column number.
+-- Textual source position. The position includes the name of the file, the
+-- line number, and the column number.
 --
 -- You probably do not want to import this module directly because
 -- "Text.Megaparsec" re-exports it anyway.
@@ -42,7 +42,7 @@
 -- Abstract position
 
 -- | 'Pos' is the type for positive integers. This is used to represent line
--- number, column number, and similar things like indentation level.
+-- number, column number, and similar things like indentation level. The
 -- 'Semigroup' instance can be used to safely and efficiently add 'Pos'es
 -- together.
 --
@@ -74,9 +74,9 @@
 pos1 :: Pos
 pos1 = mkPos 1
 
--- | Value of tab width used by default. Always prefer this constant when
--- you want to refer to the default tab width because actual value /may/
--- change in future.
+-- | The value of the tab width used by default. Always prefer this constant
+-- when you want to refer to the default tab width, because the actual value
+-- /may/ change in the future.
 --
 -- Currently:
 --
@@ -129,8 +129,8 @@
 
 instance NFData SourcePos
 
--- | Construct initial position (line 1, column 1) given name of source
--- file.
+-- | Construct the initial position (line 1, column 1) given the name of the
+-- source file.
 initialPos :: FilePath -> SourcePos
 initialPos n = SourcePos n pos1 pos1
 
diff --git a/Text/Megaparsec/State.hs b/Text/Megaparsec/State.hs
--- a/Text/Megaparsec/State.hs
+++ b/Text/Megaparsec/State.hs
@@ -33,10 +33,10 @@
 import {-# SOURCE #-} Text.Megaparsec.Error (ParseError)
 import Text.Megaparsec.Pos
 
--- | This is the Megaparsec's state parametrized over stream type @s@ and
--- custom error component type @e@.
+-- | This is Megaparsec's state, parametrized over the stream type @s@ and
+-- the custom error component type @e@.
 data State s e = State
-  { -- | The rest of input to process
+  { -- | The rest of the input to process
     stateInput :: s,
     -- | Number of processed tokens so far
     --
@@ -75,7 +75,7 @@
 
 instance (NFData s, NFData (ParseError s e)) => NFData (State s e)
 
--- | Given the name of the source file and the input construct the initial
+-- | Given the name of the source file and the input, construct the initial
 -- state for a parser.
 --
 -- @since 9.6.0
@@ -98,22 +98,22 @@
 --
 -- @since 7.0.0
 data PosState s = PosState
-  { -- | The rest of input to process
+  { -- | The rest of the input to process
     pstateInput :: s,
-    -- | Offset corresponding to beginning of 'pstateInput'
+    -- | Offset corresponding to the beginning of 'pstateInput'
     pstateOffset :: !Int,
-    -- | Source position corresponding to beginning of 'pstateInput'
+    -- | Source position corresponding to the beginning of 'pstateInput'
     pstateSourcePos :: !SourcePos,
     -- | Tab width to use for column calculation
     pstateTabWidth :: Pos,
-    -- | Prefix to prepend to offending line
+    -- | Prefix to prepend to the offending line
     pstateLinePrefix :: String
   }
   deriving (Show, Eq, Data, Generic)
 
 instance (NFData s) => NFData (PosState s)
 
--- | Given the name of source file and the input construct the initial
+-- | Given the name of the source file and the input, construct the initial
 -- positional state.
 --
 -- @since 9.6.0
diff --git a/Text/Megaparsec/Stream.hs b/Text/Megaparsec/Stream.hs
--- a/Text/Megaparsec/Stream.hs
+++ b/Text/Megaparsec/Stream.hs
@@ -63,7 +63,7 @@
 -- retain the current behaviour and are concerned with maximum performance you
 -- should consider using the 'ShareInput' wrapper explicitly.
 --
--- __Note__: before the version /9.0.0/ the class included the methods from
+-- __Note__: before version /9.0.0/ the class included the methods from
 -- 'VisualStream' and 'TraversableStream'.
 class (Ord (Token s), Ord (Tokens s)) => Stream s where
   -- | Type of token in the stream.
@@ -72,29 +72,29 @@
   -- | Type of “chunk” of the stream.
   type Tokens s :: Type
 
-  -- | Lift a single token to chunk of the stream. The default
+  -- | Lift a single token to a chunk of the stream. The default
   -- implementation is:
   --
   -- > tokenToChunk pxy = tokensToChunk pxy . pure
   --
-  -- However for some types of stream there may be a more efficient way to
+  -- However, for some types of stream there may be a more efficient way to
   -- lift.
   tokenToChunk :: Proxy s -> Token s -> Tokens s
   tokenToChunk pxy = tokensToChunk pxy . pure
 
-  -- | The first method that establishes isomorphism between list of tokens
-  -- and chunk of the stream. Valid implementation should satisfy:
+  -- | The first method that establishes the isomorphism between a list of
+  -- tokens and a chunk of the stream. A valid implementation should satisfy:
   --
   -- > chunkToTokens pxy (tokensToChunk pxy ts) == ts
   tokensToChunk :: Proxy s -> [Token s] -> Tokens s
 
-  -- | The second method that establishes isomorphism between list of tokens
-  -- and chunk of the stream. Valid implementation should satisfy:
+  -- | The second method that establishes the isomorphism between a list of
+  -- tokens and a chunk of the stream. A valid implementation should satisfy:
   --
   -- > tokensToChunk pxy (chunkToTokens pxy chunk) == chunk
   chunkToTokens :: Proxy s -> Tokens s -> [Token s]
 
-  -- | Return length of a chunk of the stream.
+  -- | Return the length of a chunk of the stream.
   chunkLength :: Proxy s -> Tokens s -> Int
 
   -- | Check if a chunk of the stream is empty. The default implementation
@@ -102,16 +102,16 @@
   --
   -- > chunkEmpty pxy ts = chunkLength pxy ts <= 0
   --
-  -- However for many streams there may be a more efficient implementation.
+  -- However, for many streams there may be a more efficient implementation.
   chunkEmpty :: Proxy s -> Tokens s -> Bool
   chunkEmpty pxy ts = chunkLength pxy ts <= 0
 
-  -- | Extract a single token form the stream. Return 'Nothing' if the
+  -- | Extract a single token from the stream. Return 'Nothing' if the
   -- stream is empty.
   take1_ :: s -> Maybe (Token s, s)
 
   -- | @'takeN_' n s@ should try to extract a chunk of length @n@, or if the
-  -- stream is too short, the rest of the stream. Valid implementation
+  -- stream is too short, the rest of the stream. A valid implementation
   -- should follow the rules:
   --
   --     * If the requested length @n@ is 0 (or less), 'Nothing' should
@@ -120,16 +120,16 @@
   --       stream (second argument).
   --     * If the requested length is greater than 0 and the stream is
   --       empty, 'Nothing' should be returned indicating end of input.
-  --     * In other cases, take chunk of length @n@ (or shorter if the
+  --     * In other cases, take a chunk of length @n@ (or shorter if the
   --       stream is not long enough) from the input stream and return the
   --       chunk along with the rest of the stream.
   takeN_ :: Int -> s -> Maybe (Tokens s, s)
 
-  -- | Extract chunk of the stream taking tokens while the supplied
+  -- | Extract a chunk of the stream, taking tokens while the supplied
   -- predicate returns 'True'. Return the chunk and the rest of the stream.
   --
-  -- For many types of streams, the method allows for significant
-  -- performance improvements, although it is not strictly necessary from
+  -- For many types of streams, this method allows for significant
+  -- performance improvements, although it is not strictly necessary from a
   -- conceptual point of view.
   takeWhile_ :: (Token s -> Bool) -> s -> (Tokens s, s)
 
@@ -174,11 +174,11 @@
 -- 'T.split'.
 --
 -- Note that using slices is in general faster than copying; on the other
--- hand it also has the potential for causing surprising memory leaks: if
+-- hand, it also has the potential for causing surprising memory leaks: if
 -- any slice of the input survives in the output, holding on to the output
 -- will force the entire input 'T.Text'/'B.ByteString' to stay in memory!
 -- Even when using lazy 'TL.Text'/'BL.ByteString' we will hold on to whole
--- chunks at a time leading to to significantly worse memory residency in
+-- chunks at a time, leading to significantly worse memory residency in
 -- some cases.
 --
 -- See 'NoShareInput' for a somewhat slower implementation that avoids this
@@ -257,7 +257,7 @@
 -- garbage collected.
 --
 -- For maximum performance you might consider using 'ShareInput' instead,
--- but beware of its pitfalls!
+-- but beware its pitfalls!
 --
 -- @since 9.3.0
 newtype NoShareInput a = NoShareInput {unNoShareInput :: a}
@@ -412,7 +412,7 @@
 --
 -- @since 9.0.0
 class (Stream s) => VisualStream s where
-  -- | Pretty-print non-empty stream of tokens. This function is also used
+  -- | Pretty-print a non-empty stream of tokens. This function is also used
   -- to print single tokens (represented as singleton lists).
   --
   -- @since 7.0.0
@@ -450,7 +450,7 @@
 class (Stream s) => TraversableStream s where
   {-# MINIMAL reachOffset | reachOffsetNoLine #-}
 
-  -- | Given an offset @o@ and initial 'PosState', adjust the state in such
+  -- | Given an offset @o@ and an initial 'PosState', adjust the state in such
   -- a way that it starts at the offset.
   --
   -- Return two values (in order):
@@ -463,20 +463,21 @@
   --     * The updated 'PosState' which can be in turn used to locate
   --       another offset @o'@ given that @o' >= o@.
   --
-  -- The 'String' representing the offending line in input stream should
+  -- The 'String' representing the offending line in the input stream should
   -- satisfy the following:
   --
-  --     * It should adequately represent location of token at the offset of
-  --       interest, that is, character at 'sourceColumn' of the returned
-  --       'SourcePos' should correspond to the token at the offset @o@.
+  --     * It should adequately represent the location of the token at the
+  --       offset of interest, that is, the character at 'sourceColumn' of the
+  --       returned 'SourcePos' should correspond to the token at the offset
+  --       @o@.
   --     * It should not include the newline at the end.
-  --     * It should not be empty, if the line happens to be empty, it
+  --     * It should not be empty; if the line happens to be empty, it
   --       should be replaced with the string @\"\<empty line\>\"@.
-  --     * Tab characters should be replaced by appropriate number of
+  --     * Tab characters should be replaced by an appropriate number of
   --       spaces, which is determined by the 'pstateTabWidth' field of
   --       'PosState'.
   --
-  -- __Note__: type signature of the function was changed in the version
+  -- __Note__: the type signature of the function was changed in version
   -- /9.0.0/.
   --
   -- @since 7.0.0
@@ -491,14 +492,14 @@
     (Nothing, reachOffsetNoLine o pst)
 
   -- | A version of 'reachOffset' that may be faster because it doesn't need
-  -- to fetch the line at which the given offset in located.
+  -- to fetch the line at which the given offset is located.
   --
   -- The default implementation is this:
   --
   -- > reachOffsetNoLine o pst =
   -- >   snd (reachOffset o pst)
   --
-  -- __Note__: type signature of the function was changed in the version
+  -- __Note__: the type signature of the function was changed in version
   -- /8.0.0/.
   --
   -- @since 7.0.0
@@ -559,11 +560,11 @@
 reachOffset' ::
   forall s.
   (Stream s) =>
-  -- | How to split input stream at given offset
+  -- | How to split the input stream at a given offset
   (Int -> s -> (Tokens s, s)) ->
-  -- | How to fold over input stream
+  -- | How to fold over the input stream
   (forall b. (b -> Token s -> b) -> b -> Tokens s -> b) ->
-  -- | How to convert chunk of input stream into a 'String'
+  -- | How to convert a chunk of the input stream into a 'String'
   (Tokens s -> String) ->
   -- | How to convert a token into a 'Char'
   (Token s -> Char) ->
@@ -640,9 +641,9 @@
 reachOffsetNoLine' ::
   forall s.
   (Stream s) =>
-  -- | How to split input stream at given offset
+  -- | How to split the input stream at a given offset
   (Int -> s -> (Tokens s, s)) ->
-  -- | How to fold over input stream
+  -- | How to fold over the input stream
   (forall b. (b -> Token s -> b) -> b -> Tokens s -> b) ->
   -- | Newline token and tab token
   (Token s, Token s) ->
@@ -694,8 +695,8 @@
 splitAtTL n = TL.splitAt (fromIntegral n)
 {-# INLINE splitAtTL #-}
 
--- | @stringPretty s@ returns pretty representation of string @s@. This is
--- used when printing string tokens in error messages.
+-- | @stringPretty s@ returns a pretty representation of the string @s@. This
+-- is used when printing string tokens in error messages.
 stringPretty :: NonEmpty Char -> String
 stringPretty (x :| []) = charPretty x
 stringPretty ('\r' :| "\n") = "crlf newline"
@@ -706,8 +707,8 @@
         Nothing -> [ch]
         Just pretty -> "<" <> pretty <> ">"
 
--- | @charPretty ch@ returns user-friendly string representation of given
--- character @ch@, suitable for using in error messages.
+-- | @charPretty ch@ returns a user-friendly string representation of the
+-- given character @ch@, suitable for use in error messages.
 charPretty :: Char -> String
 charPretty ' ' = "space"
 charPretty ch = fromMaybe ("'" <> [ch] <> "'") (charPretty' ch)
@@ -752,7 +753,7 @@
   '\160' -> Just "non-breaking space"
   _ -> Nothing
 
--- | Replace tab characters with given number of spaces.
+-- | Replace tab characters with the given number of spaces.
 expandTab ::
   Pos ->
   String ->
@@ -761,19 +762,23 @@
   where
     go _ 0 [] = []
     go !i 0 ('\t' : xs) = go i (w - (i `rem` w)) xs
-    go !i 0 (x : xs) = x : go (i + 1) 0 xs
+    go !i 0 (x : xs) = x : go (i + Unicode.charLength x) 0 xs
     go !i n xs = ' ' : go (i + 1) (n - 1) xs
     w = unPos w'
 
 -- | Return updated column position that corresponds to the given 'Char'.
 charInc :: Char -> Pos -> Pos
-charInc ch c
-  | Unicode.isZeroWidthChar ch = c
-  | Unicode.isWideChar ch = c <> pos1 <> pos1
-  | otherwise = c <> pos1
+charInc ch c =
+  case Unicode.charLength ch of
+    0 -> c
+    2 -> c <> pos1 <> pos1
+    _ -> c <> pos1
 
 -- | Return updated column position that corresponds to the given 'Word8'.
 byteInc :: Word8 -> Pos -> Pos
 byteInc w c
-  | w < 0x20 || (w >= 0x7f && w < 0xa0) = c -- C0 and C1 control chars
+  | w < 0x20 -- C0 control chars
+      || (w >= 0x7f && w < 0xa0) -- DEL and C1 control chars
+      || w == 0xad = -- soft hyphen
+      c
   | otherwise = c <> pos1
diff --git a/Text/Megaparsec/Unicode.hs b/Text/Megaparsec/Unicode.hs
--- a/Text/Megaparsec/Unicode.hs
+++ b/Text/Megaparsec/Unicode.hs
@@ -20,50 +20,70 @@
   )
 where
 
-import Data.Array (Array, bounds, listArray, (!))
+import Data.Array (Array, bounds, (!))
 import Data.Char (ord)
+import Text.Megaparsec.Unicode.Tables
 
--- | Calculate length of a string taking into account the fact that certain
--- 'Char's may span more than 1 column.
+-- | Calculate the length of a string, taking into account the fact that
+-- certain 'Char's may span more than 1 column.
 --
 -- @since 9.7.0
 stringLength :: (Traversable t) => t Char -> Int
 stringLength = sum . fmap charLength
 
--- | Return length of an individual 'Char'.
+-- | Return the length of an individual 'Char'.
 --
 -- @since 9.7.0
 charLength :: Char -> Int
 charLength ch
-  | isZeroWidthChar ch = 0
-  | isWideChar ch = 2
+  | n < simpleCharLimit = if isSimpleZeroWidth n then 0 else 1
+  -- The two tables are disjoint, so the order of the lookups only affects
+  -- speed. Wide characters are looked up first because scripts that use
+  -- them use them for nearly every character, while combining marks are
+  -- interspersed with characters that are in neither table.
+  | inRanges wideCharRanges n = 2
+  | inRanges zeroWidthCharRanges n = 0
   | otherwise = 1
+  where
+    n = ord ch
 
 -- | Determine whether the given 'Char' is “wide”, that is, whether it spans
 -- 2 columns instead of one.
 --
 -- @since 9.7.0
 isWideChar :: Char -> Bool
-isWideChar c = go (bounds wideCharRanges)
+isWideChar ch = n >= simpleCharLimit && inRanges wideCharRanges n
   where
-    go (lo, hi)
-      | hi < lo = False
-      | a <= n && n <= b = True
-      | n < a = go (lo, pred mid)
-      | otherwise = go (succ mid, hi)
-      where
-        mid = (lo + hi) `div` 2
-        (a, b) = wideCharRanges ! mid
-    n = ord c
+    n = ord ch
 
--- | Determine whether the given 'Char' is "zero-width", that is, whether it
+-- | Determine whether the given 'Char' is “zero-width”, that is, whether it
 -- has no visible representation and does not advance the cursor position.
--- This includes control characters and certain Unicode zero-width characters.
+-- This includes control characters and certain Unicode zero-width
+-- characters.
 --
 -- @since 9.8.0
 isZeroWidthChar :: Char -> Bool
-isZeroWidthChar c = go (bounds zeroWidthCharRanges)
+isZeroWidthChar ch
+  | n < simpleCharLimit = isSimpleZeroWidth n
+  | otherwise = inRanges zeroWidthCharRanges n
   where
+    n = ord ch
+
+-- | Decide whether a code point below 'simpleCharLimit' is zero-width. Only
+-- the control characters and the soft hyphen are; the generator checks that
+-- this agrees with the data it produces.
+isSimpleZeroWidth :: Int -> Bool
+isSimpleZeroWidth n =
+  n < 0x20 -- C0 control chars
+    || (n >= 0x7f && n <= 0x9f) -- DEL and C1 control chars
+    || n == 0xad -- soft hyphen
+{-# INLINE isSimpleZeroWidth #-}
+
+-- | Look up a code point in a sorted collection of ranges that neither
+-- overlap nor touch.
+inRanges :: Array Int (Int, Int) -> Int -> Bool
+inRanges ranges n = go (bounds ranges)
+  where
     go (lo, hi)
       | hi < lo = False
       | a <= n && n <= b = True
@@ -71,153 +91,4 @@
       | otherwise = go (succ mid, hi)
       where
         mid = (lo + hi) `div` 2
-        (a, b) = zeroWidthCharRanges ! mid
-    n = ord c
-
--- | Wide character ranges.
-wideCharRanges :: Array Int (Int, Int)
-wideCharRanges =
-  listArray
-    (0, 118)
-    [ (0x001100, 0x00115f),
-      (0x00231a, 0x00231b),
-      (0x002329, 0x00232a),
-      (0x0023e9, 0x0023ec),
-      (0x0023f0, 0x0023f0),
-      (0x0023f3, 0x0023f3),
-      (0x0025fd, 0x0025fe),
-      (0x002614, 0x002615),
-      (0x002648, 0x002653),
-      (0x00267f, 0x00267f),
-      (0x002693, 0x002693),
-      (0x0026a1, 0x0026a1),
-      (0x0026aa, 0x0026ab),
-      (0x0026bd, 0x0026be),
-      (0x0026c4, 0x0026c5),
-      (0x0026ce, 0x0026ce),
-      (0x0026d4, 0x0026d4),
-      (0x0026ea, 0x0026ea),
-      (0x0026f2, 0x0026f3),
-      (0x0026f5, 0x0026f5),
-      (0x0026fa, 0x0026fa),
-      (0x0026fd, 0x0026fd),
-      (0x002705, 0x002705),
-      (0x00270a, 0x00270b),
-      (0x002728, 0x002728),
-      (0x00274c, 0x00274c),
-      (0x00274e, 0x00274e),
-      (0x002753, 0x002755),
-      (0x002757, 0x002757),
-      (0x002795, 0x002797),
-      (0x0027b0, 0x0027b0),
-      (0x0027bf, 0x0027bf),
-      (0x002b1b, 0x002b1c),
-      (0x002b50, 0x002b50),
-      (0x002b55, 0x002b55),
-      (0x002e80, 0x002e99),
-      (0x002e9b, 0x002ef3),
-      (0x002f00, 0x002fd5),
-      (0x002ff0, 0x002ffb),
-      (0x003000, 0x00303e),
-      (0x003041, 0x003096),
-      (0x003099, 0x0030ff),
-      (0x003105, 0x00312f),
-      (0x003131, 0x00318e),
-      (0x003190, 0x0031ba),
-      (0x0031c0, 0x0031e3),
-      (0x0031f0, 0x00321e),
-      (0x003220, 0x003247),
-      (0x003250, 0x004db5),
-      (0x004e00, 0x009fef),
-      (0x00a000, 0x00a48c),
-      (0x00a490, 0x00a4c6),
-      (0x00a960, 0x00a97c),
-      (0x00ac00, 0x00d7a3),
-      (0x00f900, 0x00fa6d),
-      (0x00fa70, 0x00fad9),
-      (0x00fe10, 0x00fe19),
-      (0x00fe30, 0x00fe52),
-      (0x00fe54, 0x00fe66),
-      (0x00fe68, 0x00fe6b),
-      (0x00ff01, 0x00ff60),
-      (0x00ffe0, 0x00ffe6),
-      (0x016fe0, 0x016fe3),
-      (0x017000, 0x0187f7),
-      (0x018800, 0x018af2),
-      (0x01b000, 0x01b11e),
-      (0x01b150, 0x01b152),
-      (0x01b164, 0x01b167),
-      (0x01b170, 0x01b2fb),
-      (0x01f004, 0x01f004),
-      (0x01f0cf, 0x01f0cf),
-      (0x01f18e, 0x01f18e),
-      (0x01f191, 0x01f19a),
-      (0x01f200, 0x01f202),
-      (0x01f210, 0x01f23b),
-      (0x01f240, 0x01f248),
-      (0x01f250, 0x01f251),
-      (0x01f260, 0x01f265),
-      (0x01f300, 0x01f320),
-      (0x01f32d, 0x01f335),
-      (0x01f337, 0x01f37c),
-      (0x01f37e, 0x01f393),
-      (0x01f3a0, 0x01f3ca),
-      (0x01f3cf, 0x01f3d3),
-      (0x01f3e0, 0x01f3f0),
-      (0x01f3f4, 0x01f3f4),
-      (0x01f3f8, 0x01f43e),
-      (0x01f440, 0x01f440),
-      (0x01f442, 0x01f4fc),
-      (0x01f4ff, 0x01f53d),
-      (0x01f54b, 0x01f54e),
-      (0x01f550, 0x01f567),
-      (0x01f57a, 0x01f57a),
-      (0x01f595, 0x01f596),
-      (0x01f5a4, 0x01f5a4),
-      (0x01f5fb, 0x01f64f),
-      (0x01f680, 0x01f6c5),
-      (0x01f6cc, 0x01f6cc),
-      (0x01f6d0, 0x01f6d2),
-      (0x01f6d5, 0x01f6d5),
-      (0x01f6eb, 0x01f6ec),
-      (0x01f6f4, 0x01f6fa),
-      (0x01f7e0, 0x01f7eb),
-      (0x01f90d, 0x01f971),
-      (0x01f973, 0x01f976),
-      (0x01f97a, 0x01f9a2),
-      (0x01f9a5, 0x01f9aa),
-      (0x01f9ae, 0x01f9ca),
-      (0x01f9cd, 0x01f9ff),
-      (0x01fa70, 0x01fa73),
-      (0x01fa78, 0x01fa7a),
-      (0x01fa80, 0x01fa82),
-      (0x01fa90, 0x01fa95),
-      (0x020000, 0x02a6d6),
-      (0x02a700, 0x02b734),
-      (0x02b740, 0x02b81d),
-      (0x02b820, 0x02cea1),
-      (0x02ceb0, 0x02ebe0),
-      (0x02f800, 0x02fa1d)
-    ]
-{-# NOINLINE wideCharRanges #-}
-
--- | Zero-width character ranges.
-zeroWidthCharRanges :: Array Int (Int, Int)
-zeroWidthCharRanges =
-  listArray
-    (0, 12)
-    [ (0x0000, 0x001f), -- C0 control characters
-      (0x007f, 0x009f), -- DEL and C1 control characters
-      (0x00ad, 0x00ad), -- Soft Hyphen
-      (0x0300, 0x036f), -- Combining Diacritical Marks
-      (0x0483, 0x0489), -- Combining Cyrillic
-      (0x0591, 0x05bd), -- Hebrew combining marks
-      (0x05bf, 0x05bf), -- Hebrew point
-      (0x05c1, 0x05c2), -- Hebrew points
-      (0x05c4, 0x05c5), -- Hebrew marks
-      (0x05c7, 0x05c7), -- Hebrew point
-      (0x0610, 0x061a), -- Arabic combining marks
-      (0x200b, 0x200f), -- Zero width chars and directional marks
-      (0x202a, 0x202e) -- Directional formatting
-    ]
-{-# NOINLINE zeroWidthCharRanges #-}
+        (a, b) = ranges ! mid
diff --git a/Text/Megaparsec/Unicode/Tables.hs b/Text/Megaparsec/Unicode/Tables.hs
new file mode 100644
--- /dev/null
+++ b/Text/Megaparsec/Unicode/Tables.hs
@@ -0,0 +1,560 @@
+{-# LANGUAGE Safe #-}
+
+-- |
+-- Module      :  Text.Megaparsec.Unicode.Tables
+-- Copyright   :  © 2026–present Megaparsec contributors
+-- License     :  FreeBSD
+--
+-- Maintainer  :  Mark Karpov <markkarpov92@gmail.com>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- Character width data extracted from the Unicode Character
+-- Database.
+--
+-- __This module is generated by @script\/GenUnicodeTables.hs@, do not
+-- edit it by hand.__
+module Text.Megaparsec.Unicode.Tables
+  ( unicodeVersion,
+    simpleCharLimit,
+    wideCharRanges,
+    zeroWidthCharRanges,
+  )
+where
+
+import Data.Array (Array, listArray)
+
+-- | The version of the Unicode Character Database that the tables in
+-- this module were extracted from.
+unicodeVersion :: String
+unicodeVersion = "17.0.0"
+
+-- | Below this code point a character is neither wide nor zero-width,
+-- with the exception of the C0 and C1 control characters and the soft
+-- hyphen. This is what allows the common case to avoid a table lookup
+-- altogether.
+simpleCharLimit :: Int
+simpleCharLimit = 0x000300
+
+-- | Ranges of characters that span two columns, that is, those whose
+-- East Asian Width is Wide or Fullwidth. Zero-width characters are
+-- excluded, so the two tables are disjoint.
+wideCharRanges :: Array Int (Int, Int)
+wideCharRanges =
+  listArray
+    (0, 123)
+    [ (0x001100, 0x00115f),
+      (0x00231a, 0x00231b),
+      (0x002329, 0x00232a),
+      (0x0023e9, 0x0023ec),
+      (0x0023f0, 0x0023f0),
+      (0x0023f3, 0x0023f3),
+      (0x0025fd, 0x0025fe),
+      (0x002614, 0x002615),
+      (0x002630, 0x002637),
+      (0x002648, 0x002653),
+      (0x00267f, 0x00267f),
+      (0x00268a, 0x00268f),
+      (0x002693, 0x002693),
+      (0x0026a1, 0x0026a1),
+      (0x0026aa, 0x0026ab),
+      (0x0026bd, 0x0026be),
+      (0x0026c4, 0x0026c5),
+      (0x0026ce, 0x0026ce),
+      (0x0026d4, 0x0026d4),
+      (0x0026ea, 0x0026ea),
+      (0x0026f2, 0x0026f3),
+      (0x0026f5, 0x0026f5),
+      (0x0026fa, 0x0026fa),
+      (0x0026fd, 0x0026fd),
+      (0x002705, 0x002705),
+      (0x00270a, 0x00270b),
+      (0x002728, 0x002728),
+      (0x00274c, 0x00274c),
+      (0x00274e, 0x00274e),
+      (0x002753, 0x002755),
+      (0x002757, 0x002757),
+      (0x002795, 0x002797),
+      (0x0027b0, 0x0027b0),
+      (0x0027bf, 0x0027bf),
+      (0x002b1b, 0x002b1c),
+      (0x002b50, 0x002b50),
+      (0x002b55, 0x002b55),
+      (0x002e80, 0x002e99),
+      (0x002e9b, 0x002ef3),
+      (0x002f00, 0x002fd5),
+      (0x002ff0, 0x003029),
+      (0x00302e, 0x00303e),
+      (0x003041, 0x003096),
+      (0x00309b, 0x0030ff),
+      (0x003105, 0x00312f),
+      (0x003131, 0x00318e),
+      (0x003190, 0x0031e5),
+      (0x0031ef, 0x00321e),
+      (0x003220, 0x003247),
+      (0x003250, 0x00a48c),
+      (0x00a490, 0x00a4c6),
+      (0x00a960, 0x00a97c),
+      (0x00ac00, 0x00d7a3),
+      (0x00f900, 0x00faff),
+      (0x00fe10, 0x00fe19),
+      (0x00fe30, 0x00fe52),
+      (0x00fe54, 0x00fe66),
+      (0x00fe68, 0x00fe6b),
+      (0x00ff01, 0x00ff60),
+      (0x00ffe0, 0x00ffe6),
+      (0x016fe0, 0x016fe3),
+      (0x016ff0, 0x016ff6),
+      (0x017000, 0x018cd5),
+      (0x018cff, 0x018d1e),
+      (0x018d80, 0x018df2),
+      (0x01aff0, 0x01aff3),
+      (0x01aff5, 0x01affb),
+      (0x01affd, 0x01affe),
+      (0x01b000, 0x01b122),
+      (0x01b132, 0x01b132),
+      (0x01b150, 0x01b152),
+      (0x01b155, 0x01b155),
+      (0x01b164, 0x01b167),
+      (0x01b170, 0x01b2fb),
+      (0x01d300, 0x01d356),
+      (0x01d360, 0x01d376),
+      (0x01f004, 0x01f004),
+      (0x01f0cf, 0x01f0cf),
+      (0x01f18e, 0x01f18e),
+      (0x01f191, 0x01f19a),
+      (0x01f200, 0x01f202),
+      (0x01f210, 0x01f23b),
+      (0x01f240, 0x01f248),
+      (0x01f250, 0x01f251),
+      (0x01f260, 0x01f265),
+      (0x01f300, 0x01f320),
+      (0x01f32d, 0x01f335),
+      (0x01f337, 0x01f37c),
+      (0x01f37e, 0x01f393),
+      (0x01f3a0, 0x01f3ca),
+      (0x01f3cf, 0x01f3d3),
+      (0x01f3e0, 0x01f3f0),
+      (0x01f3f4, 0x01f3f4),
+      (0x01f3f8, 0x01f43e),
+      (0x01f440, 0x01f440),
+      (0x01f442, 0x01f4fc),
+      (0x01f4ff, 0x01f53d),
+      (0x01f54b, 0x01f54e),
+      (0x01f550, 0x01f567),
+      (0x01f57a, 0x01f57a),
+      (0x01f595, 0x01f596),
+      (0x01f5a4, 0x01f5a4),
+      (0x01f5fb, 0x01f64f),
+      (0x01f680, 0x01f6c5),
+      (0x01f6cc, 0x01f6cc),
+      (0x01f6d0, 0x01f6d2),
+      (0x01f6d5, 0x01f6d8),
+      (0x01f6dc, 0x01f6df),
+      (0x01f6eb, 0x01f6ec),
+      (0x01f6f4, 0x01f6fc),
+      (0x01f7e0, 0x01f7eb),
+      (0x01f7f0, 0x01f7f0),
+      (0x01f90c, 0x01f93a),
+      (0x01f93c, 0x01f945),
+      (0x01f947, 0x01f9ff),
+      (0x01fa70, 0x01fa7c),
+      (0x01fa80, 0x01fa8a),
+      (0x01fa8e, 0x01fac6),
+      (0x01fac8, 0x01fac8),
+      (0x01facd, 0x01fadc),
+      (0x01fadf, 0x01faea),
+      (0x01faef, 0x01faf8),
+      (0x020000, 0x02fffd),
+      (0x030000, 0x03fffd)
+    ]
+{-# NOINLINE wideCharRanges #-}
+
+-- | Ranges of characters that take up no space at all: control
+-- characters, non-spacing and enclosing marks, formatting characters,
+-- and conjoining Hangul jamo of the medial and final kinds.
+zeroWidthCharRanges :: Array Int (Int, Int)
+zeroWidthCharRanges =
+  listArray
+    (0, 378)
+    [ (0x000000, 0x00001f),
+      (0x00007f, 0x00009f),
+      (0x0000ad, 0x0000ad),
+      (0x000300, 0x00036f),
+      (0x000483, 0x000489),
+      (0x000591, 0x0005bd),
+      (0x0005bf, 0x0005bf),
+      (0x0005c1, 0x0005c2),
+      (0x0005c4, 0x0005c5),
+      (0x0005c7, 0x0005c7),
+      (0x000600, 0x000605),
+      (0x000610, 0x00061a),
+      (0x00061c, 0x00061c),
+      (0x00064b, 0x00065f),
+      (0x000670, 0x000670),
+      (0x0006d6, 0x0006dd),
+      (0x0006df, 0x0006e4),
+      (0x0006e7, 0x0006e8),
+      (0x0006ea, 0x0006ed),
+      (0x00070f, 0x00070f),
+      (0x000711, 0x000711),
+      (0x000730, 0x00074a),
+      (0x0007a6, 0x0007b0),
+      (0x0007eb, 0x0007f3),
+      (0x0007fd, 0x0007fd),
+      (0x000816, 0x000819),
+      (0x00081b, 0x000823),
+      (0x000825, 0x000827),
+      (0x000829, 0x00082d),
+      (0x000859, 0x00085b),
+      (0x000890, 0x000891),
+      (0x000897, 0x00089f),
+      (0x0008ca, 0x000902),
+      (0x00093a, 0x00093a),
+      (0x00093c, 0x00093c),
+      (0x000941, 0x000948),
+      (0x00094d, 0x00094d),
+      (0x000951, 0x000957),
+      (0x000962, 0x000963),
+      (0x000981, 0x000981),
+      (0x0009bc, 0x0009bc),
+      (0x0009c1, 0x0009c4),
+      (0x0009cd, 0x0009cd),
+      (0x0009e2, 0x0009e3),
+      (0x0009fe, 0x0009fe),
+      (0x000a01, 0x000a02),
+      (0x000a3c, 0x000a3c),
+      (0x000a41, 0x000a42),
+      (0x000a47, 0x000a48),
+      (0x000a4b, 0x000a4d),
+      (0x000a51, 0x000a51),
+      (0x000a70, 0x000a71),
+      (0x000a75, 0x000a75),
+      (0x000a81, 0x000a82),
+      (0x000abc, 0x000abc),
+      (0x000ac1, 0x000ac5),
+      (0x000ac7, 0x000ac8),
+      (0x000acd, 0x000acd),
+      (0x000ae2, 0x000ae3),
+      (0x000afa, 0x000aff),
+      (0x000b01, 0x000b01),
+      (0x000b3c, 0x000b3c),
+      (0x000b3f, 0x000b3f),
+      (0x000b41, 0x000b44),
+      (0x000b4d, 0x000b4d),
+      (0x000b55, 0x000b56),
+      (0x000b62, 0x000b63),
+      (0x000b82, 0x000b82),
+      (0x000bc0, 0x000bc0),
+      (0x000bcd, 0x000bcd),
+      (0x000c00, 0x000c00),
+      (0x000c04, 0x000c04),
+      (0x000c3c, 0x000c3c),
+      (0x000c3e, 0x000c40),
+      (0x000c46, 0x000c48),
+      (0x000c4a, 0x000c4d),
+      (0x000c55, 0x000c56),
+      (0x000c62, 0x000c63),
+      (0x000c81, 0x000c81),
+      (0x000cbc, 0x000cbc),
+      (0x000cbf, 0x000cbf),
+      (0x000cc6, 0x000cc6),
+      (0x000ccc, 0x000ccd),
+      (0x000ce2, 0x000ce3),
+      (0x000d00, 0x000d01),
+      (0x000d3b, 0x000d3c),
+      (0x000d41, 0x000d44),
+      (0x000d4d, 0x000d4d),
+      (0x000d62, 0x000d63),
+      (0x000d81, 0x000d81),
+      (0x000dca, 0x000dca),
+      (0x000dd2, 0x000dd4),
+      (0x000dd6, 0x000dd6),
+      (0x000e31, 0x000e31),
+      (0x000e34, 0x000e3a),
+      (0x000e47, 0x000e4e),
+      (0x000eb1, 0x000eb1),
+      (0x000eb4, 0x000ebc),
+      (0x000ec8, 0x000ece),
+      (0x000f18, 0x000f19),
+      (0x000f35, 0x000f35),
+      (0x000f37, 0x000f37),
+      (0x000f39, 0x000f39),
+      (0x000f71, 0x000f7e),
+      (0x000f80, 0x000f84),
+      (0x000f86, 0x000f87),
+      (0x000f8d, 0x000f97),
+      (0x000f99, 0x000fbc),
+      (0x000fc6, 0x000fc6),
+      (0x00102d, 0x001030),
+      (0x001032, 0x001037),
+      (0x001039, 0x00103a),
+      (0x00103d, 0x00103e),
+      (0x001058, 0x001059),
+      (0x00105e, 0x001060),
+      (0x001071, 0x001074),
+      (0x001082, 0x001082),
+      (0x001085, 0x001086),
+      (0x00108d, 0x00108d),
+      (0x00109d, 0x00109d),
+      (0x001160, 0x0011ff),
+      (0x00135d, 0x00135f),
+      (0x001712, 0x001714),
+      (0x001732, 0x001733),
+      (0x001752, 0x001753),
+      (0x001772, 0x001773),
+      (0x0017b4, 0x0017b5),
+      (0x0017b7, 0x0017bd),
+      (0x0017c6, 0x0017c6),
+      (0x0017c9, 0x0017d3),
+      (0x0017dd, 0x0017dd),
+      (0x00180b, 0x00180f),
+      (0x001885, 0x001886),
+      (0x0018a9, 0x0018a9),
+      (0x001920, 0x001922),
+      (0x001927, 0x001928),
+      (0x001932, 0x001932),
+      (0x001939, 0x00193b),
+      (0x001a17, 0x001a18),
+      (0x001a1b, 0x001a1b),
+      (0x001a56, 0x001a56),
+      (0x001a58, 0x001a5e),
+      (0x001a60, 0x001a60),
+      (0x001a62, 0x001a62),
+      (0x001a65, 0x001a6c),
+      (0x001a73, 0x001a7c),
+      (0x001a7f, 0x001a7f),
+      (0x001ab0, 0x001add),
+      (0x001ae0, 0x001aeb),
+      (0x001b00, 0x001b03),
+      (0x001b34, 0x001b34),
+      (0x001b36, 0x001b3a),
+      (0x001b3c, 0x001b3c),
+      (0x001b42, 0x001b42),
+      (0x001b6b, 0x001b73),
+      (0x001b80, 0x001b81),
+      (0x001ba2, 0x001ba5),
+      (0x001ba8, 0x001ba9),
+      (0x001bab, 0x001bad),
+      (0x001be6, 0x001be6),
+      (0x001be8, 0x001be9),
+      (0x001bed, 0x001bed),
+      (0x001bef, 0x001bf1),
+      (0x001c2c, 0x001c33),
+      (0x001c36, 0x001c37),
+      (0x001cd0, 0x001cd2),
+      (0x001cd4, 0x001ce0),
+      (0x001ce2, 0x001ce8),
+      (0x001ced, 0x001ced),
+      (0x001cf4, 0x001cf4),
+      (0x001cf8, 0x001cf9),
+      (0x001dc0, 0x001dff),
+      (0x00200b, 0x00200f),
+      (0x00202a, 0x00202e),
+      (0x002060, 0x002064),
+      (0x002066, 0x00206f),
+      (0x0020d0, 0x0020f0),
+      (0x002cef, 0x002cf1),
+      (0x002d7f, 0x002d7f),
+      (0x002de0, 0x002dff),
+      (0x00302a, 0x00302d),
+      (0x003099, 0x00309a),
+      (0x00a66f, 0x00a672),
+      (0x00a674, 0x00a67d),
+      (0x00a69e, 0x00a69f),
+      (0x00a6f0, 0x00a6f1),
+      (0x00a802, 0x00a802),
+      (0x00a806, 0x00a806),
+      (0x00a80b, 0x00a80b),
+      (0x00a825, 0x00a826),
+      (0x00a82c, 0x00a82c),
+      (0x00a8c4, 0x00a8c5),
+      (0x00a8e0, 0x00a8f1),
+      (0x00a8ff, 0x00a8ff),
+      (0x00a926, 0x00a92d),
+      (0x00a947, 0x00a951),
+      (0x00a980, 0x00a982),
+      (0x00a9b3, 0x00a9b3),
+      (0x00a9b6, 0x00a9b9),
+      (0x00a9bc, 0x00a9bd),
+      (0x00a9e5, 0x00a9e5),
+      (0x00aa29, 0x00aa2e),
+      (0x00aa31, 0x00aa32),
+      (0x00aa35, 0x00aa36),
+      (0x00aa43, 0x00aa43),
+      (0x00aa4c, 0x00aa4c),
+      (0x00aa7c, 0x00aa7c),
+      (0x00aab0, 0x00aab0),
+      (0x00aab2, 0x00aab4),
+      (0x00aab7, 0x00aab8),
+      (0x00aabe, 0x00aabf),
+      (0x00aac1, 0x00aac1),
+      (0x00aaec, 0x00aaed),
+      (0x00aaf6, 0x00aaf6),
+      (0x00abe5, 0x00abe5),
+      (0x00abe8, 0x00abe8),
+      (0x00abed, 0x00abed),
+      (0x00fb1e, 0x00fb1e),
+      (0x00fe00, 0x00fe0f),
+      (0x00fe20, 0x00fe2f),
+      (0x00feff, 0x00feff),
+      (0x00fff9, 0x00fffb),
+      (0x0101fd, 0x0101fd),
+      (0x0102e0, 0x0102e0),
+      (0x010376, 0x01037a),
+      (0x010a01, 0x010a03),
+      (0x010a05, 0x010a06),
+      (0x010a0c, 0x010a0f),
+      (0x010a38, 0x010a3a),
+      (0x010a3f, 0x010a3f),
+      (0x010ae5, 0x010ae6),
+      (0x010d24, 0x010d27),
+      (0x010d69, 0x010d6d),
+      (0x010eab, 0x010eac),
+      (0x010efa, 0x010eff),
+      (0x010f46, 0x010f50),
+      (0x010f82, 0x010f85),
+      (0x011001, 0x011001),
+      (0x011038, 0x011046),
+      (0x011070, 0x011070),
+      (0x011073, 0x011074),
+      (0x01107f, 0x011081),
+      (0x0110b3, 0x0110b6),
+      (0x0110b9, 0x0110ba),
+      (0x0110bd, 0x0110bd),
+      (0x0110c2, 0x0110c2),
+      (0x0110cd, 0x0110cd),
+      (0x011100, 0x011102),
+      (0x011127, 0x01112b),
+      (0x01112d, 0x011134),
+      (0x011173, 0x011173),
+      (0x011180, 0x011181),
+      (0x0111b6, 0x0111be),
+      (0x0111c9, 0x0111cc),
+      (0x0111cf, 0x0111cf),
+      (0x01122f, 0x011231),
+      (0x011234, 0x011234),
+      (0x011236, 0x011237),
+      (0x01123e, 0x01123e),
+      (0x011241, 0x011241),
+      (0x0112df, 0x0112df),
+      (0x0112e3, 0x0112ea),
+      (0x011300, 0x011301),
+      (0x01133b, 0x01133c),
+      (0x011340, 0x011340),
+      (0x011366, 0x01136c),
+      (0x011370, 0x011374),
+      (0x0113bb, 0x0113c0),
+      (0x0113ce, 0x0113ce),
+      (0x0113d0, 0x0113d0),
+      (0x0113d2, 0x0113d2),
+      (0x0113e1, 0x0113e2),
+      (0x011438, 0x01143f),
+      (0x011442, 0x011444),
+      (0x011446, 0x011446),
+      (0x01145e, 0x01145e),
+      (0x0114b3, 0x0114b8),
+      (0x0114ba, 0x0114ba),
+      (0x0114bf, 0x0114c0),
+      (0x0114c2, 0x0114c3),
+      (0x0115b2, 0x0115b5),
+      (0x0115bc, 0x0115bd),
+      (0x0115bf, 0x0115c0),
+      (0x0115dc, 0x0115dd),
+      (0x011633, 0x01163a),
+      (0x01163d, 0x01163d),
+      (0x01163f, 0x011640),
+      (0x0116ab, 0x0116ab),
+      (0x0116ad, 0x0116ad),
+      (0x0116b0, 0x0116b5),
+      (0x0116b7, 0x0116b7),
+      (0x01171d, 0x01171d),
+      (0x01171f, 0x01171f),
+      (0x011722, 0x011725),
+      (0x011727, 0x01172b),
+      (0x01182f, 0x011837),
+      (0x011839, 0x01183a),
+      (0x01193b, 0x01193c),
+      (0x01193e, 0x01193e),
+      (0x011943, 0x011943),
+      (0x0119d4, 0x0119d7),
+      (0x0119da, 0x0119db),
+      (0x0119e0, 0x0119e0),
+      (0x011a01, 0x011a0a),
+      (0x011a33, 0x011a38),
+      (0x011a3b, 0x011a3e),
+      (0x011a47, 0x011a47),
+      (0x011a51, 0x011a56),
+      (0x011a59, 0x011a5b),
+      (0x011a8a, 0x011a96),
+      (0x011a98, 0x011a99),
+      (0x011b60, 0x011b60),
+      (0x011b62, 0x011b64),
+      (0x011b66, 0x011b66),
+      (0x011c30, 0x011c36),
+      (0x011c38, 0x011c3d),
+      (0x011c3f, 0x011c3f),
+      (0x011c92, 0x011ca7),
+      (0x011caa, 0x011cb0),
+      (0x011cb2, 0x011cb3),
+      (0x011cb5, 0x011cb6),
+      (0x011d31, 0x011d36),
+      (0x011d3a, 0x011d3a),
+      (0x011d3c, 0x011d3d),
+      (0x011d3f, 0x011d45),
+      (0x011d47, 0x011d47),
+      (0x011d90, 0x011d91),
+      (0x011d95, 0x011d95),
+      (0x011d97, 0x011d97),
+      (0x011ef3, 0x011ef4),
+      (0x011f00, 0x011f01),
+      (0x011f36, 0x011f3a),
+      (0x011f40, 0x011f40),
+      (0x011f42, 0x011f42),
+      (0x011f5a, 0x011f5a),
+      (0x013430, 0x013440),
+      (0x013447, 0x013455),
+      (0x01611e, 0x016129),
+      (0x01612d, 0x01612f),
+      (0x016af0, 0x016af4),
+      (0x016b30, 0x016b36),
+      (0x016f4f, 0x016f4f),
+      (0x016f8f, 0x016f92),
+      (0x016fe4, 0x016fe4),
+      (0x01bc9d, 0x01bc9e),
+      (0x01bca0, 0x01bca3),
+      (0x01cf00, 0x01cf2d),
+      (0x01cf30, 0x01cf46),
+      (0x01d167, 0x01d169),
+      (0x01d173, 0x01d182),
+      (0x01d185, 0x01d18b),
+      (0x01d1aa, 0x01d1ad),
+      (0x01d242, 0x01d244),
+      (0x01da00, 0x01da36),
+      (0x01da3b, 0x01da6c),
+      (0x01da75, 0x01da75),
+      (0x01da84, 0x01da84),
+      (0x01da9b, 0x01da9f),
+      (0x01daa1, 0x01daaf),
+      (0x01e000, 0x01e006),
+      (0x01e008, 0x01e018),
+      (0x01e01b, 0x01e021),
+      (0x01e023, 0x01e024),
+      (0x01e026, 0x01e02a),
+      (0x01e08f, 0x01e08f),
+      (0x01e130, 0x01e136),
+      (0x01e2ae, 0x01e2ae),
+      (0x01e2ec, 0x01e2ef),
+      (0x01e4ec, 0x01e4ef),
+      (0x01e5ee, 0x01e5ef),
+      (0x01e6e3, 0x01e6e3),
+      (0x01e6e6, 0x01e6e6),
+      (0x01e6ee, 0x01e6ef),
+      (0x01e6f5, 0x01e6f5),
+      (0x01e8d0, 0x01e8d6),
+      (0x01e944, 0x01e94a),
+      (0x0e0001, 0x0e0001),
+      (0x0e0020, 0x0e007f),
+      (0x0e0100, 0x0e01ef)
+    ]
+{-# NOINLINE zeroWidthCharRanges #-}
diff --git a/megaparsec.cabal b/megaparsec.cabal
--- a/megaparsec.cabal
+++ b/megaparsec.cabal
@@ -1,6 +1,6 @@
 cabal-version:   2.4
 name:            megaparsec
-version:         9.8.1
+version:         9.8.2
 license:         BSD-2-Clause
 license-file:    LICENSE.md
 maintainer:      Mark Karpov <markkarpov92@gmail.com>
@@ -56,6 +56,7 @@
         Text.Megaparsec.Class
         Text.Megaparsec.Common
         Text.Megaparsec.Lexer
+        Text.Megaparsec.Unicode.Tables
 
     default-language: Haskell2010
     build-depends:
@@ -74,7 +75,7 @@
     if flag(dev)
         ghc-options:
             -Wall -Werror -Wredundant-constraints -Wpartial-fields
-            -Wunused-packages
+            -Wunused-packages -haddock -Winvalid-haddock
 
     else
         ghc-options: -O2 -Wall
@@ -99,7 +100,7 @@
     if flag(dev)
         ghc-options:
             -Wall -Werror -Wredundant-constraints -Wpartial-fields
-            -Wunused-packages
+            -Wunused-packages -haddock -Winvalid-haddock
 
     else
         ghc-options: -O2 -Wall
@@ -121,7 +122,7 @@
     if flag(dev)
         ghc-options:
             -Wall -Werror -Wredundant-constraints -Wpartial-fields
-            -Wunused-packages
+            -Wunused-packages -haddock -Winvalid-haddock
 
     else
         ghc-options: -O2 -Wall