@likecoin/epubcheck-ts 0.3.6 → 0.3.8

package/dist/index.cjs

@@ -439,6 +439,11 @@ var MessageDefs = {
     severity: "warning",
     description: "Property is deprecated"
   },
+  OPF_086b: {
+    id: "OPF-086b",
+    severity: "usage",
+    description: "epub:type value is deprecated"
+  },
   OPF_087: {
     id: "OPF-087",
     severity: "usage",
@@ -1362,13 +1367,6 @@ var CSSValidator = class {
         location
       });
     }
-    if (value === "absolute") {
-      pushMessage(context.messages, {
-        id: MessageId.CSS_019,
-        message: 'CSS property "position: absolute" should be used with caution in EPUB',
-        location
-      });
-    }
   }
   /**
    * Extract the value from a Declaration node
@@ -1706,24 +1704,113 @@ var SPINE_PROPERTIES = /* @__PURE__ */ new Set([
   "rendition:layout-pre-paginated",
   "rendition:orientation-auto",
   "rendition:orientation-landscape",
-  "rendition:orientation-portrait"
+  "rendition:orientation-portrait",
+  "rendition:flow-auto",
+  "rendition:flow-paginated",
+  "rendition:flow-scrolled-continuous",
+  "rendition:flow-scrolled-doc",
+  "rendition:align-x-center"
 ]);
 
 // src/references/types.ts
+var PUBLICATION_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "generic" /* GENERIC */,
+  "stylesheet" /* STYLESHEET */,
+  "font" /* FONT */,
+  "image" /* IMAGE */,
+  "audio" /* AUDIO */,
+  "video" /* VIDEO */,
+  "track" /* TRACK */,
+  "media-overlay" /* MEDIA_OVERLAY */,
+  "svg-symbol" /* SVG_SYMBOL */,
+  "svg-paint" /* SVG_PAINT */,
+  "svg-clip-path" /* SVG_CLIP_PATH */
+]);
 function isPublicationResourceReference(type) {
-  return [
-    "generic" /* GENERIC */,
-    "stylesheet" /* STYLESHEET */,
-    "font" /* FONT */,
-    "image" /* IMAGE */,
-    "audio" /* AUDIO */,
-    "video" /* VIDEO */,
-    "track" /* TRACK */,
-    "media-overlay" /* MEDIA_OVERLAY */,
-    "svg-symbol" /* SVG_SYMBOL */,
-    "svg-paint" /* SVG_PAINT */,
-    "svg-clip-path" /* SVG_CLIP_PATH */
-  ].includes(type);
+  return PUBLICATION_RESOURCE_TYPES.has(type);
+}
+
+// src/references/uri-schemes.ts
+var URI_SCHEMES = /* @__PURE__ */ new Set([
+  "aaa",
+  "aaas",
+  "acap",
+  "afs",
+  "cap",
+  "cid",
+  "crid",
+  "data",
+  "dav",
+  "dict",
+  "dns",
+  "dtn",
+  "fax",
+  "file",
+  "ftp",
+  "go",
+  "gopher",
+  "h323",
+  "http",
+  "https",
+  "iax",
+  "icap",
+  "im",
+  "imap",
+  "info",
+  "ipp",
+  "irc",
+  "iris",
+  "iris.beep",
+  "iris.lwz",
+  "iris.xpc",
+  "iris.xpcs",
+  "javascript",
+  "ldap",
+  "mailto",
+  "mailserver",
+  "mid",
+  "modem",
+  "msrp",
+  "msrps",
+  "mtqp",
+  "mupdate",
+  "news",
+  "nfs",
+  "nntp",
+  "opaquelocktoken",
+  "pack",
+  "pop",
+  "pres",
+  "prospero",
+  "rtsp",
+  "service",
+  "shttp",
+  "sip",
+  "sips",
+  "snews",
+  "snmp",
+  "soap.beep",
+  "soap.beeps",
+  "tag",
+  "tel",
+  "telnet",
+  "tftp",
+  "thismessage",
+  "tip",
+  "tn3270",
+  "tv",
+  "urn",
+  "vemmi",
+  "videotex",
+  "wais",
+  "xmlrpc.beep",
+  "xmlrpc.beeps",
+  "xmpp",
+  "z39.50r",
+  "z39.50s"
+]);
+function isRegisteredScheme(scheme) {
+  return URI_SCHEMES.has(scheme.toLowerCase());
 }
 
 // src/references/url.ts
@@ -1761,15 +1848,9 @@ function hasParentDirectoryReference(url) {
   return url.includes("..");
 }
 function isMalformedURL(url) {
-  if (!url) return true;
-  try {
-    const trimmed = url.trim();
-    if (!trimmed) return true;
-    if (/[\s<>]/.test(trimmed)) return true;
-    return false;
-  } catch {
-    return true;
-  }
+  if (!url.trim()) return true;
+  if (/[\s<>]/.test(url)) return true;
+  return false;
 }
 function isHTTPS(url) {
   return url.startsWith("https://");
@@ -1804,7 +1885,205 @@ function resolveManifestHref(opfDir, href) {
 }
 
 // src/content/validator.ts
-var DISCOURAGED_ELEMENTS = /* @__PURE__ */ new Set(["base", "embed"]);
+var DISCOURAGED_ELEMENTS = /* @__PURE__ */ new Set(["base", "embed", "rp"]);
+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*"([^"]*)"/;
+function validateAbsoluteHyperlinkURL(context, href, path, line) {
+  const location = line != null ? { path, line } : { path };
+  const scheme = href.slice(0, href.indexOf(":")).toLowerCase();
+  if (!isRegisteredScheme(scheme)) {
+    pushMessage(context.messages, {
+      id: MessageId.HTM_025,
+      message: "Hyperlink uses non-registered URI scheme type",
+      location
+    });
+  }
+  if (/[\s<>]/.test(href) || SPECIAL_URL_SCHEMES.has(scheme) && !href.slice(href.indexOf(":")).startsWith("://")) {
+    pushMessage(context.messages, {
+      id: MessageId.RSC_020,
+      message: `URL is not valid: "${href}"`,
+      location
+    });
+  }
+}
+var IMAGE_MAGIC = [
+  { mime: "image/jpeg", bytes: [255, 216], extensions: [".jpg", ".jpeg", ".jpe"] },
+  { mime: "image/gif", bytes: [71, 73, 70, 56], extensions: [".gif"] },
+  { mime: "image/png", bytes: [137, 80, 78, 71], extensions: [".png"] },
+  { mime: "image/webp", bytes: [82, 73, 70, 70], extensions: [".webp"] }
+];
+function stripMimeParams(t) {
+  const idx = t.indexOf(";");
+  return (idx >= 0 ? t.substring(0, idx) : t).trim();
+}
+var EPUB_SSV_DEPRECATED = /* @__PURE__ */ new Set([
+  "annoref",
+  "annotation",
+  "biblioentry",
+  "bridgehead",
+  "endnote",
+  "help",
+  "marginalia",
+  "note",
+  "rearnote",
+  "rearnotes",
+  "sidebar",
+  "subchapter",
+  "warning"
+]);
+var EPUB_SSV_DISALLOWED_ON_CONTENT = /* @__PURE__ */ new Set([
+  "aside",
+  "figure",
+  "list",
+  "list-item",
+  "table",
+  "table-cell",
+  "table-row"
+]);
+var EPUB_SSV_ALL = /* @__PURE__ */ new Set([
+  ...EPUB_SSV_DEPRECATED,
+  ...EPUB_SSV_DISALLOWED_ON_CONTENT,
+  "abstract",
+  "acknowledgments",
+  "afterword",
+  "appendix",
+  "assessment",
+  "assessments",
+  "backlink",
+  "backmatter",
+  "balloon",
+  "bibliography",
+  "biblioref",
+  "bodymatter",
+  "case-study",
+  "chapter",
+  "colophon",
+  "concluding-sentence",
+  "conclusion",
+  "contributors",
+  "copyright-page",
+  "cover",
+  "covertitle",
+  "credit",
+  "credits",
+  "dedication",
+  "division",
+  "endnotes",
+  "epigraph",
+  "epilogue",
+  "errata",
+  "fill-in-the-blank-problem",
+  "footnote",
+  "footnotes",
+  "foreword",
+  "frontmatter",
+  "fulltitle",
+  "general-problem",
+  "glossary",
+  "glossdef",
+  "glossref",
+  "glossterm",
+  "halftitle",
+  "halftitlepage",
+  "imprimatur",
+  "imprint",
+  "index",
+  "index-editor-note",
+  "index-entry",
+  "index-entry-list",
+  "index-group",
+  "index-headnotes",
+  "index-legend",
+  "index-locator",
+  "index-locator-list",
+  "index-locator-range",
+  "index-term",
+  "index-term-categories",
+  "index-term-category",
+  "index-xref-preferred",
+  "index-xref-related",
+  "introduction",
+  "keyword",
+  "keywords",
+  "label",
+  "landmarks",
+  "learning-objective",
+  "learning-objectives",
+  "learning-outcome",
+  "learning-outcomes",
+  "learning-resource",
+  "learning-resources",
+  "learning-standard",
+  "learning-standards",
+  "loa",
+  "loi",
+  "lot",
+  "lov",
+  "match-problem",
+  "multiple-choice-problem",
+  "noteref",
+  "notice",
+  "ordinal",
+  "other-credits",
+  "page-list",
+  "pagebreak",
+  "panel",
+  "panel-group",
+  "part",
+  "practice",
+  "practices",
+  "preamble",
+  "preface",
+  "prologue",
+  "pullquote",
+  "qna",
+  "question",
+  "referrer",
+  "revision-history",
+  "seriespage",
+  "sound-area",
+  "subtitle",
+  "tip",
+  "title",
+  "titlepage",
+  "toc",
+  "toc-brief",
+  "topic-sentence",
+  "true-false-problem",
+  "volume"
+]);
+var TIME_RE = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d{1,3})?)?$/;
+var TZ_RE = /(?:Z|[+-](?:[01]\d|2[0-3]):?[0-5]\d)$/;
+var DATE_RE = /^\d{4,}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
+var ISO_DURATION_RE = /^P(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d{1,3})?S)?)?$/;
+var INFORMAL_DURATION_RE = /^\s*(?:\d+(?:\.\d{1,3})?[WDHMS]\s*)+$/;
+function isValidDatetime(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (trimmed.startsWith("P")) {
+    if (!ISO_DURATION_RE.test(trimmed)) return false;
+    if (trimmed === "P" || trimmed === "PT") return false;
+    if (trimmed.endsWith("T")) return false;
+    return true;
+  }
+  if (INFORMAL_DURATION_RE.test(value)) return true;
+  if (/^\d{4,}$/.test(trimmed)) return true;
+  if (/^\d{4,}-(?:0[1-9]|1[0-2])$/.test(trimmed)) return true;
+  if (/^-?-?(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/.test(trimmed)) return true;
+  if (DATE_RE.test(trimmed)) return true;
+  if (/^\d{4,}-W(?:0[1-9]|[1-4]\d|5[0-3])$/.test(trimmed)) return true;
+  if (TIME_RE.test(trimmed)) return true;
+  const dtMatch = /^(\d{4,}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]))[T ]([\s\S]+)$/.exec(trimmed);
+  if (dtMatch?.[2]) {
+    let timePart = dtMatch[2];
+    const tzMatch = TZ_RE.exec(timePart);
+    if (tzMatch) timePart = timePart.substring(0, timePart.length - tzMatch[0].length);
+    return TIME_RE.test(timePart);
+  }
+  return false;
+}
 var HTML_ENTITIES = /* @__PURE__ */ new Set([
   "nbsp",
   "iexcl",
@@ -1903,7 +2182,18 @@ var HTML_ENTITIES = /* @__PURE__ */ new Set([
   "thorn",
   "yuml"
 ]);
+function isItemFixedLayout(packageDoc, itemId) {
+  const spineItem = packageDoc.spine.find((s) => s.idref === itemId);
+  if (!spineItem) return false;
+  if (spineItem.properties?.includes("rendition:layout-pre-paginated")) return true;
+  if (spineItem.properties?.includes("rendition:layout-reflowable")) return false;
+  const globalLayout = packageDoc.metaElements.find(
+    (m) => m.property === "rendition:layout" && !m.refines
+  );
+  return globalLayout?.value === "pre-paginated";
+}
 var ContentValidator = class {
+  cssWithRemoteResources = /* @__PURE__ */ new Set();
   validate(context, registry, refValidator) {
     const packageDoc = context.packageDocument;
     if (!packageDoc) {
@@ -1911,13 +2201,18 @@ var ContentValidator = class {
     }
     const opfPath = context.opfPath ?? "";
     const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+    if (refValidator) {
+      for (const item of packageDoc.manifest) {
+        if (item.mediaType === "text/css") {
+          const fullPath = resolveManifestHref(opfDir, item.href);
+          this.validateCSSDocument(context, fullPath, opfDir, refValidator);
+        }
+      }
+    }
     for (const item of packageDoc.manifest) {
       if (item.mediaType === "application/xhtml+xml") {
         const fullPath = resolveManifestHref(opfDir, item.href);
         this.validateXHTMLDocument(context, fullPath, item.id, opfDir, registry, refValidator);
-      } else if (item.mediaType === "text/css" && refValidator) {
-        const fullPath = resolveManifestHref(opfDir, item.href);
-        this.validateCSSDocument(context, fullPath, opfDir, refValidator);
       } else if (item.mediaType === "image/svg+xml") {
         const fullPath = resolveManifestHref(opfDir, item.href);
         if (registry) {
@@ -1930,6 +2225,47 @@ var ContentValidator = class {
           this.extractSVGReferences(context, fullPath, opfDir, refValidator);
         }
       }
+      this.validateMediaFile(context, item, opfDir);
+    }
+  }
+  validateMediaFile(context, item, opfDir) {
+    const declaredType = item.mediaType;
+    const magicEntry = IMAGE_MAGIC.find((m) => m.mime === declaredType);
+    if (!magicEntry) return;
+    const fullPath = resolveManifestHref(opfDir, item.href);
+    const fileData = context.files.get(fullPath);
+    if (!fileData) return;
+    const bytes = typeof fileData === "string" ? new TextEncoder().encode(fileData) : fileData;
+    if (bytes.length < 4) {
+      pushMessage(context.messages, {
+        id: MessageId.MED_004,
+        message: "Image file header may be corrupted",
+        location: { path: fullPath }
+      });
+      pushMessage(context.messages, {
+        id: MessageId.PKG_021,
+        message: "Corrupted image file encountered",
+        location: { path: fullPath }
+      });
+      return;
+    }
+    const headerMatches = magicEntry.bytes.every((b, i) => bytes[i] === b);
+    if (!headerMatches) {
+      const actualType = IMAGE_MAGIC.find((m) => m.bytes.every((b, i) => bytes[i] === b));
+      pushMessage(context.messages, {
+        id: MessageId.OPF_029,
+        message: `File does not match declared media type "${declaredType}"${actualType ? ` (appears to be ${actualType.mime})` : ""}`,
+        location: { path: fullPath }
+      });
+      return;
+    }
+    const ext = item.href.includes(".") ? item.href.substring(item.href.lastIndexOf(".")).toLowerCase() : "";
+    if (ext && !magicEntry.extensions.includes(ext)) {
+      pushMessage(context.messages, {
+        id: MessageId.PKG_022,
+        message: `Wrong file extension "${ext}" for declared media type "${declaredType}"`,
+        location: { path: fullPath }
+      });
     }
   }
   extractSVGIDs(context, path, registry) {
@@ -1972,6 +2308,22 @@ var ContentValidator = class {
           location: { path }
         });
       }
+      this.checkDuplicateIDs(context, path, root);
+      this.checkSVGInvalidIDs(context, path, root);
+      this.validateSvgEpubType(context, path, root);
+      this.checkUnknownEpubAttributes(context, path, root);
+      this.checkSVGLinkAccessibility(context, path, root);
+      const packageDoc = context.packageDocument;
+      if (packageDoc && isItemFixedLayout(packageDoc, manifestItem.id)) {
+        const viewBox = this.getAttribute(root, "viewBox");
+        if (!viewBox) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_048,
+            message: "SVG Fixed-Layout Documents must have a viewBox attribute on the outermost svg element",
+            location: { path }
+          });
+        }
+      }
     } finally {
       doc.dispose();
     }
