app.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="Author" content="Laurent LYAUDET">
  <meta name="Publisher" content="Laurent LYAUDET">
  <meta name="Description"
    content="Dev tool to generate a regular expression matching a range of decimal numbers">
  <meta name="Keywords"
    content="RegExp, regular expression, generator, decimal number, min, max, step">
  <title>DecimalsRangeRegexpGenerator</title>
  <style>
    table.transitions {
      border: solid 2px;
      border-collapse: collapse;
    }
    table.transitions td, table.transitions th{
      border: solid 2px;
    }
  </style>
</head>
<body>
  <!--
  This file is part of DecimalsRangeRegexpGenerator.

  DecimalsRangeRegexpGenerator is free software:
  you can redistribute it and/or modify it
  under the terms of the GNU Affero General Public License
  as published by the Free Software Foundation,
  either version 3 of the License,
  or (at your option) any later version.

  DecimalsRangeRegexpGenerator is distributed in the hope
  that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Affero General Public License for more details.

  You should have received a copy of the
  GNU Affero General Public License
  along with DecimalsRangeRegexpGenerator.
  If not, see <https://www.gnu.org/licenses/>

  ©Copyright 2022 Laurent Lyaudet
  -->
  <h1>DecimalsRangeRegexpGenerator</h1>

  <form>
    <h4>Main parameters</h4>
    <h5 id="title_achievement_unlocked">
      They impact the decimal numbers that can be written.
    </h5>
    <p id="is_a_number_regexp"></p>
    <div>
      <label for="min">
        Min (optional):
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="(-|\+)?\d+(\.\d+)?"
        title="This input has the following pattern: (-|\+)?\d+(\.\d+)?"
        id="min"
        name="min"
      >
      <p id="equals_min"></p>
      <p id="more_than_min"></p>
      <p id="at_least_min"></p>
    </div>
    <div>
      <label for="is_min_excluded">Min excluded: </label>
      <input
        type="checkbox"
        value="1"
        id="is_min_excluded"
        name="is_min_excluded"
      >
    </div>
    <div>
      <label for="max">
        Max (optional):
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="(-|\+)?\d+(\.\d+)?"
        title="This input has the following pattern: (-|\+)?\d+(\.\d+)?"
        id="max"
        name="max"
      >
      <p id="equals_max"></p>
      <p id="less_than_max"></p>
      <p id="at_most_max"></p>
    </div>
    <div>
      <label for="is_max_excluded">Max excluded: </label>
      <input
        type="checkbox"
        value="1"
        id="is_max_excluded"
        name="is_max_excluded"
      >
    </div>
    <div>
      <label for="step">
        Step
        (optional, it will default to arbitrary precision and not 1):
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="\d+(\.\d+)?"
        title="This input has the following pattern: \d+(\.\d+)?"
        id="step"
        name="step"
      >
      <p>
        <span style="color: forestgreen">
          Efficient for a step that is
          a power of your base (default: 10).
        </span>
        <span style="color: crimson">
          Otherwise experimental,
          since the general algorithm I use
          generates regular expressions
          that becomes too big most of the time.
          Try 111 = 7 in base 01, or 5 or 0.5 in base 0123456789
          for an example
          where it works without being excessively long.
          Try 0.25 in base 0123456789 for an example
          where the current algorithm is too dumb to compute
          a short regular expression.
        </span>
      </p>
    </div>

    <hr>

    <h4>More optional parameters</h4>
    <h5>
      They impact the formatting of the decimal numbers
      that can be written.
    </h5>
    <div>
      <label for="allow_leading_zeros">
        Allow leading zeros:
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_leading_zeros"
        name="allow_leading_zeros"
      >
    </div>
    <div>
      <label for="allow_trailing_zeros">
        Allow trailing zeros:
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_trailing_zeros"
        name="allow_trailing_zeros"
      >
    </div>
    <div>
      <label for="min_number_of_digits_before_decimal_separator">
        Min number of digits before decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_digits_before_decimal_separator"
        name="min_number_of_digits_before_decimal_separator"
      >
    </div>
    <div>
      <label for="max_number_of_digits_before_decimal_separator">
        Max number of digits before decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_digits_before_decimal_separator"
        name="max_number_of_digits_before_decimal_separator"
      >
    </div>
    <div>
      <label for="min_number_of_digits_after_decimal_separator">
        Min number of digits after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_digits_after_decimal_separator"
        name="min_number_of_digits_after_decimal_separator"
      >
    </div>
    <div>
      <label for="max_number_of_digits_after_decimal_separator">
        Max number of digits after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_digits_after_decimal_separator"
        name="max_number_of_digits_after_decimal_separator"
      >
    </div>
    <div>
      <label
        for="min_number_of_digits_after_decimal_separator_or_no"
      >
        Do not apply min number of digits after decimal part
        if there is no decimal part:
      </label>
      <input
        type="checkbox"
        value="1"
        id="min_number_of_digits_after_decimal_separator_or_no"
        name="min_number_of_digits_after_decimal_separator_or_no"
      >
    </div>
    <div>
      <label for="min_number_of_digits">
        Min number of digits before or after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_digits"
        name="min_number_of_digits"
      >
    </div>
    <div>
      <label for="max_number_of_digits">
        Max number of digits before or after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_digits"
        name="max_number_of_digits"
      >
    </div>
    <div>
      <label for="allow_zero_with_minus">
        Allow zero to be written with a minus sign:
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_zero_with_minus"
        name="allow_zero_with_minus"
      >
    </div>
    <div>
      <label for="allow_zero_with_plus">
        Allow zero to be written with a plus sign:
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_zero_with_plus"
        name="allow_zero_with_plus"
      >
    </div>
    <div>
      <label for="allow_positive_number_with_plus">
        Allow numbers above zero to be written with a plus sign:
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_positive_number_with_plus"
        name="allow_positive_number_with_plus"
      >
    </div>
    <h5>
      Here you can break out of base ten,
      and use any encoding of numbers using positional notation
      with fixed base.
    </h5>
    <p>
      I like "creeping featurism".
      Without sabotage, it is easy to add as many features
      as you like, for the good of everyone.
      Blaming creeping featurism for high maintenance cost
      is hypocrisy.
    </p>
    <div>
      <label for="digits">
        Digits:
      </label>
      <input
        type="text"
        inputmode="text"
        id="digits"
        name="digits"
        onchange="achievement_unlocked()"
      >
      <p>
        A string that defaults to "0123456789";
        you may use "01" (base 2)
        or "0123456789abcdef" (base 16) for example,
        or even "five" for base four ;).
        ("f" would be your zero, "i" your unit, etc.)
      </p>
    </div>
    <div>
      <label for="decimal_separators">
        Decimal separators:
      </label>
      <input
        type="text"
        inputmode="text"
        id="decimal_separators"
        name="decimal_separators"
        onchange="achievement_unlocked()"
      >
      <p>
        A string that defaults to ".";
        you may use "," or ".," for example.
      </p>
    </div>
    <div>
      <label for="plus_signs">
        Plus signs:
      </label>
      <input
        type="text"
        inputmode="text"
        id="plus_signs"
        name="plus_signs"
        onchange="achievement_unlocked()"
      >
      <p>
        A string that defaults to "+";
        you may use "p" for example,
        or "pl" if you would like to use "p" or "l" as you wish.
      </p>
    </div>
    <div>
      <label for="minus_signs">
        Minus signs:
      </label>
      <input
        type="text"
        inputmode="text"
        id="minus_signs"
        name="minus_signs"
        onchange="achievement_unlocked()"
      >
      <p>
        A string that defaults to "-";
        you may use "m" for example,
        or "mn" if you would like to use "m" or "n" as you wish.
      </p>
    </div>

    <h5>
      Spacing
    </h5>
    <div>
      <label for="spaces_before_sign">
        Spaces characters before a sign character:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_before_sign"
        name="spaces_before_sign"
      >
    </div>
    <div>
      <label for="min_number_of_spaces_before_sign">
        Min number of spaces before a sign character:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_before_sign"
        name="min_number_of_spaces_before_sign"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_before_sign">
        Max number of spaces before a sign character:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_before_sign"
        name="max_number_of_spaces_before_sign"
      >
    </div>
    <div>
      <label for="spaces_before_number">
        Spaces characters before a number without sign:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_before_number"
        name="spaces_before_number"
      >
    </div>
    <div>
      <label for="min_number_of_spaces_before_number">
        Min number of spaces before a number without sign:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_before_number"
        name="min_number_of_spaces_before_number"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_before_number">
        Max number of spaces before a number without sign:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_before_number"
        name="max_number_of_spaces_before_number"
      >
    </div>
    <div>
      <label for="spaces_between_sign_and_number">
        Spaces characters between a sign and number:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_between_sign_and_number"
        name="spaces_between_sign_and_number"
      >
      <p>
        You may try exactly one non-breakable space here,
        for example.
      </p>
    </div>
    <div>
      <label for="min_number_of_spaces_between_sign_and_number">
        Min number of spaces between a sign and number:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_between_sign_and_number"
        name="min_number_of_spaces_between_sign_and_number"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_between_sign_and_number">
        Max number of spaces between a sign and number:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_between_sign_and_number"
        name="max_number_of_spaces_between_sign_and_number"
      >
    </div>
    <div>
      <label for="spaces_after_last_digit">
        Spaces characters after_last_digit:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_after_last_digit"
        name="spaces_after_last_digit"
      >
    </div>
    <div>
      <label for="min_number_of_spaces_after_last_digit">
        Min number of spaces after last digit:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_after_last_digit"
        name="min_number_of_spaces_after_last_digit"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_after_last_digit">
        Max number of spaces after last digit:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_after_last_digit"
        name="max_number_of_spaces_after_last_digit"
      >
    </div>
    <div>
      <label for="spaces_inter_digits_before">
        Spaces characters between digits before decimal separator:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_inter_digits_before"
        name="spaces_inter_digits_before"
      >
    </div>
    <div>
      <label for="min_number_of_spaces_inter_digits_before">
        Min number of spaces between digits before decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_inter_digits_before"
        name="min_number_of_spaces_inter_digits_before"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_inter_digits_before">
        Max number of spaces between digits before decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_inter_digits_before"
        name="max_number_of_spaces_inter_digits_before"
      >
    </div>
    <div>
      <label for="spaces_between_digit_and_decimal_separator">
        Spaces characters between digit and decimal separator:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_between_digit_and_decimal_separator"
        name="spaces_between_digit_and_decimal_separator"
      >
    </div>
    <div>
      <label
        for="min_number_of_spaces_between_digit_and_decimal_separator"
      >
        Min number of spaces between digit and decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_between_digit_and_decimal_separator"
        name="min_number_of_spaces_between_digit_and_decimal_separator"
      >
    </div>
    <div>
      <label
        for="max_number_of_spaces_between_digit_and_decimal_separator"
      >
        Max number of spaces between digit and decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_between_digit_and_decimal_separator"
        name="max_number_of_spaces_between_digit_and_decimal_separator"
      >
    </div>
    <div>
      <label for="spaces_between_decimal_separator_and_digit">
        Spaces characters between decimal separator and digit:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_between_decimal_separator_and_digit"
        name="spaces_between_decimal_separator_and_digit"
      >
    </div>
    <div>
      <label
        for="min_number_of_spaces_between_decimal_separator_and_digit"
      >
        Min number of spaces between decimal separator and digit:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_between_decimal_separator_and_digit"
        name="min_number_of_spaces_between_decimal_separator_and_digit"
      >
    </div>
    <div>
      <label
        for="max_number_of_spaces_between_decimal_separator_and_digit"
      >
        Max number of spaces between decimal separator and digit:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_between_decimal_separator_and_digit"
        name="max_number_of_spaces_between_decimal_separator_and_digit"
      >
    </div>
    <div>
      <label for="spaces_inter_digits_after">
        Spaces characters between digits after decimal separator:
      </label>
      <input
        type="text"
        inputmode="text"
        id="spaces_inter_digits_after"
        name="spaces_inter_digits_after"
      >
    </div>
    <div>
      <label for="min_number_of_spaces_inter_digits_after">
        Min number of spaces between digits after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="min_number_of_spaces_inter_digits_after"
        name="min_number_of_spaces_inter_digits_after"
      >
    </div>
    <div>
      <label for="max_number_of_spaces_inter_digits_after">
        Max number of spaces between digits after decimal separator:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="0|[1-9]\d*"
        title="This input has the following pattern: 0|[1-9]\d*"
        id="max_number_of_spaces_inter_digits_after"
        name="max_number_of_spaces_inter_digits_after"
      >
    </div>
    <div>
      <label for="min_number_of_contiguous_digits">
        Min number of contiguous digits:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="[1-9]\d*"
        title="This input has the following pattern: [1-9]\d*"
        id="min_number_of_contiguous_digits"
        name="min_number_of_contiguous_digits"
      >
    </div>
    <div>
      <label for="max_number_of_contiguous_digits">
        Max number of contiguous digits:
      </label>
      <input
        type="text"
        inputmode="numeric"
        pattern="[1-9]\d*"
        title="This input has the following pattern: [1-9]\d*"
        id="max_number_of_contiguous_digits"
        name="max_number_of_contiguous_digits"
      >
      <p>
        With both min and max at 3,
        you can have spacing like thousands separators.
      </p>
    </div>

    <h5>
      More strange things
    </h5>
    <div>
      <label for="regexp_enclosing_start">
        Enclose groups in regular expression with:
      </label>
      <select
        id="regexp_enclosing_start"
        name="regexp_enclosing_start"
      >
        <option value="(">"(" for simple capturing group (shorter regular expression)</option>
        <option value="(?:">"(?:" for non-capturing group (faster and use less memory)</option>
      </select>
      <p>
        The generated regular expressions sometimes need to use groups,
        that are not positive or negative look-ahead or look-behind.
        It is used either for alternatives or repetitions.
        In that case, one may freely choose to use simple capturing group
        or non-capturing group.
      </p>
    </div>
    <div>
      <label for="allow_leading_decimal_separator">
        <span style="text-decoration-line: line-through;">
          Allow leading decimal separator (without any digit before):
        </span>
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_leading_decimal_separator"
        name="allow_leading_decimal_separator"
        disabled
      >
      <p>
        You do not need it,
        you can use "Min number of digits before decimal separator"
        = 0
        or empty and a max is given.
        Note that when no min and no max are given, it defaults to
        "+" or "{1,}"
        that disallow leading decimal separator.
        Because "+" is the most sensible choice for most use cases.
      </p>
    </div>
    <div>
      <label for="allow_trailing_decimal_separator">
        <span style="text-decoration-line: line-through;">
          Allow trailing decimal separator (without any digit after):
        </span>
      </label>
      <input
        type="checkbox"
        value="1"
        id="allow_trailing_decimal_separator"
        name="allow_trailing_decimal_separator"
        disabled
      >
      <p>
        You do not need it,
        you can use "Min number of digits after decimal separator"
        = 0
        or empty and a max is given.
        Note that when no min and no max are given, it defaults to
        "+" or "{1,}"
        that disallow trailing decimal separator.
        Because "+" is the most sensible choice for most use cases.
        If you want to make sure that no trailing decimal separator
        is allowed,
        while specifying a max number of digits after decimal
        use "Min number of digits after decimal separator" = 1
        with or without
        "Do not apply min number of digits after decimal part
        if there is no decimal part".
      </p>
    </div>

    <hr>

    <button type="submit">Generate</button>
  </form>

  <hr>
  <h4>Error message</h4>
  <div id="error" style="color: red;"></div>

  <hr>
  <h4>Result</h4>
  <div>
    <textarea
      id="result"
      style="width: 100%; box-sizing: border-box;"
      onkeyup="result_changed()"
    ></textarea>
  </div>

  <hr>
  <h4 id="test_your_result">Test your result</h4>
  <form action="javascript:test_validated()">
    <label for="test_string">
      Test string:
    </label>
    <div>
      <input
        type="text"
        inputmode="text"
        id="test_string"
        name="test_string"
        onkeyup="reinit_test_your_result()"
      >
    </div>
    <button
      id="submit_test"
      type="submit"
      style="display: none;"
    >Test</button>
    <p>
      Note that an empty string will always validate.
      If you want to exclude an empty string,
      you have to add "required" as an attribute to your HTML input.
    </p>
  </form>

  <hr>
  <h4>Detail of step calculus</h4>
  <div id="step_calculus">
  </div>

  <br>
  <br>
  <hr>

  ©Copyright 2022 Laurent Lyaudet
  <br>
  GNU AGPL : this HTML file you're currently viewing
  must contain all the source code,
  other files of the repository should be <a href=".">here</a>,
  or on GitHub
  <a href="https://github.com/LLyaudet/DecimalsRangeRegexpGenerator">
    here
  </a>.

  <script>
    "use strict";


    // This code is from StackOverflow.
    // https://stackoverflow.com/a/9251169/5796086
    // I can not believe that there is still no HTML.escape()
    // and HTML.unescape() functions in JS standard in 2022.
    // Seriously !
    let escape = document.createElement('textarea');
    function escapeHTML(html) {
        escape.textContent = html;
        return escape.innerHTML;
    }

    function unescapeHTML(html) {
        escape.innerHTML = html;
        return escape.textContent;
    }


    function achievement_unlocked(){
      let title_achievement_unlocked_element = (
        document.getElementById("title_achievement_unlocked")
      );
      title_achievement_unlocked_element.innerHTML = (
        "<span style=\"color: steelblue\">"
        + "They impact the"
        + " <span style=\"text-decoration-line: line-through;\">"
        + "decimal</span> (achievement unlocked)"
        + " numbers that can be written."
        + "</span>"
      );
      let minElement = document.getElementById("min");
      let maxElement = document.getElementById("max");
      let stepElement = document.getElementById("step");
      minElement.inputMode = "text";
      minElement.removeAttribute("pattern");
      minElement.title = "This input has no pattern.";
      maxElement.inputMode = "text";
      maxElement.removeAttribute("pattern");
      maxElement.title = "This input has no pattern.";
      stepElement.inputMode = "text";
      stepElement.removeAttribute("pattern");
      stepElement.title = "This input has no pattern.";
    }


    function test_validated(){
      document.getElementById("test_your_result").innerHTML = (
        "<span style=\"color: forestgreen\">"
        + "Test your result: Congratulations it works !"
        + "</span>"
      );
    }


    function reinit_test_your_result(){
      document.getElementById("test_your_result").innerHTML = (
        "<span style=\"color: crimson\">"
        + "Test your result:"
        + " Congratulations it does not validate your string !"
        + " It may have been your goal anyway :)"
        + "</span>"
      );
      document.getElementById("submit_test").click();
    }


    function result_changed(){
      let result_regexp = (
        document.getElementById("result").value
      );
      let test_string_element = (
        document.getElementById("test_string")
      );
      test_string_element.pattern = result_regexp;
      test_string_element.title = (
        "This input has the following pattern: "
        + result_regexp
      );
      reinit_test_your_result();
      document.getElementById("result").focus();
    }


    const url_search_params = new URLSearchParams(
      window.location.search
    );
    let parameters = {
      min: "",
      is_min_excluded: false,
      max: "",
      is_max_excluded: false,
      step: "",
      allow_leading_zeros: false,
      allow_trailing_zeros: false,
      min_number_of_digits_before_decimal_separator: null,
      max_number_of_digits_before_decimal_separator: null,
      min_number_of_digits_after_decimal_separator: null,
      max_number_of_digits_after_decimal_separator: null,
      min_number_of_digits_after_decimal_separator_or_no: false,
      min_number_of_digits: null,
      max_number_of_digits: null,
      allow_zero_with_minus: false,
      allow_zero_with_plus: false,
      allow_positive_number_with_plus: false,
      digits: "",
      decimal_separators: "",
      plus_signs: "",
      minus_signs: "",
      spaces_before_sign: "",
      min_number_of_spaces_before_sign: null,
      max_number_of_spaces_before_sign: null,
      spaces_before_number: "",
      min_number_of_spaces_before_number: null,
      max_number_of_spaces_before_number: null,
      spaces_between_sign_and_number: "",
      min_number_of_spaces_between_sign_and_number: null,
      max_number_of_spaces_between_sign_and_number: null,
      spaces_after_last_digit: "",
      min_number_of_spaces_after_last_digit: null,
      max_number_of_spaces_after_last_digit: null,
      spaces_inter_digits_before: "",
      min_number_of_spaces_inter_digits_before: null,
      max_number_of_spaces_inter_digits_before: null,
      spaces_between_digit_and_decimal_separator: "",
      min_number_of_spaces_between_digit_and_decimal_separator: null,
      max_number_of_spaces_between_digit_and_decimal_separator: null,
      spaces_between_decimal_separator_and_digit: "",
      min_number_of_spaces_between_decimal_separator_and_digit: null,
      max_number_of_spaces_between_decimal_separator_and_digit: null,
      spaces_inter_digits_after: "",
      min_number_of_spaces_inter_digits_after: null,
      max_number_of_spaces_inter_digits_after: null,
      min_number_of_contiguous_digits: null,
      max_number_of_contiguous_digits: null,
      regexp_enclosing_start: "",
    };
    let error_message = "";


    function set_text_parameter_in_form(parameter_name){
      if(
        url_search_params.get(parameter_name) !== undefined
        && url_search_params.get(parameter_name) !== null
      ){
        document.getElementById(parameter_name).value = (
          url_search_params.get(parameter_name)
        );
        parameters[parameter_name] = (
          url_search_params.get(parameter_name)
        );
      }
    }


    function set_checkbox_parameter_in_form(parameter_name){
      if(url_search_params.get(parameter_name) === "1"){
        document.getElementById(parameter_name).checked = true;
        parameters[parameter_name] = true;
      }
    }


    function set_positive_integer_parameter_in_form(parameter_name){
      if(
        url_search_params.get(parameter_name) !== undefined
        && url_search_params.get(parameter_name) !== null
      ){
        document.getElementById(parameter_name).value = (
          url_search_params.get(parameter_name)
        );
        if(url_search_params.get(parameter_name) === ""){
          parameters[parameter_name] = null;
        }
        else{
          if(
            url_search_params.get(parameter_name)
            === Math.abs(
              parseInt(url_search_params.get(parameter_name))
            ).toString()
          ){
            parameters[parameter_name] = parseInt(
              url_search_params.get(parameter_name)
            );
          }
          else{
            error_message += (
              "Value \""
              + escapeHTML(url_search_params.get(parameter_name))
              + "\""
              + " for " + parameter_name
              + " is incorrect (probably too big).\n"
              + "<br>\n"
            );
          }
        }
      }
    }


    set_text_parameter_in_form("min");
    set_checkbox_parameter_in_form("is_min_excluded");
    set_text_parameter_in_form("max");
    set_checkbox_parameter_in_form("is_max_excluded");
    set_text_parameter_in_form("step");
    set_checkbox_parameter_in_form("allow_leading_zeros");
    set_checkbox_parameter_in_form("allow_trailing_zeros");
    set_positive_integer_parameter_in_form(
      "min_number_of_digits_before_decimal_separator"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_digits_before_decimal_separator"
    );
    set_positive_integer_parameter_in_form(
      "min_number_of_digits_after_decimal_separator"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_digits_after_decimal_separator"
    );
    set_checkbox_parameter_in_form(
      "min_number_of_digits_after_decimal_separator_or_no"
    );
    set_positive_integer_parameter_in_form("min_number_of_digits");
    set_positive_integer_parameter_in_form("max_number_of_digits");
    set_checkbox_parameter_in_form("allow_zero_with_minus");
    set_checkbox_parameter_in_form("allow_zero_with_plus");
    set_checkbox_parameter_in_form(
      "allow_positive_number_with_plus"
    );
    set_text_parameter_in_form("digits");
    set_text_parameter_in_form("decimal_separators");
    set_text_parameter_in_form("plus_signs");
    set_text_parameter_in_form("minus_signs");
    set_text_parameter_in_form("spaces_before_sign");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_before_sign"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_before_sign"
    );
    set_text_parameter_in_form("spaces_before_number");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_before_number"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_before_number"
    );
    set_text_parameter_in_form("spaces_between_sign_and_number");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_between_sign_and_number"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_between_sign_and_number"
    );
    set_text_parameter_in_form("spaces_after_last_digit");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_after_last_digit"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_after_last_digit"
    );
    set_text_parameter_in_form("spaces_inter_digits_before");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_inter_digits_before"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_inter_digits_before"
    );
    set_text_parameter_in_form(
      "spaces_between_digit_and_decimal_separator"
    );
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_between_digit_and_decimal_separator"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_between_digit_and_decimal_separator"
    );
    set_text_parameter_in_form(
      "spaces_between_decimal_separator_and_digit"
    );
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_between_decimal_separator_and_digit"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_between_decimal_separator_and_digit"
    );
    set_text_parameter_in_form("spaces_inter_digits_after");
    set_positive_integer_parameter_in_form(
      "min_number_of_spaces_inter_digits_after"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_spaces_inter_digits_after"
    );
    set_positive_integer_parameter_in_form(
      "min_number_of_contiguous_digits"
    );
    set_positive_integer_parameter_in_form(
      "max_number_of_contiguous_digits"
    );

    if(
      url_search_params.get("regexp_enclosing_start") === undefined
      || url_search_params.get("regexp_enclosing_start") === null
    ){
      parameters.regexp_enclosing_start = "(";
    }
    else{
      if(
        url_search_params.get("regexp_enclosing_start") === "("
        || url_search_params.get("regexp_enclosing_start") === "(?:"
      ){
        document.getElementById("regexp_enclosing_start").value = (
          url_search_params.get("regexp_enclosing_start")
        );
        parameters.regexp_enclosing_start = (
          url_search_params.get("regexp_enclosing_start")
        );
      }
      else{
        error_message += (
          "Value \""
          + escapeHTML(url_search_params.get("regexp_enclosing_start"))
          + "\""
          + " for regexp_enclosing_start"
          + " is incorrect.\n"
          + "<br>\n"
        );
      }
    }

    let number_of_defaults = 0;
    if(parameters.digits === ""){
      parameters.digits = "0123456789";
      ++number_of_defaults;
    }
    if(parameters.decimal_separators === ""){
      parameters.decimal_separators = ".";
      ++number_of_defaults;
    }
    if(parameters.plus_signs === ""){
      parameters.plus_signs = "+";
      ++number_of_defaults;
    }
    if(parameters.minus_signs === ""){
      parameters.minus_signs = "-";
      ++number_of_defaults;
    }
    if(number_of_defaults < 4){
      achievement_unlocked();
    }


    function explode_and_check_unicity(
      parameter_name,
      some_error_message,
    ){
      let some_array = Array.from(parameters[parameter_name]);
      let unique_array = [... new Set(some_array)];
      if(some_array.length !== unique_array.length){
        error_message += some_error_message + "\n<br>\n";
      }
      parameters[parameter_name] = unique_array;
    }


    explode_and_check_unicity("digits", "You have repeated digits.");
    explode_and_check_unicity(
      "decimal_separators",
      "You have repeated decimal separators.",
    );
    explode_and_check_unicity(
      "plus_signs",
      "You have repeated plus signs.",
    );
    explode_and_check_unicity(
      "minus_signs",
      "You have repeated minus signs.",
    );
    explode_and_check_unicity(
      "spaces_before_sign",
      "You have repeated spaces characters"
      + " (spaces before sign).",
    );
    explode_and_check_unicity(
      "spaces_before_number",
      "You have repeated spaces characters"
      + " (spaces before number without sign).",
    );
    explode_and_check_unicity(
      "spaces_between_sign_and_number",
      "You have repeated spaces characters"
      + " (spaces between sign and number).",
    );
    explode_and_check_unicity(
      "spaces_after_last_digit",
      "You have repeated spaces characters"
      + " (spaces after last digit).",
    );
    explode_and_check_unicity(
      "spaces_inter_digits_before",
      "You have repeated spaces characters"
      + " (spaces inter digits before decimal separator).",
    );
    explode_and_check_unicity(
      "spaces_between_digit_and_decimal_separator",
      "You have repeated spaces characters"
      + " (spaces between digit and decimal separator).",
    );
    explode_and_check_unicity(
      "spaces_between_decimal_separator_and_digit",
      "You have repeated spaces characters"
      + " (spaces between decimal separator and digit).",
    );
    explode_and_check_unicity(
      "spaces_inter_digits_after",
      "You have repeated spaces characters"
      + " (spaces inter digits after decimal separator).",
    );

    if(parameters.digits.length < 2){
      error_message += (
        "You need at least two digits for positional notation.\n"
        + "<br>\n"
      );
    }
    for(let decimal_separator of parameters.decimal_separators){
      if(parameters.digits.includes(decimal_separator)){
        error_message += (
          "You gave a decimal separator that is a digit"
          + " (\"" + escapeHTML(decimal_separator) + "\").\n"
          + "<br>\n"
        );
      }
    }
    for(let plus_sign of parameters.plus_signs){
      if(parameters.digits.includes(plus_sign)){
        error_message += (
          "You gave a plus sign that is a digit"
          + " (\"" + escapeHTML(plus_sign) + "\").\n"
          + "<br>\n"
        );
      }
      if(parameters.decimal_separators.includes(plus_sign)){
        error_message += (
          "You gave a plus sign that is a decimal separator"
          + " (\"" + escapeHTML(plus_sign) + "\").\n"
          + "<br>\n"
        );
      }
    }
    for(let minus_sign of parameters.minus_signs){
      if(parameters.digits.includes(minus_sign)){
        error_message += (
          "You gave a minus sign that is a digit"
          + " (\"" + escapeHTML(minus_sign) + "\").\n"
          + "<br>\n"
        );
      }
      if(parameters.decimal_separators.includes(minus_sign)){
        error_message += (
          "You gave a minus sign that is a decimal separator"
          + " (\"" + escapeHTML(minus_sign) + "\").\n"
          + "<br>\n"
        );
      }
      if(parameters.plus_signs.includes(minus_sign)){
        error_message += (
          "You gave a minus sign that is a plus sign"
          + " (\"" + escapeHTML(minus_sign) + "\").\n"
          + "<br>\n"
        );
      }
    }


    function check_collision_for_space_characters(
      space_characters,
      sub_type_of_space_characters,
    ){
      for(
        let space_character of space_characters
      ){
        if(parameters.digits.includes(space_character)){
          error_message += (
            "You gave a space character"
            + " (" + sub_type_of_space_characters + ")"
            + " that is a digit"
            + " (\"" + escapeHTML(space_character) + "\").\n"
            + "<br>\n"
          );
        }
        if(parameters.decimal_separators.includes(space_character)){
          error_message += (
            "You gave a space character"
            + " (" + sub_type_of_space_characters + ")"
            + " that is a decimal separator"
            + " (\"" + escapeHTML(space_character) + "\").\n"
            + "<br>\n"
          );
        }
        if(parameters.plus_signs.includes(space_character)){
          error_message += (
            "You gave a space character"
            + " (" + sub_type_of_space_characters + ")"
            + " that is a plus sign"
            + " (\"" + escapeHTML(space_character) + "\").\n"
            + "<br>\n"
          );
        }
        if(parameters.minus_signs.includes(space_character)){
          error_message += (
            "You gave a space character"
            + " (" + sub_type_of_space_characters + ")"
            + " that is a minus sign"
            + " (\"" + escapeHTML(space_character) + "\").\n"
            + "<br>\n"
          );
        }
      }
    }


    check_collision_for_space_characters(
      parameters.spaces_before_sign,
      "before sign",
    );
    check_collision_for_space_characters(
      parameters.spaces_before_number,
      "before number without sign",
    );
    check_collision_for_space_characters(
      parameters.spaces_between_sign_and_number,
      "between sign and number",
    );
    check_collision_for_space_characters(
      parameters.spaces_after_last_digit,
      "after last digit",
    );
    check_collision_for_space_characters(
      parameters.spaces_inter_digits_before,
      "inter digits before decimal separator",
    );
    check_collision_for_space_characters(
      parameters.spaces_between_digit_and_decimal_separator,
      "between digit and decimal separator",
    );
    check_collision_for_space_characters(
      parameters.spaces_between_decimal_separator_and_digit,
      "between decimal separator and digit",
    );
    check_collision_for_space_characters(
      parameters.spaces_inter_digits_after,
      "inter digits after decimal separator",
    );

    let zero_digit = parameters.digits[0];
    let unit_digit = parameters.digits[1];
    let positive_digits = parameters.digits.slice(
      1,
      parameters.digits.length,
    );
    let sign_signs = [
      ...parameters.plus_signs,
      ...parameters.minus_signs,
    ];

    let all_characters = [
      ...parameters.digits,
      ...parameters.decimal_separators,
      ...sign_signs,
    ];


    function canonize_number(some_number_string, number_name){
      let digits_array = Array.from(some_number_string);
      let digits_array_result = [];
      const debug = false;
      if(debug){
        console.log("canonize_number() digits_array1", digits_array);
      }

      // Check that all characters are allowed
      for(let digit of digits_array){
        if(!all_characters.includes(digit)){
          error_message += (
            "You gave a " + number_name
            + " number with unknown character \"" + escapeHTML(digit)
            + "\".\n"
            + "<br>\n"
          );
          return null;
        }
      }

      // Check that there is at most one plus sign or one minus sign
      // and that it is the first character.
      let first = true;
      for(let digit of digits_array){
        if(!parameters.plus_signs.includes(digit)){
          digits_array_result.push(digit);
        }
        if(sign_signs.includes(digit)){
          if(!first){
            error_message += (
              "You gave a " + number_name
              + " number with wrong sign.\n"
              + "<br>\n"
            );
            return null;
          }
        }
        first = false;
      }
      if(debug){
        console.log(
          "canonize_number() digits_array_result1",
          digits_array_result,
        );
      }

      let number_of_decimal_separators = digits_array_result.reduce(
        (acc, digit) => {
          if(parameters.decimal_separators.includes(digit)){
            ++acc;
          }
          return acc;
        },
        0,
      );
      if(debug){
        console.log(
          "canonize_number() number_of_decimal_separators",
          number_of_decimal_separators,
        );
      }
      if(number_of_decimal_separators > 1){
        error_message += (
          "You gave a " + number_name
          + " number with too many decimal separators.\n"
          + "<br>\n"
        );
        return null;
      }
      if(number_of_decimal_separators === 1){
        // We remove trailing zeros after decimal separator.
        while(true){
          let digit = digits_array_result.pop();
          if(digit === zero_digit){
            continue;
          }
          if(!parameters.decimal_separators.includes(digit)){
            digits_array_result.push(digit);
          }
          break;
        }
      }
      if(debug){
        console.log(
          "canonize_number() digits_array_result2",
          digits_array_result,
        );
      }

      // Filter out leading zeros except before decimal separator
      digits_array = digits_array_result;
      digits_array_result = [];
      let non_zero_digit_or_decimal_separator_found = false;
      for(let digit of digits_array){
        if(non_zero_digit_or_decimal_separator_found){
          digits_array_result.push(digit);
          continue;
        }
        if(parameters.minus_signs.includes(digit)){
          digits_array_result.push(digit);
          continue;
        }
        if(positive_digits.includes(digit)){
          non_zero_digit_or_decimal_separator_found = true;
          digits_array_result.push(digit);
          continue;
        }
        if(parameters.decimal_separators.includes(digit)){
          non_zero_digit_or_decimal_separator_found = true;
          digits_array_result.push(zero_digit);
          digits_array_result.push(digit);
        }
      }
      if(debug){
        console.log(
          "canonize_number() digits_array_result3",
          digits_array_result,
        );
      }
      if(
        digits_array_result.length === 0
        || (
          digits_array_result.length === 1
          && parameters.minus_signs.includes(digits_array_result[0])
        )
      ){
        digits_array_result = [zero_digit];
      }
      if(debug){
        console.log(
          "canonize_number() final result",
          digits_array_result,
        );
      }

      return digits_array_result;
    }


    if(error_message === ""){
      if(parameters.min !== ""){
        parameters.min = canonize_number(parameters.min, "min");
      }
      if(parameters.max !== ""){
        parameters.max = canonize_number(parameters.max, "max");
      }
      if(parameters.step !== ""){
        parameters.step = canonize_number(parameters.step, "step");
      }
      if(parameters.step !== null){
        if(sign_signs.includes(parameters.step[0])){
          error_message += (
            "You gave a step with sign.\n"
            + "<br>\n"
          );
        }
        if(
          parameters.step.length === 1
          && parameters.step[0] === zero_digit
        ){
          error_message += (
            "You gave a zero step," +
            " but it does not mean epsilon step." +
            " It should stay empty instead.\n"
            + "<br>\n"
          );
        }
      }
    }


    // This function is from
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide
    // /Regular_Expressions
    function escapeRegExp(string) {
      return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    }


    let regexp_to_enclosed = new Map();
    function enclose_regexp(some_regexp){
      if(
        some_regexp.length <= 1
        || (
          some_regexp.length === 2
          && some_regexp[0] === '\\'
        )
      ){
        return some_regexp;
      }
      if(regexp_to_enclosed.has(some_regexp)){
        return regexp_to_enclosed.get(some_regexp);
      }
      let enclosed_regexp = (
        parameters.regexp_enclosing_start
        + some_regexp
        + ")"
      );
      regexp_to_enclosed.set(some_regexp, enclosed_regexp);
      return enclosed_regexp;
    }


    const decimal_digits = [
      "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
    ];
    const lower_case_letters = [
      "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
      "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x",
      "y", "z",
    ];
    const upper_case_letters = lower_case_letters.map(
      (value) => { return value.toUpperCase(); }
    );


    function shrink_array_of_characters_with(
      array_to_shrink,
      array_of_reference, // may be one of the three arrays above
      all_range_equivalent,
    ){
      // This way around avoids a sort.
      let common_elements = array_of_reference.filter(
        (element) => { return array_to_shrink.includes(element); }
      )
      if(common_elements.length < 3){
        return array_to_shrink;
      }
      let result = array_to_shrink.filter(
        (element) => {
          return !array_of_reference.includes(element);
        }
      )
      if(common_elements.length === array_of_reference.length){
        result.push(all_range_equivalent);
        return result;
      }
      let start_of_range = null;
      let end_of_range = null;
      for(let element of common_elements){
        if(start_of_range === null){
          start_of_range = element;
          continue;
        }
        if(end_of_range === null){
          if(
            element.charCodeAt(0)
            === start_of_range.charCodeAt(0) + 1
          ){
            end_of_range = element;
          }
          else{
            result.push(start_of_range);
            start_of_range = element;
          }
          continue;
        }
        if(element.charCodeAt(0) === end_of_range.charCodeAt(0) + 1){
          end_of_range = element;
          continue;
        }
        if(
          end_of_range.charCodeAt(0)
          === start_of_range.charCodeAt(0) + 1
        ){
          result.push(start_of_range);
          result.push(end_of_range);
        }
        else{
          result.push(start_of_range + "-" + end_of_range);
        }
        start_of_range = element;
        end_of_range = null;
      }
      if(end_of_range === null){
        result.push(start_of_range);
      }
      else{
        if(
          end_of_range.charCodeAt(0)
          === start_of_range.charCodeAt(0) + 1
        ){
          result.push(start_of_range);
          result.push(end_of_range);
        }
        else{
          result.push(start_of_range + "-" + end_of_range);
        }
      }
      return result;
    }


    function shrink_array_of_characters(some_array){
      some_array = shrink_array_of_characters_with(
        some_array,
        decimal_digits,
        "\\d",
      );
      some_array = shrink_array_of_characters_with(
        some_array,
        lower_case_letters,
        "a-z",
      );
      some_array = shrink_array_of_characters_with(
        some_array,
        upper_case_letters,
        "A-Z",
      );
      return some_array;
    }


    function compute_regexp_for_any_character_in_array(some_array){
      if(some_array.length === 0){
        return "";
      }
      some_array = shrink_array_of_characters(some_array);
      // We must put "-" at the end.
      let index = some_array.indexOf("-");
      if(index > -1){
        // It does not bug with >= -1;
        // but the reason lies in splice function.
        some_array.push(some_array.splice(index, 1)[0]);
      }

      let result = some_array.map(
        (value) => {
          if(value === "\\d"){
            return value;
          }
          return escapeRegExp(value);
        }
      ).join("");
      let final_array = Array.from(result);
      if(
        final_array.length > 1
        && (
          final_array.length > 2
          || final_array[0] !== "\\"
        )
      ){
        regexp_to_enclosed.set(result, "[" + result + "]");
        result = "[" + result + "]";
      }
      return result;
    }


    function get_repeat_string(min, max){
      if(min === null){
        min = 0;
      }
      let repeat = "{";
      if(min === max){
        if(max === 0){
          return "no";
        }
        if(max === 1){
          return ""; // No need to repeat
        }
        repeat += min;
      }
      else if(max === null){
        if(min === 0){
          return "*";
        }
        if(min === 1){
          return "+";
        }
        repeat += min + ",";
      }
      else {
        if(min > max || max === 0){
          return "no";
        }
        if(min === 0 && max === 1){
          return "?";
        }
        repeat += min + "," + max;
      }
      repeat += "}";
      return repeat;
    }


    function get_regexp_with_repeat(regexp, repeat){
      if(repeat === "no"){
        return "";
      }
      if(regexp === ""){
        return "";
      }
      return enclose_regexp(regexp) + repeat;
    }


    function get_regexp_with_minmax_repeat_and_spacing(
      regexp,
      min_repeat,
      max_repeat,
      spacing_between_regexp,
    ){
      let repeat = get_repeat_string(min_repeat, max_repeat);
      if(repeat === "no"){
        return "";
      }
      if(spacing_between_regexp === ""){
        return get_regexp_with_repeat(regexp, repeat);
      }
      let no_occurrence = "";
      let first_occurrence = regexp;
      let other_occurrence = enclose_regexp(
        spacing_between_regexp + regexp
      );
      if(min_repeat === null){
        min_repeat = 0;
      }
      // no != first != other
      // (|first other{min-1, max-1})
      let min_repeat_for_other = Math.max(0, min_repeat - 1);
      let max_repeat_for_other = (
        max_repeat === null
        ? null
        : Math.max(0, max_repeat - 1)
      );
      // no = first = "" != other
      // other{min-1, max-1}
      // no != first = other
      // see if(spacing_between_regexp === "")
      // at the beginning of function
      let repeat_other = get_repeat_string(
        min_repeat_for_other,
        max_repeat_for_other,
      );
      let other_regexp = get_regexp_with_repeat(
        other_occurrence,
        repeat_other,
      );
      if(no_occurrence === first_occurrence){
        return other_regexp;
      }

      if(min_repeat === 0){
        return enclose_regexp("|" + first_occurrence + other_regexp);
      }
      return first_occurrence + other_regexp;
    }


    if(error_message === ""){
      // We compute the building blocks for the regular expression.
      let any_sign_regexp = (
        compute_regexp_for_any_character_in_array(
          sign_signs
        )
      );
      let any_digit_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.digits
        )
      );
      let not_a_digit_regexp = "";
      if(any_digit_regexp === "\\d"){
        not_a_digit_regexp = "\\D";
      }
      else{
        // Since there are at least two digits,
        // we must have "[" and "]".
        not_a_digit_regexp = (
          any_digit_regexp.substring(0, 1)
          + "^"
          + any_digit_regexp.substring(1)
        );
      }
      let any_decimal_separator_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.decimal_separators
        )
      );
      let zero_digit_regexp = (
        compute_regexp_for_any_character_in_array(
          [zero_digit]
        )
      );
      let minus_sign_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.minus_signs
        )
      );
      let plus_sign_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.plus_signs
        )
      );
      let any_positive_digit_regexp = (
        compute_regexp_for_any_character_in_array(
          positive_digits
        )
      );
      let any_digit_or_decimal_separator_regexp = (
        compute_regexp_for_any_character_in_array(
          [...parameters.digits, ...parameters.decimal_separators]
        )
      );
      let any_space_before_sign_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_before_sign
        )
      );
      let any_space_before_number_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_before_number
        )
      );
      let any_space_between_sign_and_number_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_between_sign_and_number
        )
      );
      let any_space_after_last_digit_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_after_last_digit
        )
      );
      let any_space_inter_digits_before_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_inter_digits_before
        )
      );
      let any_space_between_digit_and_decimal_separator_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_between_digit_and_decimal_separator
        )
      );
      let any_space_between_decimal_separator_and_digit_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_between_decimal_separator_and_digit
        )
      );
      let any_space_inter_digits_after_regexp = (
        compute_regexp_for_any_character_in_array(
          parameters.spaces_inter_digits_after
        )
      );
      let all_spaces_intra_number = [... new Set(
        [
          ...parameters.spaces_inter_digits_before,
          ...parameters.spaces_between_digit_and_decimal_separator,
          ...parameters.spaces_between_decimal_separator_and_digit,
          ...parameters.spaces_inter_digits_after,
        ]
      )];
      let any_space_intra_number_regexp = (
        compute_regexp_for_any_character_in_array(
          all_spaces_intra_number
        )
      );
      let some_contiguous_spaces_intra_number = "";
      if(any_space_intra_number_regexp !== ""){
        some_contiguous_spaces_intra_number = (
          any_space_intra_number_regexp + "*"
        );
      }
      let zero_digit_any_time_regexp = (
        get_regexp_with_minmax_repeat_and_spacing(
          zero_digit_regexp,
          0,
          null,
          some_contiguous_spaces_intra_number,
        )
      );
      let any_digit_any_time_regexp = (
        get_regexp_with_minmax_repeat_and_spacing(
          any_digit_regexp,
          0,
          null,
          some_contiguous_spaces_intra_number,
        )
      );

      let is_a_number_regexp = (
        any_sign_regexp + "?" // It may start with a sign
        + any_digit_regexp + "+" // Followed by some digits
        + "("
          + any_decimal_separator_regexp
          + any_digit_regexp + "+"
          + ")?" // Then maybe a decimal part
      );
      document.getElementById("is_a_number_regexp").innerHTML = (
        "You are looking at numbers that must satisfy"
        + " this regular expression: "
        + "<span style=\"color: forestgreen\">"
        + escapeHTML(is_a_number_regexp)
        + "</span>"
        + "\n<br>\n"
        + "But read on to see the other constraints"
        + " you must add to it."
      );
      let regular_expression_string = "";
      // We first add the spacing at the beginning.
      let repeat_before_sign = "*";
      let repeat_before_number = "*";
      if(
        parameters.min_number_of_spaces_before_sign !== null
        || parameters.max_number_of_spaces_before_sign !== null
      ){
        repeat_before_sign = get_repeat_string(
          parameters.min_number_of_spaces_before_sign,
          parameters.max_number_of_spaces_before_sign,
        );
      }
      if(
        parameters.min_number_of_spaces_before_number !== null
        || parameters.max_number_of_spaces_before_number !== null
      ){
        repeat_before_number = get_repeat_string(
          parameters.min_number_of_spaces_before_number,
          parameters.max_number_of_spaces_before_number,
        );
      }
      let all_spaces_before_sign_regexp = get_regexp_with_repeat(
        any_space_before_sign_regexp,
        repeat_before_sign,
      );
      let all_spaces_before_number_regexp = get_regexp_with_repeat(
        any_space_before_number_regexp,
        repeat_before_number,
      );
      if(
        all_spaces_before_sign_regexp !== ""
        || all_spaces_before_number_regexp !== ""
      ){
        regular_expression_string += (
          enclose_regexp(
            all_spaces_before_sign_regexp
            + "(?=" + any_sign_regexp + ")"
          + "|"
            + all_spaces_before_number_regexp
            + "(?!" + any_sign_regexp + ")"
          )
        );
      }

      let repeat_between_sign_and_number = "*";
      if(
        parameters.min_number_of_spaces_between_sign_and_number
        !== null
        || parameters.max_number_of_spaces_between_sign_and_number
        !== null
      ){
        repeat_between_sign_and_number = get_repeat_string(
          parameters.min_number_of_spaces_between_sign_and_number,
          parameters.max_number_of_spaces_between_sign_and_number,
        );
      }
      let all_spaces_between_sign_and_number_regexp = (
        get_regexp_with_repeat(
          any_space_between_sign_and_number_regexp,
          repeat_between_sign_and_number,
        )
      );
      let any_sign_and_spaces_regexp = (
        any_sign_regexp
        + all_spaces_between_sign_and_number_regexp
      );
      let plus_sign_and_spaces_regexp = (
        plus_sign_regexp
        + all_spaces_between_sign_and_number_regexp
      );
      let minus_sign_and_spaces_regexp = (
        minus_sign_regexp
        + all_spaces_between_sign_and_number_regexp
      );

      let repeat_after_last_digit = "*";
      if(
        parameters.min_number_of_spaces_after_last_digit
        !== null
        || parameters.max_number_of_spaces_after_last_digit
        !== null
      ){
        repeat_after_last_digit = get_repeat_string(
          parameters.min_number_of_spaces_after_last_digit,
          parameters.max_number_of_spaces_after_last_digit,
        );
      }
      let all_spaces_after_last_digit_regexp = (
        get_regexp_with_repeat(
          any_space_after_last_digit_regexp,
          repeat_after_last_digit,
        )
      );

      // let repeat_before = "+";
      // let repeat_after = "+";
      let min_digits_before = 1;
      let max_digits_before = null;
      let min_digits_after = 1;
      let max_digits_after = null;
      if(
        parameters.min_number_of_digits_before_decimal_separator
        !== null
        || parameters.max_number_of_digits_before_decimal_separator
        !== null
      ){
        // repeat_before = get_repeat_string(
        //  parameters.min_number_of_digits_before_decimal_separator,
        //  parameters.max_number_of_digits_before_decimal_separator,
        // );
        min_digits_before = (
          parameters.min_number_of_digits_before_decimal_separator
        );
        max_digits_before = (
          parameters.max_number_of_digits_before_decimal_separator
        );
      }
      if(
        parameters.min_number_of_digits_after_decimal_separator
        !== null
        || parameters.max_number_of_digits_after_decimal_separator
        !== null
      ){
        // repeat_after = get_repeat_string(
        //   parameters.min_number_of_digits_after_decimal_separator,
        //   parameters.max_number_of_digits_after_decimal_separator,
        // );
        min_digits_after = (
          parameters.min_number_of_digits_after_decimal_separator
        );
        max_digits_after = (
          parameters.max_number_of_digits_after_decimal_separator
        );
      }
      // bare requirement with positive look-ahead
      let bare_requirement_as_positive_look_ahead = false;
      let enforce_decimal_part = false;
      if(
        parameters.min_number_of_digits_after_decimal_separator
        !== null
        && parameters.min_number_of_digits_after_decimal_separator
        > 0
        &&
        !parameters.min_number_of_digits_after_decimal_separator_or_no
      ){
        enforce_decimal_part = true;
      }
      let optional_spacing_inter_digits_before = (
        get_regexp_with_repeat(
          any_space_inter_digits_before_regexp,
          get_repeat_string(
            parameters.min_number_of_spaces_inter_digits_before,
            parameters.max_number_of_spaces_inter_digits_before,
          )
        )
      );
      if(
        optional_spacing_inter_digits_before !== ""
        && parameters.min_number_of_spaces_inter_digits_before
        !== null
        && parameters.min_number_of_spaces_inter_digits_before
        > 0
      ){
        optional_spacing_inter_digits_before = enclose_regexp(
          "|" + optional_spacing_inter_digits_before
        );
      }
      let optional_spacing_inter_digits_after = (
        get_regexp_with_repeat(
          any_space_inter_digits_after_regexp,
          get_repeat_string(
            parameters.min_number_of_spaces_inter_digits_after,
            parameters.max_number_of_spaces_inter_digits_after,
          )
        )
      );
      if(
        optional_spacing_inter_digits_after !== ""
        && parameters.min_number_of_spaces_inter_digits_after
        !== null
        && parameters.min_number_of_spaces_inter_digits_after
        > 0
      ){
        optional_spacing_inter_digits_after = enclose_regexp(
          "|" + optional_spacing_inter_digits_after
        );
      }
      let all_space_between_digit_and_decimal_separator_regexp = (
        get_regexp_with_repeat(
          any_space_between_digit_and_decimal_separator_regexp,
          get_repeat_string(
            parameters
            .min_number_of_spaces_between_digit_and_decimal_separator,
            parameters
            .max_number_of_spaces_between_digit_and_decimal_separator,
          )
        )
      );
      let all_space_between_decimal_separator_and_digit_regexp = (
        get_regexp_with_repeat(
          any_space_between_decimal_separator_and_digit_regexp,
          get_repeat_string(
            parameters
            .min_number_of_spaces_between_decimal_separator_and_digit,
            parameters
            .max_number_of_spaces_between_decimal_separator_and_digit,
          )
        )
      );
      let decimal_part = "";
      if(
        all_space_between_digit_and_decimal_separator_regexp !== ""
      ){
        decimal_part += enclose_regexp(
          "(?<!" + any_digit_regexp + ".*)"
          + "|"
          + "(?<=" + any_digit_regexp + ".*)"
          + all_space_between_digit_and_decimal_separator_regexp
        );
      }
      decimal_part += any_decimal_separator_regexp;
      if(
        all_space_between_decimal_separator_and_digit_regexp !== ""
      ){
        decimal_part += enclose_regexp(
          "(?!.*" + any_digit_regexp + ")"
          + "|"
          + "(?=.*" + any_digit_regexp + ")"
          + all_space_between_decimal_separator_and_digit_regexp
        );
      }
      decimal_part += (
        // + any_digit_regexp + "+"
        // + get_regexp_with_repeat(any_digit_regexp, repeat_after)
        get_regexp_with_minmax_repeat_and_spacing(
          any_digit_regexp,
          min_digits_after,
          max_digits_after,
          optional_spacing_inter_digits_after,
        )
      );

      let bare_requirement = (
        // "(?=" +
        // any_sign_regexp + "?" // It may start with a sign
        // It may start with a sign and spacing
        enclose_regexp(any_sign_and_spaces_regexp) + "?"
        //+ any_digit_regexp + "+" // Followed by some digits
        // + get_regexp_with_repeat(any_digit_regexp, repeat_before)
        + get_regexp_with_minmax_repeat_and_spacing(
          any_digit_regexp,
          min_digits_before,
          max_digits_before,
          optional_spacing_inter_digits_before,
        )
        + (enforce_decimal_part
          ? decimal_part
          : enclose_regexp(decimal_part) + "?"
        )
        + all_spaces_after_last_digit_regexp
        // + "$)" // We want all the string.
      );
      if(bare_requirement_as_positive_look_ahead){
        regular_expression_string += (
          "(?="
          + bare_requirement
          + "$)" // We want all the string.
        );
      }
      if(!parameters.allow_leading_zeros){
        // No leading zero with negative look-ahead
        regular_expression_string += (
          "(?!"
          // It may start with a sign and spacing
          + enclose_regexp(any_sign_and_spaces_regexp) + "?"
          + zero_digit_regexp
          + some_contiguous_spaces_intra_number
          + any_digit_regexp
          + ")"
        );
      }
      if(!parameters.allow_trailing_zeros){
        // No trailing zero with negative look-ahead
        regular_expression_string += (
          "(?!"
          + ".*"
          + any_decimal_separator_regexp
          + ".*"
          + zero_digit_regexp
          + all_spaces_after_last_digit_regexp
          + "$)" // We want all the string.
        );
      }

      if(!parameters.allow_zero_with_minus){
        // No zero with minus with negative look-ahead
        regular_expression_string += (
          "(?!"
          + minus_sign_and_spaces_regexp
          // + zero_digit_regexp + "*"
          + zero_digit_any_time_regexp
          + enclose_regexp(
            some_contiguous_spaces_intra_number
            + any_decimal_separator_regexp
            + some_contiguous_spaces_intra_number
            // + zero_digit_regexp + "*"
            + zero_digit_any_time_regexp
          ) + "?" // Then maybe a decimal part
          + all_spaces_after_last_digit_regexp
          + "$)" // We want all the string.
        );
      }
      if(!parameters.allow_zero_with_plus){
        // No zero with plus with negative look-ahead
        regular_expression_string += (
          "(?!"
          + plus_sign_and_spaces_regexp
          // + zero_digit_regexp + "*"
          + zero_digit_any_time_regexp
          + enclose_regexp(
            some_contiguous_spaces_intra_number
            + any_decimal_separator_regexp
            + some_contiguous_spaces_intra_number
            // + zero_digit_regexp + "*"
            + zero_digit_any_time_regexp
          ) + "?" // Then maybe a decimal part
          + all_spaces_after_last_digit_regexp
          + "$)" // We want all the string.
        );
      }
      if(!parameters.allow_positive_number_with_plus){
        // No positive number with plus with negative look-ahead
        regular_expression_string += (
          "(?!"
          + plus_sign_regexp
          + ".*" + any_positive_digit_regexp
          + ")"
        );
      }

      if(
        parameters.min_number_of_digits !== null
        || parameters.max_number_of_digits !== null
      ){
        let min_digits_without = parameters.min_number_of_digits;
        let max_digits_without = parameters.max_number_of_digits;
        let min_digits_with = (
          parameters.min_number_of_digits === null
          ? null
          : parameters.min_number_of_digits + 1
        );
        let max_digits_with = (
          parameters.max_number_of_digits === null
          ? null
          : parameters.max_number_of_digits + 1
        );
        regular_expression_string += (
          "(?="
          // It may start with a sign and spacing
          + enclose_regexp(any_sign_and_spaces_regexp) + "?"
          + enclose_regexp(
              get_regexp_with_minmax_repeat_and_spacing(
                any_digit_regexp,
                min_digits_without,
                max_digits_without,
                some_contiguous_spaces_intra_number,
              )
            + "|"
              + "(?=.*" + any_decimal_separator_regexp + ")"
              + get_regexp_with_minmax_repeat_and_spacing(
                any_digit_or_decimal_separator_regexp,
                min_digits_with,
                max_digits_with,
                some_contiguous_spaces_intra_number,
              )
          )
          + all_spaces_after_last_digit_regexp
          + "$)" // We want all the string.
        );
      }


      function equals_regexp(some_number_array){
        // Needs canonized numbers.
        if(
          some_number_array.length === 1
          && some_number_array[0] === zero_digit
        ){
          return (
            enclose_regexp(any_sign_and_spaces_regexp) + "?"
            + zero_digit_any_time_regexp
            + enclose_regexp(
              some_contiguous_spaces_intra_number
              + any_decimal_separator_regexp
              + some_contiguous_spaces_intra_number
              + zero_digit_any_time_regexp
            ) + "?"
            + all_spaces_after_last_digit_regexp
            + "$"
          );
        }
        let equals_regexp = "";
        let start_at = 0;
        if(parameters.minus_signs.includes(some_number_array[0])){
          equals_regexp += minus_sign_and_spaces_regexp;
          start_at = 1;
        }
        else{
          equals_regexp += (
            enclose_regexp(plus_sign_and_spaces_regexp) + "?"
          );
        }
        equals_regexp += zero_digit_any_time_regexp;
        for(let i = start_at; i < some_number_array.length; ++i){
          equals_regexp += some_contiguous_spaces_intra_number;
          equals_regexp += escapeRegExp(some_number_array[i]);
        }
        let has_decimal_separator = false;
        for(let digit of some_number_array){
          if(parameters.decimal_separators.includes(digit)){
            has_decimal_separator = true;
            break;
          }
        }
        if(has_decimal_separator){
          equals_regexp += some_contiguous_spaces_intra_number;
          equals_regexp += zero_digit_any_time_regexp;
        }
        else{
          equals_regexp += enclose_regexp(
            some_contiguous_spaces_intra_number
            + any_decimal_separator_regexp
            + some_contiguous_spaces_intra_number
            + zero_digit_any_time_regexp
          ) + "?";
        }

        equals_regexp += all_spaces_after_last_digit_regexp;
        equals_regexp += "$";
        return equals_regexp;
      }


      // Symmetric to positive digits
      let not_last_digits = parameters.digits.slice(
        0,
        parameters.digits.length - 1,
      );

      let next_digits_regexp_map = new Map();
      for(let i = 0; i < parameters.digits.length - 1; ++i){
        next_digits_regexp_map.set(
          parameters.digits[i],
          compute_regexp_for_any_character_in_array(
            parameters.digits.slice(i + 1, parameters.digits.length)
          ),
        );
      }

      let previous_digits_regexp_map = new Map();
      for(let i = 1; i < parameters.digits.length; ++i){
        previous_digits_regexp_map.set(
          parameters.digits[i],
          compute_regexp_for_any_character_in_array(
            parameters.digits.slice(0, i)
          ),
        );
      }


      function positive_at_least_regexp(some_number_array){
        // Needs canonized numbers.
        if(parameters.minus_signs.includes(some_number_array[0])){
          throw Error(
            "Do not call positive_at_least_regexp()"
            + " with a negative number."
          );
        }
        let result_regexp = "";
        let has_a_decimal_separator = false;
        let number_of_digits_before_decimal_separator = 0;
        if(zero_digit === some_number_array[0]){
          // A positive number less than one.
          if(some_number_array.length === 1){
            // At least zero
            result_regexp += (
              enclose_regexp(
                // A zero
                enclose_regexp(any_sign_and_spaces_regexp) + "?"
                + zero_digit_any_time_regexp
                + enclose_regexp(
                  some_contiguous_spaces_intra_number
                  + any_decimal_separator_regexp
                  + some_contiguous_spaces_intra_number
                  + zero_digit_any_time_regexp
                ) + "?"
              + "|" // Or a positive number
                + "(?!" + minus_sign_regexp + ")"
                + ".*" // + any_positive_digit_regexp + ".*"
              )
              + all_spaces_after_last_digit_regexp
              + "$"
            )
            return result_regexp;
          }
          // 0.xyz... counts as one digit.
          number_of_digits_before_decimal_separator = 1;
          has_a_decimal_separator = true;
        }
        else{
          for(let digit of some_number_array){
            if(parameters.decimal_separators.includes(digit)){
              has_a_decimal_separator = true;
              break;
            }
            if(sign_signs.includes(digit)){
              continue;
            }
            ++number_of_digits_before_decimal_separator;
          }
        }
        let common_prefix = (
          enclose_regexp(plus_sign_and_spaces_regexp) + "?"
          + any_digit_any_time_regexp
        );
        // A number with more digits before decimal separator
        result_regexp += (
          parameters.regexp_enclosing_start
            + common_prefix
            + some_contiguous_spaces_intra_number
            + any_positive_digit_regexp
            + some_contiguous_spaces_intra_number
            + get_regexp_with_minmax_repeat_and_spacing(
              any_digit_regexp,
              number_of_digits_before_decimal_separator,
              null,
              some_contiguous_spaces_intra_number,
            )
            + ".*"
        );

        // Now we need to deal with numbers that do not have
        // a bigger power of the base than our number.
        for(let i = 0; i < some_number_array.length; ++i){
          let digit = some_number_array[i];
          --number_of_digits_before_decimal_separator;
          if(not_last_digits.includes(digit)){
            // We add when the checked number can be bigger
            // than our number on the current power.
            result_regexp += (
              "|" + common_prefix
              + some_contiguous_spaces_intra_number
              + next_digits_regexp_map.get(digit)
            );
            if(number_of_digits_before_decimal_separator > 0){
              result_regexp += (
                some_contiguous_spaces_intra_number
                + get_regexp_with_minmax_repeat_and_spacing(
                  any_digit_regexp,
                  number_of_digits_before_decimal_separator,
                  number_of_digits_before_decimal_separator,
                  some_contiguous_spaces_intra_number,
                )
              );
            }
            // We can always add digits after.
            result_regexp += ".*";
          }

          // common prefix update
          common_prefix += some_contiguous_spaces_intra_number;
          common_prefix += escapeRegExp(digit);
        }
        // Last, we add our number with more decimals.
        result_regexp += (
          "|" + common_prefix
          // Variant 1
          // + (has_a_decimal_separator
          //   ? ""
          //   : any_decimal_separator_regexp
          // )
          // + any_digit_regexp + "*"
          // Variant 2
          + ".*"
          // In at least context with positive numbers,
          // Variant 1 and 2 are equivalent.
        );

        // We close our sequence of alternatives.
        result_regexp += (
          ")"
          + all_spaces_after_last_digit_regexp
          + "$"
        );
        return result_regexp;
      }


      function negative_at_least_regexp(some_number_array){
        // Needs canonized numbers.
        if(!parameters.minus_signs.includes(some_number_array[0])){
          throw Error(
            "Do not call negative_at_least_regexp()"
            + " with a positive number."
          );
        }
        let result_regexp = "";
        let has_a_decimal_separator = false;
        let number_of_digits_before_decimal_separator = 0;
        if(zero_digit === some_number_array[1]){
          // A negative number more than -1.
          // -0.xyz... counts as one digit.
          number_of_digits_before_decimal_separator = 1;
          has_a_decimal_separator = true;
        }
        else{
          for(let digit of some_number_array){
            if(parameters.decimal_separators.includes(digit)){
              has_a_decimal_separator = true;
              break;
            }
            if(sign_signs.includes(digit)){
              continue;
            }
            ++number_of_digits_before_decimal_separator;
          }
        }
        result_regexp += (
          parameters.regexp_enclosing_start
            // We allow all positive numbers.
            + "(?!" + minus_sign_regexp + ")"
            + ".*"
        );
        let common_prefix = (
          minus_sign_and_spaces_regexp
          + zero_digit_any_time_regexp
        );
        // A number with fewer digits before decimal separator
        if(number_of_digits_before_decimal_separator > 1){
          result_regexp += (
            "|" + common_prefix
            + some_contiguous_spaces_intra_number
            + get_regexp_with_minmax_repeat_and_spacing(
              any_digit_regexp,
              0,
              number_of_digits_before_decimal_separator - 1,
              some_contiguous_spaces_intra_number,
            )
            + enclose_regexp(
              not_a_digit_regexp + "*|"
              + some_contiguous_spaces_intra_number
              + any_decimal_separator_regexp + ".*"
            )
          );
        }

        for(let i = 1; i < some_number_array.length; ++i){
          let digit = some_number_array[i];
          --number_of_digits_before_decimal_separator;
          if(positive_digits.includes(digit)){
            // We add when the checked number can be lower
            // than our number on the current power.
            result_regexp += (
              "|" + common_prefix
              + some_contiguous_spaces_intra_number
              + previous_digits_regexp_map.get(digit)
            );
            if(number_of_digits_before_decimal_separator >= 0){
              if(number_of_digits_before_decimal_separator > 0){
                result_regexp += (
                  some_contiguous_spaces_intra_number
                  + get_regexp_with_minmax_repeat_and_spacing(
                    any_digit_regexp,
                    number_of_digits_before_decimal_separator,
                    number_of_digits_before_decimal_separator,
                    some_contiguous_spaces_intra_number,
                  )
                );
              }
              result_regexp += enclose_regexp(
                not_a_digit_regexp + "*|"
                + some_contiguous_spaces_intra_number
                + any_decimal_separator_regexp + ".*"
              );
            }
            else{
              result_regexp += ".*";
            }
          }
          if(
            number_of_digits_before_decimal_separator <= 0
            && i < some_number_array.length - 1
          ){
            // From the last digit before decimal separator to the end,
            // we must add it anyway with some zeros after,
            // or just the end of the string.
            if(number_of_digits_before_decimal_separator === 0) {
              result_regexp += (
                "|" + common_prefix
                + some_contiguous_spaces_intra_number
                + escapeRegExp(digit)
                + enclose_regexp(
                  not_a_digit_regexp + "*|"
                  + some_contiguous_spaces_intra_number
                  + any_decimal_separator_regexp
                  + some_contiguous_spaces_intra_number
                  + zero_digit_any_time_regexp
                )
              );
            }
            else{
              result_regexp += (
                "|" + common_prefix
                + some_contiguous_spaces_intra_number
                + escapeRegExp(digit)
                + not_a_digit_regexp + "*"
              );
            }
          }

          // common prefix update
          common_prefix += some_contiguous_spaces_intra_number;
          common_prefix += escapeRegExp(digit);
        }
        // Last, we add our number with more zeros at the end.
        result_regexp += (
          "|" + common_prefix
          + (has_a_decimal_separator
              ? some_contiguous_spaces_intra_number
              + zero_digit_any_time_regexp
              : enclose_regexp(
                some_contiguous_spaces_intra_number
                + any_decimal_separator_regexp
                + some_contiguous_spaces_intra_number
                + zero_digit_any_time_regexp
              ) + "?"
            )
        );

        // We close our sequence of alternatives.
        result_regexp += (
          ")"
          + all_spaces_after_last_digit_regexp
          + "$"
        );
        return result_regexp;
      }


      function positive_at_most_regexp(some_number_array){
        // Needs canonized numbers.
        if(parameters.minus_signs.includes(some_number_array[0])){
          throw Error(
            "Do not call positive_at_most_regexp()"
            + " with a negative number."
          );
        }
        let result_regexp = "";
        let has_a_decimal_separator = false;
        let number_of_digits_before_decimal_separator = 0;
        if(zero_digit === some_number_array[0]){
          // A positive number less than one.
          if(some_number_array.length === 1){
            // At most zero
            result_regexp += (
              enclose_regexp(
                // A zero
                enclose_regexp(any_sign_and_spaces_regexp) + "?"
                + zero_digit_any_time_regexp
                + enclose_regexp(
                  some_contiguous_spaces_intra_number
                  + any_decimal_separator_regexp
                  + some_contiguous_spaces_intra_number
                  + zero_digit_any_time_regexp
                ) + "?"
              + "|" // Or a negative number
                + minus_sign_regexp
                + ".*" // + any_positive_digit_regexp + ".*"
              )
              + all_spaces_after_last_digit_regexp
              + "$"
            )
            return result_regexp;
          }
          // 0.xyz... counts as one digit.
          number_of_digits_before_decimal_separator = 1;
          has_a_decimal_separator = true;
        }
        else{
          for(let digit of some_number_array){
            if(parameters.decimal_separators.includes(digit)){
              has_a_decimal_separator = true;
              break;
            }
            if(sign_signs.includes(digit)){
              continue;
            }
            ++number_of_digits_before_decimal_separator;
          }
        }
        result_regexp += (
          parameters.regexp_enclosing_start
            // We allow all negative numbers.
            + minus_sign_regexp
            + ".*"
        );

        let common_prefix = (
          enclose_regexp(plus_sign_and_spaces_regexp) + "?"
          + zero_digit_any_time_regexp
        );
        // A number with fewer digits before decimal separator
        if(number_of_digits_before_decimal_separator > 1){
          result_regexp += (
            "|"
            + common_prefix
            + some_contiguous_spaces_intra_number
            + get_regexp_with_minmax_repeat_and_spacing(
              any_digit_regexp,
              0,
              number_of_digits_before_decimal_separator - 1,
              some_contiguous_spaces_intra_number,
            )
            + enclose_regexp(
              not_a_digit_regexp + "*|"
              + some_contiguous_spaces_intra_number
              + any_decimal_separator_regexp + ".*"
            )
          );
        }

        for(let i = 0; i < some_number_array.length; ++i){
          let digit = some_number_array[i];
          --number_of_digits_before_decimal_separator;
          if(positive_digits.includes(digit)){
            // We add when the checked number can be lower
            // than our number on the current power.
            result_regexp += (
              "|" + common_prefix
              + some_contiguous_spaces_intra_number
              + previous_digits_regexp_map.get(digit)
            );
            if(number_of_digits_before_decimal_separator >= 0){
              if(number_of_digits_before_decimal_separator > 0){
                result_regexp += (
                  some_contiguous_spaces_intra_number
                  + get_regexp_with_minmax_repeat_and_spacing(
                    any_digit_regexp,
                    number_of_digits_before_decimal_separator,
                    number_of_digits_before_decimal_separator,
                    some_contiguous_spaces_intra_number,
                  )
                );
              }
              result_regexp += enclose_regexp(
                not_a_digit_regexp + "*|"
                + some_contiguous_spaces_intra_number
                + any_decimal_separator_regexp + ".*"
              );
            }
            else{
              result_regexp += ".*";
            }
          }
          if(
            number_of_digits_before_decimal_separator <= 0
            && i < some_number_array.length - 1
          ){
            // From the last digit before decimal separator to the end,
            // we must add it anyway with some zeros after,
            // or just the end of the string.
            if(number_of_digits_before_decimal_separator === 0) {
              result_regexp += (
                "|" + common_prefix
                + some_contiguous_spaces_intra_number
                + escapeRegExp(digit)
                + enclose_regexp(
                  not_a_digit_regexp + "*|"
                  + some_contiguous_spaces_intra_number
                  + any_decimal_separator_regexp
                  + some_contiguous_spaces_intra_number
                  + zero_digit_any_time_regexp
                )
              );
            }
            else{
              result_regexp += (
                "|" + common_prefix
                + some_contiguous_spaces_intra_number
                + escapeRegExp(digit)
                + not_a_digit_regexp + "*"
              );
            }
          }

          common_prefix += some_contiguous_spaces_intra_number;
          common_prefix += escapeRegExp(digit);
        }
        // Last, we add our number with more zeros at the end.
        result_regexp += (
          "|" + common_prefix
          + (has_a_decimal_separator
              ? some_contiguous_spaces_intra_number
              + zero_digit_any_time_regexp
              : enclose_regexp(
                some_contiguous_spaces_intra_number
                + any_decimal_separator_regexp
                + some_contiguous_spaces_intra_number
                + zero_digit_any_time_regexp
              ) + "?"
            )
        );

        // We close our sequence of alternatives.
        result_regexp += (
          ")"
          + all_spaces_after_last_digit_regexp
          + "$"
        );
        return result_regexp;
      }


      function negative_at_most_regexp(some_number_array){
        // Needs canonized numbers.
        if(!parameters.minus_signs.includes(some_number_array[0])){
          throw Error(
            "Do not call negative_at_most_regexp()"
            + " with a positive number."
          );
        }
        let result_regexp = "";
        let has_a_decimal_separator = false;
        let number_of_digits_before_decimal_separator = 0;
        if(zero_digit === some_number_array[1]){
          // A negative number less than one.
          number_of_digits_before_decimal_separator = 1;
          has_a_decimal_separator = true;
        }
        else{
          for(let digit of some_number_array){
            if(parameters.decimal_separators.includes(digit)){
              has_a_decimal_separator = true;
              break;
            }
            if(sign_signs.includes(digit)){
              continue;
            }
            ++number_of_digits_before_decimal_separator;
          }
        }
        let common_prefix = (
          minus_sign_and_spaces_regexp
          + any_digit_any_time_regexp
        );
        // A number with more digits before decimal separator
        result_regexp += (
          parameters.regexp_enclosing_start
            + common_prefix
            + some_contiguous_spaces_intra_number
            + any_positive_digit_regexp
            + some_contiguous_spaces_intra_number
            + get_regexp_with_minmax_repeat_and_spacing(
              any_digit_regexp,
              number_of_digits_before_decimal_separator,
              null,
              some_contiguous_spaces_intra_number,
            )
            + ".*"
        );

        // Now we need to deal with numbers that do not have
        // a bigger power of the base than our number.
        for(let i = 1; i < some_number_array.length; ++i){
          let digit = some_number_array[i];
          --number_of_digits_before_decimal_separator;
          if(not_last_digits.includes(digit)){
            // We add when the checked number can be bigger
            // than our number on the current power.
            result_regexp += (
              "|" + common_prefix
              + some_contiguous_spaces_intra_number
              + next_digits_regexp_map.get(digit)
            );
            if(number_of_digits_before_decimal_separator > 0){
              result_regexp += (
                some_contiguous_spaces_intra_number
                + get_regexp_with_minmax_repeat_and_spacing(
                  any_digit_regexp,
                  number_of_digits_before_decimal_separator,
                  number_of_digits_before_decimal_separator,
                  some_contiguous_spaces_intra_number,
                )
              );
            }
            // We can always add digits after.
            result_regexp += ".*";
          }
          common_prefix += escapeRegExp(digit);
        }
        // Last, we add our number with more decimals.
        result_regexp += (
          "|" + common_prefix
          + ".*"
        );

        // We close our sequence of alternatives.
        result_regexp += (
          ")"
          + all_spaces_after_last_digit_regexp
          + "$"
        );
        return result_regexp;
      }


      let min_equals_regexp = null;
      let at_least_min_regexp = null;
      let more_than_min_regexp = null;
      if(parameters.min !== ""){
        min_equals_regexp = equals_regexp(parameters.min);
        if(parameters.minus_signs.includes(parameters.min[0])){
          at_least_min_regexp = negative_at_least_regexp(
            parameters.min
          );
        }
        else{
          at_least_min_regexp = positive_at_least_regexp(
            parameters.min
          );
        }
        more_than_min_regexp = (
          "(?!" + min_equals_regexp + ")"
          + at_least_min_regexp
        );

        document.getElementById("equals_min").innerHTML = (
          "Here is a regular expression for testing equality"
          + " with min: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(min_equals_regexp)
          + "</span>"
        );
        document.getElementById("at_least_min").innerHTML = (
          "Here is a regular expression for testing at least min: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(at_least_min_regexp)
          + "</span>"
        );
        document.getElementById("more_than_min").innerHTML = (
          "Here is a regular expression for testing more than min: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(more_than_min_regexp)
          + "</span>"
        );

        regular_expression_string += (
          "(?=" + at_least_min_regexp + ")"
        );
        if(parameters.is_min_excluded){
          regular_expression_string += (
            "(?!" + min_equals_regexp + ")"
          );
        }
      }

      let max_equals_regexp = null;
      let at_most_max_regexp = null;
      let less_than_max_regexp = null;
      if(parameters.max !== ""){
        max_equals_regexp = equals_regexp(parameters.max);
        if(parameters.minus_signs.includes(parameters.max[0])){
          at_most_max_regexp = negative_at_most_regexp(
            parameters.max
          );
        }
        else{
          at_most_max_regexp = positive_at_most_regexp(
            parameters.max
          );
        }
        less_than_max_regexp = (
          "(?!" + max_equals_regexp + ")"
          + at_most_max_regexp
        );

        document.getElementById("equals_max").innerHTML = (
          "Here is a regular expression for testing equality"
          + " with max: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(max_equals_regexp)
          + "</span>"
        );
        document.getElementById("at_most_max").innerHTML = (
          "Here is a regular expression for testing at most max: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(at_most_max_regexp)
          + "</span>"
        );
        document.getElementById("less_than_max").innerHTML = (
          "Here is a regular expression for testing less than max: "
          + "<span style=\"color: forestgreen\">"
          + escapeHTML(less_than_max_regexp)
          + "</span>"
        );

        regular_expression_string += (
          "(?=" + at_most_max_regexp + ")"
        );
        if(parameters.is_max_excluded){
          regular_expression_string += (
            "(?!" + max_equals_regexp + ")"
          );
        }
      }

      if(parameters.step !== ""){
        let number_of_unit_digits = 0;
        let number_of_other_positive_digits = 0;
        let has_a_decimal_separator = false;
        for(let digit of parameters.step){
          if(digit === unit_digit){
            ++number_of_unit_digits;
          }
          else if(positive_digits.includes(digit)){
            ++number_of_other_positive_digits;
          }
          else if(parameters.decimal_separators.includes(digit)){
            has_a_decimal_separator = true;
          }
        }
        if(
          number_of_other_positive_digits === 0
          && number_of_unit_digits === 1
        ){
          if(!has_a_decimal_separator){
            regular_expression_string += (
              "(?!.*"
              + any_decimal_separator_regexp
              + ".*"
              + any_positive_digit_regexp
              + ")"
            );
            if(parameters.step.length > 1){
              regular_expression_string += (
                "(?="
                // Zéro est valide
                + "(?!.*" + any_positive_digit_regexp + ")"
                // Sinon:
                + "|.*"
                  // at least this number of zeros at the end
                  + get_regexp_with_minmax_repeat_and_spacing(
                    zero_digit_regexp,
                    parameters.step.length - 1,
                    null,
                    some_contiguous_spaces_intra_number,
                  )
                  + enclose_regexp(
                    all_spaces_after_last_digit_regexp + "$|"
                    + some_contiguous_spaces_intra_number
                    + any_decimal_separator_regexp
                  )
                + ")"
              );
            }
          }
          else{
            regular_expression_string += (
              "(?!.*" + any_decimal_separator_regexp
              + some_contiguous_spaces_intra_number
              + get_regexp_with_minmax_repeat_and_spacing(
                any_digit_regexp,
                parameters.step.length - 2,
                null,
                some_contiguous_spaces_intra_number,
              )
              + some_contiguous_spaces_intra_number
              + any_positive_digit_regexp
              + ")"
            );
          }
        }
        else{
          // We compute the underlying positive integer
          // and the offset.
          let step_calculus_element = (
            document.getElementById("step_calculus")
          );
          let underlying_integer_string = "";
          let underlying_integer = 0
          let offset = null;

          if(has_a_decimal_separator){
            for(let digit of parameters.step){
              if(
                offset !== null
                && parameters.digits.includes(digit)
              ){
                --offset;
                continue;
              }
              if(parameters.decimal_separators.includes(digit)){
                offset = 0;
              }
            }
            for(let digit of parameters.step){
              if(parameters.digits.includes(digit)){
                underlying_integer_string += digit;
                underlying_integer = (
                  (underlying_integer * parameters.digits.length)
                  + parameters.digits.indexOf(digit)
                );
              }
            }
          }
          else{
            offset = 0;
            for(let i = parameters.step.length - 1; i >= 0; --i){
              if(zero_digit !== parameters.step[i]){
                break;
              }
              ++offset;
            }
            for(
              let i = 0, i_max = parameters.step.length - offset;
              i < i_max;
              ++i
            ){
              let digit = parameters.step[i];
              if(parameters.digits.includes(digit)){
                underlying_integer_string += digit;
                underlying_integer = (
                  (underlying_integer * parameters.digits.length)
                  + parameters.digits.indexOf(digit)
                );
              }
            }
          }

          step_calculus_element.innerHTML = (
            "From step: "
            + escapeHTML(parameters.step.join("")) + "\n<br>\n"
            + "I found one underlying integer: "
            + escapeHTML(underlying_integer_string) + "\n<br>\n"
            + "Its value in decimal is: "
            + underlying_integer + "\n<br>\n"
            + "The offset to apply is: "
            + offset + "\n<br>\n"
          );

          // We compute the transitions between congruences/states
          // of the automaton.
          let number_of_states = underlying_integer;
          let needed_states_for_offset = new Map();
          let all_states_to_keep = [0];
          if(offset < 0){
            needed_states_for_offset.set(offset, [0]);
            let current_offset = offset;
            while(current_offset < 0){
              let previous_offset = current_offset;
              ++current_offset;
              let current_states = [];
              needed_states_for_offset.set(
                current_offset,
                current_states,
              );
              for(let i = 0; i < number_of_states; ++i){
                if(
                  needed_states_for_offset.get(previous_offset)
                  .includes(
                    (i * parameters.digits.length)
                    % underlying_integer
                  )
                ){
                  current_states.push(i);
                }
              }
              if(
                current_states.length > 0
                && current_states.length < number_of_states
              ){
                all_states_to_keep.push(...current_states);
              }
            }
            all_states_to_keep = [... new Set(all_states_to_keep)];
            let log = (
              "Given the decimal part,"
              + " the following states will be needed:\n<br>\n"
            );
            for(
              const [offset, states]
              of needed_states_for_offset.entries()
            ){
              log += (
                "Offset: " + offset
                + " needs states: " + states.join(",")
                + ".\n<br>\n"
              );
            }
            log += (
              "Reduced to states: "
              + all_states_to_keep.join(",")
              + ".\n<br>\n"
            )
            step_calculus_element.innerHTML += log;
          }

          let max_total_length = 1000000;
          let all_transitions = [];
          let initial_transitions = new Map();
          all_transitions.push(initial_transitions);
          // init of initial_transitions 2-dimensional array
          for(let i = 0; i < number_of_states; ++i){
            let row = new Map();
            initial_transitions.set(i, row);
            for(let j = 0; j < number_of_states; ++j){
              row.set(j, null);
            }
          }
          for(let i = 0; i < number_of_states; ++i){
            // i is the state we start from
            let row = initial_transitions.get(i);
            for(let j = 0; j < parameters.digits.length; ++j){
              // j is the digit we read (digits[j])
              let digit = parameters.digits[j];
              let result_state = (
                ((i * parameters.digits.length) + j)
                % underlying_integer
              );
              if(row.get(result_state) === null){
                row.set(result_state, escapeRegExp(digit));
              }
              else{
                row.set(
                  result_state,
                  row.get(result_state) + "|" + escapeRegExp(digit)
                );
              }
            }
          }


          function log_table_for_transitions(transitions){
            let table_string = "";
            table_string += (
              "Computing the possible transitions between"
              + " the following states:\n"
              + "<table class=\"transitions\">"
              + "<tbody><tr><th style=\"border: solid 2px;\"></th>"
            );
            // state 0 is always there
            for(const j of transitions.get(0).keys()){
              table_string += (
                "<th>" + j + "</th>"
              );
            }
            table_string += "</tr>\n";
            for(const [i, row] of transitions.entries()){
              table_string += (
                "<tr>"
                + "<th>" + i + "</th>"
              );
              for(const value of row.values()){
                let td = "";
                if(value !== null){
                  td = escapeHTML(value);
                }
                table_string += (
                  "<td>" + td + "</td>"
                );
              }
              table_string += "</tr>\n";
            }

            table_string += (
               "</tbody></table>\n"
               + "\n<br>\n"
            )
            step_calculus_element.innerHTML += table_string;
          }


          log_table_for_transitions(initial_transitions);


          let total_length = 0;
          function delete_one_state_of(
            previous_transitions,
            deleted_state,
          ){
            total_length = 0;
            let current_transitions = new Map();
            for(
              const [i, old_row] of previous_transitions.entries()
            ){
              if(i === deleted_state){
                continue;
              }
              let row = new Map();
              current_transitions.set(i, row);
              for(const j of old_row.keys()){
                if(j === deleted_state){
                  continue;
                }
                let transition = [];
                row.set(j, transition);
                let old_value = old_row.get(j);
                if(old_value !== null){
                  transition.push(old_value);
                  total_length += old_value.length;
                }
              }
            }

            let loop_on_deleted_state = "";
            let delete_to_delete = (
              previous_transitions.get(deleted_state)
              .get(deleted_state)
            );
            if(delete_to_delete !== null){
              if(
                some_contiguous_spaces_intra_number === ""
                && parameters.digits.includes(delete_to_delete)
                && !has_a_decimal_separator
              ){
                loop_on_deleted_state = delete_to_delete + "*";
              }
              else{
                loop_on_deleted_state = (
                  enclose_regexp(
                    delete_to_delete
                    + some_contiguous_spaces_intra_number
                    + (has_a_decimal_separator
                      ? any_decimal_separator_regexp + "?"
                      + some_contiguous_spaces_intra_number
                      : ""
                      )
                  ) + "*"
                );
              }
            }

            for(const i of current_transitions.keys()){
              let from_transition = (
                previous_transitions.get(i).get(deleted_state)
              );
              if(from_transition === null){
                continue;
              }
              if(from_transition.length > 1){
                from_transition = enclose_regexp(from_transition);
              }
              for(const j of current_transitions.keys()){
                let to_transition = (
                  previous_transitions.get(deleted_state).get(j)
                );
                if(to_transition === null){
                  continue;
                }
                if(to_transition.length > 1){
                  to_transition = enclose_regexp(to_transition);
                }
                let transition = enclose_regexp(
                  from_transition
                  + some_contiguous_spaces_intra_number
                  + (has_a_decimal_separator
                    ? any_decimal_separator_regexp + "?"
                    + some_contiguous_spaces_intra_number
                    : ""
                    )
                  + loop_on_deleted_state
                  + to_transition
                );
                current_transitions.get(i).get(j).push(transition);
                total_length += transition.length;
                if(total_length > max_total_length){
                  return null;
                }
              }
            }

            // Convert back each value from array to string
            for(const i of current_transitions.keys()){
              let row = current_transitions.get(i);
              for(const j of current_transitions.keys()){
                let value = row.get(j);
                if(value.length === 0){
                  row.set(j, null);
                  continue;
                }
                if(value.length === 1){
                  row.set(j, value[0]);
                  continue;
                }
                row.set(j, enclose_regexp(value.join("|")));
              }
            }
            return current_transitions;
          }// end function delete_one_state_of()


          function delete_some_states_of(
            initial_transitions,
            states_to_keep,
          ){
            step_calculus_element.innerHTML += (
              "Trying to keep states:" + states_to_keep.join(",")
              + "\n<br>\n"
            );
            let previous_transitions = initial_transitions;
            let states_to_delete = [];
            for(let state of initial_transitions.keys()){
              if(states_to_keep.includes(state)){
                continue;
              }
              states_to_delete.push(state);
            }
            while(states_to_delete.length > 0){
              let deleted_state = states_to_delete.pop();
              let current_transitions = delete_one_state_of(
                previous_transitions,
                deleted_state,
              );
              if(current_transitions === null){
                return null;
              }
              all_transitions.push(current_transitions);
              previous_transitions = current_transitions;
              log_table_for_transitions(current_transitions);
            }
            return all_transitions[all_transitions.length - 1];
          }

          // We compute all walks from 0 state to some needed state.
          let state_to_reduced_transitions = new Map();
          for(let state of all_states_to_keep){
            let reduced_transitions = delete_some_states_of(
              initial_transitions,
              [... new Set([0, state])],
            );
            if(reduced_transitions === null){
              break;
            }
            state_to_reduced_transitions.set(
              state,
              reduced_transitions,
            );
          }

          if(total_length > max_total_length) {
            error_message += (
              "This value of step is not currently supported,"
              + " sorry.\n"
              + "<br>\n"
              + "Maximum length (" + max_total_length
              + ") of subregexps for steps was reached.\n"
              + "<br>\n"
              + "You will find below some intermediate"
              + " steps of calculus (of step... regexp ;) ).\n"
              + "<br>\n"
              + "You can modify the source code and try anyway."
              + " But I recommend saving all your work,"
              + " and using some web-browser where you have not"
              + " all your pinned open tabs."
              + "Because it can grow really fast;"
              + " your PC or your smartphone may swap memory;"
              + " and you may have to kill your web-browser"
              + " or restart your device,"
              + " or the OS will do it for you."
            );
          }
          else{
            let walk_from_0_to_0 = (
              enclose_regexp(
                state_to_reduced_transitions.get(0).get(0).get(0)
                + some_contiguous_spaces_intra_number
                + (has_a_decimal_separator
                  ? any_decimal_separator_regexp + "?"
                  + some_contiguous_spaces_intra_number
                  : ""
                  )
              ) + "*"
            );
            for(
              const [state, transitions]
              of state_to_reduced_transitions.entries()
            ){
              if(state === 0){
                state_to_reduced_transitions.set(
                  0,
                  walk_from_0_to_0,
                )
                continue;
              }
              let walk_from_0_to = null;
              if(transitions.get(0).get(state) !== null){
                walk_from_0_to = (
                  walk_from_0_to_0
                  + transitions.get(0).get(state)
                );
              }
              state_to_reduced_transitions.set(
                state,
                walk_from_0_to,
              )
            }

            if(offset >= 0){
              regular_expression_string += (
                "(?="
                // Zéro est valide
                + "(?!.*" + any_positive_digit_regexp + ")"
                // Sinon:
                + "|"
                  + enclose_regexp(any_sign_and_spaces_regexp) + "?"
                  + walk_from_0_to_0
                  + get_regexp_with_minmax_repeat_and_spacing(
                    zero_digit_regexp,
                    offset,
                    null,
                    some_contiguous_spaces_intra_number,
                  )
                  + enclose_regexp(
                    some_contiguous_spaces_intra_number
                    + any_decimal_separator_regexp
                    + some_contiguous_spaces_intra_number
                    + zero_digit_any_time_regexp
                  ) + "?"
                  + all_spaces_after_last_digit_regexp
                + "$)"
              );
            }
            else{
              regular_expression_string += (
                "(?="
                // Zéro est valide
                + "(?!.*" + any_positive_digit_regexp + ")"
                // Sinon:
                + "|("
              );

              function get_sub_possibilities(needed_states){
                let sub_possibilities = [];
                for(const state of needed_states){
                  if(
                    state_to_reduced_transitions.get(state) !== null
                  ){
                    sub_possibilities.push(
                      state_to_reduced_transitions.get(state)
                    );
                  }
                }
                return sub_possibilities;
              }

              // We list the possibilities
              let possibilities = [];
              for(
                const [current_offset, needed_states]
                of needed_states_for_offset.entries()
              ){
                if(needed_states.length === 0){
                  // No possibility
                  continue;
                }
                let possibility = "";
                if(needed_states.length === underlying_integer){
                  // Any number with that precision
                  // is a multiple of step.
                  possibility = ".*";
                }
                else{
                  let sub_possibilities = get_sub_possibilities(
                    needed_states
                  );
                  if(sub_possibilities.length === 0){
                    continue;
                  }
                  possibility += (
                    enclose_regexp(any_sign_and_spaces_regexp) + "?"
                    + walk_from_0_to_0
                    + some_contiguous_spaces_intra_number
                    + any_decimal_separator_regexp + "?"
                    + some_contiguous_spaces_intra_number
                    + (sub_possibilities.length === 1
                      ? sub_possibilities[0]
                      : enclose_regexp(sub_possibilities.join("|"))
                    )
                  );
                }

                if(current_offset === 0){
                  possibility += (
                    "(?<!"
                    + any_decimal_separator_regexp
                    + ".*)"
                  );
                }
                else{
                  possibility += (
                    "(?<="
                    + any_decimal_separator_regexp
                    + some_contiguous_spaces_intra_number
                    + get_regexp_with_minmax_repeat_and_spacing(
                      any_digit_regexp,
                      -current_offset,
                      -current_offset,
                      some_contiguous_spaces_intra_number,
                    )
                    + some_contiguous_spaces_intra_number
                    + ")"
                    + zero_digit_any_time_regexp
                  );
                }
                possibilities.push(possibility);
              }
              regular_expression_string += (
                possibilities.join("|")
              );

              regular_expression_string += (
                ")"
                  + all_spaces_after_last_digit_regexp
                + "$)"
              );
            }
          }
        }
      }

      if(
        parameters.min_number_of_contiguous_digits !== null
        && parameters.min_number_of_contiguous_digits > 1
      ){
        regular_expression_string += (
          "(?!"
            + ".*" + any_decimal_separator_regexp
            + enclose_regexp("|.*" + any_space_intra_number_regexp)
            + get_regexp_with_repeat(
              any_digit_regexp,
              get_repeat_string(
                1,
                parameters.min_number_of_contiguous_digits - 1,
              )
            )
            + any_space_intra_number_regexp + "+"
            + any_digit_regexp
          + "|"
            + ".*"
            + any_digit_regexp
            + any_space_intra_number_regexp + "+"
            + get_regexp_with_repeat(
              any_digit_regexp,
              get_repeat_string(
                1,
                parameters.min_number_of_contiguous_digits - 1,
              )
            )
            + "(?!" + any_digit_regexp + ")"
            + "(?<!" + any_decimal_separator_regexp + ".*)"
          + ")"
        );
      }

      if(parameters.max_number_of_contiguous_digits !== null){
        regular_expression_string += (
          "(?!.*"
          + get_regexp_with_repeat(
            any_digit_regexp,
            get_repeat_string(
              parameters.max_number_of_contiguous_digits + 1,
              null
            )
          )
          + ")"
        );
      }

      // Negative or positive look-behind is not enough.
      // At the end, we must truly match the string.
      if(bare_requirement_as_positive_look_ahead){
        regular_expression_string += ".*";
      }
      else{
        regular_expression_string += bare_requirement;
      }

      document.getElementById("result").textContent = (
        regular_expression_string
      );
      let test_string_element = (
        document.getElementById("test_string")
      );
      test_string_element.pattern = regular_expression_string;
      test_string_element.title = (
        "This input has the following pattern: "
        + regular_expression_string
      );
    }

    if(error_message !== ""){
      document.getElementById("error").innerHTML = error_message;
    }

  </script>
</body>
</html>