ochre-sdk 1.0.78 → 1.1.0

package/dist/parsers/helpers.d.mts

@@ -6,14 +6,34 @@ export type FetchFunction = (input: string | URL | globalThis.Request, init?: Re
 export type FetchBaseOptions<TLanguages extends ReadonlyArray<string> | undefined = undefined> = {
   languages?: TLanguages;
   fetch?: FetchFunction;
+  signal?: AbortSignal;
+  timeoutMilliseconds?: number;
 };
 export type FetchRuntimeOptions = FetchBaseOptions<ReadonlyArray<string>>;
 export type FetchLanguages<TLanguages extends ReadonlyArray<string> | undefined> = TLanguages extends readonly [] ? ReadonlyArray<string> : TLanguages extends ReadonlyArray<string> ? TLanguages : ReadonlyArray<string>;
 export type ParserOptions<T extends ReadonlyArray<string>> = {
   languages: T;
+  /**
+   * The language the dataset declares as its default
+   *
+   * Threaded into every {@link MultilingualString} so a read with no language
+   * resolves to the dataset's default rather than whichever language happens to
+   * come first in the payload.
+   */
+  defaultLanguage?: T[number];
 };
 export declare function getParserOptions<T extends ReadonlyArray<string>>(options: ParserOptions<T>): ParserOptions<T>;
-export declare function cleanObject<T extends Record<string, unknown>>(object: T): Partial<T>;
+/**
+ * Drop the keys whose value is undefined
+ *
+ * Constrained to `object` rather than `Record<string, unknown>`, which an
+ * interface never satisfies for want of an index signature. `Object.entries`
+ * cannot be typed precisely, so the one cast that costs is here rather than at
+ * the call site.
+ * @param object - The object to clean
+ * @returns A copy carrying only the defined keys
+ */
+export declare function cleanObject<T extends object>(object: T): Partial<T>;
 export declare function parseLicense(availability: {
   license: XMLString & {
     target?: string;

package/dist/parsers/helpers.mjs

@@ -4,11 +4,25 @@ import { parseXMLContent, parseXMLString } from "./string.mjs";
 //#region src/parsers/helpers.ts
 const FALLBACK_PARSER_OPTIONS = { languages: DEFAULT_LANGUAGES };
 function getParserOptions(options) {
-	return { languages: options.languages };
+	return {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	};
 }
+/**
+* Drop the keys whose value is undefined
+*
+* Constrained to `object` rather than `Record<string, unknown>`, which an
+* interface never satisfies for want of an index signature. `Object.entries`
+* cannot be typed precisely, so the one cast that costs is here rather than at
+* the call site.
+* @param object - The object to clean
+* @returns A copy carrying only the defined keys
+*/
 function cleanObject(object) {
+	const entries = Object.entries(object);
 	const cleaned = {};
-	for (const [key, value] of Object.entries(object)) if (value !== void 0) cleaned[key] = value;
+	for (const [key, value] of entries) if (value !== void 0) cleaned[key] = value;
 	return cleaned;
 }
 function parseLicense(availability) {
@@ -29,16 +43,19 @@ function isXMLContent(value) {
 function multilingualFromText(text, options) {
 	const content = {};
 	for (const language of options.languages) content[language] = text;
-	return MultilingualString.fromObject(content, options.languages);
+	return MultilingualString.fromObject(content, options.languages, { defaultLanguage: options.defaultLanguage });
 }
 function parseContentLike(value, options) {
 	if (value == null) return null;
 	if (typeof value === "string") return multilingualFromText(value, options);
 	if (!isXMLContent(value)) return multilingualFromText(parseXMLString(value), options);
-	return parseXMLContent(value, { languages: options.languages });
+	return parseXMLContent(value, {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	});
 }
 function parseRequiredContentLike(value, options) {
-	return parseContentLike(value, options) ?? MultilingualString.empty(options.languages);
+	return parseContentLike(value, options) ?? MultilingualString.empty(options.languages, { defaultLanguage: options.defaultLanguage });
 }
 function parseContentLikeText(value, options) {
 	return parseContentLike(value, options)?.getText().trim() ?? "";
@@ -46,7 +63,10 @@ function parseContentLikeText(value, options) {
 function parseStringContent(value, options = FALLBACK_PARSER_OPTIONS) {
 	if (value == null) return "";
 	if (typeof value === "string") return value;
-	if (isXMLContent(value)) return parseXMLContent(value, { languages: options.languages }).getText();
+	if (isXMLContent(value)) return parseXMLContent(value, {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	}).getText();
 	return parseXMLString(value).text;
 }
 //#endregion

package/dist/parsers/index.d.mts

@@ -21,14 +21,6 @@ export declare function parseBibliographyList<T extends ReadonlyArray<string>>(r
   bibliography: Array<XMLBibliography>;
 } | undefined, options: ParserOptions<T>): Array<Bibliography<T, "embedded">>;
 export declare function parsePersonList<T extends ReadonlyArray<string>>(rawPersons: Array<XMLPerson> | undefined, options: ParserOptions<T>): Array<Person<T, "embedded">>;
-export declare function parseMetadataLanguages(rawOchre: {
-  metadata: XMLMetadata;
-  languages?: string;
-}): Array<string>;
-export declare function resolveLanguages<T extends ReadonlyArray<string>>(requestedLanguages: T | undefined, metadataLanguages: Array<string>): T;
-export declare function resolveDefaultLanguage<T extends ReadonlyArray<string>>(rawOchre: {
-  metadata: XMLMetadata;
-}, languages: T): T[number];
 export declare function parseMetadata<T extends ReadonlyArray<string>>(rawOchre: {
   uuidBelongsTo: string;
   metadata: XMLMetadata;

package/dist/parsers/index.mjs

@@ -1,8 +1,12 @@
-import { DEFAULT_LANGUAGES } from "../constants.mjs";
-import { MultilingualString } from "./multilingual.mjs";
+import { CONTEXT_CATEGORY_ALIASES, ITEM_CATEGORY_BY_ALIAS, ITEM_CATEGORY_FACTS, SET_ITEM_CATEGORIES, isHeadingItemCategory, normalizeItemCategory } from "../categories.mjs";
+import { readEntries, readProperty } from "../reflection.mjs";
 import { getXMLSourceIndex } from "../xml/metadata.mjs";
+import { MultilingualString } from "./multilingual.mjs";
+import { readPropertyValueText } from "./property-token.mjs";
 import { parseXMLString, transformPermanentIdentificationUrl } from "./string.mjs";
 import { getParserOptions, multilingualFromText, parseContentLike, parseContentLikeText, parseLicense, parseRequiredContentLike, parseStringLike } from "./helpers.mjs";
+import { parseMetadataLanguages, resolveDefaultLanguage, resolveLanguages } from "./languages.mjs";
+import * as v from "valibot";
 //#region src/parsers/index.ts
 function isXMLContextGroup(context) {
 	return "context" in context;
@@ -10,68 +14,82 @@ function isXMLContextGroup(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"
+const ITEM_CATEGORIES = {
+	tree: {
+		parseEmbedded: (item, options) => parseTree(item, {
+			...options,
+			containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
+		}),
+		parseSetItem: (item, options) => parseSetTree(item, options),
+		parseLink: (item, options) => parseTreeItemLink(item, options)
+	},
+	bibliography: {
+		parseEmbedded: (item, options) => parseBibliography(item, options),
+		parseSetItem: (item, options) => parseSetBibliography(item, options),
+		parseLink: (item, options) => parseBibliographyItemLink(item, options)
+	},
+	concept: {
+		parseEmbedded: (item, options) => parseConcept(item, options),
+		parseSetItem: (item, options) => parseSetConcept(item, options),
+		parseLink: (item, options) => parseConceptItemLink(item, options)
+	},
+	spatialUnit: {
+		parseEmbedded: (item, options) => parseSpatialUnit(item, options),
+		parseSetItem: (item, options) => parseSetSpatialUnit(item, options),
+		parseLink: (item, options) => parseSpatialUnitItemLink(item, options)
 	},
-	{
-		raw: "concept",
-		parsed: "concept"
+	period: {
+		parseEmbedded: (item, options) => parsePeriod(item, options),
+		parseSetItem: (item, options) => parseSetPeriod(item, options),
+		parseLink: (item, options) => parsePeriodItemLink(item, options)
 	},
-	{
-		raw: "spatialUnit",
-		parsed: "spatialUnit"
+	person: {
+		parseEmbedded: (item, options) => parsePerson(item, options),
+		parseSetItem: (item, options) => {
+			const person = item;
+			return withSetItemProperties(parsePerson(person, options), person.properties, options);
+		},
+		parseLink: (item, options) => parsePersonItemLink(item, options)
 	},
-	{
-		raw: "period",
-		parsed: "period"
+	propertyVariable: {
+		parseEmbedded: (item, options) => parsePropertyVariable(item, options),
+		parseSetItem: (item, options) => parsePropertyVariable(item, options),
+		parseLink: (item, options) => parsePropertyVariableItemLink(item, options)
 	},
-	{
-		raw: "propertyVariable",
-		parsed: "propertyVariable"
+	propertyValue: {
+		parseEmbedded: (item, options) => parsePropertyValue(item, options),
+		parseSetItem: (item, options) => {
+			const propertyValue = item;
+			return withSetItemProperties(parsePropertyValue(propertyValue, options), propertyValue.properties, options);
+		},
+		parseLink: (item, options) => parsePropertyValueItemLink(item, options)
 	},
-	{
-		raw: "variable",
-		parsed: "propertyVariable"
+	resource: {
+		parseEmbedded: (item, options) => parseResource(item, options),
+		parseSetItem: (item, options) => parseSetResource(item, options),
+		parseLink: (item, options) => parseResourceItemLink(item, options)
 	},
-	{
-		raw: "propertyValue",
-		parsed: "propertyValue"
+	text: {
+		parseEmbedded: (item, options) => parseText(item, options),
+		parseSetItem: (item, options) => parseText(item, options),
+		parseLink: (item, options) => parseTextItemLink(item, options)
 	},
-	{
-		raw: "value",
-		parsed: "propertyValue"
+	set: {
+		parseEmbedded: (item, options) => parseSet(item, options),
+		parseSetItem: (item, options) => parseSetSet(item, options),
+		parseLink: (item, options) => parseSetItemLink(item, options)
 	},
-	{
-		raw: "resource",
-		parsed: "resource"
+	dictionaryUnit: {
+		parseEmbedded: null,
+		parseSetItem: null,
+		parseLink: (item, options) => parseDictionaryUnitItemLink(item, options)
 	},
-	{
-		raw: "text",
-		parsed: "text"
+	heading: {
+		parseEmbedded: null,
+		parseSetItem: null,
+		parseLink: null
 	}
-];
+};
 const PROPERTY_DATA_TYPES = [
 	"string",
 	"coordinate",
@@ -128,12 +146,12 @@ function parseContextNode(rawContextItem) {
 	};
 	const headings = rawContextItem.heading ?? [];
 	for (const heading of headings) node.heading.push(parseContextItem(heading));
-	for (const { raw, parsed } of CONTEXT_CATEGORY_MAPPINGS) {
-		const contextValues = rawContextItem[raw] ?? [];
+	for (const { alias, category } of CONTEXT_CATEGORY_ALIASES) {
+		const contextValues = rawContextItem[alias] ?? [];
 		for (const contextValue of contextValues) {
-			const parsedItems = node[parsed] ?? [];
+			const parsedItems = node[category] ?? [];
 			parsedItems.push(parseContextItem(contextValue));
-			node[parsed] = parsedItems;
+			node[category] = parsedItems;
 		}
 	}
 	return node;
@@ -176,7 +194,7 @@ function parseEvent(rawEvent, options) {
 		location: parseEventReference(rawEvent.location, options),
 		other: rawEvent.other == null ? null : {
 			uuid: rawEvent.other.uuid ?? null,
-			category: normalizeCategory(rawEvent.other.category),
+			category: normalizeItemCategory(rawEvent.other.category),
 			label: parseRequiredContentLike(rawEvent.other, options)
 		}
 	};
@@ -202,44 +220,26 @@ function parseBaseItem(category, rawItem, 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;
-}
+	return ITEM_CATEGORY_BY_ALIAS.get(key) ?? null;
+}
+/**
+* A group element wrapping child resources rather than being one itself
+*
+* A schema rather than a hand-written predicate: `v.is` narrows to exactly what
+* it checked, and a wrapper is distinguished from a resource by carrying no
+* `uuid`, which the `undefined` entry states rather than leaving to a
+* `!("uuid" in value)` test whose false branch means nothing in particular.
+*/
+const resourceWrapperSchema = v.looseObject({
+	uuid: v.undefined(),
+	resource: v.array(v.unknown())
+});
 function isResourceWrapper(value) {
-	return isRecord(value) && !("uuid" in value) && Array.isArray(value.resource);
+	return v.is(resourceWrapperSchema, value);
 }
 function sourceOrderSort(left, right) {
 	const leftIndex = getXMLSourceIndex(left.item);
@@ -249,9 +249,8 @@ function sourceOrderSort(left, right) {
 }
 function collectHierarchyEntries(hierarchy, categories) {
 	const entries = [];
-	if (hierarchy == null) return entries;
 	let fallbackIndex = 0;
-	for (const [key, values] of Object.entries(hierarchy)) {
+	for (const [key, values] of readEntries(hierarchy)) {
 		const category = getHierarchyEntryCategory(key);
 		if (category == null || !(categories == null || categories.includes(category))) continue;
 		if (!Array.isArray(values)) continue;
@@ -458,8 +457,7 @@ function parsePropertyDataType(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 contentText = readPropertyValueText(value, () => rawLabel?.getText() ?? null);
 	const common = {
 		hierarchy: {
 			isLeaf: value.inherited == null || !value.inherited,
@@ -563,24 +561,8 @@ function withoutItems(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;
-	}
+	const parse = ITEM_CATEGORIES[entry.category].parseEmbedded;
+	return parse == null ? null : parse(entry.item, options);
 }
 function parseItemHierarchy(hierarchy, options, categories) {
 	const items = [];
@@ -594,52 +576,19 @@ function parseItemHierarchy(hierarchy, options, categories) {
 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));
+	for (const entry of collectHierarchyEntries(hierarchy, categories)) {
+		const parse = ITEM_CATEGORIES[entry.category].parseSetItem;
+		if (parse != null) items.push(parse(entry.item, options));
 	}
 	return items;
 }
 function normalizeTreeLinkItemsCategory(type) {
-	const category = normalizeCategory(type);
+	const category = normalizeItemCategory(type);
 	if (category === "tree" || category == null) return null;
 	return category;
 }
 function normalizeSetLinkItemsCategory(type) {
-	const category = normalizeCategory(type);
+	const category = normalizeItemCategory(type);
 	return category == null ? null : [category];
 }
 function parseBaseItemLink(category, rawItem, options) {
@@ -794,41 +743,9 @@ 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));
+	for (const entry of collectHierarchyEntries(hierarchy)) {
+		const parse = ITEM_CATEGORIES[entry.category].parseLink;
+		if (parse != null) links.push(parse(entry.item, options));
 	}
 	return links;
 }
@@ -1149,37 +1066,6 @@ function parseText(rawText, options) {
 		editions
 	};
 }
-function parseMetadataLanguages(rawOchre) {
-	const languages = [];
-	const metadataLanguages = rawOchre.metadata.language ?? [];
-	for (const language of metadataLanguages) {
-		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 == null || 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) {
-	const metadataLanguages = rawOchre.metadata.language ?? [];
-	for (const language of metadataLanguages) {
-		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) {
 	const publisher = Array.isArray(rawPublisher) ? rawPublisher[0] : rawPublisher;
 	return parseStringLike(publisher) ?? "";
@@ -1211,7 +1097,7 @@ function parseMetadata(rawOchre, options, defaultLanguage) {
 		},
 		item: rawMetadata.item == null ? null : {
 			identification: parseIdentification(rawMetadata.item.identification, metadataOptions),
-			category: normalizeCategory(rawMetadata.item.category) ?? rawMetadata.item.category,
+			category: normalizeItemCategory(rawMetadata.item.category) ?? rawMetadata.item.category,
 			type: rawMetadata.item.type,
 			maxLength: rawMetadata.item.maxLength ?? null
 		},
@@ -1231,45 +1117,17 @@ function getSingleTopLevelRawItem(items, category) {
 	return items[0];
 }
 function parseTopLevelItem(rawOchre, category, options) {
-	const rawItems = rawOchre;
-	let parsedItem;
-	switch (category) {
-		case "tree":
-			parsedItem = parseTree(getSingleTopLevelRawItem(rawItems.tree, "tree"), {
-				...options,
-				containedItemCategory: normalizeTreeItemCategory(options.containedItemCategory)
-			});
-			break;
-		case "bibliography":
-			parsedItem = parseBibliography(getSingleTopLevelRawItem(rawItems.bibliography, "bibliography"), options);
-			break;
-		case "concept":
-			parsedItem = parseConcept(getSingleTopLevelRawItem(rawItems.concept, "concept"), options);
-			break;
-		case "spatialUnit":
-			parsedItem = parseSpatialUnit(getSingleTopLevelRawItem(rawItems.spatialUnit, "spatial unit"), options);
-			break;
-		case "period":
-			parsedItem = parsePeriod(getSingleTopLevelRawItem(rawItems.period, "period"), options);
-			break;
-		case "person":
-			parsedItem = parsePerson(getSingleTopLevelRawItem(rawItems.person, "person"), options);
-			break;
-		case "propertyVariable":
-			parsedItem = parsePropertyVariable(getSingleTopLevelRawItem(rawItems.propertyVariable ?? rawItems.variable, "property variable"), options);
+	const entry = ITEM_CATEGORIES[category];
+	const facts = ITEM_CATEGORY_FACTS[category];
+	let rawCategoryItems;
+	for (const alias of facts.aliases) {
+		const aliasItems = readProperty(rawOchre, alias);
+		if (Array.isArray(aliasItems)) {
+			rawCategoryItems = aliasItems;
 			break;
-		case "propertyValue":
-			parsedItem = parsePropertyValue(getSingleTopLevelRawItem(rawItems.propertyValue ?? rawItems.value, "property value"), options);
-			break;
-		case "resource":
-			parsedItem = parseResource(getSingleTopLevelRawItem(rawItems.resource, "resource"), options);
-			break;
-		case "text":
-			parsedItem = parseText(getSingleTopLevelRawItem(rawItems.text, "text"), options);
-			break;
-		case "set": parsedItem = parseSet(getSingleTopLevelRawItem(rawItems.set, "set"), options);
+		}
 	}
-	return parsedItem;
+	return entry.parseEmbedded(getSingleTopLevelRawItem(rawCategoryItems, facts.label), options);
 }
 function parseLinkedItems(rawItems, options) {
 	const parserOptions = {
@@ -1300,11 +1158,13 @@ function parseItem(rawData, options) {
 	const rawOchre = rawData.result.ochre;
 	const metadataLanguages = parseMetadataLanguages(rawOchre);
 	const languagesToUse = resolveLanguages(options.languages, metadataLanguages);
+	const defaultLanguage = resolveDefaultLanguage(rawOchre, languagesToUse);
 	const parserOptions = {
 		languages: languagesToUse,
+		defaultLanguage,
 		containedItemCategory: options.containedItemCategory
 	};
-	const inferredCategory = normalizeCategory(rawOchre.metadata.item?.category) ?? inferTopLevelCategory(rawOchre);
+	const inferredCategory = normalizeItemCategory(rawOchre.metadata.item?.category) ?? inferTopLevelCategory(rawOchre);
 	let category = inferredCategory;
 	if (options.category != null) {
 		if (typeof options.category === "string") category = options.category;
@@ -1313,7 +1173,6 @@ function parseItem(rawData, options) {
 			categories: options.category
 		} });
 	}
-	const defaultLanguage = resolveDefaultLanguage(rawOchre, languagesToUse);
 	const belongsTo = {
 		uuid: rawOchre.uuidBelongsTo,
 		abbreviation: rawOchre.belongsTo
@@ -1342,4 +1201,4 @@ function parseItem(rawData, options) {
 	};
 }
 //#endregion
-export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };
+export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike };