@powerlines/plugin-date 0.12.279 → 0.12.280

package/dist/index.cjs

@@ -1,15 +1,2004 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_date_fns = require('./components/date-fns.cjs');
-const require_dayjs = require('./components/dayjs.cjs');
-const require_luxon = require('./components/luxon.cjs');
-const require_moment = require('./components/moment.cjs');
-require('./components/index.cjs');
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+require('./plugin-DHXHjv16.cjs');
+require('./runtime-D4zTdSwv.cjs');
+require('./types-CBTc19th.cjs');
 let __powerlines_plugin_env = require("@powerlines/plugin-env");
-__powerlines_plugin_env = require_rolldown_runtime.__toESM(__powerlines_plugin_env);
-let defu = require("defu");
-defu = require_rolldown_runtime.__toESM(defu);
+__powerlines_plugin_env = __toESM(__powerlines_plugin_env);
+let powerlines_lib_utilities_file_header = require("powerlines/lib/utilities/file-header");
+
+//#region ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+	if (object[key] !== void 0 && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+	if (Array.isArray(object[key]) && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+
+//#endregion
+//#region src/components/date-fns.ts
+/**
+* Generates the Powerlines configuration file.
+*
+* @param context - The build context containing runtime information.
+* @returns A string representing the configuration file content.
+*/
+function dateFnsModule(context) {
+	return `
+/**
+ * The Date module provides utility functions for date manipulation and formatting
+ *
+ * @module ${context.config.framework}:date
+ */
+
+${(0, powerlines_lib_utilities_file_header.getFileHeader)(context)}
+
+import { DateFormats, TimeUnit } from "@powerlines/plugin-date/types/runtime";
+import { addDays as dateFnsAddDays } from "date-fns/addDays";
+import { addHours as dateFnsAddHours } from "date-fns/addHours";
+import { addMinutes as dateFnsAddMinutes } from "date-fns/addMinutes";
+import { addMonths as dateFnsAddMonths } from "date-fns/addMonths";
+import { addSeconds as dateFnsAddSeconds } from "date-fns/addSeconds";
+import { addWeeks as dateFnsAddWeeks } from "date-fns/addWeeks";
+import { addYears as dateFnsAddYears } from "date-fns/addYears";
+import { differenceInDays } from "date-fns/differenceInDays";
+import { differenceInHours } from "date-fns/differenceInHours";
+import { differenceInMilliseconds } from "date-fns/differenceInMilliseconds";
+import { differenceInMinutes } from "date-fns/differenceInMinutes";
+import { differenceInMonths } from "date-fns/differenceInMonths";
+import { differenceInQuarters } from "date-fns/differenceInQuarters";
+import { differenceInSeconds } from "date-fns/differenceInSeconds";
+import { differenceInWeeks } from "date-fns/differenceInWeeks";
+import { differenceInYears } from "date-fns/differenceInYears";
+import { eachDayOfInterval } from "date-fns/eachDayOfInterval";
+import { endOfDay as dateFnsEndOfDay } from "date-fns/endOfDay";
+import { endOfMonth as dateFnsEndOfMonth } from "date-fns/endOfMonth";
+import { endOfWeek as dateFnsEndOfWeek } from "date-fns/endOfWeek";
+import { endOfYear as dateFnsEndOfYear } from "date-fns/endOfYear";
+import { format as dateFnsFormat, longFormatters } from "date-fns/format";
+import { formatISO } from "date-fns/formatISO";
+import { getDate as dateFnsGetDate } from "date-fns/getDate";
+import { getDay as dateFnsGetDay } from "date-fns/getDay";
+import { getDaysInMonth as dateFnsGetDaysInMonth } from "date-fns/getDaysInMonth";
+import { getHours as dateFnsGetHours } from "date-fns/getHours";
+import { getMinutes as dateFnsGetMinutes } from "date-fns/getMinutes";
+import { getMonth as dateFnsGetMonth } from "date-fns/getMonth";
+import { getSeconds as dateFnsGetSeconds } from "date-fns/getSeconds";
+import { getWeek as dateFnsGetWeek } from "date-fns/getWeek";
+import { getYear as dateFnsGetYear } from "date-fns/getYear";
+import { isAfter as dateFnsIsAfter } from "date-fns/isAfter";
+import { isBefore as dateFnsIsBefore } from "date-fns/isBefore";
+import { isEqual as dateFnsIsEqual } from "date-fns/isEqual";
+import { isSameDay as dateFnsIsSameDay } from "date-fns/isSameDay";
+import { isSameHour as dateFnsIsSameHour } from "date-fns/isSameHour";
+import { isSameMonth as dateFnsIsSameMonth } from "date-fns/isSameMonth";
+import { isSameYear as dateFnsIsSameYear } from "date-fns/isSameYear";
+import { isValid as dateFnsIsValid } from "date-fns/isValid";
+import { isWithinInterval } from "date-fns/isWithinInterval";
+import { Locale } from "date-fns/locale";
+import { ${context.env.parsed.DEFAULT_LOCALE?.replaceAll("-", "") || "enUS"} as defaultLocale } from "date-fns/locale/${context.env.parsed.DEFAULT_LOCALE || "en-US"}";
+import { parse as dateFnsParse } from "date-fns/parse";
+import { parseISO as dateFnsParseISO } from "date-fns/parseISO";
+import { setDate as dateFnsSetDate } from "date-fns/setDate";
+import { setHours as dateFnsSetHours } from "date-fns/setHours";
+import { setMinutes as dateFnsSetMinutes } from "date-fns/setMinutes";
+import { setMonth as dateFnsSetMonth } from "date-fns/setMonth";
+import { setSeconds as dateFnsSetSeconds } from "date-fns/setSeconds";
+import { setYear as dateFnsSetYear } from "date-fns/setYear";
+import { startOfDay as dateFnsStartOfDay } from "date-fns/startOfDay";
+import { startOfMonth as dateFnsStartOfMonth } from "date-fns/startOfMonth";
+import { startOfWeek as dateFnsStartOfWeek } from "date-fns/startOfWeek";
+import { startOfYear as dateFnsStartOfYear } from "date-fns/startOfYear";
+
+export const formats: DateFormats = {
+  dayOfMonth: "d",
+  fullDate: "PP",
+  fullDateWithWeekday: "PPPP",
+  fullDateTime: "PP p",
+  fullDateTime12h: "PP hh:mm aa",
+  fullDateTime24h: "PP HH:mm",
+  fullTime: "p",
+  fullTime12h: "hh:mm aa",
+  fullTime24h: "HH:mm",
+  hours12h: "hh",
+  hours24h: "HH",
+  keyboardDate: "P",
+  keyboardDateTime: "P p",
+  keyboardDateTime12h: "P hh:mm aa",
+  keyboardDateTime24h: "P HH:mm",
+  systemDateTime: "P HH:mm:ss.SSS",
+  filePathDateTime: "P_HH-mm-ss-SSS",
+  minutes: "mm",
+  month: "LLLL",
+  monthAndDate: "MMMM d",
+  monthAndYear: "LLLL yyyy",
+  monthShort: "MMM",
+  weekday: "EEEE",
+  weekdayShort: "EEE",
+  normalDate: "d MMMM",
+  normalDateWithWeekday: "EEE, MMM d",
+  seconds: "ss",
+  shortDate: "MMM d",
+  year: "yyyy"
+};
+
+export const locale: Locale = defaultLocale;
+
+/**
+ * Creates a date object using the provided value.
+ *
+ * @remarks
+ * This function creates a date object using the provided value. If the value is \`null\`, it returns \`null\`. If the value is \`undefined\`, it returns the current date. If the value is a string, it parses the string as a date. If the value is a number, it treats it as a timestamp. If the value is a date object, it returns the date object.
+ *
+ * @example
+ * \`\`\`ts
+ * import { createDate } from "storm:date";
+ *
+ * const date = createDate("2023-10-01");
+ * console.log(date.format("YYYY-MM-DD")); // Outputs: 2023-10-01
+ * \`\`\`
+ *
+ * @param value - The value to create the date object from.
+ * @returns A date object or \`null\` if the value is \`null\`.
+ */
+export function createDate<
+  TArg = undefined,
+  TResultingDate = TArg extends null
+    ? null
+    : TArg extends undefined
+      ? Date
+      : Date | null
+>(value?: TArg): TResultingDate {
+  if (typeof value === "undefined") {
+    return new Date() as TResultingDate;
+  }
+  if (value === null) {
+    return null as TResultingDate;
+  }
+  return new Date(value as string | number) as TResultingDate;
+}
+
+export const type = "date-fns";
+
+// Note: date-fns input types are more lenient than this adapter, so we need to expose our more
+// strict signature and delegate to the more lenient signature. Otherwise, we have downstream type errors upon usage.
+export function is12HourCycleInCurrentLocale(): boolean {
+  if (locale) {
+    return /a/.test(locale.formatLong?.time({}));
+  }
+
+  // By default date-fns is using en-US locale with am/pm enabled
+  return true;
+}
+
+export function getFormatHelperText(format: string) {
+  // @see https://github.com/date-fns/date-fns/blob/master/src/format/index.js#L31
+  const longFormatRegexp = /P+p+|P+|p+|''|'(?:''|[^'])+(?:'|$)|./g;
+  const _locale = locale || defaultLocale;
+
+  return (
+    format
+      .match(longFormatRegexp)
+      ?.map(token => {
+        const firstCharacter = token[0];
+        if (firstCharacter === "p" || firstCharacter === "P") {
+          const longFormatter = longFormatters[firstCharacter]!;
+
+          return longFormatter(token, _locale.formatLong);
+        }
+
+        return token;
+      })
+      .join("")
+      .replace(/aaa|aa|a/g, "(a|p)m")
+      .toLocaleLowerCase() ?? format
+  );
+}
+
+export function parseISO(isoString: string) {
+  return dateFnsParseISO(isoString);
+}
+
+export function toISO(value: Date) {
+  return formatISO(value, {
+    format: "extended"
+  });
+}
+
+export function getCurrentLocaleCode() {
+  return locale?.code || $storm.env.DEFAULT_LOCALE;
+}
+
+export function addSeconds(value: Date, count: number) {
+  return dateFnsAddSeconds(value, count);
+}
+
+export function addMinutes(value: Date, count: number) {
+  return dateFnsAddMinutes(value, count);
+}
+
+export function addHours(value: Date, count: number) {
+  return dateFnsAddHours(value, count);
+}
+
+export function addDays(value: Date, count: number) {
+  return dateFnsAddDays(value, count);
+}
+
+export function addWeeks(value: Date, count: number) {
+  return dateFnsAddWeeks(value, count);
+}
+
+export function addMonths(value: Date, count: number) {
+  return dateFnsAddMonths(value, count);
+}
+
+export function addYears(value: Date, count: number) {
+  return dateFnsAddYears(value, count);
+}
+
+export function isValid(value: any) {
+  return dateFnsIsValid(createDate(value));
+}
+
+export function getDiff(
+  value: Date,
+  comparing: Date | string,
+  unit?: TimeUnit
+) {
+  // we output 0 if the compare date is string and parsing is not valid
+  const dateToCompare = createDate(comparing) ?? value;
+  if (!isValid(dateToCompare)) {
+    return 0;
+  }
+
+  switch (unit) {
+    case "years":
+      return differenceInYears(value, dateToCompare);
+    case "quarters":
+      return differenceInQuarters(value, dateToCompare);
+    case "months":
+      return differenceInMonths(value, dateToCompare);
+    case "weeks":
+      return differenceInWeeks(value, dateToCompare);
+    case "days":
+      return differenceInDays(value, dateToCompare);
+    case "hours":
+      return differenceInHours(value, dateToCompare);
+    case "minutes":
+      return differenceInMinutes(value, dateToCompare);
+    case "seconds":
+      return differenceInSeconds(value, dateToCompare);
+    case "milliseconds":
+    case undefined:
+    default:
+      return differenceInMilliseconds(value, dateToCompare);
+  }
+}
+
+export function isAfter(value: Date, comparing: Date) {
+  return dateFnsIsAfter(value, comparing);
+}
+
+export function isBefore(value: Date, comparing: Date) {
+  return dateFnsIsBefore(value, comparing);
+}
+
+export function startOfDay(value: Date) {
+  return dateFnsStartOfDay(value);
+}
+
+export function endOfDay(value: Date) {
+  return dateFnsEndOfDay(value);
+}
+
+export function getHours(value: Date) {
+  return dateFnsGetHours(value);
+}
+
+export function setHours(value: Date, count: number) {
+  return dateFnsSetHours(value, count);
+}
+
+export function setMinutes(value: Date, count: number) {
+  return dateFnsSetMinutes(value, count);
+}
+
+export function getSeconds(value: Date) {
+  return dateFnsGetSeconds(value);
+}
+
+export function setSeconds(value: Date, count: number) {
+  return dateFnsSetSeconds(value, count);
+}
+
+export function isSameDay(value: Date, comparing: Date) {
+  return dateFnsIsSameDay(value, comparing);
+}
+
+export function isSameMonth(value: Date, comparing: Date) {
+  return dateFnsIsSameMonth(value, comparing);
+}
+
+export function isSameYear(value: Date, comparing: Date) {
+  return dateFnsIsSameYear(value, comparing);
+}
+
+export function isSameHour(value: Date, comparing: Date) {
+  return dateFnsIsSameHour(value, comparing);
+}
+
+export function startOfYear(value: Date) {
+  return dateFnsStartOfYear(value);
+}
+
+export function endOfYear(value: Date) {
+  return dateFnsEndOfYear(value);
+}
+
+export function startOfMonth(value: Date) {
+  return dateFnsStartOfMonth(value);
+}
+
+export function endOfMonth(value: Date) {
+  return dateFnsEndOfMonth(value);
+}
+
+export function startOfWeek(value: Date) {
+  return dateFnsStartOfWeek(value, {
+    locale
+  });
+}
+
+export function endOfWeek(value: Date) {
+  return dateFnsEndOfWeek(value, {
+    locale
+  });
+}
+
+export function getYear(value: Date) {
+  return dateFnsGetYear(value);
+}
+
+export function setYear(value: Date, count: number) {
+  return dateFnsSetYear(value, count);
+}
+
+export function toJsDate(value: Date) {
+  return value;
+}
+
+export function parse(value: string, formatString: string) {
+  if (value === "") {
+    return null;
+  }
+  return dateFnsParse(value, formatString, new Date(), {
+    locale
+  });
+}
+
+export function format(date: Date, formatKey: keyof DateFormats) {
+  return formatByString(date, formats[formatKey]);
+}
+
+export function formatByString(date: Date, formatString: string) {
+  return dateFnsFormat(date, formatString, {
+    locale
+  });
+}
+
+export function isEqual(date: any, comparing: any) {
+  if (date === null && comparing === null) {
+    return true;
+  }
+  return dateFnsIsEqual(date, comparing);
+}
+
+export function isNull(date: Date) {
+  return date === null;
+}
+
+export function isAfterDay(date: Date, value: Date) {
+  return isAfter(date, endOfDay(value));
+}
+
+export function isBeforeDay(date: Date, value: Date) {
+  return isBefore(date, startOfDay(value));
+}
+
+export function isBeforeYear(date: Date, value: Date) {
+  return isBefore(date, startOfYear(value));
+}
+
+export function isBeforeMonth(value: Date, comparing: Date): boolean {
+  return isBefore(value, startOfMonth(comparing));
+}
+
+export function isAfterMonth(value: Date, comparing: Date): boolean {
+  return isAfter(value, startOfMonth(comparing));
+}
+
+export function isAfterYear(date: Date, value: Date) {
+  return isAfter(date, endOfYear(value));
+}
+
+export function isWithinRange(date: Date, [start, end]: [Date, Date]) {
+  return isWithinInterval(date, {
+    start,
+    end
+  });
+}
+
+export function formatNumber(numberToFormat: string) {
+  return numberToFormat;
+}
+
+export function getMinutes(date: Date) {
+  return dateFnsGetMinutes(date);
+}
+
+export function getDate(date: Date) {
+  return dateFnsGetDate(date);
+}
+
+export function setDate(date: Date, count: number) {
+  return dateFnsSetDate(date, count);
+}
+
+export function getWeek(date: Date) {
+  return dateFnsGetWeek(date);
+}
+
+export function getMonth(date: Date) {
+  return dateFnsGetMonth(date);
+}
+
+export function getDaysInMonth(date: Date) {
+  return dateFnsGetDaysInMonth(date);
+}
+
+export function setMonth(date: Date, count: number) {
+  return dateFnsSetMonth(date, count);
+}
+
+export function getMeridiemText(meridiem: "am" | "pm") {
+  return meridiem === "am" ? "AM" : "PM";
+}
+
+export function getNextMonth(date: Date) {
+  return addMonths(date, 1);
+}
+
+export function getPreviousMonth(date: Date) {
+  return addMonths(date, -1);
+}
+
+export function getMonthArray(date: Date) {
+  const firstMonth = startOfYear(date);
+  const monthArray = [firstMonth];
+
+  while (monthArray.length < 12) {
+    const prevMonth = monthArray[monthArray.length - 1]!;
+    monthArray.push(getNextMonth(prevMonth));
+  }
+
+  return monthArray;
+}
+
+export function mergeDateAndTime(date: Date, time: Date) {
+  return setSeconds(
+    setMinutes(setHours(date, getHours(time)), getMinutes(time)),
+    getSeconds(time)
+  );
+}
+
+export function getWeekdays() {
+  const now = new Date();
+
+  return eachDayOfInterval({
+    start: startOfWeek(now),
+    end: endOfWeek(now)
+  }).map(day => formatByString(day, "EEEEEE"));
+}
+
+export function getWeekArray(date: Date) {
+  const start = startOfWeek(startOfMonth(date));
+  const end = endOfWeek(endOfMonth(date));
+  let count = 0;
+  let current = start;
+  const nestedWeeks: Date[][] = [];
+  let lastDay = null as null | number;
+  while (isBefore(current, end)) {
+    const weekNumber = Math.floor(count / 7);
+    nestedWeeks[weekNumber] ??= [];
+    const day = dateFnsGetDay(current);
+    if (lastDay !== day) {
+      lastDay = day;
+      nestedWeeks[weekNumber].push(current);
+      count += 1;
+    }
+    current = addDays(current, 1);
+  }
+  return nestedWeeks;
+}
+
+export function getYearRange(start: Date, end: Date) {
+  const startDate = startOfYear(start);
+  const endDate = endOfYear(end);
+  const years: Date[] = [];
+
+  let current = startDate;
+  while (isBefore(current, endDate)) {
+    years.push(current);
+    current = addYears(current, 1);
+  }
+  return years;
+}
+
+
+`;
+}
+
+//#endregion
+//#region src/components/dayjs.ts
+/**
+* Generates the Powerlines configuration file.
+*
+* @param context - The build context containing runtime information.
+* @returns A string representing the configuration file content.
+*/
+function dayjsModule(context) {
+	return `
+/**
+ * The Date module provides utility functions for date manipulation and formatting
+ *
+ * @module ${context.config.framework}:date
+ */
+
+${(0, powerlines_lib_utilities_file_header.getFileHeader)(context)}
+
+import defaultDayjs, { QUnitType } from "dayjs";
+import customParseFormatPlugin from "dayjs/plugin/customParseFormat";
+import localizedFormatPlugin from "dayjs/plugin/localizedFormat";
+import isBetweenPlugin from "dayjs/plugin/isBetween";
+import weekOfYear from "dayjs/plugin/weekOfYear";
+import {
+  StormDateInterface,
+  DateFormats,
+  TimeUnit
+} from "@powerlines/plugin-date/types/runtime";
+
+defaultDayjs.extend(customParseFormatPlugin);
+defaultDayjs.extend(localizedFormatPlugin);
+defaultDayjs.extend(isBetweenPlugin);
+defaultDayjs.extend(weekOfYear);
+
+interface Opts {
+  locale?: string;
+  /** Make sure that your dayjs instance extends customParseFormat and advancedFormat */
+  instance?: typeof defaultDayjs;
+  formats?: Partial<DateFormats>;
+}
+
+type Dayjs = defaultDayjs.Dayjs;
+type Constructor<TDate extends Dayjs> = (
+  ...args: Parameters<typeof defaultDayjs>
+) => TDate;
+const withLocale = <TDate extends Dayjs>(
+  dayjs: any,
+  locale?: string
+): Constructor<TDate> => (!locale ? dayjs : (...args) => dayjs(...args).locale(locale));
+
+export const formats: DateFormats = {
+  normalDateWithWeekday: "ddd, MMM D",
+  normalDate: "D MMMM",
+  shortDate: "MMM D",
+  monthAndDate: "MMMM D",
+  dayOfMonth: "D",
+  year: "YYYY",
+  month: "MMMM",
+  monthShort: "MMM",
+  monthAndYear: "MMMM YYYY",
+  weekday: "dddd",
+  weekdayShort: "ddd",
+  minutes: "mm",
+  hours12h: "hh",
+  hours24h: "HH",
+  seconds: "ss",
+  fullTime: "LT",
+  fullTime12h: "hh:mm A",
+  fullTime24h: "HH:mm",
+  fullDate: "ll",
+  fullDateWithWeekday: "dddd, LL",
+  fullDateTime: "lll",
+  fullDateTime12h: "ll hh:mm A",
+  fullDateTime24h: "ll HH:mm",
+  keyboardDate: "L",
+  keyboardDateTime: "L LT",
+  keyboardDateTime12h: "L hh:mm A",
+  keyboardDateTime24h: "L HH:mm",
+  systemDateTime: "L HH:mm:ss.SSS",
+  filePathDateTime: "L_HH-mm-ss-SSS"
+};
+
+export let locale = "${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale ? `${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale}` : "en-US"}";
+
+export const dayjs = withLocale(defaultDayjs, locale);
+
+export const type = "dayjs";
+
+/**
+ * Creates a date object using the provided value.
+ *
+ * @remarks
+ * This function creates a date object using the provided value. If the value is \`null\`, it returns \`null\`. If the value is \`undefined\`, it returns the current date. If the value is a string, it parses the string as a date. If the value is a number, it treats it as a timestamp. If the value is a date object, it returns the date object.
+ *
+ * @example
+ * \`\`\`ts
+ * import { createDate } from "storm:date";
+ *
+ * const date = createDate("2023-10-01");
+ * console.log(date.format("YYYY-MM-DD")); // Outputs: 2023-10-01
+ * \`\`\`
+ *
+ * @param value - The value to create the date object from.
+ * @returns A date object or \`null\` if the value is \`null\`.
+ */
+export function createDate<
+  TArg extends unknown = undefined,
+  TResultingDate extends unknown = TArg extends null
+    ? null
+    : TArg extends undefined
+    ? TDate
+    : TDate | null
+>(value?: TArg): TResultingDate {
+  if (value === null) {
+    return null as TResultingDate;
+  }
+
+  return dayjs(value as any) as unknown as TResultingDate;
+}
+
+export function is12HourCycleInCurrentLocale() {
+  /* istanbul ignore next */
+  return /A|a/.test(dayjs.Ls[dayjs.locale() || $storm.env.DEFAULT_LOCALE]?.formats?.LT ?? "");
+};
+
+export function getCurrentLocaleCode() {
+  return dayjs.locale() || $storm.env.DEFAULT_LOCALE;
+};
+
+export function getFormatHelperText(format: string) {
+  // @see https://github.com/iamkun/dayjs/blob/dev/src/plugin/localizedFormat/index.js
+  const localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?)|./g;
+
+  return (
+    format
+      .match(localFormattingTokens)
+      ?.map((token) => {
+        const firstCharacter = token[0];
+        if (firstCharacter === "L") {
+          /* istanbul ignore next */
+          return (
+            dayjs.Ls[dayjs.locale() || $storm.env.DEFAULT_LOCALE]?.formats[
+              token as keyof ILocale["formats"]
+            ] ?? token
+          );
+        }
+        return token;
+      })
+      .join("")
+      .replace(/a/gi, "(a|p)m")
+      .toLocaleLowerCase() ?? format
+  );
+};
+
+export function parseISO(isoString: string) {
+  return dayjs(isoString);
+};
+
+export function toISO(value: Dayjs) {
+  return value.toISOString();
+};
+
+export function parse(value: any, format: string) {
+  if (value === "") {
+    return null;
+  }
+
+  return dayjs(value, format, dayjs.locale(), true);
+};
+
+export function toJsDate(value: Dayjs) {
+  return value.toDate();
+};
+
+export function isValid(value: any) {
+  return dayjs(value).isValid();
+};
+
+export function isNull(date: Dayjs | null) {
+  return date === null;
+};
+
+export function getDiff(date: Dayjs, comparing: Dayjs | string, units?: Unit) {
+  if (typeof comparing === "string") {
+    comparing = dayjs(comparing);
+  }
+
+  if (!comparing.isValid()) {
+    return 0;
+  }
+
+  return date.diff(comparing, units as QUnitType);
+};
+
+export function isAfter(date: Dayjs, value: Dayjs) {
+  return date.isAfter(value);
+};
+
+export function isBefore(date: Dayjs, value: Dayjs) {
+  return date.isBefore(value);
+};
+
+export function isAfterDay(date: Dayjs, value: Dayjs) {
+  return date.isAfter(value, "day");
+};
+
+export function isBeforeDay(date: Dayjs, value: Dayjs) {
+  return date.isBefore(value, "day");
+};
+
+export function isAfterMonth(date: Dayjs, value: Dayjs) {
+  return date.isAfter(value, "month");
+};
+
+export function isBeforeMonth(date: Dayjs, value: Dayjs) {
+  return date.isBefore(value, "month");
+};
+
+export function isBeforeYear(date: Dayjs, value: Dayjs) {
+  return date.isBefore(value, "year");
+};
+
+export function isAfterYear(date: Dayjs, value: Dayjs) {
+  return date.isAfter(value, "year");
+};
+
+export function startOfDay(date: Dayjs) {
+  return date.startOf("day");
+};
+
+export function endOfDay(date: Dayjs) {
+  return date.endOf("day");
+};
+
+export function format(date: Dayjs, formatKey: keyof DateFormats) {
+  return formatByString(date, formats[formatKey]);
+};
+
+export function formatByString(date: Dayjs, formatString: string) {
+  return dayjs(date).format(formatString);
+};
+
+export function formatNumber(numberToFormat: string) {
+  return numberToFormat;
+};
+
+export function getHours(date: Dayjs) {
+  return date.hour();
+};
+
+export function addSeconds(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "second") as Dayjs)
+    : (date.add(count, "second") as Dayjs);
+};
+
+export function addMinutes(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "minute") as Dayjs)
+    : (date.add(count, "minute") as Dayjs);
+};
+
+export function addHours(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "hour") as Dayjs)
+    : (date.add(count, "hour") as Dayjs);
+};
+
+export function addDays(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "day") as Dayjs)
+    : (date.add(count, "day") as Dayjs);
+};
+
+export function addWeeks(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "week") as Dayjs)
+    : (date.add(count, "week") as Dayjs);
+};
+
+export function addMonths(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "month") as Dayjs)
+    : (date.add(count, "month") as Dayjs);
+};
+
+export function addYears(date: Dayjs, count: number) {
+  return count < 0
+    ? (date.subtract(Math.abs(count), "year") as Dayjs)
+    : (date.add(count, "year") as Dayjs);
+};
+
+export function setMonth(date: Dayjs, count: number) {
+  return date.set("month", count) as Dayjs;
+};
+
+export function setHours(date: Dayjs, count: number) {
+  return date.set("hour", count) as Dayjs;
+};
+
+export function getMinutes(date: Dayjs) {
+  return date.minute();
+};
+
+export function setMinutes(date: Dayjs, count: number) {
+  return date.set("minute", count) as Dayjs;
+};
+
+export function getSeconds(date: Dayjs) {
+  return date.second();
+};
+
+export function setSeconds(date: Dayjs, count: number) {
+  return date.set("second", count) as Dayjs;
+};
+
+export function getWeek(date: Dayjs) {
+  return date.week();
+};
+
+export function getMonth(date: Dayjs) {
+  return date.month();
+};
+
+export function getDate(date: Dayjs) {
+  return date.date();
+};
+
+export function setDate(date: Dayjs, count: number) {
+  return date.set("date", count) as Dayjs;
+};
+
+export function getDaysInMonth(date: Dayjs) {
+  return date.daysInMonth();
+};
+
+export function isSameDay(date: Dayjs, comparing: Dayjs) {
+  return date.isSame(comparing, "day");
+};
+
+export function isSameMonth(date: Dayjs, comparing: Dayjs) {
+  return date.isSame(comparing, "month");
+};
+
+export function isSameYear(date: Dayjs, comparing: Dayjs) {
+  return date.isSame(comparing, "year");
+};
+
+export function isSameHour(date: Dayjs, comparing: Dayjs) {
+  return date.isSame(comparing, "hour");
+};
+
+export function getMeridiemText(meridiem: "am" | "pm") {
+  return meridiem === "am" ? "AM" : "PM";
+};
+
+export function startOfYear(date: Dayjs) {
+  return date.startOf("year") as Dayjs;
+};
 
+export function endOfYear(date: Dayjs) {
+  return date.endOf("year") as Dayjs;
+};
+
+export function startOfMonth(date: Dayjs) {
+  return date.startOf("month") as Dayjs;
+};
+
+export function endOfMonth(date: Dayjs) {
+  return date.endOf("month") as Dayjs;
+};
+
+export function startOfWeek(date: Dayjs) {
+  return date.startOf("week") as Dayjs;
+};
+
+export function endOfWeek(date: Dayjs) {
+  return date.endOf("week") as Dayjs;
+};
+
+export function getNextMonth(date: Dayjs) {
+  return date.add(1, "month") as Dayjs;
+};
+
+export function getPreviousMonth(date: Dayjs) {
+  return date.subtract(1, "month") as Dayjs;
+};
+
+export function getMonthArray(date: Dayjs) {
+  const firstMonth = date.startOf("year") as Dayjs;
+  const monthArray = [firstMonth];
+
+  while (monthArray.length < 12) {
+    const prevMonth = monthArray[monthArray.length - 1];
+    monthArray.push(getNextMonth(prevMonth));
+  }
+
+  return monthArray;
+};
+
+export function getYear(date: Dayjs) {
+  return date.year();
+};
+
+export function setYear(date: Dayjs, year: number) {
+  return date.set("year", year) as Dayjs;
+};
+
+export function mergeDateAndTime(date: Dayjs, time: Dayjs) {
+  return date.hour(time.hour()).minute(time.minute()).second(time.second()) as Dayjs;
+};
+
+export function getWeekdays() {
+  const start = dayjs().startOf("week");
+  return [0, 1, 2, 3, 4, 5, 6].map((diff) =>
+    formatByString(start.add(diff, "day"), "dd")
+  );
+};
+
+export function isEqual(value: any, comparing: any) {
+  if (value === null && comparing === null) {
+    return true;
+  }
+
+  return dayjs(value).isSame(comparing);
+};
+
+export function getWeekArray(date: Dayjs) {
+  const start = dayjs(date).startOf("month").startOf("week") as Dayjs;
+  const end = dayjs(date).endOf("month").endOf("week") as Dayjs;
+
+  let count = 0;
+  let current = start;
+  const nestedWeeks: Dayjs[][] = [];
+
+  while (current.isBefore(end)) {
+    const weekNumber = Math.floor(count / 7);
+    nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+    nestedWeeks[weekNumber].push(current);
+
+    current = current.add(1, "day") as TDate;
+    count += 1;
+  }
+
+  return nestedWeeks;
+};
+
+export function getYearRange(start: Dayjs, end: Dayjs) {
+  const startDate = start.startOf("year");
+  const endDate = end.endOf("year");
+  const years: Dayjs[] = [];
+
+  let current = startDate;
+  while (current.isBefore(endDate)) {
+    years.push(current);
+    current = current.add(1, "year");
+  }
+
+  return years;
+};
+
+export function isWithinRange(date: Dayjs, [start, end]: [Dayjs, Dayjs]) {
+  return date.isBetween(start, end, null, "[]");
+};
+
+
+`;
+}
+
+//#endregion
+//#region src/components/luxon.ts
+/**
+* Generates the Powerlines configuration file.
+*
+* @param context - The build context containing runtime information.
+* @returns A string representing the configuration file content.
+*/
+function luxonModule(context) {
+	return `
+/**
+ * The Date module provides utility functions for date manipulation and formatting
+ *
+ * @module ${context.config.framework}:date
+ */
+
+${(0, powerlines_lib_utilities_file_header.getFileHeader)(context)}
+
+import { DateTime, Settings, Info } from "luxon";
+import {
+  StormDateInterface,
+  DateFormats,
+  TimeUnit
+} from "@powerlines/plugin-date/types/runtime";
+
+export const formats: DateFormats = {
+  dayOfMonth: "d",
+  fullDate: "DD",
+  fullDateWithWeekday: "DDDD",
+  fullDateTime: "ff",
+  fullDateTime12h: "DD, hh:mm a",
+  fullDateTime24h: "DD, T",
+  fullTime: "t",
+  fullTime12h: "hh:mm a",
+  fullTime24h: "HH:mm",
+  hours12h: "hh",
+  hours24h: "HH",
+  keyboardDate: "D",
+  keyboardDateTime: "D t",
+  keyboardDateTime12h: "D hh:mm a",
+  keyboardDateTime24h: "D T",
+  systemDateTime: "D HH:mm:ss.SSS",
+  filePathDateTime: "D_HH-mm-ss-SSS",
+  minutes: "mm",
+  seconds: "ss",
+  month: "LLLL",
+  monthAndDate: "MMMM d",
+  monthAndYear: "LLLL yyyy",
+  monthShort: "MMM",
+  weekday: "cccc",
+  weekdayShort: "ccc",
+  normalDate: "d MMMM",
+  normalDateWithWeekday: "EEE, MMM d",
+  shortDate: "MMM d",
+  year: "yyyy",
+};
+
+export let locale = "${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale ? `${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale}` : "en-US"}";
+
+export const type = "luxon";
+
+/**
+ * Creates a date object using the provided value.
+ *
+ * @remarks
+ * This function creates a date object using the provided value. If the value is \`null\`, it returns \`null\`. If the value is \`undefined\`, it returns the current date. If the value is a string, it parses the string as a date. If the value is a number, it treats it as a timestamp. If the value is a date object, it returns the date object.
+ *
+ * @example
+ * \`\`\`ts
+ * import { createDate } from "storm:date";
+ *
+ * const date = createDate("2023-10-01");
+ * console.log(date.format("YYYY-MM-DD")); // Outputs: 2023-10-01
+ * \`\`\`
+ *
+ * @param value - The value to create the date object from.
+ * @returns A date object or \`null\` if the value is \`null\`.
+ */
+export function createDate<
+  TArg extends unknown = undefined,
+  TResultingDate extends unknown = TArg extends null
+    ? null
+    : TArg extends undefined
+    ? DateTime
+    : DateTime | null
+>(value?: TArg): TResultingDate {
+  if (typeof value === "undefined") {
+    return DateTime.local() as TResultingDate;
+  }
+
+  if (value === null) {
+    return null as TResultingDate;
+  }
+
+  if (typeof value === "string") {
+    return DateTime.fromJSDate(new Date(value), { locale }) as TResultingDate;
+  }
+
+  if (DateTime.isDateTime(value)) {
+    return value as TResultingDate;
+  }
+
+  if (value instanceof Date) {
+    return DateTime.fromJSDate(value, { locale }) as TResultingDate;
+  }
+
+  /* istanbul ignore next */
+  return DateTime.local() as TResultingDate;
+}
+
+export function toJsDate(value: DateTime) {
+  return value.toJSDate();
+};
+
+export function parseISO(isoString: string) {
+  return DateTime.fromISO(isoString);
+};
+
+export function toISO(value: DateTime) {
+  return value.toISO({ format: "extended" });
+};
+
+export function parse(value: string, formatString: string) {
+  if (value === "") {
+    return null;
+  }
+
+  return DateTime.fromFormat(value, formatString, { locale });
+};
+
+/* istanbul ignore next */
+export function is12HourCycleInCurrentLocale() {
+  if (typeof Intl === "undefined" || typeof Intl.DateTimeFormat === "undefined") {
+    return true; // Luxon defaults to en-US if Intl not found
+  }
+
+  return Boolean(
+    new Intl.DateTimeFormat(this.locale, { hour: "numeric" })?.resolvedOptions()?.hour12
+  );
+};
+
+export function getFormatHelperText(format: string) {
+  // Unfortunately there is no way for luxon to retrieve readable formats from localized format
+  return "";
+};
+
+/* istanbul ignore next */
+export function getCurrentLocaleCode() {
+  return this.locale || Settings.defaultLocale;
+};
+
+export function addSeconds(date: DateTime, count: number) {
+  return date.plus({ seconds: count });
+};
+
+export function addMinutes(date: DateTime, count: number) {
+  return date.plus({ minutes: count });
+};
+
+export function addHours(date: DateTime, count: number) {
+  return date.plus({ hours: count });
+};
+
+export function addDays(date: DateTime, count: number) {
+  return date.plus({ days: count });
+};
+
+export function addWeeks(date: DateTime, count: number) {
+  return date.plus({ weeks: count });
+};
+
+export function addMonths(date: DateTime, count: number) {
+  return date.plus({ months: count });
+};
+
+export function addYears(date: DateTime, count: number) {
+  return date.plus({ years: count });
+};
+
+export function isValid(value: any) {
+  if (DateTime.isDateTime(value)) {
+    return value.isValid;
+  }
+
+  if (value === null) {
+    return false;
+  }
+
+  return createDate(value)?.isValid ?? false;
+};
+
+export function isEqual(value: any, comparing: any) {
+  if (value === null && comparing === null) {
+    return true;
+  }
+
+  // make sure that null will not be passed to createDate
+  if (value === null || comparing === null) {
+    return false;
+  }
+
+  if (!createDate(comparing)) {
+    /* istanbul ignore next */
+    return false;
+  }
+
+  return createDate(value)?.equals(createDate(comparing) as DateTime) ?? false;
+};
+
+export function isSameDay(date: DateTime, comparing: DateTime) {
+  return date.hasSame(comparing, "day");
+};
+
+export function isSameMonth(date: DateTime, comparing: DateTime) {
+  return date.hasSame(comparing, "month");
+};
+
+export function isSameYear(date: DateTime, comparing: DateTime) {
+  return date.hasSame(comparing, "year");
+};
+
+export function isSameHour(date: DateTime, comparing: DateTime) {
+  return date.hasSame(comparing, "hour");
+};
+
+export function isAfter(value: DateTime, comparing: DateTime) {
+  return value > comparing;
+};
+
+export function isBefore(value: DateTime, comparing: DateTime) {
+  return value < comparing;
+};
+
+export function isBeforeDay(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.startOf("day"), "days").toObject();
+  return diff.days! < 0;
+};
+
+export function isAfterDay(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.endOf("day"), "days").toObject();
+  return diff.days! > 0;
+};
+
+export function isBeforeMonth(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.startOf("month"), "months").toObject();
+  return diff.months! < 0;
+};
+
+export function isAfterMonth(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.startOf("month"), "months").toObject();
+  return diff.months! > 0;
+};
+
+export function isBeforeYear(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.startOf("year"), "years").toObject();
+  return diff.years! < 0;
+};
+
+export function isAfterYear(value: DateTime, comparing: DateTime) {
+  const diff = value.diff(comparing.endOf("year"), "years").toObject();
+  return diff.years! > 0;
+};
+
+export function getDiff(value: DateTime, comparing: DateTime | string, unit?: TimeUnit) {
+  if (typeof comparing === "string") {
+    comparing = DateTime.fromJSDate(new Date(comparing));
+  }
+
+  if (!comparing.isValid) {
+    return 0;
+  }
+
+  if (unit) {
+    return Math.floor(value.diff(comparing).as(unit));
+  }
+
+  return value.diff(comparing).as("millisecond");
+};
+
+export function startOfDay(value: DateTime) {
+  return value.startOf("day");
+};
+
+export function endOfDay(value: DateTime) {
+  return value.endOf("day");
+};
+
+export function format(date: DateTime, formatKey: keyof DateFormats) {
+  return formatByString(date, formats[formatKey]);
+};
+
+export function formatByString(date: DateTime, format: string) {
+  return date.setLocale(locale).toFormat(format);
+};
+
+export function formatNumber(numberToFormat: string) {
+  return numberToFormat;
+};
+
+export function getHours(value: DateTime) {
+  return value.get("hour");
+};
+
+export function setHours(value: DateTime, count: number) {
+  return value.set({ hour: count });
+};
+
+export function getMinutes(value: DateTime) {
+  return value.get("minute");
+};
+
+export function setMinutes(value: DateTime, count: number) {
+  return value.set({ minute: count });
+};
+
+export function getSeconds(value: DateTime) {
+  return value.get("second");
+};
+
+export function setSeconds(value: DateTime, count: number) {
+  return value.set({ second: count });
+};
+
+export function getWeek(value: DateTime) {
+  return value.get("weekNumber");
+};
+
+export function getMonth(value: DateTime) {
+  // See https://github.com/moment/luxon/blob/master/docs/moment.md#major-functional-differences
+  return value.get("month") - 1;
+};
+
+export function getDaysInMonth(value: DateTime) {
+  return value.daysInMonth;
+};
+
+export function setMonth(value: DateTime, count: number) {
+  return value.set({ month: count + 1 });
+};
+
+export function getYear(value: DateTime) {
+  return value.get("year");
+};
+
+export function setYear(value: DateTime, year: number) {
+  return value.set({ year });
+};
+
+export function getDate(value: DateTime) {
+  return value.get("day");
+};
+
+export function setDate(value: DateTime, day: number) {
+  return value.set({ day });
+};
+
+export function mergeDateAndTime(date: DateTime, time: DateTime) {
+  return date.set({
+    second: time.second,
+    hour: time.hour,
+    minute: time.minute,
+  });
+};
+
+export function startOfYear(value: DateTime) {
+  return value.startOf("year");
+};
+
+export function endOfYear(value: DateTime) {
+  return value.endOf("year");
+};
+
+export function startOfMonth(value: DateTime) {
+  return value.startOf("month");
+};
+
+export function endOfMonth(value: DateTime) {
+  return value.endOf("month");
+};
+
+export function startOfWeek(value: DateTime) {
+  return value.startOf("week");
+};
+
+export function endOfWeek(value: DateTime) {
+  return value.endOf("week");
+};
+
+export function getNextMonth(value: DateTime) {
+  return value.plus({ months: 1 });
+};
+
+export function getPreviousMonth(value: DateTime) {
+  return value.minus({ months: 1 });
+};
+
+export function getMonthArray(date: DateTime) {
+  const firstMonth = date.startOf("year");
+  const monthArray = [firstMonth];
+
+  while (monthArray.length < 12) {
+    const prevMonth = monthArray[monthArray.length - 1];
+    monthArray.push(this.getNextMonth(prevMonth));
+  }
+
+  return monthArray;
+};
+
+export function getWeekdays() {
+  return Info.weekdaysFormat("short", { locale });
+};
+
+export function getWeekArray(date: DateTime) {
+  const { days } = date
+    .endOf("month")
+    .endOf("week")
+    .diff(date.startOf("month").startOf("week"), "days")
+    .toObject();
+
+  const weeks: DateTime[][] = [];
+  new Array<number>(Math.round(days!))
+    .fill(0)
+    .map((_, i) => i)
+    .map((day) => date.startOf("month").startOf("week").plus({ days: day }))
+    .forEach((v, i) => {
+      if (i === 0 || (i % 7 === 0 && i > 6)) {
+        weeks.push([v]);
+        return;
+      }
+
+      weeks[weeks.length - 1].push(v);
+    });
+
+  return weeks;
+};
+
+export function getYearRange(start: DateTime, end: DateTime) {
+  const startDate = start.startOf("year");
+  const endDate = end.endOf("year");
+
+  let current = startDate;
+  const years: DateTime[] = [];
+
+  while (current < endDate) {
+    years.push(current);
+    current = current.plus({ year: 1 });
+  }
+
+  return years;
+};
+
+export function getMeridiemText(meridiem: "am" | "pm") {
+  return Info.meridiems({ locale }).find(
+    (v) => v.toLowerCase() === meridiem.toLowerCase()
+  )!;
+};
+
+export function isNull(date: DateTime | null) {
+  return date === null;
+};
+
+export function isWithinRange(date: DateTime, [start, end]: [DateTime, DateTime]) {
+  return (
+    date.equals(start) ||
+    date.equals(end) ||
+    (isAfter(date, start) && isBefore(date, end))
+  );
+};
+
+
+`;
+}
+
+//#endregion
+//#region src/components/moment.ts
+/**
+* Generates the Powerlines configuration file.
+*
+* @param context - The build context containing runtime information.
+* @returns A string representing the configuration file content.
+*/
+function momentModule(context) {
+	return `
+/**
+ * The Date module provides utility functions for date manipulation and formatting
+ *
+ * @module ${context.config.framework}:date
+ */
+
+${(0, powerlines_lib_utilities_file_header.getFileHeader)(context)}
+
+import defaultMoment, { LongDateFormatKey } from "moment";
+import {
+  StormDateInterface,
+  DateFormats,
+  TimeUnit
+} from "@powerlines/plugin-date/types/runtime";
+
+type Moment = defaultMoment.Moment;
+
+export const formats: DateFormats = {
+  normalDateWithWeekday: "ddd, MMM D",
+  normalDate: "D MMMM",
+  shortDate: "MMM D",
+  monthAndDate: "MMMM D",
+  dayOfMonth: "D",
+  year: "YYYY",
+  month: "MMMM",
+  monthShort: "MMM",
+  monthAndYear: "MMMM YYYY",
+  weekday: "dddd",
+  weekdayShort: "ddd",
+  minutes: "mm",
+  hours12h: "hh",
+  hours24h: "HH",
+  seconds: "ss",
+  fullTime: "LT",
+  fullTime12h: "hh:mm A",
+  fullTime24h: "HH:mm",
+  fullDate: "ll",
+  fullDateWithWeekday: "dddd, LL",
+  fullDateTime: "lll",
+  fullDateTime12h: "ll hh:mm A",
+  fullDateTime24h: "ll HH:mm",
+  keyboardDate: "L",
+  keyboardDateTime: "L LT",
+  keyboardDateTime12h: "L hh:mm A",
+  keyboardDateTime24h: "L HH:mm",
+  systemDateTime: "L HH:mm:ss.SSS",
+  filePathDateTime: "L_HH-mm-ss-SSS"
+};
+
+export let locale = "${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale ? `${context.env.parsed.DEFAULT_LOCALE || context.workspaceConfig.locale}` : "en-US"}";
+
+export const type = "moment";
+
+const moment = defaultMoment;
+
+/**
+ * Creates a date object using the provided value.
+ *
+ * @remarks
+ * This function creates a date object using the provided value. If the value is \`null\`, it returns \`null\`. If the value is \`undefined\`, it returns the current date. If the value is a string, it parses the string as a date. If the value is a number, it treats it as a timestamp. If the value is a date object, it returns the date object.
+ *
+ * @example
+ * \`\`\`ts
+ * import { createDate } from "storm:date";
+ *
+ * const date = createDate("2023-10-01");
+ * console.log(date.format("YYYY-MM-DD")); // Outputs: 2023-10-01
+ * \`\`\`
+ *
+ * @param value - The value to create the date object from.
+ * @returns A date object or \`null\` if the value is \`null\`.
+ */
+export function createDate<
+  TArg extends unknown = undefined,
+  TResultingDate extends unknown = TArg extends null
+    ? null
+    : TArg extends undefined
+    ? defaultMoment.Moment
+    : defaultMoment.Moment | null
+>(value?: TArg): TResultingDate {
+  if (value === null) {
+    return null as TResultingDate;
+  }
+
+  const _moment = moment(value);
+  if (locale) {
+    _moment.locale(locale);
+  }
+
+  return _moment as TResultingDate;
+}
+
+
+export function is12HourCycleInCurrentLocale(): boolean {
+  return /A|a/.test(
+    moment.localeData(getCurrentLocaleCode()).longDateFormat("LT")
+  );
+};
+
+export function getFormatHelperText(format: string) {
+  // @see https://github.com/moment/moment/blob/develop/src/lib/format/format.js#L6
+  const localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})|./g;
+
+  return (
+    format
+      .match(localFormattingTokens)
+      ?.map((token) => {
+        const firstCharacter = token[0];
+        if (firstCharacter === "L" || firstCharacter === ";") {
+          return moment
+            .localeData(getCurrentLocaleCode())
+            .longDateFormat(token as LongDateFormatKey);
+        }
+
+        return token;
+      })
+      .join("")
+      .replace(/a/gi, "(a|p)m")
+      .toLocaleLowerCase() ?? format
+  );
+};
+
+export function getCurrentLocaleCode() {
+  return locale || moment.locale();
+};
+
+export function parseISO(isoString: string) {
+  return moment(isoString, true);
+};
+
+export function toISO(value: Moment) {
+  return value.toISOString();
+};
+
+export function parse(value: string, format: string) {
+  if (value === "") {
+    return null;
+  }
+
+  if (locale) {
+    return moment(value, format, locale, true);
+  }
+
+  return moment(value, format, true);
+};
+
+export function toJsDate(value: Moment) {
+  return value.toDate();
+};
+
+export function isValid(value: any) {
+  return moment(value).isValid();
+};
+
+export function isNull(date: Moment) {
+  return date === null;
+};
+
+export function getDiff(date: Moment, comparing: Moment | string, unit?: TimeUnit) {
+  if (!moment(comparing).isValid()) {
+    return 0;
+  }
+
+  return date.diff(comparing, unit);
+};
+
+export function isAfter(date: Moment, value: Moment) {
+  return date.isAfter(value);
+};
+
+export function isBefore(date: Moment, value: Moment) {
+  return date.isBefore(value);
+};
+
+export function isAfterDay(date: Moment, value: Moment) {
+  return date.isAfter(value, "day");
+};
+
+export function isBeforeDay(date: Moment, value: Moment) {
+  return date.isBefore(value, "day");
+};
+
+export function isBeforeMonth(date: Moment, value: Moment) {
+  return date.isBefore(value, "month");
+};
+
+export function isAfterMonth(date: Moment, value: Moment) {
+  return date.isAfter(value, "month");
+};
+
+export function isBeforeYear(date: Moment, value: Moment) {
+  return date.isBefore(value, "year");
+};
+
+export function isAfterYear(date: Moment, value: Moment) {
+  return date.isAfter(value, "year");
+};
+
+export function startOfDay(date: Moment) {
+  return date.clone().startOf("day");
+};
+
+export function endOfDay(date: Moment) {
+  return date.clone().endOf("day");
+};
+
+export function format(date: Moment, formatKey: keyof DateFormats) {
+  return formatByString(date, formats[formatKey]);
+};
+
+export function formatByString(date: Moment, formatString: string) {
+  const clonedDate = date.clone();
+  if (locale) {
+    clonedDate.locale(locale);
+  }
+  return clonedDate.format(formatString);
+};
+
+export function formatNumber(numberToFormat: string) {
+  return numberToFormat;
+};
+
+export function getHours(date: Moment) {
+  return date.get("hours");
+};
+
+export function addSeconds(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "seconds")
+    : date.clone().add(count, "seconds");
+};
+
+export function addMinutes(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "minutes")
+    : date.clone().add(count, "minutes");
+};
+
+export function addHours(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "hours")
+    : date.clone().add(count, "hours");
+};
+
+export function addDays(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "days")
+    : date.clone().add(count, "days");
+};
+
+export function addWeeks(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "weeks")
+    : date.clone().add(count, "weeks");
+};
+
+export function addMonths(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "months")
+    : date.clone().add(count, "months");
+};
+
+export function addYears(date: Moment, count: number) {
+  return count < 0
+    ? date.clone().subtract(Math.abs(count), "years")
+    : date.clone().add(count, "years");
+};
+
+export function setHours(date: Moment, count: number) {
+  return date.clone().hours(count);
+};
+
+export function getMinutes(date: Moment) {
+  return date.get("minutes");
+};
+
+export function setMinutes(date: Moment, count: number) {
+  return date.clone().minutes(count);
+};
+
+export function getSeconds(date: Moment) {
+  return date.get("seconds");
+};
+
+export function setSeconds(date: Moment, count: number) {
+  return date.clone().seconds(count);
+};
+
+export function getWeek(date: Moment) {
+  return date.get("week");
+};
+
+export function getMonth(date: Moment) {
+  return date.get("month");
+};
+
+export function getDaysInMonth(date: Moment) {
+  return date.daysInMonth();
+};
+
+export function isSameDay(date: Moment, comparing: Moment) {
+  return date.isSame(comparing, "day");
+};
+
+export function isSameMonth(date: Moment, comparing: Moment) {
+  return date.isSame(comparing, "month");
+};
+
+export function isSameYear(date: Moment, comparing: Moment) {
+  return date.isSame(comparing, "year");
+};
+
+export function isSameHour(date: Moment, comparing: Moment) {
+  return date.isSame(comparing, "hour");
+};
+
+export function setMonth(date: Moment, count: number) {
+  return date.clone().month(count);
+};
+
+export function getMeridiemText(meridiem: "am" | "pm") {
+  if (is12HourCycleInCurrentLocale()) {
+    // AM/PM translation only possible in those who have 12 hour cycle in locale.
+    return moment
+      .localeData(getCurrentLocaleCode())
+      .meridiem(meridiem === "am" ? 0 : 13, 0, false);
+  }
+
+  return meridiem === "am" ? "AM" : "PM"; // fallback for de, ru, ...etc
+};
+
+export function startOfYear(date: Moment) {
+  return date.clone().startOf("year");
+};
+
+export function endOfYear(date: Moment) {
+  return date.clone().endOf("year");
+};
+
+export function startOfMonth(date: Moment) {
+  return date.clone().startOf("month");
+};
+
+export function endOfMonth(date: Moment) {
+  return date.clone().endOf("month");
+};
+
+export function startOfWeek(date: Moment) {
+  return date.clone().startOf("week");
+};
+
+export function endOfWeek(date: Moment) {
+  return date.clone().endOf("week");
+};
+
+export function getNextMonth(date: Moment) {
+  return date.clone().add(1, "month");
+};
+
+export function getPreviousMonth(date: Moment) {
+  return date.clone().subtract(1, "month");
+};
+
+export function getMonthArray(date: Moment) {
+  const firstMonth = date.clone().startOf("year");
+  const monthArray = [firstMonth];
+
+  while (monthArray.length < 12) {
+    const prevMonth = monthArray[monthArray.length - 1];
+    monthArray.push(getNextMonth(prevMonth));
+  }
+
+  return monthArray;
+};
+
+export function getYear(date: Moment) {
+  return date.get("year");
+};
+
+export function setYear(date: Moment, year: number) {
+  return date.clone().set("year", year);
+};
+
+export function getDate(date: Moment) {
+  return date.get("date");
+};
+
+export function setDate(date: Moment, day: number) {
+  return date.clone().set("date", day);
+};
+
+export function mergeDateAndTime(date: Moment, time: Moment) {
+  return date.hour(time.hour()).minute(time.minute()).second(time.second());
+};
+
+export function getWeekdays() {
+  return moment.weekdaysShort(true);
+};
+
+export function isEqual(value: any, comparing: any) {
+  if (value === null && comparing === null) {
+    return true;
+  }
+
+  return moment(value).isSame(comparing);
+};
+
+export function getWeekArray(date: Moment) {
+  const start = date.clone().startOf("month").startOf("week");
+  const end = date.clone().endOf("month").endOf("week");
+
+  let count = 0;
+  let current = start;
+  const nestedWeeks: Moment[][] = [];
+
+  while (current.isBefore(end)) {
+    const weekNumber = Math.floor(count / 7);
+    nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+    nestedWeeks[weekNumber].push(current);
+
+    current = current.clone().add(1, "day");
+    count += 1;
+  }
+
+  return nestedWeeks;
+};
+
+export function getYearRange(start: Moment, end: Moment) {
+  const startDate = moment(start).startOf("year");
+  const endDate = moment(end).endOf("year");
+  const years: Moment[] = [];
+
+  let current = startDate;
+  while (current.isBefore(endDate)) {
+    years.push(current);
+    current = current.clone().add(1, "year");
+  }
+
+  return years;
+};
+
+export function isWithinRange(date: Moment, [start, end]: [Moment, Moment]) {
+  return date.isBetween(start, end, null, "[]");
+};
+
+
+`;
+}
+
+//#endregion
 //#region src/index.ts
 /**
 * A Powerlines plugin to assist in developing other Powerlines plugins.
@@ -19,7 +2008,7 @@ function plugin(options = {}) {
 		name: "date",
 		async config() {
 			this.debug("Providing default configuration for the Powerlines `date` build plugin.");
-			const config = { date: (0, defu.default)(options, { type: "date-fns" }) };
+			const config = { date: defu(options, { type: "date-fns" }) };
 			if (!config.date.type || ![
 				"date-fns",
 				"dayjs",
@@ -41,17 +2030,17 @@ function plugin(options = {}) {
 			let dateModule;
 			switch (this.config.date.type) {
 				case "dayjs":
-					dateModule = require_dayjs.dayjsModule;
+					dateModule = dayjsModule;
 					break;
 				case "luxon":
-					dateModule = require_luxon.luxonModule;
+					dateModule = luxonModule;
 					break;
 				case "moment":
-					dateModule = require_moment.momentModule;
+					dateModule = momentModule;
 					break;
 				case "date-fns":
 				default:
-					dateModule = require_date_fns.dateFnsModule;
+					dateModule = dateFnsModule;
 					break;
 			}
 			await this.emitBuiltin(await Promise.resolve(dateModule(this)), "date");
@@ -61,9 +2050,9 @@ function plugin(options = {}) {
 var src_default = plugin;
 
 //#endregion
-exports.dateFnsModule = require_date_fns.dateFnsModule;
-exports.dayjsModule = require_dayjs.dayjsModule;
+exports.dateFnsModule = dateFnsModule;
+exports.dayjsModule = dayjsModule;
 exports.default = src_default;
-exports.luxonModule = require_luxon.luxonModule;
-exports.momentModule = require_moment.momentModule;
+exports.luxonModule = luxonModule;
+exports.momentModule = momentModule;
 exports.plugin = plugin;