@checkdigit/time 1.0.0

package/dist/date-fns/nextThursday/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @name nextThursday
+ * @category Weekday Helpers
+ * @summary When is the next Thursday?
+ *
+ * @description
+ * When is the next Thursday?
+ *
+ * @param date - the date to start counting from
+ * @returns the next Thursday
+ *
+ * @example
+ * // When is the next Thursday after Mar, 22, 2020?
+ * const result = nextThursday(new Date(2020, 2, 22))
+ * //=> Thur Mar 26 2020 00:00:00
+ */
+export default function nextThursday<DateType extends Date>(date: DateType | number): DateType;

package/dist/date-fns/nextTuesday/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @name nextTuesday
+ * @category Weekday Helpers
+ * @summary When is the next Tuesday?
+ *
+ * @description
+ * When is the next Tuesday?
+ *
+ * @param date - the date to start counting from
+ * @returns the next Tuesday
+ *
+ * @example
+ * // When is the next Tuesday after Mar, 22, 2020?
+ * const result = nextTuesday(new Date(2020, 2, 22))
+ * //=> Tue Mar 24 2020 00:00:00
+ */
+export default function nextTuesday<DateType extends Date>(date: DateType | number): DateType;

package/dist/date-fns/nextWednesday/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @name nextWednesday
+ * @category Weekday Helpers
+ * @summary When is the next Wednesday?
+ *
+ * @description
+ * When is the next Wednesday?
+ *
+ * @param date - the date to start counting from
+ * @returns the next Wednesday
+ *
+ * @example
+ * // When is the next Wednesday after Mar, 22, 2020?
+ * const result = nextWednesday(new Date(2020, 2, 22))
+ * //=> Wed Mar 25 2020 00:00:00
+ */
+export default function nextWednesday<DateType extends Date>(date: DateType | number): DateType;

package/dist/date-fns/parse/_lib/Parser.d.ts

@@ -0,0 +1,15 @@
+import type { Match } from '../../locale/types';
+import { ValueSetter } from './Setter';
+import type { ParseFlags, ParseResult, ParserOptions } from './types';
+export declare abstract class Parser<Value> {
+    abstract incompatibleTokens: string[] | '*';
+    abstract priority: number;
+    subPriority?: number;
+    run(dateString: string, token: string, match: Match, options: ParserOptions): {
+        setter: ValueSetter<Value>;
+        rest: string;
+    } | null;
+    protected abstract parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<Value>;
+    protected validate<DateType extends Date>(_utcDate: DateType, _value: Value, _options: ParserOptions): boolean;
+    protected abstract set<DateType extends Date>(date: DateType, flags: ParseFlags, value: Value, options: ParserOptions): DateType | [DateType, ParseFlags];
+}

package/dist/date-fns/parse/_lib/Setter.d.ts

@@ -0,0 +1,21 @@
+import type { ParseFlags, ParserOptions } from './types';
+export declare abstract class Setter {
+    abstract priority: number;
+    subPriority: number;
+    validate<DateType extends Date>(_utcDate: DateType, _options?: ParserOptions): boolean;
+    abstract set<DateType extends Date>(utcDate: DateType, flags: ParseFlags, options: ParserOptions): DateType | [DateType, ParseFlags];
+}
+export declare class ValueSetter<Value> extends Setter {
+    private value;
+    private validateValue;
+    private setValue;
+    priority: number;
+    constructor(value: Value, validateValue: <DateType extends Date>(utcDate: DateType, value: Value, options: ParserOptions) => boolean, setValue: <DateType extends Date>(utcDate: DateType, flags: ParseFlags, value: Value, options: ParserOptions) => DateType | [DateType, ParseFlags], priority: number, subPriority?: number);
+    validate<DateType extends Date>(date: DateType, options: ParserOptions): boolean;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, options: ParserOptions): DateType | [DateType, ParseFlags];
+}
+export declare class DateToSystemTimezoneSetter extends Setter {
+    priority: number;
+    subPriority: number;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags): DateType;
+}

package/dist/date-fns/parse/_lib/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const numericPatterns: {
+    month: RegExp;
+    date: RegExp;
+    dayOfYear: RegExp;
+    week: RegExp;
+    hour23h: RegExp;
+    hour24h: RegExp;
+    hour11h: RegExp;
+    hour12h: RegExp;
+    minute: RegExp;
+    second: RegExp;
+    singleDigit: RegExp;
+    twoDigits: RegExp;
+    threeDigits: RegExp;
+    fourDigits: RegExp;
+    anyDigitsSigned: RegExp;
+    singleDigitSigned: RegExp;
+    twoDigitsSigned: RegExp;
+    threeDigitsSigned: RegExp;
+    fourDigitsSigned: RegExp;
+};
+export declare const timezonePatterns: {
+    basicOptionalMinutes: RegExp;
+    basic: RegExp;
+    basicOptionalSeconds: RegExp;
+    extended: RegExp;
+    extendedOptionalSeconds: RegExp;
+};

package/dist/date-fns/parse/_lib/parsers/AMPMMidnightParser.d.ts