@@ -2028,44 +2380,7 @@ var ContentValidator = class {
         }
       } catch {
       }
-      try {
-        const svgUseXlink = root.find(".//svg:use[@xlink:href]", {
-          svg: "http://www.w3.org/2000/svg",
-          xlink: "http://www.w3.org/1999/xlink"
-        });
-        const svgUseHref = root.find(".//svg:use[@href]", {
-          svg: "http://www.w3.org/2000/svg"
-        });
-        for (const useNode of [...svgUseXlink, ...svgUseHref]) {
-          const useElem = useNode;
-          const href = this.getAttribute(useElem, "xlink:href") ?? this.getAttribute(useElem, "href");
-          if (!href) continue;
-          if (href.startsWith("http://") || href.startsWith("https://")) continue;
-          if (!href.includes("#")) {
-            pushMessage(context.messages, {
-              id: MessageId.RSC_015,
-              message: `SVG "use" element requires a fragment identifier, but found "${href}"`,
-              location: { path, line: useNode.line }
-            });
-            continue;
-          }
-          const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
-          const hashIndex = resolvedPath.indexOf("#");
-          const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : path;
-          const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
-          const useRef = {
-            url: href,
-            targetResource,
-            type: "svg-symbol" /* SVG_SYMBOL */,
-            location: { path, line: useNode.line }
-          };
-          if (fragment) {
-            useRef.fragment = fragment;
-          }
-          refValidator.addReference(useRef);
-        }
-      } catch {
-      }
+      this.extractSVGUseReferences(context, path, root, docDir, opfDir, refValidator);
     } finally {
       doc.dispose();
     }
@@ -2103,6 +2418,57 @@ var ContentValidator = class {
       }
     }
   }
