datetime-lube 1.0.0

package/src/start_of.js

@@ -0,0 +1,113 @@
+import { days_of, wall_of_fields } from "./calendar.js"
+import time_of from "./time_of.js"
+import {
+	check_zone,
+	fields_of,
+	instant_of,
+	offset_in,
+	offset_of,
+	transition_of,
+	unit_start
+} from "./zone.js"
+/** @type {Record<string, number | undefined>} */
+const unit_ms = { H: 3600000, m: 60000, s: 1000 }
+/** @type {Record<string, number>} */
+const units = { D: 3, M: 2, W: 3, Y: 1 }
+const units_of = new Set(
+	[ "D", "H", "M", "W", "Y", "m", "s" ]
+)
+/**
+ * Returns a new Date at the start of the given unit, such as midnight of the same day.
+ * A week starts on Monday, as in ISO 8601.
+ * @param {Date} date
+ * @param {Exclude<import("../public.js").Unit, "sss">} unit
+ * ```
+ * "Y" | "M" | "W" | "D" | "H" | "m" | "s"
+ * ```
+ * @param {import("../public.js").TimeZone=} zone
+ * @returns {Date}
+ * @throws
+ * ```
+ * RangeError(`startOf: Invalid unit "${unit}"`) // The unit is not one of the listed ones
+ * RangeError(`startOf: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`startOf: Expected a Date, got ${typeof date}`)
+ * ```
+ * @example startOf(new Date, "D", "Asia/Seoul") //=> Date { midnight in Seoul }
+ */
+export default function(date, unit, zone) {
+	const time = time_of("startOf", date)
+	if (!units_of.has(unit)) throw new RangeError(
+		`startOf: Invalid unit "${String(unit)}"`
+	)
+	check_zone("startOf", zone)
+	if (isNaN(time)) return new Date(NaN)
+	const ms = unit_ms[unit]
+	if (ms) {
+		if (zone !== undefined) {
+			const offset = offset_of(time, zone)
+			const rest = ((time + offset) % ms + ms) % ms
+			return new Date(
+				offset_of(time - rest, zone) == offset
+					? time - rest
+					: unit_start(time, ms, zone)
+			)
+		}
+		const rest = ms > 60000
+			? date.getMinutes() * 60000 + date.getSeconds() * 1000 + date.getMilliseconds()
+			: ms > 1000
+				? date.getSeconds() * 1000 + date.getMilliseconds()
+				: date.getMilliseconds()
+		const result = new Date(time - rest)
+		if (
+			result.getTimezoneOffset() == date.getTimezoneOffset()
+			&& result.getSeconds() == (ms > 1000 ? 0 : date.getSeconds())
+		) return result
+		result.setTime(unit_start(time, ms))
+		return result
+	}
+	const from = /** @type {number} */(units[unit])/**/
+	if (zone === undefined) {
+		const result = new Date(time)
+		result.setHours(
+			unit == "D"
+				? 0
+				: unit == "W"
+					? -24 * ((result.getDay() + 6) % 7)
+					: unit == "M"
+						? 24 - 24 * result.getDate()
+						: -24 * (days_of(
+							result.getFullYear(),
+							result.getMonth(),
+							result.getDate()
+						) - days_of(result.getFullYear(), 0, 1)),
+			0,
+			0,
+			0
+		)
+		if (result.getTime() <= time && !(result.getHours() || result.getMinutes() || result.getSeconds())) return result
+	}
+	const fields = fields_of(date, zone)
+	if (unit == "W") fields[2] = /** @type {number} */(fields[2])/**/ - (/** @type {number} */(fields[7])/**/ + 6) % 7
+	for (let i = from; i < 7; i++) fields[i] = i == 2 ? 1 : 0
+	const wall = wall_of_fields(fields)
+	if (zone !== undefined) {
+		const start = instant_of(wall, zone, true)
+		if (start <= time) return new Date(start)
+	}
+	const before = offset_in(wall - 86400000, zone)
+	const guess = wall - before
+	const after = offset_in(guess, zone)
+	const earliest = after == before
+		? wall - offset_in(time, zone)
+		: wall - after
+	if (!(earliest >= -8.64e15)) return new Date(NaN)
+	return new Date(
+		transition_of(
+			earliest,
+			after == before || guess > time
+				? time
+				: guess,
+			zone
+		)
+	)
+}

package/src/string_to_date.js

