@likecoin/epubcheck-ts 0.3.8 → 0.3.9

package/dist/index.cjs

@@ -1604,31 +1604,276 @@ var CSSValidator = class {
    * Check for reserved media overlay class names
    */
   checkMediaOverlayClasses(context, ast, resourcePath) {
-    const reservedClassNames = /* @__PURE__ */ new Set([
-      "-epub-media-overlay-active",
-      "media-overlay-active",
-      "-epub-media-overlay-playing",
-      "media-overlay-playing"
-    ]);
+    const activeClassNames = /* @__PURE__ */ new Set(["-epub-media-overlay-active", "media-overlay-active"]);
+    const playbackClassNames = /* @__PURE__ */ new Set(["-epub-media-overlay-playing", "media-overlay-playing"]);
     cssTree.walk(ast, (node) => {
       if (node.type === "ClassSelector") {
         const className = node.name.toLowerCase();
-        if (reservedClassNames.has(className)) {
-          const loc = node.loc;
-          const start = loc?.start;
-          const location = { path: resourcePath };
-          if (start) {
-            location.line = start.line;
-            location.column = start.column;
-          }
+        const isActive = activeClassNames.has(className);
+        const isPlayback = playbackClassNames.has(className);
+        if (!isActive && !isPlayback) return;
+        const isDeclared = isActive ? !!context.mediaActiveClass : !!context.mediaPlaybackActiveClass;
+        if (isDeclared) return;
+        const loc = node.loc;
+        const start = loc?.start;
+        const location = { path: resourcePath };
+        if (start) {
+          location.line = start.line;
+          location.column = start.column;
+        }
+        const property = isActive ? "media:active-class" : "media:playback-active-class";
+        pushMessage(context.messages, {
+          id: MessageId.CSS_029,
+          message: `Class name "${className}" is reserved for media overlays but "${property}" is not declared in the package document`,
+          location
+        });
+      }
+    });
+  }
+};
+
+// src/smil/clock.ts
+var FULL_CLOCK_RE = /^(\d+):([0-5]\d):([0-5]\d)(\.\d+)?$/;
+var PARTIAL_CLOCK_RE = /^([0-5]\d):([0-5]\d)(\.\d+)?$/;
+var TIMECOUNT_RE = /^(\d+(\.\d+)?)(h|min|s|ms)?$/;
+function parseSmilClock(value) {
+  const trimmed = value.trim();
+  const full = FULL_CLOCK_RE.exec(trimmed);
+  if (full) {
+    const hours = Number.parseInt(full[1] ?? "0", 10);
+    const minutes = Number.parseInt(full[2] ?? "0", 10);
+    const seconds = Number.parseInt(full[3] ?? "0", 10);
+    const frac = full[4] ? Number.parseFloat(full[4]) : 0;
+    return hours * 3600 + minutes * 60 + seconds + frac;
+  }
+  const partial = PARTIAL_CLOCK_RE.exec(trimmed);
+  if (partial) {
+    const minutes = Number.parseInt(partial[1] ?? "0", 10);
+    const seconds = Number.parseInt(partial[2] ?? "0", 10);
+    const frac = partial[3] ? Number.parseFloat(partial[3]) : 0;
+    return minutes * 60 + seconds + frac;
+  }
+  const timecount = TIMECOUNT_RE.exec(trimmed);
+  if (timecount) {
+    const num = Number.parseFloat(timecount[1] ?? "0");
+    const unit = timecount[3] ?? "s";
+    switch (unit) {
+      case "h":
+        return num * 3600;
+      case "min":
+        return num * 60;
+      case "s":
+        return num;
+      case "ms":
+        return num / 1e3;
+      default:
+        return NaN;
+    }
+  }
+  return NaN;
+}
+function isValidSmilClock(value) {
+  return !Number.isNaN(parseSmilClock(value));
+}
+
+// src/smil/validator.ts
+var SMIL_NS = { smil: "http://www.w3.org/ns/SMIL" };
+var BLESSED_AUDIO_TYPES = /* @__PURE__ */ new Set(["audio/mpeg", "audio/mp4"]);
+var BLESSED_AUDIO_PATTERN = /^audio\/ogg\s*;\s*codecs=opus$/i;
+function isBlessedAudioType(mimeType) {
+  return BLESSED_AUDIO_TYPES.has(mimeType) || BLESSED_AUDIO_PATTERN.test(mimeType);
+}
+var SMILValidator = class {
+  getAttribute(element, name) {
+    return element.attr(name)?.value ?? null;
+  }
+  getEpubAttribute(element, localName) {
+    return element.attr(localName, "epub")?.value ?? null;
+  }
+  validate(context, path, manifestByPath) {
+    const result = {
+      textReferences: [],
+      referencedDocuments: /* @__PURE__ */ new Set(),
+      hasRemoteResources: false
+    };
+    const data = context.files.get(path);
+    if (!data) return result;
+    const content = typeof data === "string" ? data : new TextDecoder().decode(data);
+    let doc = null;
+    try {
+      doc = libxml2Wasm.XmlDocument.fromString(content);
+    } catch {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_016,
+        message: "Media Overlay document is not well-formed XML",
+        location: { path }
+      });
+      return result;
+    }
+    try {
+      const root = doc.root;
+      this.validateStructure(context, path, root);
+      this.validateAudioElements(context, path, root, manifestByPath, result);
+      this.extractTextReferences(path, root, result);
+    } finally {
+      doc.dispose();
+    }
+    return result;
+  }
+  validateStructure(context, path, root) {
+    try {
+      for (const text of root.find(".//smil:seq/smil:text", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'text' not allowed here; expected 'seq' or 'par'",
+          location: { path, line: text.line }
+        });
+      }
+      for (const audio of root.find(".//smil:seq/smil:audio", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'audio' not allowed here; expected 'seq' or 'par'",
+          location: { path, line: audio.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      for (const seq of root.find(".//smil:par/smil:seq", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'seq' not allowed here; expected 'text' or 'audio'",
+          location: { path, line: seq.line }
+        });
+      }
+      const parElements = root.find(".//smil:par", SMIL_NS);
+      for (const par of parElements) {
+        const textChildren = par.find("./smil:text", SMIL_NS);
+        for (let i = 1; i < textChildren.length; i++) {
+          const extra = textChildren[i];
+          if (!extra) continue;
           pushMessage(context.messages, {
-            id: MessageId.CSS_029,
-            message: `Class name "${className}" is reserved for media overlays`,
-            location
+            id: MessageId.RSC_005,
+            message: "element 'text' not allowed here; only one 'text' element is allowed in 'par'",
+            location: { path, line: extra.line }
           });
         }
       }
-    });
+    } catch {
+    }
+    try {
+      const headMetaElements = root.find(".//smil:head/smil:meta", SMIL_NS);
+      for (const meta of headMetaElements) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'meta' not allowed here; expected 'metadata'",
+          location: { path, line: meta.line }
+        });
+      }
+    } catch {
+    }
+  }
+  validateAudioElements(context, path, root, manifestByPath, result) {
+    try {
+      const audioElements = root.find(".//smil:audio", SMIL_NS);
+      for (const audio of audioElements) {
+        const elem = audio;
+        const src = this.getAttribute(elem, "src");
+        if (src) {
+          if (/^https?:\/\//i.test(src)) {
+            result.hasRemoteResources = true;
+          }
+          if (src.includes("#")) {
+            pushMessage(context.messages, {
+              id: MessageId.MED_014,
+              message: `Media overlay audio file URLs must not have a fragment: "${src}"`,
+              location: { path, line: audio.line }
+            });
+          }
+          if (manifestByPath) {
+            const audioPath = this.resolveRelativePath(path, src.split("#")[0] ?? src);
+            const audioItem = manifestByPath.get(audioPath);
+            if (audioItem && !isBlessedAudioType(audioItem.mediaType)) {
+              pushMessage(context.messages, {
+                id: MessageId.MED_005,
+                message: `Media Overlay audio reference "${src}" to non-standard audio type "${audioItem.mediaType}"`,
+                location: { path, line: audio.line }
+              });
+            }
+          }
+        }
+        const clipBegin = this.getAttribute(elem, "clipBegin");
+        const clipEnd = this.getAttribute(elem, "clipEnd");
+        this.checkClipTiming(context, path, audio.line, clipBegin, clipEnd);
+      }
+    } catch {
+    }
+  }
+  checkClipTiming(context, path, line, clipBegin, clipEnd) {
+    if (clipEnd === null) return;
+    const beginStr = clipBegin ?? "0";
+    const start = parseSmilClock(beginStr);
+    const end = parseSmilClock(clipEnd);
+    if (Number.isNaN(start) || Number.isNaN(end)) return;
+    const location = line != null ? { path, line } : { path };
+    if (start > end) {
+      pushMessage(context.messages, {
+        id: MessageId.MED_008,
+        message: "The time specified in the clipBegin attribute must not be after clipEnd",
+        location
+      });
+    } else if (start === end) {
+      pushMessage(context.messages, {
+        id: MessageId.MED_009,
+        message: "The time specified in the clipBegin attribute must not be the same as clipEnd",
+        location
+      });
+    }
+  }
+  extractTextReferences(path, root, result) {
+    try {
+      const textElements = root.find(".//smil:text", SMIL_NS);
+      for (const text of textElements) {
+        const src = this.getAttribute(text, "src");
+        if (!src) continue;
+        const hashIndex = src.indexOf("#");
+        const docRef = hashIndex >= 0 ? src.substring(0, hashIndex) : src;
+        const fragment = hashIndex >= 0 ? src.substring(hashIndex + 1) : void 0;
+        const docPath = this.resolveRelativePath(path, docRef);
+        result.textReferences.push({ docPath, fragment, line: text.line });
+        result.referencedDocuments.add(docPath);
+      }
+      const bodyElements = root.find(".//smil:body", SMIL_NS);
+      const seqElements = root.find(".//smil:seq", SMIL_NS);
+      for (const elem of [...bodyElements, ...seqElements]) {
+        const textref = this.getEpubAttribute(elem, "textref");
+        if (!textref) continue;
+        const hashIndex = textref.indexOf("#");
+        const docRef = hashIndex >= 0 ? textref.substring(0, hashIndex) : textref;
+        const fragment = hashIndex >= 0 ? textref.substring(hashIndex + 1) : void 0;
+        const docPath = this.resolveRelativePath(path, docRef);
+        result.textReferences.push({ docPath, fragment, line: elem.line });
+        result.referencedDocuments.add(docPath);
+      }
+    } catch {
+    }
+  }
+  resolveRelativePath(basePath, relativePath) {
+    if (relativePath.startsWith("/") || /^[a-zA-Z]+:/.test(relativePath)) {
+      return relativePath;
+    }
+    const baseDir = basePath.includes("/") ? basePath.substring(0, basePath.lastIndexOf("/")) : "";
+    if (!baseDir) return relativePath;
+    const segments = `${baseDir}/${relativePath}`.split("/");
+    const resolved = [];
+    for (const seg of segments) {
+      if (seg === "..") {
+        resolved.pop();
+      } else if (seg !== ".") {
+        resolved.push(seg);
+      }
+    }
+    return resolved.join("/");
   }
 };
 
