@likecoin/epubcheck-ts 0.3.5 → 0.3.7

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",
@@ -870,7 +875,7 @@ var MessageDefs = {
   NAV_001: {
     id: "NAV-001",
     severity: "error",
-    description: "Nav file not supported for EPUB v2"
+    description: 'Navigation Document must have a nav element with epub:type="toc"'
   },
   NAV_002: { id: "NAV-002", severity: "suppressed", description: "Missing toc nav element" },
   NAV_003: {
@@ -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
@@ -1634,18 +1632,97 @@ var CSSValidator = class {
   }
 };
 
+// src/opf/types.ts
+var CORE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  // Image types
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp",
+  // Audio types
+  "audio/mpeg",
+  "audio/mp4",
+  "audio/ogg",
+  // CSS
+  "text/css",
+  // Fonts
+  "font/otf",
+  "font/ttf",
+  "font/woff",
+  "font/woff2",
+  "application/font-sfnt",
+  // deprecated alias for font/otf, font/ttf
+  "application/font-woff",
+  // deprecated alias for font/woff
+  "application/vnd.ms-opentype",
+  // deprecated alias
+  // Content documents
+  "application/xhtml+xml",
+  "application/x-dtbncx+xml",
+  // NCX
+  // JavaScript (EPUB 3)
+  "text/javascript",
+  "application/javascript",
+  // Media overlays
+  "application/smil+xml",
+  // PLS (Pronunciation Lexicon)
+  "application/pls+xml"
+]);
+function isCoreMediaType(mimeType) {
+  if (CORE_MEDIA_TYPES.has(mimeType)) return true;
+  if (mimeType.startsWith("video/")) return true;
+  if (/^audio\/ogg\s*;\s*codecs=opus$/i.test(mimeType)) return true;
+  const semicolonIndex = mimeType.indexOf(";");
+  if (semicolonIndex >= 0) {
+    const baseType = mimeType.substring(0, semicolonIndex).trim();
+    if (CORE_MEDIA_TYPES.has(baseType)) return true;
+    if (baseType.startsWith("video/")) return true;
+  }
+  return false;
+}
+var ITEM_PROPERTIES = /* @__PURE__ */ new Set([
+  "cover-image",
+  "mathml",
+  "nav",
+  "remote-resources",
+  "scripted",
+  "svg",
+  "switch"
+]);
+var LINK_PROPERTIES = /* @__PURE__ */ new Set(["onix", "marc21xml-record", "mods-record", "xmp-record"]);
+var SPINE_PROPERTIES = /* @__PURE__ */ new Set([
+  "page-spread-left",
+  "page-spread-right",
+  "rendition:spread-none",
+  "rendition:spread-landscape",
+  "rendition:spread-portrait",
+  "rendition:spread-both",
+  "rendition:spread-auto",
+  "rendition:page-spread-center",
+  "rendition:layout-reflowable",
+  "rendition:layout-pre-paginated",
+  "rendition:orientation-auto",
+  "rendition:orientation-landscape",
+  "rendition:orientation-portrait"
+]);
+
 // 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 */
-  ].includes(type);
+  return PUBLICATION_RESOURCE_TYPES.has(type);
 }
 
 // src/references/url.ts
