fn pub inline static new(year: Int, month: Int, day: Int) -> Option[Date] {
  if
    year >= -2147483648
      and year <= 2147483647
      and month >= 1
      and month <= 12
      and day >= 1
      and day <= 31
  {
    Option.Some(new_unchecked(year, month, day))
  } else {
    Option.None
  }
}

fn pub !=(other: ref Self) -> Bool {
  !(self == other)
}

fn pub ==(other: Date) -> Bool {
  @bits == other.bits
}

fn pub inline day -> Int {
  @bits & 0x1F
}

fn pub day_of_week -> Int {
  # January 1st, 1970 (our anchor date) was on a Thursday. We add 3 so that
  # Monday (3 days before Thursday) becomes the anchor date.
  #
  # We later on add 1 since the % operator will return 0 for Monday (since its
  # the first value in the range), but week days range from 1 to 7; not 0 to
  # 6.
  #
  # The following table should help illustrate this:
  #
  # | Date       | Day of week | days_since_unix_epoch
  # |:-----------|:------------|:----------------------
  # | 1969-12-29 | Monday      | -3
  # | 1969-12-30 | Tuesday     | -2
  # | 1969-12-31 | Wednesday   | -1
  # | 1970-01-01 | Thursday    | 0
  # | 1970-01-02 | Friday      | 1
  # | 1970-01-03 | Saturday    | 2
  # | 1970-01-04 | Sunday      | 3
  #
  # For these dates, the calculations would be as follows:
  #
  # | Date       | Calculation        | Simplified  | Return value
  # |:-----------|:-------------------|:------------|:------------
  # | 1969-12-29 | ((-3 + 3) % 7) + 1 | (0 % 7) + 1 | 1
  # | 1969-12-30 | ((-2 + 3) % 7) + 1 | (1 % 7) + 1 | 2
  # | 1969-12-31 | ((-1 + 3) % 7) + 1 | (2 % 7) + 1 | 3
  # | 1970-01-01 | ((0 + 3) % 7) + 1  | (3 % 7) + 1 | 4
  # | 1970-01-02 | ((1 + 3) % 7) + 1  | (4 % 7) + 1 | 5
  # | 1970-01-03 | ((2 + 3) % 7) + 1  | (5 % 7) + 1 | 6
  # | 1970-01-04 | ((3 + 3) % 7) + 1  | (6 % 7) + 1 | 7
  days_since_unix_epoch + 3 % DAYS_PER_WEEK + 1
}

fn pub day_of_year -> Int {
  let days = if leap_year? { LEAP_DAYS } else { NORMAL_DAYS }

  days.get(month - 1).or_panic + day
}

fn pub days_since_unix_epoch -> Int {
  let year = if month <= 2 { year - 1 } else { year }
  let month = month
  let era = if year >= 0 { year } else { year - 399 } / 400
  let yoe = year - (era * 400)
  let doy = (((153 * if month > 2 { month - 3 } else { month + 9 }) + 2) / 5)
    + day
    - 1
  let doe = (yoe * 365) + (yoe / 4) - (yoe / 100) + doy

  (era * 146_097) + doe - 719_468
}

fn pub fmt(formatter: mut Formatter) {
  let year = year.to_string.pad_start(with: '0', chars: 4)
  let month = month.to_string.pad_start(with: '0', chars: 2)
  let day = day.to_string.pad_start(with: '0', chars: 2)

  formatter.write('${year}-${month}-${day}')
}

fn pub leap_year? -> Bool {
  let year = year

  (year % 4) == 0 and ((year % 100) > 0 or (year % 400) == 0)
}

fn pub inline month -> Int {
  @bits >> 5 & 0xF
}

fn pub inline year -> Int {
  @bits >> 9
}