Try explicit end of anchor

Author: rollbear

README.md

@@ -73,7 +73,7 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
 
 # <A name="modifiers"/> Modifiers:
 
-* `strong::affine_point<D>`<A name="affine_point"/> allows instances to be
+* <A name="affine_point"></A>`strong::affine_point<D>` allows instances to be
   subtracted (yielding a `D`) or to add or subtract a `D` to an instance.
   See [Affine Space](https://en.wikipedia.org/wiki/Affine_space). Examples of
   one dimentional affine points are pointer (with `D` being `ptrdiff_t`,) or
@@ -90,7 +90,7 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
   Available in `strong_type//affine_point.hpp`.
 
 
-* `strong::arithmetic`<A name="arithmetic"/> allows addition, subtraction,
+* <A name="arithmetic"></A>`strong::arithmetic` allows addition, subtraction,
   multiplication, division and remainder of instances.
 
   [`std::numeric_limits<T>`](https://en.cppreference.com/w/cpp/types/numeric_limits)
@@ -99,49 +99,49 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
   Available in `strong_type/arithmetic.hpp`.
 
 
-* `strong::bicrementable` <A name="bicrementable"/>. Obviously a made up word
+* <A name="bicrementable"></A>`strong::bicrementable`. Obviously a made up word
   for the occation. Implements both
   [`strong::incrementable`](#incrementable) and
   [`strong::decrementable`](#decrementable).
 
   Available in `strong_type/bicrementable.hpp`
 
 
-* `strong::bitarithmetic` <A name="bitarithmetic"/> allows bitwise `&`, bitwise
+* <A name="bitarithmetic"></A>`strong::bitarithmetic` allows bitwise `&`, bitwise
   `|`, bitwise `^` and shift operations.
 
   Available in `strong_type/bitarithmetic.hpp`.
 
 
-* `strong::boolean` <A name="boolean"/> provides
+* <A name="boolean"></A>`strong::boolean` provides
   `explicit operator bool() const`, providing the
   underlying type supports it.
 
   Available in `strong_type/boolean.hpp`.
 
 
-* `strong::convertible_to<Ts...>` <A name="convertible_to"/> provides an
+* <A name="convertible_to"></A>`strong::convertible_to<Ts...>` provides an
   `explicit operator Ts() const` for each type `Ts`, providing the underlying
   type supports it.
 
   Available in `strong_type/convertible_to.hpp`.
 
 
-* `strong::decrementable` <A name="decrementable"/>. Provides
+* <A name="decrementable"></A>`strong::decrementable`. Provides
   [`operator--`](https://en.cppreference.com/w/cpp/language/operator_incdec) for
   the strong type, using the operator of the underlying type.
 
   Available in `strong_type/incrementable.hpp`
 
 
-* <A name="default_constructible"/>`strong::default_constructible`. The strong
+* <A name="default_constructible"></A>`strong::default_constructible`. The strong
   type is not default constructible by default. This modifier enables a default
   constructor which uses a default constructor of the underlying type.
 
   Available in `strong_type/type.hpp`
 
 
-* <A name="difference"/>`strong::difference` allows instances to be subtracted
+* <A name="difference"></A>`strong::difference` allows instances to be subtracted
   and added (yielding a `strong::difference`).
 
   Conditionally, if the underlying
@@ -155,21 +155,21 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
   Available in `strong_type/difference.hpp`.
 
 
-* <A name="equality"/>`strong::equality` provides operators `==` and `!=`. The
+* <A name="equality"></A>`strong::equality` provides operators `==` and `!=`. The
   strong type can be compared for equality or inequality.
 
   Available in `strong_type/equality.hpp`.
 
 
-* <A name="equality_with"/>`strong::equality_with<Ts...>` provides operators
+* <A name="equality_with"></A>`strong::equality_with<Ts...>` provides operators
   `==` and `!=` between the  strong type and each of the types `Ts...`.
   Note! While `Ts` can include other strong types, it can not refer to the
   strong type being defined. Use [`strong::equality`](#equality) for that.
 
   Available in `strong_type/equality_with.hpp`.
 
 
-* <A name="formattable"/>`strong::formattable` adds `std::format` and/or
+* <A name="formattable"></A>`strong::formattable` adds `std::format` and/or
   [`fmt::format`](https://fmt.dev/latest/index.html) capability, based on
   availability of the formatting library. This can further be controlled
   (globally) with the defines `STRONG_HAS_STD_FORMAT` respectively
@@ -182,57 +182,57 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
   Available in `strong_type/formattable.hpp`.
 
 
-* <A name="hashable"/>`strong::hashable` allows `std::hash<>` on the type
+* <A name="hashable"></A>`strong::hashable` allows `std::hash<>` on the type
   (forwards to the underlying type,) to allow use in `std::unordered_set<>` and
   `std::unordered_map<>`.
 
   Available in `strong_type/hashable.hpp`.
 
 
-* <A name="implicitly_convertible_to"/>`strong::implicitly_convertible_to<Ts...>`
+* <A name="implicitly_convertible_to"></A>`strong::implicitly_convertible_to<Ts...>`
   provides an `operator Ts() const` for each type `Ts`, providing the underlying
   type supports it.
 
   Available in `strong_type/implicitly_convertible_to.hpp`.
 
 
-* <A name="incrementable"/>`strong::incrementable`. Provides
+* <A name="incrementable"></A>`strong::incrementable`. Provides
   [`operator++`](https://en.cppreference.com/w/cpp/language/operator_incdec) for
   the strong type, using the operator of the underlying type.
 
   Available in `strong_type/incrementable.hpp`
 
 
-* <A name="indexed"/>`strong::indexed<D>` allows use of the subscript operator[]
+* <A name="indexed"></A>`strong::indexed<D>` allows use of the subscript operator[]
   on type `D`. This also allows member function `at(D)`, providing the
   underlying type supports it. A lame version `indexed<>` allows subscript on
   any type that works.
 
   Available in `strong_type/indexed.hpp`.
 
 
-* <A name="invocable"/>`strong::invocable` provides `operator()` for
+* <A name="invocable"></A>`strong::invocable` provides `operator()` for
   the strong type, using the operator of the underlying type.
 
   Available in `strong_type/invocable.hpp`
 
 
-* <A name="iostreamable"/>`strong::iostreamable`. Both
+* <A name="iostreamable"></A>`strong::iostreamable`. Both
   [`strong::istreamable`](#istreamable) and
   [`strong::ostreamable`](#ostreamable).
 
   Available in `strong_type/iostreamable.hpp`
 
 
-* <A name="istreamable"/>`strong::istreamable`. Provides the default
+* <A name="istreamable"></A>`strong::istreamable`. Provides the default
   [`istream`](https://en.cppreference.com/w/cpp/io/basic_istream) extraction
   `operator>>` for the strong type, as handled by the underfying type. Provide
   your own operator istead if you prefer a custom istream extraction operator.
 
   Available in `strong_type/istreamable.hpp`
 
 
-* <A name="iterator"/>`strong::iterator` adds functionality needed depending on
+* <A name="iterator"></A>`strong::iterator` adds functionality needed depending on
   iterator category. If the iterator type is a `random_access_iterator`,
   the strong type is [`strong::indexed<>`](#indexed) and
   [`strong::affine_point<difference>`](#affine_point). It should be
@@ -245,7 +245,7 @@ define the macro `STRONG_TYPE_IMPORT_STD_LIBRARY=1`.
   Available in `strong_type/iterator.hpp`
 
 
-* <A name="ordered"/>`strong::ordered` provides operators `<`, `<=`, `>=` and
+* <A name="ordered"></A>`strong::ordered` provides operators `<`, `<=`, `>=` and
   `>`. The strong type offers the same ordering relation as the underlying type.
 
   Available in `strong_type/ordered.hpp`