ochre-sdk 1.0.78 → 1.1.0

package/dist/parsers/multilingual.mjs

@@ -1,4 +1,5 @@
 import { DEFAULT_LANGUAGES } from "../constants.mjs";
+import { readProperty } from "../reflection.mjs";
 import { serializeMDXText } from "./mdx.mjs";
 //#region src/parsers/multilingual.ts
 const MULTILINGUAL_STRING_INTERNAL_INIT = Symbol("MultilingualString.internalInit");
@@ -56,8 +57,28 @@ function getImplicitLanguages(content, options) {
 	for (const language of Object.keys(content)) if (!languages.includes(language)) languages.push(language);
 	return languages.length > 0 ? languages : [...DEFAULT_LANGUAGES];
 }
+/**
+* Pick the language reads should fall back to first
+* @param availableLanguages - The languages carrying content, in order
+* @param supportedLanguages - Every language the string was created for
+* @returns The default language
+*/
+function resolveDefaultLanguageOption(availableLanguages, supportedLanguages) {
+	return availableLanguages[0] ?? supportedLanguages[0] ?? DEFAULT_LANGUAGES[0];
+}
+/**
+* Whether a constructor argument is the module's own normalized init
+*
+* The assertion is earned by the brand rather than by inspecting the fields:
+* {@link MULTILINGUAL_STRING_INTERNAL_INIT} is a module-private symbol, so no
+* caller outside this file can produce a value carrying it, and the single
+* producer is `fromNormalized`. That is what makes the narrowing sound; a
+* field-by-field check would only re-state what the brand already guarantees.
+* @param value - The constructor argument
+* @returns True when the value carries the internal brand
+*/
 function isInternalInit(value) {
-	return typeof value === "object" && value != null && Object.hasOwn(value, MULTILINGUAL_STRING_INTERNAL_INIT);
+	return readProperty(value, MULTILINGUAL_STRING_INTERNAL_INIT) === true;
 }
 /**
 * Multilingual string
@@ -84,7 +105,7 @@ var MultilingualString = class MultilingualString {
 			for (const language of actualLanguages) normalizedContent[language] = entriesFromTexts(content[language] ?? []);
 			const availableLanguages = getLanguagesWithEntries(normalizedContent, actualLanguages);
 			const defaultOptions = {
-				defaultLanguage: options.defaultLanguage ?? availableLanguages[0] ?? actualLanguages[0],
+				defaultLanguage: options.defaultLanguage ?? resolveDefaultLanguageOption(availableLanguages, actualLanguages),
 				availableLanguages: actualLanguages,
 				aliases: normalizeAliases(options.aliases)
 			};
@@ -97,7 +118,7 @@ var MultilingualString = class MultilingualString {
 		}
 		const availableLanguages = getLanguagesWithEntries(normalizedContent, languages);
 		const defaultOptions = {
-			defaultLanguage: options.defaultLanguage ?? availableLanguages[0] ?? languages[0],
+			defaultLanguage: options.defaultLanguage ?? resolveDefaultLanguageOption(availableLanguages, languages),
 			availableLanguages: languages,
 			aliases: normalizeAliases(options.aliases)
 		};
@@ -120,6 +141,7 @@ var MultilingualString = class MultilingualString {
 	static fromJSON(json, languages, options = {}) {
 		const content = json.content;
 		const mergedOptions = {
+			defaultLanguage: json.defaultLanguage,
 			...options,
 			aliases: json.aliases
 		};
@@ -144,256 +166,133 @@ var MultilingualString = class MultilingualString {
 		this._availableLanguages = parsed._availableLanguages;
 		this._aliases = parsed._aliases;
 	}
-	getPrimaryEntry(language) {
-		const entries = this._content[language] ?? [];
+	/**
+	* Resolve the entries to read for a language
+	*
+	* The fallback order is requested language, then the dataset's default
+	* language, then the first language that has any content. This is the only
+	* place that order is written down; every reader below is a projection of it.
+	*/
+	resolveEntries(language, isExact) {
+		const candidateLanguages = isExact ? [language] : [
+			language,
+			this._options.defaultLanguage,
+			...this._availableLanguages
+		];
+		for (const candidateLanguage of candidateLanguages) {
+			if (candidateLanguage == null) continue;
+			const entries = this._content[candidateLanguage] ?? [];
+			if (entries.length > 0) return entries;
+		}
+		return [];
+	}
+	resolvePrimaryEntry(language, isExact) {
+		const entries = this.resolveEntries(language, isExact);
 		for (const entry of entries) if (entry.isPrimary) return entry;
 		return entries[0] ?? null;
 	}
 	/**
-	* Get text in a specific language with automatic fallback
+	* Get text in a specific language, falling back when it has none
 	*/
 	getText(language) {
-		if (language == null) {
-			const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
-			if (defaultEntry != null) return defaultEntry.text;
-		}
-		if (language != null) {
-			const requestedEntry = this.getPrimaryEntry(language);
-			if (requestedEntry != null) return requestedEntry.text;
-		}
-		const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
-		if (defaultEntry != null) return defaultEntry.text;
-		for (const availableLanguage of this._availableLanguages) {
-			const entry = this.getPrimaryEntry(availableLanguage);
-			if (entry != null) return entry.text;
-		}
-		return "";
+		return this.resolvePrimaryEntry(language, false)?.text ?? "";
 	}
 	/**
-	* Get rich text in a specific language with automatic fallback
+	* Get rich text in a specific language, falling back when it has none
 	*/
 	getRichText(language) {
-		if (language == null) {
-			const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
-			if (defaultEntry != null) return defaultEntry.richText;
-		}
-		if (language != null) {
-			const requestedEntry = this.getPrimaryEntry(language);
-			if (requestedEntry != null) return requestedEntry.richText;
-		}
-		const defaultEntry = this.getPrimaryEntry(this._options.defaultLanguage);
-		if (defaultEntry != null) return defaultEntry.richText;
-		for (const availableLanguage of this._availableLanguages) {
-			const entry = this.getPrimaryEntry(availableLanguage);
-			if (entry != null) return entry.richText;
-		}
-		return "";
+		return this.resolvePrimaryEntry(language, false)?.richText ?? "";
 	}
 	/**
-	* Get primary text in a specific language without fallback
+	* Get text in a specific language, with no fallback
 	*/
 	getExactText(language) {
-		return this.getPrimaryEntry(language)?.text ?? null;
+		return this.resolvePrimaryEntry(language, true)?.text ?? "";
 	}
 	/**
-	* Get primary rich text in a specific language without fallback
+	* Get rich text in a specific language, with no fallback
 	*/
 	getExactRichText(language) {
-		return this.getPrimaryEntry(language)?.richText ?? null;
-	}
-	/**
-	* Get all text entries in a specific language without fallback
-	*/
-	getExactTexts(language) {
-		return Array.from(this._content[language] ?? [], (entry) => entry.text);
+		return this.resolvePrimaryEntry(language, true)?.richText ?? "";
 	}
 	/**
-	* Get all rich text entries in a specific language without fallback
-	*/
-	getExactRichTexts(language) {
-		return Array.from(this._content[language] ?? [], (entry) => entry.richText);
-	}
-	/**
-	* Get all text entries in a specific language with fallback
-	*/
-	getTexts(language) {
-		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactTexts(language);
-		const defaultLanguage = this._options.defaultLanguage;
-		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactTexts(defaultLanguage);
-		const firstLanguage = this._availableLanguages[0];
-		return firstLanguage == null ? [] : this.getExactTexts(firstLanguage);
-	}
-	/**
-	* Get all rich text entries in a specific language with fallback
-	*/
-	getRichTexts(language) {
-		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactRichTexts(language);
-		const defaultLanguage = this._options.defaultLanguage;
-		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactRichTexts(defaultLanguage);
-		const firstLanguage = this._availableLanguages[0];
-		return firstLanguage == null ? [] : this.getExactRichTexts(firstLanguage);
-	}
-	/**
-	* Get all entries in a specific language without fallback
+	* Get every entry for a specific language, with no fallback
 	*/
 	getExactEntries(language) {
-		return Array.from(this._content[language] ?? [], (entry) => ({
-			text: entry.text,
-			richText: entry.richText,
-			isPrimary: entry.isPrimary
-		}));
+		return Array.from(this.resolveEntries(language, true), (entry) => ({ ...entry }));
 	}
 	/**
-	* Get all entries in a specific language with fallback
-	*/
-	getEntries(language) {
-		if (language != null && (this._content[language]?.length ?? 0) > 0) return this.getExactEntries(language);
-		const defaultLanguage = this._options.defaultLanguage;
-		if ((this._content[defaultLanguage]?.length ?? 0) > 0) return this.getExactEntries(defaultLanguage);
-		const firstLanguage = this._availableLanguages[0];
-		return firstLanguage == null ? [] : this.getExactEntries(firstLanguage);
-	}
-	/**
-	* Get aliases carried by OCHRE as zxx content
+	* Get the alias values OCHRE carries as `zxx` content
 	*/
 	getAliases() {
 		return [...this._aliases];
 	}
 	/**
-	* Check if text exists for a specific language
-	*/
-	hasLanguage(language) {
-		return (this._content[language]?.length ?? 0) > 0;
-	}
-	/**
-	* Check if aliases exist
-	*/
-	hasAliases() {
-		return this._aliases.length > 0;
-	}
-	/**
-	* Get all available languages
+	* Get the languages that actually carry content
 	*/
 	getAvailableLanguages() {
-		return this._availableLanguages;
+		return [...this._availableLanguages];
 	}
 	/**
-	* Get all supported languages (the full language array passed to constructor)
-	*/
-	getSupportedLanguages() {
-		return this._options.availableLanguages;
-	}
-	/**
-	* Check if the multilingual string is empty (no content in any language)
-	*/
-	isEmpty() {
-		return this._availableLanguages.length === 0;
-	}
-	/**
-	* Check if the multilingual string has any content
-	*/
-	hasContent() {
-		for (const language of this._availableLanguages) {
-			const entries = this._content[language] ?? [];
-			for (const entry of entries) if (entry.text.trim().length > 0 || entry.richText.trim().length > 0) return true;
-		}
-		return false;
-	}
-	/**
-	* Get the default language
+	* Get the language reads fall back to before trying the rest
 	*/
 	getDefaultLanguage() {
 		return this._options.defaultLanguage;
 	}
 	/**
-	* Add or update the primary text for a language (returns new instance)
+	* Set the text for a language, or append another entry to it
+	* @param language - The language to write
+	* @param text - The text to write
+	* @param options - Write options
+	* @param options.shouldAppend - Append as an additional entry instead of replacing
+	* @returns A new multilingual string
 	*/
