Repository: jama5262/jiffy

Issue:
Update the documentation with better vocabulary
Update the documentation with better vocabulary. Fix some typos and invalid informaion



Fix patch:
diff --git a/README.md b/README.md
index a4053d7d..af3e0b49 100644
--- a/README.md
+++ b/README.md
@@ -87,9 +87,9 @@ Jiffy.parse('1997/9/23')
 ## Locale Support
 ```dart
 // Get current locale code, by default it is en_us
-Jiffy.now().localeCode; // en_us
+Jiffy.now().locale.code; // en_us
 
-//  Setting your preferred locale
+// Setting your preferred locale
 await Jiffy.setLocale('fr_ca');
 Jiffy.now().yMMMMEEEEdjm; // dimanche 26 février 2023 12 h 03
 
@@ -110,7 +110,6 @@ Reach out to me at one of the following places!
 
 - Email me at [jama3137@gmail.com](mailto:jama3137@gmail.com)
 - LinkedIn [Jama Mohamed](https://www.linkedin.com/in/jama-mohamed/)
-- Twitter [timedjama5262](https://twitter.com/timedjama5262)
 
 
 ## License
diff --git a/doc/README.md b/doc/README.md
index 2f10e023..09a102b8 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -4,405 +4,393 @@ Jiffy is a Flutter (Android, IOS and Web) date time
 package for parsing, manipulating, querying and formatting dates
 
 # Parsing
-### Now
-To get the current date time, just call `Jiffy.now()`. 
-This will return a Jiffy instance with the current date time.
+
+Jiffy makes date-time parsing in Dart simple and intuitive. Below are various ways to create and manipulate date-time objects using Jiffy.
+
+## Getting the Current Date-Time
+
+To get the current date-time, use `Jiffy.now()`. This returns a Jiffy instance with the current date-time.
+
 ```dart
 Jiffy.now(); // Returns a Jiffy instance
-Jiffy.now().dateTime; // Returns a dart DateTime.now()
-Jiffy.now().format(); // Return a ISO 8601 date time format
+Jiffy.now().dateTime; // Returns a Dart DateTime.now()
+Jiffy.now().format(); // Returns an ISO 8601 formatted date-time
 ```
 
-### String
-Creating a Jiffy date time by parsing a string.
+## Parsing from Strings
+
+You can create a Jiffy instance by parsing a string representation of a date.
+
 ```dart
-Jiffy.parse('2021-05-25'); // A calendar date part
-Jiffy.parse('2021/05/25'); // A calendar date part separated by slash "/"
-Jiffy.parse('2021-05-25 12:00:00.000'); // An hour, minute, second, and millisecond time part
+Jiffy.parse('2021-05-25'); // Standard date format (YYYY-MM-DD)
+Jiffy.parse('2021/05/25'); // Date format using slashes
+Jiffy.parse('2021-05-25 12:00:00.000'); // Date with time
 Jiffy.parse('2021-05-25T12:00:00.000'); // ISO date format
-Jiffy.parse('2021-05-25T12:00:00.000Z'); // ISO date format (UTC)
+Jiffy.parse('2021-05-25T12:00:00.000Z'); // ISO UTC format
 ```
 
-### String Formatting
-Create a Jiffy date time from a string date time pattern. 
-Use this if you know the format of an input string
+## Parsing with Custom String Patterns
+
+If you know the format of an input string, specify a pattern to parse it correctly.
+
 ```dart
 Jiffy.parse('2021, May 25', pattern: 'yyyy, MMMM dd');
 Jiffy.parse('25-05-2021', pattern: 'dd-MM-yyyy');
 Jiffy.parse('5-2021', pattern: 'MM-yyyy');
 ```
-You can also parse ordinal date formats. The date pattern for the ordinal date is `do`
+
+### Ordinal Date Formats
+
+Jiffy supports ordinal dates (e.g., "1st", "2nd", "3rd"). Use `do` in the pattern:
 
 ```dart
 Jiffy.parse('Jan 19th', pattern: 'MMM do');
 Jiffy.parse('19th January 2021', pattern: 'do MMMM yyyy');
 ```
 
-**_Note: Jiffy runs on top of the [Intl DateFormat](https://pub.dev/packages/intl) 
-package, so you can find all the date time patterns also
-used by Jiffy [here](https://pub.dev/documentation/intl/latest/intl/DateFormat-class.html)_**
+> **Note:** Jiffy is built on top of the [Intl DateFormat](https://pub.dev/packages/intl) package.
+> You can find supported date-time patterns [here](https://pub.dev/documentation/intl/latest/intl/DateFormat-class.html).
 
-This is also same for Jiffy pre-set formats.
-```dart
-Jiffy.now().MMMEd; // Tue, May 25
-Jiffy.parse('2021-05-25', pattern: 'yyyy-MM-dd').yMMMMd; // May 25, 2021
-```
 
-If you want to parse them as `utc` do the following. This will return Jiffy instance in
-UTC date time
+## Parsing in UTC
+
+To parse dates that are already in UTC, set `isUtc: true`:
+
 ```dart
-Jiffy.parse('2021-05-25', isUtc: true)
-Jiffy.parse('2021-05-25', pattern: 'yyyy-MM-dd', isUtc: true)
+Jiffy.parse('2021-05-25', isUtc: true).isUtc; // true
 ```
 
-### DateTime
-Jiffy date time can be created from a dart `DateTime` instance.
+## Parsing from `DateTime`
+
+You can create a Jiffy instance from a Dart `DateTime` object.
+
 ```dart
 var dateTime = DateTime.now();
 Jiffy.parseFromDateTime(dateTime);
-
 Jiffy.parseFromDateTime(DateTime(2021, 5, 25)).yMMMM; // May 2021
 ```
 
-### Jiffy
-Jiffy date time can be created from another `Jiffy` instance.
+## Parsing from Another Jiffy Instance
+
+You can create a Jiffy instance from an existing Jiffy instance.
+
 ```dart
 var jiffy = Jiffy.now();
 Jiffy.parseFromJiffy(jiffy);
 ```
 
-### List
-You can also create Jiffy from a List. But they should mirror the following order
+## Parsing from Lists
+
+Create a Jiffy instance from a list of date components:
+
+But it has to be in the following order
 
 `[ year, month, day, hour, minute, second, millisecond, microsecond ]`
-```dart
-Jiffy.parseFromList([2021]); // January 1st 2021
-Jiffy.parseFromList([2021, 10]); // October 1st 2021
-Jiffy.parseFromList([2021, 10, 19]); // October 19th 2021
-```
 
-If you want to parse them as `utc` do the following. This will return Jiffy instance in
-UTC date time
 ```dart
-Jiffy.parseFromList([2021, 10], isUtc: true);
+Jiffy.parseFromList([2021]); // January 1st, 2021
+Jiffy.parseFromList([2021, 10]); // October 1st, 2021
+Jiffy.parseFromList([2021, 10, 19]); // October 19th, 2021
 ```
 
-### Maps
-You can also create a Jiffy from a Map, Supported key pairs are,
+## Parsing from Maps
+
+Jiffy supports parsing from maps with specific date-time units enum.
 
-`[ Unit.year, Unit.month, Unit.day, Unit.hour, 
-Unit.minute, Unit.second, Unit.millisecond and Unit.microsecond ]`.
+Here are all the units supported
 
-If any of the units are not provided, the current date time will be used
+`[ Unit.year, Unit.month, Unit.day, Unit.hour, Unit.minute, Unit.second, Unit.millisecond and Unit.microsecond ]`.
 
 ```dart
