@digitalculture/ochre-sdk 0.1.20 → 0.1.22

package/dist/index.cjs

@@ -0,0 +1,2121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  fetchByUuid: () => fetchByUuid,
+  fetchConcept: () => fetchConcept,
+  fetchGallery: () => fetchGallery,
+  fetchResource: () => fetchResource,
+  fetchSet: () => fetchSet,
+  fetchSpatialUnit: () => fetchSpatialUnit,
+  fetchTree: () => fetchTree,
+  fetchWebsite: () => fetchWebsite,
+  filterProperties: () => filterProperties,
+  getAllPropertyLabels: () => getAllPropertyLabels,
+  getPropertyByLabel: () => getPropertyByLabel,
+  getPropertyValueByLabel: () => getPropertyValueByLabel,
+  getPropertyValuesByLabel: () => getPropertyValuesByLabel,
+  parseBibliographies: () => parseBibliographies,
+  parseBibliography: () => parseBibliography,
+  parseConcept: () => parseConcept,
+  parseConcepts: () => parseConcepts,
+  parseContext: () => parseContext,
+  parseCoordinates: () => parseCoordinates,
+  parseDocument: () => parseDocument,
+  parseEmailAndUrl: () => parseEmailAndUrl,
+  parseEvents: () => parseEvents,
+  parseFakeString: () => parseFakeString,
+  parseIdentification: () => parseIdentification,
+  parseImage: () => parseImage,
+  parseImageMap: () => parseImageMap,
+  parseInterpretations: () => parseInterpretations,
+  parseLanguages: () => parseLanguages,
+  parseLicense: () => parseLicense,
+  parseLink: () => parseLink,
+  parseLinks: () => parseLinks,
+  parseMetadata: () => parseMetadata,
+  parseNotes: () => parseNotes,
+  parseObservation: () => parseObservation,
+  parseObservations: () => parseObservations,
+  parsePeriod: () => parsePeriod,
+  parsePeriods: () => parsePeriods,
+  parsePersons: () => parsePersons,
+  parseProperties: () => parseProperties,
+  parseResource: () => parseResource,
+  parseResources: () => parseResources,
+  parseSet: () => parseSet,
+  parseSpatialUnit: () => parseSpatialUnit,
+  parseSpatialUnits: () => parseSpatialUnits,
+  parseStringContent: () => parseStringContent,
+  parseStringDocumentItem: () => parseStringDocumentItem,
+  parseStringItem: () => parseStringItem,
+  parseTree: () => parseTree,
+  parseWebsite: () => parseWebsite,
+  trimEndLineBreaks: () => trimEndLineBreaks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/fetchers/generic.ts
+var import_zod = require("zod");
+var uuidSchema = import_zod.z.string().uuid({ message: "Invalid UUID provided" });
+async function fetchByUuid(uuid) {
+  try {
+    const result = uuidSchema.safeParse(uuid);
+    if (!result.success) {
+      throw new Error(result.error.issues[0]?.message);
+    }
+    const response = await fetch(
+      `https://ochre.lib.uchicago.edu/ochre?uuid=${uuid}&format=json&lang="*"`
+    );
+    if (!response.ok) {
+      throw new Error("Failed to fetch OCHRE data");
+    }
+    const dataRaw = await response.json();
+    if (!("ochre" in dataRaw)) {
+      throw new Error("Invalid OCHRE data: API response missing 'ochre' key");
+    }
+    return [null, dataRaw];
+  } catch (error) {
+    return [error instanceof Error ? error.message : "Unknown error", null];
+  }
+}
+
+// src/utils/parse.ts
+var import_zod3 = require("zod");
+
+// src/utils/string.ts
+var import_zod2 = require("zod");
+var renderOptionsSchema = import_zod2.z.string().transform((str) => str.split(" ")).pipe(
+  import_zod2.z.array(
+    import_zod2.z.enum([
+      "bold",
+      "italic",
+      "underline"
+    ])
+  )
+);
+var whitespaceSchema = import_zod2.z.string().transform((str) => str.split(" ")).pipe(
+  import_zod2.z.array(
+    import_zod2.z.enum([
+      "newline",
+      "trailing",
+      "leading"
+    ])
+  )
+);
+var emailSchema = import_zod2.z.string().email({ message: "Invalid email" });
+var urlSchema = import_zod2.z.string().refine((v) => v ? isUrlValid(v) : false, {
+  message: "Invalid URL"
+});
+function isUrlValid(url) {
+  const pattern = (
+    // eslint-disable-next-line regexp/no-useless-quantifier, regexp/no-unused-capturing-group
+    /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+(:\d+)?|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[\w%+./~-]*)?\??[\w%&+.;=@-]*#?\w*)?)/
+  );
+  return !!pattern.test(url);
+}
+function getStringItemByLanguage(content, language) {
+  const stringItemToFind = content.find((item) => item.lang === language);
+  return stringItemToFind ?? null;
+}
+function parseEmailAndUrl(string) {
+  const splitString = string.split(" ");
+  const returnSplitString = [];
+  for (const string2 of splitString) {
+    const cleanString = string2.replaceAll(/(?<=\s|^)[([{]+|[)\]}]+(?=\s|$)/g, "").replace(/[!),.:;?\]]$/, "");
+    const index = string2.indexOf(cleanString);
+    const before = string2.slice(0, index);
+    const after = string2.slice(index + cleanString.length);
+    const isEmail = emailSchema.safeParse(cleanString).success;
+    if (isEmail) {
+      returnSplitString.push(
+        before,
+        `${before}<ExternalLink href="mailto:${cleanString}">${cleanString}</ExternalLink>${after}`
+      );
+      continue;
+    }
+    const isUrl = urlSchema.safeParse(cleanString).success;
+    if (isUrl) {
+      returnSplitString.push(
+        `${before}<ExternalLink href="${cleanString}">${cleanString}</ExternalLink>${after}`
+      );
+      continue;
+    }
+    returnSplitString.push(string2);
+  }
+  return returnSplitString.join(" ");
+}
+function parseRenderOptions(contentString, renderString) {
+  let returnString = contentString;
+  const result = renderOptionsSchema.safeParse(renderString);
+  if (!result.success) {
+    console.warn(`Invalid render options string provided: \u201C${renderString}\u201D`);
+    return contentString;
+  }
+  for (const option of result.data) {
+    switch (option) {
+      case "bold": {
+        returnString = `**${returnString}**`;
+        break;
+      }
+      case "italic": {
+        returnString = `*${returnString}*`;
+        break;
+      }
+      case "underline": {
+        returnString = `_${returnString}_`;
+        break;
+      }
+    }
+  }
+  return returnString.replaceAll("&#39;", "'");
+}
+function parseWhitespace(contentString, whitespace) {
+  let returnString = contentString;
+  const result = whitespaceSchema.safeParse(whitespace);
+  if (!result.success) {
+    console.warn(`Invalid whitespace string provided: \u201C${whitespace}\u201D`);
+    return contentString;
+  }
+  for (const option of result.data) {
+    switch (option) {
+      case "newline": {
+        returnString = `${returnString}
+<br />`;
+        break;
+      }
+      case "trailing": {
+        returnString = `${returnString} `;
+        break;
+      }
+      case "leading": {
+        returnString = ` ${returnString}`;
+        break;
+      }
+    }
+  }
+  return returnString.replaceAll("&#39;", "'");
+}
+function parseFakeString(string) {
+  let returnString = "";
+  if (typeof string === "string") {
+    returnString = string;
+  } else if (typeof string === "number") {
+    returnString = string.toString();
+  } else if (typeof string === "boolean") {
+    returnString = string ? "Yes" : "No";
+  }
+  return returnString.replaceAll("&#39;", "'");
+}
+function parseStringItem(item) {
+  let returnString = "";
+  switch (typeof item.string) {
+    case "string": {
+      returnString = item.string;
+      break;
+    }
+    case "number":
+    case "boolean": {
+      returnString = parseFakeString(item.string);
+      break;
+    }
+    case "object": {
+      const stringItems = Array.isArray(item.string) ? item.string : [item.string];
+      for (const stringItem of stringItems) {
+        const renderedText = stringItem.rend != null ? parseRenderOptions(
+          parseFakeString(stringItem.content),
+          stringItem.rend
+        ) : parseFakeString(stringItem.content);
+        const whitespacedText = stringItem.whitespace != null ? parseWhitespace(renderedText, stringItem.whitespace) : renderedText;
+        returnString += whitespacedText;
+      }
+      break;
+    }
+    default: {
+      returnString = "";
+      break;
+    }
+  }
+  return returnString.replaceAll("&#39;", "'");
+}
+function parseStringDocumentItem(item, footnotes) {
+  if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+    return parseEmailAndUrl(parseFakeString(item));
+  }
+  if ("whitespace" in item && !("content" in item) && !("string" in item)) {
+    if (item.whitespace === "newline") {
+      return "  \n";
+    } else {
+      return "";
+    }
+  }
+  if ("links" in item) {
+    const itemString = parseFakeString(item.string).replaceAll("<", String.raw`\<`).replaceAll("{", String.raw`\{`);
+    const itemLinks = Array.isArray(item.links) ? item.links : [item.links];
+    for (const link of itemLinks) {
+      if ("resource" in link) {
+        const linkResource = Array.isArray(link.resource) ? link.resource[0] : link.resource;
+        let linkContent = null;
+        if (linkResource.content != null) {
+          linkContent = parseFakeString(linkResource.content).replaceAll("<", String.raw`\<`).replaceAll("{", String.raw`\{`);
+        }
+        switch (linkResource.type) {
+          case "image": {
+            if (linkResource.rend === "inline") {
+              return `<InlineImage uuid="${linkResource.uuid}" ${linkContent !== null ? `content="${linkContent}"` : ""} height={${linkResource.height?.toString() ?? "null"}} width={${linkResource.width?.toString() ?? "null"}} />`;
+            } else if (linkResource.publicationDateTime != null) {
+              return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkResource.uuid}" type="image"${linkContent !== null ? ` content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+            } else {
+              return `<TooltipSpan type="image" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+            }
+          }
+          case "internalDocument": {
+            const isFootnote = linkContent?.toLocaleLowerCase("en-US").includes("footnote");
+            if (isFootnote) {
+              if (footnotes) {
+                footnotes.push({
+                  uuid: linkResource.uuid,
+                  label: itemString,
+                  content: ""
+                });
+              }
+              return ` <Footnote uuid="${linkResource.uuid}"${itemString ? ` label="${itemString}"` : ""}${linkContent !== null ? ` content="${linkContent}"` : ""} />`;
+            } else {
+              return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkResource.uuid}" type="internalDocument" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+            }
+          }
+          case "externalDocument": {
+            if (linkResource.publicationDateTime != null) {
+              return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkResource.uuid}" type="externalDocument" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+            } else {
+              return `<TooltipSpan type="externalDocument" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+            }
+          }
+          default: {
+            return "";
+          }
+        }
+      } else if ("concept" in link) {
+        const linkConcept = Array.isArray(link.concept) ? link.concept[0] : link.concept;
+        if (linkConcept.publicationDateTime != null) {
+          return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkConcept.uuid}" type="concept">${itemString}</ExternalLink>`;
+        } else {
+          return `<TooltipSpan type="concept">${itemString}</TooltipSpan>`;
+        }
+      } else if ("set" in link) {
+        const linkSet = Array.isArray(link.set) ? link.set[0] : link.set;
+        if (linkSet.publicationDateTime != null) {
+          return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkSet.uuid}" type="set">${itemString}</ExternalLink>`;
+        } else {
+          return `<TooltipSpan type="set">${itemString}</TooltipSpan>`;
+        }
+      } else if ("person" in link) {
+        const linkPerson = Array.isArray(link.person) ? link.person[0] : link.person;
+        const linkContent = linkPerson.identification ? parseStringContent(linkPerson.identification.label) : null;
+        if (linkPerson.publicationDateTime != null) {
+          return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkPerson.uuid}" type="${linkPerson.type ?? "person"}" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</ExternalLink>`;
+        } else {
+          return `<TooltipSpan type="${linkPerson.type ?? "person"}" ${linkContent !== null ? `content="${linkContent}"` : ""}>${itemString}</TooltipSpan>`;
+        }
+      } else if ("bibliography" in link) {
+        const linkBibliography = Array.isArray(link.bibliography) ? link.bibliography[0] : link.bibliography;
+        if (linkBibliography.publicationDateTime != null) {
+          return `<ExternalLink href="https:\\/\\/ochre.lib.uchicago.edu/ochre?uuid=${linkBibliography.uuid}" type="${linkBibliography.type ?? "bibliography"}">${itemString}</ExternalLink>`;
+        } else {
+          return `<TooltipSpan type="bibliography">${itemString}</TooltipSpan>`;
+        }
+      }
+    }
+  }
+  let returnString = "";
+  if ("string" in item) {
+    const stringItems = Array.isArray(item.string) ? item.string : [item.string];
+    for (const stringItem of stringItems) {
+      returnString += parseStringDocumentItem(stringItem, footnotes);
+    }
+    if ("whitespace" in item && item.whitespace != null) {
+      returnString = parseWhitespace(
+        parseEmailAndUrl(returnString),
+        item.whitespace
+      );
+    }
+    return returnString.replaceAll("&#39;", "'");
+  } else {
+    returnString = parseFakeString(item.content);
+    if (item.rend != null) {
+      returnString = parseRenderOptions(
+        parseEmailAndUrl(returnString),
+        item.rend
+      );
+    }
+    if (item.whitespace != null) {
+      returnString = parseWhitespace(
+        parseEmailAndUrl(returnString),
+        item.whitespace
+      );
+    }
+  }
+  return returnString.replaceAll("&#39;", "'");
+}
+function trimEndLineBreaks(string) {
+  const trimmedString = string.replaceAll(/^\n<br \/>|\n<br \/>$/g, "");
+  const finalLineBreaks = /\n<br \/>$/.exec(trimmedString);
+  if (finalLineBreaks) {
+    return trimEndLineBreaks(trimmedString);
+  }
+  return trimmedString;
+}
+function parseStringContent(content, language = "eng") {
+  switch (typeof content.content) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return parseFakeString(content.content);
+    }
+    case "object": {
+      if (Array.isArray(content.content)) {
+        const stringItem = getStringItemByLanguage(content.content, language);
+        if (stringItem) {
+          return parseStringItem(stringItem);
+        } else {
+          const returnStringItem = content.content[0];
+          if (!returnStringItem) {
+            throw new Error(
+              `No string item found for language \u201C${language}\u201D in the following content:
+${JSON.stringify(
+                content.content
+              )}.`
+            );
+          }
+          return parseStringItem(returnStringItem);
+        }
+      } else {
+        return parseStringItem(content.content);
+      }
+    }
+    default: {
+      return String(content.content);
+    }
+  }
+}
+
+// src/utils/fetchers/resource.ts
+async function fetchResource(uuid) {
+  try {
+    const [error, dataRaw] = await fetchByUuid(uuid);
+    if (error !== null) {
+      throw new Error(error);
+    }
+    if (!("resource" in dataRaw.ochre)) {
+      throw new Error(
+        "Invalid OCHRE data: API response missing 'resource' key"
+      );
+    }
+    const resourceItem = parseResource(dataRaw.ochre.resource);
+    const data = {
+      uuid: parseFakeString(dataRaw.ochre.uuid),
+      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
+      belongsTo: {
+        uuid: dataRaw.ochre.uuidBelongsTo,
+        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
+      },
+      metadata: parseMetadata(dataRaw.ochre.metadata),
+      item: resourceItem
+    };
+    return { metadata: data.metadata, resource: data.item };
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/getters.ts
+var DEFAULT_OPTIONS = {
+  searchNestedProperties: false
+};
+function getPropertyByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const property = properties.find((property2) => property2.label === label);
+  if (property) {
+    return property;
+  }
+  if (searchNestedProperties) {
+    for (const property2 of properties) {
+      if (property2.properties.length > 0) {
+        const nestedResult = getPropertyByLabel(property2.properties, label, {
+          searchNestedProperties
+        });
+        if (nestedResult) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getPropertyValuesByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const property = properties.find((property2) => property2.label === label);
+  if (property) {
+    return property.values.map((value) => value.content);
+  }
+  if (searchNestedProperties) {
+    for (const property2 of properties) {
+      if (property2.properties.length > 0) {
+        const nestedResult = getPropertyValuesByLabel(
+          property2.properties,
+          label,
+          { searchNestedProperties }
+        );
+        if (nestedResult) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getPropertyValueByLabel(properties, label, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const values = getPropertyValuesByLabel(properties, label, {
+    searchNestedProperties
+  });
+  if (values !== null && values.length > 0) {
+    return values[0];
+  }
+  if (searchNestedProperties) {
+    for (const property of properties) {
+      if (property.properties.length > 0) {
+        const nestedResult = getPropertyValueByLabel(
+          property.properties,
+          label,
+          { searchNestedProperties }
+        );
+        if (nestedResult !== null) {
+          return nestedResult;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getAllPropertyLabels(properties, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const labels = /* @__PURE__ */ new Set();
+  for (const property of properties) {
+    labels.add(property.label);
+    if (property.properties.length > 0 && searchNestedProperties) {
+      const nestedLabels = getAllPropertyLabels(property.properties, {
+        searchNestedProperties: true
+      });
+      for (const label of nestedLabels) {
+        labels.add(label);
+      }
+    }
+  }
+  return [...labels];
+}
+function filterProperties(property, filter, options = DEFAULT_OPTIONS) {
+  const { searchNestedProperties } = options;
+  const isAllFields = filter.label.toLocaleLowerCase("en-US") === "all fields";
+  if (isAllFields || property.label.toLocaleLowerCase("en-US") === filter.label.toLocaleLowerCase("en-US")) {
+    let isFound = property.values.some(
+      (value) => value.content.toLocaleLowerCase("en-US").includes(filter.value.toLocaleLowerCase("en-US"))
+    );
+    if (!isFound && searchNestedProperties) {
+      isFound = property.properties.some(
+        (property2) => filterProperties(property2, filter, { searchNestedProperties: true })
+      );
+    }
+    return isFound;
+  }
+  return false;
+}
+
+// src/utils/parse.ts
+var websiteSchema = import_zod3.z.object({
+  type: import_zod3.z.enum(
+    [
+      "traditional",
+      "digital-collection",
+      "plum",
+      "cedar",
+      "elm",
+      "maple",
+      "oak",
+      "palm"
+    ],
+    { message: "Invalid website type" }
+  ),
+  status: import_zod3.z.enum(
+    ["development", "preview", "production"],
+    { message: "Invalid website status" }
+  ),
+  privacy: import_zod3.z.enum(
+    ["public", "password", "private"],
+    { message: "Invalid website privacy" }
+  )
+});
+var componentSchema = import_zod3.z.enum(
+  [
+    "annotated-document",
+    "annotated-image",
+    "bibliography",
+    "blog",
+    "button",
+    "collection",
+    "iiif-viewer",
+    "image",
+    "image-gallery",
+    "interactive-chapter-table",
+    "item-gallery",
+    "menu",
+    "menu-item",
+    "n-columns",
+    "n-rows",
+    "network-graph",
+    "table",
+    "text",
+    "text-image",
+    "timeline"
+  ],
+  { message: "Invalid component" }
+);
+function parseIdentification(identification) {
+  try {
+    const returnIdentification = {
+      label: parseStringContent(identification.label),
+      abbreviation: ""
+    };
+    for (const key of Object.keys(identification).filter(
+      (key2) => key2 !== "label"
+    )) {
+      returnIdentification[key] = parseStringContent(
+        identification[key]
+      );
+    }
+    return returnIdentification;
+  } catch (error) {
+    console.error(error);
+    return {
+      label: "",
+      abbreviation: ""
+    };
+  }
+}
+function parseLanguages(language) {
+  if (Array.isArray(language)) {
+    return language.map((lang) => parseStringContent(lang));
+  } else {
+    return [parseStringContent(language)];
+  }
+}
+function parseMetadata(metadata) {
+  let identification = {
+    label: "",
+    abbreviation: ""
+  };
+  if (metadata.item) {
+    if (metadata.item.label || metadata.item.abbreviation) {
+      let label = "";
+      let abbreviation = "";
+      if (metadata.item.label) {
+        label = parseStringContent(metadata.item.label);
+      }
+      if (metadata.item.abbreviation) {
+        abbreviation = parseStringContent(metadata.item.abbreviation);
+      }
+      identification = { label, abbreviation };
+    } else {
+      identification = parseIdentification(metadata.item.identification);
+    }
+  }
+  let projectIdentification = null;
+  const baseProjectIdentification = metadata.project?.identification ? parseIdentification(metadata.project.identification) : null;
+  if (baseProjectIdentification) {
+    projectIdentification = {
+      ...baseProjectIdentification,
+      website: metadata.project?.identification.website ?? null
+    };
+  }
+  return {
+    project: projectIdentification ? { identification: projectIdentification } : null,
+    item: metadata.item ? {
+      identification,
+      category: metadata.item.category,
+      type: metadata.item.type,
+      maxLength: metadata.item.maxLength ?? null
+    } : null,
+    dataset: parseStringContent(metadata.dataset),
+    publisher: parseStringContent(metadata.publisher),
+    languages: parseLanguages(metadata.language),
+    identifier: parseStringContent(metadata.identifier),
+    description: parseStringContent(metadata.description)
+  };
+}
+function parseContextItem(contextItem) {
+  return {
+    uuid: contextItem.uuid,
+    publicationDateTime: contextItem.publicationDateTime != null ? new Date(contextItem.publicationDateTime) : null,
+    number: contextItem.n,
+    content: parseFakeString(contextItem.content)
+  };
+}
+function parseContext(context) {
+  const contexts = Array.isArray(context.context) ? context.context : [context.context];
+  const returnContexts = {
+    nodes: contexts.map((context2) => {
+      const spatialUnit = [];
+      if ("spatialUnit" in context2 && context2.spatialUnit) {
+        const contextsToParse = Array.isArray(context2.spatialUnit) ? context2.spatialUnit : [context2.spatialUnit];
+        for (const contextItem of contextsToParse) {
+          spatialUnit.push(parseContextItem(contextItem));
+        }
+      }
+      return {
+        tree: parseContextItem(context2.tree),
+        project: parseContextItem(context2.project),
+        spatialUnit
+      };
+    }),
+    displayPath: context.displayPath
+  };
+  return returnContexts;
+}
+function parseLicense(license) {
+  if (typeof license.license === "string") {
+    return null;
+  }
+  return {
+    content: license.license.content,
+    url: license.license.target
+  };
+}
+function parsePersons(persons) {
+  const returnPersons = [];
+  for (const person of persons) {
+    returnPersons.push({
+      uuid: person.uuid,
+      publicationDateTime: person.publicationDateTime != null ? new Date(person.publicationDateTime) : null,
+      type: person.type ?? null,
+      date: person.date != null ? new Date(person.date) : null,
+      identification: person.identification ? parseIdentification(person.identification) : null,
+      content: person.content != null ? parseFakeString(person.content) : null
+    });
+  }
+  return returnPersons;
+}
+function parseLink(linkRaw) {
+  const links = "resource" in linkRaw ? linkRaw.resource : "concept" in linkRaw ? linkRaw.concept : "set" in linkRaw ? linkRaw.set : "tree" in linkRaw ? linkRaw.tree : "person" in linkRaw ? linkRaw.person : "bibliography" in linkRaw ? linkRaw.bibliography : "epigraphicUnit" in linkRaw ? linkRaw.epigraphicUnit : null;
+  if (!links) {
+    throw new Error(
+      `Invalid link provided: ${JSON.stringify(linkRaw, null, 2)}`
+    );
+  }
+  const linksToParse = Array.isArray(links) ? links : [links];
+  const returnLinks = [];
+  for (const link of linksToParse) {
+    const returnLink = {
+      category: "resource" in linkRaw ? "resource" : "concept" in linkRaw ? "concept" : "set" in linkRaw ? "set" : "person" in linkRaw ? "person" : "tree" in linkRaw ? "tree" : "bibliography" in linkRaw ? "bibliography" : "epigraphicUnit" in linkRaw ? "epigraphicUnit" : null,
+      content: "content" in link ? link.content != null ? parseFakeString(link.content) : null : null,
+      uuid: link.uuid,
+      type: link.type ?? null,
+      identification: link.identification ? parseIdentification(link.identification) : null,
+      image: null,
+      bibliographies: "bibliography" in linkRaw ? parseBibliographies(
+        Array.isArray(linkRaw.bibliography) ? linkRaw.bibliography : [linkRaw.bibliography]
+      ) : null,
+      publicationDateTime: link.publicationDateTime != null ? new Date(link.publicationDateTime) : null
+    };
+    if ("height" in link && link.height != null && link.width != null && link.heightPreview != null && link.widthPreview != null) {
+      returnLink.image = {
+        isInline: link.rend === "inline",
+        heightPreview: link.heightPreview,
+        widthPreview: link.widthPreview,
+        height: link.height,
+        width: link.width
+      };
+    }
+    returnLinks.push(returnLink);
+  }
+  return returnLinks;
+}
+function parseLinks(links) {
+  const returnLinks = [];
+  for (const link of links) {
+    returnLinks.push(...parseLink(link));
+  }
+  return returnLinks;
+}
+function parseDocument(document, language = "eng") {
+  let returnString = "";
+  const footnotes = [];
+  const documentWithLanguage = Array.isArray(document) ? document.find((doc) => doc.lang === language) : document;
+  if (typeof documentWithLanguage.string === "string" || typeof documentWithLanguage.string === "number" || typeof documentWithLanguage.string === "boolean") {
+    returnString += parseEmailAndUrl(
+      parseFakeString(documentWithLanguage.string)
+    );
+  } else {
+    const documentItems = Array.isArray(documentWithLanguage.string) ? documentWithLanguage.string : [documentWithLanguage.string];
+    for (const item of documentItems) {
+      returnString += parseStringDocumentItem(item, footnotes);
+    }
+  }
+  returnString = trimEndLineBreaks(returnString);
+  return { content: returnString, footnotes };
+}
+function parseImage(image) {
+  return {
+    publicationDateTime: image.publicationDateTime != null ? new Date(image.publicationDateTime) : null,
+    identification: image.identification ? parseIdentification(image.identification) : null,
+    url: image.href ?? (image.htmlImgSrcPrefix == null && image.content != null ? parseFakeString(image.content) : null),
+    htmlPrefix: image.htmlImgSrcPrefix ?? null,
+    content: image.htmlImgSrcPrefix != null && image.content != null ? parseFakeString(image.content) : null
+  };
+}
+function parseNotes(notes, language = "eng") {
+  const returnNotes = [];
+  for (const note of notes) {
+    if (typeof note === "string") {
+      if (note === "") {
+        continue;
+      }
+      returnNotes.push({
+        number: -1,
+        title: null,
+        content: note
+      });
+      continue;
+    }
+    let content = "";
+    const notesToParse = Array.isArray(note.content) ? note.content : [note.content];
+    let noteWithLanguage = notesToParse.find((item) => item.lang === language);
+    if (!noteWithLanguage) {
+      noteWithLanguage = notesToParse[0];
+      if (!noteWithLanguage) {
+        throw new Error(
+          `Note does not have a valid content item: ${JSON.stringify(
+            note,
+            null,
+            2
+          )}`
+        );
+      }
+    }
+    if (typeof noteWithLanguage.string === "string" || typeof noteWithLanguage.string === "number" || typeof noteWithLanguage.string === "boolean") {
+      content = parseEmailAndUrl(parseFakeString(noteWithLanguage.string));
+    } else {
+      content = parseEmailAndUrl(parseDocument(noteWithLanguage).content);
+    }
+    returnNotes.push({
+      number: note.noteNo,
+      title: noteWithLanguage.title != null ? parseFakeString(noteWithLanguage.title) : null,
+      content
+    });
+  }
+  return returnNotes;
+}
+function parseCoordinates(coordinates) {
+  return {
+    latitude: coordinates.latitude,
+    longitude: coordinates.longitude,
+    type: coordinates.coord?.coordType ?? null,
+    label: coordinates.coord?.coordLabel != null ? parseFakeString(coordinates.coord.coordLabel) : null
+  };
+}
+function parseObservation(observation) {
+  return {
+    number: observation.observationNo,
+    date: observation.date != null ? new Date(observation.date) : null,
+    observers: observation.observers != null ? parseFakeString(observation.observers).split(";").map((observer) => observer.trim()) : [],
+    notes: observation.notes ? parseNotes(
+      Array.isArray(observation.notes.note) ? observation.notes.note : [observation.notes.note]
+    ) : [],
+    links: observation.links ? parseLinks(
+      Array.isArray(observation.links) ? observation.links : [observation.links]
+    ) : [],
+    properties: observation.properties ? parseProperties(
+      Array.isArray(observation.properties.property) ? observation.properties.property : [observation.properties.property]
+    ) : []
+  };
+}
+function parseObservations(observations) {
+  const returnObservations = [];
+  for (const observation of observations) {
+    returnObservations.push(parseObservation(observation));
+  }
+  return returnObservations;
+}
+function parseEvents(events) {
+  const returnEvents = [];
+  for (const event of events) {
+    returnEvents.push({
+      date: event.dateTime != null ? new Date(event.dateTime) : null,
+      label: parseStringContent(event.label),
+      agent: event.agent ? {
+        uuid: event.agent.uuid,
+        content: parseFakeString(event.agent.content)
+      } : null
+    });
+  }
+  return returnEvents;
+}
+function parseProperties(properties, language = "eng") {
+  const returnProperties = [];
+  for (const property of properties) {
+    const valuesToParse = "value" in property && property.value ? Array.isArray(property.value) ? property.value : [property.value] : [];
+    const values = valuesToParse.map((value) => ({
+      content: parseStringContent(value),
+      type: value.type,
+      category: value.category !== "value" ? value.category ?? null : null,
+      uuid: value.uuid ?? null,
+      publicationDateTime: value.publicationDateTime != null ? new Date(value.publicationDateTime) : null
+    }));
+    returnProperties.push({
+      label: parseStringContent(property.label, language).replace(/\s*\.{3}$/, "").trim(),
+      values,
+      comment: property.comment != null ? parseFakeString(property.comment) : null,
+      properties: property.property ? parseProperties(
+        Array.isArray(property.property) ? property.property : [property.property]
+      ) : []
+    });
+  }
+  return returnProperties;
+}
+function parseInterpretations(interpretations) {
+  const returnInterpretations = [];
+  for (const interpretation of interpretations) {
+    returnInterpretations.push({
+      date: new Date(interpretation.date),
+      number: interpretation.interpretationNo,
+      properties: interpretation.properties ? parseProperties(
+        Array.isArray(interpretation.properties.property) ? interpretation.properties.property : [interpretation.properties.property]
+      ) : []
+    });
+  }
+  return returnInterpretations;
+}
+function parseImageMap(imageMap) {
+  const returnImageMap = {
+    area: [],
+    width: imageMap.width,
+    height: imageMap.height
+  };
+  const imageMapAreasToParse = Array.isArray(imageMap.area) ? imageMap.area : [imageMap.area];
+  for (const area of imageMapAreasToParse) {
+    returnImageMap.area.push({
+      uuid: area.uuid,
+      publicationDateTime: area.publicationDateTime != null ? new Date(area.publicationDateTime) : null,
+      type: area.type,
+      title: parseFakeString(area.title),
+      shape: area.shape === "rect" ? "rectangle" : "polygon",
+      coords: area.coords.split(",").map((coord) => Number.parseInt(coord))
+    });
+  }
+  return returnImageMap;
+}
+function parsePeriod(period) {
+  return {
+    uuid: period.uuid,
+    publicationDateTime: period.publicationDateTime != null ? new Date(period.publicationDateTime) : null,
+    type: period.type ?? null,
+    number: period.n ?? null,
+    identification: parseIdentification(period.identification),
+    description: period.description ? parseStringContent(period.description) : null
+  };
+}
+function parsePeriods(periods) {
+  const returnPeriods = [];
+  for (const period of periods) {
+    returnPeriods.push(parsePeriod(period));
+  }
+  return returnPeriods;
+}
+function parseBibliography(bibliography) {
+  let resource = null;
+  if (bibliography.source?.resource) {
+    resource = {
+      uuid: bibliography.source.resource.uuid,
+      publicationDateTime: bibliography.source.resource.publicationDateTime ? new Date(bibliography.source.resource.publicationDateTime) : null,
+      type: bibliography.source.resource.type,
+      identification: parseIdentification(
+        bibliography.source.resource.identification
+      )
+    };
+  }
+  return {
+    uuid: bibliography.uuid,
+    publicationDateTime: bibliography.publicationDateTime != null ? new Date(bibliography.publicationDateTime) : null,
+    type: bibliography.type ?? null,
+    number: bibliography.n ?? null,
+    identification: bibliography.identification ? parseIdentification(bibliography.identification) : null,
+    projectIdentification: bibliography.project?.identification ? parseIdentification(bibliography.project.identification) : null,
+    context: bibliography.context ? parseContext(bibliography.context) : null,
+    citation: {
+      format: bibliography.citationFormat ?? null,
+      short: bibliography.citationFormatSpan ? parseFakeString(
+        "default:span" in bibliography.citationFormatSpan ? bibliography.citationFormatSpan["default:span"].content : bibliography.citationFormatSpan.span.content
+      ) : null,
+      long: bibliography.referenceFormatDiv ? parseFakeString(
+        "default:div" in bibliography.referenceFormatDiv ? bibliography.referenceFormatDiv["default:div"]["default:div"].content : bibliography.referenceFormatDiv.div.div.content
+      ) : null
+    },
+    publicationInfo: {
+      publishers: bibliography.publicationInfo?.publishers ? parsePersons(
+        Array.isArray(
+          bibliography.publicationInfo.publishers.publishers.person
+        ) ? bibliography.publicationInfo.publishers.publishers.person : [bibliography.publicationInfo.publishers.publishers.person]
+      ) : [],
+      startDate: bibliography.publicationInfo?.startDate ? new Date(
+        bibliography.publicationInfo.startDate.year,
+        bibliography.publicationInfo.startDate.month,
+        bibliography.publicationInfo.startDate.day
+      ) : null
+    },
+    entryInfo: bibliography.entryInfo ? {
+      startIssue: parseFakeString(bibliography.entryInfo.startIssue),
+      startVolume: parseFakeString(bibliography.entryInfo.startVolume)
+    } : null,
+    source: {
+      resource,
+      documentUrl: bibliography.sourceDocument ? `https://ochre.lib.uchicago.edu/ochre?uuid=${bibliography.sourceDocument.uuid}&load` : null
+    },
+    authors: bibliography.authors ? parsePersons(
+      Array.isArray(bibliography.authors.person) ? bibliography.authors.person : [bibliography.authors.person]
+    ) : [],
+    properties: bibliography.properties ? parseProperties(
+      Array.isArray(bibliography.properties.property) ? bibliography.properties.property : [bibliography.properties.property]
+    ) : []
+  };
+}
+function parseBibliographies(bibliographies) {
+  const returnBibliographies = [];
+  for (const bibliography of bibliographies) {
+    returnBibliographies.push(parseBibliography(bibliography));
+  }
+  return returnBibliographies;
+}
+function parseTree(tree) {
+  let creators = [];
+  if (tree.creators) {
+    creators = parsePersons(
+      Array.isArray(tree.creators.creator) ? tree.creators.creator : [tree.creators.creator]
+    );
+  }
+  let date = null;
+  if (tree.date != null) {
+    date = new Date(tree.date);
+  }
+  let resources = [];
+  let spatialUnits = [];
+  let concepts = [];
+  let periods = [];
+  let bibliographies = [];
+  if (typeof tree.items !== "string" && "resource" in tree.items) {
+    resources = parseResources(
+      Array.isArray(tree.items.resource) ? tree.items.resource : [tree.items.resource]
+    );
+  }
+  if (typeof tree.items !== "string" && "spatialUnit" in tree.items) {
+    spatialUnits = parseSpatialUnits(
+      Array.isArray(tree.items.spatialUnit) ? tree.items.spatialUnit : [tree.items.spatialUnit]
+    );
+  }
+  if (typeof tree.items !== "string" && "concept" in tree.items) {
+    concepts = parseConcepts(
+      Array.isArray(tree.items.concept) ? tree.items.concept : [tree.items.concept]
+    );
+  }
+  if (typeof tree.items !== "string" && "period" in tree.items) {
+    periods = parsePeriods(
+      Array.isArray(tree.items.period) ? tree.items.period : [tree.items.period]
+    );
+  }
+  if (typeof tree.items !== "string" && "bibliography" in tree.items) {
+    bibliographies = parseBibliographies(
+      Array.isArray(tree.items.bibliography) ? tree.items.bibliography : [tree.items.bibliography]
+    );
+  }
+  const returnTree = {
+    uuid: tree.uuid,
+    category: "tree",
+    publicationDateTime: new Date(tree.publicationDateTime),
+    identification: parseIdentification(tree.identification),
+    creators,
+    license: parseLicense(tree.availability),
+    date,
+    type: tree.type,
+    number: tree.n,
+    items: {
+      resources,
+      spatialUnits,
+      concepts,
+      periods,
+      bibliographies
+    },
+    properties: tree.properties ? parseProperties(
+      Array.isArray(tree.properties.property) ? tree.properties.property : [tree.properties.property]
+    ) : []
+  };
+  return returnTree;
+}
+function parseSet(set) {
+  let resources = [];
+  let spatialUnits = [];
+  let concepts = [];
+  let periods = [];
+  let bibliographies = [];
+  if (typeof set.items !== "string" && "resource" in set.items) {
+    resources = parseResources(
+      Array.isArray(set.items.resource) ? set.items.resource : [set.items.resource],
+      true
+    );
+  }
+  if (typeof set.items !== "string" && "spatialUnit" in set.items) {
+    spatialUnits = parseSpatialUnits(
+      Array.isArray(set.items.spatialUnit) ? set.items.spatialUnit : [set.items.spatialUnit],
+      true
+    );
+  }
+  if (typeof set.items !== "string" && "concept" in set.items) {
+    concepts = parseConcepts(
+      Array.isArray(set.items.concept) ? set.items.concept : [set.items.concept],
+      true
+    );
+  }
+  if (typeof set.items !== "string" && "period" in set.items) {
+    periods = parsePeriods(
+      Array.isArray(set.items.period) ? set.items.period : [set.items.period]
+    );
+  }
+  if (typeof set.items !== "string" && "bibliography" in set.items) {
+    bibliographies = parseBibliographies(
+      Array.isArray(set.items.bibliography) ? set.items.bibliography : [set.items.bibliography]
+    );
+  }
+  return {
+    uuid: set.uuid,
+    category: "set",
+    publicationDateTime: set.publicationDateTime ? new Date(set.publicationDateTime) : null,
+    date: set.date != null ? new Date(set.date) : null,
+    license: parseLicense(set.availability),
+    identification: parseIdentification(set.identification),
+    isSuppressingBlanks: set.suppressBlanks ?? false,
+    description: set.description ? parseStringContent(set.description) : "",
+    creators: set.creators ? parsePersons(
+      Array.isArray(set.creators.creator) ? set.creators.creator : [set.creators.creator]
+    ) : [],
+    type: set.type,
+    number: set.n,
+    items: {
+      resources,
+      spatialUnits,
+      concepts,
+      periods,
+      bibliographies
+    }
+  };
+}
+function parseResource(resource, isNested = false) {
+  const returnResource = {
+    uuid: resource.uuid,
+    category: "resource",
+    publicationDateTime: resource.publicationDateTime ? new Date(resource.publicationDateTime) : null,
+    type: resource.type,
+    number: resource.n,
+    format: resource.format ?? null,
+    context: "context" in resource && resource.context ? parseContext(resource.context) : null,
+    license: "availability" in resource && resource.availability ? parseLicense(resource.availability) : null,
+    copyright: "copyright" in resource && resource.copyright != null ? parseFakeString(resource.copyright) : null,
+    identification: parseIdentification(resource.identification),
+    date: resource.date != null ? new Date(resource.date) : null,
+    image: resource.image ? parseImage(resource.image) : null,
+    creators: resource.creators ? parsePersons(
+      Array.isArray(resource.creators.creator) ? resource.creators.creator : [resource.creators.creator]
+    ) : [],
+    notes: (
+      // TODO: Remove this check once the { rend: "splitNotes" } issue is fixed
+      resource.notes && "note" in resource.notes ? parseNotes(
+        Array.isArray(resource.notes.note) ? resource.notes.note : [resource.notes.note]
+      ) : []
+    ),
+    description: resource.description ? parseStringContent(resource.description) : "",
+    document: resource.document ? parseDocument(resource.document.content) : null,
+    href: resource.href ?? null,
+    imageMap: resource.imagemap ? parseImageMap(resource.imagemap) : null,
+    periods: resource.periods ? parsePeriods(
+      Array.isArray(resource.periods.period) ? resource.periods.period : [resource.periods.period]
+    ) : [],
+    links: resource.links ? parseLinks(
+      Array.isArray(resource.links) ? resource.links : [resource.links]
+    ) : [],
+    reverseLinks: resource.reverseLinks ? parseLinks(
+      Array.isArray(resource.reverseLinks) ? resource.reverseLinks : [resource.reverseLinks]
+    ) : [],
+    properties: resource.properties ? parseProperties(
+      Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]
+    ) : [],
+    citedBibliographies: resource.citedBibliography ? parseBibliographies(
+      Array.isArray(resource.citedBibliography.reference) ? resource.citedBibliography.reference : [resource.citedBibliography.reference]
+    ) : [],
+    resources: resource.resource ? parseResources(
+      Array.isArray(resource.resource) ? resource.resource : [resource.resource],
+      true
+    ) : []
+  };
+  if (isNested) {
+    const returnNestedResource = {
+      ...returnResource,
+      publicationDateTime: null,
+      context: null,
+      license: null,
+      copyright: null
+    };
+    delete returnNestedResource.publicationDateTime;
+    delete returnNestedResource.license;
+    delete returnNestedResource.copyright;
+    return returnNestedResource;
+  }
+  return returnResource;
+}
+function parseResources(resources, isNested = false) {
+  const returnResources = [];
+  const resourcesToParse = Array.isArray(resources) ? resources : [resources];
+  for (const resource of resourcesToParse) {
+    returnResources.push(parseResource(resource, isNested));
+  }
+  return returnResources;
+}
+function parseSpatialUnit(spatialUnit, isNested = false) {
+  const returnSpatialUnit = {
+    uuid: spatialUnit.uuid,
+    category: "spatialUnit",
+    publicationDateTime: spatialUnit.publicationDateTime != null ? new Date(spatialUnit.publicationDateTime) : null,
+    type: spatialUnit.type,
+    number: spatialUnit.n,
+    context: "context" in spatialUnit && spatialUnit.context ? parseContext(spatialUnit.context) : null,
+    license: "availability" in spatialUnit && spatialUnit.availability ? parseLicense(spatialUnit.availability) : null,
+    identification: parseIdentification(spatialUnit.identification),
+    image: spatialUnit.image ? parseImage(spatialUnit.image) : null,
+    description: spatialUnit.description ? parseStringContent(spatialUnit.description) : "",
+    coordinates: spatialUnit.coordinates ? parseCoordinates(spatialUnit.coordinates) : null,
+    observations: "observations" in spatialUnit && spatialUnit.observations ? parseObservations(
+      Array.isArray(spatialUnit.observations.observation) ? spatialUnit.observations.observation : [spatialUnit.observations.observation]
+    ) : spatialUnit.observation ? [parseObservation(spatialUnit.observation)] : [],
+    events: "events" in spatialUnit && spatialUnit.events ? parseEvents(
+      Array.isArray(spatialUnit.events.event) ? spatialUnit.events.event : [spatialUnit.events.event]
+    ) : []
+  };
+  if (isNested) {
+    const returnNestedSpatialUnit = {
+      ...returnSpatialUnit,
+      publicationDateTime: null,
+      license: null,
+      properties: "properties" in spatialUnit && spatialUnit.properties ? parseProperties(
+        Array.isArray(spatialUnit.properties.property) ? spatialUnit.properties.property : [spatialUnit.properties.property]
+      ) : []
+    };
+    delete returnNestedSpatialUnit.publicationDateTime;
+    delete returnNestedSpatialUnit.license;
+    return returnNestedSpatialUnit;
+  }
+  return returnSpatialUnit;
+}
+function parseSpatialUnits(spatialUnits, isNested = false) {
+  const returnSpatialUnits = [];
+  const spatialUnitsToParse = Array.isArray(spatialUnits) ? spatialUnits : [spatialUnits];
+  for (const spatialUnit of spatialUnitsToParse) {
+    returnSpatialUnits.push(
+      parseSpatialUnit(spatialUnit, isNested)
+    );
+  }
+  return returnSpatialUnits;
+}
+function parseConcept(concept, isNested = false) {
+  const returnConcept = {
+    uuid: concept.uuid,
+    category: "concept",
+    publicationDateTime: concept.publicationDateTime ? new Date(concept.publicationDateTime) : null,
+    number: concept.n,
+    license: "availability" in concept && concept.availability ? parseLicense(concept.availability) : null,
+    context: "context" in concept && concept.context ? parseContext(concept.context) : null,
+    identification: parseIdentification(concept.identification),
+    interpretations: parseInterpretations(
+      Array.isArray(concept.interpretations.interpretation) ? concept.interpretations.interpretation : [concept.interpretations.interpretation]
+    )
+  };
+  if (isNested) {
+    const returnNestedConcept = {
+      ...returnConcept,
+      publicationDateTime: null,
+      context: null,
+      license: null
+    };
+    delete returnNestedConcept.publicationDateTime;
+    delete returnNestedConcept.license;
+    return returnNestedConcept;
+  }
+  return returnConcept;
+}
+var parseWebpageResources = async (webpageResources, type) => {
+  const returnElements = [];
+  for (const resource of webpageResources) {
+    const resourceProperties = resource.properties ? parseProperties(
+      Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]
+    ) : [];
+    const resourceProperty = resourceProperties.find(
+      (property) => property.label === "presentation" && property.values[0].content === type
+    );
+    if (!resourceProperty) continue;
+    if (type === "element") {
+      const element = await parseWebElement(
+        resource,
+        resourceProperty.properties
+      );
+      returnElements.push(
+        element
+      );
+    } else {
+      const webpage = await parseWebpage(resource);
+      if (webpage) {
+        returnElements.push(
+          webpage
+        );
+      }
+    }
+  }
+  return returnElements;
+};
+function parseConcepts(concepts, isNested = false) {
+  const returnConcepts = [];
+  const conceptsToParse = Array.isArray(concepts) ? concepts : [concepts];
+  for (const concept of conceptsToParse) {
+    returnConcepts.push(parseConcept(concept, isNested));
+  }
+  return returnConcepts;
+}
+async function parseWebElementProperties(componentProperty, elementResource) {
+  const componentName = componentSchema.parse(
+    componentProperty.values[0].content
+  );
+  const properties = {
+    component: componentName
+  };
+  const links = elementResource.links ? parseLinks(
+    Array.isArray(elementResource.links) ? elementResource.links : [elementResource.links]
+  ) : [];
+  const imageLink = links.find((link) => link.type === "image");
+  let document = elementResource.document ? parseDocument(elementResource.document.content) : null;
+  if (document === null) {
+    const documentLink = links.find((link) => link.type === "internalDocument");
+    if (documentLink) {
+      const documentResource = await fetchResource(documentLink.uuid);
+      if (documentResource === null) {
+        throw new Error("Failed to fetch OCHRE data");
+      }
+      document = documentResource.resource.document;
+    }
+  }
+  switch (componentName) {
+    case "annotated-document": {
+      if (!document) {
+        throw new Error(
+          `Document not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.document = document;
+      break;
+    }
+    case "annotated-image": {
+      if (!imageLink) {
+        throw new Error(
+          `Image link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      let isSearchable = getPropertyValueByLabel(
+        componentProperty.properties,
+        "is-searchable"
+      ) === "Yes";
+      if (!isSearchable) {
+        isSearchable = false;
+      }
+      properties.imageUuid = imageLink.uuid;
+      properties.isSearchable = isSearchable;
+      break;
+    }
+    case "bibliography": {
+      const bibliographyLink = links.find(
+        (link) => link.category === "bibliography"
+      );
+      if (!bibliographyLink) {
+        throw new Error(
+          `Bibliography link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      if (!bibliographyLink.bibliographies) {
+        throw new Error(
+          `Bibliography not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      let layout = getPropertyValueByLabel(
+        componentProperty.properties,
+        "layout"
+      );
+      if (layout === null) {
+        layout = "long";
+      }
+      properties.bibliographies = bibliographyLink.bibliographies;
+      properties.layout = layout;
+      break;
+    }
+    case "blog": {
+      const blogLink = links.find((link) => link.category === "tree");
+      if (!blogLink) {
+        throw new Error(
+          `Blog link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.blogId = blogLink.uuid;
+      break;
+    }
+    case "button": {
+      let isExternal = false;
+      let href = getPropertyValueByLabel(
+        componentProperty.properties,
+        "navigate-to"
+      );
+      if (href === null) {
+        href = getPropertyValueByLabel(componentProperty.properties, "link-to");
+        if (href === null) {
+          throw new Error(
+            `Properties \u201Cnavigate-to\u201D or \u201Clink-to\u201D not found for the following component: \u201C${componentName}\u201D`
+          );
+        } else {
+          isExternal = true;
+        }
+      }
+      properties.href = href;
+      properties.isExternal = isExternal;
+      properties.label = parseStringContent(
+        elementResource.identification.label
+      );
+      break;
+    }
+    case "collection": {
+      let variant = getPropertyValueByLabel(
+        componentProperty.properties,
+        "variant"
+      );
+      if (variant === null) {
+        variant = "full";
+      }
+      let layout = getPropertyValueByLabel(
+        componentProperty.properties,
+        "layout"
+      );
+      if (layout === null) {
+        layout = "image-start";
+      }
+      const collectionLink = links.find((link) => link.category === "set");
+      if (!collectionLink) {
+        throw new Error(
+          `Collection link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.variant = variant;
+      properties.layout = layout;
+      properties.collectionId = collectionLink.uuid;
+      break;
+    }
+    case "iiif-viewer": {
+      const manifestLink = links.find((link) => link.type === "IIIF");
+      if (!manifestLink) {
+        throw new Error(
+          `Manifest link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.IIIFId = manifestLink.uuid;
+      break;
+    }
+    case "image": {
+      if (!imageLink) {
+        throw new Error(
+          `Image link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.image = {
+        url: `https://ochre.lib.uchicago.edu/ochre?uuid=${imageLink.uuid}&load`,
+        label: imageLink.identification?.label ?? null,
+        width: imageLink.image?.width ?? 0,
+        height: imageLink.image?.height ?? 0
+      };
+      break;
+    }
+    case "image-gallery": {
+      const galleryLink = links.find((link) => link.category === "tree");
+      if (!galleryLink) {
+        throw new Error(
+          `Image gallery link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.galleryId = galleryLink.uuid;
+      break;
+    }
+    case "interactive-chapter-table": {
+      break;
+    }
+    case "item-gallery": {
+      const galleryLink = links.find((link) => link.category === "tree");
+      if (!galleryLink) {
+        throw new Error(
+          `Item gallery link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.galleryId = galleryLink.uuid;
+      break;
+    }
+    case "menu": {
+      break;
+    }
+    case "menu-item": {
+      break;
+    }
+    case "n-columns": {
+      const subElements = elementResource.resource ? await parseWebpageResources(
+        Array.isArray(elementResource.resource) ? elementResource.resource : [elementResource.resource],
+        "element"
+      ) : [];
+      properties.columns = subElements;
+      break;
+    }
+    case "n-rows": {
+      const subElements = elementResource.resource ? await parseWebpageResources(
+        Array.isArray(elementResource.resource) ? elementResource.resource : [elementResource.resource],
+        "element"
+      ) : [];
+      properties.rows = subElements;
+      break;
+    }
+    case "network-graph": {
+      break;
+    }
+    case "table": {
+      const tableLink = links.find((link) => link.category === "set");
+      if (!tableLink) {
+        throw new Error(
+          `Table link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.tableId = tableLink.uuid;
+      break;
+    }
+    case "text": {
+      if (!document) {
+        throw new Error(
+          `Document not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      let variant = getPropertyValueByLabel(
+        componentProperty.properties,
+        "variant"
+      );
+      if (variant === null) {
+        variant = "block";
+      }
+      properties.variant = variant;
+      properties.content = document.content;
+      break;
+    }
+    case "text-image": {
+      if (!document) {
+        throw new Error(
+          `Document not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      let variant = getPropertyValueByLabel(
+        componentProperty.properties,
+        "variant"
+      );
+      if (variant === null) {
+        variant = "block";
+      }
+      let layout = getPropertyValueByLabel(
+        componentProperty.properties,
+        "layout"
+      );
+      if (layout === null) {
+        layout = "image-start";
+      }
+      let captionLayout = getPropertyValueByLabel(
+        componentProperty.properties,
+        "caption-layout"
+      );
+      if (captionLayout === null) {
+        captionLayout = "bottom";
+      }
+      const imageLink2 = links.find(
+        (link) => link.type === "image" || link.type === "IIIF"
+      );
+      if (!imageLink2) {
+        throw new Error(
+          `Image link not found for the following component: \u201C${componentName}\u201D: ${JSON.stringify(
+            links
+          )}`
+        );
+      }
+      properties.variant = variant;
+      properties.layout = layout;
+      properties.captionLayout = captionLayout;
+      properties.content = document.content;
+      properties.image = {
+        url: `https://ochre.lib.uchicago.edu/ochre?uuid=${imageLink2.uuid}&preview`,
+        label: imageLink2.identification?.label ?? null,
+        width: imageLink2.image?.width ?? 0,
+        height: imageLink2.image?.height ?? 0
+      };
+      properties.imageOpacity = null;
+      break;
+    }
+    case "timeline": {
+      const timelineLink = links.find((link) => link.category === "tree");
+      if (!timelineLink) {
+        throw new Error(
+          `Timeline link not found for the following component: \u201C${componentName}\u201D`
+        );
+      }
+      properties.timelineId = timelineLink.uuid;
+      break;
+    }
+    default: {
+      console.warn(
+        `Invalid or non-implemented component name \u201C${componentName}\u201D for the following element: \u201C${parseStringContent(
+          elementResource.identification.label
+        )}\u201D`
+      );
+    }
+  }
+  return properties;
+}
+async function parseWebElement(elementResource, elementProperties) {
+  const identification = parseIdentification(elementResource.identification);
+  const componentProperty = elementProperties.find(
+    (property) => property.label === "component"
+  );
+  if (!componentProperty) {
+    throw new Error(
+      `Component for element \u201C${identification.label}\u201D not found`
+    );
+  }
+  const properties = await parseWebElementProperties(
+    componentProperty,
+    elementResource
+  );
+  const elementResourceProperties = elementResource.properties?.property ? parseProperties(
+    Array.isArray(elementResource.properties.property) ? elementResource.properties.property : [elementResource.properties.property]
+  ) : [];
+  const cssProperties = elementResourceProperties.find(
+    (property) => property.label === "presentation" && property.values[0].content === "css"
+  )?.properties ?? [];
+  const cssStyles = [];
+  for (const property of cssProperties) {
+    const cssStyle = property.values[0].content;
+    cssStyles.push({ label: property.label, value: cssStyle });
+  }
+  return {
+    uuid: elementResource.uuid,
+    title: identification.label,
+    cssStyles,
+    ...properties
+  };
+}
+async function parseWebpage(webpageResource) {
+  const webpageProperties = webpageResource.properties ? parseProperties(
+    Array.isArray(webpageResource.properties.property) ? webpageResource.properties.property : [webpageResource.properties.property]
+  ) : [];
+  if (webpageProperties.length === 0 || webpageProperties.find((property) => property.label === "presentation")?.values[0]?.content !== "page") {
+    return null;
+  }
+  const identification = parseIdentification(webpageResource.identification);
+  const slug = webpageResource.slug === "/" ? "" : webpageResource.slug;
+  if (slug === void 0) {
+    throw new Error(`Slug not found for page \u201C${identification.label}\u201D`);
+  }
+  const links = webpageResource.links ? parseLinks(
+    Array.isArray(webpageResource.links) ? webpageResource.links : [webpageResource.links]
+  ) : [];
+  const imageLink = links.find(
+    (link) => link.type === "image" || link.type === "IIIF"
+  );
+  const elements = webpageResource.resource ? await parseWebpageResources(
+    Array.isArray(webpageResource.resource) ? webpageResource.resource : [webpageResource.resource],
+    "element"
+  ) : [];
+  const webpages = webpageResource.resource ? await parseWebpageResources(
+    Array.isArray(webpageResource.resource) ? webpageResource.resource : [webpageResource.resource],
+    "page"
+  ) : [];
+  let displayedInHeader = true;
+  let width = "default";
+  let variant = "default";
+  const webpageSubProperties = webpageProperties.find(
+    (property) => property.label === "presentation" && property.values[0]?.content === "page"
+  )?.properties;
+  if (webpageSubProperties) {
+    const headerProperty = webpageSubProperties.find(
+      (property) => property.label === "header"
+    )?.values[0];
+    if (headerProperty) {
+      displayedInHeader = headerProperty.content === "Yes";
+    }
+    const widthProperty = webpageSubProperties.find(
+      (property) => property.label === "width"
+    )?.values[0];
+    if (widthProperty) {
+      width = widthProperty.content;
+    }
+    const variantProperty = webpageSubProperties.find(
+      (property) => property.label === "variant"
+    )?.values[0];
+    if (variantProperty) {
+      variant = variantProperty.content;
+    }
+  }
+  const cssStyleSubProperties = webpageProperties.find(
+    (property) => property.label === "presentation" && property.values[0]?.content === "css"
+  )?.properties;
+  const cssStyles = [];
+  if (cssStyleSubProperties) {
+    for (const property of cssStyleSubProperties) {
+      cssStyles.push({
+        label: property.label,
+        value: property.values[0].content
+      });
+    }
+  }
+  return {
+    title: identification.label,
+    slug,
+    elements,
+    properties: {
+      displayedInHeader,
+      width,
+      variant,
+      backgroundImageUrl: imageLink ? `https://ochre.lib.uchicago.edu/ochre?uuid=${imageLink.uuid}&preview` : null,
+      cssStyles
+    },
+    webpages
+  };
+}
+async function parseWebpages(webpageResources) {
+  const returnPages = [];
+  const pagesToParse = Array.isArray(webpageResources) ? webpageResources : [webpageResources];
+  for (const page of pagesToParse) {
+    const webpage = await parseWebpage(page);
+    if (webpage) {
+      returnPages.push(webpage);
+    }
+  }
+  return returnPages;
+}
+function parseWebsiteProperties(properties) {
+  const mainProperties = parseProperties(properties);
+  const websiteProperties = mainProperties.find(
+    (property) => property.label === "presentation"
+  )?.properties;
+  if (!websiteProperties) {
+    throw new Error("Presentation property not found");
+  }
+  const type = websiteProperties.find((property) => property.label === "webUI")?.values[0]?.content;
+  if (type == null) {
+    throw new Error("Website type not found");
+  }
+  const status = websiteProperties.find(
+    (property) => property.label === "status"
+  )?.values[0]?.content;
+  if (status == null) {
+    throw new Error("Website status not found");
+  }
+  let privacy = websiteProperties.find(
+    (property) => property.label === "privacy"
+  )?.values[0]?.content;
+  if (privacy == null) {
+    privacy = "public";
+  }
+  const result = websiteSchema.safeParse({
+    type,
+    status,
+    privacy
+  });
+  if (!result.success) {
+    throw new Error(`Invalid website properties: ${result.error.message}`);
+  }
+  const logoUuid = websiteProperties.find((property) => property.label === "logo")?.values[0]?.uuid ?? null;
+  let isHeaderDisplayed = true;
+  let headerVariant = "default";
+  let isFooterDisplayed = true;
+  let isSidebarDisplayed = false;
+  let searchCollectionUuid = null;
+  const headerProperty = websiteProperties.find(
+    (property) => property.label === "navbar-visible"
+  )?.values[0];
+  if (headerProperty) {
+    isHeaderDisplayed = headerProperty.content === "Yes";
+  }
+  const headerVariantProperty = websiteProperties.find(
+    (property) => property.label === "navbar-variant"
+  )?.values[0];
+  if (headerVariantProperty) {
+    headerVariant = headerVariantProperty.content;
+  }
+  const footerProperty = websiteProperties.find(
+    (property) => property.label === "footer-visible"
+  )?.values[0];
+  if (footerProperty) {
+    isFooterDisplayed = footerProperty.content === "Yes";
+  }
+  const sidebarProperty = websiteProperties.find(
+    (property) => property.label === "sidebar-visible"
+  )?.values[0];
+  if (sidebarProperty) {
+    isSidebarDisplayed = sidebarProperty.content === "Yes";
+  }
+  const collectionSearchProperty = websiteProperties.find(
+    (property) => property.label === "search-collection"
+  )?.values[0];
+  if (collectionSearchProperty) {
+    searchCollectionUuid = collectionSearchProperty.uuid;
+  }
+  const {
+    type: validatedType,
+    status: validatedStatus,
+    privacy: validatedPrivacy
+  } = result.data;
+  return {
+    type: validatedType,
+    privacy: validatedPrivacy,
+    status: validatedStatus,
+    isHeaderDisplayed,
+    headerVariant,
+    isFooterDisplayed,
+    isSidebarDisplayed,
+    searchCollectionUuid,
+    logoUrl: logoUuid !== null ? `https://ochre.lib.uchicago.edu/ochre?uuid=${logoUuid}&load` : null
+  };
+}
+async function parseWebsite(websiteTree, projectName, website) {
+  if (!websiteTree.properties) {
+    throw new Error("Website properties not found");
+  }
+  const properties = parseWebsiteProperties(
+    Array.isArray(websiteTree.properties.property) ? websiteTree.properties.property : [websiteTree.properties.property]
+  );
+  if (typeof websiteTree.items === "string" || !("resource" in websiteTree.items)) {
+    throw new Error("Website pages not found");
+  }
+  const resources = Array.isArray(websiteTree.items.resource) ? websiteTree.items.resource : [websiteTree.items.resource];
+  const pages = await parseWebpages(resources);
+  const sidebarElements = [];
+  const sidebar = resources.find((resource) => {
+    const resourceProperties = resource.properties ? parseProperties(
+      Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]
+    ) : [];
+    return resourceProperties.some(
+      (property) => property.label === "presentation" && property.values[0]?.content === "element" && property.properties[0]?.label === "component" && property.properties[0]?.values[0]?.content === "sidebar"
+    );
+  });
+  if (sidebar) {
+    const sidebarResources = sidebar.resource ? Array.isArray(sidebar.resource) ? sidebar.resource : [sidebar.resource] : [];
+    for (const resource of sidebarResources) {
+      const sidebarResourceProperties = resource.properties ? parseProperties(
+        Array.isArray(resource.properties.property) ? resource.properties.property : [resource.properties.property]
+      ) : [];
+      const element = await parseWebElement(
+        resource,
+        sidebarResourceProperties.find(
+          (property) => property.label === "presentation" && property.values[0]?.content === "element"
+        )?.properties ?? []
+      );
+      sidebarElements.push(element);
+    }
+  }
+  return {
+    uuid: websiteTree.uuid,
+    publicationDateTime: websiteTree.publicationDateTime ? new Date(websiteTree.publicationDateTime) : null,
+    identification: parseIdentification(websiteTree.identification),
+    project: {
+      name: parseFakeString(projectName),
+      website: website !== null ? parseFakeString(website) : null
+    },
+    creators: websiteTree.creators ? parsePersons(
+      Array.isArray(websiteTree.creators.creator) ? websiteTree.creators.creator : [websiteTree.creators.creator]
+    ) : [],
+    license: parseLicense(websiteTree.availability),
+    pages,
+    sidebarElements,
+    properties
+  };
+}
+
+// src/utils/fetchers/concept.ts
+async function fetchConcept(uuid) {
+  try {
+    const [error, dataRaw] = await fetchByUuid(uuid);
+    if (error !== null) {
+      throw new Error(error);
+    }
+    if (!("concept" in dataRaw.ochre)) {
+      throw new Error("Invalid OCHRE data: API response missing 'concept' key");
+    }
+    const conceptItem = parseConcept(dataRaw.ochre.concept);
+    const data = {
+      uuid: parseFakeString(dataRaw.ochre.uuid),
+      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
+      belongsTo: {
+        uuid: dataRaw.ochre.uuidBelongsTo,
+        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
+      },
+      metadata: parseMetadata(dataRaw.ochre.metadata),
+      item: conceptItem
+    };
+    return { metadata: data.metadata, concept: data.item };
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/fetchers/gallery.ts
+var import_zod4 = require("zod");
+var gallerySchema = import_zod4.z.object({
+  uuid: import_zod4.z.string().uuid({ message: "Invalid UUID" }),
+  filter: import_zod4.z.string().optional(),
+  page: import_zod4.z.number().positive({ message: "Page must be positive" }),
+  perPage: import_zod4.z.number().positive({ message: "Per page must be positive" })
+}).strict();
+async function fetchGallery(uuid, filter, page, perPage) {
+  try {
+    const parsed = gallerySchema.safeParse({ uuid, filter, page, perPage });
+    if (!parsed.success) {
+      throw new Error(parsed.error.message);
+    }
+    const response = await fetch(
+      `https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(`
+        for $q in input()/ochre[@uuid='${uuid}']
+        let $filtered := $q/tree/items/resource[contains(lower-case(identification/label), lower-case('${filter}'))]
+        let $maxLength := count($filtered)
+        return <gallery maxLength='{$maxLength}'>
+          {$q/metadata/project}
+          {$q/metadata/item}
+          {$filtered[position() >= ${((page - 1) * perPage + 1).toString()} and position() < ${(page * perPage + 1).toString()}]}
+        </gallery>
+      `)}&format=json`
+    );
+    if (!response.ok) {
+      throw new Error("Error fetching gallery items, please try again later.");
+    }
+    const data = await response.json();
+    if (!("gallery" in data.result)) {
+      throw new Error("Failed to fetch gallery");
+    }
+    const galleryIdentification = parseIdentification(data.result.gallery.item);
+    const galleryProjectIdentification = parseIdentification(
+      data.result.gallery.project.identification
+    );
+    const gallery = {
+      identification: galleryIdentification,
+      projectIdentification: galleryProjectIdentification,
+      resources: Array.isArray(data.result.gallery.resource) ? parseResources(data.result.gallery.resource) : [parseResource(data.result.gallery.resource)],
+      maxLength: data.result.gallery.maxLength
+    };
+    return gallery;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/fetchers/set.ts
+async function fetchSet(uuid) {
+  try {
+    const [error, dataRaw] = await fetchByUuid(uuid);
+    if (error !== null) {
+      throw new Error(error);
+    }
+    if (!("set" in dataRaw.ochre)) {
+      throw new Error("Invalid OCHRE data: API response missing 'set' key");
+    }
+    const setItem = parseSet(dataRaw.ochre.set);
+    const data = {
+      uuid: parseFakeString(dataRaw.ochre.uuid),
+      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
+      belongsTo: {
+        uuid: dataRaw.ochre.uuidBelongsTo,
+        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
+      },
+      metadata: parseMetadata(dataRaw.ochre.metadata),
+      item: setItem
+    };
+    return { metadata: data.metadata, set: data.item };
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/fetchers/spatial-unit.ts
+async function fetchSpatialUnit(uuid) {
+  try {
+    const [error, dataRaw] = await fetchByUuid(uuid);
+    if (error !== null) {
+      throw new Error(error);
+    }
+    if (!("spatialUnit" in dataRaw.ochre)) {
+      throw new Error(
+        "Invalid OCHRE data: API response missing 'spatialUnit' key"
+      );
+    }
+    const spatialUnitItem = parseSpatialUnit(dataRaw.ochre.spatialUnit);
+    const data = {
+      uuid: parseFakeString(dataRaw.ochre.uuid),
+      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
+      belongsTo: {
+        uuid: dataRaw.ochre.uuidBelongsTo,
+        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
+      },
+      metadata: parseMetadata(dataRaw.ochre.metadata),
+      item: spatialUnitItem
+    };
+    return { metadata: data.metadata, spatialUnit: data.item };
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/fetchers/tree.ts
+async function fetchTree(uuid) {
+  try {
+    const [error, dataRaw] = await fetchByUuid(uuid);
+    if (error !== null) {
+      throw new Error(error);
+    }
+    if (!("tree" in dataRaw.ochre)) {
+      throw new Error("Invalid OCHRE data: API response missing 'tree' key");
+    }
+    const tree = parseTree(dataRaw.ochre.tree);
+    if (!tree) {
+      throw new Error("Invalid OCHRE data: Could not parse tree");
+    }
+    const data = {
+      uuid: parseFakeString(dataRaw.ochre.uuid),
+      publicationDateTime: new Date(dataRaw.ochre.publicationDateTime),
+      belongsTo: {
+        uuid: dataRaw.ochre.uuidBelongsTo,
+        abbreviation: parseFakeString(dataRaw.ochre.belongsTo)
+      },
+      metadata: parseMetadata(dataRaw.ochre.metadata),
+      item: tree
+    };
+    return { metadata: data.metadata, tree: data.item };
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+// src/utils/fetchers/website.ts
+async function fetchWebsite(abbreviation) {
+  try {
+    const response = await fetch(
+      `https://ochre.lib.uchicago.edu/ochre?xquery=for $q in input()/ochre[tree[@type='lesson'][identification/abbreviation='${abbreviation.toLocaleLowerCase("en-US")}']] return $q&format=json`
+    );
+    if (!response.ok) {
+      throw new Error("Failed to fetch website");
+    }
+    const data = await response.json();
+    if (!("ochre" in data.result) || !("tree" in data.result.ochre)) {
+      throw new Error("Failed to fetch website");
+    }
+    const projectIdentification = data.result.ochre.metadata.project?.identification ? parseIdentification(data.result.ochre.metadata.project.identification) : null;
+    const website = await parseWebsite(
+      data.result.ochre.tree,
+      projectIdentification?.label ?? "",
+      data.result.ochre.metadata.project?.identification.website ?? null
+    );
+    return website;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchByUuid,
+  fetchConcept,
+  fetchGallery,
+  fetchResource,
+  fetchSet,
+  fetchSpatialUnit,
+  fetchTree,
+  fetchWebsite,
+  filterProperties,
+  getAllPropertyLabels,
+  getPropertyByLabel,
+  getPropertyValueByLabel,
+  getPropertyValuesByLabel,
+  parseBibliographies,
+  parseBibliography,
+  parseConcept,
+  parseConcepts,
+  parseContext,
+  parseCoordinates,
+  parseDocument,
+  parseEmailAndUrl,
+  parseEvents,
+  parseFakeString,
+  parseIdentification,
+  parseImage,
+  parseImageMap,
+  parseInterpretations,
+  parseLanguages,
+  parseLicense,
+  parseLink,
+  parseLinks,
+  parseMetadata,
+  parseNotes,
+  parseObservation,
+  parseObservations,
+  parsePeriod,
+  parsePeriods,
+  parsePersons,
+  parseProperties,
+  parseResource,
+  parseResources,
+  parseSet,
+  parseSpatialUnit,
+  parseSpatialUnits,
+  parseStringContent,
+  parseStringDocumentItem,
+  parseStringItem,
+  parseTree,
+  parseWebsite,
+  trimEndLineBreaks
+});