+  extractSVGUseReferences(context, path, root, docDir, opfDir, refValidator) {
+    try {
+      const svgUseXlink = root.find(".//svg:use[@xlink:href]", {
+        svg: "http://www.w3.org/2000/svg",
+        xlink: "http://www.w3.org/1999/xlink"
+      });
+      const svgUseHref = root.find(".//svg:use[@href]", {
+        svg: "http://www.w3.org/2000/svg"
+      });
+      for (const useNode of [...svgUseXlink, ...svgUseHref]) {
+        const useElem = useNode;
+        const href = this.getAttribute(useElem, "xlink:href") ?? this.getAttribute(useElem, "href");
+        if (href === null) continue;
+        if (href.startsWith("http://") || href.startsWith("https://")) continue;
+        const line = useNode.line;
+        if (href === "" || !href.includes("#")) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_015,
+            message: `SVG "use" element requires a fragment identifier, but found "${href}"`,
+            location: { path, line }
+          });
+          continue;
+        }
+        if (href.startsWith("#")) {
+          refValidator.addReference({
+            url: href,
+            targetResource: path,
+            fragment: href.slice(1),
+            type: "svg-symbol" /* SVG_SYMBOL */,
+            location: { path, line }
+          });
+          continue;
+        }
+        const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+        const hashIndex = resolvedPath.indexOf("#");
+        const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : path;
+        const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
+        const useRef = {
+          url: href,
+          targetResource,
+          type: "svg-symbol" /* SVG_SYMBOL */,
+          location: { path, line }
+        };
+        if (fragment) {
+          useRef.fragment = fragment;
+        }
+        refValidator.addReference(useRef);
+      }
+    } catch {
+    }
+  }
   detectSVGRemoteResources(root) {
     try {
       const fontFaceUris = root.find(".//svg:font-face-uri", {
@@ -2143,13 +2509,33 @@ var ContentValidator = class {
     if (!cssData) {
       return;
     }
-    const cssContent = new TextDecoder().decode(cssData);
+    let cssContent;
+    const utf16Encoding = cssData.length >= 2 && cssData[0] === 254 && cssData[1] === 255 ? "utf-16be" : cssData.length >= 2 && cssData[0] === 255 && cssData[1] === 254 ? "utf-16le" : null;
+    if (utf16Encoding) {
+      pushMessage(context.messages, {
+        id: MessageId.CSS_003,
+        message: "CSS documents should be encoded in UTF-8, but UTF-16 was detected",
+        location: { path }
+      });
+      cssContent = new TextDecoder(utf16Encoding).decode(cssData);
+    } else {
+      cssContent = new TextDecoder().decode(cssData);
+      const charsetMatch = CSS_CHARSET_RE.exec(cssContent);
+      if (charsetMatch?.[1] && charsetMatch[1].toLowerCase() !== "utf-8") {
+        pushMessage(context.messages, {
+          id: MessageId.CSS_004,
+          message: `CSS documents must be encoded in UTF-8, but detected "${charsetMatch[1]}"`,
+          location: { path }
+        });
+      }
+    }
     const cssValidator = new CSSValidator();
     const result = cssValidator.validate(context, cssContent, path);
     const hasRemoteResources = result.references.some(
       (ref) => ref.url.startsWith("http://") || ref.url.startsWith("https://")
     );
     if (hasRemoteResources) {
+      this.cssWithRemoteResources.add(path);
       const packageDoc = context.packageDocument;
       if (packageDoc) {
         const manifestItem = packageDoc.manifest.find(
@@ -2235,12 +2621,66 @@ var ContentValidator = class {
     if (!data) {
       return;
     }
-    const content = new TextDecoder().decode(data);
+    if (data.length >= 2 && (data[0] === 254 && data[1] === 255 || data[0] === 255 && data[1] === 254)) {
+      pushMessage(context.messages, {
+        id: MessageId.HTM_058,
+        message: "HTML documents must be encoded in UTF-8, but UTF-16 was detected",
+        location: { path }
+      });
+      return;
+    }
+    let content = new TextDecoder().decode(data);
     const packageDoc = context.packageDocument;
     if (!packageDoc) {
       return;
     }
+    const epubNsMatch = EPUB_XMLNS_RE.exec(content);
+    if (epubNsMatch?.[1] && epubNsMatch[1] !== "http://www.idpf.org/2007/ops") {
+      pushMessage(context.messages, {
+        id: MessageId.HTM_010,
+        message: `Namespace URI "${epubNsMatch[1]}" is unusual for the "epub" prefix`,
+        location: { path }
+      });
+      content = content.replace(epubNsMatch[0], 'xmlns:epub="http://www.idpf.org/2007/ops"');
+    }
     this.checkUnescapedAmpersands(context, path, content);
+    if (context.version !== "2.0") {
+      const doctypeMatch = /<!DOCTYPE\s+html\b([\s\S]*?)>/i.exec(content);
+      if (doctypeMatch) {
+        const inner = doctypeMatch[1] ?? "";
+        const hasPublic = /\bPUBLIC\b/i.test(inner);
+        const hasSystem = /\bSYSTEM\b/i.test(inner);
+        const isLegacyCompat = /['"]about:legacy-compat['"]/.test(inner);
+        if (hasPublic || hasSystem && !isLegacyCompat) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_004,
+            message: 'Irregular DOCTYPE found; expected "<!DOCTYPE html>"',
+            location: { path }
+          });
+        }
+      }
+    }
+    if (context.version !== "2.0") {
+      const entityRe = /<!ENTITY\s+\w+\s+(?:SYSTEM|PUBLIC)\s/gi;
+      let entityMatch = entityRe.exec(content);
+      while (entityMatch) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_003,
+          message: "External entities are not allowed in EPUB 3 content documents",
+          location: { path }
+        });
+        entityMatch = entityRe.exec(content);
+      }
+    }
+    const xmlVersionMatch = /<\?xml\s[^?]*version\s*=\s*["']([^"']+)["']/.exec(content);
+    if (xmlVersionMatch?.[1] && xmlVersionMatch[1] !== "1.0") {
+      pushMessage(context.messages, {
+        id: MessageId.HTM_001,
+        message: `XML version "${xmlVersionMatch[1]}" is not allowed; must be "1.0"`,
+        location: { path }
+      });
+      return;
+    }
     let doc = null;
     try {
       doc = libxml2Wasm.XmlDocument.fromString(content);
@@ -2260,8 +2700,9 @@ var ContentValidator = class {
           if (column !== void 0) {
             location.column = column;
           }
+          const isEntityError = error.message.includes("Entity '") || error.message.includes("EntityRef:");
           pushMessage(context.messages, {
-            id: MessageId.HTM_004,
+            id: isEntityError ? MessageId.RSC_016 : MessageId.HTM_004,
             message,
             location
           });
@@ -2291,10 +2732,19 @@ var ContentValidator = class {
       const title = root.get(".//html:title", { html: "http://www.w3.org/1999/xhtml" });
       if (!title) {
         pushMessage(context.messages, {
-          id: MessageId.HTM_003,
-          message: "XHTML document must have a title element",
+          id: MessageId.RSC_017,
+          message: 'The "head" element should have a "title" child element',
           location: { path }
         });
+      } else {
+        const titleText = title.content.trim();
+        if (titleText === "") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "title" element must not be empty',
+            location: { path, line: title.line }
+          });
+        }
       }
       const body = root.get(".//html:body", { html: "http://www.w3.org/1999/xhtml" });
       if (!body) {
@@ -2372,7 +2822,7 @@ var ContentValidator = class {
             location: { path }
           });
         }
-        const hasRemoteResources = this.detectRemoteResources(context, path, root);
+        const hasRemoteResources = this.detectRemoteResources(context, path, root, opfDir);
         if (hasRemoteResources && !manifestItem?.properties?.includes("remote-resources")) {
           pushMessage(context.messages, {
             id: MessageId.OPF_014,
@@ -2389,11 +2839,28 @@ var ContentValidator = class {
         }
       }
       this.checkDiscouragedElements(context, path, root);
+      this.checkSSMLPh(context, path, root, content);
+      this.checkObsoleteHTML(context, path, root);
+      this.checkDuplicateIDs(context, path, root);
+      this.checkImgSrcEmpty(context, path, root);
+      this.checkStyleInBody(context, path, root);
+      this.validateInlineStyles(context, path, root);
+      this.checkHttpEquivCharset(context, path, root);
+      this.checkLangMismatch(context, path, root);
+      this.checkDpubAriaDeprecated(context, path, root);
+      this.checkTableBorder(context, path, root);
+      this.checkTimeElement(context, path, root);
+      this.checkMathMLAnnotations(context, path, root);
+      this.checkReservedNamespace(context, path, content);
+      this.checkDataAttributes(context, path, root);
       this.checkAccessibility(context, path, root);
       this.validateImages(context, path, root);
       if (context.version.startsWith("3")) {
         this.validateEpubTypes(context, path, root);
       }
+      this.validateEpubSwitch(context, path, root);
+      this.validateEpubTrigger(context, path, root);
+      this.validateStyleAttributes(context, path, root);
       this.validateStylesheetLinks(context, path, root);
       this.validateViewportMeta(context, path, root, manifestItem);
       if (registry) {
@@ -2401,7 +2868,7 @@ var ContentValidator = class {
       }
       if (refValidator && opfDir !== void 0) {
         this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, !!isNavItem);
-        this.extractAndRegisterStylesheets(path, root, opfDir, refValidator);
+        this.extractAndRegisterStylesheets(context, path, root, opfDir, refValidator);
         this.extractAndRegisterImages(context, path, root, opfDir, refValidator, registry);
         this.extractAndRegisterMathMLAltimg(path, root, opfDir, refValidator);
         this.extractAndRegisterScripts(path, root, opfDir, refValidator);
@@ -2841,7 +3308,7 @@ var ContentValidator = class {
    * - Remote scripts do NOT require the property (scripted property is used instead)
    * - Remote stylesheets DO require the property
    */
-  detectRemoteResources(_context, _path, root) {
+  detectRemoteResources(_context, path, root, opfDir) {
     const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
     for (const img of images) {
       const src = this.getAttribute(img, "src");
@@ -2887,6 +3354,7 @@ var ContentValidator = class {
     const linkElements = root.find(".//html:link[@rel and @href]", {
       html: "http://www.w3.org/1999/xhtml"
     });
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
     for (const linkElem of linkElements) {
       const rel = this.getAttribute(linkElem, "rel");
       const href = this.getAttribute(linkElem, "href");
@@ -2894,6 +3362,10 @@ var ContentValidator = class {
         if (href.startsWith("http://") || href.startsWith("https://")) {
           return true;
         }
+        const resolvedCss = this.resolveRelativePath(docDir, href, opfDir ?? "");
+        if (this.cssWithRemoteResources.has(resolvedCss)) {
+          return true;
+        }
       }
     }
     const styleElements = root.find(".//html:style", { html: "http://www.w3.org/1999/xhtml" });
@@ -2921,77 +3393,733 @@ var ContentValidator = class {
       }
     }
   }
-  checkAccessibility(context, path, root) {
-    const links = root.find(".//html:a", { html: "http://www.w3.org/1999/xhtml" });
-    for (const link of links) {
-      if (!this.hasAccessibleContent(link)) {
+  checkSSMLPh(context, path, root, content) {
+    const ssmlPhPattern = /\bssml:ph\s*=\s*"([^"]*)"/g;
+    let match;
+    while ((match = ssmlPhPattern.exec(content)) !== null) {
+      if (match[1]?.trim() === "") {
+        const line = content.substring(0, match.index).split("\n").length;
         pushMessage(context.messages, {
-          id: MessageId.ACC_004,
-          message: "Hyperlink has no accessible text content",
-          location: { path }
+          id: MessageId.HTM_007,
+          message: "The ssml:ph attribute value should not be empty",
+          location: { path, line }
         });
       }
     }
-    const images = root.find(".//html:img", { html: "http://www.w3.org/1999/xhtml" });
-    for (const img of images) {
-      const altAttr = this.getAttribute(img, "alt");
-      if (altAttr === null) {
+  }
+  checkObsoleteHTML(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    const obsoleteGlobalAttrs = ["contextmenu", "dropzone"];
+    for (const attr of obsoleteGlobalAttrs) {
+      try {
+        const elements = root.find(`.//*[@${attr}]`);
+        for (const el of elements) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "${attr}" attribute is obsolete`,
+            location: { path, line: el.line }
+          });
+        }
+      } catch {
+      }
+    }
+    const obsoleteElementAttrs = [
+      ["typemustmatch", ".//html:object[@typemustmatch]"],
+      ["pubdate", ".//html:time[@pubdate]"],
+      ["seamless", ".//html:iframe[@seamless]"]
+    ];
+    for (const [attr, xpath] of obsoleteElementAttrs) {
+      try {
+        const elements = root.find(xpath, HTML_NS);
+        for (const el of elements) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "${attr}" attribute is obsolete`,
+            location: { path, line: el.line }
+          });
+        }
+      } catch {
+      }
+    }
+    try {
+      const keygens = root.find(".//html:keygen", HTML_NS);
+      for (const keygen of keygens) {
         pushMessage(context.messages, {
-          id: MessageId.ACC_005,
-          message: "Image is missing alt attribute",
-          location: { path }
+          id: MessageId.RSC_005,
+          message: 'The "keygen" element is obsolete',
+          location: { path, line: keygen.line }
         });
       }
+    } catch {
     }
-    const svgLinks = root.find(".//svg:a", {
-      svg: "http://www.w3.org/2000/svg",
-      xlink: "http://www.w3.org/1999/xlink"
-    });
-    for (const svgLink of svgLinks) {
-      const svgElem = svgLink;
-      const title = svgElem.get("./svg:title", { svg: "http://www.w3.org/2000/svg" });
-      const ariaLabel = this.getAttribute(svgElem, "aria-label");
-      if (!title && !ariaLabel) {
+    try {
+      const menuTypes = root.find(".//html:menu[@type]", HTML_NS);
+      for (const menuType of menuTypes) {
         pushMessage(context.messages, {
-          id: MessageId.ACC_011,
-          message: "SVG hyperlink has no accessible name (missing title element or aria-label)",
-          location: { path }
+          id: MessageId.RSC_005,
+          message: 'The "type" attribute on the "menu" element is obsolete',
+          location: { path, line: menuType.line }
         });
       }
+    } catch {
     }
-    const mathElements = root.find(".//math:math", { math: "http://www.w3.org/1998/Math/MathML" });
-    for (const mathElem of mathElements) {
-      const elem = mathElem;
-      const alttext = elem.attr("alttext");
-      const annotation = elem.get('./math:annotation[@encoding="application/x-tex"]', {
-        math: "http://www.w3.org/1998/Math/MathML"
-      });
-      const ariaLabel = this.getAttribute(elem, "aria-label");
-      if (!alttext?.value && !annotation && !ariaLabel) {
+    try {
+      const commands = root.find(".//html:command", HTML_NS);
+      for (const command of commands) {
         pushMessage(context.messages, {
-          id: MessageId.ACC_009,
-          message: "MathML element should have alttext attribute or annotation for accessibility",
-          location: { path }
+          id: MessageId.RSC_005,
+          message: 'The "command" element is obsolete',
+          location: { path, line: command.line }
         });
       }
+    } catch {
     }
   }
-  validateImages(context, path, root) {
-    const packageDoc = context.packageDocument;
-    if (!packageDoc) return;
-    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
-    for (const img of images) {
-      const imgElem = img;
-      const srcAttr = this.getAttribute(imgElem, "src");
-      if (!srcAttr) continue;
-      const src = srcAttr;
-      const opfDir = context.opfPath?.includes("/") ? context.opfPath.substring(0, context.opfPath.lastIndexOf("/")) : "";
-      let fullPath = src;
-      if (opfDir && !src.startsWith("http://") && !src.startsWith("https://")) {
-        if (src.startsWith("/")) {
-          fullPath = src.slice(1);
+  checkDuplicateIDs(context, path, root) {
+    const seen = /* @__PURE__ */ new Map();
+    const elements = root.find(".//*[@id]");
+    for (const elem of elements) {
+      const id = this.getAttribute(elem, "id");
+      if (id) {
+        if (seen.has(id)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `Duplicate ID "${id}"`,
+            location: { path, line: elem.line }
+          });
         } else {
-          const parts = opfDir.split("/");
+          seen.set(id, elem.line);
+        }
+      }
+    }
+  }
+  checkImgSrcEmpty(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const imgs = root.find(".//html:img[@src]", HTML_NS);
+      for (const img of imgs) {
+        const src = this.getAttribute(img, "src");
+        if (src !== null && src.trim() === "") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "src" attribute must not be empty',
+            location: { path, line: img.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  checkStyleInBody(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const bodyStyles = root.find(".//html:body//html:style", HTML_NS);
+      for (const style of bodyStyles) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The "style" element must not appear in the document body',
+          location: { path, line: style.line }
+        });
+      }
+    } catch {
+    }
+  }
+  checkHttpEquivCharset(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const metas = root.find(".//html:head/html:meta", HTML_NS);
+      let hasCharsetMeta = false;
+      let hasHttpEquivContentType = false;
+      for (const meta of metas) {
+        const el = meta;
+        const charset = this.getAttribute(el, "charset");
+        if (charset !== null) {
+          hasCharsetMeta = true;
+        }
+        const httpEquiv = this.getAttribute(el, "http-equiv");
+        if (httpEquiv?.toLowerCase() === "content-type") {
+          hasHttpEquivContentType = true;
+          const contentAttr = (this.getAttribute(el, "content") ?? "").trim();
+          if (!/^text\/html;\s*charset=utf-8$/i.test(contentAttr)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The meta element in encoding declaration state must have the value "text/html; charset=utf-8"`,
+              location: { path, line: el.line }
+            });
+          }
+        }
+      }
+      if (hasCharsetMeta && hasHttpEquivContentType) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "The document must not contain both a meta charset declaration and a meta http-equiv Content-Type declaration",
+          location: { path }
+        });
+      }
+    } catch {
+    }
+  }
+  checkSVGInvalidIDs(context, path, root) {
+    const XML_NAME_START_RE = /^[a-zA-Z_:\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF]/;
+    const elements = root.find(".//*[@id]");
+    for (const elem of elements) {
+      const id = this.getAttribute(elem, "id");
+      if (id && !XML_NAME_START_RE.test(id)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Invalid ID value "${id}"`,
+          location: { path, line: elem.line }
+        });
+      }
+    }
+    const rootId = this.getAttribute(root, "id");
+    if (rootId && !XML_NAME_START_RE.test(rootId)) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `Invalid ID value "${rootId}"`,
+        location: { path, line: root.line }
+      });
+    }
+  }
+  validateInlineStyles(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const styles = root.find(".//html:style", HTML_NS);
+      for (const style of styles) {
+        const cssContent = style.content;
+        if (cssContent) {
+          const cssValidator = new CSSValidator();
+          cssValidator.validate(context, cssContent, path);
+        }
+      }
+    } catch {
+    }
+  }
+  checkLangMismatch(context, path, root) {
+    const lang = root.attr("lang")?.value ?? null;
+    const xmlLang = root.attr("lang", "xml")?.value ?? null;
+    if (lang !== null && xmlLang !== null && lang.toLowerCase() !== xmlLang.toLowerCase()) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: "The lang and xml:lang attributes must have the same value",
+        location: { path, line: root.line }
+      });
+    }
+  }
+  checkDpubAriaDeprecated(context, path, root) {
+    const DEPRECATED_ROLES = ["doc-endnote", "doc-biblioentry"];
+    try {
+      const elements = root.find(".//*[@role]");
+      for (const elem of elements) {
+        const roleAttr = this.getAttribute(elem, "role");
+        if (!roleAttr) continue;
+        const roles = roleAttr.split(/\s+/);
+        for (const role of DEPRECATED_ROLES) {
+          if (roles.includes(role)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_017,
+              message: `The "${role}" role is deprecated and should not be used`,
+              location: { path, line: elem.line }
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  validateEpubSwitch(context, path, root) {
+    const EPUB_NS = { epub: "http://www.idpf.org/2007/ops" };
+    try {
+      const switches = root.find(".//epub:switch", EPUB_NS);
+      for (const sw of switches) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_017,
+          message: 'The "epub:switch" element is deprecated',
+          location: { path, line: sw.line }
+        });
+        const swElem = sw;
+        const cases = [];
+        const defaults = [];
+        let defaultBeforeCase = false;
+        try {
+          const childCases = swElem.find("./epub:case", EPUB_NS);
+          const childDefaults = swElem.find("./epub:default", EPUB_NS);
+          cases.push(...childCases);
+          defaults.push(...childDefaults);
+          const firstDefault = childDefaults[0];
+          const lastCase = childCases[childCases.length - 1];
+          if (firstDefault && lastCase && firstDefault.line < lastCase.line) {
+            defaultBeforeCase = true;
+          }
+        } catch {
+        }
+        if (cases.length === 0) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "epub:switch" element must contain at least one "epub:case" child element',
+            location: { path, line: sw.line }
+          });
+        }
+        if (defaults.length === 0) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "epub:switch" element must contain an "epub:default" child element',
+            location: { path, line: sw.line }
+          });
+        }
+        const secondDefault = defaults[1];
+        if (secondDefault) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "epub:switch" element must not contain more than one "epub:default" child element',
+            location: { path, line: secondDefault.line }
+          });
+        }
+        const firstDefaultElem = defaults[0];
+        if (defaultBeforeCase && firstDefaultElem) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "epub:default" element must appear after all "epub:case" elements',
+            location: { path, line: firstDefaultElem.line }
+          });
+        }
+        for (const c of cases) {
+          const caseElem = c;
+          const reqNs = caseElem.attr("required-namespace");
+          if (!reqNs) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'The "epub:case" element must have a "required-namespace" attribute',
+              location: { path, line: c.line }
+            });
+          }
+        }
+        try {
+          const MATH_NS = { m: "http://www.w3.org/1998/Math/MathML" };
+          const nestedMath = swElem.find(".//m:math//m:math", MATH_NS);
+          for (const nested of nestedMath) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'The "math" element must not be nested inside another "math" element',
+              location: { path, line: nested.line }
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  validateEpubTrigger(context, path, root) {
+    const EPUB_NS = { epub: "http://www.idpf.org/2007/ops" };
+    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 {
+      }
+      for (const trigger of triggers) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_017,
+          message: 'The "epub:trigger" element is deprecated',
+          location: { path, line: trigger.line }
+        });
+        const triggerElem = trigger;
+        const ref = triggerElem.attr("ref");
+        if (ref?.value && !allIds.has(ref.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "ref" attribute value "${ref.value}" does not reference a valid ID in the document`,
+            location: { path, line: trigger.line }
+          });
+        }
+        const observer = triggerElem.attr("observer", "ev") ?? triggerElem.attr("ev:observer");
+        if (observer?.value && !allIds.has(observer.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "ev:observer" attribute value "${observer.value}" does not reference a valid ID in the document`,
+            location: { path, line: trigger.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  validateStyleAttributes(context, path, root) {
+    try {
+      const elements = root.find(".//*[@style]");
+      for (const elem of elements) {
+        const style = this.getAttribute(elem, "style");
+        if (!style) continue;
+        const wrappedCss = `* { ${style} }`;
+        const cssValidator = new CSSValidator();
+        cssValidator.validate(context, wrappedCss, path);
+      }
+    } catch {
+    }
+  }
+  validateSvgEpubType(context, path, root) {
+    const ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([
+      "svg",
+      "a",
+      "audio",
+      "canvas",
+      "circle",
+      "ellipse",
+      "g",
+      "iframe",
+      "image",
+      "line",
+      "path",
+      "polygon",
+      "polyline",
+      "rect",
+      "switch",
+      "symbol",
+      "text",
+      "textPath",
+      "tspan",
+      "unknown",
+      "use",
+      "video"
+    ]);
+    const EPUB_NS = { epub: "http://www.idpf.org/2007/ops" };
+    try {
+      const elements = root.find(".//*[@epub:type]", EPUB_NS);
+      for (const elem of elements) {
+        const elemTyped = elem;
+        const localName = elemTyped.name;
+        if (!ALLOWED_ELEMENTS.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `Attribute "epub:type" not allowed on SVG element "${localName}"`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+      const rootEpubType = root.attr("type", "epub");
+      if (rootEpubType && !ALLOWED_ELEMENTS.has(root.name)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Attribute "epub:type" not allowed on SVG element "${root.name}"`,
+          location: { path, line: root.line }
+        });
+      }
+    } catch {
+    }
+  }
+  checkUnknownEpubAttributes(context, path, root) {
+    const KNOWN_EPUB_ATTRS = /* @__PURE__ */ new Set(["type"]);
+    const checkElement = (elem) => {
+      if (!("attrs" in elem)) return;
+      for (const attr of elem.attrs) {
+        if (attr.prefix === "epub" && !KNOWN_EPUB_ATTRS.has(attr.name)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `Attribute "epub:${attr.name}" not allowed`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+    };
+    checkElement(root);
+    try {
+      const allElements = root.find(".//*");
+      for (const elem of allElements) {
+        checkElement(elem);
+      }
+    } catch {
+    }
+  }
+  checkTableBorder(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const tables = root.find(".//html:table[@border]", HTML_NS);
+      for (const table of tables) {
+        const border = this.getAttribute(table, "border");
+        if (border !== null && border !== "" && border !== "1") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The value of the "border" attribute on the "table" element must be either "1" or the empty string`,
+            location: { path, line: table.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  checkTimeElement(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    try {
+      const nestedTimes = root.find(".//html:time//html:time", HTML_NS);
+      for (const nested of nestedTimes) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The element "time" must not appear as a descendant of the "time" element',
+          location: { path, line: nested.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const times = root.find(".//html:time[@datetime]", HTML_NS);
+      for (const time of times) {
+        const datetime = this.getAttribute(time, "datetime");
+        if (datetime !== null && !isValidDatetime(datetime)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "datetime" attribute value "${datetime}" is not a valid date, time, or duration`,
+            location: { path, line: time.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  checkMathMLAnnotations(context, path, root) {
+    const MATH_NS = { math: "http://www.w3.org/1998/Math/MathML" };
+    const CONTENT_MATHML_ENCODINGS = /* @__PURE__ */ new Set(["mathml-content", "application/mathml-content+xml"]);
+    const CONTENT_MATHML_ELEMENTS = /* @__PURE__ */ new Set([
+      "apply",
+      "bind",
+      "ci",
+      "cn",
+      "cs",
+      "csymbol",
+      "cbytes",
+      "cerror",
+      "share",
+      "piecewise",
+      "lambda",
+      "set",
+      "list",
+      "vector",
+      "matrix",
+      "matrixrow",
+      "interval"
+    ]);
+    const contentMathMLNames = [...CONTENT_MATHML_ELEMENTS];
+    try {
+      const annotations = root.find(".//math:annotation-xml", MATH_NS);
+      for (const anno of annotations) {
+        const el = anno;
+        const encoding = this.getAttribute(el, "encoding");
+        const name = this.getAttribute(el, "name");
+        if (encoding) {
+          const encodingLower = encoding.toLowerCase();
+          if (CONTENT_MATHML_ENCODINGS.has(encodingLower)) {
+            if (!name) {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: 'The "annotation-xml" element with Content MathML encoding must have a "name" attribute with value "contentequiv"',
+                location: { path, line: el.line }
+              });
+            } else if (name !== "contentequiv") {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: `The "name" attribute on "annotation-xml" with Content MathML encoding must be "contentequiv", but found "${name}"`,
+                location: { path, line: el.line }
+              });
+            }
+          } else {
+            for (const cElemName of contentMathMLNames) {
+              try {
+                const found = el.get(`./math:${cElemName}`, MATH_NS);
+                if (found) {
+                  pushMessage(context.messages, {
+                    id: MessageId.RSC_005,
+                    message: `Content MathML element "${cElemName}" found in annotation-xml with encoding "${encoding}"`,
+                    location: { path, line: found.line }
+                  });
+                  break;
+                }
+              } catch {
+              }
+            }
+          }
+          if (encodingLower === "application/xml+xhtml") {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'The encoding "application/xml+xhtml" is not valid; use "application/xhtml+xml" instead',
+              location: { path, line: el.line }
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    for (const elemName of contentMathMLNames) {
+      try {
+        const found = root.get(`.//math:math/math:${elemName}`, MATH_NS);
+        if (found) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `Content MathML element "${elemName}" must not appear as a direct child of "math"; use "semantics" with "annotation-xml" instead`,
+            location: { path, line: found.line }
+          });
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  checkReservedNamespace(context, path, content) {
+    const nsPattern = /xmlns:(\w+)="([^"]+)"/g;
+    const STANDARD_PREFIXES = /* @__PURE__ */ new Set([
+      "xml",
+      "xmlns",
+      "xlink",
+      "epub",
+      "ops",
+      "dc",
+      "dcterms",
+      "svg",
+      "math",
+      "ssml",
+      "ev",
+      "xsi"
+    ]);
+    const STANDARD_NAMESPACES = /* @__PURE__ */ new Set([
+      "http://www.w3.org/XML/1998/namespace",
+      "http://www.w3.org/2000/xmlns/",
+      "http://www.w3.org/1999/xhtml",
+      "http://www.w3.org/1999/xlink",
+      "http://www.w3.org/2000/svg",
+      "http://www.w3.org/1998/Math/MathML",
+      "http://www.idpf.org/2007/ops",
+      "http://purl.org/dc/elements/1.1/",
+      "http://purl.org/dc/terms/",
+      "http://www.w3.org/2001/10/synthesis",
+      "http://www.w3.org/2001/xml-events",
+      "http://www.w3.org/2001/XMLSchema-instance"
+    ]);
+    let match;
+    while ((match = nsPattern.exec(content)) !== null) {
+      const prefix = match[1] ?? "";
+      const uri = match[2] ?? "";
+      if (STANDARD_PREFIXES.has(prefix) || STANDARD_NAMESPACES.has(uri)) continue;
+      try {
+        const url = new URL(uri);
+        const host = url.hostname.toLowerCase();
+        for (const reserved of ["w3.org", "idpf.org"]) {
+          if (host.includes(reserved)) {
+            const line = content.substring(0, match.index).split("\n").length;
+            pushMessage(context.messages, {
+              id: MessageId.HTM_054,
+              message: `Custom attribute namespace ("${uri}") must not include the string "${reserved}" in its domain`,
+              location: { path, line }
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  checkDataAttributes(context, path, root) {
+    const elements = root.find(".//*");
+    const XML_NCNAME_RE = /^[a-z_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF][a-z0-9._\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF-]*$/;
+    for (const elem of elements) {
+      const el = elem;
+      if (!("attrs" in el)) continue;
+      const attrs = el.attrs;
+      for (const attr of attrs) {
+        if (!attr.name.startsWith("data-")) continue;
+        const suffix = attr.name.substring(5);
+        if (suffix.length === 0 || !XML_NCNAME_RE.test(suffix) || /[A-Z]/.test(attr.name)) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_061,
+            message: `"${attr.name}" is not a valid custom data attribute (it must have at least one character after the hyphen, be XML-compatible, and not contain ASCII uppercase letters)`,
+            location: { path, line: el.line }
+          });
+        }
+      }
+    }
+  }
+  checkAccessibility(context, path, root) {
+    const links = root.find(".//html:a", { html: "http://www.w3.org/1999/xhtml" });
+    for (const link of links) {
+      if (!this.hasAccessibleContent(link)) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_004,
+          message: "Hyperlink has no accessible text content",
+          location: { path }
+        });
+      }
+    }
+    const images = root.find(".//html:img", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const altAttr = this.getAttribute(img, "alt");
+      if (altAttr === null) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_005,
+          message: "Image is missing alt attribute",
+          location: { path }
+        });
+      }
+    }
+    this.checkSVGLinkAccessibility(context, path, root);
+    const mathElements = root.find(".//math:math", { math: "http://www.w3.org/1998/Math/MathML" });
+    for (const mathElem of mathElements) {
+      const elem = mathElem;
+      const alttext = elem.attr("alttext");
+      const annotation = elem.get('./math:annotation[@encoding="application/x-tex"]', {
+        math: "http://www.w3.org/1998/Math/MathML"
+      });
+      const ariaLabel = this.getAttribute(elem, "aria-label");
+      if (!alttext?.value && !annotation && !ariaLabel) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_009,
+          message: "MathML element should have alttext attribute or annotation for accessibility",
+          location: { path }
+        });
+      }
+    }
+  }
+  hasSVGLinkAccessibleName(svgElem) {
+    const ns = { svg: "http://www.w3.org/2000/svg" };
+    if (svgElem.get(".//svg:title", ns)) return true;
+    if (svgElem.get(".//svg:text", ns)) return true;
+    if (this.getAttribute(svgElem, "aria-label")) return true;
+    if (this.getAttribute(svgElem, "xlink:title")) return true;
+    return false;
+  }
+  checkSVGLinkAccessibility(context, path, root) {
+    const svgLinks = root.find(".//svg:a", {
+      svg: "http://www.w3.org/2000/svg",
+      xlink: "http://www.w3.org/1999/xlink"
+    });
+    for (const svgLink of svgLinks) {
+      if (!this.hasSVGLinkAccessibleName(svgLink)) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_011,
+          message: "SVG hyperlink has no accessible name (missing title element or aria-label)",
+          location: { path }
+        });
+      }
+    }
+  }
+  validateImages(context, path, root) {
+    const packageDoc = context.packageDocument;
+    if (!packageDoc) return;
+    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const imgElem = img;
+      const srcAttr = this.getAttribute(imgElem, "src");
+      if (!srcAttr) continue;
+      const src = srcAttr;
+      const opfDir = context.opfPath?.includes("/") ? context.opfPath.substring(0, context.opfPath.lastIndexOf("/")) : "";
+      let fullPath = src;
+      if (opfDir && !src.startsWith("http://") && !src.startsWith("https://")) {
+        if (src.startsWith("/")) {
+          fullPath = src.slice(1);
+        } else {
+          const parts = opfDir.split("/");
           const relParts = src.split("/");
           for (const part of relParts) {
             if (part === "..") {
@@ -3033,24 +4161,32 @@ var ContentValidator = class {
     const epubTypeElements = root.find(".//*[@epub:type]", {
       epub: "http://www.idpf.org/2007/ops"
     });
-    const knownPrefixes = /* @__PURE__ */ new Set([
-      "",
-      "http://idpf.org/epub/structure/v1/",
-      "http://idpf.org/epub/vocab/structure/",
-      "http://www.idpf.org/2007/ops"
-    ]);
     for (const elem of epubTypeElements) {
       const elemTyped = elem;
-      const epubTypeAttr = elemTyped.attr("epub:type");
+      const epubTypeAttr = elemTyped.attr("type", "epub");
       if (!epubTypeAttr?.value) continue;
-      const epubTypeValue = epubTypeAttr.value;
-      for (const part of epubTypeValue.split(/\s+/)) {
-        const prefix = part.includes(":") ? part.substring(0, part.indexOf(":")) : "";
-        if (!knownPrefixes.has(prefix) && !prefix.startsWith("http://") && !prefix.startsWith("https://")) {
+      for (const part of epubTypeAttr.value.split(/\s+/)) {
+        if (!part) continue;
+        const hasPrefix = part.includes(":");
+        const localName = hasPrefix ? part.substring(part.indexOf(":") + 1) : part;
+        if (hasPrefix) continue;
+        if (EPUB_SSV_DEPRECATED.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_086b,
+            message: `epub:type value "${localName}" is deprecated`,
+            location: { path, line: elem.line }
+          });
+        } else if (EPUB_SSV_DISALLOWED_ON_CONTENT.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_087,
+            message: `epub:type value "${localName}" is not allowed on documents of type "application/xhtml+xml"`,
+            location: { path, line: elem.line }
+          });
+        } else if (!EPUB_SSV_ALL.has(localName)) {
           pushMessage(context.messages, {
             id: MessageId.OPF_088,
-            message: `Unknown epub:type prefix "${prefix}": ${epubTypeValue}`,
-            location: { path }
+            message: `Unrecognized epub:type value "${localName}"`,
+            location: { path, line: elem.line }
           });
         }
       }
@@ -3125,40 +4261,119 @@ var ContentValidator = class {
     return attr?.value ?? null;
   }
   validateViewportMeta(context, path, root, manifestItem) {
-    const isFixedLayout = manifestItem?.properties?.includes("fixed-layout");
-    const metaTags = root.find(".//html:meta[@name]", { html: "http://www.w3.org/1999/xhtml" });
-    let hasViewportMeta = false;
-    for (const meta of metaTags) {
+    const packageDoc = context.packageDocument;
+    const isFixedLayout = manifestItem && packageDoc ? isItemFixedLayout(packageDoc, manifestItem.id) : false;
+    const headMetas = root.find(".//html:head/html:meta[@name]", {
+      html: "http://www.w3.org/1999/xhtml"
+    });
+    let viewportCount = 0;
+    for (const meta of headMetas) {
       const nameAttr = this.getAttribute(meta, "name");
-      if (nameAttr === "viewport") {
-        hasViewportMeta = true;
-        const contentAttr = this.getAttribute(meta, "content");
-        if (isFixedLayout) {
-          if (!contentAttr) {
-            pushMessage(context.messages, {
-              id: MessageId.HTM_046,
-              message: "Viewport meta element should have a content attribute in fixed-layout documents",
-              location: { path }
-            });
-            continue;
-          }
-        } else {
-          pushMessage(context.messages, {
-            id: MessageId.HTM_060b,
-            message: `EPUB reading systems must ignore viewport meta elements in reflowable documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
-            location: { path }
-          });
-        }
+      if (nameAttr !== "viewport") continue;
+      viewportCount++;
+      const contentAttr = this.getAttribute(meta, "content");
+      if (!isFixedLayout) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_060b,
+          message: `EPUB reading systems must ignore viewport meta elements in reflowable documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
+          location: { path, line: meta.line }
+        });
+        continue;
       }
+      if (viewportCount > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_060a,
+          message: `EPUB reading systems must ignore secondary viewport meta elements in fixed-layout documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
+          location: { path, line: meta.line }
+        });
+        continue;
+      }
+      if (!contentAttr?.trim()) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_047,
+          message: `Viewport metadata "${contentAttr ?? ""}" has a syntax error`,
+          location: { path, line: meta.line }
+        });
+        continue;
+      }
+      this.parseViewportContent(context, path, contentAttr, meta.line);
     }
-    if (isFixedLayout && !hasViewportMeta) {
+    if (isFixedLayout && viewportCount === 0) {
       pushMessage(context.messages, {
-        id: MessageId.HTM_049,
-        message: "Fixed-layout document should include a viewport meta element",
+        id: MessageId.HTM_046,
+        message: "Fixed layout document has no viewport meta element",
         location: { path }
       });
     }
   }
+  parseViewportContent(context, path, content, line) {
+    const location = line != null ? { path, line } : { path };
+    const parts = content.split(/[,;]/);
+    const seenKeys = /* @__PURE__ */ new Set();
+    let hasWidth = false;
+    let hasHeight = false;
+    let hasSyntaxError = false;
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const eqIndex = trimmed.indexOf("=");
+      let key;
+      let value;
+      if (eqIndex < 0) {
+        key = trimmed;
+        value = "";
+      } else {
+        key = trimmed.substring(0, eqIndex).trim();
+        const rawValue = trimmed.substring(eqIndex + 1);
+        if (!rawValue.trim()) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_047,
+            message: `Viewport metadata "${content}" has a syntax error`,
+            location
+          });
+          hasSyntaxError = true;
+          break;
+        }
+        value = rawValue.trim();
+      }
+      if (key === "width" || key === "height") {
+        if (seenKeys.has(key)) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_059,
+            message: `Viewport "${key}" property must not be defined more than once`,
+            location
+          });
+        }
+        seenKeys.add(key);
+        if (key === "width") hasWidth = true;
+        if (key === "height") hasHeight = true;
+        const deviceKeyword = key === "width" ? "device-width" : "device-height";
+        if (value === deviceKeyword) ; else if (value === "" || !/^[0-9]*\.?[0-9]+$/.test(value)) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_057,
+            message: `Viewport "${key}" value must be a positive number or the keyword "${deviceKeyword}"`,
+            location
+          });
+        }
+      }
+    }
+    if (!hasSyntaxError) {
+      if (!hasWidth) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_056,
+          message: 'Viewport metadata has no "width" dimension (both "width" and "height" properties are required)',
+          location
+        });
+      }
+      if (!hasHeight) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_056,
+          message: 'Viewport metadata has no "height" dimension (both "width" and "height" properties are required)',
+          location
+        });
+      }
+    }
+  }
   extractAndRegisterIDs(path, root, registry) {
     const elementsWithId = root.find(".//*[@id]");
     for (const elem of elementsWithId) {
@@ -3190,7 +4405,8 @@ var ContentValidator = class {
         else if (types.includes("page-list")) refType = "nav-pagelist-link" /* NAV_PAGELIST_LINK */;
         const navAnchors = navElem.find(".//html:a[@href]", HTML_NS);
         for (const a of navAnchors) {
-          navAnchorTypes.set(a.line, refType);
+          const anchorHref = this.getAttribute(a, "href") ?? "";
+          navAnchorTypes.set(`${String(a.line)}:${anchorHref}`, refType);
         }
       }
     }
@@ -3207,11 +4423,18 @@ var ContentValidator = class {
         continue;
       }
       const line = link.line;
-      const refType = isNavDocument ? navAnchorTypes.get(line) ?? "hyperlink" /* HYPERLINK */ : "hyperlink" /* HYPERLINK */;
-      if (href.startsWith("http://") || href.startsWith("https://")) {
+      const refType = isNavDocument ? navAnchorTypes.get(`${String(line)}:${href}`) ?? "hyperlink" /* HYPERLINK */ : "hyperlink" /* HYPERLINK */;
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: refType,
+          location: { path, line }
+        });
         continue;
       }
-      if (href.startsWith("mailto:") || href.startsWith("tel:")) {
+      if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
         continue;
       }
       if (href.includes("#epubcfi(")) {
@@ -3249,8 +4472,19 @@ var ContentValidator = class {
       const href = this.getAttribute(area, "href")?.trim();
       if (!href) continue;
       const line = area.line;
-      if (href.startsWith("http://") || href.startsWith("https://")) continue;
-      if (href.startsWith("mailto:") || href.startsWith("tel:")) continue;
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path, line }
+        });
+        continue;
+      }
+      if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
+        continue;
+      }
       if (href.includes("#epubcfi(")) continue;
       if (href.startsWith("#")) {
         refValidator.addReference({
@@ -3286,7 +4520,17 @@ var ContentValidator = class {
       const href = this.getAttribute(elem, "xlink:href") ?? this.getAttribute(elem, "href");
       if (!href) continue;
       const line = link.line;
-      if (href.startsWith("http://") || href.startsWith("https://")) {
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path, line }
+        });
+        continue;
+      }
+      if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
         continue;
       }
       if (href.startsWith("#")) {
@@ -3317,16 +4561,19 @@ var ContentValidator = class {
       refValidator.addReference(svgRef);
     }
   }
-  extractAndRegisterStylesheets(path, root, opfDir, refValidator) {
+  extractAndRegisterStylesheets(context, path, root, opfDir, refValidator) {
     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 linkElements = root.find(".//html:link[@href]", { html: "http://www.w3.org/1999/xhtml" });
     for (const linkElem of linkElements) {
       const href = this.getAttribute(linkElem, "href");
       const rel = this.getAttribute(linkElem, "rel");
       if (!href) continue;
+      if (!rel?.toLowerCase().includes("stylesheet")) continue;
       const line = linkElem.line;
-      const isStylesheet = rel?.toLowerCase().includes("stylesheet");
-      const type = isStylesheet ? "stylesheet" /* STYLESHEET */ : "link" /* LINK */;
+      const type = "stylesheet" /* STYLESHEET */;
       if (href.startsWith("http://") || href.startsWith("https://")) {
         refValidator.addReference({
           url: href,
@@ -3336,6 +4583,15 @@ var ContentValidator = class {
         });
         continue;
       }
+      if (remoteBaseUrl && !ABSOLUTE_URI_RE.test(href)) {
+        const resolvedUrl = new URL(href, remoteBaseUrl).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;
@@ -3481,56 +4737,18 @@ var ContentValidator = class {
       const hashIndex = resolvedPath.indexOf("#");
       const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
       const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
-      const svgImgRef = {
-        url: href,
-        targetResource,
-        type: "image" /* IMAGE */,
-        location: { path, line }
-      };
-      if (fragment) {
-        svgImgRef.fragment = fragment;
-      }
-      refValidator.addReference(svgImgRef);
-    }
-    try {
-      const svgUseXlink = root.find(".//svg:use[@xlink:href]", {
-        svg: "http://www.w3.org/2000/svg",
-        xlink: "http://www.w3.org/1999/xlink"
-      });
-      const svgUseHref = root.find(".//svg:use[@href]", {
-        svg: "http://www.w3.org/2000/svg"
-      });
-      for (const useNode of [...svgUseXlink, ...svgUseHref]) {
-        const useElem = useNode;
-        const href = this.getAttribute(useElem, "xlink:href") ?? this.getAttribute(useElem, "href");
-        if (href === null) continue;
-        const line = useNode.line;
-        if (href.startsWith("http://") || href.startsWith("https://")) continue;
-        if (href === "" || !href.includes("#")) {
-          pushMessage(context.messages, {
-            id: MessageId.RSC_015,
-            message: `SVG "use" element requires a fragment identifier, but found "${href}"`,
-            location: { path, line }
-          });
-          continue;
-        }
-        const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
-        const hashIndex = resolvedPath.indexOf("#");
-        const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : path;
-        const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
-        const useRef = {
-          url: href,
-          targetResource,
-          type: "svg-symbol" /* SVG_SYMBOL */,
-          location: { path, line }
-        };
-        if (fragment) {
-          useRef.fragment = fragment;
-        }
-        refValidator.addReference(useRef);
+      const svgImgRef = {
+        url: href,
+        targetResource,
+        type: "image" /* IMAGE */,
+        location: { path, line }
+      };
+      if (fragment) {
+        svgImgRef.fragment = fragment;
       }
-    } catch {
+      refValidator.addReference(svgImgRef);
     }
+    this.extractSVGUseReferences(context, path, root, docDir, opfDir, refValidator);
     const videos = root.find(".//html:video[@poster]", { html: "http://www.w3.org/1999/xhtml" });
     for (const video of videos) {
       const poster = this.getAttribute(video, "poster");
@@ -3830,12 +5048,8 @@ var ContentValidator = class {
     const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
     const resource = registry.getResource(targetResource);
     if (!resource) return;
-    const stripParams = (t) => {
-      const idx = t.indexOf(";");
-      return (idx >= 0 ? t.substring(0, idx) : t).trim();
-    };
-    const declaredType = stripParams(typeAttr);
-    const manifestType = stripParams(resource.mimeType);
+    const declaredType = stripMimeParams(typeAttr);
+    const manifestType = stripMimeParams(resource.mimeType);
     if (declaredType && declaredType !== manifestType) {
       pushMessage(context.messages, {
         id: MessageId.OPF_013,
@@ -3912,12 +5126,8 @@ var ContentValidator = class {
             const resolvedPath2 = this.resolveRelativePath(docDir, sourceUrl, opfDir);
             const resource2 = registry.getResource(resolvedPath2);
             if (resource2) {
-              const stripParams = (t) => {
-                const idx = t.indexOf(";");
-                return (idx >= 0 ? t.substring(0, idx) : t).trim();
-              };
-              const declaredType = stripParams(typeAttr);
-              const manifestType = stripParams(resource2.mimeType);
+              const declaredType = stripMimeParams(typeAttr);
+              const manifestType = stripMimeParams(resource2.mimeType);
               if (declaredType && declaredType !== manifestType) {
                 pushMessage(context.messages, {
                   id: MessageId.OPF_013,
@@ -4779,9 +5989,17 @@ var OCFValidator = class {
       const xml = block[0];
       const algorithmMatch = /Algorithm=["']([^"']+)["']/.exec(xml);
       const uriMatch = /<(?:\w+:)?CipherReference[^>]+URI=["']([^"']+)["']/.exec(xml);
-      if (algorithmMatch?.[1] === IDPF_OBFUSCATION && uriMatch?.[1]) {
-        obfuscated.add(uriMatch[1]);
+      const algorithm = algorithmMatch?.[1];
+      const uri = uriMatch?.[1];
+      if (!uri) continue;
+      if (algorithm === IDPF_OBFUSCATION) {
+        obfuscated.add(uri);
       }
+      pushMessage(context.messages, {
+        id: MessageId.RSC_004,
+        message: `File "${uri}" is encrypted, its content will not be checked`,
+        location: { path: encryptionPath }
+      });
     }
     if (obfuscated.size > 0) {
       context.obfuscatedResources = obfuscated;
@@ -5063,6 +6281,9 @@ function parseSpine(spineXml, spineAttrs) {
         idref,
         linear: attrs.linear !== "no"
       };
+      if (attrs.id) {
+        itemref.id = attrs.id.trim();
+      }
       if (attrs.properties) {
         itemref.properties = attrs.properties.split(/\s+/);
       }
@@ -5101,9 +6322,14 @@ function parseAttributes(attrsStr) {
     const name = match[1];
     const value = match[2];
     if (name !== void 0 && value !== void 0) {
+      attrs[name] = value;
       const colonIdx = name.indexOf(":");
-      const localName = colonIdx >= 0 ? name.slice(colonIdx + 1) : name;
-      attrs[localName] = value;
+      if (colonIdx >= 0) {
+        const localName = name.slice(colonIdx + 1);
+        if (!(localName in attrs)) {
+          attrs[localName] = value;
+        }
+      }
     }
   }
   return attrs;
@@ -5149,6 +6375,378 @@ function parseCollections(xml) {
 }
 
 // src/opf/validator.ts
+var VALID_VERSIONS = /* @__PURE__ */ new Set(["2.0", "3.0", "3.1", "3.2", "3.3"]);
+var DEPRECATED_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "text/x-oeb1-document",
+  "text/x-oeb1-css",
+  "application/x-oeb1-package",
+  "text/x-oeb1-html"
+]);
+var VALID_RELATOR_CODES = /* @__PURE__ */ new Set([
+  "abr",
+  "acp",
+  "act",
+  "adi",
+  "adp",
+  "aft",
+  "anl",
+  "anm",
+  "ann",
+  "ant",
+  "ape",
+  "apl",
+  "app",
+  "aqt",
+  "arc",
+  "ard",
+  "arr",
+  "art",
+  "asg",
+  "asn",
+  "ato",
+  "att",
+  "auc",
+  "aud",
+  "aui",
+  "aus",
+  "aut",
+  "bdd",
+  "bjd",
+  "bkd",
+  "bkp",
+  "blw",
+  "bnd",
+  "bpd",
+  "brd",
+  "brl",
+  "bsl",
+  "cas",
+  "ccp",
+  "chr",
+  "clb",
+  "cli",
+  "cll",
+  "clr",
+  "clt",
+  "cmm",
+  "cmp",
+  "cmt",
+  "cnd",
+  "cng",
+  "cns",
+  "coe",
+  "col",
+  "com",
+  "con",
+  "cor",
+  "cos",
+  "cot",
+  "cou",
+  "cov",
+  "cpc",
+  "cpe",
+  "cph",
+  "cpl",
+  "cpt",
+  "cre",
+  "crp",
+  "crr",
+  "crt",
+  "csl",
+  "csp",
+  "cst",
+  "ctb",
+  "cte",
+  "ctg",
+  "ctr",
+  "cts",
+  "ctt",
+  "cur",
+  "cwt",
+  "dbp",
+  "dfd",
+  "dfe",
+  "dft",
+  "dgc",
+  "dgg",
+  "dgs",
+  "dis",
+  "dln",
+  "dnc",
+  "dnr",
+  "dpc",
+  "dpt",
+  "drm",
+  "drt",
+  "dsr",
+  "dst",
+  "dtc",
+  "dte",
+  "dtm",
+  "dto",
+  "dub",
+  "edc",
+  "edm",
+  "edt",
+  "egr",
+  "elg",
+  "elt",
+  "eng",
+  "enj",
+  "etr",
+  "evp",
+  "exp",
+  "fac",
+  "fds",
+  "fld",
+  "flm",
+  "fmd",
+  "fmk",
+  "fmo",
+  "fmp",
+  "fnd",
+  "fpy",
+  "frg",
+  "gis",
+  "grt",
+  "his",
+  "hnr",
+  "hst",
+  "ill",
+  "ilu",
+  "ins",
+  "inv",
+  "isb",
+  "itr",
+  "ive",
+  "ivr",
+  "jud",
+  "jug",
+  "lbr",
+  "lbt",
+  "ldr",
+  "led",
+  "lee",
+  "lel",
+  "len",
+  "let",
+  "lgd",
+  "lie",
+  "lil",
+  "lit",
+  "lsa",
+  "lse",
+  "lso",
+  "ltg",
+  "lyr",
+  "mcp",
+  "mdc",
+  "med",
+  "mfp",
+  "mfr",
+  "mod",
+  "mon",
+  "mrb",
+  "mrk",
+  "msd",
+  "mte",
+  "mtk",
+  "mus",
+  "nrt",
+  "opn",
+  "org",
+  "orm",
+  "osp",
+  "oth",
+  "own",
+  "pad",
+  "pan",
+  "pat",
+  "pbd",
+  "pbl",
+  "pdr",
+  "pfr",
+  "pht",
+  "plt",
+  "pma",
+  "pmn",
+  "pop",
+  "ppm",
+  "ppt",
+  "pra",
+  "prc",
+  "prd",
+  "pre",
+  "prf",
+  "prg",
+  "prm",
+  "prn",
+  "pro",
+  "prp",
+  "prs",
+  "prt",
+  "prv",
+  "pta",
+  "pte",
+  "ptf",
+  "pth",
+  "ptt",
+  "pup",
+  "rbr",
+  "rcd",
+  "rce",
+  "rcp",
+  "rdd",
+  "red",
+  "ren",
+  "res",
+  "rev",
+  "rpc",
+  "rps",
+  "rpt",
+  "rpy",
+  "rse",
+  "rsg",
+  "rsp",
+  "rsr",
+  "rst",
+  "rth",
+  "rtm",
+  "sad",
+  "sce",
+  "scl",
+  "scr",
+  "sds",
+  "sec",
+  "sgd",
+  "sgn",
+  "sht",
+  "sll",
+  "sng",
+  "spk",
+  "spn",
+  "spy",
+  "srv",
+  "std",
+  "stg",
+  "stl",
+  "stm",
+  "stn",
+  "str",
+  "tcd",
+  "tch",
+  "ths",
+  "tld",
+  "tlp",
+  "trc",
+  "trl",
+  "tyd",
+  "tyg",
+  "uvp",
+  "vac",
+  "vdg",
+  "voc",
+  "wac",
+  "wal",
+  "wam",
+  "wat",
+  "wdc",
+  "wde",
+  "win",
+  "wit",
+  "wpr",
+  "wst"
+]);
+var DEPRECATED_LINK_REL = /* @__PURE__ */ new Set([
+  "marc21xml-record",
+  "mods-record",
+  "onix-record",
+  "xmp-record",
+  "xml-signature"
+]);
+var EXCLUSIVE_SPINE_GROUPS = [
+  ["rendition:layout-reflowable", "rendition:layout-pre-paginated"],
+  [
+    "rendition:orientation-auto",
+    "rendition:orientation-landscape",
+    "rendition:orientation-portrait"
+  ],
+  [
+    "rendition:spread-auto",
+    "rendition:spread-both",
+    "rendition:spread-landscape",
+    "rendition:spread-none",
+    "rendition:spread-portrait"
+  ],
+  ["page-spread-left", "page-spread-right", "rendition:page-spread-center"],
+  [
+    "rendition:flow-auto",
+    "rendition:flow-paginated",
+    "rendition:flow-scrolled-continuous",
+    "rendition:flow-scrolled-doc"
+  ]
+];
+var RENDITION_META_RULES = [
+  {
+    property: "rendition:layout",
+    allowedValues: /* @__PURE__ */ new Set(["reflowable", "pre-paginated"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:orientation",
+    allowedValues: /* @__PURE__ */ new Set(["landscape", "portrait", "auto"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:spread",
+    allowedValues: /* @__PURE__ */ new Set(["none", "landscape", "portrait", "both", "auto"]),
+    forbidRefines: true,
+    deprecatedValues: /* @__PURE__ */ new Set(["portrait"])
+  },
+  {
+    property: "rendition:flow",
+    allowedValues: /* @__PURE__ */ new Set(["paginated", "scrolled-continuous", "scrolled-doc", "auto"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:viewport",
+    deprecated: true,
+    allowedValues: /* @__PURE__ */ new Set(),
+    validateSyntax: (v) => /^(width=\d+,\s*height=\d+|height=\d+,\s*width=\d+)$/.test(v)
+  }
+];
+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",
+  "i-bnn",
+  "i-default",
+  "i-enochian",
+  "i-hak",
+  "i-klingon",
+  "i-lux",
+  "i-mingo",
+  "i-navajo",
+  "i-pwn",
+  "i-tao",
+  "i-tay",
+  "i-tsu",
+  "sgn-BE-FR",
+  "sgn-BE-NL",
+  "sgn-CH-DE",
+  "art-lojban",
+  "cel-gaulish",
+  "no-bok",
+  "no-nyn",
+  "zh-guoyu",
+  "zh-hakka",
+  "zh-min",
+  "zh-min-nan",
+  "zh-xiang"
+]);
 var OPFValidator = class {
   packageDoc = null;
   manifestById = /* @__PURE__ */ new Map();
@@ -5210,13 +6808,7 @@ var OPFValidator = class {
     if (this.packageDoc.xmlLangs) {
       for (const lang of this.packageDoc.xmlLangs) {
         if (lang === "") continue;
-        if (lang !== lang.trim()) {
-          pushMessage(context.messages, {
-            id: MessageId.OPF_092,
-            message: `Language tag "${lang}" is not well-formed`,
-            location: { path: opfPath }
-          });
-        } else if (!isValidLanguageTag(lang)) {
+        if (lang !== lang.trim() || !isValidLanguageTag(lang)) {
           pushMessage(context.messages, {
             id: MessageId.OPF_092,
             message: `Language tag "${lang}" is not well-formed`,
@@ -5242,11 +6834,10 @@ var OPFValidator = class {
    */
   validatePackageAttributes(context, opfPath) {
     if (!this.packageDoc) return;
-    const validVersions = /* @__PURE__ */ new Set(["2.0", "3.0", "3.1", "3.2", "3.3"]);
-    if (!validVersions.has(this.packageDoc.version)) {
+    if (!VALID_VERSIONS.has(this.packageDoc.version)) {
       pushMessage(context.messages, {
         id: MessageId.OPF_001,
-        message: `Invalid package version "${this.packageDoc.version}"; must be one of: ${Array.from(validVersions).join(", ")}`,
+        message: `Invalid package version "${this.packageDoc.version}"; must be one of: ${Array.from(VALID_VERSIONS).join(", ")}`,
         location: { path: opfPath }
       });
     }
@@ -5322,280 +6913,539 @@ var OPFValidator = class {
             location: { path: opfPath }
           });
         }
-      }
-      if (dc.name === "date" && dc.value) {
-        if (!isValidW3CDateFormat(dc.value)) {
-          pushMessage(context.messages, {
-            id: MessageId.OPF_053,
-            message: `Invalid date format "${dc.value}"; must be W3C date format (ISO 8601)`,
-            location: { path: opfPath }
-          });
+      }
+      if (dc.name === "date" && dc.value) {
+        if (!isValidW3CDateFormat(dc.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_053,
+            message: `Invalid date format "${dc.value}"; must be W3C date format (ISO 8601)`,
+            location: { path: opfPath }
+          });
+        }
+      }
+      if (dc.name === "identifier" && dc.value) {
+        const val = dc.value.trim();
+        if (val.startsWith("urn:uuid:")) {
+          const uuid = val.substring(9);
+          if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(uuid)) {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_085,
+              message: `Invalid UUID value "${uuid}"`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+      if (dc.name === "creator" && dc.attributes) {
+        const role = dc.attributes["opf:role"];
+        if (role && !VALID_RELATOR_CODES.has(role) && !role.startsWith("oth.")) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_052,
+            message: `Invalid role value "${role}" in dc:creator`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+    if (this.packageDoc.version !== "2.0") {
+      for (const meta of this.packageDoc.metaElements) {
+        if (meta.property && /\s/.test(meta.property.trim())) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_025,
+            message: `Property value must be a single value, not a list: "${meta.property}"`,
+            location: { path: opfPath }
+          });
+        }
+        if (meta.scheme && /\s/.test(meta.scheme.trim())) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_025,
+            message: `Scheme value must be a single value, not a list: "${meta.scheme}"`,
+            location: { path: opfPath }
+          });
+        }
+        if (meta.property && !/\s/.test(meta.property.trim())) {
+          const prop = meta.property.trim();
+          if (prop.includes(":") && /:\s*$/.test(prop)) {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_026,
+              message: `Malformed property name: "${prop}"`,
+              location: { path: opfPath }
+            });
+          }
+        }
+        if (meta.scheme) {
+          const scheme = meta.scheme.trim();
+          if (scheme && !scheme.includes(":")) {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_027,
+              message: `Undefined property: "${scheme}"`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+    }
+    if (this.packageDoc.version !== "2.0") {
+      const allIds = /* @__PURE__ */ new Set();
+      for (const dc of dcElements) {
+        if (dc.id) allIds.add(dc.id);
+      }
+      for (const meta of this.packageDoc.metaElements) {
+        if (meta.id) allIds.add(meta.id);
+      }
+      for (const link of this.packageDoc.linkElements) {
+        if (link.id) allIds.add(link.id);
+      }
+      for (const item of this.packageDoc.manifest) {
+        allIds.add(item.id);
+      }
+      const seenGlobalIds = /* @__PURE__ */ new Set();
+      const allIdSources = [];
+      for (const dc of dcElements) {
+        if (dc.id) allIdSources.push({ id: dc.id, normalized: dc.id.trim() });
+      }
+      for (const meta of this.packageDoc.metaElements) {
+        if (meta.id) allIdSources.push({ id: meta.id, normalized: meta.id.trim() });
+      }
+      for (const link of this.packageDoc.linkElements) {
+        if (link.id) allIdSources.push({ id: link.id, normalized: link.id.trim() });
+      }
+      for (const item of this.packageDoc.manifest) {
+        allIdSources.push({ id: item.id, normalized: item.id.trim() });
+      }
+      for (const itemref of this.packageDoc.spine) {
+        if (itemref.id) allIdSources.push({ id: itemref.id, normalized: itemref.id.trim() });
+      }
+      for (const src of allIdSources) {
+        if (seenGlobalIds.has(src.normalized)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `Duplicate "${src.normalized}"`,
+            location: { path: opfPath }
+          });
+        }
+        seenGlobalIds.add(src.normalized);
+      }
+      for (const meta of this.packageDoc.metaElements) {
+        if (!meta.refines) continue;
+        const refines = meta.refines;
+        if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(refines)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: "@refines must be a relative URL",
+            location: { path: opfPath }
+          });
+          continue;
+        }
+        if (!refines.startsWith("#")) {
+          const isManifestHref = this.packageDoc.manifest.some((item) => item.href === refines);
+          if (isManifestHref) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_017,
+              message: `@refines should instead refer to "${refines}" using a fragment identifier pointing to its manifest item`,
+              location: { path: opfPath }
+            });
+          }
+          continue;
+        }
+        const targetId = refines.substring(1);
+        if (!allIds.has(targetId)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `@refines missing target id: "${targetId}"`,
+            location: { path: opfPath }
+          });
+        }
+      }
+      this.detectRefinesCycles(context, opfPath);
+    }
+    if (this.packageDoc.version !== "2.0") {
+      this.validateMetaPropertiesVocab(context, opfPath, dcElements);
+      this.validateRenditionVocab(context, opfPath);
+      this.validateMediaOverlaysVocab(context, opfPath);
+    }
+    if (this.packageDoc.version !== "2.0") {
+      const modifiedMetas = this.packageDoc.metaElements.filter(
+        (meta) => meta.property === "dcterms:modified"
+      );
+      const modifiedMeta = modifiedMetas[0];
+      if (modifiedMetas.length > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "package dcterms:modified meta element must occur exactly once",
+          location: { path: opfPath }
+        });
+      }
+      if (!modifiedMeta) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "package dcterms:modified meta element must occur exactly once",
+          location: { path: opfPath }
+        });
+        pushMessage(context.messages, {
+          id: MessageId.OPF_054,
+          message: "EPUB 3 metadata must include a dcterms:modified meta element",
+          location: { path: opfPath }
+        });
+      } else if (modifiedMeta.value) {
+        const strictModifiedPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+        if (!strictModifiedPattern.test(modifiedMeta.value.trim())) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `dcterms:modified illegal syntax (expecting: "CCYY-MM-DDThh:mm:ssZ")`,
+            location: { path: opfPath }
+          });
+        }
+        if (!isValidW3CDateFormat(modifiedMeta.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_054,
+            message: `Invalid dcterms:modified date format "${modifiedMeta.value}"; must be W3C date format (ISO 8601)`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate EPUB 3 meta element vocabulary (D-vocabularies: meta-properties)
+   * Ports package-30.sch Schematron patterns for authority, term, belongs-to-collection,
+   * collection-type, display-seq, file-as, group-position, identifier-type, meta-auth,
+   * role, source-of, and title-type.
+   */
+  validateMetaPropertiesVocab(context, opfPath, dcElements) {
+    if (!this.packageDoc) return;
+    const metaElements = this.packageDoc.metaElements;
+    const metaIdToProp = /* @__PURE__ */ new Map();
+    for (const meta of metaElements) {
+      if (meta.id) metaIdToProp.set(meta.id.trim(), meta.property.trim());
+    }
+    for (const dc of dcElements) {
+      if (dc.name !== "subject" || !dc.id) continue;
+      const subjectId = dc.id.trim();
+      const authorityCount = metaElements.filter(
+        (m) => m.property.trim() === "authority" && m.refines?.trim().substring(1) === subjectId
+      ).length;
+      const termCount = metaElements.filter(
+        (m) => m.property.trim() === "term" && m.refines?.trim().substring(1) === subjectId
+      ).length;
+      if (authorityCount > 1 || termCount > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "Only one pair of authority and term properties can be associated with a dc:subject",
+          location: { path: opfPath }
+        });
+      } else if (authorityCount === 1 && termCount === 0) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "A term property must be associated with a dc:subject when an authority is specified",
+          location: { path: opfPath }
+        });
+      } else if (authorityCount === 0 && termCount === 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "An authority property must be associated with a dc:subject when a term is specified",
+          location: { path: opfPath }
+        });
+      }
+    }
+    const seenPropertyRefines = /* @__PURE__ */ new Set();
+    for (const meta of metaElements) {
+      const prop = meta.property.trim();
+      const refines = meta.refines?.trim();
+      switch (prop) {
+        case "authority": {
+          const ok = dcElements.some(
+            (dc) => dc.name === "subject" && dc.id && "#" + dc.id.trim() === refines
+          );
+          if (!ok) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'Property "authority" must refine a "subject" property.',
+              location: { path: opfPath }
+            });
+          }
+          break;
+        }
+        case "term": {
+          const ok = dcElements.some(
+            (dc) => dc.name === "subject" && dc.id && "#" + dc.id.trim() === refines
+          );
+          if (!ok) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'Property "term" must refine a "subject" property.',
+              location: { path: opfPath }
+            });
+          }
+          break;
+        }
+        case "belongs-to-collection": {
+          if (refines) {
+            const targetId = refines.substring(1);
+            if (metaIdToProp.get(targetId) !== "belongs-to-collection") {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: 'Property "belongs-to-collection" can only refine other "belongs-to-collection" properties.',
+                location: { path: opfPath }
+              });
+            }
+          }
+          break;
+        }
+        case "collection-type": {
+          if (!refines) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'Property "collection-type" must refine a "belongs-to-collection" property.',
+              location: { path: opfPath }
+            });
+          } else {
+            const targetId = refines.substring(1);
+            if (metaIdToProp.get(targetId) !== "belongs-to-collection") {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: 'Property "collection-type" must refine a "belongs-to-collection" property.',
+                location: { path: opfPath }
+              });
+            }
+          }
+          const ctKey = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(ctKey)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: '"collection-type" cannot be declared more than once to refine the same "belongs-to-collection" expression.',
+              location: { path: opfPath }
+            });
+          }
+          seenPropertyRefines.add(ctKey);
+          break;
+        }
+        case "display-seq": {
+          const key = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(key)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: '"display-seq" cannot be declared more than once to refine the same expression.',
+              location: { path: opfPath }
+            });
+          }
+          seenPropertyRefines.add(key);
+          break;
         }
-      }
-      if (dc.name === "identifier" && dc.value) {
-        const val = dc.value.trim();
-        if (val.startsWith("urn:uuid:")) {
-          const uuid = val.substring(9);
-          if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(uuid)) {
+        case "file-as": {
+          const key = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(key)) {
             pushMessage(context.messages, {
-              id: MessageId.OPF_085,
-              message: `Invalid UUID value "${uuid}"`,
+              id: MessageId.RSC_005,
+              message: '"file-as" cannot be declared more than once to refine the same expression.',
               location: { path: opfPath }
             });
           }
+          seenPropertyRefines.add(key);
+          break;
         }
-      }
-      if (dc.name === "creator" && dc.attributes) {
-        const opfRole = dc.attributes["opf:role"];
-        if (opfRole?.startsWith("marc:")) {
-          const relatorCode = opfRole.substring(5);
-          const validRelatorCodes = /* @__PURE__ */ new Set([
-            "arr",
-            "aut",
-            "aut",
-            "ccp",
-            "com",
-            "ctb",
-            "csl",
-            "edt",
-            "ill",
-            "itr",
-            "pbl",
-            "pdr",
-            "prt",
-            "trl",
-            "cre",
-            "art",
-            "ctb",
-            "edt",
-            "pfr",
-            "red",
-            "rev",
-            "spn",
-            "dsx",
-            "pmc",
-            "dte",
-            "ove",
-            "trc",
-            "ldr",
-            "led",
-            "prg",
-            "rap",
-            "rce",
-            "rpc",
-            "rtr",
-            "sad",
-            "sgn",
-            "tce",
-            "aac",
-            "acq",
-            "ant",
-            "arr",
-            "art",
-            "ard",
-            "asg",
-            "aus",
-            "aft",
-            "bdd",
-            "bdd",
-            "clb",
-            "clc",
-            "drd",
-            "edt",
-            "edt",
-            "fmd",
-            "flm",
-            "fmo",
-            "fpy",
-            "hnr",
-            "ill",
-            "ilt",
-            "img",
-            "itr",
-            "lrg",
-            "lsa",
-            "led",
-            "lee",
-            "lel",
-            "lgd",
-            "lse",
-            "mfr",
-            "mod",
-            "mon",
-            "mus",
-            "nrt",
-            "ogt",
-            "org",
-            "oth",
-            "pnt",
-            "ppa",
-            "prv",
-            "pup",
-            "red",
-            "rev",
-            "rsg",
-            "srv",
-            "stn",
-            "stl",
-            "trc",
-            "typ",
-            "vdg",
-            "voc",
-            "wac",
-            "wdc"
-          ]);
-          if (!validRelatorCodes.has(relatorCode)) {
+        case "group-position": {
+          const key = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(key)) {
             pushMessage(context.messages, {
-              id: MessageId.OPF_052,
-              message: `Unknown MARC relator code "${relatorCode}" in dc:creator`,
+              id: MessageId.RSC_005,
+              message: '"group-position" cannot be declared more than once to refine the same expression.',
               location: { path: opfPath }
             });
           }
+          seenPropertyRefines.add(key);
+          break;
         }
-      }
-    }
-    if (this.packageDoc.version !== "2.0") {
-      for (const meta of this.packageDoc.metaElements) {
-        if (meta.property && /\s/.test(meta.property.trim())) {
-          pushMessage(context.messages, {
-            id: MessageId.OPF_025,
-            message: `Property value must be a single value, not a list: "${meta.property}"`,
-            location: { path: opfPath }
-          });
+        case "identifier-type": {
+          const ok = dcElements.some(
+            (dc) => (dc.name === "identifier" || dc.name === "source") && dc.id && "#" + dc.id.trim() === refines
+          );
+          if (!ok) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'Property "identifier-type" must refine an "identifier" or "source" property.',
+              location: { path: opfPath }
+            });
+          }
+          const itKey = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(itKey)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: '"identifier-type" cannot be declared more than once to refine the same expression.',
+              location: { path: opfPath }
+            });
+          }
+          seenPropertyRefines.add(itKey);
+          break;
         }
-        if (meta.scheme && /\s/.test(meta.scheme.trim())) {
+        case "meta-auth": {
           pushMessage(context.messages, {
-            id: MessageId.OPF_025,
-            message: `Scheme value must be a single value, not a list: "${meta.scheme}"`,
+            id: MessageId.RSC_017,
+            message: "Use of the meta-auth property is deprecated",
             location: { path: opfPath }
           });
+          break;
         }
-        if (meta.property && !/\s/.test(meta.property.trim())) {
-          const prop = meta.property.trim();
-          if (prop.includes(":") && /:\s*$/.test(prop)) {
+        case "role": {
+          const ok = dcElements.some(
+            (dc) => (dc.name === "creator" || dc.name === "contributor" || dc.name === "publisher") && dc.id && "#" + dc.id.trim() === refines
+          );
+          if (!ok) {
             pushMessage(context.messages, {
-              id: MessageId.OPF_026,
-              message: `Malformed property name: "${prop}"`,
+              id: MessageId.RSC_005,
+              message: 'Property "role" must refine a "creator", "contributor", or "publisher" property.',
               location: { path: opfPath }
             });
           }
+          break;
         }
-        if (meta.scheme) {
-          const scheme = meta.scheme.trim();
-          if (scheme && !scheme.includes(":")) {
+        case "source-of": {
+          if (meta.value.trim() !== "pagination") {
             pushMessage(context.messages, {
-              id: MessageId.OPF_027,
-              message: `Undefined property: "${scheme}"`,
+              id: MessageId.RSC_005,
+              message: 'The "source-of" property must have the value "pagination"',
+              location: { path: opfPath }
+            });
+          }
+          const hasSourceRefines = dcElements.some(
+            (dc) => dc.name === "source" && dc.id && refines?.substring(1) === dc.id.trim()
+          );
+          if (!hasSourceRefines) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'The "source-of" property must refine a "source" property.',
+              location: { path: opfPath }
+            });
+          }
+          const soKey = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(soKey)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: '"source-of" cannot be declared more than once to refine the same "source" expression.',
+              location: { path: opfPath }
+            });
+          }
+          seenPropertyRefines.add(soKey);
+          break;
+        }
+        case "title-type": {
+          const ok = dcElements.some(
+            (dc) => dc.name === "title" && dc.id && "#" + dc.id.trim() === refines
+          );
+          if (!ok) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: 'Property "title-type" must refine a "title" property.',
+              location: { path: opfPath }
+            });
+          }
+          const ttKey = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(ttKey)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: '"title-type" cannot be declared more than once to refine the same "title" expression.',
               location: { path: opfPath }
             });
           }
+          seenPropertyRefines.add(ttKey);
+          break;
         }
       }
     }
-    if (this.packageDoc.version !== "2.0") {
-      const allIds = /* @__PURE__ */ new Set();
-      for (const dc of dcElements) {
-        if (dc.id) allIds.add(dc.id);
-      }
-      for (const meta of this.packageDoc.metaElements) {
-        if (meta.id) allIds.add(meta.id);
-      }
-      for (const link of this.packageDoc.linkElements) {
-        if (link.id) allIds.add(link.id);
-      }
-      for (const item of this.packageDoc.manifest) {
-        allIds.add(item.id);
-      }
-      const seenGlobalIds = /* @__PURE__ */ new Set();
-      const allIdSources = [];
-      for (const dc of dcElements) {
-        if (dc.id) allIdSources.push({ id: dc.id, normalized: dc.id.trim() });
-      }
-      for (const meta of this.packageDoc.metaElements) {
-        if (meta.id) allIdSources.push({ id: meta.id, normalized: meta.id.trim() });
-      }
-      for (const link of this.packageDoc.linkElements) {
-        if (link.id) allIdSources.push({ id: link.id, normalized: link.id.trim() });
-      }
-      for (const item of this.packageDoc.manifest) {
-        allIdSources.push({ id: item.id, normalized: item.id.trim() });
-      }
-      for (const src of allIdSources) {
-        if (seenGlobalIds.has(src.normalized)) {
+  }
+  /**
+   * Validate rendition vocabulary meta properties (rendition:layout, orientation, spread, flow, viewport).
+   * Ports the Schematron rules from package-30.sch for the rendition vocabulary.
+   */
+  validateRenditionVocab(context, opfPath) {
+    if (!this.packageDoc) return;
+    const metas = this.packageDoc.metaElements;
+    for (const rp of RENDITION_META_RULES) {
+      const matching = metas.filter((m) => m.property === rp.property);
+      for (const meta of matching) {
+        if (meta.refines && rp.forbidRefines) {
           pushMessage(context.messages, {
             id: MessageId.RSC_005,
-            message: `Duplicate "${src.normalized}"`,
+            message: `The "${rp.property}" property must not refine a publication resource`,
             location: { path: opfPath }
           });
+          continue;
         }
-        seenGlobalIds.add(src.normalized);
-      }
-      for (const meta of this.packageDoc.metaElements) {
-        if (!meta.refines) continue;
-        const refines = meta.refines;
-        if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(refines)) {
+        if (rp.deprecated) {
           pushMessage(context.messages, {
-            id: MessageId.RSC_005,
-            message: "@refines must be a relative URL",
+            id: MessageId.OPF_086,
+            message: `The "${rp.property}" property is deprecated`,
             location: { path: opfPath }
           });
-          continue;
         }
-        if (!refines.startsWith("#")) {
+        if (rp.validateSyntax) {
+          if (!rp.validateSyntax(meta.value)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The value of the "${rp.property}" property must be of the form "width=x, height=y"`,
+              location: { path: opfPath }
+            });
+          }
+        } else if (!rp.allowedValues.has(meta.value)) {
           pushMessage(context.messages, {
-            id: MessageId.RSC_017,
-            message: `@refines should instead refer to "${refines}" using a fragment identifier pointing to its manifest item`,
+            id: MessageId.RSC_005,
+            message: `The value of the "${rp.property}" property must be ${[...rp.allowedValues].map((v) => `"${v}"`).join(" or ")}`,
             location: { path: opfPath }
           });
-          continue;
         }
-        const targetId = refines.substring(1);
-        if (!allIds.has(targetId)) {
+        if (rp.deprecatedValues?.has(meta.value)) {
           pushMessage(context.messages, {
-            id: MessageId.RSC_005,
-            message: `@refines missing target id: "${targetId}"`,
+            id: MessageId.OPF_086,
+            message: `The "${rp.property}" property value "${meta.value}" is deprecated`,
             location: { path: opfPath }
           });
         }
       }
-      this.detectRefinesCycles(context, opfPath);
-    }
-    if (this.packageDoc.version !== "2.0") {
-      const modifiedMetas = this.packageDoc.metaElements.filter(
-        (meta) => meta.property === "dcterms:modified"
-      );
-      const modifiedMeta = modifiedMetas[0];
-      if (modifiedMetas.length > 1) {
+      const countable = rp.forbidRefines ? matching : matching.filter((m) => !m.refines);
+      if (countable.length > 1) {
         pushMessage(context.messages, {
           id: MessageId.RSC_005,
-          message: "package dcterms:modified meta element must occur exactly once",
+          message: `The "${rp.property}" property must not occur more than one time as a global value`,
           location: { path: opfPath }
         });
       }
-      if (!modifiedMeta) {
+    }
+    for (const meta of metas) {
+      if (meta.property.startsWith("rendition:")) {
+        const localName = meta.property.slice("rendition:".length);
+        if (!KNOWN_RENDITION_META_PROPERTIES.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_027,
+            message: `Undefined property: "${meta.property}"`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate media overlays vocabulary meta properties (media:active-class, playback-active-class, duration).
+   * Ports the Schematron rules from package-30.sch for the media overlays vocabulary.
+   */
+  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);
         pushMessage(context.messages, {
           id: MessageId.RSC_005,
-          message: "package dcterms:modified meta element must occur exactly once",
-          location: { path: opfPath }
-        });
-        pushMessage(context.messages, {
-          id: MessageId.OPF_054,
-          message: "EPUB 3 metadata must include a dcterms:modified meta element",
+          message: `The '${displayName}' property must not occur more than one time in the package metadata`,
           location: { path: opfPath }
         });
-      } else if (modifiedMeta.value) {
-        const strictModifiedPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
-        if (!strictModifiedPattern.test(modifiedMeta.value.trim())) {
+      }
+    }
+    for (const meta of metas) {
+      if (meta.property === "media:duration") {
+        if (!SMIL3_CLOCK_RE.test(meta.value.trim())) {
           pushMessage(context.messages, {
             id: MessageId.RSC_005,
-            message: `dcterms:modified illegal syntax (expecting: "CCYY-MM-DDThh:mm:ssZ")`,
-            location: { path: opfPath }
-          });
-        }
-        if (!isValidW3CDateFormat(modifiedMeta.value)) {
-          pushMessage(context.messages, {
-            id: MessageId.OPF_054,
-            message: `Invalid dcterms:modified date format "${modifiedMeta.value}"; must be W3C date format (ISO 8601)`,
+            message: `The value of the "media:duration" property must be a valid SMIL3 clock value`,
             location: { path: opfPath }
           });
         }
@@ -5607,7 +7457,6 @@ var OPFValidator = class {
    */
   validateLinkElements(context, opfPath) {
     if (!this.packageDoc) return;
-    const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
     for (const link of this.packageDoc.linkElements) {
       if (link.hreflang !== void 0 && link.hreflang !== "") {
         const lang = link.hreflang;
@@ -5636,6 +7485,40 @@ var OPFValidator = class {
           }
         }
       }
+      const relKeywords = link.rel ? link.rel.trim().split(/\s+/).filter(Boolean) : [];
+      const hasRecord = relKeywords.includes("record");
+      const hasVoicing = relKeywords.includes("voicing");
+      const hasAlternate = relKeywords.includes("alternate");
+      if (hasAlternate && relKeywords.length > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_089,
+          message: `The "alternate" keyword must not be combined with other keywords in the "rel" attribute`,
+          location: { path: opfPath }
+        });
+      }
+      for (const kw of relKeywords) {
+        if (DEPRECATED_LINK_REL.has(kw)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_086,
+            message: `The rel keyword "${kw}" is deprecated`,
+            location: { path: opfPath }
+          });
+        }
+      }
+      if (hasRecord && link.refines) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: '"record" links only applies to the Publication (must not have a "refines" attribute).',
+          location: { path: opfPath }
+        });
+      }
+      if (hasVoicing && !link.refines) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: '"voicing" links must have a "refines" attribute.',
+          location: { path: opfPath }
+        });
+      }
       const href = link.href;
       const decodedHref = tryDecodeUriComponent(href);
       const basePath = href.includes("#") ? href.substring(0, href.indexOf("#")) : href;
@@ -5648,7 +7531,44 @@ var OPFValidator = class {
         });
         continue;
       }
+      if (isDataURL(href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_029,
+          message: `Data URLs are not allowed in the package document link href`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
+      if (isFileURL(href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_030,
+          message: `File URLs are not allowed in the package document`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
       const isRemote = /^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(href);
+      if (!isRemote && href.includes("?")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_033,
+          message: `Relative URL strings must not have a query component: "${href}"`,
+          location: { path: opfPath }
+        });
+      }
+      if (hasVoicing && link.mediaType && !link.mediaType.startsWith("audio/")) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_095,
+          message: `The "voicing" link media type must be an audio type, but found "${link.mediaType}"`,
+          location: { path: opfPath }
+        });
+      }
+      if (isRemote && !link.mediaType && (hasRecord || hasVoicing)) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_094,
+          message: `The "media-type" attribute is required for "record" and "voicing" links`,
+          location: { path: opfPath }
+        });
+      }
       if (isRemote) {
         continue;
       }
