diff --git a/.size-limit.json b/.size-limit.json
index ec1c34f..8ba8625 100644
--- a/.size-limit.json
+++ b/.size-limit.json
@@ -4,63 +4,127 @@
       "path": "src/index.js",
       "import": "{ datetime }"
     },
+    {
+      "name": "`datetime` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ datetime }"
+    },
     {
       "name": "`utc`",
       "path": "src/index.js",
       "import": "{ utc }"
     },
+    {
+      "name": "`utc` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ utc }"
+    },
     {
       "name": "`datetimeTz`",
       "path": "src/index.js",
       "import": "{ datetimeTz }"
     },
+    {
+      "name": "`datetimeTz` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ datetimeTz }"
+    },
     {
       "name": "`duration`",
       "path": "src/index.js",
       "import": "{ duration }"
     },
+    {
+      "name": "`duration` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ duration }"
+    },
     {
       "name": "`tzOffset`",
       "path": "src/index.js",
       "import": "{ tzOffset }"
     },
+    {
+      "name": "`tzOffset` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ tzOffset }"
+    },
     {
       "name": "`setTimeSeparator`",
       "path": "src/index.js",
       "import": "{ setTimeSeparator }"
     },
+    {
+      "name": "`setTimeSeparator` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ setTimeSeparator }"
+    },
     {
       "name": "`setTzConfig`",
       "path": "src/index.js",
       "import": "{ setTzConfig }"
     },
+    {
+      "name": "`setTzConfig` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ setTzConfig }"
+    },
     {
       "name": "`setTzInRealWorldRange`",
       "path": "src/index.js",
       "import": "{ setTzInRealWorldRange }"
     },
+    {
+      "name": "`setTzInRealWorldRange` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ setTzInRealWorldRange }"
+    },
     {
       "name": "`setTzSeparator`",
       "path": "src/index.js",
       "import": "{ setTzSeparator }"
     },
+    {
+      "name": "`setTzSeparator` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ setTzSeparator }"
+    },
     {
       "name": "`daysBetween`",
       "path": "src/index.js",
       "import": "{ daysBetween }"
     },
+    {
+      "name": "`daysBetween` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ daysBetween }"
+    },
     {
       "name": "`weekNumber`",
       "path": "src/index.js",
       "import": "{ weekNumber }"
     },
+    {
+      "name": "`weekNumber` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ weekNumber }"
+    },
     {
       "name": "`DateTime`",
       "path": "src/index.js",
       "import": "{ DateTime }"
     },
+    {
+      "name": "`DateTime` (Temporal)",
+      "path": "src/temporal-same-features/index.js",
+      "import": "{ DateTime }"
+    },
     {
       "name": "**All modules** (`import *`)",
       "path": "src/index.js"
+    },
+    {
+      "name": "**All modules** (`import *`, Temporal)",
+      "path": "src/temporal-same-features/index.js"
     }
   ]
diff --git a/package.json b/package.json
index fc98446..e09d9a3 100644
--- a/package.json
+++ b/package.json
@@ -73,5 +73,9 @@
       "has": "npm:@nolyfill/has@latest",
       "hasown": "npm:@nolyfill/hasown@latest"
     }
+  },
+  "peerDependencies": {
+    "@js-temporal/polyfill": "^0.4.4",
+    "temporal-polyfill": "^0.2.4"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 57e090a..8f128d4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,14 @@ overrides:
   has: npm:@nolyfill/has@latest
   hasown: npm:@nolyfill/hasown@latest
 
+dependencies:
+  '@js-temporal/polyfill':
+    specifier: ^0.4.4
+    version: 0.4.4
+  temporal-polyfill:
+    specifier: ^0.2.4
+    version: 0.2.5
+
 devDependencies:
   '@eslint/js':
     specifier: ^9.9.0
@@ -429,6 +437,14 @@ packages:
       '@jridgewell/sourcemap-codec': 1.5.0
     dev: true
 
+  /@js-temporal/polyfill@0.4.4:
+    resolution: {integrity: sha512-2X6bvghJ/JAoZO52lbgyAPFj8uCflhTo2g7nkFzEQdXd/D8rEeD4HtmTEpmtGCva260fcd66YNXBOYdnmHqSOg==}
+    engines: {node: '>=12'}
+    dependencies:
+      jsbi: 4.3.0
+      tslib: 2.6.3
+    dev: false
+
   /@nodelib/fs.scandir@2.1.5:
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -1749,6 +1765,10 @@ packages:
       argparse: 2.0.1
     dev: true
 
+  /jsbi@4.3.0:
+    resolution: {integrity: sha512-SnZNcinB4RIcnEyZqFPdGPVgrg2AcnykiBy0sHVJQKHYeaLUvi3Exj+iaPpLnFVkDPZIV4U0yvgC9/R4uEAZ9g==}
+    dev: false
+
   /json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
     dev: true
@@ -2443,6 +2463,16 @@ packages:
     engines: {node: '>= 0.4'}
     dev: true
 
+  /temporal-polyfill@0.2.5:
+    resolution: {integrity: sha512-ye47xp8Cb0nDguAhrrDS1JT1SzwEV9e26sSsrWzVu+yPZ7LzceEcH0i2gci9jWfOfSCCgM3Qv5nOYShVUUFUXA==}
+    dependencies:
+      temporal-spec: 0.2.4
+    dev: false
+
+  /temporal-spec@0.2.4:
+    resolution: {integrity: sha512-lDMFv4nKQrSjlkHKAlHVqKrBG4DyFfa9F74cmBZ3Iy3ed8yvWnlWSIdi4IKfSqwmazAohBNwiN64qGx4y5Q3IQ==}
+    dev: false
+
   /test-exclude@7.0.1:
     resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}
     engines: {node: '>=18'}
@@ -2520,6 +2550,10 @@ packages:
       read-pkg-up: 7.0.1
     dev: true
 
+  /tslib@2.6.3:
+    resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==}
+    dev: false
+
   /type-check@0.4.0:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
