ochre-sdk 0.22.2 → 0.22.4

package/dist/index.mjs

@@ -2158,7 +2158,7 @@ async function fetchItem(uuid, category, itemCategories, options) {
 }
 //#endregion
 //#region src/utils/query.ts
-const CTS_INCLUDES_STOP_WORDS = [
+const CTS_INCLUDES_STOP_WORDS = new Set([
 	"and",
 	"at",
 	"in",
@@ -2166,601 +2166,415 @@ const CTS_INCLUDES_STOP_WORDS = [
 	"of",
 	"the",
 	"to"
-];
-const CTS_INCLUDES_STOP_WORDS_VAR = "$ctsIncludesStopWords";
+]);
 const CTS_INCLUDES_TOKEN_SPLIT_REGEX = /\W+/u;
+const CONTENT_TARGET_CONTAINER_ELEMENTS = {
+	title: "identification",
+	description: "description",
+	image: "image",
+	periods: "period",
+	bibliography: "bibliography"
+};
 function tokenizeIncludesSearchValue(params) {
 	const { value, isCaseSensitive } = params;
 	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).split(CTS_INCLUDES_TOKEN_SPLIT_REGEX);
 	const terms = [];
 	for (const term of rawTerms) {
 		const normalizedTerm = term.toLowerCase();
-		if (normalizedTerm !== "" && !CTS_INCLUDES_STOP_WORDS.includes(normalizedTerm)) terms.push(term);
+		if (normalizedTerm !== "" && !CTS_INCLUDES_STOP_WORDS.has(normalizedTerm)) terms.push(term);
 	}
 	return terms;
 }
-function buildFlattenedContentValuesExpression(contentNodesExpression) {
-	return `for $content in ${contentNodesExpression}
-    return string-join($content//text(), "")`;
-}
-function buildSearchableContentNodesExpression(contentNodesExpression) {
-	return `for $content in ${contentNodesExpression}
-    return (
-      $content//string[not(ancestor::string)],
-      $content[not(.//string)]
-    )`;
-}
-function buildCombinedSearchableContentNodesExpression(contentNodesExpressions) {
-	const searchableExpressions = [];
-	for (const contentNodesExpression of contentNodesExpressions) searchableExpressions.push(buildSearchableContentNodesExpression(contentNodesExpression));
-	if (searchableExpressions.length === 0) return "()";
-	if (searchableExpressions.length === 1) return searchableExpressions[0] ?? "()";
-	return `(${searchableExpressions.join(", ")})`;
-}
-function buildAttributeValuesExpression(params) {
-	const { nodeExpression, attributeName } = params;
-	return `for $node in ${nodeExpression}[@${attributeName}]
-    return string($node/@${attributeName})`;
-}
-function buildNotesContentNodesExpression(language) {
-	return `notes/note/content[@xml:lang="${language}"]`;
-}
-function buildNotesTitleValuesExpression(language) {
-	return buildAttributeValuesExpression({
-		nodeExpression: buildNotesContentNodesExpression(language),
-		attributeName: "title"
-	});
-}
-function buildNotesValueExpressions(language) {
-	return [buildFlattenedContentValuesExpression(buildNotesContentNodesExpression(language)), buildNotesTitleValuesExpression(language)];
-}
-function buildPropertyValueNodesExpression(params) {
-	const predicates = [];
-	if (params?.excludeInherited) predicates.push(`not(@inherited="true")`);
-	for (const excludedDataType of params?.excludedDataTypes ?? []) predicates.push(`not(@dataType=${stringLiteral(excludedDataType)})`);
-	if (predicates.length === 0) return "value";
-	return `value[${predicates.join(" and ")}]`;
-}
-function buildPropertyValueContentNodesExpression(params) {
-	const { language, excludeInherited, excludedDataTypes } = params;
-	return `${buildPropertyValueNodesExpression({
-		excludeInherited,
-		excludedDataTypes
-	})}/content[@xml:lang="${language}"]`;
-}
-function buildPropertyValueContentValuesExpression(params) {
-	return buildFlattenedContentValuesExpression(buildPropertyValueContentNodesExpression(params));
-}
-function buildPropertyValueRawValuesExpression(params) {
-	return `for $value in ${buildPropertyValueNodesExpression(params)}[@rawValue]
-    return string($value/@rawValue)`;
-}
-function buildPropertyValueDirectTextValuesExpression(params) {
-	return `for $value in ${buildPropertyValueNodesExpression(params)}
-    let $candidate := string-join($value/text(), "")
-    where normalize-space($candidate) != ""
-    return $candidate`;
-}
-function buildPropertyScalarValueExpressions() {
-	return [buildPropertyValueRawValuesExpression(), buildPropertyValueDirectTextValuesExpression()];
-}
-function buildAllPropertyValueExpressions(language) {
-	const params = { excludedDataTypes: ["IDREF"] };
-	return [
-		buildPropertyValueRawValuesExpression(params),
-		buildPropertyValueContentValuesExpression({
-			language,
-			...params
-		}),
-		buildPropertyValueDirectTextValuesExpression(params)
-	];
-}
-/**
-* Build a string match predicate for an XQuery string.
-*/
-function buildRawStringMatchPredicate(params) {
-	const { valueExpression, value, matchMode, isCaseSensitive } = params;
-	const comparedValueLiteral = stringLiteral(isCaseSensitive ? value : value.toLowerCase());
-	const candidateVar = "$candidate";
-	const comparedCandidate = isCaseSensitive ? candidateVar : `lower-case(${candidateVar})`;
-	if (matchMode === "includes") return `exists(
-  for ${candidateVar} in (${valueExpression})
-    where contains(${comparedCandidate}, ${comparedValueLiteral})
-    return ${candidateVar}
-)`;
-	return `exists(
-  for ${candidateVar} in (${valueExpression})
-    where ${comparedCandidate} = ${comparedValueLiteral}
-    return ${candidateVar}
-)`;
-}
-/**
-* Build a combined raw string match predicate for multiple paths.
-*/
-function buildCombinedRawStringMatchPredicate(params) {
-	const { valueExpressions, value, matchMode, isCaseSensitive } = params;
-	const predicates = [];
-	for (const valueExpression of valueExpressions) predicates.push(`(${buildRawStringMatchPredicate({
-		valueExpression,
-		value,
-		matchMode,
-		isCaseSensitive
-	})})`);
-	return buildOrPredicate(predicates);
-}
-/**
-* Build CTS word-query options for API v2 includes search.
-*/
-function buildCtsQueryOptionsExpression(params) {
-	const { isCaseSensitive, isWildcarded } = params;
-	const options = [
+function buildCtsMatchOptionsExpression(params) {
+	const { isCaseSensitive } = params;
+	return `(${[
 		isCaseSensitive ? "case-sensitive" : "case-insensitive",
 		"diacritic-insensitive",
-		"punctuation-insensitive"
-	];
-	if (isWildcarded) options.push("wildcarded");
-	return `(${options.map((option) => stringLiteral(option)).join(", ")})`;
-}
-function buildWildcardedTermExpression(termExpression) {
-	return `fn:concat("*", ${termExpression}, "*")`;
+		"punctuation-insensitive",
+		"whitespace-insensitive",
+		"unstemmed",
+		"unwildcarded"
+	].map((option) => stringLiteral(option)).join(", ")})`;
 }
-/**
-* Build a CTS word-query expression for an XQuery term.
-*/
 function buildCtsWordQueryExpression(params) {
-	const { termExpression, isCaseSensitive, isWildcarded } = params;
-	return `cts:word-query(${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
-		isCaseSensitive,
-		isWildcarded
+	const { value, matchMode, isCaseSensitive } = params;
+	return `cts:word-query(${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
+		matchMode,
+		isCaseSensitive
 	})})`;
 }
 function buildCtsElementWordQueryExpression(params) {
-	const { elementName, termExpression, isCaseSensitive, isWildcarded } = params;
-	return `cts:element-word-query(xs:QName("${elementName}"), ${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
-		isCaseSensitive,
-		isWildcarded
+	const { elementName, value, matchMode, isCaseSensitive } = params;
+	return `cts:element-word-query(xs:QName("${elementName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
+		matchMode,
+		isCaseSensitive
 	})})`;
 }
 function buildCtsElementAttributeWordQueryExpression(params) {
-	const { elementName, attributeName, termExpression, isCaseSensitive, isWildcarded } = params;
-	return `cts:element-attribute-word-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
-		isCaseSensitive,
-		isWildcarded
+	const { elementName, attributeName, value, matchMode, isCaseSensitive } = params;
+	return `cts:element-attribute-word-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
+		matchMode,
+		isCaseSensitive
 	})})`;
 }
-/**
-* Build tokenized search declarations for CTS-backed queries.
-*/
-function buildTokenizedSearchDeclarations(params) {
-	const { value, isCaseSensitive, queryKey } = params;
-	const searchStringVar = `$query${queryKey}SearchString`;
-	const rawTermsVar = `$query${queryKey}RawTerms`;
-	const termsVar = `$query${queryKey}Terms`;
-	const tokenSourceExpression = isCaseSensitive ? searchStringVar : `fn:lower-case(${searchStringVar})`;
-	return {
-		declarations: [
-			`let ${searchStringVar} := ${stringLiteral(value)}`,
-			String.raw`let ${rawTermsVar} := fn:tokenize(${tokenSourceExpression}, "\W+")`,
-			`let ${termsVar} :=
-  for $term in ${rawTermsVar}
-    let $normalizedTerm := fn:lower-case($term)
-    where $normalizedTerm ne "" and not($normalizedTerm = ${CTS_INCLUDES_STOP_WORDS_VAR})
-    return $term`
-		],
-		termsVar
-	};
+function buildCtsElementValueQueryExpression(params) {
+	const { elementName, value, isCaseSensitive } = params;
+	return `cts:element-value-query(xs:QName("${elementName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
+		matchMode: "exact",
+		isCaseSensitive
+	})})`;
 }
-function buildCtsCandidateQuery(params) {
-	const { value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
-	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
-		value,
-		isCaseSensitive,
-		queryKey
-	});
-	const termQueriesVar = `$query${queryKey}TermQueries`;
-	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	if (tokenizeIncludesSearchValue({
-		value,
+function buildCtsElementAttributeValueQueryExpression(params) {
+	const { elementName, attributeName, value, isCaseSensitive } = params;
+	return `cts:element-attribute-value-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
+		matchMode: "exact",
 		isCaseSensitive