@@ -0,0 +1,178 @@
+import { fields_of_wall, last_day } from "./calendar.js"
+import { check_zone, date_of, fields_of } from "./zone.js"
+const comment_regex = /\([^)]*\)?/g
+/** @type {Map<string, (number | number[])[]>} */
+const formats = new Map()
+const iso_regex = /^([+-]\d{6}|\d{4})(?:-(\d{2})(?:-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?)?)?([^]*)$/
+const token_regex = /DD|HH|MM|YYYY|mm|sss?/g
+/** @type {Record<string, number[]>} */
+const tokens = {
+	DD: [ 2, 2, 1, 31 ],
+	HH: [ 3, 2, 0, 23 ],
+	MM: [ 1, 2, 1, 12 ],
+	YYYY: [ 0, 4, 0, 275760 ],
+	mm: [ 4, 2, 0, 59 ],
+	ss: [ 5, 2, 0, 59 ],
+	sss: [ 6, 3, 0, 999 ]
+}
+const zone_regex = /(?<![a-z])(?:[cemp][ds]t|gmt|utc?|z)(?![a-z])|(?:\s|[ap]m|\d:\d\d?(?::\d\d?(?:\.\d*)?)?)[+-]\d/i
+/**
+ * @param {string} format
+ * @returns {(number | number[])[]}
+ */
+function compile(format) {
+	let parts = formats.get(format)
+	if (parts) return parts
+	parts = []
+	let last = 0
+	for (const { 0: token, index = 0 } of format.matchAll(token_regex)) {
+		if (index > last) parts.push(
+			[ ...format.slice(last, index) ].length
+		)
+		parts.push(
+			/** @type {number[]} */(tokens[token])/**/
+		)
+		last = index + token.length
+	}
+	if (last < format.length) parts.push(
+		[ ...format.slice(last) ].length
+	)
+	if (formats.size >= 1000) formats.clear()
+	formats.set(format, parts)
+	return parts
+}
+/**
+ * @param {RegExpExecArray} match
+ * @returns {boolean}
+ */
+function out_of_range(match) {
+	const [ , year, month, day, hour, minute, second ] = match
+	if (month === undefined) return false
+	const index = +month - 1
+	return index < 0 || index > 11 || day !== undefined && (+day < 1 || +day > last_day(+(year ?? 0), index)) || +(hour ?? 0) > (+(minute ?? 0) || +(second ?? 0) || +(match[7] ?? 0)
+		? 23
+		: 24) || +(minute ?? 0) > 59 || +(second ?? 0) > 59
+}
+/**
+ * Converts a date string to a Date object based on the provided format.
+ * Without a format the platform parser reads the string, so an offset such as `"Z"` is applied,
+ * while a date without a time is read as midnight. Out-of-range values give an invalid Date only in an
+ * ECMAScript date string: V8 rolls `"2025/02/30"` over to March 2, so check user input with a format.
+ * With a format, letters that are not a time unit only reserve their place, and a unit reads up to its own length of digits (`"sss"` reads them as a fraction, so `".5"` is 500 ms).
+ * `"YYYY"` also reads an expanded year such as `"+012345"`, and text left after the format gives an invalid Date.
+ * Missing units default to 0000-01-01T00:00:00.000, where a time zone is at its local mean time, so
+ * read a time alone in `"UTC"`. An invalid value returns an invalid Date.
+ * A wall clock inside a daylight saving gap moves forward, and one that occurs twice takes the
+ * first occurrence, as `new Date(year, month, day, hour)` does.
+ * @param {string} date
+ * @param {string=} format
+ * ```js
+ * e.g. "YYYY-MM-DDTHH:mm:ss.sss"
+ * ```
+ *
+ * Supported time units:
+ * - "YYYY": Years
+ * - "MM": Months
+ * - "DD": Days
+ * - "HH": Hours
+ * - "mm": Minutes
+ * - "ss": Seconds
+ * - "sss": Milliseconds
+ * @param {import("../public.js").TimeZone=} zone
+ * @returns {Date}
+ * @throws
+ * ```
+ * RangeError(`stringToDate: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`stringToDate: Expected a string, got ${typeof date}`)
+ * ```
+ * @example stringToDate("2024-07-15 09:00", "YYYY-MM-DD HH:mm", "Asia/Seoul")
+ */
+export default function(date, format, zone) {
+	if (typeof date != "string") throw new TypeError(
+		`stringToDate: Expected a string, got ${date === null ? "null" : typeof date}`
+	)
+	check_zone("stringToDate", zone)
+	if (format === undefined) {
+		const native = new Date(date)
+		const valid = !isNaN(native.getTime())
+		if (!valid && zone === undefined) return native
+		const match = iso_regex.exec(date)
+		if (match && out_of_range(match)) return new Date(NaN)
+		const parsed = match?.[8] === ""
+			? match
+			: null
+		if (parsed) {
+			if (zone === undefined && parsed[4] !== undefined) return native
+			if (!valid && isNaN(Date.parse(`${date}Z`))) return native
+			const fraction = parsed[7]
+			return date_of(
+				[
+					+(parsed[1] ?? NaN),
+					+(parsed[2] ?? 1) - 1,
+					+(parsed[3] ?? 1),
+					+(parsed[4] ?? 0),
+					+(parsed[5] ?? 0),
+					+(parsed[6] ?? 0),
+					fraction === undefined
+						? 0
+						: +fraction.slice(0, 3).padEnd(3, "0")
+				],
+				zone
+			)
+		}
+		if (zone === undefined) return native
+		const text = date.replace(comment_regex, "")
+		if (zone_regex.test(text)) return native
+		const wall = new Date(`${text} GMT`)
+		if (!valid && isNaN(wall.getTime())) return native
+		return date_of(
+			isNaN(wall.getTime())
+				? fields_of(native)
+				: fields_of_wall(wall.getTime()),
+			zone
+		)
+	}
+	const fields = [ 0, 0, 1, 0, 0, 0, 0 ]
+	let index = 0
+	for (const part of compile(format)) {
+		if (typeof part == "number") {
+			for (let i = 0; i < part; i++) {
+				const code = date.charCodeAt(index)
+				index += code >= 0xd800 && code < 0xdc00 && date.charCodeAt(index + 1) >= 0xdc00 && date.charCodeAt(index + 1) < 0xe000
+					? 2
+					: 1
+			}
+			continue
+		}
+		let text = ""
+		let length = /** @type {number} */(part[1])/**/
+		let min = /** @type {number} */(part[2])/**/
+		let sign = ""
+		const code = date.charCodeAt(index)
+		if (part[0] == 0 && (code == 43 || code == 45)) {
+			sign = code == 45
+				? "-"
+				: "+"
+			index++
+			length = 6
+			min = -271821
+		}
+		while (text.length < length && date.charCodeAt(index) > 47 && date.charCodeAt(index) < 58) text += date[index++]
+		if (!text || sign && (text.length < 6 || sign == "-" && !+text)) return new Date(NaN)
+		if (part[0] == 6) {
+			while (date.charCodeAt(index) > 47 && date.charCodeAt(index) < 58) index++
+		}
+		const value = part[0] == 6
+			? +text.padEnd(3, "0")
+			: +(sign + text)
+		if (value > /** @type {number} */(part[3])/**/ || value < min) return new Date(NaN)
+		fields[/** @type {number} */(part[0])/**/] = /** @type {number} */(part[0])/**/ == 1
+			? value - 1
+			: value
+	}
+	if (index != date.length || /** @type {number} */(fields[2])/**/ > last_day(
+		/** @type {number} */(fields[0])/**/,
+		/** @type {number} */(fields[1])/**/
+	)) return new Date(NaN)
+	return date_of(fields, zone)
+}