diff --git a/src/datetime.js b/src/datetime.js
index 15f9475..5fb17ac 100644
--- a/src/datetime.js
+++ b/src/datetime.js
@@ -106,7 +106,6 @@ export function datetime(date = new Date(), precision = 'day') {
  * - `datetime(someDate, 'somePrecision utc')`
  * - `utc(someDate, 'somePrecision')`
  *
- *
  * @param {Date} [date=new Date()] - default to now
  * @param {'datetime'|'datetime second'|'datetime ms'|'time'|'second'|'ms'} [precision=datetime]
  * @returns {string}
diff --git a/src/temporal-experimenting/README.md b/src/temporal-experimenting/README.md
new file mode 100644
index 0000000..e62499f
--- /dev/null
+++ b/src/temporal-experimenting/README.md
@@ -0,0 +1,32 @@
+> [!INFO]  
+>
+> Work in progress document. Very drafty.
+
+This folder will contain the implementation of `datetime-attribute` where functions will accept [`Temporal`](https://tc39.es/proposal-temporal/docs) objects while keeping current parameters.
+
+It’s possible that some functions will not require to accept a `Temporal` object because what they accomplish is maybe already available as a `Temporal.{className}` feature.
+
+It’s also possible that new functions are created to facilitate the usage of `Temporal` objects, and the extended scope they cover in comparison with `Date`.
+
+## Parity between `Date` and `Temporal` implementations
+
+**Drafty.**
+
+function | in `Date` | in `Temporal` | note
+---|---|---|---
+`tzOffset` | yes | yes | @todo accept a `Temporal.TimeZone` (or any temporal) and output its “real-world” timezone.
+`datetime` | yes | yes | @todo evaluate
+`utc` | yes | yes | @todo evaluate
+`datetimeTz` | yes | yes | @todo evaluate
+`DateTime` | yes | yes | @todo evaluate
+`duration` | yes | yes | @todo evaluate
+`daysBetween` | yes | yes | @todo evaluate
+`weekNumber` | yes | yes | @todo evaluate
+(config feature…)| yes | yes | @todo evaluate
+
+## `tzOffset` notes
+
+```js
+const tz = new Temporal.TimeZone('-23:59')
+console.log(tz.id) // -23:59
+```
diff --git a/src/temporal-same-features/README.md b/src/temporal-same-features/README.md
new file mode 100644
index 0000000..c5a59f2
--- /dev/null
+++ b/src/temporal-same-features/README.md
@@ -0,0 +1,5 @@
+# datetime-attribute implemented with the `Temporal` API
+
+This folder contains the implementation of `datetime-attribute` using the [`Temporal` API](https://tc39.es/proposal-temporal/docs).
+
+It has feature parity with the initial `datetime-attribute`.
diff --git a/src/temporal-same-features/config/datetime.js b/src/temporal-same-features/config/datetime.js
new file mode 100644
index 0000000..576a79e
--- /dev/null
+++ b/src/temporal-same-features/config/datetime.js
@@ -0,0 +1,38 @@
+/**
+ * @typedef {Object} DateTimeOptions
+ * @property {('T'|' ')} separator The separator between date and time
+ *                                 (`'2024-04-21T10:34'`) can be a
+ *                                 'T' (default) or a space.
+ */
+
+/** @type DateTimeOptions */
+export const config = {
+  separator: 'T',
+}
+
+/**
+ * Set datetime related configuration
+ *
+ * @param {DateTimeOptions} options
+ * @returns {DateTimeOptions}
+ */
+export const setConfig = options => {
+
+  /**
+   * The separator can only be 'T' or ' '.
+   * https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#local-dates-and-times
+   */
+  if (options.separator != 'T' && options.separator != ' ') {
+    throw new Error(`Invalid timezone separator. Use 'T' or ' '.`)
+  }
+
+  return Object.assign(config, options)
+}
+
+/**
+ * Set separator between date and time
+ *
+ * @param {DateTimeOptions['separator']} [separator='T']
+ * @returns {DateTimeOptions}
+ */
+export const setTimeSeparator = (separator = 'T') => setConfig({ separator })
diff --git a/src/temporal-same-features/config/datetime.test.js b/src/temporal-same-features/config/datetime.test.js
new file mode 100644
index 0000000..1039d04
--- /dev/null
+++ b/src/temporal-same-features/config/datetime.test.js
@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest'
+
+import { datetime, setTimeSeparator } from '../index.js'
+
+import { setConfig } from './datetime.js'
+
+const togoIndependanceDay = new Date(1960, 3, 27)
+const date = togoIndependanceDay // alias for the sake of brevity
+
+describe('setTimeSeparator', () => {
+
+  test('is a function', () => {
+    expect(setTimeSeparator).toBeInstanceOf(Function)
+  })
+
+  test('throws with invalid separator', () => {
+    expect(() => setTimeSeparator(42)).toThrow(Error)
+  })
+
+  test('no time separator', () => {
+    setTimeSeparator()
+    expect(datetime(date, 'datetime')).toBe('1960-04-27T00:00')
+  })
+
+  test('T as time separator', () => {
+    setTimeSeparator('T')
+    expect(datetime(date, 'datetime')).toBe('1960-04-27T00:00')
+  })
+
+  test('space as time separator', () => {
+    setTimeSeparator(' ')
+    expect(datetime(date, 'datetime')).toBe('1960-04-27 00:00')
+  })
+})
+
+describe('setConfig', () => {
+
+  test('is a function', () => {
+    expect(setConfig).toBeInstanceOf(Function)
+  })
+
+  test('throws without parameter', () => {
+    expect(() => setConfig()).toThrow(TypeError)
+  })
+
+  test('throws without proper parameter', () => {
+    expect(() => setConfig({})).toThrow(Error)
+  })
+
+  test('throws with invalid separator', () => {
+    expect(() => setConfig({ separator: 42 })).toThrow(Error)
+  })
+
+  test('T as time separator using datetime', () => {
+    setConfig({ separator: 'T' })
+    expect(datetime(date, 'datetime')).toBe('1960-04-27T00:00')
+  })
+
+  test('space as time separator using datetime', () => {
+    setConfig({ separator: ' ' })
+    expect(datetime(date, 'datetime')).toBe('1960-04-27 00:00')
+  })
+})
diff --git a/src/temporal-same-features/config/index.js b/src/temporal-same-features/config/index.js
new file mode 100644
index 0000000..c3fff3a
--- /dev/null
+++ b/src/temporal-same-features/config/index.js
@@ -0,0 +1,6 @@
+export { setTimeSeparator } from './datetime.js'
+export {
+  setTzConfig,
+  setTzInRealWorldRange,
+  setTzSeparator,
+} from './tz.js'
diff --git a/src/temporal-same-features/config/tz.js b/src/temporal-same-features/config/tz.js
new file mode 100644
index 0000000..07b1084
--- /dev/null
+++ b/src/temporal-same-features/config/tz.js
@@ -0,0 +1,59 @@
+/**
+ * @typedef {Object} TimezoneOptions
+ *
+ * @property {boolean} [inRealWorldRange] Adapt the timezone value to be inside
+ *                                        the real-world IANA range. `false`
+ *                                         by default.
+ *
+ * @property {(':'|'')} [separator] The separator between hours and minutes
+ *                                  (`'+02:00'`) can be ':' (default) or
+ *                                  an empty string.
+ */
+
+/** @type TimezoneOptions */
+export const tzConfig = {
+  inRealWorldRange: false,
+  separator: ':',
+}
+
+const defaultConfig = { ...tzConfig }
+
+/**
+ * Set timezone related configuration
+ *
+ * @param {TimezoneOptions} options
+ * @returns {TimezoneOptions}
+ */
+export const setTzConfig = (options = defaultConfig) => {
+  const { separator, inRealWorldRange } = options
+
+  /**
+   * The separator can only be ':' or ''.
+   * https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#time-zones
+   */
+  if ('separator' in options && separator != ':' && separator != '') {
+    throw new Error(`Invalid timezone separator. Use ':' or ''.`)
+  }
+
+  if ('inRealWorldRange' in options && typeof inRealWorldRange != 'boolean') {
+    throw new Error(`Invalid value for 'inRealWorldRange'. Use true or false.`)
+  }
+
+  return Object.assign(tzConfig, options)
+}
+
+/**
+ * Set timezone separator
+ *
+ * @param {TimezoneOptions['separator']} [separator='']
+ * @returns {TimezoneOptions}
+ */
+export const setTzSeparator = (separator = '') => setTzConfig({ separator })
+
+/**
+ * Shift timezones to be inside the real-world (IANA) range
+ *
+ * @param {TimezoneOptions['inRealWorldRange']} [inRealWorldRange=false]
+ * @returns {TimezoneOptions}
+ */
+export const setTzInRealWorldRange = (inRealWorldRange = false) => setTzConfig({ inRealWorldRange })
diff --git a/src/temporal-same-features/config/tz.test.js b/src/temporal-same-features/config/tz.test.js
new file mode 100644
index 0000000..ea5240a
--- /dev/null
+++ b/src/temporal-same-features/config/tz.test.js
@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import { datetimeTz, tzOffset, setTzConfig, setTzInRealWorldRange, setTzSeparator } from '../index.js'
+import { tzConfig } from './tz.js'
+
+const togoIndependanceDay = new Date(1960, 3, 27)
+const date = togoIndependanceDay // alias for the sake of brevity
+
+// Reset default config between each test.
+const defaultConfig = { ...tzConfig }
+beforeEach(() => setTzConfig(defaultConfig))
+
+describe('setTzSeparator', () => {
+  test('is a function', () => expect(setTzSeparator).toBeInstanceOf(Function))
+
+  test('throws with invalid separator', () => {
+    expect(() => setTzSeparator(42)).toThrow(Error)
+  })
+
+  test('no timezone separator', () => {
+    setTzSeparator()
+    expect(tzOffset(3)).toBe('+0300')
+  })
+
+  test('empty string timezone separator', () => {
+    setTzSeparator('')
+    expect(tzOffset(3)).toBe('+0300')
+  })
+
+  test(': as timezone separator', () => {
+    setTzSeparator(':')
+    expect(tzOffset(3)).toBe('+03:00')
+  })
+
+  test('empty string timezone separator with datetimeTz', () => {
+    setTzSeparator('')
+    expect(datetimeTz(date, 'datetime second', -6)).toBe('1960-04-27T00:00:00-0600')
+  })
+})
+
+describe('setTzInRealWorldRange', () => {
+  test('is a function', () => expect(setTzInRealWorldRange).toBeInstanceOf(Function))
+  test('throws with invalid value', () => expect(() => setTzInRealWorldRange(42)).toThrow(Error))
+
+  test('default value disables real-world range', () => {
+    expect(tzOffset(20)).toBe('+20:00')
+    setTzInRealWorldRange()
+    expect(tzOffset(20)).toBe('+20:00')
+  })
+
+  test('enable real-world range', () => {
+    expect(tzOffset(20)).toBe('+20:00')
+    setTzInRealWorldRange(true)
+    expect(tzOffset(20)).toBe('-04:00')
+  })
+
+  test('disable real-world range', () => {
+    setTzInRealWorldRange(false)
+    expect(tzOffset(20)).toBe('+20:00')
+  })
+
+  test('enable real-world range with datetimeTz', () => {
+    setTzInRealWorldRange(true)
+    expect(datetimeTz(date, 'datetime second', 20)).toBe('1960-04-27T00:00:00-04:00')
+  })
+})
+
+describe('setTzConfig', () => {
+
+  describe('general', () => {
+    test('is a function', () => expect(setTzConfig).toBeInstanceOf(Function))
+
+    test('reset the default config without parameter', () => {
+      setTzConfig({ separator: '', inRealWorldRange: true })
+      expect(tzOffset(20)).toBe('-0400')
+
+      setTzConfig()
+      expect(tzOffset(20)).toBe('+20:00')
+    })
+  })
+
+  describe('timezone separator', () => {
+    test('throws with invalid separator', () => expect(() => setTzConfig({ separator: 42 })).toThrow(Error))
+
+    test('empty string separator using tzOffset', () => {
+      setTzConfig({ separator: '' })
+      expect(tzOffset(3)).toBe('+0300')
+    })
+
+    test(': as separator using tzOffset', () => {
+      setTzConfig({ separator: ':' })
+      expect(tzOffset(3)).toBe('+03:00')
+    })
+
+    test(': as separator with datetimeTz', () => {
+      setTzConfig({ separator: ':' })
+      expect(datetimeTz(date, 'datetime second', -6)).toBe('1960-04-27T00:00:00-06:00')
+    })
+  })
+
+  describe('real-world boundaries', () => {
+    test('throws with invalid value', () => expect(() => setTzConfig({ inRealWorldRange: 42 })).toThrow(Error))
+
+    test('inside boundaries using tzOffset', () => {
+      setTzConfig({ inRealWorldRange: true })
+      expect(tzOffset(20)).toBe('-04:00')
+    })
+
+    test('outside boundaries using tzOffset', () => {
+      setTzConfig({ inRealWorldRange: false })
+      expect(tzOffset(20)).toBe('+20:00')
+    })
+
+    test('inside boundaries using datetimeTz', () => {
+      setTzConfig({ inRealWorldRange: true })
+      expect(datetimeTz(date, 'datetime second', 20)).toBe('1960-04-27T00:00:00-04:00')
+    })
+
+    test('outside boundaries using datetimeTz', () => {
+      setTzConfig({ inRealWorldRange: false })
+      expect(datetimeTz(date, 'datetime second', 20)).toBe('1960-04-27T00:00:00+20:00')
+    })
+  })
+})
diff --git a/src/temporal-same-features/datetime-class.js b/src/temporal-same-features/datetime-class.js
new file mode 100644
index 0000000..f7e0e1c
--- /dev/null
+++ b/src/temporal-same-features/datetime-class.js
@@ -0,0 +1,54 @@
+import { MILLISECONDS_PER_WEEK } from './utils/const.js'
+import { datetime, weekNumber } from './index.js'
+
+export class DateTime extends Date {
+
+  /**
+   * Returns the week of the year (`1`–`53`) of the specified date according to
+   * local time, as defined by the WHATWG and the ISO-8601 specs:
+   *
+   * - a week starts on Monday (https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#concept-week);
+   * - the first week of the year includes a Thursday;
+   * - week numbers go from 1 to 53 (https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#week-number-of-the-last-day).
+   *
+   * @todo: cache the result of weekNumber as long as date isn’t changed:
+   * compare the current object timestamp wuth a stored/cached one in
+   * order to decide if the cache is stale.
+   *
+   * @returns {number}
+   */
+  getWeek = () => weekNumber(this)
+
+  /**
+   * Set the week number.
+   *
+   * If the week number is outside the year range, the `DateTime` object is
+   * updated accordingly.
+   *
+   * @param {number} weekNumber
+   * @returns {number} Milliseconds since midnight on January 1, 1970, UTC
+   */
+  setWeek(weekNumber) {
+    const weeksDiffInMs = (weekNumber - this.getWeek()) * MILLISECONDS_PER_WEEK
+
+    /**
+     * Temporal API is less efficient here, it’s probably better with a
+     * Temporal object while this class is really `Date` focused as
+     * it extends it. Commented code: Temporal implementation.
+     */
+    // const temporalThis = Temporal.Instant.fromEpochMilliseconds(
+    //   this.getTime() + weeksDiffInMs
+    // )
+    // return this.setTime(temporalThis.epochMilliseconds)
+
+    return this.setTime(this.getTime() + weeksDiffInMs)
+  }
+
+  /**
+   * Converts a date to a string following the ISO 8601 Extended Format.
+   *
+   * @param {import('./datetime.js').Precision} precision
+   * @returns {string}
+   */
+  to = precision => datetime(this, precision)
+}
diff --git a/src/temporal-same-features/datetime-class.test.js b/src/temporal-same-features/datetime-class.test.js
new file mode 100644
index 0000000..c5c8748
--- /dev/null
+++ b/src/temporal-same-features/datetime-class.test.js
@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import { DateTime, datetime } from './index.js'
+import { MILLISECONDS_PER_DAY } from './utils/const.js'
+
+const FOURTEEN_DAYS_IN_MS = MILLISECONDS_PER_DAY * 14
+
+describe('DateTime class', () => {
+  /** @type {Date} */ let summer
+  /** @type {Date} */ let twoWeeksIntoSummer
+  /** @type {Date} */ let winter
+  /** @type {Date} */ let twoWeeksIntoWinter
+
+  beforeEach(() => {
+    summer = new DateTime(2021, 5, 21)
+    twoWeeksIntoSummer = new DateTime(summer.getTime() + FOURTEEN_DAYS_IN_MS) // same as `new DateTime(2021, 6, 5)`
+
+    winter = new DateTime(2021, 11, 21)
+    twoWeeksIntoWinter = new DateTime(winter.getTime() + FOURTEEN_DAYS_IN_MS) // same as `new DateTime(2022, 1, 4)`
+  })
+
+  test('extends the Date class', () => {
+    expect(summer).toBeInstanceOf(DateTime)
+    expect(summer).toBeInstanceOf(Date)
+  })
+
+  describe('.to() == datetime()', () => {
+
+    test('with default precision', () => {
+      expect(summer.to()).toBe('2021-06-21')
+      expect(datetime(summer)).toBe('2021-06-21')
+    })
+
+    test(`with 'month' precision`, () => {
+      expect(twoWeeksIntoSummer.to('month')).toBe('2021-07')
+      expect(datetime(twoWeeksIntoSummer, 'month')).toBe('2021-07')
+    })
+
+    test(`with 'week' precision, after the week is changed to a new year`, () => {
+      winter.setDate(winter.getDate() + 14)
+
+      expect(winter.to('week')).toBe(twoWeeksIntoWinter.to('week'))
+      expect(winter.to('week')).toBe('2022-W01')
+      expect(datetime(winter, 'week')).toBe('2022-W01')
+    })
+  })
+
+  describe('.getWeek()', () => {
+
+    test('returns the week number', () => {
+      expect(summer.getWeek()).toBe(25)
+    })
+
+    test('returns the week number after the date is changed', () => {
+      summer.setDate(summer.getDate() + 14)
+
+      expect(summer.getWeek()).toBe(twoWeeksIntoSummer.getWeek())
+    })
+
+    test('returns the week number after the date is changed to a new year', () => {
+      winter.setDate(winter.getDate() + 14)
+
+      expect(winter.getWeek()).toBe(twoWeeksIntoWinter.getWeek())
+    })
+  })
+
+  test('.setWeek() returns the timestamp of the changed date', () => {
+    expect(summer.setWeek(27)).toBe(twoWeeksIntoSummer.getTime())
+  })
+})
diff --git a/src/temporal-same-features/datetime.js b/src/temporal-same-features/datetime.js
new file mode 100644
index 0000000..ac5c699
--- /dev/null
+++ b/src/temporal-same-features/datetime.js
@@ -0,0 +1,136 @@
+import { p } from './utils/string.js'
+import { tzOffset } from './timezone.js'
+import { config } from './config/datetime.js'
+import { tzConfig } from './config/tz.js'
+import { Temporal, toTemporalInstant } from '@js-temporal/polyfill'
+// import { Temporal, toTemporalInstant } from 'temporal-polyfill'
+
+Date.prototype.toTemporalInstant = toTemporalInstant
+
+/**
+ * Create `datetime="2021-12-02"` attribute for `<time>`.
+ *
+ * Support all format from the spec.
+ * https://html.spec.whatwg.org/multipage/text-level-semantics.html#attr-time-datetime
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLTimeElement/datetime
+ *
+ * See also: https://www.brucelawson.co.uk/2012/best-of-time/
+ *
+ * @param {Date} [date=new Date()] - default to now
+ * @param {Precision} [precision='day']
+ * @returns {string}
+ */
+export function datetime(date = new Date(), precision = 'day') {
+  if (!(date instanceof Date)) {
+    throw new TypeError('Input date should be of type `Date`')
+  }
+
+  const { Now, PlainDate, PlainDateTime, PlainMonthDay, PlainTime, PlainYearMonth, } = Temporal
+
+  const instant = date.toTemporalInstant()
+  const zoned = instant.toZonedDateTimeISO(Now.timeZoneId())
+
+  const yearISO = y => {
+
+    // Year 0 doesn’t exists in real world, but does in the ISO-8601 spec.
+    const sign = y < 0 ? '-' : '' // no sign if year is not negative
+
+    // Remove sign (stored separately, see previous line).
+    y = Math.abs(y)
+
+    let bigYearDigits = ''
+
+    // Cut last 4 digits of the year from the others to ease further computation.
+    if (y > 9999) {
+      [bigYearDigits, y] = (y / 10000).toFixed(4).split('.')
+    }
+
+    return sign + bigYearDigits + y.toString().padStart(4, 0)
+  }
+
+  // const iso = date.toISOString();
+
+  const temporalFormat = {
+    year: () => yearISO(PlainYearMonth.from(zoned).year), // 1960
+    // year: () => date.getFullYear(), // 1960
+    month: () => PlainYearMonth.from(zoned), // 1960-04
+    day: () => PlainDate.from(zoned), // 1960-04-27
+
+    week: () => zoned.yearOfWeek + '-W' + p(zoned.weekOfYear), // 1960-W17
+    yearless: () => PlainMonthDay.from(zoned), // 04-27
+
+    time: () => PlainTime.from(zoned).toString({ smallestUnit: 'minutes' }), // 00:00
+    second: () => PlainTime.from(zoned), // 00:00:00
+    ms: () => PlainTime.from(zoned).toString({ smallestUnit: 'milliseconds' }), // 00:00:00.123
+
+    datetime: () => PlainDateTime.from(zoned).toString({ smallestUnit: 'minutes' }), // 1960-04-27T00:00
+    'datetime second': () => PlainDateTime.from(zoned), // 1960-04-27T00:00:00
+    'datetime ms': () => PlainDateTime.from(zoned).toString({ smallestUnit: 'milliseconds' }), // 1960-04-27T00:00:00.123
+
+    'datetime utc': () => instant.toString({ smallestUnit: 'minute' }), // 1960-04-26T23:00Z
+    'datetime second utc': () => instant, // 1960-04-26T23:00:00Z
+    'datetime ms utc': () => instant.toString({ fractionalSecondDigits: 3 }), // 1960-04-26T23:00:00.000Z
+
+    'time utc': () =>
+      instant.toString({ smallestUnit: 'minute' }).substr(11, 6), // 23:00Z
+    'second utc': () => instant.toString().substr(11, 9), // 23:00:00Z
+    'ms utc': () =>
+      instant.toString({ fractionalSecondDigits: 3 }).substr(11, 13), // 23:00:00.000Z
+  }
+
+  return (temporalFormat[precision] || temporalFormat.day)().toString().replace('T', config.separator)
+}
+
+/**
+ * Shortcut for `datetime` with UTC output.
+ *
+ * For exemple, these two are the same:
+ * - `datetime(someDate, 'somePrecision utc')`
+ * - `utc(someDate, 'somePrecision')`
+ *
+ * @param {Date} [date=new Date()] - default to now
+ * @param {'datetime'|'datetime second'|'datetime ms'|'time'|'second'|'ms'} [precision=datetime]
+ * @returns {string}
+ */
+export const utc = (date = new Date(), precision = 'datetime') =>
+  datetime(date, `${precision} utc`)
+
+/**
+ * Create `datetime="2021-12-02T17:34-06:00"` attribute for `<time>`.
+ *
+ * @param {Date} [date=new Date()] - default to now
+ * @param {Precision} [precision=datetime]
+ * @param {number} [offsetHours=0]
+ * @param {number} [offsetMinutes=0]
+ * @param {import('./config/tz.js').TimezoneOptions['inRealWorldRange']} [inRealWorldRange=false]
+ * @returns {string}
+ */
+export function datetimeTz(
+  date = new Date(),
+  precision = 'datetime',
+  offsetHours = 0,
+  offsetMinutes = 0,
+  inRealWorldRange = tzConfig.inRealWorldRange,
+) {
+  let timezoneOffset = ''
+
+  if (!precision.includes('utc')) {
+    // ignore request for UTC conversion
+    timezoneOffset =
+      '2' in arguments // see similar line in tzOffset()
+        ? tzOffset(offsetHours, offsetMinutes, inRealWorldRange)
+        : tzOffset()
+  }
+
+  return datetime(date, precision) + timezoneOffset
+}
+
+/**
+ * Supported precision keywords.
+ *
+ * @typedef { 'day' | 'year' | 'yearless' | 'month' | 'week' |
+ *            'time' | 'second' | 'ms' |
+ *            'time utc' | 'second utc' | 'ms utc' |
+ *            'datetime' | 'datetime second' | 'datetime ms' |
+ *            'datetime utc' | 'datetime second utc' | 'datetime ms utc' } Precision
+ */
diff --git a/src/temporal-same-features/datetime.test.js b/src/temporal-same-features/datetime.test.js
new file mode 100644
index 0000000..4a7d52b
--- /dev/null
+++ b/src/temporal-same-features/datetime.test.js
@@ -0,0 +1,317 @@
+import { describe, expect, test } from 'vitest'
+
+import { datetime, datetimeTz, tzOffset, utc } from './index.js'
+import { getTemporalDay } from './utils/date.js'
+
+const togoIndependanceDay = new Date(1960, 3, 27)
+const date = togoIndependanceDay // alias for the sake of brevity
+
+const firstCerealHarvest = new Date(-23000, 6, 7)
+const foundationOfSyracuse = new Date(-733, 6, 7)
+const birthOfChineseEmpressWuZetian = new Date(624, 1, 17) // https://en.wikipedia.org/wiki/Wu_Zetian
+const january1st2021 = new Date(2021, 0, 1, 10, 10, 12)
+const january11th = new Date(2021, 0, 11, 10, 10, 12)
+const january19th = new Date(2021, 0, 19, 10, 10, 12)
+const december31th2020 = new Date(2020, 11, 31, 10, 10, 12)
+const december31th2021 = new Date(2021, 11, 31, 10, 10, 12)
+const year10k = new Date(10000, 0, 1)
+
+const tzOffsetInMinutes = (new Date()).getTimezoneOffset() * -1
+
+describe('datetime', () => {
+
+  test('is a function', () => {
+    expect(datetime).toBeInstanceOf(Function)
+  })
+
+  test('throws on wrong date type', () => {
+    expect(() => datetime(123)).toThrow(TypeError)
+  })
+
+  test('“now” as default date parameter', () => {
+    expect(datetime()).toBe(datetime((new Date())))
+  })
+
+  test('no precision', () => expect(datetime(date)).toBe('1960-04-27'))
+  test('no precision before the 10th', () => expect(datetime(january1st2021)).toBe('2021-01-01'))
+
+  describe('precision, no UTC', () => {
+
+    test('day', () => {
+      expect(datetime(date, 'day')).toBe('1960-04-27')
+    })
+
+    test('year', () => {
+      expect(datetime(date, 'year')).toBe('1960')
+    })
+
+    test('month', () => {
+      expect(datetime(date, 'month')).toBe('1960-04')
+    })
+
+    test('yearless', () => {
+      expect(datetime(date, 'yearless')).toBe('04-27')
+    })
+
+    test('time', () => {
+      expect(datetime(date, 'time')).toBe('00:00')
+    })
+
+    test('second', () => {
+      expect(datetime(date, 'second')).toBe('00:00:00')
+    })
+
+    test('ms', () => {
+      expect(datetime(date, 'ms')).toBe('00:00:00.000')
+    })
+
+    test('datetime', () => {
+      expect(datetime(date, 'datetime')).toBe('1960-04-27T00:00')
+    })
+
+    test('datetime second', () => {
+      expect(datetime(date, 'datetime second')).toBe('1960-04-27T00:00:00')
+    })
+
+    test('datetime ms', () => {
+      expect(datetime(date, 'datetime ms')).toBe('1960-04-27T00:00:00.000')
+    })
+  })
+
+  describe('week', () => {
+
+    test('week on 1960-04-27 is 1960-W17', () => {
+      expect(datetime(date, 'week')).toBe('1960-W17')
+    })
+
+    test('week on 2020-12-31 is 2020-W53', () => {
+      expect(datetime(december31th2020, 'week')).toBe('2020-W53')
+    })
+
+    // 1st day of the year is after Thurdsay
+    test('week on 2021-01-01 is 2020-W53', () => {
+      expect(getTemporalDay(january1st2021)).toBeGreaterThan(4)
+      expect(datetime(january1st2021, 'week')).toBe('2020-W53')
+    })
+
+    test('week on 2021-01-08 is 2021-W01', () => {
+      expect(datetime(new Date(2021, 0, 8), 'week')).toBe('2021-W01')
+    })
+
+    test('week on 2021-01-11 is 2021-W02', () => {
+      expect(datetime(january11th, 'week')).toBe('2021-W02')
+    })
+
+    test('week on 2021-01-19 is 2021-W03', () => {
+      expect(datetime(january19th, 'week')).toBe('2021-W03')
+    })
+
+    // 1st day of the month is after Thurdsay, but it’s not in January
+    test('week on 2021-03-01 is 2021-W17', () => {
+      const march1st2021 = new Date(2021, 4, 1)
+      expect(getTemporalDay(march1st2021)).toBeGreaterThan(4)
+      expect(datetime(march1st2021, 'week')).toBe('2021-W17')
+    })
+
+    test('week on 2021-12-31 is 2021-W52', () => {
+      expect(datetime(december31th2021, 'week')).toBe('2021-W52')
+    })
+  })
+
+  // These ones can’t be tested providing an exact value as the output depends on client timezone.
+  describe('precision, UTC', () => {
+
+    test('time utc', () => {
+      expect(datetime(date, 'time utc')).toBe(date.toJSON().substr(11, 5) + 'Z')
+    })
+
+    test('second utc', () => {
+      expect(datetime(date, 'second utc')).toBe(date.toJSON().substr(11, 8) + 'Z')
+    })
+
+    test('ms utc', () => {
+      expect(datetime(date, 'ms utc')).toBe(date.toJSON().substr(11, 12) + 'Z')
+    })
+
+    test('datetime utc', () => {
+      expect(datetime(date, 'datetime utc')).toBe(date.toJSON().substr(0, 16) + 'Z')
+    })
+
+    test('datetime second utc', () => {
+      expect(datetime(date, 'datetime second utc')).toBe(date.toJSON().substr(0, 19) + 'Z')
+    })
+
+    test('datetime ms utc', () => {
+      expect(datetime(date, 'datetime ms utc')).toBe(date.toJSON())
+    })
+  })
+
+  describe('year and yearless, but for years outside the ISO-8601 range', () => {
+
+    test('3 digits year before 0', () => {
+      expect(datetime(foundationOfSyracuse, 'year')).toBe('-0733')
+    })
+
+    test('3 digits year', () => {
+      expect(datetime(birthOfChineseEmpressWuZetian, 'year')).toBe('0624')
+    })
+
+    test('5 digits year before 0', () => {
+      expect(datetime(firstCerealHarvest, 'year')).toBe('-23000')
+    })
+
+    test('5 digits year after 9999', () => {
+      expect(datetime(year10k, 'year')).toBe('10000')
+    })
+
+    test('yearless and year before 0', () => {
+      expect(datetime(foundationOfSyracuse, 'yearless')).toBe('07-07')
+    })
+
+    test('yearless and 3 digits year', () => {
+      expect(datetime(birthOfChineseEmpressWuZetian, 'yearless')).toBe('02-17')
+    })
+  })
+
+  test('unsupported precision falls back on the default one', () => {
+    expect(datetime(date, 'n00t')).toBe('1960-04-27')
+  })
+})
+
+describe('datetimeTz', () => {
+
+  test('is a function', () => {
+    expect(datetimeTz).toBeInstanceOf(Function)
+  })
+
+  test('throws on wrong date type', () => {
+    expect(() => datetimeTz(123)).toThrow(TypeError)
+  })
+
+  test('“now” as default date parameter', () => {
+    expect(datetimeTz()).toBe(datetimeTz((new Date())))
+  })
+
+  test('no precision', () => {
+    expect(datetimeTz(date)).toBe('1960-04-27T00:00' + tzOffset(0, tzOffsetInMinutes))
+  })
+
+  test('no offset', () => {
+    expect(datetimeTz(date, 'time')).toBe('00:00' + tzOffset(0, tzOffsetInMinutes))
+  })
+
+  describe('precision, no UTC', () => {
+
+    test('time 0', () => {
+      expect(datetimeTz(date, 'time', 0)).toBe('00:00Z')
+    })
+
+    test('time +4', () => {
+      expect(datetimeTz(date, 'time', 4)).toBe('00:00+04:00')
+    })
+
+    test('second -3', () => {
+      expect(datetimeTz(date, 'second', -3)).toBe('00:00:00-03:00')
+    })
+
+    test('ms +3.5', () => {
+      expect(datetimeTz(date, 'ms', 3.5)) .toBe('00:00:00.000+03:30')
+    })
+
+    test('datetime +12:45', () => {
+      expect(datetimeTz(date, 'datetime', 12, 45)).toBe('1960-04-27T00:00+12:45')
+    })
+
+    test('datetime +17, 30, true', () => {
+      expect(datetimeTz(date, 'datetime', 17, 30, true)).toBe('1960-04-27T00:00-06:30')
+    })
+
+    test('datetime second -6', () => {
+      expect(datetimeTz(date, 'datetime second', -6)).toBe('1960-04-27T00:00:00-06:00')
+    })
+
+    test('datetime ms +1', () => {
+      expect(datetimeTz(date, 'datetime ms', 1)).toBe('1960-04-27T00:00:00.000+01:00')
+    })
+  })
+
+  // These ones can’t be tested providing an exact value as the output depends on client timezone.
+
+  describe('precision, UTC', () => {
+
+    test('time utc', () => {
+      expect(datetimeTz(date, 'time utc')).toBe(date.toJSON().substr(11, 5) + 'Z')
+    })
+
+    test('second utc', () => {
+      expect(datetimeTz(date, 'second utc')).toBe(date.toJSON().substr(11, 8) + 'Z')
+    })
+
+    test('ms utc', () => {
+      expect(datetimeTz(date, 'ms utc')).toBe(date.toJSON().substr(11, 12) + 'Z')
+    })
+
+    test('datetime utc', () => {
+      expect(datetimeTz(date, 'datetime utc')).toBe(date.toJSON().substr(0, 16) + 'Z')
+    })
+
+    test('datetime second utc', () => {
+      expect(datetimeTz(date, 'datetime second utc')).toBe(date.toJSON().substr(0, 19) + 'Z')
+    })
+
+    test('datetime ms utc', () => {
+      expect(datetimeTz(date, 'datetime ms utc')).toBe(date.toJSON())
+    })
+  })
+})
+
+describe('utc', () => {
+  test('is a function', () => {
+    expect(utc).toBeInstanceOf(Function)
+  })
+
+  test('throws on wrong date type', () => {
+    expect(() => utc(123)).toThrow(TypeError)
+  })
+
+  test('“now” as default date parameter', () => {
+    expect(utc()).toBe(utc((new Date())))
+  })
+
+  // These ones can’t be tested providing an exact value as the output depends on client timezone.
+
+  describe('precision', () => {
+
+    test(`'datetime' is the default precision`, () => {
+      expect(utc(date)).toBe(date.toJSON().substr(0, 16) + 'Z')
+    })
+
+    test('time', () => {
+      expect(utc(date, 'time')).toBe(date.toJSON().substr(11, 5) + 'Z')
+    })
+
+    test('second', () => {
+      expect(utc(date, 'second')).toBe(date.toJSON().substr(11, 8) + 'Z')
+    })
+
+    test('ms', () => {
+      expect(utc(date, 'ms')).toBe(date.toJSON().substr(11, 12) + 'Z')
+    })
+
+    test('datetime', () => {
+      expect(utc(date, 'datetime')).toBe(date.toJSON().substr(0, 16) + 'Z')
+    })
+
+    test('datetime second', () => {
+      expect(utc(date, 'datetime second')).toBe(date.toJSON().substr(0, 19) + 'Z')
+    })
+
+    test('datetime ms', () => {
+      expect(utc(date, 'datetime ms')).toBe(date.toJSON())
+    })
+  })
+
+  test('unsupported precision falls back on the default one', () => {
+    expect(utc(date, 'n00t')).toBe('1960-04-27')
+  })
+})
diff --git a/src/temporal-same-features/duration.js b/src/temporal-same-features/duration.js
new file mode 100644
index 0000000..b6aa8b1
--- /dev/null
+++ b/src/temporal-same-features/duration.js
@@ -0,0 +1,89 @@
+/**
+ * @todo
+ * - check balancing (https://tc39.es/proposal-temporal/docs/balancing.html)
+ * - add support for sub-second units (ms, mis, ns)
+ */
+
+import { Temporal } from '@js-temporal/polyfill'
+// import { Temporal } from 'temporal-polyfill'
+import { round } from './utils/math.js'
+
+/**
+ * Create `datetime="P3DT2H8M32.541S"` duration attribute for `<time>`.
+ * https://html.spec.whatwg.org/multipage/text-level-semantics.html#attr-time-datetime
+ * https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#concept-duration
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLTimeElement/datetime
+ *
+ * See also: https://www.brucelawson.co.uk/2012/best-of-time/
+ *
+ * @param {DurationObject} [duration={}]
+ * @param {boolean} [convertExcess=true] Convert overflow values to their
+ *                                       higher unit (e.g. `{ m: 90 }`
+ *                                       equals `{ h: 1, m: 30 }`.
+ * @returns {string}
+ */
+export function duration(duration = {}, convertExcess = true) {
+
+  if (!duration) {
+    throw new Error('No duration provided.')
+  }
+
+  // Set default values for missing keys.
+
+  duration = Object.assign({ w: 0, d: 0, h: 0, m: 0, s: 0, ms: 0 }, duration)
+
+  /**
+   * At least one duration must be different than zero.
+   * Not needed with the Temporal API, only here for
+   * early return.
+   */
+  if (!Object.values(duration).some(value => value)) {
+    return 'PT0S'
+  }
+
+  // Transfer decimals as they aren’t accepted by `Temporal.Duration` constructor.
+
+  const processDecimals = (unit, smallerUnit, howManySmallInUnit) => {
+    if (!Number.isInteger(duration[unit])) {
+      duration[smallerUnit] += duration[unit] / howManySmallInUnit
+      duration[unit] = Math.floor(duration[unit])
+    }
+  }
+
+  processDecimals('w', 'd', 7)
+  processDecimals('d', 'h', 24)
+  processDecimals('h', 'm', 60)
+  processDecimals('m', 's', 60)
+  processDecimals('s', 'ms', 1) // last item of the chain (`ms`) is a special use case, we process it in the next line
+  duration.ms = round((duration.ms - duration.s) * 1000) //
+
+  let { w = 0, d = 0, h = 0, m = 0, s = 0, ms = 0 } = duration
+
+  // Create a Duration object
+
+  let dur = new Temporal.Duration(0, 0, w, d, h, m, s, ms)
+
+  if (convertExcess) {
+    dur = dur.round({ largestUnit: 'weeks', relativeTo: '2019-01-01' })
+  }
+
+  return dur.toString()
+}
+
+/**
+ * @typedef {Object} DurationObject
+ *
+ * @property {number} [y=0] – Number of years
+ * @property {number} [mo=0] – Number of months
+ * @property {number} [w=0] – Number of weeks
+ * @property {number} [d=0] – Number of days
+ * @property {number} [h=0] – Number of hours
+ * @property {number} [m=0] – Number of minutes
+ * @property {number} [s=0] – Number of seconds
+ * @property {number} [ms=0] – Number of milliseconds
+ * @property {number} [mis=0] – Number of microseconds
+ * @property {number} [ns=0] – Number of nanoseconds
+*
+ * The chosen propertie abbreviations follow the spec algorithm:
+ * https://tc39.es/proposal-temporal/#sec-temporal.duration
+ */
diff --git a/src/temporal-same-features/duration.test.js b/src/temporal-same-features/duration.test.js
new file mode 100644
index 0000000..ef382ec
--- /dev/null
+++ b/src/temporal-same-features/duration.test.js
@@ -0,0 +1,99 @@
+import { describe, expect, test } from 'vitest'
+
+import { duration } from './index.js'
+
+describe('duration', () => {
+  const durationObject = { w: 3, d: 5, h: 10, m: 43, s: 2.61 }
+  const durationWithTooHighValues = { w: 3, d: 19, h: 36, m: 53, s: 175.3 }
+  const durationInHours = { h: 17 }
+  const durationInDays = { d: 43 }
+
+  test('is a function', () => {
+    expect(duration).toBeInstanceOf(Function)
+  })
+
+  test('duration(null) throws', () => {
+    expect(() => duration(null)).toThrow(Error)
+  })
+
+  describe('empty or missing object', () => {
+
+    test('duration()', () => {
+      expect(duration()).toBe('PT0S')
+    })
+
+    test('duration({})        is PT0S', () => {
+      expect(duration({})).toBe('PT0S')
+    })
+
+    test('duration({}, true)  is PT0S', () => {
+      expect(duration({}, true)).toBe('PT0S')
+    })
+
+    test('duration({}, false) is PT0S', () => {
+      expect(duration({}, false)).toBe('PT0S')
+    })
+  })
+
+  describe('complete object', () => {
+
+    test('{ w: 3, d: 5, h: 10, m: 43, s: 2.61 } is P3W5DT10H43M2.61S', () => {
+      expect(duration(durationObject)).toBe('P3W5DT10H43M2.61S')
+    })
+
+    test('with too high values', () => {
+      expect(duration(durationWithTooHighValues)).toBe('P5W6DT12H55M55.3S')
+    })
+  })
+
+  describe('partial object', () => {
+
+    test('hours only', () => {
+      expect(duration(durationInHours)).toBe('PT17H')
+    })
+
+    test('days only', () => {
+      expect(duration(durationInDays)).toBe('P6W1D')
+    })
+
+  })
+
+  describe('conversion of excess values', () => {
+
+    test('is enabled by default', () => {
+      expect(duration(durationWithTooHighValues)).toBe(duration(durationWithTooHighValues, true))
+    })
+
+    test('disabled: full object without excess', () => {
+      expect(duration(durationObject, false)).toBe('P3W5DT10H43M2.61S')
+    })
+
+    test('disabled: full object with excess', () => {
+      expect(duration(durationWithTooHighValues, false)).toBe('P3W19DT36H53M175.3S')
+    })
+
+    test('disabled: partial object without excess', () => {
+      expect(duration(durationInHours, false)).toBe('PT17H')
+    })
+
+    test('disabled: partial object with excess', () => {
+      expect(duration(durationInDays, false)).toBe('P43D')
+    })
+
+    test('enabled: full object without excess', () => {
+      expect(duration(durationObject, true)).toBe('P3W5DT10H43M2.61S')
+    })
+
+    test('enabled: full object with excess', () => {
+      expect(duration(durationWithTooHighValues, true)).toBe('P5W6DT12H55M55.3S')
+    })
+
+    test('enabled: partial object without excess', () => {
+      expect(duration(durationInHours, true)).toBe('PT17H')
+    })
+
+    test('enabled: partial object with excess', () => {
+      expect(duration(durationInDays, true)).toBe('P6W1D')
+    })
+  })
+})
diff --git a/src/temporal-same-features/index.js b/src/temporal-same-features/index.js
new file mode 100644
index 0000000..77a550d
--- /dev/null
+++ b/src/temporal-same-features/index.js
@@ -0,0 +1,14 @@
+export { datetime, utc, datetimeTz } from './datetime.js'
+export { duration } from './duration.js'
+export { tzOffset } from './timezone.js'
+
+export {
+  setTimeSeparator,
+  setTzConfig,
+  setTzInRealWorldRange,
+  setTzSeparator
+} from './config/index.js'
+
+export { daysBetween, weekNumber } from './utils/date.js'
+
+export { DateTime } from './datetime-class.js'
diff --git a/src/temporal-same-features/timezone.js b/src/temporal-same-features/timezone.js
new file mode 100644
index 0000000..be728d0
--- /dev/null
+++ b/src/temporal-same-features/timezone.js
@@ -0,0 +1,97 @@
+import {
+  MINUTES_PER_DAY,
+  IANA_LOWER_TIMEZONE,
+  IANA_UPPER_TIMEZONE,
+  LOCAL_TZ_OFFSET,
+} from './utils/const.js'
+
+import { p } from './utils/string.js'
+import { tzConfig } from './config/tz.js'
+
+import { Temporal } from '@js-temporal/polyfill'
+// import { Temporal } from 'temporal-polyfill'
+
+/**
+ * Create `datetime="+04:00"` timezone attribute for `<time>`.
+ * https://html.spec.whatwg.org/multipage/text-level-semantics.html#attr-time-datetime
+ * https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#concept-timezone
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLTimeElement/datetime
+ *
+ * @param {number} [hours=0] The number of hours from UTC
+ * @param {number} [minutes=0] The number of minutes from UTC
+ * @param {import('./config/tz.js').TimezoneOptions['inRealWorldRange']} [inRealWorldRange=false] Make sure the timezone stays in spec boundaries.
+ * @returns {string}
+ */
+export function tzOffset(hours = 0, minutes = 0, inRealWorldRange = tzConfig.inRealWorldRange) {
+
+  // No arguments received: the local timezone offset is returned.
+  if (!('0' in arguments)) {
+    return tzOffset(0, LOCAL_TZ_OFFSET)
+  }
+
+  if (typeof hours != 'number' || typeof minutes != 'number') {
+    throw new TypeError('hours and (optional) minutes must be numbers.')
+  }
+
+  // Convert given offset in minutes and ignore the decimal part.
+  minutes = Math.trunc(hours * 60 + minutes)
+
+  // Compute minutes to remove in order to suppress the excess of minutes.
+  const suppressMinutesExcess = limit => Math.floor(minutes / limit) * MINUTES_PER_DAY
+
+  if (inRealWorldRange) {
+
+    /**
+     * Because lower and upper boundaries are not necessarily symetric,
+     * suppressing the minutes excess can lead to another excess but
+     * on the other side (e.g. by jumping from beyond +14 to -12).
+     */
+
+    // Upper boundary
+    if (minutes > IANA_UPPER_TIMEZONE) {
+      minutes -= suppressMinutesExcess(IANA_UPPER_TIMEZONE)
+      return tzOffset(0, minutes, true)
+    }
+
+    // Lower boundary
+    if (minutes < IANA_LOWER_TIMEZONE) {
+      minutes += suppressMinutesExcess(IANA_LOWER_TIMEZONE)
+      return tzOffset(0, minutes, true)
+    }
+  }
+
+  if (minutes == 0) { return 'Z' }
+
+  const utcMidnight = Temporal.ZonedDateTime.from({
+    timeZone: 'UTC',
+    year: 2023,
+    month: 11,
+    day: 11,
+  })
+
+  /**
+   * The timezone offset must stay between -23:59 and +23:59:
+   * https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#concept-timezone
+   * Using `Temporal.ZonedDatetime.add` helps with overflow while `.from`
+   * ignores it.
+   */
+  let zonedTime = utcMidnight.add({ minutes })
+
+  if (!zonedTime.hour && !zonedTime.minute) { return 'Z' }
+
+  /**
+   * Offset sign: `+` (UTC > 0) or `-` (UTC < 0).
+   * We don’t have condition when minutes is 0: `'Z'` was returned earlier.
+   */
+  const sign =
+    Temporal.ZonedDateTime.compare(utcMidnight, zonedTime) > 0
+      ? '-'
+      : '+'
+
+  if (sign == '-') {
+    // time goes from -21:00 to 03:00
+    zonedTime = zonedTime.subtract({ minutes: minutes * 2 })
+  }
+
+  return `${sign}${p(zonedTime.hour)}${tzConfig.separator}${p(zonedTime.minute)}`
+}
diff --git a/src/temporal-same-features/timezone.test.js b/src/temporal-same-features/timezone.test.js
new file mode 100644
index 0000000..cc952bb
--- /dev/null
+++ b/src/temporal-same-features/timezone.test.js
@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'vitest'
+import { tzOffset } from './index.js'
+import { Temporal } from '@js-temporal/polyfill'
+
+const tzOffsetInMinutes = (new Date()).getTimezoneOffset() * -1
+
+describe('tzOffset', () => {
+
+  test('is a function', () => {
+    expect(tzOffset).toBeInstanceOf(Function)
+  })
+
+  test('tzOffset(Z) throws', () => {
+    expect(() => tzOffset('Z')).toThrow(TypeError)
+  })
+
+  // This one can’t be tested providing an exact value as the output depends on client timezone and daylight time saving.
+  test('tzOffset() is the local timezone offset from UTC, in minutes', () => {
+    expect(tzOffset()).toBe(tzOffset(0, tzOffsetInMinutes))
+  })
+
+  describe('in boundaries', () => {
+
+    test('tzOffset(-23, -59)  is -23:59', () => {
+      expect(tzOffset(-23, -59)).toBe('-23:59')
+    })
+
+    test('tzOffset(-9, -30)   is -09:30', () => {
+      expect(tzOffset(-9, -30)).toBe('-09:30')
+    })
+
+    test('tzOffset(-9, 30)    is -08:30', () => {
+      expect(tzOffset(-9, 30)).toBe('-08:30')
+    })
+
+    test('tzOffset(-8)        is -08:00', () => {
+      expect(tzOffset(-8)).toBe('-08:00')
+    })
+
+    test('tzOffset(-4.5)      is -04:30', () => {
+      expect(tzOffset(-4.5)).toBe('-04:30')
+    })
+
+    test('tzOffset(0, -30)    is -00:30', () => {
+      expect(tzOffset(0, -30)).toBe('-00:30')
+    })
+
+    test('tzOffset(0)         is Z', () => {
+      expect(tzOffset(0)).toBe('Z')
+    })
+
+    test('tzOffset(0, 30)     is +00:30', () => {
+      expect(tzOffset(0, 30)).toBe('+00:30')
+    })
+
+    test('tzOffset(1)         is +01:00', () => {
+      expect(tzOffset(1)).toBe('+01:00')
+    })
+
+    test('tzOffset(2, -200)   is -01:20', () => {
+      expect(tzOffset(2, -200)).toBe('-01:20')
+    })
+
+    test('tzOffset(4, 30)     is +04:30', () => {
+      expect(tzOffset(4, 30)).toBe('+04:30')
+    })
+
+    test('tzOffset(12, 45)    is +12:45', () => {
+      expect(tzOffset(12, 45)).toBe('+12:45')
+    })
+
+    test('tzOffset(12.75)     is +12:45', () => {
+      expect(tzOffset(12.75)).toBe('+12:45')
+    })
+
+    test('tzOffset(23, 59)    is +23:59', () => {
+      expect(tzOffset(23, 59)).toBe('+23:59')
+    })
+  })
+
+  describe('out of boundaries', () => {
+
+    test('tzOffset(-24)            is Z', () => {
+      expect(tzOffset(-24)).toBe('Z')
+    })
+
+    test('tzOffset(24)             is Z', () => {
+      expect(tzOffset(24)).toBe('Z')
+    })
+
+    test('tzOffset(-24, 0, true)   is Z', () => {
+      expect(tzOffset(-24, 0, true)).toBe('Z')
+    })
+
+    test('tzOffset(24, 0, true)    is Z', () => {
+      expect(tzOffset(24, 0, true)).toBe('Z')
+    })
+
+    test('tzOffset(-24, -1)        is -00:01', () => {
+      expect(tzOffset(-24, -1)).toBe('-00:01')
+    })
+
+    test('tzOffset(24, 1)          is 00:01', () => {
+      expect(tzOffset(24, 1)).toBe('+00:01')
+    })
+
+    test('tzOffset(-35)            is -11:00', () => {
+      expect(tzOffset(-35)).toBe('-11:00')
+    })
+
+    test('tzOffset(-35, 0, true)   is +13:00', () => {
+      expect(tzOffset(-35, 0, true)).toBe('+13:00')
+    })
+
+    test('tzOffset(62.75)          is +14:45', () => {
+      expect(tzOffset(62.75)).toBe('+14:45')
+    })
+
+    test('tzOffset(-12, 0, true)   is -12:00', () => {
+      expect(tzOffset(-12, 0, true)).toBe('-12:00')
+    })
+
+    test('tzOffset(-12, -20, true) is +11:40', () => {
+      expect(tzOffset(-12, -20, true)).toBe('+11:40')
+    })
+
+    test('tzOffset(-13, -20, true) is +10:40', () => {
+      expect(tzOffset(-13, -20, true)).toBe('+10:40')
+    })
+
+    test('tzOffset(14, 45, true)   is -09:15', () => {
+      expect(tzOffset(14, 45, true)).toBe('-09:15')
+    })
+
+    test('tzOffset(62.75, 0, true) is -09:15', () => {
+      expect(tzOffset(62.75, 0, true)).toBe('-09:15')
+    })
+  })
+})
diff --git a/src/temporal-same-features/utils/const.js b/src/temporal-same-features/utils/const.js
new file mode 100644
index 0000000..e04fc0d
--- /dev/null
+++ b/src/temporal-same-features/utils/const.js
@@ -0,0 +1,18 @@
+export const MINUTES_PER_DAY = 60 * 24
+export const MILLISECONDS_PER_DAY = 1000 * 60 * 60 * 24
+export const MILLISECONDS_PER_WEEK = MILLISECONDS_PER_DAY * 7
+
+/**
+ * The farthest timezone offset **behind** UTC time.
+ */
+export const IANA_LOWER_TIMEZONE = -12 * 60 // -12:00
+
+/**
+ * The farthest timezone offset **ahead of** UTC time.
+ */
+export const IANA_UPPER_TIMEZONE = 14 * 60 // +14:00
+
+/**
+ * Local timezone offset from UTC, in minutes.
+ */
+export const LOCAL_TZ_OFFSET = (new Date()).getTimezoneOffset() * -1
diff --git a/src/temporal-same-features/utils/date.js b/src/temporal-same-features/utils/date.js
new file mode 100644
index 0000000..f0ee775
--- /dev/null
+++ b/src/temporal-same-features/utils/date.js
@@ -0,0 +1,41 @@
+/**
+ * @todo
+ * - `weekNumber` and `daysBetween` could accept Temporal objects as parameters
+ * - make sur to understand zoned datetime (https://tc39.es/proposal-temporal/docs/zoneddatetime.html#weekOfYear)
+ */
+
+import { dateToPlainDate } from './temporal.js'
+
+/**
+ * Calculate the difference between 2 dates in days, discarding the time of day.
+ *
+ * @todo Consider renaming it daysDiff when there’s a breaking change, since it
+ * can returns a negative number when date > furtherDate.
+ *
+ * @param {Date} date The oldest of the two dates.
+ * @param {Date} furtherDate Another date, greater than the first one.
+ * @returns {number}
+ */
+export const daysBetween = (date, furtherDate) => dateToPlainDate(date).until(dateToPlainDate(furtherDate)).days
+
+/**
+ * Get the week number (`1`–`53`) of a date according to local time, as defined
+ * by the WHATWG and the ISO-8601 specs:
+ *
+ * - a week starts on Monday (https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#concept-week);
+ * - the first week of the year includes a Thursday;
+ * - week numbers go from 1 to 53 (https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#week-number-of-the-last-day).
+ *
+ * @param {Date} date
+ * @returns {number}
+ */
+export const weekNumber = date => dateToPlainDate(date).weekOfYear
+// export const weekNumber = date => date.toTemporalInstant().toZonedDateTimeISO('UTC').weekOfYear
+
+/**
+ * Get the day index of the week, Monday is 1 and Sunday is 7.
+ *
+ * @param {Date} date
+ * @returns {number}
+ */
+export const getTemporalDay = date => dateToPlainDate(date).dayOfWeek
diff --git a/src/temporal-same-features/utils/date.test.js b/src/temporal-same-features/utils/date.test.js
new file mode 100644
index 0000000..a65527a
--- /dev/null
+++ b/src/temporal-same-features/utils/date.test.js
@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'vitest'
+
+import { daysBetween, weekNumber } from '../index.js'
+
+const togoIndependanceDay = new Date(1960, 3, 27)
+const january1st2021 = new Date(2021, 0, 1, 10, 10, 12)
+const january11th = new Date(2021, 0, 11, 10, 10, 12)
+const december31th2020 = new Date(2020, 11, 31, 10, 10, 12)
+const december31th2020OneMinuteLater = new Date(2020, 11, 31, 10, 11, 12)
+const december31th2021 = new Date(2021, 11, 31, 10, 10, 12)
+const january2nd2022 = new Date(2022, 0, 2, 10, 10, 12)
+const january3rd2022 = new Date(2022, 0, 3, 10, 10, 12)
+
+describe('weekNumber', () => {
+
+  test('is a function', () => {
+    expect(weekNumber).toBeInstanceOf(Function)
+  })
+
+  describe('weeks without year overlap', () => {
+
+    test('1960-04-27 is week 17', () => {
+      expect(weekNumber(togoIndependanceDay)).toBe(17)
+    })
+
+    test('2021-01-11 is week 2', () => {
+      expect(weekNumber(january11th)).toBe(2)
+    })
+  })
+
+  describe('weeks with potential year overlap', () => {
+
+    test('2020-12-31 is week 53', () => {
+      expect(weekNumber(december31th2020)).toBe(53)
+    })
+
+    test('2021-01-01 is week 53', () => {
+      expect(weekNumber(january1st2021)).toBe(53)
+    })
+
+    test('2021-12-31 is week 52', () => {
+      expect(weekNumber(december31th2021)).toBe(52)
+    })
+
+    test('2022-01-02 is week 52', () => {
+      expect(weekNumber(january2nd2022)).toBe(52)
+    })
+
+    test('2022-01-03 is week 1', () => {
+      expect(weekNumber(january3rd2022)).toBe(1)
+    })
+  })
+
+})
+
+describe('daysBetween', () => {
+
+  test('is a function', () => expect(daysBetween).toBeInstanceOf(Function))
+
+  test('10 days between 1/1 and 11/1', () => {
+    expect(daysBetween(january1st2021, january11th)).toBe(10)
+  })
+
+  test('-10 days between 11/1 and 1/1', () => {
+    expect(daysBetween(january11th, january1st2021)).toBe(-10)
+  })
+
+  test('same day, different time', () => {
+    expect(daysBetween(december31th2020, december31th2020OneMinuteLater)).toBe(0)
+  })
+})
diff --git a/src/temporal-same-features/utils/math.js b/src/temporal-same-features/utils/math.js
new file mode 100644
index 0000000..7d51717
--- /dev/null
+++ b/src/temporal-same-features/utils/math.js
@@ -0,0 +1,11 @@
+/**
+ * Round a number to the provided precision.
+ *
+ * @param {number} number The number to round.
+ * @param {number} [precision=0] The rounding precision.
+ * @returns {number}
+ */
+export const round = (number, precision = 0) => {
+  precision = 10 ** precision
+  return Math.round(number * precision) / precision
+}
diff --git a/src/temporal-same-features/utils/string.js b/src/temporal-same-features/utils/string.js
new file mode 100644
index 0000000..9116a75
--- /dev/null
+++ b/src/temporal-same-features/utils/string.js
@@ -0,0 +1,8 @@
+/**
+ * padStart a stringable variable by the provided number of 0.
+ *
+ * @param {*} value A stringable value (string, number…).
+ * @param {number} [length=2] The number of 0 at the beginning of the result.
+ * @returns {string}
+ */
+export const p = (value, length = 2) => value.toString().padStart(length, '0')
diff --git a/src/temporal-same-features/utils/temporal.js b/src/temporal-same-features/utils/temporal.js
new file mode 100644
index 0000000..1a7479b
--- /dev/null
+++ b/src/temporal-same-features/utils/temporal.js
@@ -0,0 +1,9 @@
+import { Temporal } from '@js-temporal/polyfill'
+// import { Temporal } from 'temporal-polyfill'
+
+// Date.prototype.toTemporalInstant = toTemporalInstant
+
+export const dateToPlainDate = d => new Temporal.PlainDate(d.getFullYear(), d.getMonth() + 1, d.getDate())
+
+/** @todo check https://tc39.es/proposal-temporal/docs/cookbook.html#date-only-values-legacy-date--temporalplaindate */
+// export const dateToPlainDate = d => d.toTemporalInstant().toZonedDateTimeISO(Temporal.Now.timeZoneId()).toPlainDate()