-	}).length === 0) return {
-		declarations: [],
-		termsVar: tokenizedSearchDeclarations.termsVar,
-		candidateQueryVar: null
-	};
-	return {
-		declarations: [
-			...tokenizedSearchDeclarations.declarations,
-			`let ${termQueriesVar} :=
-  for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildCandidateTermQuery("$term")}`,
-			`let ${candidateQueryVar} :=
-  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
-  then ${termQueriesVar}[1]
-  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
-  then cts:and-query(${termQueriesVar})
-  else ()`
-		],
-		termsVar: tokenizedSearchDeclarations.termsVar,
-		candidateQueryVar
-	};
+	})})`;
+}
+function buildPlainElementAttributeValueQueryExpression(params) {
+	const { elementName, attributeName, value } = params;
+	return `cts:element-attribute-value-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${stringLiteral(value)})`;
 }
-function buildCtsIncludesPredicate(params) {
-	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
-	const candidateQuery = buildCtsCandidateQuery({
+function buildSearchableContentTextQueryExpression(params) {
+	const { value, matchMode, isCaseSensitive } = params;
+	if (matchMode === "exact") return buildCtsWordQueryExpression({
 		value,
-		isCaseSensitive,
-		queryKey,
-		buildCandidateTermQuery
+		matchMode,
+		isCaseSensitive
 	});
-	const fallbackPredicate = buildRawStringMatchPredicate({
-		valueExpression: fallbackValueExpression,
+	return buildOrCtsQueryExpressionInternal([buildCtsElementWordQueryExpression({
+		elementName: "string",
 		value,
-		matchMode: "includes",
+		matchMode,
 		isCaseSensitive
-	});
-	if (candidateQuery.candidateQueryVar == null) return {
-		declarations: [],
-		predicate: fallbackPredicate,
-		candidateQueryVar: null
-	};
-	return {
-		declarations: candidateQuery.declarations,
-		predicate: `(every $term in ${candidateQuery.termsVar}
-  satisfies some $searchNode in (${searchableNodesExpression})
-    satisfies cts:contains(
-      $searchNode,
-      ${buildCtsWordQueryExpression({
-			termExpression: "$term",
-			isCaseSensitive
-		})}
-    ))`,
-		candidateQueryVar: candidateQuery.candidateQueryVar
-	};
-}
-/**
-* Build the raw search paths for item-level string search.
-*/
-function buildItemStringSearchPaths(language) {
-	return [buildFlattenedContentValuesExpression(`identification/label/content[@xml:lang="${language}"]`), buildFlattenedContentValuesExpression(`properties//property/value[not(@inherited="true")]/content[@xml:lang="${language}"]`)];
-}
-function buildItemStringSearchableNodesExpression(language) {
-	return buildCombinedSearchableContentNodesExpression([`identification/label/content[@xml:lang="${language}"]`, `properties//property/value[not(@inherited="true")]/content[@xml:lang="${language}"]`]);
-}
-/**
-* Build the identification branch for an item-level CTS string search.
-*/
-function buildItemStringIdentificationBranch(params) {
-	const { termExpression, isCaseSensitive, language } = params;
-	return `cts:element-query(xs:QName("identification"),
-        cts:and-query((
-          cts:element-attribute-value-query(xs:QName("content"), xs:QName("xml:lang"), ${stringLiteral(language)}),
-          ${buildCtsWordQueryExpression({
-		termExpression,
+	}), buildCtsWordQueryExpression({
+		value,
+		matchMode,
 		isCaseSensitive
-	})}
-        ))
-      )`;
+	})]);
 }
