effect 3.10.19 → 3.11.0

package/src/DateTime.ts

@@ -1,31 +1,25 @@
 /**
  * @since 3.6.0
  */
-import { IllegalArgumentException } from "./Cause.js"
-import * as Clock from "./Clock.js"
+import type { IllegalArgumentException } from "./Cause.js"
 import * as Context from "./Context.js"
-import * as Duration from "./Duration.js"
+import type * as Duration from "./Duration.js"
 import * as Effect from "./Effect.js"
-import * as Either from "./Either.js"
-import * as Equal from "./Equal.js"
-import * as Equivalence_ from "./Equivalence.js"
-import type { LazyArg } from "./Function.js"
-import { dual, pipe } from "./Function.js"
-import { globalValue } from "./GlobalValue.js"
-import * as Hash from "./Hash.js"
-import * as Inspectable from "./Inspectable.js"
+import type * as Either from "./Either.js"
+import type * as equivalence from "./Equivalence.js"
+import { dual, type LazyArg } from "./Function.js"
+import type { Inspectable } from "./Inspectable.js"
+import * as Internal from "./internal/dateTime.js"
 import * as Layer from "./Layer.js"
-import * as Option from "./Option.js"
-import * as order from "./Order.js"
-import { type Pipeable, pipeArguments } from "./Pipeable.js"
-import * as Predicate from "./Predicate.js"
-import type { Mutable } from "./Types.js"
+import type * as Option from "./Option.js"
+import type * as order from "./Order.js"
+import type { Pipeable } from "./Pipeable.js"
 
 /**
  * @since 3.6.0
  * @category type ids
  */
-export const TypeId: unique symbol = Symbol.for("effect/DateTime")
+export const TypeId: unique symbol = Internal.TypeId
 
 /**
  * @since 3.6.0
@@ -168,7 +162,7 @@ export declare namespace DateTime {
    * @since 3.6.0
    * @category models
    */
-  export interface Proto extends Pipeable, Inspectable.Inspectable {
+  export interface Proto extends Pipeable, Inspectable {
     readonly [TypeId]: TypeId
   }
 }