@@ -1702,6 +1779,17 @@ function isHTTP(url) {
 function isRemoteURL(url) {
   return isHTTP(url) || isHTTPS(url);
 }
+function checkUrlLeaking(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 resolveManifestHref(opfDir, href) {
   if (isRemoteURL(href)) return href;
   try {
@@ -1715,7 +1803,184 @@ 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 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",
@@ -1815,6 +2080,7 @@ var HTML_ENTITIES = /* @__PURE__ */ new Set([
   "yuml"
 ]);
 var ContentValidator = class {
+  cssWithRemoteResources = /* @__PURE__ */ new Set();
   validate(context, registry, refValidator) {
     const packageDoc = context.packageDocument;
     if (!packageDoc) {
@@ -1822,13 +2088,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) {
@@ -1837,7 +2108,51 @@ var ContentValidator = class {
         if (context.version.startsWith("3")) {
           this.validateSVGDocument(context, fullPath, item);
         }
+        if (refValidator) {
+          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) {
@@ -1880,9 +2195,154 @@ 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);
+    } finally {
+      doc.dispose();
+    }
+  }
+  /**
+   * Extract references from SVG documents: font-face-uri, xml-stylesheet PI, @import in style
+   */
+  extractSVGReferences(context, path, opfDir, refValidator) {
+    const svgData = context.files.get(path);
+    if (!svgData) return;
+    const svgContent = new TextDecoder().decode(svgData);
+    let doc;
+    try {
+      doc = libxml2Wasm.XmlDocument.fromString(svgContent);
+    } catch {
+      return;
+    }
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    try {
+      const root = doc.root;
+      try {
+        const fontFaceUris = root.find(".//svg:font-face-uri", {
+          svg: "http://www.w3.org/2000/svg"
+        });
+        for (const uri of fontFaceUris) {
+          const href = this.getAttribute(uri, "xlink:href") ?? this.getAttribute(uri, "href");
+          if (!href) continue;
+          if (href.startsWith("http://") || href.startsWith("https://")) {
+            refValidator.addReference({
+              url: href,
+              targetResource: href,
+              type: "font" /* FONT */,
+              location: { path, line: uri.line }
+            });
+          } else {
+            const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+            refValidator.addReference({
+              url: href,
+              targetResource: resolvedPath,
+              type: "font" /* FONT */,
+              location: { path, line: uri.line }
+            });
+          }
+        }
+      } catch {
+      }
+      try {
+        const styles = root.find(".//svg:style", { svg: "http://www.w3.org/2000/svg" });
+        for (const style of styles) {
+          const cssContent = style.content;
+          if (cssContent) {
+            this.extractCSSImports(path, cssContent, opfDir, refValidator);
+          }
+        }
+      } catch {
+      }
+      this.extractSVGUseReferences(context, path, root, docDir, opfDir, refValidator);
     } finally {
       doc.dispose();
     }
+    this.extractXmlStylesheetPIs(svgContent, path, docDir, opfDir, refValidator);
+  }
+  /**
+   * Extract href from <?xml-stylesheet?> processing instructions
+   */
+  extractXmlStylesheetPIs(content, path, docDir, opfDir, refValidator) {
+    const piRegex = /<\?xml-stylesheet\s+([^?]*)\?>/g;
+    let match;
+    while ((match = piRegex.exec(content)) !== null) {
+      const attrs = match[1];
+      if (!attrs) continue;
+      const hrefMatch = /href\s*=\s*["']([^"']*)["']/.exec(attrs);
+      if (!hrefMatch?.[1]) continue;
+      const href = hrefMatch[1];
+      const beforeMatch = content.substring(0, match.index);
+      const line = beforeMatch.split("\n").length;
+      if (href.startsWith("http://") || href.startsWith("https://")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "stylesheet" /* STYLESHEET */,
+          location: { path, line }
+        });
+      } else {
+        const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+        refValidator.addReference({
+          url: href,
+          targetResource: resolvedPath,
+          type: "stylesheet" /* STYLESHEET */,
+          location: { path, line }
+        });
+      }
+    }
+  }
+  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 {
@@ -1931,6 +2391,7 @@ var ContentValidator = class {
       (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(
@@ -1949,9 +2410,11 @@ var ContentValidator = class {
     for (const ref of result.references) {
       if (ref.type === "font") {
         if (ref.url.startsWith("http://") || ref.url.startsWith("https://")) {
+          const hashIndex = ref.url.indexOf("#");
+          const targetResource = hashIndex >= 0 ? ref.url.slice(0, hashIndex) : ref.url;
           refValidator.addReference({
             url: ref.url,
-            targetResource: ref.url,
+            targetResource,
             type: "font" /* FONT */,
             location: { path }
           });
@@ -1968,9 +2431,11 @@ var ContentValidator = class {
         }
       } else if (ref.type === "image") {
         if (ref.url.startsWith("http://") || ref.url.startsWith("https://")) {
+          const hashIndex = ref.url.indexOf("#");
+          const targetResource = hashIndex >= 0 ? ref.url.slice(0, hashIndex) : ref.url;
           refValidator.addReference({
             url: ref.url,
-            targetResource: ref.url,
+            targetResource,
             type: "image" /* IMAGE */,
             location: { path }
           });
@@ -1985,9 +2450,27 @@ var ContentValidator = class {
             location: { path }
           });
         }
+      } else if (ref.type === "import") {
+        const location = { path };
+        if (ref.line !== void 0) location.line = ref.line;
+        if (ref.url.startsWith("http://") || ref.url.startsWith("https://")) {
+          refValidator.addReference({
+            url: ref.url,
+            targetResource: ref.url,
+            type: "stylesheet" /* STYLESHEET */,
+            location
+          });
+        } else {
+          const resolvedPath = this.resolveRelativePath(cssDir, ref.url, opfDir);
+          refValidator.addReference({
+            url: ref.url,
+            targetResource: resolvedPath,
+            type: "stylesheet" /* STYLESHEET */,
+            location
+          });
+        }
       }
     }
-    this.extractCSSImports(path, cssContent, opfDir, refValidator);
   }
   validateXHTMLDocument(context, path, itemId, opfDir, registry, refValidator) {
     const data = context.files.get(path);
@@ -2000,6 +2483,43 @@ var ContentValidator = class {
       return;
     }
     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);
@@ -2019,8 +2539,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
           });
@@ -2050,10 +2571,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) {
@@ -2094,6 +2624,13 @@ var ContentValidator = class {
             location: { path }
           });
         }
+        if (!hasMathML && manifestItem?.properties?.includes("mathml")) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_015,
+            message: 'The property "mathml" should not be declared in the OPF file',
+            location: { path }
+          });
+        }
         const hasSVG = this.detectSVG(context, path, root);
         if (hasSVG && !manifestItem?.properties?.includes("svg")) {
           pushMessage(context.messages, {
@@ -2117,7 +2654,14 @@ var ContentValidator = class {
             location: { path }
           });
         }
-        const hasRemoteResources = this.detectRemoteResources(context, path, root);
+        if (!hasSwitch && manifestItem?.properties?.includes("switch")) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_015,
+            message: 'The property "switch" should not be declared in the OPF file',
+            location: { path }
+          });
+        }
+        const hasRemoteResources = this.detectRemoteResources(context, path, root, opfDir);
         if (hasRemoteResources && !manifestItem?.properties?.includes("remote-resources")) {
           pushMessage(context.messages, {
             id: MessageId.OPF_014,
@@ -2134,24 +2678,49 @@ 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) {
         this.extractAndRegisterIDs(path, root, registry);
       }
       if (refValidator && opfDir !== void 0) {
-        this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator);
+        this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, !!isNavItem);
         this.extractAndRegisterStylesheets(path, root, opfDir, refValidator);
-        this.extractAndRegisterImages(path, root, opfDir, refValidator);
+        this.extractAndRegisterImages(context, path, root, opfDir, refValidator, registry);
         this.extractAndRegisterMathMLAltimg(path, root, opfDir, refValidator);
         this.extractAndRegisterScripts(path, root, opfDir, refValidator);
         this.extractAndRegisterCiteAttributes(path, root, opfDir, refValidator);
-        this.extractAndRegisterMediaElements(path, root, opfDir, refValidator);
+        this.extractAndRegisterMediaElements(context, path, root, opfDir, refValidator, registry);
+        this.extractAndRegisterEmbeddedElements(
+          context,
+          path,
+          root,
+          opfDir,
+          refValidator,
+          registry
+        );
       }
     } finally {
       doc.dispose();
@@ -2207,14 +2776,12 @@ var ContentValidator = class {
       return epubTypeAttr ? epubTypeAttr.value.trim().split(/\s+/) : [];
     };
     let tocNav;
-    let tocEpubTypeValue = "";
     let pageListCount = 0;
     let landmarksCount = 0;
     for (const nav of navElements) {
       const types = getNavTypes(nav);
       if (types.includes("toc") && !tocNav) {
         tocNav = nav;
-        tocEpubTypeValue = types.join(" ");
       }
       if (types.includes("page-list")) pageListCount++;
       if (types.includes("landmarks")) landmarksCount++;
@@ -2265,7 +2832,7 @@ var ContentValidator = class {
     }
     this.checkNavHeadingContent(context, path, root);
     this.checkNavHiddenAttribute(context, path, root);
-    this.checkNavRemoteLinks(context, path, root, tocEpubTypeValue);
+    this.checkNavRemoteLinks(context, path, root);
     this.collectTocLinks(context, path, tocNav);
   }
   checkNavFirstChildHeading(context, path, navElem) {
@@ -2448,27 +3015,33 @@ var ContentValidator = class {
       }
     }
   }
-  checkNavRemoteLinks(context, path, root, epubTypeValue) {
-    const navTypes = epubTypeValue.split(/\s+/);
-    const isToc = navTypes.includes("toc");
-    const isLandmarks = navTypes.includes("landmarks");
-    const isPageList = navTypes.includes("page-list");
-    if (!isToc && !isLandmarks && !isPageList) {
-      return;
-    }
-    const links = root.find(".//html:a[@href]", { html: "http://www.w3.org/1999/xhtml" });
-    for (const link of links) {
-      const href = this.getAttribute(link, "href");
-      if (href && (href.startsWith("http://") || href.startsWith("https://"))) {
-        const navType = isToc ? "toc" : isLandmarks ? "landmarks" : "page-list";
-        pushMessage(context.messages, {
-          id: MessageId.NAV_010,
-          message: `"${navType}" nav must not link to remote resources; found link to "${href}"`,
-          location: { path }
-        });
-      }
-    }
-  }
+  checkNavRemoteLinks(context, path, root) {
+    const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+    const navElements = root.find(".//html:nav", HTML_NS);
+    for (const nav of navElements) {
+      const navElem = nav;
+      const epubTypeAttr = "attrs" in navElem ? navElem.attrs.find(
+        (attr) => attr.name === "type" && attr.prefix === "epub" && attr.namespaceUri === "http://www.idpf.org/2007/ops"
+      ) : void 0;
+      const types = epubTypeAttr ? epubTypeAttr.value.trim().split(/\s+/) : [];
+      const isToc = types.includes("toc");
+      const isLandmarks = types.includes("landmarks");
+      const isPageList = types.includes("page-list");
+      if (!isToc && !isLandmarks && !isPageList) continue;
+      const navType = isToc ? "toc" : isLandmarks ? "landmarks" : "page-list";
+      const links = navElem.find(".//html:a[@href]", HTML_NS);
+      for (const link of links) {
+        const href = this.getAttribute(link, "href");
+        if (href && (href.startsWith("http://") || href.startsWith("https://"))) {
+          pushMessage(context.messages, {
+            id: MessageId.NAV_010,
+            message: `"${navType}" nav must not link to remote resources; found link to "${href}"`,
+            location: { path }
+          });
+        }
+      }
+    }
+  }
   collectTocLinks(context, path, tocNav) {
     const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
@@ -2574,7 +3147,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");
@@ -2603,9 +3176,24 @@ var ContentValidator = class {
         return true;
       }
     }
+    const objects = root.find(".//html:object[@data]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const obj of objects) {
+      const data = this.getAttribute(obj, "data");
+      if (data && (data.startsWith("http://") || data.startsWith("https://"))) {
+        return true;
+      }
+    }
+    const embeds = root.find(".//html:embed[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const embed of embeds) {
+      const src = this.getAttribute(embed, "src");
+      if (src && (src.startsWith("http://") || src.startsWith("https://"))) {
+        return true;
+      }
+    }
     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");
@@ -2613,6 +3201,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" });
@@ -2640,6 +3232,654 @@ var ContentValidator = class {
       }
     }
   }