-/**
-* Build the property value branch for an item-level CTS string search.
-*/
-function buildItemStringPropertyValueBranch(params) {
-	const { termExpression, isCaseSensitive, language } = params;
-	return `cts:element-query(xs:QName("properties"),
-        cts:element-query(xs:QName("property"),
-          cts:element-query(xs:QName("value"),
-            cts:and-query((
-              cts:not-query(cts:element-attribute-value-query(xs:QName("value"), xs:QName("inherited"), "true")),
-              cts:element-query(xs:QName("content"),
-                cts:and-query((
-                  cts:element-attribute-value-query(xs:QName("content"), xs:QName("xml:lang"), ${stringLiteral(language)}),
-                  ${buildCtsWordQueryExpression({
-		termExpression,
-		isCaseSensitive
-	})}
-                ))
-              )
-            ))
-          )
-        )
-      )`;
+function buildNestedElementQuery(elementNames, queryExpression) {
+	let wrappedQueryExpression = queryExpression;
+	for (const elementName of elementNames.toReversed()) wrappedQueryExpression = `cts:element-query(xs:QName("${elementName}"), ${wrappedQueryExpression})`;
+	return wrappedQueryExpression;
 }
-/**
-* Build an item-level CTS string search predicate.
-*/
-function buildItemStringSearchClause(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	const fallbackPredicate = buildCombinedRawStringMatchPredicate({
-		valueExpressions: buildItemStringSearchPaths(query.language),
-		value: query.value,
-		matchMode: query.matchMode,
-		isCaseSensitive: query.isCaseSensitive
-	});
-	if (!allowCtsPredicates || query.matchMode !== "includes" || version !== 2) return {
-		declarations: [],
-		predicate: fallbackPredicate,
-		candidateQueryVar: null
-	};
-	return buildCtsIncludesPredicate({
-		searchableNodesExpression: buildItemStringSearchableNodesExpression(query.language),
-		fallbackValueExpression: `(${buildItemStringSearchPaths(query.language).join(", ")})`,
-		value: query.value,
-		isCaseSensitive: query.isCaseSensitive,
-		queryKey,
-		buildCandidateTermQuery: (termExpression) => `cts:or-query((
-        ${buildItemStringIdentificationBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
-		})},
-        ${buildItemStringPropertyValueBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
-		})}
-      ))`
-	});
+function buildNotCtsQueryExpression(queryExpression) {
+	return `cts:not-query(${queryExpression})`;
 }
-function buildOrPredicate(predicates) {
-	if (predicates.length === 0) return "false()";
-	if (predicates.length === 1) return predicates[0] ?? "false()";
-	return `(${predicates.join(" or ")})`;
+function buildAndCtsQueryExpressionInternal(queryExpressions) {
+	if (queryExpressions.length === 0) return "cts:true-query()";
+	if (queryExpressions.length === 1) return queryExpressions[0] ?? "cts:true-query()";
+	return `cts:and-query((${queryExpressions.join(", ")}))`;
 }
-function buildAndPredicate(predicates) {
-	if (predicates.length === 0) return "true()";
-	if (predicates.length === 1) return predicates[0] ?? "true()";
-	return `(${predicates.join(" and ")})`;
+function buildOrCtsQueryExpressionInternal(queryExpressions) {
+	if (queryExpressions.length === 0) return "cts:false-query()";
+	if (queryExpressions.length === 1) return queryExpressions[0] ?? "cts:false-query()";
+	return `cts:or-query((${queryExpressions.join(", ")}))`;
 }
-/**
-* Build a date/dateTime range predicate for an XQuery string.
-*/
-function buildDateRangePredicate(params) {
-	const { from, to } = params;
-	const conditions = [];
-	if (from != null) conditions.push(`(value/@rawValue ge ${stringLiteral(from)})`);
-	if (to != null) conditions.push(`(value/@rawValue le ${stringLiteral(to)})`);
-	return buildAndPredicate(conditions);
+function buildAndCtsQueryExpression(queryExpressions) {
+	if (queryExpressions.length === 0) return null;
+	return buildAndCtsQueryExpressionInternal(queryExpressions);
 }
-/**
-* Build a property label predicate for an XQuery string.
-*/
-function buildPropertyLabelPredicate(propertyVariable) {
-	return `label[@uuid=${stringLiteral(propertyVariable)}]`;
+function buildContentLanguageQuery(language) {
+	return buildPlainElementAttributeValueQueryExpression({
+		elementName: "content",
+		attributeName: "xml:lang",
+		value: language
+	});
 }
-function buildOrCtsQueryExpression(queries) {
-	if (queries.length === 1) return queries[0] ?? "cts:false-query()";
-	return `cts:or-query((${queries.join(", ")}))`;
+function buildPropertyLabelQuery(propertyVariable) {
+	return buildPlainElementAttributeValueQueryExpression({
+		elementName: "label",
+		attributeName: "uuid",
+		value: propertyVariable
+	});
 }
-function isQueryLeaf(query) {
-	return "target" in query;
+function buildValueNotInheritedQuery() {
+	return buildNotCtsQueryExpression(buildPlainElementAttributeValueQueryExpression({
+		elementName: "value",
+		attributeName: "inherited",
+		value: "true"
+	}));
 }
-function getQueryGroupChildren(query) {
-	return "and" in query ? query.and : query.or;
+function buildValueNotIdRefQuery() {
+	return buildNotCtsQueryExpression(buildPlainElementAttributeValueQueryExpression({
+		elementName: "value",
+		attributeName: "dataType",
+		value: "IDREF"
+	}));
 }
-function getQueryGroupOperator(query) {
-	return "and" in query ? "and" : "or";
+function buildValueContentInnerQuery(params) {
+	const { language, value, matchMode, isCaseSensitive } = params;
+	return buildNestedElementQuery(["content"], buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildSearchableContentTextQueryExpression({
+		value,
+		matchMode,
+		isCaseSensitive
+	})]));
 }
-function buildContentTargetCandidateBranch(params) {
-	const { containerElementName, termExpression, isCaseSensitive, language } = params;
-	return `cts:element-query(xs:QName("${containerElementName}"),
-        cts:and-query((
-          cts:element-attribute-value-query(xs:QName("content"), xs:QName("xml:lang"), ${stringLiteral(language)}),
-          ${buildCtsWordQueryExpression({
-		termExpression,
+function buildValueDirectTextInnerQuery(params) {
+	const { value, matchMode, isCaseSensitive } = params;
+	const directTextQuery = matchMode === "exact" ? buildCtsElementValueQueryExpression({
+		elementName: "value",
+		value,
 		isCaseSensitive
-	})}
-        ))
-      )`;
-}
-function buildPropertyStringCandidateBranch(params) {
-	const { termExpression, isCaseSensitive, language } = params;
-	return `cts:element-query(xs:QName("properties"),
-        cts:element-query(xs:QName("property"),
-          cts:element-query(xs:QName("value"),
-            cts:and-query((
-              cts:not-query(cts:element-attribute-value-query(xs:QName("value"), xs:QName("inherited"), "true")),
-              cts:element-query(xs:QName("content"),
-                cts:and-query((
-                  cts:element-attribute-value-query(xs:QName("content"), xs:QName("xml:lang"), ${stringLiteral(language)}),
-                  ${buildCtsWordQueryExpression({
-		termExpression,
+	}) : buildCtsElementWordQueryExpression({
+		elementName: "value",
+		value,
+		matchMode,
 		isCaseSensitive
-	})}
-                ))
-              )
-            ))
-          )
-        )
-      )`;
-}
-function buildPropertyScalarCandidateBranch(params) {
-	const { termExpression, isCaseSensitive } = params;
-	return `cts:element-query(xs:QName("properties"),
-        cts:element-query(xs:QName("property"),
-          cts:or-query((
-            ${buildCtsElementAttributeWordQueryExpression({
+	});
+	return buildAndCtsQueryExpressionInternal([buildNotCtsQueryExpression(buildNestedElementQuery(["content"], "cts:true-query()")), directTextQuery]);
+}
+function buildValueRawValueInnerQuery(params) {
+	const { value, matchMode, isCaseSensitive } = params;
+	if (matchMode === "exact") return buildCtsElementAttributeValueQueryExpression({
 		elementName: "value",
 		attributeName: "rawValue",
-		termExpression,
-		isCaseSensitive,
-		isWildcarded: true
-	})},
-            ${buildCtsElementWordQueryExpression({
+		value,
+		isCaseSensitive
+	});
+	return buildCtsElementAttributeWordQueryExpression({
 		elementName: "value",
-		termExpression,
-		isCaseSensitive,
-		isWildcarded: true
-	})}
-          ))
-        )
-      )`;
-}
-function buildNotesCandidateBranch(params) {
-	const { termExpression, isCaseSensitive, language } = params;
-	return `cts:element-query(xs:QName("notes"),
-        cts:element-query(xs:QName("note"),
-          cts:element-query(xs:QName("content"),
-            cts:and-query((
-              cts:element-attribute-value-query(xs:QName("content"), xs:QName("xml:lang"), ${stringLiteral(language)}),
-              cts:or-query((
-                ${buildCtsElementAttributeWordQueryExpression({
+		attributeName: "rawValue",
+		value,
+		matchMode,
+		isCaseSensitive
+	});
+}
+function buildNotesQueryExpression(params) {
+	const { value, matchMode, isCaseSensitive, language } = params;
+	return buildNestedElementQuery([
+		"notes",
+		"note",
+		"content"
+	], buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildOrCtsQueryExpressionInternal([matchMode === "exact" ? buildCtsElementAttributeValueQueryExpression({
 		elementName: "content",
 		attributeName: "title",
-		termExpression,
+		value,
 		isCaseSensitive
-	})},
-                ${buildCtsWordQueryExpression({
-		termExpression,
+	}) : buildCtsElementAttributeWordQueryExpression({
+		elementName: "content",
+		attributeName: "title",
+		value,
+		matchMode,
 		isCaseSensitive
-	})}
-              ))
-            ))
-          )
-        )
-      )`;
+	}), buildSearchableContentTextQueryExpression({
+		value,
+		matchMode,
+		isCaseSensitive
+	})])]));
 }
-function getGroupableIncludesValue(query) {
+function buildContentTargetQueryExpression(params) {
+	const { target, value, matchMode, isCaseSensitive, language } = params;
+	const containerElement = CONTENT_TARGET_CONTAINER_ELEMENTS[target];
+	return buildNestedElementQuery([containerElement], buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildSearchableContentTextQueryExpression({
+		value,
+		matchMode,
+		isCaseSensitive
+	})]));
+}
+function buildPropertyQueryExpression(params) {
+	const { propertyVariable, queryExpression } = params;
+	const propertyQueryExpressions = [queryExpression];
+	if (propertyVariable != null) propertyQueryExpressions.unshift(buildPropertyLabelQuery(propertyVariable));
+	return buildNestedElementQuery(["properties", "property"], buildAndCtsQueryExpressionInternal(propertyQueryExpressions));
+}
+function buildPropertyPresenceQueryExpression(params) {
+	return buildPropertyQueryExpression({
+		propertyVariable: params.propertyVariable,
+		queryExpression: "cts:true-query()"
+	});
+}
+function buildPropertyStringQueryExpression(params) {
+	const { propertyVariable, value, matchMode, isCaseSensitive, language } = params;
+	return buildPropertyQueryExpression({
+		propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildAndCtsQueryExpressionInternal([buildValueNotInheritedQuery(), buildValueContentInnerQuery({
+			language,
+			value,
+			matchMode,
+			isCaseSensitive
+		})]))
+	});
+}
+function buildPropertyScalarQueryExpression(params) {
+	const { propertyVariable, value, matchMode, isCaseSensitive } = params;
+	return buildPropertyQueryExpression({
+		propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildOrCtsQueryExpressionInternal([buildValueRawValueInnerQuery({
+			value,
+			matchMode,
+			isCaseSensitive
+		}), buildValueDirectTextInnerQuery({
+			value,
+			matchMode,
+			isCaseSensitive
+		})]))
+	});
+}
+function buildPropertyAllQueryExpression(params) {
+	const { query, value, matchMode } = params;
+	return buildPropertyQueryExpression({
+		propertyVariable: query.propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildAndCtsQueryExpressionInternal([buildValueNotIdRefQuery(), buildCtsWordQueryExpression({
+			value,
+			matchMode,
+			isCaseSensitive: query.isCaseSensitive
+		})]))
+	});
+}
+function buildPropertyIdRefQueryExpression(params) {
+	const { propertyVariable, value } = params;
+	return buildPropertyQueryExpression({
+		propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildPlainElementAttributeValueQueryExpression({
+			elementName: "value",
+			attributeName: "uuid",
+			value
+		}))
+	});
+}
+function buildPropertyDateRangeQueryExpression(query) {
+	const rangeQueryExpressions = [];
+	if (query.from != null) rangeQueryExpressions.push(`cts:element-attribute-range-query(xs:QName("value"), xs:QName("rawValue"), ">=", ${stringLiteral(query.from)})`);
+	if (query.to != null) rangeQueryExpressions.push(`cts:element-attribute-range-query(xs:QName("value"), xs:QName("rawValue"), "<=", ${stringLiteral(query.to)})`);
+	return buildPropertyQueryExpression({
+		propertyVariable: query.propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildAndCtsQueryExpressionInternal(rangeQueryExpressions))
+	});
+}
+function buildItemStringQueryExpression(params) {
+	const { value, matchMode, isCaseSensitive, language } = params;
+	return buildOrCtsQueryExpressionInternal([buildContentTargetQueryExpression({
+		target: "title",
+		value,
+		matchMode,
+		isCaseSensitive,
+		language
+	}), buildPropertyStringQueryExpression({
+		value,
+		matchMode,
+		isCaseSensitive,
+		language
+	})]);
+}
+function getLeafSearchValue(query) {
 	switch (query.target) {
 		case "string":
 		case "title":
 		case "description":
 		case "image":
-		case "notes":
 		case "periods":
-		case "bibliography": return query.value;
-		case "property":
-			if (query.dataType !== "string" || query.value == null) return null;
-			return query.value;
+		case "bibliography":
+		case "notes": return query.value;
+		case "property": return "value" in query && query.value != null ? query.value : null;
 	}
 }
