@fedify/vocab-runtime 2.0.36-dev.2530 → 2.0.36-dev.2551

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.0.36-dev.2530+fb03bc56",
+  "version": "2.0.36-dev.2551+8b012df4",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mod.cjs

@@ -4502,7 +4502,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.36-dev.2530+fb03bc56";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/mod.js

@@ -4498,7 +4498,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.36-dev.2530+fb03bc56";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/temporal.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation

package/dist/temporal.d.cts

@@ -1,7 +1,8 @@
 /// <reference lib="esnext.temporal" />
 //#region src/temporal.d.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation

package/dist/temporal.d.ts

@@ -1,7 +1,8 @@
 /// <reference lib="esnext.temporal" />
 //#region src/temporal.d.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation

package/dist/temporal.js

@@ -1,7 +1,8 @@
 
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation

package/dist/tests/{body-KJu7BVrD.cjs → body-5wwZdMK0.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-C1QT7ro7.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/{body-aEN-Jw2f.mjs → body-DqkK9XBY.mjs}

@@ -1,4 +1,4 @@
-import { t as FetchError } from "./request-DMfShbXT.mjs";
+import { t as FetchError } from "./request-BiuryHCs.mjs";
 import { getLogger } from "@logtape/logtape";
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/body.test.cjs

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_body = require("./body-KJu7BVrD.cjs");
+const require_body = require("./body-5wwZdMK0.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");

package/dist/tests/body.test.mjs

@@ -1,4 +1,4 @@
-import { r as readBoundedText, t as BodyTooLargeError } from "./body-aEN-Jw2f.mjs";
+import { r as readBoundedText, t as BodyTooLargeError } from "./body-DqkK9XBY.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { test } from "node:test";
 import { gunzipSync, gzipSync } from "node:zlib";

package/dist/tests/docloader.test.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-C1QT7ro7.cjs");
-const require_body = require("./body-KJu7BVrD.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
+const require_body = require("./body-5wwZdMK0.cjs");
 const require_esm = require("./esm-4DuocLvD.cjs");
 const require_link = require("./link-qDTmjPw_.cjs");
 const require_url = require("./url-DLuSj57U.cjs");

package/dist/tests/docloader.test.mjs

@@ -1,6 +1,6 @@
 import { t as esm_default } from "./esm-CnLt0wAF.mjs";
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-DMfShbXT.mjs";
-import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-aEN-Jw2f.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-BiuryHCs.mjs";
+import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-DqkK9XBY.mjs";
 import { t as HttpHeaderLink } from "./link-CYszIegt.mjs";
 import { t as UrlError } from "./url-DjsVF44Q.mjs";
 import { n as openDirectFetch, r as openPublicFetch, t as createPublicFetch } from "./public-fetch-BUSPlh1C.mjs";

package/dist/tests/{request-C1QT7ro7.cjs → request-BNAT7gZ3.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.36-dev.2530+fb03bc56";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-DMfShbXT.mjs → request-BiuryHCs.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.36-dev.2530+fb03bc56";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-C1QT7ro7.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
 let node_test = require("node:test");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { o as version, r as getUserAgent } from "./request-DMfShbXT.mjs";
+import { o as version, r as getUserAgent } from "./request-BiuryHCs.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

package/dist/tests/temporal.test.cjs

@@ -4,7 +4,8 @@ let node_assert = require("node:assert");
 let _js_temporal_polyfill = require("@js-temporal/polyfill");
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -147,30 +148,40 @@ function normalizeDateTimeLiteral(value) {
 		sign: 0
 	}), false);
 });
