prepare version 0.17.0

* fix(relative): add the fraction of a negative relative second count

`Relative::Seconds` holds a floor decomposition, so -0.25 seconds is
`(-1, 750_000_000)`. A `jiff::Span` is sign-uniform, so combining those two
fields directly subtracted the fraction instead of adding it and the result
was off by `2 * (1 - fraction)` seconds. Rebalance the fraction onto the sign
of the whole seconds before building the span.

* fix(relative): shorten the fraction comment, align the GNU version to 9.11

.github/workflows/audit.yml

@@ -0,0 +1,15 @@
+name: Security audit
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: rustsec/audit-check@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -3,6 +3,7 @@ on: [push, pull_request]
 name: Basic CI
 
 env:
+  CARGO_INCREMENTAL: "0"
   CARGO_TERM_COLOR: always
   RUST_MIN_SRV: "1.71.1"
 
@@ -14,8 +15,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v7
       - run: cargo check
 
   test:
@@ -25,17 +25,14 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v7
       - run: cargo test
 
   fmt:
     name: cargo fmt --all -- --check
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
-      - run: rustup component add rustfmt
+      - uses: actions/checkout@v7
       - run: cargo fmt --all -- --check
 
   clippy:
@@ -45,9 +42,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
-      - run: rustup component add clippy
+      - uses: actions/checkout@v7
       - run: cargo clippy --all-targets -- -D warnings
 
   min_version:
@@ -57,11 +52,11 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: ${{ env.RUST_MIN_SRV }}
-      - run: cargo test
+      - run: cargo check
 
   coverage:
     name: Code Coverage
@@ -74,15 +69,15 @@ jobs:
           - { os: macos-latest   , features: macos }
           - { os: windows-latest , features: windows }
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
+    - name: emulate nightly toolchain
+      run: echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # toolchain
-        TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
         # * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
         case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
         # * use requested TOOLCHAIN if specified
@@ -94,13 +89,12 @@ jobs:
         outputs CODECOV_FLAGS
 
     - name: rust toolchain ~ install
-      uses: dtolnay/rust-toolchain@nightly
+      uses: dtolnay/rust-toolchain@nightly # this job is not reproducible...
       with:
         components: llvm-tools-preview
     - name: Test
       run: cargo test --no-fail-fast
       env:
-        CARGO_INCREMENTAL: "0"
         RUSTC_WRAPPER: ""
         RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
         RUSTDOCFLAGS: "-Cpanic=abort"
@@ -109,12 +103,12 @@ jobs:
       id: build_grcov
       shell: bash
       run: |
-        git clone https://github.com/mozilla/grcov.git ~/grcov/
+        git clone --depth=1 https://github.com/mozilla/grcov.git ~/grcov/
         cd ~/grcov
         # Hardcode the version of crossbeam-epoch. See
         # https://github.com/uutils/coreutils/issues/3680
         sed -i -e "s|tempfile =|crossbeam-epoch = \"=0.9.8\"\ntempfile =|" Cargo.toml
-        cargo install --path .
+        cargo install --path . --locked
         cd -
 # Uncomment when the upstream issue
 # https://github.com/mozilla/grcov/issues/849 is fixed
@@ -134,32 +128,44 @@ jobs:
         # display coverage files
         grcov . --binary-path="${COVERAGE_REPORT_DIR}" --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
         # generate coverage report
-        grcov . --binary-path="${COVERAGE_REPORT_DIR}" --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
+        grcov . --binary-path="${COVERAGE_REPORT_DIR}" --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" --source-dir .
         echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
     - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v5
+      uses: codecov/codecov-action@v7
       with:
         token: ${{ secrets.CODECOV_TOKEN }}
         files: ${{ steps.coverage.outputs.report }}
-        ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
         name: codecov-umbrella
         fail_ci_if_error: false
+        verbose: true
+        directory: ./
+        root_dir: ./
 
   fuzz:
     name: Run the fuzzers
     runs-on: ubuntu-latest
     env:
       RUN_FOR: 60
+      # cargo-fuzz uses nightly features
+      RUSTC_BOOTSTRAP: 1
     steps:
-    - uses: actions/checkout@v6
-    - uses: dtolnay/rust-toolchain@nightly
+    - uses: actions/checkout@v7
     - name: Install `cargo-fuzz`
-      run: cargo install cargo-fuzz
+      uses: taiki-e/install-action@v2
+      with:
+        tool: cargo-fuzz
     - uses: Swatinem/rust-cache@v2
-    - name: Run from_str for XX seconds
+    - name: Run fuzz_parse_datetime for XX seconds
       shell: bash
       run: |
         ## Run it
         cd fuzz
-        cargo +nightly fuzz run fuzz_parse_datetime -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+        # https://github.com/rust-fuzz/cargo-fuzz/issues/398
+        cargo fuzz run --target host-tuple fuzz_parse_datetime -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+    - name: Run fuzz_large_year for XX seconds
+      shell: bash
+      run: |
+        ## Run it
+        cd fuzz
+        cargo fuzz run --target host-tuple fuzz_large_year -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0

.github/workflows/codspeed.yml

@@ -0,0 +1,37 @@
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - "main"
+  pull_request:
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  codspeed:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Setup rust toolchain, cache and cargo-codspeed binary
+        uses: moonrepo/setup-rust@v1
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-codspeed
+
+      - name: Build the benchmark target(s)
+        run: cargo codspeed build
+
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v5
+        with:
+          mode: simulation
+          run: cargo codspeed run

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "parse_datetime"
-description = "parsing human-readable time strings and converting them to a DateTime"
-version = "0.13.3"
+description = "parsing human-readable time strings and converting them to a Zoned datetime"
+version = "0.17.0"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/uutils/parse_datetime"
@@ -9,9 +9,16 @@ readme = "README.md"
 rust-version = "1.71.1"
 
 [dependencies]
-winnow = "0.7.10"
+winnow = "1.0.0"
 num-traits = "0.2.19"
 jiff = { version = "0.2.15", default-features = false, features = ["tz-system", "tzdb-bundle-platform", "tzdb-zoneinfo"] }
 
 [dev-dependencies]
-rstest = "0.26"
+rstest = "0.27"
+
+[dev-dependencies.codspeed-criterion-compat]
+version = "5.0"
+
+[[bench]]
+name = "parse_datetime"
+harness = false

README.md