-function isCompatibleIncludesGroupQuery(params) {
-	const { query, value, isCaseSensitive, language, version } = params;
-	if (version !== 2 || query.matchMode !== "includes" || query.isNegated === true) return false;
-	const queryValue = getGroupableIncludesValue(query);
-	return queryValue != null && queryValue === value && query.isCaseSensitive === isCaseSensitive && query.language === language;
-}
-function buildContentTargetIncludesGroupMember(params) {
-	const { contentNodesExpression, value, isCaseSensitive, language, containerElementName } = params;
-	return {
-		rawPredicate: buildRawStringMatchPredicate({
-			valueExpression: buildFlattenedContentValuesExpression(contentNodesExpression),
+function buildLeafValueQueryExpression(params) {
+	const { query, value, matchMode } = params;
+	switch (query.target) {
+		case "string": return buildItemStringQueryExpression({
 			value,
-			matchMode: "includes",
-			isCaseSensitive
-		}),
-		buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-			containerElementName,
-			termExpression,
-			isCaseSensitive,
-			language
-		})
-	};
-}
-function buildItemStringIncludesGroupMember(query) {
-	return {
-		rawPredicate: buildCombinedRawStringMatchPredicate({
-			valueExpressions: buildItemStringSearchPaths(query.language),
-			value: query.value,
-			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
-		}),
-		buildCandidateTermQuery: (termExpression) => `cts:or-query((
-        ${buildItemStringIdentificationBranch({
-			termExpression,
+			matchMode,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language
-		})},
-        ${buildItemStringPropertyValueBranch({
-			termExpression,
+		});
+		case "notes": return buildNotesQueryExpression({
+			value,
+			matchMode,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language
-		})}
-      ))`
-	};
-}
-function buildPropertyStringIncludesGroupMember(query) {
-	const propertyVariable = query.propertyVariable;
-	const predicateParts = [];
-	const valueExpression = buildPropertyValueContentValuesExpression({
-		language: query.language,
-		excludeInherited: true
-	});
-	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	return {
-		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildRawStringMatchPredicate({
-			valueExpression,
-			value: query.value,
-			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
-		})]),
-		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
-			termExpression,
+		});
+		case "title":
+		case "description":
+		case "image":
+		case "periods":
+		case "bibliography": return buildContentTargetQueryExpression({
+			target: query.target,
+			value,
+			matchMode,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language
-		})
-	};
+		});
+		case "property": switch (query.dataType) {
+			case "all": return buildPropertyAllQueryExpression({
+				query,
+				value,
+				matchMode
+			});
+			case "IDREF": return buildPropertyIdRefQueryExpression({
+				propertyVariable: query.propertyVariable,
+				value
+			});
+			case "string": return buildPropertyStringQueryExpression({
+				propertyVariable: query.propertyVariable,
+				value,
+				matchMode,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			});
+			case "integer":
+			case "decimal":
+			case "time":
+			case "boolean":
+			case "date":
+			case "dateTime": return buildPropertyScalarQueryExpression({
+				propertyVariable: query.propertyVariable,
+				value,
+				matchMode,
+				isCaseSensitive: query.isCaseSensitive
+			});
+		}
+	}
 }