package/src/time_of.js

@@ -0,0 +1,15 @@
+const get_time = Date.prototype.getTime
+/**
+ * @param {string} name
+ * @param {Date} date
+ * @returns {number}
+ */
+export default function(name, date) {
+	try {
+		return get_time.call(date)
+	} catch {
+		throw new TypeError(
+			`${name}: Expected a Date, got ${date === null ? "null" : typeof date}`
+		)
+	}
+}

package/src/time_unit.js

@@ -0,0 +1,6 @@
+export default /** @type {const} */({
+	DD: 86400000,
+	HH: 3600000,
+	mm: 60000,
+	ss: 1000
+})/**/

package/src/time_zone_offset.js

@@ -0,0 +1,22 @@
+import time_of from "./time_of.js"
+import { check_zone, offset_of } from "./zone.js"
+/**
+ * Returns the offset of the time zone at the given date in milliseconds, east of UTC positive.
+ * Daylight saving time is taken from the given date, so a summer date gives the summer offset.
+ * @param {Date} date
+ * @param {import("../public.js").TimeZone} zone
+ * @returns {number}
+ * @throws
+ * ```
+ * RangeError(`timeZoneOffset: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`timeZoneOffset: Expected a Date, got ${typeof date}`)
+ * ```
+ * @example timeZoneOffset(new Date, "Asia/Seoul") //=> 32400000
+ */
+export default function(date, zone) {
+	const time = time_of("timeZoneOffset", date)
+	check_zone("timeZoneOffset", zone)
+	return isNaN(time)
+		? NaN
+		: offset_of(time, zone)
+}