@@ -5659,10 +7579,12 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
-      const resolvedPath = resolvePath(opfDir, basePath);
-      const resolvedPathDecoded = basePathDecoded !== basePath ? resolvePath(opfDir, basePathDecoded) : resolvedPath;
+      const basePathNoQuery = basePath.includes("?") ? basePath.substring(0, basePath.indexOf("?")) : basePath;
+      const basePathDecodedNoQuery = basePathDecoded.includes("?") ? basePathDecoded.substring(0, basePathDecoded.indexOf("?")) : basePathDecoded;
+      const resolvedPath = resolvePath(opfPath, basePathNoQuery);
+      const resolvedPathDecoded = basePathDecodedNoQuery !== basePathNoQuery ? resolvePath(opfPath, basePathDecodedNoQuery) : resolvedPath;
       const fileExists = context.files.has(resolvedPath) || context.files.has(resolvedPathDecoded);
-      const inManifest = this.manifestByHref.has(basePath) || this.manifestByHref.has(basePathDecoded);
+      const inManifest = this.manifestByHref.has(basePathNoQuery) || this.manifestByHref.has(basePathDecodedNoQuery);
       if (!fileExists && !inManifest) {
         pushMessage(context.messages, {
           id: MessageId.RSC_007w,
@@ -5696,7 +7618,24 @@ var OPFValidator = class {
         });
       }
       seenHrefs.add(item.href);
-      const fullPath = resolvePath(opfPath, item.href);
+      if (isDataURL(item.href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_029,
+          message: `Data URLs are not allowed in the manifest item href`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
+      const isRemoteItem = /^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(item.href);
+      if (!isRemoteItem && item.href.includes("?")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_033,
+          message: `Relative URL strings must not have a query component: "${item.href}"`,
+          location: { path: opfPath }
+        });
+      }
+      const itemHrefBase = item.href.includes("?") ? item.href.substring(0, item.href.indexOf("?")) : item.href;
+      const fullPath = resolvePath(opfPath, itemHrefBase);
       if (fullPath === opfPath) {
         pushMessage(context.messages, {
           id: MessageId.OPF_099,
@@ -5705,7 +7644,7 @@ var OPFValidator = class {
         });
       }
       if (!item.href.startsWith("http") && !item.href.startsWith("mailto:")) {
-        const leaked = checkUrlLeaking2(item.href);
+        const leaked = checkUrlLeaking(item.href);
         if (leaked) {
           pushMessage(context.messages, {
             id: MessageId.RSC_026,
@@ -5714,8 +7653,8 @@ var OPFValidator = class {
           });
         }
       }
-      const decodedHref = tryDecodeUriComponent(item.href);
-      const fullPathDecoded = decodedHref !== item.href ? resolvePath(opfPath, decodedHref).normalize("NFC") : fullPath;
+      const decodedHref = tryDecodeUriComponent(itemHrefBase);
+      const fullPathDecoded = decodedHref !== itemHrefBase ? resolvePath(opfPath, decodedHref).normalize("NFC") : fullPath;
       if (!context.files.has(fullPath) && !context.files.has(fullPathDecoded) && !item.href.startsWith("http")) {
         pushMessage(context.messages, {
           id: MessageId.RSC_001,
@@ -5737,13 +7676,7 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
-      const deprecatedTypes = /* @__PURE__ */ new Set([
-        "text/x-oeb1-document",
-        "text/x-oeb1-css",
-        "application/x-oeb1-package",
-        "text/x-oeb1-html"
-      ]);
-      if (deprecatedTypes.has(item.mediaType)) {
+      if (DEPRECATED_MEDIA_TYPES.has(item.mediaType)) {
         pushMessage(context.messages, {
           id: MessageId.OPF_037,
           message: `Found deprecated media-type "${item.mediaType}"`,
@@ -5799,7 +7732,7 @@ var OPFValidator = class {
         });
       }
       if (this.packageDoc.version !== "2.0" && (item.href.startsWith("http://") || item.href.startsWith("https://"))) {
-        const isAllowedRemoteType = item.mediaType.startsWith("audio/") || item.mediaType.startsWith("video/") || item.mediaType.startsWith("font/") || item.mediaType === "application/font-sfnt" || item.mediaType === "application/font-woff" || item.mediaType === "application/vnd.ms-opentype";
+        const isAllowedRemoteType = item.mediaType.startsWith("audio/") || item.mediaType.startsWith("video/") || item.mediaType.startsWith("font/") || item.mediaType === "application/font-sfnt" || item.mediaType === "application/font-woff" || item.mediaType === "application/font-woff2" || item.mediaType === "application/vnd.ms-opentype";
         const inSpine = this.packageDoc.spine.some((s) => s.idref === item.id);
         if (inSpine) {
           if (!isAllowedRemoteType) {
@@ -5944,6 +7877,24 @@ var OPFValidator = class {
               location: { path: opfPath }
             });
           }
+          if (prop === "rendition:spread-portrait") {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_086,
+              message: `The "rendition:spread-portrait" property is deprecated`,
+              location: { path: opfPath }
+            });
+          }
+        }
+        const props = new Set(itemref.properties);
+        for (const group of EXCLUSIVE_SPINE_GROUPS) {
+          const found = group.filter((p) => props.has(p));
+          if (found.length > 1) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `Properties "${found.join('", "')}" are mutually exclusive`,
+              location: { path: opfPath }
+            });
+          }
         }
       }
     }
@@ -6153,35 +8104,7 @@ function isValidLanguageTag(tag) {
   const pattern = /^[a-zA-Z]{2,3}(-[a-zA-Z]{4})?(-[a-zA-Z]{2}|-\d{3})?(-([a-zA-Z\d]{5,8}|\d[a-zA-Z\d]{3}))*(-[a-wyzA-WYZ](-[a-zA-Z\d]{2,8})+)*(-x(-[a-zA-Z\d]{1,8})+)?$/;
   if (pattern.test(tag)) return true;
   if (/^x(-[a-zA-Z\d]{1,8})+$/.test(tag)) return true;
-  const grandfathered = /* @__PURE__ */ new Set([
-    "en-GB-oed",
-    "i-ami",
-    "i-bnn",
-    "i-default",
-    "i-enochian",
-    "i-hak",
-    "i-klingon",
-    "i-lux",
-    "i-mingo",
-    "i-navajo",
-    "i-pwn",
-    "i-tao",
-    "i-tay",
-    "i-tsu",
-    "sgn-BE-FR",
-    "sgn-BE-NL",
-    "sgn-CH-DE",
-    "art-lojban",
-    "cel-gaulish",
-    "no-bok",
-    "no-nyn",
-    "zh-guoyu",
-    "zh-hakka",
-    "zh-min",
-    "zh-min-nan",
-    "zh-xiang"
-  ]);
-  return grandfathered.has(tag);
+  return GRANDFATHERED_LANG_TAGS.has(tag);
 }
 function resolvePath(basePath, relativePath) {
   if (relativePath.startsWith("/")) {
@@ -6209,17 +8132,6 @@ function tryDecodeUriComponent(encoded) {
     return encoded;
   }
 }
-function checkUrlLeaking2(href) {
-  const TEST_BASE_A = "https://a.example.org/A/";
-  const TEST_BASE_B = "https://b.example.org/B/";
-  try {
-    const urlA = new URL(href, TEST_BASE_A).toString();
-    const urlB = new URL(href, TEST_BASE_B).toString();
-    return !urlA.startsWith(TEST_BASE_A) || !urlB.startsWith(TEST_BASE_B);
-  } catch {
-    return false;
-  }
-}
 function isValidMimeType(mediaType) {
   const mimeTypePattern = /^[a-zA-Z][a-zA-Z0-9!#$&\-^_.]*\/[a-zA-Z0-9][a-zA-Z0-9!#$&\-^_.+]*(?:\s*;\s*[a-zA-Z0-9-]+=[^;]+)?$/;
   if (!mimeTypePattern.test(mediaType)) {
@@ -6664,7 +8576,7 @@ var ReferenceValidator = class {
       }
     }
     const parsedMimeTypes = ["application/xhtml+xml", "image/svg+xml"];
-    if (resource && parsedMimeTypes.includes(resource.mimeType) && !isRemoteURL(resourcePath)) {
+    if (resource && parsedMimeTypes.includes(resource.mimeType) && !isRemoteURL(resourcePath) && !fragment.includes("svgView(") && reference.type !== "svg-symbol" /* SVG_SYMBOL */) {
       if (!this.registry.hasID(resourcePath, fragment)) {
         pushMessage(context.messages, {
           id: MessageId.RSC_012,