-Jiffy.parseFromMap(
-  {
-    Unit.hour: 19,
-    Unit.minute: 20
-  }
-);
+Jiffy.parseFromMap({
+  Unit.hour: 19,
+  Unit.minute: 20
+}); // January 1st, 2021 19:20:00
 
-Jiffy.parseFromMap(
-  {
-    Unit.year: 2019,
-    Unit.month: 10,
-    Unit.day: 19,
-    Unit.hour: 19
-  }
-);
+Jiffy.parseFromMap({
+  Unit.year: 2019,
+  Unit.month: 10,
+  Unit.day: 19,
+  Unit.hour: 19
+}); // October 19th, 2019 19:00:00
 ```
 
-If you want to parse them as `utc` do the following. This will return Jiffy instance in
-UTC date time
-```dart
-Jiffy.parseFromMap(
-  {
-    Unit.year: 2019,
-    Unit.month: 10,
-    Unit.day: 19,
-    Unit.hour: 19
-  }, 
-  isUtc: true
-);
-```
+## Parsing from Epoch Timestamps
+
+Jiffy supports parsing timestamps in microseconds or milliseconds since epoch time.
 
-### Timestamps since epoch
-Jiffy can also parse timestamp milliseconds and microseconds since epoch.
 ```dart
-// Parsing a timestamp in microseconds since epoch
+// Microseconds since epoch
 Jiffy.parseFromMicrosecondsSinceEpoch(874962000000000); // 1997-09-23 00:00:00.000
 
-// Parsing a timestamp in milliseconds since epoch
+// Milliseconds since epoch
 Jiffy.parseFromMillisecondsSinceEpoch(874962000000); // 1997-09-23 00:00:00.000
 ```
 
-If you want to parse them as `utc` do the following. This will return Jiffy instance in
-UTC date time
-```dart
-// Parsing a timestamp in microseconds since epoch
-Jiffy.parseFromMicrosecondsSinceEpoch(874962000000000, isUtc: true); // 1997-09-22 21:00:00.000Z
+## Cloning Jiffy Instances
 
-// Parsing a timestamp in milliseconds since epoch
-Jiffy.parseFromMillisecondsSinceEpoch(874962000000, isUtc: true); // 1997-09-22 21:00:00.000Z
-```
+You can clone an existing Jiffy instance using `Jiffy.parseFromJiffy` or `.clone()` function.
 
-### Jiffy Cloning
-Jiffy date time can be created from another Jiffy instance, a way of cloning.
 ```dart
 var jiffy1 = Jiffy.parseFromList([2021]);
 var jiffy2 = Jiffy.parseFromJiffy(jiffy1);
+
 jiffy1.add(years: 10);
-jiffy1.year; // 2031
-jiffy2.year; // 2021
+print(jiffy1.year); // 2031
+print(jiffy2.year); // 2021
 ```
 
-Or you can use the clone method itself
+Or using `.clone()`:
+
 ```dart
 var jiffy1 = Jiffy.parseFromList([2021]);
 var jiffy2 = jiffy1.clone();
+
 jiffy1.add(years: 10);
-jiffy1.year; // 2031
-jiffy2.year; // 2021
+print(jiffy1.year); // 2031
+print(jiffy2.year); // 2021
 ```
 
-### UTC
-Get date time in UTC.
+## Converting to UTC
+
+To convert a Jiffy instance to UTC:
+
 ```dart
-// In local time
 var jiffy1 = Jiffy.now();
-jiffy1.format(); // 2021-03-02T14:35:24.363919
+print(jiffy1.isUtc); // false
 
-// Change to UTC
 var jiffy2 = jiffy1.toUtc();
-jiffy2.format(); // 2021-03-02T11:35:24.363919Z
+print(jiffy2.isUtc); // true
 ```
 
 # Get
-### DateTime
-Returns a new `DateTime` instance of the `Jiffy` object.
+
+Jiffy provides various methods to retrieve specific date-time components from a 
+Jiffy instance. Below are the available getters and their respective outputs.
+
+### Get `Dart` Date-Time
+Returns a `DateTime` instance representing the Jiffy object.
 ```dart
 Jiffy.now().dateTime;
 ```
-### Microsecond
-Returns the microsecond ranging from 0 to 999.
+
+### Get Microseconds
+Returns the microsecond part of the time, ranging from 0 to 999.
 ```dart
 Jiffy.now().microsecond;
 ```
-### Microsecond since epoch
-Returns the number of microseconds since epoch time `January 1, 1970, 00:00:00 UTC`.
+
+### Get Microseconds Since Epoch
+Returns the number of microseconds elapsed since the Unix epoch (`January 1, 1970, 00:00:00 UTC`).
 ```dart
 Jiffy.now().microsecondsSinceEpoch;
 ```
-### Millisecond
-Returns the millisecond ranging from 0 to 999.
+
+### Get Milliseconds
+Returns the millisecond part of the time, ranging from 0 to 999.
 ```dart
 Jiffy.now().millisecond;
 ```
-### Millisecond since epoch
-Returns the number of milliseconds since epoch time `January 1, 1970, 00:00:00 UTC`.
+
+### Get Milliseconds Since Epoch
+Returns the number of milliseconds elapsed since the Unix epoch.
 ```dart
 Jiffy.now().millisecondsSinceEpoch;
 ```
-### Second
-Returns the second ranging from 0 to 59.
+
+### Get Seconds
+Returns the second component of the time, ranging from 0 to 59.
 ```dart
 Jiffy.now().second;
 ```
-### Minute
-Returns the minute ranging from 0 to 59.
+
+### Get Minutes
+Returns the minute component of the time, ranging from 0 to 59.
 ```dart
 Jiffy.now().minute;
 ```
-### Hour
-Returns the hour ranging from 0 to 23.
+
+### Get Hours
+Returns the hour component of the time, ranging from 0 to 23.
 ```dart
 Jiffy.now().hour;
 ```
-### Date of month
-Returns the date ranging from 1 to 31.
+
+### Get Day of the Month
+Returns the day of the month, ranging from 1 to 31.
 ```dart
 Jiffy.now().date;
 ```
-### Day of week
-Returns the day of the week according to the 
-locale's start of week. The return value is an integer 
-between 1 and 7, where 1 represents the
-locale start of week, either Saturday, Sunday or Monday
+
+### Get Day of the Week
+Returns the day of the week as an integer (1-7). The value depends on the locale’s start 
+of the week (Saturday, Sunday, or Monday).
+
+More on how to override the default start of week can be found 
+[here](#start-of-week)
 ```dart
 Jiffy.now().dayOfWeek;
 ```
-### Days in a month
-Returns the number of days in the month.
+
+### Get Number of Days in a Month
+Returns the total number of days in the current month
 ```dart
 Jiffy.now().daysInMonth;
 ```
-### Day of year
-Returns the day of the year ranging from 1 to 366, 
-where 1 represents January 1st of the year and 366 represents 
-December 31st of a leap year.
+
+### Get Day of the Year
+Returns the day number of the year, ranging from 1 to 366.
 ```dart
 Jiffy.now().dayOfYear;
 ```
-### Week of year
-Returns the week of the year based on the current 
-locale's start of week. The week of the year ranges from 1 to 53, 
-where week 1 is the first week that has at least 'DateTime.daysPerWeek' days in the new year.
+
+### Get Week of the Year
+Returns the current week number based on the locale’s start of the week. The week of the year ranges from 1 to 53, where week 1 is the first full week of the year.
+
+More on how to override the default start of week can be found
+[here](#start-of-week)
 ```dart
 Jiffy.now().weekOfYear;
 ```
-### Month
-Returns the month of the year ranging from 1 to 12, 
-where 1 represents January and 12 represents December
+
+### Get Month
+Returns the month of the year as an integer (1-12), where 1 represents January and 12 represents December.
 ```dart
 Jiffy.now().month;
 ```
-### Quarter
-Returns the quarter on the year ranging from 1 to 4.
+
+### Get Quarter of the Year
+Returns the quarter of the year as an integer (1-4).
 ```dart
 Jiffy.now().quarter;
 ```
-### Year
-Returns the year.
+
+### Get Year
+Returns the current year as an integer.
 ```dart
 Jiffy.now().year;
 ```
 
 # Manipulation
 
-### Add using Dart's `Duration` object
+Jiffy allows you to manipulate dates by adding, subtracting, or modifying 
+specific time units. Below are various methods for date-time manipulation.
+
+### Add Using Dart's `Duration` Object
+Allows you to add time by specifying a `Duration` object.
 ```dart
 Jiffy.parse('1997/09/23')
   .addDuration(Duration(days: 5, hours: 6))
   .format(); // 1997-09-28T06:00:00.000
 ```
 
-### Add
-This adds time to Jiffy by the following units 
-`years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds`.
+### Add Specific Units
+Adds the specified time units to a Jiffy instance. Supported units: `years, months,
+ weeks, days, hours, minutes, seconds, milliseconds, microseconds`.
 ```dart
 Jiffy.parse('1997/09/23')
     .add(years: 2, months: 3, days: 5)
     .yMMMMd; // December 28, 1999
 ```
 
-### Subtract using Dart's `Duration` object
+### Subtract Using Dart's `Duration` Object
+Allows you to subtract time using a `Duration` object.
 ```dart
 Jiffy.parse('1997/09/23')
