@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/S3MediaObjects-y-WacEi9.js

@@ -0,0 +1,193 @@
+import { ByteSize, Context, Deferred, Effect, FileSystem, Layer, Pull, Schema, Stream } from "effect";
+import { Readable } from "node:stream";
+import * as NodeStream from "@effect/platform-node/NodeStream";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { DeleteObjectCommand, GetObjectCommand, HeadBucketCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+//#region ../server/src/MediaObjects.ts
+var MediaStorageError = class extends Schema.TaggedError()("Media.StorageError", {
+	operation: Schema.NonEmptyString,
+	cause: Schema.Defect()
+}) {};
+/** The private-object-store seam used by the Media library and its recovery worker. */
+const MediaObjects = Context.Service("@internal/server/MediaObjects");
+//#endregion
+//#region ../s3/src/internal/keys.ts
+function safePath(path, allowEmpty) {
+	if (!path) return allowEmpty;
+	return path === path.trim() && !path.startsWith("/") && !path.endsWith("/") && !Array.from(path).some((character) => {
+		const code = character.codePointAt(0);
+		return character === "\\" || code !== void 0 && (code <= 31 || code === 127);
+	}) && path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function physicalKey(prefix, key) {
+	if (!safePath(prefix, true) || !safePath(key, false)) throw new Error("Unsafe media object key.");
+	return prefix ? `${prefix}/${key}` : key;
+}
+/** Listing a folder includes its separator; listing a key prefix does not. */
+function physicalPrefix(prefix, key) {
+	if (!key) return prefix ? `${physicalKey("", prefix)}/` : "";
+	return key.endsWith("/") ? `${physicalKey(prefix, key.slice(0, -1))}/` : physicalKey(prefix, key);
+}
+/** Ignore provider records outside this installation's namespace. */
+function relativeKey(prefix, key) {
+	const namespace = prefix ? `${prefix}/` : "";
+	return key && key.startsWith(namespace) ? key.slice(namespace.length) : void 0;
+}
+function validateOptions(options) {
+	if (!options.bucket.trim() || !options.region.trim() || !safePath(options.prefix ?? "", true) || options.endpoint !== void 0 && !options.endpoint.trim() || options.credentials && (!options.credentials.accessKeyId.trim() || !options.credentials.secretAccessKey)) return Effect.fail(new MediaStorageError({
+		operation: "configure",
+		cause: /* @__PURE__ */ new Error("Invalid S3 media configuration.")
+	}));
+	return Effect.succeed(options);
+}
+//#endregion
+//#region ../s3/src/internal/upload.ts
+const openUpload = Effect.fn("S3MediaObjects.openUpload")(function* (fs, filePath) {
+	const pull = yield* Stream.toPull(fs.stream(filePath));
+	const first = yield* Pull.catchDone(pull, () => Effect.succeed([])).pipe(Effect.mapError((cause) => new MediaStorageError({
+		operation: "put.open",
+		cause
+	})));
+	const error = yield* Deferred.make();
+	const closed = yield* Deferred.make();
+	const onError = (cause) => Deferred.doneUnsafe(error, Effect.fail(new MediaStorageError({
+		operation: "put.read",
+		cause
+	})));
+	return {
+		body: yield* Effect.acquireRelease(NodeStream.toReadable(Stream.concat(Stream.fromArray(first), Stream.fromPull(Effect.succeed(pull)))).pipe(Effect.tap((body) => Effect.sync(() => {
+			body.on("error", onError);
+			body.once("close", () => Deferred.doneUnsafe(closed, Effect.void));
+		}))), (body) => Effect.sync(() => body.destroy()).pipe(Effect.andThen(Deferred.await(closed)), Effect.ensuring(Effect.sync(() => body.removeListener("error", onError))))),
+		error
+	};
+});
+//#endregion
+//#region ../s3/src/internal/client.ts
+const failure = (operation, cause) => new MediaStorageError({
+	operation,
+	cause
+});
+function isMissing(cause) {
+	if (!(cause instanceof Error)) return false;
+	return cause.name === "NoSuchKey" || cause.name === "NotFound";
+}
+function make(client, options, fs) {
+	const bucket = options.bucket;
+	const prefix = options.prefix ?? "";
+	const key = (value) => physicalKey(prefix, value);
+	const request = Effect.fn("S3MediaObjects.request")(function* (operation, send) {
+		return yield* Effect.tryPromise({
+			try: send,
+			catch: (cause) => failure(operation, cause)
+		});
+	});
+	const missingAsNull = (effect) => effect.pipe(Effect.catchIf((error) => isMissing(error.cause), () => Effect.succeed(null)));
+	const statObject = Effect.fn("S3MediaObjects.stat")(function* (objectKey) {
+		const output = yield* request("stat", (signal) => client.send(new HeadObjectCommand({
+			Bucket: bucket,
+			Key: key(objectKey)
+		}), { abortSignal: signal })).pipe(missingAsNull);
+		if (!output) return null;
+		if (output.ContentLength === void 0 || !output.ContentType) return yield* failure("stat", /* @__PURE__ */ new Error("S3 object metadata is incomplete."));
+		return {
+			key: objectKey,
+			byteSize: output.ContentLength,
+			mimeType: output.ContentType
+		};
+	});
+	return MediaObjects.of({
+		check: request("bucket.check", (signal) => client.send(new HeadBucketCommand({ Bucket: bucket }), { abortSignal: signal })).pipe(Effect.timeoutOrElse({
+			duration: "3 seconds",
+			orElse: () => Effect.fail(failure("bucket.check.timeout", /* @__PURE__ */ new Error("S3 bucket check timed out.")))
+		}), Effect.asVoid),
+		put: Effect.fn("S3MediaObjects.put")(function* (input) {
+			const file = yield* fs.stat(input.filePath).pipe(Effect.mapError((cause) => failure("put.stat", cause)));
+			if (ByteSize.toBigInt(file.size) !== BigInt(input.byteSize)) return yield* failure("put.size", /* @__PURE__ */ new Error("The upload size changed before storage."));
+			const error = yield* Effect.gen(function* () {
+				const upload = yield* openUpload(fs, input.filePath);
+				yield* Effect.gen(function* () {
+					yield* request("put", (signal) => client.send(new PutObjectCommand({
+						Bucket: bucket,
+						Key: key(input.key),
+						Body: upload.body,
+						ContentLength: input.byteSize,
+						ContentType: input.mimeType
+					}), { abortSignal: signal }));
+					const stored = yield* statObject(input.key);
+					if (!stored || stored.byteSize !== input.byteSize || stored.mimeType !== input.mimeType) return yield* failure("put.verify", /* @__PURE__ */ new Error("Stored object metadata does not match the upload."));
+				}).pipe(Effect.raceFirst(Deferred.await(upload.error)));
+				return upload.error;
+			}).pipe(Effect.scoped);
+			yield* Effect.transposeOption(yield* Deferred.poll(error));
+		}),
+		read: Effect.fn("S3MediaObjects.read")(function* (objectKey, range) {
+			const output = yield* request("read", (signal) => client.send(new GetObjectCommand({
+				Bucket: bucket,
+				Key: key(objectKey),
+				Range: range ? `bytes=${range.start}-${range.end}` : void 0
+			}), { abortSignal: signal })).pipe(missingAsNull);
+			if (!output) return null;
+			if (!output.Body) return yield* failure("read", /* @__PURE__ */ new Error("S3 returned an empty response body."));
+			const body = output.Body;
+			const stream = yield* Effect.try({
+				try: () => body.transformToWebStream(),
+				catch: (cause) => failure("read", cause)
+			}).pipe(Effect.onError(() => Effect.sync(() => {
+				if (body instanceof Readable) body.destroy();
+			})));
+			if (range && (output.ContentLength !== range.end - range.start + 1 || !output.ContentRange?.startsWith(`bytes ${range.start}-${range.end}/`))) {
+				yield* Effect.tryPromise({
+					try: () => stream.cancel(),
+					catch: (cause) => failure("read.cleanup", cause)
+				}).pipe(Effect.ignore);
+				return yield* failure("read.range", /* @__PURE__ */ new Error("S3 returned a different byte range."));
+			}
+			return stream;
+		}),
+		stat: statObject,
+		remove: Effect.fn("S3MediaObjects.remove")(function* (objectKey) {
+			yield* request("remove", (signal) => client.send(new DeleteObjectCommand({
+				Bucket: bucket,
+				Key: key(objectKey)
+			}), { abortSignal: signal }));
+		}),
+		list: Effect.fn("S3MediaObjects.list")(function* (objectPrefix, cursor) {
+			const listPrefix = yield* Effect.try({
+				try: () => physicalPrefix(prefix, objectPrefix),
+				catch: (cause) => failure("list.key", cause)
+			});
+			const output = yield* request("list", (signal) => client.send(new ListObjectsV2Command({
+				Bucket: bucket,
+				Prefix: listPrefix,
+				ContinuationToken: cursor
+			}), { abortSignal: signal }));
+			return {
+				objects: (output.Contents ?? []).flatMap((entry) => {
+					const objectKey = entry.Key === void 0 ? void 0 : relativeKey(prefix, entry.Key);
+					return objectKey === void 0 || entry.Size === void 0 ? [] : [{
+						key: objectKey,
+						byteSize: entry.Size
+					}];
+				}),
+				nextCursor: output.NextContinuationToken
+			};
+		})
+	});
+}
+//#endregion
+//#region ../s3/src/S3MediaObjects.ts
+const layerNoDeps = (options) => Layer.effect(MediaObjects, Effect.gen(function* () {
+	const valid = yield* validateOptions(options);
+	const fs = yield* FileSystem.FileSystem;
+	return make(yield* Effect.acquireRelease(Effect.sync(() => new S3Client({
+		region: valid.region,
+		endpoint: valid.endpoint,
+		forcePathStyle: valid.forcePathStyle,
+		credentials: valid.credentials,
+		requestChecksumCalculation: "WHEN_REQUIRED"
+	})), (opened) => Effect.sync(() => opened.destroy())), valid, fs);
+}));
+const layer = (options) => layerNoDeps(options).pipe(Layer.provide(NodeFileSystem.layer));
+//#endregion
+export { MediaObjects as n, MediaStorageError as r, layer as t };

package/src/Seo-BcpqxoAs.d.ts

@@ -0,0 +1,57 @@
+import "./Media-BQ0uL4w7.js";
+import { Schema } from "effect";
+//#region ../model/src/Seo.d.ts
+declare const SiteSeoSettings: Schema.Struct<{
+  readonly siteName: Schema.String;
+  readonly canonicalOrigin: Schema.String;
+  readonly defaultDescription: Schema.optionalKey<Schema.String>;
+  readonly titleTemplate: Schema.optionalKey<Schema.String>;
+  readonly socialTitle: Schema.optionalKey<Schema.String>;
+  readonly socialDescription: Schema.optionalKey<Schema.String>;
+  readonly socialImage: Schema.optionalKey<Schema.Struct<{
+    readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+    readonly alt: Schema.String;
+  }>>;
+  readonly index: Schema.Boolean;
+  readonly follow: Schema.Boolean;
+  readonly identity: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly image: Schema.optionalKey<Schema.Struct<{
+      readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+      readonly alt: Schema.String;
+    }>>;
+    readonly name: Schema.String;
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.Literal<"Person">;
+  }>, Schema.Struct<{
+    readonly logo: Schema.optionalKey<Schema.Struct<{
+      readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+      readonly alt: Schema.String;
+    }>>;
+    readonly name: Schema.String;
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.Literal<"Organization">;
+  }>, Schema.Struct<{
+    readonly logo: Schema.optionalKey<Schema.Struct<{
+      readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+      readonly alt: Schema.String;
+    }>>;
+    readonly image: Schema.optionalKey<Schema.Struct<{
+      readonly mediaId: Schema.brand<Schema.String, "MediaId">;
+      readonly alt: Schema.String;
+    }>>;
+    readonly telephone: Schema.optionalKey<Schema.String>;
+    readonly address: Schema.optionalKey<Schema.Struct<{
+      readonly streetAddress: Schema.optionalKey<Schema.String>;
+      readonly addressLocality: Schema.optionalKey<Schema.String>;
+      readonly addressRegion: Schema.optionalKey<Schema.String>;
+      readonly postalCode: Schema.optionalKey<Schema.String>;
+      readonly addressCountry: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly name: Schema.String;
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly type: Schema.Literal<"LocalBusiness">;
+  }>]>>;
+}>;
+interface SiteSeoSettings extends Schema.Schema.Type<typeof SiteSeoSettings> {}
+//#endregion
+export { SiteSeoSettings as t };

package/src/Seo-CjNUtUkj.js

@@ -0,0 +1,254 @@
+import { i as MediaId } from "./Media-DSyvd14o.js";
+import { Predicate, Schema } from "effect";
+//#region ../model/src/internal/canonicalContent.ts
+/** Stable JSON bytes that preserve array order and ignore object property order. */
+function canonicalContent(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalContent).join(",")}]`;
+	if (isObject(value)) return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonicalContent(item)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+/** The caller already supplies JSON, so only its representation needs narrowing. */
+function isObject(value) {
+	return Predicate.isObject(value);
+}
+//#endregion
+//#region ../model/src/ValidationIssue.ts
+const IssuePath = Schema.Array(Schema.Union([Schema.String, Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))]));
+const IssueLocation = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("field"),
+		path: IssuePath
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("block"),
+		blockId: Schema.optionalKey(Schema.String),
+		path: IssuePath
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("seo"),
+		path: IssuePath
+	}),
+	Schema.Struct({ kind: Schema.Literal("placement") }),
+	Schema.Struct({
+		kind: Schema.Literal("body"),
+		path: Schema.optionalKey(IssuePath)
+	}),
+	Schema.Struct({ kind: Schema.Literal("document") })
+]);
+const ValidationIssue = Schema.Struct({
+	code: Schema.String,
+	location: IssueLocation,
+	message: Schema.String,
+	details: Schema.optionalKey(Schema.JsonObject),
+	locale: Schema.optionalKey(Schema.String)
+});
+function issue(code, location, message, details) {
+	return details === void 0 ? {
+		code,
+		location,
+		message
+	} : {
+		code,
+		location,
+		message,
+		details
+	};
+}
+/** Presentation text is never an identity or compatibility key. */
+function issueKey(value) {
+	const details = value.details === void 0 ? null : Object.fromEntries(Object.entries(value.details).filter(([key]) => key !== "label"));
+	return canonicalContent([
+		value.code,
+		value.location,
+		details,
+		value.locale ?? null
+	]);
+}
+//#endregion
+//#region ../model/src/internal/calendarDate.ts
+/** Accept only real calendar dates in the shared authored YYYY-MM-DD representation. */
+function isCalendarDate(value) {
+	if (!/^\d{4}-\d{2}-\d{2}$/u.test(value)) return false;
+	const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+//#endregion
+//#region ../model/src/Seo.ts
+/** Installation and initial SEO addresses share one normalized HTTP origin contract. */
+const SiteOrigin = Schema.String.check(Schema.makeFilter(isCanonicalOrigin, { message: "Use an HTTP or HTTPS origin without credentials, a path, query, or fragment." }));
+const SeoImage = Schema.Struct({
+	mediaId: MediaId,
+	alt: Schema.String
+});
+const DocumentStructuredData = Schema.Union([Schema.Struct({ type: Schema.Literal("WebPage") }), Schema.Struct({
+	type: Schema.Literal("Article"),
+	headline: Schema.optionalKey(Schema.String),
+	datePublished: Schema.optionalKey(Schema.String),
+	dateModified: Schema.optionalKey(Schema.String)
+})]);
+/** Page overrides are optional; omitted values inherit the published site settings. */
+const DocumentSeo = Schema.Struct({
+	title: Schema.optionalKey(Schema.String),
+	description: Schema.optionalKey(Schema.String),
+	socialTitle: Schema.optionalKey(Schema.String),
+	socialDescription: Schema.optionalKey(Schema.String),
+	socialImage: Schema.optionalKey(SeoImage),
+	index: Schema.optionalKey(Schema.Boolean),
+	follow: Schema.optionalKey(Schema.Boolean),
+	canonicalUrl: Schema.optionalKey(Schema.String),
+	structuredData: Schema.optionalKey(DocumentStructuredData)
+});
+const identityFields = {
+	name: Schema.String,
+	url: Schema.optionalKey(Schema.String)
+};
+const SiteIdentity = Schema.Union([
+	Schema.Struct({
+		type: Schema.Literal("Person"),
+		...identityFields,
+		image: Schema.optionalKey(SeoImage)
+	}),
+	Schema.Struct({
+		type: Schema.Literal("Organization"),
+		...identityFields,
+		logo: Schema.optionalKey(SeoImage)
+	}),
+	Schema.Struct({
+		type: Schema.Literal("LocalBusiness"),
+		...identityFields,
+		logo: Schema.optionalKey(SeoImage),
+		image: Schema.optionalKey(SeoImage),
+		telephone: Schema.optionalKey(Schema.String),
+		address: Schema.optionalKey(Schema.Struct({
+			streetAddress: Schema.optionalKey(Schema.String),
+			addressLocality: Schema.optionalKey(Schema.String),
+			addressRegion: Schema.optionalKey(Schema.String),
+			postalCode: Schema.optionalKey(Schema.String),
+			addressCountry: Schema.optionalKey(Schema.String)
+		}))
+	})
+]);
+const SiteSeoSettings = Schema.Struct({
+	siteName: Schema.String,
+	canonicalOrigin: Schema.String,
+	defaultDescription: Schema.optionalKey(Schema.String),
+	titleTemplate: Schema.optionalKey(Schema.String),
+	socialTitle: Schema.optionalKey(Schema.String),
+	socialDescription: Schema.optionalKey(Schema.String),
+	socialImage: Schema.optionalKey(SeoImage),
+	index: Schema.Boolean,
+	follow: Schema.Boolean,
+	identity: Schema.optionalKey(SiteIdentity)
+});
+const SiteSeoRevision = Schema.Struct({
+	version: Schema.String.check(Schema.isUUID()),
+	settings: SiteSeoSettings,
+	editedBy: Schema.String,
+	editedAt: Schema.String
+});
+const SiteSeoState = Schema.Struct({
+	working: SiteSeoRevision,
+	published: SiteSeoRevision
+});
+function resolveDocumentSeo(input) {
+	const { fields, path, page, site } = input;
+	const pageTitle = Schema.is(Schema.String)(fields.title) ? fields.title : site.siteName;
+	const title = site.titleTemplate?.replaceAll("%s", page?.title ?? pageTitle) ?? page?.title ?? pageTitle;
+	const fieldDescription = Schema.is(Schema.String)(fields.summary) ? fields.summary : void 0;
+	const description = page?.description ?? fieldDescription ?? site.defaultDescription;
+	return {
+		title,
+		...description ? { description } : void 0,
+		socialTitle: page?.socialTitle ?? site.socialTitle ?? title,
+		...page?.socialDescription ?? site.socialDescription ?? description ? { socialDescription: page?.socialDescription ?? site.socialDescription ?? description } : void 0,
+		...page?.socialImage ?? site.socialImage ? { socialImage: page?.socialImage ?? site.socialImage } : void 0,
+		canonicalUrl: page?.canonicalUrl ?? new URL(path, `${site.canonicalOrigin}/`).href,
+		index: site.index && (page?.index ?? true),
+		follow: site.follow && (page?.follow ?? true),
+		structuredData: page?.structuredData ?? { type: "WebPage" },
+		...site.identity ? { identity: site.identity } : void 0
+	};
+}
+function inspectDocumentSeo(seo) {
+	if (!seo) return [];
+	const issues = [];
+	const problem = (code, path, message) => issue(code, {
+		kind: "seo",
+		path
+	}, message);
+	for (const key of [
+		"title",
+		"description",
+		"socialTitle",
+		"socialDescription"
+	]) if (seo[key] !== void 0 && !seo[key]?.trim()) issues.push(problem("seo.empty", [key], `${key} cannot be empty.`));
+	if (seo.canonicalUrl !== void 0 && !isHttpUrl(seo.canonicalUrl)) issues.push(problem("seo.url", ["canonicalUrl"], "Preferred page address needs a complete HTTP or HTTPS URL."));
+	if (seo.socialImage && !seo.socialImage.alt.trim()) issues.push(problem("seo.required", ["socialImage", "alt"], "Shared image needs a description."));
+	if (seo.structuredData?.type === "Article") {
+		if (seo.structuredData.headline !== void 0 && !seo.structuredData.headline.trim()) issues.push(problem("seo.empty", ["structuredData", "headline"], "Article headline cannot be empty."));
+		for (const key of ["datePublished", "dateModified"]) {
+			const value = seo.structuredData[key];
+			if (value !== void 0 && !isCalendarDate(value)) issues.push(problem("seo.date", ["structuredData", key], `${key} needs a valid calendar date.`));
+		}
+	}
+	return issues;
+}
+function inspectSiteSeo(settings) {
+	const issues = [];
+	const problem = (code, path, message) => issue(code, {
+		kind: "seo",
+		path
+	}, message);
+	if (!settings.siteName.trim()) issues.push(problem("seo.siteName", ["siteName"], "Website name is required."));
+	if (!isCanonicalOrigin(settings.canonicalOrigin)) issues.push(problem("seo.canonicalOrigin", ["canonicalOrigin"], "Website address needs an HTTP or HTTPS origin."));
+	if (settings.titleTemplate !== void 0 && !settings.titleTemplate.includes("%s")) issues.push(problem("seo.titleTemplate", ["titleTemplate"], "Title template needs %s."));
+	for (const key of [
+		"defaultDescription",
+		"socialTitle",
+		"socialDescription"
+	]) if (settings[key] !== void 0 && !settings[key]?.trim()) issues.push(problem("seo.empty", [key], `${key} cannot be empty.`));
+	if (settings.socialImage && !settings.socialImage.alt.trim()) issues.push(problem("seo.required", ["socialImage", "alt"], "Default shared image needs a description."));
+	if (settings.identity) {
+		if (!settings.identity.name.trim()) issues.push(problem("seo.required", ["identity", "name"], "Website identity needs a name."));
+		if (settings.identity.url !== void 0 && !isHttpUrl(settings.identity.url)) issues.push(problem("seo.url", ["identity", "url"], "Website identity needs a complete HTTP or HTTPS URL."));
+		if ("image" in settings.identity && settings.identity.image && !settings.identity.image.alt.trim()) issues.push(problem("seo.required", [
+			"identity",
+			"image",
+			"alt"
+		], "Website identity image needs a description."));
+		if ("logo" in settings.identity && settings.identity.logo && !settings.identity.logo.alt.trim()) issues.push(problem("seo.required", [
+			"identity",
+			"logo",
+			"alt"
+		], "Website identity logo needs a description."));
+	}
+	return issues;
+}
+function siteSeoIssues(settings) {
+	return inspectSiteSeo(settings).map((issue) => issue.message);
+}
+function documentSeoMediaIds(seo) {
+	return seo?.socialImage ? [seo.socialImage.mediaId] : [];
+}
+function siteSeoMediaIds(settings) {
+	return [
+		settings.socialImage,
+		settings.identity && "image" in settings.identity ? settings.identity.image : void 0,
+		settings.identity && "logo" in settings.identity ? settings.identity.logo : void 0
+	].flatMap((image) => image ? [image.mediaId] : []);
+}
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && !!url.hostname && !url.username && !url.password && value === value.trim();
+	} catch {
+		return false;
+	}
+}
+function isCanonicalOrigin(value) {
+	if (!isHttpUrl(value)) return false;
+	const url = new URL(value);
+	return url.origin === value && url.pathname === "/" && !url.search && !url.hash;
+}
+//#endregion
+export { canonicalContent as _, SiteSeoState as a, inspectSiteSeo as c, siteSeoMediaIds as d, isCalendarDate as f, issueKey as g, issue as h, SiteSeoSettings as i, resolveDocumentSeo as l, ValidationIssue as m, SiteOrigin as n, documentSeoMediaIds as o, IssuePath as p, SiteSeoRevision as r, inspectDocumentSeo as s, DocumentSeo as t, siteSeoIssues as u };