@kikiutils/shared 18.0.1 → 18.1.0

package/dist/buffer.d.ts

@@ -2,36 +2,34 @@ import { BinaryInput } from "./types/index.js";
 import { Buffer } from "node:buffer";
 //#region src/buffer.d.ts
 /**
- * Converts various binary data types to a Node.js Buffer.
+ * Converts binary input to a Node.js `Buffer`.
  *
- * This function provides a unified, efficient way to convert different binary formats
- * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
- * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
- * optimal performance.
+ * @remarks
+ * An existing `Buffer` is returned unchanged. `ArrayBuffer` and `Uint8Array` inputs share their backing memory
+ * with the result, so changes are visible through both views. `Blob` and `File` inputs are read asynchronously.
  *
- * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
- * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
+ * @param input - The binary data to convert.
  *
- * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
+ * @returns A promise resolving to the original buffer or a new buffer view after the input is available.
+ *
+ * @throws TypeError through promise rejection if the input is unsupported.
  *
  * @example
- * ```typescript
- * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // From ArrayBuffer
- * const ab = new ArrayBuffer(8);
- * const bufferFromAB = await toBuffer(ab);
+ * ```ts
+ * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // From Uint8Array (Zero-copy)
- * const u8 = new Uint8Array([10, 20, 30]);
- * const bufferFromU8 = await toBuffer(u8);
+ * const bytes = new Uint8Array([
+ *     10,
+ *     20,
+ *     30,
+ * ]);
  *
- * // From Blob or File
- * const blob = new Blob(['data'], { type: 'text/plain' });
- * const bufferFromBlob = await toBuffer(blob);
+ * const buffer = await toBuffer(bytes);
+ * bytes[0] = 40;
+ * console.log(buffer[0]); // => 40
  * ```
  */
-declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;
+export declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;
 //#endregion
-export { toBuffer };
 //# sourceMappingURL=buffer.d.ts.map