@@ -177,7 +171,7 @@ export declare namespace DateTime {
  * @since 3.6.0
  * @category type ids
  */
-export const TimeZoneTypeId: unique symbol = Symbol.for("effect/DateTime/TimeZone")
+export const TimeZoneTypeId: unique symbol = Internal.TimeZoneTypeId
 
 /**
  * @since 3.6.0
@@ -200,7 +194,7 @@ export declare namespace TimeZone {
    * @since 3.6.0
    * @category models
    */
-  export interface Proto extends Inspectable.Inspectable {
+  export interface Proto extends Inspectable {
     readonly [TimeZoneTypeId]: TimeZoneTypeId
   }
 
@@ -225,109 +219,6 @@ export declare namespace TimeZone {
   }
 }
 
-const Proto = {
-  [TypeId]: TypeId,
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  [Inspectable.NodeInspectSymbol](this: DateTime) {
-    return this.toString()
-  },
-  toJSON(this: DateTime) {
-    return toDateUtc(this).toJSON()
-  }
-}
-
-const ProtoUtc = {
-  ...Proto,
-  _tag: "Utc",
-  [Hash.symbol](this: Utc) {
-    return Hash.cached(this, Hash.number(this.epochMillis))
-  },
-  [Equal.symbol](this: Utc, that: unknown) {
-    return isDateTime(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis
-  },
-  toString(this: Utc) {
-    return `DateTime.Utc(${toDateUtc(this).toJSON()})`
-  }
-}
-
-const ProtoZoned = {
-  ...Proto,
-  _tag: "Zoned",
-  [Hash.symbol](this: Zoned) {
-    return pipe(
-      Hash.number(this.epochMillis),
-      Hash.combine(Hash.hash(this.zone)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](this: Zoned, that: unknown) {
-    return isDateTime(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis &&
-      Equal.equals(this.zone, that.zone)
-  },
-  toString(this: Zoned) {
-    return `DateTime.Zoned(${formatIsoZoned(this)})`
-  }
-}
-
-const ProtoTimeZone = {
-  [TimeZoneTypeId]: TimeZoneTypeId,
-  [Inspectable.NodeInspectSymbol](this: TimeZone) {
-    return this.toString()
-  }
-}
-
-const ProtoTimeZoneNamed = {
-  ...ProtoTimeZone,
-  _tag: "Named",
-  [Hash.symbol](this: TimeZone.Named) {
-    return Hash.cached(this, Hash.string(`Named:${this.id}`))
-  },
-  [Equal.symbol](this: TimeZone.Named, that: unknown) {
-    return isTimeZone(that) && that._tag === "Named" && this.id === that.id
-  },
-  toString(this: TimeZone.Named) {
-    return `TimeZone.Named(${this.id})`
-  },
-  toJSON(this: TimeZone.Named) {
-    return {
-      _id: "TimeZone",
-      _tag: "Named",
-      id: this.id
-    }
-  }
-}
-
-const ProtoTimeZoneOffset = {
-  ...ProtoTimeZone,
-  _tag: "Offset",
-  [Hash.symbol](this: TimeZone.Offset) {
-    return Hash.cached(this, Hash.string(`Offset:${this.offset}`))
-  },
-  [Equal.symbol](this: TimeZone.Offset, that: unknown) {
-    return isTimeZone(that) && that._tag === "Offset" && this.offset === that.offset
-  },
-  toString(this: TimeZone.Offset) {
-    return `TimeZone.Offset(${offsetToString(this.offset)})`
-  },
-  toJSON(this: TimeZone.Offset) {
-    return {
-      _id: "TimeZone",
-      _tag: "Offset",
-      offset: this.offset
-    }
-  }
-}
-
-const makeZonedProto = (epochMillis: number, zone: TimeZone, partsUtc?: DateTime.PartsWithWeekday): Zoned => {
-  const self = Object.create(ProtoZoned)
-  self.epochMillis = epochMillis
-  self.zone = zone
-  self.partsUtc = partsUtc
-  return self
-}
-
 // =============================================================================
 // guards
 // =============================================================================
@@ -336,39 +227,37 @@ const makeZonedProto = (epochMillis: number, zone: TimeZone, partsUtc?: DateTime
  * @since 3.6.0
  * @category guards
  */
-export const isDateTime = (u: unknown): u is DateTime => Predicate.hasProperty(u, TypeId)
-
-const isDateTimeArgs = (args: IArguments) => isDateTime(args[0])
+export const isDateTime: (u: unknown) => u is DateTime = Internal.isDateTime
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZone = (u: unknown): u is TimeZone => Predicate.hasProperty(u, TimeZoneTypeId)
+export const isTimeZone: (u: unknown) => u is TimeZone = Internal.isTimeZone
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZoneOffset = (u: unknown): u is TimeZone.Offset => isTimeZone(u) && u._tag === "Offset"
+export const isTimeZoneOffset: (u: unknown) => u is TimeZone.Offset = Internal.isTimeZoneOffset
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isTimeZoneNamed = (u: unknown): u is TimeZone.Named => isTimeZone(u) && u._tag === "Named"
+export const isTimeZoneNamed: (u: unknown) => u is TimeZone.Named = Internal.isTimeZoneNamed
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isUtc = (self: DateTime): self is Utc => self._tag === "Utc"
+export const isUtc: (self: DateTime) => self is Utc = Internal.isUtc
 
 /**
  * @since 3.6.0
  * @category guards
  */
-export const isZoned = (self: DateTime): self is Zoned => self._tag === "Zoned"
+export const isZoned: (self: DateTime) => self is Zoned = Internal.isZoned
 
 // =============================================================================
 // instances
@@ -378,17 +267,13 @@ export const isZoned = (self: DateTime): self is Zoned => self._tag === "Zoned"
  * @since 3.6.0
  * @category instances
  */
-export const Equivalence: Equivalence_.Equivalence<DateTime> = Equivalence_.make((a, b) =>
-  a.epochMillis === b.epochMillis
-)
+export const Equivalence: equivalence.Equivalence<DateTime> = Internal.Equivalence
 
 /**
  * @since 3.6.0
  * @category instances
  */
-export const Order: order.Order<DateTime> = order.make((self, that) =>
-  self.epochMillis < that.epochMillis ? -1 : self.epochMillis > that.epochMillis ? 1 : 0
-)
+export const Order: order.Order<DateTime> = Internal.Order
 
 /**
  * @since 3.6.0
@@ -402,18 +287,12 @@ export const clamp: {
    * @since 3.6.0
    */
   (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): DateTime
-} = order.clamp(Order)
+} = Internal.clamp
 
 // =============================================================================
 // constructors
 // =============================================================================
 
-const makeUtc = (epochMillis: number): Utc => {
-  const self = Object.create(ProtoUtc)
-  self.epochMillis = epochMillis
-  return self
-}
-
 /**
  * Create a `DateTime` from a `Date`.
  *
@@ -422,13 +301,7 @@ const makeUtc = (epochMillis: number): Utc => {
  * @since 3.6.0
  * @category constructors
  */
-export const unsafeFromDate = (date: Date): Utc => {
-  const epochMillis = date.getTime()
-  if (Number.isNaN(epochMillis)) {
-    throw new IllegalArgumentException("Invalid date")
-  }
-  return makeUtc(epochMillis)
-}
+export const unsafeFromDate: (date: Date) => Utc = Internal.unsafeFromDate
 
 /**
  * Create a `DateTime` from one of the following:
@@ -455,18 +328,7 @@ export const unsafeFromDate = (date: Date): Utc => {
  * DateTime.unsafeMake("2024-01-01")
  * ```
  */
-export const unsafeMake = <A extends DateTime.Input>(input: A): DateTime.PreserveZone<A> => {
-  if (isDateTime(input)) {
-    return input as DateTime.PreserveZone<A>
-  } else if (input instanceof Date) {
-    return unsafeFromDate(input) as DateTime.PreserveZone<A>
-  } else if (typeof input === "object") {
-    const date = new Date(0)
-    setPartsDate(date, input)
-    return unsafeFromDate(date) as DateTime.PreserveZone<A>
-  }
-  return unsafeFromDate(new Date(input)) as DateTime.PreserveZone<A>
-}
+export const unsafeMake: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A> = Internal.unsafeMake
 
 /**
  * Create a `DateTime.Zoned` using `DateTime.unsafeMake` and a time zone.
@@ -484,34 +346,10 @@ export const unsafeMake = <A extends DateTime.Input>(input: A): DateTime.Preserv
  * DateTime.unsafeMakeZoned(new Date(), { timeZone: "Europe/London" })
  * ```
  */
-export const unsafeMakeZoned = (input: DateTime.Input, options?: {
+export const unsafeMakeZoned: (input: DateTime.Input, options?: {
   readonly timeZone?: number | string | TimeZone | undefined
   readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => {
-  if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
-    return input
-  }
-  const self = unsafeMake(input)
-  let zone: TimeZone
-  if (options?.timeZone === undefined) {
-    const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
-    zone = zoneMakeOffset(offset)
-  } else if (isTimeZone(options?.timeZone)) {
-    zone = options.timeZone
-  } else if (typeof options?.timeZone === "number") {
-    zone = zoneMakeOffset(options.timeZone)
-  } else {
-    const parsedZone = zoneFromString(options.timeZone)
-    if (Option.isNone(parsedZone)) {
-      throw new IllegalArgumentException(`Invalid time zone: ${options.timeZone}`)
-    }
-    zone = parsedZone.value
-  }
-  if (options?.adjustForTimeZone !== true) {
-    return makeZonedProto(self.epochMillis, zone, self.partsUtc)
-  }
-  return makeZonedFromAdjusted(self.epochMillis, zone)
-}
+}) => Zoned = Internal.unsafeMakeZoned
 
 /**
  * Create a `DateTime.Zoned` using `DateTime.make` and a time zone.
@@ -535,7 +373,7 @@ export const makeZoned: (
     readonly timeZone?: number | string | TimeZone | undefined
     readonly adjustForTimeZone?: boolean | undefined
   }
-) => Option.Option<Zoned> = Option.liftThrowable(unsafeMakeZoned)
+) => Option.Option<Zoned> = Internal.makeZoned
 
 /**
  * Create a `DateTime` from one of the following:
@@ -564,10 +402,7 @@ export const makeZoned: (
  * DateTime.make("2024-01-01")
  * ```
  */
-export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Option
-  .liftThrowable(unsafeMake)
-
-const zonedStringRegex = /^(.{17,35})\[(.+)\]$/
+export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Internal.make
 
 /**
  * Create a `DateTime.Zoned` from a string.
@@ -577,15 +412,7 @@ const zonedStringRegex = /^(.{17,35})\[(.+)\]$/
  * @since 3.6.0
  * @category constructors
  */
-export const makeZonedFromString = (input: string): Option.Option<Zoned> => {
-  const match = zonedStringRegex.exec(input)
-  if (match === null) {
-    const offset = parseOffset(input)
-    return offset !== null ? makeZoned(input, { timeZone: offset }) : Option.none()
-  }
-  const [, isoString, timeZone] = match
-  return makeZoned(isoString, { timeZone })
-}
+export const makeZonedFromString: (input: string) => Option.Option<Zoned> = Internal.makeZonedFromString
 
 /**
  * Get the current time using the `Clock` service and convert it to a `DateTime`.
@@ -601,7 +428,7 @@ export const makeZonedFromString = (input: string): Option.Option<Zoned> => {
  * })
  * ```
  */
-export const now: Effect.Effect<Utc> = Effect.map(Clock.currentTimeMillis, makeUtc)
+export const now: Effect.Effect<Utc> = Internal.now
 
 /**
  * Get the current time using `Date.now`.
@@ -609,7 +436,7 @@ export const now: Effect.Effect<Utc> = Effect.map(Clock.currentTimeMillis, makeU
  * @since 3.6.0
  * @category constructors
  */
-export const unsafeNow: LazyArg<Utc> = () => makeUtc(Date.now())
+export const unsafeNow: LazyArg<Utc> = Internal.unsafeNow
 
 // =============================================================================
 // time zones
@@ -691,12 +518,7 @@ export const setZone: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, zone: TimeZone, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned =>
-  options?.adjustForTimeZone === true
-    ? makeZonedFromAdjusted(self.epochMillis, zone)
-    : makeZonedProto(self.epochMillis, zone, self.partsUtc))
+} = Internal.setZone
 
 /**
  * Add a fixed offset time zone to a `DateTime`.
@@ -769,35 +591,7 @@ export const setZoneOffset: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, offset: number, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => setZone(self, zoneMakeOffset(offset), options))
-
-const validZoneCache = globalValue("effect/DateTime/validZoneCache", () => new Map<string, TimeZone.Named>())
-
-const formatOptions: Intl.DateTimeFormatOptions = {
-  day: "numeric",
-  month: "numeric",
-  year: "numeric",
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric",
-  timeZoneName: "longOffset",
-  fractionalSecondDigits: 3,
-  hourCycle: "h23"
-}
-
-const zoneMakeIntl = (format: Intl.DateTimeFormat): TimeZone.Named => {
-  const zoneId = format.resolvedOptions().timeZone
-  if (validZoneCache.has(zoneId)) {
-    return validZoneCache.get(zoneId)!
-  }
-  const zone = Object.create(ProtoTimeZoneNamed)
-  zone.id = zoneId
-  zone.format = format
-  validZoneCache.set(zoneId, zone)
-  return zone
-}
+} = Internal.setZoneOffset
 
 /**
  * Attempt to create a named time zone from a IANA time zone identifier.
@@ -807,21 +601,7 @@ const zoneMakeIntl = (format: Intl.DateTimeFormat): TimeZone.Named => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneUnsafeMakeNamed = (zoneId: string): TimeZone.Named => {
-  if (validZoneCache.has(zoneId)) {
-    return validZoneCache.get(zoneId)!
-  }
-  try {
-    return zoneMakeIntl(
-      new Intl.DateTimeFormat("en-US", {
-        ...formatOptions,
-        timeZone: zoneId
-      })
-    )
-  } catch (_) {
-    throw new IllegalArgumentException(`Invalid time zone: ${zoneId}`)
-  }
-}
+export const zoneUnsafeMakeNamed: (zoneId: string) => TimeZone.Named = Internal.zoneUnsafeMakeNamed
 
 /**
  * Create a fixed offset time zone.
@@ -829,11 +609,7 @@ export const zoneUnsafeMakeNamed = (zoneId: string): TimeZone.Named => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeOffset = (offset: number): TimeZone.Offset => {
-  const zone = Object.create(ProtoTimeZoneOffset)
-  zone.offset = offset
-  return zone
-}
+export const zoneMakeOffset: (offset: number) => TimeZone.Offset = Internal.zoneMakeOffset
 
 /**
  * Create a named time zone from a IANA time zone identifier. If the time zone
@@ -842,9 +618,7 @@ export const zoneMakeOffset = (offset: number): TimeZone.Offset => {
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Option.liftThrowable(
-  zoneUnsafeMakeNamed
-)
+export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Internal.zoneMakeNamed
 
 /**
  * Create a named time zone from a IANA time zone identifier. If the time zone
@@ -853,11 +627,8 @@ export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> =
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeNamedEffect = (zoneId: string): Effect.Effect<TimeZone.Named, IllegalArgumentException> =>
-  Effect.try({
-    try: () => zoneUnsafeMakeNamed(zoneId),
-    catch: (e) => e as IllegalArgumentException
-  })
+export const zoneMakeNamedEffect: (zoneId: string) => Effect.Effect<TimeZone.Named, IllegalArgumentException> =
+  Internal.zoneMakeNamedEffect
 
 /**
  * Create a named time zone from the system's local time zone.
@@ -865,9 +636,7 @@ export const zoneMakeNamedEffect = (zoneId: string): Effect.Effect<TimeZone.Name
  * @since 3.6.0
  * @category time zones
  */
-export const zoneMakeLocal = (): TimeZone.Named => zoneMakeIntl(new Intl.DateTimeFormat("en-US", formatOptions))
-
-const offsetZoneRegex = /^(?:GMT|[+-])/
+export const zoneMakeLocal: () => TimeZone.Named = Internal.zoneMakeLocal
 
 /**
  * Try parse a TimeZone from a string
@@ -875,13 +644,7 @@ const offsetZoneRegex = /^(?:GMT|[+-])/
  * @since 3.6.0
  * @category time zones
  */
-export const zoneFromString = (zone: string): Option.Option<TimeZone> => {
-  if (offsetZoneRegex.test(zone)) {
-    const offset = parseOffset(zone)
-    return offset === null ? Option.none() : Option.some(zoneMakeOffset(offset))
-  }
-  return zoneMakeNamed(zone)
-}
+export const zoneFromString: (zone: string) => Option.Option<TimeZone> = Internal.zoneFromString
 
 /**
  * Format a `TimeZone` as a string.
@@ -899,12 +662,7 @@ export const zoneFromString = (zone: string): Option.Option<TimeZone> => {
  * DateTime.zoneToString(DateTime.zoneUnsafeMakeNamed("Europe/London"))
  * ```
  */
-export const zoneToString = (self: TimeZone): string => {
-  if (self._tag === "Offset") {
-    return offsetToString(self.offset)
-  }
-  return self.id
-}
+export const zoneToString: (self: TimeZone) => string = Internal.zoneToString
 
 /**
  * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
@@ -971,12 +729,7 @@ export const setZoneNamed: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Option.Option<Zoned>
-} = dual(
-  isDateTimeArgs,
-  (self: DateTime, zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-  }): Option.Option<Zoned> => Option.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
-)
+} = Internal.setZoneNamed
 
 /**
  * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
@@ -1043,9 +796,7 @@ export const unsafeSetZoneNamed: {
       readonly adjustForTimeZone?: boolean | undefined
     }
   ): Zoned
-} = dual(isDateTimeArgs, (self: DateTime, zoneId: string, options?: {
-  readonly adjustForTimeZone?: boolean | undefined
-}): Zoned => setZone(self, zoneUnsafeMakeNamed(zoneId), options))
+} = Internal.unsafeSetZoneNamed
 
 // =============================================================================
 // comparisons
@@ -1125,7 +876,7 @@ export const distance: {
    * ```
    */
   (self: DateTime, other: DateTime): number
-} = dual(2, (self: DateTime, other: DateTime): number => toEpochMillis(other) - toEpochMillis(self))
+} = Internal.distance
 
 /**
  * Calulate the difference between two `DateTime` values.
@@ -1211,12 +962,7 @@ export const distanceDurationEither: {
    * ```
    */
   (self: DateTime, other: DateTime): Either.Either<Duration.Duration, Duration.Duration>
-} = dual(2, (self: DateTime, other: DateTime): Either.Either<Duration.Duration, Duration.Duration> => {
-  const diffMillis = distance(self, other)
-  return diffMillis > 0
-    ? Either.right(Duration.millis(diffMillis))
-    : Either.left(Duration.millis(-diffMillis))
-})
+} = Internal.distanceDurationEither
 
 /**
  * Calulate the distance between two `DateTime` values.
@@ -1275,10 +1021,7 @@ export const distanceDuration: {
    * ```
    */
   (self: DateTime, other: DateTime): Duration.Duration