@@ -1890,6 +2135,17 @@ var ABSOLUTE_URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
 var SPECIAL_URL_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "ftp", "ws", "wss"]);
 var CSS_CHARSET_RE = /^@charset\s+"([^"]+)"\s*;/;
 var EPUB_XMLNS_RE = /xmlns:epub\s*=\s*"([^"]*)"/;
+var XHTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+var EPUB_TYPE_FORBIDDEN_ELEMENTS = /* @__PURE__ */ new Set([
+  "head",
+  "meta",
+  "title",
+  "style",
+  "link",
+  "script",
+  "noscript",
+  "base"
+]);
 function validateAbsoluteHyperlinkURL(context, href, path, line) {
   const location = line != null ? { path, line } : { path };
   const scheme = href.slice(0, href.indexOf(":")).toLowerCase();
@@ -2209,6 +2465,11 @@ var ContentValidator = class {
         }
       }
     }
+    const overlayDocMap = /* @__PURE__ */ new Map();
+    const manifestByPath = /* @__PURE__ */ new Map();
+    for (const item of packageDoc.manifest) {
+      manifestByPath.set(resolveManifestHref(opfDir, item.href), item);
+    }
     for (const item of packageDoc.manifest) {
       if (item.mediaType === "application/xhtml+xml") {
         const fullPath = resolveManifestHref(opfDir, item.href);
@@ -2224,9 +2485,96 @@ var ContentValidator = class {
         if (refValidator) {
           this.extractSVGReferences(context, fullPath, opfDir, refValidator);
         }
+      } else if (item.mediaType === "application/smil+xml") {
+        const fullPath = resolveManifestHref(opfDir, item.href);
+        const smilValidator = new SMILValidator();
+        const result = smilValidator.validate(context, fullPath, manifestByPath);
+        overlayDocMap.set(item.id, result.referencedDocuments);
+        if (refValidator) {
+          for (const textRef of result.textReferences) {
+            const refUrl = textRef.fragment ? `${textRef.docPath}#${textRef.fragment}` : textRef.docPath;
+            const location = textRef.line != null ? { path: fullPath, line: textRef.line } : { path: fullPath };
+            const ref = {
+              url: refUrl,
+              targetResource: textRef.docPath,
+              type: "overlay-text-link" /* OVERLAY_TEXT_LINK */,
+              location
+            };
+            if (textRef.fragment !== void 0) ref.fragment = textRef.fragment;
+            refValidator.addReference(ref);
+            context.overlayTextLinks ??= [];
+            const link = {
+              targetResource: textRef.docPath,
+              location
+            };
+            if (textRef.fragment !== void 0) link.fragment = textRef.fragment;
+            context.overlayTextLinks.push(link);
+          }
+        }
+        if (result.hasRemoteResources) {
+          const properties = item.properties ?? [];
+          if (!properties.includes("remote-resources")) {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_014,
+              message: `The "remote-resources" property must be set on the media overlay item "${item.href}" because it references remote audio resources`,
+              location: { path: context.opfPath ?? "" }
+            });
+          }
+        }
       }
       this.validateMediaFile(context, item, opfDir);
     }