+const literalsWithOffset = [
+	"2024-01-01T10:00Z",
+	"2024-01-01T10:00+09:00",
+	"2024-01-01T10:00-05:00",
+	"2024-01-01T10:00:00Z",
+	"2024-01-01T10:00:00+09:00",
+	"2024-01-01T10:00:00-05:00",
+	"2024-01-01T10:00:00+0900",
+	"2024-01-01T10:00:00.123456789Z",
+	"2024-01-01t10:00z",
+	"2024-01-01 10:00:00Z"
+];
+const literalsWithoutOffset = [
+	"2024-01-01T10:00",
+	"2024-01-01T10:00:00",
+	"2024-01-01T10:00:00.123",
+	"2025-01-01 12:34:56"
+];
+const literalsWithoutSeconds = [
+	["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+	["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+	["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
+];
+const literalsWithExpandedYear = [["+002024-01-01T10:00", "+002024-01-01T10:00Z"], ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"]];
 (0, node_test.test)("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
-	for (const literal of [
-		"2024-01-01T10:00Z",
-		"2024-01-01T10:00+09:00",
-		"2024-01-01T10:00-05:00",
-		"2024-01-01T10:00:00Z",
-		"2024-01-01T10:00:00+09:00",
-		"2024-01-01T10:00:00-05:00",
-		"2024-01-01T10:00:00+0900",
-		"2024-01-01T10:00:00.123456789Z",
-		"2024-01-01t10:00z",
-		"2024-01-01 10:00:00Z"
-	]) {
+	for (const literal of literalsWithOffset) {
 		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), literal);
 		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(literal), "object");
 	}
 });
 (0, node_test.test)("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
-	for (const literal of [
-		"2024-01-01T10:00",
-		"2024-01-01T10:00:00",
-		"2024-01-01T10:00:00.123",
-		"2025-01-01 12:34:56"
-	]) {
+	for (const literal of literalsWithoutOffset) {
 		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), `${literal}Z`);
 		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalizeDateTimeLiteral(literal)), "object");
 	}
@@ -179,16 +190,29 @@ function normalizeDateTimeLiteral(value) {
 	(0, node_assert.strictEqual)(normalizeDateTimeLiteral("2024-01-01"), "2024-01-01");
 });
 (0, node_test.test)("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
-	for (const [literal, normalized] of [
-		["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
-		["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
-		["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
-		["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
-		["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
-	]) {
+	for (const [literal, normalized] of literalsWithoutSeconds) {
 		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), normalized);
 		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalized), "object");
 	}
 	(0, node_assert.strictEqual)(normalizeDateTimeLiteral("2024-01-01T10:00:00.5Z"), "2024-01-01T10:00:00.5Z");
 });
+(0, node_test.test)("normalizeDateTimeLiteral() handles expanded years", () => {
+	for (const [literal, normalized] of literalsWithExpandedYear) {
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), normalized);
+		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalized), "object");
+	}
+});
+(0, node_test.test)("normalizeDateTimeLiteral() is idempotent", () => {
+	const literals = [
+		...literalsWithOffset,
+		...literalsWithoutOffset,
+		...literalsWithoutSeconds.map(([literal]) => literal),
+		...literalsWithExpandedYear.map(([literal]) => literal),
+		"2024-01-01"
+	];
+	for (const literal of literals) {
+		const normalized = normalizeDateTimeLiteral(literal);
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(normalized), normalized);
+	}
+});
 //#endregion

package/dist/tests/temporal.test.mjs

@@ -3,7 +3,8 @@ import { strictEqual } from "node:assert";
 import { Temporal } from "@js-temporal/polyfill";
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -146,30 +147,40 @@ test("isTemporalDuration() rejects default Object.prototype.toString", () => {
 		sign: 0
 	}), false);
 });