@@ -3,8 +3,10 @@
 [![Crates.io](https://img.shields.io/crates/v/parse_datetime.svg)](https://crates.io/crates/parse_datetime)
 [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/parse_datetime/blob/main/LICENSE)
 [![CodeCov](https://codecov.io/gh/uutils/parse_datetime/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/parse_datetime)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/uutils/parse_datetime?utm_source=badge)
 
-A Rust crate for parsing human-readable relative time strings and human-readable datetime strings and converting them to a jiff's `Zoned` object.
+A Rust crate for parsing human-readable relative time strings and
+human-readable datetime strings.
 
 ## Features
 
@@ -26,25 +28,44 @@ Then, import the crate and use the `parse_datetime_at_date` function:
 
 ```rs
 use jiff::{ToSpan, Zoned};
-use parse_datetime::parse_datetime_at_date;
+use parse_datetime::{parse_datetime_at_date, ParsedDateTime};
 
 let now = Zoned::now();
 let after = parse_datetime_at_date(now.clone(), "+3 days");
 
-assert_eq!(
-  now.checked_add(3.days()).unwrap(),
-  after.unwrap()
-);
+match after.unwrap() {
+  ParsedDateTime::InRange(z) => assert_eq!(now.checked_add(3.days()).unwrap(), z),
+  ParsedDateTime::Extended(_) => unreachable!("unexpected for this input"),
+}
 ```
 
 For DateTime parsing, import the `parse_datetime` function:
 
 ```rs
 use jiff::{civil::{date, time} ,Zoned};
-use parse_datetime::parse_datetime;
+use parse_datetime::{parse_datetime, ParsedDateTime};
 
 let dt = parse_datetime("2021-02-14 06:37:47");
-assert_eq!(dt.unwrap(), Zoned::now().with().date(date(2021, 2, 14)).time(time(6, 37, 47, 0)).build().unwrap());
+match dt.unwrap() {
+  ParsedDateTime::InRange(z) => assert_eq!(z, Zoned::now().with().date(date(2021, 2, 14)).time(time(6, 37, 47, 0)).build().unwrap()),
+  ParsedDateTime::Extended(_) => unreachable!("unexpected for this input"),
+}
+```
+
+For years beyond jiff's representable range (e.g., year 10000+), the result is an `ExtendedDateTime`:
+
+```rs
+use parse_datetime::{parse_datetime, ParsedDateTime};
+
+let dt = parse_datetime("12000-01-01").unwrap();
+match dt {
+  ParsedDateTime::Extended(ext) => {
+    assert_eq!(ext.year, 12000);
+    assert_eq!(ext.month, 1);
+    assert_eq!(ext.day, 1);
+  }
+  ParsedDateTime::InRange(_) => unreachable!("year 12000 is out of jiff range"),
+}
 ```
 
 ### Supported Formats
@@ -56,7 +77,7 @@ The `parse_datetime` and `parse_datetime_at_date` functions support absolute dat
 - "now" or "today"
 - "yesterday"
 - "tomorrow"
-- use "ago" for the past
+- use "ago" for the past or "hence" for the future
 - use "next" or "last" with `unit` (e.g., "next week", "last year")
 - unix timestamps (for example "@0" "@1344000")
 
@@ -69,7 +90,9 @@ The `parse_datetime` and `parse_datetime_at_date` functions support absolute dat
 
 The `parse_datetime` and `parse_datetime_at_date` function return:
 
-- `Ok(Zoned)` - If the input string can be parsed as a `Zoned` object
+- `Ok(ParsedDateTime)` - If the input string can be parsed
+  - `ParsedDateTime::InRange(Zoned)` for years supported by `jiff::Zoned`
+  - `ParsedDateTime::Extended(ExtendedDateTime)` for out-of-range years (for example `>9999`)
 - `Err(ParseDateTimeError::InvalidInput)` - If the input string cannot be parsed
 
 ## Fuzzer

benches/parse_datetime.rs

@@ -0,0 +1,155 @@
+use codspeed_criterion_compat::{criterion_group, criterion_main, Criterion};
+use jiff::Zoned;
+use parse_datetime::{parse_datetime, parse_datetime_at_date};
+
+fn bench_iso_datetime(c: &mut Criterion) {
+    c.bench_function("parse_iso_datetime", |b| {
+        b.iter(|| parse_datetime("2021-02-14 06:37:47 +0000"))
+    });
+}
+
+fn bench_iso_datetime_t_sep(c: &mut Criterion) {
+    c.bench_function("parse_iso_datetime_t_separator", |b| {
+        b.iter(|| parse_datetime("2021-02-14T22:37:47-0800"))
+    });
+}
+
+fn bench_date_only(c: &mut Criterion) {
+    c.bench_function("parse_date_only", |b| {
+        b.iter(|| parse_datetime("1997-01-01"))
+    });
+}
+
+fn bench_date_slash_format(c: &mut Criterion) {
+    c.bench_function("parse_date_slash_format", |b| {
+        b.iter(|| parse_datetime("05/07/1987"))
+    });
+}
+
+fn bench_epoch_timestamp(c: &mut Criterion) {
+    c.bench_function("parse_epoch_timestamp", |b| {
+        b.iter(|| parse_datetime("@1613371067"))
+    });
+}
+
+fn bench_relative_time(c: &mut Criterion) {
+    let now = Zoned::now();
+    c.bench_function("parse_relative_time", |b| {
+        b.iter(|| parse_datetime_at_date(now.clone(), "+3 days"))
+    });
+}
+
+fn bench_relative_time_complex(c: &mut Criterion) {
+    let now = Zoned::now();
+    c.bench_function("parse_relative_time_complex", |b| {
+        b.iter(|| parse_datetime_at_date(now.clone(), "1 year 3 months 2 days ago"))
+    });
+}
+
+fn bench_relative_keywords(c: &mut Criterion) {
+    c.bench_function("parse_yesterday", |b| {
+        b.iter(|| parse_datetime("yesterday"))
+    });
+    c.bench_function("parse_tomorrow", |b| b.iter(|| parse_datetime("tomorrow")));
+    c.bench_function("parse_now", |b| b.iter(|| parse_datetime("now")));
+}
+
+fn bench_weekday(c: &mut Criterion) {
+    // Use a fixed reference date: the cost of resolving a weekday depends on
+    // how many days separate it from "today", so relying on the current date
+    // makes the measurement vary with the day the benchmark runs.
+    // 2000-01-03 is a Monday, so "wednesday" resolves two days ahead.
+    let base = jiff::civil::DateTime::from(jiff::civil::date(2000, 1, 3))
+        .to_zoned(jiff::tz::TimeZone::UTC)
+        .unwrap();
+    c.bench_function("parse_weekday", |b| {
+        b.iter(|| parse_datetime_at_date(base.clone(), "wednesday"))
+    });
+}
+
+fn bench_timezone_offset(c: &mut Criterion) {
+    c.bench_function("parse_timezone_offset", |b| {
+        b.iter(|| parse_datetime("UTC+07:00"))
+    });
+}
+
+fn bench_datetime_with_delta(c: &mut Criterion) {
+    c.bench_function("parse_datetime_with_delta", |b| {
+        b.iter(|| parse_datetime("1997-01-01 00:00:00 +0000 +1 year"))
+    });
+}
+
+fn bench_ctime_format(c: &mut Criterion) {
+    c.bench_function("parse_ctime_format", |b| {
+        b.iter(|| parse_datetime("Wed Jan  1 00:00:00 1997"))
+    });
+}
+
+fn bench_datetime_with_timezone_name(c: &mut Criterion) {
+    c.bench_function("parse_datetime_with_tz_name", |b| {
+        b.iter(|| parse_datetime("1997-01-19 08:17:48 BRT"))
+    });
+}
+
+fn bench_datetime_ending_in_z(c: &mut Criterion) {
+    c.bench_function("parse_datetime_ending_in_z", |b| {
+        b.iter(|| parse_datetime("2023-06-03 12:00:01Z"))
+    });
+}
+
+fn bench_invalid_input(c: &mut Criterion) {
+    c.bench_function("parse_invalid_input", |b| {
+        b.iter(|| parse_datetime("NotADate"))
+    });
+}
+
+fn bench_extended_year(c: &mut Criterion) {
+    c.bench_function("parse_extended_year", |b| {
+        b.iter(|| parse_datetime("10000-01-01"))
+    });
+}
+
+fn bench_extended_year_rollover(c: &mut Criterion) {
+    c.bench_function("parse_extended_year_rollover", |b| {
+        b.iter(|| parse_datetime("9999-12-31 +1 day"))
+    });
+}
+
+fn bench_extended_year_relative(c: &mut Criterion) {
+    let base = jiff::civil::DateTime::from(jiff::civil::date(2000, 1, 1))
+        .to_zoned(jiff::tz::TimeZone::UTC)
+        .unwrap();
+    c.bench_function("parse_extended_year_relative", |b| {
+        b.iter(|| parse_datetime_at_date(base.clone(), "10000-01-01 +1 day"))
+    });
+}
+
+fn bench_extended_large_year(c: &mut Criterion) {
+    c.bench_function("parse_extended_large_year", |b| {
+        b.iter(|| parse_datetime("999999-06-15"))
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_iso_datetime,
+    bench_iso_datetime_t_sep,
+    bench_date_only,
+    bench_date_slash_format,
+    bench_epoch_timestamp,
+    bench_relative_time,
+    bench_relative_time_complex,
+    bench_relative_keywords,
+    bench_weekday,
+    bench_timezone_offset,
+    bench_datetime_with_delta,
+    bench_ctime_format,
+    bench_datetime_with_timezone_name,
+    bench_datetime_ending_in_z,
+    bench_invalid_input,
+    bench_extended_year,
+    bench_extended_year_rollover,
+    bench_extended_year_relative,
+    bench_extended_large_year,
+);
+criterion_main!(benches);

fuzz/Cargo.lock

@@ -4,21 +4,30 @@ version = 4
 
 [[package]]
 name = "arbitrary"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
+dependencies = [
+ "derive_arbitrary",
+]
 
 [[package]]
 name = "autocfg"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "cc"
-version = "1.2.47"
+version = "1.2.62"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -33,15 +42,60 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
-name = "find-msvc-tools"
-version = "0.1.5"
+name = "defmt"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
+checksum = "a6e524506490a1953d237cb87b1cfc1e46f88c18f10a22dfe0f507dc6bfc7f7f"
+dependencies = [
+ "bitflags",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0a27770e9c8f719a79d8b638281f4d828f77d8fd61e0bd94451b9b85e576a0b"
+dependencies = [
+ "defmt-parser",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "fuzz_parse_datetime"
 version = "0.2.0"
 dependencies = [
+ "arbitrary",
+ "jiff",
  "libfuzzer-sys",
  "parse_datetime",
 ]
@@ -60,35 +114,47 @@ dependencies = [
 
 [[package]]
 name = "jiff"
-version = "0.2.16"
+version = "0.2.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
+checksum = "b2b005715dcbeb0089a3c0dab99f2ff1cc3b2525323552703d648585d342a383"
 dependencies = [
+ "defmt",
+ "jiff-core",
  "jiff-static",
  "jiff-tzdb-platform",
  "log",
  "portable-atomic",
  "portable-atomic-util",
  "serde_core",
- "windows-sys",
+ "windows-link",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
+dependencies = [
+ "defmt",
 ]
 
 [[package]]
 name = "jiff-static"
-version = "0.2.16"
+version = "0.2.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+checksum = "2cc9817253cf7c7ee4684451bd327e88d6f3658014e54a29198625590650695c"
 dependencies = [
+ "jiff-core",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "jiff-tzdb"
-version = "0.1.4"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
+checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
 
 [[package]]
 name = "jiff-tzdb-platform"
@@ -111,15 +177,15 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.10"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5037190e1f70cbeef565bd267599242926f724d3b8a9f510fd7e0b540cfa4404"
+checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"
 dependencies = [
  "arbitrary",
  "cc",
@@ -127,15 +193,15 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "num-traits"
@@ -148,7 +214,7 @@ dependencies = [
 
 [[package]]
 name = "parse_datetime"
-version = "0.13.2"
+version = "0.16.0"
 dependencies = [
  "jiff",
  "num-traits",
@@ -157,33 +223,55 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.1"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.4"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
 dependencies = [
  "portable-atomic",
 ]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.103"
+name = "proc-macro-error-attr2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.42"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -211,7 +299,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -222,9 +310,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"
-version = "2.0.110"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -232,16 +320,47 @@ dependencies = [
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.22"
+name = "syn"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.3+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
 dependencies = [
  "wit-bindgen",
 ]
@@ -252,26 +371,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
-[[package]]
-name = "windows-sys"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "wit-bindgen"
-version = "0.46.0"
+version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"

fuzz/Cargo.toml

@@ -8,6 +8,8 @@ cargo-fuzz = true
 
 [dependencies]
 libfuzzer-sys = "0.4.7"
+arbitrary = { version = "1", features = ["derive"] }
+jiff = "0.2"
 
 [dependencies.parse_datetime]
 path = "../"
@@ -17,3 +19,9 @@ name = "fuzz_parse_datetime"
 path = "fuzz_targets/parse_datetime.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "fuzz_large_year"
+path = "fuzz_targets/large_year.rs"
+test = false
+doc = false

fuzz/fuzz_targets/large_year.rs

@@ -0,0 +1,64 @@
+#![no_main]
+
+use arbitrary::Arbitrary;
+use jiff::{civil::DateTime, tz::TimeZone};
+use libfuzzer_sys::fuzz_target;
+
+#[derive(Arbitrary, Debug)]
+struct Input {
+    /// Year for the base date (biased toward boundary years).
+    base_year_selector: u8,
+    /// Year to embed in a constructed large-year input string.
+    input_year: u32,
+    month: u8,
+    day: u8,
+    /// Suffix appended after the constructed date (e.g. relative items).
+    suffix: String,
+    /// Whether to also call parse_datetime (no base).
+    try_no_base: bool,
+}
+
+fn base_year(selector: u8) -> i16 {
+    match selector % 6 {
+        0 => 2024,
+        1 => 9998,
+        2 => 9999,
+        3 => 1,
+        4 => 100,
+        _ => (selector as i16) * 40,
+    }
+}
+
+fn clamp_year(y: u32) -> u32 {
+    // Focus on the interesting range: 9990..=100_000 and 0..=20_000
+    match y % 4 {
+        0 => 9990 + (y % 20),          // near boundary
+        1 => 10000 + (y % 90_000),     // large years
+        2 => y % 20_000,               // general range
+        _ => 2_147_485_540 + (y % 10), // near GNU_MAX_YEAR
+    }
+}
+
+fuzz_target!(|input: Input| {
+    let year = clamp_year(input.input_year);
+    let month = (input.month % 12) + 1;
+    let day = (input.day % 28) + 1;
+    let date_str = format!("{year:04}-{month:02}-{day:02} {}", input.suffix);
+
+    // Test parse_datetime (uses current time as base).
+    if input.try_no_base {
+        let _ = parse_datetime::parse_datetime(&date_str);
+    }
+
+    // Test parse_datetime_at_date with a controlled base.
+    let by = base_year(input.base_year_selector);
+    if let Ok(base) = DateTime::new(by, 1, 1, 0, 0, 0, 0) {
+        if let Ok(base) = base.to_zoned(TimeZone::UTC) {
+            let _ = parse_datetime::parse_datetime_at_date(base, &date_str);
+        }
+    }
+
+    // Also try a bare large year as a pure number.
+    let bare = format!("{year}");
+    let _ = parse_datetime::parse_datetime(&bare);
+});

src/items/combined.rs

@@ -16,7 +16,7 @@
 //! > discarded.
 use winnow::{
     combinator::{alt, trace},
-    seq, ModalResult, Parser,
+    ModalResult, Parser,
 };
 
 use crate::items::space;
@@ -29,20 +29,46 @@ pub(crate) struct DateTime {
     pub(crate) time: time::Time,
 }
 
-pub(crate) fn parse(input: &mut &str) -> ModalResult<DateTime> {
-    seq!(DateTime {
-        date: trace("iso_date", alt((date::iso1, date::iso2))),
-        // Note: the `T` is lowercased by the main parse function
-        _: alt((s('t').void(), (' ', space).void())),
-        time: trace("iso_time", time::iso),
-    })
-    .parse_next(input)
+fn remaining_starts_with_meridiem(input: &str) -> bool {
+    let trimmed = input.trim_start();
+    trimmed.starts_with("am")
+        || trimmed.starts_with("pm")
+        || trimmed.starts_with("a.m.")
+        || trimmed.starts_with("p.m.")
+}
+
+/// Parse the separator and time of a combined item whose ISO date has already
+/// been parsed.
+pub(crate) fn parse_time_after_date(input: &mut &str, date: date::Date) -> ModalResult<DateTime> {
+    // Note: the `T` is lowercased by the main parse function
+    alt((s('t').void(), (' ', space).void())).parse_next(input)?;
+
+    let mut iso_input = *input;
+    if let Ok(parsed_time) = trace("iso_time", time::iso).parse_next(&mut iso_input) {
+        if !remaining_starts_with_meridiem(iso_input) {
+            *input = iso_input;
+            return Ok(DateTime {
+                date,
+                time: parsed_time,
+            });
+        }
+    }
+
+    let time = trace("iso_time", time::parse).parse_next(input)?;
+    Ok(DateTime { date, time })
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{parse, DateTime};
-    use crate::items::{date::Date, time::Time};
+    use winnow::{combinator::alt, ModalResult, Parser};
+
+    use super::{parse_time_after_date, DateTime};
+    use crate::items::{date, date::Date, time::Time};
+
+    fn parse(input: &mut &str) -> ModalResult<DateTime> {
+        let date = alt((date::iso1, date::iso2)).parse_next(input)?;
+        parse_time_after_date(input, date)
+    }
 
     #[test]
     fn some_date() {
@@ -73,4 +99,31 @@ mod tests {
             assert_eq!(parse(&mut s).ok(), reference, "Failed string: {old_s}")
         }
     }
+
+    #[test]
+    fn date_and_time_ampm() {
+        let reference = Some(DateTime {
+            date: Date {
+                day: 15,
+                month: 6,
+                year: Some(2024),
+            },
+            time: Time {
+                hour: 15,
+                minute: 0,
+                second: 0,
+                nanosecond: 0,
+                offset: None,
+            },
+        });
+
+        for mut s in [
+            "2024-06-15 3:00 pm",
+            "2024-06-15 3:00pm",
+            "2024-06-15 3:00 p.m.",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).ok(), reference, "Failed string: {old_s}");
+        }
+    }
 }

src/items/date.rs

@@ -27,7 +27,7 @@
 //! > ‘September’.
 
 use winnow::{
-    ascii::{alpha1, multispace1},
+    ascii::alpha1,
     combinator::{alt, eof, opt, preceded, terminated},
     error::ErrMode,
     stream::AsChar,
@@ -36,7 +36,7 @@ use winnow::{
 };
 
 use super::{
-    primitive::{ctx_err, dec_uint, s},
+    primitive::{ctx_err, dec_uint, multispace1, s},
     year::{year_from_str, year_str},
 };
 
@@ -44,11 +44,11 @@ use super::{
 pub(crate) struct Date {
     pub(crate) day: u8,
     pub(crate) month: u8,
-    pub(crate) year: Option<u16>,
+    pub(crate) year: Option<u32>,
 }
 
 impl Date {
-    pub(super) fn with_year(self, year: u16) -> Self {
+    pub(super) fn with_year(self, year: u32) -> Self {
         Date {
             day: self.day,
             month: self.month,
@@ -118,17 +118,19 @@ impl TryFrom<Date> for jiff::civil::Date {
     type Error = &'static str;
 
     fn try_from(date: Date) -> Result<Self, Self::Error> {
-        jiff::civil::Date::new(
-            date.year.unwrap_or(0) as i16,
-            date.month as i8,
-            date.day as i8,
-        )
-        .map_err(|_| "date is not valid")
+        let year = date.year.unwrap_or(0);
+        let year: i16 = year
+            .try_into()
+            .map_err(|_| "date year is outside the supported range")?;
+        jiff::civil::Date::new(year, date.month as i8, date.day as i8)
+            .map_err(|_| "date is not valid")
     }
 }
 
-pub(super) fn parse(input: &mut &str) -> ModalResult<Date> {
-    alt((iso1, iso2, us, literal1, literal2, literal3)).parse_next(input)
+/// Parse a date that is not in ISO format. ISO dates are parsed by [`iso1`]
+/// and [`iso2`], which the caller tries first.
+pub(super) fn parse_non_iso(input: &mut &str) -> ModalResult<Date> {
+    alt((us, literal1, literal2, literal3)).parse_next(input)
 }
 
 /// Parse `[year]-[month]-[day]`
@@ -299,7 +301,13 @@ fn day_from_str(s: &str) -> ModalResult<u8> {
 
 #[cfg(test)]
 mod tests {
-    use super::{parse, Date};
+    use winnow::{combinator::alt, ModalResult, Parser};
+
+    use super::Date;
+
+    fn parse(input: &mut &str) -> ModalResult<Date> {
+        alt((super::iso1, super::iso2, super::parse_non_iso)).parse_next(input)
+    }
 
     // Test cases from the GNU docs:
     //

src/items/epoch.rs

@@ -33,7 +33,7 @@ use super::primitive::{dec_uint, plus_or_minus, s};
 /// - `nanosecond` is always in the range of `0..1_000_000_000`.
 /// - Negative timestamps are represented by a negative `second` value and a
 ///   positive `nanosecond` value.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) struct Timestamp {
     second: i64,
     nanosecond: u32,

src/items/mod.rs

@@ -48,6 +48,9 @@ mod primitive;
 
 pub(crate) mod error;
 
+use std::borrow::Cow;
+
+use crate::ParsedDateTime;
 use jiff::Zoned;
 use primitive::space;
 use winnow::{
@@ -62,29 +65,35 @@ use error::Error;
 
 #[derive(PartialEq, Debug)]
 enum Item {
-    Timestamp(epoch::Timestamp),
     DateTime(combined::DateTime),
     Date(date::Date),
     Time(time::Time),
     Weekday(weekday::Weekday),
     Relative(relative::Relative),
     Offset(offset::Offset),
+    /// The military timezone letter `j`, which GNU `date` defines as local
+    /// time. It is a timezone item like [`Item::Offset`], but carries no
+    /// offset, so it cannot be represented as one.
+    LocalZone,
     TimeZone(jiff::tz::TimeZone),
     Pure(String),
 }
 
-/// Parse a date and time string and build a `Zoned` object. The parsed result
-/// is resolved against the given base date and time.
-pub(crate) fn parse_at_date<S: AsRef<str> + Clone>(base: Zoned, input: S) -> Result<Zoned, Error> {
+/// Parse a date and time string and resolve it against the given base date and
+/// time, returning a [`ParsedDateTime`] result.
+pub(crate) fn parse_at_date<S: AsRef<str> + Clone>(
+    base: Zoned,
+    input: S,
+) -> Result<ParsedDateTime, Error> {
     match parse(&mut input.as_ref()) {
         Ok(builder) => builder.set_base(base).build(),
         Err(e) => Err(e.into()),
     }
 }
 
-/// Parse a date and time string and build a `Zoned` object. The parsed result
-/// is resolved against the current local date and time.
-pub(crate) fn parse_at_local<S: AsRef<str> + Clone>(input: S) -> Result<Zoned, Error> {
+/// Parse a date and time string and resolve it against the current local date
+/// and time, returning a [`ParsedDateTime`] result.
+pub(crate) fn parse_at_local<S: AsRef<str> + Clone>(input: S) -> Result<ParsedDateTime, Error> {
     match parse(&mut input.as_ref()) {
         Ok(builder) => builder.build(), // the builder uses current local date and time if no base is given.
         Err(e) => Err(e.into()),
@@ -152,7 +161,7 @@ pub(crate) fn parse_at_local<S: AsRef<str> + Clone>(input: S) -> Result<Zoned, E
 ///
 /// time_offset         = ( "+" | "-" ) , dec_uint , [ ":" , dec_uint ] ;
 ///
-/// relative            = [ numeric_ordinal  ] , unit , [ "ago" ] | day_shift ;
+/// relative            = [ numeric_ordinal  ] , unit , [ "ago" | "hence" ] | day_shift ;
 ///
 /// unit                = "year" | "years"
 ///                     | "month" | "months"
@@ -209,12 +218,9 @@ fn parse_timestamp(input: &mut &str) -> ModalResult<DateTimeBuilder> {
     trace(
         "parse_timestamp",
         // Expect exactly one timestamp and then EOF (allowing trailing spaces).
-        terminated(epoch::parse.map(Item::Timestamp), preceded(space, eof)),
+        terminated(epoch::parse, preceded(space, eof)),
     )
-    .verify_map(|item: Item| match item {
-        Item::Timestamp(ts) => DateTimeBuilder::new().set_timestamp(ts).ok(),
-        _ => None,
-    })
+    .verify_map(|ts| DateTimeBuilder::new().set_timestamp(ts).ok())
     .parse_next(input)
 }
 
@@ -232,8 +238,12 @@ fn parse_items(input: &mut &str) -> ModalResult<DateTimeBuilder> {
     let tz = timezone::parse(input).map(Item::TimeZone);
 
     // Convert input to lowercase for case-insensitive parsing.
-    let lower = input.to_ascii_lowercase();
-    let input = &mut lower.as_str();
+    let lower: Cow<str> = if input.bytes().any(|b| b.is_ascii_uppercase()) {
+        input.to_ascii_lowercase().into()
+    } else {
+        (*input).into()
+    };
+    let input = &mut lower.as_ref();
 
     let (mut items, _): (Vec<Item>, _) = trace(
         "parse_items",
@@ -251,15 +261,31 @@ fn parse_items(input: &mut &str) -> ModalResult<DateTimeBuilder> {
 
 /// Parse an item.
 fn parse_item(input: &mut &str) -> ModalResult<Item> {
+    // An ISO date is either the start of a combined date and time item or a
+    // date item on its own. Parse it once instead of once per alternative.
+    let start = input.checkpoint();
+    if let Ok(date) = alt((date::iso1, date::iso2)).parse_next(input) {
+        let after_date = input.checkpoint();
+        match combined::parse_time_after_date(input, date.clone()) {
+            Ok(dt) => return Ok(Item::DateTime(dt)),
+            Err(ErrMode::Backtrack(_)) => {
+                input.reset(&after_date);
+                return Ok(Item::Date(date));
+            }
+            Err(e) => return Err(e),
+        }
+    }
+    input.reset(&start);
+
     trace(
         "parse_item",
         alt((
-            combined::parse.map(Item::DateTime),
-            date::parse.map(Item::Date),
+            date::parse_non_iso.map(Item::Date),
             time::parse.map(Item::Time),
             relative::parse.map(Item::Relative),
             weekday::parse.map(Item::Weekday),
             offset::parse.map(Item::Offset),
+            offset::parse_local.map(|()| Item::LocalZone),
             pure::parse.map(Item::Pure),
         )),
     )
@@ -277,12 +303,13 @@ fn expect_error(input: &mut &str, reason: &'static str) -> ErrMode<ContextError>
 
 #[cfg(test)]
 mod tests {
+    use crate::ParsedDateTime;
     use jiff::{civil::DateTime, tz::TimeZone, ToSpan, Zoned};
 
     use super::*;
 
     fn at_date(builder: DateTimeBuilder, base: Zoned) -> Zoned {
-        builder.set_base(base).build().unwrap()
+        builder.set_base(base).build().unwrap().expect_in_range()
     }
 
     fn at_utc(builder: DateTimeBuilder) -> Zoned {
@@ -299,6 +326,22 @@ mod tests {
             .to_string()
     }
 
+    fn assert_extended_datetime(input: &str, base: Zoned, expected: &str) {
+        let parsed = parse_at_date(base, input).unwrap();
+        assert!(
+            matches!(parsed, ParsedDateTime::Extended(_)),
+            "expected extended datetime, got in-range for: {input}"
+        );
+        assert_eq!(parsed.to_string(), expected, "{input}");
+    }
+
+    fn expect_extended_datetime(parsed: ParsedDateTime) -> crate::ExtendedDateTime {
+        match parsed {
+            ParsedDateTime::Extended(dt) => dt,
+            ParsedDateTime::InRange(z) => panic!("expected extended datetime, got in-range: {z}"),
+        }
+    }
+
     #[test]
     fn date_and_time() {
         assert_eq!(
@@ -360,12 +403,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn date_and_time_ampm() {
+        // https://github.com/uutils/parse_datetime/issues/282
+        assert_eq!("12:00", test_eq_fmt("%H:%M", "2024-06-15 12:00 PM"));
+        assert_eq!("11:30", test_eq_fmt("%H:%M", "2024-06-15 11:30am"));
+        assert_eq!("15:00", test_eq_fmt("%H:%M", "2024-06-15 3:00 PM"));
+    }
+
     #[test]
     fn empty() {
         let result = parse(&mut "");
         assert!(result.is_ok());
     }
 
+    #[test]
+    fn whitespace_only() {
+        let result = parse(&mut "\x0B \x0C");
+        assert!(result.is_ok());
+    }
+
     #[test]
     fn invalid() {
         let result = parse(&mut "2025-05-19 2024-05-20 06:14:49");
@@ -408,13 +465,12 @@ mod tests {
         let result = parse(&mut "2025-05-19 @1690466034");
         assert!(result.is_err());
 
-        // Pure number as year (too large).
+        // Pure number as year (large years are accepted).
         let result = parse(&mut "jul 18 12:30 10000");
-        assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("year must be no greater than 9999"));
+        assert!(result.is_ok());
+        let built = result.unwrap().build().unwrap();
+        let dt = expect_extended_datetime(built);
+        assert_eq!(dt.year, 10000);
 
         // Pure number as time (too long).
         let result = parse(&mut "01:02 12345");
@@ -449,6 +505,184 @@ mod tests {
             .contains("invalid minute in pure number"));
     }
 
+    #[test]
+    fn negative_base_year_with_yearless_date_errors() {
+        let base = DateTime::new(-1, 1, 1, 0, 0, 0, 0)
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let result = parse_at_date(base, "11/14");
+        assert!(result.is_err());
+        assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("base year must be non-negative"));
+    }
+
+    #[test]
+    fn boundary_rollover_from_9999_falls_back_to_extended() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("9999-12-31 +1 day", base, "10000-01-01 00:00:00+00:00");
+    }
+
+    #[test]
+    fn boundary_year_9999_absolute_date_parses() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("9999-12-31", base, "9999-12-31 00:00:00+00:00");
+    }
+
+    #[test]
+    fn boundary_year_9999_with_time_parses() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("9999-12-31 12:00", base, "9999-12-31 12:00:00+00:00");
+    }
+
+    #[test]
+    fn boundary_year_9999_with_utc_timezone_parses() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("9999-12-31 12:00 UTC", base, "9999-12-31 12:00:00+00:00");
+    }
+
+    #[test]
+    fn boundary_year_9999_with_explicit_offset_parses() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("9999-12-31 12:00 +01:00", base, "9999-12-31 12:00:00+01:00");
+    }
+
+    #[test]
+    fn large_year_relative_parity_months_and_years() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+
+        assert_extended_datetime(
+            "10000-01-31 +2 months",
+            base.clone(),
+            "10000-03-31 00:00:00+00:00",
+        );
+        assert_extended_datetime(
+            "10000-01-31 +3 months",
+            base.clone(),
+            "10000-05-01 00:00:00+00:00",
+        );
+        assert_extended_datetime(
+            "10000-08-31 +6 months",
+            base.clone(),
+            "10001-03-03 00:00:00+00:00",
+        );
+        assert_extended_datetime(
+            "10000-05-31 3 months ago",
+            base.clone(),
+            "10000-03-02 00:00:00+00:00",
+        );
+        assert_extended_datetime("10000-02-29 +1 year", base, "10001-03-01 00:00:00+00:00");
+    }
+
+    #[test]
+    fn rejects_year_above_gnu_max() {
+        assert!(parse_at_local("2147485548-01-01").is_err());
+    }
+
+    #[test]
+    fn large_year_can_return_in_range_after_relative() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let result = parse_at_date(base, "10000-01-01 -1000 years").unwrap();
+        let z = result.expect_in_range();
+        assert_eq!(
+            z.strftime("%Y-%m-%d %H:%M:%S%:z").to_string(),
+            "9000-01-01 00:00:00+00:00"
+        );
+    }
+
+    #[test]
+    fn large_year_can_return_in_range_after_relative_with_named_timezone_rule() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let result = parse_at_date(base, "TZ=\"Europe/Paris\" 10000-01-01 -1000 years").unwrap();
+        let z = result.expect_in_range();
+        assert_eq!(
+            z.strftime("%Y-%m-%d %H:%M:%S%:z").to_string(),
+            "9000-01-01 00:00:00+01:00"
+        );
+    }
+
+    #[test]
+    fn large_year_time_with_explicit_offset_is_extended() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let dt =
+            expect_extended_datetime(parse_at_date(base, "10000-01-01 12:34:56+02:00").unwrap());
+        assert_eq!((dt.year, dt.month, dt.day), (10000, 1, 1));
+        assert_eq!((dt.hour, dt.minute, dt.second), (12, 34, 56));
+        assert_eq!(dt.offset_seconds, 2 * 3600);
+    }
+
+    #[test]
+    fn parse_at_date_returns_error_for_invalid_input() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let result = parse_at_date(base, "not-a-date");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    #[should_panic(expected = "expected extended datetime")]
+    fn assert_extended_datetime_panics_for_in_range_input() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        assert_extended_datetime("2001-01-01", base, "2001-01-01 00:00:00+00:00");
+    }
+
+    #[test]
+    #[should_panic(expected = "ParsedDateTime is not representable as jiff::Zoned")]
+    fn expect_in_range_panics_for_extended_input() {
+        let base = "2000-01-01 00:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+        let parsed = parse_at_date(base, "10000-01-01").unwrap();
+        let _ = parsed.expect_in_range();
+    }
+
     #[test]
     fn relative_weekday() {
         // Jan 1 2025 is a Wed
@@ -530,6 +764,45 @@ mod tests {
         assert_eq!(result.second(), 0);
     }
 
+    #[test]
+    fn offset_followed_by_relative() {
+        let base = "2000-01-01 12:00:00"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+
+        // Both read "+8 years" as a relative item, not as an offset of +8.
+        for input in ["UTC +8 years", "+8 years"] {
+            let result = parse_at_date(base.clone(), input).unwrap();
+            assert_eq!(result.to_string(), "2008-01-01 12:00:00+00:00", "{input}");
+        }
+    }
+
+    #[test]
+    fn comments_and_ignored_signs() {
+        let base = "2000-06-15 12:34:56"
+            .parse::<DateTime>()
+            .unwrap()
+            .to_zoned(TimeZone::UTC)
+            .unwrap();
+
+        for (input, expected) in [
+            ("1997-01-01 (foo) 10:00", "1997-01-01 10:00:00+00:00"),
+            ("1997-01-01 (a (b)) 10:00", "1997-01-01 10:00:00+00:00"),
+            ("(foo) 1997-01-01", "1997-01-01 00:00:00+00:00"),
+            ("+ (c) 1997-01-01", "1997-01-01 00:00:00+00:00"),
+            ("- (c) 1997-01-01", "1997-01-01 00:00:00+00:00"),
+            ("1997-01-01 (x) + 1 day", "1997-01-02 00:00:00+00:00"),
+        ] {
+            let result = parse_at_date(base.clone(), input).unwrap();
+            assert_eq!(result.to_string(), expected, "{input}");
+        }
+
+        // Like GNU, a hyphen followed by a digit is a sign, not ignored.
+        assert!(parse_at_date(base.clone(), "- 1997-01-01").is_err());
+    }
+
     #[test]
     fn pure() {
         let now = Zoned::now().with_time_zone(TimeZone::UTC);
@@ -563,14 +836,44 @@ mod tests {
         for (input, expected) in [
             (
                 r#"TZ="Europe/Paris" 2025-01-02"#,
-                "2025-01-02 00:00:00[Europe/Paris]".parse().unwrap(),
+                "2025-01-02 00:00:00[Europe/Paris]"
+                    .parse::<Zoned>()
+                    .unwrap(),
             ),
             (
                 r#"TZ="Europe/Paris" 2025-01-02 03:04:05"#,
-                "2025-01-02 03:04:05[Europe/Paris]".parse().unwrap(),
+                "2025-01-02 03:04:05[Europe/Paris]"
+                    .parse::<Zoned>()
+                    .unwrap(),
             ),
         ] {
             assert_eq!(parse_build(input), expected, "{input}");
         }
     }
+    /// `j` is a time zone item, so it participates in the same duplicate check
+    /// as a numeric offset. GNU rejects all three of these as a repeated zone.
+    #[test]
+    fn military_j_is_a_timezone_item() {
+        // Parses on its own, attached or spaced, in either case.
+        for input in ["j", "8j", "8 j", "8J", "j 8"] {
+            assert!(parse(&mut &*input).is_ok(), "`{input}` should parse");
+        }
+
+        for input in ["8j utc", "8 utc j", "8 j j"] {
+            let result = parse(&mut &*input);
+            assert!(result.is_err(), "`{input}` should be rejected");
+            assert!(
+                result
+                    .unwrap_err()
+                    .to_string()
+                    .contains("time offset cannot appear more than once"),
+                "`{input}` should report a repeated time offset"
+            );
+        }
+
+        // A bare numeric offset is not an item on its own (the grammar requires
+        // a named zone), so this is rejected by the parser rather than by the
+        // duplicate check. GNU rejects it too.
+        assert!(parse(&mut "j +05:00").is_err());
+    }
 }

src/items/offset.rs

@@ -108,6 +108,15 @@ impl Offset {
             hour_adjustment,
         )
     }
+
+    pub(super) fn total_seconds(&self) -> i32 {
+        let secs = (self.hours as i32) * 3600 + (self.minutes as i32) * 60;
+        if self.negative {
+            -secs
+        } else {
+            secs
+        }
+    }
 }
 
 impl TryFrom<(bool, u8, u8)> for Offset {
@@ -159,46 +168,60 @@ impl Display for Offset {
     }
 }
 
+/// Timezone abbreviations are assumed to be no longer than 6 characters.
+const MAX_TZ_SIZE: usize = 6;
+
 pub(super) fn parse(input: &mut &str) -> ModalResult<Offset> {
     timezone_name_offset.parse_next(input)
 }
 
+/// Parse the military timezone letter `j`.
+///
+/// Every other military letter denotes a fixed offset from UTC, but GNU `date`
+/// defines `j` as local time, which cannot be expressed as an [`Offset`] at
+/// all. It is therefore reported to the builder as its own item.
+///
+/// The whole alphabetic word is consumed before comparing, so `jan` is left to
+/// the date parser rather than being read as `j` followed by `an`, and `jj` is
+/// rejected rather than matching a `j` prefix.
+pub(super) fn parse_local(input: &mut &str) -> ModalResult<()> {
+    s(take_while(1..=MAX_TZ_SIZE, AsChar::is_alpha))
+        .verify(|word: &str| word.eq_ignore_ascii_case("j"))
+        .void()
+        .parse_next(input)
+}
+
 /// Parse a timezone starting with `+` or `-`.
 pub(super) fn timezone_offset(input: &mut &str) -> ModalResult<Offset> {
-    // Strings like "+8 years" are ambiguous, they can either be parsed as a
-    // timezone offset "+8" and a relative time "years", or just a relative time
-    // "+8 years". GNU date parses them the second way, so we do the same here.
-    //
-    // Return early if the input can be parsed as a relative time.
+    // Like GNU, read "+8 years" as a relative item, not as "+8" and "years".
+    // The costlier relative check only runs once an offset has parsed.
+    let start = input.checkpoint();
+    let result = alt((timezone_offset_colon, timezone_offset_colonless)).parse_next(input);
+    if matches!(result, Err(ErrMode::Backtrack(_))) {
+        return result;
+    }
+
+    let end = input.checkpoint();
+    input.reset(&start);
     if peek(relative::parse).parse_next(input).is_ok() {
         return Err(ErrMode::Backtrack(ContextError::new()));
     }
-
-    alt((timezone_offset_colon, timezone_offset_colonless)).parse_next(input)
+    input.reset(&end);
+    result
 }
 
 /// Parse a timezone by name, with an optional numeric offset appended.
 fn timezone_name_offset(input: &mut &str) -> ModalResult<Offset> {
-    /// I'm assuming there are no timezone abbreviations with more
-    /// than 6 charactres
-    const MAX_TZ_SIZE: usize = 6;
     let nextword = s(take_while(1..=MAX_TZ_SIZE, AsChar::is_alpha)).parse_next(input)?;
     let tz = timezone_name_to_offset(nextword)?;
 
-    // Strings like "UTC +8 years" are ambiguous, they can either be parsed as
-    // "UTC+8" and "years", or "UTC" and "+8 years". GNU date parses them the
-    // second way, so we do the same here.
-    //
-    // Only process if the input cannot be parsed as a relative time.
-    if peek(relative::parse).parse_next(input).is_err() {
-        let start = input.checkpoint();
-        if let Ok(other_tz) = timezone_offset.parse_next(input) {
-            let new_tz = tz.merge(other_tz);
-
-            return Ok(new_tz);
-        };
-        input.reset(&start);
-    }
+    // Like GNU, read "UTC +8 years" as "UTC" and "+8 years", not as "UTC+8"
+    // and "years". `timezone_offset` rejects input that parses as relative.
+    let start = input.checkpoint();
+    if let Ok(other_tz) = timezone_offset.parse_next(input) {
+        return Ok(tz.merge(other_tz));
+    };
+    input.reset(&start);
 
     Ok(tz)
 }
@@ -262,78 +285,87 @@ fn timezone_offset_colonless(input: &mut &str) -> ModalResult<Offset> {
 /// https://www.timeanddate.com/time/zones/. GNU date only supports a subset of
 /// these. We support the same subset as GNU date.
 fn timezone_name_to_offset(input: &str) -> ModalResult<Offset> {
-    let mut offset_str = match input {
-        "z" => Ok("+0"),
-        "y" => Ok("-12"),
-        "x" => Ok("-11"),
-        "wet" => Ok("+0"),
-        "west" => Ok("+1"),
-        "wat" => Ok("+1"),
-        "w" => Ok("-10"),
-        "v" => Ok("-9"),
-        "utc" => Ok("+0"),
-        "u" => Ok("-8"),
-        "t" => Ok("-7"),
-        "sst" => Ok("-11"),
-        "sgt" => Ok("+8"),
-        "sast" => Ok("+2"),
-        "s" => Ok("-6"),
-        "r" => Ok("-5"),
-        "q" => Ok("-4"),
-        "pst" => Ok("-8"),
-        "pdt" => Ok("-7"),
-        "p" => Ok("-3"),
-        "o" => Ok("-2"),
-        "nzst" => Ok("+12"),
-        "nzdt" => Ok("+13"),
-        "nst" => Ok("-3:30"),
-        "ndt" => Ok("-2:30"),
-        "n" => Ok("-1"),
-        "mst" => Ok("-7"),
-        "msk" => Ok("+3"),
-        "msd" => Ok("+4"),
-        "mdt" => Ok("-6"),
-        "m" => Ok("+12"),
-        "l" => Ok("+11"),
-        "k" => Ok("+10"),
-        "jst" => Ok("+9"),
-        "ist" => Ok("+5:30"),
-        "i" => Ok("+9"),
-        "hst" => Ok("-10"),
-        "h" => Ok("+8"),
-        "gst" => Ok("+4"),
-        "gmt" => Ok("+0"),
-        "g" => Ok("+7"),
-        "f" => Ok("+6"),
-        "est" => Ok("-5"),
-        "eet" => Ok("+2"),
-        "eest" => Ok("+3"),
-        "edt" => Ok("-4"),
-        "eat" => Ok("+3"),
-        "e" => Ok("+5"),
-        "d" => Ok("+4"),
-        "cst" => Ok("-6"),
-        "clt" => Ok("-4"),
-        "clst" => Ok("-3"),
-        "cet" => Ok("+1"),
-        "cest" => Ok("+2"),
-        "cdt" => Ok("-5"),
-        "cat" => Ok("+2"),
-        "c" => Ok("+3"),
-        "bst" => Ok("+6"),
-        "brt" => Ok("-3"),
-        "brst" => Ok("-2"),
-        "b" => Ok("+2"),
-        "ast" => Ok("-3"),
-        "art" => Ok("-3"),
-        "akst" => Ok("-9"),
-        "akdt" => Ok("-8"),
-        "adt" => Ok("+4"),
-        "a" => Ok("+1"),
-        _ => Err(ErrMode::Backtrack(ContextError::new())),
-    }?;
+    let (negative, hours, minutes) = match input {
+        "z" => (false, 0, 0),
+        "y" => (true, 12, 0),
+        "x" => (true, 11, 0),
+        "wet" => (false, 0, 0),
+        "west" => (false, 1, 0),
+        "wat" => (false, 1, 0),
+        "w" => (true, 10, 0),
+        "v" => (true, 9, 0),
+        "utc" => (false, 0, 0),
+        "ut" => (false, 0, 0),
+        "u" => (true, 8, 0),
+        "t" => (true, 7, 0),
+        "sst" => (true, 12, 0),
+        "sgt" => (false, 8, 0),
+        "sast" => (false, 2, 0),
+        "s" => (true, 6, 0),
+        "r" => (true, 5, 0),
+        "q" => (true, 4, 0),
+        "pst" => (true, 8, 0),
+        "pdt" => (true, 7, 0),
+        "p" => (true, 3, 0),
+        "o" => (true, 2, 0),
+        "nzst" => (false, 12, 0),
+        "nzdt" => (false, 13, 0),
+        "nst" => (true, 3, 30),
+        "ndt" => (true, 2, 30),
+        "n" => (true, 1, 0),
+        "mst" => (true, 7, 0),
+        "msk" => (false, 3, 0),
+        "msd" => (false, 4, 0),
+        "mez" => (false, 1, 0),
+        "mesz" => (false, 2, 0),
+        "mest" => (false, 2, 0),
+        "mdt" => (true, 6, 0),
+        "m" => (false, 12, 0),
+        "l" => (false, 11, 0),
+        "kst" => (false, 9, 0),
+        "k" => (false, 10, 0),
+        "jst" => (false, 9, 0),
+        "ist" => (false, 5, 30),
+        "i" => (false, 9, 0),
+        "hst" => (true, 10, 0),
+        "h" => (false, 8, 0),
+        "gst" => (false, 10, 0),
+        "gmt" => (false, 0, 0),
+        "g" => (false, 7, 0),
+        "f" => (false, 6, 0),
+        "est" => (true, 5, 0),
+        "eet" => (false, 2, 0),
+        "eest" => (false, 3, 0),
+        "edt" => (true, 4, 0),
+        "eat" => (false, 3, 0),
+        "e" => (false, 5, 0),
+        "d" => (false, 4, 0),
+        "cst" => (true, 6, 0),
+        "clt" => (true, 4, 0),
+        "clst" => (true, 3, 0),
+        "cet" => (false, 1, 0),
+        "cest" => (false, 2, 0),
+        "cdt" => (true, 5, 0),
+        "cat" => (false, 2, 0),
+        "c" => (false, 3, 0),
+        "bst" => (false, 1, 0),
+        "brt" => (true, 3, 0),
+        "brst" => (true, 2, 0),
+        "b" => (false, 2, 0),
+        "ast" => (true, 4, 0),
+        "art" => (true, 3, 0),
+        "akst" => (true, 9, 0),
+        "akdt" => (true, 8, 0),
+        "adt" => (true, 3, 0),
+        "a" => (false, 1, 0),
+        _ => return Err(ErrMode::Backtrack(ContextError::new())),
+    };
 
-    timezone_offset(&mut offset_str)
+    Ok(Offset {
+        negative,
+        hours,
+        minutes,
+    })
 }
 
 #[cfg(test)]
@@ -414,12 +446,25 @@ mod tests {
     fn timezone_name_without_offset() {
         for (input, expected) in [
             ("utc", off(false, 0, 0)),  // UTC
+            ("ut", off(false, 0, 0)),   // Universal Time = UTC (issue #280)
             ("gmt", off(false, 0, 0)),  // UTC
             ("z", off(false, 0, 0)),    // UTC
             ("west", off(false, 1, 0)), // positive offset
             ("cst", off(true, 6, 0)),   // negative offset
             ("ist", off(false, 5, 30)), // positive offset with non-zero minutes
             ("nst", off(true, 3, 30)),  // negative offset with non-zero minutes
+            // Accepted by GNU date but previously missing here, which made
+            // `date -d "2024-01-15 12:00 MEZ"` fail (uutils/coreutils#13865).
+            ("mez", off(false, 1, 0)),
+            ("mesz", off(false, 2, 0)),
+            ("mest", off(false, 2, 0)),
+            ("kst", off(false, 9, 0)),
+            // Corrected to the offsets GNU date assigns these abbreviations.
+            ("adt", off(true, 3, 0)),   // Atlantic Daylight, was +4
+            ("ast", off(true, 4, 0)),   // Atlantic Standard, was -3
+            ("bst", off(false, 1, 0)),  // British Summer, was +6
+            ("gst", off(false, 10, 0)), // Guam Standard, was +4
+            ("sst", off(true, 12, 0)),  // was -11
             ("z123", off(false, 0, 0)), // space separator can be ignored if immediately followed by digits (GNU date behavior)
         ] {
             let mut s = input;
@@ -465,4 +510,57 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn offset_followed_by_relative() {
+        // "+8 years" is a relative item, so it is not an offset.
+        let mut s = "+8 years";
+        assert!(timezone_offset(&mut s).is_err());
+        assert_eq!(s, "+8 years");
+
+        // "utc +8 years" is "utc" followed by the relative item "+8 years".
+        let mut s = "utc +8 years";
+        assert_eq!(timezone_name_offset(&mut s).unwrap(), off(false, 0, 0));
+        assert_eq!(s, " +8 years");
+
+        // Without a relative item, the offset is still merged.
+        let mut s = "utc +8";
+        assert_eq!(timezone_name_offset(&mut s).unwrap(), off(false, 8, 0));
+        assert!(s.is_empty());
+    }
+
+    #[test]
+    fn total_seconds() {
+        assert_eq!(off(false, 0, 0).total_seconds(), 0);
+        assert_eq!(off(false, 5, 30).total_seconds(), 19_800);
+        assert_eq!(off(true, 5, 30).total_seconds(), -19_800);
+        assert_eq!(off(false, 24, 0).total_seconds(), 86_400);
+    }
+    /// `j` is the one military letter that is not an offset, so it is parsed
+    /// separately. The whole alphabetic word must be consumed before matching,
+    /// otherwise `jan` would be read as `j` followed by `an`.
+    #[test]
+    fn military_letter_j_local() {
+        for input in ["j", "J", " j"] {
+            let mut s = input;
+            assert!(
+                parse_local(&mut s).is_ok(),
+                "`{input}` should parse as local time"
+            );
+            assert!(s.is_empty(), "`{input}` should be fully consumed");
+        }
+
+        for input in ["jj", "jan", "jst", "z", "a", ""] {
+            let mut s = input;
+            assert!(
+                parse_local(&mut s).is_err(),
+                "`{input}` should not parse as local time"
+            );
+        }
+
+        // `j` is absent from the offset table, so the offset parser must not
+        // claim it.
+        let mut s = "j";
+        assert!(timezone_name_offset(&mut s).is_err());
+    }
 }

src/items/ordinal.rs

@@ -35,7 +35,7 @@ fn text_ordinal(input: &mut &str) -> ModalResult<i32> {
                 "fifth" => 5,
                 "sixth" => 6,
                 "seventh" => 7,
-                "eight" => 8,
+                "eighth" => 8,
                 "ninth" => 9,
                 "tenth" => 10,
                 "eleventh" => 11,
@@ -45,3 +45,39 @@ fn text_ordinal(input: &mut &str) -> ModalResult<i32> {
         })
         .parse_next(input)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::ordinal;
+
+    #[test]
+    fn text_ordinal() {
+        for (s, expected) in [
+            ("last", -1),
+            ("this", 0),
+            ("next", 1),
+            ("first", 1),
+            ("third", 3),
+            ("fourth", 4),
+            ("fifth", 5),
+            ("sixth", 6),
+            ("seventh", 7),
+            ("eighth", 8),
+            ("ninth", 9),
+            ("tenth", 10),
+            ("eleventh", 11),
+            ("twelfth", 12),
+        ] {
+            let mut input = s;
+            assert_eq!(ordinal(&mut input).unwrap(), expected, "{s}");
+            assert!(input.is_empty(), "{s}");
+        }
+    }
+
+    #[test]
+    fn invalid_text_ordinal() {
+        for mut s in ["eight", "second", "foo"] {
+            assert!(ordinal(&mut s).is_err(), "{s}");
+        }
+    }
+}

src/items/primitive.rs

@@ -6,7 +6,7 @@
 use std::str::FromStr;
 
 use winnow::{
-    ascii::{digit1, multispace0, Uint},
+    ascii::{digit1, Uint},
     combinator::{alt, delimited, not, opt, peek, preceded, repeat, separated},
     error::{ContextError, ParserError, StrContext, StrContextValue},
     stream::AsChar,
@@ -26,6 +26,29 @@ where
     preceded(space, p)
 }
 
+/// Same as winnow's `multispace0`, but also accepting `\v` and `\f`, like
+/// the whitespace GNU `date` accepts between tokens
+fn multispace0<'a, E>(input: &mut &'a str) -> winnow::Result<&'a str, E>
+where
+    E: ParserError<&'a str>,
+{
+    let len = input
+        .bytes()
+        .take_while(|b| matches!(b, b' ' | b'\t' | b'\n' | b'\x0B' | b'\x0C' | b'\r'))
+        .count();
+    let (ws, rest) = input.split_at(len);
+    *input = rest;
+    Ok(ws)
+}
+
+/// Same as [`multispace0`], but requiring at least one character
+pub(super) fn multispace1<'a, E>(input: &mut &'a str) -> winnow::Result<&'a str, E>
+where
+    E: ParserError<&'a str>,
+{
+    take_while(1.., (' ', '\t', '\n', '\x0B', '\x0C', '\r')).parse_next(input)
+}
+
 /// Parse the space in-between tokens
 ///
 /// You probably want to use the [`s`] combinator instead.
@@ -33,6 +56,11 @@ pub(super) fn space<'a, E>(input: &mut &'a str) -> winnow::Result<(), E>
 where
     E: ParserError<&'a str>,
 {
+    // Fast path: most calls see no comment or ignorable sign
+    multispace0.parse_next(input)?;
+    if !input.starts_with(['(', '-', '+']) {
+        return Ok(());
+    }
     separated(0.., multispace0, alt((comment, ignored_hyphen_or_plus))).parse_next(input)
 }
 
@@ -142,3 +170,87 @@ pub(super) fn ctx_err(reason: &'static str) -> ContextError {
     err.push(StrContext::Expected(StrContextValue::Description(reason)));
     err
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_dec_int() {
+        for (input, expected) in [
+            ("123", 123),                 // positive without sign
+            ("+123", 123),                // positive with '+' sign
+            ("-123", -123),               // negative with '-' sign
+            ("0", 0),                     // zero
+            ("+0", 0),                    // zero with '+' sign
+            ("-0", 0),                    // zero with '-' sign (parses as 0)
+            ("012", 12),                  // zero-prefixed (the main reason for this function)
+            ("+012", 12),                 // zero-prefixed with '+' sign
+            ("-012", -12),                // zero-prefixed with '-' sign
+            ("00123", 123),               // multiple leading zeros
+            ("2147483647", 2147483647),   // i32::MAX
+            ("-2147483648", -2147483648), // i32::MIN
+        ] {
+            let mut s = input;
+            assert_eq!(
+                dec_int::<ContextError>(&mut s).unwrap(),
+                expected,
+                "{input}"
+            );
+        }
+
+        for input in [
+            "",    // empty string
+            "+",   // sign without digits
+            "-",   // sign without digits
+            "abc", // non-numeric
+            "12a", // starts with digits but has non-digit after (but should parse "12" successfully)
+        ] {
+            let mut s = input;
+            let result = dec_int::<ContextError>(&mut s);
+            // Note: "12a" will actually succeed and parse "12", leaving "a" unparsed
+            if input == "12a" {
+                assert_eq!(result.unwrap(), 12, "{input}");
+                assert_eq!(s, "a", "Should leave 'a' unparsed");
+            } else {
+                assert!(result.is_err(), "{input} should fail");
+            }
+        }
+
+        // Test overflow cases
+        for input in [
+            "2147483648",  // i32::MAX + 1
+            "-2147483649", // i32::MIN - 1
+            "99999999999", // way too large
+        ] {
+            let mut s = input;
+            assert!(
+                dec_int::<ContextError>(&mut s).is_err(),
+                "{input} should overflow"
+            );
+        }
+    }
+
+    #[test]
+    fn space_skips_comments_and_ignored_signs() {
+        for (input, rest) in [
+            ("", ""),
+            ("abc", "abc"),
+            (" \t abc", "abc"),
+            ("(foo) abc", "abc"),
+            (" (a (b)) abc", "abc"),
+            ("- abc", "abc"),
+            ("+ (c) abc", "abc"),
+            ("- (c) 12", "12"),
+            // A sign followed by a digit is not ignored.
+            ("- 12", "- 12"),
+            (" +12", "+12"),
+            // An unbalanced comment is not skipped.
+            ("(foo abc", "(foo abc"),
+        ] {
+            let mut s = input;
+            space::<ContextError>(&mut s).unwrap();
+            assert_eq!(s, rest, "{input:?}");
+        }
+    }
+}

src/items/relative.rs

@@ -59,9 +59,19 @@ impl TryFrom<Relative> for jiff::Span {
             Relative::Days(days) => jiff::Span::new().try_days(days),
             Relative::Hours(hours) => jiff::Span::new().try_hours(hours),
             Relative::Minutes(minutes) => jiff::Span::new().try_minutes(minutes),
-            Relative::Seconds(seconds, nanoseconds) => jiff::Span::new()
-                .try_seconds(seconds)
-                .and_then(|span| span.try_nanoseconds(nanoseconds)),
+            Relative::Seconds(seconds, nanoseconds) => {
+                // -0.25 is stored as (-1, 750_000_000), but a `jiff::Span` needs
+                // both fields with one sign, so move the fraction onto it.
+                let (seconds, nanoseconds) = if seconds < 0 && nanoseconds > 0 {
+                    (seconds + 1, -i64::from(1_000_000_000 - nanoseconds))
+                } else {
+                    (seconds, i64::from(nanoseconds))
+                };
+
+                jiff::Span::new()
+                    .try_seconds(seconds)
+                    .and_then(|span| span.try_nanoseconds(nanoseconds))
+            }
         }
         .map_err(|_| "relative value is invalid")
     }
@@ -85,7 +95,7 @@ fn seconds(input: &mut &str) -> ModalResult<Relative> {
         opt(alt((s('+').value(1), s('-').value(-1)))),
         s(sec_and_nsec),
         s(alpha1).verify(|s: &str| matches!(s, "seconds" | "second" | "sec" | "secs")),
-        ago,
+        direction,
     )
         .verify_map(|(sign, (sec, nsec), _, ago)| {
             let sec = i64::try_from(sec).ok()?;
@@ -102,7 +112,7 @@ fn seconds(input: &mut &str) -> ModalResult<Relative> {
 }
 
 fn displacement(input: &mut &str) -> ModalResult<Relative> {
-    (opt(ordinal), s(alpha1), ago)
+    (opt(ordinal), s(alpha1), direction)
         .verify_map(|(n, unit, ago): (Option<i32>, &str, bool)| {
             let multiplier = n.unwrap_or(1) * if ago { -1 } else { 1 };
             Some(match unit.strip_suffix('s').unwrap_or(unit) {
@@ -120,8 +130,10 @@ fn displacement(input: &mut &str) -> ModalResult<Relative> {
         .parse_next(input)
 }
 
-fn ago(input: &mut &str) -> ModalResult<bool> {
-    opt(s("ago")).map(|o| o.is_some()).parse_next(input)
+fn direction(input: &mut &str) -> ModalResult<bool> {
+    opt(alt((s("ago").value(true), s("hence").value(false))))
+        .map(|backward| backward.unwrap_or(false))
+        .parse_next(input)
 }
 
 #[cfg(test)]