@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_schema.js

@@ -0,0 +1,120 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { binary } from "./_type/binary.js";
+import { bool } from "./_type/bool.js";
+import { float$1 as float } from "./_type/float.js";
+import { int } from "./_type/int.js";
+import { map } from "./_type/map.js";
+import { merge } from "./_type/merge.js";
+import { nil } from "./_type/nil.js";
+import { omap } from "./_type/omap.js";
+import { pairs } from "./_type/pairs.js";
+import { regexp } from "./_type/regexp.js";
+import { seq } from "./_type/seq.js";
+import { set } from "./_type/set.js";
+import { str } from "./_type/str.js";
+import { timestamp } from "./_type/timestamp.js";
+import { undefinedType } from "./_type/undefined.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_schema.js
+function createTypeMap(implicitTypes, explicitTypes) {
+	const result = {
+		fallback: new Map(),
+		mapping: new Map(),
+		scalar: new Map(),
+		sequence: new Map()
+	};
+	const fallbackMap = result.fallback;
+	for (const type of [...implicitTypes, ...explicitTypes]) {
+		const map$1 = result[type.kind];
+		map$1.set(type.tag, type);
+		fallbackMap.set(type.tag, type);
+	}
+	return result;
+}
+function createSchema({ explicitTypes = [], implicitTypes = [], include }) {
+	if (include) {
+		implicitTypes.push(...include.implicitTypes);
+		explicitTypes.push(...include.explicitTypes);
+	}
+	const typeMap = createTypeMap(implicitTypes, explicitTypes);
+	return {
+		implicitTypes,
+		explicitTypes,
+		typeMap
+	};
+}
+/**
+* Standard YAML's failsafe schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2802346}
+*/ const FAILSAFE_SCHEMA = createSchema({ explicitTypes: [
+	str,
+	seq,
+	map
+] });
+/**
+* Standard YAML's JSON schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2803231}
+*/ const JSON_SCHEMA = createSchema({
+	implicitTypes: [
+		nil,
+		bool,
+		int,
+		float
+	],
+	include: FAILSAFE_SCHEMA
+});
+/**
+* Standard YAML's core schema.
+*
+* @see {@link http://www.yaml.org/spec/1.2/spec.html#id2804923}
+*/ const CORE_SCHEMA = createSchema({ include: JSON_SCHEMA });
+/**
+* Default YAML schema. It is not described in the YAML specification.
+*/ const DEFAULT_SCHEMA = createSchema({
+	explicitTypes: [
+		binary,
+		omap,
+		pairs,
+		set
+	],
+	implicitTypes: [timestamp, merge],
+	include: CORE_SCHEMA
+});
+/***
+* Extends JS-YAML default schema with additional JavaScript types
+* It is not described in the YAML specification.
+* Functions are no longer supported for security reasons.
+*
+* @example
+* ```ts
+* import { parse } from "@std/yaml";
+*
+* const data = parse(
+*   `
+*   regexp:
+*     simple: !!js/regexp foobar
+*     modifiers: !!js/regexp /foobar/mi
+*   undefined: !!js/undefined ~
+* `,
+*   { schema: "extended" },
+* );
+* ```
+*/ const EXTENDED_SCHEMA = createSchema({
+	explicitTypes: [regexp, undefinedType],
+	include: DEFAULT_SCHEMA
+});
+const SCHEMA_MAP = new Map([
+	["core", CORE_SCHEMA],
+	["default", DEFAULT_SCHEMA],
+	["failsafe", FAILSAFE_SCHEMA],
+	["json", JSON_SCHEMA],
+	["extended", EXTENDED_SCHEMA]
+]);
+
+//#endregion
+export { DEFAULT_SCHEMA, SCHEMA_MAP };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/binary.js