-} = dual(
-  2,
-  (self: DateTime, other: DateTime): Duration.Duration => Duration.millis(Math.abs(distance(self, other)))
-)
+} = Internal.distanceDuration
 
 /**
  * @since 3.6.0
@@ -1295,7 +1038,7 @@ export const min: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): DateTime
-} = order.min(Order)
+} = Internal.min
 
 /**
  * @since 3.6.0
@@ -1312,7 +1055,7 @@ export const max: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): DateTime
-} = order.max(Order)
+} = Internal.max
 
 /**
  * @since 3.6.0
@@ -1329,7 +1072,7 @@ export const greaterThan: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.greaterThan(Order)
+} = Internal.greaterThan
 
 /**
  * @since 3.6.0
@@ -1346,7 +1089,7 @@ export const greaterThanOrEqualTo: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.greaterThanOrEqualTo(Order)
+} = Internal.greaterThanOrEqualTo
 
 /**
  * @since 3.6.0
@@ -1363,7 +1106,7 @@ export const lessThan: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.lessThan(Order)
+} = Internal.lessThan
 
 /**
  * @since 3.6.0
@@ -1380,7 +1123,7 @@ export const lessThanOrEqualTo: {
    * @category comparisons
    */
   (self: DateTime, that: DateTime): boolean