-function buildNotesIncludesGroupMember(query) {
-	return {
-		rawPredicate: buildCombinedRawStringMatchPredicate({
-			valueExpressions: buildNotesValueExpressions(query.language),
-			value: query.value,
-			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
-		}),
-		buildCandidateTermQuery: (termExpression) => buildNotesCandidateBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
-		})
-	};
+function buildLeafQueryExpression(query) {
+	if (query.target === "property" && query.dataType !== "date" && query.dataType !== "dateTime" && !("value" in query) && query.propertyVariable != null) return buildPropertyPresenceQueryExpression({ propertyVariable: query.propertyVariable });
+	if (query.target === "property" && (query.dataType === "date" || query.dataType === "dateTime") && query.value == null) return buildPropertyDateRangeQueryExpression(query);
+	const searchValue = getLeafSearchValue(query);
+	if (searchValue == null) throw new Error("Missing searchable value for query leaf");
+	if (query.matchMode === "exact") return buildLeafValueQueryExpression({
+		query,
+		value: searchValue,
+		matchMode: "exact"
+	});
+	const terms = tokenizeIncludesSearchValue({
+		value: searchValue,
+		isCaseSensitive: query.isCaseSensitive
+	});
+	if (terms.length === 0) return "cts:false-query()";
+	const termQueryExpressions = [];
+	for (const term of terms) termQueryExpressions.push(buildLeafValueQueryExpression({
+		query,
+		value: term,
+		matchMode: "includes"
+	}));
+	return buildAndCtsQueryExpressionInternal(termQueryExpressions);
 }
-function buildIncludesGroupMember(query) {
+function getGroupableIncludesValue(query) {
+	if (query.matchMode !== "includes" || query.isNegated === true) return null;
 	switch (query.target) {
-		case "string": return buildItemStringIncludesGroupMember(query);
-		case "title": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "identification"
-		});
-		case "description": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "description"
-		});
-		case "periods": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "period"
-		});
-		case "bibliography": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "bibliography"
-		});
-		case "image": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "image"
-		});
-		case "notes": return buildNotesIncludesGroupMember(query);
+		case "string":
+		case "title":
+		case "description":
+		case "image":
+		case "periods":
+		case "bibliography":
+		case "notes": return query.value;
 		case "property":
-			if (query.dataType === "all") throw new Error(`Property queries with dataType "all" are not compatible with includes-group optimization`);
-			return buildPropertyStringIncludesGroupMember(query);
+			if (!("value" in query) || query.value == null || query.dataType === "IDREF") return null;
+			return query.value;
 	}
 }