package/src/zone.js

@@ -0,0 +1,235 @@
+import { fields_of_wall, wall_of_fields } from "./calendar.js"
+const offset_regex = /GMT([+-])([0-9][0-9]):([0-9][0-9])(?::([0-9][0-9]))?/
+/** @type {Map<string, Intl.DateTimeFormat>} */
+const canonical = new Map()
+/** @type {Map<string, Intl.DateTimeFormat>} */
+const formatters = new Map()
+/**
+ * @param {string} name
+ * @param {string=} zone
+ */
+function check_zone(name, zone) {
+	if (zone === undefined || formatters.has(zone)) return
+	try {
+		formatter_of(zone)
+	} catch (error) {
+		throw new RangeError(
+			`${name}: Invalid time zone "${String(zone)}"`,
+			{ cause: error }
+		)
+	}
+}
+/**
+ * @param {number[]} fields
+ * @param {string=} zone
+ * @returns {Date}
+ */
+function date_of(fields, zone) {
+	if (zone !== undefined) return new Date(
+		instant_of(wall_of_fields(fields), zone)
+	)
+	const year = /** @type {number} */(fields[0])/**/
+	if (year >= 0 && year < 100) {
+		const date = new Date(0)
+		date.setFullYear(year, fields[1], fields[2])
+		date.setHours(
+			/** @type {number} */(fields[3])/**/,
+			fields[4],
+			fields[5],
+			fields[6]
+		)
+		return date
+	}
+	return new Date(
+		year,
+		/** @type {number} */(fields[1])/**/,
+		fields[2],
+		fields[3],
+		fields[4],
+		fields[5],
+		fields[6]
+	)
+}
+/**
+ * @param {number} wall
+ * @param {number} end
+ * @param {number} time
+ * @param {string=} zone
+ * @returns {number}
+ */
+function end_at(wall, end, time, zone) {
+	if (end < time) return wall - offset_in(time, zone) - 1
+	const next = end + 1
+	const offset = offset_in(next, zone)
+	if (next + offset == wall || offset_in(end, zone) != offset) return end
+	const transition = transition_of(time, next, zone)
+	return transition + offset_in(transition, zone) >= wall
+		? transition - 1
+		: end
+}
+/**
+ * @param {Date} date
+ * @param {string=} zone
+ * @returns {number[]}
+ */
+function fields_of(date, zone) {
+	if (zone === undefined) return [
+		date.getFullYear(),
+		date.getMonth(),
+		date.getDate(),
+		date.getHours(),
+		date.getMinutes(),
+		date.getSeconds(),
+		date.getMilliseconds(),
+		date.getDay()
+	]
+	const time = date.getTime()
+	return fields_of_wall(time + offset_of(time, zone))
+}
+/**
+ * @param {string} zone
+ * @returns {Intl.DateTimeFormat}
+ */
+function formatter_of(zone) {
+	let formatter = formatters.get(zone)
+	if (formatter) return formatter
+	formatter = new Intl.DateTimeFormat(
+		"en-US",
+		{
+			timeZone: zone,
+			timeZoneName: "longOffset"
+		}
+	)
+	const name = formatter.resolvedOptions().timeZone
+	const known = canonical.get(name)
+	if (known) {
+		formatter = known
+	} else {
+		if (canonical.size >= 1000) canonical.clear()
+		canonical.set(name, formatter)
+	}
+	if (formatters.size >= 1000) formatters.clear()
+	formatters.set(zone, formatter)
+	return formatter
+}
+/**
+ * @param {number} wall
+ * @param {string} zone
+ * @param {boolean=} exact
+ * @returns {number}
+ */
+function instant_of(wall, zone, exact) {
+	const before = offset_of(wall - 86400000, zone)
+	const guess = wall - before
+	const offset = offset_of(guess, zone)
+	if (offset == before) return guess
+	const candidate = wall - offset
+	return offset_of(candidate, zone) == offset
+		? candidate
+		: exact
+			? NaN
+			: guess
+}
+/**
+ * @param {number} time
+ * @param {string=} zone
+ * @returns {number}
+ */
+function offset_in(time, zone) {
+	return zone === undefined
+		? wall_of_fields(fields_of(new Date(time))) - time
+		: offset_of(time, zone)
+}
+/**
+ * @param {number} time
+ * @param {string} zone
+ * @returns {number}
+ */
+function offset_of(time, zone) {
+	const match = offset_regex.exec(
+		formatter_of(zone).format(
+			time < -8.64e15
+				? -8.64e15
+				: time <= 8.64e15
+					? time
+					: 8.64e15
+		)
+	)
+	if (!match) return 0
+	return (match[1] == "-" ? -1 : 1) * (
+		(+(match[2] ?? 0) * 60 + +(match[3] ?? 0)) * 60000
+		+ +(match[4] ?? 0) * 1000
+	)
+}
+/**
+ * @param {number} from
+ * @param {number} to
+ * @param {string=} zone
+ * @returns {number}
+ */
+function transition_of(from, to, zone) {
+	const offset = offset_in(to, zone)
+	while (to - from > 1) {
+		const middle = Math.floor((from + to) / 2)
+		if (offset_in(middle, zone) == offset) to = middle
+		else from = middle
+	}
+	return to
+}
+/**
+ * @param {number} time
+ * @param {number} ms
+ * @param {string=} zone
+ * @returns {number}
+ */
+function unit_end(time, ms, zone) {
+	const bucket = Math.floor(
+		(time + offset_in(time, zone)) / ms
+	)
+	let at = time
+	for (;;) {
+		const offset = offset_in(at, zone)
+		const end = (bucket + 1) * ms - offset - 1
+		if (!(end <= 8.64e15)) return NaN
+		if (offset_in(end, zone) == offset) return end
+		const transition = transition_of(at, end, zone)
+		const wall = transition + offset_in(transition, zone)
+		if (Math.floor(wall / ms) != bucket || wall <= transition - 1 + offset) return transition - 1
+		at = transition
+	}
+}
+/**
+ * @param {number} time
+ * @param {number} ms
+ * @param {string=} zone
+ * @returns {number}
+ */
+function unit_start(time, ms, zone) {
+	const bucket = Math.floor(
+		(time + offset_in(time, zone)) / ms
+	)
+	let at = time
+	for (;;) {
+		const offset = offset_in(at, zone)
+		const start = bucket * ms - offset
+		if (!(start >= -8.64e15)) return NaN
+		if (offset_in(start, zone) == offset) return start
+		const transition = transition_of(start, at, zone)
+		const before = transition - 1
+		const wall = before + offset_in(before, zone)
+		if (Math.floor(wall / ms) != bucket || wall >= transition + offset) return transition
+		at = before
+	}
+}
+export {
+	check_zone,
+	date_of,
+	end_at,
+	fields_of,
+	instant_of,
+	offset_in,
+	offset_of,
+	transition_of,
+	unit_end,
+	unit_start
+}