+    this.validateMediaOverlayCrossRefs(context, packageDoc, opfDir, overlayDocMap);
+  }
+  validateMediaOverlayCrossRefs(context, packageDoc, opfDir, overlayDocMap) {
+    if (overlayDocMap.size === 0) return;
+    const docToOverlays = /* @__PURE__ */ new Map();
+    for (const [overlayId, docPaths] of overlayDocMap) {
+      for (const docPath of docPaths) {
+        const existing = docToOverlays.get(docPath) ?? [];
+        existing.push(overlayId);
+        docToOverlays.set(docPath, existing);
+      }
+    }
+    const opfPath = context.opfPath ?? "";
+    for (const item of packageDoc.manifest) {
+      if (item.mediaType !== "application/xhtml+xml" && item.mediaType !== "image/svg+xml") {
+        continue;
+      }
+      const fullPath = resolveManifestHref(opfDir, item.href);
+      const referencingOverlays = docToOverlays.get(fullPath);
+      if (referencingOverlays && referencingOverlays.length > 0) {
+        if (referencingOverlays.length > 1) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_011,
+            message: `EPUB Content Document "${item.href}" referenced from multiple Media Overlay Documents`,
+            location: { path: opfPath }
+          });
+        }
+        if (!item.mediaOverlay) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_010,
+            message: `EPUB Content Document "${item.href}" referenced from a Media Overlay must specify the "media-overlay" attribute`,
+            location: { path: opfPath }
+          });
+        } else if (!referencingOverlays.includes(item.mediaOverlay)) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_012,
+            message: `The "media-overlay" attribute does not match the ID of the Media Overlay that refers to this document`,
+            location: { path: opfPath }
+          });
+        }
+      } else if (item.mediaOverlay) {
+        const overlayDocs = overlayDocMap.get(item.mediaOverlay);
+        if (overlayDocs && !overlayDocs.has(fullPath)) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_013,
+            message: `Media Overlay Document referenced from the "media-overlay" attribute does not contain a reference to this Content Document`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
   }
   validateMediaFile(context, item, opfDir) {
     const declaredType = item.mediaType;
@@ -2324,6 +2672,7 @@ var ContentValidator = class {
           });
         }
       }
+      this.checkMediaOverlayActiveClassCSS(context, path, root, manifestItem, svgContent);
     } finally {
       doc.dispose();
     }