+  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.HTM_007,
+          message: "The ssml:ph attribute value should not be empty",
+          location: { path, line }
+        });
+      }
+    }
+  }
+  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.RSC_005,
+          message: 'The "keygen" element is obsolete',
+          location: { path, line: keygen.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const menuTypes = root.find(".//html:menu[@type]", HTML_NS);
+      for (const menuType of menuTypes) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The "type" attribute on the "menu" element is obsolete',
+          location: { path, line: menuType.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const commands = root.find(".//html:command", HTML_NS);
+      for (const command of commands) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The "command" element is obsolete',
+          location: { path, line: command.line }
+        });
+      }
+    } catch {
+    }
+  }
+  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 {
+          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) {
@@ -2752,24 +3992,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 }
           });
         }
       }
@@ -2881,14 +4129,39 @@ var ContentValidator = class {
   extractAndRegisterIDs(path, root, registry) {
     const elementsWithId = root.find(".//*[@id]");
     for (const elem of elementsWithId) {
-      const id = this.getAttribute(elem, "id");
+      const xmlElem = elem;
+      const id = this.getAttribute(xmlElem, "id");
       if (id) {
         registry.registerID(path, id);
+        const localName = xmlElem.name.includes(":") ? xmlElem.name.split(":").pop() : xmlElem.name;
+        if (localName === "symbol") {
+          registry.registerSVGSymbolID(path, id);
+        }
       }
     }
   }
-  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator) {
+  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, isNavDocument = false) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const navAnchorTypes = /* @__PURE__ */ new Map();
+    if (isNavDocument) {
+      const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+      const navElements = root.find(".//html:nav", HTML_NS);
+      for (const nav of navElements) {
+        const navElem = nav;
+        const epubTypeAttr = "attrs" in navElem ? navElem.attrs.find(
+          (attr) => attr.name === "type" && attr.prefix === "epub" && attr.namespaceUri === "http://www.idpf.org/2007/ops"
+        ) : void 0;
+        const types = epubTypeAttr ? epubTypeAttr.value.trim().split(/\s+/) : [];
+        let refType = "hyperlink" /* HYPERLINK */;
+        if (types.includes("toc")) refType = "nav-toc-link" /* NAV_TOC_LINK */;
+        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) {
+          const anchorHref = this.getAttribute(a, "href") ?? "";
+          navAnchorTypes.set(`${String(a.line)}:${anchorHref}`, refType);
+        }
+      }
+    }
     const links = root.find(".//html:a[@href]", { html: "http://www.w3.org/1999/xhtml" });
     for (const link of links) {
       const href = this.getAttribute(link, "href")?.trim() ?? null;
@@ -2902,10 +4175,8 @@ var ContentValidator = class {
         continue;
       }
       const line = link.line;
-      if (href.startsWith("http://") || href.startsWith("https://")) {
-        continue;
-      }
-      if (href.startsWith("mailto:") || href.startsWith("tel:")) {
+      const refType = isNavDocument ? navAnchorTypes.get(`${String(line)}:${href}`) ?? "hyperlink" /* HYPERLINK */ : "hyperlink" /* HYPERLINK */;
+      if (ABSOLUTE_URI_RE.test(href)) {
         continue;
       }
       if (href.includes("#epubcfi(")) {
@@ -2918,7 +4189,7 @@ var ContentValidator = class {
           url: href,
           targetResource: targetResource2,
           fragment,
-          type: "hyperlink" /* HYPERLINK */,
+          type: refType,
           location: { path, line }
         });
         continue;
@@ -2930,7 +4201,7 @@ var ContentValidator = class {
       const ref = {
         url: href,
         targetResource,
-        type: "hyperlink" /* HYPERLINK */,
+        type: refType,
         location: { path, line }
       };
       if (fragmentPart) {
@@ -2938,6 +4209,38 @@ var ContentValidator = class {
       }
       refValidator.addReference(ref);
     }
+    const areaLinks = root.find(".//html:area[@href]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const area of areaLinks) {
+      const href = this.getAttribute(area, "href")?.trim();
+      if (!href) continue;
+      const line = area.line;
+      if (ABSOLUTE_URI_RE.test(href)) continue;
+      if (href.includes("#epubcfi(")) continue;
+      if (href.startsWith("#")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: path,
+          fragment: href.slice(1),
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path, line }
+        });
+        continue;
+      }
+      const resolvedAreaPath = this.resolveRelativePath(docDir, href, opfDir);
+      const areaHashIndex = resolvedAreaPath.indexOf("#");
+      const areaTarget = areaHashIndex >= 0 ? resolvedAreaPath.slice(0, areaHashIndex) : resolvedAreaPath;
+      const areaFragment = areaHashIndex >= 0 ? resolvedAreaPath.slice(areaHashIndex + 1) : void 0;
+      const areaRef = {
+        url: href,
+        targetResource: areaTarget,
+        type: "hyperlink" /* HYPERLINK */,
+        location: { path, line }
+      };
+      if (areaFragment) {
+        areaRef.fragment = areaFragment;
+      }
+      refValidator.addReference(areaRef);
+    }
     const svgLinks = root.find(".//svg:a", {
       svg: "http://www.w3.org/2000/svg",
       xlink: "http://www.w3.org/1999/xlink"
@@ -2985,9 +4288,9 @@ var ContentValidator = class {
       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,
@@ -3014,10 +4317,10 @@ var ContentValidator = class {
   extractCSSImports(cssPath, cssContent, opfDir, refValidator) {
     const cssDir = cssPath.includes("/") ? cssPath.substring(0, cssPath.lastIndexOf("/")) : "";
     const cleanedCSS = cssContent.replace(/\/\*[\s\S]*?\*\//g, "");
-    const importRegex = /@import\s+(?:url\s*\(\s*)?["']([^"']+)["']\s*\)?[^;]*;/gi;
+    const importRegex = /@import\s+(?:url\s*\(\s*["']?([^"')]+?)["']?\s*\)|["']([^"']+)["'])[^;]*;/gi;
     let match;
     while ((match = importRegex.exec(cleanedCSS)) !== null) {
-      const importUrl = match[1];
+      const importUrl = match[1] ?? match[2];
       if (!importUrl) continue;
       const beforeMatch = cleanedCSS.substring(0, match.index);
       const line = beforeMatch.split("\n").length;
@@ -3039,21 +4342,56 @@ var ContentValidator = class {
       });
     }
   }
-  extractAndRegisterImages(path, root, opfDir, refValidator) {
+  extractAndRegisterImages(context, path, root, opfDir, refValidator, registry) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
-    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    const ns = { html: "http://www.w3.org/1999/xhtml" };
+    const pictureHasCMTSource = /* @__PURE__ */ new Set();
+    if (registry) {
+      const pictures = root.find(".//html:picture", ns);
+      for (const pic of pictures) {
+        const picElem = pic;
+        const sources = picElem.find("html:source[@src]", ns);
+        const sourcesWithSrcset = picElem.find("html:source[@srcset]", ns);
+        for (const source of [...sources, ...sourcesWithSrcset]) {
+          const srcAttr = this.getAttribute(source, "src");
+          const srcsetAttr = this.getAttribute(source, "srcset");
+          const sourceUrl = srcAttr ?? srcsetAttr?.split(",")[0]?.trim().split(/\s+/)[0];
+          if (!sourceUrl || sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://"))
+            continue;
+          const resolvedSource = this.resolveRelativePath(docDir, sourceUrl, opfDir);
+          const resource = registry.getResource(resolvedSource);
+          if (resource && isCoreMediaType(resource.mimeType)) {
+            pictureHasCMTSource.add(pic.line);
+            break;
+          }
+        }
+      }
+    }
+    const images = root.find(".//html:img[@src]", ns);
     for (const img of images) {
       const imgElem = img;
       const src = this.getAttribute(imgElem, "src");
       if (!src) continue;
       const line = img.line;
+      let hasIntrinsicFallback;
+      if (pictureHasCMTSource.size > 0) {
+        try {
+          const pictureParent = imgElem.get("ancestor::html:picture", ns);
+          if (pictureParent && pictureHasCMTSource.has(pictureParent.line)) {
+            hasIntrinsicFallback = true;
+          }
+        } catch {
+        }
+      }
       if (src.startsWith("http://") || src.startsWith("https://")) {
-        refValidator.addReference({
+        const ref = {
           url: src,
           targetResource: src,
           type: "image" /* IMAGE */,
           location: { path, line }
-        });
+        };
+        if (hasIntrinsicFallback) ref.hasIntrinsicFallback = true;
+        refValidator.addReference(ref);
       } else {
         const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
         const hashIndex = resolvedPath.indexOf("#");
@@ -3065,6 +4403,7 @@ var ContentValidator = class {
           type: "image" /* IMAGE */,
           location: { path, line }
         };
+        if (hasIntrinsicFallback) ref.hasIntrinsicFallback = true;
         if (fragment) {
           ref.fragment = fragment;
         }
@@ -3117,6 +4456,7 @@ var ContentValidator = class {
       }
       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");
@@ -3213,110 +4553,88 @@ var ContentValidator = class {
       }
       if (cite.startsWith("#")) {
         const targetResource2 = path;
-        const fragment2 = cite.slice(1);
-        refValidator.addReference({
-          url: cite,
-          targetResource: targetResource2,
-          fragment: fragment2,
-          type: "hyperlink" /* HYPERLINK */,
-          location: { path, line }
-        });
-        continue;
-      }
-      const resolvedPath = this.resolveRelativePath(docDir, cite, opfDir);
-      const hashIndex = resolvedPath.indexOf("#");
-      const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
-      const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
-      const ref = {
-        url: cite,
-        targetResource,
-        type: "hyperlink" /* HYPERLINK */,
-        location: { path, line }
-      };
-      if (fragment) {
-        ref.fragment = fragment;
-      }
-      refValidator.addReference(ref);
-    }
-  }
-  extractAndRegisterMediaElements(path, root, opfDir, refValidator) {
-    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
-    const audioElements = root.find(".//html:audio[@src]", {
-      html: "http://www.w3.org/1999/xhtml"
-    });
-    for (const audio of audioElements) {
-      const src = this.getAttribute(audio, "src");
-      if (!src) continue;
-      const line = audio.line;
-      if (src.startsWith("http://") || src.startsWith("https://")) {
-        refValidator.addReference({
-          url: src,
-          targetResource: src,
-          type: "audio" /* AUDIO */,
-          location: line !== void 0 ? { path, line } : { path }
-        });
-      } else {
-        const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
-        refValidator.addReference({
-          url: src,
-          targetResource: resolvedPath,
-          type: "audio" /* AUDIO */,
-          location: line !== void 0 ? { path, line } : { path }
-        });
-      }
-    }
-    const videoElements = root.find(".//html:video[@src]", {
-      html: "http://www.w3.org/1999/xhtml"
-    });
-    for (const video of videoElements) {
-      const src = this.getAttribute(video, "src");
-      if (!src) continue;
-      const line = video.line;
-      if (src.startsWith("http://") || src.startsWith("https://")) {
-        refValidator.addReference({
-          url: src,
-          targetResource: src,
-          type: "video" /* VIDEO */,
-          location: line !== void 0 ? { path, line } : { path }
-        });
-      } else {
-        const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+        const fragment2 = cite.slice(1);
         refValidator.addReference({
-          url: src,
-          targetResource: resolvedPath,
-          type: "video" /* VIDEO */,
-          location: line !== void 0 ? { path, line } : { path }
+          url: cite,
+          targetResource: targetResource2,
+          fragment: fragment2,
+          type: "cite" /* CITE */,
+          location: { path, line }
         });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, cite, opfDir);
+      const hashIndex = resolvedPath.indexOf("#");
+      const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+      const fragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
+      const ref = {
+        url: cite,
+        targetResource,
+        type: "cite" /* CITE */,
+        location: { path, line }
+      };
+      if (fragment) {
+        ref.fragment = fragment;
       }
+      refValidator.addReference(ref);
     }
-    const sourceElements = root.find(".//html:source[@src]", {
-      html: "http://www.w3.org/1999/xhtml"
-    });
-    for (const source of sourceElements) {
-      const src = this.getAttribute(source, "src");
-      if (!src) continue;
-      const parent = source.parent;
-      const parentName = parent?.name ?? "";
-      const isAudioChild = parentName === "audio";
-      const type = isAudioChild ? "audio" /* AUDIO */ : "video" /* VIDEO */;
-      const line = source.line;
-      if (src.startsWith("http://") || src.startsWith("https://")) {
-        refValidator.addReference({
-          url: src,
-          targetResource: src,
-          type,
-          location: line !== void 0 ? { path, line } : { path }
-        });
-      } else {
-        const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
-        refValidator.addReference({
-          url: src,
-          targetResource: resolvedPath,
-          type,
-          location: line !== void 0 ? { path, line } : { path }
-        });
+  }
+  extractAndRegisterMediaElements(context, path, root, opfDir, refValidator, registry) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const ns = { html: "http://www.w3.org/1999/xhtml" };
+    for (const tagName of ["audio", "video"]) {
+      const isAudio = tagName === "audio";
+      const refType = isAudio ? "audio" /* AUDIO */ : "video" /* VIDEO */;
+      const elements = root.find(`.//html:${tagName}`, ns);
+      for (const elem of elements) {
+        const mediaElem = elem;
+        const pendingRefs = [];
+        const src = this.getAttribute(mediaElem, "src");
+        if (src) {
+          const line = elem.line;
+          if (src.startsWith("http://") || src.startsWith("https://")) {
+            pendingRefs.push({ url: src, targetResource: src, type: refType, line });
+          } else {
+            const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+            pendingRefs.push({ url: src, targetResource: resolvedPath, type: refType, line });
+          }
+        }
+        const sources = mediaElem.find("html:source[@src]", ns);
+        for (const source of sources) {
+          const sourceElem = source;
+          const sourceSrc = this.getAttribute(sourceElem, "src");
+          if (!sourceSrc) continue;
+          const line = source.line;
+          if (sourceSrc.startsWith("http://") || sourceSrc.startsWith("https://")) {
+            pendingRefs.push({ url: sourceSrc, targetResource: sourceSrc, type: refType, line });
+          } else {
+            const resolvedPath = this.resolveRelativePath(docDir, sourceSrc, opfDir);
+            pendingRefs.push({ url: sourceSrc, targetResource: resolvedPath, type: refType, line });
+          }
+          if (registry) {
+            this.checkMimeTypeMatch(context, path, docDir, opfDir, sourceElem, "src", registry);
+          }
+        }
+        let hasIntrinsicFallback = false;
+        if (registry && pendingRefs.length > 1) {
+          hasIntrinsicFallback = pendingRefs.some((ref) => {
+            const resource = registry.getResource(ref.targetResource);
+            return resource && isCoreMediaType(resource.mimeType);
+          });
+        }
+        for (const ref of pendingRefs) {
+          const reference = {
+            url: ref.url,
+            targetResource: ref.targetResource,
+            type: ref.type,
+            location: ref.line !== void 0 ? { path, line: ref.line } : { path }
+          };
+          if (hasIntrinsicFallback) reference.hasIntrinsicFallback = true;
+          refValidator.addReference(reference);
+        }
       }
     }
+    this.extractAndRegisterPictureElements(context, path, root, opfDir, refValidator, registry);
     const iframeElements = root.find(".//html:iframe[@src]", {
       html: "http://www.w3.org/1999/xhtml"
     });
@@ -3366,6 +4684,180 @@ var ContentValidator = class {
       }
     }
   }
+  extractAndRegisterEmbeddedElements(context, path, root, opfDir, refValidator, registry) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const ns = { html: "http://www.w3.org/1999/xhtml" };
+    const addRef = (src, type, line, hasIntrinsicFallback) => {
+      const location = line !== void 0 ? { path, line } : { path };
+      if (src.startsWith("http://") || src.startsWith("https://")) {
+        const ref = {
+          url: src,
+          targetResource: src,
+          type,
+          location
+        };
+        if (hasIntrinsicFallback) ref.hasIntrinsicFallback = true;
+        refValidator.addReference(ref);
+      } else {
+        const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+        const hashIndex = resolvedPath.indexOf("#");
+        const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+        const ref = {
+          url: src,
+          targetResource,
+          type,
+          location
+        };
+        if (hashIndex >= 0) ref.fragment = resolvedPath.slice(hashIndex + 1);
+        if (hasIntrinsicFallback) ref.hasIntrinsicFallback = true;
+        refValidator.addReference(ref);
+      }
+    };
+    for (const elem of root.find(".//html:embed[@src]", ns)) {
+      const embedElem = elem;
+      const src = this.getAttribute(embedElem, "src");
+      if (src) addRef(src, "generic" /* GENERIC */, elem.line);
+      if (registry) {
+        this.checkMimeTypeMatch(context, path, docDir, opfDir, embedElem, "src", registry);
+      }
+    }
+    for (const elem of root.find(".//html:input[@src]", ns)) {
+      const type = this.getAttribute(elem, "type");
+      if (type?.toLowerCase() === "image") {
+        const src = this.getAttribute(elem, "src");
+        if (src) addRef(src, "image" /* IMAGE */, elem.line);
+      }
+    }
+    for (const elem of root.find(".//html:object[@data]", ns)) {
+      const objElem = elem;
+      const data = this.getAttribute(objElem, "data");
+      if (!data) continue;
+      const allChildren = objElem.find("html:*", ns);
+      const hasFallbackContent = allChildren.some((child) => {
+        const c = child;
+        return c.name !== "param" && this.getAttribute(c, "hidden") === null;
+      });
+      addRef(data, "generic" /* GENERIC */, elem.line, hasFallbackContent || void 0);
+      if (registry) {
+        this.checkMimeTypeMatch(context, path, docDir, opfDir, objElem, "data", registry);
+      }
+    }
+  }
+  /**
+   * Check if an element's type attribute matches the manifest MIME type (OPF-013)
+   */
+  checkMimeTypeMatch(context, path, docDir, opfDir, element, srcAttr, registry) {
+    const typeAttr = this.getAttribute(element, "type");
+    if (!typeAttr) return;
+    const src = this.getAttribute(element, srcAttr);
+    if (!src || src.startsWith("http://") || src.startsWith("https://")) return;
+    const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+    const hashIndex = resolvedPath.indexOf("#");
+    const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+    const resource = registry.getResource(targetResource);
+    if (!resource) return;
+    const declaredType = stripMimeParams(typeAttr);
+    const manifestType = stripMimeParams(resource.mimeType);
+    if (declaredType && declaredType !== manifestType) {
+      pushMessage(context.messages, {
+        id: MessageId.OPF_013,
+        message: `Resource "${targetResource}" is declared with MIME type "${declaredType}" in content, but has MIME type "${manifestType}" in the package document`,
+        location: { path, line: element.line }
+      });
+    }
+  }
+  /**
+   * Extract and validate picture elements (MED-003, MED-007, OPF-013)
+   */
+  extractAndRegisterPictureElements(context, path, root, opfDir, refValidator, registry) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const ns = { html: "http://www.w3.org/1999/xhtml" };
+    const BLESSED_IMAGE_TYPES = /* @__PURE__ */ new Set([
+      "image/gif",
+      "image/jpeg",
+      "image/png",
+      "image/svg+xml",
+      "image/webp"
+    ]);
+    const pictures = root.find(".//html:picture", ns);
+    for (const pic of pictures) {
+      const picElem = pic;
+      const imgs = picElem.find("html:img[@src]", ns);
+      for (const img of imgs) {
+        const imgElem = img;
+        const src = this.getAttribute(imgElem, "src");
+        if (!src || src.startsWith("http://") || src.startsWith("https://")) continue;
+        if (registry) {
+          const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+          const resource = registry.getResource(resolvedPath);
+          if (resource && !BLESSED_IMAGE_TYPES.has(resource.mimeType)) {
+            pushMessage(context.messages, {
+              id: MessageId.MED_003,
+              message: `Image in "picture" element must be a core image type, but found "${resource.mimeType}"`,
+              location: { path, line: img.line }
+            });
+          }
+        }
+        const srcset = this.getAttribute(imgElem, "srcset");
+        if (srcset && registry) {
+          const entries = srcset.split(",");
+          for (const entry of entries) {
+            const url = entry.trim().split(/\s+/)[0];
+            if (!url || url.startsWith("http://") || url.startsWith("https://")) continue;
+            const resolvedPath = this.resolveRelativePath(docDir, url, opfDir);
+            const resource = registry.getResource(resolvedPath);
+            if (resource && !BLESSED_IMAGE_TYPES.has(resource.mimeType)) {
+              pushMessage(context.messages, {
+                id: MessageId.MED_003,
+                message: `Image in "picture" element must be a core image type, but found "${resource.mimeType}"`,
+                location: { path, line: img.line }
+              });
+            }
+          }
+        }
+      }
+      const sourcesWithSrc = picElem.find("html:source[@src]", ns);
+      const sourcesWithSrcset = picElem.find("html:source[@srcset]", ns);
+      const allSources = /* @__PURE__ */ new Set([...sourcesWithSrc, ...sourcesWithSrcset]);
+      for (const source of allSources) {
+        const sourceElem = source;
+        const typeAttr = this.getAttribute(sourceElem, "type");
+        const src = this.getAttribute(sourceElem, "src");
+        const srcset = this.getAttribute(sourceElem, "srcset");
+        const sourceUrl = src ?? srcset?.split(",")[0]?.trim().split(/\s+/)[0];
+        if (!sourceUrl || sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://"))
+          continue;
+        if (registry) {
+          if (src) {
+            this.checkMimeTypeMatch(context, path, docDir, opfDir, sourceElem, "src", registry);
+          } else if (srcset && typeAttr) {
+            const resolvedPath2 = this.resolveRelativePath(docDir, sourceUrl, opfDir);
+            const resource2 = registry.getResource(resolvedPath2);
+            if (resource2) {
+              const declaredType = stripMimeParams(typeAttr);
+              const manifestType = stripMimeParams(resource2.mimeType);
+              if (declaredType && declaredType !== manifestType) {
+                pushMessage(context.messages, {
+                  id: MessageId.OPF_013,
+                  message: `Resource "${resolvedPath2}" is declared with MIME type "${declaredType}" in content, but has MIME type "${manifestType}" in the package document`,
+                  location: { path, line: source.line }
+                });
+              }
+            }
+          }
+          const resolvedPath = this.resolveRelativePath(docDir, sourceUrl, opfDir);
+          const resource = registry.getResource(resolvedPath);
+          if (resource && !BLESSED_IMAGE_TYPES.has(resource.mimeType) && !typeAttr) {
+            pushMessage(context.messages, {
+              id: MessageId.MED_007,
+              message: `Source element in "picture" with foreign resource type "${resource.mimeType}" must declare a "type" attribute`,
+              location: { path, line: source.line }
+            });
+          }
+        }
+      }
+    }
+  }
   parseSrcset(srcset, docDir, opfDir, path, line, refValidator) {
     const entries = srcset.split(",");
     for (const entry of entries) {
@@ -4489,6 +5981,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+/);
       }
@@ -4527,9 +6022,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;
@@ -4574,70 +6074,324 @@ function parseCollections(xml) {
   return collections;
 }
 
-// src/opf/types.ts
-var CORE_MEDIA_TYPES = /* @__PURE__ */ new Set([
-  // Image types
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/svg+xml",
-  "image/webp",
-  // Audio types
-  "audio/mpeg",
-  "audio/mp4",
-  "audio/ogg",
-  // CSS
-  "text/css",
-  // Fonts
-  "font/otf",
-  "font/ttf",
-  "font/woff",
-  "font/woff2",
-  "application/font-sfnt",
-  // deprecated alias for font/otf, font/ttf
-  "application/font-woff",
-  // deprecated alias for font/woff
-  "application/vnd.ms-opentype",
-  // deprecated alias
-  // Content documents
-  "application/xhtml+xml",
-  "application/x-dtbncx+xml",
-  // NCX
-  // JavaScript (EPUB 3)
-  "text/javascript",
-  "application/javascript",
-  // Media overlays
-  "application/smil+xml",
-  // PLS (Pronunciation Lexicon)
-  "application/pls+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 ITEM_PROPERTIES = /* @__PURE__ */ new Set([
-  "cover-image",
-  "mathml",
-  "nav",
-  "remote-resources",
-  "scripted",
-  "svg",
-  "switch"
+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 LINK_PROPERTIES = /* @__PURE__ */ new Set(["onix", "marc21xml-record", "mods-record", "xmp-record"]);
-var SPINE_PROPERTIES = /* @__PURE__ */ new Set([
-  "page-spread-left",
-  "page-spread-right",
-  "rendition:spread-none",
-  "rendition:spread-landscape",
-  "rendition:spread-portrait",
-  "rendition:spread-both",
-  "rendition:spread-auto",
-  "rendition:page-spread-center",
-  "rendition:layout-reflowable",
-  "rendition:layout-pre-paginated",
-  "rendition:orientation-auto",
-  "rendition:orientation-landscape",
-  "rendition:orientation-portrait"
+var DEPRECATED_LINK_REL = /* @__PURE__ */ new Set([
+  "marc21xml-record",
+  "mods-record",
+  "onix-record",
+  "xmp-record",
+  "xml-signature"
+]);
+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"
 ]);
-
-// src/opf/validator.ts
 var OPFValidator = class {
   packageDoc = null;
   manifestById = /* @__PURE__ */ new Map();
@@ -4699,13 +6453,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`,
@@ -4731,11 +6479,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 }
       });
     }
@@ -4835,111 +6582,13 @@ var OPFValidator = class {
         }
       }
       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)) {
-            pushMessage(context.messages, {
-              id: MessageId.OPF_052,
-              message: `Unknown MARC relator code "${relatorCode}" in dc:creator`,
-              location: { path: opfPath }
-            });
-          }
+        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 }
+          });
         }
       }
     }
@@ -5009,6 +6658,9 @@ var OPFValidator = class {
       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, {
@@ -5031,11 +6683,14 @@ var OPFValidator = class {
           continue;
         }
         if (!refines.startsWith("#")) {
-          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 }
-          });
+          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);
@@ -5050,35 +6705,293 @@ var OPFValidator = class {
       this.detectRefinesCycles(context, opfPath);
     }
     if (this.packageDoc.version !== "2.0") {
-      const modifiedMeta = this.packageDoc.metaElements.find(
+      this.validateMetaPropertiesVocab(context, opfPath, dcElements);
+    }
+    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",
+          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.OPF_054,
-          message: "EPUB 3 metadata must include a dcterms:modified meta element",
+          id: MessageId.RSC_005,
+          message: "An authority property must be associated with a dc:subject when a term is specified",
           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 }
-          });
+      }
+    }
+    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;
         }
-        if (!isValidW3CDateFormat(modifiedMeta.value)) {
+        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;
+        }
+        case "file-as": {
+          const key = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(key)) {
+            pushMessage(context.messages, {
+              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;
+        }
+        case "group-position": {
+          const key = `${prop}:${refines ?? ""}`;
+          if (seenPropertyRefines.has(key)) {
+            pushMessage(context.messages, {
+              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;
+        }
+        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;
+        }
+        case "meta-auth": {
           pushMessage(context.messages, {
-            id: MessageId.OPF_054,
-            message: `Invalid dcterms:modified date format "${modifiedMeta.value}"; must be W3C date format (ISO 8601)`,
+            id: MessageId.RSC_017,
+            message: "Use of the meta-auth property is deprecated",
             location: { path: opfPath }
           });
+          break;
+        }
+        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.RSC_005,
+              message: 'Property "role" must refine a "creator", "contributor", or "publisher" property.',
+              location: { path: opfPath }
+            });
+          }
+          break;
+        }
+        case "source-of": {
+          if (meta.value.trim() !== "pagination") {
+            pushMessage(context.messages, {
+              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;
         }
       }
     }
@@ -5088,7 +7001,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;
@@ -5117,6 +7029,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;
@@ -5130,6 +7076,20 @@ var OPFValidator = class {
         continue;
       }
       const isRemote = /^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(href);
+      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;
       }
@@ -5140,8 +7100,8 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
-      const resolvedPath = resolvePath(opfDir, basePath);
-      const resolvedPathDecoded = basePathDecoded !== basePath ? resolvePath(opfDir, basePathDecoded) : resolvedPath;
+      const resolvedPath = resolvePath(opfPath, basePath);
+      const resolvedPathDecoded = basePathDecoded !== basePath ? resolvePath(opfPath, basePathDecoded) : resolvedPath;
       const fileExists = context.files.has(resolvedPath) || context.files.has(resolvedPathDecoded);
       const inManifest = this.manifestByHref.has(basePath) || this.manifestByHref.has(basePathDecoded);
       if (!fileExists && !inManifest) {
@@ -5218,13 +7178,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}"`,
@@ -5280,20 +7234,23 @@ var OPFValidator = class {
         });
       }
       if (this.packageDoc.version !== "2.0" && (item.href.startsWith("http://") || item.href.startsWith("https://"))) {
-        if (!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") {
-          pushMessage(context.messages, {
-            id: MessageId.RSC_006,
-            message: `Remote resource reference is not allowed in this context; resource "${item.href}" must be located in the EPUB container`,
-            location: { path: opfPath }
-          });
-        }
+        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 && !item.properties?.includes("remote-resources")) {
-          pushMessage(context.messages, {
-            id: MessageId.RSC_006,
-            message: `Manifest item "${item.id}" references remote resource but is missing "remote-resources" property`,
-            location: { path: opfPath }
-          });
+        if (inSpine) {
+          if (!isAllowedRemoteType) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_006,
+              message: `Remote resource reference is not allowed in this context; resource "${item.href}" must be located in the EPUB container`,
+              location: { path: opfPath }
+            });
+          }
+          if (!item.properties?.includes("remote-resources")) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_006,
+              message: `Manifest item "${item.id}" references remote resource but is missing "remote-resources" property`,
+              location: { path: opfPath }
+            });
+          }
         }
       }
     }