@@ -0,0 +1,92 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/binary.js
+const BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
+	if (data === null) return false;
+	let code;
+	let bitlen = 0;
+	const max = data.length;
+	const map = BASE64_MAP;
+	for (let idx = 0; idx < max; idx++) {
+		code = map.indexOf(data.charAt(idx));
+		if (code > 64) continue;
+		if (code < 0) return false;
+		bitlen += 6;
+	}
+	return bitlen % 8 === 0;
+}
+function constructYamlBinary(data) {
+	const input = data.replace(/[\r\n=]/g, "");
+	const max = input.length;
+	const map = BASE64_MAP;
+	const result = [];
+	let bits = 0;
+	for (let idx = 0; idx < max; idx++) {
+		if (idx % 4 === 0 && idx) {
+			result.push(bits >> 16 & 255);
+			result.push(bits >> 8 & 255);
+			result.push(bits & 255);
+		}
+		bits = bits << 6 | map.indexOf(input.charAt(idx));
+	}
+	const tailbits = max % 4 * 6;
+	if (tailbits === 0) {
+		result.push(bits >> 16 & 255);
+		result.push(bits >> 8 & 255);
+		result.push(bits & 255);
+	} else if (tailbits === 18) {
+		result.push(bits >> 10 & 255);
+		result.push(bits >> 2 & 255);
+	} else if (tailbits === 12) result.push(bits >> 4 & 255);
+	return new Uint8Array(result);
+}
+function representYamlBinary(object) {
+	const max = object.length;
+	const map = BASE64_MAP;
+	let result = "";
+	let bits = 0;
+	for (let idx = 0; idx < max; idx++) {
+		if (idx % 3 === 0 && idx) {
+			result += map[bits >> 18 & 63];
+			result += map[bits >> 12 & 63];
+			result += map[bits >> 6 & 63];
+			result += map[bits & 63];
+		}
+		bits = (bits << 8) + object[idx];
+	}
+	const tail = max % 3;
+	if (tail === 0) {
+		result += map[bits >> 18 & 63];
+		result += map[bits >> 12 & 63];
+		result += map[bits >> 6 & 63];
+		result += map[bits & 63];
+	} else if (tail === 2) {
+		result += map[bits >> 10 & 63];
+		result += map[bits >> 4 & 63];
+		result += map[bits << 2 & 63];
+		result += map[64];
+	} else if (tail === 1) {
+		result += map[bits >> 2 & 63];
+		result += map[bits << 4 & 63];
+		result += map[64];
+		result += map[64];
+	}
+	return result;
+}
+function isBinary(obj) {
+	return obj instanceof Uint8Array;
+}
+const binary = {
+	tag: "tag:yaml.org,2002:binary",
+	construct: constructYamlBinary,
+	kind: "scalar",
+	predicate: isBinary,
+	represent: representYamlBinary,
+	resolve: resolveYamlBinary
+};
+
+//#endregion
+export { binary };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/bool.js

@@ -0,0 +1,41 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/bool.js
+const YAML_TRUE_BOOLEANS = [
+	"true",
+	"True",
+	"TRUE"
+];
+const YAML_FALSE_BOOLEANS = [
+	"false",
+	"False",
+	"FALSE"
+];
+const YAML_BOOLEANS = [...YAML_TRUE_BOOLEANS, ...YAML_FALSE_BOOLEANS];
+const bool = {
+	tag: "tag:yaml.org,2002:bool",
+	kind: "scalar",
+	defaultStyle: "lowercase",
+	predicate: (value) => typeof value === "boolean" || value instanceof Boolean,
+	construct: (data) => YAML_TRUE_BOOLEANS.includes(data),
+	resolve: (data) => YAML_BOOLEANS.includes(data),
+	represent: {
+		lowercase: (object) => {
+			const value = object instanceof Boolean ? object.valueOf() : object;
+			return value ? "true" : "false";
+		},
+		uppercase: (object) => {
+			const value = object instanceof Boolean ? object.valueOf() : object;
+			return value ? "TRUE" : "FALSE";
+		},
+		camelcase: (object) => {
+			const value = object instanceof Boolean ? object.valueOf() : object;
+			return value ? "True" : "False";
+		}
+	}
+};
+
+//#endregion
+export { bool };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/float.js