@@ -2848,6 +3197,7 @@ var ContentValidator = class {
       this.checkHttpEquivCharset(context, path, root);
       this.checkLangMismatch(context, path, root);
       this.checkDpubAriaDeprecated(context, path, root);
+      this.validateIdRefs(context, path, root);
       this.checkTableBorder(context, path, root);
       this.checkTimeElement(context, path, root);
       this.checkMathMLAnnotations(context, path, root);
@@ -2855,6 +3205,7 @@ var ContentValidator = class {
       this.checkDataAttributes(context, path, root);
       this.checkAccessibility(context, path, root);
       this.validateImages(context, path, root);
+      this.checkUsemapAttribute(context, path, root);
       if (context.version.startsWith("3")) {
         this.validateEpubTypes(context, path, root);
       }
@@ -2867,8 +3218,24 @@ var ContentValidator = class {
         this.extractAndRegisterIDs(path, root, registry);
       }
       if (refValidator && opfDir !== void 0) {
-        this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, !!isNavItem);
-        this.extractAndRegisterStylesheets(context, path, root, opfDir, refValidator);
+        const remoteXmlBase = this.getRemoteXmlBase(root);
+        this.extractAndRegisterHyperlinks(
+          context,
+          path,
+          root,
+          opfDir,
+          refValidator,
+          !!isNavItem,
+          remoteXmlBase
+        );
+        this.extractAndRegisterStylesheets(
+          context,
+          path,
+          root,
+          opfDir,
+          refValidator,
+          remoteXmlBase
+        );
         this.extractAndRegisterImages(context, path, root, opfDir, refValidator, registry);
         this.extractAndRegisterMathMLAltimg(path, root, opfDir, refValidator);
         this.extractAndRegisterScripts(path, root, opfDir, refValidator);
@@ -2883,10 +3250,65 @@ var ContentValidator = class {
           registry
         );
       }
+      this.checkMediaOverlayActiveClassCSS(context, path, root, manifestItem);
     } finally {
       doc.dispose();
     }
   }
+  /**
+   * CSS-030: If media:active-class or media:playback-active-class is declared in OPF,
+   * and this content document has a media-overlay, it must have at least some CSS.
+   */
+  checkMediaOverlayActiveClassCSS(context, path, root, manifestItem, decodedContent) {
+    if (!manifestItem?.mediaOverlay) return;
+    if (!context.mediaActiveClass && !context.mediaPlaybackActiveClass) return;
+    const isSVG = root.name === "svg" || root.name.endsWith(":svg");
+    let hasCSS = false;
+    if (isSVG) {
+      try {
+        const styles = root.find(".//svg:style", { svg: "http://www.w3.org/2000/svg" });
+        if (styles.length > 0) hasCSS = true;
+      } catch {
+      }
+      if (!hasCSS) {
+        try {
+          const links = root.find(".//html:link", XHTML_NS);
+          if (links.length > 0) hasCSS = true;
+        } catch {
+        }
+      }
+      if (!hasCSS) {
+        const content = decodedContent ?? new TextDecoder().decode(context.files.get(path));
+        if (content.includes("<?xml-stylesheet")) hasCSS = true;
+      }
+    } else {
+      try {
+        const links = root.find(".//html:link[@rel]", XHTML_NS);
+        for (const link of links) {
+          const rel = this.getAttribute(link, "rel");
+          if (rel?.toLowerCase().includes("stylesheet")) {
+            hasCSS = true;
+            break;
+          }
+        }
+      } catch {
+      }
+      if (!hasCSS) {
+        try {
+          const styles = root.find(".//html:style", XHTML_NS);
+          if (styles.length > 0) hasCSS = true;
+        } catch {
+        }
+      }
+    }
+    if (!hasCSS) {
+      pushMessage(context.messages, {
+        id: MessageId.CSS_030,
+        message: 'The "media:active-class" property is declared in the package document but no CSS was found in this content document',
+        location: { path }
+      });
+    }
+  }
   parseLibxmlError(error) {
     const lineRegex = /(?:Entity:\s*)?line\s+(\d+):/;
     const lineMatch = lineRegex.exec(error);
@@ -3627,6 +4049,92 @@ var ContentValidator = class {
     } catch {
     }
   }