-} = order.lessThanOrEqualTo(Order)
+} = Internal.lessThanOrEqualTo
 
 /**
  * @since 3.6.0
@@ -1397,31 +1140,31 @@ export const between: {
    * @category comparisons
    */
   (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): boolean
-} = order.between(Order)
+} = Internal.between
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const isFuture = (self: DateTime): Effect.Effect<boolean> => Effect.map(now, lessThan(self))
+export const isFuture: (self: DateTime) => Effect.Effect<boolean> = Internal.isFuture
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const unsafeIsFuture = (self: DateTime): boolean => lessThan(unsafeNow(), self)
+export const unsafeIsFuture: (self: DateTime) => boolean = Internal.unsafeIsFuture
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const isPast = (self: DateTime): Effect.Effect<boolean> => Effect.map(now, greaterThan(self))
+export const isPast: (self: DateTime) => Effect.Effect<boolean> = Internal.isPast
 
 /**
  * @since 3.6.0
  * @category comparisons
  */
-export const unsafeIsPast = (self: DateTime): boolean => greaterThan(unsafeNow(), self)
+export const unsafeIsPast: (self: DateTime) => boolean = Internal.unsafeIsPast
 
 // =============================================================================
 // conversions
@@ -1433,7 +1176,7 @@ export const unsafeIsPast = (self: DateTime): boolean => greaterThan(unsafeNow()
  * @since 3.6.0
  * @category conversions
  */
-export const toDateUtc = (self: DateTime): Date => new Date(self.epochMillis)
+export const toDateUtc: (self: DateTime) => Date = Internal.toDateUtc
 
 /**
  * Convert a `DateTime` to a `Date`, applying the time zone first.
@@ -1441,30 +1184,7 @@ export const toDateUtc = (self: DateTime): Date => new Date(self.epochMillis)
  * @since 3.6.0
  * @category conversions
  */
-export const toDate = (self: DateTime): Date => {
-  if (self._tag === "Utc") {
-    return new Date(self.epochMillis)
-  } else if (self.zone._tag === "Offset") {
-    return new Date(self.epochMillis + self.zone.offset)
-  } else if (self.adjustedEpochMillis !== undefined) {
-    return new Date(self.adjustedEpochMillis)
-  }
-  const parts = self.zone.format.formatToParts(self.epochMillis).filter((_) => _.type !== "literal")
-  const date = new Date(0)
-  date.setUTCFullYear(
-    Number(parts[2].value),
-    Number(parts[0].value) - 1,
-    Number(parts[1].value)
-  )
-  date.setUTCHours(
-    Number(parts[3].value),
-    Number(parts[4].value),
-    Number(parts[5].value),
-    Number(parts[6].value)
-  )
-  self.adjustedEpochMillis = date.getTime()
-  return date
-}
+export const toDate: (self: DateTime) => Date = Internal.toDate
 
 /**
  * Calculate the time zone offset of a `DateTime.Zoned` in milliseconds.
@@ -1472,17 +1192,7 @@ export const toDate = (self: DateTime): Date => {
  * @since 3.6.0
  * @category conversions
  */
-export const zonedOffset = (self: Zoned): number => {
-  const date = toDate(self)
-  return date.getTime() - toEpochMillis(self)
-}
-
-const offsetToString = (offset: number): string => {
-  const abs = Math.abs(offset)
-  const hours = Math.floor(abs / (60 * 60 * 1000))
-  const minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
-  return `${offset < 0 ? "-" : "+"}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
-}
+export const zonedOffset: (self: Zoned) => number = Internal.zonedOffset
 
 /**
  * Calculate the time zone offset of a `DateTime` in milliseconds.
@@ -1492,7 +1202,7 @@ const offsetToString = (offset: number): string => {
  * @since 3.6.0
  * @category conversions
  */
-export const zonedOffsetIso = (self: Zoned): string => offsetToString(zonedOffset(self))
+export const zonedOffsetIso: (self: Zoned) => string = Internal.zonedOffsetIso
 
 /**
  * Get the milliseconds since the Unix epoch of a `DateTime`.
@@ -1500,7 +1210,7 @@ export const zonedOffsetIso = (self: Zoned): string => offsetToString(zonedOffse
  * @since 3.6.0
  * @category conversions
  */
-export const toEpochMillis = (self: DateTime): number => self.epochMillis
+export const toEpochMillis: (self: DateTime) => number = Internal.toEpochMillis
 
 /**
  * Remove the time aspect of a `DateTime`, first adjusting for the time
@@ -1522,27 +1232,12 @@ export const toEpochMillis = (self: DateTime): number => self.epochMillis
  * )
  * ```
  */
-export const removeTime = (self: DateTime): Utc =>
-  withDate(self, (date) => {
-    date.setUTCHours(0, 0, 0, 0)
-    return makeUtc(date.getTime())
-  })
+export const removeTime: (self: DateTime) => Utc = Internal.removeTime
 
 // =============================================================================
 // parts
 // =============================================================================
 
-const dateToParts = (date: Date): DateTime.PartsWithWeekday => ({
-  millis: date.getUTCMilliseconds(),
-  seconds: date.getUTCSeconds(),
-  minutes: date.getUTCMinutes(),
-  hours: date.getUTCHours(),
-  day: date.getUTCDate(),
-  weekDay: date.getUTCDay(),
-  month: date.getUTCMonth() + 1,
-  year: date.getUTCFullYear()
-})
-
 /**
  * Get the different parts of a `DateTime` as an object.
  *
@@ -1551,15 +1246,7 @@ const dateToParts = (date: Date): DateTime.PartsWithWeekday => ({
  * @since 3.6.0
  * @category parts
  */
-export const toParts = (self: DateTime): DateTime.PartsWithWeekday => {
-  if (self._tag === "Utc") {
-    return toPartsUtc(self)
-  } else if (self.partsAdjusted !== undefined) {
-    return self.partsAdjusted
-  }
-  self.partsAdjusted = withDate(self, dateToParts)
-  return self.partsAdjusted
-}
+export const toParts: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toParts
 
 /**
  * Get the different parts of a `DateTime` as an object.
@@ -1569,13 +1256,7 @@ export const toParts = (self: DateTime): DateTime.PartsWithWeekday => {
  * @since 3.6.0
  * @category parts
  */
-export const toPartsUtc = (self: DateTime): DateTime.PartsWithWeekday => {
-  if (self.partsUtc !== undefined) {
-    return self.partsUtc
-  }
-  self.partsUtc = withDateUtc(self, dateToParts)
-  return self.partsUtc
-}
+export const toPartsUtc: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toPartsUtc
 
 /**
  * Get a part of a `DateTime` as a number.
@@ -1628,7 +1309,7 @@ export const getPartUtc: {
    * ```
    */
   (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = dual(2, (self: DateTime, part: keyof DateTime.PartsWithWeekday): number => toPartsUtc(self)[part])
+} = Internal.getPartUtc
 
 /**
  * Get a part of a `DateTime` as a number.
@@ -1681,35 +1362,7 @@ export const getPart: {
    * ```
    */
   (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = dual(2, (self: DateTime, part: keyof DateTime.PartsWithWeekday): number => toParts(self)[part])
-
-const setPartsDate = (date: Date, parts: Partial<DateTime.PartsWithWeekday>): void => {
-  if (parts.year !== undefined) {
-    date.setUTCFullYear(parts.year)
-  }
-  if (parts.month !== undefined) {
-    date.setUTCMonth(parts.month - 1)
-  }
-  if (parts.day !== undefined) {
-    date.setUTCDate(parts.day)
-  }
-  if (parts.weekDay !== undefined) {
-    const diff = parts.weekDay - date.getUTCDay()
-    date.setUTCDate(date.getUTCDate() + diff)
-  }
-  if (parts.hours !== undefined) {
-    date.setUTCHours(parts.hours)
-  }
-  if (parts.minutes !== undefined) {
-    date.setUTCMinutes(parts.minutes)
-  }
-  if (parts.seconds !== undefined) {
-    date.setUTCSeconds(parts.seconds)
-  }
-  if (parts.millis !== undefined) {
-    date.setUTCMilliseconds(parts.millis)
-  }
-}
+} = Internal.getPart
 
 /**
  * Set the different parts of a `DateTime` as an object.
@@ -1738,11 +1391,7 @@ export const setParts: {
    * @category parts
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, parts: Partial<DateTime.PartsWithWeekday>): DateTime =>
-    mutate(self, (date) => setPartsDate(date, parts))
-)
+} = Internal.setParts
 
 /**
  * Set the different parts of a `DateTime` as an object.
@@ -1765,24 +1414,18 @@ export const setPartsUtc: {
    * @category parts
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, parts: Partial<DateTime.PartsWithWeekday>): DateTime =>
-    mutateUtc(self, (date) => setPartsDate(date, parts))
-)
+} = Internal.setPartsUtc
 
 // =============================================================================
 // current time zone
 // =============================================================================
 
-/**
- * @since 3.6.0
- * @category current time zone
- */
-export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZone")<
-  CurrentTimeZone,
-  TimeZone
->() {}
+// =============================================================================
+// current time zone
+// =============================================================================
+
+/** @internal */
+export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZone")<CurrentTimeZone, TimeZone>() {}
 
 /**
  * Set the time zone of a `DateTime` to the current time zone, which is
@@ -1858,8 +1501,10 @@ export const withCurrentZone: {
   <A, E, R>(effect: Effect.Effect<A, E, R>, zone: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
 } = dual(
   2,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, zone: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> =>
-    Effect.provideService(effect, CurrentTimeZone, zone)
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    zone: TimeZone
+  ): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> => Effect.provideService(effect, CurrentTimeZone, zone)
 )
 
 /**
@@ -2025,80 +1670,12 @@ export const withCurrentZoneNamed: {
  * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
  * ```
  */
-export const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone> = Effect.flatMap(
-  now,
-  setZoneCurrent
-)
-
-/**
- * Create a Layer from the given time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZone = (zone: TimeZone): Layer.Layer<CurrentTimeZone> => Layer.succeed(CurrentTimeZone, zone)
-
-/**
- * Create a Layer from the given time zone offset.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneOffset = (offset: number): Layer.Layer<CurrentTimeZone> =>
-  Layer.succeed(CurrentTimeZone, zoneMakeOffset(offset))
-
-/**
- * Create a Layer from the given IANA time zone identifier.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneNamed = (zoneId: string): Layer.Layer<CurrentTimeZone, IllegalArgumentException> =>
-  Layer.effect(CurrentTimeZone, zoneMakeNamedEffect(zoneId))
-
-/**
- * Create a Layer from the systems local time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone> = Layer.sync(
-  CurrentTimeZone,
-  zoneMakeLocal
-)
+export const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone> = Effect.flatMap(now, setZoneCurrent)
 
 // =============================================================================
 // mapping
 // =============================================================================
 
-const makeZonedFromAdjusted = (adjustedMillis: number, zone: TimeZone): Zoned => {
-  const offset = zone._tag === "Offset" ? zone.offset : calculateNamedOffset(adjustedMillis, zone)
-  return makeZonedProto(adjustedMillis - offset, zone)
-}
-
-const offsetRegex = /([+-])(\d{2}):(\d{2})$/
-const parseOffset = (offset: string): number | null => {
-  const match = offsetRegex.exec(offset)
-  if (match === null) {
-    return null
-  }
-  const [, sign, hours, minutes] = match
-  return (sign === "+" ? 1 : -1) * (Number(hours) * 60 + Number(minutes)) * 60 * 1000
-}
-
-const calculateNamedOffset = (adjustedMillis: number, zone: TimeZone.Named): number => {
-  const offset = zone.format.formatToParts(adjustedMillis).find((_) => _.type === "timeZoneName")?.value ?? ""
-  if (offset === "GMT") {
-    return 0
-  }
-  const result = parseOffset(offset)
-  if (result === null) {
-    // fallback to using the adjusted date
-    return zonedOffset(makeZonedProto(adjustedMillis, zone))
-  }
-  return result
-}
-
 /**
  * Modify a `DateTime` by applying a function to a cloned `Date` instance.
  *
@@ -2109,6 +1686,10 @@ const calculateNamedOffset = (adjustedMillis: number, zone: TimeZone.Named): num
  * @category mapping
  */
 export const mutate: {
+  // =============================================================================
+  // mapping
+  // =============================================================================
+
   /**
    * Modify a `DateTime` by applying a function to a cloned `Date` instance.
    *
@@ -2119,6 +1700,10 @@ export const mutate: {
    * @category mapping
    */
   (f: (date: Date) => void): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  // =============================================================================
+  // mapping
+  // =============================================================================
+
   /**
    * Modify a `DateTime` by applying a function to a cloned `Date` instance.
    *
@@ -2129,17 +1714,7 @@ export const mutate: {
    * @category mapping
    */
   <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (date: Date) => void): DateTime => {
-  if (self._tag === "Utc") {
-    const date = toDateUtc(self)
-    f(date)
-    return makeUtc(date.getTime())
-  }
-  const adjustedDate = toDate(self)
-  const newAdjustedDate = new Date(adjustedDate.getTime())
-  f(newAdjustedDate)
-  return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone)
-})
+} = Internal.mutate
 
 /**
  * Modify a `DateTime` by applying a function to a cloned UTC `Date` instance.
@@ -2162,12 +1737,7 @@ export const mutateUtc: {
    * @category mapping
    */
   <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (date: Date) => void): DateTime =>
