import "@js-temporal/polyfill";
import "urlpattern-polyfill";
globalThis.addEventListener = () => {};
import { t as test } from "../testing-BQeTO4ss.mjs";
import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
import "../std__assert-2v7gYiZp.mjs";
import { a as parseProtocol, c as parseUsage, i as parseOutboundService, n as parseInboundService, o as parseServices, r as parseNodeInfo, s as parseSoftware, t as getNodeInfo } from "../client-DACpcUfJ.mjs";
import { t as esm_default } from "../esm-D-9VAGKG.mjs";
//#region src/nodeinfo/client.test.ts
test("getNodeInfo()", async (t) => {
	esm_default.spyGlobal();
	esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [{
		rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
		href: "https://example.com/nodeinfo/2.1"
	}] } });
	const rawExpected = {
		software: {
			name: "foo",
			version: "1.2.3"
		},
		protocols: ["activitypub", "diaspora"],
		usage: {
			users: {},
			localPosts: 123,
			localComments: 456
		}
	};
	esm_default.get("https://example.com/nodeinfo/2.1", { body: rawExpected });
	esm_default.get("https://example.com/404", { status: 404 });
	const expected = {
		software: {
			name: "foo",
			version: {
				major: 1,
				minor: 2,
				patch: 3,
				build: [],
				prerelease: []
			}
		},
		protocols: ["activitypub", "diaspora"],
		usage: {
			users: {},
			localPosts: 123,
			localComments: 456
		}
	};
	await t.step("indirect", async () => {
		assertEquals(await getNodeInfo("https://example.com/"), expected);
		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), rawExpected);
	});
	await t.step("direct", async () => {
		assertEquals(await getNodeInfo("https://example.com/nodeinfo/2.1", { direct: true }), expected);
	});
	esm_default.removeRoutes();
	esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [] } });
	await t.step("indirect: no links", async () => {
		assertEquals(await getNodeInfo("https://example.com/"), void 0);
	});
	esm_default.removeRoutes();
	esm_default.get("https://example.com/.well-known/nodeinfo", { status: 404 });
	await t.step("indirect: 404", async () => {
		assertEquals(await getNodeInfo("https://example.com/"), void 0);
	});
	await t.step("direct: 404", async () => {
		assertEquals(await getNodeInfo("https://example.com/nodeinfo/2.0", { direct: true }), void 0);
		assertEquals(await getNodeInfo("https://example.com/404", { direct: true }), void 0);
	});
	esm_default.hardReset();
});
test("getNodeInfo() blocks SSRF", async (t) => {
	esm_default.spyGlobal();
	await t.step("link href pointing to a loopback address", async () => {
		esm_default.removeRoutes();
		esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [{
			rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
			href: "http://127.0.0.1:8080/internal"
		}] } });
		let internalFetched = false;
		esm_default.get("http://127.0.0.1:8080/internal", () => {
			internalFetched = true;
			return { body: { secret: "INTERNAL_DATA_LEAKED" } };
		});
		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
		assertEquals(internalFetched, false);
	});
	await t.step("link href using a data: URL", async () => {
		esm_default.removeRoutes();
		esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [{
			rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
			href: "data:application/json,{\"software\":{\"name\":\"x\"}}"
		}] } });
		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
	});
	await t.step("redirect to a private address", async () => {
		esm_default.removeRoutes();
		esm_default.get("https://example.com/.well-known/nodeinfo", { body: { links: [{
			rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
			href: "https://example.com/nodeinfo/2.1"
		}] } });
		esm_default.get("https://example.com/nodeinfo/2.1", {
			status: 302,
			headers: { Location: "https://127.0.0.1:8080/internal" }
		});
		let internalFetched = false;
		esm_default.get("https://127.0.0.1:8080/internal", () => {
			internalFetched = true;
			return { body: { secret: "INTERNAL_DATA_LEAKED" } };
		});
		assertEquals(await getNodeInfo("https://example.com/", { parse: "none" }), void 0);
		assertEquals(internalFetched, false);
	});
	await t.step("direct fetch of a private address", async () => {
		esm_default.removeRoutes();
		let internalFetched = false;
		esm_default.get("http://127.0.0.1:8080/nodeinfo", () => {
			internalFetched = true;
			return { body: { software: {
				name: "x",
				version: "1.0.0"
			} } };
		});
		assertEquals(await getNodeInfo("http://127.0.0.1:8080/nodeinfo", {
			direct: true,
			parse: "none"
		}), void 0);
		assertEquals(internalFetched, false);
	});
	esm_default.hardReset();
});
test("parseNodeInfo()", () => {
	const input = {
		software: {
			name: "foo",
			version: "1.2.3",
			repository: "https://codeberg.org/foo/foo",
			homepage: "https://foo.example"
		},
		protocols: ["activitypub", "diaspora"],
		services: {
			inbound: [
				"atom1.0",
				"pop3",
				"twitter"
			],
			outbound: [
				"atom1.0",
				"diaspora",
				"facebook"
			]
		},
		openRegistrations: true,
		usage: {
			users: {
				activeHalfyear: 10,
				activeMonth: 20,
				total: 30
			},
			localPosts: 123,
			localComments: 456
		},
		metadata: {
			foo: 123,
			bar: "456"
		}
	};
	const output = {
		software: {
			name: "foo",
			version: {
				major: 1,
				minor: 2,
				patch: 3,
				build: [],
				prerelease: []
			},
			repository: new URL("https://codeberg.org/foo/foo"),
			homepage: new URL("https://foo.example")
		},
		protocols: ["activitypub", "diaspora"],
		services: {
			inbound: [
				"atom1.0",
				"pop3",
				"twitter"
			],
			outbound: [
				"atom1.0",
				"diaspora",
				"facebook"
			]
		},
		openRegistrations: true,
		usage: {
			users: {
				activeHalfyear: 10,
				activeMonth: 20,
				total: 30
			},
			localPosts: 123,
			localComments: 456
		},
		metadata: {
			foo: 123,
			bar: "456"
		}
	};
	assertEquals(parseNodeInfo(123), null);
	assertEquals(parseNodeInfo(123, { tryBestEffort: true }), null);
	assertEquals(parseNodeInfo(input), output);
	assertEquals(parseNodeInfo({
		...input,
		software: {
			name: " FOO ",
			version: "1.2.3"
		}
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		software: {
			name: " FOO ",
			version: "1.2.3"
		}
	}, { tryBestEffort: true }), {
		...output,
		software: {
			name: output.software.name,
			version: output.software.version
		}
	});
	assertEquals(parseNodeInfo({
		...input,
		protocols: 123
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		protocols: 123
	}, { tryBestEffort: true }), {
		...output,
		protocols: []
	});
	assertEquals(parseNodeInfo({
		...input,
		protocols: ["activitypub", "foo"]
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		protocols: ["activitypub", "foo"]
	}, { tryBestEffort: true }), {
		...output,
		protocols: ["activitypub"]
	});
	assertEquals(parseNodeInfo({
		...input,
		services: 123
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		services: 123
	}, { tryBestEffort: true }), {
		software: output.software,
		protocols: output.protocols,
		openRegistrations: output.openRegistrations,
		usage: output.usage,
		metadata: output.metadata
	});
	assertEquals(parseNodeInfo({
		...input,
		services: { inbound: ["atom1.0", "foo"] }
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		services: { inbound: ["atom1.0", "foo"] }
	}, { tryBestEffort: true }), {
		software: output.software,
		protocols: output.protocols,
		services: { inbound: ["atom1.0"] },
		openRegistrations: output.openRegistrations,
		usage: output.usage,
		metadata: output.metadata
	});
	assertEquals(parseNodeInfo({
		...input,
		openRegistrations: 123
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		openRegistrations: 123
	}, { tryBestEffort: true }), {
		software: output.software,
		protocols: output.protocols,
		services: output.services,
		usage: output.usage,
		metadata: output.metadata
	});
	assertEquals(parseNodeInfo({
		...input,
		usage: 123
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		usage: 123
	}, { tryBestEffort: true }), {
		software: output.software,
		protocols: output.protocols,
		services: output.services,
		openRegistrations: output.openRegistrations,
		usage: {
			users: {},
			localPosts: 0,
			localComments: 0
		},
		metadata: output.metadata
	});
	assertEquals(parseNodeInfo({
		...input,
		metadata: 123
	}), null);
	assertEquals(parseNodeInfo({
		...input,
		metadata: 123
	}, { tryBestEffort: true }), {
		software: output.software,
		protocols: output.protocols,
		services: output.services,
		openRegistrations: output.openRegistrations,
		usage: output.usage
	});
});
test("parseSoftware()", () => {
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		repository: "https://codeberg.org/foo/foo",
		homepage: "https://foo.example"
	}), {
		name: "foo",
		version: {
			major: 1,
			minor: 2,
			patch: 3,
			build: [],
			prerelease: []
		},
		repository: new URL("https://codeberg.org/foo/foo"),
		homepage: new URL("https://foo.example")
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "4.5.6-beta.7+build.8"
	}), {
		name: "foo",
		version: {
			major: 4,
			minor: 5,
			patch: 6,
			build: ["build", "8"],
			prerelease: ["beta", 7]
		}
	});
	assertEquals(parseSoftware(123), null);
	assertEquals(parseSoftware(123, { tryBestEffort: true }), null);
	assertEquals(parseSoftware({ name: 123 }), null);
	assertEquals(parseSoftware({ name: 123 }, { tryBestEffort: true }), null);
	assertEquals(parseSoftware({ name: "" }), null);
	assertEquals(parseSoftware({ name: "" }, { tryBestEffort: true }), null);
	assertEquals(parseSoftware({ name: " FOO " }), null);
	assertEquals(parseSoftware({ name: " FOO " }, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 0,
			minor: 0,
			patch: 0,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: 123
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: 123
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 0,
			minor: 0,
			patch: 0,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "abc"
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: "abc"
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 0,
			minor: 0,
			patch: 0,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: " 1.2.3 "
	}), {
		name: "foo",
		version: {
			major: 1,
			minor: 2,
			patch: 3,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: " 1.2.3 "
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 1,
			minor: 2,
			patch: 3,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		repository: 123
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		homepage: 456
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		repository: 123,
		homepage: 456
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 1,
			minor: 2,
			patch: 3,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		repository: ""
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		homepage: ""
	}), null);
	assertEquals(parseSoftware({
		name: "foo",
		version: "1.2.3",
		repository: "",
		homepage: ""
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 1,
			minor: 2,
			patch: 3,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "2.81",
		repository: "",
		homepage: ""
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 2,
			minor: 81,
			patch: 0,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "3",
		repository: "",
		homepage: ""
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 3,
			minor: 0,
			patch: 0,
			build: [],
			prerelease: []
		}
	});
	assertEquals(parseSoftware({
		name: "foo",
		version: "2.1.3.4",
		repository: "",
		homepage: ""
	}, { tryBestEffort: true }), {
		name: "foo",
		version: {
			major: 2,
			minor: 1,
			patch: 3,
			build: [],
			prerelease: []
		}
	});
});
test("parseProtocol()", () => {
	for (const protocol of [
		"activitypub",
		"buddycloud",
		"dfrn",
		"diaspora",
		"libertree",
		"ostatus",
		"pumpio",
		"tent",
		"xmpp",
		"zot"
	]) assertEquals(parseProtocol(protocol), protocol);
	assertEquals(parseProtocol("foo"), null);
});
test("parseServices()", () => {
	assertEquals(parseServices({
		inbound: [
			"atom1.0",
			"pop3",
			"twitter"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook"
		]
	}), {
		inbound: [
			"atom1.0",
			"pop3",
			"twitter"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook"
		]
	});
	assertEquals(parseServices({ inbound: [
		"atom1.0",
		"pop3",
		"twitter"
	] }), { inbound: [
		"atom1.0",
		"pop3",
		"twitter"
	] });
	assertEquals(parseServices({ outbound: [
		"atom1.0",
		"diaspora",
		"facebook"
	] }), { outbound: [
		"atom1.0",
		"diaspora",
		"facebook"
	] });
	assertEquals(parseServices({}), {});
	assertEquals(parseServices(123), null);
	assertEquals(parseServices(123, { tryBestEffort: true }), {});
	assertEquals(parseServices({
		inbound: [
			"atom1.0",
			"pop3",
			"twitter",
			"foo"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook"
		]
	}), null);
	assertEquals(parseServices({
		inbound: [
			"atom1.0",
			"pop3",
			"twitter"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook",
			"bar"
		]
	}), null);
	assertEquals(parseServices({
		inbound: [
			"atom1.0",
			"pop3",
			"twitter",
			"foo"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook",
			"bar"
		]
	}, { tryBestEffort: true }), {
		inbound: [
			"atom1.0",
			"pop3",
			"twitter"
		],
		outbound: [
			"atom1.0",
			"diaspora",
			"facebook"
		]
	});
});
test("parseInboundService()", () => {
	for (const service of [
		"atom1.0",
		"gnusocial",
		"imap",
		"pnut",
		"pop3",
		"pumpio",
		"rss2.0",
		"twitter"
	]) assertEquals(parseInboundService(service), service);
	assertEquals(parseInboundService("foo"), null);
});
test("parseOutboundService()", () => {
	for (const service of [
		"atom1.0",
		"blogger",
		"buddycloud",
		"diaspora",
		"dreamwidth",
		"drupal",
		"facebook",
		"friendica",
		"gnusocial",
		"google",
		"insanejournal",
		"libertree",
		"linkedin",
		"livejournal",
		"mediagoblin",
		"myspace",
		"pinterest",
		"pnut",
		"posterous",
		"pumpio",
		"redmatrix",
		"rss2.0",
		"smtp",
		"tent",
		"tumblr",
		"twitter",
		"wordpress",
		"xmpp"
	]) assertEquals(parseOutboundService(service), service);
	assertEquals(parseOutboundService("foo"), null);
});
test("parseUsage()", () => {
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: 456
	}), {
		users: {},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage(123), null);
	assertEquals(parseUsage(123, { tryBestEffort: true }), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: "123",
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: "123",
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {},
		localPosts: "",
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: "",
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 0,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {},
		localPosts: [],
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: [],
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 0,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: "456"
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: "456"
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: ""
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: ""
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 123,
		localComments: 0
	});
	assertEquals(parseUsage({
		users: null,
		localPosts: 123,
		localComments: []
	}), null);
	assertEquals(parseUsage({
		users: null,
		localPosts: 123,
		localComments: ""
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 123,
		localComments: 0
	});
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: []
	}), null);
	assertEquals(parseUsage({
		users: {},
		localPosts: 123,
		localComments: []
	}, { tryBestEffort: true }), {
		users: {},
		localPosts: 123,
		localComments: 0
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: "10",
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: "10",
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: "",
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: "",
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: [],
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: [],
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: "20",
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: "20",
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: "",
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: "",
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: [],
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: [],
			total: 30
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: "30"
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: "30"
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: 30
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: ""
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: ""
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20
		},
		localPosts: 123,
		localComments: 456
	});
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: []
		},
		localPosts: 123,
		localComments: 456
	}), null);
	assertEquals(parseUsage({
		users: {
			activeHalfyear: 10,
			activeMonth: 20,
			total: []
		},
		localPosts: 123,
		localComments: 456
	}, { tryBestEffort: true }), {
		users: {
			activeHalfyear: 10,
			activeMonth: 20
		},
		localPosts: 123,
		localComments: 456
	});
});
//#endregion
export {};
