Merge pull request #248 from cakebaker/bump_version_to_0_13_3

chore: bump version to `0.13.3`
chore: bump version to 0.13.3
2026-06-10 16:13:15 -07:00 · 2025-11-21 10:12:43 +01:00 · 2025-11-21 09:52:19 +01:00 · 2025-11-21 09:49:15 +01:00 · 2025-11-21 09:44:58 +01:00 · 2025-11-21 09:16:18 +01:00
31 changed files with 5329 additions and 692 deletions
@@ -4,6 +4,7 @@ name: Basic CI

 env:
  CARGO_TERM_COLOR: always
+  RUST_MIN_SRV: "1.71.1"

 jobs:
  check:
@@ -13,15 +14,9 @@ jobs:
      matrix:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo check

  test:
    name: cargo test
@@ -30,31 +25,18 @@ jobs:
      matrix:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo test

  fmt:
    name: cargo fmt --all -- --check
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
      - run: rustup component add rustfmt
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - run: cargo fmt --all -- --check

  clippy:
    name: cargo clippy -- -D warnings
@@ -63,17 +45,23 @@ jobs:
      matrix:
        os: [ubuntu-latest, macOS-latest, windows-latest]
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
      - run: rustup component add clippy
-      - uses: actions-rs/cargo@v1
+      - run: cargo clippy --all-targets -- -D warnings
+
+  min_version:
+    name: Minimum Supported Rust Version
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
        with:
-          command: clippy
-          args: -- -D warnings
+          toolchain: ${{ env.RUST_MIN_SRV }}
+      - run: cargo test

  coverage:
    name: Code Coverage
@@ -86,7 +74,7 @@ jobs:
          - { os: macos-latest   , features: macos }
          - { os: windows-latest , features: windows }
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v6
    - name: Initialize workflow variables
      id: vars
      shell: bash
@@ -101,28 +89,22 @@ jobs:
        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
        outputs TOOLCHAIN
        # target-specific options
-        # * CARGO_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='--all -- --check' ;  ## default to '--all-features' for code coverage
        # * CODECOV_FLAGS
        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
        outputs CODECOV_FLAGS

    - name: rust toolchain ~ install
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@nightly
      with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-        default: true
-        profile: minimal # minimal component installation (ie, no documentation)
+        components: llvm-tools-preview
    - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+      run: cargo test --no-fail-fast
      env:
        CARGO_INCREMENTAL: "0"
        RUSTC_WRAPPER: ""
-        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
        RUSTDOCFLAGS: "-Cpanic=abort"
+        LLVM_PROFILE_FILE: "parse_datetime-%p-%m.profraw"
    - name: "`grcov` ~ install"
      id: build_grcov
      shell: bash
@@ -150,17 +132,34 @@ jobs:
        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
        mkdir -p "${COVERAGE_REPORT_DIR}"
        # display coverage files
-        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
+        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 . --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\()"
        echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
    - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+      uses: codecov/codecov-action@v5
      with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
-        file: ${{ steps.coverage.outputs.report }}
+        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
+
+  fuzz:
+    name: Run the fuzzers
+    runs-on: ubuntu-latest
+    env:
+      RUN_FOR: 60
+    steps:
+    - uses: actions/checkout@v6
+    - uses: dtolnay/rust-toolchain@nightly
+    - name: Install `cargo-fuzz`
+      run: cargo install cargo-fuzz
+    - uses: Swatinem/rust-cache@v2
+    - name: Run from_str 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
@@ -0,0 +1 @@
+target/
@@ -4,32 +4,239 @@ version = 3

 [[package]]
 name = "aho-corasick"
-version = "1.0.1"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fc08ce920c31afb70f013dcce1bfc3a3195de6a228474e45e1f145b36f8d04"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
 "memchr",
 ]

 [[package]]
-name = "humantime_to_duration"
-version = "0.1.4"
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
- "regex",
- "time",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]

 [[package]]
-name = "memchr"
-version = "2.5.0"
+name = "futures-task"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-core",
+ "futures-macro",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "indexmap"
+version = "2.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "jiff"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
+dependencies = [
+ "jiff-static",
+ "jiff-tzdb-platform",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+ "windows-sys",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
+]
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "parse_datetime"
+version = "0.13.3"
+dependencies = [
+ "jiff",
+ "num-traits",
+ "rstest",
+ "winnow",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]

 [[package]]
 name = "regex"
-version = "1.8.1"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af83e617f331cc6ae2da5443c602dfa5af81e517212d9d611a5b3ba1777b5370"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -38,28 +245,153 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.7.1"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"

 [[package]]
-name = "serde"
-version = "1.0.160"
+name = "relative-path"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"

 [[package]]
-name = "time"
-version = "0.3.20"
+name = "rstest"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
+checksum = "f5a3193c063baaa2a95a33f03035c8a72b83d97a54916055ba22d35ed3839d49"
 dependencies = [
- "serde",
- "time-core",
+ "futures-timer",
+ "futures-util",
+ "rstest_macros",
 ]

 [[package]]
-name = "time-core"
-version = "0.1.0"
+name = "rstest_macros"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "9c845311f0ff7951c5506121a9ad75aec44d083c31583b2ea5a30bcb0b0abba0"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn",
+ "unicode-ident",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+
+[[package]]
+name = "syn"
+version = "2.0.110"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a197c0ec7d131bfc6f7e82c8442ba1595aeab35da7adbf05b6b73cd06a16b6be"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2ad0b7ae9cfeef5605163839cb9221f453399f15cfb5c10be9885fcf56611f9"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b551886f449aa90d4fe2bdaa9f4a2577ad2dde302c61ecf262d80b116db95c10"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "windows-link"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+dependencies = [
+ "memchr",
+]
@@ -1,12 +1,17 @@
 [package]
-name = "humantime_to_duration"
-description = " parsing human-readable relative time strings and converting them to a Duration"
-version = "0.2.0"
+name = "parse_datetime"
+description = "parsing human-readable time strings and converting them to a DateTime"
+version = "0.13.3"
 edition = "2021"
 license = "MIT"
-repository = "https://github.com/uutils/humantime_to_duration"
+repository = "https://github.com/uutils/parse_datetime"
 readme = "README.md"
+rust-version = "1.71.1"

 [dependencies]
-regex = "1.7"
-time = "0.3.20"
+winnow = "0.7.10"
+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"
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2023 uutils
+Copyright (c) 2023 Sylvestre Ledru and others

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,46 +1,55 @@
-# humantime_to_duration
+# parse_datetime