@@ -5398,12 +7355,20 @@ var OPFValidator = class {
         });
       }
       seenIdrefs.add(itemref.idref);
-      if (!isSpineMediaType(item.mediaType) && !item.fallback) {
-        pushMessage(context.messages, {
-          id: MessageId.OPF_043,
-          message: `Spine item "${item.id}" has non-standard media type "${item.mediaType}" without fallback`,
-          location: { path: opfPath }
-        });
+      if (!isSpineMediaType(item.mediaType)) {
+        if (!item.fallback) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_043,
+            message: `Spine item "${item.id}" has non-standard media type "${item.mediaType}" without fallback`,
+            location: { path: opfPath }
+          });
+        } else if (!this.fallbackChainResolvesToContentDocument(item.id)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_044,
+            message: `Spine item "${item.id}" has non-standard media type "${item.mediaType}" and its fallback chain does not resolve to a content document`,
+            location: { path: opfPath }
+          });
+        }
       }
       if (this.packageDoc.version !== "2.0" && itemref.properties) {
         for (const prop of itemref.properties) {
@@ -5601,14 +7566,29 @@ var OPFValidator = class {
       }
     }
   }
+  fallbackChainResolvesToContentDocument(itemId) {
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = itemId;
+    while (currentId) {
+      if (visited.has(currentId)) return false;
+      visited.add(currentId);
+      const item = this.manifestById.get(currentId);
+      if (!item) return false;
+      if (isSpineMediaType(item.mediaType)) return true;
+      currentId = item.fallback;
+    }
+    return false;
+  }
 };
 function isSpineMediaType(mediaType) {
   return mediaType === "application/xhtml+xml" || mediaType === "image/svg+xml" || // EPUB 2 also allows these in spine
   mediaType === "application/x-dtbook+xml";
 }
 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}))*$/;