-  mapEpochMillis(self, (millis) => {
-    const date = new Date(millis)
-    f(date)
-    return date.getTime()
-  }))
+} = Internal.mutateUtc
 
 /**
  * Transform a `DateTime` by applying a function to the number of milliseconds
@@ -2220,10 +1790,7 @@ export const mapEpochMillis: {
    * ```
    */
   <A extends DateTime>(self: A, f: (millis: number) => number): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, f: (millis: number) => number): DateTime => {
-  const millis = f(toEpochMillis(self))
-  return self._tag === "Utc" ? makeUtc(millis) : makeZonedProto(millis, self.zone)
-})
+} = Internal.mapEpochMillis
 
 /**
  * Using the time zone adjusted `Date`, apply a function to the `Date` and
@@ -2276,7 +1843,7 @@ export const withDate: {
    * ```
    */
   <A>(self: DateTime, f: (date: Date) => A): A
-} = dual(2, <A>(self: DateTime, f: (date: Date) => A): A => f(toDate(self)))
+} = Internal.withDate
 
 /**
  * Using the time zone adjusted `Date`, apply a function to the `Date` and
@@ -2329,7 +1896,7 @@ export const withDateUtc: {
    * ```
    */
   <A>(self: DateTime, f: (date: Date) => A): A
-} = dual(2, <A>(self: DateTime, f: (date: Date) => A): A => f(toDateUtc(self)))
+} = Internal.withDateUtc
 
 /**
  * @since 3.6.0
@@ -2357,10 +1924,7 @@ export const match: {
       readonly onZoned: (_: Zoned) => B
     }
   ): A | B
-} = dual(2, <A, B>(self: DateTime, options: {
-  readonly onUtc: (_: Utc) => A
-  readonly onZoned: (_: Zoned) => B
-}): A | B => self._tag === "Utc" ? options.onUtc(self) : options.onZoned(self))
+} = Internal.match
 
 // =============================================================================
 // math
@@ -2422,11 +1986,7 @@ export const addDuration: {
    * ```
    */
   <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, duration: Duration.DurationInput): DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(duration))