-    .subtractDuration(Duration(days: 5, hours: 6))
-    .format(); // 1997-09-17T18:00:00.000
+.subtractDuration(Duration(days: 5, hours: 6))
+.format(); // 1997-09-17T18:00:00.000
 ```
 
-### Subtract
-This subtracts time from Jiffy by the following units 
-`years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds`.
+### Subtract Specific Units
+Subtracts the specified time units from a Jiffy instance. Supported units: `years, 
+months, weeks, days, hours, minutes, seconds, milliseconds, microseconds`.
 ```dart
 Jiffy.parse('1997/09/23')
-    .subtract(years: 2, months: 3, days: 5)
-    .yMMMMd; // June 18, 1995
+.subtract(years: 2, months: 3, days: 5)
+.yMMMMd; // June 18, 1995
 ```
-### Start of Time
-Returns a new Jiffy instance representing the start of the specified
-`unit` of time
 
-The units that are available are,
-
-`[ Unit.microsecond, Unit.millisecond, Unit.second, Unit.minute, 
-Unit.hour, Unit.day, Unit.week, Unit.month, Unit.year ]`
+### Start of Time
+Returns a new Jiffy instance representing the start of the specified `unit` of time.
 
+Available units: `microsecond, millisecond, second, minute, hour, day, week, month, year`
 ```dart
-// Set to now, but with 0 microseconds
 Jiffy.now().startOf(Unit.millisecond); // 2023-02-26T13:28:20.047000
-
-// Set to now, but with 0 milliseconds and microseconds
-Jiffy.now().startOf(Unit.second); // 2023-02-26T13:28:20.00000
-
-// Set to now, but with 0 seconds, milliseconds and microsecond
-Jiffy.now().startOf(Unit.minute); // 2023-02-26T13:28:00.00000
-
-// Set to now, but with 0 minutes, seconds, milliseconds and microseconds
-Jiffy.now().startOf(Unit.hour); // 2023-02-26T13:00:00.00000
-
-// Set to now 12:00 am today
-Jiffy.now().startOf(Unit.day);  // 2023-02-26T00:00:00.00000
-
-// Set to the first day of this week, 12:00 am
-Jiffy.now().startOf(Unit.week); // 2023-02-26T00:00:00.00000
-
-// Set to the first of this month, 12:00 am
-Jiffy.now().startOf(Unit.month); // 2023-02-01T00:00:00.00000
-
-// Set to January 1st, 12:00 am this year
+Jiffy.now().startOf(Unit.second); // 2023-02-26T13:28:20.000000
+Jiffy.now().startOf(Unit.minute); // 2023-02-26T13:28:00.000000
+Jiffy.now().startOf(Unit.hour); // 2023-02-26T13:00:00.000000
+Jiffy.now().startOf(Unit.day); // 2023-02-26T00:00:00.000000
+Jiffy.now().startOf(Unit.week); // 2023-02-26T00:00:00.000000
+Jiffy.now().startOf(Unit.month); // 2023-02-01T00:00:00.000000
 Jiffy.now().startOf(Unit.year); // 2023-01-01T00:00:00.000000
 ```
-Another example
+
+Additional Example:
 ```dart
 Jiffy.now()
     .startOf(Unit.day)
-    .add(days: 1);
+    .add(days: 1)
     .format('MMMM do yyyy, h:mm:ss a'); // March 3rd 2021, 12:00:00 AM
 ```
 
 ### End of Time
-Returns a new Jiffy instance representing the end of the specified unit of time
-
+Returns a new Jiffy instance representing the end of the specified `unit` of time.
 ```dart
 Jiffy.now().endOf(Unit.year);    // Set to December 31st, 23:59:59:999 this year
 Jiffy.now().endOf(Unit.month);   // Set to the end of this month, 23:59:59:999
-Jiffy.now().endOf(Unit.week);    // Set to the end day of this week, 23:59:59:999
+Jiffy.now().endOf(Unit.week);    // Set to the last day of this week, 23:59:59:999
 Jiffy.now().endOf(Unit.day);     // Set to 23:59:59:999 today
 ```
-### To Local
-Sets Jiffy to local time.
+
+### Convert to Local Time
+Sets the Jiffy instance to local time.
 ```dart
-var jiffy = Jiffy.parseFromList([2022]).toUtc(); // Time in utc
-var jiffy = Jiffy.parseFromList([2022], isUtc: true).utc(); // Also time in utc
+var jiffy = Jiffy.parseFromList([2022]).toUtc(); // Time in UTC
 
-jiffy.local(); // Set to local
+jiffy.local(); // Convert to local time
 ```
-### To UTC
-Sets Jiffy to UTC time.
+
+### Convert to UTC Time
+Sets the Jiffy instance to Coordinated Universal Time (UTC).
 ```dart
-var jiffy = Jiffy.now(); // Time in local
+var jiffy = Jiffy.now(); // Time in local timezone
 
