@duplojs/utils 1.1.15 → 1.2.16

package/dist/date/getters/getYear.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+require('../types/timezone.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../common/override.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var toNative = require('../toNative.cjs');
+require('../toTimestamp.cjs');
+require('../createOrThrow.cjs');
+
+function getYear(input, timezone = "UTC") {
+    const nativeDate = toNative.toNative(input);
+    if (timezone === "UTC") {
+        return nativeDate.getUTCFullYear();
+    }
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+    });
+    return Number(formatter.format(nativeDate));
+}
+
+exports.getYear = getYear;

package/dist/date/getters/getYear.d.ts

@@ -0,0 +1,2 @@
+import { type TheDate, type Timezone } from "..";
+export declare function getYear<GenericInput extends TheDate>(input: GenericInput, timezone?: Timezone): number;

package/dist/date/getters/getYear.mjs

@@ -0,0 +1,45 @@
+import '../types/timezone.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../common/override.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { toNative } from '../toNative.mjs';
+import '../toTimestamp.mjs';
+import '../createOrThrow.mjs';
+
+function getYear(input, timezone = "UTC") {
+    const nativeDate = toNative(input);
+    if (timezone === "UTC") {
+        return nativeDate.getUTCFullYear();
+    }
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+    });
+    return Number(formatter.format(nativeDate));
+}
+
+export { getYear };

package/dist/date/getters/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./getDayOfMonth";
+export * from "./getDayOfWeek";
+export * from "./getFirstDayOfWeek";
+export * from "./getLastDayOfWeek";
+export * from "./getFirstDayOfMonth";
+export * from "./getLastDayOfMonth";
+export * from "./getHour";
+export * from "./getMilliseconds";
+export * from "./getMinute";
+export * from "./getMonth";
+export * from "./getSecond";
+export * from "./getYear";
+export * from "./getMilliseconds";
+export * from "./getDayOfYear";
+export * from "./getWeekOfYear";

