ochre-sdk 1.0.13 → 1.0.15

package/dist/parsers/website/index.mjs

@@ -0,0 +1,1245 @@
+import { componentSchema } from "../../schemas.mjs";
+import { parseXMLContent } from "../string.mjs";
+import { cleanObject, parseLicense, parseStringContent } from "../helpers.mjs";
+import { parseBibliographyList, parseIdentification, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseSimplifiedProperties, resolveDefaultLanguage, resolveLanguages } from "../index.mjs";
+import { websitePresentationReader } from "./reader.mjs";
+import * as v from "valibot";
+//#region src/parsers/website/index.ts
+function isWebsiteLink(link, category) {
+	return link.category === category;
+}
+function findWebsiteLink(links, category, predicate) {
+	for (const link of links) if (isWebsiteLink(link, category) && (predicate == null || predicate(link))) return link;
+	return null;
+}
+function findWebsiteLinkByCategories(links, categories) {
+	for (const link of links) for (const category of categories) if (isWebsiteLink(link, category)) return link;
+	return null;
+}
+function getWebsiteLinks(links, category) {
+	const matchedLinks = [];
+	for (const link of links) if (isWebsiteLink(link, category)) matchedLinks.push(link);
+	return matchedLinks;
+}
+function transformPermanentIdentificationUrlToItemLink(url) {
+	return url.replace("https://pi.lib.uchicago.edu/1001/org/ochre/", "/item/");
+}
+function normalizeWebsiteResources(resources) {
+	const normalized = [];
+	for (const resource of resources ?? []) {
+		if ("identification" in resource) {
+			normalized.push(resource);
+			continue;
+		}
+		if ("resource" in resource) normalized.push(...resource.resource);
+	}
+	return normalized;
+}
+const SEGMENT_UNIQUE_SLUG_PREFIX_REGEX = /^\$[^-]*-/;
+function prefixSlug(slug, slugPrefix) {
+	if (slugPrefix == null || slugPrefix === "") return slug;
+	if (slug === "") return slugPrefix;
+	return `${slugPrefix}/${slug}`;
+}
+function formatXMLWebsiteResourceMetadata(resource) {
+	const metadata = [`label “${parseStringContent(resource.identification.label)}”`, `uuid “${resource.uuid}”`];
+	if (resource.slug != null) metadata.push(`slug “${resource.slug}”`);
+	if (resource.identification.abbreviation != null) metadata.push(`abbreviation “${parseStringContent(resource.identification.abbreviation)}”`);
+	return metadata.join(", ");
+}
+function formatComponentError(message, componentName, elementResource) {
+	return `${message} for component “${componentName ?? "(unknown)"}” (${formatXMLWebsiteResourceMetadata(elementResource)})`;
+}
+/**
+* Extracts CSS style properties for a given presentation variant.
+*
+* @param properties - Array of properties to parse
+* @param cssVariant - CSS variant to parse
+* @returns Array of CSS styles
+*/
+function parseCssStylesFromProperties(properties, cssVariant) {
+	const label = cssVariant != null ? `css-${cssVariant}` : "css";
+	const cssProperties = websitePresentationReader(properties).nestedByValue("presentation", label).properties;
+	const styles = [];
+	for (const property of cssProperties) {
+		const value = property.values[0]?.content.toString();
+		if (value != null) styles.push({
+			label: property.variable.label,
+			value
+		});
+	}
+	return styles;
+}
+/**
+* Parses responsive CSS styles (default, tablet, mobile) from properties.
+*
+* @param properties - Array of properties to parse
+* @returns Object containing responsive CSS styles
+*/
+function parseResponsiveCssStyles(properties) {
+	return {
+		default: parseCssStylesFromProperties(properties),
+		tablet: parseCssStylesFromProperties(properties, "tablet"),
+		mobile: parseCssStylesFromProperties(properties, "mobile")
+	};
+}
+/**
+* Parses raw bounds data into a standardized bounds structure
+*
+* @param bounds - Raw bounds data in OCHRE format
+* @returns Parsed bounds object
+*/
+function parseBounds(bounds) {
+	const [southWest, northEast] = bounds.trim().startsWith("[") ? parseJsonBounds(bounds) : bounds.split(";").map((pair) => pair.split(",").map((coordinate) => Number.parseFloat(coordinate.trim())));
+	if (southWest?.length !== 2 || northEast?.length !== 2 || southWest.some((coordinate) => Number.isNaN(coordinate)) || northEast.some((coordinate) => Number.isNaN(coordinate))) throw new Error(`Invalid bounds: ${bounds}`, { cause: bounds });
+	return [[southWest[0], southWest[1]], [northEast[0], northEast[1]]];
+}
+function parseJsonBounds(bounds) {
+	let parsed;
+	try {
+		parsed = JSON.parse(bounds);
+	} catch {
+		throw new Error(`Invalid bounds: ${bounds}`, { cause: bounds });
+	}
+	if (!isNumberPairArray(parsed)) throw new Error(`Invalid bounds: ${bounds}`, { cause: bounds });
+	return parsed;
+}
+function isNumberPairArray(value) {
+	return Array.isArray(value) && value.every((pair) => Array.isArray(pair) && pair.every((coordinate) => typeof coordinate === "number"));
+}
+/**
+* Parses all context option arrays from an options object.
+*
+* @param options - Options object containing context options
+* @param options.flattenContexts - Flatten contexts
+* @param options.suppressContexts - Suppress contexts
+* @param options.filterContexts - Filter contexts
+* @param options.sortContexts - Sort contexts
+* @param options.detailContexts - Detail contexts
+* @param options.downloadContexts - Download contexts
+* @param options.labelContexts - Label contexts
+* @param options.prominentContexts - Prominent contexts
+* @returns Parsed context options
+*/
+function parseAllOptionContexts(options, parserOptions) {
+	function handleContexts(v) {
+		return parseContexts(v ?? [], parserOptions);
+	}
+	function handleFilterContexts(v) {
+		return parseFilterContexts(v ?? [], parserOptions);
+	}
+	return {
+		flatten: handleContexts(options.flattenContexts),
+		suppress: handleContexts(options.suppressContexts),
+		filter: handleFilterContexts(options.filterContexts),
+		sort: handleContexts(options.sortContexts),
+		detail: handleContexts(options.detailContexts),
+		download: handleContexts(options.downloadContexts),
+		label: handleContexts(options.labelContexts),
+		prominent: handleContexts(options.prominentContexts)
+	};
+}
+function parseWebsiteScopes(scopes, options) {
+	if (scopes == null) return null;
+	const parsedScopes = [];
+	for (const scope of scopes.scope) parsedScopes.push({
+		uuid: scope.uuid.payload,
+		type: scope.uuid.type,
+		identification: parseIdentification(scope.identification, options)
+	});
+	return parsedScopes;
+}
+function parseWebsiteOptions(rawOptions, options) {
+	const parsedOptions = {
+		scopes: parseWebsiteScopes(rawOptions?.scopes, options),
+		contextTree: rawOptions == null ? null : parseAllOptionContexts(rawOptions, options),
+		labels: { title: null }
+	};
+	for (const note of parseNotes(rawOptions?.notes, options)) if (note.title?.getText() === "Title label") {
+		parsedOptions.labels.title = note.content;
+		break;
+	}
+	return parsedOptions;
+}
+function parseStylesheets(styles) {
+	const parsedStyles = [];
+	for (const style of styles) {
+		const defaultStyles = [];
+		for (const [label, value] of Object.entries(style)) {
+			if (label === "variableUuid" || label === "valueUuid" || label === "category" || label === "payload" || label === "content") continue;
+			const valueString = value?.toString();
+			if (valueString != null) defaultStyles.push({
+				label,
+				value: valueString
+			});
+		}
+		const stylesByViewport = {
+			default: defaultStyles,
+			tablet: [],
+			mobile: []
+		};
+		if (style.category === "propertyValue" || style.valueUuid != null) {
+			if (style.valueUuid == null) throw new Error(`Stylesheet property value "${style.variableUuid}" is missing a value UUID`, { cause: style });
+			parsedStyles.push({
+				uuid: style.valueUuid,
+				category: "propertyValue",
+				variableUuid: style.variableUuid,
+				icon: style.lucideIcon ?? null,
+				styles: stylesByViewport
+			});
+			continue;
+		}
+		parsedStyles.push({
+			uuid: style.variableUuid,
+			category: "propertyVariable",
+			icon: style.lucideIcon ?? null,
+			styles: stylesByViewport
+		});
+	}
+	return parsedStyles;
+}
+/**
+* Parses raw web element properties into a standardized WebElementComponent structure
+*
+* @param componentProperty - Raw component property data in OCHRE format
+* @param elementResource - Raw element resource data in OCHRE format
+* @returns Parsed WebElementComponent object
+*/
+function parseWebElementProperties(componentProperty, elementResource, options) {
+	const unparsedComponentName = componentProperty.values[0].content;
+	const componentNameResult = v.safeParse(componentSchema, unparsedComponentName);
+	const componentName = componentNameResult.success ? componentNameResult.output : void 0;
+	let properties = null;
+	const websiteLinks = parseLinks(elementResource.links, options);
+	const componentReader = websitePresentationReader(componentProperty.properties);
+	switch (componentName) {
+		case "3d-viewer": {
+			const resourceLink = findWebsiteLink(websiteLinks, "resource", (link) => link.fileFormat === "model/obj");
+			if (resourceLink == null) throw new Error(formatComponentError("Resource link not found", componentName, elementResource), { cause: componentProperty });
+			const isInteractive = componentReader.valueOr("is-interactive", true);
+			const isControlsDisplayed = componentReader.valueOr("controls-displayed", true);
+			properties = {
+				component: "3d-viewer",
+				linkUuid: resourceLink.uuid,
+				fileSize: resourceLink.fileSize,
+				isInteractive,
+				isControlsDisplayed
+			};
+			break;
+		}
+		case "advanced-search": {
+			const boundElementPropertyUuid = componentReader.uuid("bound-element");
+			const href = componentReader.linkTarget("link-to", transformPermanentIdentificationUrlToItemLink);
+			if (boundElementPropertyUuid == null && href == null) throw new Error(formatComponentError("Bound element or href not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "advanced-search",
+				boundElementUuid: boundElementPropertyUuid,
+				href
+			};
+			break;
+		}
+		case "annotated-document": {
+			const documentLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "internalDocument");
+			if (documentLink == null) throw new Error(formatComponentError("Document link not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "annotated-document",
+				linkUuid: documentLink.uuid
+			};
+			break;
+		}
+		case "annotated-image": {
+			const imageLinks = getWebsiteLinks(websiteLinks, "resource").filter((link) => link.type === "image" || link.type === "IIIF");
+			if (imageLinks.length === 0) throw new Error(formatComponentError("Image link not found", componentName, elementResource), { cause: componentProperty });
+			const isFilterInputDisplayed = componentReader.valueOr("filter-input-displayed", true);
+			const isOptionsDisplayed = componentReader.valueOr("options-displayed", true);
+			const isAnnotationHighlightsDisplayed = componentReader.valueOr("annotation-highlights-displayed", true);
+			const isAnnotationTooltipsDisplayed = componentReader.valueOr("annotation-tooltips-displayed", true);
+			properties = {
+				component: "annotated-image",
+				linkUuid: imageLinks[0].uuid,
+				isFilterInputDisplayed,
+				isOptionsDisplayed,
+				isAnnotationHighlightsDisplayed,
+				isAnnotationTooltipsDisplayed
+			};
+			break;
+		}
+		case "audio-player": {
+			const audioLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "audio");
+			if (audioLink == null) throw new Error(formatComponentError("Audio link not found", componentName, elementResource), { cause: componentProperty });
+			const isSpeedControlsDisplayed = componentReader.valueOr("speed-controls-displayed", true);
+			const isVolumeControlsDisplayed = componentReader.valueOr("volume-controls-displayed", true);
+			const isSeekBarDisplayed = componentReader.valueOr("seek-bar-displayed", true);
+			properties = {
+				component: "audio-player",
+				linkUuid: audioLink.uuid,
+				isSpeedControlsDisplayed,
+				isVolumeControlsDisplayed,
+				isSeekBarDisplayed
+			};
+			break;
+		}
+		case "bibliography": {
+			const itemLinks = websiteLinks.filter((link) => link.category !== "bibliography");
+			const bibliographies = parseBibliographyList(elementResource.bibliographies, options);
+			if (itemLinks.length === 0 && bibliographies.length === 0) throw new Error(formatComponentError("No links found", componentName, elementResource), { cause: componentProperty });
+			const layout = componentReader.valueOr("layout", "long");
+			const isSourceDocumentDisplayed = componentReader.valueOr("source-document-displayed", true);
+			properties = {
+				component: "bibliography",
+				linkUuids: itemLinks.map((link) => link.uuid),
+				bibliographies,
+				layout,
+				isSourceDocumentDisplayed
+			};
+			break;
+		}
+		case "button": {
+			const variant = componentReader.valueOr("variant", "default");
+			let isExternal = false;
+			let href = componentReader.linkTarget("navigate-to", transformPermanentIdentificationUrlToItemLink);
+			if (href === null) {
+				href = componentReader.linkTarget("link-to", transformPermanentIdentificationUrlToItemLink);
+				if (href === null) throw new Error(formatComponentError("Properties “navigate-to” or “link-to” not found", componentName, elementResource), { cause: componentProperty });
+				else isExternal = true;
+			}
+			const startIcon = componentReader.value("start-icon");
+			const endIcon = componentReader.value("end-icon");
+			let image = null;
+			const imageLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "image" || link.type === "IIIF");
+			if (imageLink != null) image = {
+				uuid: imageLink.uuid,
+				label: imageLink.identification.label,
+				width: imageLink.image?.width ?? 0,
+				height: imageLink.image?.height ?? 0,
+				description: imageLink.description,
+				quality: "high"
+			};
+			properties = {
+				component: "button",
+				variant,
+				href,
+				isExternal,
+				label: elementResource.document && "content" in elementResource.document ? parseXMLContent(elementResource.document, options) : null,
+				startIcon,
+				endIcon,
+				image
+			};
+			break;
+		}
+		case "collection": {
+			const setLinks = getWebsiteLinks(websiteLinks, "set");
+			if (setLinks.length === 0) throw new Error(formatComponentError("Set links not found", componentName, elementResource), { cause: componentProperty });
+			const displayedProperties = componentReader.property("use-property");
+			const variant = componentReader.valueOr("variant", "slide");
+			const paginationVariant = componentReader.valueOr("pagination-variant", "default");
+			const loadingVariant = componentReader.valueOr("loading-variant", "skeleton");
+			const expectedItemCount = componentReader.valueOr("item-count", null);
+			const isUsingQueryParams = componentReader.valueOr("is-using-query-params", false);
+			const isFilterResultsBarDisplayed = componentReader.valueOr("filter-results-bar-displayed", false);
+			const isFilterInputDisplayed = componentReader.valueOr("filter-input-displayed", false);
+			const isFilterLimitedToInputFilter = componentReader.valueOr("filter-limit-to-input-filter", false);
+			const isFilterLimitedToLeafPropertyValues = componentReader.valueOr("filter-limit-to-leaf-property-values", false);
+			const isSortDisplayed = componentReader.valueOr("sort-displayed", false);
+			const isFilterSidebarDisplayed = componentReader.valueOr("filter-sidebar-displayed", false);
+			const filterSidebarSort = componentReader.valueOr("filter-sidebar-sort", "default");
+			const imageLayout = componentReader.valueOr("image-layout", "start");
+			const componentOptions = parseWebsiteOptions(elementResource.options, options);
+			properties = {
+				component: "collection",
+				linkUuids: setLinks.map((link) => link.uuid),
+				displayedProperties: displayedProperties?.values.filter(({ uuid }) => uuid !== null).map((value) => ({
+					uuid: value.uuid,
+					label: value.label
+				})) ?? null,
+				variant,
+				paginationVariant,
+				loadingVariant,
+				imageLayout,
+				expectedItemCount,
+				isUsingQueryParams,
+				isSortDisplayed,
+				filter: {
+					isSidebarDisplayed: isFilterSidebarDisplayed,
+					isResultsBarDisplayed: isFilterResultsBarDisplayed,
+					isInputDisplayed: isFilterInputDisplayed,
+					isLimitedToInputFilter: isFilterLimitedToInputFilter,
+					isLimitedToLeafPropertyValues: isFilterLimitedToLeafPropertyValues,
+					sidebarSort: filterSidebarSort
+				},
+				options: componentOptions
+			};
+			break;
+		}
+		case "empty-space":
+			properties = {
+				component: "empty-space",
+				height: componentReader.stringValue("height"),
+				width: componentReader.stringValue("width")
+			};
+			break;
+		case "entries": {
+			const entriesLink = findWebsiteLinkByCategories(websiteLinks, ["set", "tree"]);
+			if (entriesLink == null) throw new Error(formatComponentError("Entries link not found", componentName, elementResource), { cause: componentProperty });
+			const variant = componentReader.valueOr("variant", "entry");
+			const isFilterInputDisplayed = componentReader.valueOr("filter-input-displayed", false);
+			properties = {
+				component: "entries",
+				linkUuid: entriesLink.uuid,
+				variant,
+				isFilterInputDisplayed
+			};
+			break;
+		}
+		case "iframe": {
+			const webpageLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "webpage");
+			if (webpageLink?.href == null) throw new Error(formatComponentError("URL not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "iframe",
+				href: transformPermanentIdentificationUrlToItemLink(webpageLink.href),
+				height: componentReader.stringValue("height"),
+				width: componentReader.stringValue("width")
+			};
+			break;
+		}
+		case "iiif-viewer": {
+			const manifestLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "IIIF");
+			if (manifestLink == null) throw new Error(formatComponentError("Manifest link not found", componentName, elementResource), { cause: componentProperty });
+			const variant = componentReader.valueOr("variant", "universal-viewer");
+			properties = {
+				component: "iiif-viewer",
+				linkUuid: manifestLink.uuid,
+				variant
+			};
+			break;
+		}
+		case "image": {
+			if (websiteLinks.length === 0) throw new Error(formatComponentError("No links found", componentName, elementResource), { cause: componentProperty });
+			const imageQuality = componentReader.valueOr("image-quality", "high");
+			const images = [];
+			for (const link of websiteLinks) images.push({
+				uuid: link.uuid,
+				label: link.identification.label,
+				width: "image" in link ? link.image?.width ?? 0 : 0,
+				height: "image" in link ? link.image?.height ?? 0 : 0,
+				description: link.description,
+				quality: imageQuality
+			});
+			const variant = componentReader.valueOr("variant", "default");
+			const captionLayout = componentReader.valueOr("layout-caption", "bottom");
+			let width = null;
+			const widthProperty = componentReader.value("width");
+			if (widthProperty !== null) {
+				if (typeof widthProperty === "number") width = widthProperty;
+				else if (typeof widthProperty === "string") width = Number.parseFloat(widthProperty);
+			}
+			let height = null;
+			const heightProperty = componentReader.value("height");
+			if (heightProperty !== null) {
+				if (typeof heightProperty === "number") height = heightProperty;
+				else if (typeof heightProperty === "string") height = Number.parseFloat(heightProperty);
+			}
+			const isFullWidth = componentReader.valueOr("is-full-width", true);
+			const isFullHeight = componentReader.valueOr("is-full-height", true);
+			const captionSource = componentReader.valueOr("source-caption", "name");
+			const altTextSource = componentReader.valueOr("alt-text-source", "name");
+			const isTransparentBackground = componentReader.valueOr("is-transparent", false);
+			const isCover = componentReader.valueOr("is-cover", false);
+			const variantReader = componentReader.nested("variant");
+			let carouselOptions = null;
+			if (images.length > 1) {
+				let secondsPerImage = 5;
+				if (variant === "carousel") {
+					const secondsPerImageProperty = variantReader.value("seconds-per-image");
+					if (secondsPerImageProperty !== null) {
+						if (typeof secondsPerImageProperty === "number") secondsPerImage = secondsPerImageProperty;
+						else if (typeof secondsPerImageProperty === "string") secondsPerImage = Number.parseFloat(secondsPerImageProperty);
+					}
+				}
+				carouselOptions = { secondsPerImage };
+			}
+			let heroOptions = null;
+			if (variant === "hero") heroOptions = {
+				isBackgroundImageDisplayed: variantReader.valueOr("background-image-displayed", true),
+				isDocumentDisplayed: variantReader.valueOr("document-displayed", true)
+			};
+			properties = {
+				component: "image",
+				images,
+				variant,
+				width,
+				height,
+				isFullWidth,
+				isFullHeight,
+				imageQuality,
+				captionLayout,
+				captionSource,
+				altTextSource,
+				isTransparentBackground,
+				isCover,
+				carouselOptions,
+				heroOptions
+			};
+			break;
+		}
+		case "image-gallery": {
+			const galleryLink = findWebsiteLinkByCategories(websiteLinks, ["set", "tree"]);
+			if (galleryLink == null) throw new Error(formatComponentError("Image gallery link not found", componentName, elementResource), { cause: componentProperty });
+			const isFilterInputDisplayed = componentReader.valueOr("filter-input-displayed", true);
+			properties = {
+				component: "image-gallery",
+				linkUuid: galleryLink.uuid,
+				isFilterInputDisplayed
+			};
+			break;
+		}
+		case "map": {
+			const mapLink = findWebsiteLinkByCategories(websiteLinks, ["set", "tree"]);
+			if (mapLink == null) throw new Error(formatComponentError("Map link not found", componentName, elementResource), { cause: componentProperty });
+			const isInteractive = componentReader.valueOr("is-interactive", true);
+			const isClustered = componentReader.valueOr("is-clustered", false);
+			const isUsingPins = componentReader.valueOr("is-using-pins", false);
+			const customBasemap = componentReader.value("custom-basemap");
+			let initialBounds = null;
+			const initialBoundsProperty = componentReader.value("initial-bounds");
+			if (initialBoundsProperty !== null) initialBounds = parseBounds(String(initialBoundsProperty));
+			let maximumBounds = null;
+			const maximumBoundsProperty = componentReader.value("maximum-bounds");
+			if (maximumBoundsProperty !== null) maximumBounds = parseBounds(String(maximumBoundsProperty));
+			const isControlsDisplayed = componentReader.valueOr("controls-displayed", false);
+			const isFullHeight = componentReader.valueOr("is-full-height", false);
+			properties = {
+				component: "map",
+				linkUuid: mapLink.uuid,
+				customBasemap,
+				initialBounds,
+				maximumBounds,
+				isInteractive,
+				isClustered,
+				isUsingPins,
+				isControlsDisplayed,
+				isFullHeight
+			};
+			break;
+		}
+		case "query": {
+			const setLinks = getWebsiteLinks(websiteLinks, "set");
+			if (setLinks.length === 0) throw new Error(formatComponentError("Set links not found", componentName, elementResource), { cause: componentProperty });
+			const items = [];
+			if (componentProperty.properties.length === 0) throw new Error(formatComponentError("Query properties not found", componentName, elementResource), { cause: componentProperty });
+			for (const queryItem of componentProperty.properties) {
+				const queryReader = websitePresentationReader(queryItem.properties);
+				const label = queryReader.multilingualValue("query-prompt", options);
+				if (label === null) continue;
+				const propertyVariables = queryReader.values("use-property").filter((value) => value.uuid !== null);
+				const queryLanguage = options.languages[0];
+				if (queryLanguage == null) throw new Error(formatComponentError("Query language not found", componentName, elementResource));
+				const queries = [];
+				for (const propertyVariable of propertyVariables) {
+					if (propertyVariable.uuid === null) throw new Error(formatComponentError("Property variable UUID not found", componentName, elementResource), { cause: propertyVariable });
+					const dataType = propertyVariable.dataType;
+					if (dataType === "coordinate") throw new Error(formatComponentError("Query prompts with data type \"coordinate\" are not supported", componentName, elementResource), { cause: propertyVariable });
+					queries.push({
+						target: "property",
+						propertyVariable: propertyVariable.uuid,
+						dataType,
+						matchMode: "exact",
+						isCaseSensitive: true,
+						language: queryLanguage
+					});
+				}
+				const startIcon = queryReader.value("start-icon");
+				const endIcon = queryReader.value("end-icon");
+				items.push({
+					label,
+					queries,
+					startIcon,
+					endIcon
+				});
+			}
+			if (items.length === 0) throw new Error(formatComponentError("No queries found", componentName, elementResource), { cause: componentProperty });
+			const componentOptions = parseWebsiteOptions(elementResource.options, options);
+			const displayedProperties = componentReader.property("use-property");
+			const variant = componentReader.valueOr("variant", "slide");
+			const paginationVariant = componentReader.valueOr("pagination-variant", "default");
+			const loadingVariant = componentReader.valueOr("loading-variant", "skeleton");
+			const imageLayout = componentReader.valueOr("image-layout", "start");
+			properties = {
+				component: "query",
+				linkUuids: setLinks.map((link) => link.uuid),
+				items,
+				options: componentOptions,
+				collectionProperties: {
+					displayedProperties: displayedProperties?.values.filter((value) => value.uuid !== null).map((value) => ({
+						uuid: value.uuid,
+						label: value.label
+					})) ?? null,
+					variant,
+					paginationVariant,
+					loadingVariant,
+					imageLayout
+				}
+			};
+			break;
+		}
+		case "table": {
+			const tableLink = findWebsiteLink(websiteLinks, "set");
+			if (tableLink == null) throw new Error(formatComponentError("Table link not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "table",
+				linkUuid: tableLink.uuid
+			};
+			break;
+		}
+		case "search-bar": {
+			const queryVariant = componentReader.valueOr("query-variant", "submit");
+			const boundElementUuid = componentReader.uuid("bound-element");
+			const href = componentReader.linkTarget("link-to", transformPermanentIdentificationUrlToItemLink);
+			if (!boundElementUuid && !href) throw new Error(formatComponentError("Bound element or href not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "search-bar",
+				queryVariant,
+				placeholder: componentReader.multilingualValue("placeholder-text", options),
+				baseFilterQueries: componentReader.value("base-filter-queries")?.replaceAll(String.raw`\{`, "{").replaceAll(String.raw`\}`, "}") ?? null,
+				boundElementUuid,
+				href
+			};
+			break;
+		}
+		case "text": {
+			const content = elementResource.document && "content" in elementResource.document ? parseXMLContent(elementResource.document, options) : null;
+			if (content == null) throw new Error(formatComponentError("Content not found", componentName, elementResource), { cause: componentProperty });
+			let variantName = "block";
+			let variant;
+			const variantProperty = componentReader.property("variant");
+			if (variantProperty !== null) {
+				const variantReader = websitePresentationReader(variantProperty.properties);
+				variantName = variantProperty.values[0].content;
+				switch (variantName) {
+					case "paragraph":
+						variant = {
+							name: variantName,
+							size: variantReader.valueOr("size", "md")
+						};
+						break;
+					case "label":
+						variant = {
+							name: variantName,
+							size: variantReader.valueOr("size", "md")
+						};
+						break;
+					case "heading":
+						variant = {
+							name: variantName,
+							size: variantReader.valueOr("size", "md")
+						};
+						break;
+					case "display":
+						variant = {
+							name: variantName,
+							size: variantReader.valueOr("size", "md")
+						};
+						break;
+					default: variant = { name: variantName };
+				}
+			} else variant = { name: variantName };
+			const headingLevel = componentReader.value("heading-level");
+			properties = {
+				component: "text",
+				variant,
+				headingLevel,
+				content
+			};
+			break;
+		}
+		case "timeline": {
+			const timelineLink = findWebsiteLink(websiteLinks, "tree");
+			if (timelineLink == null) throw new Error(formatComponentError("Timeline link not found", componentName, elementResource), { cause: componentProperty });
+			properties = {
+				component: "timeline",
+				linkUuid: timelineLink.uuid
+			};
+			break;
+		}
+		case "video": {
+			const videoLink = findWebsiteLink(websiteLinks, "resource", (link) => link.type === "video");
+			if (videoLink == null) throw new Error(formatComponentError("Video link not found", componentName, elementResource), { cause: componentProperty });
+			const isChaptersDisplayed = componentReader.valueOr("chapters-displayed", true);
+			properties = {
+				component: "video",
+				linkUuid: videoLink.uuid,
+				isChaptersDisplayed
+			};
+			break;
+		}
+		default: throw new Error(`Invalid or non-implemented component name “${unparsedComponentName.toString()}” for the following element: “${parseStringContent(elementResource.identification.label, options)}”`);
+	}
+	return properties;
+}
+function parseWebTitle(properties, identification, overrides) {
+	const title = {
+		label: identification.label,
+		variant: "default",
+		properties: {
+			isNameDisplayed: overrides?.isNameDisplayed ?? false,
+			isDescriptionDisplayed: overrides?.isDescriptionDisplayed ?? false,
+			isDateDisplayed: overrides?.isDateDisplayed ?? false,
+			isCreatorsDisplayed: overrides?.isCreatorsDisplayed ?? false,
+			isCountDisplayed: overrides?.isCountDisplayed ?? false
+		}
+	};
+	const titleReader = websitePresentationReader(properties).nestedByValue("presentation", "title");
+	if (titleReader.size > 0) {
+		title.variant = titleReader.valueOr("variant", "default");
+		title.properties.isNameDisplayed = titleReader.valueOr("name-displayed", false);
+		title.properties.isDescriptionDisplayed = titleReader.valueOr("description-displayed", false);
+		title.properties.isDateDisplayed = titleReader.valueOr("date-displayed", false);
+		title.properties.isCreatorsDisplayed = titleReader.valueOr("creators-displayed", false);
+		title.properties.isCountDisplayed = titleReader.valueOr("count-displayed", false);
+	}
+	return title;
+}
+/**
+* Parses raw web element data into a standardized WebElement structure
+*
+* @param elementResource - Raw element resource data in OCHRE format
+* @returns Parsed WebElement object
+*/
+function parseWebElement(elementResource, options) {
+	const identification = parseIdentification(elementResource.identification, options);
+	const elementProperties = elementResource.properties?.property ? parseSimplifiedProperties(elementResource.properties, options) : [];
+	const properties = parseWebElementProperties(websitePresentationReader(websitePresentationReader(elementProperties).requiredProperty("presentation", `Presentation property not found for element (${formatXMLWebsiteResourceMetadata(elementResource)})`).properties).requiredProperty("component", `Component property not found for element (${formatXMLWebsiteResourceMetadata(elementResource)})`), elementResource, options);
+	const cssStyles = parseResponsiveCssStyles(elementProperties);
+	const title = parseWebTitle(elementProperties, identification, {
+		isNameDisplayed: properties.component === "annotated-image" || properties.component === "annotated-document" || properties.component === "collection",
+		isCountDisplayed: properties.component === "collection"
+	});
+	return {
+		uuid: elementResource.uuid,
+		type: "element",
+		title,
+		cssStyles,
+		...properties
+	};
+}
+/**
+* Parses raw webpage data into a standardized Webpage structure
+*
+* @param webpageResource - Raw webpage resource data in OCHRE format
+* @returns Parsed Webpage object
+*/
+function parseWebpage(webpageResource, options, context, slugPrefix) {
+	const webpageProperties = webpageResource.properties ? parseSimplifiedProperties(webpageResource.properties, options) : [];
+	const webpageReader = websitePresentationReader(webpageProperties);
+	if (webpageReader.value("presentation") !== "page") return null;
+	const identification = parseIdentification(webpageResource.identification, options);
+	const slug = webpageResource.slug?.replace(SEGMENT_UNIQUE_SLUG_PREFIX_REGEX, "") ?? null;
+	if (slug == null) throw new Error(`Slug not found for page (${formatXMLWebsiteResourceMetadata(webpageResource)})`, { cause: webpageResource });
+	const returnWebpage = {
+		uuid: webpageResource.uuid,
+		type: "page",
+		title: identification.label,
+		slug: prefixSlug(slug, slugPrefix),
+		publicationDateTime: webpageResource.publicationDateTime ?? null,
+		items: [],
+		segments: [],
+		properties: {
+			width: "default",
+			variant: "default",
+			isBreadcrumbsDisplayed: false,
+			isSidebarDisplayed: true,
+			isDisplayedInNavbar: true,
+			isNavbarSearchBarDisplayed: true,
+			backgroundImage: null,
+			cssStyles: {
+				default: [],
+				tablet: [],
+				mobile: []
+			}
+		},
+		webpages: []
+	};
+	const imageLink = findWebsiteLink(parseLinks(webpageResource.links, options), "resource", (link) => link.type === "image" || link.type === "IIIF");
+	const webpageResources = webpageResource.resource != null ? normalizeWebsiteResources(webpageResource.resource) : [];
+	const items = [];
+	for (const resource of webpageResources) {
+		const resourceType = websitePresentationReader(resource.properties != null ? parseSimplifiedProperties(resource.properties, options) : []).value("presentation");
+		if (resourceType === null) continue;
+		switch (resourceType) {
+			case "element": {
+				const element = parseWebElement(resource, options);
+				items.push(element);
+				break;
+			}
+			case "block": {
+				const block = parseWebBlock(resource, options);
+				if (block) items.push(block);
+				break;
+			}
+		}
+	}
+	returnWebpage.items = items;
+	returnWebpage.webpages = parseWebpages(webpageResources, options, context, slugPrefix == null ? void 0 : returnWebpage.slug);
+	returnWebpage.segments = parseWebsiteSegments(webpageResource.resource, context, options, returnWebpage.slug);
+	const pageReader = webpageReader.nestedByValue("presentation", "page");
+	if (pageReader.size > 0) {
+		returnWebpage.properties.isDisplayedInNavbar = pageReader.valueOr("displayed-in-navbar", true);
+		returnWebpage.properties.width = pageReader.valueOr("width", "default");
+		returnWebpage.properties.variant = pageReader.valueOr("variant", "default");
+		returnWebpage.properties.isSidebarDisplayed = pageReader.valueOr("sidebar-displayed", true);
+		returnWebpage.properties.isBreadcrumbsDisplayed = pageReader.valueOr("breadcrumbs-displayed", false);
+		returnWebpage.properties.isNavbarSearchBarDisplayed = pageReader.valueOr("navbar-search-bar-displayed", true);
+	}
+	if (imageLink != null) returnWebpage.properties.backgroundImage = {
+		uuid: imageLink.uuid,
+		label: imageLink.identification.label,
+		description: imageLink.description,
+		width: imageLink.image?.width ?? 0,
+		height: imageLink.image?.height ?? 0,
+		quality: "high"
+	};
+	returnWebpage.properties.cssStyles = parseResponsiveCssStyles(webpageProperties);
+	return returnWebpage;
+}
+/**
+* Parses raw webpage resources into an array of Webpage objects
+*
+* @param webpageResources - Array of raw webpage resources in OCHRE format
+* @returns Array of parsed Webpage objects
+*/
+function parseWebpages(webpageResources, options, context, slugPrefix) {
+	const returnPages = [];
+	for (const webpageResource of webpageResources) {
+		const webpage = parseWebpage(webpageResource, options, context, slugPrefix);
+		if (webpage !== null) returnPages.push(webpage);
+	}
+	return returnPages;
+}
+function parseWebpageView(view, options, context) {
+	return parseWebpages(view?.resource ?? [], options, context)[0] ?? null;
+}
+function parseWebsiteSegments(resources, context, options, slugPrefix) {
+	const segments = [];
+	for (const resource of resources ?? []) {
+		if (!("segments" in resource)) continue;
+		for (const tree of resource.segments.tree) {
+			const segmentSlug = tree.identification.abbreviation == null ? null : parseStringContent(tree.identification.abbreviation, options);
+			if (segmentSlug == null) throw new Error(`Slug not found for segment website (website uuid “${tree.uuid}”)`, { cause: tree });
+			segments.push(parseWebsiteTree(tree, context, "segment", options, prefixSlug(segmentSlug, slugPrefix)));
+		}
+	}
+	return segments;
+}
+/**
+* Parses raw sidebar data into a standardized Sidebar structure
+*
+* @param resources - Array of raw sidebar resources in OCHRE format
+* @returns Parsed Sidebar object
+*/
+function parseSidebar(resources, options) {
+	let returnSidebar = null;
+	const items = [];
+	let title = null;
+	let layout = "start";
+	let mobileLayout = "default";
+	const cssStyles = {
+		default: [],
+		tablet: [],
+		mobile: []
+	};
+	const sidebarResource = resources.find((resource) => {
+		const resourceReader = websitePresentationReader(resource.properties ? parseSimplifiedProperties(resource.properties, options) : []);
+		return resourceReader.value("presentation") === "element" && resourceReader.nestedByValue("presentation", "element").value("component") === "sidebar";
+	});
+	if (sidebarResource != null) {
+		const sidebarBaseProperties = sidebarResource.properties ? parseSimplifiedProperties(sidebarResource.properties, options) : [];
+		title = parseWebTitle(sidebarBaseProperties, parseIdentification(sidebarResource.identification, options));
+		const sidebarReader = websitePresentationReader(sidebarBaseProperties).nestedByValue("presentation", "element").nestedByValue("component", "sidebar");
+		layout = sidebarReader.valueOr("layout", "start");
+		mobileLayout = sidebarReader.valueOr("layout-mobile", "default");
+		const parsedCssStyles = parseResponsiveCssStyles(sidebarBaseProperties);
+		cssStyles.default = parsedCssStyles.default;
+		cssStyles.tablet = parsedCssStyles.tablet;
+		cssStyles.mobile = parsedCssStyles.mobile;
+		const sidebarResources = sidebarResource.resource ? normalizeWebsiteResources(sidebarResource.resource) : [];
+		for (const resource of sidebarResources) {
+			const resourceType = websitePresentationReader(resource.properties ? parseSimplifiedProperties(resource.properties, options) : []).value("presentation");
+			if (resourceType === null) continue;
+			switch (resourceType) {
+				case "element": {
+					const element = parseWebElement(resource, options);
+					items.push(element);
+					break;
+				}
+				case "block": {
+					const block = parseWebBlock(resource, options);
+					if (block) items.push(block);
+					break;
+				}
+			}
+		}
+	}
+	if (items.length > 0 && title != null) returnSidebar = {
+		isDisplayed: true,
+		items,
+		title,
+		layout,
+		mobileLayout,
+		cssStyles
+	};
+	return returnSidebar;
+}
+/**
+* Parses raw text element data for accordion layout with items support
+*
+* @param elementResource - Raw element resource data in OCHRE format
+* @returns Parsed text WebElement with items array
+*/
+function parseWebElementForAccordion(elementResource, options) {
+	const textElement = parseWebElement(elementResource, options);
+	const childResources = elementResource.resource ? normalizeWebsiteResources(elementResource.resource) : [];
+	const items = [];
+	for (const resource of childResources) {
+		const resourceType = websitePresentationReader(resource.properties ? parseSimplifiedProperties(resource.properties, options) : []).value("presentation");
+		if (resourceType === null) continue;
+		switch (resourceType) {
+			case "element": {
+				const element = parseWebElement(resource, options);
+				items.push(element);
+				break;
+			}
+			case "block": {
+				const block = parseWebBlock(resource, options);
+				if (block) items.push(block);
+				break;
+			}
+		}
+	}
+	return {
+		...textElement,
+		items
+	};
+}
+/**
+* Parses raw block data into a standardized WebBlock structure
+*
+* @param blockResource - Raw block resource data in OCHRE format
+* @returns Parsed WebBlock object
+*/
+function parseWebBlock(blockResource, options) {
+	const blockProperties = blockResource.properties ? parseSimplifiedProperties(blockResource.properties, options) : [];
+	const returnBlock = {
+		uuid: blockResource.uuid,
+		type: "block",
+		title: parseWebTitle(blockProperties, parseIdentification(blockResource.identification, options)),
+		items: [],
+		properties: {
+			default: {
+				layout: "vertical",
+				wrap: "nowrap",
+				spacing: null,
+				gap: null
+			},
+			mobile: null,
+			tablet: null
+		},
+		cssStyles: {
+			default: [],
+			tablet: [],
+			mobile: []
+		}
+	};
+	const blockReader = websitePresentationReader(blockProperties).nestedByValue("presentation", "block");
+	if (blockReader.size > 0) {
+		returnBlock.properties.default.layout = blockReader.valueOr("layout", "vertical");
+		returnBlock.properties.default.wrap = blockReader.valueOr("wrap", "nowrap");
+		if (returnBlock.properties.default.layout === "accordion") {
+			returnBlock.properties.default.isAccordionEnabled = blockReader.valueOr("accordion-enabled", true);
+			returnBlock.properties.default.isAccordionExpandedByDefault = blockReader.valueOr("accordion-expanded", true);
+			returnBlock.properties.default.isAccordionSidebarDisplayed = blockReader.valueOr("accordion-sidebar-displayed", false);
+		}
+		returnBlock.properties.default.spacing = blockReader.valueOr("spacing", null);
+		returnBlock.properties.default.gap = blockReader.valueOr("gap", null);
+		const tabletOverwriteReader = blockReader.nested("overwrite-tablet");
+		if (tabletOverwriteReader.size > 0) {
+			const propertiesTablet = {
+				layout: tabletOverwriteReader.value("layout") ?? void 0,
+				wrap: tabletOverwriteReader.value("wrap") ?? void 0,
+				spacing: tabletOverwriteReader.value("spacing") ?? void 0,
+				gap: tabletOverwriteReader.value("gap") ?? void 0,
+				isAccordionEnabled: void 0,
+				isAccordionExpandedByDefault: void 0,
+				isAccordionSidebarDisplayed: void 0
+			};
+			if (propertiesTablet.layout === "accordion" || returnBlock.properties.default.layout === "accordion") {
+				propertiesTablet.isAccordionEnabled = tabletOverwriteReader.value("accordion-enabled") ?? void 0;
+				propertiesTablet.isAccordionExpandedByDefault = tabletOverwriteReader.value("accordion-expanded") ?? void 0;
+				propertiesTablet.isAccordionSidebarDisplayed = tabletOverwriteReader.value("accordion-sidebar-displayed") ?? void 0;
+			}
+			const cleanedPropertiesTablet = cleanObject(propertiesTablet);
+			if (Object.keys(cleanedPropertiesTablet).length > 0) returnBlock.properties.tablet = cleanedPropertiesTablet;
+		}
+		const mobileOverwriteReader = blockReader.nested("overwrite-mobile");
+		if (mobileOverwriteReader.size > 0) {
+			const propertiesMobile = {
+				layout: mobileOverwriteReader.value("layout") ?? void 0,
+				wrap: mobileOverwriteReader.value("wrap") ?? void 0,
+				spacing: mobileOverwriteReader.value("spacing") ?? void 0,
+				gap: mobileOverwriteReader.value("gap") ?? void 0,
+				isAccordionEnabled: void 0,
+				isAccordionExpandedByDefault: void 0,
+				isAccordionSidebarDisplayed: void 0
+			};
+			if (propertiesMobile.layout === "accordion" || returnBlock.properties.default.layout === "accordion") {
+				propertiesMobile.isAccordionEnabled = mobileOverwriteReader.value("accordion-enabled") ?? void 0;
+				propertiesMobile.isAccordionExpandedByDefault = mobileOverwriteReader.value("accordion-expanded") ?? void 0;
+				propertiesMobile.isAccordionSidebarDisplayed = mobileOverwriteReader.value("accordion-sidebar-displayed") ?? void 0;
+			}
+			const cleanedPropertiesMobile = cleanObject(propertiesMobile);
+			if (Object.keys(cleanedPropertiesMobile).length > 0) returnBlock.properties.mobile = cleanedPropertiesMobile;
+		}
+	}
+	const blockResources = blockResource.resource ? normalizeWebsiteResources(blockResource.resource) : [];
+	if (returnBlock.properties.default.layout === "accordion") {
+		const accordionItems = [];
+		for (const resource of blockResources) {
+			const resourceReader = websitePresentationReader(resource.properties ? parseSimplifiedProperties(resource.properties, options) : []);
+			const resourceType = resourceReader.value("presentation");
+			if (resourceType !== "element") throw new Error(`Accordion only accepts elements, but got “${resourceType}” (${formatXMLWebsiteResourceMetadata(resource)})`, { cause: resource });
+			const componentType = resourceReader.nestedByValue("presentation", "element").value("component");
+			if (componentType !== "text") throw new Error(`Accordion only accepts text components, but got “${componentType}” (${formatXMLWebsiteResourceMetadata(resource)})`, { cause: resource });
+			const element = parseWebElementForAccordion(resource, options);
+			accordionItems.push(element);
+		}
+		returnBlock.items = accordionItems;
+	} else {
+		const blockItems = [];
+		for (const resource of blockResources) {
+			const resourceType = websitePresentationReader(resource.properties ? parseSimplifiedProperties(resource.properties, options) : []).value("presentation");
+			if (resourceType === null) continue;
+			switch (resourceType) {
+				case "element": {
+					const element = parseWebElement(resource, options);
+					blockItems.push(element);
+					break;
+				}
+				case "block": {
+					const block = parseWebBlock(resource, options);
+					if (block) blockItems.push(block);
+					break;
+				}
+			}
+		}
+		returnBlock.items = blockItems;
+	}
+	returnBlock.cssStyles = parseResponsiveCssStyles(blockProperties);
+	return returnBlock;
+}
+/**
+* Parses raw website properties into a standardized Website properties structure
+*
+* @param properties - Array of raw website properties in OCHRE format
+* @returns Parsed WebsiteProperties object
+*/
+function parseWebsiteProperties(properties, websiteTree, sidebar, options) {
+	const websiteReader = websitePresentationReader(parseSimplifiedProperties({ property: properties }, options)).nested("presentation");
+	const returnProperties = {
+		type: websiteReader.valueOr("webUI", "traditional"),
+		status: websiteReader.valueOr("status", "development"),
+		versionLabel: websiteReader.valueOr("version-label", "release"),
+		privacy: websiteReader.valueOr("privacy", "public"),
+		contact: null,
+		loadingVariant: "spinner",
+		theme: {
+			isThemeToggleDisplayed: true,
+			defaultTheme: "system"
+		},
+		icon: {
+			logoUuid: null,
+			faviconUuid: null,
+			appleTouchIconUuid: null
+		},
+		navbar: {
+			isDisplayed: true,
+			variant: "default",
+			alignment: "start",
+			isProjectDisplayed: true,
+			searchBarBoundElementUuid: null,
+			items: null
+		},
+		footer: {
+			isDisplayed: true,
+			logoUuid: null,
+			items: null
+		},
+		sidebar,
+		itemPage: {
+			isMainContentDisplayed: true,
+			isDescriptionDisplayed: true,
+			isDocumentDisplayed: true,
+			isNotesDisplayed: true,
+			isEventsDisplayed: true,
+			isPeriodsDisplayed: true,
+			isPropertiesDisplayed: true,
+			isBibliographyDisplayed: true,
+			isPropertyValuesGrouped: true,
+			isPublicationDateTimeDisplayed: true,
+			isPersistentIdentifierDisplayed: true,
+			iiifViewer: "universal-viewer"
+		},
+		options: {
+			contextTree: null,
+			scopes: null,
+			labels: { title: null },
+			stylesheets: { properties: [] }
+		}
+	};
+	const contactProperty = websiteReader.property("contact");
+	if (contactProperty !== null) {
+		const contactContent = contactProperty.values[0]?.content.toString().split(";") ?? [];
+		if (contactContent.length === 2) returnProperties.contact = {
+			name: contactContent[0],
+			email: contactContent[1] ?? null
+		};
+		else throw new Error(`Contact property must use “name;email”, got “${contactProperty.values[0]?.content}” (website uuid “${websiteTree.uuid}”)`, { cause: websiteTree });
+	}
+	returnProperties.loadingVariant = websiteReader.valueOr("loading-variant", "spinner");
+	returnProperties.theme.isThemeToggleDisplayed = websiteReader.valueOr("supports-theme-toggle", true);
+	returnProperties.theme.defaultTheme = websiteReader.valueOr("default-theme", "system");
+	returnProperties.icon.logoUuid = websiteReader.uuid("navbar-logo");
+	returnProperties.icon.faviconUuid = websiteReader.uuid("favicon-ico");
+	returnProperties.icon.appleTouchIconUuid = websiteReader.uuid("favicon-img");
+	returnProperties.navbar.isDisplayed = websiteReader.valueOr("navbar-displayed", true);
+	returnProperties.navbar.variant = websiteReader.valueOr("navbar-variant", "default");
+	returnProperties.navbar.alignment = websiteReader.valueOr("navbar-alignment", "start");
+	returnProperties.navbar.isProjectDisplayed = websiteReader.valueOr("navbar-project-displayed", true);
+	returnProperties.navbar.searchBarBoundElementUuid = websiteReader.uuid("bound-element-navbar-search-bar");
+	returnProperties.footer.isDisplayed = websiteReader.valueOr("footer-displayed", true);
+	returnProperties.footer.logoUuid = websiteReader.uuid("footer-logo");
+	const itemPageReader = websiteReader.nestedByValue("page-type", "item-page");
+	if (itemPageReader.size > 0) {
+		returnProperties.itemPage.isMainContentDisplayed = itemPageReader.valueOr("item-page-main-content-displayed", true);
+		returnProperties.itemPage.isDescriptionDisplayed = itemPageReader.valueOr("item-page-description-displayed", true);
+		returnProperties.itemPage.isDocumentDisplayed = itemPageReader.valueOr("item-page-document-displayed", true);
+		returnProperties.itemPage.isNotesDisplayed = itemPageReader.valueOr("item-page-notes-displayed", true);
+		returnProperties.itemPage.isEventsDisplayed = itemPageReader.valueOr("item-page-events-displayed", true);
+		returnProperties.itemPage.isPeriodsDisplayed = itemPageReader.valueOr("item-page-periods-displayed", true);
+		returnProperties.itemPage.isPropertiesDisplayed = itemPageReader.valueOr("item-page-properties-displayed", true);
+		returnProperties.itemPage.isBibliographyDisplayed = itemPageReader.valueOr("item-page-bibliography-displayed", true);
+		returnProperties.itemPage.isPropertyValuesGrouped = itemPageReader.valueOr("item-page-property-values-grouped", true);
+		returnProperties.itemPage.isPublicationDateTimeDisplayed = itemPageReader.valueOr("item-page-publication-date-time-displayed", true);
+		returnProperties.itemPage.isPersistentIdentifierDisplayed = itemPageReader.valueOr("item-page-persistent-identifier-displayed", true);
+		returnProperties.itemPage.iiifViewer = itemPageReader.valueOr("item-page-iiif-viewer", "universal-viewer");
+	}
+	if (websiteTree.options != null) {
+		const parsedOptions = parseWebsiteOptions(websiteTree.options, options);
+		returnProperties.options.scopes = parsedOptions.scopes;
+		returnProperties.options.contextTree = parsedOptions.contextTree;
+		returnProperties.options.labels = parsedOptions.labels;
+	}
+	if ("styleOptions" in websiteTree && websiteTree.styleOptions != null) returnProperties.options.stylesheets.properties = parseStylesheets(websiteTree.styleOptions.style);
+	return returnProperties;
+}
+function parseContextItem(contextItemToParse, options) {
+	let type = "";
+	const levels = [];
+	for (const level of contextItemToParse.levels?.level ?? []) {
+		const [rawVariableUuid = "", rawValueUuid] = level.payload.split(",");
+		const valueUuid = rawValueUuid == null || rawValueUuid.trim() === "null" ? null : rawValueUuid.trim();
+		type = level.dataType ?? type;
+		levels.push({
+			variableUuid: rawVariableUuid.trim(),
+			valueUuid
+		});
+	}
+	return {
+		context: levels,
+		type,
+		identification: parseIdentification(contextItemToParse.identification, options)
+	};
+}
+function parseFilterContextDisplay(filterOption) {
+	switch (filterOption) {
+		case "inline-displayed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-closed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-open": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		case "sidebar-displayed-closed": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "sidebar-displayed-open": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		default: return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
+	}
+}
+function parseContexts(contextLevels, options) {
+	const contextTreeLevels = [];
+	for (const contextLevel of contextLevels) for (const contextItemToParse of contextLevel.context) contextTreeLevels.push(parseContextItem(contextItemToParse, options));
+	return contextTreeLevels;
+}
+function parseFilterContexts(filterContextLevels, options) {
+	const filterContextTreeLevels = [];
+	for (const filterContextLevel of filterContextLevels) for (const contextItemToParse of filterContextLevel.context) filterContextTreeLevels.push({
+		...parseContextItem(contextItemToParse, options),
+		filterType: contextItemToParse.filterType ?? "property",
+		...parseFilterContextDisplay(contextItemToParse.filterOption)
+	});
+	return filterContextTreeLevels;
+}
+function parseWebsiteTree(websiteTree, context, type, options, slugPrefix) {
+	if (!websiteTree.properties) throw new Error(`Website properties not found (website uuid “${websiteTree.uuid}”)`, { cause: websiteTree });
+	if (type === "website" && websiteTree.items?.resource == null) throw new Error(`Website pages not found (website uuid “${websiteTree.uuid}”)`, { cause: websiteTree });
+	const resources = normalizeWebsiteResources(websiteTree.items?.resource);
+	const sidebar = parseSidebar(resources, options);
+	const properties = parseWebsiteProperties(websiteTree.properties.property, websiteTree, sidebar, options);
+	return {
+		uuid: websiteTree.uuid,
+		type,
+		belongsTo: context.belongsTo,
+		metadata: context.metadata,
+		publicationDateTime: websiteTree.publicationDateTime ?? null,
+		identification: parseIdentification(websiteTree.identification, options),
+		creators: websiteTree.creators ? parsePersonList(websiteTree.creators.creator, options) : [],
+		license: parseLicense(websiteTree.availability),
+		items: parseWebpages(resources, options, context, slugPrefix),
+		properties
+	};
+}
+function parseWebsite(data, options) {
+	const rawOchre = data.result.ochre;
+	const metadataLanguages = parseMetadataLanguages(rawOchre);
+	const languages = resolveLanguages(options?.languages ?? [], metadataLanguages);
+	const parserOptions = { languages };
+	const defaultLanguage = resolveDefaultLanguage(rawOchre, languages);
+	const websiteTree = rawOchre.tree[0];
+	if (websiteTree == null) throw new Error("Website tree not found", { cause: data });
+	return parseWebsiteTree(websiteTree, {
+		belongsTo: {
+			uuid: rawOchre.uuidBelongsTo,
+			abbreviation: rawOchre.belongsTo
+		},
+		metadata: parseMetadata(rawOchre, parserOptions, defaultLanguage)
+	}, "website", parserOptions);
+}
+//#endregion
+export { parseBounds, parseWebpageView, parseWebsite };