+const literalsWithOffset = [
+	"2024-01-01T10:00Z",
+	"2024-01-01T10:00+09:00",
+	"2024-01-01T10:00-05:00",
+	"2024-01-01T10:00:00Z",
+	"2024-01-01T10:00:00+09:00",
+	"2024-01-01T10:00:00-05:00",
+	"2024-01-01T10:00:00+0900",
+	"2024-01-01T10:00:00.123456789Z",
+	"2024-01-01t10:00z",
+	"2024-01-01 10:00:00Z"
+];
+const literalsWithoutOffset = [
+	"2024-01-01T10:00",
+	"2024-01-01T10:00:00",
+	"2024-01-01T10:00:00.123",
+	"2025-01-01 12:34:56"
+];
+const literalsWithoutSeconds = [
+	["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+	["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+	["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
+];
+const literalsWithExpandedYear = [["+002024-01-01T10:00", "+002024-01-01T10:00Z"], ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"]];
 test("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
-	for (const literal of [
-		"2024-01-01T10:00Z",
-		"2024-01-01T10:00+09:00",
-		"2024-01-01T10:00-05:00",
-		"2024-01-01T10:00:00Z",
-		"2024-01-01T10:00:00+09:00",
-		"2024-01-01T10:00:00-05:00",
-		"2024-01-01T10:00:00+0900",
-		"2024-01-01T10:00:00.123456789Z",
-		"2024-01-01t10:00z",
-		"2024-01-01 10:00:00Z"
-	]) {
+	for (const literal of literalsWithOffset) {
 		strictEqual(normalizeDateTimeLiteral(literal), literal);
 		strictEqual(typeof Temporal.Instant.from(literal), "object");
 	}
 });
 test("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
-	for (const literal of [
-		"2024-01-01T10:00",
-		"2024-01-01T10:00:00",
-		"2024-01-01T10:00:00.123",
-		"2025-01-01 12:34:56"
-	]) {
+	for (const literal of literalsWithoutOffset) {
 		strictEqual(normalizeDateTimeLiteral(literal), `${literal}Z`);
 		strictEqual(typeof Temporal.Instant.from(normalizeDateTimeLiteral(literal)), "object");
 	}
@@ -178,17 +189,30 @@ test("normalizeDateTimeLiteral() keeps literals without a time part", () => {
 	strictEqual(normalizeDateTimeLiteral("2024-01-01"), "2024-01-01");
 });
 test("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
-	for (const [literal, normalized] of [
-		["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
-		["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
-		["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
-		["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
-		["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
-	]) {
+	for (const [literal, normalized] of literalsWithoutSeconds) {
 		strictEqual(normalizeDateTimeLiteral(literal), normalized);
 		strictEqual(typeof Temporal.Instant.from(normalized), "object");
 	}
 	strictEqual(normalizeDateTimeLiteral("2024-01-01T10:00:00.5Z"), "2024-01-01T10:00:00.5Z");
 });
+test("normalizeDateTimeLiteral() handles expanded years", () => {
+	for (const [literal, normalized] of literalsWithExpandedYear) {
+		strictEqual(normalizeDateTimeLiteral(literal), normalized);
+		strictEqual(typeof Temporal.Instant.from(normalized), "object");
+	}
+});
+test("normalizeDateTimeLiteral() is idempotent", () => {
+	const literals = [
+		...literalsWithOffset,
+		...literalsWithoutOffset,
+		...literalsWithoutSeconds.map(([literal]) => literal),
+		...literalsWithExpandedYear.map(([literal]) => literal),
+		"2024-01-01"
+	];
+	for (const literal of literals) {
+		const normalized = normalizeDateTimeLiteral(literal);
+		strictEqual(normalizeDateTimeLiteral(normalized), normalized);
+	}
+});
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.0.36-dev.2530+fb03bc56",
+  "version": "2.0.36-dev.2551+8b012df4",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/temporal.test.ts

@@ -124,33 +124,48 @@ test("isTemporalDuration() rejects default Object.prototype.toString", () => {
   strictEqual(isTemporalDuration(decoy), false);
 });
 
+const literalsWithOffset = [
+  "2024-01-01T10:00Z",
+  "2024-01-01T10:00+09:00",
+  "2024-01-01T10:00-05:00",
+  "2024-01-01T10:00:00Z",
+  "2024-01-01T10:00:00+09:00",
+  "2024-01-01T10:00:00-05:00",
+  "2024-01-01T10:00:00+0900",
+  "2024-01-01T10:00:00.123456789Z",
+  "2024-01-01t10:00z",
+  "2024-01-01 10:00:00Z",
+] as const;
+
+const literalsWithoutOffset = [
+  "2024-01-01T10:00",
+  "2024-01-01T10:00:00",
+  "2024-01-01T10:00:00.123",
+  "2025-01-01 12:34:56",
+] as const;
+
+const literalsWithoutSeconds = [
+  ["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+  ["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+  ["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+  ["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+  ["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"],
+] as const;
+
+const literalsWithExpandedYear = [
+  ["+002024-01-01T10:00", "+002024-01-01T10:00Z"],
+  ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"],
+] as const;
+
 test("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
-  const literals = [
-    "2024-01-01T10:00Z",
-    "2024-01-01T10:00+09:00",
-    "2024-01-01T10:00-05:00",
-    "2024-01-01T10:00:00Z",
-    "2024-01-01T10:00:00+09:00",
-    "2024-01-01T10:00:00-05:00",
-    "2024-01-01T10:00:00+0900",
-    "2024-01-01T10:00:00.123456789Z",
-    "2024-01-01t10:00z",
-    "2024-01-01 10:00:00Z",
-  ];
-  for (const literal of literals) {
+  for (const literal of literalsWithOffset) {
     strictEqual(normalizeDateTimeLiteral(literal), literal);
     strictEqual(typeof Temporal.Instant.from(literal), "object");
   }
 });
 
 test("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
-  const literals = [
-    "2024-01-01T10:00",
-    "2024-01-01T10:00:00",
-    "2024-01-01T10:00:00.123",
-    "2025-01-01 12:34:56",
-  ];
-  for (const literal of literals) {
+  for (const literal of literalsWithoutOffset) {
     strictEqual(normalizeDateTimeLiteral(literal), `${literal}Z`);
     strictEqual(
       typeof Temporal.Instant.from(normalizeDateTimeLiteral(literal)),
@@ -164,14 +179,7 @@ test("normalizeDateTimeLiteral() keeps literals without a time part", () => {
 });
 
 test("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
-  const literals = [
-    ["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
-    ["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
-    ["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
-    ["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
-    ["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"],
-  ] as const;
-  for (const [literal, normalized] of literals) {
+  for (const [literal, normalized] of literalsWithoutSeconds) {
     strictEqual(normalizeDateTimeLiteral(literal), normalized);
     strictEqual(typeof Temporal.Instant.from(normalized), "object");
   }
@@ -180,3 +188,24 @@ test("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", ()
     "2024-01-01T10:00:00.5Z",
   );
 });
+
+test("normalizeDateTimeLiteral() handles expanded years", () => {
+  for (const [literal, normalized] of literalsWithExpandedYear) {
+    strictEqual(normalizeDateTimeLiteral(literal), normalized);
+    strictEqual(typeof Temporal.Instant.from(normalized), "object");
+  }
+});
+
+test("normalizeDateTimeLiteral() is idempotent", () => {
+  const literals = [
+    ...literalsWithOffset,
+    ...literalsWithoutOffset,
+    ...literalsWithoutSeconds.map(([literal]) => literal),
+    ...literalsWithExpandedYear.map(([literal]) => literal),
+    "2024-01-01",
+  ];
+  for (const literal of literals) {
+    const normalized = normalizeDateTimeLiteral(literal);
+    strictEqual(normalizeDateTimeLiteral(normalized), normalized);
+  }
+});

package/src/temporal.ts

@@ -1,5 +1,6 @@
 /**
- * Type guards for `Temporal` namespace objects.
+ * Type guards for `Temporal` namespace objects and normalization of
+ * `xsd:dateTime` literals.
  *
  * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
  * `temporal-polyfill`) and the host's native `Temporal` implementation