@daihum/record-formats 0.1.0 → 0.1.1

package/dist/ead3-DM2in-ck.js

@@ -0,0 +1,592 @@
+import { i as hasFormatErrors, n as formatFail, r as formatOk, t as createFormatIssue } from "./result-Cl7IY6PN.js";
+import { a as getXmlText, c as parseXml, n as buildXml, r as findXmlValue, s as normalizeXmlName, t as asXmlArray } from "./xml-DXtayJiw.js";
+
+//#region src/ead3/ead3.ts
+const EAD3_FORMAT_ID = "ead3";
+const EAD3_NAMESPACE = "http://ead3.archivists.org/schema/";
+const EAD3_FORMAT_GENERATION = "EAD3";
+const EAD3_SCHEMA_VERSION = "1.1.1";
+const EAD3_SCHEMA_REVISION = "1.1.1";
+const EAD3_TAG_LIBRARY_VERSION = "1.1.2";
+const EAD3_VALIDATION_LEVEL = "projection";
+const EAD3_OFFICIAL_SCHEMA_VALIDATION = false;
+const EAD3_ADAPTER_PROFILE = {
+	profileId: "daihum.record-formats.ead3.projection.v0",
+	profileVersion: "0.1.0",
+	formatId: EAD3_FORMAT_ID,
+	formatGeneration: EAD3_FORMAT_GENERATION,
+	namespace: EAD3_NAMESPACE,
+	schemaVersion: EAD3_SCHEMA_VERSION,
+	schemaRevision: EAD3_SCHEMA_REVISION,
+	tagLibraryVersion: EAD3_TAG_LIBRARY_VERSION,
+	validationLevel: EAD3_VALIDATION_LEVEL,
+	officialSchemaValidation: EAD3_OFFICIAL_SCHEMA_VALIDATION,
+	conformanceNotes: [
+		"This adapter is a DAIHUM finding-aid projection for common EAD3 elements.",
+		"Validation checks required projection fields and structured parser/serializer invariants.",
+		"It does not run official EAD3 RNG, XSD, DTD, or Schematron schema validation.",
+		"Unknown XML subtrees can be preserved through extension fields when preserveUnknown is enabled.",
+		"DAIHUM href/source policy metadata is carried as projection attributes and is not official EAD3 schema validation."
+	],
+	sourceReferences: [{
+		label: "Library of Congress EAD3 schema page",
+		url: "https://www.loc.gov/ead/ead3schema.html"
+	}, {
+		label: "Library of Congress EAD3 tag library",
+		url: "https://www.loc.gov/ead/EAD3taglib/"
+	}]
+};
+const EAD3_ARRAY_TAGS = [
+	"unitdate",
+	"dao",
+	"c",
+	"odd"
+];
+const ACCESS_POINT_XML_TAGS = {
+	person: "persname",
+	family: "famname",
+	organization: "corpname",
+	place: "geogname",
+	subject: "subject",
+	documentaryForm: "genreform",
+	occupation: "occupation",
+	function: "function"
+};
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readElementText(parent, localName) {
+	return getXmlText(findXmlValue(parent, localName));
+}
+function readParagraphElementText(parent, localName) {
+	return readElementText(readRecord(parent, localName), "p");
+}
+function readRecord(parent, localName) {
+	const value = findXmlValue(parent, localName);
+	return isRecord(value) ? value : {};
+}
+function createEad3Issue(params) {
+	return createFormatIssue({
+		severity: params.severity ?? "error",
+		code: params.code,
+		path: params.path,
+		message: params.message,
+		format: EAD3_FORMAT_ID
+	});
+}
+function withEad3Profile(result) {
+	return {
+		...result,
+		adapterProfile: EAD3_ADAPTER_PROFILE
+	};
+}
+function ead3Ok(value, issues = []) {
+	return withEad3Profile(formatOk(value, issues));
+}
+function ead3Fail(issues, value) {
+	return withEad3Profile(formatFail(issues, value));
+}
+function collectUnknownXml(record, knownLocalNames) {
+	const known = new Set(knownLocalNames);
+	const unknown = Object.fromEntries(Object.entries(record).filter(([key]) => !known.has(normalizeXmlName(key))));
+	return Object.keys(unknown).length > 0 ? unknown : void 0;
+}
+function mergeKnown(extension, known) {
+	return {
+		...extension ?? {},
+		...known
+	};
+}
+function hasExtensionKeys(extension) {
+	return extension !== void 0 && Object.keys(extension).length > 0;
+}
+function hasComponentExtensions(extensions) {
+	return hasExtensionKeys(extensions.xml) || hasExtensionKeys(extensions.did);
+}
+function hasFindingAidExtensions(extensions) {
+	return hasExtensionKeys(extensions.ead) || hasExtensionKeys(extensions.control);
+}
+function dateToXml(date) {
+	return mergeKnown(date.extensions, {
+		"#text": date.expression,
+		...date.normalized ? { "@_normal": date.normalized } : {},
+		...date.type ? { "@_type": date.type } : {}
+	});
+}
+function textBlockToXml(value) {
+	return { p: value };
+}
+function accessPointToXml(value) {
+	return mergeKnown(value.extensions, {
+		"#text": value.label,
+		...value.identifier ? { "@_identifier": value.identifier } : {},
+		...value.source ? { "@_source": value.source } : {}
+	});
+}
+function controlAccessToXml(values, extensions) {
+	const grouped = {};
+	for (const value of values) {
+		const tag = ACCESS_POINT_XML_TAGS[value.type];
+		(grouped[tag] ??= []).push(accessPointToXml(value));
+	}
+	return mergeKnown(extensions, grouped);
+}
+function nestedExtension(extension, localName) {
+	const value = findXmlValue(extension, localName);
+	return isRecord(value) ? value : void 0;
+}
+function isHrefPolicyKind(value) {
+	return value === "preserve" || value === "relative" || value === "redact" || value === "externalize";
+}
+function readJsonRecord(value) {
+	const text = readString(value);
+	if (!text) return void 0;
+	try {
+		const parsed = JSON.parse(text);
+		return isRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function jsonRecordAttribute(value) {
+	if (!value || Object.keys(value).length === 0) return void 0;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function digitalObjectToXml(ref) {
+	const locatorJson = jsonRecordAttribute(ref.sourceRef?.locator);
+	const metadataJson = jsonRecordAttribute(ref.sourceRef?.metadata);
+	return mergeKnown(ref.extensions, {
+		"@_href": ref.href,
+		...ref.label ? { "@_label": ref.label } : {},
+		...ref.role ? { "@_role": ref.role } : {},
+		...ref.targetKind ? { "@_targetkind": ref.targetKind } : {},
+		...ref.hrefPolicy?.kind ? { "@_data-daihum-href-policy": ref.hrefPolicy.kind } : {},
+		...ref.hrefPolicy?.publicHref ? { "@_data-daihum-public-href": ref.hrefPolicy.publicHref } : {},
+		...ref.hrefPolicy?.baseHref ? { "@_data-daihum-base-href": ref.hrefPolicy.baseHref } : {},
+		...ref.hrefPolicy?.redactedHref ? { "@_data-daihum-redacted-href": ref.hrefPolicy.redactedHref } : {},
+		...ref.hrefPolicy?.note ? { "@_data-daihum-policy-note": ref.hrefPolicy.note } : {},
+		...ref.sourceRef?.kind ? { "@_data-daihum-source-kind": ref.sourceRef.kind } : {},
+		...ref.sourceRef?.id ? { "@_data-daihum-source-id": ref.sourceRef.id } : {},
+		...ref.sourceRef?.label ? { "@_data-daihum-source-label": ref.sourceRef.label } : {},
+		...locatorJson ? { "@_data-daihum-source-locator": locatorJson } : {},
+		...metadataJson ? { "@_data-daihum-source-metadata": metadataJson } : {}
+	});
+}
+function componentToXml(component) {
+	const repositoryExtension = nestedExtension(component.extensions?.did, "repository");
+	const repositoryNameExtension = nestedExtension(repositoryExtension, "corpname");
+	const controlAccessExtension = nestedExtension(component.extensions?.xml, "controlaccess");
+	const did = mergeKnown(component.extensions?.did, {
+		...component.referenceCode ? { unitid: component.referenceCode } : {},
+		unittitle: component.title,
+		...component.repository ? { repository: mergeKnown(repositoryExtension, { corpname: mergeKnown(repositoryNameExtension, { "#text": component.repository }) }) } : {},
+		...component.dates?.length ? { unitdate: component.dates.map(dateToXml) } : {},
+		...component.extent ? { physdesc: { extent: component.extent } } : {},
+		...component.creator ? { origination: { name: component.creator } } : {},
+		...component.language ? { langmaterial: { language: component.language } } : {},
+		...component.digitalObjects?.length ? { dao: component.digitalObjects.map(digitalObjectToXml) } : {}
+	});
+	return mergeKnown(component.extensions?.xml, {
+		...component.id ? { "@_id": component.id } : {},
+		"@_level": component.level,
+		...component.otherLevel ? { "@_otherlevel": component.otherLevel } : {},
+		did,
+		...component.abstract ? { abstract: textBlockToXml(component.abstract) } : {},
+		...component.scopeContent ? { scopecontent: { p: component.scopeContent } } : {},
+		...component.arrangement ? { arrangement: { p: component.arrangement } } : {},
+		...component.accessRestriction ? { accessrestrict: { p: component.accessRestriction } } : {},
+		...component.useRestriction ? { userestrict: { p: component.useRestriction } } : {},
+		...component.biographicalHistory ? { bioghist: textBlockToXml(component.biographicalHistory) } : {},
+		...component.custodialHistory ? { custodhist: { p: component.custodialHistory } } : {},
+		...component.acquisitionInformation ? { acqinfo: textBlockToXml(component.acquisitionInformation) } : {},
+		...component.appraisal ? { appraisal: textBlockToXml(component.appraisal) } : {},
+		...component.processingInformation ? { processinfo: textBlockToXml(component.processingInformation) } : {},
+		...component.relatedMaterial ? { relatedmaterial: textBlockToXml(component.relatedMaterial) } : {},
+		...component.separatedMaterial ? { separatedmaterial: textBlockToXml(component.separatedMaterial) } : {},
+		...component.preferredCitation ? { prefercite: textBlockToXml(component.preferredCitation) } : {},
+		...component.notes?.length ? { odd: component.notes.map((note) => ({ p: note })) } : {},
+		...component.accessPoints?.length || controlAccessExtension ? { controlaccess: controlAccessToXml(component.accessPoints ?? [], controlAccessExtension) } : {},
+		...component.components?.length ? { dsc: { c: component.components.map(componentToXml) } } : {}
+	});
+}
+function findingAidToXmlObject(findingAid) {
+	const languageDeclarationExtension = nestedExtension(findingAid.extensions?.control, "languagedeclaration");
+	const languageExtension = nestedExtension(languageDeclarationExtension, "language");
+	const control = mergeKnown(findingAid.extensions?.control, {
+		recordid: findingAid.recordId,
+		maintenancestatus: findingAid.maintenanceStatus ?? "new",
+		publicationstatus: "inprocess",
+		...findingAid.agencyName ? { maintenanceagency: { agencyname: findingAid.agencyName } } : {},
+		...findingAid.language ? { languagedeclaration: mergeKnown(languageDeclarationExtension, { language: mergeKnown(languageExtension, { "#text": findingAid.language }) }) } : {},
+		filedesc: { titlestmt: { titleproper: findingAid.title } }
+	});
+	return { ead: mergeKnown(findingAid.extensions?.ead, {
+		"@_xmlns": EAD3_NAMESPACE,
+		control,
+		archdesc: componentToXml(findingAid.description)
+	}) };
+}
+function readDate(value) {
+	const expression = getXmlText(value);
+	if (!expression) return void 0;
+	const record = isRecord(value) ? value : {};
+	const normalized = readString(findXmlValue(record, "normal"));
+	const type = readString(findXmlValue(record, "type"));
+	const extensions = collectUnknownXml(record, [
+		"#text",
+		"normal",
+		"type"
+	]);
+	return {
+		expression,
+		...normalized ? { normalized } : {},
+		...type ? { type } : {},
+		...extensions ? { extensions } : {}
+	};
+}
+function readDigitalObject(value) {
+	if (!isRecord(value)) return void 0;
+	const href = readString(findXmlValue(value, "href"));
+	if (!href) return void 0;
+	const label = readString(findXmlValue(value, "label"));
+	const role = readString(findXmlValue(value, "role"));
+	const targetKind = readString(findXmlValue(value, "targetkind"));
+	const hrefPolicyKind = readString(findXmlValue(value, "data-daihum-href-policy"));
+	const publicHref = readString(findXmlValue(value, "data-daihum-public-href"));
+	const baseHref = readString(findXmlValue(value, "data-daihum-base-href"));
+	const redactedHref = readString(findXmlValue(value, "data-daihum-redacted-href"));
+	const policyNote = readString(findXmlValue(value, "data-daihum-policy-note"));
+	const sourceKind = readString(findXmlValue(value, "data-daihum-source-kind"));
+	const sourceId = readString(findXmlValue(value, "data-daihum-source-id"));
+	const sourceLabel = readString(findXmlValue(value, "data-daihum-source-label"));
+	const sourceLocator = readJsonRecord(findXmlValue(value, "data-daihum-source-locator"));
+	const sourceMetadata = readJsonRecord(findXmlValue(value, "data-daihum-source-metadata"));
+	const extensions = collectUnknownXml(value, [
+		"href",
+		"label",
+		"role",
+		"targetkind",
+		"data-daihum-href-policy",
+		"data-daihum-public-href",
+		"data-daihum-base-href",
+		"data-daihum-redacted-href",
+		"data-daihum-policy-note",
+		"data-daihum-source-kind",
+		"data-daihum-source-id",
+		"data-daihum-source-label",
+		"data-daihum-source-locator",
+		"data-daihum-source-metadata"
+	]);
+	return {
+		href,
+		...label ? { label } : {},
+		...role ? { role } : {},
+		...targetKind ? { targetKind } : {},
+		...isHrefPolicyKind(hrefPolicyKind) ? { hrefPolicy: {
+			kind: hrefPolicyKind,
+			...publicHref ? { publicHref } : {},
+			...baseHref ? { baseHref } : {},
+			...redactedHref ? { redactedHref } : {},
+			...policyNote ? { note: policyNote } : {}
+		} } : {},
+		...sourceKind && sourceId ? { sourceRef: {
+			kind: sourceKind,
+			id: sourceId,
+			...sourceLabel ? { label: sourceLabel } : {},
+			...sourceLocator ? { locator: sourceLocator } : {},
+			...sourceMetadata ? { metadata: sourceMetadata } : {}
+		} } : {},
+		...extensions ? { extensions } : {}
+	};
+}
+function readAccessPoint(value, type) {
+	const label = getXmlText(value);
+	if (!label) return void 0;
+	const record = isRecord(value) ? value : {};
+	const identifier = readString(findXmlValue(record, "identifier"));
+	const source = readString(findXmlValue(record, "source"));
+	const extensions = collectUnknownXml(record, [
+		"#text",
+		"identifier",
+		"source"
+	]);
+	return {
+		type,
+		label,
+		...identifier ? { identifier } : {},
+		...source ? { source } : {},
+		...extensions ? { extensions } : {}
+	};
+}
+function readAccessPoints(controlAccess) {
+	return Object.entries(ACCESS_POINT_XML_TAGS).flatMap(([type, tag]) => asXmlArray(findXmlValue(controlAccess, tag)).map((value) => readAccessPoint(value, type)).filter((value) => Boolean(value)));
+}
+function readMaintenanceStatus(value) {
+	const status = getXmlText(value);
+	if (status === "new" || status === "revised" || status === "deleted" || status === "derived" || status === "unknown") return status;
+}
+function readLevel(value) {
+	const level = readString(value);
+	if (level === "collection" || level === "series" || level === "subseries" || level === "file" || level === "item" || level === "otherlevel") return { level };
+	return {
+		level: "otherlevel",
+		...level ? { otherLevel: level } : {}
+	};
+}
+function readComponent(value, path, issues, options) {
+	if (!isRecord(value)) return void 0;
+	const did = readRecord(value, "did");
+	const title = readElementText(did, "unittitle") ?? "";
+	if (!title) issues.push(createEad3Issue({
+		code: "ead3.component.title.required",
+		path: `${path}.title`,
+		message: "EAD3 component title is required."
+	}));
+	const childrenContainer = readRecord(value, "dsc");
+	const dates = asXmlArray(findXmlValue(did, "unitdate")).map(readDate).filter((date) => Boolean(date));
+	const digitalObjects = asXmlArray(findXmlValue(did, "dao")).map(readDigitalObject).filter((ref) => Boolean(ref));
+	const components = asXmlArray(findXmlValue(childrenContainer, "c")).map((child, index) => readComponent(child, `${path}.components.${index}`, issues, options)).filter((component) => Boolean(component));
+	const level = readLevel(findXmlValue(value, "level"));
+	const explicitOtherLevel = readString(findXmlValue(value, "otherlevel"));
+	const id = readString(findXmlValue(value, "id"));
+	const referenceCode = readElementText(did, "unitid");
+	const repository = readElementText(readRecord(did, "repository"), "corpname");
+	const extent = readElementText(readRecord(did, "physdesc"), "extent");
+	const creator = readElementText(readRecord(did, "origination"), "name");
+	const abstract = readParagraphElementText(value, "abstract");
+	const scopeContent = readParagraphElementText(value, "scopecontent");
+	const arrangement = readParagraphElementText(value, "arrangement");
+	const accessRestriction = readParagraphElementText(value, "accessrestrict");
+	const useRestriction = readParagraphElementText(value, "userestrict");
+	const language = readElementText(readRecord(did, "langmaterial"), "language");
+	const biographicalHistory = readParagraphElementText(value, "bioghist");
+	const custodialHistory = readParagraphElementText(value, "custodhist");
+	const acquisitionInformation = readParagraphElementText(value, "acqinfo");
+	const appraisal = readParagraphElementText(value, "appraisal");
+	const processingInformation = readParagraphElementText(value, "processinfo");
+	const relatedMaterial = readParagraphElementText(value, "relatedmaterial");
+	const separatedMaterial = readParagraphElementText(value, "separatedmaterial");
+	const preferredCitation = readParagraphElementText(value, "prefercite");
+	const notes = asXmlArray(findXmlValue(value, "odd")).map((note) => readElementText(note, "p")).filter((note) => Boolean(note));
+	const accessPoints = readAccessPoints(readRecord(value, "controlaccess"));
+	const componentUnknown = collectUnknownXml(value, [
+		"id",
+		"level",
+		"otherlevel",
+		"did",
+		"abstract",
+		"scopecontent",
+		"arrangement",
+		"accessrestrict",
+		"userestrict",
+		"bioghist",
+		"custodhist",
+		"acqinfo",
+		"appraisal",
+		"processinfo",
+		"relatedmaterial",
+		"separatedmaterial",
+		"prefercite",
+		"odd",
+		"dsc"
+	]);
+	const didUnknown = collectUnknownXml(did, [
+		"unitid",
+		"unittitle",
+		"unitdate",
+		"physdesc",
+		"origination",
+		"langmaterial",
+		"dao"
+	]);
+	const componentExtensions = options.preserveUnknown === false ? {} : {
+		...componentUnknown ? { xml: componentUnknown } : {},
+		...didUnknown ? { did: didUnknown } : {}
+	};
+	return {
+		...id ? { id } : {},
+		level: level.level,
+		...explicitOtherLevel ?? level.otherLevel ? { otherLevel: explicitOtherLevel ?? level.otherLevel } : {},
+		title,
+		...referenceCode ? { referenceCode } : {},
+		...repository ? { repository } : {},
+		...dates.length > 0 ? { dates } : {},
+		...extent ? { extent } : {},
+		...creator ? { creator } : {},
+		...abstract ? { abstract } : {},
+		...scopeContent ? { scopeContent } : {},
+		...arrangement ? { arrangement } : {},
+		...accessRestriction ? { accessRestriction } : {},
+		...useRestriction ? { useRestriction } : {},
+		...language ? { language } : {},
+		...biographicalHistory ? { biographicalHistory } : {},
+		...custodialHistory ? { custodialHistory } : {},
+		...acquisitionInformation ? { acquisitionInformation } : {},
+		...appraisal ? { appraisal } : {},
+		...processingInformation ? { processingInformation } : {},
+		...relatedMaterial ? { relatedMaterial } : {},
+		...separatedMaterial ? { separatedMaterial } : {},
+		...preferredCitation ? { preferredCitation } : {},
+		...notes.length > 0 ? { notes } : {},
+		...accessPoints.length > 0 ? { accessPoints } : {},
+		...digitalObjects.length > 0 ? { digitalObjects } : {},
+		...components.length > 0 ? { components } : {},
+		...hasComponentExtensions(componentExtensions) ? { extensions: componentExtensions } : {}
+	};
+}
+function getEadRoot(document) {
+	if (normalizeXmlName(document.rootName) === "ead") return document.root;
+	const maybeEad = findXmlValue(document.raw, "ead");
+	return isRecord(maybeEad) ? maybeEad : void 0;
+}
+function ead3FromXmlDocument(document, options = {}) {
+	const issues = [];
+	const ead = getEadRoot(document);
+	if (!ead) return ead3Fail([createEad3Issue({
+		code: "ead3.root.required",
+		path: "ead",
+		message: "EAD3 document must contain an ead root element."
+	})]);
+	const control = readRecord(ead, "control");
+	const titlestmt = readRecord(readRecord(control, "filedesc"), "titlestmt");
+	const description = readComponent(findXmlValue(ead, "archdesc"), "description", issues, options);
+	if (!description) return ead3Fail([createEad3Issue({
+		code: "ead3.archdesc.required",
+		path: "ead.archdesc",
+		message: "EAD3 document must contain an archdesc element."
+	})]);
+	const recordId = readElementText(control, "recordid") ?? "";
+	if (!recordId) issues.push(createEad3Issue({
+		code: "ead3.recordId.required",
+		path: "recordId",
+		message: "EAD3 record id is required."
+	}));
+	const title = readElementText(titlestmt, "titleproper") ?? description.title;
+	if (!title) issues.push(createEad3Issue({
+		code: "ead3.title.required",
+		path: "title",
+		message: "EAD3 title is required."
+	}));
+	const agencyName = readElementText(readRecord(control, "maintenanceagency"), "agencyname");
+	const language = readElementText(readRecord(control, "languagedeclaration"), "language");
+	const maintenanceStatus = readMaintenanceStatus(findXmlValue(control, "maintenancestatus"));
+	const eadUnknown = options.preserveUnknown === false ? void 0 : collectUnknownXml(ead, [
+		"xmlns",
+		"control",
+		"archdesc"
+	]);
+	const controlUnknown = options.preserveUnknown === false ? void 0 : collectUnknownXml(control, [
+		"recordid",
+		"maintenancestatus",
+		"publicationstatus",
+		"maintenanceagency",
+		"filedesc"
+	]);
+	const extensions = {
+		...eadUnknown ? { ead: eadUnknown } : {},
+		...controlUnknown ? { control: controlUnknown } : {}
+	};
+	const findingAid = {
+		recordId,
+		title,
+		...maintenanceStatus ? { maintenanceStatus } : {},
+		...agencyName ? { agencyName } : {},
+		...language ? { language } : {},
+		description,
+		...hasFindingAidExtensions(extensions) ? { extensions } : {}
+	};
+	return hasFormatErrors(issues) ? ead3Fail(issues, findingAid) : ead3Ok(findingAid, issues);
+}
+function parseEad3Xml(input, options = {}) {
+	const parsed = parseXml(input, { arrayTags: EAD3_ARRAY_TAGS });
+	if (!parsed.ok) return ead3Fail(parsed.issues);
+	return ead3FromXmlDocument(parsed.value, options);
+}
+function ead3ToXmlDocument(findingAid, options = {}) {
+	const issues = validateEad3(findingAid, options);
+	if (hasFormatErrors(issues)) return ead3Fail(issues);
+	const raw = findingAidToXmlObject(findingAid);
+	const ead = raw.ead;
+	if (!isRecord(ead)) return ead3Fail([createEad3Issue({
+		code: "ead3.serialize.failed",
+		path: "ead",
+		message: "EAD3 serializer did not produce an ead root element."
+	})]);
+	return ead3Ok({
+		rootName: "ead",
+		root: ead,
+		raw
+	});
+}
+function serializeEad3Xml(findingAid, options = {}) {
+	const document = ead3ToXmlDocument(findingAid);
+	if (!document.ok) return ead3Fail(document.issues);
+	return withEad3Profile(buildXml(document.value, {
+		format: options.format ?? true,
+		suppressEmptyNode: true
+	}));
+}
+function validateComponent(component, path) {
+	const issues = [];
+	if (!readString(component.title)) issues.push(createEad3Issue({
+		code: "ead3.component.title.required",
+		path: `${path}.title`,
+		message: "EAD3 component title is required."
+	}));
+	component.digitalObjects?.forEach((ref, index) => {
+		if (!readString(ref.href)) issues.push(createEad3Issue({
+			code: "ead3.digitalObject.href.required",
+			path: `${path}.digitalObjects.${index}.href`,
+			message: "EAD3 digital object href is required."
+		}));
+	});
+	component.accessPoints?.forEach((accessPoint, index) => {
+		if (!readString(accessPoint.label)) issues.push(createEad3Issue({
+			code: "ead3.accessPoint.label.required",
+			path: `${path}.accessPoints.${index}.label`,
+			message: "EAD3 access point label is required."
+		}));
+	});
+	component.components?.forEach((child, index) => {
+		issues.push(...validateComponent(child, `${path}.components.${index}`));
+	});
+	return issues;
+}
+function validateEad3(findingAid, options = {}) {
+	const issues = [];
+	if ((options.requireRecordId ?? true) && !readString(findingAid.recordId)) issues.push(createEad3Issue({
+		code: "ead3.recordId.required",
+		path: "recordId",
+		message: "EAD3 record id is required."
+	}));
+	if (!readString(findingAid.title)) issues.push(createEad3Issue({
+		code: "ead3.title.required",
+		path: "title",
+		message: "EAD3 title is required."
+	}));
+	issues.push(...validateComponent(findingAid.description, "description"));
+	return issues;
+}
+const ead3Adapter = {
+	format: EAD3_FORMAT_ID,
+	profile: EAD3_ADAPTER_PROFILE,
+	parse: parseEad3Xml,
+	serialize: serializeEad3Xml,
+	validate: validateEad3,
+	detect(input) {
+		return /<([A-Za-z0-9_-]+:)?ead[\s>]/.test(input);
+	}
+};
+
+//#endregion
+export { EAD3_OFFICIAL_SCHEMA_VALIDATION as a, EAD3_TAG_LIBRARY_VERSION as c, ead3FromXmlDocument as d, ead3ToXmlDocument as f, validateEad3 as h, EAD3_NAMESPACE as i, EAD3_VALIDATION_LEVEL as l, serializeEad3Xml as m, EAD3_FORMAT_GENERATION as n, EAD3_SCHEMA_REVISION as o, parseEad3Xml as p, EAD3_FORMAT_ID as r, EAD3_SCHEMA_VERSION as s, EAD3_ADAPTER_PROFILE as t, ead3Adapter as u };
+//# sourceMappingURL=ead3-DM2in-ck.js.map