-)
+} = Internal.addDuration
 
 /**
  * Subtract the given `Duration` from a `DateTime`.
@@ -2476,15 +2036,7 @@ export const subtractDuration: {
    * ```
    */
   <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
-} = dual(
-  2,
-  (self: DateTime, duration: Duration.DurationInput): DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(duration))
-)
-
-const addMillis = (date: Date, amount: number): void => {
-  date.setTime(date.getTime() + amount)
-}
+} = Internal.subtractDuration
 
 /**
  * Add the given `amount` of `unit`'s to a `DateTime`.
@@ -2543,46 +2095,7 @@ export const add: {
    * ```
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, parts: Partial<DateTime.PartsForMath>): DateTime =>
-  mutate(self, (date) => {
-    if (parts.millis) {
-      addMillis(date, parts.millis)
-    }
-    if (parts.seconds) {
-      addMillis(date, parts.seconds * 1000)
-    }
-    if (parts.minutes) {
-      addMillis(date, parts.minutes * 60 * 1000)
-    }
-    if (parts.hours) {
-      addMillis(date, parts.hours * 60 * 60 * 1000)
-    }
-    if (parts.days) {
-      date.setUTCDate(date.getUTCDate() + parts.days)
-    }
-    if (parts.weeks) {
-      date.setUTCDate(date.getUTCDate() + parts.weeks * 7)
-    }
-    if (parts.months) {
-      const day = date.getUTCDate()
-      date.setUTCMonth(date.getUTCMonth() + parts.months + 1, 0)
-      if (day < date.getUTCDate()) {
-        date.setUTCDate(day)
-      }
-    }
-    if (parts.years) {
-      const day = date.getUTCDate()
-      const month = date.getUTCMonth()
-      date.setUTCFullYear(
-        date.getUTCFullYear() + parts.years,
-        month + 1,
-        0
-      )
-      if (day < date.getUTCDate()) {
-        date.setUTCDate(day)
-      }
-    }
-  }))
+} = Internal.add
 
 /**
  * Subtract the given `amount` of `unit`'s from a `DateTime`.
@@ -2632,54 +2145,7 @@ export const subtract: {
    * ```
    */
   <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
