pro-editor-schema 1.4.1 → 1.5.5-8

package/dist/index.mjs

@@ -17,6 +17,7 @@ var FIGURE_PLACEMENT_ATTRIBUTE = "data-figure-placement";
 var LAYOUT_CELL_WIDTH_ATTRIBUTE = "data-cell-width";
 var LAYOUT_TABLE_ORIENTATION_ATTRIBUTE = "data-table-orientation";
 var LAYOUT_TABLE_PLACEMENT_ATTRIBUTE = "data-table-placement";
+var VALIDATION_IGNORED_ATTRIBUTE = "data-validation-ignored";
 var LAYOUT_ATTRIBUTES = [
   ALIGNMENT_ATTRIBUTE,
   LEFT_INDENT_ATTRIBUTE,
@@ -146,7 +147,7 @@ var EMPHASIS_SCHEMA = createSchema({
     ...TRACK_CHANGES_ATTRS,
     {
       name: "role",
-      values: ["lowercase", "uppercase", "initialcaps"],
+      values: ["lowercase", "uppercase", "initialcaps", "Non breaking space"],
       defaultValue: "lowercase"
     }
   ],
@@ -646,6 +647,27 @@ var POEM_TAG = "POEM";
 var BIBLIOMIXED_TAG = "BIBLIOMIXED";
 var REFERENCE_BIBLIOGRAPHY_TAG = "BIBLIOGRAPHY";
 var BIBLIODIV_TAG = "BIBLIODIV";
+var BIBLIOMSET_TAG = "BIBLIOMSET";
+var EDITOR_TAG = "EDITOR";
+var OTHERCREDIT_TAG = "OTHERCREDIT";
+var TRANSLATOR_TAG = "TRANSLATOR";
+var COLLAB_TAG = "COLLAB";
+var PUBDATE_TAG = "PUBDATE";
+var DATE_TAG = "DATE";
+var PUBLISHERNAME_TAG = "PUBLISHERNAME";
+var ADDRESS_TAG = "ADDRESS";
+var CITY_TAG = "CITY";
+var VOLUMENUM_TAG = "VOLUMENUM";
+var ISSUENUM_TAG = "ISSUENUM";
+var PAGENUMS_TAG = "PAGENUMS";
+var PAGENUM_TAG = "PAGENUM";
+var EDITION_TAG = "EDITION";
+var PUB_ID_TAG = "PUB-ID";
+var BIBLIOID_TAG = "BIBLIOID";
+var BIBLIOMISC_TAG = "BIBLIOMISC";
+var CONFGROUP_TAG = "CONFGROUP";
+var CONFTITLE_TAG = "CONFTITLE";
+var CONFDATES_TAG = "CONFDATES";
 var MATHPHRASE_TAG = "MATHPHRASE";
 var MATH_TAG = "MATH";
 var MERROR_TAG = "MERROR";
@@ -866,7 +888,8 @@ var EQUATION_SCHEMA = createSchema({
   ],
   allowedChildrenCodes: [
     { code: "mathphrase", required: true },
-    { code: "caption1", required: false }
+    { code: "caption1", required: false },
+    { code: "tag", required: false }
   ]
 });
 
@@ -1791,6 +1814,82 @@ var TABLE_SCHEMA = createSchema({
   ]
 });
 
+// src/schema/elementSchemas/elements/heading.ts
+var HEADING_LEVEL = ["H0", "H1", "H2", "H3", "H4", "H5", "H6"];
+var HEADING_ROLES = [...HEADING_LEVEL, "vignette_group"];
+var HEADING_SCHEMA = createSchema({
+  code: "heading",
+  kind: "element",
+  tag: SECTION_TAG,
+  matchesElement: (element) => {
+    const role = element.getAttribute("role");
+    if (!role) return false;
+    return HEADING_ROLES.includes(role);
+  },
+  requiredAttributes: [
+    ...ID_ATTRS,
+    "xmlid",
+    {
+      name: "role",
+      values: HEADING_ROLES,
+      defaultValue: "H1"
+    }
+  ],
+  optionalAttributes: [...TRACK_CHANGES_ATTRS],
+  defaultChildCode: "para",
+  allowedChildrenCodes: [
+    { code: "title1", required: false },
+    { code: "label1", required: false },
+    { code: "para", required: false },
+    { code: "subtitle1", required: false },
+    { code: "sidebar", required: false },
+    { code: "epigraph", required: false },
+    { code: "blockquote", required: false },
+    { code: "ul", required: false },
+    { code: "ol", required: false },
+    { code: "poem", required: false },
+    { code: "dialogue", required: false },
+    { code: "appendix", required: false },
+    { code: "table1", required: false },
+    { code: "figure1", required: false },
+    { code: "heading", required: false },
+    { code: "footnoteSection", required: false },
+    { code: "info1", required: false },
+    { code: "equation", required: false }
+  ]
+});
+
+// src/schema/elementSchemas/elements/box.ts
+var BOX_LEVEL = ["box1", "box2", "box3", "box4", "box5"];
+var BOX_SCHEMA = createSchema({
+  code: "sidebar",
+  kind: "element",
+  tag: SIDEBAR_TAG,
+  requiredAttributes: [
+    ...ID_ATTRS,
+    {
+      name: "status",
+      values: BOX_LEVEL,
+      defaultValue: "box1"
+    }
+  ],
+  optionalAttributes: [
+    ...TRACK_CHANGES_ATTRS,
+    "xmlid",
+    {
+      name: "role",
+      values: ["add-element", "change-para-box"],
+      defaultValue: "add-element"
+    }
+  ],
+  defaultChildCode: "para",
+  allowedChildrenCodes: [
+    { code: "para", required: false },
+    { code: "title1", required: false },
+    { code: "sidebar", required: false }
+  ]
+});
+
 // src/schema/elementSchemas/elements/title.ts
 var TITLE_SCHEMA = createSchema({
   code: "title1",
@@ -1808,7 +1907,7 @@ var TITLE_SCHEMA = createSchema({
     },
     {
       name: "title",
-      values: ["H1", "H2", "H3", "H4", "H5", "H6", "foot_note"],
+      values: [...HEADING_LEVEL, ...BOX_LEVEL, "foot_note"],
       defaultValue: "H1"
     }
   ],
@@ -1886,36 +1985,8 @@ var BLOCKQUOTE_SCHEMA = createSchema({
     { code: "ul", required: false },
     { code: "ol", required: false },
     { code: "sidebar", required: false },
-    { code: "source1", required: false }
-  ]
-});
-
-// src/schema/elementSchemas/elements/box.ts
-var BOX_SCHEMA = createSchema({
-  code: "sidebar",
-  kind: "element",
-  tag: SIDEBAR_TAG,
-  requiredAttributes: [
-    ...ID_ATTRS,
-    {
-      name: "status",
-      values: ["box1", "box2", "box3", "box4", "box5"],
-      defaultValue: "box1"
-    }
-  ],
-  optionalAttributes: [
-    ...TRACK_CHANGES_ATTRS,
-    "xmlid",
-    {
-      name: "role",
-      values: ["add-element", "change-para-box"],
-      defaultValue: "add-element"
-    }
-  ],
-  defaultChildCode: "para",
-  allowedChildrenCodes: [
-    { code: "para", required: false },
-    { code: "title1", required: false }
+    { code: "source1", required: false },
+    { code: "tag", required: false }
   ]
 });
 
@@ -1972,7 +2043,10 @@ var EPIGRAPH_SCHEMA = createSchema({
     }
   ],
   defaultChildCode: "para",
-  allowedChildrenCodes: [{ code: "para", required: false }]
+  allowedChildrenCodes: [
+    { code: "para", required: false },
+    { code: "tag", required: false }
+  ]
 });
 
 // src/schema/elementSchemas/elements/footnoteSection.ts
@@ -2002,51 +2076,6 @@ var FOOTNOTE_SECTION_SCHEMA = createSchema({
   ]
 });
 