-	withText(language, text) {
+	with(language, text, options = {}) {
 		const newContent = cloneContent(this._content);
-		newContent[language] = entriesFromTexts([text]);
-		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
-		return MultilingualString.fromNormalized(newContent, this._options, newAvailableLanguages);
-	}
-	/**
-	* Add another text entry for a language (returns new instance)
-	*/
-	withEntry(language, text) {
-		const newContent = cloneContent(this._content);
-		newContent[language] = normalizePrimary([...newContent[language] ?? [], {
+		newContent[language] = options.shouldAppend === true ? normalizePrimary([...newContent[language] ?? [], {
 			...normalizeInputText(text),
 			isPrimary: false
-		}]);
-		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
-		return MultilingualString.fromNormalized(newContent, this._options, newAvailableLanguages);
+		}]) : entriesFromTexts([text]);
+		return MultilingualString.fromNormalized(newContent, this._options, getLanguagesWithEntries(newContent, this._options.availableLanguages));
 	}
 	/**
-	* Replace aliases (returns new instance)
+	* Remove the content for a language
+	*
+	* When the removed language was the default, the default moves to the first
+	* language that still has content, so reads keep resolving.
+	* @param language - The language to remove
+	* @returns A new multilingual string
 	*/
-	withAliases(aliases) {
-		return MultilingualString.fromNormalized(this._content, {
-			...this._options,
-			aliases: normalizeAliases(aliases)
-		}, this._availableLanguages);
-	}
-	/**
-	* Remove text for a language (returns new instance)
-	*/
-	withoutLanguage(language) {
-		const newContent = {};
+	without(language) {
 		const currentContent = cloneContent(this._content);
-		for (const supportedLanguage of this._options.availableLanguages) if (supportedLanguage !== language) newContent[supportedLanguage] = normalizePrimary(currentContent[supportedLanguage] ?? []);
-		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
-		const newDefaultLanguage = this._options.defaultLanguage === language ? newAvailableLanguages[0] ?? this._options.availableLanguages[0] : this._options.defaultLanguage;
-		return MultilingualString.fromNormalized(newContent, {
-			...this._options,
-			defaultLanguage: newDefaultLanguage
-		}, newAvailableLanguages);
-	}
-	/**
-	* Transform all language versions (returns new instance)
-	*/
-	map(function_) {
-		const newContent = {};
-		for (const language of this._availableLanguages) newContent[language] = normalizePrimary(Array.from(this._content[language] ?? [], (entry) => ({
-			text: function_(entry.text, language),
-			richText: function_(entry.richText, language),
-			isPrimary: entry.isPrimary
-		})));
-		return MultilingualString.fromNormalized(newContent, this._options, this._availableLanguages);
-	}
-	/**
-	* Filter languages based on predicate (returns new instance)
-	*/
-	filter(shouldInclude) {
 		const newContent = {};
-		for (const language of this._availableLanguages) {
-			const entries = [];
-			const languageEntries = this._content[language] ?? [];
-			for (const entry of languageEntries) if (shouldInclude(entry.text, language)) entries.push(entry);
-			newContent[language] = normalizePrimary(entries);
-		}
+		for (const supportedLanguage of this._options.availableLanguages) if (supportedLanguage !== language) newContent[supportedLanguage] = normalizePrimary(currentContent[supportedLanguage] ?? []);
 		const newAvailableLanguages = getLanguagesWithEntries(newContent, this._options.availableLanguages);
-		const newDefaultLanguage = (newContent[this._options.defaultLanguage]?.length ?? 0) > 0 ? this._options.defaultLanguage : newAvailableLanguages[0] ?? this._options.availableLanguages[0];
 		return MultilingualString.fromNormalized(newContent, {
 			...this._options,
-			defaultLanguage: newDefaultLanguage
+			defaultLanguage: this._options.defaultLanguage === language ? resolveDefaultLanguageOption(newAvailableLanguages, this._options.availableLanguages) : this._options.defaultLanguage
 		}, newAvailableLanguages);
 	}
 	/**
-	* Get the string representation (uses default language)
+	* Get the string representation, using the default language
 	*/
 	toString() {
 		return this.getText();
 	}
 	/**
-	* Get JSON representation
+	* Get the JSON representation
+	*
+	* Carries `defaultLanguage`, because it is not derivable from the content:
+	* without it {@link MultilingualString.fromJSON} would fall back to the first
+	* available language and `getText()` would resolve differently.
 	*/
 	toJSON() {
 		const content = {};
 		for (const language of this._availableLanguages) content[language] = this.getExactEntries(language);
 		return {
 			content,
-			aliases: this.getAliases()
+			aliases: this.getAliases(),
+			defaultLanguage: this._options.defaultLanguage
 		};
 	}
 };

package/dist/parsers/property-token.d.mts

@@ -0,0 +1,34 @@
+//#region src/parsers/property-token.d.ts
+/**
+ * The attributes a property value can carry its text in
+ */
+type PropertyValueTextSource = {
+  rawValue?: string;
+  payload?: string;
+  slug?: string;
+};
+/**
+ * The text a property value stands for
+ *
+ * OCHRE spreads that text over four places, so which one wins is real domain
+ * knowledge and this is the only place it is written down. The content step is
+ * injected because the two callers reach it differently: the item parser builds
+ * a full multilingual string, while the rich-text parser needs one language's
+ * plain text. Reading the sources in a different order is what let the two
+ * disagree for a value carrying both a `slug` and `content`.
+ * @param value - The raw property value
+ * @param readContentText - Reads the value's `content` as plain text, or null when it has none
+ * @returns The text, or an empty string when the value carries none
+ * @internal
+ */
+export declare function readPropertyValueText(value: PropertyValueTextSource, readContentText: () => string | null): string;
+/**
+ * The UUID a property value points at, treating an empty attribute as absent
+ * @param value - The raw property value
+ * @returns The UUID, or null when there is none
+ * @internal
+ */
+export declare function readPropertyValueUuid(value: {
+  uuid?: string;
+} | undefined): string | null;
+//#endregion

package/dist/parsers/property-token.mjs

@@ -0,0 +1,29 @@
+//#region src/parsers/property-token.ts
+/**
+* The text a property value stands for
+*
+* OCHRE spreads that text over four places, so which one wins is real domain
+* knowledge and this is the only place it is written down. The content step is
+* injected because the two callers reach it differently: the item parser builds
+* a full multilingual string, while the rich-text parser needs one language's
+* plain text. Reading the sources in a different order is what let the two
+* disagree for a value carrying both a `slug` and `content`.
+* @param value - The raw property value
+* @param readContentText - Reads the value's `content` as plain text, or null when it has none
+* @returns The text, or an empty string when the value carries none
+* @internal
+*/
+function readPropertyValueText(value, readContentText) {
+	return value.rawValue ?? value.payload ?? readContentText() ?? value.slug ?? "";
+}
+/**
+* The UUID a property value points at, treating an empty attribute as absent
+* @param value - The raw property value
+* @returns The UUID, or null when there is none
+* @internal
+*/
+function readPropertyValueUuid(value) {
+	return value?.uuid == null || value.uuid === "" ? null : value.uuid;
+}
+//#endregion
+export { readPropertyValueText, readPropertyValueUuid };

package/dist/parsers/string.d.mts

@@ -1,7 +1,24 @@
 import { MultilingualString, MultilingualStringText } from "./multilingual.mjs";
 import { XMLContent, XMLString } from "../xml/types.mjs";
 //#region src/parsers/string.d.ts
+/**
+ * Rewrite a permanent identification URL as an OCHRE API endpoint
+ *
+ * The counterpart of {@link transformPermanentIdentificationUrlToItemLink}:
+ * the same prefix becomes an API call here and a route into a consuming
+ * website there, so which one a caller wants depends on who reads the result.
+ * @param url - The permanent identification URL
+ * @returns The API URL
+ * @internal
+ */
 export declare function transformPermanentIdentificationUrl(url: string): string;
+/**
+ * Rewrite a permanent identification URL as a website item route
+ * @param url - The permanent identification URL
+ * @returns The item route
+ * @internal
+ */
+export declare function transformPermanentIdentificationUrlToItemLink(url: string): string;
 export declare function parseXMLString(string: XMLString): MultilingualStringText;
 /**
  * Parses rich text content into a formatted string with links and annotations
@@ -9,12 +26,14 @@ export declare function parseXMLString(string: XMLString): MultilingualStringTex
  * @param item - XML-based rich text item to parse
  * @param options - Options for parsing
  * @param options.languages - Languages of the content
+ * @param options.defaultLanguage - The language the dataset declares as its default
  * @returns Plain and rich formatted strings
  *
  * @internal
  */
 export declare function parseXMLContent<V extends ReadonlyArray<string>>(item: XMLContent, options: {
   languages: V;
+  defaultLanguage?: V[number];
 }): MultilingualString<V>;
 /**
  * Extracts alias strings from XMLContent where lang="zxx"

package/dist/parsers/string.mjs

@@ -1,8 +1,10 @@
-import { TEXT_ANNOTATION_UUID } from "../constants.mjs";
+import { OCHRE_ENDPOINT, PERMANENT_IDENTIFICATION_URL_PREFIX, TEXT_ANNOTATION_UUID, getOchreItemUrl } from "../constants.mjs";
+import { normalizePropertyVariableLabel } from "../getters.mjs";
+import { getXMLSourceIndex } from "../xml/metadata.mjs";
 import { serializeMDXContent, serializeMDXText } from "./mdx.mjs";
 import { MultilingualString } from "./multilingual.mjs";
+import { readPropertyValueText, readPropertyValueUuid } from "./property-token.mjs";
 import { renderOptionsSchema } from "../schemas.mjs";
-import { getXMLSourceIndex } from "../xml/metadata.mjs";
 import * as v from "valibot";
 //#region src/parsers/string.ts
 const TEXT_ANNOTATION_TOKEN = "text-annotation";
@@ -21,9 +23,6 @@ const MDX_RENDER_ELEMENTS = {
 	italic: "em",
 	underline: "u"
 };
-function isXMLRichTextLink(value) {
-	return typeof value === "object" && value != null;
-}
 function getLinkStringProperty(link, property) {
 	switch (property) {
 		case "uuid": return "uuid" in link && typeof link.uuid === "string" ? link.uuid : null;
@@ -32,8 +31,27 @@ function getLinkStringProperty(link, property) {
 		case "width": return "width" in link && link.width != null ? link.width.toString() : null;
 	}
 }
+/**
+* Rewrite a permanent identification URL as an OCHRE API endpoint
+*
+* The counterpart of {@link transformPermanentIdentificationUrlToItemLink}:
+* the same prefix becomes an API call here and a route into a consuming
+* website there, so which one a caller wants depends on who reads the result.
+* @param url - The permanent identification URL
+* @returns The API URL
+* @internal
+*/
 function transformPermanentIdentificationUrl(url) {
-	return url.replace("https://pi.lib.uchicago.edu/1001/org/ochre/", "https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?uuid=");
+	return url.replace(PERMANENT_IDENTIFICATION_URL_PREFIX, () => `${OCHRE_ENDPOINT}?uuid=`);
+}
+/**
+* Rewrite a permanent identification URL as a website item route
+* @param url - The permanent identification URL
+* @returns The item route
+* @internal
+*/
+function transformPermanentIdentificationUrlToItemLink(url) {
+	return url.replace(PERMANENT_IDENTIFICATION_URL_PREFIX, "/item/");
 }
 /**
 * Applies text rendering options (bold, italic, underline) to a string
@@ -126,7 +144,7 @@ function createMDXComponent(variant, properties) {
 			returnString = `<ExternalLink${createMDXStringAttribute("href", href == null ? "#" : transformPermanentIdentificationUrl(href))}>${text}</ExternalLink>`;
 			break;
 		case "documentLink":
-			returnString = `<ExternalLink${createMDXStringAttribute("href", `https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?uuid=${uuid}&load`)}>${text}</ExternalLink>`;
+			returnString = `<ExternalLink${createMDXStringAttribute("href", getOchreItemUrl(uuid ?? "null", "load"))}>${text}</ExternalLink>`;
 			break;
 		case "tooltipSpan": returnString = `<TooltipSpan${createMDXStringAttribute("content", content)}>${text}</TooltipSpan>`;
 	}
@@ -137,8 +155,7 @@ function createMDXStringAttribute(name, value) {
 	return ` ${name}=${MDX_QUOTED_ATTRIBUTE_ESCAPE_REGEX.test(value) ? `{${JSON.stringify(value)}}` : `"${value}"`}`;
 }
 function getPropertyValueUuid(property) {
-	const value = property?.value?.[0];
-	return value?.uuid == null || value.uuid === "" ? null : value.uuid;
+	return readPropertyValueUuid(property?.value?.[0]);
 }
 function getFirstPropertyMetadata(item) {
 	const itemProperty = item.properties?.property[0];
@@ -159,23 +176,16 @@ function parseContentLikeForLanguage(value, options) {
 function parsePropertyValueText(property, options) {
 	const value = property?.value?.[0];
 	if (value == null) return "";
-	if (value.rawValue != null) return value.rawValue;
-	if (value.payload != null) return value.payload;
-	if (value.slug != null) return value.slug;
-	if (value.content != null) return parseContentLikeForLanguage(value, options);
-	return "";
-}
-function normalizePropertyToken(value) {
-	return value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-");
+	return readPropertyValueText(value, () => value.content == null ? null : parseContentLikeForLanguage(value, options));
 }
 function hasMatchingPropertyLabel(property, uuid, tokens, options) {
 	if (uuid !== "" && property.label.uuid === uuid) return true;
-	const label = normalizePropertyToken(parseContentLikeForLanguage(property.label, options));
+	const label = normalizePropertyVariableLabel(parseContentLikeForLanguage(property.label, options));
 	return tokens.includes(label);
 }
 function hasMatchingPropertyValue(property, uuid, tokens, options) {
 	if (uuid !== "" && getPropertyValueUuid(property) === uuid) return true;
-	const value = normalizePropertyToken(parsePropertyValueText(property, options));
+	const value = normalizePropertyVariableLabel(parsePropertyValueText(property, options));
 	return tokens.includes(value);
 }
 function parseTextStylingSize(textStylingProperty, options) {
@@ -336,7 +346,7 @@ function getXMLRichTextLinks(item) {
 	for (const rawLinks of linkGroups) {
 		if (!Array.isArray(rawLinks)) continue;
 		for (const rawLink of rawLinks) {
-			if (!isXMLRichTextLink(rawLink) || isTextAnnotationMarkerLink(rawLink)) continue;
+			if (isTextAnnotationMarkerLink(rawLink)) continue;
 			links.push({
 				link: rawLink,
 				fallbackIndex
@@ -408,7 +418,7 @@ function renderRichTextItem(item, linkString, contentItem, options) {
 	let result = "";
 	for (const link of links) {
 		const linkContent = link.identification != null ? "content" in link.identification.label ? parseXMLContent(link.identification.label, { languages }) : MultilingualString.create(contentItem.lang, parseXMLString(link.identification.label), languages) : MultilingualString.create(contentItem.lang, "", languages);
-		const contentText = (rendering === "plain" ? linkContent.getExactText(contentItem.lang) : linkContent.getExactRichText(contentItem.lang)) ?? "";
+		const contentText = rendering === "plain" ? linkContent.getExactText(contentItem.lang) : linkContent.getExactRichText(contentItem.lang);
 		result += renderRichTextLink(item, link, linkString, contentText, annotationMetadata);
 	}
 	return applyNewlineWhitespace(result, item.whitespace, rendering);
@@ -419,6 +429,7 @@ function renderRichTextItem(item, linkString, contentItem, options) {
 * @param item - XML-based rich text item to parse
 * @param options - Options for parsing
 * @param options.languages - Languages of the content
+* @param options.defaultLanguage - The language the dataset declares as its default
 * @returns Plain and rich formatted strings
 *
 * @internal
@@ -434,15 +445,24 @@ function parseXMLContent(item, options) {
 		entries.push(parseXMLContentItem(contentItem, { languages }));
 		content[language] = entries;
 	}
-	if (Object.keys(content).length > 0) return MultilingualString.fromEntries(content, languages, { aliases });
+	if (Object.keys(content).length > 0) return MultilingualString.fromEntries(content, languages, {
+		aliases,
+		defaultLanguage: options.defaultLanguage
+	});
 	for (const contentItem of item.content) {
 		if (contentItem.lang === "zxx") continue;
 		const fallbackText = parseXMLContentItem(contentItem, { languages: [contentItem.lang] });
 		const fallbackContent = {};
 		for (const language of languages) fallbackContent[language] = [fallbackText];
-		return MultilingualString.fromEntries(fallbackContent, languages, { aliases });
+		return MultilingualString.fromEntries(fallbackContent, languages, {
+			aliases,
+			defaultLanguage: options.defaultLanguage
+		});
 	}
-	return MultilingualString.empty(languages, { aliases });
+	return MultilingualString.empty(languages, {
+		aliases,
+		defaultLanguage: options.defaultLanguage
+	});
 }
 function parseXMLContentItem(contentItem, options) {
 	const rawMDXBlocks = [];
@@ -483,4 +503,4 @@ function extractAliases(content) {
 	return aliases.length > 0 ? aliases : null;
 }
 //#endregion
-export { extractAliases, parseXMLContent, parseXMLString, transformPermanentIdentificationUrl };
+export { extractAliases, parseXMLContent, parseXMLString, transformPermanentIdentificationUrl, transformPermanentIdentificationUrlToItemLink };

package/dist/parsers/website/bounds.d.mts

@@ -0,0 +1,10 @@
+//#region src/parsers/website/bounds.d.ts
+/**
+ * Parses raw bounds data into a standardized bounds structure
+ *
+ * @param bounds - Raw bounds data in OCHRE format
+ * @returns Parsed bounds object
+ * @internal
+ */
+export declare function parseBounds(bounds: string): [[number, number], [number, number]];
+//#endregion