-  return pattern.test(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;
+  return GRANDFATHERED_LANG_TAGS.has(tag);
 }
 function resolvePath(basePath, relativePath) {
   if (relativePath.startsWith("/")) {
@@ -5636,17 +7616,6 @@ function tryDecodeUriComponent(encoded) {
     return encoded;
   }
 }
-function checkUrlLeaking(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)) {
@@ -5714,9 +7683,11 @@ function isValidW3CDateFormat(dateStr) {
 var ResourceRegistry = class {
   resources;
   ids;
+  svgSymbolIds;
   constructor() {
     this.resources = /* @__PURE__ */ new Map();
     this.ids = /* @__PURE__ */ new Map();
+    this.svgSymbolIds = /* @__PURE__ */ new Map();
   }
   /**
    * Register a resource from manifest
@@ -5778,6 +7749,21 @@ var ResourceRegistry = class {
     }
     return -1;
   }
+  /**
+   * Register an ID as belonging to an SVG symbol element
+   */
+  registerSVGSymbolID(resourceURL, id) {
+    if (!this.svgSymbolIds.has(resourceURL)) {
+      this.svgSymbolIds.set(resourceURL, /* @__PURE__ */ new Set());
+    }
+    this.svgSymbolIds.get(resourceURL)?.add(id);
+  }
+  /**
+   * Check if an ID in a resource belongs to an SVG symbol element
+   */
+  isSVGSymbolID(resourceURL, id) {
+    return this.svgSymbolIds.get(resourceURL)?.has(id) ?? false;
+  }
   /**
    * Get all resources
    */
@@ -5827,6 +7813,7 @@ var ReferenceValidator = class {
     for (const reference of this.references) {
       this.validateReference(context, reference);
     }
+    this.checkRemoteResources(context);
     this.checkUndeclaredResources(context);
     this.checkReadingOrder(context);
     this.checkNonLinearReachability(context);
@@ -5836,14 +7823,6 @@ var ReferenceValidator = class {
    */
   validateReference(context, reference) {
     const url = reference.url.trim();
-    if (isMalformedURL(url)) {
-      pushMessage(context.messages, {
-        id: MessageId.RSC_020,
-        message: `Malformed URL: ${url}`,
-        location: reference.location
-      });
-      return;
-    }
     if (isDataURL(url)) {
       if (this.version.startsWith("3.")) {
         const forbiddenDataUrlTypes = [
@@ -5858,10 +7837,35 @@ var ReferenceValidator = class {
             message: "Data URLs are not allowed in this context",
             location: reference.location
           });
+        } else {
+          const fallbackCheckedTypes = [
+            "image" /* IMAGE */,
+            "audio" /* AUDIO */,
+            "video" /* VIDEO */,
+            "generic" /* GENERIC */
+          ];
+          if (fallbackCheckedTypes.includes(reference.type) && !reference.hasIntrinsicFallback) {
+            const dataUrlMimeType = this.extractDataURLMimeType(url);
+            if (dataUrlMimeType && !isCoreMediaType(dataUrlMimeType)) {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_032,
+                message: `Fallback must be provided for foreign resources, but found none for data URL of type "${dataUrlMimeType}"`,
+                location: reference.location
+              });
+            }
+          }
         }
       }
       return;
     }
+    if (isMalformedURL(url)) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_020,
+        message: `Malformed URL: ${url}`,
+        location: reference.location
+      });
+      return;
+    }
     if (isFileURL(url)) {
       pushMessage(context.messages, {
         id: MessageId.RSC_030,
@@ -5873,6 +7877,13 @@ var ReferenceValidator = class {
     const resourcePath = reference.targetResource || parseURL(url).resource;
     const fragment = reference.fragment ?? parseURL(url).fragment;
     const hasFragment = fragment !== void 0 && fragment !== "";
+    if (!isRemoteURL(url) && url.includes("?")) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_033,
+        message: `Relative URL strings must not have a query component: "${url}"`,
+        location: reference.location
+      });
+    }
     if (!isRemoteURL(url)) {
       this.validateLocalReference(context, reference, resourcePath);
     } else {
@@ -5888,7 +7899,7 @@ var ReferenceValidator = class {
   validateLocalReference(context, reference, resourcePath) {
     if (hasAbsolutePath(resourcePath)) {
       pushMessage(context.messages, {
-        id: MessageId.RSC_027,
+        id: MessageId.RSC_026,
         message: "Absolute paths are not allowed in EPUB",
         location: reference.location
       });
@@ -5900,10 +7911,16 @@ var ReferenceValidator = class {
     ];
     if (hasParentDirectoryReference(reference.url) && forbiddenParentDirTypes.includes(reference.type)) {
       pushMessage(context.messages, {
-        id: MessageId.RSC_028,
+        id: MessageId.RSC_026,
         message: "Parent directory references (..) are not allowed",
         location: reference.location
       });
+    } else if (!hasAbsolutePath(resourcePath) && !hasParentDirectoryReference(reference.url) && checkUrlLeaking(reference.url)) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_026,
+        message: `URL "${reference.url}" leaks outside the container`,
+        location: reference.location
+      });
     }
     if (!this.registry.hasResource(resourcePath)) {
       const fileExistsInContainer = context.files.has(resourcePath);
@@ -5928,14 +7945,15 @@ var ReferenceValidator = class {
       return;
     }
     const resource = this.registry.getResource(resourcePath);
-    if (reference.type === "hyperlink" /* HYPERLINK */ && !resource?.inSpine) {
+    const isHyperlinkLike = reference.type === "hyperlink" /* HYPERLINK */ || reference.type === "nav-toc-link" /* NAV_TOC_LINK */ || reference.type === "nav-pagelist-link" /* NAV_PAGELIST_LINK */;
+    if (this.version.startsWith("3") && isHyperlinkLike && !resource?.inSpine) {
       pushMessage(context.messages, {
         id: MessageId.RSC_011,
         message: "Hyperlinks must reference spine items",
         location: reference.location
       });
     }
-    if (reference.type === "hyperlink" /* HYPERLINK */ || reference.type === "overlay-text-link" /* OVERLAY_TEXT_LINK */) {
+    if (isHyperlinkLike || reference.type === "overlay-text-link" /* OVERLAY_TEXT_LINK */) {
       const targetMimeType = resource?.mimeType;
       if (targetMimeType && !this.isBlessedItemType(targetMimeType, context.version) && !this.isDeprecatedBlessedItemType(targetMimeType) && !resource.hasCoreMediaTypeFallback) {
         pushMessage(context.messages, {
@@ -5945,7 +7963,13 @@ var ReferenceValidator = class {
         });
       }
     }
-    if (resource && isPublicationResourceReference(reference.type) && !CORE_MEDIA_TYPES.has(resource.mimeType) && !resource.hasCoreMediaTypeFallback && !reference.hasIntrinsicFallback) {
+    const fallbackCheckedTypes = [
+      "image" /* IMAGE */,
+      "audio" /* AUDIO */,
+      "video" /* VIDEO */,
+      "generic" /* GENERIC */
+    ];
+    if (resource && fallbackCheckedTypes.includes(reference.type) && !isCoreMediaType(resource.mimeType) && !resource.hasCoreMediaTypeFallback && !reference.hasIntrinsicFallback) {
       pushMessage(context.messages, {
         id: MessageId.RSC_032,
         message: `Fallback must be provided for foreign resources, but found none for resource "${resourcePath}" of type "${resource.mimeType}"`,
@@ -5958,20 +7982,24 @@ var ReferenceValidator = class {
    */
   validateRemoteReference(context, reference) {
     const url = reference.url;
-    if (isHTTP(url) && !isHTTPS(url)) {
-      pushMessage(context.messages, {
-        id: MessageId.RSC_031,
-        message: "Remote resources must use HTTPS",
-        location: reference.location
-      });
-    }
     if (isPublicationResourceReference(reference.type)) {
-      const allowedRemoteTypes = /* @__PURE__ */ new Set([
+      if (isHTTP(url) && !isHTTPS(url)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_031,
+          message: "Remote resources must use HTTPS",
+          location: reference.location
+        });
+      }
+      const allowedRemoteRefTypes = /* @__PURE__ */ new Set([
         "audio" /* AUDIO */,
         "video" /* VIDEO */,
         "font" /* FONT */
       ]);
-      if (!allowedRemoteTypes.has(reference.type)) {
+      const targetResource = reference.targetResource || url;
+      const resource = this.registry.getResource(targetResource);
+      const isAllowedByRefType = allowedRemoteRefTypes.has(reference.type);
+      const isAllowedByMimeType = resource && this.isRemoteResourceType(resource.mimeType);
+      if (!isAllowedByRefType && !isAllowedByMimeType) {
         pushMessage(context.messages, {
           id: MessageId.RSC_006,
           message: "Remote resources are only allowed for audio, video, and fonts",
@@ -5979,8 +8007,7 @@ var ReferenceValidator = class {
         });
         return;
       }
-      const targetResource = reference.targetResource || url;
-      if (!this.registry.hasResource(targetResource)) {
+      if (!resource) {
         pushMessage(context.messages, {
           id: MessageId.RSC_008,
           message: `Referenced resource "${targetResource}" is not declared in the OPF manifest`,
@@ -6013,9 +8040,9 @@ var ReferenceValidator = class {
       });
       return;
     }
-    if (resource?.mimeType === "image/svg+xml") {
+    if (resource?.mimeType === "image/svg+xml" && reference.type === "hyperlink" /* HYPERLINK */) {
       const hasSVGView = fragment.includes("svgView(") || fragment.includes("viewBox(");
-      if (hasSVGView && reference.type === "hyperlink" /* HYPERLINK */) {
+      if (hasSVGView) {
         pushMessage(context.messages, {
           id: MessageId.RSC_014,
           message: "SVG view fragments can only be referenced from SVG documents",
@@ -6023,11 +8050,51 @@ var ReferenceValidator = class {
         });
       }
     }
-    if (!this.registry.hasID(resourcePath, fragment)) {
+    if (reference.type === "hyperlink" /* HYPERLINK */) {
+      if (this.registry.isSVGSymbolID(resourcePath, fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_014,
+          message: `Fragment identifier "${fragment}" defines an incompatible resource type (SVG symbol)`,
+          location: reference.location
+        });
+      }
+    }
+    const parsedMimeTypes = ["application/xhtml+xml", "image/svg+xml"];
+    if (resource && parsedMimeTypes.includes(resource.mimeType) && !isRemoteURL(resourcePath) && !fragment.includes("svgView(") && reference.type !== "svg-symbol" /* SVG_SYMBOL */) {
+      if (!this.registry.hasID(resourcePath, fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_012,
+          message: `Fragment identifier not found: #${fragment}`,
+          location: reference.location
+        });
+      }
+    }
+  }
+  /**
+   * Check non-spine remote resources that have non-standard types.
+   * Fires RSC-006 for remote items that aren't audio/video/font types
+   * and aren't referenced as audio/video/font by content documents.
+   * This mirrors Java's checkItemAfterResourceValidation behavior.
+   */
+  checkRemoteResources(context) {
+    if (!this.version.startsWith("3")) return;
+    const referencedAsAllowed = /* @__PURE__ */ new Set();
+    for (const ref of this.references) {
+      if (isRemoteURL(ref.url) || isRemoteURL(ref.targetResource)) {
+        if (ref.type === "font" /* FONT */ || ref.type === "audio" /* AUDIO */ || ref.type === "video" /* VIDEO */) {
+          referencedAsAllowed.add(ref.targetResource);
+        }
+      }
+    }
+    for (const resource of this.registry.getAllResources()) {
+      if (!isRemoteURL(resource.url)) continue;
+      if (resource.inSpine) continue;
+      if (this.isRemoteResourceType(resource.mimeType)) continue;
+      if (referencedAsAllowed.has(resource.url)) continue;
       pushMessage(context.messages, {
-        id: MessageId.RSC_012,
-        message: `Fragment identifier not found: #${fragment}`,
-        location: reference.location
+        id: MessageId.RSC_006,
+        message: `Remote resource reference is not allowed; resource "${resource.url}" must be located in the EPUB container`,
+        location: { path: resource.url }
       });
     }
   }
@@ -6051,9 +8118,9 @@ var ReferenceValidator = class {
     for (const resource of this.registry.getAllResources()) {
       if (resource.inSpine) continue;
       if (referencedResources.has(resource.url)) continue;
-      if (resource.url.includes("nav")) continue;
-      if (resource.url.includes("toc.ncx") || resource.url.includes(".ncx")) continue;
-      if (resource.url.includes("cover-image")) continue;
+      if (resource.isNav) continue;
+      if (resource.isNcx) continue;
+      if (resource.isCoverImage) continue;
       pushMessage(context.messages, {
         id: MessageId.OPF_097,
         message: `Resource declared in manifest but not referenced: ${resource.url}`,
@@ -6114,7 +8181,7 @@ var ReferenceValidator = class {
     const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
     const hyperlinkTargets = /* @__PURE__ */ new Set();
     for (const ref of this.references) {
-      if (ref.type === "hyperlink" /* HYPERLINK */) {
+      if (ref.type === "hyperlink" /* HYPERLINK */ || ref.type === "nav-toc-link" /* NAV_TOC_LINK */ || ref.type === "nav-pagelist-link" /* NAV_PAGELIST_LINK */) {
         hyperlinkTargets.add(ref.targetResource);
       }
     }
@@ -6151,6 +8218,13 @@ var ReferenceValidator = class {
   isDeprecatedBlessedItemType(mimeType) {
     return mimeType === "text/x-oeb1-document" || mimeType === "text/html";
   }
+  extractDataURLMimeType(url) {
+    const match = /^data:([^;,]+)/.exec(url);
+    return match?.[1]?.trim().toLowerCase() ?? "text/plain";
+  }
+  isRemoteResourceType(mimeType) {
+    return mimeType.startsWith("audio/") || mimeType.startsWith("video/") || mimeType.startsWith("font/") || mimeType === "application/font-sfnt" || mimeType === "application/font-woff" || mimeType === "application/font-woff2" || mimeType === "application/vnd.ms-opentype";
+  }
 };
 var COMPRESSED_SCHEMAS = {
   "applications.rng": "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",
@@ -6665,11 +8739,15 @@ var EpubCheck = class _EpubCheck {
     const manifestById = new Map(packageDoc.manifest.map((item) => [item.id, item]));
     for (const item of packageDoc.manifest) {
       const fullPath = resolveManifestHref(opfDir, item.href);
+      const properties = item.properties ?? [];
       registry.registerResource({
         url: fullPath,
         mimeType: item.mediaType,
         inSpine: spineIdrefs.has(item.id),
         hasCoreMediaTypeFallback: this.hasCMTFallback(item.id, manifestById),
+        isNav: properties.includes("nav"),
+        isCoverImage: properties.includes("cover-image"),
+        isNcx: item.mediaType === "application/x-dtbncx+xml",
         ids: /* @__PURE__ */ new Set()
       });
     }
@@ -6685,7 +8763,7 @@ var EpubCheck = class _EpubCheck {
       visited.add(currentId);
       const item = manifestById.get(currentId);
       if (!item) return false;
-      if (CORE_MEDIA_TYPES.has(item.mediaType)) return true;
+      if (isCoreMediaType(item.mediaType)) return true;
       currentId = item.fallback;
     }
     return false;