@parischap/conversions 0.1.0

package/cjs/NumberBase10Format.js

@@ -0,0 +1,759 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withoutThousandSeparator = exports.withoutSignDisplay = exports.withTruncRoundingMode = exports.withThousandSeparator = exports.withStandardScientificNotation = exports.withSignDisplayForNegativeExceptZero = exports.withSignDisplayForNegative = exports.withSignDisplayExceptZero = exports.withSignDisplay = exports.withNullIntegerPartShowing = exports.withNullIntegerPartNotShowing = exports.withNormalizedScientificNotation = exports.withNoScientificNotation = exports.withNDecimals = exports.withMinNDecimals = exports.withMaxNDecimals = exports.withHalfTruncRoundingMode = exports.withHalfFloorRoundingMode = exports.withHalfExpandRoundingMode = exports.withHalfEvenRoundingMode = exports.withHalfCeilRoundingMode = exports.withFractionalSeparator = exports.withFloorRoundingMode = exports.withExpandRoundingMode = exports.withEngineeringScientificNotation = exports.withCeilRoundingMode = exports.ukStyleUngroupedNumber = exports.ukStyleNumber = exports.ukStyleInteger = exports.toThrowingRealParser = exports.toThrowingRealExtractor = exports.toThrowingBigDecimalParser = exports.toThrowingBigDecimalExtractor = exports.toRealParser = exports.toRealExtractor = exports.toNumberFormatter = exports.toDescription = exports.toBigDecimalParser = exports.toBigDecimalExtractor = exports.thousandSeparator = exports.signDisplay = exports.showNullIntegerPart = exports.scientificNotation = exports.roundingMode = exports.moduleTag = exports.minimumFractionalDigits = exports.maximumFractionalDigits = exports.make = exports.integer = exports.has = exports.frenchStyleUngroupedNumber = exports.frenchStyleNumber = exports.frenchStyleInteger = exports.fractionalSeparator = exports.eNotationChars = exports.dutchStyleUngroupedNumber = exports.dutchStyleNumber = exports.dutchStyleInteger = exports.SignDisplay = exports.ScientificNotation = void 0;
+var _effectLib = /*#__PURE__*/require("@parischap/effect-lib");
+var _effect = /*#__PURE__*/require("effect");
+var CVReal = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Real.js"));
+var CVRoundingMode = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./RoundingMode.js"));
+var CVRoundingOption = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./RoundingOption.js"));
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap) var r = new WeakMap(),
+    n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = {
+        __proto__: null,
+        default: e
+      };
+    if (null === e || "object" != typeof e && "function" != typeof e) return f;
+    if (o = t ? n : r) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
+    }
+    for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);
+    return f;
+  })(e, t);
+}
+/**
+ * This module implements conversions from number to string and string to number in base-10
+ * notation.
+ */
+
+/**
+ * Module tag
+ *
+ * @category Module markers
+ */
+const moduleTag = exports.moduleTag = '@parischap/conversions/NumberBase10Format/';
+const _TypeId = /*#__PURE__*/Symbol.for(moduleTag);
+/**
+ * Possible sign display options
+ *
+ * @category Models
+ */
+var SignDisplay;
+(function (SignDisplay) {
+  /**
+   * Formatting: sign display for negative numbers only, including negative zero.
+   *
+   * Parsing: conversion will fail if a positive sign is used.
+   */
+  SignDisplay[SignDisplay["Auto"] = 0] = "Auto";
+  /**
+   * Formatting: sign display for all numbers.
+   *
+   * Parsing: conversion will fail if no sign is present
+   */
+  SignDisplay[SignDisplay["Always"] = 1] = "Always";
+  /**
+   * Formatting: sign display for positive and negative numbers, but not zero
+   *
+   * Parsing: conversion will fail if a sign is not present for a value other than 0 or if a sign is
+   * present for 0.
+   */
+  SignDisplay[SignDisplay["ExceptZero"] = 2] = "ExceptZero";
+  /**
+   * Formatting: sign display for negative numbers only, excluding negative zero.
+   *
+   * Parsing: conversion will fail if a positive sign is used or if a negative sign is used for 0.
+   */
+  SignDisplay[SignDisplay["Negative"] = 3] = "Negative";
+  /**
+   * Formatting: no sign display.
+   *
+   * Parsing: conversion will fail if any sign is present. The number will be treated as positive.
+   */
+  SignDisplay[SignDisplay["Never"] = 4] = "Never";
+})(SignDisplay || (exports.SignDisplay = SignDisplay = {}));
+/**
+ * SignDisplay namespace
+ *
+ * @category Models
+ */
+(function (SignDisplay) {
+  const isPlusSign = /*#__PURE__*/_effectLib.MPredicate.strictEquals('+');
+  const isMinusSign = /*#__PURE__*/_effectLib.MPredicate.strictEquals('-');
+  const signStringToSignValue = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effect.Option.liftPredicate(isMinusSign), /*#__PURE__*/_effect.Option.as(-1), /*#__PURE__*/_effect.Option.getOrElse(/*#__PURE__*/_effect.Function.constant(1)));
+  const hasASign = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effect.Struct.get('sign'), /*#__PURE__*/_effect.Option.liftPredicate(_effect.String.isNonEmpty), /*#__PURE__*/_effect.Option.map(signStringToSignValue));
+  const hasNoSign = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effect.Struct.get('sign'), /*#__PURE__*/_effect.Option.liftPredicate(_effect.String.isEmpty), /*#__PURE__*/_effect.Option.map(signStringToSignValue));
+  const hasNotPlusSign = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effect.Struct.get('sign'), /*#__PURE__*/_effect.Option.liftPredicate(/*#__PURE__*/_effect.Predicate.not(isPlusSign)), /*#__PURE__*/_effect.Option.map(signStringToSignValue));
+  /**
+   * Builds a `Parser` implementing `self`
+   *
+   * @category Destructors
+   */
+  SignDisplay.toParser = /*#__PURE__*/(0, _effect.flow)(_effectLib.MMatch.make, /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Auto, /*#__PURE__*/_effect.Function.constant(hasNotPlusSign)), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Always, /*#__PURE__*/_effect.Function.constant(hasASign)), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.ExceptZero, () => (0, _effect.flow)(_effectLib.MMatch.make, _effectLib.MMatch.when(_effectLib.MPredicate.struct({
+    isZero: _effect.Function.identity
+  }), hasNoSign), _effectLib.MMatch.orElse(hasASign))), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Negative, () => (0, _effect.flow)(_effectLib.MMatch.make, _effectLib.MMatch.when(_effectLib.MPredicate.struct({
+    isZero: _effect.Function.identity
+  }), hasNoSign), _effectLib.MMatch.orElse(hasNotPlusSign))), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Never, /*#__PURE__*/_effect.Function.constant(hasNoSign)), _effectLib.MMatch.exhaustive);
+  /**
+   * Builds a `Formatter` implementing `self`
+   *
+   * @category Destructors
+   */
+  SignDisplay.toFormatter = /*#__PURE__*/(0, _effect.flow)(_effectLib.MMatch.make, /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Auto, () => ({
+    sign
+  }) => sign === -1 ? '-' : ''), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Always, () => ({
+    sign
+  }) => sign === -1 ? '-' : '+'), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.ExceptZero, () => ({
+    sign,
+    isZero
+  }) => isZero ? '' : sign === -1 ? '-' : '+'), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Negative, () => ({
+    sign,
+    isZero
+  }) => isZero || sign === 1 ? '' : '-'), /*#__PURE__*/_effectLib.MMatch.whenIs(SignDisplay.Never, () => _effectLib.MFunction.constEmptyString), _effectLib.MMatch.exhaustive);
+})(SignDisplay || (exports.SignDisplay = SignDisplay = {}));
+/**
+ * Possible scientific notation options
+ *
+ * @category Models
+ */
+var ScientificNotation;
+(function (ScientificNotation) {
+  /**
+   * Formatting: scientific notation is not used.
+   *
+   * Parsing: conversion will fail if a scientific notation is present.
+   */
+  ScientificNotation[ScientificNotation["None"] = 0] = "None";
+  /**
+   * Formatting: scientific notation is not used.
+   *
+   * Parsing: scientific notation may be used but is not mandatory.
+   */
+  ScientificNotation[ScientificNotation["Standard"] = 1] = "Standard";
+  /**
+   * Formatting: scientific notation is used so that the absolute value of the mantissa m fulfills 1
+   * ≤ |m| < 10. Number 0 will be displayed as `0e0`.
+   *
+   * Parsing: the conversion will fail if the mantissa is not null and its value m does not fulfill
+   * 1 ≤ |m| < 10. Scientific notation may be used but is not mandatory. A string that does not
+   * contain a scientific notation is deemed equivalent to a string with a null exponent.
+   */
+  ScientificNotation[ScientificNotation["Normalized"] = 2] = "Normalized";
+  /**
+   * Formatting: scientific notation is used so that the mantissa m fulfills 1 ≤ |m| < 1000 and the
+   * exponent is a multiple of 3. Number 0 will be displayed as `0e0`.
+   *
+   * Parsing: the conversion will fail if the mantissa is not null and its value m does not fulfill
+   * 1 ≤ |m| < 1000 or if the exponent is not a multiple of 3. Scientific notation may be used but
+   * is not mandatory. A string that does not contain a scientific notation is deemed equivalent to
+   * a string with a null exponent.
+   */
+  ScientificNotation[ScientificNotation["Engineering"] = 3] = "Engineering";
+})(ScientificNotation || (exports.ScientificNotation = ScientificNotation = {}));
+/**
+ * Namespace for possible scientific notation options
+ *
+ * @category Models
+ */
+(function (ScientificNotation) {
+  const _stringToExponent = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effect.Option.liftPredicate(_effect.String.isNonEmpty), /*#__PURE__*/_effect.Option.map(_effectLib.MNumber.unsafeFromString), /*#__PURE__*/_effect.Option.orElseSome(/*#__PURE__*/_effect.Function.constant(0)));
+  /**
+   * Builds a `Parser` implementing `self`
+   *
+   * @category Destructors
+   */
+  ScientificNotation.toParser = /*#__PURE__*/(0, _effect.flow)(_effectLib.MMatch.make, /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.None, () => (0, _effect.flow)(_effect.Option.liftPredicate(_effect.String.isEmpty), _effect.Option.as(0))), /*#__PURE__*/_effectLib.MMatch.whenIsOr(ScientificNotation.Standard, ScientificNotation.Normalized, /*#__PURE__*/_effect.Function.constant(_stringToExponent)), /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.Engineering, () => (0, _effect.flow)(_stringToExponent, _effect.Option.filter(_effectLib.MNumber.isMultipleOf(3)))), _effectLib.MMatch.exhaustive);
+  const zeroOrinRange = rangeTop => _effect.Predicate.or(_effect.BigDecimal.isZero, _effect.Predicate.and(_effect.BigDecimal.greaterThanOrEqualTo(_effect.BigDecimal.unsafeFromNumber(1)), _effect.BigDecimal.lessThan(_effect.BigDecimal.unsafeFromNumber(rangeTop))));
+  const zeroOrinOneToTenRange = /*#__PURE__*/zeroOrinRange(10);
+  const zeroOrinOneToOneThousandRange = /*#__PURE__*/zeroOrinRange(1000);
+  /**
+   * Builds a `Parser` implementing `self`
+   *
+   * @category Destructors
+   */
+  ScientificNotation.toMantissaChecker = /*#__PURE__*/(0, _effect.flow)(_effectLib.MMatch.make, /*#__PURE__*/_effectLib.MMatch.whenIsOr(ScientificNotation.None, ScientificNotation.Standard, () => _effect.Option.some), /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.Normalized, () => _effect.Option.liftPredicate(zeroOrinOneToTenRange)), /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.Engineering, () => _effect.Option.liftPredicate(zeroOrinOneToOneThousandRange)), _effectLib.MMatch.exhaustive);
+  /**
+   * Builds a `Parser` implementing `self`
+   *
+   * @category Destructors
+   */
+  ScientificNotation.toMantissaAdjuster = /*#__PURE__*/(0, _effect.flow)(_effectLib.MMatch.make, /*#__PURE__*/_effectLib.MMatch.whenIsOr(ScientificNotation.None, ScientificNotation.Standard, () => (0, _effect.flow)(_effect.Tuple.make, _effect.Tuple.appendElement(_effect.Option.none()))), /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.Normalized, () => b => {
+    if (_effect.BigDecimal.isZero(b)) return _effect.Tuple.make(b, _effect.Option.some(0));
+    const value = b.value;
+    const log10 = _effectLib.MBigInt.unsafeLog10(_effect.BigInt.abs(value));
+    return _effect.Tuple.make(_effect.BigDecimal.make(value, log10), _effect.Option.some(log10 - b.scale));
+  }), /*#__PURE__*/_effectLib.MMatch.whenIs(ScientificNotation.Engineering, () => b => {
+    if (_effect.BigDecimal.isZero(b)) return _effect.Tuple.make(b, _effect.Option.some(0));
+    const value = b.value;
+    const log10 = _effectLib.MBigInt.unsafeLog10(_effect.BigInt.abs(value)) - b.scale;
+    const correctedLog10 = log10 - _effectLib.MNumber.intModulo(3)(log10);
+    return _effect.Tuple.make(_effect.BigDecimal.make(value, correctedLog10 + b.scale), _effect.Option.some(correctedLog10));
+  }), _effectLib.MMatch.exhaustive);
+})(ScientificNotation || (exports.ScientificNotation = ScientificNotation = {}));
+/**
+ * Type guard
+ *
+ * @category Guards
+ */
+const has = u => _effect.Predicate.hasProperty(u, _TypeId);
+/** Prototype */
+exports.has = has;
+const proto = {
+  [_TypeId]: _TypeId,
+  ... /*#__PURE__*/_effectLib.MInspectable.BaseProto(moduleTag),
+  ..._effectLib.MPipeable.BaseProto
+};
+/**
+ * Constructor
+ *
+ * @category Constructors
+ */
+const make = params => _effectLib.MTypes.objectFromDataAndProto(proto, params);
+/**
+ * Returns the `thousandSeparator` property of `self`
+ *
+ * @category Destructors
+ */
+exports.make = make;
+const thousandSeparator = exports.thousandSeparator = /*#__PURE__*/_effect.Struct.get('thousandSeparator');
+/**
+ * Returns the `fractionalSeparator` property of `self`
+ *
+ * @category Destructors
+ */
+const fractionalSeparator = exports.fractionalSeparator = /*#__PURE__*/_effect.Struct.get('fractionalSeparator');
+/**
+ * Returns the `showNullIntegerPart` property of `self`
+ *
+ * @category Destructors
+ */
+const showNullIntegerPart = exports.showNullIntegerPart = /*#__PURE__*/_effect.Struct.get('showNullIntegerPart');
+/**
+ * Returns the `minimumFractionalDigits` property of `self`
+ *
+ * @category Destructors
+ */
+const minimumFractionalDigits = exports.minimumFractionalDigits = /*#__PURE__*/_effect.Struct.get('minimumFractionalDigits');
+/**
+ * Returns the `maximumFractionalDigits` property of `self`
+ *
+ * @category Destructors
+ */
+const maximumFractionalDigits = exports.maximumFractionalDigits = /*#__PURE__*/_effect.Struct.get('maximumFractionalDigits');
+/**
+ * Returns the `eNotationChar` property of `self`
+ *
+ * @category Destructors
+ */
+const eNotationChars = exports.eNotationChars = /*#__PURE__*/_effect.Struct.get('eNotationChars');
+/**
+ * Returns the `scientificNotation` property of `self`
+ *
+ * @category Destructors
+ */
+const scientificNotation = exports.scientificNotation = /*#__PURE__*/_effect.Struct.get('scientificNotation');
+/**
+ * Returns the `roundingMode` property of `self`
+ *
+ * @category Destructors
+ */
+const roundingMode = exports.roundingMode = /*#__PURE__*/_effect.Struct.get('roundingMode');
+/**
+ * Returns the `signDisplay` property of `self`
+ *
+ * @category Destructors
+ */
+const signDisplay = exports.signDisplay = /*#__PURE__*/_effect.Struct.get('signDisplay');
+/**
+ * Returns a short description of `self`
+ *
+ * @category Destructors
+ */
+const toDescription = self => {
+  const {
+    thousandSeparator,
+    fractionalSeparator,
+    minimumFractionalDigits,
+    maximumFractionalDigits,
+    scientificNotation,
+    signDisplay
+  } = self;
+  const isInteger = maximumFractionalDigits <= 0;
+  const isUngrouped = thousandSeparator === '';
+  return (0, _effect.pipe)(signDisplay, _effectLib.MMatch.make, _effectLib.MMatch.whenIs(SignDisplay.Always, _effect.Function.constant('signed ')), _effectLib.MMatch.whenIs(SignDisplay.Never, _effect.Function.constant('unsigned ')), _effectLib.MMatch.orElse(_effect.Function.constant('potentially signed '))) + (isUngrouped && isInteger ? '' : (isUngrouped || thousandSeparator === ' ') && (fractionalSeparator === ',' || isInteger) ? 'French-style ' : thousandSeparator === '.' && (fractionalSeparator === ',' || isInteger) ? 'Dutch-style ' : (isUngrouped || thousandSeparator === ',') && (fractionalSeparator === '.' || isInteger) ? 'UK-style ' : '') + (isInteger ? 'integer' : minimumFractionalDigits === maximumFractionalDigits ? `${minimumFractionalDigits}-decimal number` : 'number') + (0, _effect.pipe)(scientificNotation, _effectLib.MMatch.make, _effectLib.MMatch.whenIs(ScientificNotation.None, _effectLib.MFunction.constEmptyString), _effectLib.MMatch.whenIs(ScientificNotation.Standard, _effect.Function.constant(' in standard scientific notation')), _effectLib.MMatch.whenIs(ScientificNotation.Normalized, _effect.Function.constant(' in normalized scientific notation')), _effectLib.MMatch.whenIs(ScientificNotation.Engineering, _effect.Function.constant(' in engineering notation')), _effectLib.MMatch.exhaustive);
+};
+exports.toDescription = toDescription;
+const _toBigDecimalExtractor = (self, fillChar = '') => {
+  const removeThousandSeparator = _effectLib.MString.removeNCharsEveryMCharsFromRight({
+    m: _effectLib.MRegExpString.DIGIT_GROUP_SIZE,
+    n: self.thousandSeparator.length
+  });
+  const getParts = _effectLib.MString.matchAndGroups((0, _effect.pipe)(self, _effectLib.MStruct.append({
+    fillChar
+  }), _effectLib.MRegExpString.base10Number, _effectLib.MRegExpString.atStart, RegExp), 5);
+  const signParser = SignDisplay.toParser(self.signDisplay);
+  const exponentParser = ScientificNotation.toParser(self.scientificNotation);
+  const mantissaChecker = ScientificNotation.toMantissaChecker(self.scientificNotation);
+  const fillCharIsZero = fillChar === '0';
+  return text => _effect.Option.gen(function* () {
+    const [match, [signPart, fillChars, mantissaIntegerPart, mantissaFractionalPart, exponentPart]] = yield* getParts(text);
+    const mantissaFractionalPartLength = yield* (0, _effect.pipe)(mantissaFractionalPart, _effect.String.length, _effect.Option.liftPredicate(_effect.Number.between({
+      minimum: self.minimumFractionalDigits,
+      maximum: self.maximumFractionalDigits
+    })));
+    const mantissa = yield* (0, _effect.pipe)(mantissaIntegerPart, _effect.Option.liftPredicate(_effect.String.isNonEmpty), _effect.Option.match({
+      // No integer part
+      onNone: () => !self.showNullIntegerPart && mantissaFractionalPartLength !== 0 || fillCharIsZero && fillChars.length !== 0 ? _effect.Option.some(_effectLib.MBigDecimal.zero) : _effect.Option.none(),
+      // With integer part
+      onSome: (0, _effect.flow)(self.showNullIntegerPart || mantissaFractionalPartLength === 0 ? _effect.Option.some : _effect.Option.liftPredicate(_effect.Predicate.not(_effectLib.MPredicate.strictEquals('0'))), _effect.Option.map((0, _effect.flow)(removeThousandSeparator, _effectLib.MBigDecimal.fromPrimitiveOrThrow(0))))
+    }), _effect.Option.map(_effect.BigDecimal.sum((0, _effect.pipe)(mantissaFractionalPart, _effect.Option.liftPredicate(_effect.String.isNonEmpty), _effect.Option.map(_effectLib.MBigDecimal.fromPrimitiveOrThrow(mantissaFractionalPartLength)), _effect.Option.getOrElse(_effect.Function.constant(_effectLib.MBigDecimal.zero))))));
+    const checkedMantissa = yield* mantissaChecker(mantissa);
+    const sign = yield* signParser({
+      isZero: _effect.BigDecimal.isZero(checkedMantissa),
+      sign: signPart
+    });
+    const exponent = yield* exponentParser(exponentPart);
+    return _effect.Tuple.make(_effect.BigDecimal.make(checkedMantissa.value, checkedMantissa.scale - exponent), match, sign);
+  });
+};
+/**
+ * Returns a function that tries to parse, from the start of a string `text`, a number respecting
+ * the options represented by `self` and an optional `fillChar` parameter. If successful, that
+ * function returns a `some` containing `parsedText` (the part of `text` that could be analyzed as
+ * representing a number) and `value` (`parsedText` converted to a BigDecimal value). Otherwise, it
+ * returns a `none`. As there is no way to distinguish `-0n` and `0n` in Javascript, parsing '-0',
+ * '0', '+0' will yield the same result.
+ *
+ * `fillChar` is a character that may be used as filler between the sign and the number (or at the
+ * start of the number if it is unsigned). It must be a one-character string (but no error is
+ * triggered if it's not). You can use '0' as `fillChar` but you shoud not use any other digit
+ * because the value of the number to parse would depend on the number of removed `fillChar`'s.
+ *
+ * @category Parsing
+ */
+const toBigDecimalExtractor = exports.toBigDecimalExtractor = /*#__PURE__*/(0, _effect.flow)(_toBigDecimalExtractor, /*#__PURE__*/_effect.Function.compose(/*#__PURE__*/_effect.Option.map(([value, parsedText, sign]) => _effect.Tuple.make(_effect.BigDecimal.multiply(value, _effect.BigDecimal.unsafeFromNumber(sign)), parsedText))));
+/**
+ * Same as toBigDecimalExtractor but the returned parser throws in case of error
+ *
+ * @category Parsing
+ */
+const toThrowingBigDecimalExtractor = (self, fillChar) => text => (0, _effect.pipe)(text, toBigDecimalExtractor(self, fillChar), _effect.Option.getOrThrowWith(() => new Error(`A BigDecimal could not be parsed from the start of '${text}'`)));
+/**
+ * Same as `toBigDecimalExtractor` but returns a `Real` which is the most usual use case.
+ * Furthermore, this function will return -0 if your parse '-0' and 0 if you parse '0' or '+0'.
+ *
+ * @category Parsing
+ */
+exports.toThrowingBigDecimalExtractor = toThrowingBigDecimalExtractor;
+const toRealExtractor = exports.toRealExtractor = /*#__PURE__*/(0, _effect.flow)(_toBigDecimalExtractor, /*#__PURE__*/_effect.Function.compose(/*#__PURE__*/_effect.Option.flatMap(([value, parsedText, sign]) => (0, _effect.pipe)(value, CVReal.fromBigDecimalOption, _effect.Option.map((0, _effect.flow)(_effect.Number.multiply(sign), _effect.Tuple.make, _effect.Tuple.appendElement(parsedText)))))));
+/**
+ * Same as toRealExtractor but the returned parser throws in case of error
+ *
+ * @category Parsing
+ */
+const toThrowingRealExtractor = (self, fillChar) => text => (0, _effect.pipe)(text, toRealExtractor(self, fillChar), _effect.Option.getOrThrowWith(() => new Error(`A Real could not be parsed from the start of '${text}'`)));
+/**
+ * Same as toBigDecimalExtractor but the whole of the input text must represent a number, not just
+ * its start
+ *
+ * @category Parsing
+ */
+exports.toThrowingRealExtractor = toThrowingRealExtractor;
+const toBigDecimalParser = (self, fillChar) => {
+  const extractor = toBigDecimalExtractor(self, fillChar);
+  return text => (0, _effect.pipe)(text, extractor, _effect.Option.flatMap((0, _effect.flow)(_effect.Option.liftPredicate((0, _effect.flow)(_effect.Tuple.getSecond, _effect.String.length, _effectLib.MPredicate.strictEquals(text.length))), _effect.Option.map(_effect.Tuple.getFirst))));
+};
+/**
+ * Same as toRealExtractor but the returned parser throws in case of error
+ *
+ * @category Parsing
+ */
+exports.toBigDecimalParser = toBigDecimalParser;
+const toThrowingBigDecimalParser = (self, fillChar) => text => (0, _effect.pipe)(text, toBigDecimalParser(self, fillChar), _effect.Option.getOrThrowWith(() => new Error(`A BigDecimal could not be parsed from '${text}'`)));
+/**
+ * Same as `toRealExtractor` but the whole of the input text must represent a number, not just its
+ * start
+ *
+ * @category Parsing
+ */
+exports.toThrowingBigDecimalParser = toThrowingBigDecimalParser;
+const toRealParser = (self, fillChar) => {
+  const extractor = toRealExtractor(self, fillChar);
+  return text => (0, _effect.pipe)(text, extractor, _effect.Option.flatMap((0, _effect.flow)(_effect.Option.liftPredicate((0, _effect.flow)(_effect.Tuple.getSecond, _effect.String.length, _effectLib.MPredicate.strictEquals(text.length))), _effect.Option.map(_effect.Tuple.getFirst))));
+};
+/**
+ * Same as toRealParser but the returned parser throws in case of error
+ *
+ * @category Parsing
+ */
+exports.toRealParser = toRealParser;
+const toThrowingRealParser = (self, fillChar) => text => (0, _effect.pipe)(text, toRealParser(self, fillChar), _effect.Option.getOrThrowWith(() => new Error(`A Real could not be parsed from '${text}'`)));
+/**
+ * Returns a function that tries to format a `number` respecting the options represented by
+ * `self`and an optional parameter `fillChars`. If successful, that function returns a `some` of the
+ * formatted number. Otherwise, it returns a `none`. `number` can be of type number or BigDecimal
+ * for better accuracy. There is a difference between number and BigDecimal (and bigint) regarding
+ * the sign of 0. In Javascript, Object.is(0,-0) is false whereas Object.is(0n,-0n) is true. So if
+ * the sign of zero is important to you, prefer passing a number to the function. `0` as a
+ * BigDecimal will always be interpreted as a positive `0` as we have no means of knowing if it is
+ * negative or positive.
+ *
+ * `fillChars` is a string whose first characters will be inserted between the sign and the number
+ * (or at the start of the number if it is unsigned) so that the formatted number has at least the
+ * same number of characters as fillChars (e.g. the result will be '-02' if you try to format the
+ * value -2 with fillChars = '000')
+ *
+ * @category Formatting
+ */
+exports.toThrowingRealParser = toThrowingRealParser;
+const toNumberFormatter = (self, fillChars = '') => {
+  const rounder = self.maximumFractionalDigits === +Infinity ? _effect.Function.identity : (0, _effect.pipe)({
+    precision: self.maximumFractionalDigits,
+    roundingMode: self.roundingMode
+  }, CVRoundingOption.make, CVRoundingOption.toBigDecimalRounder);
+  const signFormatter = SignDisplay.toFormatter(self.signDisplay);
+  const mantissaAdjuster = ScientificNotation.toMantissaAdjuster(self.scientificNotation);
+  const hasThousandSeparator = self.thousandSeparator !== '';
+  const eNotationChar = (0, _effect.pipe)(self.eNotationChars, _effect.Array.get(0), _effect.Option.getOrElse(_effectLib.MFunction.constEmptyString));
+  const takeNFirstCharsOfFillChars = _effectLib.MFunction.flipDual(_effect.String.takeLeft)(fillChars);
+  return number => {
+    const [sign, selfAsBigDecimal] = _effectLib.MTypes.isNumber(number) ? _effect.Tuple.make(number < 0 || Object.is(-0, number) ? -1 : 1, _effect.BigDecimal.unsafeFromNumber(number)) : _effect.Tuple.make(number.value < 0 ? -1 : 1, number);
+    const [adjusted, exponent] = mantissaAdjuster(selfAsBigDecimal);
+    const absRounded = (0, _effect.pipe)(adjusted, rounder, _effect.BigDecimal.abs);
+    const [integerPart, fractionalPart] = (0, _effect.pipe)(absRounded, _effectLib.MBigDecimal.truncatedAndFollowingParts());
+    const signString = signFormatter({
+      sign,
+      isZero: _effect.BigDecimal.isZero(absRounded)
+    });
+    const normalizedFractionalPart = _effect.BigDecimal.normalize(fractionalPart);
+    const fractionalPartString = (0, _effect.pipe)(normalizedFractionalPart.value, _effect.Option.liftPredicate(_effect.Predicate.not(_effectLib.MBigInt.isZero)), _effect.Option.map(_effectLib.MString.fromNonNullablePrimitive), _effect.Option.getOrElse(_effectLib.MFunction.constEmptyString), _effect.String.padStart(normalizedFractionalPart.scale, '0'), _effect.String.padEnd(self.minimumFractionalDigits, '0'), _effect.Option.liftPredicate(_effect.String.isNonEmpty), _effect.Option.map(_effectLib.MString.prepend(self.fractionalSeparator)), _effect.Option.getOrElse(_effectLib.MFunction.constEmptyString));
+    const integerPartString = (0, _effect.pipe)(integerPart.value.toString(), _effectLib.MFunction.fIfTrue({
+      condition: hasThousandSeparator,
+      f: (0, _effect.flow)(_effectLib.MString.splitEquallyRestAtStart(_effectLib.MRegExpString.DIGIT_GROUP_SIZE), _effect.Array.intersperse(self.thousandSeparator), _effect.Array.join(''))
+    }), _effect.Either.liftPredicate(_effect.Predicate.not(_effectLib.MPredicate.strictEquals('0')), _effectLib.MFunction.fIfTrue({
+      condition: !self.showNullIntegerPart && fractionalPartString.length !== 0,
+      f: _effectLib.MFunction.constEmptyString
+    })), _effect.Either.merge);
+    const exponentString = (0, _effect.pipe)(exponent, _effect.Option.map((0, _effect.flow)(_effectLib.MString.fromNumber(10), _effectLib.MString.prepend(eNotationChar))), _effect.Option.getOrElse(_effectLib.MFunction.constEmptyString));
+    const numberString = integerPartString + fractionalPartString + exponentString;
+    const pad = (0, _effect.pipe)(fillChars.length, _effect.Number.subtract(signString.length), _effect.Number.subtract(numberString.length), _effect.Number.max(0), takeNFirstCharsOfFillChars);
+    return signString + pad + numberString;
+  };
+};
+/**
+ * Combinator that returns a copy of self with `minimumFractionalDigits` and
+ * `maximumFractionalDigits` set to `n`. `n` must be a finite positive integer.
+ *
+ * @category Modifiers
+ */
+exports.toNumberFormatter = toNumberFormatter;
+const withNDecimals = decimalNumber => (0, _effect.flow)(_effectLib.MStruct.append({
+  minimumFractionalDigits: decimalNumber,
+  maximumFractionalDigits: decimalNumber
+}), make);
+/**
+ * Combinator that returns a copy of self with `maximumFractionalDigits` set to `n`. `n` must be a
+ * positive integer. Pass 0 for an integer format.
+ *
+ * @category Modifiers
+ */
+exports.withNDecimals = withNDecimals;
+const withMaxNDecimals = maxDecimalNumber => self => (0, _effect.pipe)(self, _effectLib.MStruct.append({
+  minimumFractionalDigits: Math.min(self.minimumFractionalDigits, maxDecimalNumber),
+  maximumFractionalDigits: maxDecimalNumber
+}), make);
+/**
+ * Combinator that returns a copy of self with `minimumFractionalDigits` set to `n`. `n` must be a
+ * finite positive integer.
+ *
+ * @category Modifiers
+ */
+exports.withMaxNDecimals = withMaxNDecimals;
+const withMinNDecimals = minDecimalNumber => self => (0, _effect.pipe)(self, _effectLib.MStruct.append({
+  minimumFractionalDigits: minDecimalNumber,
+  maximumFractionalDigits: Math.max(self.maximumFractionalDigits, minDecimalNumber)
+}), make);
+/**
+ * Combinator that returns a copy of self with `scientificNotation` set to `None`.
+ *
+ * @category Modifiers
+ */
+exports.withMinNDecimals = withMinNDecimals;
+const withNoScientificNotation = exports.withNoScientificNotation = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  scientificNotation: ScientificNotation.None
+}), make);
+/**
+ * Combinator that returns a copy of self with `scientificNotation` set to `Standard`.
+ *
+ * @category Modifiers
+ */
+const withStandardScientificNotation = exports.withStandardScientificNotation = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  scientificNotation: ScientificNotation.Standard
+}), make);
+/**
+ * Combinator that returns a copy of self with `scientificNotation` set to `Normalized`.
+ *
+ * @category Modifiers
+ */
+const withNormalizedScientificNotation = exports.withNormalizedScientificNotation = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  scientificNotation: ScientificNotation.Normalized
+}), make);
+/**
+ * Combinator that returns a copy of self with `scientificNotation` set to `Engineering`.
+ *
+ * @category Modifiers
+ */
+const withEngineeringScientificNotation = exports.withEngineeringScientificNotation = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  scientificNotation: ScientificNotation.Engineering
+}), make);
+/**
+ * Combinator that returns a copy of self with `thousandSeparator` set to `thousandSeparator`.
+ *
+ * @category Modifiers
+ */
+const withThousandSeparator = thousandSeparator => (0, _effect.flow)(_effectLib.MStruct.append({
+  thousandSeparator
+}), make);
+/**
+ * Combinator that returns a copy of self with `thousandSeparator` set to ''.
+ *
+ * @category Modifiers
+ */
+exports.withThousandSeparator = withThousandSeparator;
+const withoutThousandSeparator = exports.withoutThousandSeparator = /*#__PURE__*/withThousandSeparator('');
+/**
+ * Combinator that returns a copy of self with `fractionalSeparator` set to `fractionalSeparator`.
+ *
+ * @category Modifiers
+ */
+const withFractionalSeparator = fractionalSeparator => (0, _effect.flow)(_effectLib.MStruct.append({
+  fractionalSeparator: fractionalSeparator
+}), make);
+/**
+ * Combinator that returns a copy of self with `signDisplay` set to `Auto`.
+ *
+ * @category Modifiers
+ */
+exports.withFractionalSeparator = withFractionalSeparator;
+const withSignDisplayForNegative = exports.withSignDisplayForNegative = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  signDisplay: SignDisplay.Auto
+}), make);
+/**
+ * Combinator that returns a copy of self with `signDisplay` set to `Always`.
+ *
+ * @category Modifiers
+ */
+const withSignDisplay = exports.withSignDisplay = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  signDisplay: SignDisplay.Always
+}), make);
+/**
+ * Combinator that returns a copy of self with `signDisplay` set to `ExceptZero`.
+ *
+ * @category Modifiers
+ */
+const withSignDisplayExceptZero = exports.withSignDisplayExceptZero = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  signDisplay: SignDisplay.ExceptZero
+}), make);
+/**
+ * Combinator that returns a copy of self with `signDisplay` set to `Negative`.
+ *
+ * @category Modifiers
+ */
+const withSignDisplayForNegativeExceptZero = exports.withSignDisplayForNegativeExceptZero = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  signDisplay: SignDisplay.Negative
+}), make);
+/**
+ * Combinator that returns a copy of self with `signDisplay` set to `Never`.
+ *
+ * @category Modifiers
+ */
+const withoutSignDisplay = exports.withoutSignDisplay = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  signDisplay: SignDisplay.Never
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `Ceil`.
+ *
+ * @category Modifiers
+ */
+const withCeilRoundingMode = exports.withCeilRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.Ceil
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `Floor`.
+ *
+ * @category Modifiers
+ */
+const withFloorRoundingMode = exports.withFloorRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.Floor
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `Expand`.
+ *
+ * @category Modifiers
+ */
+const withExpandRoundingMode = exports.withExpandRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.Expand
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `Trunc`.
+ *
+ * @category Modifiers
+ */
+const withTruncRoundingMode = exports.withTruncRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.Trunc
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `HalfCeil`.
+ *
+ * @category Modifiers
+ */
+const withHalfCeilRoundingMode = exports.withHalfCeilRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.HalfCeil
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `HalfFloor`.
+ *
+ * @category Modifiers
+ */
+const withHalfFloorRoundingMode = exports.withHalfFloorRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.HalfFloor
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `HalfExpand`.
+ *
+ * @category Modifiers
+ */
+const withHalfExpandRoundingMode = exports.withHalfExpandRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.HalfExpand
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `HalfTrunc`.
+ *
+ * @category Modifiers
+ */
+const withHalfTruncRoundingMode = exports.withHalfTruncRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.HalfTrunc
+}), make);
+/**
+ * Combinator that returns a copy of self with `roundingMode` set to `HalfEven`.
+ *
+ * @category Modifiers
+ */
+const withHalfEvenRoundingMode = exports.withHalfEvenRoundingMode = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  roundingMode: CVRoundingMode.Type.HalfEven
+}), make);
+/**
+ * Combinator that returns a copy of self with `showNullIntegerPart` set to `false`.
+ *
+ * @category Modifiers
+ */
+const withNullIntegerPartNotShowing = exports.withNullIntegerPartNotShowing = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  showNullIntegerPart: false
+}), make);
+/**
+ * Combinator that returns a copy of self with `showNullIntegerPart` set to `true`.
+ *
+ * @category Modifiers
+ */
+const withNullIntegerPartShowing = exports.withNullIntegerPartShowing = /*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.append({
+  showNullIntegerPart: true
+}), make);
+/**
+ * NumberBase10Format instance that uses a comma as fractional separator, a space as thousand
+ * separator and shows at most three fractional digits. Used in countries like France,
+ * French-speaking Canada, French-speaking Belgium, Denmark, Finland, Sweden...
+ *
+ * @category Instances
+ */
+const frenchStyleNumber = exports.frenchStyleNumber = /*#__PURE__*/make({
+  thousandSeparator: ' ',
+  fractionalSeparator: ',',
+  showNullIntegerPart: true,
+  minimumFractionalDigits: 0,
+  maximumFractionalDigits: 3,
+  eNotationChars: ['e', 'E'],
+  scientificNotation: ScientificNotation.None,
+  roundingMode: CVRoundingMode.Type.HalfExpand,
+  signDisplay: SignDisplay.Negative
+});
+/**
+ * NumberBase10Format instance that uses a comma as fractional separator, no thousand separator and
+ * shows at most three fractional digits. Used in countries like France, French-speaking Canada,
+ * French-speaking Belgium, Denmark, Finland, Sweden...
+ *
+ * @category Instances
+ */
+const frenchStyleUngroupedNumber = exports.frenchStyleUngroupedNumber = /*#__PURE__*/(0, _effect.pipe)(frenchStyleNumber, withoutThousandSeparator);
+/**
+ * French-style integer NumberBase10Format instance. Used in countries like France, French-speaking
+ * Canada, French-speaking Belgium, Denmark, Finland, Sweden...
+ *
+ * @category Instances
+ */
+const frenchStyleInteger = exports.frenchStyleInteger = /*#__PURE__*/(0, _effect.pipe)(frenchStyleNumber, /*#__PURE__*/withMaxNDecimals(0));
+/**
+ * NumberBase10Format instance that uses a comma as fractional separator, a dot as thousand
+ * separator and shows at most three fractional digits. Used in countries like Dutch-speaking
+ * Belgium, the Netherlands, Germany, Italy, Norway, Croatia, Spain...
+ *
+ * @category Instances
+ */
+const dutchStyleNumber = exports.dutchStyleNumber = /*#__PURE__*/(0, _effect.pipe)(frenchStyleNumber, /*#__PURE__*/_effectLib.MStruct.append({
+  thousandSeparator: '.'
+}), make);
+/**
+ * NumberBase10Format instance that uses a comma as fractional separator, no thousand separator and
+ * shows at most three fractional digits. Used in countries like Dutch-speaking Belgium, the
+ * Netherlands, Germany, Italy, Norway, Croatia, Spain...
+ *
+ * @category Instances
+ */
+const dutchStyleUngroupedNumber = exports.dutchStyleUngroupedNumber = /*#__PURE__*/(0, _effect.pipe)(dutchStyleNumber, withoutThousandSeparator);
+/**
+ * Dutch-style integer NumberBase10Format instance. Used in countries like Dutch-speaking Belgium,
+ * the Netherlands, Germany, Italy, Norway, Croatia, Spain...
+ *
+ * @category Instances
+ */
+const dutchStyleInteger = exports.dutchStyleInteger = /*#__PURE__*/(0, _effect.pipe)(dutchStyleNumber, /*#__PURE__*/withMaxNDecimals(0));
+/**
+ * NumberBase10Format instance that uses a dot as fractional separator, a comma as thousand
+ * separator and shows at most three fractional digits. Used in countries like the UK, the US,
+ * English-speaking Canada, Australia, Thaïland, Bosnia...
+ *
+ * @category Instances
+ */
+const ukStyleNumber = exports.ukStyleNumber = /*#__PURE__*/(0, _effect.pipe)(frenchStyleNumber, /*#__PURE__*/_effectLib.MStruct.append({
+  fractionalSeparator: '.',
+  thousandSeparator: ','
+}), make);
+/**
+ * NumberBase10Format instance that uses a dot as fractional separator, no thousand separator and
+ * shows at most three fractional digits. Used in countries like the UK, the US, English-speaking
+ * Canada, Australia, Thaïland, Bosnia...
+ *
+ * @category Instances
+ */
+const ukStyleUngroupedNumber = exports.ukStyleUngroupedNumber = /*#__PURE__*/(0, _effect.pipe)(ukStyleNumber, withoutThousandSeparator);
+/**
+ * Uk-style integer NumberBase10Format instance. Used in countries like the UK, the US,
+ * English-speaking Canada, Australia, Thaïland, Bosnia...
+ *
+ * @category Instances
+ */
+const ukStyleInteger = exports.ukStyleInteger = /*#__PURE__*/(0, _effect.pipe)(ukStyleNumber, /*#__PURE__*/withMaxNDecimals(0));
+/**
+ * Integer NumberBase10Format instance with no thousand separator
+ *
+ * @category Instances
+ */
+const integer = exports.integer = /*#__PURE__*/(0, _effect.pipe)(frenchStyleInteger, withoutThousandSeparator);
+//# sourceMappingURL=NumberBase10Format.js.map