@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/cryptography.js

@@ -1,137 +1,179 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cryptography_exports = {};
-__export(cryptography_exports, {
-  decrypt: () => decrypt,
-  deriveBytes: () => deriveBytes,
-  deriveBytesMultiple: () => deriveBytesMultiple,
-  digest: () => digest,
-  encrypt: () => encrypt,
-  generateEcdsaKey: () => generateEcdsaKey,
-  generatePbkdf2Key: () => generatePbkdf2Key,
-  importEcdsaKey: () => importEcdsaKey,
-  importHmacKey: () => importHmacKey,
-  importPbkdf2Key: () => importPbkdf2Key,
-  importSymmetricKey: () => importSymmetricKey,
-  sign: () => sign,
-  verify: () => verify
-});
-module.exports = __toCommonJS(cryptography_exports);
-var import_array = require("./array/array.js");
-var import_base64 = require("./base64.js");
-var import_encoding = require("./encoding.js");
-var import_random = require("./random.js");
-var import_type_guards = require("./type-guards.js");
-var import_z_base32 = require("./z-base32.js");
+import { createArray } from './array/array.js';
+import { encodeBase64, encodeBase64Url } from './base64.js';
+import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
+import { getRandomBytes } from './random.js';
+import { isDefined, isString } from './type-guards.js';
+import { zBase32Encode } from './z-base32.js';
 const subtle = globalThis.crypto.subtle;
-function encrypt(algorithm, key, data) {
-  const bytes = (0, import_type_guards.isString)(data) ? (0, import_encoding.encodeUtf8)(data) : data;
-  const encryptedBuffer = subtle.encrypt(algorithm, key, bytes);
-  return {
-    toBuffer: async () => encryptedBuffer,
-    toHex: async () => (0, import_encoding.encodeHex)(await encryptedBuffer),
-    toBase64: async () => (0, import_base64.encodeBase64)(await encryptedBuffer),
-    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await encryptedBuffer),
-    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await encryptedBuffer)
-  };
+/**
+ * encrypt data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to encrypt. Encodes string to utf8
+ */
+export function encrypt(algorithm, key, data) {
+    const bytes = isString(data) ? encodeUtf8(data) : data;
+    const encryptedBuffer = subtle.encrypt(algorithm, key, bytes);
+    return {
+        toBuffer: async () => encryptedBuffer,
+        toHex: async () => encodeHex(await encryptedBuffer),
+        toBase64: async () => encodeBase64(await encryptedBuffer),
+        toBase64Url: async () => encodeBase64Url(await encryptedBuffer),
+        toZBase32: async () => zBase32Encode(await encryptedBuffer)
+    };
 }
-function decrypt(algorithm, key, bytes) {
-  const decryptedBuffer = subtle.decrypt(algorithm, key, bytes);
-  return {
-    toBuffer: async () => decryptedBuffer,
-    toHex: async () => (0, import_encoding.encodeHex)(await decryptedBuffer),
-    toBase64: async () => (0, import_base64.encodeBase64)(await decryptedBuffer),
-    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await decryptedBuffer),
-    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await decryptedBuffer),
-    toUtf8: async () => (0, import_encoding.decodeText)(await decryptedBuffer)
-  };
+/**
+ * decrypt data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to decrypt
+ */
+export function decrypt(algorithm, key, bytes) {
+    const decryptedBuffer = subtle.decrypt(algorithm, key, bytes);
+    return {
+        toBuffer: async () => decryptedBuffer,
+        toHex: async () => encodeHex(await decryptedBuffer),
+        toBase64: async () => encodeBase64(await decryptedBuffer),
+        toBase64Url: async () => encodeBase64Url(await decryptedBuffer),
+        toZBase32: async () => zBase32Encode(await decryptedBuffer),
+        toUtf8: async () => decodeText(await decryptedBuffer)
+    };
 }