+  collectIds(root) {
+    const ids = /* @__PURE__ */ new Set();
+    try {
+      for (const el of root.find(".//*[@id]")) {
+        const id = this.getAttribute(el, "id");
+        if (id) ids.add(id);
+      }
+    } catch {
+    }
+    return ids;
+  }
+  validateIdRefs(context, path, root) {
+    try {
+      const allIds = this.collectIds(root);
+      const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+      const idrefsChecks = [
+        { xpath: ".//*[@aria-describedby]", attr: "aria-describedby" },
+        { xpath: ".//*[@aria-flowto]", attr: "aria-flowto" },
+        { xpath: ".//*[@aria-labelledby]", attr: "aria-labelledby" },
+        { xpath: ".//*[@aria-owns]", attr: "aria-owns" },
+        { xpath: ".//*[@aria-controls]", attr: "aria-controls" },
+        { xpath: ".//html:output[@for]", attr: "for", ns: HTML_NS },
+        {
+          xpath: ".//html:td[@headers] | .//html:th[@headers]",
+          attr: "headers",
+          ns: HTML_NS
+        }
+      ];
+      for (const { xpath, attr, ns } of idrefsChecks) {
+        const elements = ns ? root.find(xpath, ns) : root.find(xpath);
+        for (const elem of elements) {
+          const value = this.getAttribute(elem, attr);
+          if (!value) continue;
+          const idrefs = value.trim().split(/\s+/);
+          if (idrefs.some((idref) => !allIds.has(idref))) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The ${attr} attribute must refer to elements in the same document (target ID missing)`,
+              location: { path, line: elem.line }
+            });
+          }
+        }
+      }
+      const activedescMsg = "The aria-activedescendant attribute must refer to a descendant element.";
+      for (const elem of root.find(".//*[@aria-activedescendant]")) {
+        const idref = this.getAttribute(elem, "aria-activedescendant");
+        if (!idref) continue;
+        if (!allIds.has(idref)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: activedescMsg,
+            location: { path, line: elem.line }
+          });
+        } else {
+          try {
+            if (elem.find(`.//*[@id="${idref}"]`).length === 0) {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: activedescMsg,
+                location: { path, line: elem.line }
+              });
+            }
+          } catch {
+          }
+        }
+      }
+      for (const elem of root.find(".//*[@aria-describedat]")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'attribute "aria-describedat" not allowed here',
+          location: { path, line: elem.line }
+        });
+      }
+      for (const elem of root.find(".//html:label[@for]", HTML_NS)) {
+        const idref = this.getAttribute(elem, "for");
+        if (idref && !allIds.has(idref)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The for attribute must refer to an element in the same document (the ID "${idref}" does not exist).`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
   validateEpubSwitch(context, path, root) {
     const EPUB_NS = { epub: "http://www.idpf.org/2007/ops" };
     try {
@@ -3715,15 +4223,7 @@ var ContentValidator = class {
     try {
       const triggers = root.find(".//epub:trigger", EPUB_NS);
       if (triggers.length === 0) return;
-      const allIds = /* @__PURE__ */ new Set();
-      try {
-        const idElements = root.find(".//*[@id]");
-        for (const el of idElements) {
-          const idAttr = this.getAttribute(el, "id");
-          if (idAttr) allIds.add(idAttr);
-        }
-      } catch {
-      }
+      const allIds = this.collectIds(root);
       for (const trigger of triggers) {
         pushMessage(context.messages, {
           id: MessageId.RSC_017,
@@ -3854,6 +4354,22 @@ var ContentValidator = class {
     } catch {
     }
   }
+  checkUsemapAttribute(context, path, root) {
+    try {
+      const elements = root.find(".//html:*[@usemap]", XHTML_NS);
+      for (const elem of elements) {
+        const usemap = this.getAttribute(elem, "usemap");
+        if (usemap !== null && !/^#.+$/.test(usemap)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "usemap" is invalid; must be a string matching the regular expression "#.+"`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
   checkTimeElement(context, path, root) {
     const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
     try {
@@ -4165,6 +4681,14 @@ var ContentValidator = class {
       const elemTyped = elem;
       const epubTypeAttr = elemTyped.attr("type", "epub");
       if (!epubTypeAttr?.value) continue;
+      if (EPUB_TYPE_FORBIDDEN_ELEMENTS.has(elemTyped.name)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `attribute "epub:type" not allowed here`,
+          location: { path, line: elem.line }
+        });
+        continue;
+      }
       for (const part of epubTypeAttr.value.split(/\s+/)) {
         if (!part) continue;
         const hasPrefix = part.includes(":");
@@ -4260,6 +4784,17 @@ var ContentValidator = class {
     const attr = attrs.find((a) => a.name === name);
     return attr?.value ?? null;
   }
+  /**
+   * Get remote xml:base URL from the document root element.
+   * Returns the URL if it's remote (http/https), or null otherwise.
+   */
+  getRemoteXmlBase(root) {
+    const xmlBase = root.attr("base", "xml")?.value ?? null;
+    if (xmlBase?.startsWith("http://") || xmlBase?.startsWith("https://")) {
+      return xmlBase;
+    }
+    return null;
+  }
   validateViewportMeta(context, path, root, manifestItem) {
     const packageDoc = context.packageDocument;
     const isFixedLayout = manifestItem && packageDoc ? isItemFixedLayout(packageDoc, manifestItem.id) : false;
@@ -4388,7 +4923,7 @@ var ContentValidator = class {
       }
     }
   }
-  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, isNavDocument = false) {
+  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, isNavDocument = false, remoteXmlBase = null) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
     const navAnchorTypes = /* @__PURE__ */ new Map();
     if (isNavDocument) {
@@ -4452,6 +4987,15 @@ var ContentValidator = class {
         });
         continue;
       }
+      if (remoteXmlBase && !ABSOLUTE_URI_RE.test(href)) {
+        const resolvedUrl = new URL(href, remoteXmlBase).href;
+        pushMessage(context.messages, {
+          id: MessageId.RSC_006,
+          message: `Remote resource reference is not allowed; resource "${resolvedUrl}" must be located in the EPUB container`,
+          location: { path, line }
+        });
+        continue;
+      }
       const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
       const hashIndex = resolvedPath.indexOf("#");
       const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
@@ -4561,11 +5105,12 @@ var ContentValidator = class {
       refValidator.addReference(svgRef);
     }
   }