-jiffy.toUtc(); // Set to utc
+jiffy.toUtc(); // Convert to UTC
 ```
+
 # Display
+
 ### Format
-**_Note: Jiffy runs on top of the [Intl DateFormat](https://pub.dev/packages/intl) 
-package, so you can find all the date time patterns used 
-by Jiffy [here](https://pub.dev/documentation/intl/latest/intl/DateFormat-class.html)_**
+Jiffy runs on top of the [Intl DateFormat](https://pub.dev/packages/intl) package. You can find all the date-time patterns used by Jiffy [here](https://pub.dev/documentation/intl/latest/intl/DateFormat-class.html).
 ```dart
 Jiffy.now().format('MMMM do yyyy, h:mm:ss a'); // October 19th 2019, 7:00:53 PM
 Jiffy.now().format('EEEE'); // Saturday
 Jiffy.now().format('yyyy [escaped] yyyy'); // 2019 escaped 2019
 
-// Not passing a string pattern to the format method will return an ISO Date format
+// Default format returns an ISO Date
 Jiffy().format(); // 2019-10-19T19:00:53.090646
 ```
-You can also use pre-set formats.
+Pre-set formats can also be used:
 ```dart
 Jiffy.now().yMMMMd; // October 19, 2019
 Jiffy.now().yMMMMEEEEdjm; // Saturday, October 19, 2019 7:00 PM
 ```
+
 ### Time from Now
-This method is used to get the relative time from now.
+Returns the relative time from now.
 ```dart
 Jiffy.parse('2007-01-29').fromNow(); // 14 years ago
 Jiffy.parseFromList([2022, 10, 29]).fromNow(); // in a year
 Jiffy.parseFromDateTime(DateTime(2050, 10, 29)).fromNow(); // in 30 years
-
 Jiffy.now().startOf(Unit.hour).fromNow(); // 9 minutes ago
 ```
-
-You can also omit returning the prefix and suffix like `in` and `ago`.
-
+To omit the `in` and `ago`:
 ```dart
 Jiffy.parse('2007-01-29').fromNow(withPrefixAndSuffix: false); // 14 years
 ```
 
 ### Time from X
-This method is used to get the relative time from a specific date time.
+Gets the relative time from a specific date-time.
 ```dart
 var jiffy1 = Jiffy.parse('2007-01-28');
 var jiffy2 = Jiffy.parse('2017-01-29');
@@ -410,238 +398,150 @@ var jiffy2 = Jiffy.parse('2017-01-29');
 jiffy1.from(jiffy2); // a day ago
 ```
 
-You can also omit returning the prefix and suffix like `in` and `ago`.
-
-```dart
-var jiffy1 = Jiffy.parse('2007-01-28');
-var jiffy2 = Jiffy.parse('2017-01-29');
-
-jiffy1.from(jiffy2, withPrefixAndSuffix: false); // a day
-```
-
 ### Time to Now
-This works opposite to the `fromNow()` method. 
-This method is used to get the relative time to now.
+Works opposite to `fromNow()`, returning the relative time to now.
 ```dart
 Jiffy.parse('2007-01-29').toNow(); // in 14 years
-Jiffy.parseFromList([2022, 10, 29]).toNow(); // a year ago
-Jiffy.parseFromDateTime(DateTime(2050, 10, 29)).toNow(); // 30 years ago
-
-Jiffy.now().startOf(Unit.hour).toNow(); // in 9 minutes
 ```
 
-You can also omit returning the prefix and suffix like `in` and `ago`.
-
-```dart
-Jiffy.parse('2007-01-29').toNow(withPrefixAndSuffix: false); // 14 years
-```
-
-### Time to X
-This works opposite to the `from()` method. 
-This method is used to get the relative time to a specific date time.
-```dart
-var jiffy1 = Jiffy.parse('2007-01-28');
-var jiffy2 = Jiffy.parse('2017-01-29');
-
-jiffy1.to(jiffy2); // in a day
-```
-
-You can also omit returning the prefix and suffix like `in` and `ago`.
-
-```dart
-var jiffy1 = Jiffy.parse('2007-01-28');
-var jiffy2 = Jiffy.parse('2017-01-29');
-
-jiffy1.to(jiffy2, withPrefixAndSuffix: false); // a day
-```
 ### Difference
-Used to get the difference between two Jiffy date times.
+Gets the difference between two Jiffy date-times.
 ```dart
-// By default, diff method, get the difference in microseconds
 var jiffy1 = Jiffy.parse('2017-1-29');
 var jiffy2 = Jiffy.parse('2017-1-28');
 
-jiff1.diff(jiffy2); // 86400000000
+jiffy1.diff(jiffy2); // 86400000000 (microseconds)
 ```
-You can get the difference in another unit of measurement. 
+You can get the difference in another unit of measurement. The default is `Unit.microsecond`.
 The units that are available are,
 
 `[ Unit.microsecond, Unit.millisecond, Unit.second, Unit.minute, 
 Unit.hour, Unit.day, Unit.week, Unit.month, Unit.year ]`
 ```dart
-Jiffy.parseFromList([2007, 1, 28])
-  .diff(Jiffy.parseFromList([2017, 1, 29]), unit: Unit.day); // -3654
+Jiffy.parseFromList([2007, 1, 28]).diff(Jiffy.parseFromList([2017, 1, 29]), unit: Unit.day); // -3654
 ```
-
 Also by default `diff` will truncate the result to return a whole number. 
-To get decimal numbers, just pass a third param `asFloat` to `false`.
+For floating-point values, set `asFloat` to `true`:
 ```dart
 var jiffy1 = Jiffy.parse('2008-10', pattern: 'yyyy-MM');
 var jiffy2 = Jiffy.parse('2007-01', pattern: 'yyyy-MM');
 
-jiffy1.diff(jiffy2, unit: Unit.year); // 1
-jiffy1.diff(jiffy2, unit: Unit.year, asFloat: false); // 1.75
+jiffy1.diff(jiffy2, unit: Unit.year, asFloat: true); // 1.75
 ```
 
 # Query
+
+## Checking DateTime Comparisons with Jiffy
+
 ### Is Before
-Check if date time is before another date time.
+Check if a DateTime is before another DateTime.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
 var jiffy2 = Jiffy.parse("2021-10-21");
 
-jiffy1.isBefore(jiffy2); // true
+print(jiffy1.isBefore(jiffy2)); // true
 ```
 
-You can also check in terms of units of measurement. 
-The below example checks if year is before.
+You can also check in terms of specific time units. The following example checks if a year is before another year:
 ```dart
-var jiffy1 = Jiffy.parseFromList([2020, 10, 20]);
+var jiffy1 = Jiffy.parse("2020-10-20");
 
 var jiffy2 = Jiffy.parse("2020-12-31");
 var jiffy3 = Jiffy.parse("2021-01-01");
 
-jiffy1.isBefore(jiffy2, unit: Unit.year); // false
-jiffy1.isBefore(jiffy3, unit: Unit.year); // true
+print(jiffy1.isBefore(jiffy2, unit: Unit.year)); // false
+print(jiffy1.isBefore(jiffy3, unit: Unit.year)); // true
 ```
 
 ### Is Same
-Check if date time is same with another date time.
+Check if a DateTime is the same as another DateTime.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
 var jiffy2 = Jiffy.parse("2021-10-20");
 
-jiffy1.isSame(jiffy2); // true
+print(jiffy1.isSame(jiffy2)); // true
 ```
 
-You can also check in terms of units of measurement. 
-The below example checks if years are the same.
+Checking by a specific unit, such as the year:
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
 
 var jiffy2 = Jiffy.parse("2020-12-31");
 var jiffy3 = Jiffy.parse("2021-01-01");
 
-jiffy1.isSame(jiffy2, unit: Unit.year); // false
-jiffy1.isSame(jiffy3, unit: Unit.year); // true
+print(jiffy1.isSame(jiffy2, unit: Unit.year)); // false
+print(jiffy1.isSame(jiffy3, unit: Unit.year)); // true
 ```
 
 ### Is After