-function getCompatibleIncludesGroupLeaves(params) {
-	const { query, version } = params;
+function isQueryLeaf(query) {
+	return "target" in query;
+}
+function getQueryGroupChildren(query) {
+	return "and" in query ? query.and : query.or;
+}
+function getQueryGroupOperator(query) {
+	return "and" in query ? "and" : "or";
+}
+function getCompatibleIncludesGroupLeaves(query) {
 	if (!("or" in query) || query.or.length <= 1) return null;
 	const leafQueries = [];
 	for (const childQuery of query.or) {
@@ -2770,482 +2584,64 @@ function getCompatibleIncludesGroupLeaves(params) {
 	const firstQuery = leafQueries[0];
 	if (firstQuery == null) return null;
 	const groupValue = getGroupableIncludesValue(firstQuery);
-	if (groupValue == null || !isCompatibleIncludesGroupQuery({
-		query: firstQuery,
-		value: groupValue,
-		isCaseSensitive: firstQuery.isCaseSensitive,
-		language: firstQuery.language,
-		version
-	})) return null;
-	for (const leafQuery of leafQueries.slice(1)) if (!isCompatibleIncludesGroupQuery({
-		query: leafQuery,
-		value: groupValue,
-		isCaseSensitive: firstQuery.isCaseSensitive,
-		language: firstQuery.language,
-		version
-	})) return null;
+	if (groupValue == null) return null;
+	for (const leafQuery of leafQueries) if (getGroupableIncludesValue(leafQuery) !== groupValue || leafQuery.isCaseSensitive !== firstQuery.isCaseSensitive || leafQuery.language !== firstQuery.language) return null;
 	return leafQueries;
 }
-function buildIncludesGroupClause(params) {
-	const { queries, queryKey } = params;
+function buildIncludesGroupMember(query) {
+	return { buildTermQuery: (term) => buildLeafValueQueryExpression({
+		query,
+		value: term,
+		matchMode: "includes"
+	}) };
+}
+function buildIncludesGroupQueryExpression(queries) {
 	const firstQuery = queries[0];
 	if (firstQuery == null) throw new Error("Cannot build an includes group without queries");
 	const groupValue = getGroupableIncludesValue(firstQuery);
 	if (groupValue == null) throw new Error("Cannot build an includes group without a search value");
-	const members = queries.map((query) => buildIncludesGroupMember(query));
-	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
-		value: groupValue,
-		isCaseSensitive: firstQuery.isCaseSensitive,
-		queryKey
-	});
-	const tokenizedTerms = tokenizeIncludesSearchValue({
+	const terms = tokenizeIncludesSearchValue({
 		value: groupValue,
 		isCaseSensitive: firstQuery.isCaseSensitive
 	});
-	const termQueriesVar = `$query${queryKey}TermQueries`;
-	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	if (tokenizedTerms.length === 0) return {
-		declarations: [],
-		predicate: buildOrPredicate(members.map((member) => member.rawPredicate)),
-		candidateQueryVar: null
-	};
-	return {
-		declarations: [
-			...tokenizedSearchDeclarations.declarations,
-			`let ${termQueriesVar} :=
-  for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildOrCtsQueryExpression(members.map((member) => member.buildCandidateTermQuery("$term")))}`,
-			`let ${candidateQueryVar} :=
-  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
-  then ${termQueriesVar}[1]
-  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
-  then cts:and-query(${termQueriesVar})
-  else ()`
-		],
-		predicate: `cts:contains(., ${candidateQueryVar})`,
-		candidateQueryVar
-	};
-}
-/**
-* Build a string match predicate for an XQuery string.
-*/
-function buildStringMatchClause(params) {
-	const { contentNodesExpression, value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates, buildCandidateTermQuery } = params;
-	const valueExpression = buildFlattenedContentValuesExpression(contentNodesExpression);
-	if (allowCtsPredicates && matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) return buildCtsIncludesPredicate({
-		searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
-		fallbackValueExpression: valueExpression,
-		value,
-		isCaseSensitive,
-		queryKey,
-		buildCandidateTermQuery
-	});
-	return {
-		declarations: [],
-		predicate: buildRawStringMatchPredicate({
-			valueExpression,
-			value,
-			matchMode,
-			isCaseSensitive
-		}),
-		candidateQueryVar: null
-	};
-}
-function buildCombinedRawStringMatchClause(params) {
-	const { valueExpressions, value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates, buildCandidateTermQuery } = params;
-	const predicate = buildCombinedRawStringMatchPredicate({
-		valueExpressions,
-		value,
-		matchMode,
-		isCaseSensitive
-	});
-	if (allowCtsPredicates && matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) {
-		const candidateQuery = buildCtsCandidateQuery({
-			value,
-			isCaseSensitive,
-			queryKey,
-			buildCandidateTermQuery
-		});
-		return {
-			declarations: candidateQuery.declarations,
-			predicate,
-			candidateQueryVar: candidateQuery.candidateQueryVar
-		};
-	}
-	return {
-		declarations: [],
-		predicate,
-		candidateQueryVar: null
-	};
-}
-function buildPropertyValueAttributePredicate(params) {
-	const { propertyValue, attributeName } = params;
-	return `value[@${attributeName}=${stringLiteral(propertyValue)}]`;
-}
-function buildPropertyPredicateExpression(propertyPredicates) {
-	let propertyExpression = ".//properties//property";
-	for (const propertyPredicate of propertyPredicates) propertyExpression += `[${propertyPredicate}]`;
-	return propertyExpression;
-}
-function buildPropertyStringValueClause(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	return buildStringMatchClause({
-		contentNodesExpression: buildPropertyValueContentNodesExpression({
-			language: query.language,
-			excludeInherited: allowCtsPredicates && query.matchMode === "includes" && version === 2
-		}),
-		value: query.value,
-		matchMode: query.matchMode,
-		isCaseSensitive: query.isCaseSensitive,
-		version,
-		queryKey,
-		allowCtsPredicates,
-		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
-		})
-	});
-}
-function buildPropertyScalarValueClause(params) {
-	const { value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates } = params;
-	return buildCombinedRawStringMatchClause({
-		valueExpressions: buildPropertyScalarValueExpressions(),
-		value,
-		matchMode,
-		isCaseSensitive,
-		version,
-		queryKey,
-		allowCtsPredicates,
-		buildCandidateTermQuery: (termExpression) => buildPropertyScalarCandidateBranch({
-			termExpression,
-			isCaseSensitive
-		})
-	});
-}
-function buildPropertyAllValueClause(query) {
-	return {
-		declarations: [],
-		predicate: buildCombinedRawStringMatchPredicate({
-			valueExpressions: buildAllPropertyValueExpressions(query.language),
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive
-		}),
-		candidateQueryVar: null
-	};
-}
-function buildNotesValueClause(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	return buildCombinedRawStringMatchClause({
-		valueExpressions: buildNotesValueExpressions(query.language),
-		value: query.value,
-		matchMode: query.matchMode,
-		isCaseSensitive: query.isCaseSensitive,
-		version,
-		queryKey,
-		allowCtsPredicates,
-		buildCandidateTermQuery: (termExpression) => buildNotesCandidateBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
-		})
-	});
-}
-/**
-* Build a property predicate for an XQuery string.
-*/
-function buildPropertyClause(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	const predicateParts = [];
-	const declarations = [];
-	const propertyVariable = query.propertyVariable;
-	let candidateQueryVar = null;
-	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	if (query.dataType === "all") {
-		const compiledAllClause = buildPropertyAllValueClause(query);
-		declarations.push(...compiledAllClause.declarations);
-		predicateParts.push(compiledAllClause.predicate);
-		candidateQueryVar = compiledAllClause.candidateQueryVar;
-	} else if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) {
-		const compiledScalarClause = buildPropertyScalarValueClause({
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates
-		});
-		declarations.push(...compiledScalarClause.declarations);
-		predicateParts.push(compiledScalarClause.predicate);
-		candidateQueryVar = compiledScalarClause.candidateQueryVar;
-	} else predicateParts.push(buildDateRangePredicate({
-		from: query.from,
-		to: query.to
-	}));
-	else if (query.value != null) switch (query.dataType) {
-		case "IDREF":
-			predicateParts.push(buildPropertyValueAttributePredicate({
-				propertyValue: query.value,
-				attributeName: "uuid"
-			}));
-			break;
-		case "integer":
-		case "decimal":
-		case "time":
-		case "boolean": {
-			const compiledScalarClause = buildPropertyScalarValueClause({
-				value: query.value,
-				matchMode: query.matchMode,
-				isCaseSensitive: query.isCaseSensitive,
-				version,
-				queryKey,
-				allowCtsPredicates
-			});
-			declarations.push(...compiledScalarClause.declarations);
-			predicateParts.push(compiledScalarClause.predicate);
-			candidateQueryVar = compiledScalarClause.candidateQueryVar;
-			break;
-		}
-		case "string": {
-			const compiledStringClause = buildPropertyStringValueClause({
-				query,
-				version,
-				queryKey,
-				allowCtsPredicates
-			});
-			declarations.push(...compiledStringClause.declarations);
-			predicateParts.push(compiledStringClause.predicate);
-			candidateQueryVar = compiledStringClause.candidateQueryVar;
-			break;
-		}
+	if (terms.length === 0) return "cts:false-query()";
+	const members = queries.map((query) => buildIncludesGroupMember(query));
+	const perTermQueryExpressions = [];
+	for (const term of terms) {
+		const fieldQueryExpressions = [];
+		for (const member of members) fieldQueryExpressions.push(member.buildTermQuery(term));
+		perTermQueryExpressions.push(buildOrCtsQueryExpressionInternal(fieldQueryExpressions));
 	}
-	return {
-		declarations,
-		predicate: buildPropertyPredicateExpression(predicateParts),
-		candidateQueryVar
-	};
+	return buildAndCtsQueryExpressionInternal(perTermQueryExpressions);
 }