-  extractAndRegisterStylesheets(context, path, root, opfDir, refValidator) {
+  extractAndRegisterStylesheets(context, path, root, opfDir, refValidator, remoteXmlBase = null) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
     const baseElem = root.get(".//html:base[@href]", { html: "http://www.w3.org/1999/xhtml" });
     const baseHref = baseElem ? this.getAttribute(baseElem, "href") : null;
-    const remoteBaseUrl = baseHref?.startsWith("http://") || baseHref?.startsWith("https://") ? baseHref : null;
+    const effectiveBase = baseHref ?? remoteXmlBase;
+    const remoteBaseUrl = effectiveBase?.startsWith("http://") || effectiveBase?.startsWith("https://") ? effectiveBase : null;
     const linkElements = root.find(".//html:link[@href]", { html: "http://www.w3.org/1999/xhtml" });
     for (const linkElem of linkElements) {
       const href = this.getAttribute(linkElem, "href");
@@ -5649,6 +6194,8 @@ var OCFValidator = class {
     this.validateUtf8Filenames(zip, context.messages);
     this.validateEmptyDirectories(zip, context.messages);
     this.parseEncryption(zip, context);
+    this.validateEncryptionXml(context);
+    this.validateSignaturesXml(context);
   }
   /**
    * Validate the mimetype file
@@ -6005,6 +6552,93 @@ var OCFValidator = class {
       context.obfuscatedResources = obfuscated;
     }
   }
+  /**
+   * Validate encryption.xml structure:
+   * - Root element must be "encryption" in OCF namespace
+   * - Compression Method must be "0" or "8"
+   * - Compression OriginalLength must be a non-negative integer
+   * - All Id attributes must be unique
+   */
+  extractRootElementName(xml) {
+    const match = /<(\w+)[\s>]/.exec(xml.replace(/<\?xml[^?]*\?>/, "").trimStart());
+    return match?.[1] ?? null;
+  }
+  validateEncryptionXml(context) {
+    const encPath = "META-INF/encryption.xml";
+    const content = context.files.get(encPath);
+    if (!content) return;
+    const xml = new TextDecoder().decode(content);
+    const rootName = this.extractRootElementName(xml);
+    if (rootName !== null && rootName !== "encryption") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `expected element "encryption" but found "${rootName}"`,
+        location: { path: encPath }
+      });
+      return;
+    }
+    const idPattern = /\bId=["']([^"']+)["']/g;
+    const ids = /* @__PURE__ */ new Map();
+    let idMatch;
+    while ((idMatch = idPattern.exec(xml)) !== null) {
+      const id = idMatch[1] ?? "";
+      ids.set(id, (ids.get(id) ?? 0) + 1);
+    }
+    for (const [id, count] of ids) {
+      if (count > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Duplicate "${id}"`,
+          location: { path: encPath }
+        });
+      }
+    }
+    const compressionPattern = /<(?:\w+:)?Compression\s+([^>]*)\/?>/g;
+    let compMatch;
+    while ((compMatch = compressionPattern.exec(xml)) !== null) {
+      const attrs = compMatch[1] ?? "";
+      const methodMatch = /Method=["']([^"']*)["']/.exec(attrs);
+      const lengthMatch = /OriginalLength=["']([^"']*)["']/.exec(attrs);
+      if (methodMatch) {
+        const method = methodMatch[1] ?? "";
+        if (method !== "0" && method !== "8") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "Method" is invalid; must be "0" or "8"`,
+            location: { path: encPath }
+          });
+        }
+      }
+      if (lengthMatch) {
+        const length = lengthMatch[1] ?? "";
+        if (!/^\d+$/.test(length)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "OriginalLength" is invalid; must be a non-negative integer`,
+            location: { path: encPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate signatures.xml structure:
+   * - Root element must be "signatures" in OCF namespace
+   */
+  validateSignaturesXml(context) {
+    const sigPath = "META-INF/signatures.xml";
+    const content = context.files.get(sigPath);
+    if (!content) return;
+    const xml = new TextDecoder().decode(content);
+    const rootName = this.extractRootElementName(xml);
+    if (rootName !== null && rootName !== "signatures") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `expected element "signatures" but found "${rootName}"`,
+        location: { path: sigPath }
+      });
+    }
+  }
   /**
    * Validate empty directories
    */
@@ -6032,6 +6666,65 @@ var OCFValidator = class {
   }
 };
 
+// src/util/encoding.ts
+function sniffXmlEncoding(data) {
+  if (data.length < 2) return null;
+  if (data.length >= 4) {
+    if (data[0] === 0 && data[1] === 0 && data[2] === 254 && data[3] === 255) {
+      return "UCS-4";
+    }
+    if (data[0] === 255 && data[1] === 254 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 255 && data[3] === 254) {
+      return "UCS-4";
+    }
+    if (data[0] === 254 && data[1] === 255 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 0 && data[3] === 60) {
+      return "UCS-4";
+    }
+    if (data[0] === 60 && data[1] === 0 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 60 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+  }
+  if (data[0] === 254 && data[1] === 255) {
+    return "UTF-16";
+  }
+  if (data[0] === 255 && data[1] === 254) {
+    return "UTF-16";
+  }
+  if (data.length >= 4) {
+    if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63) {
+      return "UTF-16";
+    }
+    if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0) {
+      return "UTF-16";
+    }
+  }
+  if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
+    return null;
+  }
+  if (data.length >= 4 && data[0] === 76 && data[1] === 111 && data[2] === 167 && data[3] === 148) {
+    return "EBCDIC";
+  }
+  const prefix = String.fromCharCode(...data.slice(0, Math.min(256, data.length)));
+  const match = /^<\?xml[^?]*\bencoding\s*=\s*["']([^"']+)["']/.exec(prefix);
+  if (match) {
+    const declared = (match[1] ?? "").toUpperCase();
+    if (declared === "UTF-8") return null;
+    return declared;
+  }
+  return null;
+}
+
 // src/opf/parser.ts
 function parseOPF(xml) {
   const packageRegex = /<package[^>]*\sversion=["']([^"']+)["'][^>]*(?:\sunique-identifier=["']([^"']+)["'])?[^>]*>/;
@@ -6382,6 +7075,25 @@ var DEPRECATED_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "application/x-oeb1-package",
   "text/x-oeb1-html"
 ]);
+function getPreferredMediaType(mimeType, path) {
+  switch (mimeType) {
+    case "application/font-sfnt":
+      if (path.endsWith(".ttf")) return "font/ttf";
+      if (path.endsWith(".otf")) return "font/otf";
+      return "font/(ttf|otf)";
+    case "application/vnd.ms-opentype":
+      return "font/otf";
+    case "application/font-woff":
+      return "font/woff";
+    case "application/x-font-ttf":
+      return "font/ttf";
+    case "text/javascript":
+    case "application/ecmascript":
+      return "application/javascript";
+    default:
+      return null;
+  }
+}
 var VALID_RELATOR_CODES = /* @__PURE__ */ new Set([
   "abr",
   "acp",
@@ -6718,7 +7430,6 @@ var RENDITION_META_RULES = [
 var KNOWN_RENDITION_META_PROPERTIES = new Set(
   RENDITION_META_RULES.map((r) => r.property.slice("rendition:".length))
 );
-var SMIL3_CLOCK_RE = /^([0-9]+:[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|[0-9]+(\.[0-9]+)?(h|min|s|ms)?)$/;
 var GRANDFATHERED_LANG_TAGS = /* @__PURE__ */ new Set([
   "en-GB-oed",
   "i-ami",
@@ -6772,6 +7483,20 @@ var OPFValidator = class {
       });
       return;
     }
+    const encoding = sniffXmlEncoding(opfData);
+    if (encoding === "UTF-16") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_027,
+        message: `Detected non-UTF-8 encoding "${encoding}" in "${opfPath}"`,
+        location: { path: opfPath }
+      });
+    } else if (encoding !== null) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_028,
+        message: `Detected non-UTF-8 encoding "${encoding}" in "${opfPath}"`,
+        location: { path: opfPath }
+      });
+    }
     const opfXml = new TextDecoder().decode(opfData);
     try {
       this.packageDoc = parseOPF(opfXml);
@@ -7063,6 +7788,7 @@ var OPFValidator = class {
       this.validateMetaPropertiesVocab(context, opfPath, dcElements);
       this.validateRenditionVocab(context, opfPath);
       this.validateMediaOverlaysVocab(context, opfPath);
+      this.validateMediaOverlayItems(context, opfPath);
     }
     if (this.packageDoc.version !== "2.0") {
       const modifiedMetas = this.packageDoc.metaElements.filter(
@@ -7430,19 +8156,42 @@ var OPFValidator = class {
   validateMediaOverlaysVocab(context, opfPath) {
     if (!this.packageDoc) return;
     const metas = this.packageDoc.metaElements;
-    for (const prop of ["media:active-class", "media:playback-active-class"]) {
-      if (metas.filter((m) => m.property === prop).length > 1) {
-        const displayName = prop.slice("media:".length);
+    const matchingActive = metas.filter((m) => m.property === "media:active-class");
+    const matchingPlayback = metas.filter((m) => m.property === "media:playback-active-class");
+    for (const [prop, matching] of [
+      ["media:active-class", matchingActive],
+      ["media:playback-active-class", matchingPlayback]
+    ]) {
+      const displayName = prop.slice("media:".length);
+      if (matching.length > 1) {
         pushMessage(context.messages, {
           id: MessageId.RSC_005,
           message: `The '${displayName}' property must not occur more than one time in the package metadata`,
           location: { path: opfPath }
         });
       }
+      for (const meta of matching) {
+        if (meta.refines) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `@refines must not be used with the ${prop} property`,
+            location: { path: opfPath }
+          });
+        }
+        if (meta.value.trim().includes(" ")) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `the '${displayName}' property must define a single class name`,
+            location: { path: opfPath }
+          });
+        }
+      }
     }
+    if (matchingActive[0]) context.mediaActiveClass = matchingActive[0].value.trim();
+    if (matchingPlayback[0]) context.mediaPlaybackActiveClass = matchingPlayback[0].value.trim();
     for (const meta of metas) {
       if (meta.property === "media:duration") {
-        if (!SMIL3_CLOCK_RE.test(meta.value.trim())) {
+        if (!isValidSmilClock(meta.value.trim())) {
           pushMessage(context.messages, {
             id: MessageId.RSC_005,
             message: `The value of the "media:duration" property must be a valid SMIL3 clock value`,
@@ -7451,6 +8200,84 @@ var OPFValidator = class {
         }
       }
     }
+    const globalDuration = metas.find((m) => m.property === "media:duration" && !m.refines);
+    if (globalDuration) {
+      const totalSeconds = parseSmilClock(globalDuration.value.trim());
+      if (!Number.isNaN(totalSeconds)) {
+        let sumSeconds = 0;
+        let allValid = true;
+        for (const meta of metas) {
+          if (meta.property === "media:duration" && meta.refines) {
+            const s = parseSmilClock(meta.value.trim());
+            if (Number.isNaN(s)) {
+              allValid = false;
+              break;
+            }
+            sumSeconds += s;
+          }
+        }
+        if (allValid && Math.abs(totalSeconds - sumSeconds) > 1) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_016,
+            message: `Media Overlays total duration should be the sum of the durations of all Media Overlays documents.`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate media-overlay manifest item constraints:
+   * - media-overlay must reference a SMIL item (application/smil+xml)
+   * - media-overlay attribute only allowed on XHTML and SVG content documents
+   * - Global media:duration required when overlays exist
+   * - Per-item media:duration required for each overlay
+   */
+  validateMediaOverlayItems(context, opfPath) {
+    if (!this.packageDoc) return;
+    const manifest = this.packageDoc.manifest;
+    const metas = this.packageDoc.metaElements;
+    const itemsWithOverlay = manifest.filter((item) => item.mediaOverlay);
+    if (itemsWithOverlay.length === 0) return;
+    for (const item of itemsWithOverlay) {
+      const moId = item.mediaOverlay;
+      if (!moId) continue;
+      const moItem = this.manifestById.get(moId);
+      if (moItem && moItem.mediaType !== "application/smil+xml") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `media overlay items must be of the "application/smil+xml" type (given type was "${moItem.mediaType}")`,
+          location: { path: opfPath }
+        });
+      }
+      if (item.mediaType !== "application/xhtml+xml" && item.mediaType !== "image/svg+xml") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `The media-overlay attribute is only allowed on XHTML and SVG content documents.`,
+          location: { path: opfPath }
+        });
+      }
+    }
+    if (!metas.some((m) => m.property === "media:duration" && !m.refines)) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `global media:duration meta element not set`,
+        location: { path: opfPath }
+      });
+    }
+    const overlayIds = new Set(
+      itemsWithOverlay.map((item) => item.mediaOverlay).filter((id) => id != null && this.manifestById.has(id))
+    );
+    for (const overlayId of overlayIds) {
+      const refinesUri = `#${overlayId}`;
+      if (!metas.some((m) => m.property === "media:duration" && m.refines === refinesUri)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `item media:duration meta element not set (expecting: meta property='media:duration' refines='${refinesUri}')`,
+          location: { path: opfPath }
+        });
+      }
+    }
   }
   /**
    * Validate EPUB 3 link elements in metadata
@@ -7683,6 +8510,14 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
+      const preferred = getPreferredMediaType(item.mediaType, fullPath);
+      if (preferred !== null) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_090,
+          message: `Encouraged to use media type "${preferred}" instead of "${item.mediaType}"`,
+          location: { path: opfPath }
+        });
+      }
       if (this.packageDoc.version !== "2.0" && item.properties) {
         for (const prop of item.properties) {
           if (!ITEM_PROPERTIES.has(prop)) {
@@ -8438,7 +9273,7 @@ var ReferenceValidator = class {
         location: reference.location
       });
     }
-    if (!this.registry.hasResource(resourcePath)) {
+    if (reference.type !== "overlay-text-link" /* OVERLAY_TEXT_LINK */ && !this.registry.hasResource(resourcePath)) {
       const fileExistsInContainer = context.files.has(resourcePath);
       if (fileExistsInContainer) {
         if (!context.referencedUndeclaredResources?.has(resourcePath)) {
@@ -8575,6 +9410,24 @@ var ReferenceValidator = class {
         });
       }
     }
