@nfdi4plants/arctrl 3.1.1 → 3.2.0

package/dist/ts/node_modules/@fable-org/fable-library-ts/Date.js

@@ -0,0 +1,843 @@
+import { toInt64, toFloat64 } from './BigInt.js';
+import { Exception, DateTimeKind, padWithZeros, dateOffset, compareDates } from './Util.js';
+
+const shortDays = [
+  "Sun",
+  "Mon",
+  "Tue",
+  "Wed",
+  "Thu",
+  "Fri",
+  "Sat"
+];
+const longDays = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+const shortMonths = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+const longMonths = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function parseRepeatToken(format, pos, patternChar) {
+  let tokenLength = 0;
+  let internalPos = pos;
+  while (internalPos < format.length && format[internalPos] === patternChar) {
+    internalPos++;
+    tokenLength++;
+  }
+  return tokenLength;
+}
+function parseNextChar(format, pos) {
+  if (pos >= format.length - 1) {
+    return -1;
+  }
+  return format.charCodeAt(pos + 1);
+}
+function parseQuotedString(format, pos) {
+  let beginPos = pos;
+  const quoteChar = format[pos];
+  let result = "";
+  let foundQuote = false;
+  while (pos < format.length) {
+    pos++;
+    const currentChar = format[pos];
+    if (currentChar === quoteChar) {
+      foundQuote = true;
+      break;
+    } else if (currentChar === "\\") {
+      if (pos < format.length) {
+        pos++;
+        result += format[pos];
+      } else {
+        throw new Exception("Invalid string format");
+      }
+    } else {
+      result += currentChar;
+    }
+  }
+  if (!foundQuote) {
+    throw new Exception(`Invalid string format could not find matching quote for ${quoteChar}`);
+  }
+  return [result, pos - beginPos + 1];
+}
+function dateToStringWithCustomFormat(date2, format, utc) {
+  let cursorPos = 0;
+  let tokenLength = 0;
+  let result = "";
+  const localizedDate = utc ? DateTime(date2.getTime(), DateTimeKind.Utc) : date2;
+  while (cursorPos < format.length) {
+    const token = format[cursorPos];
+    switch (token) {
+      case "d":
+        tokenLength = parseRepeatToken(format, cursorPos, "d");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += day(localizedDate);
+            break;
+          case 2:
+            result += padWithZeros(day(localizedDate), 2);
+            break;
+          case 3:
+            result += shortDays[dayOfWeek(localizedDate)];
+            break;
+          case 4:
+          default:
+            result += longDays[dayOfWeek(localizedDate)];
+            break;
+        }
+        break;
+      case "f":
+        tokenLength = parseRepeatToken(format, cursorPos, "f");
+        cursorPos += tokenLength;
+        if (tokenLength <= 3) {
+          const precision = 10 ** (3 - tokenLength);
+          result += padWithZeros(Math.floor(millisecond(localizedDate) / precision), tokenLength);
+        } else if (tokenLength <= 7) {
+          result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+        } else {
+          throw "Input string was not in a correct format.";
+        }
+        break;
+      case "F":
+        tokenLength = parseRepeatToken(format, cursorPos, "F");
+        cursorPos += tokenLength;
+        if (tokenLength <= 3) {
+          const precision = 10 ** (3 - tokenLength);
+          const value = Math.floor(millisecond(localizedDate) / precision);
+          if (value != 0) {
+            result += padWithZeros(value, tokenLength);
+          }
+        } else if (tokenLength <= 7) {
+          const value = millisecond(localizedDate);
+          if (value != 0) {
+            result += padWithZeros(value, 3);
+          }
+        } else {
+          throw "Input string was not in a correct format.";
+        }
+        break;
+      case "g":
+        tokenLength = parseRepeatToken(format, cursorPos, "g");
+        cursorPos += tokenLength;
+        result += "A.D.";
+        break;
+      case "h":
+        tokenLength = parseRepeatToken(format, cursorPos, "h");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            const h1Value = hour(localizedDate) % 12;
+            result += h1Value ? h1Value : 12;
+            break;
+          case 2:
+          default:
+            const h2Value = hour(localizedDate) % 12;
+            result += padWithZeros(h2Value ? h2Value : 12, 2);
+            break;
+        }
+        break;
+      case "H":
+        tokenLength = parseRepeatToken(format, cursorPos, "H");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += hour(localizedDate);
+            break;
+          case 2:
+          default:
+            result += padWithZeros(hour(localizedDate), 2);
+            break;
+        }
+        break;
+      case "K":
+        tokenLength = parseRepeatToken(format, cursorPos, "K");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            switch (getKind(localizedDate)) {
+              case DateTimeKind.Utc:
+                result += "Z";
+                break;
+              case DateTimeKind.Local:
+                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -6e4);
+                break;
+              case DateTimeKind.Unspecified:
+                break;
+            }
+            break;
+          default:
+            break;
+        }
+        break;
+      case "m":
+        tokenLength = parseRepeatToken(format, cursorPos, "m");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += minute(localizedDate);
+            break;
+          case 2:
+          default:
+            result += padWithZeros(minute(localizedDate), 2);
+            break;
+        }
+        break;
+      case "M":
+        tokenLength = parseRepeatToken(format, cursorPos, "M");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += month(localizedDate);
+            break;
+          case 2:
+            result += padWithZeros(month(localizedDate), 2);
+            break;
+          case 3:
+            result += shortMonths[month(localizedDate) - 1];
+            break;
+          case 4:
+          default:
+            result += longMonths[month(localizedDate) - 1];
+            break;
+        }
+        break;
+      case "s":
+        tokenLength = parseRepeatToken(format, cursorPos, "s");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += second(localizedDate);
+            break;
+          case 2:
+          default:
+            result += padWithZeros(second(localizedDate), 2);
+            break;
+        }
+        break;
+      case "t":
+        tokenLength = parseRepeatToken(format, cursorPos, "t");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += localizedDate.getHours() < 12 ? "A" : "P";
+            break;
+          case 2:
+          default:
+            result += localizedDate.getHours() < 12 ? "AM" : "PM";
+            break;
+        }
+        break;
+      case "y":
+        tokenLength = parseRepeatToken(format, cursorPos, "y");
+        cursorPos += tokenLength;
+        switch (tokenLength) {
+          case 1:
+            result += year(localizedDate) % 100;
+            break;
+          case 2:
+            result += padWithZeros(year(localizedDate) % 100, 2);
+            break;
+          default:
+            result += padWithZeros(year(localizedDate), tokenLength);
+            break;
+        }
+        break;
+      case "z":
+        tokenLength = parseRepeatToken(format, cursorPos, "z");
+        cursorPos += tokenLength;
+        let utcOffsetText = "";
+        switch (getKind(localizedDate)) {
+          case DateTimeKind.Utc:
+            utcOffsetText = "+00:00";
+            break;
+          case DateTimeKind.Local:
+            utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -6e4);
+            break;
+          case DateTimeKind.Unspecified:
+            utcOffsetText = dateOffsetToString(toLocalTime(localizedDate).getTimezoneOffset() * -6e4);
+            break;
+        }
+        const sign = utcOffsetText[0] === "-" ? "-" : "+";
+        const hours = parseInt(utcOffsetText.substring(1, 3), 10);
+        const minutes = parseInt(utcOffsetText.substring(4, 6), 10);
+        switch (tokenLength) {
+          case 1:
+            result += `${sign}${hours}`;
+            break;
+          case 2:
+            result += `${sign}${padWithZeros(hours, 2)}`;
+            break;
+          default:
+            result += `${sign}${padWithZeros(hours, 2)}:${padWithZeros(minutes, 2)}`;
+            break;
+        }
+        break;
+      case ":":
+        result += ":";
+        cursorPos++;
+        break;
+      case "/":
+        result += "/";
+        cursorPos++;
+        break;
+      case "'":
+      case '"':
+        const [quotedString, quotedStringLenght] = parseQuotedString(format, cursorPos);
+        result += quotedString;
+        cursorPos += quotedStringLenght;
+        break;
+      case "%":
+        const nextChar = parseNextChar(format, cursorPos);
+        if (nextChar >= 0 && nextChar !== "%".charCodeAt(0)) {
+          cursorPos += 2;
+          result += dateToStringWithCustomFormat(localizedDate, String.fromCharCode(nextChar), utc);
+        } else {
+          throw new Exception("Invalid format string");
+        }
+        break;
+      case "\\":
+        const nextChar2 = parseNextChar(format, cursorPos);
+        if (nextChar2 >= 0) {
+          cursorPos += 2;
+          result += String.fromCharCode(nextChar2);
+        } else {
+          throw new Exception("Invalid format string");
+        }
+        break;
+      default:
+        cursorPos++;
+        result += token;
+        break;
+    }
+  }
+  return result;
+}
+function getKind(value) {
+  return value.kind ?? DateTimeKind.Unspecified;
+}
+function unixEpochMillisecondsToTicks(ms, offset) {
+  return toInt64((BigInt(ms) + 62135596800000n + BigInt(offset)) * 10000n);
+}
+function ticksToUnixEpochMilliseconds(ticks) {
+  return Number(BigInt(ticks) / 10000n - 62135596800000n);
+}
+function dateOffsetToString(offset) {
+  const isMinus = offset < 0;
+  offset = Math.abs(offset);
+  const hours = ~~(offset / 36e5);
+  const minutes = offset % 36e5 / 6e4;
+  return (isMinus ? "-" : "+") + padWithZeros(hours, 2) + ":" + padWithZeros(minutes, 2);
+}
+function dateToISOString(d, utc) {
+  if (utc) {
+    return d.toISOString();
+  } else {
+    const printOffset = d.kind == null ? true : d.kind === DateTimeKind.Local;
+    return padWithZeros(d.getFullYear(), 4) + "-" + padWithZeros(d.getMonth() + 1, 2) + "-" + padWithZeros(d.getDate(), 2) + "T" + padWithZeros(d.getHours(), 2) + ":" + padWithZeros(d.getMinutes(), 2) + ":" + padWithZeros(d.getSeconds(), 2) + "." + padWithZeros(d.getMilliseconds(), 3) + (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -6e4) : "");
+  }
+}
+function dateToISOStringWithOffset(dateWithOffset, offset) {
+  const str = dateWithOffset.toISOString();
+  return str.substring(0, str.length - 1) + dateOffsetToString(offset);
+}
+function dateToStringWithOffset(date2, format) {
+  const d = new Date(date2.getTime() + (date2.offset ?? 0));
+  if (typeof format !== "string") {
+    return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString(date2.offset ?? 0);
+  } else if (format.length === 1) {
+    switch (format) {
+      case "D":
+        return dateToString_D(d);
+      case "d":
+        return dateToString_d(d);
+      case "F":
+        return dateToString_D(d) + " " + dateToString_T(d);
+      case "f":
+        return dateToString_D(d) + " " + dateToString_t(d);
+      case "G":
+        return dateToString_d(d) + " " + dateToString_T(d);
+      case "g":
+        return dateToString_d(d) + " " + dateToString_t(d);
+      case "M":
+      case "m":
+        return dateToString_M(d);
+      case "O":
+      case "o":
+        return dateToISOStringWithOffset(d, date2.offset ?? 0);
+      case "R":
+      case "r": {
+        const utcDate = DateTime(date2.getTime(), DateTimeKind.Utc);
+        return dateToString_R(utcDate);
+      }
+      case "s":
+        return dateToString_s(toUniversalTime(d));
+      case "T":
+        return dateToString_T(toUniversalTime(d));
+      case "t":
+        return dateToString_t(toUniversalTime(d));
+      case "u": {
+        const utcDate = DateTime(date2.getTime(), DateTimeKind.Utc);
+        return dateToString_u(utcDate);
+      }
+      case "U": {
+        const utcDate = DateTime(date2.getTime(), DateTimeKind.Utc);
+        return dateToString_D(utcDate) + " " + dateToString_T(utcDate);
+      }
+      case "Y":
+      case "y":
+        return dateToString_Y(d);
+      default:
+        throw new Exception("Unrecognized Date print format");
+    }
+  } else {
+    return dateToStringWithCustomFormat(d, format, true);
+  }
+}
+function dateToString_D(date2) {
+  return longDays[dayOfWeek(date2)] + ", " + padWithZeros(day(date2), 2) + " " + longMonths[month(date2) - 1] + " " + year(date2);
+}
+function dateToString_d(date2) {
+  return padWithZeros(month(date2), 2) + "/" + padWithZeros(day(date2), 2) + "/" + year(date2);
+}
+function dateToString_T(date2) {
+  return padWithZeros(hour(date2), 2) + ":" + padWithZeros(minute(date2), 2) + ":" + padWithZeros(second(date2), 2);
+}
+function dateToString_t(date2) {
+  return padWithZeros(hour(date2), 2) + ":" + padWithZeros(minute(date2), 2);
+}
+function dateToString_R(date2) {
+  const utcDate = toUniversalTime(date2);
+  return shortDays[dayOfWeek(utcDate)] + ", " + padWithZeros(day(utcDate), 2) + " " + shortMonths[month(utcDate) - 1] + " " + year(utcDate) + " " + padWithZeros(hour(utcDate), 2) + ":" + padWithZeros(minute(utcDate), 2) + ":" + padWithZeros(second(utcDate), 2) + " GMT";
+}
+function dateToString_s(date2) {
+  return padWithZeros(year(date2), 4) + "-" + padWithZeros(month(date2), 2) + "-" + padWithZeros(day(date2), 2) + "T" + padWithZeros(hour(date2), 2) + ":" + padWithZeros(minute(date2), 2) + ":" + padWithZeros(second(date2), 2);
+}
+function dateToString_u(date2) {
+  const utcDate = toUniversalTime(date2);
+  return padWithZeros(year(utcDate), 4) + "-" + padWithZeros(month(utcDate), 2) + "-" + padWithZeros(day(utcDate), 2) + " " + padWithZeros(hour(utcDate), 2) + ":" + padWithZeros(minute(utcDate), 2) + ":" + padWithZeros(second(utcDate), 2) + "Z";
+}
+function dateToString_M(date2) {
+  return longMonths[month(date2) - 1] + " " + padWithZeros(day(date2), 2);
+}
+function dateToString_Y(date2) {
+  return year(date2) + " " + longMonths[month(date2) - 1];
+}
+function dateToStringWithKind(date2, format) {
+  const utc = date2.kind === DateTimeKind.Utc;
+  if (typeof format !== "string") {
+    return dateToString_d(date2) + " " + dateToString_T(date2);
+  } else if (format.length === 1) {
+    switch (format) {
+      case "D":
+        return dateToString_D(date2);
+      case "d":
+        return dateToString_d(date2);
+      case "F":
+        return dateToString_D(date2) + " " + dateToString_T(date2);
+      case "f":
+        return dateToString_D(date2) + " " + dateToString_t(date2);
+      case "G":
+        return dateToString_d(date2) + " " + dateToString_T(date2);
+      case "g":
+        return dateToString_d(date2) + " " + dateToString_t(date2);
+      case "M":
+      case "m":
+        return dateToString_M(date2);
+      case "O":
+      case "o":
+        return dateToISOString(date2, utc);
+      case "R":
+      case "r":
+        return dateToString_R(date2);
+      case "s":
+        return dateToString_s(date2);
+      case "T":
+        return dateToString_T(date2);
+      case "t":
+        return dateToString_t(date2);
+      case "u":
+        return dateToString_u(date2);
+      case "U":
+        return dateToString_D(toUniversalTime(date2)) + " " + dateToString_T(toUniversalTime(date2));
+      case "Y":
+      case "y":
+        return dateToString_Y(date2);
+      default:
+        throw new Exception("Unrecognized Date print format");
+    }
+  } else {
+    return dateToStringWithCustomFormat(date2, format, utc);
+  }
+}
+function toString(date2, format, _provider) {
+  return date2.offset != null ? dateToStringWithOffset(date2, format) : dateToStringWithKind(date2, format);
+}
+function DateTime(value, kind) {
+  const d = new Date(value);
+  d.kind = kind == null ? DateTimeKind.Unspecified : kind;
+  return d;
+}
+function fromTicks(ticks, kind) {
+  kind = kind != null ? kind : DateTimeKind.Local;
+  let date2 = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);
+  if (kind !== DateTimeKind.Utc) {
+    date2 = DateTime(date2.getTime() - dateOffset(date2), kind);
+  }
+  return date2;
+}
+function fromDateTime(dateOnly, timeOnly, kind) {
+  const d = DateTime(dateOnly.getTime() + timeOnly, kind);
+  return DateTime(d.getTime() - dateOffset(d), kind);
+}
+function fromDateTimeOffset(date2, kind) {
+  switch (kind) {
+    case DateTimeKind.Utc:
+      return DateTime(date2.getTime(), DateTimeKind.Utc);
+    case DateTimeKind.Local:
+      return DateTime(date2.getTime(), DateTimeKind.Local);
+    default:
+      const d = DateTime(date2.getTime() + (date2.offset ?? 0), kind);
+      return DateTime(d.getTime() - dateOffset(d), kind);
+  }
+}
+function getTicks(date2) {
+  return unixEpochMillisecondsToTicks(date2.getTime(), dateOffset(date2));
+}
+function minValue() {
+  return DateTime(-621355968e5, DateTimeKind.Utc);
+}
+function maxValue() {
+  return DateTime(253402300799999, DateTimeKind.Utc);
+}
+const recognizedDateWords = /* @__PURE__ */ new Set([
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "sept",
+  "oct",
+  "nov",
+  "dec",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "mon",
+  "tue",
+  "wed",
+  "thu",
+  "fri",
+  "sat",
+  "sun",
+  "am",
+  "pm",
+  "gmt",
+  "utc",
+  "ut",
+  "t",
+  "z"
+]);
+function parseRaw(input) {
+  function fail() {
+    throw new Exception(`The string is not a valid Date: ${input}`);
+  }
+  if (input == null || input.trim() === "") {
+    fail();
+  }
+  if ((input.match(/[a-z]+/gi) ?? []).some((word) => !recognizedDateWords.has(word.toLowerCase()))) {
+    fail();
+  }
+  if (input.length === 10 && input[4] === "-" && input[7] === "-") {
+    input += "T00:00:00";
+  }
+  let date2 = new Date(input);
+  let offset = null;
+  if (isNaN(date2.getTime())) {
+    const m = /^\s*(\d+[^\w\s:]\d+[^\w\s:]\d+)?\s*(\d+:\d+(?::\d+(?:\.\d+)?)?)?\s*([AaPp][Mm])?\s*(Z|[+-]([01]?\d):?([0-5]?\d)?)?\s*$/.exec(input);
+    if (m != null) {
+      let baseDate;
+      let timeInSeconds = 0;
+      if (m[2] != null) {
+        const timeParts = m[2].split(":");
+        const hourPart = parseInt(timeParts[0], 10);
+        timeInSeconds = hourPart * 3600 + parseInt(timeParts[1] || "0", 10) * 60 + parseFloat(timeParts[2] || "0");
+        if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
+          timeInSeconds += 12 * 3600;
+        } else if (m[3] != null && m[3].toUpperCase() === "AM" && hourPart === 12) {
+          timeInSeconds -= 12 * 3600;
+        }
+      }
+      if (m[4] != null) {
+        if (m[1] != null) {
+          baseDate = /* @__PURE__ */ new Date(m[1] + " UTC");
+        } else {
+          const d = /* @__PURE__ */ new Date();
+          baseDate = /* @__PURE__ */ new Date(d.getUTCFullYear() + "/" + (d.getUTCMonth() + 1) + "/" + d.getUTCDate());
+        }
+        if (m[4] === "Z") {
+          offset = "Z";
+        } else {
+          let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || "0", 10);
+          if (m[4][0] === "-") {
+            offsetInMinutes *= -1;
+          }
+          offset = offsetInMinutes;
+          timeInSeconds -= offsetInMinutes * 60;
+        }
+      } else {
+        if (m[1] != null) {
+          baseDate = new Date(m[1]);
+        } else {
+          const d = /* @__PURE__ */ new Date();
+          baseDate = /* @__PURE__ */ new Date(d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate());
+        }
+      }
+      date2 = new Date(baseDate.getTime() + timeInSeconds * 1e3);
+      date2 = new Date(date2.getTime() + (date2.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 6e4);
+    } else {
+      fail();
+    }
+    if (isNaN(date2.getTime())) {
+      fail();
+    }
+  }
+  return [date2, offset];
+}
+function parse(str, detectUTC = false) {
+  const [date2, offset] = parseRaw(str);
+  const kind = offset != null ? detectUTC && offset === "Z" ? DateTimeKind.Utc : DateTimeKind.Local : DateTimeKind.Unspecified;
+  return DateTime(date2.getTime(), kind);
+}
+function tryParse(v, defValue) {
+  try {
+    defValue.contents = parse(v);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+function create(year2, month2, day2, h = 0, m = 0, s = 0, ms = 0, kind) {
+  const date2 = kind === DateTimeKind.Utc ? new Date(Date.UTC(year2, month2 - 1, day2, h, m, s, ms)) : new Date(year2, month2 - 1, day2, h, m, s, ms);
+  if (year2 <= 99) {
+    if (kind === DateTimeKind.Utc) {
+      date2.setUTCFullYear(year2, month2 - 1, day2);
+    } else {
+      date2.setFullYear(year2, month2 - 1, day2);
+    }
+  }
+  const dateValue = date2.getTime();
+  if (isNaN(dateValue)) {
+    throw new Exception("The parameters describe an unrepresentable Date.");
+  }
+  return DateTime(dateValue, kind);
+}
+function now() {
+  return DateTime(Date.now(), DateTimeKind.Local);
+}
+function utcNow() {
+  return DateTime(Date.now(), DateTimeKind.Utc);
+}
+function today() {
+  return date(now());
+}
+function isLeapYear(year2) {
+  return year2 % 4 === 0 && year2 % 100 !== 0 || year2 % 400 === 0;
+}
+function daysInMonth(year2, month2) {
+  return month2 === 2 ? isLeapYear(year2) ? 29 : 28 : month2 >= 8 ? month2 % 2 === 0 ? 31 : 30 : month2 % 2 === 0 ? 30 : 31;
+}
+function toUniversalTime(date2) {
+  return date2.kind === DateTimeKind.Utc ? date2 : DateTime(date2.getTime(), DateTimeKind.Utc);
+}
+function toLocalTime(date2) {
+  return date2.kind === DateTimeKind.Local ? date2 : DateTime(date2.getTime(), DateTimeKind.Local);
+}
+function specifyKind(d, kind) {
+  return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);
+}
+function timeOfDay(d) {
+  return hour(d) * 36e5 + minute(d) * 6e4 + second(d) * 1e3 + millisecond(d);
+}
+function date(d) {
+  return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);
+}
+function day(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCDate() : d.getDate();
+}
+function hour(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCHours() : d.getHours();
+}
+function millisecond(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCMilliseconds() : d.getMilliseconds();
+}
+function minute(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCMinutes() : d.getMinutes();
+}
+function month(d) {
+  return (d.kind === DateTimeKind.Utc ? d.getUTCMonth() : d.getMonth()) + 1;
+}
+function second(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCSeconds() : d.getSeconds();
+}
+function year(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCFullYear() : d.getFullYear();
+}
+function dayOfWeek(d) {
+  return d.kind === DateTimeKind.Utc ? d.getUTCDay() : d.getDay();
+}
+function dayOfYear(d) {
+  const _year = year(d);
+  const _month = month(d);
+  let _day = day(d);
+  for (let i = 1; i < _month; i++) {
+    _day += daysInMonth(_year, i);
+  }
+  return _day;
+}
+function add(d, ts) {
+  const newDate = DateTime(d.getTime() + ts, d.kind);
+  if (d.kind !== DateTimeKind.Utc) {
+    const oldTzOffset = d.getTimezoneOffset();
+    const newTzOffset = newDate.getTimezoneOffset();
+    return oldTzOffset !== newTzOffset ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 6e4, d.kind) : newDate;
+  } else {
+    return newDate;
+  }
+}
+function addDays(d, v) {
+  return add(d, v * 864e5);
+}
+function addHours(d, v) {
+  return add(d, v * 36e5);
+}
+function addMinutes(d, v) {
+  return add(d, v * 6e4);
+}
+function addSeconds(d, v) {
+  return add(d, v * 1e3);
+}
+function addMilliseconds(d, v) {
+  return add(d, v);
+}
+function addTicks(d, v) {
+  return add(d, toFloat64(v / 10000n));
+}
+function addYears(d, v) {
+  const newMonth = month(d);
+  const newYear = year(d) + v;
+  const _daysInMonth = daysInMonth(newYear, newMonth);
+  const newDay = Math.min(_daysInMonth, day(d));
+  return create(
+    newYear,
+    newMonth,
+    newDay,
+    hour(d),
+    minute(d),
+    second(d),
+    millisecond(d),
+    d.kind
+  );
+}
+function addMonths(d, v) {
+  const totalMonths = month(d) + v;
+  const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+  const yearOffset = Math.floor((totalMonths - 1) / 12);
+  const newYear = year(d) + yearOffset;
+  const _daysInMonth = daysInMonth(newYear, newMonth);
+  const newDay = Math.min(_daysInMonth, day(d));
+  return create(
+    newYear,
+    newMonth,
+    newDay,
+    hour(d),
+    minute(d),
+    second(d),
+    millisecond(d),
+    d.kind
+  );
+}
+function subtract(d, that) {
+  return typeof that === "number" ? add(d, -that) : d.getTime() - that.getTime();
+}
+function toLongDateString(d) {
+  return d.toDateString();
+}
+function toShortDateString(d) {
+  return d.toLocaleDateString();
+}
+function toLongTimeString(d) {
+  return d.toLocaleTimeString();
+}
+function toShortTimeString(d) {
+  return d.toLocaleTimeString().replace(/:\d\d(?!:)/, "");
+}
+function equals(d1, d2) {
+  return d1.getTime() === d2.getTime();
+}
+const compare = compareDates;
+const compareTo = compareDates;
+function op_Addition(x, y) {
+  return add(x, y);
+}
+function op_Subtraction(x, y) {
+  return subtract(x, y);
+}
+function isDaylightSavingTime(x) {
+  const jan = new Date(x.getFullYear(), 0, 1);
+  const jul = new Date(x.getFullYear(), 6, 1);
+  return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());
+}
+function isDST(janOffset, julOffset, tOffset) {
+  return Math.min(janOffset, julOffset) === tOffset;
+}
+
+export { DateTime, add, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addTicks, addYears, compare, compareTo, create, date, dateOffsetToString, day, dayOfWeek, dayOfYear, daysInMonth, DateTime as default, equals, fromDateTime, fromDateTimeOffset, fromTicks, getKind, getTicks, hour, isDaylightSavingTime, isLeapYear, maxValue, millisecond, minValue, minute, month, now, op_Addition, op_Subtraction, parse, parseRaw, second, specifyKind, subtract, ticksToUnixEpochMilliseconds, timeOfDay, toLocalTime, toLongDateString, toLongTimeString, toShortDateString, toShortTimeString, toString, toUniversalTime, today, tryParse, unixEpochMillisecondsToTicks, utcNow, year };