-function digest(algorithm, data) {
-  const bytes = (0, import_type_guards.isString)(data) ? (0, import_encoding.encodeUtf8)(data) : data;
-  const arrayBufferPromise = subtle.digest(algorithm, bytes);
-  const result = {
-    toBuffer: async () => arrayBufferPromise,
-    toHex: async () => (0, import_encoding.encodeHex)(await arrayBufferPromise),
-    toBase64: async () => (0, import_base64.encodeBase64)(await arrayBufferPromise),
-    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await arrayBufferPromise),
-    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await arrayBufferPromise)
-  };
-  return result;
+/**
+ * hashes data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param data data to encrypt. Encodes string to utf8
+ */
+export function digest(algorithm, data) {
+    const bytes = isString(data) ? encodeUtf8(data) : data;
+    const arrayBufferPromise = subtle.digest(algorithm, bytes);
+    const result = {
+        toBuffer: async () => arrayBufferPromise,
+        toHex: async () => encodeHex(await arrayBufferPromise),
+        toBase64: async () => encodeBase64(await arrayBufferPromise),
+        toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+    };
+    return result;
 }
-function sign(algorithm, key, data) {
-  const bytes = (0, import_type_guards.isString)(data) ? (0, import_encoding.encodeUtf8)(data) : data;
-  const arrayBufferPromise = subtle.sign(algorithm, key, bytes);
-  const result = {
-    toBuffer: async () => arrayBufferPromise,
-    toHex: async () => (0, import_encoding.encodeHex)(await arrayBufferPromise),
-    toBase64: async () => (0, import_base64.encodeBase64)(await arrayBufferPromise),
-    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await arrayBufferPromise),
-    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await arrayBufferPromise)
-  };
-  return result;
+/**
+ * signs data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param data data to sign
+ */
+export function sign(algorithm, key, data) {
+    const bytes = isString(data) ? encodeUtf8(data) : data;
+    const arrayBufferPromise = subtle.sign(algorithm, key, bytes);
+    const result = {
+        toBuffer: async () => arrayBufferPromise,
+        toHex: async () => encodeHex(await arrayBufferPromise),
+        toBase64: async () => encodeBase64(await arrayBufferPromise),
+        toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+    };
+    return result;
 }