+    if (reference.type === "overlay-text-link" /* OVERLAY_TEXT_LINK */ && resource) {
+      if (resource.mimeType === "application/xhtml+xml" && /^\w+\(/.test(fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.MED_017,
+          message: `URL fragment should indicate an element ID, but found '#${fragment}'`,
+          location: reference.location
+        });
+        return;
+      }
+      if (resource.mimeType === "image/svg+xml" && !this.isValidSVGFragment(fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.MED_018,
+          message: `URL fragment should be an SVG fragment identifier, but found '#${fragment}'`,
+          location: reference.location
+        });
+        return;
+      }
+    }
     const parsedMimeTypes = ["application/xhtml+xml", "image/svg+xml"];
     if (resource && parsedMimeTypes.includes(resource.mimeType) && !isRemoteURL(resourcePath) && !fragment.includes("svgView(") && reference.type !== "svg-symbol" /* SVG_SYMBOL */) {
       if (!this.registry.hasID(resourcePath, fragment)) {
@@ -8586,6 +9439,18 @@ var ReferenceValidator = class {
       }
     }
   }
+  /**
+   * Check if a fragment is a valid SVG fragment identifier.
+   * Valid forms: bare NCName ID, svgView(...), t=..., xywh=..., id=...
+   */
+  isValidSVGFragment(fragment) {
+    if (/^svgView\(.*\)$/.test(fragment)) return true;
+    if (fragment.startsWith("t=")) return true;
+    if (fragment.startsWith("xywh=")) return true;
+    if (fragment.startsWith("id=")) return true;
+    if (!fragment.includes("=") && /^[a-zA-Z_][\w.-]*$/.test(fragment)) return true;
+    return false;
+  }
   /**
    * Check non-spine remote resources that have non-standard types.
    * Fires RSC-006 for remote items that aren't audio/video/font types
@@ -8645,7 +9510,7 @@ var ReferenceValidator = class {
     }
   }
   checkReadingOrder(context) {
-    if (!context.tocLinks || !context.packageDocument) return;
+    if (!context.packageDocument) return;
     const packageDoc = context.packageDocument;
     const spine = packageDoc.spine;
     const opfPath = context.opfPath ?? "";
@@ -8657,15 +9522,35 @@ var ReferenceValidator = class {
         spinePositionMap.set(resolveManifestHref(opfDir, item.href), i);
       }
     }
+    if (context.tocLinks) {
+      this.checkLinkReadingOrder(
+        context,
+        spinePositionMap,
+        context.tocLinks,
+        MessageId.NAV_011,
+        '"toc" nav'
+      );
+    }
+    if (context.overlayTextLinks) {
+      this.checkLinkReadingOrder(
+        context,
+        spinePositionMap,
+        context.overlayTextLinks,
+        MessageId.MED_015,
+        "Media overlay text"
+      );
+    }
+  }
+  checkLinkReadingOrder(context, spinePositionMap, links, messageId, label) {
     let lastSpinePosition = -1;
     let lastAnchorPosition = -1;
-    for (const link of context.tocLinks) {
+    for (const link of links) {
       const spinePos = spinePositionMap.get(link.targetResource);
       if (spinePos === void 0) continue;
       if (spinePos < lastSpinePosition) {
         pushMessage(context.messages, {
-          id: MessageId.NAV_011,
-          message: `"toc" nav must be in reading order; link target "${link.targetResource}" is before the previous link's target in spine order`,
+          id: messageId,
+          message: `${label} must be in reading order; link target "${link.targetResource}" is before the previous link's target in spine order`,
           location: link.location
         });
         lastSpinePosition = spinePos;
@@ -8680,8 +9565,8 @@ var ReferenceValidator = class {
           if (targetAnchorPosition < lastAnchorPosition) {
             const target = link.fragment ? `${link.targetResource}#${link.fragment}` : link.targetResource;
             pushMessage(context.messages, {
-              id: MessageId.NAV_011,
-              message: `"toc" nav must be in reading order; link target "${target}" is before the previous link's target in document order`,
+              id: messageId,
+              message: `${label} must be in reading order; link target "${target}" is before the previous link's target in document order`,
               location: link.location
             });
           }
@@ -8900,11 +9785,11 @@ var RelaxNGValidator = class extends BaseSchemaValidator {
     try {
       const libxml2 = await import('libxml2-wasm');
       const LibRelaxNGValidator = libxml2.RelaxNGValidator;
-      const { XmlDocument: XmlDocument3 } = libxml2;
-      const doc = XmlDocument3.fromString(xml);
+      const { XmlDocument: XmlDocument4 } = libxml2;
+      const doc = XmlDocument4.fromString(xml);
       try {
         const schemaContent = await loadSchema(schemaPath);
-        const schemaDoc = XmlDocument3.fromString(schemaContent);
+        const schemaDoc = XmlDocument4.fromString(schemaContent);
         try {
           const validator = LibRelaxNGValidator.fromDoc(schemaDoc);
           try {