pro-editor-schema 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-// src/schema/utils/createSchema.ts
+// src/schema/helpers/createSchema.ts
 var createSchema = (params) => {
   return params;
 };
@@ -40,10 +40,13 @@ var TRACK_CHANGES_ATTRS = [
 ];
 var ELE_ID_ATTRIBUTE = "ele-id";
 var STORE_ATTRIBUTE = "store";
+var XMLID_ATTRIBUTE = "xmlid";
+var LINKEND_ATTRIBUTE = "linkend";
 var ID_ATTRS = [STORE_ATTRIBUTE, ELE_ID_ATTRIBUTE];
 
 // src/schema/shared/allowedAtomsChildren.ts
 var ATOM_CODES_ALLOWED_CHILDREN = [
+  { code: "mark", required: false },
   { code: "indexterm", required: false },
   { code: "b", required: false },
   { code: "i", required: false },
@@ -87,6 +90,7 @@ var QUATERNARY_TAG = "QUATERNARY";
 var BOOKMARK_TAG = "BOOKMARK";
 var SEE_TAG = "SEE";
 var REFERENCE_MARK_TAG = "REFERENCE";
+var MARK_TAG = "MARK";
 
 // src/schema/elementSchemas/atoms/b.ts
 var B_SCHEMA = createSchema({
@@ -528,6 +532,23 @@ var ABBR_SCHEMA = createSchema({
   allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
 });
 
+// src/schema/elementSchemas/atoms/mark.ts
+var MARK_SCHEMA = createSchema({
+  code: "mark",
+  kind: "atom",
+  tag: MARK_TAG,
+  requiredAttributes: ["id"],
+  optionalAttributes: [
+    "data-markjs",
+    {
+      name: "data-replaceable",
+      values: ["true", "false"],
+      defaultValue: "true"
+    }
+  ],
+  allowedChildrenCodes: [...ATOM_CODES_ALLOWED_CHILDREN]
+});
+
 // src/schema/elementSchemas/atoms/index.ts
 var ATOM_SCHEMAS = {
   indexterm: INDEXTERM_SCHEMA,
@@ -555,7 +576,8 @@ var ATOM_SCHEMAS = {
   comment: COMMENT_SCHEMA,
   query: QUERY_SCHEMA,
   reply: REPLY_SCHEMA,
-  abbreviation: ABBR_SCHEMA
+  abbreviation: ABBR_SCHEMA,
+  mark: MARK_SCHEMA
 };
 
 // src/schema/elementSchemas/elements/elementsTags.ts
@@ -622,7 +644,7 @@ var EPIGRAPH_TAG = "EPIGRAPH";
 var INFO_TAG = "INFO1";
 var POEM_TAG = "POEM";
 var BIBLIOMIXED_TAG = "BIBLIOMIXED";
-var REFERENCE_BIBLIOGRAPHY_TAG = "REFERENCE_BIBLIOGRAPHY";
+var REFERENCE_BIBLIOGRAPHY_TAG = "BIBLIOGRAPHY";
 var BIBLIODIV_TAG = "BIBLIODIV";
 var MATHPHRASE_TAG = "MATHPHRASE";
 var MATH_TAG = "MATH";
@@ -1981,7 +2003,7 @@ var FOOTNOTE_SECTION_SCHEMA = createSchema({
 });
 
 // src/schema/elementSchemas/elements/heading.ts
-var HEADING_LEVEL = ["H1", "H2", "H3", "H4", "H5", "H6"];
+var HEADING_LEVEL = ["H0", "H1", "H2", "H3", "H4", "H5", "H6"];
 var HEADING_ROLES = [...HEADING_LEVEL, "vignette_group"];
 var HEADING_SCHEMA = createSchema({
   code: "heading",
@@ -2052,6 +2074,7 @@ var POEM_SCHEMA = createSchema({
   optionalAttributes: [...TRACK_CHANGES_ATTRS, "role", "trackmsg"],
   defaultChildCode: "line",
   allowedChildrenCodes: [
+    { code: "title1", required: false },
     { code: "line", required: false },
     { code: "linegroup", required: false },
     { code: "source1", required: false }
@@ -2347,55 +2370,10 @@ var SCHEMAS = {
   ...INLINE_ELEMENT_SCHEMAS
 };
 
-// src/schema/shared/ignoredElements.ts
-var IGNORED_ELEMENT_SELECTORS = [
-  "span.rhlabel",
-  "span.printlabel",
-  "span.refIcon",
-  "span.missLink",
-  "span.ref-drag",
-  "span#dummySpan"
-];
-var IGNORED_VALIDATION_ELEMENT_SELECTORS = [
-  "referenceBibliomixed"
-];
-
-// src/schema/shared/ignoredAttributes.ts
-var IGNORED_ATTRIBUTES = [
-  // Styling & layout
-  "class",
-  "style",
-  // Editor state
-  "contenteditable",
-  "draggable",
-  "data-prevpos",
-  "tabindex",
-  // Browser behaviour
-  "spellcheck",
-  "translate",
-  "lang",
-  "dir",
-  "hidden",
-  "data-gramm"
-];
-var IGNORED_ATTRIBUTES_STARTS_WITH = ["er-", "er_", "drop", "drag"];
-
-// src/schema/utils/utils.ts
-var isTrackChangesSchema = (schema) => schema.code === "insertion" || schema.code === "deletion" || schema.code === "lineGroupRemoval";
-var isIgnoredAttribute = (attribute) => IGNORED_ATTRIBUTES.includes(attribute) || IGNORED_ATTRIBUTES_STARTS_WITH.some(
-  (startsWith) => attribute.startsWith(startsWith)
-);
-var isIgnoredElement = (element) => IGNORED_ELEMENT_SELECTORS.some((selector) => element.matches(selector));
-var isIgnoredValidation = (code) => IGNORED_VALIDATION_ELEMENT_SELECTORS.includes(code);
-var findSchemaByCode = (code) => SCHEMAS[code];
-var findSchemaByElement = (element) => {
-  const schema = Object.values(SCHEMAS).find(
-    (schema2) => schema2.tag == element.tagName && (!schema2.matchesElement || schema2.matchesElement(element))
-  );
-  return schema;
-};
-var isAttributeRestricted = (attr) => typeof attr !== "string";
+// src/schema/helpers/getAttributeName.ts
 var getAttributeName = (attribute) => typeof attribute === "string" ? attribute.toLowerCase() : attribute.name.toLowerCase();
+
+// src/schema/helpers/findAttributeDefinitionByName.ts
 var findAttributeDefinitionByName = (definitions, name) => {
   for (const def of definitions) {
     if (getAttributeName(def) === name.toLowerCase()) {
@@ -2405,47 +2383,29 @@ var findAttributeDefinitionByName = (definitions, name) => {
   return void 0;
 };
 
-// src/schema/utils/createElement.ts
-var createElement = ({
-  schemaCode,
-  attributes
-}) => {
-  const schema = findSchemaByCode(schemaCode);
-  const element = document.createElement(schema.tag.toLowerCase());
-  for (const [name, value] of Object.entries(attributes)) {
-    if (!value) continue;
-    element.setAttribute(name, String(value));
-  }
-  return element;
-};
+// src/schema/helpers/findSchemaByCode.ts
+var findSchemaByCode = (code) => SCHEMAS[code];
 
-// src/schema/utils/queryElementBySchema.ts
-var queryElementBySchema = (content, schemaCode) => {
-  const schema = findSchemaByCode(schemaCode);
-  const element = content.querySelector(schema.tag.toLowerCase());
-  if (!element) return void 0;
-  if (schema.matchesElement && !schema.matchesElement(element)) {
-    return void 0;
-  }
-  return element;
-};
-var queryAllElementsBySchema = (content, schemaCode) => {
-  const schema = findSchemaByCode(schemaCode);
-  const elements = content.querySelectorAll(
-    schema.tag.toLowerCase()
+// 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))
   );
-  const matchingElements = [];
-  for (const element of elements) {
-    if (schema.matchesElement && !schema.matchesElement(element)) {
-      continue;
-    }
-    matchingElements.push(element);
-  }
-  return matchingElements;
+  return schema;
 };
 
+// src/schema/helpers/isAttributeRestricted.ts
+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/shared/labelElements.ts
 var ElementLabel = {
+  mark: "Mark",
   referenceBibliomixed: "Reference Bibliomixed",
   referenceBibliography: "Reference Bibliography",
   bibliodiv: "Bibliodiv",
@@ -2580,40 +2540,54 @@ var DEPENDENT_FORBIDDEN_ELEMENTS = [
   }
 ];
 
-// src/validation/utils/generateValidationIssueId.ts
-var generateValidationIssueId = () => {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-};
-
-// src/validation/utils/addValidationIssue.ts
-var createValidationIssue = (issue) => ({
-  id: generateValidationIssueId(),
-  ...issue
-});
-var addValidationIssue = (errors, issue) => {
-  errors.push(createValidationIssue(issue));
-};
+// src/helpers/isIgnoredElement.ts
+var IGNORED_ELEMENT_SELECTORS = [
+  "span.rhlabel",
+  "span.printlabel",
+  "span.refIcon",
+  "span.missLink",
+  "span.ref-drag",
+  "span#dummySpan"
+];
+var isIgnoredElement = (element) => IGNORED_ELEMENT_SELECTORS.some((selector) => element.matches(selector));
 
-// src/validation/utils/getStore.ts
-var getStore = (element) => {
-  return element.getAttribute("store") || "";
-};
+// src/validation/helpers/isIgnoredValidation.ts
+var IGNORED_VALIDATION_ELEMENT_SELECTORS = [
+  "referenceBibliomixed"
+];
+var isIgnoredValidation = (code) => IGNORED_VALIDATION_ELEMENT_SELECTORS.includes(code);
 
-// src/validation/utils/retrieveTextIgnoringNodesWithSelector.ts
-var retrieveTextIgnoringNodesWithSelector = (element, selector = ".del") => {
-  const clonedElement = element.cloneNode(true);
-  for (const delElement of clonedElement.querySelectorAll(selector)) {
-    delElement.remove();
+// 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;
   }
-  return clonedElement.textContent || "";
+  if (ignoreDeletedElements && isDeletedElement(closestElement)) {
+    return closestElementBySchema({
+      element: closestElement,
+      code,
+      ignoreDeletedElements
+    });
+  }
+  return closestElement;
 };
 
-// src/validation/utils/isDeletedElement.ts
+// src/helpers/isDeletedElement.ts
 var isDeletedElement = (element) => {
-  return !!element.closest(".del");
+  return !!closestElementBySchema({
+    element,
+    code: "deletion"
+  });
 };
 
 // src/validation/utils/getElementsSelector.ts
@@ -2629,63 +2603,35 @@ var getElementsSelector = ({
   return elements;
 };
 
-// src/validation/validateLinkend.ts
-var findElementLinkedTo = (linkend, elementsToLink) => {
-  return elementsToLink.includes(linkend);
-};
-var LINK_TO_CROSS_CHECK = [
-  TABLE_LINK_ROLE,
-  FIGURE_LINK_ROLE,
-  EQUATION_LINK_ROLE,
-  FOOTNOTE_LINK_ROLE,
-  REFERENCE_LINK_ROLE
-];
-var LINK_BLOCKER_ROLES = [
-  TABLE_LINK_ROLE,
-  FIGURE_LINK_ROLE,
-  EQUATION_LINK_ROLE,
-  FOOTNOTE_LINK_ROLE
-];
-var validateLinkend = (linkElement, elementsToLink) => {
-  const linkend = linkElement.getAttribute("linkend");
-  if (!linkend) {
-    return [];
-  }
-  const isLinkFootnoteCue = linkElement.tagName.toUpperCase() === FOOTNOTE_LINK_SCHEMA.tag;
-  if (isLinkFootnoteCue) {
-    if (findElementLinkedTo(linkend, elementsToLink)) {
-      return [];
-    }
-    return [
-      createValidationIssue({
-        store: getStore(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.",
-        level: "blocker"
-      })
-    ];
-  }
-  const role = linkElement.getAttribute("role");
-  if (!role) {
-    return [];
-  }
-  if (!LINK_TO_CROSS_CHECK.includes(role)) {
-    return [];
+// src/validation/utils/retrieveTextIgnoringNodesWithSelector.ts
+var retrieveTextIgnoringNodesWithSelector = (element, selector = ".del") => {
+  const clonedElement = element.cloneNode(true);
+  for (const delElement of clonedElement.querySelectorAll(selector)) {
+    delElement.remove();
   }
-  if (findElementLinkedTo(linkend, elementsToLink)) {
-    return [];
+  return clonedElement.textContent || "";
+};
+
+// src/helpers/getStore.ts
+var getStore = (element) => {
+  return element.getAttribute(STORE_ATTRIBUTE) || "";
+};
+
+// src/validation/helpers/generateValidationIssueId.ts
+var generateValidationIssueId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
   }
-  const isBlocker = LINK_BLOCKER_ROLES.includes(role.toLowerCase());
-  return [
-    createValidationIssue({
-      store: getStore(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.",
-      level: isBlocker ? "blocker" : "warning"
-    })
-  ];
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+};
+
+// src/validation/helpers/addValidationIssue.ts
+var createValidationIssue = (issue) => ({
+  id: generateValidationIssueId(),
+  ...issue
+});
+var addValidationIssue = (errors, issue) => {
+  errors.push(createValidationIssue(issue));
 };
 
 // src/validation/validateFootnotes.ts
@@ -2698,15 +2644,11 @@ var extractFootnoteNumber = (footnote) => {
   }
   return footnoteNumber;
 };
-var validateFootnoteCue = (footnoteElement, linkElements) => {
+var validateFootnoteNumber = (footnoteElement) => {
   const errors = [];
-  const linkend = footnoteElement.getAttribute("xmlid") || "";
   const footnoteNumber = footnoteElement.querySelector(
     FOOTNOTE_NUMBER_SCHEMA.tag
   );
-  if (findElementLinkedTo(linkend, linkElements)) {
-    return errors;
-  }
   if (!footnoteNumber) {
     addValidationIssue(errors, {
       store: getStore(footnoteElement),
@@ -2716,14 +2658,6 @@ var validateFootnoteCue = (footnoteElement, linkElements) => {
       level: "blocker"
     });
   }
-  const label = extractFootnoteNumber(footnoteNumber);
-  addValidationIssue(errors, {
-    store: getStore(footnoteElement),
-    title: "Unreferenced footnote",
-    kind: "unlinked",
-    description: `The footnote ${label} is not referenced to any footnote cue in this chapter. Please reference it in the chapter.`,
-    level: "blocker"
-  });
   return errors;
 };
 var validateConsecutiveFootnotes = (root) => {
@@ -2808,6 +2742,92 @@ var validateConsecutiveFootnoteCues = (root) => {
   return errors;
 };
 
+// src/validation/validateLinkend.ts
+var findElementLinkedTo = (linkend, elementsToLink) => {
+  return elementsToLink.includes(linkend);
+};
+var LINK_TO_CROSS_CHECK = [
+  TABLE_LINK_ROLE,
+  FIGURE_LINK_ROLE,
+  EQUATION_LINK_ROLE,
+  FOOTNOTE_LINK_ROLE,
+  REFERENCE_LINK_ROLE
+];
+var LINK_BLOCKER_ROLES = [
+  TABLE_LINK_ROLE,
+  FIGURE_LINK_ROLE,
+  EQUATION_LINK_ROLE,
+  FOOTNOTE_LINK_ROLE
+];
+var validateLinkend = (linkElement, elementsToLink) => {
+  const linkend = linkElement.getAttribute("linkend");
+  if (!linkend) {
+    return [];
+  }
+  if (findElementLinkedTo(linkend, elementsToLink)) {
+    return [];
+  }
+  const isLinkFootnoteCue = matchesSchemaTag(
+    linkElement,
+    FOOTNOTE_LINK_SCHEMA.tag
+  );
+  if (isLinkFootnoteCue) {
+    return [
+      createValidationIssue({
+        store: getStore(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.",
+        level: "blocker"
+      })
+    ];
+  }
+  const isLink = matchesSchemaTag(linkElement, LINK_SCHEMA.tag);
+  if (!isLink) {
+    return [];
+  }
+  const role = linkElement.getAttribute("role");
+  if (!role) {
+    return [];
+  }
+  if (!LINK_TO_CROSS_CHECK.includes(role)) {
+    return [];
+  }
+  const isBlocker = LINK_BLOCKER_ROLES.includes(role.toLowerCase());
+  return [
+    createValidationIssue({
+      store: getStore(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.",
+      level: isBlocker ? "blocker" : "warning"
+    })
+  ];
+};
+
+// src/helpers/isIgnoredAttribute.ts
+var IGNORED_ATTRIBUTES = [
+  // Styling & layout
+  "class",
+  "style",
+  // Editor state
+  "contenteditable",
+  "draggable",
+  "data-prevpos",
+  "tabindex",
+  // Browser behaviour
+  "spellcheck",
+  "translate",
+  "lang",
+  "dir",
+  "hidden",
+  "data-gramm"
+];
+var IGNORED_ATTRIBUTES_STARTS_WITH = ["er-", "er_", "drop", "drag"];
+var isIgnoredAttribute = (attribute) => IGNORED_ATTRIBUTES.includes(attribute) || IGNORED_ATTRIBUTES_STARTS_WITH.some(
+  (startsWith) => attribute.startsWith(startsWith)
+);
+
 // src/validation/validateAttributes.ts
 var validateAttributes = (element, schema) => {
   const errors = [];
@@ -2851,7 +2871,7 @@ var validateAttributes = (element, schema) => {
 // src/validation/validateChildren.ts
 var validateElementAgainstSchema = (element, schema) => {
   const errors = [];
-  if (element.tagName.toUpperCase() !== schema.tag) {
+  if (!matchesSchemaTag(element, schema.tag)) {
     addValidationIssue(errors, {
       store: getStore(element),
       title: `Expected ${schema.tag}, got ${element.tagName}`,
@@ -2952,27 +2972,79 @@ var getExtraInstruction = (schema, childSchema) => {
   return "";
 };
 
-// src/validation/validateReferences.ts
+// src/validation/validateElementToLinkTo.ts
 var findElementLinkedTo2 = (xmlid, linkElements) => {
   return linkElements.includes(xmlid);
 };
-var validateReferenceCited = (referenceElement, linkElements) => {
-  const xmlid = referenceElement.getAttribute("xmlid");
+var isFootnote = (element) => {
+  return matchesSchemaTag(element, FOOTNOTE_SCHEMA.tag);
+};
+var isReference = (element) => {
+  return matchesSchemaTag(element, BIBLIOMIXED_SCHEMA.tag) || !!closestElementBySchema({
+    element,
+    code: "referenceBibliography"
+  });
+};
+var isTable = (element) => {
+  return matchesSchemaTag(element, TABLE_SCHEMA.tag);
+};
+var isFigure = (element) => {
+  return matchesSchemaTag(element, FIGURE_SCHEMA.tag);
+};
+var validateElementToLinkTo = (element, linkElements) => {
+  const xmlid = element.getAttribute("xmlid");
   if (!xmlid) {
     return [];
   }
   if (findElementLinkedTo2(xmlid, linkElements)) {
     return [];
   }
-  return [
-    createValidationIssue({
-      store: getStore(referenceElement),
-      title: "Unlinked element",
-      kind: "unlinked",
-      description: "This reference is not cited in this chapter or any other chapter. Please add a link to this reference or delete the reference.",
-      level: "warning"
-    })
-  ];
+  if (isFootnote(element)) {
+    const label = extractFootnoteNumber(element);
+    return [
+      createValidationIssue({
+        store: getStore(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.`,
+        level: "blocker"
+      })
+    ];
+  }
+  if (isReference(element)) {
+    return [
+      createValidationIssue({
+        store: getStore(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.",
+        level: "warning"
+      })
+    ];
+  }
+  if (isTable(element)) {
+    return [
+      createValidationIssue({
+        store: getStore(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.",
+        level: "warning"
+      })
+    ];
+  }
+  if (isFigure(element)) {
+    return [
+      createValidationIssue({
+        store: getStore(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.",
+        level: "warning"
+      })
+    ];
+  }
+  return [];
 };
 
 // src/validation/validateWeblink.ts
@@ -3024,30 +3096,12 @@ var validatePossibleWeblinks = (root) => {
   return errors;
 };
 
-// src/validation/utils/getParentElement.ts
-var getParentElement = ({
-  element,
-  schemaCode,
-  filterDeletedNodes
-}) => {
-  let current = element.parentElement;
-  while (current) {
-    const isValidParent = findSchemaByElement(current)?.code === schemaCode;
-    const isFilterDeleted = filterDeletedNodes && isDeletedElement(current);
-    if (isValidParent || isFilterDeleted) {
-      return current;
-    }
-    current = current.parentElement;
-  }
-  return void 0;
-};
-
 // src/validation/validateHeadingHierarchy.ts
 var getHierarchyLevel = (element) => {
   const role = element.getAttribute("role");
   if (!role) return void 0;
-  const validHeadingLevel = HEADING_LEVEL.indexOf(role) + 1;
-  if (!validHeadingLevel) return void 0;
+  const validHeadingLevel = HEADING_LEVEL.indexOf(role);
+  if (validHeadingLevel === -1) return void 0;
   return validHeadingLevel;
 };
 var validateHeadingHierarchy = (element) => {
@@ -3059,13 +3113,16 @@ var validateHeadingHierarchy = (element) => {
   if (level === void 0) {
     return errors;
   }
-  const parentHeading = getParentElement({
-    element,
-    schemaCode: HEADING_SCHEMA.code,
-    filterDeletedNodes: true
+  if (!element.parentElement) {
+    return errors;
+  }
+  const parentHeading = closestElementBySchema({
+    element: element.parentElement,
+    code: HEADING_SCHEMA.code,
+    ignoreDeletedElements: true
   });
   if (!parentHeading) {
-    if (level !== 1) {
+    if (level > 1) {
       addValidationIssue(errors, {
         store: getStore(element),
         title: "Missing heading H1",
@@ -3095,7 +3152,7 @@ var validateHeadingHierarchy = (element) => {
 };
 
 // src/validation/validateOlink.ts
-var ORCID_PATTERN = /^\d{4}-\d{4}-\d{4}-\d{4}$/;
+var ORCID_PATTERN = /^\d{4}-\d{4}-\d{4}-\d{3}[\dX]$/;
 var validateOlink = (element) => {
   const errors = [];
   if (isDeletedElement(element)) {
@@ -3128,14 +3185,8 @@ var validateElement = (element, root, elementsToLink, linkElements, schemasToVal
     if (schemasToValidateAgainst.includes(schema.code)) {
       errors.push(...validateElementAgainstSchema(element, schema));
     }
-    if (schema.tag === LINK_SCHEMA.tag || schema.tag === FOOTNOTE_LINK_SCHEMA.tag) {
-      errors.push(...validateLinkend(element, elementsToLink));
-    }
-    if (schema.tag === BIBLIOMIXED_SCHEMA.tag) {
-      errors.push(...validateReferenceCited(element, linkElements));
-    }
     if (schema.tag === FOOTNOTE_SCHEMA.tag) {
-      errors.push(...validateFootnoteCue(element, linkElements));
+      errors.push(...validateFootnoteNumber(element));
     }
     if (schema.code === HEADING_SCHEMA.code) {
       errors.push(...validateHeadingHierarchy(element));
@@ -3143,6 +3194,8 @@ var validateElement = (element, root, elementsToLink, linkElements, schemasToVal
     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;
     }
@@ -3178,6 +3231,84 @@ var validateXml = (xml, elementsToLink, linkElements, schemasToValidateAgainst)
   }
   return errors;
 };
+
+// src/helpers/getElementLinks.ts
+var getElementLinks = (contentChaptersToValidate) => {
+  const elementsToLink = [];
+  const linkedElements = [];
+  for (const chapter of contentChaptersToValidate) {
+    const parser = new DOMParser();
+    const content = parser.parseFromString(chapter, "text/html");
+    const elementsXMLID = content.querySelectorAll(`[${XMLID_ATTRIBUTE}]`);
+    for (const elementWithXMLID of elementsXMLID) {
+      const linkValue = elementWithXMLID.getAttribute(XMLID_ATTRIBUTE);
+      if (!linkValue) continue;
+      elementsToLink.push(linkValue);
+    }
+    const elementsLinkend = content.querySelectorAll(`[${LINKEND_ATTRIBUTE}]`);
+    for (const elementWithLinkend of elementsLinkend) {
+      const linkendValue = elementWithLinkend.getAttribute(LINKEND_ATTRIBUTE);
+      if (!linkendValue) continue;
+      linkedElements.push(linkendValue);
+    }
+  }
+  return { elementsToLink, linkedElements };
+};
+
+// src/helpers/createElement.ts
+var createElement = ({
+  schemaCode,
+  attributes
+}) => {
+  const schema = findSchemaByCode(schemaCode);
+  const element = document.createElement(schema.tag.toLowerCase());
+  for (const [name, value] of Object.entries(attributes)) {
+    if (!value) continue;
+    element.setAttribute(name, String(value));
+  }
+  return element;
+};
+
+// src/helpers/queryElementBySchema.ts
+var queryElementBySchema = (content, schemaCode) => {
+  const schema = findSchemaByCode(schemaCode);
+  const element = content.querySelector(schema.tag.toLowerCase());
+  if (!element) return void 0;
+  if (schema.matchesElement && !schema.matchesElement(element)) {
+    return void 0;
+  }
+  return element;
+};
+var queryAllElementsBySchema = (content, schemaCode) => {
+  const schema = findSchemaByCode(schemaCode);
+  const elements = content.querySelectorAll(
+    schema.tag.toLowerCase()
+  );
+  const matchingElements = [];
+  for (const element of elements) {
+    if (schema.matchesElement && !schema.matchesElement(element)) {
+      continue;
+    }
+    matchingElements.push(element);
+  }
+  return matchingElements;
+};
+
+// src/helpers/getAdjacentElement.ts
+var getAdjacentElement = ({
+  element,
+  direction,
+  code
+}) => {
+  let current = element;
+  while (current) {
+    const sibling = direction === "next" ? current.nextElementSibling : current.previousElementSibling;
+    if (sibling instanceof HTMLElement) {
+      return closestElementBySchema({ element: sibling, code }) || queryElementBySchema(sibling, code);
+    }
+    current = current.parentElement;
+  }
+};
 export {
   ALIGNMENT_ATTRIBUTE,
   ATOM_SCHEMAS,
@@ -3190,7 +3321,6 @@ export {
   IGNORED_ATTRIBUTES,
   IGNORED_ATTRIBUTES_STARTS_WITH,
   IGNORED_ELEMENT_SELECTORS,
-  IGNORED_VALIDATION_ELEMENT_SELECTORS,
   INDENT_TYPE_ATTRIBUTE,
   INLINE_ELEMENT_SCHEMAS,
   LAYOUT_ATTRIBUTES,
@@ -3199,6 +3329,7 @@ export {
   LAYOUT_TABLE_PLACEMENT_ATTRIBUTE,
   LAYOUT_USER_ATTRIBUTE,
   LEFT_INDENT_ATTRIBUTE,
+  LINKEND_ATTRIBUTE,
   RIGHT_INDENT_ATTRIBUTE,
   SCHEMAS,
   SPACE_ABOVE_ATTRIBUTE,
@@ -3211,15 +3342,20 @@ export {
   TRACK_CHANGES_ATTR_DATA_TIME,
   TRACK_CHANGES_ATTR_DATA_USERID,
   TRACK_CHANGES_ATTR_DATA_USERNAME,
+  XMLID_ATTRIBUTE,
+  closestElementBySchema,
   createElement,
   findAttributeDefinitionByName,
   findSchemaByCode,
   findSchemaByElement,
+  getAdjacentElement,
   getAttributeName,
+  getElementLinks,
+  getStore,
   isAttributeRestricted,
+  isDeletedElement,
   isIgnoredAttribute,
   isIgnoredElement,
-  isIgnoredValidation,
   isTrackChangesSchema,
   queryAllElementsBySchema,
   queryElementBySchema,