@tstdl/base 0.86.0-beta1 → 0.86.0-beta11

package/utils/crc32.js

@@ -1,25 +1,47 @@
-/* eslint-disable no-bitwise */
+"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 crc32_exports = {};
+__export(crc32_exports, {
+  crc32b: () => crc32b
+});
+module.exports = __toCommonJS(crc32_exports);
 let crcTable;
-export function crc32b(bytes) {
-    crcTable ??= generateCrc32Table();
-    let crc = 0 ^ (-1);
-    for (let i = 0; i < bytes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
-        crc = (crc >>> 8) ^ crcTable[(crc & 0xff) ^ bytes[i]];
-    }
-    crc = (crc ^ (-1)) >>> 0;
-    const buffer = new ArrayBuffer(4);
-    const dataView = new DataView(buffer);
-    dataView.setUint32(0, crc, false);
-    return new Uint8Array(buffer);
+function crc32b(bytes) {
+  crcTable ??= generateCrc32Table();
+  let crc = 0 ^ -1;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = crc >>> 8 ^ crcTable[crc & 255 ^ bytes[i]];
+  }
+  crc = (crc ^ -1) >>> 0;
+  const buffer = new ArrayBuffer(4);
+  const dataView = new DataView(buffer);
+  dataView.setUint32(0, crc, false);
+  return new Uint8Array(buffer);
 }
 function generateCrc32Table() {
-    const table = new Uint32Array(256);
-    for (let i = 0; i < 256; i++) {
-        let c = i;
-        for (let k = 0; k < 8; k++) {
-            c = ((c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1));
-        }
-        table[i] = c;
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
     }
-    return table;
+    table[i] = c;
+  }
+  return table;
 }

package/utils/cryptography.js

@@ -1,179 +1,137 @@
-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';
+"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");
 const subtle = globalThis.crypto.subtle;
-/**
- * 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 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)
+  };
 }
-/**
- * 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 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)
+  };
 }
-/**
- * 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 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;
 }
-/**
- * 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;
+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;
 }
-/**
- * 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 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);
 }
-/**
- * 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 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 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 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 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 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"]);
 }
-/**
- * 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 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"]);
 }
-/**
- * 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 generateEcdsaKey(curve, extractable = false, usages = ["sign", "verify"]) {
+  return subtle.generateKey({ name: "ECDSA", namedCurve: curve }, extractable, usages);
 }
-/**
- * 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 generatePbkdf2Key(extractable = false) {
+  const key = (0, import_random.getRandomBytes)(16);
+  return importPbkdf2Key(key, extractable);
 }
-/**
- * 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 deriveBytes(algorithm, baseKey, length) {
+  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, length * 8);
+  return new Uint8Array(bytes);
 }
-/**
- * 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)));
+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)));
 }
 function isBinaryKey(key) {
-    return isDefined(key.byteLength);
+  return (0, import_type_guards.isDefined)(key.byteLength);
 }

package/utils/date-time.js

@@ -1,103 +1,139 @@
-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 });
+"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 });
 }