-} = dual(2, (self: DateTime, parts: Partial<DateTime.PartsForMath>): DateTime => {
-  const newParts = {} as Partial<Mutable<DateTime.PartsForMath>>
-  for (const key in parts) {
-    newParts[key as keyof DateTime.PartsForMath] = -1 * parts[key as keyof DateTime.PartsForMath]!
-  }
-  return add(self, newParts)
-})
-
-function startOfDate(date: Date, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}) {
-  switch (part) {
-    case "second": {
-      date.setUTCMilliseconds(0)
-      break
-    }
-    case "minute": {
-      date.setUTCSeconds(0, 0)
-      break
-    }
-    case "hour": {
-      date.setUTCMinutes(0, 0, 0)
-      break
-    }
-    case "day": {
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "week": {
-      const weekStartsOn = options?.weekStartsOn ?? 0
-      const day = date.getUTCDay()
-      const diff = (day - weekStartsOn + 7) % 7
-      date.setUTCDate(date.getUTCDate() - diff)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "month": {
-      date.setUTCDate(1)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-    case "year": {
-      date.setUTCMonth(0, 1)
-      date.setUTCHours(0, 0, 0, 0)
-      break
-    }
-  }
-}
+} = Internal.subtract
 
 /**
  * Converts a `DateTime` to the start of the given `part`.
@@ -2752,50 +2218,7 @@ export const startOf: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime => mutate(self, (date) => startOfDate(date, part, options)))
-
-function endOfDate(date: Date, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}) {
-  switch (part) {
-    case "second": {
-      date.setUTCMilliseconds(999)
-      break
-    }
-    case "minute": {
-      date.setUTCSeconds(59, 999)
-      break
-    }
-    case "hour": {
-      date.setUTCMinutes(59, 59, 999)
-      break
-    }
-    case "day": {
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "week": {
-      const weekStartsOn = options?.weekStartsOn ?? 0
-      const day = date.getUTCDay()
-      const diff = (day - weekStartsOn + 7) % 7
-      date.setUTCDate(date.getUTCDate() - diff + 6)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "month": {
-      date.setUTCMonth(date.getUTCMonth() + 1, 0)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-    case "year": {
-      date.setUTCMonth(11, 31)
-      date.setUTCHours(23, 59, 59, 999)
-      break
-    }
-  }
-}
+} = Internal.startOf
 
 /**
  * Converts a `DateTime` to the end of the given `part`.
@@ -2868,9 +2291,7 @@ export const endOf: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime => mutate(self, (date) => endOfDate(date, part, options)))
+} = Internal.endOf
 
 /**
  * Converts a `DateTime` to the nearest given `part`.
@@ -2943,38 +2364,12 @@ export const nearest: {
       readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
     }
   ): DateTime.PreserveZone<A>
-} = dual(isDateTimeArgs, (self: DateTime, part: DateTime.UnitSingular, options?: {
-  readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-}): DateTime =>
-  mutate(self, (date) => {
-    if (part === "milli") return
-    const millis = date.getTime()
-    const start = new Date(millis)
-    startOfDate(start, part, options)
-    const startMillis = start.getTime()
-    const end = new Date(millis)
-    endOfDate(end, part, options)
-    const endMillis = end.getTime() + 1
-    const diffStart = millis - startMillis
-    const diffEnd = endMillis - millis
-    if (diffStart < diffEnd) {
-      date.setTime(startMillis)
-    } else {
-      date.setTime(endMillis)
-    }
-  }))
+} = Internal.nearest
 
 // =============================================================================
 // formatting
 // =============================================================================
 
-const intlTimeZone = (self: TimeZone): string => {
-  if (self._tag === "Named") {
-    return self.id
-  }
-  return offsetToString(self.offset)
-}
-
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
  *
@@ -2987,6 +2382,10 @@ const intlTimeZone = (self: TimeZone): string => {
  * @category formatting
  */
 export const format: {
+  // =============================================================================
+  // formatting
+  // =============================================================================
+
   /**
    * Format a `DateTime` as a string using the `DateTimeFormat` API.
    *
@@ -3005,6 +2404,10 @@ export const format: {
       }
       | undefined
   ): (self: DateTime) => string
+  // =============================================================================
+  // formatting
+  // =============================================================================
+
   /**
    * Format a `DateTime` as a string using the `DateTimeFormat` API.
    *
@@ -3024,26 +2427,7 @@ export const format: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string => {
-  try {
-    return new Intl.DateTimeFormat(options?.locale, {
-      timeZone: self._tag === "Utc" ? "UTC" : intlTimeZone(self.zone),
-      ...options
-    }).format(self.epochMillis)
-  } catch (_) {
-    return new Intl.DateTimeFormat(options?.locale, {
-      timeZone: "UTC",
-      ...options
-    }).format(toDate(self))
-  }
-})
+} = Internal.format
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -3085,14 +2469,7 @@ export const formatLocal: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMillis))
+} = Internal.formatLocal
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -3134,18 +2511,7 @@ export const formatUtc: {
       }
       | undefined
   ): string
-} = dual(isDateTimeArgs, (
-  self: DateTime,
-  options?:
-    | Intl.DateTimeFormatOptions & {
-      readonly locale?: string | undefined
-    }
-    | undefined
-): string =>
-  new Intl.DateTimeFormat(options?.locale, {
-    ...options,
-    timeZone: "UTC"
-  }).format(self.epochMillis))
+} = Internal.formatUtc
 
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
@@ -3168,7 +2534,7 @@ export const formatIntl: {
    * @category formatting
    */
   (self: DateTime, format: Intl.DateTimeFormat): string
-} = dual(2, (self: DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMillis))
+} = Internal.formatIntl
 
 /**
  * Format a `DateTime` as a UTC ISO string.
@@ -3176,7 +2542,7 @@ export const formatIntl: {
  * @since 3.6.0
  * @category formatting
  */
-export const formatIso = (self: DateTime): string => toDateUtc(self).toISOString()
+export const formatIso: (self: DateTime) => string = Internal.formatIso
 
 /**
  * Format a `DateTime` as a time zone adjusted ISO date string.
@@ -3184,7 +2550,7 @@ export const formatIso = (self: DateTime): string => toDateUtc(self).toISOString
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoDate = (self: DateTime): string => toDate(self).toISOString().slice(0, 10)
+export const formatIsoDate: (self: DateTime) => string = Internal.formatIsoDate
 
 /**
  * Format a `DateTime` as a UTC ISO date string.
@@ -3192,7 +2558,7 @@ export const formatIsoDate = (self: DateTime): string => toDate(self).toISOStrin
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoDateUtc = (self: DateTime): string => toDateUtc(self).toISOString().slice(0, 10)
+export const formatIsoDateUtc: (self: DateTime) => string = Internal.formatIsoDateUtc
 
 /**
  * Format a `DateTime.Zoned` as a ISO string with an offset.
@@ -3200,10 +2566,7 @@ export const formatIsoDateUtc = (self: DateTime): string => toDateUtc(self).toIS
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoOffset = (self: DateTime): string => {
-  const date = toDate(self)
-  return self._tag === "Utc" ? date.toISOString() : `${date.toISOString().slice(0, -1)}${zonedOffsetIso(self)}`
-}
+export const formatIsoOffset: (self: DateTime) => string = Internal.formatIsoOffset
 
 /**
  * Format a `DateTime.Zoned` as a string.
@@ -3213,5 +2576,40 @@ export const formatIsoOffset = (self: DateTime): string => {
  * @since 3.6.0
  * @category formatting
  */
-export const formatIsoZoned = (self: Zoned): string =>
-  self.zone._tag === "Offset" ? formatIsoOffset(self) : `${formatIsoOffset(self)}[${self.zone.id}]`
+export const formatIsoZoned: (self: Zoned) => string = Internal.formatIsoZoned
+
+/**
+ * Create a Layer from the given time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZone = (zone: TimeZone): Layer.Layer<CurrentTimeZone> => Layer.succeed(CurrentTimeZone, zone)
+
+/**
+ * Create a Layer from the given time zone offset.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneOffset = (offset: number): Layer.Layer<CurrentTimeZone> =>
+  Layer.succeed(CurrentTimeZone, Internal.zoneMakeOffset(offset))
+
+/**
+ * Create a Layer from the given IANA time zone identifier.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneNamed = (
+  zoneId: string
+): Layer.Layer<CurrentTimeZone, IllegalArgumentException> =>
+  Layer.effect(CurrentTimeZone, Internal.zoneMakeNamedEffect(zoneId))
+
+/**
+ * Create a Layer from the systems local time zone.
+ *
+ * @since 3.6.0
+ * @category current time zone
+ */
+export const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone> = Layer.sync(CurrentTimeZone, zoneMakeLocal)