@digitalculture/ochre-sdk 0.11.19 → 0.11.21

package/dist/index.js

@@ -0,0 +1,3119 @@
+import { z } from "zod";
+
+//#region src/schemas.ts
+/**
+* Schema for validating UUIDs
+* @internal
+*/
+const uuidSchema = z.uuid({ error: "Invalid UUID provided" });
+/**
+* Schema for validating website properties
+* @internal
+*/
+const websiteSchema = z.object({
+	type: z.enum([
+		"traditional",
+		"digital-collection",
+		"plum",
+		"cedar",
+		"elm",
+		"maple",
+		"oak",
+		"palm"
+	], { error: "Invalid website type" }),
+	status: z.enum([
+		"development",
+		"preview",
+		"production"
+	], { error: "Invalid website status" }),
+	privacy: z.enum([
+		"public",
+		"password",
+		"private"
+	], { error: "Invalid website privacy" })
+});
+/**
+* Valid component types for web elements
+* @internal
+*/
+const componentSchema = z.enum([
+	"annotated-document",
+	"annotated-image",
+	"audio-player",
+	"bibliography",
+	"button",
+	"collection",
+	"empty-space",
+	"entries",
+	"iframe",
+	"iiif-viewer",
+	"image",
+	"image-gallery",
+	"map",
+	"network-graph",
+	"query",
+	"search-bar",
+	"table",
+	"text",
+	"timeline",
+	"video"
+], { error: "Invalid component" });
+/**
+* Schema for validating data categories
+* @internal
+*/
+const categorySchema = z.enum([
+	"resource",
+	"spatialUnit",
+	"concept",
+	"period",
+	"bibliography",
+	"person",
+	"propertyValue",
+	"set",
+	"tree"
+]);
+/**
+* Schema for validating property value content types
+* @internal
+*/
+const propertyValueContentTypeSchema = z.enum([
+	"string",
+	"integer",
+	"decimal",
+	"boolean",
+	"date",
+	"dateTime",
+	"time",
+	"coordinate",
+	"IDREF"
+]);
+/**
+* Schema for validating gallery parameters
+* @internal
+*/
+const gallerySchema = z.object({
+	uuid: z.uuid({ error: "Invalid UUID" }),
+	filter: z.string().optional(),
+	page: z.number().positive({ error: "Page must be positive" }),
+	perPage: z.number().positive({ error: "Per page must be positive" })
+}).strict();
+/**
+* Schema for validating and parsing render options
+* @internal
+*/
+const renderOptionsSchema = z.string().transform((str) => str.split(" ")).pipe(z.array(z.enum([
+	"bold",
+	"italic",
+	"underline"
+])));
+/**
+* Schema for validating and parsing whitespace options
+* @internal
+*/
+const whitespaceSchema = z.string().transform((str) => str.split(" ")).pipe(z.array(z.enum([
+	"newline",
+	"trailing",
+	"leading"
+])));
+/**
+* Schema for validating email addresses
+* @internal
+*/
+const emailSchema = z.email({ error: "Invalid email" });
+
+//#endregion
+//#region src/utils/getters.ts
+const DEFAULT_OPTIONS = { includeNestedProperties: false };
+/**
+* Finds a property by its UUID in an array of properties
+*
+* @param properties - Array of properties to search through
+* @param uuid - The UUID to search for
+* @param options - Search options, including whether to include nested properties
+* @returns The matching Property object, or null if not found
+*
+* @example
+* ```ts
+* const property = getPropertyByUuid(properties, "123e4567-e89b-12d3-a456-426614174000", { includeNestedProperties: true });
+* if (property) {
+*   console.log(property.values);
+* }
+* ```
+*/
+function getPropertyByUuid(properties, uuid, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const property = properties.find((property$1) => property$1.uuid === uuid);
+	if (property) return property;
+	if (includeNestedProperties) {
+		for (const property$1 of properties) if (property$1.properties.length > 0) {
+			const nestedResult = getPropertyByUuid(property$1.properties, uuid, { includeNestedProperties });
+			if (nestedResult) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Retrieves all values for a property with the given UUID
+*
+* @param properties - Array of properties to search through
+* @param uuid - The UUID to search for
+* @param options - Search options, including whether to include nested properties
+* @returns Array of property values as strings, or null if property not found
+*
+* @example
+* ```ts
+* const values = getPropertyValuesByUuid(properties, "123e4567-e89b-12d3-a456-426614174000");
+* if (values) {
+*   for (const value of values) {
+*     console.log(value);
+*   }
+* }
+* ```
+*/
+function getPropertyValuesByUuid(properties, uuid, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const property = properties.find((property$1) => property$1.uuid === uuid);
+	if (property) return property.values.map((value) => value.content);
+	if (includeNestedProperties) {
+		for (const property$1 of properties) if (property$1.properties.length > 0) {
+			const nestedResult = getPropertyValuesByUuid(property$1.properties, uuid, { includeNestedProperties });
+			if (nestedResult) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Gets the first value of a property with the given UUID
+*
+* @param properties - Array of properties to search through
+* @param uuid - The UUID to search for
+* @param options - Search options, including whether to include nested properties
+* @returns The first property value as string, or null if property not found
+*
+* @example
+* ```ts
+* const title = getPropertyValueByUuid(properties, "123e4567-e89b-12d3-a456-426614174000");
+* if (title) {
+*   console.log(`Document title: ${title}`);
+* }
+* ```
+*/
+function getPropertyValueByUuid(properties, uuid, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const values = getPropertyValuesByUuid(properties, uuid, { includeNestedProperties });
+	if (values !== null && values.length > 0) return values[0];
+	if (includeNestedProperties) {
+		for (const property of properties) if (property.properties.length > 0) {
+			const nestedResult = getPropertyValueByUuid(property.properties, uuid, { includeNestedProperties });
+			if (nestedResult !== null) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Finds a property by its label in an array of properties
+*
+* @param properties - Array of properties to search through
+* @param label - The label to search for
+* @param options - Search options, including whether to include nested properties
+* @returns The matching Property object, or null if not found
+*
+* @example
+* ```ts
+* const property = getPropertyByLabel(properties, "author", { includeNestedProperties: true });
+* if (property) {
+*   console.log(property.values);
+* }
+* ```
+*/
+function getPropertyByLabel(properties, label, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const property = properties.find((property$1) => property$1.label === label);
+	if (property) return property;
+	if (includeNestedProperties) {
+		for (const property$1 of properties) if (property$1.properties.length > 0) {
+			const nestedResult = getPropertyByLabel(property$1.properties, label, { includeNestedProperties });
+			if (nestedResult) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Retrieves all values for a property with the given label
+*
+* @param properties - Array of properties to search through
+* @param label - The label to search for
+* @param options - Search options, including whether to include nested properties
+* @returns Array of property values as strings, or null if property not found
+*
+* @example
+* ```ts
+* const values = getPropertyValuesByLabel(properties, "keywords");
+* if (values) {
+*   for (const value of values) {
+*     console.log(value);
+*   }
+* }
+* ```
+*/
+function getPropertyValuesByLabel(properties, label, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const property = properties.find((property$1) => property$1.label === label);
+	if (property) return property.values.map((value) => value.content);
+	if (includeNestedProperties) {
+		for (const property$1 of properties) if (property$1.properties.length > 0) {
+			const nestedResult = getPropertyValuesByLabel(property$1.properties, label, { includeNestedProperties });
+			if (nestedResult) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Gets the first value of a property with the given label
+*
+* @param properties - Array of properties to search through
+* @param label - The label to search for
+* @param options - Search options, including whether to include nested properties
+* @returns The first property value as string, or null if property not found
+*
+* @example
+* ```ts
+* const title = getPropertyValueByLabel(properties, "title");
+* if (title) {
+*   console.log(`Document title: ${title}`);
+* }
+* ```
+*/
+function getPropertyValueByLabel(properties, label, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const values = getPropertyValuesByLabel(properties, label, { includeNestedProperties });
+	if (values !== null && values.length > 0) return values[0];
+	if (includeNestedProperties) {
+		for (const property of properties) if (property.properties.length > 0) {
+			const nestedResult = getPropertyValueByLabel(property.properties, label, { includeNestedProperties });
+			if (nestedResult !== null) return nestedResult;
+		}
+	}
+	return null;
+}
+/**
+* Gets all unique properties from an array of properties
+*
+* @param properties - Array of properties to get unique properties from
+* @param options - Search options, including whether to include nested properties
+* @returns Array of unique properties
+*
+* @example
+* ```ts
+* const properties = getAllUniqueProperties(properties, { includeNestedProperties: true });
+* console.log(`Available properties: ${properties.map((p) => p.label).join(", ")}`);
+* ```
+*/
+function getUniqueProperties(properties, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const uniqueProperties = new Array();
+	for (const property of properties) {
+		if (uniqueProperties.some((p) => p.uuid === property.uuid)) continue;
+		uniqueProperties.push(property);
+		if (property.properties.length > 0 && includeNestedProperties) {
+			const nestedProperties = getUniqueProperties(property.properties, { includeNestedProperties: true });
+			for (const property$1 of nestedProperties) {
+				if (uniqueProperties.some((p) => p.uuid === property$1.uuid)) continue;
+				uniqueProperties.push(property$1);
+			}
+		}
+	}
+	return uniqueProperties;
+}
+/**
+* Gets all unique property labels from an array of properties
+*
+* @param properties - Array of properties to get unique property labels from
+* @param options - Search options, including whether to include nested properties
+* @returns Array of unique property labels
+*
+* @example
+* ```ts
+* const properties = getAllUniquePropertyLabels(properties, { includeNestedProperties: true });
+* console.log(`Available properties: ${properties.join(", ")}`);
+* ```
+*/
+function getUniquePropertyLabels(properties, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	const uniquePropertyLabels = new Array();
+	for (const property of properties) {
+		if (uniquePropertyLabels.includes(property.label)) continue;
+		uniquePropertyLabels.push(property.label);
+		if (property.properties.length > 0 && includeNestedProperties) {
+			const nestedProperties = getUniquePropertyLabels(property.properties, { includeNestedProperties: true });
+			for (const property$1 of nestedProperties) {
+				if (uniquePropertyLabels.includes(property$1)) continue;
+				uniquePropertyLabels.push(property$1);
+			}
+		}
+	}
+	return uniquePropertyLabels;
+}
+/**
+* Filters a property based on a label and value criteria
+*
+* @param property - The property to filter
+* @param filter - Filter criteria containing label and value to match
+* @param filter.label - The label to filter by
+* @param filter.value - The value to filter by
+* @param options - Search options, including whether to include nested properties
+* @returns True if the property matches the filter criteria, false otherwise
+*
+* @example
+* ```ts
+* const matches = filterProperties(property, {
+*   label: "category",
+*   value: "book"
+* });
+* if (matches) {
+*   console.log("Property matches filter criteria");
+* }
+* ```
+*/
+function filterProperties(property, filter, options = DEFAULT_OPTIONS) {
+	const { includeNestedProperties } = options;
+	if (filter.label.toLocaleLowerCase("en-US") === "all fields" || property.label.toLocaleLowerCase("en-US") === filter.label.toLocaleLowerCase("en-US")) {
+		let isFound = property.values.some((value) => {
+			if (value.content === null) return false;
+			if (typeof value.content === "string") {
+				if (typeof filter.value !== "string") return false;
+				return value.content.toLocaleLowerCase("en-US").includes(filter.value.toLocaleLowerCase("en-US"));
+			}
+			if (typeof value.content === "number") {
+				if (typeof filter.value !== "number") return false;
+				return value.content === filter.value;
+			}
+			if (typeof value.content === "boolean") {
+				if (typeof filter.value !== "boolean") return false;
+				return value.content === filter.value;
+			}
+			return false;
+		});
+		if (!isFound && includeNestedProperties) isFound = property.properties.some((property$1) => filterProperties(property$1, filter, { includeNestedProperties: true }));
+		return isFound;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/utils/string.ts
+const PRESENTATION_ITEM_UUID = "f1c131b6-1498-48a4-95bf-a9edae9fd518";
+const TEXT_ANNOTATION_UUID = "b9ca2732-78f4-416e-b77f-dae7647e68a9";
+const TEXT_ANNOTATION_TEXT_STYLING_UUID = "3e6f86ab-df81-45ae-8257-e2867357df56";
+const TEXT_ANNOTATION_TEXT_STYLING_VARIANT_UUID = "e1647bef-d801-4100-bdde-d081c422f763";
+/**
+* Finds a string item in an array by language code
+*
+* @param content - Array of string items to search
+* @param language - Language code to search for
+* @returns Matching string item or null if not found
+* @internal
+*/
+function getStringItemByLanguage(content, language) {
+	return content.find((item) => item.lang === language) ?? null;
+}
+/**
+* Parses email addresses in a string into HTML links
+*
+* @param string - Input string to parse
+* @returns String with emails converted to HTML links
+*
+* @example
+* ```ts
+* const parsed = parseEmail("Contact us at info@example.com");
+* // Returns: "Contact us at <ExternalLink href="mailto:info@example.com">info@example.com</ExternalLink>"
+* ```
+*/
+function parseEmail(string) {
+	const splitString = string.split(" ");
+	const returnSplitString = [];
+	for (const string$1 of splitString) {
+		const cleanString = string$1.replaceAll(/(?<=\s|^)[([{]+|[)\]}]+(?=\s|$)/g, "").replaceAll(/[!),:;?\]]/g, "").replace(/\.$/, "");
+		const index = string$1.indexOf(cleanString);
+		const before = string$1.slice(0, index);
+		const after = string$1.slice(index + cleanString.length);
+		if (emailSchema.safeParse(cleanString).success) {
+			returnSplitString.push(`${before}<ExternalLink href="mailto:${cleanString}">${cleanString}</ExternalLink>${after}`);
+			continue;
+		}
+		returnSplitString.push(string$1);
+	}
+	return returnSplitString.join(" ");
+}
+/**
+* Applies text rendering options (bold, italic, underline) to a string
+*
+* @param contentString - The string content to render
+* @param renderString - Space-separated string of render options
+* @returns String with markdown formatting applied
+* @internal
+*/
+function parseRenderOptions(contentString, renderString) {
+	let returnString = contentString;
+	const result = renderOptionsSchema.safeParse(renderString);
+	if (!result.success) {
+		console.warn(`Invalid render options string provided: “${renderString}”`);
+		return contentString;
+	}
+	for (const option of result.data) switch (option) {
+		case "bold":
+			returnString = `**${returnString}**`;
+			break;
+		case "italic":
+			returnString = `*${returnString}*`;
+			break;
+		case "underline":
+			returnString = `_${returnString}_`;
+			break;
+	}
+	return returnString.replaceAll("&#39;", "'");
+}
+/**
+* Applies whitespace options to a string (newline, trailing, leading)
+*
+* @param contentString - The string content to modify
+* @param whitespace - Space-separated string of whitespace options
+* @returns String with whitespace modifications applied
+* @internal
+*/
+function parseWhitespace(contentString, whitespace) {
+	let returnString = contentString;
+	const result = whitespaceSchema.safeParse(whitespace);
+	if (!result.success) {
+		console.warn(`Invalid whitespace string provided: “${whitespace}”`);
+		return contentString;
+	}
+	for (const option of result.data) switch (option) {
+		case "newline":
+			returnString = `<br />\n${returnString}`;
+			break;
+		case "trailing":
+			returnString = `${returnString} `;
+			break;
+		case "leading":
+			returnString = ` ${returnString}`;
+			break;
+	}
+	return returnString.replaceAll("&#39;", "'");
+}
+/**
+* Converts a FakeString (string|number|boolean) to a proper string
+*
+* @param string - FakeString value to convert
+* @returns Converted string value
+*
+* @example
+* ```ts
+* parseFakeString(true); // Returns "Yes"
+* parseFakeString(123); // Returns "123"
+* parseFakeString("test"); // Returns "test"
+* ```
+*/
+function parseFakeString(string) {
+	return String(string).replaceAll("&#39;", "'").replaceAll("{", String.raw`\{`).replaceAll("}", String.raw`\}`);
+}
+/**
+* Parses an OchreStringItem into a formatted string
+*
+* @param item - OchreStringItem to parse
+* @returns Formatted string with applied rendering and whitespace
+*/
+function parseStringItem(item) {
+	let returnString = "";
+	switch (typeof item.string) {
+		case "string":
+		case "number":
+		case "boolean":
+			returnString = parseFakeString(item.string);
+			break;
+		case "object": {
+			const stringItems = Array.isArray(item.string) ? item.string : [item.string];
+			for (const stringItem of stringItems) if (typeof stringItem === "string" || typeof stringItem === "number" || typeof stringItem === "boolean") returnString += parseFakeString(stringItem);
+			else if ("string" in stringItem) returnString += parseStringDocumentItem(stringItem);
+			else {
+				const renderedText = stringItem.content == null ? "" : stringItem.rend != null ? parseRenderOptions(parseFakeString(stringItem.content), stringItem.rend) : parseFakeString(stringItem.content);
+				const whitespacedText = stringItem.whitespace != null ? parseWhitespace(renderedText, stringItem.whitespace) : renderedText;
+				returnString += whitespacedText;
+			}
+			break;
+		}
+		default:
+			returnString = "";
+			break;
+	}
+	return returnString;
+}
+/**
+* Parses rich text content into a formatted string with links and annotations
+*
+* @param item - Rich text item to parse
+* @returns Formatted string with HTML/markdown elements
+*/
+function parseStringDocumentItem(item) {
+	if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") return parseEmail(parseFakeString(item));
+	if ("whitespace" in item && !("content" in item) && !("string" in item)) if (item.whitespace === "newline") return "  \n";
+	else return parseWhitespace("", item.whitespace);
+	if ("links" in item) {
+		let itemString = "";
+		if (typeof item.string === "object") itemString = parseStringContent(item.string);
+		else itemString = parseFakeString(item.string).replaceAll("<", String.raw`\<`).replaceAll("{", String.raw`\{`);
+		const itemLinks = Array.isArray(item.links) ? item.links : [item.links];
+		for (const link of itemLinks) if ("resource" in link) {
+			const linkResource = Array.isArray(link.resource) ? link.resource[0] : link.resource;
+			let linkContent = null;
+			if (linkResource.content != null) linkContent = parseFakeString(linkResource.content).replaceAll("<", String.raw`\<`).replaceAll("{", String.raw`\{`);
+			switch (linkResource.type) {
+				case "image": if (linkResource.rend === "inline") return `<InlineImage uuid="${linkResource.uuid}" ${linkContent !== null ? `content="${linkContent}"` : ""} height={${linkResource.height?.toString() ?? "null"}} width={${linkResource.width?.toString() ?? "null"}} />`;
+				else if (linkResource.publicationDateTime != null) return `<InternalLink uuid="${linkResource.uuid}">${itemString}</InternalLink>`;
+				else return `<TooltipSpan${linkContent !== null ? ` content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+				case "internalDocument": if ("properties" in item && item.properties != null) {
+					const itemProperty = Array.isArray(item.properties.property) ? item.properties.property[0] : item.properties.property;
+					if (itemProperty != null) {
+						const itemPropertyLabelUuid = itemProperty.label.uuid;
+						const itemPropertyValueUuid = typeof itemProperty.value === "object" && "uuid" in itemProperty.value && itemProperty.value.uuid != null ? itemProperty.value.uuid : null;
+						if (itemPropertyLabelUuid === PRESENTATION_ITEM_UUID && itemPropertyValueUuid === TEXT_ANNOTATION_UUID) {
+							if ((itemProperty.property != null ? Array.isArray(itemProperty.property) ? itemProperty.property[0] : itemProperty.property : null) != null) return `<Annotation type="hover-card" uuid="${linkResource.uuid}">${itemString}</Annotation>`;
+						}
+						return `<InternalLink uuid="${linkResource.uuid}" properties="${itemPropertyLabelUuid}"${itemPropertyValueUuid !== null ? ` value="${itemPropertyValueUuid}"` : ""}>${itemString}</InternalLink>`;
+					} else return `<InternalLink uuid="${linkResource.uuid}">${itemString}</InternalLink>`;
+				} else return `<InternalLink uuid="${linkResource.uuid}">${itemString}</InternalLink>`;
+				case "externalDocument": if (linkResource.publicationDateTime != null) return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkResource.uuid}&load" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+				else return `<TooltipSpan${linkContent !== null ? ` content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+				case "webpage": return `<ExternalLink href="${linkResource.href}" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+				default: return "";
+			}
+		} else if ("concept" in link) {
+			const linkConcept = Array.isArray(link.concept) ? link.concept[0] : link.concept;
+			if (linkConcept.publicationDateTime != null) return `<InternalLink uuid="${linkConcept.uuid}">${itemString}</InternalLink>`;
+			else return `<TooltipSpan>${itemString}</TooltipSpan>`;
+		} else if ("set" in link) {
+			const linkSet = Array.isArray(link.set) ? link.set[0] : link.set;
+			if (linkSet.publicationDateTime != null) return `<InternalLink uuid="${linkSet.uuid}">${itemString}</InternalLink>`;
+			else return `<TooltipSpan>${itemString}</TooltipSpan>`;
+		} else if ("person" in link) {
+			const linkPerson = Array.isArray(link.person) ? link.person[0] : link.person;
+			const linkContent = linkPerson.identification ? [
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof linkPerson.identification.label) ? parseFakeString(linkPerson.identification.label) : parseStringContent(linkPerson.identification.label) : null;
+			if (linkPerson.publicationDateTime != null) return `<InternalLink uuid="${linkPerson.uuid}">${itemString}</InternalLink>`;
+			else return `<TooltipSpan${linkContent !== null ? ` content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+		} else if ("bibliography" in link) {
+			const linkBibliography = Array.isArray(link.bibliography) ? link.bibliography[0] : link.bibliography;
+			if (linkBibliography.publicationDateTime != null) return `<InternalLink uuid="${linkBibliography.uuid}">${itemString}</InternalLink>`;
+			else return `<TooltipSpan>${itemString}</TooltipSpan>`;
+		} else if ("properties" in item && item.properties != null) {
+			const itemProperty = Array.isArray(item.properties.property) ? item.properties.property[0] : item.properties.property;
+			if (itemProperty != null) {
+				const itemPropertyLabelUuid = itemProperty.label.uuid;
+				const itemPropertyValueUuid = typeof itemProperty.value === "object" && "uuid" in itemProperty.value && itemProperty.value.uuid != null ? itemProperty.value.uuid : null;
+				if (itemPropertyLabelUuid === PRESENTATION_ITEM_UUID && itemPropertyValueUuid === TEXT_ANNOTATION_UUID) {
+					const textAnnotationProperty = itemProperty.property != null ? Array.isArray(itemProperty.property) ? itemProperty.property[0] : itemProperty.property : null;
+					if (textAnnotationProperty != null) {
+						if ((typeof textAnnotationProperty.value === "object" && "uuid" in textAnnotationProperty.value && textAnnotationProperty.value.uuid != null ? textAnnotationProperty.value.uuid : null) === TEXT_ANNOTATION_TEXT_STYLING_UUID && textAnnotationProperty.property != null) {
+							const textStylingType = "text-styling";
+							let textStylingVariant = "default";
+							let textStylingSize = "md";
+							let textStylingCss = [];
+							const textStylingProperties = Array.isArray(textAnnotationProperty.property) ? textAnnotationProperty.property : [textAnnotationProperty.property];
+							if (textStylingProperties.length > 0) {
+								const textStylingVariantProperty = textStylingProperties.find((property) => property.label.uuid === TEXT_ANNOTATION_TEXT_STYLING_VARIANT_UUID);
+								if (textStylingVariantProperty != null) {
+									const textStylingPropertyVariant = parseFakeString(textStylingVariantProperty.value.content);
+									const textStylingSizeProperty = textStylingVariantProperty.property != null ? Array.isArray(textStylingVariantProperty.property) ? textStylingVariantProperty.property[0] : textStylingVariantProperty.property : null;
+									if (textStylingSizeProperty != null) textStylingSize = parseFakeString(textStylingSizeProperty.value.content);
+									textStylingVariant = textStylingPropertyVariant;
+								}
+								const textStylingCssProperties = textStylingProperties.filter((property) => property.label.uuid !== TEXT_ANNOTATION_TEXT_STYLING_VARIANT_UUID);
+								if (textStylingCssProperties.length > 0) textStylingCss = textStylingCssProperties.map((property) => ({
+									label: parseFakeString(property.label.content),
+									value: parseFakeString(property.value.content)
+								}));
+							}
+							return `<Annotation type="${textStylingType}" variant="${textStylingVariant}" size="${textStylingSize}"${textStylingCss.length > 0 ? ` cssStyles={{default: ${JSON.stringify(textStylingCss)}, tablet: [], mobile: []}}` : ""}>${itemString}</Annotation>`;
+						}
+					}
+				}
+			}
+		}
+	}
+	let returnString = "";
+	if ("string" in item) {
+		const stringItems = Array.isArray(item.string) ? item.string : [item.string];
+		for (const stringItem of stringItems) returnString += parseStringDocumentItem(stringItem);
+		if ("whitespace" in item && item.whitespace != null) returnString = parseWhitespace(parseEmail(returnString), item.whitespace);
+		return returnString.replaceAll("&#39;", "'");
+	} else {
+		returnString = parseFakeString(item.content);
+		if (item.rend != null) returnString = parseRenderOptions(parseEmail(returnString), item.rend);
+		if (item.whitespace != null) returnString = parseWhitespace(parseEmail(returnString), item.whitespace);
+	}
+	return returnString;
+}
+/**
+* Parses raw string content into a formatted string
+*
+* @param content - Raw string content to parse
+* @param language - Optional language code for content selection (defaults to "eng")
+* @returns Parsed and formatted string
+*/
+function parseStringContent(content, language = "eng") {
+	switch (typeof content.content) {
+		case "string":
+		case "number":
+		case "boolean":
+			if (content.rend != null) return parseRenderOptions(parseFakeString(content.content), content.rend);
+			return parseFakeString(content.content);
+		case "object": if (Array.isArray(content.content)) {
+			const stringItem = getStringItemByLanguage(content.content, language);
+			if (stringItem) return parseStringItem(stringItem);
+			else {
+				const returnStringItem = content.content[0];
+				if (!returnStringItem) throw new Error(`No string item found for language “${language}” in the following content:\n${JSON.stringify(content.content)}.`);
+				return parseStringItem(returnStringItem);
+			}
+		} else return parseStringItem(content.content);
+		default: return String(content.content);
+	}
+}
+
+//#endregion
+//#region src/utils/helpers.ts
+/**
+* Get the category of an item from the OCHRE API response
+* @param keys - The keys of the OCHRE API response
+* @returns The category of the item
+* @internal
+*/
+function getItemCategory(keys) {
+	const categoryFound = keys.find((key) => categorySchema.safeParse(key).success);
+	if (!categoryFound) {
+		const unknownKey = keys.find((key) => ![
+			"uuid",
+			"uuidBelongsTo",
+			"belongsTo",
+			"publicationDateTime",
+			"metadata",
+			"languages"
+		].includes(key));
+		throw new Error(`Invalid OCHRE data; found unexpected "${unknownKey}" key`);
+	}
+	return categorySchema.parse(categoryFound);
+}
+
+//#endregion
+//#region src/utils/parse.ts
+/**
+* Parses raw identification data into the standardized Identification type
+*
+* @param identification - Raw identification data from OCHRE format
+* @returns Parsed Identification object with label and abbreviation
+*/
+function parseIdentification(identification) {
+	try {
+		const returnIdentification = {
+			label: [
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof identification.label) ? parseFakeString(identification.label) : parseStringContent(identification.label),
+			abbreviation: "",
+			code: identification.code ?? null
+		};
+		for (const key of Object.keys(identification).filter((key$1) => key$1 !== "label" && key$1 !== "code")) returnIdentification[key] = typeof identification[key] === "string" ? parseFakeString(identification[key]) : parseStringContent(identification[key]);
+		return returnIdentification;
+	} catch (error) {
+		console.error(error);
+		return {
+			label: "",
+			abbreviation: "",
+			code: null
+		};
+	}
+}
+/**
+* Parses raw language data into an array of language codes
+*
+* @param language - Raw language data, either single or array
+* @returns Array of language codes as strings
+*/
+function parseLanguages(language) {
+	if (language == null) return ["eng"];
+	if (Array.isArray(language)) return language.map((lang) => parseStringContent(lang));
+	else return [parseStringContent(language)];
+}
+/**
+* Parses raw metadata into the standardized Metadata type
+*
+* @param metadata - Raw metadata from OCHRE format
+* @returns Parsed Metadata object
+*/
+function parseMetadata(metadata) {
+	let identification = {
+		label: "",
+		abbreviation: "",
+		code: null
+	};
+	if (metadata.item) if (metadata.item.label || metadata.item.abbreviation) {
+		let label = "";
+		let abbreviation = "";
+		let code = null;
+		if (metadata.item.label) label = parseStringContent(metadata.item.label);
+		if (metadata.item.abbreviation) abbreviation = parseStringContent(metadata.item.abbreviation);
+		if (metadata.item.identification.code) code = metadata.item.identification.code;
+		identification = {
+			label,
+			abbreviation,
+			code
+		};
+	} else identification = parseIdentification(metadata.item.identification);
+	let projectIdentification = null;
+	const baseProjectIdentification = metadata.project?.identification ? parseIdentification(metadata.project.identification) : null;
+	if (baseProjectIdentification) projectIdentification = {
+		...baseProjectIdentification,
+		website: metadata.project?.identification.website ?? null
+	};
+	return {
+		project: projectIdentification ? { identification: projectIdentification } : null,
+		item: metadata.item ? {
+			identification,
+			category: metadata.item.category,
+			type: metadata.item.type,
+			maxLength: metadata.item.maxLength ?? null
+		} : null,
+		dataset: parseStringContent(metadata.dataset),
+		publisher: parseStringContent(metadata.publisher),
+		languages: parseLanguages(metadata.language),
+		identifier: parseStringContent(metadata.identifier),
+		description: parseStringContent(metadata.description)
+	};
+}
+/**
+* Parses raw context item data into the standardized ContextItem type
+*
+* @param contextItem - Raw context item data from OCHRE format
+* @returns Parsed ContextItem object
+*/
+function parseContextItem(contextItem) {
+	return {
+		uuid: contextItem.uuid,
+		publicationDateTime: contextItem.publicationDateTime != null ? new Date(contextItem.publicationDateTime) : null,
+		number: contextItem.n,
+		content: parseFakeString(contextItem.content)
+	};
+}
+/**
+* Parses raw context data into the standardized Context type
+*
+* @param context - Raw context data from OCHRE format
+* @returns Parsed Context object
+*/
+function parseContext(context) {
+	return {
+		nodes: (Array.isArray(context.context) ? context.context : [context.context]).map((context$1) => {
+			const spatialUnit = [];
+			if ("spatialUnit" in context$1 && context$1.spatialUnit) {
+				const contextsToParse = Array.isArray(context$1.spatialUnit) ? context$1.spatialUnit : [context$1.spatialUnit];
+				for (const contextItem of contextsToParse) spatialUnit.push(parseContextItem(contextItem));
+			}
+			return {
+				tree: parseContextItem(context$1.tree),
+				project: parseContextItem(context$1.project),
+				spatialUnit
+			};
+		}),
+		displayPath: context.displayPath
+	};
+}
+/**
+* Parses raw license data into the standardized License type
+*
+* @param license - Raw license data from OCHRE format
+* @returns Parsed License object or null if invalid
+*/
+function parseLicense(license) {
+	if (typeof license.license === "string") return null;
+	return {
+		content: license.license.content,
+		url: license.license.target
+	};
+}
+/**
+* Parses raw person data into the standardized Person type
+*
+* @param person - Raw person data from OCHRE format
+* @returns Parsed Person object
+*/
+function parsePerson(person) {
+	return {
+		uuid: person.uuid,
+		category: "person",
+		publicationDateTime: person.publicationDateTime != null ? new Date(person.publicationDateTime) : null,
+		type: person.type ?? null,
+		number: person.n ?? null,
+		context: person.context ? parseContext(person.context) : null,
+		date: person.date ?? null,
+		identification: person.identification ? parseIdentification(person.identification) : null,
+		availability: person.availability ? parseLicense(person.availability) : null,
+		image: person.image ? parseImage(person.image) : null,
+		address: person.address ? {
+			country: person.address.country ?? null,
+			city: person.address.city ?? null,
+			state: person.address.state ?? null
+		} : null,
+		description: person.description ? typeof person.description === "string" || typeof person.description === "number" || typeof person.description === "boolean" ? parseFakeString(person.description) : parseStringContent(person.description) : null,
+		coordinates: parseCoordinates(person.coordinates),
+		content: person.content != null ? parseFakeString(person.content) : null,
+		notes: person.notes ? parseNotes(Array.isArray(person.notes.note) ? person.notes.note : [person.notes.note]) : [],
+		events: person.events ? parseEvents(Array.isArray(person.events.event) ? person.events.event : [person.events.event]) : [],
+		properties: person.properties ? parseProperties(Array.isArray(person.properties.property) ? person.properties.property : [person.properties.property]) : [],
+		bibliographies: person.bibliographies ? parseBibliographies(Array.isArray(person.bibliographies.bibliography) ? person.bibliographies.bibliography : [person.bibliographies.bibliography]) : []
+	};
+}
+/**
+* Parses raw person data into the standardized Person type
+*
+* @param persons - Array of raw person data from OCHRE format
+* @returns Array of parsed Person objects
+*/
+function parsePersons(persons) {
+	const returnPersons = [];
+	for (const person of persons) returnPersons.push(parsePerson(person));
+	return returnPersons;
+}
+/**
+* Parses an array of raw links into standardized Link objects
+*
+* @param linkRaw - Raw OCHRE link
+* @returns Parsed Link object
+*/
+function parseLink(linkRaw) {
+	const links = "resource" in linkRaw ? linkRaw.resource : "spatialUnit" in linkRaw ? linkRaw.spatialUnit : "concept" in linkRaw ? linkRaw.concept : "set" in linkRaw ? linkRaw.set : "tree" in linkRaw ? linkRaw.tree : "person" in linkRaw ? linkRaw.person : "bibliography" in linkRaw ? linkRaw.bibliography : "propertyValue" in linkRaw ? linkRaw.propertyValue : null;
+	if (!links) throw new Error(`Invalid link provided: ${JSON.stringify(linkRaw, null, 2)}`);
+	const linksToParse = Array.isArray(links) ? links : [links];
+	const returnLinks = [];
+	for (const link of linksToParse) {
+		const returnLink = {
+			category: "resource" in linkRaw ? "resource" : "spatialUnit" in linkRaw ? "spatialUnit" : "concept" in linkRaw ? "concept" : "set" in linkRaw ? "set" : "person" in linkRaw ? "person" : "tree" in linkRaw ? "tree" : "bibliography" in linkRaw ? "bibliography" : "propertyValue" in linkRaw ? "propertyValue" : null,
+			content: "content" in link ? link.content != null ? parseFakeString(link.content) : null : null,
+			href: "href" in link && link.href != null ? link.href : null,
+			fileFormat: "fileFormat" in link && link.fileFormat != null ? link.fileFormat : null,
+			fileSize: "fileSize" in link && link.fileSize != null ? link.fileSize : null,
+			uuid: link.uuid ?? null,
+			type: link.type ?? null,
+			identification: link.identification ? parseIdentification(link.identification) : null,
+			description: "description" in link && link.description != null ? parseStringContent(link.description) : null,
+			image: null,
+			bibliographies: "bibliography" in linkRaw ? parseBibliographies(Array.isArray(linkRaw.bibliography) ? linkRaw.bibliography : [linkRaw.bibliography]) : null,
+			publicationDateTime: link.publicationDateTime != null ? new Date(link.publicationDateTime) : null
+		};
+		if ("height" in link && link.height != null && link.width != null && link.heightPreview != null && link.widthPreview != null) returnLink.image = {
+			isInline: link.rend === "inline",
+			isPrimary: link.isPrimary ?? false,
+			heightPreview: link.heightPreview,
+			widthPreview: link.widthPreview,
+			height: link.height,
+			width: link.width
+		};
+		returnLinks.push(returnLink);
+	}
+	return returnLinks;
+}
+/**
+* Parses an array of raw links into standardized Link objects
+*
+* @param links - Array of raw OCHRE links
+* @returns Array of parsed Link objects
+*/
+function parseLinks(links) {
+	const returnLinks = [];
+	for (const link of links) returnLinks.push(...parseLink(link));
+	return returnLinks;
+}
+/**
+* Parses raw document content into a standardized Document structure
+*
+* @param document - Raw document content in OCHRE format
+* @param language - Language code to use for content selection (defaults to "eng")
+* @returns Parsed Document object with content and footnotes
+*/
+function parseDocument(document, language = "eng") {
+	let returnString = "";
+	const documentWithLanguage = Array.isArray(document) ? document.find((doc) => doc.lang === language) : document;
+	if (typeof documentWithLanguage.string === "string" || typeof documentWithLanguage.string === "number" || typeof documentWithLanguage.string === "boolean") returnString += parseEmail(parseFakeString(documentWithLanguage.string));
+	else {
+		const documentItems = Array.isArray(documentWithLanguage.string) ? documentWithLanguage.string : [documentWithLanguage.string];
+		for (const item of documentItems) returnString += parseStringDocumentItem(item);
+	}
+	return returnString;
+}
+/**
+* Parses raw image data into a standardized Image structure
+*
+* @param image - Raw image data in OCHRE format
+* @returns Parsed Image object or null if invalid
+*/
+function parseImage(image) {
+	return {
+		publicationDateTime: image.publicationDateTime != null ? new Date(image.publicationDateTime) : null,
+		identification: image.identification ? parseIdentification(image.identification) : null,
+		url: image.href ?? (image.htmlImgSrcPrefix == null && image.content != null ? parseFakeString(image.content) : null),
+		htmlPrefix: image.htmlImgSrcPrefix ?? null,
+		content: image.htmlImgSrcPrefix != null && image.content != null ? parseFakeString(image.content) : null,
+		widthPreview: image.widthPreview ?? null,
+		heightPreview: image.heightPreview ?? null,
+		width: image.width ?? null,
+		height: image.height ?? null
+	};
+}
+/**
+* Parses raw notes into standardized Note objects
+*
+* @param notes - Array of raw notes in OCHRE format
+* @param language - Language code for content selection (defaults to "eng")
+* @returns Array of parsed Note objects
+*/
+function parseNotes(notes, language = "eng") {
+	const returnNotes = [];
+	for (const note of notes) {
+		if (typeof note === "string") {
+			if (note === "") continue;
+			returnNotes.push({
+				number: -1,
+				title: null,
+				date: null,
+				authors: [],
+				content: note
+			});
+			continue;
+		}
+		let content = "";
+		const notesToParse = note.content != null ? Array.isArray(note.content) ? note.content : [note.content] : [];
+		if (notesToParse.length === 0) continue;
+		let noteWithLanguage = notesToParse.find((item) => item.lang === language);
+		if (!noteWithLanguage) {
+			noteWithLanguage = notesToParse[0];
+			if (!noteWithLanguage) throw new Error(`Note does not have a valid content item: ${JSON.stringify(note, null, 2)}`);
+		}
+		if (typeof noteWithLanguage.string === "string" || typeof noteWithLanguage.string === "number" || typeof noteWithLanguage.string === "boolean") content = parseEmail(parseFakeString(noteWithLanguage.string));
+		else content = parseEmail(parseDocument(noteWithLanguage));
+		returnNotes.push({
+			number: note.noteNo,
+			title: noteWithLanguage.title != null ? parseFakeString(noteWithLanguage.title) : null,
+			date: note.date ?? null,
+			authors: note.authors ? parsePersons(Array.isArray(note.authors.author) ? note.authors.author : [note.authors.author]) : [],
+			content
+		});
+	}
+	return returnNotes;
+}
+/**
+* Parses raw coordinates data into a standardized Coordinates structure
+*
+* @param coordinates - Raw coordinates data in OCHRE format
+* @returns Parsed Coordinates object
+*/
+function parseCoordinates(coordinates) {
+	if (coordinates == null) return [];
+	const returnCoordinates = [];
+	const coordsToParse = Array.isArray(coordinates.coord) ? coordinates.coord : [coordinates.coord];
+	for (const coord of coordsToParse) {
+		const source = "source" in coord && coord.source ? coord.source.context === "self" ? {
+			context: "self",
+			uuid: coord.source.label.uuid,
+			label: parseStringContent(coord.source.label)
+		} : coord.source.context === "related" ? {
+			context: "related",
+			uuid: coord.source.label.uuid,
+			label: parseStringContent(coord.source.label),
+			value: parseStringContent(coord.source.value)
+		} : {
+			context: "inherited",
+			uuid: coord.source.label.uuid,
+			item: {
+				uuid: coord.source.item.label.uuid,
+				label: parseStringContent(coord.source.item.label)
+			},
+			label: parseStringContent(coord.source.label)
+		} : null;
+		switch (coord.type) {
+			case "point":
+				returnCoordinates.push({
+					type: coord.type,
+					latitude: coord.latitude,
+					longitude: coord.longitude,
+					altitude: coord.altitude ?? null,
+					source
+				});
+				break;
+			case "plane":
+				returnCoordinates.push({
+					type: coord.type,
+					minimum: {
+						latitude: coord.minimum.latitude,
+						longitude: coord.minimum.longitude
+					},
+					maximum: {
+						latitude: coord.maximum.latitude,
+						longitude: coord.maximum.longitude
+					},
+					source
+				});
+				break;
+		}
+	}
+	return returnCoordinates;
+}
+/**
+* Parses a raw observation into a standardized Observation structure
+*
+* @param observation - Raw observation data in OCHRE format
+* @returns Parsed Observation object
+*/
+function parseObservation(observation) {
+	return {
+		number: observation.observationNo,
+		date: observation.date ?? null,
+		observers: observation.observers != null ? typeof observation.observers === "string" || typeof observation.observers === "number" || typeof observation.observers === "boolean" ? parseFakeString(observation.observers).split(";").map((observer) => observer.trim()) : parsePersons(Array.isArray(observation.observers) ? observation.observers : [observation.observers]) : [],
+		notes: observation.notes ? parseNotes(Array.isArray(observation.notes.note) ? observation.notes.note : [observation.notes.note]) : [],
+		links: observation.links ? parseLinks(Array.isArray(observation.links) ? observation.links : [observation.links]) : [],
+		properties: observation.properties ? parseProperties(Array.isArray(observation.properties.property) ? observation.properties.property : [observation.properties.property]) : [],
+		bibliographies: observation.bibliographies ? parseBibliographies(Array.isArray(observation.bibliographies.bibliography) ? observation.bibliographies.bibliography : [observation.bibliographies.bibliography]) : []
+	};
+}
+/**
+* Parses an array of raw observations into standardized Observation objects
+*
+* @param observations - Array of raw observations in OCHRE format
+* @returns Array of parsed Observation objects
+*/
+function parseObservations(observations) {
+	const returnObservations = [];
+	for (const observation of observations) returnObservations.push(parseObservation(observation));
+	return returnObservations;
+}
+/**
+* Parses an array of raw events into standardized Event objects
+*
+* @param events - Array of raw events in OCHRE format
+* @returns Array of parsed Event objects
+*/
+function parseEvents(events) {
+	const returnEvents = [];
+	for (const event of events) returnEvents.push({
+		date: event.dateTime != null ? new Date(event.dateTime) : null,
+		label: parseStringContent(event.label),
+		location: event.location ? {
+			uuid: event.location.uuid,
+			content: parseStringContent(event.location)
+		} : null,
+		agent: event.agent ? {
+			uuid: event.agent.uuid,
+			content: parseStringContent(event.agent)
+		} : null,
+		comment: event.comment ? parseStringContent(event.comment) : null,
+		value: event.value ? parseFakeString(event.value) : null
+	});
+	return returnEvents;
+}
+function parseProperty(property, language = "eng") {
+	const values = ("value" in property && property.value ? Array.isArray(property.value) ? property.value : [property.value] : []).map((value) => {
+		let content = null;
+		let label = null;
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+			content = parseFakeString(value);
+			return {
+				content,
+				label: null,
+				dataType: "string",
+				isUncertain: false,
+				category: "value",
+				type: null,
+				uuid: null,
+				publicationDateTime: null,
+				unit: null,
+				href: null,
+				slug: null
+			};
+		} else {
+			let parsedType = "string";
+			if (value.dataType != null) {
+				const { data, error } = propertyValueContentTypeSchema.safeParse(value.dataType);
+				if (error) throw new Error(`Invalid property value content type: "${value.dataType}"`);
+				parsedType = data;
+			}
+			switch (parsedType) {
+				case "integer":
+				case "decimal":
+				case "time":
+					if (value.rawValue != null) {
+						content = Number(value.rawValue);
+						label = value.content ? parseStringContent({ content: value.content }) : null;
+					} else {
+						content = Number(value.content);
+						label = null;
+					}
+					break;
+				case "boolean":
+					if (value.rawValue != null) {
+						content = value.rawValue === "true";
+						label = value.content ? parseStringContent({ content: value.content }) : null;
+					} else {
+						content = value.content === true;
+						label = null;
+					}
+					break;
+				default:
+					if ("slug" in value && value.slug != null) content = parseFakeString(value.slug);
+					else if (value.content != null) if (value.rawValue != null) {
+						content = parseFakeString(value.rawValue);
+						label = value.content ? parseStringContent({ content: value.content }) : null;
+					} else {
+						content = parseStringContent({ content: value.content });
+						label = null;
+					}
+					break;
+			}
+			return {
+				content,
+				dataType: parsedType,
+				isUncertain: value.isUncertain ?? false,
+				label,
+				category: value.category ?? null,
+				type: value.type ?? null,
+				uuid: value.uuid ?? null,
+				publicationDateTime: value.publicationDateTime != null ? new Date(value.publicationDateTime) : null,
+				unit: value.unit ?? null,
+				href: value.href ?? null,
+				slug: value.slug ?? null
+			};
+		}
+	});
+	return {
+		uuid: property.label.uuid,
+		label: parseStringContent(property.label, language).replace(/\s*\.{3}$/, "").trim(),
+		values,
+		comment: property.comment != null ? parseStringContent(property.comment) : null,
+		properties: property.property ? parseProperties(Array.isArray(property.property) ? property.property : [property.property]) : []
+	};
+}
+/**
+* Parses raw properties into standardized Property objects
+*
+* @param properties - Array of raw properties in OCHRE format
+* @param language - Language code for content selection (defaults to "eng")
+* @returns Array of parsed Property objects
+*/
+function parseProperties(properties, language = "eng") {
+	const returnProperties = [];
+	for (const property of properties) returnProperties.push(parseProperty(property, language));
+	return returnProperties;
+}
+/**
+* Parses raw interpretations into standardized Interpretation objects
+*
+* @param interpretations - Array of raw interpretations in OCHRE format
+* @returns Array of parsed Interpretation objects
+*/
+function parseInterpretations(interpretations) {
+	const returnInterpretations = [];
+	for (const interpretation of interpretations) returnInterpretations.push({
+		date: interpretation.date,
+		number: interpretation.interpretationNo,
+		properties: interpretation.properties ? parseProperties(Array.isArray(interpretation.properties.property) ? interpretation.properties.property : [interpretation.properties.property]) : [],
+		bibliographies: interpretation.bibliographies ? parseBibliographies(Array.isArray(interpretation.bibliographies.bibliography) ? interpretation.bibliographies.bibliography : [interpretation.bibliographies.bibliography]) : []
+	});
+	return returnInterpretations;
+}
+/**
+* Parses raw image map data into a standardized ImageMap structure
+*
+* @param imageMap - Raw image map data in OCHRE format
+* @returns Parsed ImageMap object
+*/
+function parseImageMap(imageMap) {
+	const returnImageMap = {
+		area: [],
+		width: imageMap.width,
+		height: imageMap.height
+	};
+	const imageMapAreasToParse = Array.isArray(imageMap.area) ? imageMap.area : [imageMap.area];
+	for (const area of imageMapAreasToParse) returnImageMap.area.push({
+		uuid: area.uuid,
+		publicationDateTime: area.publicationDateTime != null ? new Date(area.publicationDateTime) : null,
+		type: area.type,
+		title: parseFakeString(area.title),
+		shape: area.shape === "rect" ? "rectangle" : area.shape === "circle" ? "circle" : "polygon",
+		coords: area.coords.split(",").map((coord) => Number.parseInt(coord)),
+		slug: area.slug ? parseFakeString(area.slug) : null
+	});
+	return returnImageMap;
+}
+/**
+* Parses raw period data into a standardized Period structure
+*
+* @param period - Raw period data in OCHRE format
+* @returns Parsed Period object
+*/
+function parsePeriod(period) {
+	return {
+		uuid: period.uuid,
+		category: "period",
+		publicationDateTime: period.publicationDateTime != null ? new Date(period.publicationDateTime) : null,
+		type: period.type ?? null,
+		number: period.n ?? null,
+		identification: parseIdentification(period.identification),
+		description: period.description ? parseStringContent(period.description) : null
+	};
+}
+/**
+* Parses an array of raw periods into standardized Period objects
+*
+* @param periods - Array of raw periods in OCHRE format
+* @returns Array of parsed Period objects
+*/
+function parsePeriods(periods) {
+	const returnPeriods = [];
+	for (const period of periods) returnPeriods.push(parsePeriod(period));
+	return returnPeriods;
+}
+/**
+* Parses raw bibliography data into a standardized Bibliography structure
+*
+* @param bibliography - Raw bibliography data in OCHRE format
+* @returns Parsed Bibliography object
+*/
+function parseBibliography(bibliography) {
+	let resource = null;
+	if (bibliography.source?.resource) resource = {
+		uuid: bibliography.source.resource.uuid,
+		publicationDateTime: bibliography.source.resource.publicationDateTime ? new Date(bibliography.source.resource.publicationDateTime) : null,
+		type: bibliography.source.resource.type,
+		identification: parseIdentification(bibliography.source.resource.identification)
+	};
+	let shortCitation = null;
+	let longCitation = null;
+	if (bibliography.citationFormatSpan) try {
+		shortCitation = JSON.parse(`"${bibliography.citationFormatSpan}"`).replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+	} catch {
+		shortCitation = bibliography.citationFormatSpan;
+	}
+	if (bibliography.referenceFormatDiv) try {
+		longCitation = JSON.parse(`"${bibliography.referenceFormatDiv}"`).replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+	} catch {
+		longCitation = bibliography.referenceFormatDiv;
+	}
+	return {
+		uuid: bibliography.uuid ?? null,
+		zoteroId: bibliography.zoteroId ?? null,
+		category: "bibliography",
+		publicationDateTime: bibliography.publicationDateTime != null ? new Date(bibliography.publicationDateTime) : null,
+		type: bibliography.type ?? null,
+		number: bibliography.n ?? null,
+		identification: bibliography.identification ? parseIdentification(bibliography.identification) : null,
+		projectIdentification: bibliography.project?.identification ? parseIdentification(bibliography.project.identification) : null,
+		context: bibliography.context ? parseContext(bibliography.context) : null,
+		citation: {
+			details: bibliography.citationDetails ?? null,
+			format: bibliography.citationFormat ?? null,
+			short: shortCitation,
+			long: longCitation
+		},
+		publicationInfo: {
+			publishers: bibliography.publicationInfo?.publishers ? parsePersons(Array.isArray(bibliography.publicationInfo.publishers.publishers.person) ? bibliography.publicationInfo.publishers.publishers.person : [bibliography.publicationInfo.publishers.publishers.person]) : [],
+			startDate: bibliography.publicationInfo?.startDate ? new Date(bibliography.publicationInfo.startDate.year, bibliography.publicationInfo.startDate.month, bibliography.publicationInfo.startDate.day) : null
+		},
+		entryInfo: bibliography.entryInfo ? {
+			startIssue: parseFakeString(bibliography.entryInfo.startIssue),
+			startVolume: parseFakeString(bibliography.entryInfo.startVolume)
+		} : null,
+		source: {
+			resource,
+			documentUrl: bibliography.sourceDocument ? `https://ochre.lib.uchicago.edu/ochre?uuid=${bibliography.sourceDocument.uuid}&load` : null
+		},
+		periods: bibliography.periods ? parsePeriods(Array.isArray(bibliography.periods.period) ? bibliography.periods.period : [bibliography.periods.period]) : [],
+		authors: bibliography.authors ? parsePersons(Array.isArray(bibliography.authors.person) ? bibliography.authors.person : [bibliography.authors.person]) : [],
+		properties: bibliography.properties ? parseProperties(Array.isArray(bibliography.properties.property) ? bibliography.properties.property : [bibliography.properties.property]) : []
+	};
+}
+/**
+* Parses an array of raw bibliographies into standardized Bibliography objects
+*
+* @param bibliographies - Array of raw bibliographies in OCHRE format
+* @returns Array of parsed Bibliography objects
+*/
+function parseBibliographies(bibliographies) {
+	const returnBibliographies = [];
+	for (const bibliography of bibliographies) returnBibliographies.push(parseBibliography(bibliography));
+	return returnBibliographies;
+}
+/**
+* Parses raw property value data into a standardized PropertyValue structure
+*
+* @param propertyValue - Raw property value data in OCHRE format
+* @returns Parsed PropertyValue object
+*/
+function parsePropertyValue(propertyValue) {
+	return {
+		uuid: propertyValue.uuid,
+		category: "propertyValue",
+		number: propertyValue.n,
+		publicationDateTime: propertyValue.publicationDateTime ? new Date(propertyValue.publicationDateTime) : null,
+		context: propertyValue.context ? parseContext(propertyValue.context) : null,
+		availability: propertyValue.availability ? parseLicense(propertyValue.availability) : null,
+		identification: parseIdentification(propertyValue.identification),
+		date: propertyValue.date ?? null,
+		creators: propertyValue.creators ? parsePersons(Array.isArray(propertyValue.creators.creator) ? propertyValue.creators.creator : [propertyValue.creators.creator]) : [],
+		description: propertyValue.description ? typeof propertyValue.description === "string" || typeof propertyValue.description === "number" || typeof propertyValue.description === "boolean" ? parseFakeString(propertyValue.description) : parseStringContent(propertyValue.description) : "",
+		notes: propertyValue.notes ? parseNotes(Array.isArray(propertyValue.notes.note) ? propertyValue.notes.note : [propertyValue.notes.note]) : [],
+		links: propertyValue.links ? parseLinks(Array.isArray(propertyValue.links) ? propertyValue.links : [propertyValue.links]) : []
+	};
+}
+/**
+* Parses an array of raw property values into standardized PropertyValue objects
+*
+* @param propertyValues - Array of raw property values in OCHRE format
+* @returns Array of parsed PropertyValue objects
+*/
+function parsePropertyValues(propertyValues) {
+	const returnPropertyValues = [];
+	for (const propertyValue of propertyValues) returnPropertyValues.push(parsePropertyValue(propertyValue));
+	return returnPropertyValues;
+}
+/**
+* Parses a raw tree structure into a standardized Tree object
+*
+* @param tree - Raw tree data in OCHRE format
+* @returns Parsed Tree object or null if invalid
+*/
+function parseTree(tree, itemCategory, itemSubCategory) {
+	if (typeof tree.items === "string") throw new TypeError("Invalid OCHRE data: Tree has no items");
+	let creators = [];
+	if (tree.creators) creators = parsePersons(Array.isArray(tree.creators.creator) ? tree.creators.creator : [tree.creators.creator]);
+	let date = null;
+	if (tree.date != null) date = tree.date;
+	const parsedItemCategory = itemSubCategory ?? getItemCategory(Object.keys(tree.items));
+	let items = [];
+	switch (parsedItemCategory) {
+		case "resource":
+			if (!("resource" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no resources");
+			items = parseResources(Array.isArray(tree.items.resource) ? tree.items.resource : [tree.items.resource]);
+			break;
+		case "spatialUnit":
+			if (!("spatialUnit" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no spatial units");
+			items = parseSpatialUnits(Array.isArray(tree.items.spatialUnit) ? tree.items.spatialUnit : [tree.items.spatialUnit]);
+			break;
+		case "concept":
+			if (!("concept" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no concepts");
+			items = parseConcepts(Array.isArray(tree.items.concept) ? tree.items.concept : [tree.items.concept]);
+			break;
+		case "period":
+			if (!("period" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no periods");
+			items = parsePeriods(Array.isArray(tree.items.period) ? tree.items.period : [tree.items.period]);
+			break;
+		case "bibliography":
+			if (!("bibliography" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no bibliographies");
+			items = parseBibliographies(Array.isArray(tree.items.bibliography) ? tree.items.bibliography : [tree.items.bibliography]);
+			break;
+		case "person":
+			if (!("person" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no persons");
+			items = parsePersons(Array.isArray(tree.items.person) ? tree.items.person : [tree.items.person]);
+			break;
+		case "propertyValue":
+			if (!("propertyValue" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no property values");
+			items = parsePropertyValues(Array.isArray(tree.items.propertyValue) ? tree.items.propertyValue : [tree.items.propertyValue]);
+			break;
+		case "set": {
+			if (!("set" in tree.items)) throw new Error("Invalid OCHRE data: Tree has no sets");
+			const setItems = [];
+			for (const item of Array.isArray(tree.items.set) ? tree.items.set : [tree.items.set]) setItems.push(parseSet(item, itemSubCategory));
+			items = setItems;
+			break;
+		}
+		default: throw new Error("Invalid OCHRE data: Tree has no items or is malformed");
+	}
+	return {
+		uuid: tree.uuid,
+		category: "tree",
+		publicationDateTime: new Date(tree.publicationDateTime),
+		identification: parseIdentification(tree.identification),
+		creators,
+		license: parseLicense(tree.availability),
+		date,
+		type: tree.type,
+		number: tree.n,
+		items,
+		properties: tree.properties ? parseProperties(Array.isArray(tree.properties.property) ? tree.properties.property : [tree.properties.property]) : []
+	};
+}
+/**
+* Parses raw set data into a standardized Set structure
+*
+* @param set - Raw set data in OCHRE format
+* @returns Parsed Set object
+*/
+function parseSet(set, itemCategory) {
+	if (typeof set.items === "string") throw new TypeError("Invalid OCHRE data: Set has no items");
+	const parsedItemCategory = itemCategory ?? getItemCategory(Object.keys(set.items));
+	let items = [];
+	switch (parsedItemCategory) {
+		case "resource":
+			if (!("resource" in set.items)) throw new Error("Invalid OCHRE data: Set has no resources");
+			items = parseResources(Array.isArray(set.items.resource) ? set.items.resource : [set.items.resource]);
+			break;
+		case "spatialUnit":
+			if (!("spatialUnit" in set.items)) throw new Error("Invalid OCHRE data: Set has no spatial units");
+			items = parseSpatialUnits(Array.isArray(set.items.spatialUnit) ? set.items.spatialUnit : [set.items.spatialUnit]);
+			break;
+		case "concept":
+			if (!("concept" in set.items)) throw new Error("Invalid OCHRE data: Set has no concepts");
+			items = parseConcepts(Array.isArray(set.items.concept) ? set.items.concept : [set.items.concept]);
+			break;
+		case "period":
+			if (!("period" in set.items)) throw new Error("Invalid OCHRE data: Set has no periods");
+			items = parsePeriods(Array.isArray(set.items.period) ? set.items.period : [set.items.period]);
+			break;
+		case "bibliography":
+			if (!("bibliography" in set.items)) throw new Error("Invalid OCHRE data: Set has no bibliographies");
+			items = parseBibliographies(Array.isArray(set.items.bibliography) ? set.items.bibliography : [set.items.bibliography]);
+			break;
+		case "person":
+			if (!("person" in set.items)) throw new Error("Invalid OCHRE data: Set has no persons");
+			items = parsePersons(Array.isArray(set.items.person) ? set.items.person : [set.items.person]);
+			break;
+		case "propertyValue":
+			if (!("propertyValue" in set.items)) throw new Error("Invalid OCHRE data: Set has no property values");
+			items = parsePropertyValues(Array.isArray(set.items.propertyValue) ? set.items.propertyValue : [set.items.propertyValue]);
+			break;
+		default: throw new Error("Invalid OCHRE data: Set has no items or is malformed");
+	}
+	return {
+		uuid: set.uuid,
+		category: "set",
+		itemCategory,
+		publicationDateTime: set.publicationDateTime ? new Date(set.publicationDateTime) : null,
+		date: set.date ?? null,
+		license: parseLicense(set.availability),
+		identification: parseIdentification(set.identification),
+		isSuppressingBlanks: set.suppressBlanks ?? false,
+		description: set.description ? [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof set.description) ? parseFakeString(set.description) : parseStringContent(set.description) : "",
+		creators: set.creators ? parsePersons(Array.isArray(set.creators.creator) ? set.creators.creator : [set.creators.creator]) : [],
+		type: set.type,
+		number: set.n,
+		items
+	};
+}
+/**
+* Parses raw resource data into a standardized Resource structure
+*
+* @param resource - Raw resource data in OCHRE format
+* @returns Parsed Resource object
+*/
+function parseResource(resource) {
+	return {
+		uuid: resource.uuid,
+		category: "resource",
+		publicationDateTime: resource.publicationDateTime ? new Date(resource.publicationDateTime) : null,
+		type: resource.type,
+		number: resource.n,
+		fileFormat: resource.fileFormat ?? null,
+		fileSize: resource.fileSize ?? null,
+		context: "context" in resource && resource.context ? parseContext(resource.context) : null,
+		license: "availability" in resource && resource.availability ? parseLicense(resource.availability) : null,
+		copyright: "copyright" in resource && resource.copyright != null ? parseStringContent(resource.copyright) : null,
+		watermark: "watermark" in resource && resource.watermark != null ? parseStringContent(resource.watermark) : null,
+		identification: parseIdentification(resource.identification),
+		date: resource.date ?? null,
+		image: resource.image ? parseImage(resource.image) : null,
+		creators: resource.creators ? parsePersons(Array.isArray(resource.creators.creator) ? resource.creators.creator : [resource.creators.creator]) : [],
+		notes: resource.notes ? parseNotes(Array.isArray(resource.notes.note) ? resource.notes.note : [resource.notes.note]) : [],
+		description: resource.description ? [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof resource.description) ? parseFakeString(resource.description) : parseStringContent(resource.description) : "",
+		coordinates: resource.coordinates ? parseCoordinates(resource.coordinates) : [],
+		document: resource.document && "content" in resource.document ? parseDocument(resource.document.content) : null,
+		href: resource.href ?? null,
+		imageMap: resource.imagemap ? parseImageMap(resource.imagemap) : null,
+		periods: resource.periods ? parsePeriods(Array.isArray(resource.periods.period) ? resource.periods.period : [resource.periods.period]) : [],
+		links: resource.links ? parseLinks(Array.isArray(resource.links) ? resource.links : [resource.links]) : [],
+		reverseLinks: resource.reverseLinks ? parseLinks(Array.isArray(resource.reverseLinks) ? resource.reverseLinks : [resource.reverseLinks]) : [],
+		properties: resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : [],
+		bibliographies: resource.bibliographies ? parseBibliographies(Array.isArray(resource.bibliographies.bibliography) ? resource.bibliographies.bibliography : [resource.bibliographies.bibliography]) : [],
+		resources: resource.resource ? parseResources(Array.isArray(resource.resource) ? resource.resource : [resource.resource]) : []
+	};
+}
+/**
+* Parses raw resource data into a standardized Resource structure
+*
+* @param resources - Raw resource data in OCHRE format
+* @returns Parsed Resource object
+*/
+function parseResources(resources) {
+	const returnResources = [];
+	const resourcesToParse = Array.isArray(resources) ? resources : [resources];
+	for (const resource of resourcesToParse) returnResources.push(parseResource(resource));
+	return returnResources;
+}
+/**
+* Parses raw spatial units into standardized SpatialUnit objects
+*
+* @param spatialUnit - Raw spatial unit in OCHRE format
+* @returns Parsed SpatialUnit object
+*/
+function parseSpatialUnit(spatialUnit) {
+	return {
+		uuid: spatialUnit.uuid,
+		category: "spatialUnit",
+		publicationDateTime: spatialUnit.publicationDateTime != null ? new Date(spatialUnit.publicationDateTime) : null,
+		number: spatialUnit.n,
+		context: "context" in spatialUnit && spatialUnit.context ? parseContext(spatialUnit.context) : null,
+		license: "availability" in spatialUnit && spatialUnit.availability ? parseLicense(spatialUnit.availability) : null,
+		identification: parseIdentification(spatialUnit.identification),
+		image: spatialUnit.image ? parseImage(spatialUnit.image) : null,
+		description: spatialUnit.description ? [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof spatialUnit.description) ? parseFakeString(spatialUnit.description) : parseStringContent(spatialUnit.description) : "",
+		coordinates: parseCoordinates(spatialUnit.coordinates),
+		mapData: spatialUnit.mapData ?? null,
+		observations: "observations" in spatialUnit && spatialUnit.observations ? parseObservations(Array.isArray(spatialUnit.observations.observation) ? spatialUnit.observations.observation : [spatialUnit.observations.observation]) : spatialUnit.observation ? [parseObservation(spatialUnit.observation)] : [],
+		events: "events" in spatialUnit && spatialUnit.events ? parseEvents(Array.isArray(spatialUnit.events.event) ? spatialUnit.events.event : [spatialUnit.events.event]) : [],
+		properties: "properties" in spatialUnit && spatialUnit.properties ? parseProperties(Array.isArray(spatialUnit.properties.property) ? spatialUnit.properties.property : [spatialUnit.properties.property]) : [],
+		bibliographies: spatialUnit.bibliographies ? parseBibliographies(Array.isArray(spatialUnit.bibliographies.bibliography) ? spatialUnit.bibliographies.bibliography : [spatialUnit.bibliographies.bibliography]) : []
+	};
+}
+/**
+* Parses an array of raw spatial units into standardized SpatialUnit objects
+*
+* @param spatialUnits - Array of raw spatial units in OCHRE format
+* @returns Array of parsed SpatialUnit objects
+*/
+function parseSpatialUnits(spatialUnits) {
+	const returnSpatialUnits = [];
+	const spatialUnitsToParse = Array.isArray(spatialUnits) ? spatialUnits : [spatialUnits];
+	for (const spatialUnit of spatialUnitsToParse) returnSpatialUnits.push(parseSpatialUnit(spatialUnit));
+	return returnSpatialUnits;
+}
+/**
+* Parses a raw concept into a standardized Concept object
+*
+* @param concept - Raw concept data in OCHRE format
+* @returns Parsed Concept object
+*/
+function parseConcept(concept) {
+	return {
+		uuid: concept.uuid,
+		category: "concept",
+		publicationDateTime: concept.publicationDateTime ? new Date(concept.publicationDateTime) : null,
+		number: concept.n,
+		license: "availability" in concept && concept.availability ? parseLicense(concept.availability) : null,
+		context: "context" in concept && concept.context ? parseContext(concept.context) : null,
+		identification: parseIdentification(concept.identification),
+		image: concept.image ? parseImage(concept.image) : null,
+		description: concept.description ? parseStringContent(concept.description) : null,
+		interpretations: concept.interpretations ? parseInterpretations(Array.isArray(concept.interpretations.interpretation) ? concept.interpretations.interpretation : [concept.interpretations.interpretation]) : [],
+		properties: concept.properties ? parseProperties(Array.isArray(concept.properties.property) ? concept.properties.property : [concept.properties.property]) : [],
+		bibliographies: concept.bibliographies ? parseBibliographies(Array.isArray(concept.bibliographies.bibliography) ? concept.bibliographies.bibliography : [concept.bibliographies.bibliography]) : []
+	};
+}
+/**
+* Parses raw webpage resources into standardized WebElement or Webpage objects
+*
+* @param webpageResources - Array of raw webpage resources in OCHRE format
+* @param type - Type of resource to parse ("element" or "page")
+* @returns Array of parsed WebElement or Webpage objects
+*/
+const parseWebpageResources = (webpageResources, type) => {
+	const returnElements = [];
+	for (const resource of webpageResources) {
+		if (!(resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : []).find((property) => property.label === "presentation" && property.values[0].content === type)) continue;
+		switch (type) {
+			case "element": {
+				const element = parseWebElement(resource);
+				returnElements.push(element);
+				break;
+			}
+			case "page": {
+				const webpage = parseWebpage(resource);
+				if (webpage) returnElements.push(webpage);
+				break;
+			}
+			case "block": {
+				const block = parseWebBlock(resource);
+				if (block) returnElements.push(block);
+				break;
+			}
+		}
+	}
+	return returnElements;
+};
+/**
+* Parses raw concept data into standardized Concept objects
+*
+* @param concepts - Array of raw concept data in OCHRE format
+* @returns Array of parsed Concept objects
+*/
+function parseConcepts(concepts) {
+	const returnConcepts = [];
+	const conceptsToParse = Array.isArray(concepts) ? concepts : [concepts];
+	for (const concept of conceptsToParse) returnConcepts.push(parseConcept(concept));
+	return returnConcepts;
+}
+/**
+* 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) {
+	const unparsedComponentName = componentProperty.values[0].content;
+	const { data: componentName } = componentSchema.safeParse(unparsedComponentName);
+	const properties = { component: componentName };
+	const links = elementResource.links ? parseLinks(Array.isArray(elementResource.links) ? elementResource.links : [elementResource.links]) : [];
+	switch (componentName) {
+		case "annotated-document": {
+			const documentLink = links.find((link) => link.type === "internalDocument");
+			if (!documentLink) throw new Error(`Document link not found for the following component: “${componentName}”`);
+			properties.documentId = documentLink.uuid;
+			break;
+		}
+		case "annotated-image": {
+			const imageLinks = links.filter((link) => link.type === "image" || link.type === "IIIF");
+			if (imageLinks.length === 0) throw new Error(`Image link not found for the following component: “${componentName}”`);
+			const isFilterDisplayed = getPropertyValueByLabel(componentProperty.properties, "filter-displayed") === true;
+			const isOptionsDisplayed = getPropertyValueByLabel(componentProperty.properties, "options-displayed") !== false;
+			const isAnnotationHighlightsDisplayed = getPropertyValueByLabel(componentProperty.properties, "annotation-highlights-displayed") !== false;
+			const isAnnotationTooltipsDisplayed = getPropertyValueByLabel(componentProperty.properties, "annotation-tooltips-displayed") !== false;
+			properties.imageUuid = imageLinks[0].uuid;
+			properties.isFilterDisplayed = isFilterDisplayed;
+			properties.isOptionsDisplayed = isOptionsDisplayed;
+			properties.isAnnotationHighlightsDisplayed = isAnnotationHighlightsDisplayed;
+			properties.isAnnotationTooltipsDisplayed = isAnnotationTooltipsDisplayed;
+			break;
+		}
+		case "audio-player": {
+			const audioLink = links.find((link) => link.type === "audio");
+			if (!audioLink) throw new Error(`Audio link not found for the following component: “${componentName}”`);
+			let isSpeedControlsDisplayed = false;
+			const isSpeedControlsDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "speed-controls-displayed");
+			if (isSpeedControlsDisplayedProperty !== null) isSpeedControlsDisplayed = isSpeedControlsDisplayedProperty === true;
+			let isVolumeControlsDisplayed = false;
+			const isVolumeControlsDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "volume-controls-displayed");
+			if (isVolumeControlsDisplayedProperty !== null) isVolumeControlsDisplayed = isVolumeControlsDisplayedProperty === true;
+			let isSeekBarDisplayed = false;
+			const isSeekBarDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "seek-bar-displayed");
+			if (isSeekBarDisplayedProperty !== null) isSeekBarDisplayed = isSeekBarDisplayedProperty === true;
+			properties.audioId = audioLink.uuid;
+			properties.isSpeedControlsDisplayed = isSpeedControlsDisplayed;
+			properties.isVolumeControlsDisplayed = isVolumeControlsDisplayed;
+			properties.isSeekBarDisplayed = isSeekBarDisplayed;
+			break;
+		}
+		case "bibliography": {
+			const itemLinks = links.filter((link) => link.category !== "bibliography");
+			const bibliographyLink = links.find((link) => link.category === "bibliography");
+			if (itemLinks.length === 0 && bibliographyLink?.bibliographies == null) throw new Error(`No links found for the following component: “${componentName}”`);
+			let layout = getPropertyValueByLabel(componentProperty.properties, "layout");
+			layout ??= "long";
+			let isSourceDocumentDisplayed = true;
+			const isSourceDocumentDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "source-document-displayed");
+			if (isSourceDocumentDisplayedProperty !== null) isSourceDocumentDisplayed = isSourceDocumentDisplayedProperty === true;
+			properties.itemUuids = itemLinks.map((link) => link.uuid).filter((uuid) => uuid !== null);
+			properties.bibliographies = bibliographyLink?.bibliographies ?? [];
+			properties.layout = layout;
+			properties.isSourceDocumentDisplayed = isSourceDocumentDisplayed;
+			break;
+		}
+		case "button": {
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "default";
+			let isExternal = false;
+			const navigateToProperty = getPropertyByLabel(componentProperty.properties, "navigate-to");
+			let href = navigateToProperty?.values[0]?.href ?? navigateToProperty?.values[0]?.slug ?? null;
+			if (href === null) {
+				const linkToProperty = getPropertyByLabel(componentProperty.properties, "link-to");
+				href = linkToProperty?.values[0]?.href ?? linkToProperty?.values[0]?.slug ?? null;
+				if (href === null) throw new Error(`Properties “navigate-to” or “link-to” not found for the following component: “${componentName}”`);
+				else isExternal = true;
+			}
+			let startIcon = null;
+			const startIconProperty = getPropertyValueByLabel(componentProperty.properties, "start-icon");
+			if (startIconProperty !== null) startIcon = startIconProperty;
+			let endIcon = null;
+			const endIconProperty = getPropertyValueByLabel(componentProperty.properties, "end-icon");
+			if (endIconProperty !== null) endIcon = endIconProperty;
+			let image = null;
+			const imageLink = links.find((link) => link.type === "image" || link.type === "IIIF");
+			if (imageLink != null) image = {
+				url: `https://ochre.lib.uchicago.edu/ochre?uuid=${imageLink.uuid}&load`,
+				label: imageLink.identification?.label ?? null,
+				width: imageLink.image?.width ?? 0,
+				height: imageLink.image?.height ?? 0,
+				description: imageLink.description ?? null
+			};
+			properties.variant = variant;
+			properties.href = href;
+			properties.isExternal = isExternal;
+			properties.label = elementResource.document && "content" in elementResource.document ? parseDocument(elementResource.document.content) : null;
+			properties.startIcon = startIcon;
+			properties.endIcon = endIcon;
+			properties.image = image;
+			break;
+		}
+		case "collection": {
+			const collectionLink = links.find((link) => link.category === "set");
+			if (!collectionLink) throw new Error(`Collection link not found for the following component: “${componentName}”`);
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "full";
+			let itemVariant = getPropertyValueByLabel(componentProperty.properties, "item-variant");
+			itemVariant ??= "detailed";
+			let paginationVariant = getPropertyValueByLabel(componentProperty.properties, "pagination-variant");
+			paginationVariant ??= "default";
+			let isSortDisplayed = false;
+			const isSortDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "sort-displayed");
+			if (isSortDisplayedProperty !== null) isSortDisplayed = isSortDisplayedProperty === true;
+			let isFilterDisplayed = false;
+			const isFilterDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "filter-displayed");
+			if (isFilterDisplayedProperty !== null) isFilterDisplayed = isFilterDisplayedProperty === true;
+			let filterSort = getPropertyValueByLabel(componentProperty.properties, "filter-sort");
+			filterSort ??= "default";
+			let layout = getPropertyValueByLabel(componentProperty.properties, "layout");
+			layout ??= "image-start";
+			properties.collectionId = collectionLink.uuid;
+			properties.variant = variant;
+			properties.itemVariant = itemVariant;
+			properties.paginationVariant = paginationVariant;
+			properties.isSortDisplayed = isSortDisplayed;
+			properties.isFilterDisplayed = isFilterDisplayed;
+			properties.filterSort = filterSort;
+			properties.layout = layout;
+			break;
+		}
+		case "empty-space": {
+			const height = getPropertyValueByLabel(componentProperty.properties, "height");
+			const width = getPropertyValueByLabel(componentProperty.properties, "width");
+			properties.height = height;
+			properties.width = width;
+			break;
+		}
+		case "entries": {
+			const entriesLink = links.find((link) => link.category === "tree" || link.category === "set");
+			if (!entriesLink) throw new Error(`Entries link not found for the following component: “${componentName}”`);
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "entry";
+			let isFilterDisplayed = false;
+			const isFilterDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "filter-displayed");
+			if (isFilterDisplayedProperty !== null) isFilterDisplayed = isFilterDisplayedProperty === true;
+			properties.entriesId = entriesLink.uuid;
+			properties.variant = variant;
+			properties.isFilterDisplayed = isFilterDisplayed;
+			break;
+		}
+		case "iframe": {
+			const href = links.find((link) => link.type === "webpage")?.href;
+			if (!href) throw new Error(`URL not found for the following component: “${componentName}”`);
+			const height = getPropertyValueByLabel(componentProperty.properties, "height");
+			const width = getPropertyValueByLabel(componentProperty.properties, "width");
+			properties.href = href;
+			properties.height = height;
+			properties.width = width;
+			break;
+		}
+		case "iiif-viewer": {
+			const manifestLink = links.find((link) => link.type === "IIIF");
+			if (!manifestLink) throw new Error(`Manifest link not found for the following component: “${componentName}”`);
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "universal-viewer";
+			properties.iiifId = manifestLink.uuid;
+			properties.variant = variant;
+			break;
+		}
+		case "image": {
+			if (links.length === 0) throw new Error(`No links found for the following component: “${componentName}”`);
+			let imageQuality = getPropertyValueByLabel(componentProperty.properties, "quality");
+			imageQuality ??= "high";
+			const images = [];
+			for (const link of links) images.push({
+				url: `https://ochre.lib.uchicago.edu/ochre?uuid=${link.uuid}${imageQuality === "high" && (link.type === "image" || link.type === "IIIF") ? "&load" : "&preview"}`,
+				label: link.identification?.label ?? null,
+				width: link.image?.width ?? 0,
+				height: link.image?.height ?? 0,
+				description: link.description ?? null
+			});
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "default";
+			let captionLayout = getPropertyValueByLabel(componentProperty.properties, "layout-caption");
+			captionLayout ??= "bottom";
+			let width = null;
+			const widthProperty = getPropertyValueByLabel(componentProperty.properties, "width");
+			if (widthProperty !== null) {
+				if (typeof widthProperty === "number") width = widthProperty;
+				else if (typeof widthProperty === "string") width = Number.parseFloat(widthProperty);
+			}
+			let height = null;
+			const heightProperty = getPropertyValueByLabel(componentProperty.properties, "height");
+			if (heightProperty !== null) {
+				if (typeof heightProperty === "number") height = heightProperty;
+				else if (typeof heightProperty === "string") height = Number.parseFloat(heightProperty);
+			}
+			let isFullWidth = true;
+			const isFullWidthProperty = getPropertyValueByLabel(componentProperty.properties, "is-full-width");
+			if (isFullWidthProperty !== null) isFullWidth = isFullWidthProperty === true;
+			let isFullHeight = true;
+			const isFullHeightProperty = getPropertyValueByLabel(componentProperty.properties, "is-full-height");
+			if (isFullHeightProperty !== null) isFullHeight = isFullHeightProperty === true;
+			let captionSource = getPropertyValueByLabel(componentProperty.properties, "caption-source");
+			captionSource ??= "name";
+			let altTextSource = getPropertyValueByLabel(componentProperty.properties, "alt-text-source");
+			altTextSource ??= "name";
+			let isTransparentBackground = false;
+			const isTransparentBackgroundProperty = getPropertyValueByLabel(componentProperty.properties, "is-transparent");
+			if (isTransparentBackgroundProperty !== null) isTransparentBackground = isTransparentBackgroundProperty === true;
+			let isCover = false;
+			const isCoverProperty = getPropertyValueByLabel(componentProperty.properties, "is-cover");
+			if (isCoverProperty !== null) isCover = isCoverProperty === true;
+			const variantProperty = getPropertyByLabel(componentProperty.properties, "variant");
+			let carouselOptions = null;
+			if (images.length > 1) {
+				let secondsPerImage = 5;
+				if (variantProperty?.values[0].content === "carousel") {
+					const secondsPerImageProperty = getPropertyValueByLabel(variantProperty.properties, "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 (variantProperty?.values[0].content === "hero") {
+				const isBackgroundImageDisplayedProperty = getPropertyValueByLabel(variantProperty.properties, "background-image-displayed");
+				const isDocumentDisplayedProperty = getPropertyValueByLabel(variantProperty.properties, "document-displayed");
+				const isLinkDisplayedProperty = getPropertyValueByLabel(variantProperty.properties, "link-displayed");
+				heroOptions = {
+					isBackgroundImageDisplayed: isBackgroundImageDisplayedProperty !== false,
+					isDocumentDisplayed: isDocumentDisplayedProperty !== false,
+					isLinkDisplayed: isLinkDisplayedProperty !== false
+				};
+			}
+			properties.images = images;
+			properties.variant = variant;
+			properties.width = width;
+			properties.height = height;
+			properties.isFullWidth = isFullWidth;
+			properties.isFullHeight = isFullHeight;
+			properties.imageQuality = imageQuality;
+			properties.captionLayout = captionLayout;
+			properties.captionSource = captionSource;
+			properties.altTextSource = altTextSource;
+			properties.isTransparentBackground = isTransparentBackground;
+			properties.isCover = isCover;
+			properties.carouselOptions = carouselOptions;
+			properties.heroOptions = heroOptions;
+			break;
+		}
+		case "image-gallery": {
+			const galleryLink = links.find((link) => link.category === "tree" || link.category === "set");
+			if (!galleryLink) throw new Error(`Image gallery link not found for the following component: “${componentName}”`);
+			const isFilterDisplayed = getPropertyValueByLabel(componentProperty.properties, "filter-displayed") === true;
+			properties.galleryId = galleryLink.uuid;
+			properties.isFilterDisplayed = isFilterDisplayed;
+			break;
+		}
+		case "map": {
+			const mapLink = links.find((link) => link.category === "set" || link.category === "tree");
+			if (!mapLink) throw new Error(`Map link not found for the following component: “${componentName}”`);
+			let isInteractive = true;
+			const isInteractiveProperty = getPropertyValueByLabel(componentProperty.properties, "is-interactive");
+			if (isInteractiveProperty !== null) isInteractive = isInteractiveProperty === true;
+			let isClustered = false;
+			const isClusteredProperty = getPropertyValueByLabel(componentProperty.properties, "is-clustered");
+			if (isClusteredProperty !== null) isClustered = isClusteredProperty === true;
+			let isUsingPins = false;
+			const isUsingPinsProperty = getPropertyValueByLabel(componentProperty.properties, "is-using-pins");
+			if (isUsingPinsProperty !== null) isUsingPins = isUsingPinsProperty === true;
+			let customBasemap = null;
+			const customBasemapProperty = getPropertyValueByLabel(componentProperty.properties, "custom-basemap");
+			if (customBasemapProperty !== null) customBasemap = customBasemapProperty;
+			let isControlsDisplayed = false;
+			const isControlsDisplayedProperty = getPropertyValueByLabel(componentProperty.properties, "controls-displayed");
+			if (isControlsDisplayedProperty !== null) isControlsDisplayed = isControlsDisplayedProperty === true;
+			let isFullHeight = false;
+			const isFullHeightProperty = getPropertyValueByLabel(componentProperty.properties, "is-full-height");
+			if (isFullHeightProperty !== null) isFullHeight = isFullHeightProperty === true;
+			properties.mapId = mapLink.uuid;
+			properties.isInteractive = isInteractive;
+			properties.isClustered = isClustered;
+			properties.isUsingPins = isUsingPins;
+			properties.customBasemap = customBasemap;
+			properties.isControlsDisplayed = isControlsDisplayed;
+			properties.isFullHeight = isFullHeight;
+			break;
+		}
+		case "network-graph": break;
+		case "query": {
+			const queries = [];
+			const queryProperties = componentProperty.properties;
+			if (queryProperties.length === 0) throw new Error(`Query properties not found for the following component: “${componentName}”`);
+			for (const query of queryProperties) {
+				const querySubProperties = query.properties;
+				const label = getPropertyValueByLabel(querySubProperties, "query-prompt");
+				if (label === null) throw new Error(`Query prompt not found for the following component: “${componentName}”`);
+				const propertyUuids = querySubProperties.find((property) => property.label === "use-property")?.values.map((value) => value.uuid).filter((uuid) => uuid !== null) ?? [];
+				const startIcon = getPropertyValueByLabel(querySubProperties, "start-icon");
+				const endIcon = getPropertyValueByLabel(querySubProperties, "end-icon");
+				queries.push({
+					label: String(label),
+					propertyUuids,
+					startIcon: startIcon !== null ? String(startIcon) : null,
+					endIcon: endIcon !== null ? String(endIcon) : null
+				});
+			}
+			properties.queries = queries;
+			break;
+		}
+		case "table": {
+			const tableLink = links.find((link) => link.category === "set");
+			if (!tableLink) throw new Error(`Table link not found for the following component: “${componentName}”`);
+			properties.tableId = tableLink.uuid;
+			break;
+		}
+		case "search-bar": {
+			let variant = getPropertyValueByLabel(componentProperty.properties, "variant");
+			variant ??= "default";
+			const placeholder = getPropertyValueByLabel(componentProperty.properties, "placeholder-text");
+			const baseQuery = getPropertyValueByLabel(componentProperty.properties, "base-query");
+			properties.variant = variant;
+			properties.placeholder = placeholder !== null ? String(placeholder) : null;
+			properties.baseQuery = baseQuery !== null ? String(baseQuery).replaceAll(String.raw`\{`, "{").replaceAll(String.raw`\}`, "}") : null;
+			break;
+		}
+		case "text": {
+			const content = elementResource.document && "content" in elementResource.document ? parseDocument(elementResource.document.content) : null;
+			if (!content) throw new Error(`Content not found for the following component: “${componentName}”`);
+			let variantName = "block";
+			let variant;
+			const variantProperty = getPropertyByLabel(componentProperty.properties, "variant");
+			if (variantProperty !== null) {
+				variantName = variantProperty.values[0].content;
+				if (variantName === "paragraph" || variantName === "label" || variantName === "heading" || variantName === "display") {
+					const size = getPropertyValueByLabel(variantProperty.properties, "size");
+					variant = {
+						name: variantName,
+						size: size !== null ? size : "md"
+					};
+				} else variant = { name: variantName };
+			} else variant = { name: variantName };
+			properties.variant = variant;
+			properties.content = content;
+			break;
+		}
+		case "timeline": {
+			const timelineLink = links.find((link) => link.category === "tree");
+			if (!timelineLink) throw new Error(`Timeline link not found for the following component: “${componentName}”`);
+			properties.timelineId = timelineLink.uuid;
+			break;
+		}
+		case "video": {
+			const videoLink = links.find((link) => link.type === "video");
+			if (!videoLink) throw new Error(`Video link not found for the following component: “${componentName}”`);
+			let isChaptersDislayed = getPropertyValueByLabel(componentProperty.properties, "chapters-displayed");
+			isChaptersDislayed ??= true;
+			properties.videoId = videoLink.uuid;
+			properties.isChaptersDislayed = isChaptersDislayed === true;
+			break;
+		}
+		default:
+			console.warn(`Invalid or non-implemented component name “${String(unparsedComponentName)}” for the following element: “${parseStringContent(elementResource.identification.label)}”`);
+			break;
+	}
+	return properties;
+}
+function parseWebTitle(properties, identification, overrides = {}) {
+	const titleProperties = properties.find((property) => property.label === "presentation" && property.values[0].content === "title")?.properties;
+	let variant = "default";
+	let isNameDisplayed = overrides.isNameDisplayed ?? false;
+	let isDescriptionDisplayed = false;
+	let isDateDisplayed = false;
+	let isCreatorsDisplayed = false;
+	let isCountDisplayed = overrides.isCountDisplayed ?? false;
+	if (titleProperties) {
+		const titleVariant = getPropertyValueByLabel(titleProperties, "variant");
+		if (titleVariant) variant = titleVariant;
+		isNameDisplayed = getPropertyValueByLabel(titleProperties, "name-displayed") === true;
+		isDescriptionDisplayed = getPropertyValueByLabel(titleProperties, "description-displayed") === true;
+		isDateDisplayed = getPropertyValueByLabel(titleProperties, "date-displayed") === true;
+		isCreatorsDisplayed = getPropertyValueByLabel(titleProperties, "creators-displayed") === true;
+		isCountDisplayed = getPropertyValueByLabel(titleProperties, "count-displayed") === true;
+	}
+	return {
+		label: identification.label,
+		variant,
+		properties: {
+			isNameDisplayed,
+			isDescriptionDisplayed,
+			isDateDisplayed,
+			isCreatorsDisplayed,
+			isCountDisplayed
+		}
+	};
+}
+/**
+* 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) {
+	const identification = parseIdentification(elementResource.identification);
+	const presentationProperty = (elementResource.properties?.property ? parseProperties(Array.isArray(elementResource.properties.property) ? elementResource.properties.property : [elementResource.properties.property]) : []).find((property) => property.label === "presentation");
+	if (!presentationProperty) throw new Error(`Presentation property not found for element “${identification.label}”`);
+	const componentProperty = presentationProperty.properties.find((property) => property.label === "component");
+	if (!componentProperty) throw new Error(`Component for element “${identification.label}” not found`);
+	const properties = parseWebElementProperties(componentProperty, elementResource);
+	const elementResourceProperties = elementResource.properties?.property ? parseProperties(Array.isArray(elementResource.properties.property) ? elementResource.properties.property : [elementResource.properties.property]) : [];
+	const cssProperties = elementResourceProperties.find((property) => property.label === "presentation" && property.values[0].content === "css")?.properties ?? [];
+	const cssStyles = [];
+	for (const property of cssProperties) {
+		const cssStyle = property.values[0].content;
+		cssStyles.push({
+			label: property.label,
+			value: cssStyle
+		});
+	}
+	const tabletCssProperties = elementResourceProperties.find((property) => property.label === "presentation" && property.values[0].content === "css-tablet")?.properties ?? [];
+	const cssStylesTablet = [];
+	for (const property of tabletCssProperties) {
+		const cssStyle = property.values[0].content;
+		cssStylesTablet.push({
+			label: property.label,
+			value: cssStyle
+		});
+	}
+	const mobileCssProperties = elementResourceProperties.find((property) => property.label === "presentation" && property.values[0].content === "css-mobile")?.properties ?? [];
+	const cssStylesMobile = [];
+	for (const property of mobileCssProperties) {
+		const cssStyle = property.values[0].content;
+		cssStylesMobile.push({
+			label: property.label,
+			value: cssStyle
+		});
+	}
+	const title = parseWebTitle(elementResourceProperties, identification, {
+		isNameDisplayed: [
+			"annotated-image",
+			"annotated-document",
+			"collection"
+		].includes(properties.component),
+		isCountDisplayed: properties.component === "collection" && properties.variant === "full"
+	});
+	return {
+		uuid: elementResource.uuid,
+		type: "element",
+		title,
+		cssStyles: {
+			default: cssStyles,
+			tablet: cssStylesTablet,
+			mobile: cssStylesMobile
+		},
+		...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) {
+	const webpageProperties = webpageResource.properties ? parseProperties(Array.isArray(webpageResource.properties.property) ? webpageResource.properties.property : [webpageResource.properties.property]) : [];
+	if (webpageProperties.length === 0 || webpageProperties.find((property) => property.label === "presentation")?.values[0]?.content !== "page") return null;
+	const identification = parseIdentification(webpageResource.identification);
+	const slug = webpageResource.slug;
+	if (slug === void 0) throw new Error(`Slug not found for page “${identification.label}”`);
+	const imageLink = (webpageResource.links ? parseLinks(Array.isArray(webpageResource.links) ? webpageResource.links : [webpageResource.links]) : []).find((link) => link.type === "image" || link.type === "IIIF");
+	const webpageResources = webpageResource.resource ? Array.isArray(webpageResource.resource) ? webpageResource.resource : [webpageResource.resource] : [];
+	const items = [];
+	for (const resource of webpageResources) {
+		const resourceType = getPropertyValueByLabel(resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : [], "presentation");
+		if (resourceType == null) continue;
+		switch (resourceType) {
+			case "element": {
+				const element = parseWebElement(resource);
+				items.push(element);
+				break;
+			}
+			case "block": {
+				const block = parseWebBlock(resource);
+				if (block) items.push(block);
+				break;
+			}
+		}
+	}
+	const webpages = webpageResource.resource ? parseWebpageResources(Array.isArray(webpageResource.resource) ? webpageResource.resource : [webpageResource.resource], "page") : [];
+	let displayedInHeader = true;
+	let width = "default";
+	let variant = "default";
+	let isSidebarDisplayed = true;
+	let isBreadcrumbsDisplayed = false;
+	const webpageSubProperties = webpageProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "page")?.properties;
+	if (webpageSubProperties) {
+		const headerProperty = webpageSubProperties.find((property) => property.label === "header")?.values[0];
+		if (headerProperty) displayedInHeader = headerProperty.content === true;
+		const widthProperty = webpageSubProperties.find((property) => property.label === "width")?.values[0];
+		if (widthProperty) width = widthProperty.content;
+		const variantProperty = webpageSubProperties.find((property) => property.label === "variant")?.values[0];
+		if (variantProperty) variant = variantProperty.content;
+		const isSidebarDisplayedProperty = webpageSubProperties.find((property) => property.label === "sidebar-visible")?.values[0];
+		if (isSidebarDisplayedProperty) isSidebarDisplayed = isSidebarDisplayedProperty.content === true;
+		const isBreadcrumbsDisplayedProperty = webpageSubProperties.find((property) => property.label === "breadcrumbs-visible")?.values[0];
+		if (isBreadcrumbsDisplayedProperty) isBreadcrumbsDisplayed = isBreadcrumbsDisplayedProperty.content === true;
+	}
+	const cssStyleSubProperties = webpageProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css")?.properties;
+	const cssStyles = [];
+	if (cssStyleSubProperties) for (const property of cssStyleSubProperties) cssStyles.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	const tabletCssStyleSubProperties = webpageProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css-tablet")?.properties;
+	const cssStylesTablet = [];
+	if (tabletCssStyleSubProperties) for (const property of tabletCssStyleSubProperties) cssStylesTablet.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	const mobileCssStyleSubProperties = webpageProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css-mobile")?.properties;
+	const cssStylesMobile = [];
+	if (mobileCssStyleSubProperties) for (const property of mobileCssStyleSubProperties) cssStylesMobile.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	return {
+		title: identification.label,
+		slug,
+		items,
+		properties: {
+			displayedInHeader,
+			width,
+			variant,
+			backgroundImageUrl: imageLink ? `https://ochre.lib.uchicago.edu/ochre?uuid=${imageLink.uuid}&load` : null,
+			isSidebarDisplayed,
+			isBreadcrumbsDisplayed,
+			cssStyles: {
+				default: cssStyles,
+				tablet: cssStylesTablet,
+				mobile: cssStylesMobile
+			}
+		},
+		webpages
+	};
+}
+/**
+* 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) {
+	const returnPages = [];
+	const pagesToParse = Array.isArray(webpageResources) ? webpageResources : [webpageResources];
+	for (const page of pagesToParse) {
+		const webpage = parseWebpage(page);
+		if (webpage) returnPages.push(webpage);
+	}
+	return returnPages;
+}
+/**
+* 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) {
+	let sidebar = null;
+	const sidebarElements = [];
+	const sidebarTitle = {
+		label: "",
+		variant: "default",
+		properties: {
+			isNameDisplayed: false,
+			isDescriptionDisplayed: false,
+			isDateDisplayed: false,
+			isCreatorsDisplayed: false,
+			isCountDisplayed: false
+		}
+	};
+	let sidebarLayout = "start";
+	let sidebarMobileLayout = "default";
+	const sidebarCssStyles = [];
+	const sidebarCssStylesTablet = [];
+	const sidebarCssStylesMobile = [];
+	const sidebarResource = resources.find((resource) => {
+		return (resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : []).some((property) => property.label === "presentation" && property.values[0]?.content === "element" && property.properties[0]?.label === "component" && property.properties[0].values[0]?.content === "sidebar");
+	});
+	if (sidebarResource) {
+		sidebarTitle.label = typeof sidebarResource.identification.label === "string" || typeof sidebarResource.identification.label === "number" || typeof sidebarResource.identification.label === "boolean" ? parseFakeString(sidebarResource.identification.label) : parseStringContent(sidebarResource.identification.label);
+		const sidebarBaseProperties = sidebarResource.properties ? parseProperties(Array.isArray(sidebarResource.properties.property) ? sidebarResource.properties.property : [sidebarResource.properties.property]) : [];
+		const sidebarProperties = sidebarBaseProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "element")?.properties.find((property) => property.label === "component" && property.values[0]?.content === "sidebar")?.properties ?? [];
+		const sidebarLayoutProperty = sidebarProperties.find((property) => property.label === "layout");
+		if (sidebarLayoutProperty) sidebarLayout = sidebarLayoutProperty.values[0].content;
+		const sidebarMobileLayoutProperty = sidebarProperties.find((property) => property.label === "layout-mobile");
+		if (sidebarMobileLayoutProperty) sidebarMobileLayout = sidebarMobileLayoutProperty.values[0].content;
+		const cssProperties = sidebarBaseProperties.find((property) => property.label === "presentation" && property.values[0].content === "css")?.properties ?? [];
+		for (const property of cssProperties) {
+			const cssStyle = property.values[0].content;
+			sidebarCssStyles.push({
+				label: property.label,
+				value: cssStyle
+			});
+		}
+		const tabletCssProperties = sidebarBaseProperties.find((property) => property.label === "presentation" && property.values[0].content === "css-tablet")?.properties ?? [];
+		for (const property of tabletCssProperties) {
+			const cssStyle = property.values[0].content;
+			sidebarCssStylesTablet.push({
+				label: property.label,
+				value: cssStyle
+			});
+		}
+		const mobileCssProperties = sidebarBaseProperties.find((property) => property.label === "presentation" && property.values[0].content === "css-mobile")?.properties ?? [];
+		for (const property of mobileCssProperties) {
+			const cssStyle = property.values[0].content;
+			sidebarCssStylesMobile.push({
+				label: property.label,
+				value: cssStyle
+			});
+		}
+		const titleProperties = sidebarBaseProperties.find((property) => property.label === "presentation" && property.values[0].content === "title")?.properties;
+		if (titleProperties) {
+			const titleVariant = getPropertyValueByLabel(titleProperties, "variant");
+			if (titleVariant) sidebarTitle.variant = titleVariant;
+			sidebarTitle.properties.isNameDisplayed = getPropertyValueByLabel(titleProperties, "name-displayed") === true;
+			sidebarTitle.properties.isDescriptionDisplayed = getPropertyValueByLabel(titleProperties, "description-displayed") === true;
+			sidebarTitle.properties.isDateDisplayed = getPropertyValueByLabel(titleProperties, "date-displayed") === true;
+			sidebarTitle.properties.isCreatorsDisplayed = getPropertyValueByLabel(titleProperties, "creators-displayed") === true;
+			sidebarTitle.properties.isCountDisplayed = getPropertyValueByLabel(titleProperties, "count-displayed") === true;
+		}
+		const sidebarResources = sidebarResource.resource ? Array.isArray(sidebarResource.resource) ? sidebarResource.resource : [sidebarResource.resource] : [];
+		for (const resource of sidebarResources) {
+			const element = parseWebElement(resource);
+			sidebarElements.push(element);
+		}
+	}
+	if (sidebarElements.length > 0) sidebar = {
+		elements: sidebarElements,
+		title: sidebarTitle,
+		layout: sidebarLayout,
+		mobileLayout: sidebarMobileLayout,
+		cssStyles: {
+			default: sidebarCssStyles,
+			tablet: sidebarCssStylesTablet,
+			mobile: sidebarCssStylesMobile
+		}
+	};
+	return sidebar;
+}
+/**
+* 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) {
+	const textElement = parseWebElement(elementResource);
+	const childResources = elementResource.resource ? Array.isArray(elementResource.resource) ? elementResource.resource : [elementResource.resource] : [];
+	const items = [];
+	for (const resource of childResources) {
+		const resourceType = getPropertyValueByLabel(resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : [], "presentation");
+		if (resourceType == null) continue;
+		switch (resourceType) {
+			case "element": {
+				const element = parseWebElement(resource);
+				items.push(element);
+				break;
+			}
+			case "block": {
+				const block = parseWebBlock(resource);
+				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) {
+	const blockProperties = blockResource.properties ? parseProperties(Array.isArray(blockResource.properties.property) ? blockResource.properties.property : [blockResource.properties.property]) : [];
+	const returnBlock = {
+		uuid: blockResource.uuid,
+		type: "block",
+		title: parseWebTitle(blockProperties, parseIdentification(blockResource.identification)),
+		items: [],
+		properties: {
+			default: {
+				layout: "vertical",
+				spacing: void 0,
+				gap: void 0,
+				alignItems: "start",
+				justifyContent: "stretch"
+			},
+			mobile: null,
+			tablet: null
+		},
+		cssStyles: {
+			default: [],
+			tablet: [],
+			mobile: []
+		}
+	};
+	const blockMainProperties = blockProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "block")?.properties;
+	if (blockMainProperties) {
+		const layoutProperty = blockMainProperties.find((property) => property.label === "layout")?.values[0];
+		if (layoutProperty) returnBlock.properties.default.layout = layoutProperty.content;
+		if (returnBlock.properties.default.layout === "accordion") {
+			const isAccordionEnabledProperty = blockMainProperties.find((property) => property.label === "accordion-enabled")?.values[0];
+			if (isAccordionEnabledProperty) returnBlock.properties.default.isAccordionEnabled = isAccordionEnabledProperty.content === true;
+			else returnBlock.properties.default.isAccordionEnabled = true;
+			const isAccordionExpandedByDefaultProperty = blockMainProperties.find((property) => property.label === "accordion-expanded")?.values[0];
+			if (isAccordionExpandedByDefaultProperty) returnBlock.properties.default.isAccordionExpandedByDefault = isAccordionExpandedByDefaultProperty.content === true;
+			else returnBlock.properties.default.isAccordionExpandedByDefault = false;
+			const isAccordionSidebarDisplayedProperty = blockMainProperties.find((property) => property.label === "accordion-sidebar-displayed")?.values[0];
+			if (isAccordionSidebarDisplayedProperty) returnBlock.properties.default.isAccordionSidebarDisplayed = isAccordionSidebarDisplayedProperty.content === true;
+			else returnBlock.properties.default.isAccordionSidebarDisplayed = false;
+		}
+		const spacingProperty = blockMainProperties.find((property) => property.label === "spacing")?.values[0];
+		if (spacingProperty) returnBlock.properties.default.spacing = spacingProperty.content;
+		const gapProperty = blockMainProperties.find((property) => property.label === "gap")?.values[0];
+		if (gapProperty) returnBlock.properties.default.gap = gapProperty.content;
+		const alignItemsProperty = blockMainProperties.find((property) => property.label === "align-items")?.values[0];
+		if (alignItemsProperty) returnBlock.properties.default.alignItems = alignItemsProperty.content;
+		const justifyContentProperty = blockMainProperties.find((property) => property.label === "justify-content")?.values[0];
+		if (justifyContentProperty) returnBlock.properties.default.justifyContent = justifyContentProperty.content;
+		const tabletOverwriteProperty = blockMainProperties.find((property) => property.label === "overwrite-tablet");
+		if (tabletOverwriteProperty) {
+			const tabletOverwriteProperties = tabletOverwriteProperty.properties;
+			const propertiesTablet = {};
+			const layoutProperty$1 = tabletOverwriteProperties.find((property) => property.label === "layout")?.values[0];
+			if (layoutProperty$1) propertiesTablet.layout = layoutProperty$1.content;
+			if (propertiesTablet.layout === "accordion" || returnBlock.properties.default.layout === "accordion") {
+				const isAccordionEnabledProperty = tabletOverwriteProperties.find((property) => property.label === "accordion-enabled")?.values[0];
+				if (isAccordionEnabledProperty) propertiesTablet.isAccordionEnabled = isAccordionEnabledProperty.content === true;
+				const isAccordionExpandedByDefaultProperty = tabletOverwriteProperties.find((property) => property.label === "accordion-expanded")?.values[0];
+				if (isAccordionExpandedByDefaultProperty) propertiesTablet.isAccordionExpandedByDefault = isAccordionExpandedByDefaultProperty.content === true;
+				const isAccordionSidebarDisplayedProperty = tabletOverwriteProperties.find((property) => property.label === "accordion-sidebar-displayed")?.values[0];
+				if (isAccordionSidebarDisplayedProperty) propertiesTablet.isAccordionSidebarDisplayed = isAccordionSidebarDisplayedProperty.content === true;
+			}
+			const spacingProperty$1 = tabletOverwriteProperties.find((property) => property.label === "spacing")?.values[0];
+			if (spacingProperty$1) propertiesTablet.spacing = spacingProperty$1.content;
+			const gapProperty$1 = tabletOverwriteProperties.find((property) => property.label === "gap")?.values[0];
+			if (gapProperty$1) propertiesTablet.gap = gapProperty$1.content;
+			const alignItemsProperty$1 = tabletOverwriteProperties.find((property) => property.label === "align-items")?.values[0];
+			if (alignItemsProperty$1) propertiesTablet.alignItems = alignItemsProperty$1.content;
+			const justifyContentProperty$1 = tabletOverwriteProperties.find((property) => property.label === "justify-content")?.values[0];
+			if (justifyContentProperty$1) propertiesTablet.justifyContent = justifyContentProperty$1.content;
+			returnBlock.properties.tablet = propertiesTablet;
+		}
+		const mobileOverwriteProperty = blockMainProperties.find((property) => property.label === "overwrite-mobile");
+		if (mobileOverwriteProperty) {
+			const mobileOverwriteProperties = mobileOverwriteProperty.properties;
+			const propertiesMobile = {};
+			const layoutProperty$1 = mobileOverwriteProperties.find((property) => property.label === "layout")?.values[0];
+			if (layoutProperty$1) propertiesMobile.layout = layoutProperty$1.content;
+			if (propertiesMobile.layout === "accordion" || returnBlock.properties.default.layout === "accordion") {
+				const isAccordionEnabledProperty = mobileOverwriteProperties.find((property) => property.label === "accordion-enabled")?.values[0];
+				if (isAccordionEnabledProperty) propertiesMobile.isAccordionEnabled = isAccordionEnabledProperty.content === true;
+				const isAccordionExpandedByDefaultProperty = mobileOverwriteProperties.find((property) => property.label === "accordion-expanded")?.values[0];
+				if (isAccordionExpandedByDefaultProperty) propertiesMobile.isAccordionExpandedByDefault = isAccordionExpandedByDefaultProperty.content === true;
+				const isAccordionSidebarDisplayedProperty = mobileOverwriteProperties.find((property) => property.label === "accordion-sidebar-displayed")?.values[0];
+				if (isAccordionSidebarDisplayedProperty) propertiesMobile.isAccordionSidebarDisplayed = isAccordionSidebarDisplayedProperty.content === true;
+			}
+			const spacingProperty$1 = mobileOverwriteProperties.find((property) => property.label === "spacing")?.values[0];
+			if (spacingProperty$1) propertiesMobile.spacing = spacingProperty$1.content;
+			const gapProperty$1 = mobileOverwriteProperties.find((property) => property.label === "gap")?.values[0];
+			if (gapProperty$1) propertiesMobile.gap = gapProperty$1.content;
+			const alignItemsProperty$1 = mobileOverwriteProperties.find((property) => property.label === "align-items")?.values[0];
+			if (alignItemsProperty$1) propertiesMobile.alignItems = alignItemsProperty$1.content;
+			const justifyContentProperty$1 = mobileOverwriteProperties.find((property) => property.label === "justify-content")?.values[0];
+			if (justifyContentProperty$1) propertiesMobile.justifyContent = justifyContentProperty$1.content;
+			returnBlock.properties.mobile = propertiesMobile;
+		}
+	}
+	const blockResources = blockResource.resource ? Array.isArray(blockResource.resource) ? blockResource.resource : [blockResource.resource] : [];
+	if (returnBlock.properties.default.layout === "accordion") {
+		const accordionItems = [];
+		for (const resource of blockResources) {
+			const resourceProperties = resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : [];
+			const resourceType = getPropertyValueByLabel(resourceProperties, "presentation");
+			if (resourceType !== "element") throw new Error(`Accordion only accepts elements, but got “${resourceType}” for the following resource: “${parseStringContent(resource.identification.label)}”`);
+			const componentType = (resourceProperties.find((property) => property.label === "presentation")?.properties.find((property) => property.label === "component"))?.values[0]?.content;
+			if (componentType !== "text") throw new Error(`Accordion only accepts text components, but got “${componentType}” for the following resource: “${parseStringContent(resource.identification.label)}”`);
+			const element = parseWebElementForAccordion(resource);
+			accordionItems.push(element);
+		}
+		returnBlock.items = accordionItems;
+	} else {
+		const blockItems = [];
+		for (const resource of blockResources) {
+			const resourceType = getPropertyValueByLabel(resource.properties ? parseProperties(Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]) : [], "presentation");
+			if (resourceType == null) continue;
+			switch (resourceType) {
+				case "element": {
+					const element = parseWebElement(resource);
+					blockItems.push(element);
+					break;
+				}
+				case "block": {
+					const block = parseWebBlock(resource);
+					if (block) blockItems.push(block);
+					break;
+				}
+			}
+		}
+		returnBlock.items = blockItems;
+	}
+	const blockCssStyles = blockProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css")?.properties;
+	if (blockCssStyles) for (const property of blockCssStyles) returnBlock.cssStyles.default.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	const blockTabletCssStyles = blockProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css-tablet")?.properties;
+	if (blockTabletCssStyles) for (const property of blockTabletCssStyles) returnBlock.cssStyles.tablet.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	const blockMobileCssStyles = blockProperties.find((property) => property.label === "presentation" && property.values[0]?.content === "css-mobile")?.properties;
+	if (blockMobileCssStyles) for (const property of blockMobileCssStyles) returnBlock.cssStyles.mobile.push({
+		label: property.label,
+		value: property.values[0].content
+	});
+	return returnBlock;
+}
+/**
+* Parses raw website properties into a standardized WebsiteProperties structure
+*
+* @param properties - Array of raw website properties in OCHRE format
+* @returns Parsed WebsiteProperties object
+*/
+function parseWebsiteProperties(properties) {
+	const websiteProperties = parseProperties(properties).find((property) => property.label === "presentation")?.properties;
+	if (!websiteProperties) throw new Error("Presentation property not found");
+	let type = websiteProperties.find((property) => property.label === "webUI")?.values[0]?.content;
+	type ??= "traditional";
+	let status = websiteProperties.find((property) => property.label === "status")?.values[0]?.content;
+	status ??= "development";
+	let privacy = websiteProperties.find((property) => property.label === "privacy")?.values[0]?.content;
+	privacy ??= "public";
+	const result = websiteSchema.safeParse({
+		type,
+		status,
+		privacy
+	});
+	if (!result.success) throw new Error(`Invalid website properties: ${result.error.message}`);
+	let contact = null;
+	const contactProperty = websiteProperties.find((property) => property.label === "contact");
+	if (contactProperty) {
+		const [name, email] = (contactProperty.values[0]?.content).split(";");
+		contact = {
+			name,
+			email: email ?? null
+		};
+	}
+	const logoUuid = websiteProperties.find((property) => property.label === "logo")?.values[0]?.uuid ?? null;
+	let isHeaderDisplayed = true;
+	let headerVariant = "default";
+	let headerAlignment = "start";
+	let isHeaderProjectDisplayed = true;
+	let isFooterDisplayed = true;
+	let isSidebarDisplayed = false;
+	let iiifViewer = "universal-viewer";
+	let supportsThemeToggle = true;
+	let defaultTheme = null;
+	const headerProperty = websiteProperties.find((property) => property.label === "navbar-visible")?.values[0];
+	if (headerProperty) isHeaderDisplayed = headerProperty.content === true;
+	const headerVariantProperty = websiteProperties.find((property) => property.label === "navbar-variant")?.values[0];
+	if (headerVariantProperty) headerVariant = headerVariantProperty.content;
+	const headerAlignmentProperty = websiteProperties.find((property) => property.label === "navbar-alignment")?.values[0];
+	if (headerAlignmentProperty) headerAlignment = headerAlignmentProperty.content;
+	const isHeaderProjectDisplayedProperty = websiteProperties.find((property) => property.label === "navbar-project-visible")?.values[0];
+	if (isHeaderProjectDisplayedProperty) isHeaderProjectDisplayed = isHeaderProjectDisplayedProperty.content === true;
+	const footerProperty = websiteProperties.find((property) => property.label === "footer-visible")?.values[0];
+	if (footerProperty) isFooterDisplayed = footerProperty.content === true;
+	const sidebarProperty = websiteProperties.find((property) => property.label === "sidebar-visible")?.values[0];
+	if (sidebarProperty) isSidebarDisplayed = sidebarProperty.content === true;
+	const iiifViewerProperty = websiteProperties.find((property) => property.label === "iiif-viewer")?.values[0];
+	if (iiifViewerProperty) iiifViewer = iiifViewerProperty.content;
+	const supportsThemeToggleProperty = websiteProperties.find((property) => property.label === "supports-theme-toggle")?.values[0];
+	if (supportsThemeToggleProperty) supportsThemeToggle = supportsThemeToggleProperty.content === true;
+	const defaultThemeProperty = websiteProperties.find((property) => property.label === "default-theme")?.values[0];
+	if (defaultThemeProperty) defaultTheme = defaultThemeProperty.content;
+	const { type: validatedType, status: validatedStatus, privacy: validatedPrivacy } = result.data;
+	return {
+		type: validatedType,
+		privacy: validatedPrivacy,
+		status: validatedStatus,
+		contact,
+		isHeaderDisplayed,
+		headerVariant,
+		headerAlignment,
+		isHeaderProjectDisplayed,
+		isFooterDisplayed,
+		isSidebarDisplayed,
+		iiifViewer,
+		supportsThemeToggle,
+		defaultTheme,
+		logoUrl: logoUuid !== null ? `https://ochre.lib.uchicago.edu/ochre?uuid=${logoUuid}&load` : null
+	};
+}
+function parseContexts(contexts) {
+	const contextsParsed = [];
+	for (const mainContext of contexts) {
+		const contextItemsToParse = Array.isArray(mainContext.context) ? mainContext.context : [mainContext.context];
+		for (const contextItemToParse of contextItemsToParse) {
+			const levelsToParse = Array.isArray(contextItemToParse.levels.level) ? contextItemToParse.levels.level : [contextItemToParse.levels.level];
+			let type = "";
+			const levels = levelsToParse.map((level) => {
+				let variableUuid = "";
+				let valueUuid = null;
+				if (typeof level === "string") {
+					const splitLevel = level.split(", ");
+					variableUuid = splitLevel[0];
+					valueUuid = splitLevel[1] === "null" ? null : splitLevel[1];
+				} else {
+					const splitLevel = level.content.split(", ");
+					type = level.dataType;
+					variableUuid = splitLevel[0];
+					valueUuid = splitLevel[1] === "null" ? null : splitLevel[1];
+				}
+				return {
+					variableUuid,
+					valueUuid
+				};
+			});
+			contextsParsed.push({
+				context: levels,
+				type,
+				identification: parseIdentification(contextItemToParse.identification)
+			});
+		}
+	}
+	return contextsParsed;
+}
+function parseWebsite(websiteTree, projectName, website) {
+	if (!websiteTree.properties) throw new Error("Website properties not found");
+	const properties = parseWebsiteProperties(Array.isArray(websiteTree.properties.property) ? websiteTree.properties.property : [websiteTree.properties.property]);
+	if (typeof websiteTree.items === "string" || !("resource" in websiteTree.items)) throw new Error("Website pages not found");
+	const resources = Array.isArray(websiteTree.items.resource) ? websiteTree.items.resource : [websiteTree.items.resource];
+	const pages = parseWebpages(resources);
+	const sidebar = parseSidebar(resources);
+	let globalOptions = { contexts: {
+		flatten: [],
+		filter: [],
+		sort: [],
+		detail: [],
+		download: [],
+		label: [],
+		suppress: [],
+		prominent: []
+	} };
+	if (websiteTree.websiteOptions) {
+		const flattenContextsRaw = websiteTree.websiteOptions.flattenContexts != null ? Array.isArray(websiteTree.websiteOptions.flattenContexts) ? websiteTree.websiteOptions.flattenContexts : [websiteTree.websiteOptions.flattenContexts] : [];
+		const suppressContextsRaw = websiteTree.websiteOptions.suppressContexts != null ? Array.isArray(websiteTree.websiteOptions.suppressContexts) ? websiteTree.websiteOptions.suppressContexts : [websiteTree.websiteOptions.suppressContexts] : [];
+		const filterContextsRaw = websiteTree.websiteOptions.filterContexts != null ? Array.isArray(websiteTree.websiteOptions.filterContexts) ? websiteTree.websiteOptions.filterContexts : [websiteTree.websiteOptions.filterContexts] : [];
+		const sortContextsRaw = websiteTree.websiteOptions.sortContexts != null ? Array.isArray(websiteTree.websiteOptions.sortContexts) ? websiteTree.websiteOptions.sortContexts : [websiteTree.websiteOptions.sortContexts] : [];
+		const detailContextsRaw = websiteTree.websiteOptions.detailContexts != null ? Array.isArray(websiteTree.websiteOptions.detailContexts) ? websiteTree.websiteOptions.detailContexts : [websiteTree.websiteOptions.detailContexts] : [];
+		const downloadContextsRaw = websiteTree.websiteOptions.downloadContexts != null ? Array.isArray(websiteTree.websiteOptions.downloadContexts) ? websiteTree.websiteOptions.downloadContexts : [websiteTree.websiteOptions.downloadContexts] : [];
+		const labelContextsRaw = websiteTree.websiteOptions.labelContexts != null ? Array.isArray(websiteTree.websiteOptions.labelContexts) ? websiteTree.websiteOptions.labelContexts : [websiteTree.websiteOptions.labelContexts] : [];
+		const prominentContextsRaw = websiteTree.websiteOptions.prominentContexts != null ? Array.isArray(websiteTree.websiteOptions.prominentContexts) ? websiteTree.websiteOptions.prominentContexts : [websiteTree.websiteOptions.prominentContexts] : [];
+		globalOptions = { contexts: {
+			flatten: parseContexts(flattenContextsRaw),
+			filter: parseContexts(filterContextsRaw),
+			sort: parseContexts(sortContextsRaw),
+			detail: parseContexts(detailContextsRaw),
+			download: parseContexts(downloadContextsRaw),
+			label: parseContexts(labelContextsRaw),
+			suppress: parseContexts(suppressContextsRaw),
+			prominent: parseContexts(prominentContextsRaw)
+		} };
+	}
+	return {
+		uuid: websiteTree.uuid,
+		publicationDateTime: websiteTree.publicationDateTime ? new Date(websiteTree.publicationDateTime) : null,
+		identification: parseIdentification(websiteTree.identification),
+		project: {
+			name: parseFakeString(projectName),
+			website: website !== null ? parseFakeString(website) : null
+		},
+		creators: websiteTree.creators ? parsePersons(Array.isArray(websiteTree.creators.creator) ? websiteTree.creators.creator : [websiteTree.creators.creator]) : [],
+		license: parseLicense(websiteTree.availability),
+		sidebar,
+		pages,
+		properties,
+		searchOptions: {
+			filters: websiteTree.searchOptions?.filterUuids != null ? (Array.isArray(websiteTree.searchOptions.filterUuids.uuid) ? websiteTree.searchOptions.filterUuids.uuid : [websiteTree.searchOptions.filterUuids.uuid]).map((uuid) => ({
+				uuid: uuid.content,
+				type: uuid.type
+			})) : [],
+			attributeFilters: {
+				bibliographies: websiteTree.searchOptions?.filterUuids?.filterBibliography ?? false,
+				periods: websiteTree.searchOptions?.filterUuids?.filterPeriods ?? false
+			},
+			scopes: websiteTree.searchOptions?.scopes != null ? (Array.isArray(websiteTree.searchOptions.scopes.scope) ? websiteTree.searchOptions.scopes.scope : [websiteTree.searchOptions.scopes.scope]).map((scope) => ({
+				uuid: scope.uuid.content,
+				type: scope.uuid.type,
+				identification: parseIdentification(scope.identification)
+			})) : []
+		},
+		globalOptions
+	};
+}
+
+//#endregion
+//#region src/utils/fetchers/gallery.ts
+/**
+* Fetches and parses a gallery from the OCHRE API
+*
+* @param uuid - The UUID of the gallery
+* @param filter - The filter to apply to the gallery
+* @param page - The page number to fetch
+* @param perPage - The number of items per page
+* @returns The parsed gallery or null if the fetch/parse fails
+*
+* @example
+* ```ts
+* const gallery = await fetchGallery("9c4da06b-f15e-40af-a747-0933eaf3587e", "1978", 1, 12);
+* if (gallery === null) {
+*   console.error("Failed to fetch gallery");
+*   return;
+* }
+* console.log(`Fetched gallery: ${gallery.identification.label}`);
+* console.log(`Contains ${gallery.resources.length.toLocaleString()} resources`);
+* ```
+*
+* @remarks
+* The returned gallery includes:
+* - Gallery metadata and identification
+* - Project identification
+* - Resources (gallery items)
+*/
+async function fetchGallery(uuid, filter, page, perPage, customFetch) {
+	try {
+		const { uuid: parsedUuid, filter: parsedFilter, page: parsedPage, perPage: parsedPerPage } = gallerySchema.parse({
+			uuid,
+			filter,
+			page,
+			perPage
+		});
+		const response = await (customFetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(`
+        for $q in input()/ochre[@uuid='${parsedUuid}']
+        let $filtered := $q//items/resource[contains(lower-case(identification/label), lower-case('${parsedFilter}'))]
+        let $maxLength := count($filtered)
+        return <gallery maxLength='{$maxLength}'>
+          {$q/metadata/project}
+          {$q/metadata/item}
+          {$filtered[position() >= ${((parsedPage - 1) * parsedPerPage + 1).toString()} and position() < ${(parsedPage * parsedPerPage + 1).toString()}]}
+        </gallery>
+      `)}&format=json`);
+		if (!response.ok) throw new Error("Error fetching gallery items, please try again later.");
+		const data = await response.json();
+		if (!("gallery" in data.result)) throw new Error("Failed to fetch gallery");
+		return {
+			item: {
+				identification: parseIdentification(data.result.gallery.item.identification),
+				projectIdentification: parseIdentification(data.result.gallery.project.identification),
+				resources: parseResources(data.result.gallery.resource ? Array.isArray(data.result.gallery.resource) ? data.result.gallery.resource : [data.result.gallery.resource] : []),
+				maxLength: data.result.gallery.maxLength
+			},
+			error: null
+		};
+	} catch (error) {
+		console.error(error);
+		return {
+			item: null,
+			error: error instanceof Error ? error.message : "Failed to fetch gallery"
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/fetchers/uuid.ts
+/**
+* Fetches raw OCHRE data by UUID from the OCHRE API
+*
+* @param uuid - The UUID of the OCHRE item to fetch
+* @returns A tuple containing either [null, OchreData] on success or [error message, null] on failure
+*
+* @example
+* ```ts
+* const [error, data] = await fetchByUuid("123e4567-e89b-12d3-a456-426614174000");
+* if (error !== null) {
+*   console.error(`Failed to fetch: ${error}`);
+*   return;
+* }
+* // Process data...
+* ```
+*
+* @internal
+*/
+async function fetchByUuid(uuid, customFetch) {
+	try {
+		const parsedUuid = uuidSchema.parse(uuid);
+		const response = await (customFetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?uuid=${parsedUuid}&format=json&lang="*"`);
+		if (!response.ok) throw new Error("Failed to fetch OCHRE data");
+		const dataRaw = await response.json();
+		if (!("ochre" in dataRaw)) throw new Error("Invalid OCHRE data: API response missing 'ochre' key");
+		return [null, dataRaw];
+	} catch (error) {
+		return [error instanceof Error ? error.message : "Unknown error", null];
+	}
+}
+
+//#endregion
+//#region src/utils/fetchers/item.ts
+/**
+* Fetches and parses an OCHRE item from the OCHRE API
+*
+* @param uuid - The UUID of the OCHRE item to fetch
+* @returns Object containing the parsed OCHRE item and its metadata, or null if the fetch/parse fails
+*
+* @example
+* ```ts
+* const result = await fetchItem("123e4567-e89b-12d3-a456-426614174000");
+* if (result === null) {
+*   console.error("Failed to fetch OCHRE item");
+*   return;
+* }
+* const { metadata, belongsTo, item, category } = result;
+* console.log(`Fetched OCHRE item: ${item.identification.label} with category ${category}`);
+* ```
+*
+* Or, if you want to fetch a specific category, you can do so by passing the category as an argument:
+* ```ts
+* const result = await fetchItem("123e4567-e89b-12d3-a456-426614174000", "resource");
+* const { metadata, belongsTo, item, category } = result;
+* console.log(item.category); // "resource"
+* ```
+*
+* @remarks
+* The returned OCHRE item includes:
+* - Item metadata
+* - Item belongsTo information
+* - Item content
+* - Item category
+*
+* If the fetch/parse fails, the returned object will have an `error` property.
+*/
+async function fetchItem(uuid, category, setCategory, customFetch) {
+	try {
+		const [error, data] = await fetchByUuid(uuid, customFetch);
+		if (error !== null) throw new Error(error);
+		const categoryKey = getItemCategory(Object.keys(data.ochre));
+		let item;
+		switch (categoryKey) {
+			case "resource":
+				if (!("resource" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'resource' key");
+				item = parseResource(data.ochre.resource);
+				break;
+			case "spatialUnit":
+				if (!("spatialUnit" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'spatialUnit' key");
+				item = parseSpatialUnit(data.ochre.spatialUnit);
+				break;
+			case "concept":
+				if (!("concept" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'concept' key");
+				item = parseConcept(data.ochre.concept);
+				break;
+			case "period":
+				if (!("period" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'period' key");
+				item = parsePeriod(data.ochre.period);
+				break;
+			case "bibliography":
+				if (!("bibliography" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'bibliography' key");
+				item = parseBibliography(data.ochre.bibliography);
+				break;
+			case "person":
+				if (!("person" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'person' key");
+				item = parsePerson(data.ochre.person);
+				break;
+			case "propertyValue":
+				if (!("propertyValue" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'propertyValue' key");
+				item = parsePropertyValue(data.ochre.propertyValue);
+				break;
+			case "set":
+				if (!("set" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'set' key");
+				item = parseSet(data.ochre.set, setCategory);
+				break;
+			case "tree":
+				if (!("tree" in data.ochre)) throw new Error("Invalid OCHRE data: API response missing 'tree' key");
+				item = parseTree(data.ochre.tree, category, setCategory);
+				break;
+			default: throw new Error("Invalid category");
+		}
+		return {
+			error: null,
+			metadata: parseMetadata(data.ochre.metadata),
+			belongsTo: {
+				uuid: data.ochre.uuidBelongsTo,
+				abbreviation: parseFakeString(data.ochre.belongsTo)
+			},
+			item,
+			category
+		};
+	} catch (error) {
+		return {
+			error: error instanceof Error ? error.message : "Unknown error",
+			metadata: void 0,
+			belongsTo: void 0,
+			item: void 0,
+			category: void 0
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/fetchers/property-query.ts
+const PROJECT_SCOPE = "0c0aae37-7246-495b-9547-e25dbf5b99a3";
+const BELONG_TO_COLLECTION_UUID = "30054cb2-909a-4f34-8db9-8fe7369d691d";
+const UNASSIGNED_UUID = "e28e29af-b663-c0ac-ceb6-11a688fca0dd";
+/**
+* Check if a string is a valid UUID
+* @param value - The string to check
+* @returns True if the string is a valid UUID, false otherwise
+*/
+function isUUID(value) {
+	return /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i.test(value);
+}
+/**
+* Schema for a single item in the OCHRE API response
+*/
+const responseItemSchema = z.object({
+	property: z.string().refine(isUUID),
+	category: z.object({
+		uuid: z.string().refine(isUUID),
+		content: z.string()
+	}),
+	value: z.object({
+		uuid: z.string().refine(isUUID).optional(),
+		category: z.string().optional(),
+		type: z.string().optional(),
+		dataType: z.string(),
+		publicationDateTime: z.iso.datetime().optional(),
+		content: z.string().optional(),
+		rawValue: z.string().optional()
+	})
+});
+/**
+* Schema for the OCHRE API response
+*/
+const responseSchema = z.object({ result: z.object({ item: z.union([responseItemSchema, z.array(responseItemSchema)]) }) });
+/**
+* Build an XQuery string to fetch properties from the OCHRE API
+* @param scopeUuids - An array of scope UUIDs to filter by
+* @param propertyUuids - An array of property UUIDs to fetch
+* @returns An XQuery string
+*/
+function buildXQuery(scopeUuids, propertyUuids) {
+	let collectionScopeFilter = "";
+	if (scopeUuids.length > 0) collectionScopeFilter = `[properties/property[label/@uuid="${BELONG_TO_COLLECTION_UUID}"][value[${scopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ")}]]]`;
+	const propertyFilters = propertyUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ");
+	return `for $q in input()/ochre[@uuidBelongsTo="${PROJECT_SCOPE}"]/*${collectionScopeFilter}/properties//property[label[${propertyFilters}]]
+return <item>
+<property>{xs:string($q/label/@uuid)}</property>
+<value> {$q/*[2]/@*} {$q/*[2]/content[1]/string/text()} </value>
+<category> {$q/ancestor::node()[local-name(.)="properties"]/../@uuid}  {local-name($q/ancestor::node()[local-name(.)="properties"]/../self::node())} </category>
+</item>`;
+}
+/**
+* Fetches and parses a property query from the OCHRE API
+*
+* @param scopeUuids - The scope UUIDs to filter by
+* @param propertyUuids - The property UUIDs to query by
+* @param customFetch - A custom fetch function to use instead of the default fetch
+* @returns The parsed property query or null if the fetch/parse fails
+*
+* @example
+* ```ts
+* const propertyQuery = await fetchPropertyQuery(["0c0aae37-7246-495b-9547-e25dbf5b99a3"], ["9c4da06b-f15e-40af-a747-0933eaf3587e"]);
+* if (propertyQuery === null) {
+*   console.error("Failed to fetch property query");
+*   return;
+* }
+* console.log(`Fetched property query: ${propertyQuery.item}`);
+* ```
+*
+* @remarks
+* The returned property query includes:
+* - Property items
+*/
+async function fetchPropertyQuery(scopeUuids, propertyUuids, customFetch) {
+	try {
+		const xquery = buildXQuery(scopeUuids, propertyUuids);
+		const response = await (customFetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(xquery)}&format=json`);
+		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`);
+		const data = await response.json();
+		const parsedResultRaw = responseSchema.parse(data);
+		const parsedItems = Array.isArray(parsedResultRaw.result.item) ? parsedResultRaw.result.item : [parsedResultRaw.result.item];
+		const items = {};
+		for (const item of parsedItems) {
+			const categoryUuid = item.category.uuid;
+			const valueUuid = item.value.uuid;
+			const valueContent = item.value.rawValue ?? item.value.content ?? "";
+			if (valueContent in items) items[valueContent].resultUuids.push(categoryUuid);
+			else items[valueContent] = {
+				value: {
+					uuid: valueUuid ?? null,
+					category: item.value.category ?? null,
+					type: item.value.type ?? null,
+					dataType: item.value.dataType,
+					publicationDateTime: item.value.publicationDateTime ?? null,
+					content: item.value.rawValue ?? item.value.content ?? "",
+					label: item.value.rawValue != null && item.value.content != null ? item.value.content : null
+				},
+				resultUuids: [categoryUuid]
+			};
+		}
+		return {
+			items: Object.values(items).filter((result) => result.value.uuid !== UNASSIGNED_UUID).toSorted((a, b) => {
+				const aValue = a.value.label ?? a.value.content;
+				const bValue = b.value.label ?? b.value.content;
+				return aValue.localeCompare(bValue, "en-US");
+			}),
+			error: null
+		};
+	} catch (error) {
+		console.error(error);
+		return {
+			items: null,
+			error: error instanceof Error ? error.message : "Failed to fetch property query"
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/fetchers/uuid-metadata.ts
+/**
+* Fetches raw OCHRE metadata by UUID from the OCHRE API
+*
+* @param uuid - The UUID of the OCHRE item to fetch
+* @returns An object containing the OCHRE metadata or an error message
+*
+* @example
+* ```ts
+* const { item, error } = await fetchByUuidMetadata("123e4567-e89b-12d3-a456-426614174000");
+* if (error !== null) {
+*   console.error(`Failed to fetch: ${error}`);
+*   return;
+* }
+* // Process data...
+* ```
+*/
+async function fetchByUuidMetadata(uuid, customFetch) {
+	try {
+		const parsedUuid = uuidSchema.parse(uuid);
+		const response = await (customFetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(`for $q in input()/ochre[@uuid='${parsedUuid}']/metadata return ($q/item, $q/project)`)}&format=json`);
+		if (!response.ok) throw new Error("Failed to fetch metadata");
+		const data = await response.json();
+		const projectIdentification = {
+			...parseIdentification(data.result.project.identification),
+			website: data.result.project.identification.website ?? null
+		};
+		return {
+			item: {
+				item: {
+					uuid,
+					name: parseIdentification(data.result.item.identification).label,
+					type: data.result.item.type
+				},
+				project: {
+					name: projectIdentification.label,
+					website: projectIdentification.website ?? null
+				}
+			},
+			error: null
+		};
+	} catch (error) {
+		return {
+			item: null,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/fetchers/website.ts
+const KNOWN_ABBREVIATIONS = {
+	"uchicago-node": "60a1e386-7e53-4e14-b8cf-fb4ed953d57e",
+	"uchicago-node-staging": "62b60a47-fad5-49d7-a06a-2fa059f6e79a",
+	"guerrilla-television": "fad1e1bd-989d-4159-b195-4c32adc5cdc7",
+	"mapping-chicagoland": "8db5e83e-0c06-48b7-b4ac-a060d9bb5689",
+	"hannah-papanek": "20b2c919-021f-4774-b2c3-2f1ae5b910e7",
+	mepa: "85ddaa5a-535b-4809-8714-855d2d812a3e",
+	ssmc: "8ff977dd-d440-40f5-ad93-8ad7e2d39e74",
+	"sosc-core-at-smart": "db26c953-9b2a-4691-a909-5e8726b531d7"
+};
+/**
+* Fetches and parses a website configuration from the OCHRE API
+*
+* @param abbreviation - The abbreviation identifier for the website
+* @returns The parsed website configuration or null if the fetch/parse fails
+*
+* @example
+* ```ts
+* const website = await fetchWebsite("guerrilla-television");
+* if (website === null) {
+*   console.error("Failed to fetch website");
+*   return;
+* }
+* console.log(`Fetched website: ${website.identification.label}`);
+* console.log(`Contains ${website.pages.length.toLocaleString()} pages`);
+* ```
+*
+* @remarks
+* The returned website configuration includes:
+* - Website metadata and identification
+* - Page structure and content
+* - Layout and styling properties
+* - Navigation configuration
+* - Sidebar elements
+* - Project information
+* - Creator details
+*
+* The abbreviation is case-insensitive and should match the website's configured abbreviation in OCHRE.
+*/
+async function fetchWebsite(abbreviation, customFetch) {
+	try {
+		const uuid = KNOWN_ABBREVIATIONS[abbreviation.toLocaleLowerCase("en-US")];
+		const response = await (customFetch ?? fetch)(uuid != null ? `https://ochre.lib.uchicago.edu/ochre?uuid=${uuid}&format=json` : `https://ochre.lib.uchicago.edu/ochre?xquery=for $q in input()/ochre[tree[@type='lesson'][identification/abbreviation='${abbreviation.toLocaleLowerCase("en-US")}']] return $q&format=json`);
+		if (!response.ok) throw new Error("Failed to fetch website");
+		const data = await response.json();
+		const result = "result" in data && !Array.isArray(data.result) ? data.result : !("result" in data) ? data : null;
+		if (result == null || !("tree" in result.ochre)) throw new Error("Failed to fetch website");
+		const projectIdentification = result.ochre.metadata.project?.identification ? parseIdentification(result.ochre.metadata.project.identification) : null;
+		return [null, parseWebsite(result.ochre.tree, projectIdentification?.label ?? "", result.ochre.metadata.project?.identification.website ?? null)];
+	} catch (error) {
+		console.error(error);
+		return [error instanceof Error ? error.message : "Unknown error", null];
+	}
+}
+
+//#endregion
+export { fetchByUuidMetadata, fetchGallery, fetchItem, fetchPropertyQuery, fetchWebsite, filterProperties, getPropertyByLabel, getPropertyByUuid, getPropertyValueByLabel, getPropertyValueByUuid, getPropertyValuesByLabel, getPropertyValuesByUuid, getUniqueProperties, getUniquePropertyLabels };