Add all X·S·D non‐auxillary functions

[Sutra] / xsd / functions.js

// ♓️🪡 सूत्र ∷ xsd/functions.js
// ====================================================================
//
// Copyright © 2023 Lady [@ Lady’s Computer].
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at <https://mozilla.org/MPL/2.0/>.

import {
  abs,
  bind,
  call,
  get8BitUnsignedIntegralItem,
  getByteLength,
  getFirstSubstringIndex,
  getPrototype,
  isArrayBuffer,
  isFiniteNumber,
  isIntegralNumber,
  ITERATOR,
  Matcher,
  min,
  objectCreate,
  rawString,
  sameValue,
  set8BitIntegralItem,
  stringCatenate,
  stringIncludes,
  stringPadEnd,
  stringPadStart,
  stringSlice,
  stringSplit,
  substring,
  toExponentialNotation,
  toFloat32,
  toNumber,
  type,
} from "../deps.js";
import { div, mod } from "./operators.js";
import {
  booleanRep,
  dateLexicalRep,
  dateTimeLexicalRep,
  dayFrag,
  dayTimeDurationLexicalRep,
  decimalLexicalRep,
  decimalPtNumeral,
  digit as lexicalDigit,
  doubleRep,
  duDayFrag,
  duDayTimeFrag,
  duHourFrag,
  duMinuteFrag,
  duMonthFrag,
  durationLexicalRep,
  duSecondFrag,
  duTimeFrag,
  duYearFrag,
  duYearMonthFrag,
  floatRep,
  fracFrag,
  gDayLexicalRep,
  gMonthDayLexicalRep,
  gMonthLexicalRep,
  gYearLexicalRep,
  gYearMonthLexicalRep,
  hexBinary,
  hexDigit,
  hexOctet,
  hourFrag,
  minuteFrag,
  monthFrag,
  noDecimalPtNumeral,
  numericalSpecialRep,
  scientificNotationNumeral,
  secondFrag,
  stringRep,
  timeLexicalRep,
  timezoneFrag,
  unsignedDecimalPtNumeral,
  unsignedNoDecimalPtNumeral,
  yearFrag,
  yearMonthDurationLexicalRep,
} from "./productions.js";
import {
  absent,
  negativeInfinity,
  negativeZero,
  notANumber,
  positiveInfinity,
  positiveZero,
} from "./values.js";

const stringToFloat = parseFloat;

/**
 * Ensures that the provided matcher matches the provided value and
 * returns it.
 *
 * ☡ This function throws if the matcher does not match.
 *
 * ※ This function is not exposed.
 */
const ensureMatches = (matcher, $) => {
  if (matcher($)) {
    return $;
  } else {
    throw new TypeError(
      `सूत्र: Expected a ${matcher.name}, but got: ${$}.`,
    );
  }
};

/**
 * Ensures that the provided value with the provided name is present or
 * absent.
 *
 * ☡ This function throws if the presence of the value is not correct.
 *
 * ※ This function is not exposed.
 */
const ensurePresence = (name, value, present = true) => {
  if ((value !== absent) === !present) {
    throw new TypeError(
      `सूत्र: Expected ${name} to be ${
        present ? "present" : "absent"
      }, but got: ${value}.`,
    );
  } else {
    return value;
  }
};

/**
 * Ensures that the provided value is a valid, complete duration and
 * returns an object with its months and seconds.
 *
 * ☡ This function throws if the provided value is not a valid,
 * complete duration.
 *
 * ※ This function is not exposed.
 */
const duration = ($) => {
  const { months, seconds } = $;
  if (!isIntegralNumber(months)) {
    throw new TypeError(
      `सूत्र: Expected duration to have an integer for months, but got: ${months}.`,
    );
  } else if (!isFiniteNumber(seconds)) {
    throw new TypeError(
      `सूत्र: Expected duration to have a finite number for seconds, but got: ${seconds}.`,
    );
  } else if (months > 0 && seconds < 0 || months < 0 && seconds > 0) {
    throw new TypeError(
      `सूत्र: Expected seconds in duration to match polarity of months, but got: ${seconds}.`,
    );
  } else {
    return { months, seconds };
  }
};

/**
 * Ensures that the provided value is a valid
 * date/timeSevenPropertyModel value and returns an object with its
 * year, month, day, hour, minute, second, and timezoneOffset.
 *
 * ☡ This function throws if the provided value is not a valid
 * date/timeSevenPropertyModel value.
 *
 * ※ This function is not exposed.
 */
const date·timeSevenPropertyModel = ($) => {
  if (type($) !== "object") {
    throw new TypeError(
      `सूत्र: Expected a date/timeSevenPropertyModel value, but got: ${$}.`,
    );
  } else {
    const { year, month, day, hour, minute, second, timezoneOffset } =
      $;
    if (year !== absent && !isIntegralNumber(year)) {
      throw new TypeError(
        `सूत्र: Expected year to be an optional integer, but got: ${year}.`,
      );
    } else if (
      month !== absent &&
      !(isIntegralNumber(month) && month >= 1 && month <= 12)
    ) {
      throw new TypeError(
        `सूत्र: Expected month to be an optional integer between 1 and 12 inclusive, but got: ${month}.`,
      );
    } else if (
      day !== absent &&
      !(isIntegralNumber(day) && day >= 1 && day <= 31)
    ) {
      throw new TypeError(
        `सूत्र: Expected day to be an optional integer between 1 and 31 inclusive, but got: ${day}.`,
      );
    } else if (
      hour !== absent &&
      !(isIntegralNumber(hour) && hour >= 0 && hour <= 24)
    ) {
      throw new TypeError(
        `सूत्र: Expected hour to be an optional integer between 0 and 24 inclusive, but got: ${hour}.`,
      );
    } else if (
      minute !== absent &&
      !(isIntegralNumber(minute) && minute >= 0 && minute <= 59)
    ) {
      throw new TypeError(
        `सूत्र: Expected minute to be an optional integer between 0 and 59 inclusive, but got: ${minute}.`,
      );
    } else if (
      second !== absent &&
      !(isFiniteNumber(second) && second >= 0 && second < 60)
    ) {
      throw new TypeError(
        `सूत्र: Expected second to be an optional finite number greater than or equal to 0 and less than 60, but got: ${second}.`,
      );
    } else if (
      timezoneOffset !== absent &&
      !(isIntegralNumber(timezoneOffset) && timezoneOffset >= -840 &&
        timezoneOffset <= 840)
    ) {
      throw new TypeError(
        `सूत्र: Expected timezoneOffset to be an optional integer between -840 and 840 inclusive, but got: ${timezoneOffset}.`,
      );
    } else if (
      month !== absent && day !== absent && !(
        month === 2 && day === 29
      ) && day > daysInMonth(year, month)
    ) {
      throw new TypeError(
        `सूत्र: The provided day violates the day‐of‐month constraint for month ${month}: ${day}.`,
      );
    } else {
      return {
        year,
        month,
        day,
        hour,
        minute,
        second,
        timezoneOffset,
      };
    }
  }
};

/**
 * Ensures that the provided value is an integer and returns it.
 *
 * ☡ This function throws if the provided value is not an integer.
 *
 * ※ This function is not exposed.
 */