package/dist/date/index.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+var timezone = require('./types/timezone.cjs');
+var constants = require('./constants.cjs');
+var create = require('./create.cjs');
+var now = require('./now.cjs');
+var today = require('./today.cjs');
+var yesterday = require('./yesterday.cjs');
+var tomorrow = require('./tomorrow.cjs');
+var toNative = require('./toNative.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+var getDayOfMonth = require('./getters/getDayOfMonth.cjs');
+var getDayOfWeek = require('./getters/getDayOfWeek.cjs');
+var getFirstDayOfWeek = require('./getters/getFirstDayOfWeek.cjs');
+var getLastDayOfWeek = require('./getters/getLastDayOfWeek.cjs');
+var getFirstDayOfMonth = require('./getters/getFirstDayOfMonth.cjs');
+var getLastDayOfMonth = require('./getters/getLastDayOfMonth.cjs');
+var getHour = require('./getters/getHour.cjs');
+var getMilliseconds = require('./getters/getMilliseconds.cjs');
+var getMinute = require('./getters/getMinute.cjs');
+var getMonth = require('./getters/getMonth.cjs');
+var getSecond = require('./getters/getSecond.cjs');
+var getYear = require('./getters/getYear.cjs');
+var getDayOfYear = require('./getters/getDayOfYear.cjs');
+var getWeekOfYear = require('./getters/getWeekOfYear.cjs');
+var toISOString = require('./toISOString.cjs');
+var addDays = require('./operators/addDays.cjs');
+var addHours = require('./operators/addHours.cjs');
+var addMilliseconds = require('./operators/addMilliseconds.cjs');
+var addMinutes = require('./operators/addMinutes.cjs');
+var addMonths = require('./operators/addMonths.cjs');
+var addSeconds = require('./operators/addSeconds.cjs');
+var addWeeks = require('./operators/addWeeks.cjs');
+var addYears = require('./operators/addYears.cjs');
+var subtractDays = require('./operators/subtractDays.cjs');
+var subtractHours = require('./operators/subtractHours.cjs');
+var subtractMilliseconds = require('./operators/subtractMilliseconds.cjs');
+var subtractMinutes = require('./operators/subtractMinutes.cjs');
+var subtractMonths = require('./operators/subtractMonths.cjs');
+var subtractSeconds = require('./operators/subtractSeconds.cjs');
+var subtractWeeks = require('./operators/subtractWeeks.cjs');
+var subtractYears = require('./operators/subtractYears.cjs');
+var between = require('./operators/between.cjs');
+var betweenThan = require('./operators/betweenThan.cjs');
+var greater = require('./operators/greater.cjs');
+var greaterThan = require('./operators/greaterThan.cjs');
+var less = require('./operators/less.cjs');
+var lessThan = require('./operators/lessThan.cjs');
+var closestTo = require('./closestTo.cjs');
+var each = require('./each.cjs');
+var createOrThrow = require('./createOrThrow.cjs');
+var round = require('./round.cjs');
+var isSafeTimestamp = require('./isSafeTimestamp.cjs');
+
+
+
+exports.timezone = timezone.timezone;
+exports.daysInOneWeek = constants.daysInOneWeek;
+exports.hoursInOneDay = constants.hoursInOneDay;
+exports.maxTimestamp = constants.maxTimestamp;
+exports.millisecondInOneHour = constants.millisecondInOneHour;
+exports.millisecondInOneMinute = constants.millisecondInOneMinute;
+exports.millisecondInOneWeek = constants.millisecondInOneWeek;
+exports.millisecondsInOneDay = constants.millisecondsInOneDay;
+exports.millisecondsInOneSecond = constants.millisecondsInOneSecond;
+exports.minTimestamp = constants.minTimestamp;
+exports.minutesInOneHour = constants.minutesInOneHour;
+exports.monthtsInOneYear = constants.monthtsInOneYear;
+exports.secondsInOneMinute = constants.secondsInOneMinute;
+exports.theDateRegex = constants.theDateRegex;
+exports.create = create.create;
+exports.now = now.now;
+exports.today = today.today;
+exports.yesterday = yesterday.yesterday;
+exports.tomorrow = tomorrow.tomorrow;
+exports.toNative = toNative.toNative;
+exports.InvalidTheDateError = toTimestamp.InvalidTheDateError;
+exports.toTimestamp = toTimestamp.toTimestamp;
+exports.getDayOfMonth = getDayOfMonth.getDayOfMonth;
+exports.getDayOfWeek = getDayOfWeek.getDayOfWeek;
+exports.getFirstDayOfWeek = getFirstDayOfWeek.getFirstDayOfWeek;
+exports.getLastDayOfWeek = getLastDayOfWeek.getLastDayOfWeek;
+exports.getFirstDayOfMonth = getFirstDayOfMonth.getFirstDayOfMonth;
+exports.getLastDayOfMonth = getLastDayOfMonth.getLastDayOfMonth;
+exports.getHour = getHour.getHour;
+exports.getMilliseconds = getMilliseconds.getMilliseconds;
+exports.getMinute = getMinute.getMinute;
+exports.getMonth = getMonth.getMonth;
+exports.getSecond = getSecond.getSecond;
+exports.getYear = getYear.getYear;
+exports.getDayOfYear = getDayOfYear.getDayOfYear;
+exports.getWeekOfYear = getWeekOfYear.getWeekOfYear;
+exports.toISOString = toISOString.toISOString;
+exports.addDays = addDays.addDays;
+exports.addHours = addHours.addHours;
+exports.addMilliseconds = addMilliseconds.addMilliseconds;
+exports.addMinutes = addMinutes.addMinutes;
+exports.addMonths = addMonths.addMonths;
+exports.addSeconds = addSeconds.addSeconds;
+exports.addWeeks = addWeeks.addWeeks;
+exports.addYears = addYears.addYears;
+exports.subtractDays = subtractDays.subtractDays;
+exports.subtractHours = subtractHours.subtractHours;
+exports.subtractMilliseconds = subtractMilliseconds.subtractMilliseconds;
+exports.subtractMinutes = subtractMinutes.subtractMinutes;
+exports.subtractMonths = subtractMonths.subtractMonths;
+exports.subtractSeconds = subtractSeconds.subtractSeconds;
+exports.subtractWeeks = subtractWeeks.subtractWeeks;
+exports.subtractYears = subtractYears.subtractYears;
+exports.between = between.between;
+exports.betweenThan = betweenThan.betweenThan;
+exports.greater = greater.greater;
+exports.greaterThan = greaterThan.greaterThan;
+exports.less = less.less;
+exports.lessThan = lessThan.lessThan;
+exports.closestTo = closestTo.closestTo;
+exports.each = each.each;
+exports.CreateTheDateError = createOrThrow.CreateTheDateError;
+exports.createOrThrow = createOrThrow.createOrThrow;
+exports.round = round.round;
+exports.isSafeTimestamp = isSafeTimestamp.isSafeTimestamp;

package/dist/date/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./types";
+export * from "./constants";
+export * from "./create";
+export * from "./now";
+export * from "./today";
+export * from "./yesterday";
+export * from "./tomorrow";
+export * from "./toNative";
+export * from "./toTimestamp";
+export * from "./getters";
+export * from "./toISOString";
+export * from "./operators";
+export * from "./closestTo";
+export * from "./each";
+export * from "./each";
+export * from "./createOrThrow";
+export * from "./round";
+export * from "./isSafeTimestamp";

package/dist/date/index.mjs

@@ -0,0 +1,51 @@
+export { timezone } from './types/timezone.mjs';
+export { daysInOneWeek, hoursInOneDay, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimestamp, minutesInOneHour, monthtsInOneYear, secondsInOneMinute, theDateRegex } from './constants.mjs';
+export { create } from './create.mjs';
+export { now } from './now.mjs';
+export { today } from './today.mjs';
+export { yesterday } from './yesterday.mjs';
+export { tomorrow } from './tomorrow.mjs';
+export { toNative } from './toNative.mjs';
+export { InvalidTheDateError, toTimestamp } from './toTimestamp.mjs';
+export { getDayOfMonth } from './getters/getDayOfMonth.mjs';
+export { getDayOfWeek } from './getters/getDayOfWeek.mjs';
+export { getFirstDayOfWeek } from './getters/getFirstDayOfWeek.mjs';
+export { getLastDayOfWeek } from './getters/getLastDayOfWeek.mjs';
+export { getFirstDayOfMonth } from './getters/getFirstDayOfMonth.mjs';
+export { getLastDayOfMonth } from './getters/getLastDayOfMonth.mjs';
+export { getHour } from './getters/getHour.mjs';
+export { getMilliseconds } from './getters/getMilliseconds.mjs';
+export { getMinute } from './getters/getMinute.mjs';
+export { getMonth } from './getters/getMonth.mjs';
+export { getSecond } from './getters/getSecond.mjs';
+export { getYear } from './getters/getYear.mjs';
+export { getDayOfYear } from './getters/getDayOfYear.mjs';
+export { getWeekOfYear } from './getters/getWeekOfYear.mjs';
+export { toISOString } from './toISOString.mjs';
+export { addDays } from './operators/addDays.mjs';
+export { addHours } from './operators/addHours.mjs';
+export { addMilliseconds } from './operators/addMilliseconds.mjs';
+export { addMinutes } from './operators/addMinutes.mjs';
+export { addMonths } from './operators/addMonths.mjs';
+export { addSeconds } from './operators/addSeconds.mjs';
+export { addWeeks } from './operators/addWeeks.mjs';
+export { addYears } from './operators/addYears.mjs';
+export { subtractDays } from './operators/subtractDays.mjs';
+export { subtractHours } from './operators/subtractHours.mjs';
+export { subtractMilliseconds } from './operators/subtractMilliseconds.mjs';
+export { subtractMinutes } from './operators/subtractMinutes.mjs';
+export { subtractMonths } from './operators/subtractMonths.mjs';
+export { subtractSeconds } from './operators/subtractSeconds.mjs';
+export { subtractWeeks } from './operators/subtractWeeks.mjs';
+export { subtractYears } from './operators/subtractYears.mjs';
+export { between } from './operators/between.mjs';
+export { betweenThan } from './operators/betweenThan.mjs';
+export { greater } from './operators/greater.mjs';
+export { greaterThan } from './operators/greaterThan.mjs';
+export { less } from './operators/less.mjs';
+export { lessThan } from './operators/lessThan.mjs';
+export { closestTo } from './closestTo.mjs';
+export { each } from './each.mjs';
+export { CreateTheDateError, createOrThrow } from './createOrThrow.mjs';
+export { round } from './round.mjs';
+export { isSafeTimestamp } from './isSafeTimestamp.mjs';

package/dist/date/isSafeTimestamp.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+
+function isSafeTimestamp(input) {
+    if (!Number.isSafeInteger(input)) {
+        return false;
+    }
+    if (input <= constants.minTimestamp || input >= constants.maxTimestamp) {
+        return false;
+    }
+    return true;
+}
+
+exports.isSafeTimestamp = isSafeTimestamp;

package/dist/date/isSafeTimestamp.d.ts

@@ -0,0 +1 @@
+export declare function isSafeTimestamp(input: number): boolean;

package/dist/date/isSafeTimestamp.mjs

@@ -0,0 +1,13 @@
+import { minTimestamp, maxTimestamp } from './constants.mjs';
+
+function isSafeTimestamp(input) {
+    if (!Number.isSafeInteger(input)) {
+        return false;
+    }
+    if (input <= minTimestamp || input >= maxTimestamp) {
+        return false;
+    }
+    return true;
+}
+
+export { isSafeTimestamp };

package/dist/date/now.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+function now() {
+    const timestamp = Date.now();
+    return `date${timestamp}+`;
+}
+
+exports.now = now;

package/dist/date/now.d.ts

@@ -0,0 +1 @@
+export declare function now(): `date${number}+`;

package/dist/date/now.mjs

@@ -0,0 +1,6 @@
+function now() {
+    const timestamp = Date.now();
+    return `date${timestamp}+`;
+}
+
+export { now };

package/dist/date/operators/addDays.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var toNative = require('../toNative.cjs');
+var constants = require('../constants.cjs');
+
+function addDays(...args) {
+    if (args.length === 1) {
+        const [day] = args;
+        return (input) => addDays(input, day);
+    }
+    const [input, day] = args;
+    const absoluteDay = Math.abs(day);
+    const date = toNative.toNative(input);
+    date.setTime(date.getTime() + (absoluteDay * constants.millisecondsInOneDay));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addDays = addDays;

package/dist/date/operators/addDays.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addDays<GenericInput extends TheDate, GenericDay extends number>(day: PositiveNumber<GenericDay>): (input: GenericInput) => TheDate;
+export declare function addDays<GenericInput extends TheDate, GenericDay extends number>(input: GenericInput, day: PositiveNumber<GenericDay>): TheDate;

package/dist/date/operators/addDays.mjs

@@ -0,0 +1,18 @@
+import { toNative } from '../toNative.mjs';
+import { millisecondsInOneDay } from '../constants.mjs';
+
+function addDays(...args) {
+    if (args.length === 1) {
+        const [day] = args;
+        return (input) => addDays(input, day);
+    }
+    const [input, day] = args;
+    const absoluteDay = Math.abs(day);
+    const date = toNative(input);
+    date.setTime(date.getTime() + (absoluteDay * millisecondsInOneDay));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addDays };

package/dist/date/operators/addHours.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var constants = require('../constants.cjs');
+var toNative = require('../toNative.cjs');
+
+function addHours(...args) {
+    if (args.length === 1) {
+        const [hour] = args;
+        return (input) => addHours(input, hour);
+    }
+    const [input, hour] = args;
+    const absoluteHour = Math.abs(hour);
+    const date = toNative.toNative(input);
+    date.setTime(date.getTime() + (absoluteHour * constants.millisecondInOneHour));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addHours = addHours;

package/dist/date/operators/addHours.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addHours<GenericInput extends TheDate, GenericHour extends number>(hour: PositiveNumber<GenericHour>): (input: GenericInput) => TheDate;
+export declare function addHours<GenericInput extends TheDate, GenericHour extends number>(input: GenericInput, hour: PositiveNumber<GenericHour>): TheDate;

package/dist/date/operators/addHours.mjs

@@ -0,0 +1,18 @@
+import { millisecondInOneHour } from '../constants.mjs';
+import { toNative } from '../toNative.mjs';
+
+function addHours(...args) {
+    if (args.length === 1) {
+        const [hour] = args;
+        return (input) => addHours(input, hour);
+    }
+    const [input, hour] = args;
+    const absoluteHour = Math.abs(hour);
+    const date = toNative(input);
+    date.setTime(date.getTime() + (absoluteHour * millisecondInOneHour));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addHours };

package/dist/date/operators/addMilliseconds.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var toNative = require('../toNative.cjs');
+
+function addMilliseconds(...args) {
+    if (args.length === 1) {
+        const [millisecond] = args;
+        return (input) => addMilliseconds(input, millisecond);
+    }
+    const [input, millisecond] = args;
+    const absoluteMilliseconds = Math.abs(millisecond);
+    const date = toNative.toNative(input);
+    date.setTime(date.getTime() + absoluteMilliseconds);
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addMilliseconds = addMilliseconds;

package/dist/date/operators/addMilliseconds.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addMilliseconds<GenericInput extends TheDate, GenericMillisecond extends number>(millisecond: PositiveNumber<GenericMillisecond>): (input: GenericInput) => TheDate;
+export declare function addMilliseconds<GenericInput extends TheDate, GenericMillisecond extends number>(input: GenericInput, millisecond: PositiveNumber<GenericMillisecond>): TheDate;

package/dist/date/operators/addMilliseconds.mjs

@@ -0,0 +1,17 @@
+import { toNative } from '../toNative.mjs';
+
+function addMilliseconds(...args) {
+    if (args.length === 1) {
+        const [millisecond] = args;
+        return (input) => addMilliseconds(input, millisecond);
+    }
+    const [input, millisecond] = args;
+    const absoluteMilliseconds = Math.abs(millisecond);
+    const date = toNative(input);
+    date.setTime(date.getTime() + absoluteMilliseconds);
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addMilliseconds };

package/dist/date/operators/addMinutes.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var constants = require('../constants.cjs');
+var toNative = require('../toNative.cjs');
+
+function addMinutes(...args) {
+    if (args.length === 1) {
+        const [minute] = args;
+        return (input) => addMinutes(input, minute);
+    }
+    const [input, minute] = args;
+    const absoluteMinute = Math.abs(minute);
+    const date = toNative.toNative(input);
+    date.setTime(date.getTime() + (absoluteMinute * constants.millisecondInOneMinute));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addMinutes = addMinutes;

package/dist/date/operators/addMinutes.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addMinutes<GenericInput extends TheDate, GenericMinute extends number>(minute: PositiveNumber<GenericMinute>): (input: GenericInput) => TheDate;
+export declare function addMinutes<GenericInput extends TheDate, GenericMinute extends number>(input: GenericInput, minute: PositiveNumber<GenericMinute>): TheDate;

package/dist/date/operators/addMinutes.mjs

@@ -0,0 +1,18 @@
+import { millisecondInOneMinute } from '../constants.mjs';
+import { toNative } from '../toNative.mjs';
+
+function addMinutes(...args) {
+    if (args.length === 1) {
+        const [minute] = args;
+        return (input) => addMinutes(input, minute);
+    }
+    const [input, minute] = args;
+    const absoluteMinute = Math.abs(minute);
+    const date = toNative(input);
+    date.setTime(date.getTime() + (absoluteMinute * millisecondInOneMinute));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addMinutes };

package/dist/date/operators/addMonths.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var toNative = require('../toNative.cjs');
+
+function addMonths(...args) {
+    if (args.length === 1) {
+        const [month] = args;
+        return (input) => addMonths(input, month);
+    }
+    const [input, month] = args;
+    const absoluteMonth = Math.abs(month);
+    const date = toNative.toNative(input);
+    date.setUTCMonth(date.getUTCMonth() + absoluteMonth);
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addMonths = addMonths;

package/dist/date/operators/addMonths.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addMonths<GenericInput extends TheDate, GenericMonth extends number>(month: PositiveNumber<GenericMonth>): (input: GenericInput) => TheDate;
+export declare function addMonths<GenericInput extends TheDate, GenericMonth extends number>(input: GenericInput, month: PositiveNumber<GenericMonth>): TheDate;

package/dist/date/operators/addMonths.mjs

@@ -0,0 +1,17 @@
+import { toNative } from '../toNative.mjs';
+
+function addMonths(...args) {
+    if (args.length === 1) {
+        const [month] = args;
+        return (input) => addMonths(input, month);
+    }
+    const [input, month] = args;
+    const absoluteMonth = Math.abs(month);
+    const date = toNative(input);
+    date.setUTCMonth(date.getUTCMonth() + absoluteMonth);
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addMonths };

package/dist/date/operators/addSeconds.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var constants = require('../constants.cjs');
+var toNative = require('../toNative.cjs');
+
+function addSeconds(...args) {
+    if (args.length === 1) {
+        const [second] = args;
+        return (input) => addSeconds(input, second);
+    }
+    const [input, second] = args;
+    const absoluteSecond = Math.abs(second);
+    const date = toNative.toNative(input);
+    date.setTime(date.getTime() + (absoluteSecond * constants.millisecondsInOneSecond));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+exports.addSeconds = addSeconds;

package/dist/date/operators/addSeconds.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "../types";
+import type { PositiveNumber } from "../../number/types";
+export declare function addSeconds<GenericInput extends TheDate, GenericSecond extends number>(second: PositiveNumber<GenericSecond>): (input: GenericInput) => TheDate;
+export declare function addSeconds<GenericInput extends TheDate, GenericSecond extends number>(input: GenericInput, second: PositiveNumber<GenericSecond>): TheDate;

package/dist/date/operators/addSeconds.mjs

@@ -0,0 +1,18 @@
+import { millisecondsInOneSecond } from '../constants.mjs';
+import { toNative } from '../toNative.mjs';
+
+function addSeconds(...args) {
+    if (args.length === 1) {
+        const [second] = args;
+        return (input) => addSeconds(input, second);
+    }
+    const [input, second] = args;
+    const absoluteSecond = Math.abs(second);
+    const date = toNative(input);
+    date.setTime(date.getTime() + (absoluteSecond * millisecondsInOneSecond));
+    const timestamp = date.getTime();
+    const isNegative = timestamp < 0;
+    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+}
+
+export { addSeconds };