-Check if date time is after another date time.
+Check if a DateTime is after another DateTime.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
 var jiffy2 = Jiffy.parse("2021-10-19");
 
-jiffy1.isAfter(jiffy2); // true
+print(jiffy1.isAfter(jiffy2)); // true
 ```
 
-You can also check in terms of units of measurement. 
-The below example checks if year is after.
+Checking by a specific unit:
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
-
 var jiffy2 = Jiffy.parse("2021-01-01");
 var jiffy3 = Jiffy.parse("2020-12-31");
 
-jiffy1.isAfter(jiffy2, Unit.year); // false
-jiffy1.isAfter(jiffy3, Unit.year); // true
+print(jiffy1.isAfter(jiffy2, unit: Unit.year)); // false
+print(jiffy1.isAfter(jiffy3, unit: Unit.year)); // true
 ```
 
 ### Is Same or Before
-Check if date time is same or before with another date time.
+Check if a DateTime is the same as or before another DateTime.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
-
 var jiffy2 = Jiffy.parse("2020-12-31");
 var jiffy3 = Jiffy.parse("2021-12-31");
 var jiffy4 = Jiffy.parse("2022-01-01");
 
-jiffy1.isSameOrBefore(jiffy2, Unit.year); // false
-jiffy1.isSameOrBefore(jiffy3, Unit.year); // true
-jiffy1.isSameOrBefore(jiffy4, Unit.year); // true
+print(jiffy1.isSameOrBefore(jiffy2, unit: Unit.year)); // false
+print(jiffy1.isSameOrBefore(jiffy3, unit: Unit.year)); // true
+print(jiffy1.isSameOrBefore(jiffy4, unit: Unit.year)); // true
 ```
+
 ### Is Same or After
-Check if date time is same or after with another date time.
+Check if a DateTime is the same as or after another DateTime.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
-
 var jiffy2 = Jiffy.parse("2022-12-31");
 var jiffy3 = Jiffy.parse("2021-01-01");
 var jiffy4 = Jiffy.parse("2020-12-31");
 
-jiffy1.isSameOrAfter(jiffy2, Unit.year); // false
-jiffy1.isSameOrAfter(jiffy3, Unit.year); // true
-jiffy1.isSameOrAfter(jiffy4, Unit.year); // true
+print(jiffy1.isSameOrAfter(jiffy2, unit: Unit.year)); // false
+print(jiffy1.isSameOrAfter(jiffy3, unit: Unit.year)); // true
+print(jiffy1.isSameOrAfter(jiffy4, unit: Unit.year)); // true
 ```
 
 ### Is Between
-Check if a date time is between two date times.
+Check if a DateTime is between two other DateTimes.
 ```dart
 var jiffy1 = Jiffy.parse("2021-10-20");
-
 var jiffy2 = Jiffy.parse("2021-01-01");
 var jiffy3 = Jiffy.parse("2023-01-01");
-
 var jiffy4 = Jiffy.parse("2020-12-31");
 var jiffy5 = Jiffy.parse("2023-01-01");
 
-jiffy1.isBetween(jiffy2, jiffy3, Unit.year); // false
-jiffy1.isBetween(jiffy4, jiffy5, Unit.year); // true
-```
-
-### Is Local Date Time
-Check if date time is local.
-```dart
-Jiffy.parse("2019", pattern: "yyyy").isLeapYear; // false
-Jiffy.parse("2016", pattern: "yyyy").isLeapYear; // true
+print(jiffy1.isBetween(jiffy2, jiffy3, unit: Unit.year)); // false
+print(jiffy1.isBetween(jiffy4, jiffy5, unit: Unit.year)); // true
 ```
 
-### Is UTC Date Time
-Check if date time is UTC.
+### Is Leap Year
+Check if a year is a leap year.
 ```dart
-Jiffy.parse("2019", pattern: "yyyy").isLeapYear; // false
-Jiffy.parse("2016", pattern: "yyyy").isLeapYear; // true
-```
-
-### Is LeapYear
-Check if date time is a leap year or not.
-```dart
-Jiffy.parse("2019", pattern: "yyyy").isLeapYear; // false
-Jiffy.parse("2016", pattern: "yyyy").isLeapYear; // true
+print(Jiffy.parse("2019", pattern: "yyyy").isLeapYear); // false
+print(Jiffy.parse("2016", pattern: "yyyy").isLeapYear); // true
 ```
 
 # Locale Support
 