const integer = ($) => {
  if (!isIntegralNumber($)) {
    throw new TypeError(`सूत्र: Expected an integer, but got: ${$}.`);
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a nonnegative integer and returns
 * it.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ This function is not exposed.
 */
const nonnegativeInteger = ($) => {
  if (!(isIntegralNumber($) && $ >= 0)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative integer, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a finite number and returns it.
 *
 * ☡ This function throws if the provided value is not a finite number.
 *
 * ※ This function is not exposed.
 */
const decimalNumber = ($) => {
  if (!(isFiniteNumber($))) {
    throw new TypeError(
      `सूत्र: Expected a finite number, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a nonnegative finite number and
 * returns it.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number.
 *
 * ※ This function is not exposed.
 */
const nonnegativeDecimalNumber = ($) => {
  if (!(isFiniteNumber($) && $ >= 0)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative finite number, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a 32‐bit float and returns it.
 *
 * ☡ This function throws if the provided value is not a 32‐bit float.
 *
 * ※ This function is not exposed.
 */
const float = ($) => {
  if (typeof $ !== "number" || !sameValue(toFloat32($), $)) {
    throw new TypeError(
      `सूत्र: Expected a float value, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a number and returns it.
 *
 * ☡ This function throws if the provided value is not a number.
 *
 * ※ This function is not exposed.
 */
const double = ($) => {
  if (typeof $ !== "number") {
    throw new TypeError(
      `सूत्र: Expected a double value, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

/**
 * Ensures that the provided value is a hexBinary value, i·e a sequence
 * of binary octets.
 *
 * ☡ This function throws if the provided value is not an array buffer.
 *
 * ※ This function is not exposed.
 */
const hexBinaryValue = ($) => {
  if (!isArrayBuffer($)) {
    throw new TypeError(
      `सूत्र: Expected a hexBinary value, but got: ${$}.`,
    );
  } else {
    return $;
  }
};

const {
  /**
   * Converts a string of 0’s and 1’s into a sequence of binary digits.
   *
   * ※ This function is not exposed.
   */
  binaryDigitSequence,

  /**
   * Converts a generator iterator into a sequence of values.
   *
   * ※ This function is not exposed.
   */
  generatorSequence,

  /**
   * Converts a string into a sequence of characters.
   *
   * ※ This function is not exposed.
   */
  literalSequence,
} = (() => {
  const {
    next: generatorIteratorNext,
  } = getPrototype(function* () {}.prototype);
  const { [ITERATOR]: stringIterator } = String.prototype;
  const {
    next: stringIteratorNext,
  } = getPrototype(""[ITERATOR]());
  const binaryDigitIterator = function* () {
    for (const digit of literalSequence(this)) {
      yield digit === "0" ? 0 : 1;
    }
  };
  const binaryDigitSequenceIterablePrototype = {
    [ITERATOR]() {
      return {
        next: bind(
          generatorIteratorNext,
          call(binaryDigitIterator, this.binaryDigits, []),
          [],
        ),
      };
    },
  };
  const generatorSequenceIterablePrototype = {
    [ITERATOR]() {
      return {
        next: bind(
          generatorIteratorNext,
          this.generator(),
          [],
        ),
      };
    },
  };
  const literalSequenceIterablePrototype = {
    [ITERATOR]() {
      return {
        next: bind(
          stringIteratorNext,
          call(stringIterator, this.literal, []),
          [],
        ),
      };
    },
  };

  return {
    binaryDigitSequence: (digits) =>
      objectCreate(
        binaryDigitSequenceIterablePrototype,
        { binaryDigits: { value: digits } },
      ),
    generatorSequence: (generator) =>
      objectCreate(
        generatorSequenceIterablePrototype,
        { generator: { value: generator } },
      ),
    literalSequence: (literal) =>
      objectCreate(
        literalSequenceIterablePrototype,
        { literal: { value: literal } },
      ),
  };
})();

/**
 * Maps each digit to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-digitVal>.
 *
 * ☡ This function throws if the provided value is not a digit string.
 *
 * ※ This function is not exposed.
 */
const digitValue = (d) => +ensureMatches(lexicalDigit, d);

/**
 * Maps a sequence of digits to the position‐weighted sum of the terms
 * numerical values.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-digitSeqVal>.
 *
 * ☡ This function throws if the provided value is not an iterable of
 * digit strings.
 *
 * ※ Although elsewhere the X·S·D specification claims that sequences
 * count from zero, this sequence clearly must count from one.
 *
 * ※ This function is not exposed.
 */
const digitSequenceValue = (S) => {
  let sum = 0;
  for (const S_i of S) {
    sum = sum * 10 + digitValue(S_i);
  }
  return sum;
};

/**
 * Maps a sequence of digits to the position‐weighted sum of the terms
 * numerical values, weighted appropriately for fractional digits.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fracDigitSeqVal>.
 *
 * ☡ This function throws if the provided value is not an iterable of
 * digit strings.
 *
 * ※ The X·S·D specification erroneously specifies ·digitValue·(Si) −
 * 10^(−i), but ·digitValue·(Si) × 10^(−i) is correct.
 *
 * ※ Although elsewhere the X·S·D specification claims that sequences
 * count from zero, this sequence clearly must count from one.
 *
 * ※ This function is not exposed.
 */
const fractionDigitSequenceValue = (S) => {
  let sum = 0;
  let i = 0;
  for (const S_i of S) {
    sum += digitValue(S_i) * 10 ** --i;
  }
  return sum;
};

/**
 * Maps a fracFrag to the appropriate fractional decimal number.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fracFragVal>.
 *
 * ☡ This function throws if the provided value is not a fracFrag
 * string.
 *
 * ※ This function is not exposed.
 */
//deno-lint-ignore no-unused-vars
const fractionFragValue = (N) =>
  fractionDigitSequenceValue(
    literalSequence(ensureMatches(fracFrag, N)),
  );

/**
 * Maps an unsignedNoDecimalPtNumeral to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsNoDecVal>.
 *
 * ☡ This function throws if the provided value is not a
 * unsignedNoDecimalPtNumeral string.
 */
export const unsignedNoDecimalMap = (N) =>
  digitSequenceValue(
    literalSequence(ensureMatches(unsignedNoDecimalPtNumeral, N)),
  );

/**
 * Maps an noDecimalPtNumeral to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-noDecVal>.
 *
 * ☡ This function throws if the provided value is not a
 * noDecimalPtNumeral string.
 */
export const noDecimalMap = (N) => {
  switch (ensureMatches(noDecimalPtNumeral, N)[0]) {
    case "-":
      return -unsignedNoDecimalMap(substring(N, 1)) || 0;
    case "+":
      return unsignedNoDecimalMap(substring(N, 1));
    default:
      return unsignedNoDecimalMap(N);
  }
};

/**
 * Maps an unsignedDecimalPtNumeral to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsDecVal>.
 *
 * ☡ This function throws if the provided value is not a
 * unsignedDecimalPtNumeral string.
 *
 * ※ This function makes use of the built·in Ecmascript float parsing
 * to avoid rounding errors.
 */
export const unsignedDecimalPtMap = (D) => {
  // const N = substring(
  //   ensureMatches(unsignedDecimalPtNumeral, D),
  //   0,
  //   getFirstSubstringIndex(D, "."),
  // );
  // const F = substring(D, N.length + 1);
  // if (F === "") {
  //   return unsignedNoDecimalMap(N);
  // } else if (N === "") {
  //   return fractionFragValue(F);
  // } else {
  //   return unsignedNoDecimalMap(N) + fractionFragValue(F);
  // }
  return stringToFloat(ensureMatches(unsignedDecimalPtNumeral, D));
};

/**
 * Maps an decimalPtNumeral to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-decVal>.
 *
 * ☡ This function throws if the provided value is not a
 * decimalPtNumeral string.
 */
export const decimalPtMap = (N) => {
  switch (ensureMatches(decimalPtNumeral, N)[0]) {
    case "-":
      return -unsignedDecimalPtMap(substring(N, 1)) || 0;
    case "+":
      return unsignedDecimalPtMap(substring(N, 1));
    default:
      return unsignedDecimalPtMap(N);
  }
};

/**
 * Maps a scientificNotationNumeral to its numerical value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-sciVal>.
 *
 * ☡ This function throws if the provided value is not a
 * scientificNotationNumeral string.
 *
 * ※ The X·S·D specification erroneously specifies
 * ·unsignedDecimalPtMap·(E), but ·noDecimalMap·(E) is correct.
 *
 * ※ This function makes use of the built·in Ecmascript float parsing
 * to avoid rounding errors.
 */
export const scientificMap = (N) => {
  // const C = substring(
  //   ensureMatches(scientificNotationNumeral, N),
  //   0,
  //   (() => {
  //     let index = 0;
  //     for (const char of literalSequence(N)) {
  //       if (char === "e" || char === "E") {
  //         return index;
  //       } else {
  //         ++index;
  //         continue;
  //       }
  //     }
  //   })(),
  // );
  // const E = substring(N, C.length + 1);
  // return getFirstSubstringIndex(N, ".") !== -1
  //   ? decimalPtMap(C) * 10 ** noDecimalMap(E)
  //   : noDecimalMap(C) * 10 ** noDecimalMap(E);
  return stringToFloat(ensureMatches(scientificNotationNumeral, N)) ||
    0;
};

/**
 * Maps each integer between 0 and 9 to the corresponding digit.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-digit>.
 *
 * ☡ This function throws if the provided value is not an integral
 * number between 0 and 9 inclusive.
 *
 * ※ This function is not exposed.
 */
const digit = (i) => {
  if (!(isIntegralNumber(i) && i >= 0 && i <= 9)) {
    throw new TypeError(
      `सूत्र: Expected an integral number between 0 and 9 inclusive, but got: ${i}.`,
    );
  } else {
    return `${i}`;
  }
};

/**
 * Maps each nonnegative integer to a sequence of integers used by
 * ·digitSeq· to ultimately create an unsignedNoDecimalPtNumeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-digitRemSeq>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ The sequence produced by this function is infinite.
 *
 * ※ This function is not exposed.
 */
const digitRemainderSeq = (i) => {
  nonnegativeInteger(i);
  return generatorSequence(function* () {
    let s_j = i;
    while (true) {
      yield s_j;
      s_j = div(s_j, 10);
    }
  });
};

/**
 * Maps each nonnegative integer to a sequence of integers used by
 * ·unsignedNoDecimalPtCanonicalMap· to create an
 * unsignedNoDecimalPtNumeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-digitSeq>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ The sequence produced by this function is infinite.
 *
 * ※ This function is not exposed.
 */
const digitSeq = (i) => {
  nonnegativeInteger(i);
  return generatorSequence(function* () {
    for (const i_j of digitRemainderSeq(i)) {
      yield mod(i_j, 10);
    }
  });
};

/**
 * Maps a sequence of nonnegative integers to the index before the
 * first zero term.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-lastSigDigit>.
 *
 * ☡ This function throws if the values of the provided sequence are
 * not nonnegative integers.
 *
 * ※ The X·S·D specification erroneously describes this function as
 * giving the index *of* the first zero term, but it is actually the
 * index of the last nonzero term.
 *
 * ※ The X·S·D specification erroneously describes this function as
 * taking a sequence of nonnegative integers, but it is called with
 * ·FractionDigitRemainderSeq·, which is a list of nonnegative decimal
 * numbers.
 *
 * ※ This function is not exposed.
 */
const lastSignificantDigit = (s) => {
  let j = 0;
  for (const s_j of s) {
    if (nonnegativeDecimalNumber(s_j) === 0) {
      return j === 0 ? 0 : j - 1;
    } else {
      ++j;
      continue;
    }
  }
};

/**
 * Maps each nonnegative decimal number less than 1 to a sequence of
 * decimal numbers used by ·fractionDigitSeq· to ultimately create an
 * unsignedNoDecimalPtNumeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fracDigitRemSeq>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number less than 1.
 *
 * ※ The X·S·D specification erroneously specifies s_0 = f − 10 and
 * s_(j+1) = (s_j ·mod· 1) − 10, but s_0 = f × 10 and s_(j+1) = (s_j
 * ·mod· 1) × 10 is correct.
 *
 * ※ The implementation of this function uses string operations
 * because Ecmascript does not (currently) have a lossless decimal
 * type.
 *
 * ※ The sequence produced by this function is infinite.
 *
 * ※ This function is not exposed.
 */
const FractionDigitRemainderSeq = (f) => {
  if (!(isFiniteNumber(f) && f >= 0 && f < 1)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative finite number less than 1, but got: ${f}.`,
    );
  } else {
    return generatorSequence(function* () {
      let s_j = f * 10;
      while (true) {
        yield s_j;
        s_j = mod(s_j, 1) * 10;
      }
    });
  }
};

/**
 * Maps each nonnegative decimal number less than 1 to a sequence of
 * integers used by ·fractionDigitsCanonicalFragmentMap· to ultimately
 * create an unsignedNoDecimalPtNumeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fracDigitSeq>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number less than 1.
 *
 * ※ The sequence produced by this function is infinite.
 *
 * ※ This function is not exposed.
 */
const fractionDigitSeq = (f) => {
  if (!(isFiniteNumber(f) && f >= 0 && f < 1)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative finite number less than 1, but got: ${f}.`,
    );
  } else {
    return generatorSequence(function* () {
      for (const s_j of FractionDigitRemainderSeq(f)) {
        yield div(s_j, 1);
      }
    });
  }
};

/**
 * Maps each nonnegative decimal number less than 1 to a ·literal· used
 * by ·unsignedDecimalPtCanonicalMap· to create an
 * unsignedDecimalPtNumeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fracDigitsMap>.
 *
 * ☡ This function throws if the provided value is not nonnegative and
 * less than 1.
 *
 * ※ This function is not exposed.
 */
//deno-lint-ignore no-unused-vars
const fractionDigitsCanonicalFragmentMap = (f) =>
  stringCatenate(...generatorSequence(function* () {
    const l = lastSignificantDigit(FractionDigitRemainderSeq(f));
    let j = 0;
    for (const f_j of fractionDigitSeq(f)) {
      yield digit(f_j);
      if (j === l) {
        break;
      } else {
        ++j;
        continue;
      }
    }
  }));

/**
 * Maps a nonnegative integer to a unsignedNoDecimalPtNumeral, its
 * ·canonical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsNoDecCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 */
export const unsignedNoDecimalPtCanonicalMap = (i) => {
  nonnegativeInteger(i);
  return stringCatenate(...generatorSequence(function* () {
    const l = lastSignificantDigit(digitRemainderSeq(i));
    const digits = new Array(l + 1);
    let j = 0;
    for (const i_j of digitSeq(i)) {
      digits[l - j] = digit(i_j);
      if (j === l) {
        break;
      } else {
        ++j;
        continue;
      }
    }
    for (j = 0; j <= l; ++j) {
      yield digits[j];
    }
  }));
};

/**
 * Maps an integer to a noDecimalPtNumeral, its ·canonical
 * representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-noDecCanMap>.
 *
 * ☡ This function throws if the provided value is not an integer.
 */
export const noDecimalPtCanonicalMap = (i) =>
  integer(i) < 0
    ? stringCatenate("-", unsignedNoDecimalPtCanonicalMap(-i))
    : unsignedNoDecimalPtCanonicalMap(i);

/**
 * Maps a nonnegative decimal number to a unsignedDecimalPtNumeral, its
 * ·canonical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsDecCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number.
 *
 * ※ This function makes use of the built·in Ecmascript float
 * serialization to avoid rounding errors.
 */
export const unsignedDecimalPtCanonicalMap = (n) => {
  // nonnegativeDecimalNumber(n);
  // return stringCatenate(
  //   unsignedNoDecimalPtCanonicalMap(div(n, 1)),
  //   ".",
  //   fractionDigitsCanonicalFragmentMap(mod(n, 1)),
  // );
  const exp = toExponentialNotation(nonnegativeDecimalNumber(n));
  const eIndex = getFirstSubstringIndex(exp, "e");
  const exponent = +substring(exp, eIndex + 1);
  const zeroPaddedMantissa = stringPadEnd(
    stringPadStart(
      exp[0],
      -exponent + 1,
      "0",
    ) + (eIndex > 1 ? substring(exp, 2, eIndex) : ""),
    exponent + 2,
    "0",
  );
  const decimalPoint = exponent < 0 ? 1 : exponent + 1;
  return stringCatenate(
    substring(zeroPaddedMantissa, 0, decimalPoint),
    ".",
    substring(zeroPaddedMantissa, decimalPoint),
  );
};

/**
 * Maps a decimal number to a decimalPtNumeral, its ·canonical
 * representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-decCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a finite number.
 */
export const decimalPtCanonicalMap = (n) =>
  decimalNumber(n) < 0
    ? stringCatenate("-", unsignedDecimalPtCanonicalMap(-n))
    : unsignedDecimalPtCanonicalMap(n);

/**
 * Maps a nonnegative decimal number to a
 * unsignedScientificNotationNumeral, its ·canonical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsSciCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number.
 *
 * ※ This function makes use of the built·in Ecmascript float
 * serialization to avoid rounding errors.
 */
export const unsignedScientificCanonicalMap = (n) => {
  // nonnegativeDecimalNumber(n);
  // return stringCatenate(
  //   unsignedDecimalPtCanonicalMap(n / 10 ** div(log10(n), 1)),
  //   "E",
  //   noDecimalPtCanonicalMap(div(log10(n), 1)),
  // );
  const exp = toExponentialNotation(nonnegativeDecimalNumber(n));
  const [mantissa, exponent] = stringSplit(exp, "e");
  return stringCatenate(
    mantissa,
    stringIncludes(mantissa, ".") ? "E" : ".0E",
    exponent[0] === "+" ? substring(exponent, 1) : exponent,
  );
};

/**
 * Maps a decimal number to a scientificNotationNumeral, its ·canonical
 * representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-sciCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a finite number.
 */
export const scientificCanonicalMap = (n) =>
  decimalNumber(n) < 0
    ? stringCatenate("-", unsignedScientificCanonicalMap(-n))
    : unsignedScientificCanonicalMap(n);

/**
 * Maps the ·lexical representations· of ·special values· used with
 * some numerical datatypes to those ·special values·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-specRepVal>.
 *
 * ☡ This function throws if the provided value is not a
 * numericalSpecialRep string.
 */
export const specialRepValue = (c) => {
  switch (ensureMatches(numericalSpecialRep, c)) {
    case "INF":
    case "+INF":
      return positiveInfinity;
    case "-INF":
      return negativeInfinity;
    case "NaN":
      return notANumber;
  }
};

/**
 * Maps the ·special values· used with some numerical datatypes to
 * their ·canonical representations·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-specValCanMap>.
 *
 * ☡ This function throws if the provided value is not nan or positive
 * or negative infinity.
 */
export const specialRepCanonicalMap = (c) => {
  if (sameValue(c, positiveInfinity)) {
    return "INF";
  } else if (sameValue(c, negativeInfinity)) {
    return "-INF";
  } else if (sameValue(c, notANumber)) {
    return "NaN";
  } else {
    throw new TypeError(
      `सूत्र: Expected a special value, but got: ${c}.`,
    );
  }
};

/**
 * Maps a decimalLexicalRep onto a decimal value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-decimalLexmap>.
 *
 * ☡ This function throws if the provided value is not a
 * decimalLexicalRep string.
 */
export const decimalLexicalMap = (LEX) => {
  ensureMatches(decimalLexicalRep, LEX);
  if (noDecimalPtNumeral(LEX)) {
    return noDecimalMap(LEX);
  } else if (decimalPtNumeral(LEX)) {
    return decimalPtMap(LEX);
  }
};

/**
 * Maps a decimal to its ·canonical representation·, a
 * decimalLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-decimalCanmap>.
 *
 * ☡ This function throws if the provided value is not a finite number.
 */
export const decimalCanonicalMap = (d) =>
  isIntegralNumber(decimalNumber(d))
    ? noDecimalPtCanonicalMap(d)
    : decimalPtCanonicalMap(d);

/**
 * Rounds a non-zero decimal number to the nearest floating-point
 * value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-floatPtRound>.
 *
 * ☡ This function throws if the provided value is zero or is not a
 * finite number.
 *
 * ※ This function uses native Ecmascript float rounding methods and
 * only supports a cWidth of 24 or 53.
 *
 * ※ This function is not exposed.
 */
const floatingPointRound = (nV, cWidth, eMin, eMax) => {
  if (!isFiniteNumber(nV) || nV == 0) {
    throw new TypeError(
      `सूत्र: Expected a finite nonzero number, but got: ${nV}.`,
    );
  } else if (cWidth !== 24 && cWidth !== 53) {
    throw new TypeError(
      `सूत्र: Unsupported cWidth: ${cWidth}.`,
    );
  } else if (
    cWidth === 24 && (eMin !== -149 || eMax !== 104) ||
    cWidth === 53 && (eMin !== -1074 || eMax !== 971)
  ) {
    throw new TypeError(
      `सूत्र: Unsupported eMin and eMax for cWidth: ${cWidth}.`,
    );
  } else {
    return cWidth <= 24 ? toFloat32(nV) : +nV;
  }
};

/**
 * Maps a decimal number to that value rounded by some power of 10.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-round>.
 *
 * ☡ This function throws if the provided value is not a finite number.
 *
 * ☡ This function throws if the provided power of 10 is not a
 * nonnegative integer.
 *
 * ※ This function is not exposed.
 */
const round = (n, k) => {
  decimalNumber(n);
  nonnegativeInteger(k);
  return div(n / 10 ** k + 0.5, 1) * 10 ** k;
};

/**
 * Maps a decimal number (c × 10e) to successive approximations.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-round>.
 *
 * ☡ This function throws if the provided values are not a nonnegative
 * integer, an integer, an a nonnegative integer.
 *
 * ※ This function is not exposed.
 */
//deno-lint-ignore no-unused-vars
const floatApprox = (c, e, j) => {
  nonnegativeInteger(c);
  integer(e);
  nonnegativeInteger(j);
  return round(c, j) * 10 ** e;
};

/**
 * Maps a floatRep onto a float value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-floatLexmap>.
 *
 * ☡ This function throws if the provided value is not a floatRep
 * string.
 */
export const floatLexicalMap = (LEX) => {
  ensureMatches(floatRep, LEX);
  if (numericalSpecialRep(LEX)) {
    return specialRepValue(LEX);
  } else {
    const nV = noDecimalPtNumeral(LEX)
      ? noDecimalMap(LEX)
      : decimalPtNumeral(LEX)
      ? decimalPtMap(LEX)
      : scientificMap(LEX);
    const v = nV == 0 ? 0 : floatingPointRound(nV, 24, -149, 104);
    return v == 0 ? LEX[0] === "-" ? negativeZero : positiveZero : v;
  }
};

/**
 * Maps a doubleRep onto a double value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-doubleLexmap>.
 *
 * ☡ This function throws if the provided value is not a doubleRep
 * string.
 */
export const doubleLexicalMap = (LEX) => {
  ensureMatches(doubleRep, LEX);
  if (numericalSpecialRep(LEX)) {
    return specialRepValue(LEX);
  } else {
    const nV = noDecimalPtNumeral(LEX)
      ? noDecimalMap(LEX)
      : decimalPtNumeral(LEX)
      ? decimalPtMap(LEX)
      : scientificMap(LEX);
    const v = nV == 0 ? 0 : floatingPointRound(nV, 53, -1074, 971);
    return v == 0 ? LEX[0] === "-" ? negativeZero : positiveZero : v;
  }
};

/**
 * Maps a float to its ·canonical representation·, a floatRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-floatCanmap>.
 *
 * ☡ This function throws if the provided value is not a 32‐bit float.
 */
export const floatCanonicalMap = (f) => {
  float(f);
  return f === positiveInfinity || f === negativeInfinity ||
      sameValue(f, notANumber)
    ? specialRepCanonicalMap(f)
    : sameValue(f, 0)
    ? "0.0E0"
    : sameValue(f, -0)
    ? "-0.0E0"
    : scientificCanonicalMap(f);
};

/**
 * Maps a double to its ·canonical representation·, a doubleRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-doubleCanmap>.
 *
 * ☡ This function throws if the provided value is not a number.
 */
export const doubleCanonicalMap = (f) => {
  double(f);
  return f === positiveInfinity || f === negativeInfinity ||
      sameValue(f, notANumber)
    ? specialRepCanonicalMap(f)
    : sameValue(f, 0)
    ? "0.0E0"
    : sameValue(f, -0)
    ? "-0.0E0"
    : scientificCanonicalMap(f);
};

/**
 * Maps a duYearFrag to an integer, intended as part of the value of
 * the ·months· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duYrMap>.
 *
 * ☡ This function throws if the provided value is not a duYearFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ This function is not exposed.
 */
const duYearFragmentMap = (Y) =>
  noDecimalMap(stringSlice(ensureMatches(duYearFrag, Y), 0, -1));

/**
 * Maps a duMonthFrag to an integer, intended as part of the value of
 * the ·months· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duMoMap>.
 *
 * ☡ This function throws if the provided value is not a duMonthFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ This function is not exposed.
 */
const duMonthFragmentMap = (M) =>
  noDecimalMap(stringSlice(ensureMatches(duMonthFrag, M), 0, -1));

/**
 * Maps a duDayFrag to an integer, intended as part of the value of the
 * ·seconds· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duDaMap>.
 *
 * ☡ This function throws if the provided value is not a duDayFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ This function is not exposed.
 */
const duDayFragmentMap = (D) =>
  noDecimalMap(stringSlice(ensureMatches(duDayFrag, D), 0, -1));

/**
 * Maps a duHourFrag to an integer, intended as part of the value of
 * the ·seconds· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duHrMap>.
 *
 * ☡ This function throws if the provided value is not a duHourFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ The X·S·D specification has a copypasta typo in the definition of
 * this function; it takes an argument H which necessarily is followed
 * by an "H". There is no D which necessarily begins with "D".
 *
 * ※ This function is not exposed.
 */
const duHourFragmentMap = (H) =>
  noDecimalMap(stringSlice(ensureMatches(duHourFrag, H), 0, -1));

/**
 * Maps a duMinuteFrag to an integer, intended as part of the value of
 * the ·seconds· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duMiMap>.
 *
 * ☡ This function throws if the provided value is not a duMinuteFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ This function is not exposed.
 */
const duMinuteFragmentMap = (M) =>
  noDecimalMap(stringSlice(ensureMatches(duMinuteFrag, M), 0, -1));

/**
 * Maps a duSecondFrag to an integer, intended as part of the value of
 * the ·seconds· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duSeMap>.
 *
 * ☡ This function throws if the provided value is not a duMinuteFrag
 * string.
 *
 * ※ The X·S·D specification erroneously specifies the numeral as
 * following the letter, but it precedes it.
 *
 * ※ This function is not exposed.
 */
const duSecondFragmentMap = (S) =>
  getFirstSubstringIndex(ensureMatches(duSecondFrag, S), ".") !== -1
    ? decimalPtMap(stringSlice(S, 0, -1))
    : noDecimalMap(stringSlice(S, 0, -1));

/**
 * Maps a duYearMonthFrag into an integer, intended as part of the
 * ·months· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duYMMap>.
 *
 * ☡ This function throws if the provided value is not a
 * duYearMonthFrag string.
 *
 * ※ This function is not exposed.
 */
const duYearMonthFragmentMap = (YM) => {
  let Y, M;
  new Matcher(
    rawString`(?<Y>\d+Y)?(?<M>\d+M)?`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      M = groups.M;
      return true;
    },
  )(ensureMatches(duYearMonthFrag, YM));
  const y = Y ? duYearFragmentMap(Y) : 0;
  const m = M ? duMonthFragmentMap(M) : 0;
  return 12 * y + m;
};

/**
 * Maps a duTimeFrag into an integer, intended as part of the ·seconds·
 * property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duTMap>.
 *
 * ☡ This function throws if the provided value is not a duTimeFrag
 * string.
 *
 * ※ The X·S·D specification erroneously applies ·duDayFragmentMap· to
 * H; ·duHourFragmentMap· is correct.
 *
 * ※ This function is not exposed.
 */
const duTimeFragmentMap = (T) => {
  let H, M, S;
  new Matcher(
    rawString`T(?<H>\d+H)?(?<M>\d+M)?(?<S>[\d.]+S)?`,
    undefined,
    (_, { groups }) => {
      H = groups.H;
      M = groups.M;
      S = groups.S;
      return true;
    },
  )(ensureMatches(duTimeFrag, T));
  const h = H ? duHourFragmentMap(H) : 0;
  const m = M ? duMinuteFragmentMap(M) : 0;
  const s = S ? duSecondFragmentMap(S) : 0;
  return 3600 * h + 60 * m + s;
};

/**
 * Maps a duDayTimeFrag into a decimal number, which is the potential
 * value of the ·seconds· property of a duration value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duDTMap>.
 *
 * ☡ This function throws if the provided value is not a duDayTimeFrag
 * string.
 *
 * ※ This function is not exposed.
 */
const duDayTimeFragmentMap = (DT) => {
  let D, T;
  new Matcher(
    rawString`(?<D>\d+D)?(?<T>T.+)?`,
    undefined,
    (_, { groups }) => {
      D = groups.D;
      T = groups.T;
      return true;
    },
  )(ensureMatches(duDayTimeFrag, DT));
  const d = D ? duDayFragmentMap(D) : 0;
  const t = T ? duTimeFragmentMap(T) : 0;
  return 86400 * d + t;
};

/**
 * Separates the durationLexicalRep into the month part and the seconds
 * part, then maps them into the ·months· and ·seconds· of the duration
 * value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-durationMap>.
 *
 * ☡ This function throws if the provided value is not a
 * durationLexicalRep string.
 */
export const durationMap = (DUR) => {
  let Y, D;
  new Matcher(
    rawString`-?P(?<Y>(?:\d+Y)?(?:\d+M)?)(?<D>(?:\d+D)?(?:T.+)?)`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      D = groups.D;
      return true;
    },
  )(ensureMatches(durationLexicalRep, DUR));
  const s = DUR[0] === "-" ? -1 : 1;
  return {
    months: Y ? s * duYearMonthFragmentMap(Y) + 0 : 0, // cast −0 to 0
    seconds: D ? s * duDayTimeFragmentMap(D) + 0 : 0, // cast −0 to 0
  };
};

/**
 * Maps the lexical representation into the ·months· of a
 * yearMonthDuration value.  (A yearMonthDuration's ·seconds· is always
 * zero.)  ·yearMonthDurationMap· is a restriction of ·durationMap·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-yearMonthDurationMap>.
 *
 * ☡ This function throws if the provided value is not a
 * yearMonthDurationLexicalRep string.
 */
export const yearMonthDurationMap = (YM) => {
  const s = YM[0] === "-" ? -1 : 1;
  const Y = substring(
    ensureMatches(yearMonthDurationLexicalRep, YM),
    s === -1 ? 2 : 1,
  );
  return {
    months: s * duYearMonthFragmentMap(Y) + 0, // cast −0 to 0
    seconds: 0,
  };
};

/**
 * Maps the lexical representation into the ·seconds· of a
 * dayTimeDuration value.  (A dayTimeDuration's ·months· is always
 * zero.)  ·dayTimeDurationMap· is a restriction of ·durationMap·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-yearMonthDurationMap>.
 *
 * ☡ This function throws if the provided value is not a
 * dayTimeDurationLexicalRep string.
 *
 * ※ The X·S·D specification erroneously describes the argument as a
 * dayTimeDuration value rather than a dayTimeDurationLexicalRep.
 */
export const dayTimeDurationMap = (DT) => {
  const s = DT[0] === "-" ? -1 : 1;
  const D = substring(
    ensureMatches(dayTimeDurationLexicalRep, DT),
    s === -1 ? 2 : 1,
  );
  return {
    months: 0,
    seconds: s * duDayTimeFragmentMap(D) + 0, // cast −0 to 0
  };
};

/**
 * Maps a nonnegative integer, presumably the absolute value of the
 * ·months· of a duration value, to a duYearMonthFrag, a fragment of a
 * duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duYMCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ This function is not exposed.
 */
const duYearMonthCanonicalFragmentMap = (ym) => {
  nonnegativeInteger(ym);
  const y = div(ym, 12);
  const m = mod(ym, 12);
  return y !== 0 && m !== 0
    ? stringCatenate(
      unsignedNoDecimalPtCanonicalMap(y),
      "Y",
      unsignedNoDecimalPtCanonicalMap(m),
      "M",
    )
    : y !== 0
    ? stringCatenate(
      unsignedNoDecimalPtCanonicalMap(y),
      "Y",
    )
    : stringCatenate(
      unsignedNoDecimalPtCanonicalMap(m),
      "M",
    );
};

/**
 * Maps a nonnegative integer, presumably the day normalized value from
 * the ·seconds· of a duration value, to a duDayFrag, a fragment of a
 * duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duDCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ Despite the description, this function does not necessarily
 * return a duDayFrag (it can return an empty string).
 *
 * ※ This function is not exposed.
 */
const duDayCanonicalFragmentMap = (d) =>
  d !== 0
    ? stringCatenate(
      unsignedNoDecimalPtCanonicalMap(d),
      "D",
    )
    : "";

/**
 * Maps a nonnegative integer, presumably the hour normalized value
 * from the ·seconds· of a duration value, to a duHourFrag, a fragment
 * of a duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duHCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ Despite the description, this function does not necessarily
 * return a duHourFrag (it can return an empty string).
 *
 * ※ This function is not exposed.
 */
const duHourCanonicalFragmentMap = (h) =>
  h !== 0
    ? stringCatenate(
      unsignedNoDecimalPtCanonicalMap(h),
      "H",
    )
    : "";

/**
 * Maps a nonnegative integer, presumably the minute normalized value
 * from the ·seconds· of a duration value, to a duMinuteFrag, a
 * fragment of a duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duMCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer.
 *
 * ※ Despite the description, this function does not necessarily
 * return a duMinuteFrag (it can return an empty string).
 *
 * ※ This function is not exposed.
 */
const duMinuteCanonicalFragmentMap = (m) =>
  m !== 0
    ? stringCatenate(
      unsignedNoDecimalPtCanonicalMap(m),
      "M",
    )
    : "";

/**
 * Maps a nonnegative decimal number, presumably the second normalized
 * value from the ·seconds· of a duration value, to a duSecondFrag, a
 * fragment of a duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duSCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number.
 *
 * ※ Despite the description, this function does not necessarily
 * return a duSecondFrag (it can return an empty string).
 *
 * ※ This function is not exposed.
 */
const duSecondCanonicalFragmentMap = (s) =>
  s !== 0
    ? stringCatenate(
      isIntegralNumber(s)
        ? unsignedNoDecimalPtCanonicalMap(s)
        : unsignedDecimalPtCanonicalMap(s),
      "S",
    )
    : "";

/**
 * Maps three nonnegative numbers, presumably the hour, minute, and
 * second normalized values from a duration's ·seconds·, to a
 * duTimeFrag, a fragment of a duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duTCan>.
 *
 * ☡ This function throws if either of the first two provided values
 * are not nonnegative integers, or if the final provided value is not
 * a nonnegative finite number.
 *
 * ※ Despite the description, this function does not necessarily
 * return a duTimeFrag (it can return an empty string).
 *
 * ※ This function is not exposed.
 */
const duTimeCanonicalFragmentMap = (h, m, s) =>
  h !== 0 || m !== 0 || s !== 0
    ? stringCatenate(
      "T",
      duHourCanonicalFragmentMap(h),
      duMinuteCanonicalFragmentMap(m),
      duSecondCanonicalFragmentMap(s),
    )
    : "";

/**
 * Maps a nonnegative decimal number, presumably the absolute value of
 * the ·seconds· of a duration value, to a duDayTimeFrag, a fragment of
 * a duration ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-duDTCan>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number.
 *
 * ※ This function is not exposed.
 */
const duDayTimeCanonicalFragmentMap = (ss) => {
  nonnegativeDecimalNumber(ss);
  const d = div(ss, 86400);
  const h = div(mod(ss, 86400), 3600);
  const m = div(mod(ss, 3600), 60);
  const s = mod(ss, 60);
  return ss !== 0
    ? stringCatenate(
      duDayCanonicalFragmentMap(d),
      duTimeCanonicalFragmentMap(h, m, s),
    )
    : "T0S";
};

/**
 * Maps a duration's property values to durationLexicalRep fragments
 * and combines the fragments into a complete durationLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-durationCanMap>.
 *
 * ☡ This function throws if the provided value is not a complete
 * duration value.
 */
export const durationCanonicalMap = (v) => {
  const { months: m, seconds: s } = duration(v);
  const sgn = m < 0 || s < 0 ? "-" : "";
  return m !== 0 && s !== 0
    ? stringCatenate(
      sgn,
      "P",
      duYearMonthCanonicalFragmentMap(abs(m)),
      duDayTimeCanonicalFragmentMap(abs(s)),
    )
    : m !== 0
    ? stringCatenate(
      sgn,
      "P",
      duYearMonthCanonicalFragmentMap(abs(m)),
    )
    : stringCatenate(
      sgn,
      "P",
      duDayTimeCanonicalFragmentMap(abs(s)),
    );
};

/**
 * Maps a yearMonthDuration's ·months· value to a
 * yearMonthDurationLexicalRep.  (The ·seconds· value is necessarily
 * zero and is ignored.)  ·yearMonthDurationCanonicalMap· is a
 * restriction of ·durationCanonicalMap·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-yearMonthDurationCanMap>.
 *
 * ☡ This function throws if the provided value is not a complete
 * yearMonthDuration value.
 */
export const yearMonthDurationCanonicalMap = (ym) => {
  const { months: m, seconds: s } = duration(ym);
  if (s !== 0) {
    throw new TypeError(
      `सूत्र: Expected the provided yearMonthDuration to have a value of zero for seconds, but got: ${s}.`,
    );
  } else {
    const sgn = m < 0 ? "-" : "";
    return stringCatenate(
      sgn,
      "P",
      duYearMonthCanonicalFragmentMap(abs(m)),
    );
  }
};

/**
 * Maps a dayTimeDuration's ·seconds· value to a
 * dayTimeDurationLexicalRep.  (The ·months· value is necessarily zero
 * and is ignored.)  ·dayTimeDurationCanonicalMap· is a restriction of
 * ·durationCanonicalMap·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dayTimeDurationCanMap>.
 *
 * ☡ This function throws if the provided value is not a complete
 * dayTimeDuration value.
 */
export const dayTimeDurationCanonicalMap = (dt) => {
  const { months: m, seconds: s } = duration(dt);
  if (m !== 0) {
    throw new TypeError(
      `सूत्र: Expected the provided dayTimeDuration to have a value of zero for months, but got: ${m}.`,
    );
  } else {
    const sgn = s < 0 ? "-" : "";
    return stringCatenate(
      sgn,
      "P",
      duDayTimeCanonicalFragmentMap(abs(s)),
    );
  }
};

/**
 * If month (mo) is out of range, adjust month and year (yr)
 * accordingly; otherwise, make no change.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-normMo>.
 *
 * ☡ This function throws if the provided values are not integers.
 *
 * ※ This function is not exposed.
 */
const normalizeMonth = (yr, mo) => {
  integer(yr);
  integer(mo);
  return [yr + div(mo - 1, 12), mod(mo - 1, 12) + 1];
};

/**
 * If month (mo) is out of range, or day (da) is out of range for the
 * appropriate month, then adjust values accordingly, otherwise make no
 * change.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-normDa>.
 *
 * ☡ This function throws if the provided values are not integers.
 *
 * ※ This function is not exposed.
 */
const normalizeDay = (yr, mo, da) => {
  integer(yr);
  integer(mo);
  integer(da);
  [yr, mo] = normalizeMonth(yr, mo);
  let limit = daysInMonth(yr, mo);
  while (da > limit || da <= 0) {
    if (da > limit) {
      da -= limit;
      mo += 1;
      [yr, mo] = normalizeMonth(yr, mo);
      limit = daysInMonth(yr, mo);
    }
    if (da <= 0) {
      mo -= 1;
      [yr, mo] = normalizeMonth(yr, mo);
      limit = daysInMonth(yr, mo);
      da += limit;
    }
  }
  return [yr, mo, da];
};

/**
 * Normalizes minute, hour, month, and year values to values that obey
 * the appropriate constraints.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-normMi>.
 *
 * ☡ This function throws if the provided values are not integers.
 *
 * ※ This function is not exposed.
 */
const normalizeMinute = (yr, mo, da, hr, mi) => {
  integer(yr);
  integer(mo);
  integer(da);
  integer(hr);
  integer(mi);
  hr += div(mi, 60);
  mi = mod(mi, 60);
  da += div(hr, 24);
  hr = mod(hr, 24);
  [yr, mo, da] = normalizeDay(yr, mo, da);
  return [yr, mo, da, hr, mi];
};

/**
 * Normalizes minute, hour, month, and year values to values that obey
 * the appropriate constraints.  (This algorithm ignores leap seconds.)
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-normSe>.
 *
 * ☡ This function throws if the first five provided values are not
 * integers or the sixth is not a finite number.
 *
 * ※ This function is not exposed.
 */
const normalizeSecond = (yr, mo, da, hr, mi, se) => {
  integer(yr);
  integer(mo);
  integer(da);
  integer(hr);
  integer(mi);
  decimalNumber(se);
  mi += div(se, 60);
  se = mod(se, 60);
  [yr, mo, da, hr, mi] = normalizeMinute(yr, mo, da, hr, mi);
  return [yr, mo, da, hr, mi, se];
};

/**
 * Normalizes minute, hour, month, and year values to values that obey
 * the appropriate constraints.  (This algorithm ignores leap seconds.)
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-daysInMonth>.
 *
 * ☡ This function throws if the first value is not absent or an
 * integer or if the second value is not an integer between 1 and 12
 * inclusive.
 */
export const daysInMonth = (y, m) => {
  if (y !== absent && !isIntegralNumber(y)) {
    throw new TypeError(
      `सूत्र: Expected an optional integer, but got: ${y}.`,
    );
  } else if (!(isIntegralNumber(m) && m >= 1 && m <= 12)) {
    throw new TypeError(
      `सूत्र: Expected an integer between 1 and 12 inclusive, but got: ${m}.`,
    );
  } else {
    return m === 2
      ? y === absent || y % 4 || !(y % 100) && y % 400 ? 28 : 29
      : m === 4 || m === 6 || m === 9 || m === 11
      ? 30
      : 31;
  }
};

/**
 * Returns an instance of the date/timeSevenPropertyModel with property
 * values as specified in the arguments. If an argument is omitted, the
 * corresponding property is set to absent.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#p-setDTFromRaw>.
 *
 * ※ The X·S·D specification erroneously fails to account for the
 * value `"--02-29"`, which `·newDateTime·` treats as 01 March because
 * it assumes February has 28 days when the year is absent. This is a
 * correct assumption generally, but February should be treated as
 * having 29 days when a value of `"--02-29"` is explicity given.
 *
 * ☡ This function throws if the provided values do not match the
 * ranges expected by the Date∕time Seven‐Property Model.
 */
export const newDateTime = (Yr, Mo, Da, Hr, Mi, Se, Tz) => {
  if (Yr !== absent && !isIntegralNumber(Yr)) {
    throw new TypeError(
      `सूत्र: Expected an optional integer, but got: ${Yr}.`,
    );
  } else if (
    Mo !== absent && !(isIntegralNumber(Mo) && Mo >= 1 && Mo <= 12)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional integer between 1 and 12 inclusive, but got: ${Mo}.`,
    );
  } else if (
    Da !== absent && !(isIntegralNumber(Da) && Da >= 1 && Da <= 31)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional integer between 1 and 31 inclusive, but got: ${Da}.`,
    );
  } else if (
    Hr !== absent && !(isIntegralNumber(Hr) && Hr >= 0 && Hr <= 24)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional integer between 0 and 24 inclusive, but got: ${Hr}.`,
    );
  } else if (
    Mi !== absent && !(isIntegralNumber(Mi) && Mi >= 0 && Mi <= 59)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional integer between 0 and 59 inclusive, but got: ${Mi}.`,
    );
  } else if (
    Se !== absent && !(isFiniteNumber(Se) && Se >= 0 && Se < 60)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional finite number greater than or equal to 0 and less than 60, but got: ${Se}.`,
    );
  } else if (
    Tz !== absent && !(isIntegralNumber(Tz) && Tz >= -840 && Tz <= 840)
  ) {
    throw new TypeError(
      `सूत्र: Expected an optional integer between -840 and 840 inclusive, but got: ${Tz}.`,
    );
  } else {
    let yr = Yr !== absent ? Yr : Mo === 2 && Da === 29 ? 0 : 1;
    let mo = Mo !== absent ? Mo : 1;
    let da = Da !== absent ? Da : 1;
    let hr = Hr !== absent ? Hr : 0;
    let mi = Mi !== absent ? Mi : 0;
    let se = Se !== absent ? Se : 0;
    [yr, mo, da, hr, mi, se] = normalizeSecond(yr, mo, da, hr, mi, se);
    return {
      year: Yr === absent ? absent : yr,
      month: Mo === absent ? absent : mo,
      day: Da === absent ? absent : da,
      hour: Hr === absent ? absent : hr,
      minute: Mi === absent ? absent : mi,
      second: Se === absent ? absent : se,
      timezoneOffset: Tz,
    };
  }
};

/**
 * Adds a duration to a dateTime value, producing another dateTime
 * value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dt-dateTimePlusDuration>.
 *
 * ※ The X·S·D specification erroneously fails to account for the
 * value `"--02-29"`, which `·dateTimePlusDuration·` treats as 01 March
 * because it assumes February has 28 days when the year is absent.
 * This is a correct assumption generally, but February should be
 * treated as having 29 days when a value of `"--02-29"` is explicity
 * given.
 *
 * ☡ This function throws if the provided duration or
 * date/timeSevenPropertyModel values are not valid.
 *
 * ※ Despite the name and description, this function can add a
 * duration to any date/timeSevenPropertyModel value.
 */
export const dateTimePlusDuration = (du, dt) => {
  const { months, seconds } = duration(du);
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(dt);
  let yr = year !== absent ? year : month === 2 && day === 29 ? 0 : 1;
  let mo = month !== absent ? month : 1;
  let da = day !== absent ? day : 1;
  let hr = hour !== absent ? hour : 0;
  let mi = minute !== absent ? minute : 0;
  let se = second !== absent ? second : 0;
  mo += months;
  [yr, mo] = normalizeMonth(yr, mo);
  da = min(da, daysInMonth(yr, mo));
  se += seconds;
  [yr, mo, da, hr, mi, se] = normalizeSecond(yr, mo, da, hr, mi, se);
  return newDateTime(
    year === absent ? absent : yr,
    month === absent ? absent : mo,
    day === absent ? absent : da,
    hour === absent ? absent : hr,
    minute === absent ? absent : mi,
    second === absent ? absent : se,
    timezoneOffset,
  );
};

/**
 * Maps a date/timeSevenPropertyModel value to the decimal number
 * representing its position on the "time line".
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dt-timeOnTimeline>.
 *
 * ☡ This function throws if the provided date/timeSevenPropertyModel
 * value is not valid.
 */
export const timeOnTimeline = (dt) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(dt);
  const yr = year === absent ? 1971 : year - 1;
  const mo = month === absent ? 12 : month;
  const da = day === absent ? daysInMonth(yr + 1, mo) - 1 : day - 1;
  const hr = hour === absent ? 0 : hour;
  const mi = (minute === absent ? 0 : minute) -
    (timezoneOffset === absent ? 0 : timezoneOffset);
  const se = second === absent ? 0 : second;
  let ToTI = 31536000 * yr;
  ToTI += 86400 * (div(yr, 400) - div(yr, 100) + div(yr, 4));
  for (let m = 1; m < mo; ++m) {
    ToTI += 86400 * daysInMonth(yr + 1, m);
  }
  ToTI += 86400 * da;
  ToTI += 3600 * hr + 60 * mi + se;
  return ToTI;
};

/**
 * Maps a yearFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto an integer, presumably the ·year· property of
 * a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-yrMap>.
 *
 * ☡ This function throws if the provided value is not a yearFrag
 * string.
 */
export const yearFragValue = (YR) =>
  noDecimalMap(ensureMatches(yearFrag, YR));

/**
 * Maps a monthFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto an integer, presumably the ·month· property of
 * a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-moMap>.
 *
 * ☡ This function throws if the provided value is not a monthFrag
 * string.
 */
export const monthFragValue = (MO) =>
  unsignedNoDecimalMap(ensureMatches(monthFrag, MO));

/**
 * Maps a dayFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto an integer, presumably the ·day· property of a
 * date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-daMap>.
 *
 * ☡ This function throws if the provided value is not a dayFrag
 * string.
 */
export const dayFragValue = (DA) =>
  unsignedNoDecimalMap(ensureMatches(dayFrag, DA));

/**
 * Maps a hourFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto an integer, presumably the ·hour· property of
 * a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-hrMap>.
 *
 * ☡ This function throws if the provided value is not a hourFrag
 * string.
 */
export const hourFragValue = (HR) =>
  unsignedNoDecimalMap(ensureMatches(hourFrag, HR));

/**
 * Maps a minuteFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto an integer, presumably the ·minute· property
 * of a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-miMap>.
 *
 * ☡ This function throws if the provided value is not a minuteFrag
 * string.
 */
export const minuteFragValue = (MI) =>
  unsignedNoDecimalMap(ensureMatches(minuteFrag, MI));

/**
 * Maps a secondFrag, part of a date/timeSevenPropertyModel's ·lexical
 * representation·, onto a decimal number, presumably the ·second·
 * property of a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-seMap>.
 *
 * ☡ This function throws if the provided value is not a secondFrag
 * string.
 */
export const secondFragValue = (SE) =>
  getFirstSubstringIndex(ensureMatches(secondFrag, SE), ".") === -1
    ? unsignedNoDecimalMap(SE)
    : unsignedDecimalPtMap(SE);

/**
 * Maps a timezoneFrag, part of a date/timeSevenPropertyModel's
 * ·lexical representation·, onto an integer, presumably the
 * ·timezoneOffset· property of a date/timeSevenPropertyModel value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-dt-tzMap>.
 *
 * ※ The X·S·D specification erroneously specifies
 * ·unsignedDecimalPtMap·(H) and ·unsignedDecimalPtMap·(M), but
 * ·unsignedNoDecimalMap·(H) and ·unsignedDecimalPtMap·(M) is correct.
 *
 * ☡ This function throws if the provided value is not a timezoneFrag
 * string.
 */
export const timezoneFragValue = (TZ) => {
  const s = ensureMatches(timezoneFrag, TZ)[0];
  if (s === "Z") {
    return 0;
  } else {
    let H, M;
    new Matcher(
      rawString`[+-](?<H>\d{2}):(?<M>\d{2})`,
      undefined,
      (_, { groups }) => {
        H = groups.H;
        M = groups.M;
        return true;
      },
    )(TZ);
    return s === "-"
      ? -(unsignedNoDecimalMap(H) * 60 + unsignedNoDecimalMap(M)) + 0
      : unsignedNoDecimalMap(H) * 60 + unsignedNoDecimalMap(M);
  }
};

/**
 * Maps a dateTimeLexicalRep to a dateTime value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dateTimeLexRep>.
 *
 * ☡ This function throws if the provided value is not a
 * dateTimeLexicalRep string.
 */
export const dateTimeLexicalMap = (LEX) => {
  let Y, MO, D, H, MI, S, T;
  new Matcher(
    rawString`(?<Y>-?\d+)-(?<MO>\d+)-(?<D>\d+)T(?:24:00:00(?:\.0+)?|(?<H>\d+):(?<MI>\d+):(?<S>[\d.]+))(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      MO = groups.MO;
      D = groups.D;
      H = groups.H ?? absent;
      MI = groups.MI ?? absent;
      S = groups.S ?? absent;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(dateTimeLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return H === absent
    ? newDateTime(
      yearFragValue(Y),
      monthFragValue(MO),
      dayFragValue(D),
      24,
      0,
      0,
      tz,
    )
    : newDateTime(
      yearFragValue(Y),
      monthFragValue(MO),
      dayFragValue(D),
      hourFragValue(H),
      minuteFragValue(MI),
      secondFragValue(S),
      tz,
    );
};

/**
 * Maps a timeLexicalMap to a time value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-timeLexRep>.
 *
 * ☡ This function throws if the provided value is not a timeLexicalMap
 * string.
 */
export const timeLexicalMap = (LEX) => {
  let H, MI, S, T;
  new Matcher(
    rawString`(?:24:00:00(?:\.0+)?|(?<H>\d+):(?<MI>\d+):(?<S>[\d.]+))(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      H = groups.H ?? absent;
      MI = groups.MI ?? absent;
      S = groups.S ?? absent;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(timeLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return H === absent
    ? newDateTime(
      absent,
      absent,
      absent,
      0,
      0,
      0,
      tz,
    )
    : newDateTime(
      absent,
      absent,
      absent,
      hourFragValue(H),
      minuteFragValue(MI),
      secondFragValue(S),
      tz,
    );
};

/**
 * Maps a dateLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dateLexRep>.
 *
 * ☡ This function throws if the provided value is not a dateLexicalRep
 * string.
 */
export const dateLexicalMap = (LEX) => {
  let Y, M, D, T;
  new Matcher(
    rawString`(?<Y>-?\d+)-(?<M>\d+)-(?<D>\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      M = groups.M;
      D = groups.D;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(dateLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    yearFragValue(Y),
    monthFragValue(M),
    dayFragValue(D),
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a gYearMonthLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gYearMonthLexRep>.
 *
 * ☡ This function throws if the provided value is not a
 * gYearMonthLexicalRep string.
 */
export const gYearMonthLexicalMap = (LEX) => {
  let Y, M, T;
  new Matcher(
    rawString`(?<Y>-?\d+)-(?<M>\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      M = groups.M;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(gYearMonthLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    yearFragValue(Y),
    monthFragValue(M),
    absent,
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a gYearLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gYearLexRep>.
 *
 * ☡ This function throws if the provided value is not a
 * gYearLexicalRep string.
 */
export const gYearLexicalMap = (LEX) => {
  let Y, T;
  new Matcher(
    rawString`(?<Y>-?\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      Y = groups.Y;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(gYearLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    yearFragValue(Y),
    absent,
    absent,
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a gMonthDayLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gMonthDayLexRep>.
 *
 * ☡ This function throws if the provided value is not a
 * gMonthDayLexicalRep string.
 */
export const gMonthDayLexicalMap = (LEX) => {
  let M, D, T;
  new Matcher(
    rawString`--(?<M>\d+)-(?<D>\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      M = groups.M;
      D = groups.D;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(gMonthDayLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    absent,
    monthFragValue(M),
    dayFragValue(D),
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a gDayLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gDayLexRep>.
 *
 * ☡ This function throws if the provided value is not a gDayLexicalRep
 * string.
 */
export const gDayLexicalMap = (LEX) => {
  let D, T;
  new Matcher(
    rawString`---(?<D>\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      D = groups.D;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(gDayLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    absent,
    absent,
    dayFragValue(D),
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a gMonthLexicalRep to a date value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gMonthLexRep>.
 *
 * ☡ This function throws if the provided value is not a
 * gMonthLexicalRep string.
 */
export const gMonthLexicalMap = (LEX) => {
  let M, T;
  new Matcher(
    rawString`--(?<M>\d+)(?<T>.+)?`,
    undefined,
    (_, { groups }) => {
      M = groups.M;
      T = groups.T ?? absent;
      return true;
    },
  )(ensureMatches(gMonthLexicalRep, LEX));
  const tz = T === absent ? absent : timezoneFragValue(T);
  return newDateTime(
    absent,
    monthFragValue(M),
    absent,
    absent,
    absent,
    absent,
    tz,
  );
};

/**
 * Maps a nonnegative integer less than 100 onto an unsigned
 * always-two-digit numeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-unsTwoDigCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * integer less than 100.
 *
 * ※ This function is not exposed.
 */
const unsTwoDigitCanonicalFragmentMap = (i) => {
  if (!(isIntegralNumber(i) && i >= 0 && i < 100)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative integer less than 100, but got: ${i}.`,
    );
  } else {
    return stringCatenate(digit(div(i, 10)), digit(mod(i, 10)));
  }
};

/**
 * Maps an integer between -10000 and 10000 onto an always-four-digit numeral.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-fourDigCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer whose
 * absolute value is less than 10000.
 *
 * ※ This function is not exposed.
 */
const fourDigitCanonicalFragmentMap = (i) => {
  if (!(isIntegralNumber(i) && abs(i) < 10000)) {
    throw new TypeError(
      `सूत्र: Expected an integer whose absolute value is less than 10000, but got: ${i}.`,
    );
  } else {
    return i < 0
      ? stringCatenate(
        "-",
        unsTwoDigitCanonicalFragmentMap(div(-i, 100)),
        unsTwoDigitCanonicalFragmentMap(mod(-i, 100)),
      )
      : stringCatenate(
        unsTwoDigitCanonicalFragmentMap(div(i, 100)),
        unsTwoDigitCanonicalFragmentMap(mod(i, 100)),
      );
  }
};

/**
 * Maps an integer, presumably the ·year· property of a
 * date/timeSevenPropertyModel value, onto a yearFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-yrCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer.
 */
export const yearCanonicalFragmentMap = (y) =>
  abs(integer(y)) > 9999
    ? noDecimalPtCanonicalMap(y)
    : fourDigitCanonicalFragmentMap(y);

/**
 * Maps an integer, presumably the ·month· property of a
 * date/timeSevenPropertyModel value, onto a monthFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-moCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer
 * between 1 and 12 inclusive.
 */
export const monthCanonicalFragmentMap = (m) => {
  if (!(isIntegralNumber(m) && m >= 1 && m <= 12)) {
    throw new TypeError(
      `सूत्र: Expected an integer between 1 and 12 inclusive, but got: ${m}.`,
    );
  } else {
    return unsTwoDigitCanonicalFragmentMap(m);
  }
};

/**
 * Maps an integer, presumably the ·day· property of a
 * date/timeSevenPropertyModel value, onto a dayFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-daCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer
 * between 1 and 31 inclusive.
 */
export const dayCanonicalFragmentMap = (d) => {
  if (!(isIntegralNumber(d) && d >= 1 && d <= 31)) {
    throw new TypeError(
      `सूत्र: Expected an integer between 1 and 31 inclusive, but got: ${d}.`,
    );
  } else {
    return unsTwoDigitCanonicalFragmentMap(d);
  }
};

/**
 * Maps an integer, presumably the ·hour· property of a
 * date/timeSevenPropertyModel value, onto an hourFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hrCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer
 * between 0 and 23 inclusive.
 */
export const hourCanonicalFragmentMap = (h) => {
  if (!(isIntegralNumber(h) && h >= 0 && h <= 23)) {
    throw new TypeError(
      `सूत्र: Expected an integer between 0 and 23 inclusive, but got: ${h}.`,
    );
  } else {
    return unsTwoDigitCanonicalFragmentMap(h);
  }
};

/**
 * Maps an integer, presumably the ·minute· property of a
 * date/timeSevenPropertyModel value, onto a minuteFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-miCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer
 * between 0 and 59 inclusive.
 */
export const minuteCanonicalFragmentMap = (m) => {
  if (!(isIntegralNumber(m) && m >= 0 && m <= 59)) {
    throw new TypeError(
      `सूत्र: Expected an integer between 0 and 59 inclusive, but got: ${m}.`,
    );
  } else {
    return unsTwoDigitCanonicalFragmentMap(m);
  }
};

/**
 * Maps a decimal number, presumably the ·second· property of a
 * date/timeSevenPropertyModel value, onto a secondFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-seCanFragMap>.
 *
 * ☡ This function throws if the provided value is not a nonnegative
 * finite number less than 60.
 *
 * ※ The X·S·D specification identifies the argument to this function
 * as “a nonnegative decimal number less than 70”, but second values 60
 * or larger are not supported by X·S·D.
 *
 * ※ This function makes use of the built·in Ecmascript float
 * serialization to avoid rounding errors.
 */
export const secondCanonicalFragmentMap = (s) => {
  if (!(isFiniteNumber(s) && s < 60)) {
    throw new TypeError(
      `सूत्र: Expected a nonnegative finite number less than 60, but got: ${s}.`,
    );
  } else {
    // return isIntegralNumber(s)
    //  ? unsTwoDigitCanonicalFragmentMap(s)
    //  : stringCatenate(
    //    unsTwoDigitCanonicalFragmentMap(div(s, 1)),
    //    ".",
    //    fractionDigitsCanonicalFragmentMap(mod(s, 1)),
    //  );
    return isIntegralNumber(s)
      ? unsTwoDigitCanonicalFragmentMap(s)
      : s < 10
      ? stringCatenate("0", decimalPtCanonicalMap(s))
      : decimalPtCanonicalMap(s);
  }
};

/**
 * Maps an integer, presumably the ·timezoneOffset· property of a
 * date/timeSevenPropertyModel value, onto a timezoneFrag, part of a
 * date/timeSevenPropertyModel's ·lexical representation·.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-tzCanFragMap>.
 *
 * ☡ This function throws if the provided value is not an integer
 * between −840 and 840 inclusive.
 */
export const timezoneCanonicalFragmentMap = (t) => {
  if (!(isIntegralNumber(t) && t >= -840 && t <= 840)) {
    throw new TypeError(
      `सूत्र: Expected an integer between −840 and 840 inclusive, but got: ${t}.`,
    );
  } else {
    return t === 0 ? "Z" : t < 0
      ? stringCatenate(
        "-",
        unsTwoDigitCanonicalFragmentMap(div(-t, 60)),
        ":",
        unsTwoDigitCanonicalFragmentMap(mod(-t, 60)),
      )
      : stringCatenate(
        "+",
        unsTwoDigitCanonicalFragmentMap(div(t, 60)),
        ":",
        unsTwoDigitCanonicalFragmentMap(mod(t, 60)),
      );
  }
};

/**
 * Maps a dateTime value to a dateTimeLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dateTimeCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete
 * dateTime.
 */
export const dateTimeCanonicalMap = (dt) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(dt);
  ensurePresence("year", year, true);
  ensurePresence("month", month, true);
  ensurePresence("day", day, true);
  ensurePresence("hour", hour, true);
  ensurePresence("minute", minute, true);
  ensurePresence("second", second, true);
  const DT = stringCatenate(
    yearCanonicalFragmentMap(year),
    "-",
    monthCanonicalFragmentMap(month),
    "-",
    dayCanonicalFragmentMap(day),
    "T",
    hourCanonicalFragmentMap(hour),
    ":",
    minuteCanonicalFragmentMap(minute),
    ":",
    secondCanonicalFragmentMap(second),
  );
  return timezoneOffset === absent
    ? DT
    : stringCatenate(DT, timezoneCanonicalFragmentMap(timezoneOffset));
};

/**
 * Maps a time value to a timeLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-timeCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete time.
 */
export const timeCanonicalMap = (ti) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(ti);
  ensurePresence("year", year, false);
  ensurePresence("month", month, false);
  ensurePresence("day", day, false);
  ensurePresence("hour", hour, true);
  ensurePresence("minute", minute, true);
  ensurePresence("second", second, true);
  const T = stringCatenate(
    hourCanonicalFragmentMap(hour),
    ":",
    minuteCanonicalFragmentMap(minute),
    ":",
    secondCanonicalFragmentMap(second),
  );
  return timezoneOffset === absent
    ? T
    : stringCatenate(T, timezoneCanonicalFragmentMap(timezoneOffset));
};

/**
 * Maps a date value to a dateLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-dateCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete date.
 */
export const dateCanonicalMap = (da) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(da);
  ensurePresence("year", year, true);
  ensurePresence("month", month, true);
  ensurePresence("day", day, true);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  const D = stringCatenate(
    yearCanonicalFragmentMap(year),
    "-",
    monthCanonicalFragmentMap(month),
    "-",
    dayCanonicalFragmentMap(day),
  );
  return timezoneOffset === absent
    ? D
    : stringCatenate(D, timezoneCanonicalFragmentMap(timezoneOffset));
};

/**
 * Maps a gYearMonth value to a gYearMonthLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gYearMonthCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete
 * gYearMonth.
 */
export const gYearMonthCanonicalMap = (ym) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(ym);
  ensurePresence("year", year, true);
  ensurePresence("month", month, true);
  ensurePresence("day", day, false);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  const YM = stringCatenate(
    yearCanonicalFragmentMap(year),
    "-",
    monthCanonicalFragmentMap(month),
  );
  return timezoneOffset === absent
    ? YM
    : stringCatenate(YM, timezoneCanonicalFragmentMap(timezoneOffset));
};

/**
 * Maps a gYear value to a gYearLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gYearCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete
 * gYear.
 */
export const gYearCanonicalMap = (gY) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(gY);
  ensurePresence("year", year, true);
  ensurePresence("month", month, false);
  ensurePresence("day", day, false);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  return timezoneOffset === absent
    ? yearCanonicalFragmentMap(year)
    : stringCatenate(
      yearCanonicalFragmentMap(year),
      timezoneCanonicalFragmentMap(timezoneOffset),
    );
};

/**
 * Maps a gMonthDay value to a gMonthDayLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gMonthDayCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete
 * gMonthDay.
 */
export const gMonthDayCanonicalMap = (md) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(md);
  ensurePresence("year", year, false);
  ensurePresence("month", month, true);
  ensurePresence("day", day, true);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  const MD = stringCatenate(
    "--",
    monthCanonicalFragmentMap(month),
    "-",
    dayCanonicalFragmentMap(day),
  );
  return timezoneOffset === absent
    ? MD
    : stringCatenate(MD, timezoneCanonicalFragmentMap(timezoneOffset));
};

/**
 * Maps a gDay value to a gDayLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gDayCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete gDay.
 */
export const gDayCanonicalMap = (gD) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(gD);
  ensurePresence("year", year, false);
  ensurePresence("month", month, false);
  ensurePresence("day", day, true);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  return timezoneOffset === absent
    ? stringCatenate("---", dayCanonicalFragmentMap(day))
    : stringCatenate(
      "---",
      dayCanonicalFragmentMap(day),
      timezoneCanonicalFragmentMap(timezoneOffset),
    );
};

/**
 * Maps a gMonth value to a gMonthLexicalRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#vp-gMonthCanRep>.
 *
 * ☡ This function throws if the provided value is not a complete
 * gMonth.
 */
export const gMonthCanonicalMap = (gM) => {
  const {
    year,
    month,
    day,
    hour,
    minute,
    second,
    timezoneOffset,
  } = date·timeSevenPropertyModel(gM);
  ensurePresence("year", year, false);
  ensurePresence("month", month, true);
  ensurePresence("day", day, false);
  ensurePresence("hour", hour, false);
  ensurePresence("minute", minute, false);
  ensurePresence("second", second, false);
  return timezoneOffset === absent
    ? stringCatenate("--", dayCanonicalFragmentMap(month))
    : stringCatenate(
      "--",
      dayCanonicalFragmentMap(month),
      timezoneCanonicalFragmentMap(timezoneOffset),
    );
};

/**
 * Maps a ·literal· matching the stringRep production to a string
 * value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-stringLexmap>.
 *
 * ☡ This function throws if the provided value is not a stringRep
 * string.
 */
export const stringLexicalMap = (LEX) => ensureMatches(stringRep, LEX);

/**
 * Maps a ·literal· matching the booleanRep production to a boolean
 * value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-booleanLexmap>.
 *
 * ☡ This function throws if the provided value is not a booleanRep
 * string.
 */
export const booleanLexicalMap = (LEX) => {
  ensureMatches(booleanRep, LEX);
  return LEX === "true" || LEX === "1";
};

/**
 * Maps a string value to a stringRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-stringCanmap>.
 *
 * ☡ This function throws if the provided value is not a valid string.
 */
export const stringCanonicalMap = (s) => ensureMatches(stringRep, s);

/**
 * Maps a boolean value to a booleanRep.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-booleanCanmap>.
 *
 * ☡ This function throws if the provided value is not a boolean.
 */
export const booleanCanonicalMap = (b) => {
  if (typeof b !== "boolean") {
    throw new TypeError(`सूत्र: Expected a boolean, but got: ${b}.`);
  } else {
    return b ? "true" : "false";
  }
};

/**
 * Maps a ·literal· matching the hexBinary production to a sequence of
 * octets in the form of a hexBinary value.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexBinaryMap>.
 *
 * ☡ This function throws if the provided value is not a hexBinary
 * string.
 *
 * ※ This function returns an `ArrayBuffer`.
 */
export const hexBinaryMap = (LEX) => {
  ensureMatches(hexBinary, LEX);
  const bufferLength = LEX.length / 2;
  const o = new ArrayBuffer(bufferLength);
  for (let bufferIndex = 0, index = 0; bufferIndex < bufferLength;) {
    set8BitIntegralItem(
      o,
      bufferIndex,
      hexOctetMap(substring(LEX, index, index = ++bufferIndex * 2)),
    );
  }
  return o;
};

/**
 * Maps a ·literal· matching the hexOctet production to a single octet.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexOctetMap>.
 *
 * ☡ This function throws if the provided value is not a hexOctet
 * string.
 *
 * ※ This function is not exposed.
 */
const hexOctetMap = (LEX) => {
  const [d0, d1] = ensureMatches(hexOctet, LEX);
  let octet = 0;
  let bit = 8;
  for (const digit of hexDigitMap(d0)) {
    octet |= digit << --bit;
  }
  for (const digit of hexDigitMap(d1)) {
    octet |= digit << --bit;
  }
  return octet;
};

/**
 * Maps a hexadecimal digit (a character matching the hexDigit
 * production) to a sequence of four binary digits.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexDigitMap>.
 *
 * ☡ This function throws if the provided value is not a hexDigit
 * string.
 *
 * ※ It would be way simpler and more efficient to just return a
 * single value here rather than a sequence of digits.
 *
 * ※ This function is not exposed.
 */
const hexDigitMap = (d) => {
  switch (ensureMatches(hexDigit, d)) {
    case "0":
      return binaryDigitSequence("0000");
    case "1":
      return binaryDigitSequence("0001");
    case "2":
      return binaryDigitSequence("0010");
    case "3":
      return binaryDigitSequence("0011");
    case "4":
      return binaryDigitSequence("0100");
    case "5":
      return binaryDigitSequence("0101");
    case "6":
      return binaryDigitSequence("0110");
    case "7":
      return binaryDigitSequence("0111");
    case "8":
      return binaryDigitSequence("1000");
    case "9":
      return binaryDigitSequence("1001");
    case "A":
    case "a":
      return binaryDigitSequence("1010");
    case "B":
    case "b":
      return binaryDigitSequence("1011");
    case "C":
    case "c":
      return binaryDigitSequence("1100");
    case "D":
    case "d":
      return binaryDigitSequence("1101");
    case "E":
    case "e":
      return binaryDigitSequence("1110");
    case "F":
    case "f":
      return binaryDigitSequence("1111");
  }
};

/**
 * Maps a hexBinary value to a literal matching the hexBinary
 * production.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexBinaryCanonical>.
 *
 * ☡ This function throws if the provided value is not an
 * `ArrayBuffer`.
 */
export const hexBinaryCanonical = (o) => {
  hexBinaryValue(o);
  const length = getByteLength(o);
  return stringCatenate(
    "",
    ...generatorSequence(function* () {
      for (let index = 0; index < length; ++index) {
        yield hexOctetCanonical(
          toNumber(get8BitUnsignedIntegralItem(o, index)),
        );
      }
    }),
  );
};

/**
 * Maps a binary octet to a literal matching the hexOctet production.
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexOctetCanonical>.
 *
 * ☡ This function throws if the provided value is not a hexOctet
 * string.
 *
 * ※ This function is not exposed.
 */
const hexOctetCanonical = (o) => {
  if (!(isIntegralNumber(o) && o >= 0 && o <= 0xFF)) {
    throw new TypeError(
      `सूत्र: Expected a binary octet but got: ${o}.`,
    );
  } else {
    const lo = generatorSequence(function* () {
      for (let i = 1; i <= 4; ++i) {
        const offset = 4 - i;
        yield (o & 1 << offset) >> offset;
      }
    });
    const hi = generatorSequence(function* () {
      for (let i = 1; i <= 4; ++i) {
        const offset = 8 - i;
        yield (o & 1 << offset) >> offset;
      }
    });
    return hexDigitCanonical(hi) + hexDigitCanonical(lo);
  }
};

/**
 * Maps a four-bit sequence to a hexadecimal digit (a literal matching
 * the hexDigit production).
 *
 * See <https://www.w3.org/TR/xmlschema11-2/#f-hexDigitCanonical>.
 *
 * ☡ This function throws if the provided value is not an iterable of
 * binary digits.
 *
 * ※ It would be way simpler and more efficient to just call this with
 * a single value rather than a sequence of digits.
 *
 * ※ This function is not exposed.
 */
const hexDigitCanonical = (d) => {
  let sum = 0;
  for (const digit of d) {
    if (digit != 0 && digit != 1) {
      throw new TypeError(
        `सूत्र: Expected a binary digit but got: ${digit}.`,
      );
    } else {
      sum = (sum << 1) | digit;
    }
  }
  switch (sum) {
    case 0b0000:
      return "0";
    case 0b0001:
      return "1";
    case 0b0010:
      return "2";
    case 0b0011:
      return "3";
    case 0b0100:
      return "4";
    case 0b0101:
      return "5";
    case 0b0110:
      return "6";
    case 0b0111:
      return "7";
    case 0b1000:
      return "8";
    case 0b1001:
      return "9";
    case 0b1010:
      return "A";
    case 0b1011:
      return "B";
    case 0b1100:
      return "C";
    case 0b1101:
      return "D";
    case 0b1110:
      return "E";
    case 0b1111:
      return "F";
  }
};