-async function verify(algorithm, key, signature, data) {
-  const signatureBytes = (0, import_type_guards.isString)(signature) ? (0, import_encoding.encodeUtf8)(signature) : signature;
-  const dataBytes = (0, import_type_guards.isString)(data) ? (0, import_encoding.encodeUtf8)(data) : data;
-  return subtle.verify(algorithm, key, signatureBytes, dataBytes);
+/**
+ * verifies data
+ * @param algorithm algorithm as supported by Web Crypto API
+ * @param key key
+ * @param signature signature
+ * @param data data to verify using provided signature
+ */
+export async function verify(algorithm, key, signature, data) {
+    const signatureBytes = isString(signature) ? encodeUtf8(signature) : signature;
+    const dataBytes = isString(data) ? encodeUtf8(data) : data;
+    return subtle.verify(algorithm, key, signatureBytes, dataBytes);
 }
-async function importHmacKey(algorithm, key, extractable = false) {
-  const binaryKey = (0, import_type_guards.isString)(key) ? (0, import_encoding.encodeUtf8)(key) : key;
-  if (isBinaryKey(binaryKey)) {
-    return subtle.importKey("raw", binaryKey, { name: "HMAC", hash: algorithm }, extractable, ["sign", "verify"]);
-  }
-  return subtle.importKey("jwk", binaryKey, { name: "HMAC", hash: algorithm }, extractable, ["sign", "verify"]);
+/**
+ * imports a HMAC CryptoKey
+ * @param algorithm hash algorithm
+ * @param key JWK or binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export async function importHmacKey(algorithm, key, extractable = false) {
+    const binaryKey = isString(key) ? encodeUtf8(key) : key;
+    if (isBinaryKey(binaryKey)) {
+        return subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+    }
+    return subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
 }
-async function importSymmetricKey(algorithm, length, key, extractable = false) {
-  const binaryKey = (0, import_type_guards.isString)(key) ? (0, import_encoding.encodeUtf8)(key) : key;
-  if (isBinaryKey(binaryKey)) {
-    return subtle.importKey("raw", binaryKey, { name: algorithm, length }, extractable, ["encrypt", "decrypt"]);
-  }
-  return subtle.importKey("jwk", binaryKey, { name: algorithm, length }, extractable, ["encrypt", "decrypt"]);
+/**
+ * imports a CryptoKey for symmetric encryption
+ * @param algorithm symmetric algorithm
+ * @param length key length
+ * @param key JWK or binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export async function importSymmetricKey(algorithm, length, key, extractable = false) {
+    const binaryKey = isString(key) ? encodeUtf8(key) : key;
+    if (isBinaryKey(binaryKey)) {
+        return subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+    }
+    return subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
 }
-async function importEcdsaKey(curve, key, extractable = false) {
-  const binaryKey = (0, import_type_guards.isString)(key) ? (0, import_encoding.encodeUtf8)(key) : key;
-  if (isBinaryKey(binaryKey)) {
-    return subtle.importKey("spki", binaryKey, { name: "ECDSA", namedCurve: curve }, extractable, ["verify"]);
-  }
-  return subtle.importKey("jwk", binaryKey, { name: "ECDSA", namedCurve: curve }, extractable, ["verify"]);
+/**
+ * imports an ECDSA CryptoKey
+ * @param curve ECDSA curve
+ * @param key JWK or DER encoded key
+ * @param extractable whether the key can be used for exportKey
+ */
+export async function importEcdsaKey(curve, key, extractable = false) {
+    const binaryKey = isString(key) ? encodeUtf8(key) : key;
+    if (isBinaryKey(binaryKey)) {
+        return subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+    }
+    return subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
 }
-async function importPbkdf2Key(key, extractable = false) {
-  const binaryKey = (0, import_type_guards.isString)(key) ? (0, import_encoding.encodeUtf8)(key) : key;
-  return globalThis.crypto.subtle.importKey("raw", binaryKey, { name: "PBKDF2" }, extractable, ["deriveKey", "deriveBits"]);
+/**
+ * import a pbkdf2 CryptoKey
+ * @param key binary key
+ * @param extractable whether the key can be used for exportKey
+ */
+export async function importPbkdf2Key(key, extractable = false) {
+    const binaryKey = isString(key) ? encodeUtf8(key) : key;
+    return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
 }
-async function generateEcdsaKey(curve, extractable = false, usages = ["sign", "verify"]) {
-  return subtle.generateKey({ name: "ECDSA", namedCurve: curve }, extractable, usages);
+/**
+ * generates a new ECDSA CryptoKeyPair
+ * @param curve ECDSA cruve to use
+ * @param extractable whether the key can be used for exportKey
+ * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
+ */
+export async function generateEcdsaKey(curve, extractable = false, usages = ['sign', 'verify']) {
+    return subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
 }
-async function generatePbkdf2Key(extractable = false) {
-  const key = (0, import_random.getRandomBytes)(16);
-  return importPbkdf2Key(key, extractable);
+/**
+ * generates a pbkdf2 CryptoKey
+ * @param extractable whether the key can be used for exportKey
+ */
+export async function generatePbkdf2Key(extractable = false) {
+    const key = getRandomBytes(16);
+    return importPbkdf2Key(key, extractable);
 }
-async function deriveBytes(algorithm, baseKey, length) {
-  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, length * 8);
-  return new Uint8Array(bytes);
+/**
+ * derive byte array from key
+ * @param length length in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export async function deriveBytes(algorithm, baseKey, length) {
+    const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, length * 8);
+    return new Uint8Array(bytes);
 }
-async function deriveBytesMultiple(algorithm, baseKey, count, length) {
-  const totalBits = count * length * 8;
-  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
-  return (0, import_array.createArray)(count, (index) => new Uint8Array(bytes.slice(index * length, index * length + length)));
+/**
+ * derive multiply byte arrays from key
+ * @param count how many Uint8Arrays to dervice
+ * @param length length of each Uint8Array in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export async function deriveBytesMultiple(algorithm, baseKey, count, length) {
+    const totalBits = count * length * 8;
+    const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
+    return createArray(count, (index) => new Uint8Array(bytes.slice(index * length, (index * length) + length)));
 }
 function isBinaryKey(key) {
-  return (0, import_type_guards.isDefined)(key.byteLength);
+    return isDefined(key.byteLength);
 }

package/utils/date-time.js

@@ -1,139 +1,103 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var date_time_exports = {};
-__export(date_time_exports, {
-  currentDate: () => currentDate,
-  currentTime: () => currentTime,
-  currentTimestamp: () => currentTimestamp,
-  currentTimestampSeconds: () => currentTimestampSeconds,
-  dateTimeToNumericDate: () => dateTimeToNumericDate,
-  dateTimeToTime: () => dateTimeToTime,
-  dateToNumericDate: () => dateToNumericDate,
-  now: () => now,
-  numericDateTimeToDateTime: () => numericDateTimeToDateTime,
-  numericDateTimeToTimestamp: () => numericDateTimeToTimestamp,
-  numericDateToDate: () => numericDateToDate,
-  numericDateToDateTime: () => numericDateToDateTime,
-  numericDateToTimestamp: () => numericDateToTimestamp,
-  numericTimeToTimeObject: () => numericTimeToTimeObject,
-  timeObjectToNumericTime: () => timeObjectToNumericTime,
-  timestampToNumericDate: () => timestampToNumericDate,
-  timestampToNumericDateAndTime: () => timestampToNumericDateAndTime,
-  timestampToTime: () => timestampToTime,
-  timestampToTimestampSeconds: () => timestampToTimestampSeconds,
-  toDateTime: () => toDateTime,
-  zonedDateObjectToDateTime: () => zonedDateObjectToDateTime
-});
-module.exports = __toCommonJS(date_time_exports);
-var import_not_supported_error = require("../error/not-supported.error.js");
-var import_luxon = require("luxon");
-var import_type_guards = require("./type-guards.js");
-var import_type_of = require("./type-of.js");
-var import_units = require("./units.js");
-function now() {
-  return /* @__PURE__ */ new Date();
-}
-function currentTimestamp() {
-  return Date.now();
-}
-function currentTimestampSeconds() {
-  return timestampToTimestampSeconds(currentTimestamp());
-}
-function timestampToTimestampSeconds(timestamp) {
-  return Math.floor(timestamp / 1e3);
-}
-function currentDate() {
-  const timestamp = currentTimestamp();
-  return timestampToNumericDate(timestamp);
-}
-function currentTime() {
-  const timestamp = currentTimestamp();
-  return timestampToTime(timestamp);
-}
-function toDateTime(input) {
-  if ((0, import_type_guards.isNumber)(input)) {
-    return import_luxon.DateTime.fromMillis(input);
-  }
-  if ((0, import_type_guards.isDate)(input)) {
-    return import_luxon.DateTime.fromJSDate(input);
-  }
-  if (import_luxon.DateTime.isDateTime(input)) {
-    return input;
-  }
-  throw new import_not_supported_error.NotSupportedError(`Unsupported input type "${(0, import_type_of.typeOf)(input)}".`);
-}
-function timestampToNumericDate(timestamp) {
-  return Math.floor(timestamp / import_units.millisecondsPerDay);
-}
-function dateToNumericDate(date) {
-  const timestamp = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());
-  return timestampToNumericDate(timestamp);
-}
-function timestampToTime(timestamp) {
-  return timestamp % import_units.millisecondsPerDay;
-}
-function timeObjectToNumericTime(time) {
-  return (time.hour ?? 0) * import_units.millisecondsPerHour + (time.minute ?? 0) * import_units.millisecondsPerMinute + (time.second ?? 0) * import_units.millisecondsPerSecond + (time.millisecond ?? 0);
-}
-function numericTimeToTimeObject(time) {
-  return {
-    hour: Math.floor(time / import_units.millisecondsPerHour),
-    minute: Math.floor(time % import_units.millisecondsPerHour / import_units.millisecondsPerMinute),
-    second: Math.floor(time % import_units.millisecondsPerMinute / import_units.millisecondsPerSecond),
-    millisecond: Math.floor(time % import_units.millisecondsPerSecond)
-  };
-}
-function timestampToNumericDateAndTime(timestamp) {
-  return {
-    date: timestampToNumericDate(timestamp),
-    time: timestampToTime(timestamp)
-  };
-}
-function numericDateToTimestamp(numericDate) {
-  return numericDate * import_units.millisecondsPerDay;
-}
-function numericDateToDate(numericDate) {
-  const timestamp = numericDateToTimestamp(numericDate);
-  const date = new Date(timestamp);
-  return {
-    year: date.getUTCFullYear(),
-    month: date.getUTCMonth() + 1,
-    day: date.getUTCDate()
-  };
-}
-function numericDateTimeToTimestamp({ date, time }) {
-  return numericDateToTimestamp(date) + time;
-}
-function zonedDateObjectToDateTime(zonedDate, units, options) {
-  return import_luxon.DateTime.fromObject({ ...zonedDate, ...units }, options);
-}
-function dateTimeToNumericDate(dateTime) {
-  const timestamp = dateTime.toUTC(void 0, { keepLocalTime: true }).toMillis();
-  return timestampToNumericDate(timestamp);
-}
-function numericDateToDateTime(numericDate, units, options) {
-  const date = numericDateToDate(numericDate);
-  return import_luxon.DateTime.fromObject({ ...date, ...units }, options);
-}
-function dateTimeToTime(dateTime) {
-  return dateTime.startOf("day").until(dateTime).count("milliseconds");
-}
-function numericDateTimeToDateTime({ date, time }, zone) {
-  return numericDateToDateTime(date, void 0, { zone }).set({ millisecond: time });
+import { NotSupportedError } from '../error/not-supported.error.js';
+import { DateTime } from 'luxon';
+import { isDate, isNumber } from './type-guards.js';
+import { typeOf } from './type-of.js';
+import { millisecondsPerDay, millisecondsPerHour, millisecondsPerMinute, millisecondsPerSecond } from './units.js';
+export function now() {
+    return new Date();
+}
+export function currentTimestamp() {
+    return Date.now();
+}
+export function currentTimestampSeconds() {
+    return timestampToTimestampSeconds(currentTimestamp());
+}
+export function timestampToTimestampSeconds(timestamp) {
+    return Math.floor(timestamp / 1000);
+}
+export function currentDate() {
+    const timestamp = currentTimestamp();
+    return timestampToNumericDate(timestamp);
+}
+export function currentTime() {
+    const timestamp = currentTimestamp();
+    return timestampToTime(timestamp);
+}
+/**
+ * @param input {@link DateTime}, Date or timestamp in milliseconds
+ * @returns DateTime
+ */
+export function toDateTime(input) {
+    if (isNumber(input)) {
+        return DateTime.fromMillis(input);
+    }
+    if (isDate(input)) {
+        return DateTime.fromJSDate(input);
+    }
+    if (DateTime.isDateTime(input)) {
+        return input;
+    }
+    throw new NotSupportedError(`Unsupported input type "${typeOf(input)}".`);
+}
+export function timestampToNumericDate(timestamp) {
+    return Math.floor(timestamp / millisecondsPerDay);
+}
+export function dateToNumericDate(date) {
+    const timestamp = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());
+    return timestampToNumericDate(timestamp);
+}
+export function timestampToTime(timestamp) {
+    return timestamp % millisecondsPerDay;
+}
+export function timeObjectToNumericTime(time) {
+    return ((time.hour ?? 0) * millisecondsPerHour)
+        + ((time.minute ?? 0) * millisecondsPerMinute)
+        + ((time.second ?? 0) * millisecondsPerSecond)
+        + (time.millisecond ?? 0);
+}
+export function numericTimeToTimeObject(time) {
+    return {
+        hour: Math.floor(time / millisecondsPerHour),
+        minute: Math.floor((time % millisecondsPerHour) / millisecondsPerMinute),
+        second: Math.floor((time % millisecondsPerMinute) / millisecondsPerSecond),
+        millisecond: Math.floor(time % millisecondsPerSecond)
+    };
+}
+export function timestampToNumericDateAndTime(timestamp) {
+    return {
+        date: timestampToNumericDate(timestamp),
+        time: timestampToTime(timestamp)
+    };
+}
+export function numericDateToTimestamp(numericDate) {
+    return numericDate * millisecondsPerDay;
+}
+export function numericDateToDate(numericDate) {
+    const timestamp = numericDateToTimestamp(numericDate);
+    const date = new Date(timestamp);
+    return {
+        year: date.getUTCFullYear(),
+        month: date.getUTCMonth() + 1,
+        day: date.getUTCDate()
+    };
+}
+export function numericDateTimeToTimestamp({ date, time }) {
+    return numericDateToTimestamp(date) + time;
+}
+export function zonedDateObjectToDateTime(zonedDate, units, options) {
+    return DateTime.fromObject({ ...zonedDate, ...units }, options);
+}
+export function dateTimeToNumericDate(dateTime) {
+    const timestamp = dateTime.toUTC(undefined, { keepLocalTime: true }).toMillis();
+    return timestampToNumericDate(timestamp);
+}
+export function numericDateToDateTime(numericDate, units, options) {
+    const date = numericDateToDate(numericDate);
+    return DateTime.fromObject({ ...date, ...units }, options);
+}
+export function dateTimeToTime(dateTime) {
+    return dateTime.startOf('day').until(dateTime).count('milliseconds');
+}
+export function numericDateTimeToDateTime({ date, time }, zone) {
+    return numericDateToDateTime(date, undefined, { zone }).set({ millisecond: time });
 }