ochre-sdk 1.0.12 → 1.0.14

package/dist/fetchers/set/property-values.mjs

@@ -0,0 +1,514 @@
+import { BELONGS_TO_COLLECTION_UUID, DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../../constants.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utils.mjs";
+import { MultilingualString } from "../../parsers/multilingual.mjs";
+import { setPropertyValuesParamsSchema } from "../../schemas.mjs";
+import { parseXMLContent } from "../../parsers/string.mjs";
+import { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan } from "../../query.mjs";
+import * as v from "valibot";
+import { XMLParser } from "fast-xml-parser";
+//#region src/fetchers/set/property-values.ts
+function getLabelContentLanguages(content) {
+	const languages = [];
+	for (const contentItem of content) if (contentItem.lang !== "zxx" && !languages.includes(contentItem.lang)) languages.push(contentItem.lang);
+	return languages.length > 0 ? languages : [...DEFAULT_LANGUAGES];
+}
+function parsePropertyValueLabelText(text) {
+	if (text == null || text === "") return null;
+	return text === "<unassigned>" ? null : text;
+}
+function parsePropertyValueLabel(content, text) {
+	if (content != null && content.length > 0) return parseXMLContent({ content }, { languages: getLabelContentLanguages(content) });
+	const parsedText = parsePropertyValueLabelText(text);
+	if (parsedText == null) return null;
+	return MultilingualString.fromObject({ [DEFAULT_LANGUAGES[0]]: parsedText });
+}
+function parsePropertyValueBooleanContent(rawValue) {
+	if (rawValue == null || rawValue === "") return null;
+	return rawValue.toLocaleLowerCase("en-US") === "true";
+}
+function normalizePropertyValueDataType(dataType) {
+	const normalizedDataType = dataType.startsWith("xs:") ? dataType.slice(3) : dataType;
+	switch (normalizedDataType) {
+		case "IDREF":
+		case "boolean":
+		case "date":
+		case "dateTime":
+		case "decimal":
+		case "integer":
+		case "string":
+		case "time": return normalizedDataType;
+		default: return "string";
+	}
+}
+function sortPropertyValues(values) {
+	return values.toSorted((a, b) => {
+		if (a.count !== b.count) return b.count - a.count;
+		const label = a.label?.getText() ?? null;
+		const otherLabel = b.label?.getText() ?? null;
+		if (label !== otherLabel) return label?.localeCompare(otherLabel ?? "") ?? 0;
+		return a.content?.toString().localeCompare(b.content?.toString() ?? "") ?? 0;
+	});
+}
+function getPropertyValueKey(value) {
+	return `${value.dataType}|${typeof value.content}:${value.content.toLocaleString("en-US")}`;
+}
+function sortAttributeValues(values) {
+	return values.toSorted((a, b) => {
+		if (a.count !== b.count) return b.count - a.count;
+		return a.content.localeCompare(b.content);
+	});
+}
+const countSchema = v.pipe(v.optional(v.union([v.number(), v.string()]), 1), v.transform((val) => {
+	if (val === "") return 1;
+	const count = Number(val);
+	return Number.isFinite(count) ? count : 1;
+}));
+const propertyValueLabelStringSchema = v.object({ payload: v.optional(v.string(), "") });
+const propertyValueLabelContentSchema = v.object({
+	lang: v.string(),
+	string: v.array(propertyValueLabelStringSchema)
+});
+function getPropertyVariableUuidsFromQueries(queries) {
+	const propertyVariableUuids = /* @__PURE__ */ new Set();
+	if (queries == null) return [];
+	const pendingQueries = [queries];
+	for (const query of pendingQueries) {
+		if ("target" in query) {
+			if (query.target !== "property") continue;
+			if (query.propertyVariable != null) propertyVariableUuids.add(query.propertyVariable);
+			continue;
+		}
+		pendingQueries.push(..."and" in query ? query.and : query.or);
+	}
+	return [...propertyVariableUuids];
+}
+function getItemFilterQueriesFromPropertyValueQueries(queries) {
+	if (queries == null) return null;
+	if ("target" in queries) {
+		if (queries.target !== "property") return queries;
+		if (queries.dataType === "date" || queries.dataType === "dateTime") return queries;
+		return "value" in queries && queries.value != null ? queries : null;
+	}
+	const filteredChildren = [];
+	const childQueries = "and" in queries ? queries.and : queries.or;
+	for (const childQuery of childQueries) {
+		const filteredChildQuery = getItemFilterQueriesFromPropertyValueQueries(childQuery);
+		if (filteredChildQuery != null) filteredChildren.push(filteredChildQuery);
+	}
+	if (filteredChildren.length === 0) return null;
+	if (filteredChildren.length === 1) return filteredChildren[0] ?? null;
+	return "and" in queries ? { and: filteredChildren } : { or: filteredChildren };
+}
+/**
+* Schema for a single property value query item in the OCHRE API response
+*/
+const propertyValueQueryItemSchema = v.pipe(v.object({
+	uuid: v.optional(v.string(), ""),
+	scope: v.optional(v.picklist(["global", "variable"]), "global"),
+	variableUuid: v.optional(v.string()),
+	count: countSchema,
+	globalCount: v.nullish(countSchema),
+	dataType: v.optional(v.string(), "string"),
+	rawValue: v.optional(v.string()),
+	payload: v.optional(v.string()),
+	content: v.optional(v.array(propertyValueLabelContentSchema))
+}), v.transform((val) => {
+	const dataType = normalizePropertyValueDataType(val.dataType);
+	const label = parsePropertyValueLabel(val.content, val.payload);
+	const returnValue = {
+		scope: val.scope,
+		variableUuid: val.variableUuid != null && val.variableUuid !== "" ? val.variableUuid : null,
+		count: val.count,
+		globalCount: val.globalCount ?? null,
+		dataType,
+		content: null,
+		label
+	};
+	switch (dataType) {
+		case "IDREF":
+			returnValue.content = val.uuid !== "" ? val.uuid : null;
+			break;
+		case "integer":
+		case "decimal":
+		case "time":
+			if (val.rawValue != null && val.rawValue !== "") {
+				const numericContent = Number(val.rawValue);
+				returnValue.content = Number.isNaN(numericContent) ? null : numericContent;
+			}
+			break;
+		case "boolean":
+			returnValue.content = parsePropertyValueBooleanContent(val.rawValue);
+			break;
+		default: {
+			const labelText = label?.getText() ?? null;
+			returnValue.content = val.rawValue != null && val.rawValue !== "" ? val.rawValue.toString() : labelText;
+			break;
+		}
+	}
+	return returnValue;
+}));
+const attributeValueQueryItemSchema = v.pipe(v.object({
+	attributeType: v.picklist(["bibliographies", "periods"]),
+	count: countSchema,
+	content: v.optional(v.string()),
+	payload: v.optional(v.string())
+}), v.transform((val) => ({
+	attributeType: val.attributeType,
+	count: val.count,
+	content: val.content != null && val.content !== "" ? val.content : val.payload != null && val.payload !== "" ? val.payload : null
+})));
+/**
+* Schema for the property values OCHRE API response
+*/
+const responseSchema = v.object({ result: v.object({ ochre: v.object({
+	payload: v.optional(v.string()),
+	propertyValue: v.optional(v.union([v.array(propertyValueQueryItemSchema), propertyValueQueryItemSchema])),
+	attributeValue: v.optional(v.union([v.array(attributeValueQueryItemSchema), attributeValueQueryItemSchema]))
+}) }) });
+/**
+* Build an XQuery string to fetch property values from the OCHRE API
+* @param params - The parameters for the fetch
+* @param params.setScopeUuids - An array of set scope UUIDs to filter by
+* @param params.belongsToCollectionScopeUuids - An array of collection scope UUIDs to filter by
+* @param params.queries - Recursive query tree used to filter matching items
+* @param params.propertyVariableUuids - Property variable UUIDs to aggregate, if any
+* @param params.attributes - Whether to return values for bibliographies and periods
+* @param params.attributes.bibliographies - Whether to return values for bibliographies
+* @param params.attributes.periods - Whether to return values for periods
+* @param params.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
+* @returns An XQuery string
+*/
+function buildXQuery(params) {
+	const { setScopeUuids, belongsToCollectionScopeUuids, queries, propertyVariableUuids, attributes, isLimitedToLeafPropertyValues } = params;
+	const setScopeDeclaration = `declare variable $setScopeUuids := (${setScopeUuids.map((uuid) => stringLiteral(uuid)).join(", ")});`;
+	const baseItemsExpression = "doc()/ochre/set[@uuid = $setScopeUuids]/items/*";
+	const compiledQueryPlan = buildQueryPlan({ queries: getItemFilterQueriesFromPropertyValueQueries(queries) });
+	const itemsQueryExpressions = [];
+	const belongsToCollectionQueryExpression = buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids, BELONGS_TO_COLLECTION_UUID);
+	if (compiledQueryPlan.queryExpression != null) itemsQueryExpressions.push(compiledQueryPlan.queryExpression);
+	if (belongsToCollectionQueryExpression != null) itemsQueryExpressions.push(belongsToCollectionQueryExpression);
+	const itemsQueryExpression = buildAndCtsQueryExpression(itemsQueryExpressions);
+	const valueFilter = isLimitedToLeafPropertyValues ? "[not(@i)]" : "";
+	const queryBlocks = [];
+	const returnedSequences = [];
+	const xqueryDeclarations = [
+		"xquery version \"1.0-ml\";",
+		"declare namespace map = \"http://marklogic.com/xdmp/map\";",
+		setScopeDeclaration,
+		`declare function local:increment-count($counts, $key) {
+  let $current := map:get($counts, $key)
+  return map:put(
+    $counts,
+    $key,
+    if (empty($current)) then 1 else xs:integer($current) + 1
+  )
+};
+
+declare function local:value-display-text($v) {
+  if ($v/content)
+  then string-join($v/content[@xml:lang="eng"]//text(), "")
+  else string($v)
+};
+
+declare function local:value-label-content($v) {
+  if ($v/content) then
+    for $content in $v/content
+    let $lang := string($content/@xml:lang)
+    return <content lang="{$lang}"><string>{string-join($content//text(), "")}</string></content>
+  else ()
+};
+
+declare function local:value-content($data-type, $raw-value, $value-uuid, $display) {
+  if ($data-type = "IDREF") then $value-uuid
+  else if ($data-type = ("integer", "decimal", "time")) then
+    if ($raw-value castable as xs:double)
+    then string(xs:double($raw-value))
+    else ""
+  else if ($data-type = "boolean") then
+    if ($raw-value = "") then ""
+    else if (lower-case($raw-value) = "true") then "true"
+    else "false"
+  else if ($raw-value != "") then $raw-value
+  else if ($display != "" and $display != "<unassigned>") then $display
+  else ""
+};
+
+declare function local:value-kind($data-type) {
+  if ($data-type = ("integer", "decimal", "time")) then "number"
+  else if ($data-type = "boolean") then "boolean"
+  else "string"
+};
+
+declare function local:property-output-raw-value($data-type, $raw-value, $content) {
+  if ($data-type = ("integer", "decimal", "time", "boolean")) then $content
+  else $raw-value
+};
+
+declare function local:put-property-detail(
+  $details,
+  $key,
+  $scope,
+  $variable-uuid,
+  $value-uuid,
+  $raw-value,
+  $data-type,
+  $display,
+  $label-content
+) {
+  let $existing := map:get($details, $key)
+  return
+    if (
+      empty($existing)
+      or (not($existing/content) and exists($label-content))
+      or (
+        not($existing/content)
+        and string-length(string($existing)) = 0
+        and string-length($display) gt 0
+      )
+    ) then
+      map:put(
+        $details,
+        $key,
+        <propertyValue scope="{$scope}" variableUuid="{$variable-uuid}" uuid="{$value-uuid}" rawValue="{$raw-value}" dataType="{$data-type}">{
+          if (exists($label-content)) then $label-content else $display
+        }</propertyValue>
+      )
+    else ()
+};
+
+declare function local:add-property-facet(
+  $counts,
+  $details,
+  $seen,
+  $key,
+  $scope,
+  $variable-uuid,
+  $value-uuid,
+  $raw-value,
+  $data-type,
+  $display,
+  $label-content
+) {
+  if (exists(map:get($seen, $key))) then ()
+  else (
+    map:put($seen, $key, true()),
+    local:increment-count($counts, $key),
+    local:put-property-detail($details, $key, $scope, $variable-uuid, $value-uuid, $raw-value, $data-type, $display, $label-content)
+  )
+};
+
+declare function local:add-attribute-facet($counts, $seen, $key) {
+  if (exists(map:get($seen, $key))) then ()
+  else (
+    map:put($seen, $key, true()),
+    local:increment-count($counts, $key)
+  )
+};`
+	];
+	if (compiledQueryPlan.prolog !== "") xqueryDeclarations.push(compiledQueryPlan.prolog);
+	if (propertyVariableUuids.length > 0) {
+		const propertyVariableValues = propertyVariableUuids.map((uuid) => stringLiteral(uuid));
+		xqueryDeclarations.push(`declare variable $facetLabelUuids := (${propertyVariableValues.join(", ")});`);
+		queryBlocks.push(`let $global-property-counts := map:map()
+let $variable-property-counts := map:map()
+let $variable-property-details := map:map()
+let $variable-property-global-keys := map:map()
+let $_property-aggregation := xdmp:eager(
+  for $item in $items
+  let $global-seen := map:map()
+  let $variable-seen := map:map()
+  return
+    for $p in $item/properties/property[label/@uuid = $facetLabelUuids]
+    let $variable-uuid := string($p/label/@uuid)
+    for $v in $p/value${valueFilter}
+    let $value-uuid := string($v/@uuid)
+    let $raw-value := string($v/@rawValue)
+    let $data-type := string($v/@dataType)
+    let $display := local:value-display-text($v)
+    let $label-content := local:value-label-content($v)
+    let $content := local:value-content($data-type, $raw-value, $value-uuid, $display)
+    let $value-kind := local:value-kind($data-type)
+    let $output-raw-value := local:property-output-raw-value($data-type, $raw-value, $content)
+    let $global-key := string-join(($data-type, $value-kind, $content), "||")
+    let $variable-key := string-join(($variable-uuid, $data-type, $value-kind, $content), "||")
+    where $content != ""
+    return (
+      local:add-attribute-facet($global-property-counts, $global-seen, $global-key),
+      local:add-property-facet($variable-property-counts, $variable-property-details, $variable-seen, $variable-key, "variable", $variable-uuid, $value-uuid, $output-raw-value, $data-type, $display, $label-content),
+      map:put($variable-property-global-keys, $variable-key, $global-key)
+    )
+)
+
+let $property-values :=
+  (
+    $_property-aggregation,
+    for $key in map:keys($variable-property-counts)
+    let $detail := map:get($variable-property-details, $key)
+    let $global-key := map:get($variable-property-global-keys, $key)
+    return <propertyValue scope="variable" variableUuid="{string($detail/@variableUuid)}" uuid="{string($detail/@uuid)}" rawValue="{string($detail/@rawValue)}" dataType="{string($detail/@dataType)}" count="{map:get($variable-property-counts, $key)}" globalCount="{map:get($global-property-counts, $global-key)}">{
+      $detail/node()
+    }</propertyValue>
+  )`);
+		returnedSequences.push("$property-values");
+	}
+	if (attributes.bibliographies) {
+		queryBlocks.push(`let $bibliography-counts := map:map()
+let $_bibliography-aggregation := xdmp:eager(
+  for $item in $items
+  let $seen := map:map()
+  return
+    for $bibliography in $item/bibliographies/bibliography
+    let $label := string-join($bibliography/identification/label/content[@xml:lang="eng"]//text(), "")
+    where string-length($label) gt 0
+    return local:add-attribute-facet($bibliography-counts, $seen, $label)
+)
+
+let $bibliography-values :=
+  (
+    $_bibliography-aggregation,
+    for $label in map:keys($bibliography-counts)
+    return <attributeValue attributeType="bibliographies" count="{map:get($bibliography-counts, $label)}" content="{$label}" />
+  )`);
+		returnedSequences.push("$bibliography-values");
+	}
+	if (attributes.periods) {
+		queryBlocks.push(`let $period-counts := map:map()
+let $_period-aggregation := xdmp:eager(
+  for $item in $items
+  let $seen := map:map()
+  return
+    for $period in $item/periods/period
+    let $label := string-join($period/identification/label/content[@xml:lang="eng"]//text(), "")
+    where string-length($label) gt 0
+    return local:add-attribute-facet($period-counts, $seen, $label)
+)
+
+let $period-values :=
+  (
+    $_period-aggregation,
+    for $label in map:keys($period-counts)
+    return <attributeValue attributeType="periods" count="{map:get($period-counts, $label)}" content="{$label}" />
+  )`);
+		returnedSequences.push("$period-values");
+	}
+	const itemsClause = itemsQueryExpression == null ? `let $items := ${baseItemsExpression}` : `let $query := ${itemsQueryExpression}
+  let $items := cts:search(${baseItemsExpression}, $query)`;
+	return `${xqueryDeclarations.join("\n\n")}
+
+<ochre>{
+${itemsClause}
+${queryBlocks.join("\n\n")}
+
+return (${returnedSequences.join(", ")})
+}</ochre>`;
+}
+/**
+* Fetches and parses Set property values from the OCHRE API
+*
+* @param params - The parameters for the fetch
+* @param params.setScopeUuids - An array of set scope UUIDs to filter by
+* @param params.queries - Recursive query tree used to filter matching items
+* @param params.attributes - Whether to return values for bibliographies and periods
+* @param params.attributes.bibliographies - Whether to return values for bibliographies
+* @param params.attributes.periods - Whether to return values for periods
+* @param params.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
+* @param options - Options for the fetch
+* @param options.fetch - The fetch function to use
+* @returns Parsed Set property values and requested attribute values.
+* Returns empty arrays/objects when no matches are found, and null outputs on fetch/parse errors.
+*/
+async function fetchSetPropertyValues(params, options) {
+	try {
+		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = v.parse(setPropertyValuesParamsSchema, params);
+		const propertyVariableUuids = getPropertyVariableUuidsFromQueries(queries);
+		if (propertyVariableUuids.length === 0 && !attributes.bibliographies && !attributes.periods) return {
+			propertyValues: [],
+			propertyValuesByPropertyVariableUuid: {},
+			attributeValues: {
+				bibliographies: null,
+				periods: null
+			},
+			error: null,
+			detailedError: null
+		};
+		const xquery = buildXQuery({
+			setScopeUuids,
+			belongsToCollectionScopeUuids,
+			queries,
+			propertyVariableUuids,
+			attributes,
+			isLimitedToLeafPropertyValues
+		});
+		const response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&xsl=none&lang=\"*\"", {
+			method: "POST",
+			body: xquery,
+			headers: { "Content-Type": "application/xquery" }
+		});
+		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`, { cause: response.statusText });
+		const dataRaw = await response.text();
+		const data = new XMLParser(XML_PARSER_OPTIONS).parse(dataRaw);
+		const { success, issues, output } = v.safeParse(responseSchema, data);
+		if (!success) throw createSchemaValidationError("Failed to parse OCHRE Set property values", issues);
+		const parsedPropertyValues = [];
+		const parsedAttributeValues = [];
+		if (output.result.ochre.propertyValue != null) parsedPropertyValues.push(...Array.isArray(output.result.ochre.propertyValue) ? output.result.ochre.propertyValue : [output.result.ochre.propertyValue]);
+		if (output.result.ochre.attributeValue != null) parsedAttributeValues.push(...Array.isArray(output.result.ochre.attributeValue) ? output.result.ochre.attributeValue : [output.result.ochre.attributeValue]);
+		const propertyValuesByPropertyVariableUuid = {};
+		const flattenedPropertyValuesByKey = /* @__PURE__ */ new Map();
+		for (const propertyValue of parsedPropertyValues) {
+			if (propertyValue.content == null) continue;
+			const propertyValueItem = {
+				count: propertyValue.count,
+				dataType: propertyValue.dataType,
+				content: propertyValue.content,
+				label: propertyValue.label
+			};
+			const globalPropertyValueItem = {
+				count: propertyValue.globalCount ?? propertyValue.count,
+				dataType: propertyValue.dataType,
+				content: propertyValue.content,
+				label: propertyValue.label
+			};
+			const globalPropertyValueKey = getPropertyValueKey({
+				dataType: globalPropertyValueItem.dataType,
+				content: propertyValue.content
+			});
+			const existingGlobalPropertyValue = flattenedPropertyValuesByKey.get(globalPropertyValueKey);
+			if (existingGlobalPropertyValue == null) flattenedPropertyValuesByKey.set(globalPropertyValueKey, globalPropertyValueItem);
+			else if (existingGlobalPropertyValue.label == null && globalPropertyValueItem.label != null) existingGlobalPropertyValue.label = globalPropertyValueItem.label;
+			if (propertyValue.scope === "global") continue;
+			if (propertyValue.variableUuid != null) (propertyValuesByPropertyVariableUuid[propertyValue.variableUuid] ??= []).push(propertyValueItem);
+		}
+		for (const [propertyVariableUuid, values] of Object.entries(propertyValuesByPropertyVariableUuid)) propertyValuesByPropertyVariableUuid[propertyVariableUuid] = sortPropertyValues(values);
+		const attributeValuesByType = {
+			bibliographies: [],
+			periods: []
+		};
+		for (const attributeValue of parsedAttributeValues) {
+			if (attributeValue.content == null || attributeValue.content === "") continue;
+			attributeValuesByType[attributeValue.attributeType].push({
+				count: attributeValue.count,
+				content: attributeValue.content
+			});
+		}
+		return {
+			propertyValues: sortPropertyValues([...flattenedPropertyValuesByKey.values()]),
+			propertyValuesByPropertyVariableUuid,
+			attributeValues: {
+				bibliographies: attributes.bibliographies ? sortAttributeValues(attributeValuesByType.bibliographies) : null,
+				periods: attributes.periods ? sortAttributeValues(attributeValuesByType.periods) : null
+			},
+			error: null,
+			detailedError: null
+		};
+	} catch (error) {
+		return {
+			propertyValues: null,
+			propertyValuesByPropertyVariableUuid: null,
+			attributeValues: null,
+			...getErrorOutput(error, "Failed to fetch property values")
+		};
+	}
+}
+//#endregion
+export { fetchSetPropertyValues };

package/dist/fetchers/website.d.mts

@@ -0,0 +1,25 @@
+import { Website } from "../types/website.mjs";
+import { LanguageCodes } from "../types/index.mjs";
+
+//#region src/fetchers/website.d.ts
+type FetchFunction = (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Fetches and parses a website configuration from the OCHRE API
+ *
+ * @param abbreviation - The abbreviation identifier for the website
+ * @returns The parsed website configuration or null if the fetch/parse fails
+ */
+declare function fetchWebsite<const T extends LanguageCodes = LanguageCodes>(abbreviation: string, options?: {
+  fetch?: FetchFunction;
+  languages?: T;
+}): Promise<{
+  website: Website<T>;
+  error: null;
+  detailedError: null;
+} | {
+  website: null;
+  error: string;
+  detailedError: string;
+}>;
+//#endregion
+export { fetchWebsite };

package/dist/fetchers/website.mjs

@@ -0,0 +1,38 @@
+import { XML_PARSER_OPTIONS } from "../constants.mjs";
+import { createSchemaValidationError, getErrorOutput } from "../utils.mjs";
+import { restoreXMLMetadata } from "../xml/metadata.mjs";
+import { XMLWebsiteData } from "../xml/schemas.mjs";
+import { parseWebsite } from "../parsers/website/index.mjs";
+import * as v from "valibot";
+import { XMLParser } from "fast-xml-parser";
+//#region src/fetchers/website.ts
+/**
+* Fetches and parses a website configuration from the OCHRE API
+*
+* @param abbreviation - The abbreviation identifier for the website
+* @returns The parsed website configuration or null if the fetch/parse fails
+*/
+async function fetchWebsite(abbreviation, options) {
+	try {
+		const cleanAbbreviation = abbreviation.trim().toLocaleLowerCase("en-US");
+		const response = await (options?.fetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery=${encodeURIComponent(`collection('ochre/tree')/ochre[tree/identification/abbreviation/content/string='${cleanAbbreviation}']`)}&xsl=none&lang="*"`);
+		if (!response.ok) throw new Error("Failed to fetch website", { cause: response.statusText });
+		const dataRaw = await response.text();
+		const data = new XMLParser(XML_PARSER_OPTIONS).parse(dataRaw);
+		const { success, issues, output } = v.safeParse(XMLWebsiteData, data);
+		if (!success) throw createSchemaValidationError("Failed to parse website XML", issues);
+		restoreXMLMetadata(output, data);
+		return {
+			website: parseWebsite(output, { languages: options?.languages }),
+			error: null,
+			detailedError: null
+		};
+	} catch (error) {
+		return {
+			website: null,
+			...getErrorOutput(error, "Unknown error")
+		};
+	}
+}
+//#endregion
+export { fetchWebsite };