package/types/add.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Calculates and adds the specified time duration to the provided date and returns a new Date.
+ * Years and months are clamped to the end of the month, e.g. Jan 31 + 1M is Feb 28 or 29.
+ * Days follow the clock, so a day over a daylight saving change is 23 or 25 hours,
+ * while hours, minutes, seconds and milliseconds are elapsed time.
+ * A part of zero adds nothing; any other part of years, months, weeks or days lands on a clock time,
+ * which moves forward out of a daylight saving gap and takes the first occurrence of an hour that repeats.
+ * @param {Date} date
+ * @param {string} sum
+ * ```
+ * e.g. "1Y2M 3D"
+ * ```
+ *
+ * Supported time units:
+ * - "Y": Years
+ * - "M": Months
+ * - "W": Weeks
+ * - "D": Days
+ * - "H": Hours
+ * - "m": Minutes
+ * - "s": Seconds
+ * - "sss": Milliseconds
+ * @param {import("../public.js").TimeZone=} zone
+ * @returns {Date}
+ * @throws
+ * ```
+ * RangeError(`add: Invalid duration "${sum}"`) // sum is empty, or a part of it is not a number followed by a unit
+ * RangeError(`add: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`add: Expected a Date, got ${typeof date}`)
+ * ```
+ * @example add(new Date, "-1D") //=> Date { yesterday }
+ */
+export default function (date: Date, sum: string, zone?: import("../public.js").TimeZone | undefined): Date;
+//# sourceMappingURL=add.d.ts.map

package/types/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../src/add.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAzBjB,IAyBiB,EAAE,GAAG,EAxBtB,MAwBsB,EAAE,IAAI,AAVpC,CACA,EADQ,OAAO,cAAc,EAAE,QAAQ,YAUH,GAT1B,IAAI,CAuDhB"}

package/types/calendar.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @returns {number}
+ */
+declare function days_of(year: number, month: number, day: number): number;
+/**
+ * @param {number} wall
+ * @returns {number[]}
+ */
+declare function fields_of_wall(wall: number): number[];
+/**
+ * @param {number} year
+ * @param {number} month
+ * @returns {number}
+ */
+declare function last_day(year: number, month: number): number;
+/**
+ * @param {number[]} fields
+ * @returns {number}
+ */
+declare function wall_of_fields(fields: number[]): number;
+export { days_of, fields_of_wall, last_day, wall_of_fields };
+//# sourceMappingURL=calendar.d.ts.map

package/types/calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../src/calendar.js"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,iBAAS,OAAO,CAAC,IAAI,EALV,MAKU,EAAE,KAAK,EAJjB,MAIiB,EAAE,GAAG,EAHtB,MAGsB,GAFpB,MAAM,CAmBlB;AACD;;;GAGG;AACH,iBAAS,cAAc,CAAC,IAAI,EAHjB,MAGiB,GAFf,MAAM,EAAE,CA6BpB;AACD;;;;GAIG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAJX,MAIW,EAAE,KAAK,EAHlB,MAGkB,GAFhB,MAAM,CAMlB;AACD;;;GAGG;AACH,iBAAS,cAAc,CAAC,MAAM,EAHnB,MAAM,EAGa,GAFjB,MAAM,CAYlB;AACD,OAAO,EACN,OAAO,EACP,cAAc,EACd,QAAQ,EACR,cAAc,EACd,CAAA"}

package/types/date_to_string.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Converts a Date object to a formatted string representation.
+ * Letters that are not a time unit are kept as they are, so `"HHhmm"` gives `"11h22"`.
+ * A year before 0 or after 9999 is printed as an expanded year, such as `"+012345"`.
+ * @param {Date} date
+ * @param {string=} format
+ * ```js
+ * = "YYYY-MM-DDTHH:mm:ss.sss"
+ * ```
+ *
+ * Supported time units:
+ * - "YYYY": Years
+ * - "MM": Months
+ * - "DD": Days
+ * - "HH": Hours
+ * - "mm": Minutes
+ * - "ss": Seconds
+ * - "sss": Milliseconds
+ * @param {import("../public.js").TimeZone=} zone
+ * @returns {string}
+ * @throws
+ * ```
+ * RangeError(`dateToString: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`dateToString: Expected a Date, got ${typeof date}`)
+ * ```
+ * @example dateToString(new Date, "YYYY-MM-DD HH:mm", "Asia/Seoul") //=> "2024-07-15 21:00"
+ */
+export default function (date: Date, format?: string | undefined, zone?: import("../public.js").TimeZone | undefined): string;
+//# sourceMappingURL=date_to_string.d.ts.map

package/types/date_to_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date_to_string.d.ts","sourceRoot":"","sources":["../src/date_to_string.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,WACb,IAAI,EAxBM,IAwBN,EACJ,MAAM,AAxBJ,CAaA,EAbQ,MAAM,YAwBkB,EAClC,IAAI,AAZF,CACA,EADQ,OAAO,cAAc,EAAE,QAAQ,YAYrC,GAXQ,MAAM,CAgClB"}

package/types/diff.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Counts the whole units from one date to another, negative when the second date is earlier.
+ * Years, months, weeks and days follow the clock, so a day over a daylight saving change still
+ * counts as one day, while hours, minutes, seconds and milliseconds are elapsed time.
+ * @param {Date} from
+ * @param {Date} to
+ * @param {import("../public.js").Unit} unit
+ * ```
+ * "Y" | "M" | "W" | "D" | "H" | "m" | "s" | "sss"
+ * ```
+ * @param {import("../public.js").TimeZone=} zone
+ * @returns {number}
+ * @throws
+ * ```
+ * RangeError(`diff: Invalid unit "${unit}"`) // The unit is not one of the listed ones
+ * RangeError(`diff: Invalid time zone "${zone}"`) // Intl.DateTimeFormat rejects the zone
+ * TypeError(`diff: Expected a Date, got ${typeof from}`) // from or to is not a Date
+ * ```
+ * @example diff(start, end, "D") //=> 30
+ */
+export default function (from: Date, to: Date, unit: import("../public.js").Unit, zone?: import("../public.js").TimeZone | undefined): number;
+//# sourceMappingURL=diff.d.ts.map