@@ -0,0 +1,9 @@
+import type { LocaleDayPeriod, Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class AMPMMidnightParser extends Parser<LocaleDayPeriod> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/AMPMParser.d.ts

@@ -0,0 +1,9 @@
+import type { LocaleDayPeriod, Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class AMPMParser extends Parser<LocaleDayPeriod> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/DateParser.d.ts

@@ -0,0 +1,11 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class DateParser extends Parser<number> {
+    priority: number;
+    subPriority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/DayOfYearParser.d.ts

@@ -0,0 +1,11 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class DayOfYearParser extends Parser<number> {
+    priority: number;
+    subpriority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/DayParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+export declare class DayParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/DayPeriodParser.d.ts

@@ -0,0 +1,9 @@
+import type { LocaleDayPeriod, Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class DayPeriodParser extends Parser<LocaleDayPeriod> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/EraParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import type { Era } from '../../../types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class EraParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<Era>;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ExtendedYearParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ExtendedYearParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/FractionOfSecondParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class FractionOfSecondParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/Hour0To11Parser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class Hour0To11Parser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/Hour0to23Parser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class Hour0to23Parser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/Hour1To24Parser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class Hour1To24Parser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/Hour1to12Parser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class Hour1to12Parser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ISODayParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ISODayParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ISOTimezoneParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ISOTimezoneParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ISOTimezoneWithZParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ISOWeekParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ISOWeekParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/ISOWeekYearParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class ISOWeekYearParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/LocalDayParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+export declare class LocalDayParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/LocalWeekParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+export declare class LocalWeekParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/LocalWeekYearParser.d.ts

@@ -0,0 +1,11 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import type { YearParserValue } from './YearParser';
+export declare class LocalWeekYearParser extends Parser<YearParserValue> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<YearParserValue>;
+    validate<DateType extends Date>(_date: DateType, value: YearParserValue): boolean;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, value: YearParserValue, options: ParserOptions): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/MinuteParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class MinuteParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/MonthParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class MonthParser extends Parser<number> {
+    incompatibleTokens: string[];
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+}

package/dist/date-fns/parse/_lib/parsers/QuarterParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class QuarterParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/SecondParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class SecondParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/StandAloneLocalDayParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+export declare class StandAloneLocalDayParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/StandAloneMonthParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class StandAloneMonthParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/StandAloneQuarterParser.d.ts

@@ -0,0 +1,10 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class StandAloneQuarterParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string, token: string, match: Match): ParseResult<number>;
+    validate<DateType extends Date>(_date: DateType, value: number): boolean;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
+    incompatibleTokens: string[];
+}

package/dist/date-fns/parse/_lib/parsers/TimestampMillisecondsParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class TimestampMillisecondsParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): [DateType, ParseFlags];
+    incompatibleTokens: "*";
+}

package/dist/date-fns/parse/_lib/parsers/TimestampSecondsParser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export declare class TimestampSecondsParser extends Parser<number> {
+    priority: number;
+    parse(dateString: string): ParseResult<number>;
+    set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): [DateType, ParseFlags];
+    incompatibleTokens: "*";
+}

package/dist/date-fns/parse/_lib/parsers/YearParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+export interface YearParserValue {
+    year: number;
+    isTwoDigitYear: boolean;
+}
+export declare class YearParser extends Parser<YearParserValue> {
+    priority: number;
+    incompatibleTokens: string[];
+    parse(dateString: string, token: string, match: Match): ParseResult<YearParserValue>;
+    validate<DateType extends Date>(_date: DateType, value: YearParserValue): boolean;
+    set<DateType extends Date>(date: DateType, flags: ParseFlags, value: YearParserValue): DateType;
+}

package/dist/date-fns/parse/_lib/parsers/index.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '../Parser';
+export declare const parsers: Record<string, Parser<any>>;

package/dist/date-fns/parse/_lib/types.d.ts

@@ -0,0 +1,10 @@
+import type { LocaleOptions, FirstWeekContainsDateOptions, WeekStartOptions } from '../../types';
+export interface ParseFlags {
+    timestampIsSet?: boolean;
+    era?: number;
+}
+export declare type ParserOptions = Required<LocaleOptions & FirstWeekContainsDateOptions & WeekStartOptions>;
+export declare type ParseResult<TValue> = {
+    value: TValue;
+    rest: string;
+} | null;

package/dist/date-fns/parse/_lib/utils.d.ts

@@ -0,0 +1,11 @@
+import type { LocaleDayPeriod } from '../../locale/types';
+import type { ParseResult } from './types';
+export declare function mapValue<TInput, TResult>(parseFnResult: ParseResult<TInput>, mapFn: (value: TInput) => TResult): ParseResult<TResult>;
+export declare function parseNumericPattern(pattern: RegExp, dateString: string): ParseResult<number>;
+export declare function parseTimezonePattern(pattern: RegExp, dateString: string): ParseResult<number>;
+export declare function parseAnyDigitsSigned(dateString: string): ParseResult<number>;
+export declare function parseNDigits(n: number, dateString: string): ParseResult<number>;
+export declare function parseNDigitsSigned(n: number, dateString: string): ParseResult<number>;
+export declare function dayPeriodEnumToHours(dayPeriod: LocaleDayPeriod): number;
+export declare function normalizeTwoDigitYear(twoDigitYear: number, currentYear: number): number;
+export declare function isLeapYearIndex(year: number): boolean;