@likecoin/epubcheck-ts 0.5.1 → 0.6.0

package/dist/index.js

@@ -1666,144 +1666,6 @@ var CSSValidator = class {
   }
 };
 
-// src/vocab/epub-ssv.ts
-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"
-]);
-
 // src/references/url.ts
 function parseURL(urlString) {
   const hashIndex = urlString.indexOf("#");
@@ -1832,12 +1694,13 @@ function isDataURL(url) {
 function isFileURL(url) {
   return url.startsWith("file:");
 }
+function isRelativeURL(url) {
+  const regex = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+  return regex.exec(url) === null;
+}
 function hasAbsolutePath(url) {
   return url.startsWith("/");
 }
-function hasParentDirectoryReference(url) {
-  return url.includes("..");
-}
 function isMalformedURL(url) {
   if (!url.trim()) return true;
   if (/[\s<>]/.test(url)) return true;
@@ -1852,12 +1715,14 @@ function isHTTP(url) {
 function isRemoteURL(url) {
   return isHTTP(url) || isHTTPS(url);
 }
-function checkUrlLeaking(href) {
+function checkUrlLeaking(href, resourcePath) {
   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();
+    const baseA = resourcePath ? new URL(resourcePath, TEST_BASE_A).toString() : TEST_BASE_A;
+    const baseB = resourcePath ? new URL(resourcePath, TEST_BASE_B).toString() : TEST_BASE_B;
+    const urlA = new URL(href, baseA).toString();
+    const urlB = new URL(href, baseB).toString();
     return !urlA.startsWith(TEST_BASE_A) || !urlB.startsWith(TEST_BASE_B);
   } catch {
     return false;
@@ -2029,6 +1894,8 @@ function parseOPF(xml) {
       }
     }
   }
+  const nsRegex = /<package[^>]*\sxmlns=["']([^"']+)["']/;
+  const isLegacyOebps12 = nsRegex.exec(xml)?.[1] === "http://openebook.org/namespaces/oeb-package/1.0/";
   const prefixes = parsePrefixes(xml);
   const dirRegex = /<package[^>]*\sdir=["']([^"']+)["']/;
   const dirMatch = dirRegex.exec(xml);
@@ -2067,6 +1934,9 @@ function parseOPF(xml) {
   if (!versionDeclared) {
     result.versionDeclared = false;
   }
+  if (isLegacyOebps12) {
+    result.isLegacyOebps12 = true;
+  }
   if (Object.keys(prefixes).length > 0) {
     result.prefixes = prefixes;
   }
@@ -2157,7 +2027,7 @@ function parseDCElements(metadataXml) {
 }
 function parseMetaElements(metadataXml) {
   const elements = [];
-  const metaRegex = /<meta([^>]*property=["'][^"']+["'][^>]*)>([^<]*)<\/meta>/g;
+  const metaRegex = /<(?:[A-Za-z_][\w.-]*:)?meta([^>]*property=["'][^"']+["'][^>]*)>([^<]*)<\/(?:[A-Za-z_][\w.-]*:)?meta>/g;
   let match;
   while ((match = metaRegex.exec(metadataXml)) !== null) {
     const attrsStr = match[1] ?? "";
@@ -2927,6 +2797,9 @@ var OPFValidator = class {
     }
     this.validatePackageAttributes(context, opfPath);
     this.validateMetadata(context, opfPath);
+    if (this.packageDoc.version !== "2.0") {
+      this.validateMetaPrefixes(context, opfPath, opfXml);
+    }
     this.validateLinkElements(context, opfPath);
     this.validateManifest(context, opfPath);
     this.validateSpine(context, opfPath);
@@ -4120,6 +3993,7 @@ var OPFValidator = class {
     if (!this.packageDoc) return;
     const seenIds = /* @__PURE__ */ new Set();
     const seenHrefs = /* @__PURE__ */ new Set();
+    const declaredPrefixes = this.packageDoc.prefixes ?? {};
     for (const item of this.packageDoc.manifest) {
       if (seenIds.has(item.id)) {
         pushMessage(context.messages, {
@@ -4163,7 +4037,7 @@ var OPFValidator = class {
         });
       }
       if (!item.href.startsWith("http") && !item.href.startsWith("mailto:")) {
-        const leaked = checkUrlLeaking(item.href);
+        const leaked = checkUrlLeaking(item.href, opfPath);
         if (leaked) {
           pushMessage(context.messages, {
             id: MessageId.RSC_026,
@@ -4198,11 +4072,11 @@ var OPFValidator = class {
       if (DEPRECATED_MEDIA_TYPES.has(item.mediaType) || item.mediaType === "text/html") {
         if (this.packageDoc.version === "2.0" && item.mediaType === "text/html") {
           pushMessage(context.messages, {
-            id: MessageId.OPF_035,
+            id: this.packageDoc.isLegacyOebps12 ? MessageId.OPF_038 : MessageId.OPF_035,
             message: `XHTML Content Document "${item.id}" is declared as "text/html"`,
             location: { path: opfPath }
           });
-        } else if (this.packageDoc.version === "2.0") {
+        } else if (this.packageDoc.version === "2.0" && !this.packageDoc.isLegacyOebps12) {
           pushMessage(context.messages, {
             id: MessageId.OPF_037,
             message: `Found deprecated media-type "${item.mediaType}"`,
@@ -4210,6 +4084,13 @@ var OPFValidator = class {
           });
         }
       }
+      if (this.packageDoc.version === "2.0" && this.packageDoc.isLegacyOebps12 && item.mediaType === "text/css" && !item.fallback) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_039,
+          message: `Media type "${item.mediaType}" requires a fallback in legacy OEBPS 1.2 context`,
+          location: { path: opfPath }
+        });
+      }
       const preferred = getPreferredMediaType(item.mediaType, fullPath);
       if (preferred !== null) {
         pushMessage(context.messages, {
@@ -4220,13 +4101,14 @@ var OPFValidator = class {
       }
       if (this.packageDoc.version !== "2.0" && item.properties) {
         for (const prop of item.properties) {
-          if (!ITEM_PROPERTIES.has(prop)) {
-            pushMessage(context.messages, {
-              id: MessageId.OPF_027,
-              message: `Undefined property: "${prop}"`,
-              location: { path: opfPath }
-            });
-          }
+          if (ITEM_PROPERTIES.has(prop)) continue;
+          const colon = prop.indexOf(":");
+          if (colon > 0 && declaredPrefixes[prop.slice(0, colon)] !== void 0) continue;
+          pushMessage(context.messages, {
+            id: MessageId.OPF_027,
+            message: `Undefined property: "${prop}"`,
+            location: { path: opfPath }
+          });
         }
         if (item.properties.includes("nav")) {
           if (item.mediaType !== "application/xhtml+xml") {
@@ -4389,6 +4271,42 @@ var OPFValidator = class {
    * emits one assertion failure per offending element (so two duplicate ids
    * produce two RSC-005 messages).
    */
+  validateMetaPrefixes(context, opfPath, opfXml) {
+    if (!this.packageDoc) return;
+    const RESERVED = /* @__PURE__ */ new Set([
+      "dcterms",
+      "marc",
+      "onix",
+      "schema",
+      "xsd",
+      "a11y",
+      "media",
+      "rendition"
+    ]);
+    const declared = new Set(Object.keys(this.packageDoc.prefixes ?? {}));
+    const reported = /* @__PURE__ */ new Set();
+    const reportIfUndeclared = (prefix) => {
+      if (!prefix || reported.has(prefix)) return;
+      if (RESERVED.has(prefix) || declared.has(prefix)) return;
+      reported.add(prefix);
+      pushMessage(context.messages, {
+        id: MessageId.OPF_028,
+        message: `Undeclared prefix: "${prefix}"`,
+        location: { path: opfPath }
+      });
+    };
+    const stripped = stripXmlComments(opfXml);
+    const attrRegex = /\b(?:property|scheme|rel)\s*=\s*["']([^"']+)["']/g;
+    for (const match of stripped.matchAll(attrRegex)) {
+      const value = match[1]?.trim();
+      if (!value) continue;
+      for (const token of value.split(/\s+/)) {
+        const colon = token.indexOf(":");
+        if (colon <= 0) continue;
+        reportIfUndeclared(token.slice(0, colon));
+      }
+    }
+  }
   validateOpfIdUniqueness(context, opfPath, opfXml) {
     const stripped = stripXmlComments(opfXml);
     const counts = /* @__PURE__ */ new Map();
@@ -4420,11 +4338,12 @@ var OPFValidator = class {
     for (const item of this.packageDoc.manifest) {
       const hrefBase = item.href.split("?")[0] ?? item.href;
       if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(hrefBase)) continue;
-      manifestPaths.add(resolvePath(opfPath, hrefBase).normalize("NFC"));
+      manifestPaths.add(resolvePath(opfPath, tryDecodeUriComponent(hrefBase)).normalize("NFC"));
     }
     const rootfilePaths = new Set(context.rootfiles.map((r) => r.path.normalize("NFC")));
     for (const path of context.files.keys()) {
       if (path === "mimetype") continue;
+      if (path.endsWith("/")) continue;
       if (path.startsWith("META-INF/")) continue;
       if (rootfilePaths.has(path)) continue;
       if (manifestPaths.has(path)) continue;
@@ -5013,6 +4932,246 @@ function isValidW3CDateFormat(dateStr) {
   return false;
 }
 
+// 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 PUBLICATION_RESOURCE_TYPES.has(type);
+}
+
+// src/skm/validator.ts
+var OPS_NS_URI = "http://www.idpf.org/2007/ops";
+var SKM_NS = { ops: OPS_NS_URI };
+var SKMValidator = class {
+  validate(context, path, refValidator) {
+    const data = context.files.get(path);
+    if (!data) return;
+    const content = typeof data === "string" ? data : new TextDecoder().decode(data);
+    let doc = null;
+    try {
+      doc = XmlDocument.fromString(content);
+    } catch {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_016,
+        message: "Search Key Map document is not well-formed XML",
+        location: { path }
+      });
+      return;
+    }
+    try {
+      const root = doc.root;
+      if (root.namespaceUri !== OPS_NS_URI || root.name !== "search-key-map") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Root element must be "search-key-map" in the OPS namespace`,
+          location: { path, line: root.line }
+        });
+        return;
+      }
+      const groups = root.find("./ops:search-key-group", SKM_NS);
+      if (groups.length === 0) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'A "search-key-map" must contain at least one "search-key-group"',
+          location: { path, line: root.line }
+        });
+      }
+      for (const group of groups) {
+        const groupEl = group;
+        const href = groupEl.attr("href")?.value;
+        if (!href) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "href" attribute is required on "search-key-group"',
+            location: { path, line: groupEl.line }
+          });
+        } else if (refValidator) {
+          registerSkmRef(refValidator, path, href, groupEl.line);
+        }
+        const matches = groupEl.find("./ops:match", SKM_NS);
+        if (matches.length === 0) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'A "search-key-group" must contain at least one "match"',
+            location: { path, line: groupEl.line }
+          });
+        }
+        for (const match of matches) {
+          const matchEl = match;
+          const matchHref = matchEl.attr("href")?.value;
+          if (matchHref && refValidator) {
+            registerSkmRef(refValidator, path, matchHref, matchEl.line);
+          }
+        }
+      }
+    } finally {
+      doc.dispose();
+    }
+  }
+};
+function registerSkmRef(refValidator, path, href, line) {
+  const parsed = parseURL(href);
+  const targetResource = resolvePath(path, tryDecodeUriComponent(parsed.resource)).normalize("NFC");
+  const location = line != null ? { path, line } : { path };
+  const ref = {
+    url: parsed.hasFragment ? `${targetResource}#${parsed.fragment ?? ""}` : targetResource,
+    targetResource,
+    type: "search-key" /* SEARCH_KEY */,
+    location
+  };
+  if (parsed.fragment !== void 0) ref.fragment = parsed.fragment;
+  refValidator.addReference(ref);
+}
+
+// src/vocab/epub-ssv.ts
+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"
+]);
+
 // src/smil/validator.ts
 var SMIL_NS = { smil: "http://www.w3.org/ns/SMIL" };
 var BLESSED_AUDIO_TYPES = /* @__PURE__ */ new Set(["audio/mpeg", "audio/mp4"]);
@@ -5258,24 +5417,6 @@ var SMILValidator = class {
   }
 };
 
-// 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 PUBLICATION_RESOURCE_TYPES.has(type);
-}
-
 // src/references/uri-schemes.ts
 var URI_SCHEMES = /* @__PURE__ */ new Set([
   "aaa",
@@ -5365,7 +5506,9 @@ var ABSOLUTE_URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
 var SPECIAL_URL_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "ftp", "ws", "wss"]);
 var CSS_CHARSET_RE = /^@charset\s+"([^"]+)"\s*;/;
 var EPUB_XMLNS_RE = /xmlns:epub\s*=\s*"([^"]*)"/;
-var XHTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+var XHTML_NS_URI = "http://www.w3.org/1999/xhtml";
+var XML_NS_URI = "http://www.w3.org/XML/1998/namespace";
+var XHTML_NS = { html: XHTML_NS_URI };
 var EPUB_OPS_NS = { epub: "http://www.idpf.org/2007/ops" };
 var EPUB_TYPE_FORBIDDEN_ELEMENTS = /* @__PURE__ */ new Set([
   "head",
@@ -5649,6 +5792,112 @@ var HTML5_ELEMENTS = /* @__PURE__ */ new Set([
   "video",
   "wbr"
 ]);
+var XHTML11_ELEMENTS = /* @__PURE__ */ new Set([
+  // struct
+  "html",
+  "head",
+  "title",
+  "body",
+  "meta",
+  "link",
+  "base",
+  "style",
+  "script",
+  "noscript",
+  // text
+  "br",
+  "span",
+  "abbr",
+  "acronym",
+  "cite",
+  "code",
+  "dfn",
+  "em",
+  "kbd",
+  "q",
+  "samp",
+  "strong",
+  "var",
+  "div",
+  "p",
+  "address",
+  "blockquote",
+  "pre",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  // pres / legacy
+  "hr",
+  "b",
+  "big",
+  "i",
+  "small",
+  "sub",
+  "sup",
+  "tt",
+  "basefont",
+  "center",
+  "font",
+  "s",
+  "strike",
+  "u",
+  "dir",
+  "menu",
+  "isindex",
+  // list
+  "dl",
+  "dt",
+  "dd",
+  "ol",
+  "ul",
+  "li",
+  // table
+  "table",
+  "caption",
+  "tr",
+  "th",
+  "td",
+  "col",
+  "colgroup",
+  "tbody",
+  "thead",
+  "tfoot",
+  // hypertext / image / object / form / edit / ruby / map / iframe / applet / bdo / param
+  "a",
+  "img",
+  "object",
+  "param",
+  "form",
+  "label",
+  "input",
+  "select",
+  "option",
+  "optgroup",
+  "fieldset",
+  "button",
+  "legend",
+  "textarea",
+  "ins",
+  "del",
+  "ruby",
+  "rbc",
+  "rtc",
+  "rb",
+  "rt",
+  "rp",
+  "map",
+  "area",
+  "iframe",
+  "applet",
+  "bdo",
+  // frames
+  "frameset",
+  "frame",
+  "noframes"
+]);
 function isItemFixedLayout(packageDoc, itemId) {
   const spineItem = packageDoc.spine.find((s) => s.idref === itemId);
   if (!spineItem) return false;
@@ -5715,6 +5964,10 @@ var ContentValidator = class {
         if (refValidator) {
           this.extractSVGReferences(context, fullPath, opfDir, refValidator);
         }
+      } else if (item.mediaType === "application/vnd.epub.search-key-map+xml") {
+        const fullPath = resolveManifestHref(opfDir, item.href);
+        const skmValidator = new SKMValidator();
+        skmValidator.validate(context, fullPath, refValidator);
       } else if (item.mediaType === "application/smil+xml") {
         const fullPath = resolveManifestHref(opfDir, item.href);
         const smilValidator = new SMILValidator();
@@ -6477,6 +6730,9 @@ var ContentValidator = class {
           }
         }
       }
+      if (context.version === "2.0") {
+        this.checkEpub2XhtmlStrict(context, path, root);
+      }
       this.checkDiscouragedElements(context, path, root);
       this.checkSSMLPh(context, path, root, content);
       this.checkObsoleteHTML(context, path, root);
@@ -6507,6 +6763,9 @@ var ContentValidator = class {
         this.validateEpubTypes(context, path, root);
         this.validateRegionBasedNav(context, path, root, manifestItem);
       }
+      if (context.version.startsWith("3") && context.options.profile === "dict") {
+        this.validateDictionaryContent(context, path, root);
+      }
       if (context.version.startsWith("3") && context.options.profile === "edupub") {
         const isFxl = manifestItem && packageDoc ? isItemFixedLayout(packageDoc, manifestItem.id) : false;
         const isNonLinear = manifestItem && packageDoc ? packageDoc.spine.find((ref) => ref.idref === manifestItem.id)?.linear === false : false;
@@ -6515,7 +6774,7 @@ var ContentValidator = class {
         }
       }
       if (context.version.startsWith("3")) {
-        this.collectFeatures(context, root);
+        this.collectFeatures(context, path, root);
       }
       this.validateEpubSwitch(context, path, root);
       this.validateEpubTrigger(context, path, root);
@@ -8038,7 +8297,7 @@ var ContentValidator = class {
       }
     }
   }
-  collectFeatures(context, root) {
+  collectFeatures(context, path, root) {
     const features = context.contentFeatures;
     if (!features) return;
     if (!features.hasTable && root.get(".//html:table", XHTML_NS)) {
@@ -8053,22 +8312,20 @@ var ContentValidator = class {
     if (!features.hasVideo && root.get(".//html:video", XHTML_NS)) {
       features.hasVideo = true;
     }
-    if (!features.hasPageBreak || !features.hasDictionary || !features.hasIndex) {
-      const epubTypeElements = root.find(".//*[@epub:type]", EPUB_OPS_NS);
-      for (const el of epubTypeElements) {
-        const attr = el.attr("type", "epub");
-        if (!attr?.value) continue;
-        const tokens = attr.value.trim().split(/\s+/);
-        if (!features.hasPageBreak && tokens.includes("pagebreak")) {
-          features.hasPageBreak = true;
-        }
-        if (!features.hasDictionary && tokens.includes("dictionary")) {
-          features.hasDictionary = true;
-        }
-        if (!features.hasIndex && tokens.includes("index")) {
-          features.hasIndex = true;
-        }
-        if (features.hasPageBreak && features.hasDictionary && features.hasIndex) break;
+    const epubTypeElements = root.find(".//*[@epub:type]", EPUB_OPS_NS);
+    for (const el of epubTypeElements) {
+      const attr = el.attr("type", "epub");
+      if (!attr?.value) continue;
+      const tokens = attr.value.trim().split(/\s+/);
+      if (!features.hasPageBreak && tokens.includes("pagebreak")) {
+        features.hasPageBreak = true;
+      }
+      if (tokens.includes("dictionary")) {
+        features.hasDictionary = true;
+        (features.dictionaryContentPaths ??= /* @__PURE__ */ new Set()).add(path);
+      }
+      if (!features.hasIndex && tokens.includes("index")) {
+        features.hasIndex = true;
       }
     }
     if (!features.hasMicrodata && root.get(".//*[@itemscope]")) {
@@ -8169,6 +8426,158 @@ var ContentValidator = class {
           });
         }
       }
+      this.validateRegionBasedNavRules(context, path, root);
+    }
+  }
+  validateRegionBasedNavRules(context, path, root) {
+    const XHTML_NS2 = { html: "http://www.w3.org/1999/xhtml" };
+    let regionNavs;
+    try {
+      regionNavs = root.find(".//html:nav", XHTML_NS2);
+    } catch {
+      return;
+    }
+    const packageDoc = context.packageDocument;
+    const opfDir = context.opfPath?.includes("/") ? context.opfPath.substring(0, context.opfPath.lastIndexOf("/")) : "";
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const manifestByPath = packageDoc ? new Map(packageDoc.manifest.map((m) => [resolveManifestHref(opfDir, m.href), m])) : void 0;
+    for (const nav of regionNavs) {
+      const epubType = nav.attr("type", "epub")?.value ?? "";
+      if (!epubType.split(/\s+/).includes("region-based")) continue;
+      const childEls = nav.find("./html:*", XHTML_NS2);
+      if (childEls.length !== 1 || childEls[0]?.name !== "ol") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_017,
+          message: "A region-based nav element must contain exactly one child ol element.",
+          location: { path, line: nav.line }
+        });
+      }
+      const liElements = nav.find(".//html:li", XHTML_NS2);
+      for (const li of liElements) {
+        const liChildren = li.find("./html:*", XHTML_NS2);
+        const first = liChildren[0];
+        if (!first || first.name !== "a" && first.name !== "span") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_017,
+            message: "The first child of a region-based nav list item must be either an 'a' or 'span' element.",
+            location: { path, line: li.line }
+          });
+        }
+        if (liChildren.length > 1 && (liChildren.length !== 2 || liChildren[1]?.name !== "ol")) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_017,
+            message: "The first child of a region-based nav list item can only be followed by a single 'ol' element.",
+            location: { path, line: li.line }
+          });
+        }
+      }
+      const spans = nav.find(".//html:span", XHTML_NS2);
+      for (const span of spans) {
+        const spanChildren = span.find("./html:*", XHTML_NS2);
+        const aChildren = spanChildren.filter((c) => c.name === "a");
+        if (spanChildren.length !== 2 || aChildren.length !== 2) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_017,
+            message: "'span' elements in region-based navs must contain exactly two 'a' elements.",
+            location: { path, line: span.line }
+          });
+        }
+      }
+      const anchors = nav.find(".//html:a", XHTML_NS2);
+      for (const a of anchors) {
+        if (a.content.trim() !== "") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_017,
+            message: "'a' elements in region-based navs should not contain text labels.",
+            location: { path, line: a.line }
+          });
+        }
+      }
+      if (!packageDoc || !manifestByPath) continue;
+      for (const a of anchors) {
+        const href = a.attr("href")?.value;
+        if (!href || !isRelativeURL(href)) continue;
+        const resolved = this.resolveRelativePath(docDir, href, opfDir);
+        const targetPath = parseURL(resolved).resource;
+        if (!targetPath) continue;
+        const item = manifestByPath.get(targetPath);
+        if (!item) continue;
+        if (!isItemFixedLayout(packageDoc, item.id)) {
+          pushMessage(context.messages, {
+            id: MessageId.NAV_009,
+            message: "Region-based navigation links must point to Fixed-Layout Documents.",
+            location: { path, line: a.line }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * EPUB Dictionaries content document rules.
+   *
+   * Mirrors ../epubcheck/src/main/resources/com/adobe/epubcheck/schema/30/dict/dict-xhtml.sch
+   * (minimum set: `dictionary` must be on body/section with article children; each article or
+   * `dictentry` must have a `dfn` descendant outside of optional `condensed-entry`).
+   */
+  validateDictionaryContent(context, path, root) {
+    let typedElements;
+    try {
+      typedElements = root.find(".//*[@epub:type]", EPUB_OPS_NS);
+    } catch {
+      return;
+    }
+    for (const el of typedElements) {
+      const tokens = el.attr("type", "epub")?.value.split(/\s+/) ?? [];
+      if (tokens.includes("dictionary")) {
+        if (el.name !== "body" && el.name !== "section") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "dictionary" type is only allowed on "body" or "section" elements.',
+            location: { path, line: el.line }
+          });
+        }
+        const articles = el.find("./html:article", XHTML_NS);
+        if (articles.length === 0) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'A "dictionary" must have at least one article child.',
+            location: { path, line: el.line }
+          });
+        }
+        for (const article of articles) {
+          this.checkDictionaryEntry(context, path, article);
+        }
+      }
+      if (tokens.includes("dictentry")) {
+        if (el.name !== "article") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: 'The "dictentry" type is only allowed on "article" elements.',
+            location: { path, line: el.line }
+          });
+        } else {
+          this.checkDictionaryEntry(context, path, el);
+        }
+      }
+    }
+  }
+  checkDictionaryEntry(context, path, article) {
+    const dfns = article.find(".//html:dfn", XHTML_NS);
+    const hasDfnOutsideCondensed = dfns.some((dfn) => {
+      let parent = dfn.parent;
+      while (parent) {
+        const type = parent.attr("type", "epub")?.value;
+        if (type?.split(/\s+/).includes("condensed-entry")) return false;
+        parent = parent.parent;
+      }
+      return true;
+    });
+    if (!hasDfnOutsideCondensed) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: 'A dictionary entry must have at least one "dfn" descendant (outside of the optional condensed entry "aside").',
+        location: { path, line: article.line }
+      });
     }
   }
   /**
@@ -9565,13 +9974,11 @@ var ContentValidator = class {
     }
   }
   checkUnknownElements(context, path, root) {
-    const XHTML_NS2 = "http://www.w3.org/1999/xhtml";
     try {
       const allElements = root.find(".//*");
       for (const el of allElements) {
         const xmlEl = el;
-        const ns = xmlEl.namespaceUri;
-        if (ns !== XHTML_NS2) continue;
+        if (xmlEl.namespaceUri !== XHTML_NS_URI) continue;
         const localName = xmlEl.name.includes(":") ? xmlEl.name.substring(xmlEl.name.indexOf(":") + 1) : xmlEl.name;
         if (localName.includes("-")) continue;
         if (!HTML5_ELEMENTS.has(localName)) {
@@ -9585,6 +9992,51 @@ var ContentValidator = class {
     } catch {
     }
   }
+  checkEpub2XhtmlStrict(context, path, root) {
+    if (!root.namespaceUri) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `element "${root.name}" from namespace "" is not allowed`,
+        location: { path, line: root.line }
+      });
+      return;
+    }
+    const checkElement = (xmlEl) => {
+      if (xmlEl.namespaceUri !== XHTML_NS_URI) return;
+      const localName = xmlEl.name.includes(":") ? xmlEl.name.substring(xmlEl.name.indexOf(":") + 1) : xmlEl.name;
+      if (!XHTML11_ELEMENTS.has(localName)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `element "${localName}" not allowed here`,
+          location: { path, line: xmlEl.line }
+        });
+      }
+      for (const attr of xmlEl.attrs) {
+        const ns = attr.namespaceUri;
+        if (!ns || ns === XHTML_NS_URI || ns === XML_NS_URI) continue;
+        const qname = attr.prefix ? `${attr.prefix}:${attr.name}` : attr.name;
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `attribute "${qname}" not allowed here`,
+          location: { path, line: xmlEl.line }
+        });
+      }
+    };
+    checkElement(root);
+    try {
+      for (const el of root.find(".//*")) {
+        checkElement(el);
+      }
+      for (const a of root.find(".//html:a//html:a", XHTML_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The "a" element cannot contain any nested "a" elements',
+          location: { path, line: a.line }
+        });
+      }
+    } catch {
+    }
+  }
   checkForeignObjectContent(context, path, root, isSVGDoc) {
     const SVG_NS = { svg: "http://www.w3.org/2000/svg" };
     const XHTML_URI = "http://www.w3.org/1999/xhtml";
@@ -9793,6 +10245,7 @@ var NCXValidator = class {
       this.checkContentSrc(context, root, ncxPath, registry);
       this.checkEmptyLabels(context, root, ncxPath);
       this.checkPageTargets(context, root, ncxPath);
+      this.checkIdSyntax(context, root, ncxPath);
     } finally {
       doc.dispose();
     }
@@ -9896,10 +10349,21 @@ var NCXValidator = class {
       }
     }
   }
-  /**
-   * pageTarget@type must be one of "front", "normal", "special".
-   * Reported via RSC-005 to mirror Java Schematron output.
-   */
+  checkIdSyntax(context, root, ncxPath) {
+    const nodes = root.find(".//*[@id]", {
+      ncx: "http://www.daisy.org/z3986/2005/ncx/"
+    });
+    for (const node of nodes) {
+      const idValue = node.attr("id")?.value;
+      if (idValue && !NC_NAME_REGEX.test(idValue)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Invalid id "${idValue}"; must match xs:ID syntax (NCName)`,
+          location: { path: ncxPath, line: node.line }
+        });
+      }
+    }
+  }
   checkPageTargets(context, root, ncxPath) {
     const pageTargets = root.find(".//ncx:pageTarget[@type]", {
       ncx: "http://www.daisy.org/z3986/2005/ncx/"
@@ -9917,6 +10381,7 @@ var NCXValidator = class {
     }
   }
 };
+var NC_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9._-]*$/;
 var PAGE_TARGET_TYPES = /* @__PURE__ */ new Set(["front", "normal", "special"]);
 var OPS_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "application/xhtml+xml",
@@ -10046,15 +10511,6 @@ function parseContainerContent(content, context, fileExists, getFileContent) {
       }
     }
   }
-  for (const rootfile of context.rootfiles) {
-    if (!fileExists(rootfile.path)) {
-      pushMessage(context.messages, {
-        id: MessageId.PKG_010,
-        message: `Rootfile "${rootfile.path}" not found in EPUB`,
-        location: { path: containerPath }
-      });
-    }
-  }
 }
 function validateMappingDocumentContent(xml, mappingPath, context) {
   const stripped = stripXmlComments(xml);
@@ -10973,19 +11429,7 @@ var ReferenceValidator = class {
         message: "Absolute paths are not allowed in EPUB",
         location: reference.location
       });
-    }
-    const forbiddenParentDirTypes = [
-      "hyperlink" /* HYPERLINK */,
-      "nav-toc-link" /* NAV_TOC_LINK */,
-      "nav-pagelist-link" /* NAV_PAGELIST_LINK */
-    ];
-    if (hasParentDirectoryReference(reference.url) && forbiddenParentDirTypes.includes(reference.type)) {
-      pushMessage(context.messages, {
-        id: MessageId.RSC_026,
-        message: "Parent directory references (..) are not allowed",
-        location: reference.location
-      });
-    } else if (!hasAbsolutePath(resourcePath) && !hasParentDirectoryReference(reference.url) && checkUrlLeaking(reference.url)) {
+    } else if (checkUrlLeaking(reference.url, reference.location.path)) {
       pushMessage(context.messages, {
         id: MessageId.RSC_026,
         message: `URL "${reference.url}" leaks outside the container`,
@@ -11023,6 +11467,16 @@ var ReferenceValidator = class {
         location: reference.location
       });
     }
+    if (reference.type === "search-key" /* SEARCH_KEY */ && !resource?.inSpine) {
+      const isEpubCfi = reference.fragment?.startsWith("epubcfi(") ?? false;
+      if (!isEpubCfi) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_021,
+          message: `Search Key Map target "${resourcePath}" must be a Content Document in the spine`,
+          location: reference.location
+        });
+      }
+    }
     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) {
@@ -11507,11 +11961,11 @@ var RelaxNGValidator = class extends BaseSchemaValidator {
     try {
       const libxml2 = await import('libxml2-wasm');
       const LibRelaxNGValidator = libxml2.RelaxNGValidator;
-      const { XmlDocument: XmlDocument4 } = libxml2;
-      const doc = XmlDocument4.fromString(xml);
+      const { XmlDocument: XmlDocument5 } = libxml2;
+      const doc = XmlDocument5.fromString(xml);
       try {
         const schemaContent = await loadSchema(schemaPath);
-        const schemaDoc = XmlDocument4.fromString(schemaContent);
+        const schemaDoc = XmlDocument5.fromString(schemaContent);
         try {
           const validator = LibRelaxNGValidator.fromDoc(schemaDoc);
           try {
@@ -11975,6 +12429,73 @@ var EpubCheck = class _EpubCheck {
         location: { path: opfPath }
       });
     }
+    if (profile === "dict" && context.packageDocument) {
+      const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+      const manifestByPath = /* @__PURE__ */ new Map();
+      for (const item of context.packageDocument.manifest) {
+        manifestByPath.set(resolveManifestHref(opfDir, item.href), item);
+      }
+      const dictPaths = features.dictionaryContentPaths ?? /* @__PURE__ */ new Set();
+      for (const coll of context.packageDocument.collections) {
+        if (coll.role !== "dictionary") continue;
+        const hasDictContent = coll.links.some((href) => {
+          const full = resolveManifestHref(opfDir, href);
+          const item = manifestByPath.get(full);
+          return item?.mediaType === "application/xhtml+xml" && dictPaths.has(full);
+        });
+        if (!hasDictContent) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_078,
+            message: 'An EPUB Dictionary must contain at least one Content Document with dictionary content (epub:type "dictionary")',
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Mirrors ../epubcheck/src/main/resources/com/adobe/epubcheck/schema/30/edupub/
+   *   edu-ocf-metadata.sch (META-INF/metadata.xml) and edu-opf.sch (each OPF).
+   *
+   * Non-primary OPFs are otherwise unreached: runPipeline only runs OPFValidator
+   * on context.opfPath.
+   */
+  validateEdupubMultiRendition(context) {
+    if (context.options.profile !== "edupub") return;
+    if (context.rootfiles.length <= 1) return;
+    const metadataPath = "META-INF/metadata.xml";
+    const metadataData = context.files.get(metadataPath);
+    if (metadataData) {
+      const content = typeof metadataData === "string" ? metadataData : new TextDecoder().decode(metadataData);
+      const stripped = stripXmlComments(content);
+      if (!/<dc:type\b[^>]*>\s*edupub\s*<\/dc:type>/i.test(stripped)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'A dc:type element with the value "edupub" is required.',
+          location: { path: metadataPath }
+        });
+      }
+    }
+    const primary = context.opfPath;
+    for (const rootfile of context.rootfiles) {
+      if (rootfile.path === primary) continue;
+      if (rootfile.mediaType !== "application/oebps-package+xml") continue;
+      const path = rootfile.path.normalize("NFC");
+      const opfData = context.files.get(path);
+      if (!opfData) continue;
+      const xml = typeof opfData === "string" ? opfData : new TextDecoder().decode(opfData);
+      const pkg = parseOPF(xml);
+      const hasType = pkg.dcElements.some(
+        (dc) => dc.name === "type" && dc.value.trim() === "edupub"
+      );
+      if (!hasType) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'The dc:type identifier "edupub" is required.',
+          location: { path }
+        });
+      }
+    }
   }
   /**
    * Validate NCX navigation document (EPUB 2 always, EPUB 3 when NCX present)
@@ -12120,6 +12641,7 @@ var EpubCheck = class _EpubCheck {
     const contentValidator = new ContentValidator();
     contentValidator.validate(context, registry, refValidator);
     this.validateCrossDocumentFeatures(context);
+    this.validateEdupubMultiRendition(context);
     if (context.packageDocument) {
       this.validateNCX(context, registry);
     }