-/**
-* Build a query predicate for an XQuery string.
-*/
-function buildQueryClause(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	switch (query.target) {
-		case "string": return buildItemStringSearchClause({
-			query,
-			version,
-			queryKey,
-			allowCtsPredicates
-		});
-		case "title": return buildStringMatchClause({
-			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "identification",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "description": return buildStringMatchClause({
-			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "description",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "periods": return buildStringMatchClause({
-			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "period",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "bibliography": return buildStringMatchClause({
-			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "bibliography",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "image": return buildStringMatchClause({
-			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			allowCtsPredicates,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "image",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "notes": return buildNotesValueClause({
-			query,
-			version,
-			queryKey,
-			allowCtsPredicates
-		});
-		case "property": return buildPropertyClause({
-			query,
-			version,
-			queryKey,
-			allowCtsPredicates
-		});
+function buildQueryNode(query) {
+	if (isQueryLeaf(query)) {
+		const queryExpression = buildLeafQueryExpression(query);
+		return query.isNegated === true ? buildNotCtsQueryExpression(queryExpression) : queryExpression;
 	}
-}
-/**
-* Build a boolean query clause for an XQuery string.
-*/
-function buildBooleanQueryNode(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	const compiledQueryClause = buildQueryClause({
-		query,
-		version,
-		queryKey,
-		allowCtsPredicates
-	});
-	const baseClause = `(${compiledQueryClause.predicate})`;
-	return {
-		declarations: compiledQueryClause.declarations,
-		predicate: query.isNegated ? `not(${baseClause})` : baseClause,
-		candidateQueryVars: query.isNegated || compiledQueryClause.candidateQueryVar == null ? [] : [compiledQueryClause.candidateQueryVar]
-	};
-}
-function buildQueryNode(params) {
-	const { query, version, queryKey, allowCtsPredicates } = params;
-	if (isQueryLeaf(query)) return buildBooleanQueryNode({
-		query,
-		version,
-		queryKey,
-		allowCtsPredicates
-	});
-	const groupQueries = getQueryGroupChildren(query);
-	const optimizedIncludesGroupQueries = getCompatibleIncludesGroupLeaves({
-		query,
-		version
-	});
-	if (groupQueries.length === 1) {
-		const onlyQuery = groupQueries[0];
-		if (onlyQuery == null) return {
-			declarations: [],
-			predicate: "",
-			candidateQueryVars: []
-		};
-		return buildQueryNode({
-			query: onlyQuery,
-			version,
-			queryKey,
-			allowCtsPredicates
-		});
-	}
-	if (allowCtsPredicates && optimizedIncludesGroupQueries != null) {
-		const compiledClause = buildIncludesGroupClause({
-			queries: optimizedIncludesGroupQueries,
-			queryKey
-		});
-		return {
-			declarations: compiledClause.declarations,
-			predicate: compiledClause.predicate,
-			candidateQueryVars: compiledClause.candidateQueryVar == null ? [] : [compiledClause.candidateQueryVar]
-		};
-	}
-	const declarations = [];
-	const predicates = [];
-	const groupOperator = getQueryGroupOperator(query);
-	let compiledChildNodes = groupQueries.map((groupQuery, groupIndex) => buildQueryNode({
-		query: groupQuery,
-		version,
-		queryKey: `${queryKey}_${groupIndex + 1}`,
-		allowCtsPredicates
-	}));
-	if (allowCtsPredicates && groupOperator === "or" && compiledChildNodes.some((node) => node.candidateQueryVars.length === 0)) compiledChildNodes = groupQueries.map((groupQuery, groupIndex) => buildQueryNode({
-		query: groupQuery,
-		version,
-		queryKey: `${queryKey}_${groupIndex + 1}`,
-		allowCtsPredicates: false
+	const optimizedIncludesGroupQueries = getCompatibleIncludesGroupLeaves(query);
+	if (optimizedIncludesGroupQueries != null) return buildIncludesGroupQueryExpression(optimizedIncludesGroupQueries);
+	const childQueryExpressions = [];
+	for (const childQuery of getQueryGroupChildren(query)) childQueryExpressions.push(buildQueryNode(childQuery));
+	return getQueryGroupOperator(query) === "and" ? buildAndCtsQueryExpressionInternal(childQueryExpressions) : buildOrCtsQueryExpressionInternal(childQueryExpressions);
+}
+function buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids, belongsToCollectionPropertyVariableUuid) {
+	if (belongsToCollectionScopeUuids.length === 0) return null;
+	const collectionValueQueryExpressions = [];
+	for (const uuid of belongsToCollectionScopeUuids) collectionValueQueryExpressions.push(buildPlainElementAttributeValueQueryExpression({
+		elementName: "value",
+		attributeName: "uuid",
+		value: uuid
 	}));
-	const candidateQueryVarsByChild = [];
-	for (const compiledQueryNode of compiledChildNodes) {
-		declarations.push(...compiledQueryNode.declarations);
-		predicates.push(compiledQueryNode.predicate);
-		candidateQueryVarsByChild.push(compiledQueryNode.candidateQueryVars);
-	}
-	const candidateQueryVars = groupOperator === "and" ? candidateQueryVarsByChild.flat() : candidateQueryVarsByChild.every((vars) => vars.length > 0) ? candidateQueryVarsByChild.flat() : [];
-	return {
-		declarations,
-		predicate: groupOperator === "and" ? buildAndPredicate(predicates) : buildOrPredicate(predicates),
-		candidateQueryVars
-	};
+	return buildPropertyQueryExpression({
+		propertyVariable: belongsToCollectionPropertyVariableUuid,
+		queryExpression: buildNestedElementQuery(["value"], buildOrCtsQueryExpressionInternal(collectionValueQueryExpressions))
+	});
 }
 function buildQueryPlan(params) {
-	const { queries, version, baseItemsExpression } = params;
-	const declarations = [];
-	let predicate = "";
-	let candidateQueryVars = [];
-	if (queries != null) {
-		const compiledQueryNode = buildQueryNode({
-			query: queries,
-			version,
-			queryKey: "1",
-			allowCtsPredicates: true
-		});
-		if (compiledQueryNode.declarations.length > 0) declarations.push(`let ${CTS_INCLUDES_STOP_WORDS_VAR} := (${CTS_INCLUDES_STOP_WORDS.map((stopWord) => stringLiteral(stopWord)).join(", ")})`, ...compiledQueryNode.declarations);
-		predicate = compiledQueryNode.predicate;
-		candidateQueryVars = compiledQueryNode.candidateQueryVars;
-	}
-	let itemsExpression = `(${baseItemsExpression})`;
-	if (candidateQueryVars.length > 0) {
-		const candidateQueriesExpression = `(${candidateQueryVars.join(", ")})`;
-		const candidateItemsQueryVar = "$candidateItemsQuery";
-		declarations.push(`let ${candidateItemsQueryVar} :=
-  if (count(${candidateQueriesExpression}) = 1)
-  then ${candidateQueriesExpression}[1]
-  else if (count(${candidateQueriesExpression}) gt 1)
-  then cts:or-query(${candidateQueriesExpression})
-  else ()`);
-		itemsExpression = `(if (exists(${candidateItemsQueryVar}))
-  then cts:search(${baseItemsExpression}, ${candidateItemsQueryVar})
-  else ${baseItemsExpression})`;
-	}
-	return {
-		declarations,
-		itemsExpression,
-		predicate
-	};
+	const { queries } = params;
+	if (queries == null) return { queryExpression: null };
+	return { queryExpression: buildQueryNode(queries) };
 }
 //#endregion
 //#region src/utils/fetchers/set/items.ts
@@ -3329,31 +2725,21 @@ function buildOrderedItemsClause(sort) {
 * For propertyValue sorting, dataType is required and the sort key uses the first valid leaf value (value[not(@i)]).
 * @param params.page - The page number (1-indexed)
 * @param params.pageSize - The number of items per page
-* @param options - Options for the fetch
-* @param options.version - The version of the OCHRE API to use
 * @returns An XQuery string
 */
-function buildXQuery$1(params, options) {
-	const version = options?.version ?? 2;
+function buildXQuery$1(params) {
 	const { queries, sort, setScopeUuids, belongsToCollectionScopeUuids, page, pageSize } = params;
 	const startPosition = (page - 1) * pageSize + 1;
 	const endPosition = page * pageSize;
-	const setScopeFilter = `/set[(${setScopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ")})]/items/*`;
-	const compiledQueryPlan = buildQueryPlan({
-		queries,
-		version,
-		baseItemsExpression: `${version === 2 ? "doc()" : "input()"}/ochre${setScopeFilter}`
-	});
-	const queryFilterDeclarations = compiledQueryPlan.declarations.length > 0 ? `${compiledQueryPlan.declarations.join("\n")}\n\n` : "";
-	const filterPredicates = [];
-	if (belongsToCollectionScopeUuids.length > 0) {
-		const belongsToCollectionScopeValues = belongsToCollectionScopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ");
-		filterPredicates.push(`.//properties[property[label/@uuid="${BELONGS_TO_COLLECTION_UUID}" and value/(${belongsToCollectionScopeValues})]]`);
-	}
-	if (compiledQueryPlan.predicate.length > 0) filterPredicates.push(`(${compiledQueryPlan.predicate})`);
-	const itemFilters = filterPredicates.length > 0 ? `[${filterPredicates.join(" and ")}]` : "";
+	const baseItemsExpression = `doc()/ochre${`/set[(${setScopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ")})]/items/*`}`;
+	const compiledQueryPlan = buildQueryPlan({ 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 orderedItemsClause = buildOrderedItemsClause(sort);
-	return `<ochre>{${`${queryFilterDeclarations}let $items := ${compiledQueryPlan.itemsExpression}${itemFilters}
+	return `<ochre>{${`${itemsQueryExpression == null ? `let $items := ${baseItemsExpression}` : `let $items := ${baseItemsExpression}[cts:contains(., ${itemsQueryExpression})]`}
 
   let $totalCount := count($items)
   ${orderedItemsClause}
@@ -3383,7 +2769,7 @@ function buildXQuery$1(params, options) {
 */
 async function fetchSetItems(params, itemCategories, options) {
 	try {
-		const version = options?.version ?? 2;
+		if (options?.version != null && options.version !== 2) throw new Error("Set item queries only support API version 2");
 		const { setScopeUuids, belongsToCollectionScopeUuids, queries, sort, page, pageSize } = setItemsParamsSchema.parse(params);
 		const xquery = buildXQuery$1({
 			setScopeUuids,
@@ -3392,14 +2778,12 @@ async function fetchSetItems(params, itemCategories, options) {
 			sort,
 			page,
 			pageSize
-		}, { version });
-		let response;
-		if (version === 2) response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&format=json", {
+		});
+		const response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&format=json", {
 			method: "POST",
 			body: xquery,
 			headers: { "Content-Type": "application/xquery" }
 		});
-		else response = await (options?.fetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(xquery)}&format=json&lang="*"`);
 		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`);
 		const data = await response.json();
 		if (Array.isArray(data.result) || Object.keys(data.result).length === 0) throw new Error("Invalid OCHRE API response");
@@ -3561,6 +2945,23 @@ function getPropertyVariableUuidsFromQueries(queries) {
 	}
 	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
 */
@@ -3634,29 +3035,20 @@ const responseSchema = z.object({ result: z.union([z.object({ ochre: z.object({
 * @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.version - The version of the OCHRE API to use
 * @returns An XQuery string
 */
-function buildXQuery(params, options) {
-	const version = options?.version ?? 2;
+function buildXQuery(params) {
 	const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = params;
 	let setScopeFilter = "/set/items/*";
 	if (setScopeUuids.length > 0) setScopeFilter = `/set[(${setScopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ")})]/items/*`;
 	const propertyVariableFilters = getPropertyVariableUuidsFromQueries(queries).map((uuid) => `@uuid="${uuid}"`).join(" or ");
-	const compiledQueryPlan = buildQueryPlan({
-		queries,
-		version,
-		baseItemsExpression: `${version === 2 ? "doc()" : "input()"}/ochre${setScopeFilter}`
-	});
-	const queryFilterDeclarations = compiledQueryPlan.declarations.length > 0 ? `${compiledQueryPlan.declarations.join("\n")}\n\n` : "";
-	const filterPredicates = [];
-	if (belongsToCollectionScopeUuids.length > 0) {
-		const belongsToCollectionScopeValues = belongsToCollectionScopeUuids.map((uuid) => `@uuid="${uuid}"`).join(" or ");
-		filterPredicates.push(`.//properties[property[label/@uuid="${BELONGS_TO_COLLECTION_UUID}" and value[${belongsToCollectionScopeValues}]]]`);
-	}
-	if (compiledQueryPlan.predicate.length > 0) filterPredicates.push(`(${compiledQueryPlan.predicate})`);
-	const itemFilters = filterPredicates.length > 0 ? `[${filterPredicates.join(" and ")}]` : "";
+	const baseItemsExpression = `doc()/ochre${setScopeFilter}`;
+	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 queryBlocks = [`let $matching-props := $items//property[label[${propertyVariableFilters}]]
 
 let $property-values :=
@@ -3686,7 +3078,7 @@ let $property-values :=
     return <attributeValue attributeType="periods" itemUuid="{$item/@uuid}" content="{$label}" />`);
 		returnedSequences.push("$period-values");
 	}
-	return `<ochre>{${`${queryFilterDeclarations}let $items := ${compiledQueryPlan.itemsExpression}${itemFilters}
+	return `<ochre>{${`${itemsQueryExpression == null ? `let $items := ${baseItemsExpression}` : `let $items := ${baseItemsExpression}[cts:contains(., ${itemsQueryExpression})]`}
 
 ${queryBlocks.join("\n\n")}
 
@@ -3710,7 +3102,7 @@ return (${returnedSequences.join(", ")})`}}</ochre>`;
 */
 async function fetchSetPropertyValues(params, options) {
 	try {
-		const version = options?.version ?? 2;
+		if (options?.version != null && options.version !== 2) throw new Error("Set property value queries only support API version 2");
 		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = setPropertyValuesParamsSchema.parse(params);
 		const xquery = buildXQuery({
 			setScopeUuids,
@@ -3718,14 +3110,12 @@ async function fetchSetPropertyValues(params, options) {
 			queries,
 			attributes,
 			isLimitedToLeafPropertyValues
-		}, { version });
-		let response;
-		if (version === 2) response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&format=json", {
+		});
+		const response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&format=json", {
 			method: "POST",
 			body: xquery,
 			headers: { "Content-Type": "application/xquery" }
 		});
-		else response = await (options?.fetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(xquery)}&format=json&lang="*"`);
 		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`);
 		const data = await response.json();
 		const parsedResultRaw = responseSchema.parse(data);