@fable-org/fable-library-ts 1.0.0-beta-001

package/DateOffset.ts

@@ -0,0 +1,324 @@
+/**
+ * DateTimeOffset functions.
+ *
+ * Note: DateOffset instances are always DateObjects in local
+ * timezone (because JS dates are all kinds of messed up).
+ * A local date returns UTC epoch when `.getTime()` is called.
+ *
+ * However, this means that in order to construct an UTC date
+ * from a DateOffset with offset of +5 hours, you first need
+ * to subtract those 5 hours, than add the "local" offset.
+ * As said, all kinds of messed up.
+ *
+ * Basically; invariant: date.getTime() always return UTC time.
+ */
+
+import { int64, fromFloat64, toFloat64 } from "./BigInt.js";
+import DateTime, { create as createDate, dateOffsetToString, daysInMonth, parseRaw, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from "./Date.js";
+import { FSharpRef } from "./Types.js";
+import { compareDates, DateKind, IDateTime, IDateTimeOffset, padWithZeros } from "./Util.js";
+
+export default function DateTimeOffset(value: number, offset?: number) {
+  checkOffsetInRange(offset);
+  const d = new Date(value) as IDateTimeOffset;
+  d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;
+  return d;
+}
+
+export function offset(value: IDateTimeOffset): number {
+  return value.offset || 0;
+}
+
+function checkOffsetInRange(offset?: number) {
+  if (offset != null && offset !== 0) {
+    if (offset % 60000 !== 0) {
+      throw new Error("Offset must be specified in whole minutes.");
+    }
+    if (Math.abs(offset / 3600000) > 14) {
+      throw new Error("Offset must be within plus or minus 14 hours.");
+    }
+  }
+}
+
+export function fromDate(date: IDateTime, offset?: number) {
+  let offset2: number = 0;
+  switch (date.kind) {
+    case DateKind.UTC:
+      if(offset != null && offset !== 0) {
+        throw new Error("The UTC Offset for Utc DateTime instances must be 0.");
+      }
+      offset2 = 0;
+      break;
+
+    case DateKind.Local:
+      offset2 = date.getTimezoneOffset() * -60_000;
+      if(offset != null && offset !== offset2) {
+        throw new Error("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+      }
+
+      break;
+
+    case DateKind.Unspecified:
+    default:
+      if(offset == null) {
+        offset2 = date.getTimezoneOffset() * -60_000;
+      }
+      else {
+        offset2 = offset;
+      }
+      break;
+  }
+
+  return DateTimeOffset(date.getTime(), offset2);
+}
+
+export function fromTicks(ticks: int64, offset: number) {
+  const ms = ticksToUnixEpochMilliseconds(ticks) - offset;
+  return DateTimeOffset(ms, offset);
+}
+
+export function fromUnixTimeMilliseconds(ms: int64) {
+  return DateTimeOffset(toFloat64(ms), 0)
+}
+
+export function fromUnixTimeSeconds(seconds: int64) {
+  return DateTimeOffset(toFloat64(seconds * 1000n), 0)
+}
+
+export function getUtcTicks(date: IDateTimeOffset) {
+  return unixEpochMillisecondsToTicks(date.getTime(), 0);
+}
+
+export function minValue() {
+  // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
+  return DateTimeOffset(-62135596800000, 0);
+}
+
+export function maxValue() {
+  // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
+  return DateTimeOffset(253402300799999, 0);
+}
+
+export function parse(str: string): IDateTimeOffset {
+  const [date, offsetMatch] = parseRaw(str);
+  const offset = offsetMatch == null
+    ? date.getTimezoneOffset() * -60000
+    : (offsetMatch === "Z" ? 0 : offsetMatch * 60000);
+  return DateTimeOffset(date.getTime(), offset);
+}
+
+export function tryParse(v: string, defValue: FSharpRef<IDateTimeOffset>): boolean {
+  try {
+    defValue.contents = parse(v);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+export function create(
+  year: number, month: number, day: number,
+  h: number, m: number, s: number,
+  ms: number, offset?: number) {
+  if (offset == null) {
+    offset = ms;
+    ms = 0;
+  }
+  checkOffsetInRange(offset);
+  let date: Date;
+  if (offset === 0) {
+    date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));
+    if (year <= 99) {
+      date.setUTCFullYear(year, month - 1, day);
+    }
+  } else {
+    const str =
+      padWithZeros(year, 4) + "-" +
+      padWithZeros(month, 2) + "-" +
+      padWithZeros(day, 2) + "T" +
+      padWithZeros(h, 2) + ":" +
+      padWithZeros(m, 2) + ":" +
+      padWithZeros(s, 2) + "." +
+      padWithZeros(ms, 3) +
+      dateOffsetToString(offset);
+    date = new Date(str);
+  }
+  const dateValue = date.getTime();
+  if (isNaN(dateValue)) {
+    throw new Error("The parameters describe an unrepresentable Date");
+  }
+  return DateTimeOffset(dateValue, offset);
+}
+
+export function now() {
+  const date = new Date();
+  const offset = date.getTimezoneOffset() * -60000;
+  return DateTimeOffset(date.getTime(), offset);
+}
+
+export function utcNow() {
+  const date = now();
+  return DateTimeOffset(date.getTime(), 0);
+}
+
+export function toUniversalTime(date: IDateTimeOffset): Date {
+  return DateTime(date.getTime(), DateKind.UTC);
+}
+
+export function toLocalTime(date: IDateTimeOffset): Date {
+  return DateTime(date.getTime(), DateKind.Local);
+}
+
+export function timeOfDay(d: IDateTimeOffset) {
+  const d2 = new Date(d.getTime() + (d.offset ?? 0));
+  return d2.getUTCHours() * 3600000
+    + d2.getUTCMinutes() * 60000
+    + d2.getUTCSeconds() * 1000
+    + d2.getUTCMilliseconds();
+}
+
+export function date(d: IDateTimeOffset) {
+  const d2 = new Date(d.getTime() + (d.offset ?? 0));
+  return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+
+export function day(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCDate();
+}
+
+export function hour(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCHours();
+}
+
+export function millisecond(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCMilliseconds();
+}
+
+export function minute(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCMinutes();
+}
+
+export function month(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCMonth() + 1;
+}
+
+export function second(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCSeconds();
+}
+
+export function year(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCFullYear();
+}
+
+export function dayOfWeek(d: IDateTimeOffset) {
+  return new Date(d.getTime() + (d.offset ?? 0)).getUTCDay();
+}
+
+export function dayOfYear(d: IDateTimeOffset) {
+  const d2 = new Date(d.getTime() + (d.offset ?? 0));
+  const _year = d2.getUTCFullYear();
+  const _month = d2.getUTCMonth() + 1;
+  let _day = d2.getUTCDate();
+  for (let i = 1; i < _month; i++) {
+    _day += daysInMonth(_year, i);
+  }
+  return _day;
+}
+
+export function add(d: IDateTimeOffset, ts: number) {
+  return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
+}
+
+export function addDays(d: IDateTimeOffset, v: number) {
+  return add(d, v * 86400000);
+}
+
+export function addHours(d: IDateTimeOffset, v: number) {
+  return add(d, v * 3600000);
+}
+
+export function addMinutes(d: IDateTimeOffset, v: number) {
+  return add(d, v * 60000);
+}
+
+export function addSeconds(d: IDateTimeOffset, v: number) {
+  return add(d, v * 1000);
+}
+
+export function addMilliseconds(d: IDateTimeOffset, v: number) {
+  return add(d, v);
+}
+
+export function addTicks(d: IDateTimeOffset, v: int64) {
+  return add(d, toFloat64(v / 10000n));
+}
+
+export function addYears(d: IDateTimeOffset, v: number) {
+  const newMonth = d.getUTCMonth() + 1;
+  const newYear = d.getUTCFullYear() + v;
+  const _daysInMonth = daysInMonth(newYear, newMonth);
+  const newDay = Math.min(_daysInMonth, d.getUTCDate());
+  return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(),
+    d.getUTCSeconds(), d.getUTCMilliseconds(), (d.offset ?? 0));
+}
+
+export function addMonths(d: IDateTimeOffset, v: number) {
+  const d2 = new Date(d.getTime() + (d.offset ?? 0));
+  let newMonth = d2.getUTCMonth() + 1 + v;
+  let newMonth_ = 0;
+  let yearOffset = 0;
+  if (newMonth > 12) {
+    newMonth_ = newMonth % 12;
+    yearOffset = Math.floor(newMonth / 12);
+    newMonth = newMonth_;
+  } else if (newMonth < 1) {
+    newMonth_ = 12 + newMonth % 12;
+    yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
+    newMonth = newMonth_;
+  }
+  const newYear = d2.getUTCFullYear() + yearOffset;
+  const _daysInMonth = daysInMonth(newYear, newMonth);
+  const newDay = Math.min(_daysInMonth, d2.getUTCDate());
+  return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(),
+    d2.getUTCSeconds(), d2.getUTCMilliseconds(), (d.offset ?? 0));
+}
+
+export function subtract<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(d: IDateTimeOffset, that: Input): Output {
+  return typeof that === "number"
+    ? DateTimeOffset(d.getTime() - that, (d.offset ?? 0)) as Output
+    : d.getTime() - that.getTime() as Output;
+}
+
+export function equals(d1: IDateTimeOffset, d2: IDateTimeOffset) {
+  return d1.getTime() === d2.getTime();
+}
+
+export function equalsExact(d1: IDateTimeOffset, d2: IDateTimeOffset) {
+  return d1.getTime() === d2.getTime() && d1.offset === d2.offset;
+}
+
+export function compare(d1: IDateTimeOffset, d2: IDateTimeOffset) {
+  return compareDates(d1, d2);
+}
+
+export const compareTo = compare;
+
+export function op_Addition(x: IDateTimeOffset, y: number) {
+  return add(x, y);
+}
+
+export function op_Subtraction<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(x: IDateTimeOffset, y: Input): Output {
+  return subtract(x, y);
+}
+
+export function toOffset(d: IDateTimeOffset, offset: number): IDateTimeOffset {
+  return DateTimeOffset(d.getTime(), offset);
+}
+
+export function toUnixTimeMilliseconds(d: IDateTimeOffset): int64 {
+  return fromFloat64(d.getTime());
+}
+
+export function toUnixTimeSeconds(d: IDateTimeOffset): int64 {
+  return fromFloat64(d.getTime() / 1000.0);
+}

package/DateOnly.ts

@@ -0,0 +1,146 @@
+import { FSharpRef } from "./Types.js";
+import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth, ticksToUnixEpochMilliseconds } from "./Date.js";
+import { IDateTime, DateKind, padWithZeros } from "./Util.js";
+
+export function fromUnixMilliseconds(value: number) {
+  return DateTime(value, DateKind.UTC);
+}
+
+export function create(year: number, month: number, day: number) {
+  const d = fromUnixMilliseconds(Date.UTC(year, month - 1, day));
+  if (year <= 99) {
+    d.setUTCFullYear(year);
+  }
+  return d;
+}
+
+export function maxValue() {
+  // This is "9999-12-31T00:00:00.000Z"
+  return fromUnixMilliseconds(253402214400000);
+}
+
+export function minValue() {
+  // This is "0001-01-01T00:00:00.000Z"
+  return fromUnixMilliseconds(-62135596800000);
+}
+
+export function dayNumber(d: IDateTime) {
+   return Number((getTicks(d) / 864000000000n));
+}
+
+export function fromDayNumber(dayNumber: number) {
+  const ticks = 864000000000n * BigInt(dayNumber);
+  return fromUnixMilliseconds(ticksToUnixEpochMilliseconds(ticks));
+}
+
+export function fromDateTime(d: IDateTime) {
+  return create(Date_year(d), Date_month(d), Date_day(d));
+}
+
+export function day(d: IDateTime) {
+  return d.getUTCDate();
+}
+
+export function month(d: IDateTime) {
+  return d.getUTCMonth() + 1;
+}
+
+export function year(d: IDateTime) {
+  return d.getUTCFullYear();
+}
+
+export function dayOfWeek(d: IDateTime) {
+  return d.getUTCDay();
+}
+
+export function dayOfYear(d: IDateTime) {
+  return Date_dayOfYear(d);
+}
+
+export function toDateTime(d: IDateTime, time: number, kind = DateKind.Unspecified) {
+  return DateTime(d.getTime() + time + (kind !== DateKind.UTC ? d.getTimezoneOffset() : 0) * 60000, kind);
+}
+
+export function toString(d: IDateTime, format = "d", _provider?: any) {
+  if (["d", "o", "O"].indexOf(format) === -1) {
+    throw new Error("Custom formats are not supported");
+  }
+
+  const y = padWithZeros(year(d), 4);
+  const m = padWithZeros(month(d), 2);
+  const dd = padWithZeros(day(d), 2);
+
+  return format === "d" ? `${m}/${dd}/${y}` : `${y}-${m}-${dd}`;
+}
+
+export function parse(str: string) {
+  function fail(): IDateTime {
+    throw new Error(`String '${str}' was not recognized as a valid DateOnly.`);
+  }
+
+  // Allowed separators: . , / -
+  // TODO whitespace alone as the separator
+  //
+  // Whitespace around separators
+  //
+  // Allowed format types:
+  // yyyy/mm/dd
+  // mm/dd/yyyy
+  // mm/dd
+  // mm/yyyy
+  // yyyy/mm
+  const r = /^\s*(\d{1,4})(?:\s*[.,-\/]\s*(\d{1,2}))?\s*[.,-\/]\s*(\d{1,4})\s*$/.exec(str);
+  if (r != null) {
+    let y = 0;
+    let m = 0;
+    let d = 1;
+
+    if (r[2] == null) {
+      if (r[1].length < 3) {
+        if (r[3].length < 3) {
+          // 12/30 = December 30, {CurrentYear}
+          y = new Date().getFullYear();
+          m = +r[1];
+          d = +r[3];
+        } else {
+          // 12/2000 = December 1, 2000
+          m = +r[1];
+          y = +r[3];
+        }
+      } else {
+        if (r[3].length > 2)
+          fail();
+
+        // 2000/12 = December 1, 2000
+        y = +r[1];
+        m = +r[3];
+      }
+    } else {
+      // 2000/1/30 or 1/30/2000
+      const yearFirst = r[1].length > 2;
+      const yTmp = r[yearFirst ? 1 : 3];
+      y = +yTmp;
+
+      // year 0-29 is 2000-2029, 30-99 is 1930-1999
+      if (yTmp.length < 3)
+        y += y >= 30 ? 1900 : 2000;
+
+      m = +r[yearFirst ? 2 : 1];
+      d = +r[yearFirst ? 3 : 2];
+    }
+
+    if (y > 0 && m > 0 && m < 13 && d > 0 && d <= Date_daysInMonth(y, m))
+      return create(y, m, d);
+  }
+
+  return fail();
+}
+
+export function tryParse(v: string, defValue: FSharpRef<IDateTime>): boolean {
+  try {
+    defValue.contents = parse(v);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/Decimal.ts

@@ -0,0 +1,250 @@
+import Decimal, { BigSource } from "./lib/big.js";
+import { Numeric, symbol } from "./Numeric.js";
+import { FSharpRef } from "./Types.js";
+import { combineHashCodes } from "./Util.js";
+
+Decimal.prototype.GetHashCode = function () {
+  return combineHashCodes([this.s, this.e].concat(this.c))
+}
+
+Decimal.prototype.Equals = function (x: Decimal) {
+  return !this.cmp(x)
+}
+
+Decimal.prototype.CompareTo = function (x: Decimal) {
+  return this.cmp(x)
+}
+
+Decimal.prototype[symbol] = function() {
+  const _this = this;
+  return {
+    multiply: (y: Numeric) => _this.mul(y as BigSource),
+    toPrecision: (sd?: number) => _this.toPrecision(sd),
+    toExponential: (dp?: number) => _this.toExponential(dp),
+    toFixed: (dp?: number) => _this.toFixed(dp),
+    toHex: () => (Number(_this) >>> 0).toString(16),
+  }
+}
+
+export default Decimal;
+export type decimal = Decimal;
+
+export const get_Zero = new Decimal(0);
+export const get_One = new Decimal(1);
+export const get_MinusOne = new Decimal(-1);
+export const get_MaxValue = new Decimal("79228162514264337593543950335");
+export const get_MinValue = new Decimal("-79228162514264337593543950335");
+
+export function compare(x: Decimal, y: Decimal) {
+  return x.cmp(y);
+}
+
+export function equals(x: Decimal, y: Decimal) {
+  return !x.cmp(y);
+}
+
+export function abs(x: Decimal) { return x.abs(); }
+export function sign(x: Decimal): number { return x < get_Zero ? -1 : x > get_Zero ? 1 : 0; }
+
+export function max(x: Decimal, y: Decimal): Decimal { return x > y ? x : y; }
+export function min(x: Decimal, y: Decimal): Decimal { return x < y ? x : y; }
+
+export function maxMagnitude(x: Decimal, y: Decimal): Decimal { return abs(x) > abs(y) ? x : y; }
+export function minMagnitude(x: Decimal, y: Decimal): Decimal { return abs(x) < abs(y) ? x : y; }
+
+export function clamp(x: Decimal, min: Decimal, max: Decimal): Decimal {
+  return x < min ? min : x > max ? max : x;
+}
+
+export function round(x: Decimal, digits: number = 0) {
+  return x.round(digits, 2 /* ROUND_HALF_EVEN */);
+}
+
+export function truncate(x: Decimal) {
+  return x.round(0, 0 /* ROUND_DOWN */);
+}
+
+export function ceiling(x: Decimal) {
+  return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);
+}
+
+export function floor(x: Decimal) {
+  return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);
+}
+
+export function pow(x: Decimal, n: number) {
+  return x.pow(n);
+}
+
+export function sqrt(x: Decimal) {
+  return x.sqrt();
+}
+
+export function op_Addition(x: Decimal, y: Decimal) {
+  return x.add(y);
+}
+
+export function op_Subtraction(x: Decimal, y: Decimal) {
+  return x.sub(y);
+}
+
+export function op_Multiply(x: Decimal, y: Decimal) {
+  return x.mul(y);
+}
+
+export function op_Division(x: Decimal, y: Decimal) {
+  return x.div(y);
+}
+
+export function op_Modulus(x: Decimal, y: Decimal) {
+  return x.mod(y);
+}
+
+export function op_UnaryNegation(x: Decimal) {
+  const x2 = new Decimal(x);
+  x2.s = -x2.s || 0;
+  return x2;
+}
+
+export function op_UnaryPlus(x: Decimal) {
+  return x;
+}
+
+export const add = op_Addition;
+export const subtract = op_Subtraction;
+export const multiply = op_Multiply;
+export const divide = op_Division;
+export const remainder = op_Modulus;
+export const negate = op_UnaryNegation;
+
+export function toString(x: Decimal) {
+  return x.toString();
+}
+
+export function tryParse(str: string, defValue: FSharpRef<Decimal>): boolean {
+  try {
+    defValue.contents = new Decimal(str.trim());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function parse(str: string): Decimal {
+  const defValue = new FSharpRef(get_Zero);
+  if (tryParse(str, defValue)) {
+    return defValue.contents;
+  } else {
+    throw new Error(`The input string ${str} was not in a correct format.`);
+  }
+}
+
+export function toNumber(x: Decimal) {
+  return +x;
+}
+
+function decimalToHex(dec: Uint8Array, bitSize: number) {
+  const hex = new Uint8Array(bitSize / 4 | 0);
+  let hexCount = 1;
+  for (let d = 0; d < dec.length; d++) {
+    let value = dec[d];
+    for (let i = 0; i < hexCount; i++) {
+      const digit = hex[i] * 10 + value | 0;
+      hex[i] = digit & 0xF;
+      value = digit >> 4;
+    }
+    if (value !== 0) {
+      hex[hexCount++] = value;
+    }
+  }
+  return hex.slice(0, hexCount); // digits in reverse order
+}
+
+function hexToDecimal(hex: Uint8Array, bitSize: number) {
+  const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);
+  let decCount = 1;
+  for (let d = hex.length - 1; d >= 0; d--) {
+    let carry = hex[d];
+    for (let i = 0; i < decCount; i++) {
+      const val = dec[i] * 16 + carry | 0;
+      dec[i] = (val % 10) | 0;
+      carry = (val / 10) | 0;
+    }
+    while (carry > 0) {
+      dec[decCount++] = (carry % 10) | 0;
+      carry = (carry / 10) | 0;
+    }
+  }
+  return dec.slice(0, decCount); // digits in reverse order
+}
+
+function setInt32Bits(hexDigits: Uint8Array, bits: number, offset: number) {
+  for (let i = 0; i < 8; i++) {
+    hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;
+  }
+}
+
+function getInt32Bits(hexDigits: Uint8Array, offset: number) {
+  let bits = 0;
+  for (let i = 0; i < 8; i++) {
+    bits = bits | (hexDigits[offset + i] << (i * 4));
+  }
+  return bits;
+}
+
+export function fromIntArray(bits: ArrayLike<number>) {
+  return fromInts(bits[0], bits[1], bits[2], bits[3]);
+}
+
+export function fromInts(low: number, mid: number, high: number, signExp: number) {
+  const isNegative = signExp < 0;
+  const scale = (signExp >> 16) & 0x7F;
+  return fromParts(low, mid, high, isNegative, scale);
+}
+
+export function fromParts(low: number, mid: number, high: number, isNegative: boolean, scale: number) {
+  const bitSize = 96;
+  const hexDigits = new Uint8Array(bitSize / 4);
+  setInt32Bits(hexDigits, low, 0);
+  setInt32Bits(hexDigits, mid, 8);
+  setInt32Bits(hexDigits, high, 16);
+  const decDigits = hexToDecimal(hexDigits, bitSize);
+  scale = scale & 0x7F;
+  const big = new Decimal(0);
+  big.c = Array.from(decDigits.reverse());
+  big.e = decDigits.length - scale - 1;
+  big.s = isNegative ? -1 : 1;
+  const d = new Decimal(big);
+  return d;
+}
+
+export function getBits(d: Decimal) {
+  const bitSize = 96;
+  const decDigits = Uint8Array.from(d.c);
+  const hexDigits = decimalToHex(decDigits, bitSize);
+  const low = getInt32Bits(hexDigits, 0);
+  const mid = getInt32Bits(hexDigits, 8);
+  const high = getInt32Bits(hexDigits, 16);
+  const decStr = d.toString();
+  const dotPos = decStr.indexOf(".");
+  const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;
+  const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);
+  return [low, mid, high, signExp];
+}
+
+// export function makeRangeStepFunction(step: Decimal, last: Decimal) {
+//   const stepComparedWithZero = step.cmp(get_Zero);
+//   if (stepComparedWithZero === 0) {
+//     throw new Error("The step of a range cannot be zero");
+//   }
+//   const stepGreaterThanZero = stepComparedWithZero > 0;
+//   return (x: Decimal) => {
+//     const comparedWithLast = x.cmp(last);
+//     if ((stepGreaterThanZero && comparedWithLast <= 0)
+//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {
+//       return [x, op_Addition(x, step)];
+//     } else {
+//       return undefined;
+//     }
+//   };
+// }