ochre-sdk 1.0.13 → 1.0.15

package/dist/parsers/index.mjs

@@ -0,0 +1,1338 @@
+import { DEFAULT_LANGUAGES } from "../constants.mjs";
+import { MultilingualString } from "./multilingual.mjs";
+import { getXMLSourceIndex } from "../xml/metadata.mjs";
+import { parseXMLString, transformPermanentIdentificationUrl } from "./string.mjs";
+import { getParserOptions, multilingualFromText, parseContentLike, parseContentLikeText, parseLicense, parseRequiredContentLike, parseStringLike } from "./helpers.mjs";
+//#region src/parsers/index.ts
+function isXMLContextGroup(context) {
+	return "context" in context;
+}
+function isXMLContextItem(context) {
+	return "project" in context;
+}
+const SET_ITEM_CATEGORIES = ["tree", ...[
+	"bibliography",
+	"concept",
+	"spatialUnit",
+	"period",
+	"person",
+	"propertyVariable",
+	"propertyValue",
+	"resource",
+	"text",
+	"set"
+]];
+const HEADING_ITEM_CATEGORIES = [
+	"person",
+	"propertyVariable",
+	"propertyValue",
+	"resource",
+	"text",
+	"set"
+];
+const CONTEXT_CATEGORY_MAPPINGS = [
+	{
+		raw: "bibliography",
+		parsed: "bibliography"
+	},
+	{
+		raw: "concept",
+		parsed: "concept"
+	},
+	{
+		raw: "spatialUnit",
+		parsed: "spatialUnit"
+	},
+	{
+		raw: "period",
+		parsed: "period"
+	},
+	{
+		raw: "propertyVariable",
+		parsed: "propertyVariable"
+	},
+	{
+		raw: "variable",
+		parsed: "propertyVariable"
+	},
+	{
+		raw: "propertyValue",
+		parsed: "propertyValue"
+	},
+	{
+		raw: "value",
+		parsed: "propertyValue"
+	},
+	{
+		raw: "resource",
+		parsed: "resource"
+	},
+	{
+		raw: "text",
+		parsed: "text"
+	}
+];
+const PROPERTY_DATA_TYPES = [
+	"string",
+	"coordinate",
+	"IDREF",
+	"date",
+	"dateTime",
+	"integer",
+	"decimal",
+	"time",
+	"boolean"
+];
+function parseIdentification(rawIdentification, options) {
+	return {
+		label: parseRequiredContentLike(rawIdentification.label, options),
+		abbreviation: parseContentLike(rawIdentification.abbreviation, options),
+		code: parseStringLike(rawIdentification.code),
+		email: parseStringLike(rawIdentification.email),
+		website: parseStringLike(rawIdentification.website)
+	};
+}
+function emptyIdentification(options) {
+	return {
+		label: MultilingualString.empty(options.languages),
+		abbreviation: null,
+		code: null,
+		email: null,
+		website: null
+	};
+}
+function parseOptionalIdentification(rawIdentification, options) {
+	return rawIdentification == null ? emptyIdentification(options) : parseIdentification(rawIdentification, options);
+}
+function parseContextItem(contextItem) {
+	return {
+		uuid: contextItem.uuid ?? null,
+		publicationDateTime: contextItem.publicationDateTime ?? null,
+		index: contextItem.n,
+		content: contextItem.payload
+	};
+}
+function emptyContextItem() {
+	return {
+		uuid: null,
+		publicationDateTime: null,
+		index: 0,
+		content: ""
+	};
+}
+function parseContext(rawContext) {
+	const nodes = [];
+	let displayPath = "";
+	for (const rawContextOuterItem of rawContext) {
+		if (!isXMLContextGroup(rawContextOuterItem)) continue;
+		displayPath = displayPath || rawContextOuterItem.displayPath;
+		for (const rawContextItem of rawContextOuterItem.context) {
+			if (!isXMLContextItem(rawContextItem)) continue;
+			const node = {
+				tree: rawContextItem.tree[0] == null ? emptyContextItem() : parseContextItem(rawContextItem.tree[0]),
+				project: parseContextItem(rawContextItem.project),
+				heading: []
+			};
+			const rawContextValues = rawContextItem;
+			for (const heading of rawContextValues.heading ?? []) node.heading.push(parseContextItem(heading));
+			for (const { raw, parsed } of CONTEXT_CATEGORY_MAPPINGS) {
+				const contextValues = rawContextValues[raw] ?? [];
+				for (const contextValue of contextValues) {
+					const parsedItems = node[parsed] ?? [];
+					parsedItems.push(parseContextItem(contextValue));
+					node[parsed] = parsedItems;
+				}
+			}
+			nodes.push(node);
+		}
+	}
+	return {
+		nodes,
+		displayPath
+	};
+}
+function parseEventReference(rawReference, options) {
+	if (rawReference == null) return null;
+	return {
+		uuid: rawReference.uuid,
+		label: parseRequiredContentLike(rawReference, options),
+		publicationDateTime: rawReference.publicationDateTime ?? null
+	};
+}
+function parseEvent(rawEvent, options) {
+	const startDate = rawEvent.dateTime ?? null;
+	const endDate = rawEvent.endDateTime ?? null;
+	return {
+		date: startDate == null ? null : endDate == null ? startDate : {
+			start: startDate,
+			end: endDate
+		},
+		label: parseRequiredContentLike(rawEvent.label, options),
+		comment: parseContentLike(rawEvent.comment, options),
+		agent: parseEventReference(rawEvent.agent, options),
+		location: parseEventReference(rawEvent.location, options),
+		other: rawEvent.other == null ? null : {
+			uuid: rawEvent.other.uuid ?? null,
+			category: normalizeCategory(rawEvent.other.category),
+			label: parseRequiredContentLike(rawEvent.other, options)
+		}
+	};
+}
+function parseBaseItem(category, rawItem, options) {
+	const events = [];
+	for (const event of rawItem.events?.event ?? []) events.push(parseEvent(event, options));
+	const creators = [];
+	for (const creator of rawItem.creators?.creator ?? []) creators.push(parsePerson(creator, options));
+	return {
+		uuid: rawItem.uuid ?? "",
+		category,
+		belongsTo: null,
+		metadata: null,
+		persistentUrl: null,
+		publicationDateTime: rawItem.publicationDateTime ?? null,
+		context: rawItem.context == null ? null : parseContext(rawItem.context),
+		date: rawItem.date instanceof Date ? rawItem.date : null,
+		license: parseLicense(rawItem.availability),
+		copyright: rawItem.copyright == null ? null : parseContentLike(rawItem.copyright, options),
+		watermark: rawItem.watermark == null ? null : parseContentLike(rawItem.watermark, options),
+		identification: parseOptionalIdentification(rawItem.identification, options),
+		creators,
+		description: parseContentLike(rawItem.description, options),
+		events
+	};
+}
+function normalizeCategory(category) {
+	if (category == null) return null;
+	if (category === "variable") return "propertyVariable";
+	if (category === "value") return "propertyValue";
+	for (const knownCategory of SET_ITEM_CATEGORIES) if (category === knownCategory) return knownCategory;
+	return null;
+}
+function isHeadingItemCategory(category) {
+	return HEADING_ITEM_CATEGORIES.includes(category);
+}
+function pushCategory(categories, category) {
+	if (!categories.includes(category)) categories.push(category);
+}
+function getHierarchyEntryCategory(key) {
+	switch (key) {
+		case "heading":
+		case "tree":
+		case "bibliography":
+		case "concept":
+		case "spatialUnit":
+		case "period":
+		case "person":
+		case "resource":
+		case "text":
+		case "set":
+		case "dictionaryUnit": return key;
+		case "propertyVariable":
+		case "variable": return "propertyVariable";
+		case "propertyValue":
+		case "value": return "propertyValue";
+		default: return null;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value != null;
+}
+function isResourceWrapper(value) {
+	return isRecord(value) && !("uuid" in value) && Array.isArray(value.resource);
+}
+function sourceOrderSort(left, right) {
+	const leftIndex = getXMLSourceIndex(left.item);
+	const rightIndex = getXMLSourceIndex(right.item);
+	if (leftIndex != null && rightIndex != null && leftIndex !== rightIndex) return leftIndex - rightIndex;
+	return left.fallbackIndex - right.fallbackIndex;
+}
+function collectHierarchyEntries(hierarchy, categories) {
+	const entries = [];
+	if (hierarchy == null) return entries;
+	let fallbackIndex = 0;
+	for (const key of Object.keys(hierarchy)) {
+		const category = getHierarchyEntryCategory(key);
+		if (category == null || !(categories == null || categories.includes(category))) continue;
+		const values = hierarchy[key];
+		if (!Array.isArray(values)) continue;
+		for (const value of values) {
+			if (category === "resource" && isResourceWrapper(value)) {
+				for (const resource of value.resource) {
+					entries.push({
+						category,
+						item: resource,
+						fallbackIndex
+					});
+					fallbackIndex += 1;
+				}
+				continue;
+			}
+			entries.push({
+				category,
+				item: value,
+				fallbackIndex
+			});
+			fallbackIndex += 1;
+		}
+	}
+	entries.sort(sourceOrderSort);
+	return entries;
+}
+function inferItemCategories(hierarchy) {
+	const categories = [];
+	if (hierarchy == null) return categories;
+	for (const entry of collectHierarchyEntries(hierarchy)) {
+		if (entry.category === "heading") {
+			for (const category of inferItemCategories(entry.item)) pushCategory(categories, category);
+			continue;
+		}
+		if (entry.category === "dictionaryUnit") continue;
+		pushCategory(categories, entry.category);
+	}
+	return categories;
+}
+function normalizeSetItemCategories(containedItemCategory) {
+	if (containedItemCategory == null) return null;
+	const categories = typeof containedItemCategory === "string" ? [containedItemCategory] : containedItemCategory;
+	const uniqueCategories = [];
+	for (const category of categories) if (!uniqueCategories.includes(category)) uniqueCategories.push(category);
+	return uniqueCategories;
+}
+function normalizeTreeItemCategory(containedItemCategory) {
+	if (containedItemCategory != null && typeof containedItemCategory !== "string") throw new Error("Tree containedItemCategory must be a single category", { cause: containedItemCategory });
+	if (containedItemCategory === "tree") throw new Error("Tree containedItemCategory cannot be \"tree\"", { cause: containedItemCategory });
+	return containedItemCategory;
+}
+function resolveTreeItemCategory(rawTree, containedItemCategory) {
+	const inferredCategories = inferItemCategories(rawTree.items);
+	if (inferredCategories.length > 1) throw new Error(`Expected Tree items to contain one category, received ${inferredCategories.join(", ")}`, { cause: inferredCategories });
+	const inferredCategory = inferredCategories[0] ?? null;
+	if (inferredCategory === "tree") throw new Error("Tree items cannot contain category \"tree\"", { cause: inferredCategory });
+	if (containedItemCategory != null && inferredCategory != null && containedItemCategory !== inferredCategory) throw new Error(`Tree containedItemCategory "${containedItemCategory}" does not match XML items category "${inferredCategory}"`, { cause: {
+		containedItemCategory,
+		inferredCategory
+	} });
+	return containedItemCategory ?? inferredCategory;
+}
+function parseImage(rawImage, options) {
+	if (rawImage == null) return null;
+	return {
+		publicationDateTime: rawImage.publicationDateTime ?? null,
+		identification: rawImage.identification == null ? null : parseIdentification(rawImage.identification, options),
+		href: parseHref(rawImage.href),
+		htmlImgSrcPrefix: rawImage.htmlImgSrcPrefix ?? null,
+		height: rawImage.height ?? null,
+		width: rawImage.width ?? null,
+		fileSize: rawImage.fileSize ?? null,
+		base64: rawImage.payload ?? null
+	};
+}
+function parseHref(href) {
+	return href == null ? null : transformPermanentIdentificationUrl(href);
+}
+function parseCoordinatesSource(source, options) {
+	if (source == null) return null;
+	switch (source.context) {
+		case "self": return {
+			context: "self",
+			uuid: source.label.uuid,
+			label: parseRequiredContentLike(source.label, options)
+		};
+		case "related": {
+			const value = source.value[0];
+			return {
+				context: "related",
+				uuid: source.label.uuid,
+				label: parseRequiredContentLike(source.label, options),
+				value: value == null ? MultilingualString.empty(options.languages) : parseRequiredContentLike(value, options)
+			};
+		}
+		case "inherited": return {
+			context: "inherited",
+			uuid: source.label.uuid,
+			label: parseRequiredContentLike(source.label, options),
+			item: {
+				uuid: source.item.label.uuid ?? source.item.uuid ?? null,
+				label: parseRequiredContentLike(source.item.label, options)
+			}
+		};
+	}
+}
+function parseCoordinate(coordinate, options) {
+	switch (coordinate.type) {
+		case "point": return {
+			type: "point",
+			latitude: coordinate.latitude,
+			longitude: coordinate.longitude,
+			altitude: coordinate.altitude ?? null,
+			source: parseCoordinatesSource(coordinate.source, options)
+		};
+		case "plane": return {
+			type: "plane",
+			minimum: {
+				latitude: coordinate.minimum.latitude,
+				longitude: coordinate.minimum.longitude
+			},
+			maximum: {
+				latitude: coordinate.maximum.latitude,
+				longitude: coordinate.maximum.longitude
+			},
+			source: parseCoordinatesSource(coordinate.source, options)
+		};
+	}
+}
+function parseCoordinates(rawCoordinates, options) {
+	const coordinates = [];
+	for (const coordinate of rawCoordinates?.coord ?? []) coordinates.push(parseCoordinate(coordinate, options));
+	return coordinates;
+}
+function parseImageMapArea(area) {
+	const coords = [];
+	for (const coord of area.coords.split(",")) {
+		const parsedCoord = Number(coord.trim());
+		coords.push(Number.isNaN(parsedCoord) ? 0 : parsedCoord);
+	}
+	const shape = area.shape === "rect" ? "rectangle" : area.shape === "circle" ? "circle" : "polygon";
+	return {
+		uuid: area.uuid,
+		publicationDateTime: area.publicationDateTime,
+		type: area.type,
+		title: area.title,
+		slug: area.slug ?? null,
+		items: shape === "rectangle" ? [{
+			shape,
+			coords: [
+				coords[0] ?? 0,
+				coords[1] ?? 0,
+				coords[2] ?? 0,
+				coords[3] ?? 0
+			]
+		}] : shape === "circle" ? [{
+			shape,
+			center: {
+				x: coords[0] ?? 0,
+				y: coords[1] ?? 0
+			},
+			radius: coords[2] ?? 0
+		}] : [{
+			shape,
+			coords
+		}]
+	};
+}
+function parseImageMap(rawImageMap) {
+	if (rawImageMap == null) return null;
+	const areas = [];
+	for (const area of rawImageMap.area) areas.push(parseImageMapArea(area));
+	return {
+		areas,
+		width: rawImageMap.width,
+		height: rawImageMap.height
+	};
+}
+function parseNote(rawNote, options) {
+	const authors = [];
+	for (const author of rawNote.authors?.author ?? []) authors.push(parsePerson(author, options));
+	const content = rawNote.content == null ? multilingualFromText(parseXMLString(rawNote), options) : parseRequiredContentLike(rawNote, options);
+	return {
+		number: rawNote.noteNo ?? 0,
+		title: parseNoteTitle(rawNote, options),
+		content,
+		authors
+	};
+}
+function parseNoteTitle(rawNote, options) {
+	if (rawNote.title != null) return multilingualFromText(rawNote.title, options);
+	const titleContent = {};
+	for (const content of rawNote.content ?? []) {
+		if (!options.languages.includes(content.lang) || content.title == null) continue;
+		titleContent[content.lang] = content.title;
+	}
+	if (Object.keys(titleContent).length > 0) return MultilingualString.fromObject(titleContent, options.languages);
+	for (const content of rawNote.content ?? []) if (content.lang !== "zxx" && content.title != null) return multilingualFromText(content.title, options);
+	return null;
+}
+function parseNotes(rawNotes, options) {
+	const notes = [];
+	for (const note of rawNotes?.note ?? []) notes.push(parseNote(note, options));
+	return notes;
+}
+function parsePropertyDataType(dataType) {
+	if (dataType == null || dataType === "") return "string";
+	const normalizedDataType = dataType.startsWith("xs:") ? dataType.slice(3) : dataType;
+	for (const propertyDataType of PROPERTY_DATA_TYPES) if (normalizedDataType === propertyDataType) return propertyDataType;
+	throw new Error(`Invalid property value data type: ${dataType}`, { cause: dataType });
+}
+function parsePropertyValueContent(value, options) {
+	const dataType = parsePropertyDataType(value.dataType);
+	const rawLabel = value.content != null ? parseRequiredContentLike(value, options) : value.payload != null && value.payload !== "" ? multilingualFromText(value.payload, options) : null;
+	const displayText = rawLabel?.getText() ?? value.payload ?? value.slug ?? "";
+	const contentText = value.rawValue ?? value.payload ?? displayText;
+	const common = {
+		hierarchy: {
+			isLeaf: value.inherited == null || !value.inherited,
+			level: value.i ?? null
+		},
+		label: rawLabel,
+		isUncertain: value.isUncertain === "true",
+		category: value.category ?? null,
+		type: value.type ?? null,
+		uuid: value.uuid == null || value.uuid === "" ? null : value.uuid,
+		publicationDateTime: value.publicationDateTime ?? null,
+		unit: value.unit ?? null,
+		href: parseHref(value.href),
+		height: value.height ?? null,
+		width: value.width ?? null,
+		fileSize: value.fileSize ?? null,
+		slug: value.slug ?? null
+	};
+	switch (dataType) {
+		case "integer":
+		case "decimal":
+		case "time": {
+			const numericContent = Number(contentText);
+			return {
+				...common,
+				dataType,
+				content: Number.isNaN(numericContent) ? 0 : numericContent
+			};
+		}
+		case "boolean": return {
+			...common,
+			dataType,
+			content: contentText === "true"
+		};
+		case "string":
+		case "coordinate":
+		case "IDREF":
+		case "date":
+		case "dateTime": return {
+			...common,
+			dataType,
+			content: contentText
+		};
+	}
+}
+function parseProperty(rawProperty, options) {
+	const values = [];
+	for (const value of rawProperty.value ?? []) values.push(parsePropertyValueContent(value, options));
+	const properties = [];
+	for (const property of rawProperty.property ?? []) properties.push(parseProperty(property, options));
+	return {
+		variable: {
+			uuid: rawProperty.label.uuid,
+			label: parseRequiredContentLike(rawProperty.label, options),
+			publicationDateTime: rawProperty.label.publicationDateTime ?? null
+		},
+		values,
+		comment: parseContentLike(rawProperty.comment, options),
+		properties
+	};
+}
+function parseProperties(rawProperties, options) {
+	const properties = [];
+	for (const property of rawProperties?.property ?? []) properties.push(parseProperty(property, options));
+	return properties;
+}
+function parseSimplifiedProperty(rawProperty, options) {
+	const values = [];
+	for (const value of rawProperty.value ?? []) values.push(parsePropertyValueContent(value, options));
+	const properties = [];
+	for (const property of rawProperty.property ?? []) properties.push(parseSimplifiedProperty(property, options));
+	return {
+		variable: {
+			uuid: rawProperty.label.uuid,
+			label: parseContentLikeText(rawProperty.label, options),
+			publicationDateTime: rawProperty.label.publicationDateTime ?? null
+		},
+		values,
+		comment: parseContentLike(rawProperty.comment, options),
+		properties
+	};
+}
+function parseSimplifiedProperties(rawProperties, options) {
+	const properties = [];
+	for (const property of rawProperties?.property ?? []) properties.push(parseSimplifiedProperty(property, options));
+	return properties;
+}
+function parseSetItemProperty(rawProperty, options) {
+	const property = parseProperty(rawProperty, options);
+	return {
+		variable: property.variable,
+		values: property.values,
+		comment: property.comment
+	};
+}
+function parseSetItemProperties(rawProperties, options) {
+	const properties = [];
+	for (const property of rawProperties?.property ?? []) properties.push(parseSetItemProperty(property, options));
+	return properties;
+}
+function withSetItemProperties(item, rawProperties, options) {
+	return {
+		...item,
+		properties: parseSetItemProperties(rawProperties, options)
+	};
+}
+function withoutItems(item) {
+	const { items: _items, ...itemWithoutItems } = item;
+	return itemWithoutItems;
+}
+function parseEmbeddedItemEntry(entry, options) {
+	switch (entry.category) {
+		case "tree": return parseTree(entry.item, {
+			...options,
+			containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
+		});
+		case "bibliography": return parseBibliography(entry.item, options);
+		case "concept": return parseConcept(entry.item, options);
+		case "spatialUnit": return parseSpatialUnit(entry.item, options);
+		case "period": return parsePeriod(entry.item, options);
+		case "person": return parsePerson(entry.item, options);
+		case "propertyVariable": return parsePropertyVariable(entry.item, options);
+		case "propertyValue": return parsePropertyValue(entry.item, options);
+		case "resource": return parseResource(entry.item, options);
+		case "text": return parseText(entry.item, options);
+		case "set": return parseSet(entry.item, options);
+		case "dictionaryUnit":
+		case "heading": return null;
+	}
+}
+function parseItemHierarchy(hierarchy, options, categories) {
+	const items = [];
+	if (hierarchy == null) return items;
+	for (const entry of collectHierarchyEntries(hierarchy, categories)) {
+		const item = parseEmbeddedItemEntry(entry, options);
+		if (item != null) items.push(item);
+	}
+	return items;
+}
+function parseSetItemHierarchy(hierarchy, options, categories) {
+	const items = [];
+	if (hierarchy == null) return items;
+	for (const entry of collectHierarchyEntries(hierarchy, categories)) switch (entry.category) {
+		case "tree":
+			items.push(parseSetTree(entry.item, options));
+			break;
+		case "bibliography":
+			items.push(parseSetBibliography(entry.item, options));
+			break;
+		case "concept":
+			items.push(parseSetConcept(entry.item, options));
+			break;
+		case "spatialUnit":
+			items.push(parseSetSpatialUnit(entry.item, options));
+			break;
+		case "period":
+			items.push(parseSetPeriod(entry.item, options));
+			break;
+		case "person": {
+			const person = entry.item;
+			items.push(withSetItemProperties(parsePerson(person, options), person.properties, options));
+			break;
+		}
+		case "propertyVariable":
+			items.push(parsePropertyVariable(entry.item, options));
+			break;
+		case "propertyValue": {
+			const propertyValue = entry.item;
+			items.push(withSetItemProperties(parsePropertyValue(propertyValue, options), propertyValue.properties, options));
+			break;
+		}
+		case "resource":
+			items.push(parseSetResource(entry.item, options));
+			break;
+		case "text":
+			items.push(parseText(entry.item, options));
+			break;
+		case "set":
+			items.push(parseSetSet(entry.item, options));
+			break;
+		case "dictionaryUnit":
+		case "heading": break;
+	}
+	return items;
+}
+function normalizeTreeLinkItemsCategory(type) {
+	const category = normalizeCategory(type);
+	if (category == null || category === "tree") return null;
+	return category;
+}
+function normalizeSetLinkItemsCategory(type) {
+	const category = normalizeCategory(type);
+	return category == null ? null : [category];
+}
+function parseBaseItemLink(category, rawItem, options) {
+	return {
+		uuid: rawItem.uuid ?? "",
+		category,
+		publicationDateTime: rawItem.publicationDateTime ?? null,
+		context: rawItem.context == null ? null : parseContext(rawItem.context),
+		date: rawItem.date instanceof Date ? rawItem.date : null,
+		identification: parseOptionalIdentification(rawItem.identification, options),
+		description: parseContentLike(rawItem.description, options)
+	};
+}
+function parseBibliographySourceDocument(sourceDocument) {
+	if (sourceDocument == null) return null;
+	return {
+		uuid: sourceDocument.uuid,
+		content: sourceDocument.payload,
+		href: parseHref(sourceDocument.href),
+		publicationDateTime: sourceDocument.publicationDateTime ?? null
+	};
+}
+function parseBibliographyStartDate(startDate) {
+	if (startDate == null) return null;
+	return new Date(startDate.year ?? 0, Math.max((startDate.month ?? 0) - 1, 0), startDate.day ?? 0);
+}
+function parseBibliographyEntryInfo(entryInfo) {
+	if (entryInfo == null || entryInfo.payload == null && entryInfo.startIssue == null && entryInfo.startVolume == null && entryInfo.startPage == null && entryInfo.endPage == null) return null;
+	return {
+		content: entryInfo.payload ?? null,
+		startIssue: entryInfo.startIssue ?? "",
+		startVolume: entryInfo.startVolume ?? "",
+		startPage: entryInfo.startPage ?? "",
+		endPage: entryInfo.endPage ?? ""
+	};
+}
+function firstItemLink(rawLinks, options) {
+	const link = parseLinks(rawLinks, options)[0];
+	return link == null ? null : link;
+}
+function parsePersonItemLinks(rawPersons, options) {
+	const people = [];
+	for (const person of rawPersons ?? []) people.push(parsePersonItemLink(person, options));
+	return people;
+}
+function parsePeriodItemLinks(rawPeriods, options) {
+	const periods = [];
+	for (const period of rawPeriods ?? []) periods.push(parsePeriodItemLink(period, options));
+	return periods;
+}
+function parseTreeItemLink(rawTree, options) {
+	return {
+		...parseBaseItemLink("tree", rawTree, options),
+		type: rawTree.type ?? null,
+		containedItemCategory: normalizeTreeLinkItemsCategory(rawTree.type)
+	};
+}
+function parseSetItemLink(rawSet, options) {
+	return {
+		...parseBaseItemLink("set", rawSet, options),
+		type: rawSet.type ?? null,
+		containedItemCategories: normalizeSetLinkItemsCategory(rawSet.type)
+	};
+}
+function parseBibliographyItemLink(rawBibliography, options) {
+	return {
+		...parseBaseItemLink("bibliography", rawBibliography, options),
+		type: rawBibliography.type ?? null,
+		zoteroId: rawBibliography.zoteroId ?? null,
+		citationDetails: rawBibliography.citationDetails ?? null,
+		citationFormat: parseContentLike(rawBibliography.citationFormat, options),
+		citationFormatSpan: parseStringLike(rawBibliography.citationFormatSpan),
+		referenceFormatDiv: parseStringLike(rawBibliography.referenceFormatDiv),
+		image: parseImage(rawBibliography.image, options),
+		sourceDocument: parseBibliographySourceDocument(rawBibliography.sourceDocument),
+		publicationInfo: rawBibliography.publicationInfo == null ? null : {
+			publishers: parsePersonItemLinks(rawBibliography.publicationInfo.publishers == null ? void 0 : "publisher" in rawBibliography.publicationInfo.publishers ? rawBibliography.publicationInfo.publishers.publisher : rawBibliography.publicationInfo.publishers.publishers.person, options),
+			startDate: parseBibliographyStartDate(rawBibliography.publicationInfo.startDate)
+		},
+		entryInfo: parseBibliographyEntryInfo(rawBibliography.entryInfo),
+		source: firstItemLink(rawBibliography.source, options),
+		authors: parsePersonItemLinks(rawBibliography.authors?.person, options),
+		periods: parsePeriodItemLinks(rawBibliography.periods?.period, options),
+		properties: parseProperties(rawBibliography.properties, options)
+	};
+}
+function parseConceptItemLink(rawConcept, options) {
+	return {
+		...parseBaseItemLink("concept", rawConcept, options),
+		image: parseImage(rawConcept.image, options),
+		coordinates: parseCoordinates(rawConcept.coordinates, options)
+	};
+}
+function parseSpatialUnitItemLink(rawSpatialUnit, options) {
+	return {
+		...parseBaseItemLink("spatialUnit", rawSpatialUnit, options),
+		image: parseImage(rawSpatialUnit.image, options),
+		coordinates: parseCoordinates(rawSpatialUnit.coordinates, options)
+	};
+}
+function parsePeriodItemLink(rawPeriod, options) {
+	return {
+		...parseBaseItemLink("period", rawPeriod, options),
+		type: rawPeriod.type ?? null,
+		coordinates: parseCoordinates(rawPeriod.coordinates, options)
+	};
+}
+function parsePersonItemLink(rawPerson, options) {
+	return {
+		...parseBaseItemLink("person", rawPerson, options),
+		type: rawPerson.type ?? null,
+		coordinates: parseCoordinates(rawPerson.coordinates, options)
+	};
+}
+function parsePropertyVariableItemLink(rawPropertyVariable, options) {
+	return {
+		...parseBaseItemLink("propertyVariable", rawPropertyVariable, options),
+		type: rawPropertyVariable.type ?? null,
+		coordinates: parseCoordinates(rawPropertyVariable.coordinates, options)
+	};
+}
+function parsePropertyValueItemLink(rawPropertyValue, options) {
+	return {
+		...parseBaseItemLink("propertyValue", rawPropertyValue, options),
+		coordinates: parseCoordinates(rawPropertyValue.coordinates, options)
+	};
+}
+function parseResourceItemLink(rawResource, options) {
+	return {
+		...parseBaseItemLink("resource", rawResource, options),
+		type: rawResource.type ?? null,
+		href: parseHref(rawResource.href),
+		fileFormat: rawResource.fileFormat ?? null,
+		fileSize: rawResource.fileSize ?? null,
+		isInline: rawResource.rend === "inline",
+		isPrimary: rawResource.isPrimary ?? false,
+		height: rawResource.height ?? null,
+		width: rawResource.width ?? null,
+		image: parseImage(rawResource.image, options),
+		coordinates: parseCoordinates(rawResource.coordinates, options)
+	};
+}
+function parseTextItemLink(rawText, options) {
+	return {
+		...parseBaseItemLink("text", rawText, options),
+		type: rawText.type ?? null,
+		text: rawText.text ?? null,
+		language: rawText.language ?? null,
+		image: parseImage(rawText.image, options),
+		coordinates: parseCoordinates(rawText.coordinates, options)
+	};
+}
+function parseDictionaryUnitItemLink(rawDictionaryUnit, options) {
+	return parseBaseItemLink("dictionaryUnit", rawDictionaryUnit, options);
+}
+function parseLinks(rawLinks, options) {
+	const links = [];
+	if (rawLinks == null) return links;
+	const hierarchy = rawLinks;
+	for (const entry of collectHierarchyEntries(hierarchy)) switch (entry.category) {
+		case "tree":
+			links.push(parseTreeItemLink(entry.item, options));
+			break;
+		case "bibliography":
+			links.push(parseBibliographyItemLink(entry.item, options));
+			break;
+		case "concept":
+			links.push(parseConceptItemLink(entry.item, options));
+			break;
+		case "spatialUnit":
+			links.push(parseSpatialUnitItemLink(entry.item, options));
+			break;
+		case "period":
+			links.push(parsePeriodItemLink(entry.item, options));
+			break;
+		case "person":
+			links.push(parsePersonItemLink(entry.item, options));
+			break;
+		case "propertyVariable":
+			links.push(parsePropertyVariableItemLink(entry.item, options));
+			break;
+		case "propertyValue":
+			links.push(parsePropertyValueItemLink(entry.item, options));
+			break;
+		case "resource":
+			links.push(parseResourceItemLink(entry.item, options));
+			break;
+		case "text":
+			links.push(parseTextItemLink(entry.item, options));
+			break;
+		case "set":
+			links.push(parseSetItemLink(entry.item, options));
+			break;
+		case "dictionaryUnit":
+			links.push(parseDictionaryUnitItemLink(entry.item, options));
+			break;
+		case "heading": break;
+	}
+	return links;
+}
+function parseReverseLinks(rawLinks, options) {
+	const links = [];
+	const rawLinksToParse = rawLinks == null ? [] : Array.isArray(rawLinks) ? rawLinks : [rawLinks];
+	for (const rawLink of rawLinksToParse) links.push(...parseLinks(rawLink, options));
+	return links;
+}
+function parsePeriodList(rawPeriods, options) {
+	const periods = [];
+	for (const period of rawPeriods?.period ?? []) periods.push(parsePeriod(period, options));
+	return periods;
+}
+function parseBibliographyList(rawBibliographies, options) {
+	const bibliographies = [];
+	for (const bibliography of rawBibliographies?.bibliography ?? []) bibliographies.push(parseBibliography(bibliography, options));
+	return bibliographies;
+}
+function parsePersonList(rawPersons, options) {
+	const persons = [];
+	for (const person of rawPersons ?? []) persons.push(parsePerson(person, options));
+	return persons;
+}
+function parseInterpretation(rawInterpretation, options) {
+	return {
+		number: rawInterpretation.interpretationNo,
+		date: rawInterpretation.date ?? null,
+		observers: parsePersonList(rawInterpretation.observers?.observer, options),
+		periods: parsePeriodList(rawInterpretation.periods, options),
+		links: parseLinks(rawInterpretation.links, options),
+		notes: parseNotes(rawInterpretation.notes, options),
+		properties: parseProperties(rawInterpretation.properties, options),
+		bibliographies: parseBibliographyList(rawInterpretation.bibliographies, options)
+	};
+}
+function parseObservation(rawObservation, options) {
+	return {
+		number: rawObservation.observationNo,
+		date: rawObservation.date ?? null,
+		observers: parsePersonList(rawObservation.observers?.observer, options),
+		periods: parsePeriodList(rawObservation.periods, options),
+		links: parseLinks(rawObservation.links, options),
+		notes: parseNotes(rawObservation.notes, options),
+		properties: parseProperties(rawObservation.properties, options),
+		bibliographies: parseBibliographyList(rawObservation.bibliographies, options)
+	};
+}
+function parseSection(rawSection, options) {
+	return {
+		uuid: rawSection.uuid,
+		publicationDateTime: rawSection.publicationDateTime ?? null,
+		identification: parseIdentification(rawSection.identification, options),
+		project: rawSection.project == null ? null : { identification: parseIdentification(rawSection.project.identification, options) }
+	};
+}
+function parseSections(rawSections, options) {
+	const sections = [];
+	if (rawSections == null || !("translation" in rawSections) && !("phonemic" in rawSections)) return sections;
+	for (const translation of rawSections.translation ?? []) for (const section of translation.section) sections.push(parseSection(section, options));
+	for (const phonemic of rawSections.phonemic ?? []) for (const section of phonemic.section) sections.push(parseSection(section, options));
+	return sections;
+}
+function parseHeading(rawHeading, containedItemCategory, options) {
+	const headings = [];
+	for (const heading of rawHeading.heading ?? []) headings.push(parseHeading(heading, containedItemCategory, options));
+	return {
+		name: rawHeading.name,
+		headings,
+		items: parseItemHierarchy(rawHeading, options, [containedItemCategory])
+	};
+}
+function parseTree(rawTree, options) {
+	const childOptions = getParserOptions(options);
+	const containedItemCategory = resolveTreeItemCategory(rawTree, normalizeTreeItemCategory(options.containedItemCategory));
+	const items = [];
+	if (containedItemCategory != null) {
+		const itemCategories = [containedItemCategory];
+		if (isHeadingItemCategory(containedItemCategory)) itemCategories.push("heading");
+		for (const entry of collectHierarchyEntries(rawTree.items, itemCategories)) {
+			if (entry.category === "heading") {
+				if (!isHeadingItemCategory(containedItemCategory)) continue;
+				items.push(parseHeading(entry.item, containedItemCategory, childOptions));
+				continue;
+			}
+			const item = parseEmbeddedItemEntry(entry, childOptions);
+			if (item != null) items.push(item);
+		}
+	}
+	return {
+		...parseBaseItem("tree", rawTree, childOptions),
+		type: rawTree.type ?? null,
+		containedItemCategory,
+		links: parseLinks(rawTree.links, childOptions),
+		notes: parseNotes(rawTree.notes, childOptions),
+		properties: parseProperties(rawTree.properties, childOptions),
+		bibliographies: parseBibliographyList(rawTree.bibliographies, childOptions),
+		items
+	};
+}
+function parseSet(rawSet, options) {
+	const childOptions = getParserOptions(options);
+	const containedItemCategories = normalizeSetItemCategories(options.containedItemCategory) ?? inferItemCategories(rawSet.items);
+	return {
+		...parseBaseItem("set", rawSet, childOptions),
+		containedItemCategories,
+		isTabularStructure: rawSet.tabularStructure ?? false,
+		isSuppressingBlanks: rawSet.suppressBlanks ?? false,
+		links: parseLinks(rawSet.links, childOptions),
+		notes: parseNotes(rawSet.notes, childOptions),
+		properties: parseProperties(rawSet.properties, childOptions),
+		items: parseSetItemHierarchy(rawSet.items, childOptions, containedItemCategories)
+	};
+}
+function parseSetBibliography(rawBibliography, options) {
+	return withoutItems(withSetItemProperties(parseBibliography(rawBibliography, options), rawBibliography.properties, options));
+}
+function parseSetConcept(rawConcept, options) {
+	return {
+		...parseBaseItem("concept", rawConcept, options),
+		image: parseImage(rawConcept.image, options),
+		coordinates: parseCoordinates(rawConcept.coordinates, options),
+		properties: parseSetItemProperties(rawConcept.properties, options)
+	};
+}
+function parseSpatialUnitMapData(mapData) {
+	if (mapData == null) return null;
+	return { geoJSON: {
+		multiPolygon: mapData.geoJSON.multiPolygon.payload,
+		EPSG: mapData.geoJSON.EPSG
+	} };
+}
+function parseSetSpatialUnit(rawSpatialUnit, options) {
+	return {
+		...parseBaseItem("spatialUnit", rawSpatialUnit, options),
+		image: parseImage(rawSpatialUnit.image, options),
+		coordinates: parseCoordinates(rawSpatialUnit.coordinates, options),
+		mapData: parseSpatialUnitMapData(rawSpatialUnit.mapData),
+		properties: parseSetItemProperties(rawSpatialUnit.properties, options),
+		bibliographies: parseBibliographyList(rawSpatialUnit.bibliographies, options)
+	};
+}
+function parseSetPeriod(rawPeriod, options) {
+	return withoutItems(withSetItemProperties(parsePeriod(rawPeriod, options), rawPeriod.properties, options));
+}
+function parseSetResource(rawResource, options) {
+	return withoutItems(withSetItemProperties(parseResource(rawResource, options), rawResource.properties, options));
+}
+function parseSetTree(rawTree, options) {
+	return withoutItems(withSetItemProperties(parseTree(rawTree, options), rawTree.properties, options));
+}
+function parseSetSet(rawSet, options) {
+	return withoutItems(withSetItemProperties(parseSet(rawSet, options), rawSet.properties, options));
+}
+function parseBibliography(rawBibliography, options) {
+	const sourceItems = rawBibliography.source == null ? [] : parseLinks(rawBibliography.source, options);
+	const bibliographies = parseBibliographyList(rawBibliography.bibliographies, options);
+	const items = [];
+	for (const bibliography of rawBibliography.bibliography ?? []) items.push(parseBibliography(bibliography, options));
+	const baseBibliography = {
+		...parseBaseItem("bibliography", rawBibliography, options),
+		citationDetails: rawBibliography.citationDetails ?? null,
+		citationFormat: parseContentLike(rawBibliography.citationFormat, options),
+		citationFormatSpan: parseStringLike(rawBibliography.citationFormatSpan),
+		referenceFormatDiv: parseStringLike(rawBibliography.referenceFormatDiv),
+		image: parseImage(rawBibliography.image, options),
+		sourceDocument: parseBibliographySourceDocument(rawBibliography.sourceDocument),
+		publicationInfo: rawBibliography.publicationInfo == null ? null : {
+			publishers: parsePersonList(rawBibliography.publicationInfo.publishers == null ? void 0 : "publisher" in rawBibliography.publicationInfo.publishers ? rawBibliography.publicationInfo.publishers.publisher : rawBibliography.publicationInfo.publishers.publishers.person, options),
+			startDate: parseBibliographyStartDate(rawBibliography.publicationInfo.startDate)
+		},
+		entryInfo: parseBibliographyEntryInfo(rawBibliography.entryInfo),
+		source: sourceItems[0] == null ? null : sourceItems[0],
+		authors: parsePersonList(rawBibliography.authors?.person, options),
+		periods: parsePeriodList(rawBibliography.periods, options),
+		links: parseLinks(rawBibliography.links, options),
+		notes: parseNotes(rawBibliography.notes, options),
+		properties: parseProperties(rawBibliography.properties, options),
+		bibliographies,
+		items
+	};
+	if (rawBibliography.type === "zotero" && rawBibliography.zoteroId != null) return {
+		...baseBibliography,
+		type: "zotero",
+		zoteroId: rawBibliography.zoteroId
+	};
+	return {
+		...baseBibliography,
+		type: rawBibliography.type ?? null
+	};
+}
+function parseConcept(rawConcept, options) {
+	const interpretations = [];
+	for (const interpretation of rawConcept.interpretations?.interpretation ?? []) interpretations.push(parseInterpretation(interpretation, options));
+	const items = [];
+	for (const concept of rawConcept.concept ?? []) items.push(parseConcept(concept, options));
+	return {
+		...parseBaseItem("concept", rawConcept, options),
+		image: parseImage(rawConcept.image, options),
+		interpretations,
+		coordinates: parseCoordinates(rawConcept.coordinates, options),
+		items
+	};
+}
+function parseSpatialUnit(rawSpatialUnit, options) {
+	const observations = [];
+	for (const observation of rawSpatialUnit.observations?.observation ?? []) observations.push(parseObservation(observation, options));
+	const items = [];
+	for (const spatialUnit of rawSpatialUnit.spatialUnit ?? []) items.push(parseSpatialUnit(spatialUnit, options));
+	return {
+		...parseBaseItem("spatialUnit", rawSpatialUnit, options),
+		image: parseImage(rawSpatialUnit.image, options),
+		coordinates: parseCoordinates(rawSpatialUnit.coordinates, options),
+		mapData: parseSpatialUnitMapData(rawSpatialUnit.mapData),
+		observations,
+		bibliographies: parseBibliographyList(rawSpatialUnit.bibliographies, options),
+		items
+	};
+}
+function parsePeriod(rawPeriod, options) {
+	const items = [];
+	for (const period of rawPeriod.period ?? []) items.push(parsePeriod(period, options));
+	return {
+		...parseBaseItem("period", rawPeriod, options),
+		type: rawPeriod.type ?? null,
+		coordinates: parseCoordinates(rawPeriod.coordinates, options),
+		links: parseLinks(rawPeriod.links, options),
+		notes: parseNotes(rawPeriod.notes, options),
+		properties: parseProperties(rawPeriod.properties, options),
+		bibliographies: parseBibliographyList(rawPeriod.bibliographies, options),
+		items
+	};
+}
+function parsePerson(rawPerson, options) {
+	return {
+		...parseBaseItem("person", rawPerson, options),
+		type: rawPerson.type ?? "",
+		image: parseImage(rawPerson.image, options),
+		address: rawPerson.address == null ? null : {
+			country: parseStringLike(rawPerson.address.country),
+			city: parseStringLike(rawPerson.address.city),
+			state: parseStringLike(rawPerson.address.state),
+			postalCode: parseStringLike(rawPerson.address.postalCode)
+		},
+		coordinates: parseCoordinates(rawPerson.coordinates, options),
+		content: rawPerson.content == null ? null : parseRequiredContentLike(rawPerson, options),
+		periods: parsePeriodList(rawPerson.periods, options),
+		links: parseLinks(rawPerson.links, options),
+		notes: parseNotes(rawPerson.notes, options),
+		properties: parseProperties(rawPerson.properties, options)
+	};
+}
+function parsePropertyVariable(rawPropertyVariable, options) {
+	return {
+		...parseBaseItem("propertyVariable", rawPropertyVariable, options),
+		type: rawPropertyVariable.type ?? null,
+		coordinates: parseCoordinates(rawPropertyVariable.coordinates, options),
+		links: parseLinks(rawPropertyVariable.links, options),
+		notes: parseNotes(rawPropertyVariable.notes, options),
+		bibliographies: parseBibliographyList(rawPropertyVariable.bibliographies, options)
+	};
+}
+function parsePropertyValue(rawPropertyValue, options) {
+	return {
+		...parseBaseItem("propertyValue", rawPropertyValue, options),
+		coordinates: parseCoordinates(rawPropertyValue.coordinates, options),
+		links: parseLinks(rawPropertyValue.links, options),
+		notes: parseNotes(rawPropertyValue.notes, options),
+		properties: parseProperties(rawPropertyValue.properties, options),
+		bibliographies: parseBibliographyList(rawPropertyValue.bibliographies, options)
+	};
+}
+function parseResource(rawResource, options) {
+	const items = [];
+	for (const resource of rawResource.resource ?? []) items.push(parseResource(resource, options));
+	return {
+		...parseBaseItem("resource", rawResource, options),
+		type: rawResource.type ?? "",
+		href: parseHref(rawResource.href),
+		fileFormat: rawResource.fileFormat ?? null,
+		fileSize: rawResource.fileSize ?? null,
+		isInline: rawResource.rend === "inline",
+		height: rawResource.height ?? null,
+		width: rawResource.width ?? null,
+		image: parseImage(rawResource.image, options),
+		document: parseContentLike(rawResource.document, options),
+		imageMap: parseImageMap(rawResource.imagemap),
+		coordinates: parseCoordinates(rawResource.coordinates, options),
+		periods: parsePeriodList(rawResource.periods, options),
+		links: parseLinks(rawResource.links, options),
+		reverseLinks: parseReverseLinks(rawResource.reverseLinks, options),
+		notes: parseNotes(rawResource.notes, options),
+		properties: parseProperties(rawResource.properties, options),
+		bibliographies: parseBibliographyList(rawResource.bibliographies, options),
+		items
+	};
+}
+function parseText(rawText, options) {
+	const editions = [];
+	for (const edition of rawText.editions?.edition ?? []) editions.push(parsePerson(edition, options));
+	for (const editor of rawText.editions?.editor ?? []) editions.push(parsePerson(editor, options));
+	for (const publisher of rawText.editions?.publisher ?? []) editions.push(parsePerson(publisher, options));
+	return {
+		...parseBaseItem("text", rawText, options),
+		type: rawText.type ?? "",
+		text: rawText.text ?? null,
+		language: rawText.language ?? null,
+		image: parseImage(rawText.image, options),
+		coordinates: parseCoordinates(rawText.coordinates, options),
+		links: parseLinks(rawText.links, options),
+		reverseLinks: parseReverseLinks(rawText.reverseLinks, options),
+		notes: parseNotes(rawText.notes, options),
+		sections: parseSections(rawText.sections, options),
+		periods: parsePeriodList(rawText.periods, options),
+		creators: parsePersonList(rawText.creators?.creator, options),
+		editions
+	};
+}
+function parseMetadataLanguages(rawOchre) {
+	const languages = [];
+	for (const language of rawOchre.metadata.language ?? []) {
+		const parsedLanguage = parseStringLike(language);
+		if (parsedLanguage != null) languages.push(parsedLanguage);
+	}
+	if (languages.length > 0) return languages;
+	if (rawOchre.languages != null) {
+		for (const language of rawOchre.languages.split(";")) if (language !== "") languages.push(language);
+	}
+	return languages.length > 0 ? languages : [...DEFAULT_LANGUAGES];
+}
+function resolveLanguages(requestedLanguages, metadataLanguages) {
+	if (requestedLanguages.length === 0) return metadataLanguages;
+	const unsupportedLanguages = [];
+	for (const requestedLanguage of requestedLanguages) if (!metadataLanguages.some((metadataLanguage) => metadataLanguage.toLocaleLowerCase("en-US") === requestedLanguage.toLocaleLowerCase("en-US"))) unsupportedLanguages.push(requestedLanguage);
+	if (unsupportedLanguages.length > 0) throw new Error(`The following language(s) are not supported by the dataset: ${unsupportedLanguages.toSorted((a, b) => a.localeCompare(b, "en-US")).join(", ")}. Available languages: ${metadataLanguages.toSorted((a, b) => a.localeCompare(b, "en-US")).join(", ")}`, { cause: unsupportedLanguages });
+	return requestedLanguages;
+}
+function resolveDefaultLanguage(rawOchre, languages) {
+	for (const language of rawOchre.metadata.language ?? []) {
+		const parsedLanguage = parseStringLike(language);
+		if (parsedLanguage != null && language.default === "true" && languages.includes(parsedLanguage)) return parsedLanguage;
+	}
+	for (const language of languages) if (language === DEFAULT_LANGUAGES[0]) return language;
+	const firstLanguage = languages[0];
+	if (firstLanguage == null) throw new Error("Default language not found", { cause: languages });
+	return firstLanguage;
+}
+function parseMetadataPublisher(rawPublisher) {
+	return parseStringLike(Array.isArray(rawPublisher) ? rawPublisher[0] : rawPublisher) ?? "";
+}
+function parseMetadata(rawOchre, options, defaultLanguage) {
+	const metadataOptions = options;
+	const rawMetadata = rawOchre.metadata;
+	return {
+		dataset: parseStringLike(rawMetadata.dataset) ?? "",
+		description: parseStringLike(rawMetadata.description) ?? "",
+		publisher: parseMetadataPublisher(rawMetadata.publisher),
+		identifier: transformPermanentIdentificationUrl(parseStringLike(rawMetadata.identifier) ?? ""),
+		project: rawMetadata.project == null ? null : {
+			uuid: rawMetadata.project.uuid ?? rawOchre.uuidBelongsTo,
+			identification: parseIdentification(rawMetadata.project.identification, metadataOptions),
+			website: parseStringLike(rawMetadata.project.identification.website),
+			dateFormat: rawMetadata.project.dateFormat ?? null,
+			page: rawMetadata.project.page ?? null
+		},
+		collection: rawMetadata.collection == null ? null : {
+			uuid: rawMetadata.collection.uuid,
+			identification: parseIdentification(rawMetadata.collection.identification, metadataOptions),
+			page: rawMetadata.collection.page
+		},
+		publication: rawMetadata.publication == null ? null : {
+			uuid: rawMetadata.publication.uuid,
+			identification: parseIdentification(rawMetadata.publication.identification, metadataOptions),
+			page: rawMetadata.publication.page
+		},
+		item: rawMetadata.item == null ? null : {
+			identification: parseIdentification(rawMetadata.item.identification, metadataOptions),
+			category: normalizeCategory(rawMetadata.item.category) ?? rawMetadata.item.category,
+			type: rawMetadata.item.type,
+			maxLength: rawMetadata.item.maxLength ?? null
+		},
+		defaultLanguage,
+		languages: options.languages
+	};
+}
+function inferTopLevelCategory(rawOchre) {
+	for (const category of SET_ITEM_CATEGORIES) if (category in rawOchre) return category;
+	if ("variable" in rawOchre) return "propertyVariable";
+	if ("value" in rawOchre) return "propertyValue";
+	throw new Error("Could not infer OCHRE item category", { cause: rawOchre });
+}
+function getSingleTopLevelRawItem(items, category) {
+	if (items == null || items.length === 0) throw new Error(`${category} not found`, { cause: items });
+	if (items.length > 1) throw new Error(`Expected one ${category}, received ${items.length}`, { cause: items });
+	return items[0];
+}
+function parseTopLevelItem(rawOchre, category, options) {
+	switch (category) {
+		case "tree": return parseTree(getSingleTopLevelRawItem("tree" in rawOchre ? rawOchre.tree : null, "tree"), {
+			...options,
+			containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
+		});
+		case "bibliography": return parseBibliography(getSingleTopLevelRawItem("bibliography" in rawOchre ? rawOchre.bibliography : null, "bibliography"), options);
+		case "concept": return parseConcept(getSingleTopLevelRawItem("concept" in rawOchre ? rawOchre.concept : null, "concept"), options);
+		case "spatialUnit": return parseSpatialUnit(getSingleTopLevelRawItem("spatialUnit" in rawOchre ? rawOchre.spatialUnit : null, "spatial unit"), options);
+		case "period": return parsePeriod(getSingleTopLevelRawItem("period" in rawOchre ? rawOchre.period : null, "period"), options);
+		case "person": return parsePerson(getSingleTopLevelRawItem("person" in rawOchre ? rawOchre.person : null, "person"), options);
+		case "propertyVariable": return parsePropertyVariable(getSingleTopLevelRawItem("propertyVariable" in rawOchre ? rawOchre.propertyVariable : "variable" in rawOchre ? rawOchre.variable : null, "property variable"), options);
+		case "propertyValue": return parsePropertyValue(getSingleTopLevelRawItem("propertyValue" in rawOchre ? rawOchre.propertyValue : "value" in rawOchre ? rawOchre.value : null, "property value"), options);
+		case "resource": return parseResource(getSingleTopLevelRawItem("resource" in rawOchre ? rawOchre.resource : null, "resource"), options);
+		case "text": return parseText(getSingleTopLevelRawItem("text" in rawOchre ? rawOchre.text : null, "text"), options);
+		case "set": return parseSet(getSingleTopLevelRawItem("set" in rawOchre ? rawOchre.set : null, "set"), options);
+	}
+}
+function parseLinkedItems(rawItems, options) {
+	const parserOptions = {
+		languages: options.languages,
+		containedItemCategory: options.containedItemCategory
+	};
+	const items = [];
+	for (const entry of collectHierarchyEntries(rawItems)) {
+		const item = parseEmbeddedItemEntry(entry, parserOptions);
+		if (item != null) items.push(item);
+	}
+	return items;
+}
+function parseSetItems(rawItems, options) {
+	return parseSetItemHierarchy(rawItems, { languages: options.languages }, normalizeSetItemCategories(options.containedItemCategories) ?? void 0);
+}
+function parseGallery(rawData, options) {
+	const gallery = rawData.result.ochre.gallery;
+	const resources = [];
+	for (const resource of gallery.resource ?? []) resources.push(parseResource(resource, options));
+	return {
+		identification: parseIdentification(gallery.item.identification, options),
+		projectIdentification: parseIdentification(gallery.project.identification, options),
+		resources,
+		maxLength: gallery.maxLength
+	};
+}
+function parseItem(rawData, options) {
+	const rawOchre = rawData.result.ochre;
+	const metadataLanguages = parseMetadataLanguages(rawOchre);
+	const languagesToUse = resolveLanguages(options.languages, metadataLanguages);
+	const parserOptions = {
+		languages: languagesToUse,
+		containedItemCategory: options.containedItemCategory
+	};
+	const category = options.category ?? normalizeCategory(rawOchre.metadata.item?.category) ?? inferTopLevelCategory(rawOchre);
+	const defaultLanguage = resolveDefaultLanguage(rawOchre, languagesToUse);
+	const belongsTo = {
+		uuid: rawOchre.uuidBelongsTo,
+		abbreviation: rawOchre.belongsTo
+	};
+	const metadata = parseMetadata(rawOchre, parserOptions, defaultLanguage);
+	const persistentUrl = parseHref(rawOchre.persistentUrl);
+	const item = parseTopLevelItem(rawOchre, category, parserOptions);
+	if (category === "resource") {
+		const rawResource = getSingleTopLevelRawItem("resource" in rawOchre ? rawOchre.resource : null, "resource");
+		return {
+			...item,
+			belongsTo,
+			metadata,
+			persistentUrl,
+			view: options.parseResourceView?.(rawResource.view, {
+				belongsTo,
+				metadata
+			}) ?? null
+		};
+	}
+	return {
+		...item,
+		belongsTo,
+		metadata,
+		persistentUrl
+	};
+}
+//#endregion
+export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };