ochre-sdk 1.0.70 → 1.0.71

package/dist/constants.mjs

@@ -33,6 +33,8 @@ const XML_ARRAY_TAGS = [
 	"Page",
 	"TextBlock",
 	"TextLine",
+	"ocrItem",
+	"ocrMatch",
 	"footnote",
 	"language",
 	"section",

package/dist/fetchers/ocr-matches.d.mts

@@ -0,0 +1,44 @@
+import { OcrMatch } from "../types/index.mjs";
+import { FetchFunction } from "../parsers/helpers.mjs";
+//#region src/fetchers/ocr-matches.d.ts
+/**
+ * Fetches the locations of OCR text matches within OCHRE resources
+ *
+ * Matching mirrors the `ocr` Set item query target, so the same value and match
+ * mode that selected an item will locate its hits. `matchCountsByUuid` reports
+ * the untruncated count, which can exceed the returned matches when
+ * `maxMatchesPerItem` caps them.
+ *
+ * @param parameters - The parameters for the fetch
+ * @param parameters.uuids - The resource UUIDs to search, typically from a filtered Set item fetch
+ * @param parameters.value - The search value
+ * @param parameters.matchMode - Whether to match loosely (stemming and wildcards) or on whole OCR words, defaults to "includes"
+ * @param parameters.isCaseSensitive - Whether matching is case sensitive, defaults to false
+ * @param parameters.maxMatchesPerItem - The cap on returned matches per requested UUID, defaults to 50
+ * @param options - Options for the fetch
+ * @param options.fetch - The fetch function to use
+ * @returns The OCR matches, or null if the fetch/parse fails
+ */
+declare function fetchOcrMatches(parameters: {
+  uuids: Array<string>;
+  value: string;
+  matchMode?: "includes" | "exact";
+  isCaseSensitive?: boolean;
+  maxMatchesPerItem?: number;
+}, options?: {
+  fetch?: FetchFunction;
+}): Promise<{
+  matches: Array<OcrMatch>;
+  matchesByUuid: Record<string, Array<OcrMatch>>;
+  matchCountsByUuid: Record<string, number>;
+  error: null;
+  detailedError: null;
+} | {
+  matches: null;
+  matchesByUuid: null;
+  matchCountsByUuid: null;
+  error: string;
+  detailedError: string;
+}>;
+//#endregion
+export { fetchOcrMatches };

package/dist/fetchers/ocr-matches.mjs

@@ -0,0 +1,134 @@
+import { XML_PARSER_OPTIONS } from "../constants.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utilities.mjs";
+import { buildOcrTermQueryExpressions } from "../query.mjs";
+import { ocrMatchesParametersSchema } from "../schemas.mjs";
+import { restoreXMLMetadata } from "../xml/metadata.mjs";
+import { parseOcrMatches } from "../parsers/index.mjs";
+import { XMLOcrMatchesData } from "../xml/schemas.mjs";
+import * as v from "valibot";
+import { XMLParser } from "fast-xml-parser";
+//#region src/fetchers/ocr-matches.ts
+/**
+* Build an XQuery string to fetch OCR match locations from the OCHRE API
+*
+* Each OCR word is matched with `cts:contains` against the same per-term CTS
+* queries the Set item filter compiles, so hit locations always agree with what
+* the filter matched — including stemming and wildcards, which cannot be
+* reproduced outside MarkLogic.
+*
+* @param parameters - The parameters for the fetch
+* @param parameters.uuids - The resource UUIDs to search
+* @param parameters.termQueryExpressions - One CTS query expression per search term, in word order
+* @param parameters.maxMatchesPerItem - The cap on returned matches per requested UUID
+* @returns An XQuery string
+*/
+function buildXQuery(parameters) {
+	const { uuids, termQueryExpressions, maxMatchesPerItem } = parameters;
+	return `xquery version "1.0-ml";
+
+declare variable $uuids := (${Array.from(uuids, (uuid) => stringLiteral(uuid)).join(", ")});
+
+declare variable $termQueries := (
+  ${termQueryExpressions.join(",\n  ")}
+);
+
+declare variable $termCount := ${termQueryExpressions.length};
+
+<ochre>{
+  <ocrMatches>{
+    for $uuid in $uuids
+    let $matches :=
+      for $page in doc($uuid)//ocr/Page
+      let $words := $page//TextLine/string
+      let $wordCount := count($words)
+      let $resourceUuid := string($page/ancestor::resource[1]/@uuid)
+      for $word at $index in $words
+      where $index + $termCount - 1 le $wordCount
+        and (every $offset in (1 to $termCount)
+             satisfies cts:contains($words[$index + $offset - 1], $termQueries[$offset]))
+      return <ocrMatch resourceUuid="{$resourceUuid}">{
+        $page/@n, $page/@fileName, $page/@WIDTH, $page/@HEIGHT,
+        subsequence($words, $index, $termCount)
+      }</ocrMatch>
+    return <ocrItem uuid="{$uuid}" matchCount="{count($matches)}">{
+      subsequence($matches, 1, ${maxMatchesPerItem})
+    }</ocrItem>
+  }</ocrMatches>
+}</ochre>`;
+}
+/**
+* Fetches the locations of OCR text matches within OCHRE resources
+*
+* Matching mirrors the `ocr` Set item query target, so the same value and match
+* mode that selected an item will locate its hits. `matchCountsByUuid` reports
+* the untruncated count, which can exceed the returned matches when
+* `maxMatchesPerItem` caps them.
+*
+* @param parameters - The parameters for the fetch
+* @param parameters.uuids - The resource UUIDs to search, typically from a filtered Set item fetch
+* @param parameters.value - The search value
+* @param parameters.matchMode - Whether to match loosely (stemming and wildcards) or on whole OCR words, defaults to "includes"
+* @param parameters.isCaseSensitive - Whether matching is case sensitive, defaults to false
+* @param parameters.maxMatchesPerItem - The cap on returned matches per requested UUID, defaults to 50
+* @param options - Options for the fetch
+* @param options.fetch - The fetch function to use
+* @returns The OCR matches, or null if the fetch/parse fails
+*/
+async function fetchOcrMatches(parameters, options) {
+	try {
+		const { uuids, value, matchMode, isCaseSensitive, maxMatchesPerItem } = v.parse(ocrMatchesParametersSchema, parameters);
+		const termQueryExpressions = buildOcrTermQueryExpressions({
+			value,
+			matchMode,
+			isCaseSensitive
+		});
+		if (termQueryExpressions.length === 0) return {
+			matches: [],
+			matchesByUuid: {},
+			matchCountsByUuid: {},
+			error: null,
+			detailedError: null
+		};
+		const response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&xsl=none&lang=\"*\"", {
+			method: "POST",
+			body: buildXQuery({
+				uuids,
+				termQueryExpressions,
+				maxMatchesPerItem
+			}),
+			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(XMLOcrMatchesData, data);
+		if (!success) throw createSchemaValidationError("Failed to parse OCHRE OCR matches", issues);
+		restoreXMLMetadata(output, data);
+		const rawOcrItems = output.result.ochre.ocrMatches?.ocrItem ?? [];
+		const matches = parseOcrMatches(rawOcrItems);
+		const matchesByUuid = {};
+		const matchCountsByUuid = {};
+		for (const uuid of uuids) {
+			matchesByUuid[uuid] = [];
+			matchCountsByUuid[uuid] = 0;
+		}
+		for (const rawOcrItem of rawOcrItems) matchCountsByUuid[rawOcrItem.uuid] = rawOcrItem.matchCount;
+		for (const match of matches) matchesByUuid[match.uuid]?.push(match);
+		return {
+			matches,
+			matchesByUuid,
+			matchCountsByUuid,
+			error: null,
+			detailedError: null
+		};
+	} catch (error) {
+		return {
+			matches: null,
+			matchesByUuid: null,
+			matchCountsByUuid: null,
+			...getErrorOutput(error, "Unknown error")
+		};
+	}
+}
+//#endregion
+export { fetchOcrMatches };

package/dist/fetchers/set/items.mjs

@@ -1,10 +1,10 @@
 import { BELONGS_TO_COLLECTION_UUID, DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../../constants.mjs";
 import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utilities.mjs";
+import { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan } from "../../query.mjs";
 import { iso639_3Schema, setItemsParametersSchema } from "../../schemas.mjs";
 import { restoreXMLMetadata } from "../../xml/metadata.mjs";
 import { parseSetItems } from "../../parsers/index.mjs";
 import { XMLSetItemsData } from "../../xml/schemas.mjs";
-import { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan } from "../../query.mjs";
 import * as v from "valibot";
 import { XMLParser } from "fast-xml-parser";
 //#region src/fetchers/set/items.ts
@@ -138,8 +138,8 @@ function buildXQuery(parameters) {
 	const { queries, sort, setScopeUuids, belongsToCollectionScopeUuids, page, pageSize } = parameters;
 	const startPosition = (page - 1) * pageSize + 1;
 	const setScopeDeclaration = `declare variable $setScopeUuids := (${setScopeUuids.map((uuid) => stringLiteral(uuid)).join(", ")});`;
-	const baseItemsExpression = "doc()/ochre/set[@uuid = $setScopeUuids]/items/*";
 	const compiledQueryPlan = buildQueryPlan({ queries });
+	const baseItemsExpression = `doc()/ochre/set[@uuid = $setScopeUuids]/items/*${compiledQueryPlan.itemPredicates}`;
 	const itemsQueryExpressions = [];
 	const belongsToCollectionQueryExpression = buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids, BELONGS_TO_COLLECTION_UUID);
 	if (compiledQueryPlan.queryExpression != null) itemsQueryExpressions.push(compiledQueryPlan.queryExpression);
@@ -148,8 +148,10 @@ function buildXQuery(parameters) {
 	const orderedItemsClause = buildOrderedItemsClause(sort);
 	const xqueryDeclarations = ["xquery version \"1.0-ml\";", setScopeDeclaration];
 	if (compiledQueryPlan.prolog !== "") xqueryDeclarations.push(compiledQueryPlan.prolog);
-	const itemsClause = itemsQueryExpression == null ? `let $items := ${baseItemsExpression}` : `let $query := ${itemsQueryExpression}
-  let $items := cts:search(${baseItemsExpression}, $query)`;
+	const letClauses = Array.from(compiledQueryPlan.ocrBindings, (binding) => `let ${binding.name} := ${binding.expression}`);
+	if (itemsQueryExpression == null) letClauses.push(`let $items := ${baseItemsExpression}`);
+	else letClauses.push(`let $query := ${itemsQueryExpression}`, `let $items := cts:search(${baseItemsExpression}, $query)`);
+	const itemsClause = letClauses.join("\n  ");
 	return `${xqueryDeclarations.join("\n\n")}
 
 <ochre>{

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

@@ -1,9 +1,9 @@
 import { BELONGS_TO_COLLECTION_UUID, DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../../constants.mjs";
 import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utilities.mjs";
 import { MultilingualString } from "../../parsers/multilingual.mjs";
+import { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan } from "../../query.mjs";
 import { setPropertyValuesParametersSchema } 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
@@ -190,8 +190,8 @@ const responseSchema = v.object({ result: v.object({ ochre: v.object({
 function buildXQuery(parameters) {
 	const { setScopeUuids, belongsToCollectionScopeUuids, queries, propertyFacetSelectors, attributes, isLimitedToLeafPropertyValues } = parameters;
 	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 baseItemsExpression = `doc()/ochre/set[@uuid = $setScopeUuids]/items/*${compiledQueryPlan.itemPredicates}`;
 	const itemsQueryExpressions = [];
 	const belongsToCollectionQueryExpression = buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids, BELONGS_TO_COLLECTION_UUID);
 	if (compiledQueryPlan.queryExpression != null) itemsQueryExpressions.push(compiledQueryPlan.queryExpression);
@@ -404,8 +404,10 @@ let $period-values :=
   )`);
 		returnedSequences.push("$period-values");
 	}
-	const itemsClause = itemsQueryExpression == null ? `let $items := ${baseItemsExpression}` : `let $query := ${itemsQueryExpression}
-  let $items := cts:search(${baseItemsExpression}, $query)`;
+	const letClauses = Array.from(compiledQueryPlan.ocrBindings, (binding) => `let ${binding.name} := ${binding.expression}`);
+	if (itemsQueryExpression == null) letClauses.push(`let $items := ${baseItemsExpression}`);
+	else letClauses.push(`let $query := ${itemsQueryExpression}`, `let $items := cts:search(${baseItemsExpression}, $query)`);
+	const itemsClause = letClauses.join("\n  ");
 	return `${xqueryDeclarations.join("\n\n")}
 
 <ochre>{

package/dist/helpers.d.mts

@@ -7,6 +7,10 @@ type FlattenedItem<U, T extends LanguageCodes> = Omit<U, "properties"> & {
  * The default page size to use for fetching paginated items
  */
 declare const DEFAULT_PAGE_SIZE = 48;
+/**
+ * The default cap on OCR matches returned per requested item
+ */
+declare const DEFAULT_MAX_OCR_MATCHES_PER_ITEM = 50;
 /**
  * Flatten the properties of an item
  * @param item - The item whose properties to flatten
@@ -14,4 +18,4 @@ declare const DEFAULT_PAGE_SIZE = 48;
  */
 declare function flattenItemProperties<U extends ItemCategory = ItemCategory, V extends ContainedItemCategory<U> = ContainedItemCategory<U>, T extends LanguageCodes = LanguageCodes, W extends ItemPayloadKind = "topLevel">(item: Item<U, V, T, W>): FlattenedItem<Item<U, V, T, W>, T>;
 //#endregion
-export { DEFAULT_PAGE_SIZE, flattenItemProperties };
+export { DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, flattenItemProperties };

package/dist/helpers.mjs

@@ -5,6 +5,10 @@ import { flattenProperties } from "./utilities.mjs";
 */
 const DEFAULT_PAGE_SIZE = 48;
 /**
+* The default cap on OCR matches returned per requested item
+*/
+const DEFAULT_MAX_OCR_MATCHES_PER_ITEM = 50;
+/**
 * Flatten the properties of an item
 * @param item - The item whose properties to flatten
 * @returns The item with the properties flattened
@@ -30,4 +34,4 @@ function flattenItemProperties(item) {
 	};
 }
 //#endregion
-export { DEFAULT_PAGE_SIZE, flattenItemProperties };
+export { DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, flattenItemProperties };

package/dist/index.d.mts

@@ -1,14 +1,15 @@
 import { MultilingualOptions, MultilingualString, MultilingualStringEntries, MultilingualStringEntry, MultilingualStringInput, MultilingualStringJSON, MultilingualStringObject, MultilingualStringText } from "./parsers/multilingual.mjs";
 import { AccordionWebBlock, ContextTree, ContextTreeFilterLevel, ContextTreeLevel, ContextTreeLevelItem, ProtectedWebsite, Scope, Style, StylesheetCategory, StylesheetItem, WebAccordionItem, WebBlock, WebBlockByLayout, WebBlockItem, WebBlockLayout, WebElement, WebElementComponent, WebElementComponentName, WebElementComponentOf, WebElementOf, WebImage, WebSidebar, WebTitle, Webpage, Website, WebsiteMetadata, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteSegment, WebsiteType } from "./types/website.mjs";
-import { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, Metadata, Note, Observation, OcrPage, OcrPoint, OcrTextBlock, OcrTextLine, OcrWord, Period, PeriodItemLink, Person, PersonItemLink, Prettify, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink } from "./types/index.mjs";
+import { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, Metadata, Note, Observation, OcrMatch, OcrPage, OcrPoint, OcrTextBlock, OcrTextLine, OcrWord, Period, PeriodItemLink, Person, PersonItemLink, Prettify, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink } from "./types/index.mjs";
 import { fetchGallery } from "./fetchers/gallery.mjs";
 import { fetchItemChildren } from "./fetchers/item-children.mjs";
 import { fetchItemLinks } from "./fetchers/item-links.mjs";
 import { defineLanguages, fetchItem, withLanguages } from "./fetchers/item.mjs";
+import { fetchOcrMatches } from "./fetchers/ocr-matches.mjs";
 import { fetchSetItems } from "./fetchers/set/items.mjs";
 import { fetchSetPropertyValues } from "./fetchers/set/property-values.mjs";
 import { fetchWebsiteMetadata } from "./fetchers/website-metadata.mjs";
 import { fetchWebsite } from "./fetchers/website.mjs";
 import { PropertyOptions, filterProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels } from "./getters.mjs";
-import { DEFAULT_PAGE_SIZE, flattenItemProperties } from "./helpers.mjs";
-export { type AccordionWebBlock, type AnyBibliography, type AnyConcept, type AnyItem, type AnyPeriod, type AnyPerson, type AnyPropertyValue, type AnyPropertyVariable, type AnyResource, type AnySet, type AnySpatialUnit, type AnyText, type AnyTree, type BaseItem, type BaseItemLink, type BelongsTo, type Bibliography, type BibliographyEntryInfo, type BibliographyItemLink, type BibliographySourceDocument, type Concept, type ConceptItemLink, type ContainedItemCategory, type ContainedItemCategoryFromOption, type ContainedItemCategoryOption, type Context, type ContextItem, type ContextItemCategory, type ContextNode, type ContextTree, type ContextTreeFilterLevel, type ContextTreeLevel, type ContextTreeLevelItem, type Coordinates, type CoordinatesSource, DEFAULT_PAGE_SIZE, type DictionaryUnitItemLink, type EmbeddedBibliography, type EmbeddedConcept, type EmbeddedItem, type EmbeddedPeriod, type EmbeddedPerson, type EmbeddedPropertyValue, type EmbeddedPropertyVariable, type EmbeddedResource, type EmbeddedSet, type EmbeddedSpatialUnit, type EmbeddedText, type EmbeddedTree, type Event, type Gallery, type Heading, type HeadingItemCategory, type Identification, type Image, type ImageMap, type ImageMapArea, type Interpretation, type Item, type ItemCategory, type ItemCategoryFromOption, type ItemCategoryOption, type ItemCategoryWithEmbeddedItems, type ItemContainerCategory, type ItemLink, type ItemLinkCategory, type ItemLinks, type ItemPayloadKind, type ItemProperty, type ItemWithoutEmbeddedItems, type LanguageCodes, type License, type Metadata, type MultilingualOptions, MultilingualString, type MultilingualStringEntries, type MultilingualStringEntry, type MultilingualStringInput, type MultilingualStringJSON, type MultilingualStringObject, type MultilingualStringText, type Note, type Observation, type OcrPage, type OcrPoint, type OcrTextBlock, type OcrTextLine, type OcrWord, type Period, type PeriodItemLink, type Person, type PersonItemLink, type Prettify, type Property, type PropertyLike, PropertyOptions, type PropertyRelation, type PropertyValue, type PropertyValueContent, type PropertyValueDataType, type PropertyValueItemLink, type PropertyValueQueryItem, type PropertyVariable, type PropertyVariableItemLink, type ProtectedWebsite, type Query, type QueryGroup, type QueryLeaf, type QueryablePropertyValueDataType, type RecursiveItemCategory, type Resource, type ResourceItemLink, type Scope, type Section, type Set, type SetAttributeValueQueryItem, type SetBibliography, type SetConcept, type SetItem, type SetItemCategory, type SetItemLink, type SetItemProperty, type SetItemSimplifiedProperty, type SetItemsSort, type SetItemsSortDirection, type SetPeriod, type SetResource, type SetSpatialUnit, type SetTree, type SimplifiedProperty, type SpatialUnit, type SpatialUnitItemLink, type Style, type StylesheetCategory, type StylesheetItem, type Text, type TextItemLink, type TopLevelItem, type Tree, type TreeItemCategory, type TreeItemLink, type WebAccordionItem, type WebBlock, type WebBlockByLayout, type WebBlockItem, type WebBlockLayout, type WebElement, type WebElementComponent, type WebElementComponentName, type WebElementComponentOf, type WebElementOf, type WebImage, type WebSidebar, type WebTitle, type Webpage, type Website, type WebsiteMetadata, type WebsitePropertyQuery, type WebsitePropertyQueryNode, type WebsiteSegment, type WebsiteType, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchSetItems, fetchSetPropertyValues, fetchWebsite, fetchWebsiteMetadata, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels, withLanguages };
+import { DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, flattenItemProperties } from "./helpers.mjs";
+export { type AccordionWebBlock, type AnyBibliography, type AnyConcept, type AnyItem, type AnyPeriod, type AnyPerson, type AnyPropertyValue, type AnyPropertyVariable, type AnyResource, type AnySet, type AnySpatialUnit, type AnyText, type AnyTree, type BaseItem, type BaseItemLink, type BelongsTo, type Bibliography, type BibliographyEntryInfo, type BibliographyItemLink, type BibliographySourceDocument, type Concept, type ConceptItemLink, type ContainedItemCategory, type ContainedItemCategoryFromOption, type ContainedItemCategoryOption, type Context, type ContextItem, type ContextItemCategory, type ContextNode, type ContextTree, type ContextTreeFilterLevel, type ContextTreeLevel, type ContextTreeLevelItem, type Coordinates, type CoordinatesSource, DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, type DictionaryUnitItemLink, type EmbeddedBibliography, type EmbeddedConcept, type EmbeddedItem, type EmbeddedPeriod, type EmbeddedPerson, type EmbeddedPropertyValue, type EmbeddedPropertyVariable, type EmbeddedResource, type EmbeddedSet, type EmbeddedSpatialUnit, type EmbeddedText, type EmbeddedTree, type Event, type Gallery, type Heading, type HeadingItemCategory, type Identification, type Image, type ImageMap, type ImageMapArea, type Interpretation, type Item, type ItemCategory, type ItemCategoryFromOption, type ItemCategoryOption, type ItemCategoryWithEmbeddedItems, type ItemContainerCategory, type ItemLink, type ItemLinkCategory, type ItemLinks, type ItemPayloadKind, type ItemProperty, type ItemWithoutEmbeddedItems, type LanguageCodes, type License, type Metadata, type MultilingualOptions, MultilingualString, type MultilingualStringEntries, type MultilingualStringEntry, type MultilingualStringInput, type MultilingualStringJSON, type MultilingualStringObject, type MultilingualStringText, type Note, type Observation, type OcrMatch, type OcrPage, type OcrPoint, type OcrTextBlock, type OcrTextLine, type OcrWord, type Period, type PeriodItemLink, type Person, type PersonItemLink, type Prettify, type Property, type PropertyLike, PropertyOptions, type PropertyRelation, type PropertyValue, type PropertyValueContent, type PropertyValueDataType, type PropertyValueItemLink, type PropertyValueQueryItem, type PropertyVariable, type PropertyVariableItemLink, type ProtectedWebsite, type Query, type QueryGroup, type QueryLeaf, type QueryablePropertyValueDataType, type RecursiveItemCategory, type Resource, type ResourceItemLink, type Scope, type Section, type Set, type SetAttributeValueQueryItem, type SetBibliography, type SetConcept, type SetItem, type SetItemCategory, type SetItemLink, type SetItemProperty, type SetItemSimplifiedProperty, type SetItemsSort, type SetItemsSortDirection, type SetPeriod, type SetResource, type SetSpatialUnit, type SetTree, type SimplifiedProperty, type SpatialUnit, type SpatialUnitItemLink, type Style, type StylesheetCategory, type StylesheetItem, type Text, type TextItemLink, type TopLevelItem, type Tree, type TreeItemCategory, type TreeItemLink, type WebAccordionItem, type WebBlock, type WebBlockByLayout, type WebBlockItem, type WebBlockLayout, type WebElement, type WebElementComponent, type WebElementComponentName, type WebElementComponentOf, type WebElementOf, type WebImage, type WebSidebar, type WebTitle, type Webpage, type Website, type WebsiteMetadata, type WebsitePropertyQuery, type WebsitePropertyQueryNode, type WebsiteSegment, type WebsiteType, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchOcrMatches, fetchSetItems, fetchSetPropertyValues, fetchWebsite, fetchWebsiteMetadata, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels, withLanguages };

package/dist/index.mjs

@@ -1,12 +1,13 @@
 import { filterProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels } from "./getters.mjs";
-import { DEFAULT_PAGE_SIZE, flattenItemProperties } from "./helpers.mjs";
+import { DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, flattenItemProperties } from "./helpers.mjs";
 import { MultilingualString } from "./parsers/multilingual.mjs";
 import { fetchGallery } from "./fetchers/gallery.mjs";
 import { fetchItemChildren } from "./fetchers/item-children.mjs";
 import { fetchItemLinks } from "./fetchers/item-links.mjs";
 import { defineLanguages, fetchItem, withLanguages } from "./fetchers/item.mjs";
+import { fetchOcrMatches } from "./fetchers/ocr-matches.mjs";
 import { fetchSetItems } from "./fetchers/set/items.mjs";
 import { fetchSetPropertyValues } from "./fetchers/set/property-values.mjs";
 import { fetchWebsiteMetadata } from "./fetchers/website-metadata.mjs";
 import { fetchWebsite } from "./fetchers/website.mjs";
-export { DEFAULT_PAGE_SIZE, MultilingualString, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchSetItems, fetchSetPropertyValues, fetchWebsite, fetchWebsiteMetadata, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels, withLanguages };
+export { DEFAULT_MAX_OCR_MATCHES_PER_ITEM, DEFAULT_PAGE_SIZE, MultilingualString, defineLanguages, fetchGallery, fetchItem, fetchItemChildren, fetchItemLinks, fetchOcrMatches, fetchSetItems, fetchSetPropertyValues, fetchWebsite, fetchWebsiteMetadata, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByVariableLabel, getPropertyByVariableLabelAndValue, getPropertyByVariableLabelAndValueContent, getPropertyByVariableLabelAndValueContents, getPropertyByVariableLabelAndValues, getPropertyByVariableUuid, getPropertyValueByVariableLabel, getPropertyValueByVariableUuid, getPropertyValueContentByVariableLabel, getPropertyValueContentByVariableUuid, getPropertyValueContentsByVariableUuid, getPropertyValuesByVariableLabel, getPropertyValuesByVariableUuid, getUniqueProperties, getUniquePropertyVariableLabels, withLanguages };

package/dist/parsers/index.d.mts

@@ -1,12 +1,19 @@
 import { Webpage } from "../types/website.mjs";
-import { Bibliography, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Gallery, Identification, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemContainerCategory, ItemLinks, Metadata, Note, Person, Property, Resource, SetItem, SetItemCategory, SimplifiedProperty } from "../types/index.mjs";
-import { XMLBibliography, XMLData, XMLDataItem, XMLGalleryData, XMLIdentification, XMLItemLinks, XMLLink, XMLMetadata, XMLNote, XMLPerson, XMLProperty, XMLResource, XMLSetItems, XMLSimplifiedProperty } from "../xml/types.mjs";
+import { Bibliography, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Gallery, Identification, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemContainerCategory, ItemLinks, Metadata, Note, OcrMatch, Person, Property, Resource, SetItem, SetItemCategory, SimplifiedProperty } from "../types/index.mjs";
+import { XMLBibliography, XMLData, XMLDataItem, XMLGalleryData, XMLIdentification, XMLItemLinks, XMLLink, XMLMetadata, XMLNote, XMLOcrMatchItem, XMLPerson, XMLProperty, XMLResource, XMLSetItems, XMLSimplifiedProperty } from "../xml/types.mjs";
 import { ParserOptions, getParserOptions, parseStringLike } from "./helpers.mjs";
 //#region src/parsers/index.d.ts
 type RawOchre = XMLData["result"]["ochre"];
 type ResourceViewParser<T extends ReadonlyArray<string>> = (view: XMLResource["view"], context: Pick<Resource<T, "topLevel">, "belongsTo" | "metadata">) => Webpage<T> | null;
 type SetItemCategoryFromCategories<T extends ReadonlyArray<SetItemCategory> | undefined> = T extends ReadonlyArray<infer U> ? Extract<U, SetItemCategory> : SetItemCategory;
 declare function parseIdentification<T extends ReadonlyArray<string>>(rawIdentification: XMLIdentification, options: ParserOptions<T>): Identification<T>;
+/**
+ * Parse OCR matches returned by the OCHRE API
+ * @param rawOcrItems - The raw OCR match items
+ * @returns The parsed OCR matches, in request order
+ * @internal
+ */
+declare function parseOcrMatches(rawOcrItems: Array<XMLOcrMatchItem>): Array<OcrMatch>;
 declare function parseNotes<T extends ReadonlyArray<string>>(rawNotes: {
   note: Array<XMLNote>;
 } | undefined, options: ParserOptions<T>): Array<Note<T>>;
@@ -61,4 +68,4 @@ declare function parseItem(rawData: XMLData, options: {
   parseResourceView?: ResourceViewParser<ReadonlyArray<string>>;
 }): Item<ItemCategory, SetItemCategory, ReadonlyArray<string>>;
 //#endregion
-export { type ParserOptions, RawOchre, getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };
+export { type ParserOptions, RawOchre, getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parseOcrMatches, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };

package/dist/parsers/index.mjs

@@ -443,18 +443,24 @@ function parseOcrVertices(rawVertices) {
 	}
 	return vertices;
 }
+function parseOcrWords(rawWords) {
+	return Array.from(rawWords ?? [], (rawWord) => ({
+		content: rawWord.CONTENT,
+		x: rawWord.HPOS,
+		y: rawWord.VPOS,
+		width: rawWord.WIDTH,
+		height: rawWord.HEIGHT,
+		vertices: parseOcrVertices(rawWord.VERTICES)
+	}));
+}
+function joinOcrWordContents(words) {
+	return Array.from(words, (word) => word.content).join(" ");
+}
 function parseOcrPage(rawPage) {
 	const blocks = Array.from(rawPage.TextBlock ?? [], (rawBlock) => ({ lines: Array.from(rawBlock.TextLine ?? [], (rawLine) => {
-		const words = Array.from(rawLine.string ?? [], (rawWord) => ({
-			content: rawWord.CONTENT,
-			x: rawWord.HPOS,
-			y: rawWord.VPOS,
-			width: rawWord.WIDTH,
-			height: rawWord.HEIGHT,
-			vertices: parseOcrVertices(rawWord.VERTICES)
-		}));
+		const words = parseOcrWords(rawLine.string);
 		return {
-			content: Array.from(words, (word) => word.content).join(" "),
+			content: joinOcrWordContents(words),
 			words
 		};
 	}) }));
@@ -469,6 +475,34 @@ function parseOcrPage(rawPage) {
 function parseOcr(rawOcr) {
 	return Array.from(rawOcr?.Page ?? [], (rawPage) => parseOcrPage(rawPage));
 }
+/**
+* Parse OCR matches returned by the OCHRE API
+* @param rawOcrItems - The raw OCR match items
+* @returns The parsed OCR matches, in request order
+* @internal
+*/
+function parseOcrMatches(rawOcrItems) {
+	const matches = [];
+	for (const rawOcrItem of rawOcrItems) {
+		const rawMatches = rawOcrItem.ocrMatch ?? [];
+		for (const rawMatch of rawMatches) {
+			const words = parseOcrWords(rawMatch.string);
+			matches.push({
+				uuid: rawOcrItem.uuid,
+				resourceUuid: rawMatch.resourceUuid ?? null,
+				page: {
+					number: rawMatch.n ?? null,
+					fileName: rawMatch.fileName ?? null,
+					width: rawMatch.WIDTH ?? null,
+					height: rawMatch.HEIGHT ?? null
+				},
+				content: joinOcrWordContents(words),
+				words
+			});
+		}
+	}
+	return matches;
+}
 function parseNote(rawNote, options) {
 	const authors = Array.from(rawNote.authors?.author ?? [], (author) => parsePerson(author, options));
 	const content = rawNote.content == null ? multilingualFromText(parseXMLString(rawNote), options) : parseRequiredContentLike(rawNote, options);
@@ -1365,4 +1399,4 @@ function parseItem(rawData, options) {
 	};
 }
 //#endregion
-export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };
+export { getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parseOcrMatches, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };

package/dist/query.d.mts

@@ -1,12 +1,40 @@
 import { Query } from "./types/index.mjs";
 //#region src/query.d.ts
+/**
+ * Error message for OCR queries nested inside an OR group
+ * @internal
+ */
+declare const OCR_DISJUNCTION_ERROR_MESSAGE = "OCR queries cannot be nested inside an OR group because they are resolved by a document join instead of a CTS query";
+type OcrUuidBinding = {
+  name: string;
+  expression: string;
+};
 declare function buildAndCtsQueryExpression(queryExpressions: Array<string>): string | null;
+/**
+ * Compile one CTS query expression per OCR search term, in word order
+ *
+ * Highlighting matches each OCR word against these same per-term expressions,
+ * so hit locations always agree with what the filter matched.
+ * @internal
+ */
+declare function buildOcrTermQueryExpressions(parameters: {
+  value: string;
+  matchMode: "includes" | "exact";
+  isCaseSensitive: boolean;
+}): Array<string>;
+/**
+ * Whether a query tree nests an OCR leaf inside an OR group
+ * @internal
+ */
+declare function hasOcrQueryInDisjunction(query: Query, isInDisjunction?: boolean): boolean;
 declare function buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids: Array<string>, belongsToCollectionPropertyVariableUuid: string): string | null;
 declare function buildQueryPlan(parameters: {
   queries: Query | null;
 }): {
   prolog: string;
   queryExpression: string | null;
+  ocrBindings: Array<OcrUuidBinding>;
+  itemPredicates: string;
 };
 //#endregion
-export { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan };
+export { OCR_DISJUNCTION_ERROR_MESSAGE, buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildOcrTermQueryExpressions, buildQueryPlan, hasOcrQueryInDisjunction };

package/dist/query.mjs

@@ -12,6 +12,11 @@ const CTS_INCLUDES_STOP_WORDS = /* @__PURE__ */ new Set([
 const CTS_INCLUDES_TOKEN_WORD_REGEX = /^\p{L}+$/u;
 const CTS_INCLUDES_TOKEN_REGEX = /[\p{L}\p{N}*?]+/gu;
 const CTS_EXACT_TEXT_TOKEN_REGEX = /[\p{L}\p{N}]+/gu;
+/**
+* Error message for OCR queries nested inside an OR group
+* @internal
+*/
+const OCR_DISJUNCTION_ERROR_MESSAGE = "OCR queries cannot be nested inside an OR group because they are resolved by a document join instead of a CTS query";
 const CONTENT_TARGET_CONTENT_ELEMENT_PATHS = {
 	title: [
 		"identification",
@@ -199,6 +204,9 @@ function buildNestedElementQuery(elementNames, queryExpression) {
 function buildNotCtsQueryExpression(queryExpression) {
 	return `cts:not-query(${queryExpression})`;
 }
+function buildCtsNearQueryExpression(queryExpressions) {
+	return `cts:near-query((${queryExpressions.join(", ")}), ${queryExpressions.length - 1}, ("ordered"))`;
+}
 function buildAndCtsQueryExpressionInternal(queryExpressions) {
 	if (queryExpressions.length === 0) return "cts:true-query()";
 	if (queryExpressions.length === 1) return queryExpressions[0] ?? "cts:true-query()";
@@ -472,6 +480,63 @@ function buildItemStringQueryExpression(parameters) {
 		language
 	})]);
 }
+function tokenizeOcrSearchValue(parameters) {
+	const { value, matchMode, isCaseSensitive } = parameters;
+	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).match(matchMode === "exact" ? CTS_EXACT_TEXT_TOKEN_REGEX : CTS_INCLUDES_TOKEN_REGEX) ?? [];
+	const terms = [];
+	for (const term of rawTerms) if (getWildcardStrippedValue(term) !== "") terms.push(term);
+	return terms;
+}
+/**
+* Compile one CTS query expression per OCR search term, in word order
+*
+* Highlighting matches each OCR word against these same per-term expressions,
+* so hit locations always agree with what the filter matched.
+* @internal
+*/
+function buildOcrTermQueryExpressions(parameters) {
+	const { value, matchMode, isCaseSensitive } = parameters;
+	const terms = tokenizeOcrSearchValue({
+		value,
+		matchMode,
+		isCaseSensitive
+	});
+	const isWholeWordEquality = matchMode === "exact" && terms.length === 1;
+	return Array.from(terms, (term) => isWholeWordEquality ? buildCtsElementValueQueryExpression({
+		elementName: "string",
+		value: term,
+		isCaseSensitive
+	}) : buildCtsWordQueryExpression({
+		value: term,
+		matchMode,
+		isCaseSensitive,
+		queryFamily: "text"
+	}));
+}
+function buildOcrQueryExpression(query) {
+	const termQueryExpressions = buildOcrTermQueryExpressions(query);
+	if (termQueryExpressions.length === 0) return "cts:false-query()";
+	return buildNestedElementQuery(["ocr"], termQueryExpressions.length > 1 ? buildCtsNearQueryExpression(termQueryExpressions) : termQueryExpressions[0] ?? "cts:false-query()");
+}
+function registerOcrItemPredicate(context, query) {
+	const bindingKey = [
+		query.value,
+		query.matchMode,
+		query.isCaseSensitive ? "case-sensitive" : "case-insensitive"
+	].join("|");
+	let variableName = context.ocrVariableNamesByKey.get(bindingKey);
+	if (variableName == null) {
+		variableName = `$ocrUuids${context.nextOcrSerial}`;
+		context.nextOcrSerial += 1;
+		context.ocrVariableNamesByKey.set(bindingKey, variableName);
+		context.ocrBindings.push({
+			name: variableName,
+			expression: `for $ocrDocument in cts:search(doc(), ${buildOcrQueryExpression(query)})\n    return document-uri($ocrDocument)`
+		});
+	}
+	const itemPredicate = query.isNegated === true ? `[not(@uuid = ${variableName})]` : `[@uuid = ${variableName}]`;
+	if (!context.itemPredicates.includes(itemPredicate)) context.itemPredicates.push(itemPredicate);
+}
 function getLeafSearchValue(query) {
 	switch (query.target) {
 		case "string":
@@ -552,7 +617,11 @@ function createQueryCompilerContext() {
 	return {
 		nextHelperSerial: 1,
 		helperNamesByKey: /* @__PURE__ */ new Map(),
-		helperDeclarations: []
+		helperDeclarations: [],
+		nextOcrSerial: 1,
+		ocrVariableNamesByKey: /* @__PURE__ */ new Map(),
+		ocrBindings: [],
+		itemPredicates: []
 	};
 }
 function registerConstantHelper(parameters) {
@@ -749,11 +818,24 @@ function getQueryGroupChildren(query) {
 function getQueryGroupOperator(query) {
 	return "and" in query ? "and" : "or";
 }
+function isDisjunctiveQueryGroup(query) {
+	return "or" in query && query.or.length > 1;
+}
+/**
+* Whether a query tree nests an OCR leaf inside an OR group
+* @internal
+*/
+function hasOcrQueryInDisjunction(query, isInDisjunction = false) {
+	if (isQueryLeaf(query)) return query.target === "ocr" && isInDisjunction;
+	const isChildInDisjunction = isInDisjunction || isDisjunctiveQueryGroup(query);
+	for (const childQuery of getQueryGroupChildren(query)) if (hasOcrQueryInDisjunction(childQuery, isChildInDisjunction)) return true;
+	return false;
+}
 function getCompatibleIncludesGroupLeaves(query) {
 	if (!("or" in query) || query.or.length <= 1) return null;
 	const leafQueries = [];
 	for (const childQuery of query.or) {
-		if (!isQueryLeaf(childQuery)) return null;
+		if (!isQueryLeaf(childQuery) || childQuery.target === "ocr") return null;
 		leafQueries.push(childQuery);
 	}
 	const firstQuery = leafQueries[0];
@@ -814,14 +896,20 @@ function buildIncludesGroupQueryExpression(context, queries) {
 		bodyExpression: buildOrCtsQueryExpressionInternal(exactMemberHelpers.map((helper) => helper.callExpression))
 	}).callExpression, tokenizedQueryExpression]);
 }
-function buildQueryNode(context, query) {
+function buildQueryNode(context, query, isInDisjunction) {
 	if (isQueryLeaf(query)) {
+		if (query.target === "ocr") {
+			if (isInDisjunction) throw new Error(OCR_DISJUNCTION_ERROR_MESSAGE, { cause: query });
+			registerOcrItemPredicate(context, query);
+			return "cts:true-query()";
+		}
 		const queryExpression = buildLeafQueryExpression(context, query);
 		return query.isNegated === true ? buildNotCtsQueryExpression(queryExpression) : queryExpression;
 	}
 	const optimizedIncludesGroupQueries = getCompatibleIncludesGroupLeaves(query);
 	if (optimizedIncludesGroupQueries != null) return buildIncludesGroupQueryExpression(context, optimizedIncludesGroupQueries);
-	const childQueryExpressions = Array.from(getQueryGroupChildren(query), (childQuery) => buildQueryNode(context, childQuery));
+	const isChildInDisjunction = isInDisjunction || isDisjunctiveQueryGroup(query);
+	const childQueryExpressions = Array.from(getQueryGroupChildren(query), (childQuery) => buildQueryNode(context, childQuery, isChildInDisjunction));
 	return (getQueryGroupOperator(query) === "and" ? buildAndCtsQueryExpressionInternal : buildOrCtsQueryExpressionInternal)(childQueryExpressions);
 }
 function buildBelongsToCollectionQueryExpression(belongsToCollectionScopeUuids, belongsToCollectionPropertyVariableUuid) {
@@ -839,14 +927,18 @@ function buildQueryPlan(parameters) {
 	const { queries } = parameters;
 	if (queries == null) return {
 		prolog: "",
-		queryExpression: null
+		queryExpression: null,
+		ocrBindings: [],
+		itemPredicates: ""
 	};
 	const context = createQueryCompilerContext();
-	const queryExpression = buildQueryNode(context, queries);
+	const queryExpression = buildQueryNode(context, queries, false);
 	return {
 		prolog: context.helperDeclarations.join("\n\n"),
-		queryExpression
+		queryExpression,
+		ocrBindings: context.ocrBindings,
+		itemPredicates: context.itemPredicates.join("")
 	};
 }
 //#endregion
-export { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan };
+export { OCR_DISJUNCTION_ERROR_MESSAGE, buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildOcrTermQueryExpressions, buildQueryPlan, hasOcrQueryInDisjunction };

package/dist/schemas.d.mts

@@ -38,7 +38,7 @@ declare const renderOptionsSchema: v.SchemaWithPipe<readonly [v.StringSchema<und
 declare const setPropertyValuesParametersSchema: v.ObjectSchema<{
   readonly setScopeUuids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, v.MinLengthAction<string[], 1, "At least one set scope UUID is required">]>;
   readonly belongsToCollectionScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
-  readonly queries: v.OptionalSchema<v.NullableSchema<v.GenericSchema<unknown, Query>, undefined>, null>;
+  readonly queries: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.GenericSchema<unknown, Query>, v.CheckAction<Query, "OCR queries cannot be nested inside an OR group because they are resolved by a document join instead of a CTS query">]>, undefined>, null>;
   readonly attributes: v.OptionalSchema<v.ObjectSchema<{
     readonly bibliographies: v.GenericSchema<unknown, boolean>;
     readonly periods: v.GenericSchema<unknown, boolean>;
@@ -48,6 +48,17 @@ declare const setPropertyValuesParametersSchema: v.ObjectSchema<{
   }>;
   readonly isLimitedToLeafPropertyValues: v.GenericSchema<unknown, boolean>;
 }, undefined>;
+/**
+ * Schema for validating OCR matches parameters
+ * @internal
+ */
+declare const ocrMatchesParametersSchema: v.ObjectSchema<{
+  readonly uuids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, v.MinLengthAction<string[], 1, "At least one UUID is required">]>;
+  readonly value: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "A search value is required">]>;
+  readonly matchMode: v.OptionalSchema<v.PicklistSchema<["includes", "exact"], undefined>, "includes">;
+  readonly isCaseSensitive: v.GenericSchema<unknown, boolean>;
+  readonly maxMatchesPerItem: v.OptionalSchema<v.GenericSchema<unknown, number>, 50>;
+}, undefined>;
 /**
  * Schema for validating Set items parameters
  * @internal
@@ -55,7 +66,7 @@ declare const setPropertyValuesParametersSchema: v.ObjectSchema<{
 declare const setItemsParametersSchema: v.ObjectSchema<{
   readonly setScopeUuids: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, v.MinLengthAction<string[], 1, "At least one set scope UUID is required">]>;
   readonly belongsToCollectionScopeUuids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid pseudo-UUID">]>, undefined>, readonly []>;
-  readonly queries: v.OptionalSchema<v.NullableSchema<v.GenericSchema<unknown, Query>, undefined>, null>;
+  readonly queries: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.GenericSchema<unknown, Query>, v.CheckAction<Query, "OCR queries cannot be nested inside an OR group because they are resolved by a document join instead of a CTS query">]>, undefined>, null>;
   readonly sort: v.OptionalSchema<v.VariantSchema<"target", [v.StrictObjectSchema<{
     readonly target: v.LiteralSchema<"none", undefined>;
   }, undefined>, v.StrictObjectSchema<{
@@ -75,4 +86,4 @@ declare const setItemsParametersSchema: v.ObjectSchema<{
   readonly pageSize: v.OptionalSchema<v.GenericSchema<unknown, number>, 48>;
 }, undefined>;
 //#endregion
-export { componentSchema, gallerySchema, iso639_3Schema, renderOptionsSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, uuidSchema };
+export { componentSchema, gallerySchema, iso639_3Schema, ocrMatchesParametersSchema, renderOptionsSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, uuidSchema };

package/dist/schemas.mjs

@@ -1,5 +1,6 @@
 import { isPseudoUuid } from "./utilities.mjs";
 import "./helpers.mjs";
+import { OCR_DISJUNCTION_ERROR_MESSAGE, hasOcrQueryInDisjunction } from "./query.mjs";
 import * as v from "valibot";
 //#region src/schemas.ts
 const positiveNumber = (message) => v.pipe(v.number(), v.minValue(1, message));
@@ -141,6 +142,13 @@ const setQueryLeafSchema = v.union([
 		value: v.string(),
 		...standardQueryFields
 	}),
+	v.strictObject({
+		target: v.literal("ocr"),
+		value: v.string(),
+		matchMode: standardQueryFields.matchMode,
+		isCaseSensitive: standardQueryFields.isCaseSensitive,
+		isNegated: standardQueryFields.isNegated
+	}),
 	v.strictObject({
 		target: v.picklist([
 			"title",
@@ -167,7 +175,7 @@ const setQuerySchema = v.lazy(() => v.union([
 * Schema for validating Set queries
 * @internal
 */
-const setQueriesSchema = v.optional(v.nullable(setQuerySchema), null);
+const setQueriesSchema = v.optional(v.nullable(v.pipe(setQuerySchema, v.check((query) => !hasOcrQueryInDisjunction(query), OCR_DISJUNCTION_ERROR_MESSAGE))), null);
 /**
 * Schema for validating Set items sort
 * @internal
@@ -214,6 +222,17 @@ const setPropertyValuesParametersSchema = v.object({
 	isLimitedToLeafPropertyValues: defaultBoolean(false)
 });
 /**
+* Schema for validating OCR matches parameters
+* @internal
+*/
+const ocrMatchesParametersSchema = v.object({
+	uuids: v.pipe(v.array(uuidSchema), v.minLength(1, "At least one UUID is required")),
+	value: v.pipe(v.string(), v.minLength(1, "A search value is required")),
+	matchMode: v.optional(v.picklist(["includes", "exact"]), "includes"),
+	isCaseSensitive: defaultBoolean(false),
+	maxMatchesPerItem: v.optional(positiveNumber("Max matches per item must be positive"), 50)
+});
+/**
 * Schema for validating Set items parameters
 * @internal
 */
@@ -226,4 +245,4 @@ const setItemsParametersSchema = v.object({
 	pageSize: v.optional(positiveNumber("Page size must be positive"), 48)
 });
 //#endregion
-export { componentSchema, gallerySchema, iso639_3Schema, renderOptionsSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, uuidSchema };
+export { componentSchema, gallerySchema, iso639_3Schema, ocrMatchesParametersSchema, renderOptionsSchema, setItemsParametersSchema, setPropertyValuesParametersSchema, uuidSchema };

package/dist/types/index.d.mts

@@ -303,6 +303,19 @@ type OcrPage = {
   height: number | null;
   blocks: Array<OcrTextBlock>;
 };
+/**
+ *  A run of adjacent OCR words matching a search value in OCHRE
+ *
+ *  `uuid` is the requested resource, while `resourceUuid` is the resource that
+ *  owns the OCR page — they differ when the OCR lives on a child page resource.
+ */
+type OcrMatch = {
+  uuid: string;
+  resourceUuid: string | null;
+  page: Omit<OcrPage, "blocks">;
+  content: string;
+  words: Array<OcrWord>;
+};
 /**
  *  Note in OCHRE
  */
@@ -831,6 +844,13 @@ type SetItemsSort = {
 };
 /**
  * Represents a leaf query for Set items
+ *
+ * The `ocr` target matches the OCR text layer of resources. Because OCR is not
+ * carried by Set item projections, it is resolved by a document join rather
+ * than a CTS term, which means `ocr` leaves compose with `and` and `isNegated`
+ * but cannot be nested inside an `or` group. Both match modes are adjacency
+ * based: `includes` allows stemming and wildcards, `exact` requires whole OCR
+ * words. OCR carries no language, so `ocr` leaves take no `language`.
  */
 type QueryLeaf = {
   target: "property";
@@ -897,6 +917,12 @@ type QueryLeaf = {
   isCaseSensitive: boolean;
   language: string;
   isNegated?: boolean;
+} | {
+  target: "ocr";
+  value: string;
+  matchMode: "includes" | "exact";
+  isCaseSensitive: boolean;
+  isNegated?: boolean;
 } | {
   target: "title" | "description" | "image" | "periods" | "bibliography" | "notes";
   value: string;
@@ -918,4 +944,4 @@ type QueryGroup = {
  */
 type Query = QueryLeaf | QueryGroup;
 //#endregion
-export { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, Metadata, Note, Observation, OcrPage, OcrPoint, OcrTextBlock, OcrTextLine, OcrWord, Period, PeriodItemLink, Person, PersonItemLink, Prettify, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink };
+export { AnyBibliography, AnyConcept, AnyItem, AnyPeriod, AnyPerson, AnyPropertyValue, AnyPropertyVariable, AnyResource, AnySet, AnySpatialUnit, AnyText, AnyTree, BaseItem, BaseItemLink, BelongsTo, Bibliography, BibliographyEntryInfo, BibliographyItemLink, BibliographySourceDocument, Concept, ConceptItemLink, ContainedItemCategory, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Context, ContextItem, ContextItemCategory, ContextNode, Coordinates, CoordinatesSource, DictionaryUnitItemLink, EmbeddedBibliography, EmbeddedConcept, EmbeddedItem, EmbeddedPeriod, EmbeddedPerson, EmbeddedPropertyValue, EmbeddedPropertyVariable, EmbeddedResource, EmbeddedSet, EmbeddedSpatialUnit, EmbeddedText, EmbeddedTree, Event, Gallery, Heading, HeadingItemCategory, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, ItemCategory, ItemCategoryFromOption, ItemCategoryOption, ItemCategoryWithEmbeddedItems, ItemContainerCategory, ItemLink, ItemLinkCategory, ItemLinks, ItemPayloadKind, ItemProperty, ItemWithoutEmbeddedItems, LanguageCodes, License, Metadata, Note, Observation, OcrMatch, OcrPage, OcrPoint, OcrTextBlock, OcrTextLine, OcrWord, Period, PeriodItemLink, Person, PersonItemLink, Prettify, Property, PropertyLike, PropertyRelation, PropertyValue, PropertyValueContent, PropertyValueDataType, PropertyValueItemLink, PropertyValueQueryItem, PropertyVariable, PropertyVariableItemLink, Query, QueryGroup, QueryLeaf, QueryablePropertyValueDataType, RecursiveItemCategory, Resource, ResourceItemLink, Section, Set, SetAttributeValueQueryItem, SetBibliography, SetConcept, SetItem, SetItemCategory, SetItemLink, SetItemProperty, SetItemSimplifiedProperty, SetItemsSort, SetItemsSortDirection, SetPeriod, SetResource, SetSpatialUnit, SetTree, SimplifiedProperty, SpatialUnit, SpatialUnitItemLink, Text, TextItemLink, TopLevelItem, Tree, TreeItemCategory, TreeItemLink };

package/dist/xml/schemas.d.mts

@@ -1,6 +1,11 @@
-import { XMLData as XMLData$1, XMLDataItem as XMLDataItem$1, XMLGalleryData as XMLGalleryData$1, XMLItemLinksData as XMLItemLinksData$1, XMLLink as XMLLink$1, XMLSetItemsData as XMLSetItemsData$1, XMLWebsiteData as XMLWebsiteData$1 } from "./types.mjs";
+import { XMLData as XMLData$1, XMLDataItem as XMLDataItem$1, XMLGalleryData as XMLGalleryData$1, XMLItemLinksData as XMLItemLinksData$1, XMLLink as XMLLink$1, XMLOcrMatchesData as XMLOcrMatchesData$1, XMLSetItemsData as XMLSetItemsData$1, XMLWebsiteData as XMLWebsiteData$1 } from "./types.mjs";
 import * as v from "valibot";
 //#region src/xml/schemas.d.ts
+/**
+ * Schema for validating OCR matches fetched from the OCHRE API
+ * @internal
+ */
+declare const XMLOcrMatchesData: v.GenericSchema<unknown, XMLOcrMatchesData$1>;
 declare const XMLLink: v.GenericSchema<unknown, XMLLink$1>;
 declare const XMLDataItem: v.GenericSchema<unknown, XMLDataItem$1>;
 declare const XMLItemLinksData: v.GenericSchema<unknown, XMLItemLinksData$1>;
@@ -9,4 +14,4 @@ declare const XMLSetItemsData: v.GenericSchema<unknown, XMLSetItemsData$1>;
 declare const XMLData: v.GenericSchema<unknown, XMLData$1>;
 declare const XMLWebsiteData: v.GenericSchema<unknown, XMLWebsiteData$1>;
 //#endregion
-export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLLink, XMLSetItemsData, XMLWebsiteData };
+export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLLink, XMLOcrMatchesData, XMLSetItemsData, XMLWebsiteData };

package/dist/xml/schemas.mjs

@@ -238,6 +238,24 @@ const XMLOcrPage = v.object({
 	TextBlock: v.optional(v.array(XMLOcrTextBlock, "XMLOcrPage: TextBlock is array of XMLOcrTextBlock"))
 }, "XMLOcrPage: Shape error");
 const XMLOcr = v.object({ Page: v.optional(v.array(XMLOcrPage, "XMLOcr: Page is array of XMLOcrPage")) }, "XMLOcr: Shape error");
+const XMLOcrMatch = v.object({
+	resourceUuid: v.optional(v.string("XMLOcrMatch: resourceUuid is string and optional")),
+	n: XMLOptionalNumber,
+	fileName: v.optional(v.string("XMLOcrMatch: fileName is string and optional")),
+	WIDTH: XMLOptionalNumber,
+	HEIGHT: XMLOptionalNumber,
+	string: v.optional(v.array(XMLOcrString, "XMLOcrMatch: string is array of XMLOcrString"))
+}, "XMLOcrMatch: Shape error");
+const XMLOcrMatchItem = v.object({
+	uuid: v.pipe(v.string("XMLOcrMatchItem: uuid is string and required"), v.check(isPseudoUuid, "XMLOcrMatchItem: uuid is not a valid pseudo-UUID")),
+	matchCount: XMLNumber,
+	ocrMatch: v.optional(v.array(XMLOcrMatch, "XMLOcrMatchItem: ocrMatch is array of XMLOcrMatch"))
+}, "XMLOcrMatchItem: Shape error");
+/**
+* Schema for validating OCR matches fetched from the OCHRE API
+* @internal
+*/
+const XMLOcrMatchesData = v.object({ result: v.object({ ochre: v.object({ ocrMatches: v.optional(v.object({ ocrItem: v.optional(v.array(XMLOcrMatchItem, "XMLOcrMatchesData: ocrItem is array of XMLOcrMatchItem")) })) }) }) }, "XMLOcrMatchesData: Shape error");
 const XMLNote = v.object({
 	content: v.optional(XMLContent.entries.content),
 	payload: v.optional(v.string("XMLNote: payload is string and optional")),
@@ -944,4 +962,4 @@ const XMLWebsiteData = v.object({ result: v.object({ ochre: v.object({
 	tree: v.array(XMLWebsiteTree)
 }, "XMLWebsiteData: ochre is object with website tree") }, "XMLWebsiteData: result is object with ochre") }, "XMLWebsiteData: Shape error");
 //#endregion
-export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLLink, XMLSetItemsData, XMLWebsiteData };
+export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLLink, XMLOcrMatchesData, XMLSetItemsData, XMLWebsiteData };

package/dist/xml/types.d.mts

@@ -199,6 +199,24 @@ type XMLOcrPage = {
 type XMLOcr = {
   Page?: Array<XMLOcrPage>;
 };
+type XMLOcrMatch = Omit<XMLOcrPage, "TextBlock"> & {
+  resourceUuid?: string;
+  string?: Array<XMLOcrString>;
+};
+type XMLOcrMatchItem = {
+  uuid: string;
+  matchCount: XMLNumber;
+  ocrMatch?: Array<XMLOcrMatch>;
+};
+type XMLOcrMatchesData = {
+  result: {
+    ochre: {
+      ocrMatches?: {
+        ocrItem?: Array<XMLOcrMatchItem>;
+      };
+    };
+  };
+};
 type XMLNote = Partial<XMLContent> & XMLString & {
   noteNo?: XMLNumber;
   title?: string;
@@ -938,4 +956,4 @@ type XMLWebsiteData = {
   };
 };
 //#endregion
-export { XMLBaseItem, XMLBibliography, XMLBoolean, XMLConcept, XMLContent, XMLContext, XMLContextGroup, XMLContextItem, XMLContextValue, XMLCoordinate, XMLCoordinates, XMLCoordinatesSource, XMLData, XMLDataItem, XMLDictionaryUnit, XMLEmptyContext, XMLEvent, XMLGallery, XMLGalleryData, XMLHeading, XMLHeadingItemCategory, XMLIdentification, XMLImage, XMLImageMap, XMLImageMapArea, XMLInterpretation, XMLItemCategory, XMLItemLinks, XMLItemLinksData, XMLLicense, XMLLink, XMLLinkedBaseItem, XMLLinkedBibliography, XMLLinkedConcept, XMLLinkedPeriod, XMLLinkedPerson, XMLLinkedPropertyValue, XMLLinkedPropertyVariable, XMLLinkedResource, XMLLinkedSet, XMLLinkedSpatialUnit, XMLLinkedText, XMLLinkedTree, XMLMetadata, XMLNote, XMLNumber, XMLObservation, XMLOcr, XMLOcrPage, XMLOcrString, XMLOcrTextBlock, XMLOcrTextLine, XMLPeriod, XMLPerson, XMLProperty, XMLPropertyRelation, XMLPropertyValue, XMLPropertyVariable, XMLRecursiveItemCategory, XMLResource, XMLSection, XMLSet, XMLSetItems, XMLSetItemsData, XMLSimplifiedProperty, XMLSpatialUnit, XMLString, XMLText, XMLTree, XMLWebsiteContext, XMLWebsiteContextItem, XMLWebsiteContextLevel, XMLWebsiteData, XMLWebsiteFilterContext, XMLWebsiteFilterContextItem, XMLWebsiteOptions, XMLWebsiteProperties, XMLWebsiteResource, XMLWebsiteResourceGroup, XMLWebsiteResourceItem, XMLWebsiteScope, XMLWebsiteSegment, XMLWebsiteStyle, XMLWebsiteTree };
+export { XMLBaseItem, XMLBibliography, XMLBoolean, XMLConcept, XMLContent, XMLContext, XMLContextGroup, XMLContextItem, XMLContextValue, XMLCoordinate, XMLCoordinates, XMLCoordinatesSource, XMLData, XMLDataItem, XMLDictionaryUnit, XMLEmptyContext, XMLEvent, XMLGallery, XMLGalleryData, XMLHeading, XMLHeadingItemCategory, XMLIdentification, XMLImage, XMLImageMap, XMLImageMapArea, XMLInterpretation, XMLItemCategory, XMLItemLinks, XMLItemLinksData, XMLLicense, XMLLink, XMLLinkedBaseItem, XMLLinkedBibliography, XMLLinkedConcept, XMLLinkedPeriod, XMLLinkedPerson, XMLLinkedPropertyValue, XMLLinkedPropertyVariable, XMLLinkedResource, XMLLinkedSet, XMLLinkedSpatialUnit, XMLLinkedText, XMLLinkedTree, XMLMetadata, XMLNote, XMLNumber, XMLObservation, XMLOcr, XMLOcrMatch, XMLOcrMatchItem, XMLOcrMatchesData, XMLOcrPage, XMLOcrString, XMLOcrTextBlock, XMLOcrTextLine, XMLPeriod, XMLPerson, XMLProperty, XMLPropertyRelation, XMLPropertyValue, XMLPropertyVariable, XMLRecursiveItemCategory, XMLResource, XMLSection, XMLSet, XMLSetItems, XMLSetItemsData, XMLSimplifiedProperty, XMLSpatialUnit, XMLString, XMLText, XMLTree, XMLWebsiteContext, XMLWebsiteContextItem, XMLWebsiteContextLevel, XMLWebsiteData, XMLWebsiteFilterContext, XMLWebsiteFilterContextItem, XMLWebsiteOptions, XMLWebsiteProperties, XMLWebsiteResource, XMLWebsiteResourceGroup, XMLWebsiteResourceItem, XMLWebsiteScope, XMLWebsiteSegment, XMLWebsiteStyle, XMLWebsiteTree };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "1.0.70",
+  "version": "1.0.71",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",