-Below are the locales that are supported in Jiffy. More can be added.
-
-| Locale      | Locale Code                                                        |
-|-------------|--------------------------------------------------------------------|
-| English     | en / en_us / en_sg / en_au / en_ca / en_gb / en_ie / en_il / en_nz |
-| Spanish     | es / es_us / es_do                                                 |
-| French      | fr / fr_ch / fr_ca                                                 |
-| Chinese     | zh / zh_cn / zh_hk / zh_tw                                         |
-| Japan       | ja                                                                 |
-| Korean      | ko                                                                 |
-| German      | de / de_de / de_at / de_ch                                         |
-| Italian     | it / it_ch                                                         |
-| Hindi       | hi                                                                 |
-| Bangladesh  | bn                                                                 |
-| Portuguese  | pt / pt_br                                                         |
-| Indonesian  | id                                                                 |
-| Russian     | ru                                                                 |
-| Swedish     | sv                                                                 |
-| Ukrainian   | uk                                                                 |
-| Arabic      | ar / ar_ly / ar_dz / ar_kw / ar_sa / ar_ma /_tn                    |
-| Hungarian   | hu / hu_hu                                                         |
-| Polish      | pl                                                                 |
-| Turkish     | tr                                                                 |
-| Norwegian   | nb                                                                 |
-| Persian     | fa                                                                 |
-| Azerbaijani | az                                                                 |
-| Dutch       | nl                                                                 |
-| Thailand    | th                                                                 |
-| Slovak      | sk                                                                 |
-| Czech       | cs                                                                 |
+Jiffy supports all locales that the [Intl](https://pub.dev/packages/intl) package 
+provides.
 
 ## Setting a locale
 Setting locales in Jiffy **_always returns a future_**
@@ -658,11 +558,163 @@ await Jiffy.setLocale('zh-cn');
 Jiffy.now().yMMMMEEEEdjm; // 2019年10月19日星期六 下午7:28
 ```
 
-## Getting the locale code
+## Advanced locale setting
+
+Jiffy allows for advanced locale configurations, such as overriding default 
+settings for the start of the week, ordinal suffixes, and relative date-time formats.
+
+```dart
+await Jiffy.setLocale(
+  locale: 'en_US',
+  startOfWeek: StartOFWeek.monday,
+  ordinals: Ordinals(first: "st", second: "nd", third: "rd", nth: "th"),
+  relativeDateTime: EnRelativeDateTime()
+);
+```
+
+Let's explore these configurations in more detail.
+
+### Start of week
+The start of week consists of the following `saturday, sunday, monday`. For example, the
+locale `en_US`, the start of week is `StartOfWeek.sunday`.
+
+But sometimes you might want to override this.
+
+```dart
+await Jiffy.setLocale(locale: 'en_US');
+
+final jiffy = Jiffy.now().locale.startOfWeek; // Sunday
+
+// Overriding the start of week
+await Jiffy.setLocale(
+    locale: 'en_US',
+    startOfWeek: StartOFWeek.saturday,
+);
+
+final jiffy = Jiffy.now().locale.startOfWeek; // Saturday
+```
+
+### Ordinals
+An ordinal represents the position or rank of a number in a sequence, often 
+used for dates. In date formatting, ordinals appear as suffixes like st, nd, 
+rd, and th, depending on the number. For example, "1st", "2nd", "3rd", and "4th" 
+follow ordinal rules.
+
+Jiffy already has a list of built-in ordinals for a vast list of supported locales. **_But, 
+there might be situations a specific locale you might require is not supported, hence, 
+when setting a locale, you can provide your own custom ordinals that Jiffy can use, 
+for cases like returning a date time format or when parsing a date time to Jiffy._**
+
+```dart
+await Jiffy.setLocale(
+    locale: 'en_US',
+    ordinals: Ordinals(first: "st", second: "nd", third: "rd", nth: "th"),
+);
+
+// Formating
+final jiffy = Jiffy.now();
+print(jiffy.format("pattern: 'do MMMM yyyy'")); // 19th October 2019
+
+// Parsing
+final jiffy = Jiffy.parse('19th October 2019', pattern: 'do MMMM yyyy');
+print(jiffy.format("pattern: 'do MMMM yyyy'")); // 19th October 2019
+```
+
+### Relative Date Time
+
+As documented [here](#Display), relative date-time is used to express how much time has 
+passed between a given time and the present moment in a human-readable format.
+
+Example
+```dart
+Jiffy.parse('2007-01-29').fromNow(); // 14 years ago
+```
+
+Jiffy provides pre-built relative date-time support for some locales, but not all. 
+To customize this, you can define your own relative date-time formatting by 
+creating a custom class that extends the `RelativeDateTime` abstract class.
+
+```dart
+class CustomRelativeDateTime extends RelativeDateTime {
+  @override
+  String prefixAgo() => '';
+  @override
+  String prefixFromNow() => 'in';
+  @override
+  String suffixAgo() => 'ago';
+  @override
+  String suffixFromNow() => '';
+  @override
+  String lessThanOneMinute(int seconds) => 'a few seconds';
+  @override
+  String aboutAMinute(int minutes) => 'a minute';
+  @override
+  String minutes(int minutes) => '$minutes minutes';
+  @override
+  String aboutAnHour(int minutes) => 'an hour';
+  @override
+  String hours(int hours) => '$hours hours';
+  @override
+  String aDay(int hours) => 'a day';
+  @override
+  String days(int days) => '$days days';
+  @override
+  String aboutAMonth(int days) => 'a month';
+  @override
+  String months(int months) => '$months months';
+  @override
+  String aboutAYear(int year) => 'a year';
+  @override
+  String years(int years) => '$years years';
+  @override
+  String wordSeparator() => ' ';
+}
+
+await Jiffy.setLocale(
+    locale: 'en_US',
+    relativeDateTime: CustomRelativeDateTime(),
+);
+
+var jiffy1 = Jiffy.parse('2007-01-28');
+var jiffy2 = Jiffy.parse('2017-01-29');
+
+jiffy1.from(jiffy2); // a day ago
+```
+
+You can also extend and customize Jiffy's pre-built relative date-time formatting, 
+giving you the option to choose what to override. The example below demonstrates 
+how to create a custom relative date-time class while building upon 
+the existing `EnRelativeDateTime`.
+
+```dart
+class CustomRelativeDateTime extends EnRelativeDateTime {
+  @override
+  String suffixAgo() => 'ago, i think';
+  @override
+  String aDay(int hours) => 'like a day';
+}
+
+await Jiffy.setLocale(
+    locale: 'en_US',
+    relativeDateTime: CustomRelativeDateTime(),
+);
+
+
+var jiffy1 = Jiffy.parse('2007-01-28');
+var jiffy2 = Jiffy.parse('2017-01-29');
+
+jiffy1.from(jiffy2); // like a day ago, i think
+```
+
+## Getting the locale information
 ```dart
-var localeCode = Jiffy.now().localeCode; // eu_us
+final locale = Jiffy.now().locale; // Returns a locale object
+final localeCode = locale.code;
+final localeStartOfWeek = locale.startOfWeek;
+final localeCode = locale.ordinals;
+final localeCode = locale.relativeDateTime;
 ```
 ## Getting a list of supported locales
 ```dart
-final supportLocales = Jiffy.getSupportedLocales(); // ['en_us', 'en', 'fr', ...]
+final supportLocales = Jiffy.getSupportedLocales();
 ```
\ No newline at end of file
diff --git a/lib/src/display.dart b/lib/src/display.dart
index 8aa950b8..be07e1be 100644
--- a/lib/src/display.dart
+++ b/lib/src/display.dart
@@ -24,7 +24,7 @@ class Display {
     final escapedPattern = _replaceEscapePattern(pattern);
     final newPattern = _replaceLocaleOrdinalDatePattern(
         escapedPattern, locale.ordinals.getOrdinal(_getter.date(dateTime)));
-    return DateFormat(newPattern).format(dateTime);
+    return DateFormat(newPattern, locale.code).format(dateTime);
   }
 
   String fromAsRelativeDateTime(DateTime firstDateTime, DateTime secondDateTime,
diff --git a/lib/src/getter.dart b/lib/src/getter.dart
index 214f0fe0..52f55a3a 100644
--- a/lib/src/getter.dart
+++ b/lib/src/getter.dart
@@ -1,6 +1,7 @@
 import 'package:intl/intl.dart';
 
 import 'enums/start_of_week.dart';
+import 'locale/locale.dart';
 import 'query.dart';
 
 class Getter {
@@ -47,19 +48,22 @@ class Getter {
   int daysInMonth(DateTime dateTime) =>
       _daysInMonth(dateTime.year, dateTime.month);
 
-  int weekOfYear(DateTime dateTime, StartOfWeek startOfWeek) {
-    return ((dayOfYear(dateTime) - dayOfWeek(dateTime, startOfWeek) + 10) / 7)
+  int weekOfYear(DateTime dateTime, Locale locale) {
+    return ((dayOfYear(dateTime, locale) -
+                dayOfWeek(dateTime, locale.startOfWeek) +
+                10) /
+            7)
         .floor();
   }
 
   int month(DateTime dateTime) => dateTime.month;
 
-  int quarterOfYear(DateTime dateTime) {
-    return int.parse(DateFormat('Q').format(dateTime));
+  int quarterOfYear(DateTime dateTime, Locale locale) {
+    return int.parse(DateFormat('Q', locale.code).format(dateTime));
   }
 
-  int dayOfYear(DateTime dateTime) {
-    return int.parse(DateFormat('D').format(dateTime));
+  int dayOfYear(DateTime dateTime, Locale locale) {
+    return int.parse(DateFormat('D', locale.code).format(dateTime));
   }
 
   int year(DateTime dateTime) => dateTime.year;
diff --git a/lib/src/jiffy.dart b/lib/src/jiffy.dart
index 8441c8de..6622cf44 100644
--- a/lib/src/jiffy.dart
+++ b/lib/src/jiffy.dart
@@ -327,22 +327,6 @@ class Jiffy {
   /// Returns the [Locale].
   Locale get locale => _locale;
 
-  /// Returns the locale code for the current [Locale].
-  ///
-  /// The locale code is a string identifier that uniquely identifies a
-  /// [Locale]. Examples include "en_US" for English as used in the
-  /// United States, or "fr_CA" for French as used in Canada.
-  @Deprecated("Use the [locale] to get the locale code")
-  String get localeCode => _locale.code;
-
-  /// Returns a [StartOfWeek] enum value indicating the day on which the week
-  /// starts for the current [Locale].
-  ///
-  /// The start of the week can vary by locale, with some starting on Sunday,
-  /// and others starting on Monday or another day of the week.
-  @Deprecated("Use the [locale] to get the locale start of week")
-  StartOfWeek get localeStartOfWeek => _locale.startOfWeek;
-
   /// Creates and returns a new [Jiffy] instance with the same date and time
   /// as the original instance.
   ///
@@ -387,13 +371,16 @@ class Jiffy {
   /// Returns the date ranging from 1 to 31.
   int get date => _getter.date(dateTime);
 
-  /// Returns the day of the week according to the [Locale.startOfWeek].
+  /// Returns the day of the week based on the locale's start of the week.
   ///
-  /// The return value is an integer between 0 and 6, where index 0, is Monday
+  /// The returned value is an integer between 1 and 7, where:
+  /// - `1` corresponds to the start of the week (which could be Saturday,
+  /// Sunday, or Monday depending on the locale).
   ///
-  /// By default, the day of the week is calculated based on the locale provided
-  /// on [Jiffy.setLocale(locale)]. If no locale was set, it uses the
-  /// default `en_US` locale.
+  /// By default, the calculation of the day of the week follows the locale
+  /// set via [Jiffy.setLocale(locale)].
+  /// If no specific locale is set, the default locale `en_US` is used, where
+  /// Sunday is considered the first day of the week.
   int get dayOfWeek => _getter.dayOfWeek(dateTime, _locale.startOfWeek);
 
   /// Returns the number of days in the month.
@@ -404,7 +391,7 @@ class Jiffy {
   /// The returned value is an integer between 1 and 366, inclusive, where 1
   /// represents January 1st of the year and 366 represents December 31st of a
   /// leap year.
-  int get dayOfYear => _getter.dayOfYear(dateTime);
+  int get dayOfYear => _getter.dayOfYear(dateTime, _locale);
 
   /// Returns the week number of the year based on the current [Locale]'s
   /// defined start of the week.
@@ -418,13 +405,13 @@ class Jiffy {
   ///   after January 1st), this method returns `2`.
   /// - In France, where weeks start on Monday, a date falling on a Sunday in
   ///   the first week of the year (6 days after January 1st) would return `1`.
-  int get weekOfYear => _getter.weekOfYear(dateTime, _locale.startOfWeek);
+  int get weekOfYear => _getter.weekOfYear(dateTime, _locale);
 
   /// Returns the month of the year ranging from 1 to 12.
   int get month => _getter.month(dateTime);
 
   /// Returns the quarter on the year ranging from 1 to 4.
-  int get quarter => _getter.quarterOfYear(dateTime);
+  int get quarter => _getter.quarterOfYear(dateTime, _locale);
 
   /// Returns the year.
   int get year => _getter.year(dateTime);
diff --git a/lib/src/parser.dart b/lib/src/parser.dart
index bfc0dda1..3dc61dee 100644
--- a/lib/src/parser.dart
+++ b/lib/src/parser.dart
@@ -19,15 +19,17 @@ class Parser {
             'be blank');
       }
       final ordinals = locale.ordinals;
-      return _parseString(_replaceParseInput(input, ordinals),
+      return _parseString(locale.code, _replaceParseInput(input, ordinals),
               _replacePatternInput(pattern))
           .copyWith(isUtc: isUtc);
     }
 
     if (_matchesHyphenStringDateTime(input)) {
-      return _parseString(input, 'yyyy-MM-dd').copyWith(isUtc: isUtc);
+      return _parseString(locale.code, input, 'yyyy-MM-dd')
+          .copyWith(isUtc: isUtc);
     } else if (_matchesSlashStringDateTime(input)) {
-      return _parseString(input, 'yyyy/MM/dd').copyWith(isUtc: isUtc);
+      return _parseString(locale.code, input, 'yyyy/MM/dd')
+          .copyWith(isUtc: isUtc);
     } else if (_matchesDartStringDateTime(input) ||
         _matchesISOStringDateTime(input)) {
       return DateTime.parse(input).copyWith(isUtc: isUtc);
@@ -71,9 +73,9 @@ class Parser {
         .copyWith(isUtc: isUtc);
   }
 
-  DateTime _parseString(String input, String pattern) {
+  DateTime _parseString(String locale, String input, String pattern) {
     try {
-      return DateFormat(pattern).parse(input);
+      return DateFormat(pattern, locale).parse(input);
     } on FormatException catch (e) {
       throw JiffyException('Could not parse input `$input`, failed with the '
           'following error: ${e.toString()}');


Test patch:
diff --git a/test/src/display_test.dart b/test/src/display_test.dart
index 0982a598..5953e825 100644
--- a/test/src/display_test.dart
+++ b/test/src/display_test.dart
@@ -13,11 +13,12 @@ void main() {
 
   final underTest = Display(getter, manipulator, query);
 
-  final locale = Locale(
-      code: "en",
-      ordinals: Ordinals(first: "st", second: "nd", third: "rd", nth: "th"),
-      startOfWeek: StartOfWeek.sunday,
-      relativeDateTime: EnRelativeDateTime());
+  late Locale locale;
+
+  setUp(() async {
+    Jiffy.setLocale("en");
+    locale = Jiffy.now().locale;
+  });
 
   test('Should successfully format datetime is iso when pattern not provided',
       () {
diff --git a/test/src/getter_test.dart b/test/src/getter_test.dart
index 945d7762..881c89b3 100644
--- a/test/src/getter_test.dart
+++ b/test/src/getter_test.dart
@@ -1,9 +1,16 @@
+import 'package:jiffy/jiffy.dart';
 import 'package:jiffy/src/getter.dart';
-import 'package:jiffy/src/enums/start_of_week.dart';
 import 'package:test/test.dart';
 
+final underTest = Getter();
+
+late Locale locale;
+
 void main() {
-  final underTest = Getter();
+  setUp(() async {
+    Jiffy.setLocale("en_US");
+    locale = Jiffy.now().locale;
+  });
 
   group('Test basic datetime getters', () {
     final dateTime = DateTime(1997, 9, 23, 12, 11, 22, 123, 456);
@@ -134,9 +141,9 @@ void main() {
 
   group('Test getting datetime of', () {
     for (var testData in dayOfWeekTestData()) {
-      test('Should successfully get day of week for locales', () {
+      test('Should successfully get day of week', () {
         // Setup
-        final startOfWeek = StartOfWeek.monday;
+        final startOfWeek = testData['startOfWeek'];
 
         // Execute
         final actualDayOfWeek =
@@ -147,21 +154,11 @@ void main() {
       });
     }
 
-    for (var testData in dayOfWeekWithStartOfWeekTestData()) {
-      test('Should successfully get day of week for locales', () {
-        // Execute
-        final actualDayOfWeek =
-            underTest.dayOfWeek(testData['dateTime'], testData['startOfWeek']);
-
-        // Verify
-        expect(actualDayOfWeek, testData['expectedDayOfWeek']);
-      });
-    }
-
     for (var testData in dayOfYearTestData()) {
       test('Should successfully get day of year', () {
         // Execute
-        final actualDayOfYear = underTest.dayOfYear(testData['dateTime']);
+        final actualDayOfYear =
+            underTest.dayOfYear(testData['dateTime'], locale);
 
         // Verify
         expect(actualDayOfYear, testData['expectedDayOfYear']);
@@ -170,9 +167,13 @@ void main() {
 
     for (var testData in weekOfYearTestData()) {
       test('Should successfully get week of year', () {
+        // Setup
+        Jiffy.setLocale(locale.code, startOfWeek: testData['startOfWeek']);
+        final newLocale = Jiffy.now().locale;
+
         // Execute
         final actualWeekOfYear =
-            underTest.weekOfYear(testData['dateTime'], testData['startOfWeek']);
+            underTest.weekOfYear(testData['dateTime'], newLocale);
 
         // Verify
         expect(actualWeekOfYear, testData['expectedWeekOfYear']);
@@ -183,7 +184,7 @@ void main() {
       test('Should successfully get quarter of year', () {
         // Execute
         final actualQuarterOfYear =
-            underTest.quarterOfYear(testData['dateTime']);
+            underTest.quarterOfYear(testData['dateTime'], locale);
 
         // Verify
         expect(actualQuarterOfYear, testData['expectedQuarterOfYear']);
@@ -211,33 +212,111 @@ void main() {
 }
 
 List<Map<String, dynamic>> dayOfWeekTestData() {
-  return [
-    {'dateTime': DateTime(2022, 12, 5), 'expectedDayOfWeek': 1},
-    {'dateTime': DateTime(2022, 12, 6), 'expectedDayOfWeek': 2},
-    {'dateTime': DateTime(2022, 12, 7), 'expectedDayOfWeek': 3},
-    {'dateTime': DateTime(2022, 12, 8), 'expectedDayOfWeek': 4},
-    {'dateTime': DateTime(2022, 12, 9), 'expectedDayOfWeek': 5},
-    {'dateTime': DateTime(2022, 12, 10), 'expectedDayOfWeek': 6},
-    {'dateTime': DateTime(2022, 12, 11), 'expectedDayOfWeek': 7}
-  ];
-}
-
-List<Map<String, dynamic>> dayOfWeekWithStartOfWeekTestData() {
   return [
     {
       'dateTime': DateTime(2022, 12, 5),
-      'startOfWeek': StartOfWeek.monday,
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 3
+    },
+    {
+      'dateTime': DateTime(2022, 12, 6),
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 4
+    },
+    {
+      'dateTime': DateTime(2022, 12, 7),
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 5
+    },
+    {
+      'dateTime': DateTime(2022, 12, 8),
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 6
+    },
+    {
+      'dateTime': DateTime(2022, 12, 9),
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 7
+    },
+    {
+      'dateTime': DateTime(2022, 12, 10),
+      'startOfWeek': StartOfWeek.saturday,
       'expectedDayOfWeek': 1
     },
     {
-      'dateTime': DateTime(2022, 12, 4),
+      'dateTime': DateTime(2022, 12, 11),
+      'startOfWeek': StartOfWeek.saturday,
+      'expectedDayOfWeek': 2
+    },
+    {
+      'dateTime': DateTime(2022, 12, 5),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 2
+    },
+    {
+      'dateTime': DateTime(2022, 12, 6),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 3
+    },
+    {
+      'dateTime': DateTime(2022, 12, 7),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 4
+    },
+    {
+      'dateTime': DateTime(2022, 12, 8),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 5
+    },
+    {
+      'dateTime': DateTime(2022, 12, 9),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 6
+    },
+    {
+      'dateTime': DateTime(2022, 12, 10),
+      'startOfWeek': StartOfWeek.sunday,
+      'expectedDayOfWeek': 7
+    },
+    {
+      'dateTime': DateTime(2022, 12, 11),
       'startOfWeek': StartOfWeek.sunday,
       'expectedDayOfWeek': 1
     },
     {
-      'dateTime': DateTime(2022, 12, 3),
-      'startOfWeek': StartOfWeek.saturday,
+      'dateTime': DateTime(2022, 12, 5),
+      'startOfWeek': StartOfWeek.monday,
       'expectedDayOfWeek': 1
+    },
+    {
+      'dateTime': DateTime(2022, 12, 6),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 2
+    },
+    {
+      'dateTime': DateTime(2022, 12, 7),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 3
+    },
+    {
+      'dateTime': DateTime(2022, 12, 8),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 4
+    },
+    {
+      'dateTime': DateTime(2022, 12, 9),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 5
+    },
+    {
+      'dateTime': DateTime(2022, 12, 10),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 6
+    },
+    {
+      'dateTime': DateTime(2022, 12, 11),
+      'startOfWeek': StartOfWeek.monday,
+      'expectedDayOfWeek': 7
     }
   ];
 }
diff --git a/test/src/jiffy_test.dart b/test/src/jiffy_test.dart
index 428a4cda..3a64a3e0 100644
--- a/test/src/jiffy_test.dart
+++ b/test/src/jiffy_test.dart
@@ -13,7 +13,7 @@ class UpdatedJpRelativeDateTime extends JaRelativeDateTime {
 
 void main() {
   setUp(() async {
-    Jiffy.setLocale("en_US");
+    Jiffy.setLocale("en");
   });
 
   group('Test parsing and creating a Jiffy instance', () {
@@ -291,20 +291,6 @@ void main() {
           "some months ago");
     });
 
-    test('Should successfully get locale code', () async {
-      // Setup
-      await Jiffy.setLocale('ja');
-      final jiffy = Jiffy.now();
-
-      final expectedLocaleCode = 'ja';
-
-      // Execute
-      final actualLocaleCode = jiffy.localeCode;
-
-      // Verify
-      expect(actualLocaleCode, expectedLocaleCode);
-    });
-
     group('Test available locales', () {
       test('Should successfully return a list of available locales', () {
         // Setup
@@ -321,20 +307,6 @@ void main() {
       });
     });
 
-    test('Should successfully get start of week', () async {
-      // Setup
-      await Jiffy.setLocale('ja');
-      final jiffy = Jiffy.now();
-
-      final expectedStartOfWeek = StartOfWeek.sunday;
-
-      // Execute
-      final actualLocaleStartOfWeek = jiffy.localeStartOfWeek;
-
-      // Verify
-      expect(actualLocaleStartOfWeek, expectedStartOfWeek);
-    });
-
     test('Should throw Jiffy exception if locale is not supported', () async {
       // Setup
       final unknownLocaleCode = 'unknown_locale';
diff --git a/test/src/parser_test.dart b/test/src/parser_test.dart
index 7e4f69b9..5f747b33 100644
--- a/test/src/parser_test.dart
+++ b/test/src/parser_test.dart
@@ -8,11 +8,12 @@ void main() {
   final getter = Getter();
   final underTest = Parser(getter);
 
-  final locale = Locale(
-      code: "en",
-      ordinals: Ordinals(first: "st", second: "nd", third: "rd", nth: "th"),
-      startOfWeek: StartOfWeek.sunday,
-      relativeDateTime: EnRelativeDateTime());
+  late Locale locale;
+
+  setUp(() async {
+    Jiffy.setLocale("en");
+    locale = Jiffy.now().locale;
+  });
 
   group('Test parsing datetime from string', () {
     for (var testData in fromStringWithPatternTestData()) {