-[![Crates.io](https://img.shields.io/crates/v/humantime_to_duration.svg)](https://crates.io/crates/humantime_to_duration)
-[![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/humantime_to_duration/blob/main/LICENSE)
-[![CodeCov](https://codecov.io/gh/uutils/humantime_to_duration/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/humantime_to_duration)
+[![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)

-A Rust crate for parsing human-readable relative time strings and converting them to a `Duration`.
+A Rust crate for parsing human-readable relative time strings and human-readable datetime strings and converting them to a jiff's `Zoned` object.

 ## Features

- Parses a variety of human-readable time formats.
+- Parses a variety of human-readable and standard time formats.
 - Supports positive and negative durations.
- Allows for chaining time units (e.g., "1 hour 2 minutes" or "2 days and 2 hours").
+- Allows for chaining time units (e.g., "1 hour 2 minutes" or "2 days 2 hours ago").
 - Calculate durations relative to a specified date.
+- Relies on Jiff

 ## Usage

-Add this to your `Cargo.toml`:
+Add `parse_datetime` to your `Cargo.toml` with:

-```toml
-[dependencies]
-humantime_to_duration = "0.1.1"
+```
+cargo add parse_datetime
 ```

-Then, import the crate and use the `from_str` and `from_str_at_date` functions:
-```
-use humantime_to_duration::{from_str, from_str_at_date};
-use time::Duration;
+Then, import the crate and use the `parse_datetime_at_date` function:

-let duration = from_str("+3 days");
-assert_eq!(duration.unwrap(), Duration::days(3));
+```rs
+use jiff::{ToSpan, Zoned};
+use parse_datetime::parse_datetime_at_date;
+
+let now = Zoned::now();
+let after = parse_datetime_at_date(now.clone(), "+3 days");

-let today = OffsetDateTime::now_utc().date();
-let yesterday = today - Duration::days(1);
 assert_eq!(
-    from_str_at_date(yesterday, "2 days").unwrap(),
-    Duration::days(1)
+  now.checked_add(3.days()).unwrap(),
+  after.unwrap()
 );
 ```

+For DateTime parsing, import the `parse_datetime` function:
+
+```rs
+use jiff::{civil::{date, time} ,Zoned};
+use parse_datetime::parse_datetime;
+
+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());
+```
+
 ### Supported Formats

-The `from_str` and `from_str_at_date` functions support the following formats for relative time:
+The `parse_datetime` and `parse_datetime_at_date` functions support absolute datetime and the following relative times:

 - `num` `unit` (e.g., "-1 hour", "+3 days")
 - `unit` (e.g., "hour", "day")
@@ -48,28 +57,36 @@ The `from_str` and `from_str_at_date` functions support the following formats fo
 - "yesterday"
 - "tomorrow"
 - use "ago" for the past
- combined units with "and" or "," (e.g., "2 years and 1 month", "1 day, 2 hours" or "2 weeks 1 second")
+- use "next" or "last" with `unit` (e.g., "next week", "last year")
+- unix timestamps (for example "@0" "@1344000")

 `num` can be a positive or negative integer.
 `unit` can be one of the following: "fortnight", "week", "day", "hour", "minute", "min", "second", "sec" and their plural forms.

 ## Return Values

-The `from_str` and `from_str_at_date` functions return:
+### parse_datetime and parse_datetime_at_date

- `Ok(Duration)` - If the input string can be parsed as a relative time
- `Err(ParseDurationError)` - If the input string cannot be parsed as a relative time
+The `parse_datetime` and `parse_datetime_at_date` function return:

-This function will return `Err(ParseDurationError::InvalidInput)` if the input string
-cannot be parsed as a relative time.
+- `Ok(Zoned)` - If the input string can be parsed as a `Zoned` object
+- `Err(ParseDateTimeError::InvalidInput)` - If the input string cannot be parsed

 ## Fuzzer

 To run the fuzzer:
+
 ```
-$ cargo fuzz run fuzz_from_str
+$ cd fuzz
+$ cargo install cargo-fuzz
+$ cargo +nightly fuzz run fuzz_parse_datetime
 ```

 ## License

 This project is licensed under the [MIT License](LICENSE).
+
+## Note
+
+At some point, this crate was called humantime_to_duration.
+It has been renamed to cover more cases.
@@ -0,0 +1 @@
+corpus
@@ -1,182 +1,277 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "aho-corasick"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fc08ce920c31afb70f013dcce1bfc3a3195de6a228474e45e1f145b36f8d04"
-dependencies = [
- "memchr",
-]
+version = 4

 [[package]]
 name = "arbitrary"
-version = "1.3.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d098ff73c1ca148721f37baad5ea6a465a13f9573aba8641fbbbae8164a54e"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"

 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.2.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
 dependencies = [
+ "find-msvc-tools",
 "jobserver",
+ "libc",
+ "shlex",
 ]

 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"

 [[package]]
-name = "fuzz_from_str"
-version = "0.1.0"
+name = "find-msvc-tools"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
+
+[[package]]
+name = "fuzz_parse_datetime"
+version = "0.2.0"
 dependencies = [
- "humantime_to_duration",
 "libfuzzer-sys",
- "rand",
- "regex",
- "time",
+ "parse_datetime",
 ]

 [[package]]
 name = "getrandom"
-version = "0.2.9"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
 "cfg-if",
 "libc",
- "wasi",
+ "r-efi",
+ "wasip2",
 ]

 [[package]]
-name = "humantime_to_duration"
-version = "0.1.0"
+name = "jiff"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
 dependencies = [
- "regex",
- "time",
+ "jiff-static",
+ "jiff-tzdb-platform",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+ "windows-sys",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
 ]

 [[package]]
 name = "jobserver"
-version = "0.1.26"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
+ "getrandom",
 "libc",
 ]

 [[package]]
 name = "libc"
-version = "0.2.142"
+version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"

 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.6"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beb09950ae85a0a94b27676cccf37da5ff13f27076aa1adbc6545dd0d0e1bd4e"
+checksum = "5037190e1f70cbeef565bd267599242926f724d3b8a9f510fd7e0b540cfa4404"
 dependencies = [
 "arbitrary",
 "cc",
- "once_cell",
 ]

+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"

 [[package]]
-name = "once_cell"
-version = "1.17.1"
+name = "num-traits"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
+ "autocfg",
 ]

 [[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+name = "parse_datetime"
+version = "0.13.2"
 dependencies = [
- "ppv-lite86",
- "rand_core",
+ "jiff",
+ "num-traits",
+ "winnow",
 ]

 [[package]]
-name = "rand_core"
-version = "0.6.4"
+name = "portable-atomic"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
 dependencies = [
- "getrandom",
+ "portable-atomic",
 ]

 [[package]]
-name = "regex"
-version = "1.8.1"
+name = "proc-macro2"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af83e617f331cc6ae2da5443c602dfa5af81e517212d9d611a5b3ba1777b5370"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.110"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "windows-link"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
- "aho-corasick",
 "memchr",
- "regex-syntax",
 ]

 [[package]]
-name = "regex-syntax"
-version = "0.7.1"
+name = "wit-bindgen"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c"
-
-[[package]]
-name = "serde"
-version = "1.0.160"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
-
-[[package]]
-name = "time"
-version = "0.3.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
-dependencies = [
- "serde",
- "time-core",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
@@ -1,22 +1,19 @@
 [package]
-name = "fuzz_from_str"
-version = "0.1.0"
-edition = "2018"
+name = "fuzz_parse_datetime"
+version = "0.2.0"
+edition = "2021"

 [package.metadata]
 cargo-fuzz = true

 [dependencies]
-rand = "0.8.4"
-libfuzzer-sys = "0.4"
-regex = "1.8.1"
-time = "0.3.20"
+libfuzzer-sys = "0.4.7"

-[dependencies.humantime_to_duration]
+[dependencies.parse_datetime]
 path = "../"

 [[bin]]
-name = "fuzz_from_str"
-path = "fuzz_targets/from_str.rs"
+name = "fuzz_parse_datetime"
+path = "fuzz_targets/parse_datetime.rs"
 test = false
 doc = false
@@ -4,5 +4,5 @@ use libfuzzer_sys::fuzz_target;

 fuzz_target!(|data: &[u8]| {
    let s = std::str::from_utf8(data).unwrap_or("");
-    let _ = humantime_to_duration::from_str(s);
+    let _ = parse_datetime::parse_datetime(s);
 });
@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}
@@ -0,0 +1,321 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use jiff::{civil, Span, Zoned};
+
+use super::{date, epoch, error, offset, relative, time, weekday, year, Item};
+
+/// The builder is used to construct a DateTime object from various components.
+/// The parser creates a `DateTimeBuilder` object with the parsed components,
+/// but without the baseline date and time. So you normally need to set the base
+/// date and time using the `set_base()` method before calling `build()`, or
+/// leave it unset to use the current date and time as the base.
+#[derive(Debug, Default)]
+pub(crate) struct DateTimeBuilder {
+    base: Option<Zoned>,
+    timestamp: Option<epoch::Timestamp>,
+    date: Option<date::Date>,
+    time: Option<time::Time>,
+    weekday: Option<weekday::Weekday>,
+    offset: Option<offset::Offset>,
+    timezone: Option<jiff::tz::TimeZone>,
+    relative: Vec<relative::Relative>,
+}
+
+impl DateTimeBuilder {
+    pub(super) fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the base date and time for the builder. If not set, the current
+    /// date and time will be used.
+    pub(super) fn set_base(mut self, base: Zoned) -> Self {
+        self.base = Some(base);
+        self
+    }
+
+    /// Sets the timezone rule for the builder.
+    ///
+    /// By default, the builder uses the time zone rules indicated by the `TZ`
+    /// environment variable, or the system default rules if `TZ` is not set.
+    /// This method allows overriding the time zone rules.
+    fn set_timezone(mut self, tz: jiff::tz::TimeZone) -> Result<Self, &'static str> {
+        if self.timezone.is_some() {
+            return Err("timezone rule cannot appear more than once");
+        }
+
+        self.timezone = Some(tz);
+        Ok(self)
+    }
+
+    /// Sets a timestamp value. Timestamp values are exclusive to other date/time
+    /// items (date, time, weekday, timezone, relative adjustments).
+    pub(super) fn set_timestamp(mut self, ts: epoch::Timestamp) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot appear more than once");
+        } else if self.date.is_some()
+            || self.time.is_some()
+            || self.weekday.is_some()
+            || self.offset.is_some()
+            || !self.relative.is_empty()
+        {
+            return Err("timestamp cannot be combined with other date/time items");
+        }
+
+        self.timestamp = Some(ts);
+        Ok(self)
+    }
+
+    fn set_date(mut self, date: date::Date) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        } else if self.date.is_some() {
+            return Err("date cannot appear more than once");
+        }
+
+        self.date = Some(date);
+        Ok(self)
+    }
+
+    fn set_time(mut self, time: time::Time) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        } else if self.time.is_some() {
+            return Err("time cannot appear more than once");
+        } else if self.offset.is_some() && time.offset.is_some() {
+            return Err("time offset and timezone are mutually exclusive");
+        }
+
+        self.time = Some(time);
+        Ok(self)
+    }
+
+    fn set_weekday(mut self, weekday: weekday::Weekday) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        } else if self.weekday.is_some() {
+            return Err("weekday cannot appear more than once");
+        }
+
+        self.weekday = Some(weekday);
+        Ok(self)
+    }
+
+    fn set_offset(mut self, timezone: offset::Offset) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        } else if self.offset.is_some()
+            || self.time.as_ref().and_then(|t| t.offset.as_ref()).is_some()
+        {
+            return Err("time offset cannot appear more than once");
+        }
+
+        self.offset = Some(timezone);
+        Ok(self)
+    }
+
+    fn push_relative(mut self, relative: relative::Relative) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        }
+
+        self.relative.push(relative);
+        Ok(self)
+    }
+
+    /// Sets a pure number that can be interpreted as either a year or time
+    /// depending on the current state of the builder.
+    ///
+    /// If a date is already set but lacks a year, the number is interpreted as
+    /// a year. Otherwise, it's interpreted as a time in HHMM, HMM, HH, or H
+    /// format.
+    fn set_pure(mut self, pure: String) -> Result<Self, &'static str> {
+        if self.timestamp.is_some() {
+            return Err("timestamp cannot be combined with other date/time items");
+        }
+
+        if let Some(date) = self.date.as_mut() {
+            if date.year.is_none() {
+                date.year = Some(year::year_from_str(&pure)?);
+                return Ok(self);
+            }
+        }
+
+        let (mut hour_str, mut minute_str) = match pure.len() {
+            1..=2 => (pure.as_str(), "0"),
+            3..=4 => pure.split_at(pure.len() - 2),
+            _ => {
+                return Err("pure number must be 1-4 digits when interpreted as time");
+            }
+        };
+
+        let hour = time::hour24(&mut hour_str).map_err(|_| "invalid hour in pure number")?;
+        let minute = time::minute(&mut minute_str).map_err(|_| "invalid minute in pure number")?;
+
+        let time = time::Time {
+            hour,
+            minute,
+            ..Default::default()
+        };
+        self.set_time(time)
+    }
+
+    /// Build a `Zoned` object from the pieces accumulated in this builder.
+    ///
+    /// Resolution order (mirrors GNU `date` semantics):
+    ///
+    /// 1. Base instant.
+    ///   - a. If `self.base` is provided, start with it.
+    ///   - b. Else if a `timezone` rule is present, start with "now" in that
+    ///     timezone.
+    ///   - c. Else start with current system local time.
+    ///
+    /// 2. Absolute timestamp override.
+    ///   - a. If `self.timestamp` is set, it fully determines the result.
+    ///
+    /// 3. Time of day truncation.
+    ///   - a. If any of date, time, weekday, offset, timezone is set, zero the
+    ///     time of day to 00:00:00 before applying fields.
+    ///
+    /// 4. Fieldwise resolution (applied to the base instant).
+    ///   - a. Apply date. If year is absent in the parsed date, inherit the year
+    ///     from the base instant.
+    ///   - b. Apply time. If time carries an explicit numeric offset, apply the
+    ///     offset before setting time.
+    ///   - c. Apply weekday (e.g., "next Friday" or "last Monday").
+    ///   - d. Apply relative adjustments (e.g., "+3 days", "-2 months").
+    ///   - e. Apply final fixed offset if present.
+    pub(super) fn build(self) -> Result<Zoned, error::Error> {
+        // 1. Choose the base instant.
+        let base = match (self.base, &self.timezone) {
+            (Some(b), _) => b,
+            (None, Some(tz)) => jiff::Timestamp::now().to_zoned(tz.clone()),
+            (None, None) => Zoned::now(),
+        };
+
+        // 2. Absolute timestamp override everything else.
+        if let Some(ts) = self.timestamp {
+            let ts = jiff::Timestamp::try_from(ts)?;
+            return Ok(ts.to_zoned(base.offset().to_time_zone()));
+        }
+
+        // 3. Determine whether to truncate the time of day.
+        let need_midnight = self.date.is_some()
+            || self.time.is_some()
+            || self.weekday.is_some()
+            || self.offset.is_some()
+            || self.timezone.is_some();
+
+        let mut dt = if need_midnight {
+            base.with().time(civil::time(0, 0, 0, 0)).build()?
+        } else {
+            base
+        };
+
+        // 4a. Apply date.
+        if let Some(date) = self.date {
+            let d: civil::Date = if date.year.is_some() {
+                date.try_into()?
+            } else {
+                date.with_year(dt.date().year() as u16).try_into()?
+            };
+            dt = dt.with().date(d).build()?;
+        }
+
+        // 4b. Apply time.
+        if let Some(time) = self.time.clone() {
+            if let Some(offset) = &time.offset {
+                dt = dt.datetime().to_zoned(offset.try_into()?)?;
+            }
+
+            let t: civil::Time = time.try_into()?;
+            dt = dt.with().time(t).build()?;
+        }
+
+        // 4c. Apply weekday.
+        if let Some(weekday::Weekday { mut offset, day }) = self.weekday {
+            if self.time.is_none() {
+                dt = dt.with().time(civil::time(0, 0, 0, 0)).build()?;
+            }
+
+            let target = day.into();
+
+            // If the current day is not the target day, we need to adjust
+            // the x value to ensure we find the correct day.
+            //
+            // Consider this:
+            // Assuming today is Monday, next Friday is actually THIS Friday;
+            // but next Monday is indeed NEXT Monday.
+            if dt.date().weekday() != target && offset > 0 {
+                offset -= 1;
+            }
+
+            // Calculate the delta to the target day.
+            //
+            // Assuming today is Thursday, here are some examples:
+            //
+            // Example 1: last Thursday (x = -1, day = Thursday)
+            //            delta = (3 - 3) % 7 + (-1) * 7 = -7
+            //
+            // Example 2: last Monday (x = -1, day = Monday)
+            //            delta = (0 - 3) % 7 + (-1) * 7 = -3
+            //
+            // Example 3: next Monday (x = 1, day = Monday)
+            //            delta = (0 - 3) % 7 + (0) * 7 = 4
+            // (Note that we have adjusted the x value above)
+            //
+            // Example 4: next Thursday (x = 1, day = Thursday)
+            //            delta = (3 - 3) % 7 + (1) * 7 = 7
+            let delta = (target.since(civil::Weekday::Monday) as i32
+                - dt.date().weekday().since(civil::Weekday::Monday) as i32)
+                .rem_euclid(7)
+                + offset.checked_mul(7).ok_or("multiplication overflow")?;
+
+            dt = dt.checked_add(Span::new().try_days(delta)?)?;
+        }
+
+        // 4d. Apply relative adjustments.
+        for rel in self.relative {
+            dt = dt.checked_add::<Span>(if let relative::Relative::Months(x) = rel {
+                // *NOTE* This is done in this way to conform to GNU behavior.
+                let days = dt.date().last_of_month().day() as i32;
+                Span::new().try_days(days.checked_mul(x).ok_or("multiplication overflow")?)?
+            } else {
+                rel.try_into()?
+            })?;
+        }
+
+        // 4e. Apply final fixed offset.
+        if let Some(offset) = self.offset {
+            let (offset, hour_adjustment) = offset.normalize();
+            dt = dt.checked_add(Span::new().hours(hour_adjustment))?;
+            dt = dt.datetime().to_zoned((&offset).try_into()?)?;
+        }
+
+        Ok(dt)
+    }
+}
+
+impl TryFrom<Vec<Item>> for DateTimeBuilder {
+    type Error = &'static str;
+
+    fn try_from(items: Vec<Item>) -> Result<Self, Self::Error> {
+        let mut builder = DateTimeBuilder::new();
+
+        for item in items {
+            builder = match item {
+                Item::Timestamp(ts) => builder.set_timestamp(ts)?,
+                Item::DateTime(dt) => builder.set_date(dt.date)?.set_time(dt.time)?,
+                Item::Date(d) => builder.set_date(d)?,
+                Item::Time(t) => builder.set_time(t)?,
+                Item::Weekday(weekday) => builder.set_weekday(weekday)?,
+                Item::Offset(offset) => builder.set_offset(offset)?,
+                Item::Relative(rel) => builder.push_relative(rel)?,
+                Item::TimeZone(tz) => builder.set_timezone(tz)?,
+                Item::Pure(pure) => builder.set_pure(pure)?,
+            }
+        }
+
+        Ok(builder)
+    }
+}
@@ -0,0 +1,76 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parse an ISO 8601 date and time item
+//!
+//! The GNU docs state:
+//!
+//! > The ISO 8601 date and time of day extended format consists of an ISO 8601
+//! > date, a ‘T’ character separator, and an ISO 8601 time of day. This format
+//! > is also recognized if the ‘T’ is replaced by a space.
+//! >
+//! > In this format, the time of day should use 24-hour notation. Fractional
+//! > seconds are allowed, with either comma or period preceding the fraction.
+//! > ISO 8601 fractional minutes and hours are not supported. Typically, hosts
+//! > support nanosecond timestamp resolution; excess precision is silently
+//! > discarded.
+use winnow::{
+    combinator::{alt, trace},
+    seq, ModalResult, Parser,
+};
+
+use crate::items::space;
+
+use super::{date, primitive::s, time};
+
+#[derive(PartialEq, Debug, Clone, Default)]
+pub(crate) struct DateTime {
+    pub(crate) date: date::Date,
+    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)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{parse, DateTime};
+    use crate::items::{date::Date, time::Time};
+
+    #[test]
+    fn some_date() {
+        let reference = Some(DateTime {
+            date: Date {
+                day: 10,
+                month: 10,
+                year: Some(2022),
+            },
+            time: Time {
+                hour: 10,
+                minute: 10,
+                second: 55,
+                nanosecond: 0,
+                offset: None,
+            },
+        });
+
+        for mut s in [
+            "2022-10-10t10:10:55",
+            "2022-10-10 10:10:55",
+            "2022-10-10    t   10:10:55",
+            "2022-10-10       10:10:55",
+            "2022-10-10  (A comment!) t   10:10:55",
+            "2022-10-10  (A comment!)   10:10:55",
+        ] {
+            let old_s = s.to_owned();
+            assert_eq!(parse(&mut s).ok(), reference, "Failed string: {old_s}")
+        }
+    }
+}
@@ -0,0 +1,137 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parse a timestamp item.
+//!
+//! From the GNU docs:
+//!
+//! > If you precede a number with ‘@’, it represents an internal timestamp as
+//! > a count of seconds.  The number can contain an internal decimal point
+//! > (either ‘.’ or ‘,’); any excess precision not supported by the internal
+//! > representation is truncated toward minus infinity.  Such a number cannot
+//! > be combined with any other date item, as it specifies a complete
+//! > timestamp.
+//! >
+//! >    On most hosts, these counts ignore the presence of leap seconds.  For
+//! > example, on most hosts ‘@1483228799’ represents 2016-12-31 23:59:59 UTC,
+//! > ‘@1483228800’ represents 2017-01-01 00:00:00 UTC, and there is no way to
+//! > represent the intervening leap second 2016-12-31 23:59:60 UTC.
+
+use winnow::{
+    ascii::digit1,
+    combinator::{opt, preceded},
+    token::one_of,
+    ModalResult, Parser,
+};
+
+use super::primitive::{dec_uint, plus_or_minus, s};
+
+/// Represents a timestamp with nanosecond accuracy.
+///
+/// # Invariants
+///
+/// - `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)]
+pub(super) struct Timestamp {
+    second: i64,
+    nanosecond: u32,
+}
+
+impl TryFrom<Timestamp> for jiff::Timestamp {
+    type Error = &'static str;
+
+    fn try_from(ts: Timestamp) -> Result<Self, Self::Error> {
+        jiff::Timestamp::new(
+            ts.second,
+            i32::try_from(ts.nanosecond).map_err(|_| "nanosecond in timestamp exceeds i32::MAX")?,
+        )
+        .map_err(|_| "timestamp value is out of valid range")
+    }
+}
+
+/// Parse a timestamp in the form of `@1234567890` or `@-1234567890.12345` or
+/// `@1234567890,12345`.
+pub(super) fn parse(input: &mut &str) -> ModalResult<Timestamp> {
+    (s("@"), opt(plus_or_minus), s(sec_and_nsec))
+        .verify_map(|(_, sign, (sec, nsec))| {
+            let sec = i64::try_from(sec).ok()?;
+            let (second, nanosecond) = match (sign, nsec) {
+                (Some('-'), 0) => (-sec, 0),
+                // Truncate towards minus infinity.
+                (Some('-'), _) => ((-sec).checked_sub(1)?, 1_000_000_000 - nsec),
+                _ => (sec, nsec),
+            };
+            Some(Timestamp { second, nanosecond })
+        })
+        .parse_next(input)
+}
+
+/// Parse a second value in the form of `1234567890` or `1234567890.12345` or
+/// `1234567890,12345`.
+///
+/// The first part represents whole seconds. The optional second part represents
+/// fractional seconds, parsed as a nanosecond value from up to 9 digits
+/// (padded with zeros on the right if fewer digits are present). If the second
+/// part is omitted, it defaults to 0 nanoseconds.
+pub(super) fn sec_and_nsec(input: &mut &str) -> ModalResult<(u64, u32)> {
+    (dec_uint, opt(preceded(one_of(['.', ',']), digit1)))
+        .verify_map(|(sec, opt_nsec_str)| match opt_nsec_str {
+            Some(nsec_str) if nsec_str.len() >= 9 => Some((sec, nsec_str[..9].parse().ok()?)),
+            Some(nsec_str) => {
+                let multiplier = 10_u32.pow(9 - nsec_str.len() as u32);
+                Some((sec, nsec_str.parse::<u32>().ok()?.checked_mul(multiplier)?))
+            }
+            None => Some((sec, 0)),
+        })
+        .parse_next(input)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ts(second: i64, nanosecond: u32) -> Timestamp {
+        Timestamp { second, nanosecond }
+    }
+
+    #[test]
+    fn parse_sec_and_nsec() {
+        for (input, expected) in [
+            ("1234567890", (1234567890, 0)),                       // only seconds
+            ("1234567890.12345", (1234567890, 123450000)), // seconds and nanoseconds, '.' as floating point
+            ("1234567890,12345", (1234567890, 123450000)), // seconds and nanoseconds, ',' as floating point
+            ("1234567890.1234567890123", (1234567890, 123456789)), // nanoseconds with more than 9 digits, truncated
+        ] {
+            let mut s = input;
+            assert_eq!(sec_and_nsec(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            ".1234567890", // invalid: no leading seconds
+            "-1234567890", // invalid: negative input not allowed
+        ] {
+            let mut s = input;
+            assert!(sec_and_nsec(&mut s).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn timestamp() {
+        for (input, expected) in [
+            ("@1234567890", ts(1234567890, 0)), // positive seconds, no nanoseconds
+            ("@ 1234567890", ts(1234567890, 0)), // space after '@', positive seconds, no nanoseconds
+            ("@-1234567890", ts(-1234567890, 0)), // negative seconds, no nanoseconds
+            ("@ -1234567890", ts(-1234567890, 0)), // space after '@', negative seconds, no nanoseconds
+            ("@ - 1234567890", ts(-1234567890, 0)), // space after '@' and after '-', negative seconds, no nanoseconds
+            ("@1234567890.12345", ts(1234567890, 123450000)), // positive seconds with nanoseconds, '.' as floating point
+            ("@1234567890,12345", ts(1234567890, 123450000)), // positive seconds with nanoseconds, ',' as floating point
+            ("@-1234567890.12345", ts(-1234567891, 876550000)), // negative seconds with nanoseconds, '.' as floating point
+            ("@1234567890.1234567890123", ts(1234567890, 123456789)), // nanoseconds with more than 9 digits, truncated
+        ] {
+            let mut s = input;
+            assert_eq!(parse(&mut s).unwrap(), expected, "{input}");
+        }
+    }
+}
@@ -0,0 +1,38 @@
+use std::fmt;
+
+use winnow::error::{ContextError, ErrMode};
+
+#[derive(Debug)]
+pub(crate) enum Error {
+    ParseError(String),
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::ParseError(reason) => {
+                write!(f, "{reason}")
+            }
+        }
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(reason: &'static str) -> Self {
+        Error::ParseError(reason.to_owned())
+    }
+}
+
+impl From<ErrMode<ContextError>> for Error {
+    fn from(err: ErrMode<ContextError>) -> Self {
+        Error::ParseError(err.to_string())
+    }
+}
+
+impl From<jiff::Error> for Error {
+    fn from(err: jiff::Error) -> Self {
+        Error::ParseError(err.to_string())
+    }
+}
@@ -0,0 +1,468 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parse an offset item.
+//!
+//! From the GNU docs:
+//!
+//! > A “time zone item” specifies an international time zone, indicated by a
+//! > small set of letters, e.g., ‘UTC’ or ‘Z’ for Coordinated Universal Time.
+//! > Any included periods are ignored.  By following a non-daylight-saving
+//! > time zone by the string ‘DST’ in a separate word (that is, separated by
+//! > some white space), the corresponding daylight saving time zone may be
+//! > specified.  Alternatively, a non-daylight-saving time zone can be
+//! > followed by a time zone correction, to add the two values.  This is
+//! > normally done only for ‘UTC’; for example, ‘UTC+05:30’ is equivalent to
+//! > ‘+05:30’.
+//! >
+//! >    Time zone items other than ‘UTC’ and ‘Z’ are obsolescent and are not
+//! > recommended, because they are ambiguous; for example, ‘EST’ has a
+//! > different meaning in Australia than in the United States, and ‘A’ has
+//! > different meaning as a military time zone than as an obsolete RFC 822
+//! > time zone.  Instead, it's better to use unambiguous numeric time zone
+//! > corrections like ‘-0500’, as described in the previous section.
+//! >
+//! >    If neither a time zone item nor a time zone correction is supplied,
+//! > timestamps are interpreted using the rules of the default time zone.
+
+use std::fmt::Display;
+
+use winnow::{
+    combinator::{alt, peek},
+    error::{ContextError, ErrMode},
+    stream::{AsChar, Stream},
+    token::take_while,
+    ModalResult, Parser,
+};
+
+use super::{
+    primitive::{colon, ctx_err, dec_uint, dec_uint_str, plus_or_minus, s},
+    relative,
+};
+
+/// Represents a time zone offset from UTC.
+///
+/// This struct is used to represent a time zone offset in hours and minutes,
+/// with a boolean indicating whether the offset is negative (i.e., west of
+/// UTC).
+#[derive(PartialEq, Debug, Clone, Default)]
+pub(super) struct Offset {
+    negative: bool,
+    hours: u8,
+    minutes: u8,
+}
+
+impl Offset {
+    /// Merge two timezone offsets.
+    ///
+    /// Note: when parsing an offset from a string (e.g., "+08:00"), the hours
+    /// and minutes are validated to ensure they fall within valid bounds. In
+    /// contrast, merging two offsets does not perform such validation. This
+    /// behavior is intentional to match GNU date.
+    fn merge(self, offset: Offset) -> Offset {
+        fn combine(a: u16, neg_a: bool, b: u16, neg_b: bool) -> (u16, bool) {
+            if neg_a == neg_b {
+                (a + b, neg_a)
+            } else if a > b {
+                (a - b, neg_a)
+            } else {
+                (b - a, neg_b)
+            }
+        }
+        let (total_minutes, negative) = combine(
+            (self.hours as u16) * 60 + (self.minutes as u16),
+            self.negative,
+            (offset.hours as u16) * 60 + (offset.minutes as u16),
+            offset.negative,
+        );
+        let hours = (total_minutes / 60) as u8;
+        let minutes = (total_minutes % 60) as u8;
+
+        Offset {
+            negative,
+            hours,
+            minutes,
+        }
+    }
+
+    /// Normalize the offset so that the hour field is within the accepted range.
+    ///
+    /// - If the hour field is less than 24, or exactly 24 with a zero minute,
+    ///   the offset is already normalized, and the function returns the offset
+    ///   itself along with a zero hour adjustment.
+    /// - Otherwise, the hour field is reduced to 23 while preserving the minute
+    ///   field, and the function returns the normalized offset along with the
+    ///   hour adjustment needed to reach the original offset.
+    pub(super) fn normalize(self) -> (Offset, i8) {
+        if self.hours < 24 || (self.hours == 24 && self.minutes == 0) {
+            return (self, 0);
+        }
+
+        let hour_adjustment = (self.hours as i8 - 23) * if self.negative { 1 } else { -1 };
+        (
+            Offset {
+                negative: self.negative,
+                hours: 23,
+                minutes: self.minutes,
+            },
+            hour_adjustment,
+        )
+    }
+}
+
+impl TryFrom<(bool, u8, u8)> for Offset {
+    type Error = &'static str;
+
+    fn try_from((negative, hours, minutes): (bool, u8, u8)) -> Result<Self, Self::Error> {
+        if hours > 24 {
+            return Err("timezone hour must be between 0 and 24");
+        }
+        if minutes > 60 || (hours == 24 && minutes != 0) {
+            return Err("timezone minute must be between 0 and 60");
+        }
+
+        Ok(Offset {
+            negative,
+            hours,
+            minutes,
+        })
+    }
+}
+
+impl TryFrom<&Offset> for jiff::tz::TimeZone {
+    type Error = &'static str;
+
+    fn try_from(
+        Offset {
+            negative,
+            hours,
+            minutes,
+        }: &Offset,
+    ) -> Result<Self, Self::Error> {
+        let secs = (*hours as i32) * 3600 + (*minutes as i32) * 60;
+        let secs = if *negative { -secs } else { secs };
+
+        let offset = jiff::tz::Offset::from_seconds(secs).map_err(|_| "offset is invalid")?;
+        Ok(jiff::tz::TimeZone::fixed(offset))
+    }
+}
+
+impl Display for Offset {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(
+            fmt,
+            "{}{:02}:{:02}",
+            if self.negative { "-" } else { "+" },
+            self.hours,
+            self.minutes
+        )
+    }
+}
+
+pub(super) fn parse(input: &mut &str) -> ModalResult<Offset> {
+    timezone_name_offset.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.
+    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)
+}
+
+/// 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);
+    }
+
+    Ok(tz)
+}
+
+/// Parse a timezone offset with a colon separating hours and minutes, e.g.,
+/// `+08:00`, `+8:00`, `+8:0`.
+fn timezone_offset_colon(input: &mut &str) -> ModalResult<Offset> {
+    (plus_or_minus, s(dec_uint), s(colon), s(dec_uint))
+        .parse_next(input)
+        .and_then(|(sign, hours, _, minutes)| {
+            (sign == '-', hours, minutes)
+                .try_into()
+                .map_err(|e| ErrMode::Cut(ctx_err(e)))
+        })
+}
+
+/// Parse a timezone offset without colon, e.g., `+0800`, `+800`, `+08`, `+8`.
+fn timezone_offset_colonless(input: &mut &str) -> ModalResult<Offset> {
+    (plus_or_minus, s(dec_uint_str))
+        .verify_map(|(sign, s)| {
+            // GNU date accepts numeric offset strings with leading zeroes. For
+            // example, `+000000110` is valid. In such cases, the string is
+            // truncated to the last four characters. Thus, `+000000110` becomes
+            // `+0110` (note that one leading zero is kept).
+            let s = if s.len() > 4 && s.trim_start_matches('0').len() <= 4 {
+                &s[s.len() - 4..]
+            } else {
+                s
+            };
+
+            // Hour and minute values are dependent on the length of the string.
+            // For example:
+            //
+            // - "5"   -> 05:00
+            // - "05"  -> 05:00
+            // - "530" -> 05:30 (the minute is the last two characters here)
+            // - "0530"-> 05:30
+            // - "0000530" -> 05:30
+            let (h_str, m_str) = match s.len() {
+                1 | 2 => (s, "0"),
+                3 => s.split_at(1),
+                4 => s.split_at(2),
+                _ => return None,
+            };
+
+            let hours = h_str.parse::<u8>().ok()?;
+            let minutes = m_str.parse::<u8>().ok()?;
+            Some((sign, hours, minutes))
+        })
+        .parse_next(input)
+        .and_then(|(sign, hours, minutes)| {
+            (sign == '-', hours, minutes)
+                .try_into()
+                .map_err(|e| ErrMode::Cut(ctx_err(e)))
+        })
+}
+
+/// Named timezone list.
+///
+/// The full list of timezones can be extracted from
+/// 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())),
+    }?;
+
+    timezone_offset(&mut offset_str)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn off(negative: bool, hours: u8, minutes: u8) -> Offset {
+        Offset {
+            negative,
+            hours,
+            minutes,
+        }
+    }
+
+    #[test]
+    fn timezone_offset_with_colon() {
+        for (input, expected) in [
+            ("+00:00", off(false, 0, 0)),        // UTC
+            ("-00:00", off(true, 0, 0)),         // UTC
+            ("+01:00", off(false, 1, 0)),        // positive offset
+            ("-06:00", off(true, 6, 0)),         // negative offset
+            ("+05:30", off(false, 5, 30)),       // positive offset with non-zero minutes
+            ("-03:30", off(true, 3, 30)),        // negative offset with non-zero minutes
+            ("- 06:00", off(true, 6, 0)),        // space after sign
+            ("- 06 : 00", off(true, 6, 0)),      // space around colon
+            ("+5:3", off(false, 5, 3)),          // single-digit hours and single-digit minutes
+            ("+5:03", off(false, 5, 3)),         // single-digit hours
+            ("+05:3", off(false, 5, 3)),         // single-digit minutes
+            ("+00005:00030", off(false, 5, 30)), // leading zeroes in hours and minutes
+            ("+00:00abc", off(false, 0, 0)), // space separator can be ignored if immediately followed by alphas (GNU date behavior)
+        ] {
+            let mut s = input;
+            assert_eq!(timezone_offset(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            "+25:00", // invalid: hours > 24
+            "-23:61", // invalid: minutes > 60
+            "+24:01", // invalid: minutes > 0 when hours == 24
+        ] {
+            let mut s = input;
+            assert!(timezone_offset(&mut s).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn timezone_offset_without_colon() {
+        for (input, expected) in [
+            ("+0000", off(false, 0, 0)),      // UTC
+            ("-0000", off(true, 0, 0)),       // UTC
+            ("+0100", off(false, 1, 0)),      // positive offset
+            ("-0600", off(true, 6, 0)),       // negative offset
+            ("+0530", off(false, 5, 30)),     // positive offset with non-zero minutes
+            ("-0330", off(true, 3, 30)),      // negative offset with non-zero minutes
+            ("- 0330", off(true, 3, 30)),     // space after sign
+            ("+530", off(false, 5, 30)),      // single-digit hours
+            ("+05", off(false, 5, 0)),        // double-digit hours and no minutes
+            ("+5", off(false, 5, 0)),         // single-digit hours and no minutes
+            ("+00000530", off(false, 5, 30)), // leading zeroes
+            ("+0000abc", off(false, 0, 0)), // space separator can be ignored if immediately followed by alphas (GNU date behavior)
+        ] {
+            let mut s = input;
+            assert_eq!(timezone_offset(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            "+2500",    // invalid: hours > 24
+            "-2361",    // invalid: minutes > 60
+            "+2401",    // invalid: minutes > 0 when hours == 24
+            "+23 days", // invalid: ambiguous with relative time parsing
+        ] {
+            let mut s = input;
+            assert!(timezone_offset(&mut s).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn timezone_name_without_offset() {
+        for (input, expected) in [
+            ("utc", off(false, 0, 0)),  // UTC
+            ("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
+            ("z123", off(false, 0, 0)), // space separator can be ignored if immediately followed by digits (GNU date behavior)
+        ] {
+            let mut s = input;
+            assert_eq!(timezone_name_offset(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            "abc",    // invalid: non-existent timezone
+            "utcabc", // invalid: non-existent timezone
+        ] {
+            let mut s = input;
+            assert!(timezone_name_offset(&mut s).is_err(), "{input}");
+        }
+    }
+
+    #[test]
+    fn timezone_name_with_offset() {
+        for (input, expected) in [
+            ("utc+5:30", off(false, 5, 30)),     // UTC with possitive offset
+            ("utc-5:30", off(true, 5, 30)),      // UTC with negative offset
+            ("utc +5:30", off(false, 5, 30)),    // space after timezone name
+            ("utc + 5 : 30", off(false, 5, 30)), // spaces
+            ("a+5:30", off(false, 6, 30)),       // merge two positive offsets (a=+1)
+            ("a-5:30", off(true, 4, 30)),        // merge positive and negative offsets (a=+1)
+            ("n-5:30", off(true, 6, 30)),        // merge two negative offsets (n=-1)
+            ("n+5:30", off(false, 4, 30)),       // merge negative and positive offsets (n=-1)
+            ("m+24", off(false, 36, 0)),         // maximum possible positive offset (m=+12)
+            ("y-24", off(true, 36, 0)),          // maximum possible negative offset (y=-12)
+        ] {
+            let mut s = input;
+            assert_eq!(timezone_name_offset(&mut s).unwrap(), expected, "{input}");
+        }
+
+        for input in [
+            "abc+08:00",   // invalid: non-existent timezone
+            "utc+25",      // invalid: invalid offset
+            "utc+23 days", // invalid: ambiguous with relative time parsing
+        ] {
+            let mut s = input;
+            assert!(
+                timezone_name_offset(&mut s).is_err() || !s.is_empty(),
+                "{input}"
+            );
+        }
+    }
+}
@@ -0,0 +1,47 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use winnow::{
+    ascii::alpha1,
+    combinator::{alt, opt},
+    ModalResult, Parser,
+};
+
+use super::primitive::{dec_uint, s};
+
+pub(super) fn ordinal(input: &mut &str) -> ModalResult<i32> {
+    alt((text_ordinal, number_ordinal)).parse_next(input)
+}
+
+fn number_ordinal(input: &mut &str) -> ModalResult<i32> {
+    let sign = opt(alt(('+'.value(1), '-'.value(-1)))).map(|s| s.unwrap_or(1));
+    (s(sign), s(dec_uint))
+        .verify_map(|(s, u): (i32, u32)| {
+            let i: i32 = u.try_into().ok()?;
+            Some(s * i)
+        })
+        .parse_next(input)
+}
+
+fn text_ordinal(input: &mut &str) -> ModalResult<i32> {
+    s(alpha1)
+        .verify_map(|s: &str| {
+            Some(match s {
+                "last" => -1,
+                "this" => 0,
+                "next" | "first" => 1,
+                "third" => 3,
+                "fourth" => 4,
+                "fifth" => 5,
+                "sixth" => 6,
+                "seventh" => 7,
+                "eight" => 8,
+                "ninth" => 9,
+                "tenth" => 10,
+                "eleventh" => 11,
+                "twelfth" => 12,
+                _ => return None,
+            })
+        })
+        .parse_next(input)
+}
@@ -0,0 +1,144 @@
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Primitive combinators.
+
+use std::str::FromStr;
+
+use winnow::{
+    ascii::{digit1, multispace0, Uint},
+    combinator::{alt, delimited, not, opt, peek, preceded, repeat, separated},
+    error::{ContextError, ParserError, StrContext, StrContextValue},
+    stream::AsChar,
+    token::{none_of, one_of, take_while},
+    Parser,
+};
+
+/// Allow spaces and comments before a parser
+///
+/// Every token parser should be wrapped in this to allow spaces and comments.
+/// It is only preceding, because that allows us to check mandatory whitespace
+/// after running the parser.
+pub(super) fn s<'a, O, E>(p: impl Parser<&'a str, O, E>) -> impl Parser<&'a str, O, E>
+where
+    E: ParserError<&'a str>,
+{
+    preceded(space, p)
+}
+
+/// Parse the space in-between tokens
+///
+/// You probably want to use the [`s`] combinator instead.
+pub(super) fn space<'a, E>(input: &mut &'a str) -> winnow::Result<(), E>
+where
+    E: ParserError<&'a str>,
+{
+    separated(0.., multispace0, alt((comment, ignored_hyphen_or_plus))).parse_next(input)
+}
+
+/// A hyphen or plus is ignored when it is not followed by a digit
+///
+/// This includes being followed by a comment! Compare these inputs:
+/// ```txt
+/// - 12 weeks
+/// - (comment) 12 weeks
+/// ```
+/// The last comment should be ignored.
+///
+/// The plus is undocumented, but it seems to be ignored.
+fn ignored_hyphen_or_plus<'a, E>(input: &mut &'a str) -> winnow::Result<(), E>
+where
+    E: ParserError<&'a str>,
+{
+    (
+        alt(('-', '+')),
+        multispace0,
+        peek(not(take_while(1, AsChar::is_dec_digit))),
+    )
+        .void()
+        .parse_next(input)
+}
+
+/// Parse a comment
+///
+/// A comment is given between parentheses, which must be balanced. Any other
+/// tokens can be within the comment.
+fn comment<'a, E>(input: &mut &'a str) -> winnow::Result<(), E>
+where
+    E: ParserError<&'a str>,
+{
+    delimited(
+        '(',
+        repeat(0.., alt((none_of(['(', ')']).void(), comment))),
+        ')',
+    )
+    .parse_next(input)
+}
+
+/// Parse a signed decimal integer.
+///
+/// Rationale for not using `winnow::ascii::dec_int`: When upgrading winnow from
+/// 0.5 to 0.7, we discovered that `winnow::ascii::dec_int` now accepts only the
+/// following two forms:
+///
+/// - 0
+/// - [+-]?[1-9][0-9]*
+///
+/// Inputs like [+-]?0[0-9]* (e.g., `+012`) are therefore rejected. We provide a
+/// custom implementation to support such zero-prefixed integers.
+#[allow(unused)]
+pub(super) fn dec_int<'a, E>(input: &mut &'a str) -> winnow::Result<i32, E>
+where
+    E: ParserError<&'a str>,
+{
+    (opt(one_of(['+', '-'])), digit1)
+        .void()
+        .take()
+        .verify_map(|s: &str| s.parse().ok())
+        .parse_next(input)
+}
+
+/// Parse an unsigned decimal integer.
+///
+/// See the rationale for `dec_int` for why we don't use
+/// `winnow::ascii::dec_uint`.
+pub(super) fn dec_uint<'a, O, E>(input: &mut &'a str) -> winnow::Result<O, E>
+where
+    O: Uint + FromStr,
+    E: ParserError<&'a str>,
+{
+    dec_uint_str
+        .verify_map(|s: &str| s.parse().ok())
+        .parse_next(input)
+}
+
+/// Parse an unsigned decimal integer as a string slice.
+pub(super) fn dec_uint_str<'a, E>(input: &mut &'a str) -> winnow::Result<&'a str, E>
+where
+    E: ParserError<&'a str>,
+{
+    digit1.void().take().parse_next(input)
+}
+
+/// Parse a colon preceded by whitespace.
+pub(super) fn colon<'a, E>(input: &mut &'a str) -> winnow::Result<(), E>
+where
+    E: ParserError<&'a str>,
+{
+    s(':').void().parse_next(input)
+}
+
+/// Parse a plus or minus character optionally preceeded by whitespace.
+pub(super) fn plus_or_minus<'a, E>(input: &mut &'a str) -> winnow::Result<char, E>
+where
+    E: ParserError<&'a str>,
+{
+    s(alt(('+', '-'))).parse_next(input)
+}
+
+/// Create a context error with a reason.
+pub(super) fn ctx_err(reason: &'static str) -> ContextError {
+    let mut err = ContextError::new();
+    err.push(StrContext::Expected(StrContextValue::Description(reason)));
+    err
+}
--- a/Show More
+++ b/Show More