-// src/schema/elementSchemas/elements/heading.ts
-var HEADING_LEVEL = ["H0", "H1", "H2", "H3", "H4", "H5", "H6"];
-var HEADING_ROLES = [...HEADING_LEVEL, "vignette_group"];
-var HEADING_SCHEMA = createSchema({
-  code: "heading",
-  kind: "element",
-  tag: SECTION_TAG,
-  matchesElement: (element) => {
-    const role = element.getAttribute("role");
-    if (!role) return false;
-    return HEADING_ROLES.includes(role);
-  },
-  requiredAttributes: [
-    ...ID_ATTRS,
-    "xmlid",
-    {
-      name: "role",
-      values: HEADING_ROLES,
-      defaultValue: "H1"
-    }
-  ],
-  optionalAttributes: [...TRACK_CHANGES_ATTRS],
-  defaultChildCode: "para",
-  allowedChildrenCodes: [
-    { code: "title1", required: false },
-    { code: "label1", required: false },
-    { code: "para", required: false },
-    { code: "subtitle1", required: false },
-    { code: "sidebar", required: false },
-    { code: "epigraph", required: false },
-    { code: "blockquote", required: false },
-    { code: "ul", required: false },
-    { code: "ol", required: false },
-    { code: "poem", required: false },
-    { code: "dialogue", required: false },
-    { code: "appendix", required: false },
-    { code: "table1", required: false },
-    { code: "figure1", required: false },
-    { code: "heading", required: false },
-    { code: "footnoteSection", required: false },
-    { code: "info1", required: false },
-    { code: "equation", required: false }
-  ]
-});
-
 // src/schema/elementSchemas/elements/info.ts
 var INFO_SCHEMA = createSchema({
   code: "info1",
@@ -2091,28 +2120,6 @@ var MATHPHRASE_SCHEMA = createSchema({
   allowedChildrenCodes: [{ code: MATH_SCHEMA.code, required: true }]
 });
 
-// src/schema/elementSchemas/elements/reference/bibliodiv.ts
-var BIBLIODIV_SCHEMA = createSchema({
-  code: "bibliodiv",
-  kind: "element",
-  tag: BIBLIODIV_TAG,
-  requiredAttributes: [
-    ...ID_ATTRS,
-    {
-      name: "role",
-      values: ["H1", "H2", "H3", "H4", "H5", "H6"],
-      defaultValue: "H1"
-    }
-  ],
-  optionalAttributes: [],
-  allowedChildrenCodes: [
-    { code: "bibliodiv", required: false },
-    { code: "referenceBibliomixed", required: false },
-    { code: "para", required: false },
-    { code: "title1", required: false }
-  ]
-});
-
 // src/schema/elementSchemas/elements/reference/bibliography.ts
 var REFERENCE_BIBLIOGRAPHY_SCHEMA = createSchema({
   code: "referenceBibliography",
@@ -2141,6 +2148,31 @@ var REFERENCE_BIBLIOGRAPHY_SCHEMA = createSchema({
   ]
 });
 
+// src/schema/shared/allowedReferenceChildren.ts
+var REFERENCE_PART_CODES_ALLOWED_CHILDREN = [
+  { code: "author", required: false },
+  { code: "editor", required: false },
+  { code: "othercredit", required: false },
+  { code: "translator", required: false },
+  { code: "collab", required: false },
+  { code: "title1", required: false },
+  { code: "pubdate", required: false },
+  { code: "date", required: false },
+  { code: "publishername", required: false },
+  { code: "orgname", required: false },
+  { code: "address", required: false },
+  { code: "volumenum", required: false },
+  { code: "issuenum", required: false },
+  { code: "pagenums", required: false },
+  { code: "pagenum", required: false },
+  { code: "edition", required: false },
+  { code: "link", required: false },
+  { code: "pubId", required: false },
+  { code: "biblioid", required: false },
+  { code: "bibliomisc", required: false },
+  { code: "confgroup", required: false }
+];
+
 // src/schema/elementSchemas/elements/reference/bibliomixed.ts
 var BIBLIOMIXED_SCHEMA = createSchema({
   code: "referenceBibliomixed",
@@ -2152,82 +2184,390 @@ var BIBLIOMIXED_SCHEMA = createSchema({
     TRACK_CHANGES_ATTR_DATA_USERID,
     TRACK_CHANGES_ATTR_DATA_DATE
   ],
-  allowedChildrenCodes: []
+  allowedChildrenCodes: [
+    { code: "bibliomset", required: false },
+    ...REFERENCE_PART_CODES_ALLOWED_CHILDREN,
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
 });
 
-// src/schema/elementSchemas/elements/index.ts
-var ELEMENT_SCHEMAS = {
-  bibliodiv: BIBLIODIV_SCHEMA,
-  referenceBibliography: REFERENCE_BIBLIOGRAPHY_SCHEMA,
-  referenceBibliomixed: BIBLIOMIXED_SCHEMA,
-  para: PARA_SCHEMA,
-  title1: TITLE_SCHEMA,
-  footnote: FOOTNOTE_SCHEMA,
-  footnoteno: FOOTNOTE_NUMBER_SCHEMA,
-  olink: OLINK_SCHEMA,
-  firstname: FIRSTNAME_SCHEMA,
-  surname: SURNAME_SCHEMA,
-  honorific: HONORIFIC_SCHEMA,
-  orgname: ORGNAME_SCHEMA,
-  email: EMAIL_SCHEMA,
-  org: ORG_SCHEMA,
-  degrees: DEGREES_SCHEMA,
-  dialogue: DIALOGUE_SCHEMA,
-  line: LINE_SCHEMA,
-  linegroup: LINE_GROUP_SCHEMA,
-  speaker: SPEAKER_SCHEMA,
-  equation: EQUATION_SCHEMA,
-  math: MATH_SCHEMA,
-  mathphrase: MATHPHRASE_SCHEMA,
-  merror: MERROR_SCHEMA,
-  mfrac: MFRAC_SCHEMA,
-  mi: MI_SCHEMA,
-  mmultiscripts: MMULTISCRIPTS_SCHEMA,
-  mn: MN_SCHEMA,
-  mo: MO_SCHEMA,
-  mover: MOVER_SCHEMA,
-  mpadded: MPADDED_SCHEMA,
-  mphantom: MPHANTOM_SCHEMA,
-  mprescripts: MPRESCRIPTS_SCHEMA,
-  mroot: MROOT_SCHEMA,
-  mrow: MROW_SCHEMA,
-  ms: MS_SCHEMA,
-  mspace: MSPACE_SCHEMA,
-  msqrt: MSQRT_SCHEMA,
-  mstyle: MSTYLE_SCHEMA,
-  msub: MSUB_SCHEMA,
-  msubsup: MSUBSUP_SCHEMA,
-  msup: MSUP_SCHEMA,
-  mtable: MTABLE_SCHEMA,
-  mtd: MTD_SCHEMA,
-  mtext: MTEXT_SCHEMA,
-  mtr: MTR_SCHEMA,
-  munder: MUNDER_SCHEMA,
-  munderover: MUNDEROVER_SCHEMA,
-  img: IMG_SCHEMA,
-  alttext: ALTTEXT_SCHEMA,
-  imageobject: IMAGEOBJECT_SCHEMA,
-  mediaobject: MEDIAOBJECT_SCHEMA,
-  caption1: CAPTION_SCHEMA,
-  figsource: FIGSOURCE_SCHEMA,
-  fignote: FIGNOTE_SCHEMA,
-  figure1: FIGURE_SCHEMA,
-  informalfigure: INFORMALFIGURE_SCHEMA,
-  keywordset: KEYWORDSET_SCHEMA,
-  keyword: KEYWORD_SCHEMA,
-  punc: PUNC_SCHEMA,
-  label1: LABEL_SCHEMA,
-  li: LI_SCHEMA,
-  ol: OL_SCHEMA,
-  ul: UL_SCHEMA,
-  token: TOKEN_SCHEMA,
-  tag: TAG_SCHEMA,
-  lrh: LRH_SCHEMA,
-  rrh: RRH_SCHEMA,
-  source1: SOURCE_SCHEMA,
-  subtitle1: SUBTITLE_SCHEMA,
-  table1: TABLE_SCHEMA,
-  tgroup: TGROUP_SCHEMA,
+// src/schema/elementSchemas/elements/reference/bibliodiv.ts
+var BIBLIODIV_SCHEMA = createSchema({
+  code: "bibliodiv",
+  kind: "element",
+  tag: BIBLIODIV_TAG,
+  requiredAttributes: [
+    ...ID_ATTRS,
+    "role"
+  ],
+  optionalAttributes: [],
+  allowedChildrenCodes: [
+    { code: "bibliodiv", required: false },
+    { code: "referenceBibliomixed", required: false },
+    { code: "para", required: false },
+    { code: "title1", required: false }
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/bibliomset.ts
+var CONTAINER_BIBLIOMSET_RELATIONS = ["book", "journal"];
+var PART_BIBLIOMSET_RELATION = "part";
+var BIBLIOMSET_SCHEMA = createSchema({
+  code: "bibliomset",
+  kind: "element",
+  tag: BIBLIOMSET_TAG,
+  requiredAttributes: [
+    {
+      name: "relation",
+      values: [
+        PART_BIBLIOMSET_RELATION,
+        "article",
+        ...CONTAINER_BIBLIOMSET_RELATIONS
+      ],
+      defaultValue: PART_BIBLIOMSET_RELATION
+    }
+  ],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...REFERENCE_PART_CODES_ALLOWED_CHILDREN,
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/editor.ts
+var EDITOR_SCHEMA = createSchema({
+  code: "editor",
+  kind: "element",
+  tag: EDITOR_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    { code: "personname", required: false },
+    { code: "orgname", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/othercredit.ts
+var OTHERCREDIT_SCHEMA = createSchema({
+  code: "othercredit",
+  kind: "element",
+  tag: OTHERCREDIT_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS, "class", "otherclass"],
+  allowedChildrenCodes: [
+    { code: "personname", required: false },
+    { code: "orgname", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/translator.ts
+var TRANSLATOR_SCHEMA = createSchema({
+  code: "translator",
+  kind: "element",
+  tag: TRANSLATOR_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    { code: "personname", required: false },
+    { code: "orgname", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/collab.ts
+var COLLAB_SCHEMA = createSchema({
+  code: "collab",
+  kind: "element",
+  tag: COLLAB_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    { code: "orgname", required: false },
+    { code: "personname", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/pubdate.ts
+var PUBDATE_SCHEMA = createSchema({
+  code: "pubdate",
+  kind: "element",
+  tag: PUBDATE_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/date.ts
+var ACCESSED_DATE_ROLE = "accessed";
+var DATE_SCHEMA = createSchema({
+  code: "date",
+  kind: "element",
+  tag: DATE_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS, "role"],
+  allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
+});
+
+// src/schema/elementSchemas/elements/reference/publishername.ts
+var PUBLISHERNAME_SCHEMA = createSchema({
+  code: "publishername",
+  kind: "element",
+  tag: PUBLISHERNAME_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/address.ts
+var ADDRESS_SCHEMA = createSchema({
+  code: "address",
+  kind: "element",
+  tag: ADDRESS_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    { code: "city", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/city.ts
+var CITY_SCHEMA = createSchema({
+  code: "city",
+  kind: "element",
+  tag: CITY_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/volumenum.ts
+var VOLUMENUM_SCHEMA = createSchema({
+  code: "volumenum",
+  kind: "element",
+  tag: VOLUMENUM_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/issuenum.ts
+var ISSUENUM_SCHEMA = createSchema({
+  code: "issuenum",
+  kind: "element",
+  tag: ISSUENUM_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/pagenums.ts
+var PAGENUMS_SCHEMA = createSchema({
+  code: "pagenums",
+  kind: "element",
+  tag: PAGENUMS_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/pagenum.ts
+var PAGENUM_SCHEMA = createSchema({
+  code: "pagenum",
+  kind: "element",
+  tag: PAGENUM_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/edition.ts
+var EDITION_SCHEMA = createSchema({
+  code: "edition",
+  kind: "element",
+  tag: EDITION_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/pubId.ts
+var PUB_ID_SCHEMA = createSchema({
+  code: "pubId",
+  kind: "element",
+  tag: PUB_ID_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS, "pub-id-type", "assigning-authority"],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/helpers/matchesSchemaTag.ts
+var matchesSchemaTag = (element, tag) => element.tagName.toUpperCase() === tag.toUpperCase();
+
+// src/schema/elementSchemas/elements/reference/biblioid.ts
+var PUBMED_ID_BIBLIOID_CLASS = "other";
+var PUBMED_ID_BIBLIOID_OTHERCLASS = "pmid";
+var BIBLIOID_SCHEMA = createSchema({
+  code: "biblioid",
+  kind: "element",
+  tag: BIBLIOID_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS, "class", "otherclass"],
+  allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
+});
+var isPubMedIdBiblioid = (element) => matchesSchemaTag(element, BIBLIOID_TAG) && element.classList.contains(PUBMED_ID_BIBLIOID_CLASS) && element.getAttribute("otherclass") === PUBMED_ID_BIBLIOID_OTHERCLASS;
+
+// src/schema/elementSchemas/elements/reference/bibliomisc.ts
+var LEGAL_REFERENCE_BIBLIOMISC_ROLE = "legalRef";
+var BIBLIOMISC_SCHEMA = createSchema({
+  code: "bibliomisc",
+  kind: "element",
+  tag: BIBLIOMISC_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS, "role"],
+  allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
+});
+
+// src/schema/elementSchemas/elements/reference/confgroup.ts
+var CONFGROUP_SCHEMA = createSchema({
+  code: "confgroup",
+  kind: "element",
+  tag: CONFGROUP_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    { code: "conftitle", required: false },
+    { code: "address", required: false },
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/reference/conftitle.ts
+var CONFTITLE_SCHEMA = createSchema({
+  code: "conftitle",
+  kind: "element",
+  tag: CONFTITLE_TAG,
+  requiredAttributes: [],
+  optionalAttributes: [...ID_ATTRS],
+  allowedChildrenCodes: [
+    ...ATOM_CODES_ALLOWED_CHILDREN
+  ]
+});
+
+// src/schema/elementSchemas/elements/index.ts
+var ELEMENT_SCHEMAS = {
+  bibliodiv: BIBLIODIV_SCHEMA,
+  referenceBibliography: REFERENCE_BIBLIOGRAPHY_SCHEMA,
+  referenceBibliomixed: BIBLIOMIXED_SCHEMA,
+  bibliomset: BIBLIOMSET_SCHEMA,
+  editor: EDITOR_SCHEMA,
+  othercredit: OTHERCREDIT_SCHEMA,
+  translator: TRANSLATOR_SCHEMA,
+  collab: COLLAB_SCHEMA,
+  pubdate: PUBDATE_SCHEMA,
+  date: DATE_SCHEMA,
+  publishername: PUBLISHERNAME_SCHEMA,
+  address: ADDRESS_SCHEMA,
+  city: CITY_SCHEMA,
+  volumenum: VOLUMENUM_SCHEMA,
+  issuenum: ISSUENUM_SCHEMA,
+  pagenums: PAGENUMS_SCHEMA,
+  pagenum: PAGENUM_SCHEMA,
+  edition: EDITION_SCHEMA,
+  pubId: PUB_ID_SCHEMA,
+  biblioid: BIBLIOID_SCHEMA,
+  bibliomisc: BIBLIOMISC_SCHEMA,
+  confgroup: CONFGROUP_SCHEMA,
+  conftitle: CONFTITLE_SCHEMA,
+  para: PARA_SCHEMA,
+  title1: TITLE_SCHEMA,
+  footnote: FOOTNOTE_SCHEMA,
+  footnoteno: FOOTNOTE_NUMBER_SCHEMA,
+  olink: OLINK_SCHEMA,
+  firstname: FIRSTNAME_SCHEMA,
+  surname: SURNAME_SCHEMA,
+  honorific: HONORIFIC_SCHEMA,
+  orgname: ORGNAME_SCHEMA,
+  email: EMAIL_SCHEMA,
+  org: ORG_SCHEMA,
+  degrees: DEGREES_SCHEMA,
+  dialogue: DIALOGUE_SCHEMA,
+  line: LINE_SCHEMA,
+  linegroup: LINE_GROUP_SCHEMA,
+  speaker: SPEAKER_SCHEMA,
+  equation: EQUATION_SCHEMA,
+  math: MATH_SCHEMA,
+  mathphrase: MATHPHRASE_SCHEMA,
+  merror: MERROR_SCHEMA,
+  mfrac: MFRAC_SCHEMA,
+  mi: MI_SCHEMA,
+  mmultiscripts: MMULTISCRIPTS_SCHEMA,
+  mn: MN_SCHEMA,
+  mo: MO_SCHEMA,
+  mover: MOVER_SCHEMA,
+  mpadded: MPADDED_SCHEMA,
+  mphantom: MPHANTOM_SCHEMA,
+  mprescripts: MPRESCRIPTS_SCHEMA,
+  mroot: MROOT_SCHEMA,
+  mrow: MROW_SCHEMA,
+  ms: MS_SCHEMA,
+  mspace: MSPACE_SCHEMA,
+  msqrt: MSQRT_SCHEMA,
+  mstyle: MSTYLE_SCHEMA,
+  msub: MSUB_SCHEMA,
+  msubsup: MSUBSUP_SCHEMA,
+  msup: MSUP_SCHEMA,
+  mtable: MTABLE_SCHEMA,
+  mtd: MTD_SCHEMA,
+  mtext: MTEXT_SCHEMA,
+  mtr: MTR_SCHEMA,
+  munder: MUNDER_SCHEMA,
+  munderover: MUNDEROVER_SCHEMA,
+  img: IMG_SCHEMA,
+  alttext: ALTTEXT_SCHEMA,
+  imageobject: IMAGEOBJECT_SCHEMA,
+  mediaobject: MEDIAOBJECT_SCHEMA,
+  caption1: CAPTION_SCHEMA,
+  figsource: FIGSOURCE_SCHEMA,
+  fignote: FIGNOTE_SCHEMA,
+  figure1: FIGURE_SCHEMA,
+  informalfigure: INFORMALFIGURE_SCHEMA,
+  keywordset: KEYWORDSET_SCHEMA,
+  keyword: KEYWORD_SCHEMA,
+  punc: PUNC_SCHEMA,
+  label1: LABEL_SCHEMA,
+  li: LI_SCHEMA,
+  ol: OL_SCHEMA,
+  ul: UL_SCHEMA,
+  token: TOKEN_SCHEMA,
+  tag: TAG_SCHEMA,
+  lrh: LRH_SCHEMA,
+  rrh: RRH_SCHEMA,
+  source1: SOURCE_SCHEMA,
+  subtitle1: SUBTITLE_SCHEMA,
+  table1: TABLE_SCHEMA,
+  tgroup: TGROUP_SCHEMA,
   table: HTML_TABLE_SCHEMA,
   thead: THEAD_SCHEMA,
   tbody: TBODY_SCHEMA,
@@ -2299,7 +2639,10 @@ var INLINEEQUATION_SCHEMA = createSchema({
       defaultValue: "added"
     }
   ],
-  allowedChildrenCodes: [{ code: "mathphrase", required: true }]
+  allowedChildrenCodes: [
+    { code: "mathphrase", required: true },
+    { code: "tag", required: false }
+  ]
 });
 
 // src/schema/elementSchemas/inlineElements/link.ts
@@ -2386,16 +2729,20 @@ var findAttributeDefinitionByName = (definitions, name) => {
 // src/schema/helpers/findSchemaByCode.ts
 var findSchemaByCode = (code) => SCHEMAS[code];
 
-// src/schema/helpers/matchesSchemaTag.ts
-var matchesSchemaTag = (element, tag) => element.tagName.toUpperCase() === tag.toUpperCase();
-
 // src/schema/helpers/findSchemaByElement.ts
-var findSchemaByElement = (element) => {
-  const schema = Object.values(SCHEMAS).find(
-    (schema2) => matchesSchemaTag(element, schema2.tag) && (!schema2.matchesElement || schema2.matchesElement(element))
-  );
-  return schema;
+var schemasByTag;
+var getSchemasByTag = () => {
+  if (schemasByTag) return schemasByTag;
+  schemasByTag = /* @__PURE__ */ new Map();
+  for (const schema of Object.values(SCHEMAS)) {
+    const tag = schema.tag.toUpperCase();
+    const schemas = schemasByTag.get(tag);
+    if (schemas) schemas.push(schema);
+    else schemasByTag.set(tag, [schema]);
+  }
+  return schemasByTag;
 };
+var findSchemaByElement = (element) => getSchemasByTag().get(element.tagName.toUpperCase())?.find((schema) => !schema.matchesElement || schema.matchesElement(element));
 
 // src/schema/helpers/isAttributeRestricted.ts
 var isAttributeRestricted = (attr) => typeof attr !== "string";
@@ -2403,12 +2750,402 @@ var isAttributeRestricted = (attr) => typeof attr !== "string";
 // src/schema/helpers/isTrackChangesSchema.ts
 var isTrackChangesSchema = (schema) => schema.code === "insertion" || schema.code === "deletion" || schema.code === "lineGroupRemoval";
 
+// src/schema/referenceSchemas/referenceTypeSchemas.ts
+var LINK_FIELDS = ["doi", "url"];
+var OTHER_MATERIAL_FIELDS = [
+  "author",
+  "editor",
+  "title",
+  "year",
+  "containerTitle",
+  "publisherPlace",
+  "publisher",
+  "volume",
+  "issue",
+  "pages",
+  "accessDate",
+  "genre",
+  "eventTitle",
+  "eventPlace",
+  "documentNumber",
+  "pubmedId",
+  ...LINK_FIELDS
+];
+var REFERENCE_TYPE_SCHEMAS = {
+  monograph: {
+    code: "monograph",
+    label: "Book",
+    legacyRoles: ["book"],
+    allowedFields: [
+      "author",
+      "editor",
+      "title",
+      "year",
+      "volume",
+      "publisherPlace",
+      "publisher",
+      ...LINK_FIELDS
+    ],
+    requiredFields: ["title", "creators"],
+    fieldLabels: { title: "Book title" }
+  },
+  serial: {
+    code: "serial",
+    label: "Journal issue",
+    legacyRoles: [],
+    allowedFields: ["title", "year", "volume", "issue", ...LINK_FIELDS],
+    requiredFields: ["title"]
+  },
+  contribution: {
+    code: "contribution",
+    label: "Contributed book",
+    legacyRoles: ["chapter"],
+    allowedFields: [
+      "author",
+      "editor",
+      "title",
+      "year",
+      "containerTitle",
+      "publisherPlace",
+      "publisher",
+      "pages",
+      ...LINK_FIELDS
+    ],
+    requiredFields: ["title", "containerTitle", "creators"],
+    bibliomsetRelations: ["part", "book"],
+    fieldLabels: { title: "Chapter title", containerTitle: "Book title" }
+  },
+  article: {
+    code: "article",
+    label: "Journal article",
+    legacyRoles: ["journal", "article-journal"],
+    allowedFields: [
+      "author",
+      "editor",
+      "title",
+      "year",
+      "containerTitle",
+      "volume",
+      "issue",
+      "pages",
+      "genre",
+      "publisher",
+      "publisherPlace",
+      "pubmedId",
+      "accessDate",
+      ...LINK_FIELDS
+    ],
+    requiredFields: ["title", "containerTitle"],
+    bibliomsetRelations: ["article", "journal"],
+    fieldLabels: { title: "Article title", containerTitle: "Journal title" }
+  },
+  message: {
+    code: "message",
+    label: "Email message",
+    legacyRoles: [],
+    allowedFields: ["author", "title", "year", ...LINK_FIELDS],
+    requiredFields: ["title"]
+  },
+  website: {
+    code: "website",
+    label: "Website",
+    legacyRoles: [],
+    allowedFields: ["author", "title", "year", "accessDate", ...LINK_FIELDS],
+    requiredFields: ["title"]
+  },
+  unpublished: {
+    code: "unpublished",
+    label: "Unpublished material",
+    legacyRoles: [],
+    allowedFields: [
+      "author",
+      "title",
+      "year",
+      "publisher",
+      "genre",
+      "eventTitle",
+      "eventPlace",
+      ...LINK_FIELDS
+    ],
+    requiredFields: ["title"],
+    replacedElements: [
+      { tag: "pubdate", replacement: "date" },
+      { tag: "publishername", replacement: "orgname" }
+    ]
+  },
+  case: {
+    code: "case",
+    label: "Case",
+    legacyRoles: [],
+    allowedFields: ["title", "year", "documentNumber", ...LINK_FIELDS],
+    requiredFields: ["title"]
+  },
+  legislation: {
+    code: "legislation",
+    label: "Legislation",
+    legacyRoles: [],
+    allowedFields: [
+      "title",
+      "year",
+      "documentNumber",
+      "publisherPlace",
+      ...LINK_FIELDS
+    ],
+    requiredFields: ["title"]
+  },
+  other: {
+    code: "other",
+    label: "Other material",
+    legacyRoles: [],
+    allowedFields: OTHER_MATERIAL_FIELDS,
+    requiredFields: ["title"]
+  },
+  recording: {
+    code: "recording",
+    label: "Recording",
+    legacyRoles: [],
+    allowedFields: ["author", "title", "year", ...LINK_FIELDS],
+    requiredFields: ["title", "year"],
+    replacedElements: [{ tag: "author", replacement: "othercredit" }]
+  },
+  film: {
+    code: "film",
+    label: "Film",
+    legacyRoles: [],
+    allowedFields: ["title", "year", ...LINK_FIELDS],
+    requiredFields: ["title"]
+  }
+};
+
+// src/schema/helpers/findReferenceTypeSchemaByElement.ts
+var findReferenceTypeSchemaByElement = (reference) => {
+  const role = reference.getAttribute("role")?.trim().toLowerCase() ?? "";
+  const schemas = Object.values(REFERENCE_TYPE_SCHEMAS);
+  return schemas.find(
+    (schema) => schema.code === role || schema.legacyRoles.includes(role)
+  );
+};
+
+// src/helpers/isDeletedElement.ts
+var isDeletedElement = (element) => {
+  return !!closestElementBySchema({
+    element,
+    code: "deletion"
+  });
+};
+
+// src/helpers/closestElementBySchema.ts
+var closestElementBySchema = ({
+  element,
+  code,
+  ignoreDeletedElements = false
+}) => {
+  const schema = findSchemaByCode(code);
+  if (!schema) return;
+  const closestElement = element.closest(
+    schema.tag.toLowerCase()
+  );
+  if (!closestElement) return;
+  if (schema.matchesElement && !schema.matchesElement(closestElement)) {
+    return;
+  }
+  if (ignoreDeletedElements && isDeletedElement(closestElement)) {
+    return closestElementBySchema({
+      element: closestElement,
+      code,
+      ignoreDeletedElements
+    });
+  }
+  return closestElement;
+};
+
+// src/helpers/isInTrackedDeletion.ts
+var isInTrackedDeletion = (element) => !!element.closest("span.del");
+
+// src/helpers/hasLiveUri.ts
+var hasLiveUri = (link) => Array.from(link.querySelectorAll("uri")).some(
+  (uri) => !isInTrackedDeletion(uri)
+);
+
+// src/schema/helpers/findReferenceFieldByElement.ts
+var isContainerTitle = (title) => {
+  const relation = closestElementBySchema({
+    element: title,
+    code: "bibliomset"
+  })?.getAttribute("relation");
+  return CONTAINER_BIBLIOMSET_RELATIONS.some(
+    (containerRelation) => containerRelation === relation
+  );
+};
+var isUnpublishedReference = (element) => {
+  const reference = closestElementBySchema({
+    element,
+    code: "referenceBibliomixed"
+  });
+  return !!reference && findReferenceTypeSchemaByElement(reference)?.code === "unpublished";
+};
+var hasAcceptedChild = (element, tag) => Array.from(element.querySelectorAll(tag.toLowerCase())).some(
+  (child) => !isInTrackedDeletion(child)
+);
+var isConferenceDates = (confgroup) => hasAcceptedChild(confgroup, CONFDATES_TAG) && !hasAcceptedChild(confgroup, CONFTITLE_TAG);
+var findReferenceFieldByElement = (element) => {
+  switch (findSchemaByElement(element)?.code) {
+    case "author":
+    case "othercredit":
+      return "author";
+    case "editor":
+      return "editor";
+    case "title1":
+      return isContainerTitle(element) ? "containerTitle" : "title";
+    case "pubdate":
+      return "year";
+    case "date":
+      return element.getAttribute("role") === ACCESSED_DATE_ROLE ? "accessDate" : "year";
+    case "publishername":
+    case "orgname":
+      return "publisher";
+    case "address":
+      return isUnpublishedReference(element) ? "eventPlace" : "publisherPlace";
+    case "volumenum":
+      return "volume";
+    case "issuenum":
+      return "issue";
+    case "pagenums":
+      return "pages";
+    case "link":
+      if (element.hasAttribute(LINKEND_ATTRIBUTE)) return void 0;
+      return hasLiveUri(element) ? "url" : "doi";
+    case "bibliomisc":
+      return element.getAttribute("role") === LEGAL_REFERENCE_BIBLIOMISC_ROLE ? "documentNumber" : "genre";
+    case "confgroup":
+      return isConferenceDates(element) ? "year" : "eventTitle";
+    case "biblioid":
+      return isPubMedIdBiblioid(element) ? "pubmedId" : void 0;
+    default:
+      return void 0;
+  }
+};
+
+// src/schema/referenceSchemas/referenceFieldSchemas.ts
+var REFERENCE_FIELD_SCHEMAS = {
+  author: {
+    code: "author",
+    label: "Author",
+    elementCodes: ["author", "othercredit"]
+  },
+  editor: {
+    code: "editor",
+    label: "Editor",
+    elementCodes: ["editor"]
+  },
+  title: {
+    code: "title",
+    label: "Title",
+    elementCodes: ["title1"]
+  },
+  year: {
+    code: "year",
+    label: "Date",
+    elementCodes: ["pubdate", "date", "confgroup"]
+  },
+  containerTitle: {
+    code: "containerTitle",
+    label: "Container title",
+    elementCodes: ["title1"]
+  },
+  publisherPlace: {
+    code: "publisherPlace",
+    label: "Publisher place",
+    elementCodes: ["address"]
+  },
+  publisher: {
+    code: "publisher",
+    label: "Publisher or institution",
+    elementCodes: ["publishername", "orgname"]
+  },
+  volume: {
+    code: "volume",
+    label: "Volume",
+    elementCodes: ["volumenum"]
+  },
+  issue: {
+    code: "issue",
+    label: "Issue",
+    elementCodes: ["issuenum"]
+  },
+  pages: {
+    code: "pages",
+    label: "Pages",
+    elementCodes: ["pagenums"]
+  },
+  doi: {
+    code: "doi",
+    label: "DOI",
+    elementCodes: ["link"]
+  },
+  url: {
+    code: "url",
+    label: "URL",
+    elementCodes: ["link"]
+  },
+  accessDate: {
+    code: "accessDate",
+    label: "Access date",
+    elementCodes: ["date"]
+  },
+  genre: {
+    code: "genre",
+    label: "Description",
+    elementCodes: ["bibliomisc"]
+  },
+  eventTitle: {
+    code: "eventTitle",
+    label: "Conference title",
+    elementCodes: ["confgroup"]
+  },
+  eventPlace: {
+    code: "eventPlace",
+    label: "Conference place",
+    elementCodes: ["address"]
+  },
+  documentNumber: {
+    code: "documentNumber",
+    label: "Legal reference",
+    elementCodes: ["bibliomisc"]
+  },
+  pubmedId: {
+    code: "pubmedId",
+    label: "PubMed ID",
+    elementCodes: ["biblioid"]
+  }
+};
+
 // src/schema/shared/labelElements.ts
 var ElementLabel = {
   mark: "Mark",
   referenceBibliomixed: "Reference Bibliomixed",
   referenceBibliography: "Reference Bibliography",
   bibliodiv: "Bibliodiv",
+  bibliomset: "Reference Block",
+  editor: "Editor",
+  othercredit: "Other Credit",
+  translator: "Translator",
+  collab: "Collaborator",
+  pubdate: "Publication Date",
+  date: "Date",
+  publishername: "Publisher Name",
+  address: "Address",
+  city: "City",
+  volumenum: "Volume Number",
+  issuenum: "Issue Number",
+  pagenums: "Page Numbers",
+  pagenum: "Page Number",
+  edition: "Edition",
+  pubId: "Publication ID",
+  biblioid: "Bibliographic ID",
+  bibliomisc: "Reference Miscellany",
+  confgroup: "Conference",
+  conftitle: "Conference Title",
   indexterm: "Indexterm",
   primary: "Primary",
   secondary: "Secondary",
@@ -2549,46 +3286,15 @@ var IGNORED_ELEMENT_SELECTORS = [
   "span.ref-drag",
   "span#dummySpan"
 ];
-var isIgnoredElement = (element) => IGNORED_ELEMENT_SELECTORS.some((selector) => element.matches(selector));
+var IGNORED_ELEMENT_SELECTOR = IGNORED_ELEMENT_SELECTORS.join(", ");
+var isIgnoredElement = (element) => element.tagName.toUpperCase() === "SPAN" && element.matches(IGNORED_ELEMENT_SELECTOR);
 
 // src/validation/helpers/isIgnoredValidation.ts
 var IGNORED_VALIDATION_ELEMENT_SELECTORS = [
   "referenceBibliomixed"
 ];
 var isIgnoredValidation = (code) => IGNORED_VALIDATION_ELEMENT_SELECTORS.includes(code);
-
-// src/helpers/closestElementBySchema.ts
-var closestElementBySchema = ({
-  element,
-  code,
-  ignoreDeletedElements = false
-}) => {
-  const schema = findSchemaByCode(code);
-  if (!schema) return;
-  const closestElement = element.closest(
-    schema.tag.toLowerCase()
-  );
-  if (!closestElement) return;
-  if (schema.matchesElement && !schema.matchesElement(closestElement)) {
-    return;
-  }
-  if (ignoreDeletedElements && isDeletedElement(closestElement)) {
-    return closestElementBySchema({
-      element: closestElement,
-      code,
-      ignoreDeletedElements
-    });
-  }
-  return closestElement;
-};
-
-// src/helpers/isDeletedElement.ts
-var isDeletedElement = (element) => {
-  return !!closestElementBySchema({
-    element,
-    code: "deletion"
-  });
-};
+var isIgnoredValidationByAttribute = (element) => element.getAttribute(VALIDATION_IGNORED_ATTRIBUTE) === "true";
 
 // src/validation/utils/getElementsSelector.ts
 var getElementsSelector = ({
@@ -2626,12 +3332,14 @@ var generateValidationIssueId = () => {
 };
 
 // src/validation/helpers/addValidationIssue.ts
-var createValidationIssue = (issue) => ({
+var createValidationIssue = (element, issue) => ({
+  ...issue,
   id: generateValidationIssueId(),
-  ...issue
+  store: element ? getStore(element) : issue.store,
+  ignored: element ? isIgnoredValidationByAttribute(element) : false
 });
-var addValidationIssue = (errors, issue) => {
-  errors.push(createValidationIssue(issue));
+var addValidationIssue = (errors, element, issue) => {
+  errors.push(createValidationIssue(element, issue));
 };
 
 // src/validation/validateFootnotes.ts
@@ -2650,8 +3358,7 @@ var validateFootnoteNumber = (footnoteElement) => {
     FOOTNOTE_NUMBER_SCHEMA.tag
   );
   if (!footnoteNumber) {
-    addValidationIssue(errors, {
-      store: getStore(footnoteElement),
+    addValidationIssue(errors, footnoteElement, {
       title: "Footnote number missing",
       kind: "missing",
       description: "The footnote number is missing. Please add it to the footnote.",
@@ -2682,8 +3389,7 @@ var validateConsecutiveFootnotes = (root) => {
         );
         if (!footnoteNumberElement) {
           errors.push(
-            createValidationIssue({
-              store: getStore(footnote),
+            createValidationIssue(footnote, {
               title: "Footnote number missing",
               kind: "missing",
               description: "The footnote number is missing. Please add it to the footnote.",
@@ -2696,8 +3402,7 @@ var validateConsecutiveFootnotes = (root) => {
           continue;
         }
         errors.push(
-          createValidationIssue({
-            store: getStore(footnote),
+          createValidationIssue(footnote, {
             title: "Non-consecutive footnote numbers",
             kind: "missing",
             description: `Footnote numbers must be consecutive, footnote number (${label}) expected to be (${expectedNumber}). Please reorder the footnotes.`,
@@ -2728,8 +3433,7 @@ var validateConsecutiveFootnoteCues = (root) => {
         continue;
       }
       errors.push(
-        createValidationIssue({
-          store: getStore(footnoteLink),
+        createValidationIssue(footnoteLink, {
           title: "Non-consecutive footnote cues",
           kind: "missing",
           description: "Footnote cues must be consecutive. Please reorder the footnote cues.",
@@ -2742,10 +3446,11 @@ var validateConsecutiveFootnoteCues = (root) => {
   return errors;
 };
 
+// src/validation/helpers/hasLinkId.ts
+var hasLinkId = (ids, id) => "has" in ids ? ids.has(id) : ids.includes(id);
+
 // src/validation/validateLinkend.ts
-var findElementLinkedTo = (linkend, elementsToLink) => {
-  return elementsToLink.includes(linkend);
-};
+var findElementLinkedTo = (linkend, elementsToLink) => hasLinkId(elementsToLink, linkend);
 var LINK_TO_CROSS_CHECK = [
   TABLE_LINK_ROLE,
   FIGURE_LINK_ROLE,
@@ -2773,8 +3478,7 @@ var validateLinkend = (linkElement, elementsToLink) => {
   );
   if (isLinkFootnoteCue) {
     return [
-      createValidationIssue({
-        store: getStore(linkElement),
+      createValidationIssue(linkElement, {
         title: "Unlinked footnote cue",
         kind: "unlinked",
         description: "This footnote cue is not referenced to any footnote in this chapter. Please link it again manually.",
@@ -2795,8 +3499,7 @@ var validateLinkend = (linkElement, elementsToLink) => {
   }
   const isBlocker = LINK_BLOCKER_ROLES.includes(role.toLowerCase());
   return [
-    createValidationIssue({
-      store: getStore(linkElement),
+    createValidationIssue(linkElement, {
       title: "Unlinked element",
       kind: "unlinked",
       description: "This link is not referenced to any element in the current chapter or any other chapter. Please link it again manually.",
@@ -2856,8 +3559,7 @@ var validateAttributes = (element, schema) => {
       continue;
     }
     if (!definition.values.includes(value)) {
-      addValidationIssue(errors, {
-        store: getStore(element),
+      addValidationIssue(errors, element, {
         title: `Invalid attribute value "${value}" in element ${element.tagName}`,
         level: "warning",
         kind: "forbidden",
@@ -2872,8 +3574,7 @@ var validateAttributes = (element, schema) => {
 var validateElementAgainstSchema = (element, schema) => {
   const errors = [];
   if (!matchesSchemaTag(element, schema.tag)) {
-    addValidationIssue(errors, {
-      store: getStore(element),
+    addValidationIssue(errors, element, {
       title: `Expected ${schema.tag}, got ${element.tagName}`,
       level: "warning",
       kind: "forbidden",
@@ -2903,8 +3604,7 @@ var validateRequiredChildren = (element, schema, childElements) => {
         `Please provide at least one ${elementLabel} in this ${parentLabel}.`,
         extraInstruction
       ].filter(Boolean).join(" ");
-      addValidationIssue(errors, {
-        store: getStore(element),
+      addValidationIssue(errors, element, {
         title: `${elementLabel} missing`,
         level: "warning",
         kind: "missing",
@@ -2938,8 +3638,7 @@ var validateChildren = (element, schema) => {
   for (const child of childElements) {
     const childSchema = findSchemaByElement(child);
     if (!childSchema) {
-      addValidationIssue(errors, {
-        store: getStore(child),
+      addValidationIssue(errors, child, {
         title: `No schema found for child element ${child.tagName}`,
         level: "warning",
         kind: "missing",
@@ -2951,8 +3650,7 @@ var validateChildren = (element, schema) => {
       (candidate) => candidate.code === childSchema.code
     );
     if (!allowedChild) {
-      addValidationIssue(errors, {
-        store: getStore(child),
+      addValidationIssue(errors, child, {
         title: `Forbidden child element ${child.tagName}`,
         level: "warning",
         kind: "forbidden",
@@ -2973,9 +3671,7 @@ var getExtraInstruction = (schema, childSchema) => {
 };
 
 // src/validation/validateElementToLinkTo.ts
-var findElementLinkedTo2 = (xmlid, linkElements) => {
-  return linkElements.includes(xmlid);
-};
+var findElementLinkedTo2 = (xmlid, linkElements) => hasLinkId(linkElements, xmlid);
 var isFootnote = (element) => {
   return matchesSchemaTag(element, FOOTNOTE_SCHEMA.tag);
 };
@@ -3002,8 +3698,7 @@ var validateElementToLinkTo = (element, linkElements) => {
   if (isFootnote(element)) {
     const label = extractFootnoteNumber(element);
     return [
-      createValidationIssue({
-        store: getStore(element),
+      createValidationIssue(element, {
         title: "Uncited footnote",
         kind: "uncited",
         description: `The footnote ${label} is not cited to any footnote cue in this chapter. Please reference it in the chapter.`,
@@ -3013,8 +3708,7 @@ var validateElementToLinkTo = (element, linkElements) => {
   }
   if (isReference(element)) {
     return [
-      createValidationIssue({
-        store: getStore(element),
+      createValidationIssue(element, {
         title: "Uncited reference",
         kind: "uncited",
         description: "This reference is not cited in this chapter or any other chapter. Please add a link to this reference or delete it.",
@@ -3024,8 +3718,7 @@ var validateElementToLinkTo = (element, linkElements) => {
   }
   if (isTable(element)) {
     return [
-      createValidationIssue({
-        store: getStore(element),
+      createValidationIssue(element, {
         title: "Uncited table",
         kind: "uncited",
         description: "This table is not cited in this chapter or any other chapter. Please add a link to this table or delete it.",
@@ -3035,8 +3728,7 @@ var validateElementToLinkTo = (element, linkElements) => {
   }
   if (isFigure(element)) {
     return [
-      createValidationIssue({
-        store: getStore(element),
+      createValidationIssue(element, {
         title: "Uncited figure",
         kind: "uncited",
         description: "This figure is not cited in this chapter or any other chapter. Please add a link to this figure or delete it.",
@@ -3049,9 +3741,20 @@ var validateElementToLinkTo = (element, linkElements) => {
 
 // src/validation/validateWeblink.ts
 import Mark from "mark.js";
+
+// src/validation/helpers/steps.ts
+var runSteps = (steps) => {
+  for (; ; ) {
+    const step = steps.next();
+    if (step.done) return step.value;
+  }
+};
+
+// src/validation/validateWeblink.ts
 var EDGE_PUNCTUATION = `:;.,\\-\u2013\u2014\u2012_(){}[\\]!'"+=\xAB\xBB\u2039\u203A\u201C\u201D\u2018\u2019<>`;
 var WEB_URI_PATTERN = `(?:(?:https?):\\/\\/|www\\.)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,}(?::\\d{1,5})?(?:\\/(?:[^\\s]*[^\\s${EDGE_PUNCTUATION}])?)?`;
 var WEB_URI_IN_TEXT_REGEX = new RegExp(WEB_URI_PATTERN, "gi");
+var POSSIBLE_WEBLINK_CLASS = "possible-weblink";
 var POSSIBLE_WEBLINK_EXCLUDE_SELECTORS = [
   "tag",
   "tag *",
@@ -3063,40 +3766,150 @@ var POSSIBLE_WEBLINK_EXCLUDE_SELECTORS = [
   "query *",
   "comment",
   "comment *",
+  `.${POSSIBLE_WEBLINK_CLASS}`,
+  `.${POSSIBLE_WEBLINK_CLASS} *`,
   ...IGNORED_ELEMENT_SELECTORS
 ];
-var collectPossibleWebLinks = (content) => {
-  const clone = content.cloneNode(true);
-  const possibleWebLinks = /* @__PURE__ */ new Set();
-  const instance = new Mark(clone);
+var getPossibleWeblinks = (root) => {
+  const possibleWeblinks = /* @__PURE__ */ new Map();
+  const allWeblinkMatches = Array.from(
+    root.getElementsByClassName(POSSIBLE_WEBLINK_CLASS)
+  );
+  for (const weblinkMatch of allWeblinkMatches) {
+    const storeId = weblinkMatch.getAttribute(STORE_ATTRIBUTE);
+    if (!storeId || possibleWeblinks.has(storeId)) continue;
+    const elements = allWeblinkMatches.filter(
+      (element) => element.getAttribute(STORE_ATTRIBUTE) === storeId
+    );
+    const weblink = elements.map((element) => element.textContent).join("");
+    possibleWeblinks.set(storeId, {
+      weblink,
+      elements
+    });
+  }
+  return possibleWeblinks;
+};
+var getWeblinkMatchId = (matchIndex) => `weblink-match-${matchIndex}`;
+var createWeblinkMatchTracker = () => {
+  const matchedText = [];
+  const matchedElements = [];
+  const possibleWeblinks = /* @__PURE__ */ new Map();
+  let matchIndex = 0;
+  let currentMatchId = getWeblinkMatchId(matchIndex);
+  const resetMatch = () => {
+    matchIndex += 1;
+    currentMatchId = getWeblinkMatchId(matchIndex);
+    matchedText.length = 0;
+    matchedElements.length = 0;
+  };
+  const composeWeblink = (element, url) => {
+    element.setAttribute(STORE_ATTRIBUTE, currentMatchId);
+    matchedText.push(element.textContent);
+    matchedElements.push(element);
+    if (matchedText.join("") !== url) return;
+    possibleWeblinks.set(currentMatchId, {
+      weblink: matchedText.join(""),
+      elements: [...matchedElements]
+    });
+    resetMatch();
+  };
+  return { composeWeblink, possibleWeblinks };
+};
+var markPossibleWeblinks = (editor) => {
+  const instance = new Mark(editor);
+  const { composeWeblink, possibleWeblinks } = createWeblinkMatchTracker();
+  let possibleWebLink = "";
   instance.markRegExp(WEB_URI_IN_TEXT_REGEX, {
+    className: POSSIBLE_WEBLINK_CLASS,
     acrossElements: false,
     exclude: POSSIBLE_WEBLINK_EXCLUDE_SELECTORS,
     filter: (_textNode, term) => {
-      possibleWebLinks.add(term);
+      possibleWebLink = term;
       return true;
-    }
+    },
+    each: (element) => composeWeblink(element, possibleWebLink)
   });
-  return possibleWebLinks;
+  return possibleWeblinks;
 };
-var validatePossibleWeblinks = (root) => {
-  const errors = [];
-  const possibleWebLinks = collectPossibleWebLinks(root);
-  for (const possibleWebLink of possibleWebLinks) {
-    errors.push(
-      createValidationIssue({
-        store: possibleWebLink,
+var TEXT_NODES_PER_STEP = 256;
+var MARK_EXCLUDED_PARENT_SELECTOR = [
+  ...POSSIBLE_WEBLINK_EXCLUDE_SELECTORS,
+  "script",
+  "style",
+  "title",
+  "head",
+  "html"
+].join(", ");
+var createWeblinkMatchElement = (ownerDocument, text, storeId) => {
+  const element = ownerDocument.createElement("mark");
+  element.setAttribute("data-markjs", "true");
+  element.setAttribute("class", POSSIBLE_WEBLINK_CLASS);
+  element.setAttribute(STORE_ATTRIBUTE, storeId);
+  element.textContent = text;
+  return element;
+};
+function* findPossibleWeblinks(root) {
+  const possibleWeblinks = /* @__PURE__ */ new Map();
+  const ownerDocument = root.ownerDocument;
+  const walker = ownerDocument.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const regex = new RegExp(WEB_URI_PATTERN, "gi");
+  let nodesSinceStep = 0;
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    if (++nodesSinceStep === TEXT_NODES_PER_STEP) {
+      nodesSinceStep = 0;
+      yield;
+    }
+    const text = node.textContent ?? "";
+    if (!text) continue;
+    const parent = node.parentNode;
+    if (parent instanceof Element && parent.matches(MARK_EXCLUDED_PARENT_SELECTOR)) {
+      continue;
+    }
+    regex.lastIndex = 0;
+    for (let match = regex.exec(text); match; match = regex.exec(text)) {
+      const storeId = getWeblinkMatchId(possibleWeblinks.size);
+      possibleWeblinks.set(storeId, {
+        weblink: match[0],
+        elements: [createWeblinkMatchElement(ownerDocument, match[0], storeId)]
+      });
+    }
+  }
+  return possibleWeblinks;
+}
+var hasWeblinkMatches = (root) => root.getElementsByClassName(POSSIBLE_WEBLINK_CLASS).length > 0;
+function* validatePossibleWeblinksSteps(root) {
+  const issues = [];
+  let possibleWeblinks;
+  if (hasWeblinkMatches(root)) {
+    const cloneRoot = root.cloneNode(true);
+    clearWeblinkMatches(cloneRoot);
+    possibleWeblinks = markPossibleWeblinks(cloneRoot);
+  } else {
+    possibleWeblinks = yield* findPossibleWeblinks(root);
+  }
+  for (const [storeId, { elements }] of Array.from(possibleWeblinks)) {
+    issues.push(
+      createValidationIssue(null, {
+        store: storeId,
         title: "Possible web link",
         kind: "possible-url",
         description: "This looks like a URL. Would you like to add weblink tags?",
-        level: "warning"
+        level: "info",
+        elements
       })
     );
   }
-  return errors;
+  return issues;
+}
+var validatePossibleWeblinks = (root) => runSteps(validatePossibleWeblinksSteps(root));
+var clearWeblinkMatches = (editor) => {
+  const instance = new Mark(editor);
+  instance.unmark({
+    className: POSSIBLE_WEBLINK_CLASS
+  });
 };
 
-// src/validation/validateHeadingHierarchy.ts
+// src/validation/validateHierarchy.ts
 var shouldSuppressWarning = (element) => {
   const closestBox = closestElementBySchema({
     element,
@@ -3105,46 +3918,66 @@ var shouldSuppressWarning = (element) => {
   });
   return !!closestBox;
 };
-var getHierarchyLevel = (element) => {
-  const role = element.getAttribute("role");
+var isHeading = (elementHierarchy) => {
+  return elementHierarchy === "heading";
+};
+var getValidLevels = (elementHierarchy) => {
+  return isHeading(elementHierarchy) ? HEADING_LEVEL : BOX_LEVEL;
+};
+var getAttributeName2 = (elementHierarchy) => {
+  return isHeading(elementHierarchy) ? "role" : "status";
+};
+var getElementSchemaCode = (elementHierarchy) => {
+  return isHeading(elementHierarchy) ? HEADING_SCHEMA.code : BOX_SCHEMA.code;
+};
+var getHierarchyLevel = (element, elementHierarchy) => {
+  const role = element.getAttribute(getAttributeName2(elementHierarchy));
   if (!role) return void 0;
-  const validHeadingLevel = HEADING_LEVEL.indexOf(role);
-  if (validHeadingLevel === -1) return void 0;
-  return validHeadingLevel;
+  const index = getValidLevels(elementHierarchy).indexOf(role);
+  if (index === -1) return void 0;
+  return isHeading(elementHierarchy) ? index : index + 1;
 };
-var validateHeadingHierarchy = (element) => {
+var validateHierarchy = (element, elementHierarchy) => {
   const errors = [];
   if (isDeletedElement(element)) {
     return errors;
   }
-  if (shouldSuppressWarning(element)) {
+  if (shouldSuppressWarning(element) && isHeading(elementHierarchy)) {
     return errors;
   }
-  const level = getHierarchyLevel(element);
+  const level = getHierarchyLevel(element, elementHierarchy);
   if (level === void 0) {
     return errors;
   }
   if (!element.parentElement) {
     return errors;
   }
-  const parentHeading = closestElementBySchema({
+  const parentElement = closestElementBySchema({
     element: element.parentElement,
-    code: HEADING_SCHEMA.code,
+    code: getElementSchemaCode(elementHierarchy),
     ignoreDeletedElements: true
   });
-  if (!parentHeading) {
+  if (!parentElement) {
     if (level > 1) {
-      addValidationIssue(errors, {
-        store: getStore(element),
-        title: "Missing heading H1",
-        kind: "missing",
-        description: `H${level} is not under an H1. Please check the heading hierarchy.`,
-        level: "warning"
-      });
+      if (isHeading(elementHierarchy)) {
+        addValidationIssue(errors, element, {
+          title: "Missing heading H1",
+          kind: "missing",
+          description: `H${level} is not under an H1. Please check the heading hierarchy.`,
+          level: "warning"
+        });
+      } else {
+        addValidationIssue(errors, element, {
+          title: "Missing box level 1",
+          kind: "missing",
+          description: `Box level ${level} is not under a box level. Please check the box hierarchy.`,
+          level: "warning"
+        });
+      }
     }
     return errors;
   }
-  const parentLevel = getHierarchyLevel(parentHeading);
+  const parentLevel = getHierarchyLevel(parentElement, elementHierarchy);
   if (parentLevel === void 0) {
     return errors;
   }
@@ -3152,13 +3985,21 @@ var validateHeadingHierarchy = (element) => {
   if (level === expectedLevel) {
     return errors;
   }
-  addValidationIssue(errors, {
-    store: getStore(element),
-    title: "Invalid heading hierarchy",
-    kind: "forbidden",
-    description: `H${level} cannot follow H${parentLevel} directly. Please check the heading hierarchy.`,
-    level: "warning"
-  });
+  if (isHeading(elementHierarchy)) {
+    addValidationIssue(errors, element, {
+      title: "Invalid heading hierarchy",
+      kind: "forbidden",
+      description: `H${level} cannot follow H${parentLevel} directly. Please check the heading hierarchy.`,
+      level: "warning"
+    });
+  } else {
+    addValidationIssue(errors, element, {
+      title: "Invalid box hierarchy",
+      kind: "forbidden",
+      description: `Box level ${level} cannot follow box level ${parentLevel} directly. Please check the box hierarchy.`,
+      level: "warning"
+    });
+  }
   return errors;
 };
 
@@ -3175,8 +4016,7 @@ var validateOlink = (element) => {
   if (isEmpty || isValidOrcid) {
     return errors;
   }
-  addValidationIssue(errors, {
-    store: getStore(element.parentElement ?? element),
+  addValidationIssue(errors, element, {
     title: "Invalid ORCID",
     kind: "forbidden",
     description: "The ORCiD is not the correct format. Please check it and adjust.",
@@ -3185,62 +4025,439 @@ var validateOlink = (element) => {
   return errors;
 };
 
+// src/helpers/getReferenceFieldElements.ts
+var REFERENCE_PART_SELECTOR = REFERENCE_PART_CODES_ALLOWED_CHILDREN.map(
+  ({ code }) => findSchemaByCode(code).tag.toLowerCase()
+).join(", ");
+var REFERENCE_PART_OWNER_SELECTOR = `${REFERENCE_PART_SELECTOR}, ${URI_SCHEMA.tag.toLowerCase()}`;
+var getReferenceParts = (reference) => Array.from(
+  reference.querySelectorAll(REFERENCE_PART_SELECTOR)
+).filter((element) => {
+  if (isInTrackedDeletion(element)) return false;
+  const owner = element.parentElement?.closest(REFERENCE_PART_OWNER_SELECTOR);
+  return !owner || !reference.contains(owner);
+});
+var getReferenceFieldElements = (reference) => getReferenceParts(reference).flatMap((element) => {
+  const field = findReferenceFieldByElement(element);
+  return field ? [{ field, element }] : [];
+});
+
+// src/validation/validateReferenceMarkup.ts
+var PERSONNAME_ORDER_ROLES = ["first-last", "last-first"];
+var ARTIST_OTHERCLASS = "artist";
+var NOT_PERMITTED_ELEMENTS = [
+  { tag: BIBLIOID_TAG.toLowerCase() },
+  { tag: "publisher" },
+  { tag: AUTHORGROUP_TAG.toLowerCase() }
+];
+var BIBLIOMSET = BIBLIOMSET_TAG.toLowerCase();
+var PERSONNAME = PERSONNAME_TAG.toLowerCase();
+var CONFGROUP = CONFGROUP_TAG.toLowerCase();
+var LINK = LINK_TAG.toLowerCase();
+var URI = URI_SCHEMA.tag.toLowerCase();
+var NAME_PARTS = [SURNAME_TAG, FIRSTNAME_TAG, HONORIFIC_TAG].map((tag) => tag.toLowerCase()).join(", ");
+var CONFERENCE_FIELDS_AND_DELETIONS = [
+  CONFTITLE_TAG,
+  CONFDATES_TAG,
+  ADDRESS_TAG
+].map((tag) => tag.toLowerCase()).concat("span.del").join(", ");
+var LOOSE_MARKUP = [
+  BIBLIOMSET,
+  PERSONNAME,
+  URI,
+  NAME_PARTS,
+  CONFDATES_TAG.toLowerCase()
+].concat(NOT_PERMITTED_ELEMENTS.map(({ tag }) => tag)).join(", ");
+var hasValue = (element, attribute) => !!element.getAttribute(attribute)?.trim();
+var hasUntaggedConferenceText = (element) => Array.from(element.childNodes).some((child) => {
+  if (child.nodeType === Node.TEXT_NODE) return !!child.textContent?.trim();
+  return child instanceof Element && !child.matches(CONFERENCE_FIELDS_AND_DELETIONS) && hasUntaggedConferenceText(child);
+});
+var isExternalLink = (link) => !hasValue(link, LINKEND_ATTRIBUTE);
+var DOI_URL = /^https?:\/\/(?:dx\.)?doi\.org\//i;
+var pointsAtDoiOrg = (link) => DOI_URL.test(link.getAttribute(LINK_ATTRIBUTE)?.trim() ?? "");
+var hasNameOrder = (personname) => {
+  const order = personname.getAttribute("role")?.replace(/\s+/g, "");
+  return PERSONNAME_ORDER_ROLES.some((role) => role === order);
+};
+var hasLooseReferenceMarkup = (reference) => Array.from(reference.querySelectorAll(LOOSE_MARKUP)).some(
+  (element) => !isInTrackedDeletion(element)
+);
+var validateReferenceMarkup = (reference, typeSchema) => {
+  const select = (selector) => Array.from(reference.querySelectorAll(selector)).filter(
+    (element) => !isInTrackedDeletion(element)
+  );
+  const relations = typeSchema.bibliomsetRelations ?? [];
+  const sets = select(BIBLIOMSET);
+  const misrelatedSets = sets.filter(
+    (set) => !relations.some((relation) => relation === set.getAttribute("relation"))
+  );
+  const hasEverySet = relations.every(
+    (relation) => sets.some((set) => set.getAttribute("relation") === relation)
+  );
+  const rules = {
+    missing_id: hasValue(reference, XMLID_ATTRIBUTE) ? [] : [reference],
+    bibliomset_relation: misrelatedSets,
+    bibliomset_missing: hasEverySet || misrelatedSets.length > 0 ? [] : [reference],
+    bibliomset_repeated: sets.filter(
+      (set, index) => sets.slice(0, index).some(
+        (earlier) => earlier.getAttribute("relation") === set.getAttribute("relation")
+      )
+    ),
+    bibliomset_title: sets.filter(
+      (set) => !Array.from(set.querySelectorAll(TITLE_TAG.toLowerCase())).some(
+        (title) => !isInTrackedDeletion(title)
+      )
+    ),
+    bibliomset_nested: sets.filter(
+      (set) => !!set.parentElement?.closest(BIBLIOMSET)
+    ),
+    part_editor: select(EDITOR_TAG.toLowerCase()).filter(
+      (editor) => editor.closest(BIBLIOMSET)?.getAttribute("relation") === PART_BIBLIOMSET_RELATION
+    ),
+    personname_role: select(PERSONNAME).filter(
+      (personname) => !hasNameOrder(personname)
+    ),
+    name_outside_personname: select(NAME_PARTS).filter(
+      (part) => !part.closest(PERSONNAME)
+    ),
+    othercredit_artist: typeSchema.code === "recording" ? select(OTHERCREDIT_TAG.toLowerCase()).filter(
+      (credit) => credit.getAttribute("otherclass") !== ARTIST_OTHERCLASS
+    ) : [],
+    link_without_target: select(LINK).filter(
+      (link) => isExternalLink(link) && !hasValue(link, LINK_ATTRIBUTE)
+    ),
+    doi_inside_uri: select(LINK).filter(
+      (link) => isExternalLink(link) && hasLiveUri(link) && pointsAtDoiOrg(link)
+    ),
+    doi_outside_doi_org: select(LINK).filter(
+      (link) => isExternalLink(link) && hasValue(link, LINK_ATTRIBUTE) && !hasLiveUri(link) && !pointsAtDoiOrg(link)
+    ),
+    uri_outside_link: select(URI).filter(
+      (uri) => !uri.closest(LINK) && !uri.closest(REFERENCE_PART_SELECTOR)
+    ),
+    confgroup_text: select(CONFGROUP).filter(hasUntaggedConferenceText),
+    confdates_outside_confgroup: select(CONFDATES_TAG.toLowerCase()).filter(
+      (dates) => !dates.closest(CONFGROUP)
+    )
+  };
+  const wrongElements = [
+    ...typeSchema.replacedElements ?? [],
+    ...NOT_PERMITTED_ELEMENTS
+  ].map(
+    ({ tag, replacement }) => ({
+      code: "wrong_element",
+      tag,
+      replacement,
+      elements: select(tag).filter((element) => !isPubMedIdBiblioid(element))
+    })
+  );
+  const markup = Object.entries(rules).map(
+    ([rule, elements]) => ({
+      code: "markup",
+      rule,
+      elements
+    })
+  );
+  return [...wrongElements, ...markup].filter(
+    ({ elements }) => elements.length > 0
+  );
+};
+
+// src/validation/validateReferenceStructure.ts
+var validateReferenceStructure = (reference) => {
+  const typeSchema = findReferenceTypeSchemaByElement(reference);
+  if (!typeSchema) return [{ code: "unknown_type" }];
+  const issues = [];
+  const present = /* @__PURE__ */ new Set();
+  for (const { field } of getReferenceFieldElements(reference)) {
+    if (!present.has(field) && !typeSchema.allowedFields.includes(field)) {
+      issues.push({ code: "not_allowed", field });
+    }
+    present.add(field);
+  }
+  for (const field of typeSchema.requiredFields) {
+    const isSatisfied = field === "creators" ? present.has("author") || present.has("editor") : present.has(field);
+    if (!isSatisfied) issues.push({ code: "missing", field });
+  }
+  return [...issues, ...validateReferenceMarkup(reference, typeSchema)];
+};
+var isSameMarkupIssue = (candidate, issue) => candidate.code === "markup" && issue.code === "markup" && candidate.rule === issue.rule || candidate.code === "wrong_element" && issue.code === "wrong_element" && candidate.tag === issue.tag;
+var getReferenceStructureIssueElements = (reference, issue) => {
+  if (issue.code === "not_allowed") {
+    return getReferenceFieldElements(reference).filter(({ field }) => field === issue.field).map(({ element }) => element);
+  }
+  if (issue.code !== "markup" && issue.code !== "wrong_element") return [];
+  const found = validateReferenceStructure(reference).find(
+    (candidate) => isSameMarkupIssue(candidate, issue)
+  );
+  return (found?.elements ?? []).filter((element) => element !== reference);
+};
+
+// src/validation/validateReference.ts
+var getFieldLabel = (field, typeSchema) => {
+  if (field === "creators") {
+    return typeSchema.allowedFields.includes("editor") ? "Author or editor" : "Author";
+  }
+  return typeSchema.fieldLabels?.[field] ?? REFERENCE_FIELD_SCHEMAS[field].label;
+};
+var getBibliomsetRelationCopy = (typeSchema) => {
+  const relations = typeSchema.bibliomsetRelations ?? [];
+  return relations.length > 0 ? `${typeSchema.label} references use bibliomset with the relation ${relations.join(" and ")}. Please correct the relation.` : `${typeSchema.label} references do not use bibliomset. Please remove it and keep its contents.`;
+};
+var getMarkupCopy = (rule, typeSchema) => {
+  switch (rule) {
+    case "missing_id":
+      return {
+        title: "Reference ID missing",
+        kind: "missing",
+        description: "Every reference needs an xml:id. Please add one."
+      };
+    case "bibliomset_relation":
+      return {
+        title: "Wrong bibliomset for this reference type",
+        kind: "forbidden",
+        description: getBibliomsetRelationCopy(typeSchema)
+      };
+    case "bibliomset_missing":
+      return {
+        title: "Bibliomset missing",
+        kind: "missing",
+        description: `${typeSchema.label} references need one bibliomset with the relation ${(typeSchema.bibliomsetRelations ?? []).join(" and one with ")}. Please wrap the details in them.`
+      };
+    case "bibliomset_repeated":
+      return {
+        title: "Bibliomset repeated",
+        kind: "forbidden",
+        description: "A reference holds one bibliomset of each relation. Please move the details of the repeated bibliomset into the first one."
+      };
+    case "bibliomset_title":
+      return {
+        title: "Bibliomset without a title",
+        kind: "missing",
+        description: "Every bibliomset must contain a title. Please move its title into it or remove the bibliomset."
+      };
+    case "bibliomset_nested":
+      return {
+        title: "Bibliomset inside another bibliomset",
+        kind: "forbidden",
+        description: "A bibliomset cannot sit inside another bibliomset. Please move it out so the two sit side by side."
+      };
+    case "part_editor":
+      return {
+        title: "Editor tagged in the chapter part",
+        kind: "forbidden",
+        description: "The part bibliomset holds the chapter and its author. Please tag the name as an author or move the editor to the book bibliomset."
+      };
+    case "personname_role":
+      return {
+        title: "Name order not set",
+        kind: "missing",
+        description: `Every personname needs a role of ${PERSONNAME_ORDER_ROLES.join(" or ")}. Please set the name order.`
+      };
+    case "name_outside_personname":
+      return {
+        title: "Name not wrapped in personname",
+        kind: "forbidden",
+        description: "A surname, firstname or honorific must sit inside a personname. Please wrap the name parts."
+      };
+    case "othercredit_artist":
+      return {
+        title: "Artist credit not marked",
+        kind: "missing",
+        description: `The othercredit of a recording needs otherclass="${ARTIST_OTHERCLASS}". Please set it.`
+      };
+    case "link_without_target":
+      return {
+        title: "Link incomplete",
+        kind: "missing",
+        description: "A link needs an xlink:href. Please complete the link."
+      };
+    case "doi_outside_doi_org":
+      return {
+        title: "DOI not pointing at doi.org",
+        kind: "forbidden",
+        description: "A DOI link must point at a https://doi.org/ address. Please fix its xlink:href, or tag the address as a URL with a uri inside the link."
+      };
+    case "doi_inside_uri":
+      return {
+        title: "DOI tagged as a URL",
+        kind: "forbidden",
+        description: "A DOI link holds the DOI directly, without a uri inside it. Please remove the uri."
+      };
+    case "uri_outside_link":
+      return {
+        title: "URL not wrapped in a link",
+        kind: "forbidden",
+        description: "A uri must sit inside a link that carries the xlink:href. Please wrap it in a link."
+      };
+    case "confgroup_text":
+      return {
+        title: "Text directly inside confgroup",
+        kind: "forbidden",
+        description: "A confgroup cannot hold text directly. Please tag the text as conftitle or confdates."
+      };
+    case "confdates_outside_confgroup":
+      return {
+        title: "Conference dates outside confgroup",
+        kind: "forbidden",
+        description: "Conference dates must sit inside a confgroup. Please wrap them in one."
+      };
+  }
+};
+var getIssueCopy = (issue, typeSchema) => {
+  if (issue.code === "unknown_type" || !typeSchema) {
+    return {
+      title: "Reference type not set",
+      kind: "missing",
+      description: "This reference has no recognised type, so its structure cannot be checked. Please set its reference type."
+    };
+  }
+  const typeLabel = typeSchema.label.toLowerCase();
+  if (issue.code === "markup") return getMarkupCopy(issue.rule, typeSchema);
+  if (issue.code === "wrong_element") {
+    return {
+      title: `${issue.tag} not allowed`,
+      kind: "forbidden",
+      description: issue.replacement ? `${issue.tag} is not used by ${typeLabel} references. Please use ${issue.replacement} instead.` : `${issue.tag} is not used by ${typeLabel} references. Please remove it and keep its contents.`
+    };
+  }
+  const fieldLabel = getFieldLabel(issue.field, typeSchema);
+  switch (issue.code) {
+    case "missing":
+      return {
+        title: `${fieldLabel} missing`,
+        kind: "missing",
+        description: `Please tag the ${fieldLabel.toLowerCase()} in this ${typeLabel} reference.`
+      };
+    case "not_allowed":
+      return {
+        title: `${fieldLabel} not allowed`,
+        kind: "forbidden",
+        description: `${fieldLabel} is not used by ${typeLabel} references. Please untag or delete it.`
+      };
+  }
+};
+var validateReference = (reference) => {
+  if (isDeletedElement(reference)) return [];
+  const isBibliographyEntry = !!closestElementBySchema({
+    element: reference,
+    code: "referenceBibliography"
+  });
+  if (!isBibliographyEntry) return [];
+  const isTagged = getReferenceParts(reference).length > 0 || hasLooseReferenceMarkup(reference);
+  if (!isTagged) return [];
+  const typeSchema = findReferenceTypeSchemaByElement(reference);
+  return validateReferenceStructure(reference).map(
+    (issue) => createValidationIssue(reference, {
+      level: "warning",
+      elements: getReferenceStructureIssueElements(reference, issue),
+      ...getIssueCopy(issue, typeSchema)
+    })
+  );
+};
+
 // src/validation/validateXml.ts
-var validateElement = (element, root, elementsToLink, linkElements, schemasToValidateAgainst) => {
+var ELEMENTS_PER_STEP = 64;
+var DEFAULT_TIME_BUDGET_MS = 8;
+var validateOwnElement = (element, {
+  elementsToLink,
+  linkElements,
+  schemasToValidateAgainst,
+  errors
+}) => {
   if (isIgnoredElement(element)) {
-    return [];
+    return false;
   }
-  const errors = [];
   const schema = findSchemaByElement(element);
-  if (schema) {
-    if (schemasToValidateAgainst.includes(schema.code)) {
-      errors.push(...validateElementAgainstSchema(element, schema));
-    }
-    if (schema.tag === FOOTNOTE_SCHEMA.tag) {
-      errors.push(...validateFootnoteNumber(element));
-    }
-    if (schema.code === HEADING_SCHEMA.code) {
-      errors.push(...validateHeadingHierarchy(element));
-    }
-    if (schema.code === OLINK_SCHEMA.code) {
-      errors.push(...validateOlink(element));
-    }
-    errors.push(...validateLinkend(element, elementsToLink));
-    errors.push(...validateElementToLinkTo(element, linkElements));
-    if (isIgnoredValidation(schema.code)) {
-      return errors;
-    }
+  if (!schema) {
+    return true;
   }
-  for (const child of Array.from(element.children)) {
+  if (schemasToValidateAgainst.includes(schema.code)) {
     errors.push(
-      ...validateElement(
-        child,
-        root,
-        elementsToLink,
-        linkElements,
-        schemasToValidateAgainst
-      )
+      ...schema.code === BIBLIOMIXED_SCHEMA.code ? validateReference(element) : validateElementAgainstSchema(element, schema)
     );
   }
-  return errors;
+  if (schema.tag === FOOTNOTE_SCHEMA.tag) {
+    errors.push(...validateFootnoteNumber(element));
+  }
+  if (schema.code === HEADING_SCHEMA.code) {
+    errors.push(...validateHierarchy(element, "heading"));
+  }
+  if (schema.code === BOX_SCHEMA.code) {
+    errors.push(...validateHierarchy(element, "box"));
+  }
+  if (schema.code === OLINK_SCHEMA.code) {
+    errors.push(...validateOlink(element));
+  }
+  errors.push(...validateLinkend(element, elementsToLink));
+  errors.push(...validateElementToLinkTo(element, linkElements));
+  return !isIgnoredValidation(schema.code);
 };
-var validateXml = (xml, elementsToLink, linkElements, schemasToValidateAgainst) => {
+function* validateElements(xml, context) {
+  const pending = Array.from(xml.children).reverse();
+  let elementsSinceStep = 0;
+  for (let element = pending.pop(); element; element = pending.pop()) {
+    if (validateOwnElement(element, context)) {
+      const { children } = element;
+      for (let index = children.length - 1; index >= 0; index -= 1) {
+        pending.push(children[index]);
+      }
+    }
+    if (++elementsSinceStep === ELEMENTS_PER_STEP) {
+      elementsSinceStep = 0;
+      yield;
+    }
+  }
+}
+function* validateXmlSteps(xml, elementsToLink, linkElements, schemasToValidateAgainst) {
   const errors = [];
   errors.push(...validateConsecutiveFootnotes(xml));
   errors.push(...validateConsecutiveFootnoteCues(xml));
-  errors.push(...validatePossibleWeblinks(xml));
-  for (const child of Array.from(xml.children)) {
-    errors.push(
-      ...validateElement(
-        child,
-        xml,
-        elementsToLink,
-        linkElements,
-        schemasToValidateAgainst
-      )
-    );
-  }
+  yield;
+  errors.push(...yield* validatePossibleWeblinksSteps(xml));
+  yield* validateElements(xml, {
+    elementsToLink: new Set(elementsToLink),
+    linkElements: new Set(linkElements),
+    schemasToValidateAgainst,
+    errors
+  });
   return errors;
+}
+var validateXml = (xml, elementsToLink, linkElements, schemasToValidateAgainst) => runSteps(
+  validateXmlSteps(
+    xml,
+    elementsToLink,
+    linkElements,
+    schemasToValidateAgainst
+  )
+);
+var yieldToMainThread = () => {
+  const scheduler = globalThis.scheduler;
+  if (scheduler?.yield) return scheduler.yield();
+  return new Promise((resolve) => setTimeout(resolve, 0));
+};
+var throwIfAborted = (signal) => {
+  if (!signal?.aborted) return;
+  throw signal.reason ?? new DOMException("Aborted", "AbortError");
+};
+var validateXmlAsync = async (xml, elementsToLink, linkElements, schemasToValidateAgainst, { signal, timeBudgetMs = DEFAULT_TIME_BUDGET_MS } = {}) => {
+  const steps = validateXmlSteps(
+    xml,
+    elementsToLink,
+    linkElements,
+    schemasToValidateAgainst
+  );
+  let sliceStart = performance.now();
+  for (; ; ) {
+    throwIfAborted(signal);
+    const step = steps.next();
+    if (step.done) return step.value;
+    if (performance.now() - sliceStart >= timeBudgetMs) {
+      await yieldToMainThread();
+      sliceStart = performance.now();
+    }
+  }
 };
 
 // src/helpers/getElementLinks.ts
@@ -3341,6 +4558,13 @@ export {
   LAYOUT_USER_ATTRIBUTE,
   LEFT_INDENT_ATTRIBUTE,
   LINKEND_ATTRIBUTE,
+  LINK_BLOCKER_ROLES,
+  LINK_TO_CROSS_CHECK,
+  POSSIBLE_WEBLINK_CLASS,
+  POSSIBLE_WEBLINK_EXCLUDE_SELECTORS,
+  REFERENCE_FIELD_SCHEMAS,
+  REFERENCE_PART_SELECTOR,
+  REFERENCE_TYPE_SCHEMAS,
   RIGHT_INDENT_ATTRIBUTE,
   SCHEMAS,
   SPACE_ABOVE_ATTRIBUTE,
@@ -3353,22 +4577,47 @@ export {
   TRACK_CHANGES_ATTR_DATA_TIME,
   TRACK_CHANGES_ATTR_DATA_USERID,
   TRACK_CHANGES_ATTR_DATA_USERNAME,
+  VALIDATION_IGNORED_ATTRIBUTE,
   XMLID_ATTRIBUTE,
+  clearWeblinkMatches,
   closestElementBySchema,
   createElement,
+  extractFootnoteNumber,
   findAttributeDefinitionByName,
+  findElementLinkedTo,
+  findReferenceFieldByElement,
+  findReferenceTypeSchemaByElement,
   findSchemaByCode,
   findSchemaByElement,
   getAdjacentElement,
   getAttributeName,
+  getEffectiveChildElements,
   getElementLinks,
+  getPossibleWeblinks,
+  getReferenceFieldElements,
+  getReferenceParts,
+  getReferenceStructureIssueElements,
   getStore,
   isAttributeRestricted,
   isDeletedElement,
   isIgnoredAttribute,
   isIgnoredElement,
   isTrackChangesSchema,
+  markPossibleWeblinks,
   queryAllElementsBySchema,
   queryElementBySchema,
-  validateXml
+  validateAttributes,
+  validateConsecutiveFootnoteCues,
+  validateConsecutiveFootnotes,
+  validateElementAgainstSchema,
+  validateElementToLinkTo,
+  validateFootnoteNumber,
+  validateHierarchy,
+  validateLinkend,
+  validateOlink,
+  validatePossibleWeblinks,
+  validatePossibleWeblinksSteps,
+  validateReferenceStructure,
+  validateXml,
+  validateXmlAsync
 };