@@ -0,0 +1,58 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isNegativeZero } from "../_utils.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/float.js
+const YAML_FLOAT_PATTERN = new RegExp("^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat(data) {
+	if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") return false;
+	return true;
+}
+function constructYamlFloat(data) {
+	let value = data.replace(/_/g, "").toLowerCase();
+	const sign = value[0] === "-" ? -1 : 1;
+	if (value[0] && "+-".includes(value[0])) value = value.slice(1);
+	if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	if (value === ".nan") return NaN;
+	return sign * parseFloat(value);
+}
+const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object, style) {
+	const value = object instanceof Number ? object.valueOf() : object;
+	if (isNaN(value)) switch (style) {
+		case "lowercase": return ".nan";
+		case "uppercase": return ".NAN";
+		case "camelcase": return ".NaN";
+	}
+	else if (Number.POSITIVE_INFINITY === value) switch (style) {
+		case "lowercase": return ".inf";
+		case "uppercase": return ".INF";
+		case "camelcase": return ".Inf";
+	}
+	else if (Number.NEGATIVE_INFINITY === value) switch (style) {
+		case "lowercase": return "-.inf";
+		case "uppercase": return "-.INF";
+		case "camelcase": return "-.Inf";
+	}
+	else if (isNegativeZero(value)) return "-0.0";
+	const res = value.toString(10);
+	return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat(object) {
+	if (object instanceof Number) object = object.valueOf();
+	return typeof object === "number" && (object % 1 !== 0 || isNegativeZero(object));
+}
+const float = {
+	tag: "tag:yaml.org,2002:float",
+	construct: constructYamlFloat,
+	defaultStyle: "lowercase",
+	kind: "scalar",
+	predicate: isFloat,
+	represent: representYamlFloat,
+	resolve: resolveYamlFloat
+};
+
+//#endregion
+export { float as float$1 };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/int.js

@@ -0,0 +1,118 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isNegativeZero } from "../_utils.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/int.js
+function isCharCodeInRange(c, lower, upper) {
+	return lower <= c && c <= upper;
+}
+function isHexCode(c) {
+	return isCharCodeInRange(c, 48, 57) || isCharCodeInRange(c, 65, 70) || isCharCodeInRange(c, 97, 102);
+}
+function isOctCode(c) {
+	return isCharCodeInRange(c, 48, 55);
+}
+function isDecCode(c) {
+	return isCharCodeInRange(c, 48, 57);
+}
+function resolveYamlInteger(data) {
+	const max = data.length;
+	let index = 0;
+	let hasDigits = false;
+	if (!max) return false;
+	let ch = data[index];
+	if (ch === "-" || ch === "+") ch = data[++index];
+	if (ch === "0") {
+		if (index + 1 === max) return true;
+		ch = data[++index];
+		if (ch === "b") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (ch !== "0" && ch !== "1") return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		if (ch === "x") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (!isHexCode(data.charCodeAt(index))) return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		for (; index < max; index++) {
+			ch = data[index];
+			if (ch === "_") continue;
+			if (!isOctCode(data.charCodeAt(index))) return false;
+			hasDigits = true;
+		}
+		return hasDigits && ch !== "_";
+	}
+	if (ch === "_") return false;
+	for (; index < max; index++) {
+		ch = data[index];
+		if (ch === "_") continue;
+		if (!isDecCode(data.charCodeAt(index))) return false;
+		hasDigits = true;
+	}
+	if (!hasDigits || ch === "_") return false;
+	return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+function constructYamlInteger(data) {
+	let value = data;
+	if (value.includes("_")) value = value.replace(/_/g, "");
+	let sign = 1;
+	let ch = value[0];
+	if (ch === "-" || ch === "+") {
+		if (ch === "-") sign = -1;
+		value = value.slice(1);
+		ch = value[0];
+	}
+	if (value === "0") return 0;
+	if (ch === "0") {
+		if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+		if (value[1] === "x") return sign * parseInt(value, 16);
+		return sign * parseInt(value, 8);
+	}
+	return sign * parseInt(value, 10);
+}
+function isInteger(object) {
+	if (object instanceof Number) object = object.valueOf();
+	return typeof object === "number" && object % 1 === 0 && !isNegativeZero(object);
+}
+const int = {
+	tag: "tag:yaml.org,2002:int",
+	construct: constructYamlInteger,
+	defaultStyle: "decimal",
+	kind: "scalar",
+	predicate: isInteger,
+	represent: {
+		binary(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0b${value.toString(2)}` : `-0b${value.toString(2).slice(1)}`;
+		},
+		octal(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0${value.toString(8)}` : `-0${value.toString(8).slice(1)}`;
+		},
+		decimal(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value.toString(10);
+		},
+		hexadecimal(object) {
+			const value = object instanceof Number ? object.valueOf() : object;
+			return value >= 0 ? `0x${value.toString(16).toUpperCase()}` : `-0x${value.toString(16).toUpperCase().slice(1)}`;
+		}
+	},
+	resolve: resolveYamlInteger
+};
+
+//#endregion
+export { int };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/map.js

@@ -0,0 +1,18 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/map.js
+const map = {
+	tag: "tag:yaml.org,2002:map",
+	resolve() {
+		return true;
+	},
+	construct(data) {
+		return data !== null ? data : {};
+	},
+	kind: "mapping"
+};
+
+//#endregion
+export { map };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/merge.js

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/merge.js
+const merge = {
+	tag: "tag:yaml.org,2002:merge",
+	kind: "scalar",
+	resolve: (data) => data === "<<" || data === null,
+	construct: (data) => data
+};
+
+//#endregion
+export { merge };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/nil.js

@@ -0,0 +1,23 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/nil.js
+const nil = {
+	tag: "tag:yaml.org,2002:null",
+	kind: "scalar",
+	defaultStyle: "lowercase",
+	predicate: (object) => object === null,
+	construct: () => null,
+	resolve: (data) => {
+		return data === "~" || data === "null" || data === "Null" || data === "NULL";
+	},
+	represent: {
+		lowercase: () => "null",
+		uppercase: () => "NULL",
+		camelcase: () => "Null"
+	}
+};
+
+//#endregion
+export { nil };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/omap.js

@@ -0,0 +1,31 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isPlainObject } from "../_utils.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/omap.js
+function resolveYamlOmap(data) {
+	const objectKeys = new Set();
+	for (const object of data) {
+		if (!isPlainObject(object)) return false;
+		const keys = Object.keys(object);
+		if (keys.length !== 1) return false;
+		for (const key of keys) {
+			if (objectKeys.has(key)) return false;
+			objectKeys.add(key);
+		}
+	}
+	return true;
+}
+const omap = {
+	tag: "tag:yaml.org,2002:omap",
+	kind: "sequence",
+	resolve: resolveYamlOmap,
+	construct(data) {
+		return data;
+	}
+};
+
+//#endregion
+export { omap };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/pairs.js