package/dist/buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCsB,SAAS,OAAO,cAAW,QAAA,OAAA"}
+{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCsB,SAAS,OAAO,cAAW,QAAA,OAAA"}

package/dist/buffer.js

@@ -1,33 +1,32 @@
 import { Buffer } from "node:buffer";
 //#region src/buffer.ts
 /**
-* Converts various binary data types to a Node.js Buffer.
+* Converts binary input to a Node.js `Buffer`.
 *
-* This function provides a unified, efficient way to convert different binary formats
-* (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
-* It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
-* optimal performance.
+* @remarks
+* An existing `Buffer` is returned unchanged. `ArrayBuffer` and `Uint8Array` inputs share their backing memory
+* with the result, so changes are visible through both views. `Blob` and `File` inputs are read asynchronously.
 *
-* @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
-* Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
+* @param input - The binary data to convert.
 *
-* @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
+* @returns A promise resolving to the original buffer or a new buffer view after the input is available.
+*
+* @throws TypeError through promise rejection if the input is unsupported.
 *
 * @example
-* ```typescript
-* import { toBuffer } from '@kikiutils/shared/buffer';
 *
-* // From ArrayBuffer
-* const ab = new ArrayBuffer(8);
-* const bufferFromAB = await toBuffer(ab);
+* ```ts
+* import { toBuffer } from '@kikiutils/shared/buffer';
 *
-* // From Uint8Array (Zero-copy)
-* const u8 = new Uint8Array([10, 20, 30]);
-* const bufferFromU8 = await toBuffer(u8);
+* const bytes = new Uint8Array([
+*     10,
+*     20,
+*     30,
+* ]);
 *
-* // From Blob or File
-* const blob = new Blob(['data'], { type: 'text/plain' });
-* const bufferFromBlob = await toBuffer(blob);
+* const buffer = await toBuffer(bytes);
+* bytes[0] = 40;
+* console.log(buffer[0]); // => 40
 * ```
 */
 async function toBuffer(input) {

package/dist/buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Converts various binary data types to a Node.js Buffer.\n *\n * This function provides a unified, efficient way to convert different binary formats\n * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.\n * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure\n * optimal performance.\n *\n * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.\n * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.\n *\n * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/buffer';\n *\n * // From ArrayBuffer\n * const ab = new ArrayBuffer(8);\n * const bufferFromAB = await toBuffer(ab);\n *\n * // From Uint8Array (Zero-copy)\n * const u8 = new Uint8Array([10, 20, 30]);\n * const bufferFromU8 = await toBuffer(u8);\n *\n * // From Blob or File\n * const blob = new Blob(['data'], { type: 'text/plain' });\n * const bufferFromBlob = await toBuffer(blob);\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    if (input instanceof ArrayBuffer) return Buffer.from(input);\n    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);\n    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());\n    // eslint-disable-next-line style/max-len\n    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,SAAS,OAAoB;CAC/C,IAAI,OAAO,SAAS,KAAK,GAAG,OAAO;CACnC,IAAI,iBAAiB,aAAa,OAAO,OAAO,KAAK,KAAK;CAC1D,IAAI,iBAAiB,YAAY,OAAO,OAAO,KAAK,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;CACpG,IAAI,OAAO,MAAM,gBAAgB,YAAY,OAAO,OAAO,KAAK,MAAM,MAAM,YAAY,CAAC;CAEzF,MAAM,IAAI,UAAU,qGAAqG;AAC7H"}
+{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Converts binary input to a Node.js `Buffer`.\n *\n * @remarks\n * An existing `Buffer` is returned unchanged. `ArrayBuffer` and `Uint8Array` inputs share their backing memory\n * with the result, so changes are visible through both views. `Blob` and `File` inputs are read asynchronously.\n *\n * @param input - The binary data to convert.\n *\n * @returns A promise resolving to the original buffer or a new buffer view after the input is available.\n *\n * @throws TypeError through promise rejection if the input is unsupported.\n *\n * @example\n *\n * ```ts\n * import { toBuffer } from '@kikiutils/shared/buffer';\n *\n * const bytes = new Uint8Array([\n *     10,\n *     20,\n *     30,\n * ]);\n *\n * const buffer = await toBuffer(bytes);\n * bytes[0] = 40;\n * console.log(buffer[0]); // => 40\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    if (input instanceof ArrayBuffer) return Buffer.from(input);\n    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);\n    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());\n    // eslint-disable-next-line style/max-len\n    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,eAAsB,SAAS,OAAoB;CAC/C,IAAI,OAAO,SAAS,KAAK,GAAG,OAAO;CACnC,IAAI,iBAAiB,aAAa,OAAO,OAAO,KAAK,KAAK;CAC1D,IAAI,iBAAiB,YAAY,OAAO,OAAO,KAAK,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;CACpG,IAAI,OAAO,MAAM,gBAAgB,YAAY,OAAO,OAAO,KAAK,MAAM,MAAM,YAAY,CAAC;CAEzF,MAAM,IAAI,UAAU,qGAAqG;AAC7H"}

package/dist/classes/enhanced-date.d.ts

@@ -0,0 +1,425 @@
+import * as dateFns from "date-fns";
+//#region src/classes/enhanced-date.d.ts
+/**
+ * A mutable calendar date with chainable date-fns operations.
+ *
+ * @remarks
+ * Inherits the native constructor, including zero-based month arguments and millisecond timestamps.
+ * Native methods retain their original behavior.
+ * Mutating arithmetic and boundary methods update this instance and return `this`;
+ * their `to`-prefixed counterparts return a new `EnhancedDate` instead.
+ * Invalid dates, parsing, rounding, and week defaults follow date-fns semantics.
+ * Operations use the system time zone unless configured through date-fns options.
+ * Day and week arithmetic uses calendar days, preserving local wall-clock time across daylight saving changes.
+ * Hour, minute, second, and millisecond arithmetic uses elapsed durations. Month and year arithmetic clamps
+ * to the last valid day of the destination month. Native setters retain their native overflow behavior.
+ * Exceptions from date-fns propagate unchanged, and operations can preserve or produce `Invalid Date`.
+ *
+ * When used in Vue state, prefer replacing the value with a `to`-prefixed result:
+ * mutating a Date's internal timestamp does not trigger reactive updates.
+ *
+ * @example
+ *
+ * ```ts
+ * import { EnhancedDate } from '@kikiutils/shared/classes/enhanced-date';
+ *
+ * const date = new EnhancedDate('2026-01-31T12:00:00Z');
+ * const nextMonth = date.toAddMonths(1); // Original date is unchanged.
+ * date.addDays(1).startOfDay(); // Mutates the original date.
+ * nextMonth.isAfter(date);
+ * ```
+ */
+export declare class EnhancedDate extends Date {
+  /**
+   * Returns a new instance at the end of today in the system time zone.
+   */
+  static endOfToday(): EnhancedDate;
+  /**
+   * Parses a date using date-fns and an explicit reference for missing fields.
+   *
+   * @param value - Date string to parse.
+   * @param pattern - date-fns parsing pattern.
+   * @param referenceDate - Reference for fields absent from the pattern.
+   * @param options - Options passed to `date-fns/parse`.
+   *
+   * @returns A new `EnhancedDate`, including `Invalid Date` for invalid values.
+   */
+  static fromFormat(value: string, pattern: string, referenceDate: dateFns.DateArg<Date>, options?: dateFns.ParseOptions): EnhancedDate;
+  /**
+   * Parses an ISO 8601 string using date-fns, including its partial-date support.
+   *
+   * @param value - ISO date string.
+   * @param options - Options passed to `date-fns/parseISO`.
+   *
+   * @returns A new `EnhancedDate`, or `Invalid Date` when parsing fails.
+   */
+  static fromISO(value: string, options?: dateFns.ParseISOOptions): EnhancedDate;
+  /**
+   * Creates a date from Unix seconds; native constructor numbers remain milliseconds.
+   *
+   * @param seconds - Seconds since the Unix epoch.
+   */
+  static fromUnixSeconds(seconds: number): EnhancedDate;
+  /**
+   * Returns a new instance at the start of today in the system time zone.
+   */
+  static startOfToday(): EnhancedDate;
+  /**
+   * Adds the specified number of days in place using date-fns.
+   *
+   * @param amount - Number of days.
+   *
+   * @returns This instance for chaining.
+   */
+  addDays(amount: number): this;
+  /**
+   * Adds the specified number of hours in place using date-fns.
+   *
+   * @param amount - Number of hours.
+   *
+   * @returns This instance for chaining.
+   */
+  addHours(amount: number): this;
+  /**
+   * Adds the specified number of milliseconds in place using date-fns.
+   *
+   * @param amount - Number of milliseconds.
+   *
+   * @returns This instance for chaining.
+   */
+  addMilliseconds(amount: number): this;
+  /**
+   * Adds the specified number of minutes in place using date-fns.
+   *
+   * @param amount - Number of minutes.
+   *
+   * @returns This instance for chaining.
+   */
+  addMinutes(amount: number): this;
+  /**
+   * Adds the specified number of months in place using date-fns.
+   *
+   * @param amount - Number of months.
+   *
+   * @returns This instance for chaining.
+   */
+  addMonths(amount: number): this;
+  /**
+   * Adds the specified number of seconds in place using date-fns.
+   *
+   * @param amount - Number of seconds.
+   *
+   * @returns This instance for chaining.
+   */
+  addSeconds(amount: number): this;
+  /**
+   * Adds the specified number of weeks in place using date-fns.
+   *
+   * @param amount - Number of weeks.
+   *
+   * @returns This instance for chaining.
+   */
+  addWeeks(amount: number): this;
+  /**
+   * Adds the specified number of years in place using date-fns.
+   *
+   * @param amount - Number of years.
+   *
+   * @returns This instance for chaining.
+   */
+  addYears(amount: number): this;
+  /**
+   * Returns a new `EnhancedDate` with the same timestamp, including `Invalid Date`.
+   */
+  clone(): EnhancedDate;
+  /**
+   * Returns the signed difference in calendar days: this date minus the other date.
+   *
+   * @remarks
+   * Defaults and rounding follow date-fns.
+   */
+  differenceInCalendarDays(other: dateFns.DateArg<Date>): number;
+  /**
+   * Returns the signed difference in calendar weeks: this date minus the other date.
+   *
+   * @remarks
+   * Defaults and rounding follow date-fns.
+   */
+  differenceInCalendarWeeks(other: dateFns.DateArg<Date>, options?: dateFns.DifferenceInCalendarWeeksOptions): number;
+  /**
+   * Returns the signed difference in full minutes: this date minus the other date.
+   *
+   * @remarks
+   * Defaults and rounding follow date-fns.
+   */
+  differenceInMinutes(other: dateFns.DateArg<Date>, options?: dateFns.DifferenceInMinutesOptions): number;
+  /**
+   * Moves this date to the end of its day in place.
+   *
+   * @returns This instance for chaining.
+   */
+  endOfDay(): this;
+  /**
+   * Moves this date to the end of its minute in place.
+   *
+   * @returns This instance for chaining.
+   */
+  endOfMinute(): this;
+  /**
+   * Moves this date to the end of its month in place.
+   *
+   * @returns This instance for chaining.
+   */
+  endOfMonth(): this;
+  /**
+   * Moves this date to the end of its week in place.
+   *
+   * @param options - date-fns week options; defaults are unchanged.
+   *
+   * @returns This instance for chaining.
+   */
+  endOfWeek(options?: dateFns.EndOfWeekOptions): this;
+  /**
+   * Formats this date using a date-fns pattern (default: `yyyy-MM-dd HH:mm:ss`) and optional locale/options.
+   *
+   * @remarks
+   * Invalid dates and invalid patterns retain date-fns error behavior.
+   */
+  format(pattern?: string, options?: dateFns.FormatOptions): string;
+  /**
+   * Formats the distance from this date to now using date-fns.
+   */
+  formatDistanceToNow(options?: dateFns.FormatDistanceToNowOptions): string;
+  /**
+   * Returns Unix seconds using date-fns; `getTime()` returns milliseconds.
+   */
+  getUnixTime(): number;
+  /**
+   * Checks whether this date occurs after the other date.
+   */
+  isAfter(other: dateFns.DateArg<Date>): boolean;
+  /**
+   * Checks whether this date occurs before the other date.
+   */
+  isBefore(other: dateFns.DateArg<Date>): boolean;
+  /**
+   * Checks whether this date has the same timestamp as the other date.
+   */
+  isEqual(other: dateFns.DateArg<Date>): boolean;
+  /**
+   * Checks whether this date is after the current time.
+   */
+  isFuture(): boolean;
+  /**
+   * Checks whether this date falls on the same calendar day as the other date.
+   */
+  isSameDay(other: dateFns.DateArg<Date>): boolean;
+  /**
+   * Checks whether this date falls in the same calendar minute as the other date.
+   */
+  isSameMinute(other: dateFns.DateArg<Date>): boolean;
+  /**
+   * Checks whether this date falls on today.
+   */
+  isToday(): boolean;
+  /**
+   * Checks whether this date falls on tomorrow.
+   */
+  isTomorrow(): boolean;
+  /**
+   * Checks whether this date has a valid timestamp.
+   */
+  isValid(): boolean;
+  /**
+   * Moves this date to the start of its day in place.
+   *
+   * @returns This instance for chaining.
+   */
+  startOfDay(): this;
+  /**
+   * Moves this date to the start of its minute in place.
+   *
+   * @returns This instance for chaining.
+   */
+  startOfMinute(): this;
+  /**
+   * Moves this date to the start of its month in place.
+   *
+   * @returns This instance for chaining.
+   */
+  startOfMonth(): this;
+  /**
+   * Moves this date to the start of its week in place.
+   *
+   * @param options - date-fns week options; defaults are unchanged.
+   *
+   * @returns This instance for chaining.
+   */
+  startOfWeek(options?: dateFns.StartOfWeekOptions): this;
+  /**
+   * Subtracts the specified number of days in place using date-fns.
+   *
+   * @param amount - Number of days.
+   *
+   * @returns This instance for chaining.
+   */
+  subDays(amount: number): this;
+  /**
+   * Subtracts the specified number of hours in place using date-fns.
+   *
+   * @param amount - Number of hours.
+   *
+   * @returns This instance for chaining.
+   */
+  subHours(amount: number): this;
+  /**
+   * Subtracts the specified number of milliseconds in place using date-fns.
+   *
+   * @param amount - Number of milliseconds.
+   *
+   * @returns This instance for chaining.
+   */
+  subMilliseconds(amount: number): this;
+  /**
+   * Subtracts the specified number of minutes in place using date-fns.
+   *
+   * @param amount - Number of minutes.
+   *
+   * @returns This instance for chaining.
+   */
+  subMinutes(amount: number): this;
+  /**
+   * Subtracts the specified number of months in place using date-fns.
+   *
+   * @param amount - Number of months.
+   *
+   * @returns This instance for chaining.
+   */
+  subMonths(amount: number): this;
+  /**
+   * Subtracts the specified number of seconds in place using date-fns.
+   *
+   * @param amount - Number of seconds.
+   *
+   * @returns This instance for chaining.
+   */
+  subSeconds(amount: number): this;
+  /**
+   * Subtracts the specified number of weeks in place using date-fns.
+   *
+   * @param amount - Number of weeks.
+   *
+   * @returns This instance for chaining.
+   */
+  subWeeks(amount: number): this;
+  /**
+   * Subtracts the specified number of years in place using date-fns.
+   *
+   * @param amount - Number of years.
+   *
+   * @returns This instance for chaining.
+   */
+  subYears(amount: number): this;
+  /**
+   * Returns a new instance with days added, leaving this date unchanged.
+   */
+  toAddDays(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with hours added, leaving this date unchanged.
+   */
+  toAddHours(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with milliseconds added, leaving this date unchanged.
+   */
+  toAddMilliseconds(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with minutes added, leaving this date unchanged.
+   */
+  toAddMinutes(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with months added, leaving this date unchanged.
+   */
+  toAddMonths(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with seconds added, leaving this date unchanged.
+   */
+  toAddSeconds(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with weeks added, leaving this date unchanged.
+   */
+  toAddWeeks(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with years added, leaving this date unchanged.
+   */
+  toAddYears(amount: number): EnhancedDate;
+  /**
+   * Returns a new plain native Date; mutations are not shared with this instance.
+   */
+  toDate(): Date;
+  /**
+   * Returns a new instance at the end of this day, leaving this date unchanged.
+   */
+  toEndOfDay(): EnhancedDate;
+  /**
+   * Returns a new instance at the end of this minute, leaving this date unchanged.
+   */
+  toEndOfMinute(): EnhancedDate;
+  /**
+   * Returns a new instance at the end of this month, leaving this date unchanged.
+   */
+  toEndOfMonth(): EnhancedDate;
+  /**
+   * Returns a new instance at the end of this week, leaving this date unchanged.
+   */
+  toEndOfWeek(options?: dateFns.EndOfWeekOptions): EnhancedDate;
+  /**
+   * Returns a new instance at the start of this day, leaving this date unchanged.
+   */
+  toStartOfDay(): EnhancedDate;
+  /**
+   * Returns a new instance at the start of this minute, leaving this date unchanged.
+   */
+  toStartOfMinute(): EnhancedDate;
+  /**
+   * Returns a new instance at the start of this month, leaving this date unchanged.
+   */
+  toStartOfMonth(): EnhancedDate;
+  /**
+   * Returns a new instance at the start of this week, leaving this date unchanged.
+   */
+  toStartOfWeek(options?: dateFns.StartOfWeekOptions): EnhancedDate;
+  /**
+   * Returns a new instance with days subtracted, leaving this date unchanged.
+   */
+  toSubDays(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with hours subtracted, leaving this date unchanged.
+   */
+  toSubHours(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with milliseconds subtracted, leaving this date unchanged.
+   */
+  toSubMilliseconds(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with minutes subtracted, leaving this date unchanged.
+   */
+  toSubMinutes(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with months subtracted, leaving this date unchanged.
+   */
+  toSubMonths(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with seconds subtracted, leaving this date unchanged.
+   */
+  toSubSeconds(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with weeks subtracted, leaving this date unchanged.
+   */
+  toSubWeeks(amount: number): EnhancedDate;
+  /**
+   * Returns a new instance with years subtracted, leaving this date unchanged.
+   */
+  toSubYears(amount: number): EnhancedDate;
+}
+//#endregion
+//# sourceMappingURL=enhanced-date.d.ts.map

package/dist/classes/enhanced-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-date.d.ts","names":[],"sources":["../../src/classes/enhanced-date.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,qBAAqB;;;;SAMvB,cAAU;;;;;;;;;;;SAcV,WACH,eACA,iBACA,eAAe,QAAQ,QAAQ,OAC/B,UAAU,QAAQ,eAAY;;;;;;;;;SAa3B,QAAQ,eAAe,UAAU,QAAQ,kBAAe;;;;;;SASxD,gBAAgB,kBAAe;;;;SAO/B,gBAAY;;;;;;;;EAanB,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,SAAK;;;;;;;EAUL,yBAAyB,OAAO,QAAQ,QAAQ;;;;;;;EAUhD,0BAA0B,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;;EAU1E,oBAAoB,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;EASpE;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,UAAU,UAAU,QAAQ;;;;;;;EAW5B,OAAO,kBAAyC,UAAU,QAAQ;;;;EAOlE,oBAAoB,UAAU,QAAQ;;;;EAOtC;;;;EAOA,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B,SAAS,OAAO,QAAQ,QAAQ;;;;EAOhC,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B;;;;EAOA,UAAU,OAAO,QAAQ,QAAQ;;;;EAOjC,aAAa,OAAO,QAAQ,QAAQ;;;;EAOpC;;;;EAOA;;;;EAOA;;;;;;EASA;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,YAAY,UAAU,QAAQ;;;;;;;;EAY9B,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc;;;;EAOzB,UAAM;;;;EAON,cAAU;;;;EAOV,iBAAa;;;;EAOb,gBAAY;;;;EAOZ,YAAY,UAAU,QAAQ,mBAAgB;;;;EAO9C,gBAAY;;;;EAOZ,mBAAe;;;;EAOf,kBAAc;;;;EAOd,cAAc,UAAU,QAAQ,qBAAkB;;;;EAOlD,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc"}