@@ -0,0 +1,22 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { isPlainObject } from "../_utils.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/pairs.js
+function resolveYamlPairs(data) {
+	if (data === null) return true;
+	return data.every((it) => isPlainObject(it) && Object.keys(it).length === 1);
+}
+const pairs = {
+	tag: "tag:yaml.org,2002:pairs",
+	construct(data) {
+		return data?.flatMap(Object.entries) ?? [];
+	},
+	kind: "sequence",
+	resolve: resolveYamlPairs
+};
+
+//#endregion
+export { pairs };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/regexp.js

@@ -0,0 +1,29 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/regexp.js
+const REGEXP = /^\/(?<regexp>[\s\S]+)\/(?<modifiers>[gismuy]*)$/;
+const regexp = {
+	tag: "tag:yaml.org,2002:js/regexp",
+	kind: "scalar",
+	resolve(data) {
+		if (data === null || !data.length) return false;
+		if (data.charAt(0) === "/") {
+			const groups = data.match(REGEXP)?.groups;
+			if (!groups) return false;
+			const modifiers = groups.modifiers ?? "";
+			if (new Set(modifiers).size < modifiers.length) return false;
+		}
+		return true;
+	},
+	construct(data) {
+		const { regexp: regexp$1 = data, modifiers = "" } = data.match(REGEXP)?.groups ?? {};
+		return new RegExp(regexp$1, modifiers);
+	},
+	predicate: (object) => object instanceof RegExp,
+	represent: (object) => object.toString()
+};
+
+//#endregion
+export { regexp };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/seq.js

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/seq.js
+const seq = {
+	tag: "tag:yaml.org,2002:seq",
+	kind: "sequence",
+	resolve: () => true,
+	construct: (data) => data !== null ? data : []
+};
+
+//#endregion
+export { seq };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/set.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/set.js
+const set = {
+	tag: "tag:yaml.org,2002:set",
+	kind: "mapping",
+	construct: (data) => data !== null ? data : {},
+	resolve: (data) => {
+		if (data === null) return true;
+		return Object.values(data).every((it) => it === null);
+	}
+};
+
+//#endregion
+export { set };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/str.js

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/str.js
+const str = {
+	tag: "tag:yaml.org,2002:str",
+	kind: "scalar",
+	resolve: () => true,
+	construct: (data) => data !== null ? data : ""
+};
+
+//#endregion
+export { str };

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/timestamp.js

@@ -0,0 +1,57 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_type/timestamp.js
+const YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+const YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
+	if (data === null) return false;
+	if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+	if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+	return false;
+}
+function constructYamlTimestamp(data) {
+	let match = YAML_DATE_REGEXP.exec(data);
+	if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+	if (match === null) throw new Error("Cannot construct YAML timestamp: date resolve error");
+	const year = +match[1];
+	const month = +match[2] - 1;
+	const day = +match[3];
+	if (!match[4]) return new Date(Date.UTC(year, month, day));
+	const hour = +match[4];
+	const minute = +match[5];
+	const second = +match[6];
+	let fraction = 0;
+	if (match[7]) {
+		let partFraction = match[7].slice(0, 3);
+		while (partFraction.length < 3) partFraction += "0";
+		fraction = +partFraction;
+	}
+	let delta = null;
+	if (match[9] && match[10]) {
+		const tzHour = +match[10];
+		const tzMinute = +(match[11] || 0);
+		delta = (tzHour * 60 + tzMinute) * 6e4;
+		if (match[9] === "-") delta = -delta;
+	}
+	const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+	if (delta) date.setTime(date.getTime() - delta);
+	return date;
+}
+function representYamlTimestamp(date) {
+	return date.toISOString();
+}
+const timestamp = {
+	tag: "tag:yaml.org,2002:timestamp",
+	construct: constructYamlTimestamp,
+	predicate(object) {
+		return object instanceof Date;
+	},
+	kind: "scalar",
+	represent: representYamlTimestamp,
+	resolve: resolveYamlTimestamp
+};
+
+//#endregion
+export { timestamp };