@likecoin/epubcheck-ts 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1904 @@
+'use strict';
+
+var libxml2Wasm = require('libxml2-wasm');
+var fflate = require('fflate');
+
+// src/content/validator.ts
+var ContentValidator = class {
+  validate(context) {
+    const packageDoc = context.packageDocument;
+    if (!packageDoc) {
+      return;
+    }
+    const opfPath = context.opfPath ?? "";
+    const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+    for (const item of packageDoc.manifest) {
+      if (item.mediaType === "application/xhtml+xml") {
+        const fullPath = opfDir ? `${opfDir}/${item.href}` : item.href;
+        this.validateXHTMLDocument(context, fullPath, item.id);
+      }
+    }
+  }
+  validateXHTMLDocument(context, path, itemId) {
+    const data = context.files.get(path);
+    if (!data) {
+      return;
+    }
+    const content = new TextDecoder().decode(data);
+    const packageDoc = context.packageDocument;
+    if (!packageDoc) {
+      return;
+    }
+    this.checkUnescapedAmpersands(context, path, content);
+    let doc = null;
+    try {
+      doc = libxml2Wasm.XmlDocument.fromString(content);
+    } catch (error) {
+      if (error instanceof Error) {
+        const message = this.normalizeErrorMessage(error.message);
+        context.messages.push({
+          id: "HTM-004",
+          severity: "error",
+          message,
+          location: { path }
+        });
+      }
+      return;
+    }
+    try {
+      const root = doc.root;
+      const nsDecls = root.nsDeclarations;
+      const hasXhtmlNamespace = nsDecls[""] === "http://www.w3.org/1999/xhtml" || Object.values(nsDecls).some((uri) => uri === "http://www.w3.org/1999/xhtml");
+      if (!hasXhtmlNamespace) {
+        context.messages.push({
+          id: "HTM-001",
+          severity: "error",
+          message: 'XHTML document must have html element with xmlns="http://www.w3.org/1999/xhtml"',
+          location: { path }
+        });
+      }
+      const head = root.get(".//html:head", { html: "http://www.w3.org/1999/xhtml" });
+      if (!head) {
+        context.messages.push({
+          id: "HTM-002",
+          severity: "error",
+          message: "XHTML document must have a head element",
+          location: { path }
+        });
+      }
+      const title = root.get(".//html:title", { html: "http://www.w3.org/1999/xhtml" });
+      if (!title) {
+        context.messages.push({
+          id: "HTM-003",
+          severity: "error",
+          message: "XHTML document must have a title element",
+          location: { path }
+        });
+      }
+      const body = root.get(".//html:body", { html: "http://www.w3.org/1999/xhtml" });
+      if (!body) {
+        context.messages.push({
+          id: "HTM-002",
+          severity: "error",
+          message: "XHTML document must have a body element",
+          location: { path }
+        });
+      }
+      const isNavItem = packageDoc.manifest.find(
+        (item) => item.id === itemId && item.properties?.includes("nav")
+      );
+      if (isNavItem) {
+        this.checkNavDocument(context, path, doc, root);
+      }
+    } finally {
+      doc.dispose();
+    }
+  }
+  normalizeErrorMessage(error) {
+    if (error.includes("Opening and ending tag mismatch")) {
+      return `Mismatched closing tag: ${error.replace("Opening and ending tag mismatch: ", "")}`;
+    }
+    if (error.includes("mismatch")) {
+      return `Mismatched closing tag: ${error}`;
+    }
+    return error;
+  }
+  checkUnescapedAmpersands(context, path, content) {
+    const ampersandPattern = /&(?!(?:[a-zA-Z][a-zA-Z0-9]*|#\d+|#x[0-9a-fA-F]+);)/g;
+    if (ampersandPattern.test(content)) {
+      context.messages.push({
+        id: "HTM-012",
+        severity: "error",
+        message: "Unescaped ampersand",
+        location: { path }
+      });
+    }
+  }
+  checkNavDocument(context, path, doc, root) {
+    const nav = root.get(".//html:nav", { html: "http://www.w3.org/1999/xhtml" });
+    if (!nav) {
+      context.messages.push({
+        id: "NAV-001",
+        severity: "error",
+        message: "Navigation document must have a nav element",
+        location: { path }
+      });
+      return;
+    }
+    if (!("attrs" in nav)) {
+      return;
+    }
+    const epubTypeAttr = nav.attrs.find(
+      (attr) => attr.name === "type" && attr.prefix === "epub" && attr.namespaceUri === "http://www.idpf.org/2007/ops"
+    );
+    if (!epubTypeAttr?.value.includes("toc")) {
+      context.messages.push({
+        id: "NAV-001",
+        severity: "error",
+        message: 'Navigation document nav element must have epub:type="toc"',
+        location: { path }
+      });
+    }
+    const ol = nav.get(".//html:ol", { html: "http://www.w3.org/1999/xhtml" });
+    if (!ol) {
+      context.messages.push({
+        id: "NAV-002",
+        severity: "error",
+        message: "Navigation document toc nav must contain an ol element",
+        location: { path }
+      });
+    }
+  }
+};
+
+// src/core/report.ts
+function buildReport(messages, version, elapsedMs) {
+  const counts = countBySeverity(messages);
+  return {
+    valid: counts.fatal === 0 && counts.error === 0,
+    messages,
+    fatalCount: counts.fatal,
+    errorCount: counts.error,
+    warningCount: counts.warning,
+    infoCount: counts.info,
+    usageCount: counts.usage,
+    version,
+    elapsedMs
+  };
+}
+function countBySeverity(messages) {
+  const counts = {
+    fatal: 0,
+    error: 0,
+    warning: 0,
+    info: 0,
+    usage: 0
+  };
+  for (const msg of messages) {
+    counts[msg.severity]++;
+  }
+  return counts;
+}
+function filterBySeverity(messages, severity) {
+  return messages.filter((msg) => msg.severity === severity);
+}
+function filterByPath(messages, path) {
+  return messages.filter((msg) => msg.location?.path === path);
+}
+function formatMessages(messages) {
+  return messages.map((msg) => {
+    const loc = msg.location;
+    const position = loc ? `${loc.path}${loc.line !== void 0 ? `:${String(loc.line)}` : ""}${loc.column !== void 0 ? `:${String(loc.column)}` : ""}` : "";
+    return `${msg.severity.toUpperCase()}(${msg.id}): ${msg.message}${position ? ` [${position}]` : ""}`;
+  }).join("\n");
+}
+function toJSONReport(result) {
+  return JSON.stringify(
+    {
+      checker: {
+        name: "epubcheck-ts",
+        version: "0.1.0"
+      },
+      publication: {
+        version: result.version
+      },
+      messages: result.messages.map((msg) => ({
+        ID: msg.id,
+        severity: msg.severity,
+        message: msg.message,
+        ...msg.location && {
+          locations: [
+            {
+              path: msg.location.path,
+              line: msg.location.line ?? -1,
+              column: msg.location.column ?? -1,
+              context: msg.location.context
+            }
+          ]
+        },
+        ...msg.suggestion && { suggestion: msg.suggestion }
+      })),
+      fatals: result.fatalCount,
+      errors: result.errorCount,
+      warnings: result.warningCount,
+      infos: result.infoCount,
+      usages: result.usageCount,
+      elapsedTime: result.elapsedMs
+    },
+    null,
+    2
+  );
+}
+var NCXValidator = class {
+  /**
+   * Validate NCX document
+   */
+  validate(context, ncxContent, ncxPath) {
+    let doc = null;
+    try {
+      doc = libxml2Wasm.XmlDocument.fromString(ncxContent);
+    } catch (error) {
+      if (error instanceof Error) {
+        context.messages.push({
+          id: "NCX-002",
+          severity: "error",
+          message: `NCX document is not well-formed: ${error.message}`,
+          location: { path: ncxPath }
+        });
+      }
+      return;
+    }
+    try {
+      const root = doc.root;
+      if (root.name !== "ncx") {
+        context.messages.push({
+          id: "NCX-001",
+          severity: "error",
+          message: "NCX document must have ncx as root element",
+          location: { path: ncxPath }
+        });
+        return;
+      }
+      const ns = root.nsDeclarations[""];
+      if (ns !== "http://www.daisy.org/z3986/2005/ncx/") {
+        context.messages.push({
+          id: "NCX-001",
+          severity: "error",
+          message: "NCX document must use namespace http://www.daisy.org/z3986/2005/ncx/",
+          location: { path: ncxPath }
+        });
+      }
+      this.checkUid(context, root, ncxPath);
+      this.checkNavMap(context, root, ncxPath);
+    } finally {
+      doc.dispose();
+    }
+  }
+  /**
+   * Check for dtb:uid meta element and validate it
+   * Note: dtb:uid is recommended but not strictly required by the NCX spec.
+   * The original epubcheck does not report an error if it's missing.
+   */
+  checkUid(context, root, path) {
+    const uidMeta = root.get('.//ncx:head/ncx:meta[@name="dtb:uid"]', {
+      ncx: "http://www.daisy.org/z3986/2005/ncx/"
+    });
+    if (!uidMeta) {
+      return;
+    }
+    const uidElement = uidMeta;
+    const uidAttr = uidElement.attr("content");
+    const uidContent = uidAttr?.value;
+    if (!uidContent || uidContent.trim() === "") {
+      context.messages.push({
+        id: "NCX-003",
+        severity: "warning",
+        message: "NCX dtb:uid meta content should not be empty",
+        location: { path }
+      });
+      return;
+    }
+    context.ncxUid = uidContent.trim();
+  }
+  /**
+   * Check for navMap element
+   */
+  checkNavMap(context, root, path) {
+    const navMapNode = root.get(".//ncx:navMap", { ncx: "http://www.daisy.org/z3986/2005/ncx/" });
+    if (!navMapNode) {
+      context.messages.push({
+        id: "NCX-001",
+        severity: "error",
+        message: "NCX document must have a navMap element",
+        location: { path }
+      });
+    }
+  }
+};
+var ZipReader = class _ZipReader {
+  files;
+  _paths;
+  _originalOrder;
+  constructor(files, originalOrder) {
+    this.files = files;
+    this._originalOrder = originalOrder;
+    this._paths = Object.keys(files).sort();
+  }
+  /**
+   * Open a ZIP file from binary data
+   */
+  static open(data) {
+    const files = fflate.unzipSync(data);
+    const originalOrder = Object.keys(files);
+    return new _ZipReader(files, originalOrder);
+  }
+  /**
+   * Get all file paths in the ZIP (sorted alphabetically)
+   */
+  get paths() {
+    return this._paths;
+  }
+  /**
+   * Get file paths in original ZIP order
+   */
+  get originalOrder() {
+    return this._originalOrder;
+  }
+  /**
+   * Check if a file exists in the ZIP
+   */
+  has(path) {
+    return path in this.files;
+  }
+  /**
+   * Read a file as text (UTF-8)
+   */
+  readText(path) {
+    const data = this.files[path];
+    if (!data) {
+      return void 0;
+    }
+    return fflate.strFromU8(data);
+  }
+  /**
+   * Read a file as binary data
+   */
+  readBinary(path) {
+    return this.files[path];
+  }
+  /**
+   * Get the size of a file in bytes
+   */
+  getSize(path) {
+    return this.files[path]?.length;
+  }
+  /**
+   * List files in a directory
+   */
+  listDirectory(dirPath) {
+    const prefix = dirPath.endsWith("/") ? dirPath : `${dirPath}/`;
+    return this._paths.filter((p) => p.startsWith(prefix));
+  }
+};
+
+// src/ocf/validator.ts
+var EPUB_MIMETYPE = "application/epub+zip";
+var OCFValidator = class {
+  /**
+   * Validate the OCF container
+   */
+  validate(context) {
+    let zip;
+    try {
+      zip = ZipReader.open(context.data);
+    } catch (error) {
+      context.messages.push({
+        id: "PKG-001",
+        severity: "fatal",
+        message: `Failed to open EPUB file: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+      return;
+    }
+    for (const path of zip.paths) {
+      const data = zip.readBinary(path);
+      if (data) {
+        context.files.set(path, data);
+      }
+    }
+    this.validateMimetype(zip, context.messages);
+    this.validateContainer(zip, context);
+    this.validateMetaInf(zip, context.messages);
+  }
+  /**
+   * Validate the mimetype file
+   *
+   * Requirements:
+   * - Must exist
+   * - Must be first file in ZIP
+   * - Must be uncompressed
+   * - Must contain exactly "application/epub+zip"
+   */
+  validateMimetype(zip, messages) {
+    if (!zip.has("mimetype")) {
+      messages.push({
+        id: "PKG-006",
+        severity: "error",
+        message: "Missing mimetype file",
+        location: { path: "mimetype" }
+      });
+      return;
+    }
+    const originalOrder = zip.originalOrder;
+    if (originalOrder.length > 0 && originalOrder[0] !== "mimetype") {
+      messages.push({
+        id: "PKG-005",
+        severity: "error",
+        message: "The mimetype file must be the first file in the ZIP archive",
+        location: { path: "mimetype" }
+      });
+    }
+    const content = zip.readText("mimetype");
+    if (content === void 0) {
+      messages.push({
+        id: "PKG-006",
+        severity: "error",
+        message: "Could not read mimetype file",
+        location: { path: "mimetype" }
+      });
+      return;
+    }
+    const trimmed = content.trim();
+    if (trimmed !== EPUB_MIMETYPE) {
+      messages.push({
+        id: "PKG-007",
+        severity: "error",
+        message: `Mimetype file must contain "${EPUB_MIMETYPE}", found "${trimmed}"`,
+        location: { path: "mimetype" }
+      });
+    }
+    if (content !== EPUB_MIMETYPE) {
+      messages.push({
+        id: "PKG-008",
+        severity: "warning",
+        message: "Mimetype file should not contain leading/trailing whitespace or newlines",
+        location: { path: "mimetype" }
+      });
+    }
+  }
+  /**
+   * Validate META-INF/container.xml
+   */
+  validateContainer(zip, context) {
+    const containerPath = "META-INF/container.xml";
+    if (!zip.has(containerPath)) {
+      context.messages.push({
+        id: "PKG-003",
+        severity: "fatal",
+        message: "Missing META-INF/container.xml",
+        location: { path: containerPath }
+      });
+      return;
+    }
+    const content = zip.readText(containerPath);
+    if (!content) {
+      context.messages.push({
+        id: "PKG-003",
+        severity: "fatal",
+        message: "Could not read META-INF/container.xml",
+        location: { path: containerPath }
+      });
+      return;
+    }
+    const rootfileMatches = content.matchAll(
+      /<rootfile[^>]+full-path=["']([^"']+)["'][^>]*media-type=["']([^"']+)["'][^>]*\/?>/g
+    );
+    for (const match of rootfileMatches) {
+      const [, path, mediaType] = match;
+      if (path && mediaType) {
+        context.rootfiles.push({ path, mediaType });
+        if (!context.opfPath && mediaType === "application/oebps-package+xml") {
+          context.opfPath = path;
+        }
+      }
+    }
+    const altMatches = content.matchAll(
+      /<rootfile[^>]+media-type=["']([^"']+)["'][^>]*full-path=["']([^"']+)["'][^>]*\/?>/g
+    );
+    for (const match of altMatches) {
+      const [, mediaType, path] = match;
+      if (path && mediaType) {
+        const exists = context.rootfiles.some((r) => r.path === path);
+        if (!exists) {
+          context.rootfiles.push({ path, mediaType });
+          if (!context.opfPath && mediaType === "application/oebps-package+xml") {
+            context.opfPath = path;
+          }
+        }
+      }
+    }
+    if (context.rootfiles.length === 0) {
+      context.messages.push({
+        id: "PKG-004",
+        severity: "fatal",
+        message: "No rootfile found in container.xml",
+        location: { path: containerPath }
+      });
+    }
+    for (const rootfile of context.rootfiles) {
+      if (!zip.has(rootfile.path)) {
+        context.messages.push({
+          id: "PKG-010",
+          severity: "error",
+          message: `Rootfile "${rootfile.path}" not found in EPUB`,
+          location: { path: containerPath }
+        });
+      }
+    }
+  }
+  /**
+   * Validate META-INF directory
+   */
+  validateMetaInf(zip, messages) {
+    const metaInfFiles = zip.listDirectory("META-INF");
+    if (metaInfFiles.length === 0) {
+      messages.push({
+        id: "PKG-002",
+        severity: "error",
+        message: "Missing META-INF directory",
+        location: { path: "META-INF/" }
+      });
+    }
+  }
+};
+
+// src/opf/parser.ts
+function parseOPF(xml) {
+  const packageRegex = /<package[^>]*\sversion=["']([^"']+)["'][^>]*(?:\sunique-identifier=["']([^"']+)["'])?[^>]*>/;
+  const packageRegexAlt = /<package[^>]*\sunique-identifier=["']([^"']+)["'][^>]*(?:\sversion=["']([^"']+)["'])?[^>]*>/;
+  const packageMatch = packageRegex.exec(xml);
+  const packageMatchAlt = packageRegexAlt.exec(xml);
+  let version = "3.0";
+  let uniqueIdentifier = "";
+  if (packageMatch?.[1]) {
+    version = normalizeVersion(packageMatch[1]);
+    uniqueIdentifier = packageMatch[2] ?? "";
+  }
+  if (!uniqueIdentifier && packageMatchAlt?.[1]) {
+    uniqueIdentifier = packageMatchAlt[1];
+    if (!packageMatch) {
+      version = normalizeVersion(packageMatchAlt[2] ?? "3.0");
+    }
+  }
+  const prefixes = parsePrefixes(xml);
+  const dirRegex = /<package[^>]*\sdir=["']([^"']+)["']/;
+  const dirMatch = dirRegex.exec(xml);
+  const metadataSection = extractSection(xml, "metadata");
+  const dcElements = parseDCElements(metadataSection);
+  const metaElements = parseMetaElements(metadataSection);
+  const linkElements = parseLinkElements(metadataSection);
+  const manifestSection = extractSection(xml, "manifest");
+  const manifest = parseManifestItems(manifestSection);
+  const spineSection = extractSection(xml, "spine");
+  const spineAttrs = extractElementAttributes(xml, "spine");
+  const spineResult = parseSpine(spineSection, spineAttrs);
+  const guideSection = extractSection(xml, "guide");
+  const guide = parseGuide(guideSection);
+  const result = {
+    version,
+    uniqueIdentifier,
+    dcElements,
+    metaElements,
+    linkElements,
+    manifest,
+    spine: spineResult.spine,
+    guide
+  };
+  if (Object.keys(prefixes).length > 0) {
+    result.prefixes = prefixes;
+  }
+  if (dirMatch?.[1]) {
+    result.dir = dirMatch[1];
+  }
+  if (spineResult.toc) {
+    result.spineToc = spineResult.toc;
+  }
+  if (spineResult.pageProgressionDirection) {
+    result.pageProgressionDirection = spineResult.pageProgressionDirection;
+  }
+  return result;
+}
+function normalizeVersion(versionStr) {
+  const v = versionStr.trim();
+  if (v === "2.0" || v === "2") return "2.0";
+  if (v === "3.0" || v === "3") return "3.0";
+  if (v === "3.1") return "3.1";
+  if (v === "3.2") return "3.2";
+  if (v === "3.3") return "3.3";
+  return "3.0";
+}
+function parsePrefixes(xml) {
+  const prefixes = {};
+  const prefixRegex = /<package[^>]*\sprefix=["']([^"']+)["']/;
+  const prefixMatch = prefixRegex.exec(xml);
+  if (prefixMatch?.[1]) {
+    const prefixStr = prefixMatch[1];
+    const parts = prefixStr.split(/\s+/);
+    for (let i = 0; i < parts.length - 1; i += 2) {
+      const prefix = parts[i]?.replace(/:$/, "");
+      const uri = parts[i + 1];
+      if (prefix && uri) {
+        prefixes[prefix] = uri;
+      }
+    }
+  }
+  return prefixes;
+}
+function extractSection(xml, tagName) {
+  const regex = new RegExp(`<(?:opf:)?${tagName}[^>]*>([\\s\\S]*?)</(?:opf:)?${tagName}>`, "i");
+  const match = regex.exec(xml);
+  return match?.[1] ?? "";
+}
+function extractElementAttributes(xml, tagName) {
+  const regex = new RegExp(`<(?:opf:)?${tagName}([^>]*)>`, "i");
+  const match = regex.exec(xml);
+  if (match?.[1]) {
+    return parseAttributes(match[1]);
+  }
+  return {};
+}
+function parseDCElements(metadataXml) {
+  const elements = [];
+  const dcRegex = /<dc:(\w+)([^>]*)>([^<]*)<\/dc:\1>/g;
+  let match;
+  while ((match = dcRegex.exec(metadataXml)) !== null) {
+    const name = match[1];
+    const attrsStr = match[2] ?? "";
+    const value = match[3] ?? "";
+    if (!name) continue;
+    const attrs = parseAttributes(attrsStr);
+    const id = attrs.id;
+    delete attrs.id;
+    const element = {
+      name,
+      value: decodeXmlEntities(value.trim())
+    };
+    if (id) {
+      element.id = id;
+    }
+    if (Object.keys(attrs).length > 0) {
+      element.attributes = attrs;
+    }
+    elements.push(element);
+  }
+  return elements;
+}
+function parseMetaElements(metadataXml) {
+  const elements = [];
+  const metaRegex = /<meta([^>]*property=["'][^"']+["'][^>]*)>([^<]*)<\/meta>/g;
+  let match;
+  while ((match = metaRegex.exec(metadataXml)) !== null) {
+    const attrsStr = match[1] ?? "";
+    const value = match[2] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const property = attrs.property;
+    if (property) {
+      const element = {
+        property,
+        value: decodeXmlEntities(value.trim())
+      };
+      if (attrs.refines) {
+        element.refines = attrs.refines;
+      }
+      if (attrs.scheme) {
+        element.scheme = attrs.scheme;
+      }
+      if (attrs.id) {
+        element.id = attrs.id;
+      }
+      elements.push(element);
+    }
+  }
+  return elements;
+}
+function parseLinkElements(metadataXml) {
+  const elements = [];
+  const linkRegex = /<link([^>]+)\/?\s*>/g;
+  let match;
+  while ((match = linkRegex.exec(metadataXml)) !== null) {
+    const attrsStr = match[1] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const rel = attrs.rel;
+    const href = attrs.href;
+    if (rel && href) {
+      const element = {
+        rel,
+        href
+      };
+      if (attrs["media-type"]) {
+        element.mediaType = attrs["media-type"];
+      }
+      if (attrs.refines) {
+        element.refines = attrs.refines;
+      }
+      if (attrs.properties) {
+        element.properties = attrs.properties.split(/\s+/);
+      }
+      if (attrs.id) {
+        element.id = attrs.id;
+      }
+      elements.push(element);
+    }
+  }
+  return elements;
+}
+function parseManifestItems(manifestXml) {
+  const items = [];
+  const itemRegex = /<item([^>]+)\/?\s*>/g;
+  let match;
+  while ((match = itemRegex.exec(manifestXml)) !== null) {
+    const attrsStr = match[1] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const id = attrs.id;
+    const href = attrs.href;
+    const mediaType = attrs["media-type"];
+    if (id && href && mediaType) {
+      const item = {
+        id,
+        href: decodeXmlEntities(href),
+        mediaType
+      };
+      if (attrs.fallback) {
+        item.fallback = attrs.fallback;
+      }
+      if (attrs["media-overlay"]) {
+        item.mediaOverlay = attrs["media-overlay"];
+      }
+      if (attrs.properties) {
+        item.properties = attrs.properties.split(/\s+/);
+      }
+      items.push(item);
+    }
+  }
+  return items;
+}
+function parseSpine(spineXml, spineAttrs) {
+  const spine = [];
+  const toc = spineAttrs.toc ?? null;
+  const ppdRaw = spineAttrs["page-progression-direction"];
+  const ppd = ppdRaw === "ltr" || ppdRaw === "rtl" || ppdRaw === "default" ? ppdRaw : null;
+  const itemrefRegex = /<itemref([^>]+)\/?\s*>/g;
+  let match;
+  while ((match = itemrefRegex.exec(spineXml)) !== null) {
+    const attrsStr = match[1] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const idref = attrs.idref;
+    if (idref) {
+      const itemref = {
+        idref,
+        linear: attrs.linear !== "no"
+      };
+      if (attrs.properties) {
+        itemref.properties = attrs.properties.split(/\s+/);
+      }
+      spine.push(itemref);
+    }
+  }
+  return { spine, toc, pageProgressionDirection: ppd };
+}
+function parseGuide(guideXml) {
+  const references = [];
+  const refRegex = /<reference([^>]+)\/?\s*>/g;
+  let match;
+  while ((match = refRegex.exec(guideXml)) !== null) {
+    const attrsStr = match[1] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const type = attrs.type;
+    const href = attrs.href;
+    if (type && href) {
+      const ref = {
+        type,
+        href: decodeXmlEntities(href)
+      };
+      if (attrs.title) {
+        ref.title = attrs.title;
+      }
+      references.push(ref);
+    }
+  }
+  return references;
+}
+function parseAttributes(attrsStr) {
+  const attrs = {};
+  const attrRegex = /(\S+)=["']([^"']*)["']/g;
+  let match;
+  while ((match = attrRegex.exec(attrsStr)) !== null) {
+    const name = match[1];
+    const value = match[2];
+    if (name !== void 0 && value !== void 0) {
+      const colonIdx = name.indexOf(":");
+      const localName = colonIdx >= 0 ? name.slice(colonIdx + 1) : name;
+      attrs[localName] = value;
+    }
+  }
+  return attrs;
+}
+function decodeXmlEntities(str) {
+  return str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
+}
+
+// src/opf/types.ts
+var ITEM_PROPERTIES = /* @__PURE__ */ new Set([
+  "cover-image",
+  "mathml",
+  "nav",
+  "remote-resources",
+  "scripted",
+  "svg",
+  "switch"
+]);
+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/opf/validator.ts
+var OPFValidator = class {
+  packageDoc = null;
+  manifestById = /* @__PURE__ */ new Map();
+  manifestByHref = /* @__PURE__ */ new Map();
+  /**
+   * Validate the OPF package document
+   */
+  validate(context) {
+    const opfPath = context.opfPath;
+    if (!opfPath) {
+      context.messages.push({
+        id: "OPF-002",
+        severity: "fatal",
+        message: "No package document (OPF) path found in container.xml"
+      });
+      return;
+    }
+    const opfData = context.files.get(opfPath);
+    if (!opfData) {
+      context.messages.push({
+        id: "OPF-002",
+        severity: "fatal",
+        message: `Package document not found: ${opfPath}`,
+        location: { path: opfPath }
+      });
+      return;
+    }
+    const opfXml = new TextDecoder().decode(opfData);
+    try {
+      this.packageDoc = parseOPF(opfXml);
+    } catch (error) {
+      context.messages.push({
+        id: "OPF-001",
+        severity: "fatal",
+        message: `Failed to parse package document: ${error instanceof Error ? error.message : "Unknown error"}`,
+        location: { path: opfPath }
+      });
+      return;
+    }
+    context.version = this.packageDoc.version;
+    this.buildManifestMaps();
+    context.packageDocument = this.packageDoc;
+    this.validatePackageAttributes(context, opfPath);
+    this.validateMetadata(context, opfPath);
+    this.validateManifest(context, opfPath);
+    this.validateSpine(context, opfPath);
+    this.validateFallbackChains(context, opfPath);
+    if (this.packageDoc.version === "2.0") {
+      this.validateGuide(context, opfPath);
+    }
+  }
+  /**
+   * Build lookup maps for manifest items
+   */
+  buildManifestMaps() {
+    if (!this.packageDoc) return;
+    for (const item of this.packageDoc.manifest) {
+      this.manifestById.set(item.id, item);
+      if (this.manifestByHref.has(item.href)) ;
+      this.manifestByHref.set(item.href, item);
+    }
+  }
+  /**
+   * Validate package element attributes
+   */
+  validatePackageAttributes(context, opfPath) {
+    if (!this.packageDoc) return;
+    if (!this.packageDoc.uniqueIdentifier) {
+      context.messages.push({
+        id: "OPF-048",
+        severity: "error",
+        message: "Package element is missing required unique-identifier attribute",
+        location: { path: opfPath }
+      });
+    } else {
+      const refId = this.packageDoc.uniqueIdentifier;
+      const matchingDc = this.packageDoc.dcElements.find(
+        (dc) => dc.name === "identifier" && dc.id === refId
+      );
+      if (!matchingDc) {
+        context.messages.push({
+          id: "OPF-030",
+          severity: "error",
+          message: `unique-identifier "${refId}" does not reference an existing dc:identifier`,
+          location: { path: opfPath }
+        });
+      }
+    }
+  }
+  /**
+   * Validate metadata section
+   */
+  validateMetadata(context, opfPath) {
+    if (!this.packageDoc) return;
+    const dcElements = this.packageDoc.dcElements;
+    const hasIdentifier = dcElements.some((dc) => dc.name === "identifier");
+    const hasTitle = dcElements.some((dc) => dc.name === "title");
+    const hasLanguage = dcElements.some((dc) => dc.name === "language");
+    if (!hasIdentifier) {
+      context.messages.push({
+        id: "OPF-015",
+        severity: "error",
+        message: "Metadata must include at least one dc:identifier element",
+        location: { path: opfPath }
+      });
+    }
+    if (!hasTitle) {
+      context.messages.push({
+        id: "OPF-016",
+        severity: "error",
+        message: "Metadata must include at least one dc:title element",
+        location: { path: opfPath }
+      });
+    }
+    if (!hasLanguage) {
+      context.messages.push({
+        id: "OPF-017",
+        severity: "error",
+        message: "Metadata must include at least one dc:language element",
+        location: { path: opfPath }
+      });
+    }
+    for (const dc of dcElements) {
+      if (dc.name === "language" && dc.value) {
+        if (!isValidLanguageTag(dc.value)) {
+          context.messages.push({
+            id: "OPF-092",
+            severity: "error",
+            message: `Invalid language tag: "${dc.value}"`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+    if (this.packageDoc.version !== "2.0") {
+      const hasModified = this.packageDoc.metaElements.some(
+        (meta) => meta.property === "dcterms:modified"
+      );
+      if (!hasModified) {
+        context.messages.push({
+          id: "OPF-054",
+          severity: "error",
+          message: "EPUB 3 metadata must include a dcterms:modified meta element",
+          location: { path: opfPath }
+        });
+      }
+    }
+  }
+  /**
+   * Validate manifest section
+   */
+  validateManifest(context, opfPath) {
+    if (!this.packageDoc) return;
+    const seenIds = /* @__PURE__ */ new Set();
+    const seenHrefs = /* @__PURE__ */ new Set();
+    for (const item of this.packageDoc.manifest) {
+      if (seenIds.has(item.id)) {
+        context.messages.push({
+          id: "OPF-074",
+          severity: "error",
+          message: `Duplicate manifest item id: "${item.id}"`,
+          location: { path: opfPath }
+        });
+      }
+      seenIds.add(item.id);
+      if (seenHrefs.has(item.href)) {
+        context.messages.push({
+          id: "OPF-074",
+          severity: "error",
+          message: `Duplicate manifest item href: "${item.href}"`,
+          location: { path: opfPath }
+        });
+      }
+      seenHrefs.add(item.href);
+      const fullPath = resolvePath(opfPath, item.href);
+      if (!context.files.has(fullPath) && !item.href.startsWith("http")) {
+        context.messages.push({
+          id: "OPF-010",
+          severity: "error",
+          message: `Manifest item "${item.id}" references missing file: ${item.href}`,
+          location: { path: opfPath }
+        });
+      }
+      if (this.packageDoc.version !== "2.0" && item.properties) {
+        for (const prop of item.properties) {
+          if (!ITEM_PROPERTIES.has(prop) && !prop.includes(":")) {
+            context.messages.push({
+              id: "OPF-012",
+              severity: "warning",
+              message: `Unknown item property: "${prop}" on item "${item.id}"`,
+              location: { path: opfPath }
+            });
+          }
+        }
+        if (item.properties.includes("nav")) {
+          if (item.mediaType !== "application/xhtml+xml") {
+            context.messages.push({
+              id: "OPF-012",
+              severity: "error",
+              message: `Item with "nav" property must be XHTML, found: ${item.mediaType}`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+      if (this.packageDoc.version !== "2.0" && item.href.includes("#")) {
+        context.messages.push({
+          id: "OPF-091",
+          severity: "error",
+          message: `Manifest item href must not contain fragment identifier: "${item.href}"`,
+          location: { path: opfPath }
+        });
+      }
+    }
+    if (this.packageDoc.version !== "2.0") {
+      const hasNav = this.packageDoc.manifest.some((item) => item.properties?.includes("nav"));
+      if (!hasNav) {
+        context.messages.push({
+          id: "OPF-013",
+          severity: "error",
+          message: 'EPUB 3 must have exactly one manifest item with the "nav" property',
+          location: { path: opfPath }
+        });
+      }
+    }
+  }
+  /**
+   * Validate spine section
+   */
+  validateSpine(context, opfPath) {
+    if (!this.packageDoc) return;
+    if (this.packageDoc.spine.length === 0) {
+      context.messages.push({
+        id: "OPF-033",
+        severity: "error",
+        message: "Spine must contain at least one itemref",
+        location: { path: opfPath }
+      });
+      return;
+    }
+    const hasLinear = this.packageDoc.spine.some((ref) => ref.linear);
+    if (!hasLinear) {
+      context.messages.push({
+        id: "OPF-033",
+        severity: "error",
+        message: "Spine must contain at least one linear itemref",
+        location: { path: opfPath }
+      });
+    }
+    if (this.packageDoc.version === "2.0") {
+      const ncxId = this.packageDoc.spineToc;
+      if (!ncxId) {
+        context.messages.push({
+          id: "OPF-050",
+          severity: "warning",
+          message: "EPUB 2 spine should have a toc attribute referencing the NCX",
+          location: { path: opfPath }
+        });
+      } else {
+        const ncxItem = this.manifestById.get(ncxId);
+        if (!ncxItem) {
+          context.messages.push({
+            id: "OPF-049",
+            severity: "error",
+            message: `Spine toc attribute references non-existent item: "${ncxId}"`,
+            location: { path: opfPath }
+          });
+        } else if (ncxItem.mediaType !== "application/x-dtbncx+xml") {
+          context.messages.push({
+            id: "OPF-050",
+            severity: "error",
+            message: `NCX item must have media-type "application/x-dtbncx+xml", found: "${ncxItem.mediaType}"`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+    const seenIdrefs = /* @__PURE__ */ new Set();
+    for (const itemref of this.packageDoc.spine) {
+      const item = this.manifestById.get(itemref.idref);
+      if (!item) {
+        context.messages.push({
+          id: "OPF-049",
+          severity: "error",
+          message: `Spine itemref references non-existent manifest item: "${itemref.idref}"`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
+      if (this.packageDoc.version === "2.0" && seenIdrefs.has(itemref.idref)) {
+        context.messages.push({
+          id: "OPF-034",
+          severity: "error",
+          message: `Duplicate spine itemref: "${itemref.idref}"`,
+          location: { path: opfPath }
+        });
+      }
+      seenIdrefs.add(itemref.idref);
+      if (!isSpineMediaType(item.mediaType) && !item.fallback) {
+        context.messages.push({
+          id: "OPF-043",
+          severity: "error",
+          message: `Spine item "${item.id}" has non-standard media type "${item.mediaType}" without fallback`,
+          location: { path: opfPath }
+        });
+      }
+      if (this.packageDoc.version !== "2.0" && itemref.properties) {
+        for (const prop of itemref.properties) {
+          if (!SPINE_PROPERTIES.has(prop) && !prop.includes(":")) {
+            context.messages.push({
+              id: "OPF-012",
+              severity: "warning",
+              message: `Unknown spine itemref property: "${prop}"`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Validate fallback chains
+   */
+  validateFallbackChains(context, opfPath) {
+    if (!this.packageDoc) return;
+    for (const item of this.packageDoc.manifest) {
+      if (item.fallback) {
+        const visited = /* @__PURE__ */ new Set();
+        let currentFallback = item.fallback;
+        while (currentFallback) {
+          if (visited.has(currentFallback)) {
+            context.messages.push({
+              id: "OPF-045",
+              severity: "error",
+              message: `Circular fallback chain detected starting from item "${item.id}"`,
+              location: { path: opfPath }
+            });
+            break;
+          }
+          visited.add(currentFallback);
+          const fallbackItem = this.manifestById.get(currentFallback);
+          if (!fallbackItem) {
+            context.messages.push({
+              id: "OPF-040",
+              severity: "error",
+              message: `Fallback item "${currentFallback}" not found in manifest`,
+              location: { path: opfPath }
+            });
+            break;
+          }
+          currentFallback = fallbackItem.fallback;
+        }
+      }
+    }
+  }
+  /**
+   * Validate guide section (EPUB 2)
+   */
+  validateGuide(context, opfPath) {
+    if (!this.packageDoc) return;
+    for (const ref of this.packageDoc.guide) {
+      const hrefBase = ref.href.split("#")[0] ?? ref.href;
+      const fullPath = resolvePath(opfPath, hrefBase);
+      const found = Array.from(this.manifestByHref.entries()).some(([href]) => {
+        const itemFullPath = resolvePath(opfPath, href);
+        return itemFullPath === fullPath;
+      });
+      if (!found) {
+        context.messages.push({
+          id: "OPF-031",
+          severity: "error",
+          message: `Guide reference "${ref.type}" references item not in manifest: ${ref.href}`,
+          location: { path: opfPath }
+        });
+      }
+    }
+  }
+};
+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);
+}
+function resolvePath(basePath, relativePath) {
+  if (relativePath.startsWith("/")) {
+    return relativePath.slice(1);
+  }
+  const baseDir = basePath.includes("/") ? basePath.substring(0, basePath.lastIndexOf("/")) : "";
+  if (!baseDir) {
+    return relativePath;
+  }
+  const parts = baseDir.split("/");
+  const relParts = relativePath.split("/");
+  for (const part of relParts) {
+    if (part === "..") {
+      parts.pop();
+    } else if (part !== ".") {
+      parts.push(part);
+    }
+  }
+  return parts.join("/");
+}
+var COMPRESSED_SCHEMAS = {
+  "applications.rng": "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",
+  "aria.rng": "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",
+  "block.rng": "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",
+  "common.rng": "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",
+  "container.rng": "H4sIAHZNcGkCA41SvW6DMBCeyVMg9sRJu1kOeYFEHbp0vZALWMI2Oh+FvH0xf6VUkeLJvvv+fLY6taaMv5G8dvaYHHb75JRuVE5gDFDcNa0/JgVzJYUgLKG1+c5RLqwXnqnOuCYUgbaJpxUYNVnpwGsvLRj0kjPpKrQ3l9UGLcteWGbOMmiLtGDfgIEfFZ71lYAes3nTNLvmvfd+2+8P4uty/swKNLCdGD5JN5HyDMTdJlJYYvCKQ4Jj8uuVdmZR1wdm0teacUSMU5j6kWJsWUxoMcOD+FqdnOO7LocMoe0sftDF0YB+ig/wwe1/nntdltsKuFiA5lAz60+uZ1IGbxq2YUivaw2VMXaYQlh9bXG3qboCrs6q+yv9qygx/qz0B2uCDqV5AgAA",
+  "core-scripting.rng": "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",
+  "data.rng": "H4sIAHZNcGkCA8VYTY/aMBC98yvcrLQ3kvZQqWIDq2rbbg9sD4VKvZpgEquxHRmHhX/fsROIyQcBJRHc8IzfPM+8Fwf85z2L0Y7ILRV86nxyPzqI8ECsKQ+nzp/lj/EX53k28kOJGcMSQTbfTvDUiZRKJp4nSYz3PHSFDD2+9QLBEqzoisZUHTzMuVDwVUDEIJvdTXu3SqaBSiXJctcYth4SMqcrieVh6jizEUL+h/EYPfTxQeOxAVyTDeUEcczI1FGUEZfEhJliEMWTtQhSRnh2jhn6/X3+9S/69YoWQUQYRhsh0c/l2xx9nqCFTgrQN2CO3rD8lyYao/x58L0yalar76PV0F/C+SboMVZP+qSPoXpqIqObAEtWX/KWQIxyRWRM8I4cl2BRko3dRMo5kY7XnICVktsiwffKqL6XczBj8rI5NYwsA8v3VelZtUGhTPBKdZHos+O4lq+9x8WSYpv2+c7yMVp4Z13KtyqyVwb4bJNWxYtxEhgT1BYQpBNfBNSB+cAKwwpFRJJaRefcdSvdJJJ4C8Z2EKyuIAfCkaDBcbTlERkjVBlVjwFeJa3W0dpD71RF2tomHemO0lWqLE2egkOK88S3VaWnzF7lWkLtoNs6U53g76/vEp+jMo5jz1NL8Tpu+jZwdc64fDjQyBHuls6fOa9SzkQLv7R4oIvHzq3TUsh04ZLH9NWTeUmnXm8hnX21hQyLS84xCX0ZxgLrxScFnrvDcXpfk1TINDjEDmoM/YahX46mDrw1nRR6gxmsGd7VA4WiW/AZgY5e1P4iwDG8ob7iNMzvE7PnehOY9KtdkBG6ZIMsoy8f2Gi9GMECvM0J9kZGebMP2oC0i9xEiiSr3wnLJhWL936AIhpG/SAxvO+vT12wbFI6kaW59bo9yKpiuu5JVn/Rb2KB1c3PtLIuGxgUoQHrawk21C9CA9Y3ym0gYMWGnACotGkCp9CA9Y/ibuBwHh6ER8fr9T4//Kx7tkTJ9/I/gWaj/8VHiKo2EgAA",
+  "datatypes.rng": "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",
+  "embed.rng": "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",
+  "epub-mathml3-inc.rng": "H4sIAHZNcGkCA7VY23LbNhB9z1egzGNN0m4mU9uh5HHcdNIZ2/XUzkzfOhAIiRiTAAuAuvSpv9Hf65d0caFISqQsuVYeJAXE7p492D1YOrlaFjmaU6mY4KPgLDoNEOVEpIzPRsG3p5/D8+Bq/C6ZSVwUWCKuRkGmdXkZx4vFIlp8iIScxWcXF+fxHdaZ/bi7DRB4bW2VNMdLPrN7uYqVlhXRlaSxjZdijfWqpLdsIrFc9QX44fT0LP797vaRZLTAYW2hgvE7hJLvwhC+EHr/Fv+sJ/uBXDJojnMGEYEgNMGKpgh+6IwiZcEoNJWisAv3Ffqqgc6bjJJnKk+clwXTmX08FXkuFkAsIhnmM6ou3QaEQnQjuKZc1yGZgiD5CmFjAREZR5hzAVkDihDIbSy76z6IsgElBaYZMc8USumUceuqtkXoy8O3z+vQPwlSFfBDNb7t88dHAIQ1eJpUmiqEJa1xNVy9FfVhaE+UcZJXKUWZpNNRUAApRf4hhNVI8pk9dHfsiC4Be4q0QIRJwD83mdTlgQiQwUxlK+8YrBwPiOOCjoJ7wR3j11p7t7BlnWy9Ytb46h5MmhVYo0tCS91egkWuzD7bKEHc+6x/daC1oOhdexnAqsSEDngdbs2LeJlBWR5mZzsOCiqkhlL1CuOz01itONShYvuas7Sc1g5+jEW5YZfEm4wn8da5JFAy/nTrOohMG0DdrJ2BWfeIk9iVRauyoLEBgKt0hUroJeDBqYCrR9+hGoqvRDnQlJ+gZ5bntvUINJUNYPZDdZoq+7I0Xkw5DlRjd1NTjyQTjPSnqECBuGakw1Tr+UMLd8t1i4m28x4aBNwNkkErbuiMVTWrDx2V6U+sa9sk1uCkZTWJNrZ5kG1QSeyVoaP7N6IogNT1mTpVsH1vn4NMgPtLUwqNxHQAOg9GBODkigk8GAUMZFHmFM9pLTiiNNhwPoTf1ppB0UBvm3QSMdyGW9p6PGxKFXlUZofBg1O4NFfecXCBFTiwiFQEoUykvaFd//bL9XFgYclwNMvFBLdKcBDNjjqPCpHSPHLi24BxDVcD2aKDcU5lNAXVcdEPjKbmsz1imV3b3ut+euoOKwIuHjfk+ElIyIhX//79j0I2t48huAudKML9TFAqGaiGm25gchGVhC9NYYY0YE9QUmjo0LGZcoxWWh31g0+gxTPliObUjCIBPAeBJdjNLEZUMTj8+gQ7/Ra7CN+frKukYGPjn9tPMQbVSuGHGtfbnSCAQ6DuE1IURoyt2+tzNVPxQzXJGYlVJhZ/TKpZRGbsiqWji/OPF+/JOdAjEba+XFI4H5IWm2vkUe5fBgYv9KvEan1zbXWBlV9geoVUSQmbMrKp0m1tvuyF1ye8HlP32ml3SLfwNqaL4Y3rqntZ/CNfTjVvB5q1r+umiZuEhpuqz2kj0NvH1chNHWaX4qX9irLbSklyqBDtwah3WLfR/7iovfK88sRa5A6baB3Wb6X7xwEj898BAxgmXeqvYLIvX+/1LyrFr/JOyL7GMa9aMIU1ELq7X0KxgwXvsBmBvJ3fvmOWBE2vKDKjC1Sam5O338iDsdPn0L8sJrE1O9wNLkuQVUtl7FIIfQrfA7MbbjeH087QvgdZfac/QJT5bEjaMxnvk/5ZsXkH+oFQX5awYzVrn04erWMHgm0q38udPOBoU1LfqMH7DmJnl2+8xr1ds/chOXbHD3R6rQft98u3FIV2qkdWhn1Y7cqDScFndX9j/vrQnPEAkCT2f0Adv/sPYuZvzHIVAAA=",
+  "epub-nav-30.rnc": "H4sIAHZNcGkCA61TX2vbMBB/jj/F4UBJ2KIkzbotgRI2VvYyytgY7FWRFVtMlows1x1Jv/tOsmM7rUr3UD2I0/393e9OEAFAwve0khYUzXlZUMbhGuLM2mIzn9d1TeoV0SadL9fr9fw+s7mMXVTvzYtq9yhEJMXeB10uFh/muih9SATRGMavcaLxGODHzbdPv+H2K/xkGc8p7LWBm++/Pm/8Dbf0TqTUCq3gi2ZVzpUtEcTwYJ5XwuO7AxCKySrhEDtOZp6s2WpBjGIxHFoffxS9I9RaUyJxnUyUdnH2b8Gd40Pkbuw0NrzkNgabcTcsoYTvSu8HaayGOqMWhIWalm3gjiMnzYA2LqszAaZy3rRKHSXAdJ5r1QLY0VKwZrpPMSHUBv/kPEgk20Z/ca5nkpZl2GSFlTxsQgjPWPy2hU1i+VEFDYWjTtmgTSOf5mSZjM5s1AhKRF5IwYQlyEa7StFoNDoGXCVVSU7Nn/9wNVpykmg2Eyrh9y96FTTlUpT2RUermfOZbvGe+tVx63dFMk4TodJ2HjjELDW6KgiXPIcjZMtOuuykVSe966SrTnrvpdPOu/VwbWNmp3Y75V6HxuAWx8NFjoNLddElIEwr68Ifhmk7LQIP9LN923tq6Yf5GJjT99jwccCr/TaD6qgLAxgYME2vFW8ClcSgFD5cKRGqJZ4t1luugXqmSZEZ/JgqRfInk6c6/BjKK6dnZExP8Nql8WF7qWs49n1E/wAgI0XDAwYAAA==",
+  "epub-nav-30.rng": "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",
+  "epub-nav-30.sch": "H4sIAHZNcGkCA81XSXPbNhS++1e8sp1abE3RS7pYlZS4nW6H5tCm04OqyUAgJKIGAQYALamTH98HkJRIU5LV2JlEFxsk3va97y0cPl9lAu6YNlzJUXDRPw+ASaoSLhej4M9XP0XfBs/HJ0NDU5YRwMvSjILU2nwQx3mhRV9RQftKL+LEJCIu71mtZADwpmB6/T2XpbKVEfYyGJ+cAP6G0kCh+UbVcrnsL6+8novr6+t4ldpMBJBrNucrdwtP8XivKE/yuRe+PD//Jla52YqyvJg50VI2J9YyLYEno0CSu0jRQmsMmKFj7oK/pAvBgCpp2cqWtgczlawbV/w1YgzTFiwzeIuqQtpeP479dVQ9seqWSf4v671wLgzsOmdnp3+bL0/D0alV9HQawggugvGPK0KtWIOSDAJ8EQBKAxMsY9K2LLpfVhgLM+bCM/h+GJdePJ1rOVmwSHBjnYOfC/sdYNJ+K4TlOaKiaA2YATXveGdTjGGjoRXJ03sqiEwyom/NO3u60fCAp8PYUaKiX1xxaBelTE5kJFVkipkH4GFSNWLdhjitnjp1x7FOCcem82AMrzAwJ1dHUzJGSWQY0qYwLAFiIGXEVSXMlYa5IF2eVREY6EllIeVME01TTolwUPEFsdgwwFhdUFsgF0ME5p1h2+bhMGD/gxEVgkpU/5D7OApmMZKMIYieJ8jWOyIKPPfrTrP/7mtn9rVUOiMCfUk2shvvhFoyHVFimo6GladHGEixfe0ysHkUYZJp246TCb3ytvZPogh+SBm99enOuDEu9RuvADOh+axASkEUHaLbNhIstP1qkG1AJE3RGJeGJ0dUWsfhDiE3GirVBkyqCpF4VkuOswZ6nz67vgo7kihY8l+zXGmLBbDkNuXS9wCDqDuNGB+6uzWyq/8eBqdjl2W5Xfdq3YNBTeEONScdUffDuuv1gRv4rOJE6CLZefU41mGDqFXd5+9ezQ/Tran1Hml3apyGwfgGY0vZFm5YYkuaYy8rU7NNTINc+M4/QhPMt3WMGoKhL4tIzcFgxiimYZ8zWBbBY1oUl7eRIDMmjmlS3Va+vxGVLnUHlCcVNlgsskgwubAptuJ2Nqq3/ygue/23/dIAzxbxCyIsnvGv5qR0O8RUjXFCdAxhNsp6qqqiUZ+mHB4uPuLqBYN87HB8Cgj3j8UPiOIf6NT7x1CzN1E1u+9j2HDpIJoT11j2T1Gs557fT88aq+BZY7SG4fTwTpJykQwGX0wuphMsynnV+NKLt83TZet01To9a52+ap2+RuMYULfZ1miXncWmuAH5bfqstZC6NtIcRj43KbnDBrPZibAXoQ6uOzbmXLtMuvgekcLKTOSThGvH4VJA2GrAaqhqkGp4KmA+uor4pcLzCQrBHbtIusU1QjI8amv0fN/D9AeI3vpaKTdw/J776+b3l7++/HkAN7vGU2OFwoHUbBT1PlMB1MHTrzAE3NLlPm8EJMxQJhOCophBkOgUTvJ6cQ+Pp+iw+mwfn/wH3SbjRw8QAAA=",
+  "epub-prefix-attr.rng": "H4sIAHZNcGkCA62SzU7DMBCE732KxT0nLlxAUZIKpMIFIQRU4uom29RS/CPboenb4zhWJAoVl/gQydnZb8dj5+tetPCFxnIlC3KdrgigrFTNZVOQ7cdjckfW5SJvDBOCGfBqaTNWkINzOqPUYMt62aTKNFRaWimhmeM73nJ3okxK5fxW+Uogj92ou90EOB6PKa/1PhBuVqtbqrSNyktTrDNd5TqDgVouAPKrJIHlHAuSJABr3HOJIJnAggyOU238rz5lzpkw04tYVquqEyjHU5bwtnm+/4SXJ3ivDigY7JWBzev2IQtfGBEwIPiuc2gHys+1zOk5dZw19wn/sP/L3iUvkyLmMzbGVHzdb2OlZr7xpDGmV2PVEhopdMKExOkY+f/pp9JOF3BmZJBm87rJaXz75eIby+yB8S0DAAA=",
+  "epub-shared-inc.rng": "H4sIAHZNcGkCA61UTW/bMAy951dw7nWOtttgOCm2oVsHpMWwpcCuiszYwmwxkOgm+fel5PQjQZxTdZJA8vHx6Unl9a5r4RF9sORm2efppwzQGaqsq2fZw/JH/iW7nk/K2uuu0x4k24VCz7KGeVMo5bHVO1dPydfKBWWo22i2K9ta3ivtHLEcSSIJOVWP1Qb2veHeY8qdTwDKD3kOV++xIM9fAG9+P3wDbLFDx+E5YJ1p+wqh8bieZbjpVzl7W9fop97ViY1k6aIi08fCNNUc/twsvv6D+5/w1zTYaViTT/gFhEZ7rKDCtXU2SZCCqU/UOuLFdVWqU9Sh13vPfob+r2HocJZCqQ6ajOkTtpZNk+RRx+JqFu1WPeMleTeytbs85r7BONcndG1KC5fzeL/BU7gXStYxiofjcNBSbc0FZruGpeObimPApOU9MRbADcYb1n3LcHu3XEAYbFCRjC7eH64fIfSmAQ1GCyT5/UcIBFtMQBUB9R5WGBiYBn8InW2jGTr9X3ACuiD80MeCA+sDrtMdzjJ5dJ2QtM6JW7XbR/pjjv1OMpYTaKqwLeB2ebeAtdd1egxjVjQNWZN8kI6i1KFz7DSNT2lQ5yS6omo/Hj1ivW5p+5xVqtd+pRomlR9IHb6g+eQJakbrFLQEAAA=",
+  "epub-ssml-attrs.rng": "H4sIAHZNcGkCA62Ty27CMBBF93zFNKwTQ7toFSVBVKLd0AqVInXrJJPEUvyQ7TTw980TCQRtF3hhyfKd6+M7drDY8xK+URsmRejMvZkDKBKZMpGHzu7zxX1yFtEkyDXlnGpo1ML4NHQKa5VPiMaS7kXuSZ0TYUgiuaKWxaxk9kCoENI2S9nsdM59NaoqPhrUde2xVGWdw/1s9kikMqPSGF6eKOuHUTcn8xkxB2ELNGwsuIZlrK4SW2nsMKIJQHDnujC9xQDX7QxTzJhAEJRj6LRX9Fp6TxUetVZ3hzYq6qcyqTiKPpcIPlbr5Re8v8I2KZBTyKSG1Wb37HczbLdva2gNWFxZNK3H+ZgG5Ny1P+vWV7yAf4Z3jeSoGOJpk/FVMYTSCDRmw1ZKm8qDwj69TSEFWpas9kqjad+oQwZPcjTt4id9/r+1gpaqoDHa04ZcQhuV/wdcjhV/4QVk+ErR5AcF/5kBfAMAAA==",
+  "epub-svg-30.rnc": "H4sIAHZNcGkCA62QUWvCMBSF3/MrDiuMDWd8F4o4FCe0c8xt+Ji0iTYjTVyadg7nf1+iL927lxC45+Z8yQlJkFyjSJIAr/NsusHzAuuykjXH1jrMX94fx+cd648F7gbYPL3l2QMGyLmv8uwevQqcK72HKFPqVkjc0FFtxUju22J4qHyth023G9bh7lpTZ8obHAnQeO48UoRZ6MJKsOqkcyoQfCXBlGDg3jtVtD5IFk5+tcpJcHRcK4FNnmE5i6huR+NJGsS05wntEYdGjJcznCbkRELWqdb2G6yw4odBallL48GbAC0rpQXsFiz8olQ7syo+ZekZSOT/06gyRjr8pogcGjHowWPy8d7JrTr0I1gDFlAMzlp/hsZZg9sU0UEvjksS00zIH51Iw70qAgAA",
+  "epub-svg-30.rng": "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",
+  "epub-svg-30.sch": "H4sIAHZNcGkCAz2MSw4CIRAF95yC9H5o3RkDzM4T6AEM4AwJdI98jMeXjMa3eKuq0vM7J/kKpUYmA0d1ABnIsY+0GLhdL9MJZit0dWvIdzlgqgbW1rYz4tZLUuySU1wW9NUn/HKtMIGVY+J/OpJL3Qe5lvAwoDCzx+inTvHZgxoioN3JXdG/lBXiAzfNt9mkAAAA",
+  "epub-svg-forgiving-inc.rng": "H4sIAHZNcGkCA9VaX2/bNhB/76fgXKDYgFjKNgwbXCdFhmXFgC0p0nbYo2npLHOhSIGk7XiffkdSkiVZ9J8mD1UeDJtHHn/3h3fHY6bvnnJO1qA0k+Jq9H10OSIgEpkykV2NPn/6ffzL6N31q2mmaJ5TRYS+Gi2NKSZxvNlsos2PkVRZ/MPl5WWs19mIIDehJ7SepIDTJ5G5WULHicwLaticcWa2MRVCGvwpkeJ29quhWM1bu7C0WFT7/BzLQpczQ7too1aJWSlwXK9fETL9Zjwmr1/ij4zHjmEKCyaACJrD1ciKbkdxnE5SmaxyEF6wa/Jw++fNP+TuPfmYLCGnZCEVuf3w+deJ+yQf/35vhzK2Ro2TSs04NXm0/Ozf62nc5er3emmhPEv3hZBPSyDaQZ6UI2MPSxODpBlLZ4Qao9h8ZYCkFJFtC6inKkArsMT42YkUBsGTXKbAiVx4FoYZDshFpGSGOgCWifv5v5CY2UXJh6BuOJcbqxu7pFZZxd76zj48asjMetHEQpoRpokUfEtWGlL8RqhliV+Bg1VpxYCQb1kEEanch/ILope0gAsH0cCTqZd8V665XxpQG6ZxDjMklaAJ+jTCK6QyDumacobaQaAElJJKR25prfGuaR8krr/120zIG27eone9yczbkBeUkPZcEUkMta440DVUQzioYLGbGzEhQI3iIN2aWO/o07jLcxqXANyxiP256D0iJa9yWXsbay1rrKi0TXPfw0y9AL1Mqdg25WvxsWfnj98aHoxO4skp0QUkbMESxLK9cAfWQvPuZT0xEAIcZgxWoVBwU+2lQ6bcofFMa14t0aqzFi1Nzn+KjHwEUVkIOVc8ekW+EVsi8SSphuQhcTJA1bHEiVXL1OTuR8T2Dpc0HAieEiicO9RDlqnLHaNrlk5j+7NN15ZHN7vsx/2mn8btfVDyJpKjiqjF50wbG5Kqo002qB6MTu0AUsWMkLICDlyC2T+IU1lYw1Pee/Ist8izs8pvHL/ussN8ml55iMl/oOS9+gtjcJBNyxsavLpLuxHi2ZrH8zdnaQriuO7rqc/T/temtT2Bq+yHbmZ1Fwo4D/W0KqEEI0+ylCzZqactRCs3+x13orSnupTemjKNd7wPS9WzzcmCTboVxGnZsrXmrLzZBnssi7Znv2RO7eN8OMN2D8kJObZP2L1NsLbPpfDUaIFB8BTODX85x9a+cjzNxm7uWbb1oI7Z1M96SVs2Ob64DZtCHbYd5lFbWfQXTW6lLcVPS5eucLb1+BIVgqWxW17VV51rQVV+USHX4Ktk93EnDUxwtNqSMIE8cROXPyjXkgiAFAt/SeZAKOoFN5UWpVvv6wRbgCec4h3Ar0fIZY3o6iHngzM7Q9v7QCjVKBApKDo/4rT3rsQ6SUUnRuS2T9PanwMefawWDsw6VIaHHLzj4n1oVymTg0KcULGm1SEcCGSmkkacGwJk4JwVeliYd7frIaBlC2woDUvBLKfZsBBzTBGDAowt2OWwAEu+zaQYHObBeYZqXoOGALjZ7hwE3g0zybAOn97mc8kHBdm26gcH+MPQorLRBR1WTF6JRyE3A8M8sAJ5zVL4qi97pzck97ZrXvnbyLp9gXDvBCWtGxm+M+HfV8edrgozS0Lrd07saLSaJX1LHEr7PtVoNBxoZbQ6H8E3q/q9qNrmSNPt/Heh61Z3se9xyA649lWISIME23kIEf0lP0h19+kQtby6hshZiOAvZEGqvfuEiLaYDNFsRR+k+eL5EPkQa1sShmjoRkGSK3SCVFdTBG2N2fAQzWbKIN0mpRCxjP9BctigLqp1iUeeIE9rNvdGvrP6vs9/l0cIR4IA9lsF2voLHo/6g2jo/aj7shWa1w5eZz817ZQefiK0nrbb/oS3vlqNX/TON43Lf/65fvU/3sBvw5UlAAA=",
+  "epub-switch.rng": "H4sIAHZNcGkCA81XXW/aMBR976/w0mfidntYiwLVJrFpUummbkh7rAkXYimxM8cpsF8/x/myQwKhg608ICW599xzzo2vHe9uE4XoGURCORs51+6Vg4D5fEHZauTMfnwa3Dh34wtvJUgUEYFYMnICKeMhxuv12l2/c7lY4evb21u8CWQUOkjhsWRIqjABIdmwlY5jCfZ5FBNJ5zSkcosJY1yqS66e6Np5NsTp3KpDF/FSI7y9unqPeZyUkUE/OlFH2A2eEhnov+l9EdzFPJEi9WUqQDMdXyDkvRkM0OUpfmgw0IALWFIGiJEIRk7mgpusqfQDdxnyta6pgshwwf00ApY7N0aPk/sPP9HDZ/TdDyAiaMkFmnybfRzqf5RDIAghy8kgdn6XHm6i5rVOrbCF/lOmc5iTfCpZdvEpRdQOFZmFOSpEwLLFQCKlSBxcRXEGX8WUCyjvdGb6JIHc/zob76R3JKuGkjSUVr6HCxW65Tjv+f72x4EgiVqS5Svwv2yoePyFFU2MF9hRt6TbjyymdoMyCSIE8rxHqEZtGNQRldV2KWMgTCeaRV6qrEe3z6qurH8WhdaK6BZYhB2nscQ+KNMkcVaVPVr5b5Sep6fNxVAgdMwets3r9gFt8D0JsBFe4P0GwRvDyw849dudV2eXiDM3s6exIeyjNsndtIIlbKTRArOmh21SBzS1vMk7XhW89VODeE/kQ52w0O3h3rMf+h1GCmeuAkZO/UKWxXicHQFI2LLDFNU1hjom1puKmdPnhTvMYndd7hDrQ61Jbv+wdgWrNdkMevbvFdmbiSlPgeqazlNZRgr4lVIBi0F2mcTEN7a3ms6CqNPgNgZ39vil5lJhHTUDynVpT+aqqIp4UGlGZ2HjQ1wF6FssyWK6v4rs7wtjAlS55lTAdgUlzObQMq5aBpZprnm31mTzsO1rH1FHT7j+c9Mafrvjr3M/8nDxTTq++AM/R1LExQ4AAA==",
+  "epub-trigger.rng": "H4sIAHZNcGkCA7VW32+bMBB+71/h0Wdwuj1sikiqTkunaVs2da20xzpwAUtgW8aQ5r/f8SshBLNGTXiIAvfd3fed72z7ty9pQgrQGZdi5tx4E4eACGTIRTRznh7v3U/O7fzKjzRLU6YJokU2hWLmxMaoKaWbzcbbfPCkjuj7yeSGIsCFAoTJnAbMdlgNCXsRUQUWGQ1kqpjhK55ws6VMCGnwVaKlotGkUvnqIBkP1bpN95FK1eaxZcmMzgOTa6iizq8I8d+5Lrk+x0NctwoYwpoLIIKlMHNKxp7RPIpAV/kQwKahDPIUy1IpnJOHxY+7v2T5lfwJYkgZWUtNFr+fPk+rX9K4E0igdCpj9J9rn/aj1rnOrW6A/nOpcdqQfG5Z2gi1IvblaV2b8iCGCwM6AVZA+wk/algP1NRjxujMof8HciEwxw7o034WnzbcqlWk9TKOr2iTvfE/pu1LVUpnySA9bPlUijoGdnKXW99vVL3HghLd8R9Fo3EQioPj1cPaAKuX10HlKgONG0cHPSr9KACWmOWJuesrOa7EaXFVzDI4ZzwtFYuYGYnZ76xTWqldynbU8Btf5aZ1OLCiPYglD7pDUrAkh3kWy41P6/99W8xDsNlUwrZWG8szq6OGDAfdZk1RgM2WiwGrT7vCcCdpy3ByOctet9RybzpY8ZDhdrVV4H378rC4b1f51RwsQ2ThAAWennv7MJHlz8df3xfLt1PZDamdTQ9y0cocjryd0xDO3vsBEwEk1i4GjYdrep5+s2w2diVd+5gCVd5QbBKaclxKwm5/G5HRw4xsREYqm45ACsNFfonZr4/69sKRKrxQHnr7tLnCzq/+AQRNMij0CgAA",
+  "epub-type-attr.rng": "H4sIAHZNcGkCA62SzWrDMBCE73mKrXK25fbSYmyHFtJeSiltAz1GtteOwPpBluvk7SvJJoGQ3KKb2NlvZ4fNVnvRwR+aniuZk/s4IYCyUjWXbU42P6/RE1kVi6w1TAhmwKlln7Kc7KzVKaUGO7aXbaxMS2VPKyU0s7zkHbcHyqRU1n2VqwTy1I16KI+AcRxjXusmEB6S5JEq3c/Ka1N6a4bKDgYDtVgAZHdRBMtbPIiiAKyx4RJBMoE58Y5je9AYM2tNmOgkLK1VNQiU044FfK3fn3/h4w2+qx0KBo0ysP7cvKSw9YTUE7bgEbwcLHrI2Vtm9Jw6zbr1fhfsX/R4zc9piVNCoXcOx0kMNnOxZq7Xp6eN0mgsx57QGUSPpBA7nXJ3F0fnkysW/0C0gn+kAgAA",
+  "epub-xhtml-30.rnc": "H4sIAHZNcGkCA+NSVlCmBuBSVlZQCHL1cYxQ8HNXCE7OSM1NVEjLL1JwDQh1sgKTChEeIb4+ChraCsFh7joK2gq+iSUZvj6aCkgAaA6V3MOVmZecU5qSqqCkp5+bn6KfWlCapFuRUZKbo1tclq6bC7Q7N0evKC9ZCQC+OuZnAwEAAA==",
+  "epub-xhtml-30.rng": "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",
+  "epub-xhtml-30.sch": "H4sIAHZNcGkCA91c3Y/buBF/z19BCAFsp5GVXB+auLt7m+LaIkDvHoor+rCXB1qiV2pkSRGp/TjsH9/fkNSX9bGS7STALe7sXZsz85vhDDnkjHLx48M+Zncil1GaXDpv128cJhI/DaLk9tL5z6//cN85P169uJB+KPacYXAiL51QqWzjeVmRx+vUj/11mt96gQxiz4xTeZo47Esh8se/RYnh9SBj9YNz9eIFw89FIlmRRxWn+/v79f2fNZu379+/9x5CtY8dluViFz1glONdDdJFQbbTlD+8efMXL81kTSeyYjtGWot85/3MVahffv5XzQCqjMq2DCD5rff2jScfExUKGTUgSAlFJnKAdV1xJxLVVOFuGjWE3902xOIP0BnCWCiW8L24dKLAlUI57I7HBf70vFc311HwqR6acaVEnrAogGjrB+tA+PFaKq4E5o+G6aF5EQvmp4kSDwqgNnuh+E2c3ovc9bkUy2vC6YovRXS3ulzogYly1WMmFp8afDQvLqXIFVNCghWMDi+SyyTN9zyOfheuzLgPhpbH6vWCZHrkI3/9Tb7yQ55Dq8tC7dx3i9eLaLFyrn4NRUsE/RBCJmKxBxMWJZWjM1KQ51whBpjWky1r8AfYV2xfSMVCficYJrsjRJuWOTVC1sLnXHhG2TELiH2mHpfrtWetem1ZfIJiH1iQ+oVWQQNJUqVngUOhbapCxlt6dvAdrzdPggPm7D5SYUcCrFLqzOBOebQtwBmeKUGy7up/4ZErWSf3rAfSn12XVJGKxdqyqpyo44qh4EHTVdvGfYikkstwo5mtnAb+q/9++PcvH3/554bBfZij2VS6yjAt4sBMPMcEE7UDRSN8aMd0lBtUbVi5JE1cPf9jsWaEj7nQYfCsW4padf9uVSuVqRxqK5jGMGe2+lSiBXgt4SV+iFUE8+bDyVpT09aMxm/M+EPtcpGllXYqL8SyT6P2BDbZ1YEv4fclFChoGJ+iIFz89lbk0zW0BGdTseR3qo5d/XjiA02auzwX3N3zzAFvl186Oa0RuQjcckRT5QyLyt5uOYGQvkgCjngtt51wQ9zKfa1DUXGsx5PgchucBDfa30YSVC4PsSOeBzR4YrckrnrDnIodyzdhqGie9alauMvdCH6Tc19Fd4hPo0WSNj91y1W6JpNDavWhm2TXBiQs5gpL1NfGZcTMBceLIErNa4kqiCSPKS0JjrWQ5jY04f3u3SSZh/0uCsR3xW4AzMSuic6MvQXkq2M/r88cgf04nwkC5ELAbN7P5zeW3zwN2kRzdaBsi/aw76mCxXCkBrs0xdffVwOLYaYGO2SL+uVs4DWzmchriqm4szy91aYvfzkb/orhLB0OqabqgUMVjs369WwaGG6z4LdIpmIPdgn9fzbcxGsW6gbBVMw+z+jQ6yq+pXPPmZBbrvPQGwgz8Zt16txLZnv1+5orpsV/5gXzGPzHrpdEdW78bSzfAP+Z/ecY/Mf5T8y3IjavZ0NvuM0C3yIZxb4NUjeIKlPXB1Hcjw1hpMN880QUDGeUmk05lORMwRQhvdgBTh5xbTJc1Ilg+1hiLL9OWjdRhwDpHq4U/GoQX8kLMF36pCLpCJ8BPC1UVujc5XjI4cZwmY+cxM618g7+qapTxrczsJU7F6527/j7+ERD9lzY6X1S5YHfDrCWOhcq3ZHkafwd4FaSJ0PG7Z8KUaF6aFyomS9mwCUem2cw90DWMmcjRekRshXPb6nm9W0Rt2RPRx4ltKTFqFC0ARPv1q3y+KKm2czGrMUOERlV2gTIvblClaEmm6AinfPorFwfNo9Scf6UjB5J+9WbfCa1MimyzPVnI18YrAWg+NpLMV4ercdtNrp8yy6ZX+Q5zLNceYMc+wqivWMbNTtdD4JiImcqRdGrMWio4jWjtmBsZlI52k1H6l160M01Rg3YpluE1LaS6V6wl4SV6p4vTfmbSVQ85S4S0nzlkQ3Fl6YRIUiXOzts8bOMU5/H2lOWmn5FxAtzYb3oIQGvARodpgstCVU38413TeXWy0UYBVhBFqtVL8N+fvr8vphBYJKfAdD9JOUVxywiiV/9eXJo6qlMhGJ+twZGpS89R5WrBimmk0qXtbsmzB4ImAnuqjq2FA8Z4KACvumwNtP4pC35ZMzzVKr8ZNR4KqE96fm7oak7mLRPq5MDo7wQbR1hDuMC8W9HdeKibvqwlxzl7m9PPpvNwd3DtIhCf0r+SJEEiBRTKv0sEpSZu90aFtjqNVv8Jv+E/oE67JYHcalxeOh2QPtCY1QrOo3I1ZA3WGmDixc42+mXGjZIJKwD14Do01cxW4F10y3YwERHpxuteu7cHU7cbSoA03etEvsped1JsKcmd6i8rjXhWBcSz26uadBIQNDrQR9Ui7A/IGwA+GmBPeJlycPQtLdgzWWFz946Vz8VWRxRGZ5BgJbft6cw50JDcdMdM4sMBLUZAlVP79BkNyXbRSN9CdYAiDXajfot2LKDSTwMNB2BRFoFHxqKKMRI53LVbbVNmeDTOnezEqlHaLtWHE8J0Zgnty6a6+j9mdWUhhgLYDzSjuR23ArNfreSgma++bn+zNioYl+O7SpfKiwHDXbaauUWSYTOzNGslFoCJ8SASae6KSjIO97/8aeGj/eGQI/fw2FP83rD090XsYqyVsdUZ/LNULOZl+NXHTO0WnSMGZr5OK6TdAng5tqwE2SJK7LEB6tf3ToXprKnRdFKboQSenkor5FIWSLsi0HdpaV9Y5/m5CDIdtIEaVCdoRskHQnN1j0WYTcskTZEYlZPaRpSaAH5PNq+djCga1oEDTJ+mxkfJBb6K3KwxcJElWZXKWYpS2UGGjSbrW4UXrrdDU2QOTW8dnXvQRiIHcdsaYzUaiWopdKV0TamxJKyK4J1U44zRzDMVVMyTV5P/6SdTKOX6TDExkC9l0FUN1+2ZpJ0qBAN6l450SnTSy3NbtZs0OuuIDRmk4Xj8VOnoi0KmlL712E6Z81WxwL2Gd7RshkEMBsaXq2lYFlYJ5Yp83meU46pQoRXc5M52iqY9c+Y/d/FaMJOo6ArDXtme81FfLmIQGqdXNNMsQeJqHLdPudSOCzV6wdHjtwIFzOgZGh2YkLBPovH+zQnxzk+B0HrsGs7g5/tJK96nifsRL3hd9A5jfXizfwQ7HQ7w149vc04Y5Rd2ScZCAUh3Wk5Zh0oFSksV3mafWJPzDRTNj4bdyvdDnn1cWcm1tLQHtOOKfxXqv2ahpp0joiHMxZjVh1eTZ880SDRDgcIgZZo1IdwvPof9qox65jhhybS1IcfGmaTLUdXnZMsZyC8xpYCoXTBYQRV9uxrmDf2JRFf2556Dxn1L2pEO7SVbmibbCqZ+5MspbmShbTMrsN196/c/2r24Vvs/rgMNa3XOAnX17rtc3DbYPqSAqhvrs0NRX2+HTfSsVeTh1IG7kMu9PEJuoWYjw6NdzV8y1tvl417ku4eWz6EsqQhrey+L5PvQeBUd3bdHJUe0Tj6Cm1wIjuFtfGZbNTO5t06T78j6wjCs03PXZZ1PGXWPVmPXzRrhCOO0Xd9NuYW5s4VnrGPpMSevDp7XHYqRueJTM/DhWRVDeoeb3u4VZbtPdlOisIZF9gdIY0LbdYNQ6S0MXnboqkWnpMLN3jB9bp3ddZQG+xt6Zmd8W3kpeFQGRf26l4m8R6NF5pycXiR18pWzqny871HB7r3VgfHDkgv6ydWBs1BzsOzTPAcISqxtdaWGb1wadRfegSSf1Sxf+wBadxPeh7GmWyvlscM22skKGrejZjoGKzf9yiLMXJGRZSDWkE3dDNzTsec90gOCWmhamaFT1VmWLaOfMJHtlyGRgAclKJY4jed9uLdpMH0Cz03VUg8F54RyXDRrCUbI/VNDt5hlQJvZb5es7L1OFy1lBW5KlOtQP5RA2zg2THUYXQbwho7sYs5BmYx6cFEff0Ni3U3x/ZjiWUuo8fabOVy0ZC2ePaZxcZghxGb9vOK+kbNPm1rD+mY8r4rq1nwtnQ1kMLI+eM0iA2C02AOhe+F/ecSrl78H+XEWa6HQQAA",
+  "epub-xhtml-inc.rng": "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",
+  "epub-xhtml-integration.rng": "H4sIAHZNcGkCA8VbX2/bNhB/z6fg3IdtQCyv3R8MhpOiA7rtoSuGpcX6GIo6SWwoUiUpJ/72PVG2k7hV4gSNf3mIbYl3v7sj7/jnjouXV40RS/JBO3syeZ79NBFklSu0rU4m79/9Of198vL0aFF52TTSC25tw1yeTOoY2/ls5snIK1tlzlczG2bKNa2MOtdGx9VMWusi/3T8JnFO1GO0IfpOxc5Tant6JMTiu+lUPPsWf2I63TDkDyFeGeMuxTm1XT6Pq5bOhbNCGiPIUEM2BkFXito4T63FVMSaxHlNsjjfNNm8aSjKQkYplLORn4sfchnoWBhtL47T22NhXVBet/FYbD/jynCjSE1rZOy/6Wjox8Q0/XvrIg3o/5NQ0n4fRRdI9DBNw8IqpqqcX4mgrSJGsCR0EAWV2lKRCEvn++fTXQkzcebEJfMqCqFjakZS1RvFMia+NpcovWuEbFujGbLvysxbtWkwwAkrGzqZtN5VnkLIZIw+THpJc357MtEM6w3JJaVuZTo5L5zqerTE81T89/rNqw/i7V/iTNXUyCTU63/f/zEXPTGPvr6ZcGV6KEJLSpdaBX4r/n73zxvm+Wwx2+U6YH27QZQ6PCn+FRXW2t4cVGMSubb/Ic3wkx94Ktc27ImznjgZcTJbU8xukixmg9m/7IFCS+OqPez/ZBKwqh0U32gkPDvqUu7jAE83BNjZtYGKELp+qlgdWIRtrMqNUxfjQQppmdoj0Vs/0IHgO4NEx8YFB9XdYZUvoMoXEYpeQNH1EupzVJE9tAG280C/5B2dBqJuoMEw4bOEhBYkWQm6YGQo1BChJqdidIzoBrqUbnXaDSNFGOyDnLnyj6SgAbyVfPKBFECXLAB0FDQSumiWng4dobYBoiHeUo8GiOA6r6Bds9QFOWjndIWGChC95N0eUIBSV+AozRIomVri3OSOpVYdG+gGIHcF7CyirT0fBo+aRmY1o0D9N7MOLQNB51dOOzhOQiAlaDjzgJ3gPTSEyjyHHowV5aEj5+0VHjQ6Qkc+9DwSmihwBXbhKKEeF2QD3VNc5NBtbeig2gcmBsJ/gjqejlDHC62ETjZ5Ad2u5QV2toNGvcuDw283Ip6Wui/xGT/s5MIOaNr60Cvga9N0+WrULOkl0C4eevjpDz1NbTsl8LFvajJ+rPAcmsl/AUX/GYr+CxT9Vyj6b1D0yjvs0pFrBvcs8Xu6Obyv7/nUcX0kLDitK1XviE7r+IW0k5XQ5L/0USsDXWvLwOkRqL9ywfDBs9u3cwOO/QQqQSM1LC8RZW5ovGA5vcaWiyLSNjsHUQY+qXBxvYSex8TeTaACAJJUO2lUKDq292tUfLqkfMo3HZohRElbXD95MRq1hgsgqRW0NAceurgVPHShe8HI/OAnJ7c7oYtthy2x5QpGowNUhj1rHMbuDHFlfqmvRM9A512k8NibQwOjJElmw8PXAn1kGfTIHM/K/lHanJ3xhaz7dblmuNVmV70vFQyBDd0OAXuj3q6CD2ElTVuzCw2DZ5zhYnZb2ntt2N+ly0q+ZHjDgqp2Wt1rveH+WLjUUdXby4ZjNtxVKVENuEmX/eRMVSp84XNU1q/DbMkeALW5i/hIs/CYqiryD7XLmuwhgt7Zd/uxX8zWt2ZPjz4Dca0XXGc7AAA=",
+  "epub-xhtml-svg-mathml.rng": "H4sIAHZNcGkCA7WSsU7DMBCG9z7FYRZQcQxiQVGSCqRShhYh2qKubnKNLcV25DhVeXuuacpQqWIpHizZ99/n/86XjHamgi36RjubsofongHa3BXalilbLl75Extlg6T00hjpgdS2iWXKVAh1LITHSu5sGTlfCtuI3JlaBr3WlQ7fQlrrAh0dRTpyl30utwm+zUPrsdNmA4DkinO4vsQCzv8HqG1etQWC8rhJGdbtmu9UMBWnQORt2dVBOhkXLm8N2kM/MvgcT59X8D6Bea7QSNg4D+OP5Uvc7bB6W8ymcDOE+dfkDoYwk0HNprd71nFdJ+KUunckekvn7DXbktNjpd7SF//aFOfkhh421ePfwkZJj8WJrsCNtghWGkwZDYdxNsIKTVQrLxsywIBu16ShsHI6x2PDCNynkeGeJg64i5H3tZ2iE9GPejb4AZqam2kcAwAA",
+  "form-datatypes.rng": "H4sIAHZNcGkCA62VTW/aQBCGz/ArpsvZdnpI1SJMhFLSVoIcEipVqnpY7AFW2Q9rvW6Movz37oepkrQGO4oPINvvPvPO7Ox4clELDr9Rl0zJlLyPzwigzFTO5DYl31dX0UdyMR1OtpoKQTVYtSzHNCU7Y4pxkmjktJbbWOltIsskU6Kghq0ZZ2afUCmVsbfKvvFkv7ptbWl0lZlKY9Dm1C7dF7hga031PiVkOgSYvIsiGL3FBVHkgTlumESQVGBKNkqL2EWOBRPownNWGh/ZSuk4V1klUIakpnAzX8x+wPUXuM12KCjY5fB1tVzA+Rg+N/5LcHkazMEoJxClYx2u0SR5SQ2x3jrP/9hfflvOwVtsM6Fx0xTmsBvxzgh+Hvs8ntco8dVMQjmPVdY2iEEt24o6v1zObjPNCgM3uK24bbp5XWgsXYe2GXVgn0pKbBvZ3u1ux/6gsYlEXGWUt7laoSiUprx3pQ74OOB72TqYOQrvjhRKmt1JZlB1ht4j3p1kelFnpCvXSaQXdUbaw8k4zXPXRq2N5zS99/cZ+VV+nk6YTmH6HbdMcaXbcr50L3vnHJD/OrAzy68cDOoyH4eDCA/No0Fz7iEFMvpJo80sujqLPv16+PBIGsmj/T8+lQPznpmdqgy3irVGete6pSusDTRqcHII+lfOuxA9lupJ5M77IJW0M8Tsm/nU4vhaycjLIOh6OP3rLsR56WySNN/w6fAPcgh9dfUHAAA=",
+  "mathml3-common.rng": "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",
+  "mathml3-content.rng": "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",
+  "mathml3-inc.rng": "H4sIAHZNcGkCA6VU0W6bMBR9z1fc8bRKAROyhyZKUqlRK1WDqdoSda8OOGAV28g2Sbuv37WBrlq7TG0RQoDPPefewzGLiwdRw4Fpw5VcBpMoDoDJXBVclstgu7kOz4OL1WjxKQxH4I9NxQ3gaSsGGcWroJbntMYHfd82kFJZtrRk8NmtZukZTKN4DFTCzyztOWjT1FhjURP2SkPBTK75DjUB2f5QSmU7EJUF5LSxrUZMT7JTtgJuDRir2xyXWAdT0jJpI0T1wDuOQFoU3FEha15hi8x4ZY7gUncieK/8WAda84JapSPZ9hyG6QPP2XtZr263l+uK5feRK+8Z1qp51LysLExms/MwiScx3E3XaNzNZgxX39c32Ri+Mq7OXhQgNoFM/eJ1TeFatRLbRbHXcF8c8ex14jFcMu76dgp98dZ0PhYcfeW71g+h9mgMfnQMBq6i0w3TglvLCkBtpr1tFt+ZwR2U+6H29ujA3xR+zo41xRtpWI+qrG3mhByPx+g4jZQuyVpJo7TlrSApK2lNkjhOSD4MFJqeE4eKk0kynYzCEOOJZgtBNUizDF6SOnuJS6O/ZGkAGHpp5vQJrFlNH2Tp0dKgnmjQ0B2vuX0kVA45NMRvkK5avEHqX0JP0fXEK7RlwWVet+hypdl+GbjtIOppOKRay9LDEEjnhcpbgW99byu0zkHA78osXZC/AY6d9PQnpBrNzFBzSu/2Ge6jmmi4OK3mkD5BBv8OEvPkwuiKALeX/xUM8zvQ897+19SC9OlZjX4DSOLEzA4FAAA=",
+  "mathml3-presentation.rng": "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",
+  "mathml3-strict-content.rng": "H4sIAHZNcGkCA9VYX2/bNhB/z6fg9LQCkWU7xdAOdorF6IBidoYtKbZXWqIlYhIpkFRs79PvJNESJZOSbbQPC4Ig4u94f353PJ60+HTIUvRGhKScLb3ZZOohwkIeURYvva+vv/ofvE+Pd4sffP8OVT+vCZUIflVC0AbD3wwrGuIUHsQ/RY7WmMUFjgn6sUQ363foYTK9R5ihvzdrrQPneQp7FNhEOy5QRGQo6BZsItDWqmRc1UKYRSjEuSoEyGglW64SRJVEUokiBIjUYpwpwtQEpLTgiudHQeNEodnHjx/8+XT2Hv31sAIHv7zeo89/rr5s7tFvhPJ79ERoAv6/azd/lbXaiIIZui0qd/gOwgcOgCdAwXBOREaVIhEqWERERY6CNam1lOZe+E7tS+FnDtHVWtfwD5NESyVK5T8HwX6/n+wfJlzEwYozyYWiRRasSYzTYD6dzoPwFJAvtU4IajqfzR9md74P2YoFzjIsEJNL71xpyUJQJqf6s1l7CGrAEBUkxQcWV7JMBg29QVUdEYacHHOypluBxdFmAJyZBZDtl7BMpX/aIb1HCHQRkR1lBDGckaUHAarPh7xCAAsTDozUD/AoyE7LSVDEgDbpV/mFHYFFKmT2ZWpflsdsy1MrVlbo0YpAlUZWQCaQCLshIgQXdmh7VECM3b3T8iJoeVkENX/nVELwWpykJIMj0F/vUTXBqq5ol3020Wep9UNrHnOk2aj3QcJUpWNwk+GP3tc6s+JZxtkvqvWlkdYSZYW1gXYLCRbecFqQRwpuxUQsgvqxDwuCUxcW8WKbEheakINVwExd+dR4PcyGUe7UntVGwpbcBrTn+Iwc+1FxHUDzNHXCg+d/ieC/iw0Xpvq+ve5JY6cub1p2iPjQqToO9u0HfQcurNnz/vLNWTeLuW56LfZ/pc1Vnc16r7hGew69ted0VF/QPnheEoNTuxNVM2k8MGUHXTB60PfpT1U23T1qqH+FPMtTchiB/Zyn2Gn/JBRiATRTzNyCTCo4DC58V7CwDMWFv5FQcacbKcxiLkwSJwRTpaB9Am5s0EahXnHH6YHDfmQ6oG1QGT08Wuy2E/RSbX6G/0/+lXMbKst26T2vKuCy+K48iUYAerAat9DjvlVhRDGi6ukNiz9OCs77rznxgWRLZlfUrb/aZc20gQxT8x2v6guLoh6DrVGY0GgYvcH6xhLt7j01ckacmetdtNDJTeGB3JUzvj13LXJF0OWuG2PubLWcpm6AN9exW+vAzFS98NjnJAO6gicpQmOdZLk6XjkG1G9a9gZrYpb3swvb69jUNjTm3TxmnTk41lcHdNVvnHaKTMzynjpG0RZL8tP7a0e3M9W3B6cdOL/AauCJMvhkMX7JuG5o++VsZ6WZBy4n4huRUH7VgboTRJYf9Tz4SpVBFykNVBfASBdp9S4C/R3p8e4/rAyS5ScUAAA=",
+  "media.rng": "H4sIAHZNcGkCA91azW7jNhC+5ylYL7A3S+2hQJE4XgSLbHtIWqC7LXqlJUYmIpECSXk3ffoOSckmJVGWHNlBN6fY88NvyJlvRqJXH74VOdoRISlnt4ufoh8XiLCEp5Rlt4u/vnxa/rL4sL5aZQIXBRYItJm8xreLrVLldRwLkuNvLIu4yGIm44QXJVZ0Q3OqXmLMGFfwkYPEeDbWIVupRJWoShCrm2IwfSnJA90ILF5uF4v1FUKrH5ZL9G6OP7Rc7h1KkSCAiihL8iolaSNLyRNlBDFckNtFQVKKI6yUkAYKyPF1ypOqIMxGuUZ/3j/c/YN+/xV9TrakwOiJC/Tbl8cH9PM1ukt3mCXg/L7YkFSv8pEzBbba1f7v3Spue7VrzR14D/w7iI1uKkUkQCsKzpDi6FGHje5zovVkCB2FSERO8I7YL+ArXmo5zpsv4CtBnrqbGeFK8TLHL4t4bxu3jcd7KyGtOE7ncZbACQmey3m85ZyX83gq4JBeESKpM9DEByfZRCu4lFzQjLKw71Xsn/UqtlUyWDCHM25Sr0m1WrclB41ky2myzyb4YofziqwbxVVsP7fkDmzXAaRts+B4zE0mBSD74jBixhkJoF0XRGFNdCG5jvYCke7TPBBqSx6OtVG8AGZTTAG8jiyMVStdAKct1QBQVxhGarTOBFXySiQkIsDvoa722ahco/e5urHq7zN1E+oE2pNuaq77Q4TdPuERU42GMkbEgYL6VGwfdqJve17FNZJR8XttvaeZHdaHEQc6Y2f9foARTBaO0iApe3Z68pmDgztgAol4EPUFqykqqgSNgMuWpCjVvldPzTMnugASRxaEUlAgTmeHpqKw+dUkrI7HODpW0F4yd8rEDkq2WELF4Rd4oLn7OfMvEfwP8cjFYMWY+nXypW3lssM43nrLZNnRlHATU/SU86+hHf9bq1leMhbjacmoj2YlC8ckjcXTz0xWbS5icvag3Aos4YFsn7EzxbL3e7l4ZuRZ93lsJMU6GKKSS1j99Bna9bUlNNuqeXx9panazuNKz8lwvjkcwukO3XOIsIAthwEPiLwsc5qYCpujT/WcTGjsdqVn5R/vbANoPGkQjd6FDApOI2Ikg13bTe9d3SQJYHKFl4PkJlvo6Doq4ZnX0T3T5Nth9dq+zTB112/2ptuPHQslcPLsNeOeVtw5EIsBbJkssdDP44cuMw5/u0O8VQx+Rwljr40OHR7BNxuQg8icZTeQ9kwwYYU9qkmrjI0FVykdMazcaTU7rBiL8cOKUR/d4C2co8OKVZuruTt7MDysnB7LkWHlHPG87bBymcbbSZf/GQv2psj3y4JtsjkPC/aVc3cluJHouydxdi5AhbKCHDZVCBc7yJwNMlaWHs2/4+nRqI+mFItu6AWT1ZiLSVxvr2CSQaZw1oieKRu+GOg3m/CeqmWWY5eTpz5duM5yvCH5PK7gCHCVDzyRjSfIzuYGhltHFp5qZbVRVOUk9IJ8nWADMyhPiUwEHdZJtuAEbnQnXjqcOEa3s+it3hn1pWUYiyMO4tE6cBM+/bGom9ShewpHqJ3Aqki/1wSIoOjVlb7+LSqp0AaMm01C5gBvEFw2J8+ISrjARlhKIkx+AM+n5HDbewr6po4C+H1xOO1rvTM9yLmUPuGd7hPN4McGg43qo63Gw1W9bVDWcnyHsvqjW1QNbKhH1SpzNSnP3bxdqp0RR0ZcWujplsLsZ/fMCb/X/zGHLQedltJOutd0Cu/c+l/4Z4JXpbN2X0D+MdcNofWCPxBKYB71HwNXsYeig2mUk5mxe5jG3VWcMDy7FX+cHDz0AYL4ZDyiWnXPDvXnSQxR20xhiQbhEaZo1GZkC9/lmzKGeSiG32LIZoNbJX/U1mSen54zMoJ/RsPPjX1PdLoyzE/v1lf/AVyE8WGsJwAA",
+  "meta.rng": "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",
+  "microdata.rng": "H4sIAHZNcGkCA+1YTW/bMAw9r79Cc4GeZns9DChSJ8UO+zg029C1wK6KzcbCbMmQ5KLZrx9lx5+NHDdNumJobpGox0eJIp8VXNynCbkDqZjgU+fUe+8Q4KGIGF9OnZvrz+6ZczE7CpaSpimVBK25mtCpE2udTXxfQkLv+dITculz5YcizahmC5YwvfIp50LjX4EzBXKx2rZWaZmHOpdQ2kYUl64yuGQLSeVq6jizI0KCt65LjvfxI657GMAIbhkHwmkKUwc3JBXco1pL5aUslMLEVYSCpnQSiTBPgZe7NCNXny4//iLfvpCfYQwpJbdCkq/X80vyYULm1Wqz1Po7Dvw+aumLcQ0yAXoH5QAOiczM06QawCEJt4PMPaYhRSPHr1H8PszOuJkU2UGAVSgyOAiyydCDALPIDhv43cMM/DLnxqZffYhVGuI0W+S6WtWd3sS4RIlwXFU0Me8qmJ05FQkwQKo1b2VVI7rGGqRmsFeOZS4NkGwboEkYCxbWdw4H7miSw6y2DPxyoGfQOvw2wj4iKHJ2IIDWPFokTOkWOcHhu5wL2SJsPYpcMo8ulEgQv8nmIp/7KIHf+NlHjHh9BiKsZ4eoPylpHIL/FjiHDuu7WlHaVgBKz3ZH9Dl8SHgONwuq4BncJIz/9iCB1MtiSRWKG1sLvrm6dIsLGJEfZf1YkTloarxMyEmizw0WqarRyVKf2zqu8YdDLQpN1j3sxp0oC76Mc5Cde9MzqGJZb2CrZPThA39NZsQ29VDt8sFyKHikLGyRsZix0zO+3SqToJD2dkOh4/Zm7SQ4Xpoe+s9kSwdDxVhhIjdGIrJIuxIt7u7lII0BiITiDd85PgtwChFbV5o9oj7tKFpAiv1plM5YJPP186bNhukECONhkkdYAhk3Vbk+7PUnzgMWkC4gQnsvFFgmuF6DYWIoJSRbsvZNH8Wrr5rs+Uclo54UCXhFhW2VyzFr1vWlKNuPXYv1NDc535U2XeZPlu7dptX0yNLNw/64odON6Y1lbPhFbnXR73FVKzQdkFStDvMlBhq9I3CPeWDeFJStOz6yQI/hPyghBmrRuNLePcp/xKfTEl4Eo3b9ehGEmhY0lk6K+q5Ot+Ly2JLeIgkNwA6S0CwbLQlLkgOSsBvFviThJtRXSfgqCQ8gCTekWiUomhs9tn0OgVleBrrTBtA8tpp9QfGGpo2kfOyTQNGPDaPiW3V7E99QkLY0wR3VwnZHgb9++p8d/QUQ0Xp+LBgAAA==",
+  "ncx.rng": "H4sIAHZNcGkCA9VZS3PbNhA+y78C1dkypWjc2hpaSae9ZMZuOm0OucIkRGJKAiwA6pFfnwX4AkFQ0ihx4vigIbnY5e737QOEw7f7PENbIiTl7GG6uJlP366vwkTgPMcCgZDJh2mqVLEKAkEyvGfJDRdJwGQglSgjVQoSaLUr1PxZGrvd7ibGVB6Mzufl/d2vwZv5/DZg0T6wVGKssDoU5JE+CywOPf3d0iiD2iL49PT4b5SSHM8aDTldd2auJuEvs5m5/4dsqY4JpVQqLg4rI9c/E7B0N1/Mf1uhPDlkGWXJCsVkQxmJEV3cMYSVEigRvCyukSAbIgiLQKbAFNoIntd2JiQjOWFKIojmGsU8+khVRszV76VKubhGDG8f8TPJzNV7tuGWC7dvlrYLein4it5FGZYSYRajdzRGOY4JoiymWxqXOMsOiBcKAsNZY2qxXMyX8xVSGyoBHLFCUYpZQhCsNiZ0PPS5VEQixVHEhSCRQqGGEGkMH6bv/5wGa3iLVATHiG9QqMheBRW05mc2W1cXDdBSYaHWV5NJWMMAAeRgCrAASibwvH1tLamzrJJOwi3OSrLW2TBbhEF1Z/SCVrG6BwpqC5odcNQ87b81Bb8bw5yRD+KJi0q9ZyAnCtcG4D39hWFQm/TZb8ht31Fz0LzCjZU23oAMUhIYIdF/EmVkTyOcAQcAtcBUJw9nwCnAay8vGf2/JIxAHhhNBJkXg7tAEZJ4D/TGGYH0wsBoStBff3xCmvocKwEpT/MiQ6UEuhc3t9dol9IoBXW4Z1yhFG8JMnDPgGgwKEjBBThi+eCmRh2lw4yGsIeDhbTOnxZpFy2L0Tyx+BgzZvPeZ+kzEdwme0hbVYkNG64rR5kbw2EIxMD5MSg8DnjBOGrQgsPFI3AAcYsTb59wcUkSX5oRLkF2HHVL7EIZsHlC27RWv3rVp060AzDxN4ci1CY6BbsvNE8dmEcztcAJDDHZ8O3AMUzXfji2ohtMzwd9H8IANi0YmnE1vux883Tm9vnA/3Hi/bwPaXctmBnWGqmHiU/VRahdaiMeBlWAw1h1yXhCbR6/5khdQ1JETWF2Vhwj54EC00XBGh8wtuibg/P9Imw6h2//YYlGuvB4+XYd2I3F133P9rXqU35nO9mP8da0Etfhqiv6He5kRzLGmzCDfDmRfxeX1gm7RYYPH0RMul3BebYnlfH+PBmfSIMNZreyKcN64fGx0I4oz4wczISxLGwHk4fUnuw1t8zRShgif7aetQMZqI0yrRH7iEVCrEFvLz6/M4xQYotevE+/VBkeT+se8O629awi0xJvoR3V/nreLPZHqsmSfj/2ajQ8H976Y+9bbFG0a02Dj1JOo3ZPXX2+w+EIU/a3fCthXOQ484pkQSLqyMLAMv+zj42XmRpnt5jxTO0LX+M0bwr8hOmLE/zn2iicvYMzx1wewtvnw1D178nNuYdU+3viqOYJqM3x1QUc+jEBApzvRL0NNus75eYwc+hMBsenU/ccuz6HhiPoYHF/fxfopbLAkXa6OzywKkVbKWEY+OvFDqN2Y+CaB6eY6mRsD2KtRtw+qxypummmRNtYvQuE6jqvbbVtwNYjy//aYyeGjgBzSBwG9f8R1l8AGTAiG2cYAAA=",
+  "ocf-container-30.rnc": "H4sIAHZNcGkCA31Uy26DMBC89yusHJpDGtNekVDOvVbqBzhmaaz4JXupGkX599pQwGAoF/Du7O7MjgUhpIaGtRKJZgq8ZRxIRXat06VhXviyC5fIS2NB14a3CjSWP0pqX3KjkQkNbvcUGgnNZVsD2dFCmbqoGTK8WfDUaZ4BwkRhJRxdaCpQGO2LsVtfECs8MoeBj+ENHdMkZsITX/NENaRAQqRJptR9DqUMUQqP5HkRj1+x8pF1H0uqvyHh7MS5RSDf4HyQEIbs3+jrfq146NtrccZgIyT4l+4ohb76U6d4ls0FTale0HheCJriw+CJVF5TEVAWbzlgnfUhY0rGpSyJknuK22D5D8mEY7b2ppXyaBlewjKG20Y/P97JgzxnYAW1YMcIiTYxa6XgLF68wsDZ+tCHX9kXHMLNTgzMGA6rGgCddblPfbj3qPteKO9juew5duHLvKj3JMYOEZCC1vkkdFbYbJDJ958u9eKg2V5+inQgU2D3o6EeLHMMoaZorqD9Ru3MurGFEgq62OM0I5w59Qs6SlUi5AQAAA==",
+  "ocf-container-30.rng": "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",
+  "opf.rng": "H4sIAHZNcGkCA22QsY7CMAyG5+tTRNlp2t52Sst2E6dDYmE1waQVTVo5LoW3JwUKA2SK9P/fZ8t6eXatOCGFpvOlzNNMLqtEWwLngEQMfShlzdz/KEXYwtnbtCOrfFCBaTA8EKoJS8T89sDAlx5XzY6ALk98HMd0/L7RRZblavu32pgaHSxmIsjqpUl040077FHUhIdSdv2hyFLyVqq44VuWF3OW6MBAPKm0qbvG4N2qY1V4cFjK//VvdPVgjmBxgS069Dyx773o/djTanbreInbvK/4fVyuugJzQS0LWQEAAA==",
+  "opf20.rng": "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",
+  "package-30.rnc": "H4sIAHZNcGkCA51YX2/cNgx/76cwMmBZk8WXtA8bCgR52Qb0tdg+gGLrLlp8tifLS4Kt372UKMnUH6t3LlDkRFI/kRRJU3xXmX/6T8v3bO5U1bMjn0bW8Oq+unhSavy02728vNSiHff1IA+7D7e3v+yGcX+hdy3SQDlzR9uQDeMsOyPcNjve8SPv1bS7q+92ZpP+L/qmm1teXdS749DuWqaYehv5VMu+MUKRAB/nx5tR8r14vWFKSS9HjJ4Ukwq0sCdWoNczO/DqP21ObVc17O7EpKofA2oz9Erv+eows1vuDflfLicx9JosLczci39mDk4CDLEXXFKmaM3qAZbajBrN8DQjcvcr4k1ozmJUcuB9pf+Ix1nxyjLAwsuP9e0lal/Qh+5FkZtFBFDcNdSff/vy+x95ZzhPoS+OXDG962dcsV7s+aRwNY2i5/jzMMM5D/j7UfSt6A+TXTZD1/FGgRlX79xZDpVcpifhbRKfRv5DghMPLzbLQUPaptZH0f1X9ncn+ucr4weKEekGetlQ1AL6nj8aMX/M/57xIWDoXYGjM3vvq5/MFchh5FK90eDSsdRD3gTeCJ0zNU+g57q//K1PEBv9oe6Hnh9H9faeahQqrTVaQklXAbBf8VfwMwAuHCfumO+r6oeOH1jzRi3WDibuNEu85icwj1qr1x0DHakxkncr6bbmoCNvBbsxNlOy9a/w0l+DVKTJENwETSvHodnkaT4Ivcp0KxAzu0CbZV9gf7DZcQDh4gKCzcNo4gyJ2wxQTT0QiYkABunfU37xaGSAYdDdf335HEY35BkpOcult82noBRFN7kWo3BFBFkJ1elPHQFFEuKBxFL91xEJoHNeiOmpZ6hJQEEoAjSUbWDTMEvzeSdwlrbVaC0QOVFTtum3H+SR0a8ywFnaNsBGcqaGKHQccavJ0/z4N3yEIjda4lbQlk+NFKP+tEXXTRhbwaEkg/hTnEMLeSuwLtkmnxMfE8ZWcChxLPWHp27XGTqhJE09dbO24vCkpkhXpJ0NSWCxz/Btx1L2ru1XZvmH3yVX2Qp8V5IKIrrIPKyzsWhcFVQA2wpsTOqCgM3RgoRNuIIEyZyClE+CkjZLNBekXGQWgTDKSigmZpb2loQNRsFqNxu1Ha6/pr2nI2FEumX0zPHktB1ONoQqJXJh2ywUP5qYozGuiURFs7TFHn76k7wOATU8n/R9dB01cJa6Z133CM+UTK+nL6lj2K+ttnuBEQFY0OY4zsqDKX9ogBCwMzBpp+mUzPWaukMs9I3UKPMkI1eDa7wb8zuKG6QlQROJZoMYZdRgYn3x+RjFVSgWmAfEgosdUugRSEQYEwwHySf9Mr5phcTHpX4jd0peQmt8KVVn/topyWVkVxrhEH3ZIAd6FOeasoS6jdo02inDuc+SRRvFumPAs4gzfMivPPTigI5PJNDUaYZc8HRGgWA/0rWD3/hkHNsPdhZh6pfDMUMA4i9co7cAn0veN/w6eGcgjexZaOkDkUQO9qveoMzL1L0LIpmH4GPtRhVEAU/C890SM/5PACIGpMxgaOBoa0hp6BRkbBSlhZE8EVnfdt+d8yzzGKIsIaK2C8FpEE9z0qqR7lkpHZC0wfr12JkGJyASNDl0aG7mJM8LX6pApX4wM8x64iOT0CW1UI+eeU/e3RmzUHPCcIMlmGuZac3CuoaciEhXibv01OP6vZ+5ZIC3T8MyYMXrWZmREYloXBbtDSZnGfxSE5z2Uav98GmirjU+TVp3yadJrjXMq72zGyKVRW0ffZrwak99Vnt9dqd9ZtN9dv99Xit+XldeatDzmZBOelfGtLlUOn226WaCKx/3ZGYZVO247qfdZvxNPArQXdOC4WJ+sJid6NEuPWwnwi8MkV7qEiZ+trD76u+2BVLBUcAxw7gTh54OOcAAYq43ZBCZuon5BvUN0RxVGwAA",
+  "package-30.rng": "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",
+  "package-30.sch": "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",
+  "phrase.rng": "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",
+  "rdfa.rng": "H4sIAHZNcGkCA+0cbW/aRvjz8iturlQlqYxDp0kVBaJKXbcPZJO6TqoEqXTYB5xm36GzIUl/fR+/4rN9xgYTQjFSFPA97+88dtK/fXRstCbCpZwNtG7nRkOEmdyibD7Q/vvySX+n3Q4v+nOBHQcLBNDM7eGBtvC8Zc8wBLHxI5t3uJgbzDVM7iyxR6fUpt6TgRnjHnzkcBJQDrBVuK4nVqa3EiSEtTCgPi3JiE4FFk8J1sPDQ+fhtwDp7c1N1/h6N/rXXBAH6zGGqw0vEOpbZEYZQQw7ZKAxzj5//IRH1CPBKZwTZwkyBqBGCBu8/1XX0asmXkjXD0NQUgws7nDW8XXvCGuGOy6eEXMlaKIn7lncXDmEha4Yos9/jD58RX//iUK7oRkX6K8vdyP0ew/5RkLdThdhZoUffJMFV1KvV30jSzXk1bSuhyGZt4iv6Mc4fNKaVn0pLeI7BvlkBxoEOGRV5BY4WmJIqsiNkDUeEUwbTsaXl+MJ1ce9+/vxxAx+X1/d9m6vxt8m7v315L5vBIiFZBzKRoTNvYU2fCvBQYiDILlgLw8lKYzqKlKsRqRFRR26++sAwji7qpAoYMQaVJHnNAsI6CzcwGQagktTABholIEhbILXJcXET50PgEynK2+n3FGmzoZ74ia+9M+xHV+AS4LMVJp08JSvPC2o8aHDsvh1CS7hkD42S5EvifCemqTphzifNUlxzU08bZKgycG5rFHfxO2/SZowojRLzuUrYTYs4rpJcpTZ1C3xS9+Q03JrKc5nT1xK4qIRl930KZybC07NJPVLy3dJO3Wv832oh8bf0P2bq8uJ+0Z5eA2omTaVLvnR5zW2V0QWKj+5pq2Z1goKX2yD+qaMyobSmNJ5kTl9P0sG5Iz8I+64SAEVYqqiKNN0E6WrYISjRlUUAIba7nIbFM4iySZOgjivW9+QLXA0XyZVQeHLzHmRL0ssu/k+kDJULVeonXAAY0S9S2EK6bQN6hcc1OHEoHBj+rB6OKsMdDQdw/FSPa1m1U7DK4KwdibXjsAq2ZwPuIyVMoTS25WIyD5zQjwcVresjKGYFspj4hn1SybV6gpmUHaInnz5aixwFGWrbl4eOer8Wb+6QzbQKl9kW5G6GSnb0S4NaaeWtFNTKm5LisaUb00nGCDrWgESQ7cBciYBEn13rh4jEsJL71qM637RK9sOthu7dmN39I3dWa/YwiSFn3WbqG2inluiHjizIsvqjCehdfZJdgIJcd7RWxqiJeKEcqh5QHTuQz7dqbZxEqQZZtsYTbFLnoWRTdn/ITyxidNxiIf9IE2eTIKLUGdSwJtdab6oSBIFlCljRCg2+BvWodQJ71TYZXn0jUiiWlotFwK7m7t0z6pVwrtJrTIGU1d5RYBAeFEzJZECjHbfse1QUMlducsrALm3SJstv2wvsn3tyUpR74rcFNFJ31kvrp9FTiuTeCv7yooUiFJRjyKJczuJdgo4o7G4iXzLTxu1820BV19Awik0qZFwWUUOkXHP/IV/G0V3ASOQpS8g1ETGEjaWm1wjhB1iUWkgaITqfiN4ipBLv8Mz3k1QwrXJ+M9i/pJWino2QZSZ9soiFrzxB8fE/ckjxxkRiDMlFsDHRSkiZgruulzQOU0PAJXkqnIvMNJZUAhwbpNOMIJtucWXxYnGjuAxzbq4MGutYBct3ZLI7+t3/c6jHAFPdE6rudmqGvLbnmhs29Xptat2QDyrvWk7m/xks0k7VLzUoSJiKm/pNrvBkE1+L6ja721ZC6a5JeNLbW7y7kvNzZcqmSQCVNUf+by2vfc+NIqhBzPOQa4gzAZTLF7Pvfd+mC4IttCl5tPX0OZhh9j6V6q/9JFXgz6ryqvBQIuy1aCsZrjd3X8rWET1RAfN0tIW6Om/jZAD15aVkZpjq5pTph0fPGcL0qFOAsFNQT2QvpFEmnLrqSCRLOpi2+YPxDp+KiUKHySlMtTP4ztc5WRorl2fRuut0QxLkrJWP9z7NmDBwwI71ZNjCfJczPtG9L8lhhc/AEqSgfSNQgAA",
+  "revision.rng": "H4sIAHZNcGkCA+1XTY+bMBC951e4rLS34PZQqWJJVqt+S9setlupVwcmxBK2kW3S7b+vbVggBhJS0d3LcgueefPeeOZFxNcPLEd7kIoKvgrehK8DBDwRKeXZKvh5/2n5LrheL+JMEsaIRCaaq4isgp3WRYSxhJw88CwUMsNc4USwgmi6oTnVfzDhXGjzU5gTh+yyx3KVlmWiSwkudr1AKH61XKKLOR60XDrAFLaUA+KEwSqAlOqQaC1VmFANrqSJIVEqkpIBr6iv0d3H25tf6Ptn9CPZASNoKyT6cv/tFr2N0B3sqW0dumm1WpTD5yLGPmpVa26BA/TfC8YsP6OTbkoNaoyL7YSLqNvT6Yk5lbB9fO8Aw5RoEpaSBrjOxw2AazWuen207QYDNGVt6z0K3rmJSHaCJg70KK8msSZ3IrQNi3G3wmRNlKsQcmDhNhe/xwbpK1cgtYrQZa6vTMZlpq/GLsOCmVctfNsCyjXIHMh+uA2WCuUcZMVluAE2yF1BV7kPHOOaxUTtxU4SZXzjUf8cGhrMp9FRYdVpfZL9EfKLi8JeIskH2fqG0+Hs500G6k/6uWBdJSGRlIxD+b093szOFNbpvaJViJaEq4JIc0WdoZ0C7o/cSIHDKRoHrpPaTUbmzcacmyNnC/06h5t/Bn7D6YwaU3WkkJ+2ow8mwv1fVYZkcqYbkgmevMyWzElDskFzLXKj/rgh/ZuGE4Y0t44XQ5rJkLwpnNeQBsbj2QzpcPf/jyH1N8yrE+P6g2G9+As++Os7YgwAAA==",
+  "ruby.rng": "H4sIAHZNcGkCA9VXTY+bMBC951e4rLS3xO2hUpUlWW2rfhx222qbSr0axyGWwEaDWWX762vAbvgwDkhcwi1jz/ObeY9xCO9PaYJeGORcik3wbvU2QExQueci3gS/d1+WH4L77SKMgaQpAaR3i3xNNsFRqWyNMbCEnES8khBjkWMq04woHvGEq1dMhJBK/5R6pUKusodycwUFVQWwau92gVD4ZrlEN3M8aLmsAPfswAVDgqRsE0ARva5YwtLqML1K1ntJi5SJmvQWPX9+fPiDvn9Fv+iRpQQdJKBvu6dH9H6NnnV2meV/bkLcRa3Pmru0Pn08UFVF/OG/NGt0m6i7she3sbobolu2SYcanTNN02tcKAYJIy/MhnQQ2KHZZi4Eg8BQcm0gSkF+3hDiLmqIDYdKSFwrOSBqDWby+vQaZ2vDplL0TpdZWTtJnHybOSsCnDRptzO7ZVzgXXfJpErBfsCThDPtXkTH6FFy2gi4mFawq+wIJNevdVOFtg5R/TY0VcJtfF1fj1WXgYumk2j7cNU7vLeDOrZ0GTo56mAMssiGCs9cwM4yBgoZU8qIYlzljOLqLBm3am4jdzKGfWksVJ55dhDS0Ujv0csVprVs550+E/X43jTLN6x27KTMmFIThpQaP6KUf0Cp+caThbqu4WT709PZM2F8cMb8l0RHn6SO6USw8tMp+tMJBqAXHEBntIDFujIP2BaZzL8M5KWrYMJV5B+gvgnYnWxtYp6KzH3nc+FHkjPjvWiC9aLxzov8xovm852Fui7b2f7MNHqMeXya/ySgA0eW89xIn02QPhsvfeaXPptPegt1XdLb/phEpW+Ejrzlf5zqw3S7+AeHiezUyg4AAA==",
+  "sectional.rng": "H4sIAHZNcGkCA+2aXW/TMBSGr9mvMJ00wUUT+inUZZ0AwYa0gtiGxK2buq21xA6OMwa/Hiex13w0jjNlVFTt1Zbj8/rYfp+TrJlz/uB74B6xEFNy1ulZbzoAEZcuMFmddb7ffuq+7ZxPj5wVg74PGRCjSTiBZ50158HEthny4ANZWZStbBLaLvUDyPEce5j/tiEhlItfqYgkykl2VW7IWeTyiKFk7PQIAOdltwuO2/iAbjcRXKAlJggQ6CNRRs9CHvKTqUQMThbUjXxE0pKn4Prj1bsf4MsFuHHXyIdgSRm4vJ1dgdEE3CA3HiR2Ccwgu4uCWKL0OXbsomo6V9sLex7JYu2XCMa+CKtWVTEevLqG5A70Xk/AicdP172TFT+t0ohPRFx6PCJ5OiKCCUfMQ/AeqUviIkPLzWliQhDr2FVhyDkLN2HHLio6tpw98YqdmmWrb1IpmVUuLDOvIMKnpDQ3DeI1Qy9Tq7um2M2srVLGggxDC/uBh13MrXW6y9l116Qy6qGnpnE4b5oSMBSqU26aKyzSDaM5x9xDuZO189vl2PkdLR6u9jRT38jEUklJ1ArWDIaP+1UtJ5NiI1lLj/7qAHFlLuIilFRcnkf1oRrldV/brvKw9RVs/Qaw9c1h6+th67cHm5I6wLYPsCnf7A42SVEdbIMGsA0UbIMGsA3MYRvoYRu0B5uSOsC2D7Ap3+wONklRHWzDBrANFWzDBrANzWEb6mEbtgebkjrAtg+wKd/sDjZJUR1sowawjRRsowawjcxhG+lhG7UHm5I6wLYPsCnf7A42SVEdbOMGsI0VbOMGsI3NYRvrYRu3B5uSOsC2D7Ap3+wONklRHWwrRqPACLiLeKSkLclqQFwy3py6tCgteemQ1ujLyrVLoMaN2cKf7LTsXlVXXuwDVV+lbftaShfN/rGy7cFfF83eDra11ny0BOcfxOhXNqNs+7KkqTP55YQ6jSx3octwwEXfCALKeK7JlaXNz+8paGeYLeP9vO9/4GIhGm+obRjyPQ+YIQ5NX3t8oOInl4PPZEnTHiNnMm8yMsG4y6il6NqMGtNWn8nr/VeNJr9d+vtaYuT272k58/1r58896t79jChHWvN/EyPS17cvTL3/PlYGcSIKU+9v5jK3/ybHmIDMknQQZIa1xUFJ8rlQKE5kiYfbzDNfEYedkLW9RmUWcQXPI/6IzSa2rbIF5NCKGFZ1Ce8oAeMidkh4EbLCDI4t/6dievQXkHjWLoUhAAA=",
+  "structural.rng": "H4sIAHZNcGkCA91awW7bOBC95yu4LtCbrd1DgYXrpMgC2/aQ9tCkQK+0RMuEKVKhqCT9+w5J2ZacWBJHamw0J0eaNxyR8x5nKC0+PGWCPDBdcCUvJ//M/p4QJmOVcJleTr7ffZz+O/lwdbFINc0yqglYy2JOLydrY/J5FGkm6JNMZ0qnkSyiWGU5NXzJBTc/IyqlMvCvgjvOs0MfwxZGl7EpNXO2VxeELP6aTsmbMf7IdOocJmzFJSOSZuxyUrDYxjZjgmVuPDCg80TFZcakj/uKfPv/5voH+fqJ3MZrllGyUpp8vvtyQ97NyX9CxRvyhepNmZPrJGEJ4dLdfWedVX9vFtGhVz/W2E/3Qvi3/hHn5K0w76vnfZua98dCslMBl5oTVM0N3ObSMC0YfWDbS3BRs9XBhHIpmZ5ErTbUGF3sbRbRoe9FVAXjFi7yK3d8Eb2/Cvo8zloEkKPZCwGo3PqhohZ1vFY8rj3qUTczqjmd8SwXPOZmpllqp602AR1IrQSbUcG0QYESToVKg6G5DdetfigUN+CKsSQUk2pV5qEgRGygbfclY6GwXLNiS6FQLC5LChisrOVtP5Shy5xKJgJwgsoEZmUzW4KMN+ncF2l3A89hqn/iHACRpeFypTDwrcJhsBnlIWuzw0n6wNPQfNijlQnJwR2uYFTH62Aaq3hKl7Dv0jhYeBw23kj1KFiS2lkOTkrnYgVK/ah0sDA4cJ4zmfAnDHbJl4IrKGvydUhq7vDxmuYQOgqqhMrXCNV1WBmL0hZrKLRmCUcttUeilhjKIuw2A2hYYEsK1Mgs526BkVjYRsrgHcFhtaaGopBP1EomBgqFKcMSKRWqKMI0eoflMmEoBkKRplUCJT8yMyAtoDrDIHOaMsELFBFyGl6kORxYUWS48AubinkpxH0ZtqvswPcSlcRGxY3iP2rW0YuoWWoflv7dtb7vLyr0s5Dc3dlKqEcfxXF/FcD2Gd6ewJUl3IdbLuTnYzR6xg73UAq09pZfd6UCFeSGy03h+zTA9e/RwLh3f2YDauvN7P2x+rK9r/PoyQbWZRj0cIkcIlQHLOzVBDFZYjBLGlwHSSVftdmCBuhwIsfTpT2vTqJJO53pcA07F49hLto06drbeCGqAP3FqAL0FqRtRG2itLUZS5ia/s5DnLbzhlCmAVBEezzg4AjbWaOPjnDnK8dEZjy1aCb9SRSjoQRdqlHwpF0z7qhM7SkNVDHX1rgSD/szQDqseX/hcEG1yoazGE00at7OQzIGn61hj5oGD4w7qzq9ArzSeceQEwBlAld1lBOAQT2m4Y3j/RFltiYRpxHZvXB2OF8zmkAcbRr72Zl4ZfXm/aXV2/fW1iqaNnGtTMZS14a785BX/EuPYCT+PddQpXpJMMYjYCOPTsLAOq86vNup6KDgR2fiKejN+1PQ2/emYBVNGwUrk7Eo2HB3LhXOoJd/OPifSsZGRp2EjHWGdXi3HWIrFa0BjOgW2BPSXulPR9eC9iWji6aNis5gLCLWnJ0HDbEvwg9x4+VybUFOksn79Ozw7Tud1ky+dSbb77Ps75DPs1wj1f/rLBdN+8dZzmS8b7Nq7s4jm4ObT3zbukPCm9kqVX7zFvTah+rIL5ieTeSYbwhrOX6iF4R7zh94X0TVV7RXF78AQQLnXncrAAA=",
+  "tables.rng": "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",
+  "web-components.rng": "H4sIAHZNcGkCA81YzW7bOBC+5ym4WqA3S7uHBRau7GJR7G4PaQu0KdorJY1lFhQpkFRS9+k7lGSJpiVabR00OQSJ55v/H844ffGl4uQelGZSbKI/4z8iAiKXBRPlJvpw99/q7+jF9iYtFa0qqgiihV7TTbQ3pl4niQJOv4gylqpMhE5yWdXUsIxxZg4JFUIa/FcipZXccecDt4jvKWcFNVLFoknyRhtZrYBDBcLopGeYU6aNanLTKOiEoxhqDjXcskxRddhE0faGkPS31Yr8fo0fslq1AgvYMQFE0Ao2kYGq5tRAbI1uFSKCrguZN9aH1vkteffv7T+fyJv/yft8DxUlO6nIq7vXt+SvNfkIGXmJYZPC+pwmPnMn8tpeTFh517ui1+QZN8+Pnj0rzfM5q/pMebHow4B0JgwoDvQejh/hhwp2fvCYEKCiJAyixig9gtLEl54mvT1tmpIuT4GUdQJ73lEh1nAlhatuqaxY72khH5SUppLFMQ6ppbGsMUemSRTi8r1kuRspbI4GtrIGkSbd3z4t51JD4VHTxJWEuTvq/0FfCgxraQtjhyUwBGzeq0n8vH/YxTDn345y7ROv7R7GUNCML0iXh3y6LmlQDAfr12VuTaCfcLbaN6JvdAUlw1fgsCB1Aban42w3B3vuU5vOB1QLjisw1L58zmCcQe64fJhESe4PYIfYhIhFiLhjJb7NAYBqskOALLPPkJuLxruoeq+oxs1lEnnPCpCXxLmgoDTaFOyiNBcUlGZs7wVikUteKtnUAYjZAy1C9EwWoXCbHbZJiK6CuQZeaAjxa2y+Y6KmiwkrmXF9inA7ar6B+jq37T02BMFPM8QguRVx/tKfLm8XnnpXx5DLR9Shc8Vqs9JNXUtlrqPMbpE4tiT+wpIlaadjSx72oACPAJIeJWwJ0x0KisnF92dN7Xi+Oyptq81J95fUl+3QJ8d7ottrscxXGVUL1tqhRoV+g4YQ5xK5dLiM9X1hBT6Z0EZRoWuqUIY3U5DnKyj5Vr2WyhF0OmzwsYmpOJxwJedsP7w4f1cH/KoYno/ZJxG7QYG/qQySkWgjNMy9hbuDe63EEh8B5aRkNHauRe72QCKmIzKom2sKWdt/KB8N9pYtlBJKj53JcZfktoRskVuAe9F5UUkTV+l8DDTHl2scDzOuvkdUNwIsfvlZa9GLT9rWlKmt4Bx1rXt29H6o/av6MdlRj+nLyV1+bmfwVJ8s1Rl7z8rvrMSDgk46j+IJNS/Kj8eSAHTWzRw2Ds1KwNYi9qsv5EfcmKrFU8Qv27kvRULv1CLpfokumuJXWA28/I8Mj7P1TfTkMkU/NcfbDr/CJG/lDCU0PYPTpP9KeHvzDeuam5hEFgAA",
+  "web-forms.rng": "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",
+  "web-forms2.rng": "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"
+};
+var schemaCache = /* @__PURE__ */ new Map();
+function base64ToUint8Array(base64) {
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function decompressSchema(compressed) {
+  const data = base64ToUint8Array(compressed);
+  const decompressed = fflate.gunzipSync(data);
+  return fflate.strFromU8(decompressed);
+}
+function getSchema(filename) {
+  const cached = schemaCache.get(filename);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const compressed = COMPRESSED_SCHEMAS[filename];
+  if (compressed === void 0) {
+    return void 0;
+  }
+  const schema = decompressSchema(compressed);
+  schemaCache.set(filename, schema);
+  return schema;
+}
+function getSchemaNames() {
+  return Object.keys(COMPRESSED_SCHEMAS);
+}
+
+// src/schema/validator.ts
+var BaseSchemaValidator = class {
+  disposed = false;
+  dispose() {
+    this.disposed = true;
+  }
+  checkDisposed() {
+    if (this.disposed) {
+      throw new Error("Validator has been disposed");
+    }
+  }
+};
+
+// src/schema/relaxng.ts
+async function loadSchema(schemaPath) {
+  const filename = schemaPath.split("/").pop() ?? schemaPath;
+  const bundled = getSchema(filename);
+  if (bundled) {
+    return bundled;
+  }
+  if (schemaPath.startsWith("http://") || schemaPath.startsWith("https://")) {
+    const response = await fetch(schemaPath);
+    if (!response.ok) {
+      throw new Error(`Failed to load schema: ${response.statusText}`);
+    }
+    return await response.text();
+  }
+  throw new Error(
+    `Schema not found: "${filename}". Available schemas: ${getSchemaNames().join(", ")}`
+  );
+}
+var RelaxNGValidator = class extends BaseSchemaValidator {
+  async validate(xml, schemaPath) {
+    this.checkDisposed();
+    const messages = [];
+    try {
+      const libxml2 = await import('libxml2-wasm');
+      const LibRelaxNGValidator = libxml2.RelaxNGValidator;
+      const { XmlDocument: XmlDocument3 } = libxml2;
+      const doc = XmlDocument3.fromString(xml);
+      try {
+        const schemaContent = await loadSchema(schemaPath);
+        const schemaDoc = XmlDocument3.fromString(schemaContent);
+        try {
+          const validator = LibRelaxNGValidator.fromDoc(schemaDoc);
+          try {
+            validator.validate(doc);
+          } catch (error) {
+            messages.push({
+              id: "RSC-005",
+              severity: "error",
+              message: error instanceof Error ? error.message : "RelaxNG validation failed",
+              location: { path: schemaPath }
+            });
+          } finally {
+            validator.dispose();
+          }
+        } finally {
+          schemaDoc.dispose();
+        }
+      } finally {
+        doc.dispose();
+      }
+    } catch (error) {
+      messages.push({
+        id: "RSC-001",
+        severity: "fatal",
+        message: `Failed to initialize RelaxNG validator: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+    }
+    return messages;
+  }
+};
+
+// src/schema/orchestrator.ts
+var SCHEMA_MAPPINGS = {
+  // EPUB 2.0
+  "2.0": {
+    container: "container.rng",
+    opf: "opf20.rng"
+    // TODO: Add XHTML 2.0 schemas (NVDL format, more complex)
+  },
+  // EPUB 3.x (using RNG format with inlined includes)
+  "3.0": {
+    container: "ocf-container-30.rng",
+    opf: "package-30.rng",
+    nav: "epub-nav-30.rng",
+    xhtml: "epub-xhtml-30.rng",
+    svg: "epub-svg-30.rng"
+  },
+  "3.1": {
+    container: "ocf-container-30.rng",
+    opf: "package-30.rng",
+    nav: "epub-nav-30.rng",
+    xhtml: "epub-xhtml-30.rng",
+    svg: "epub-svg-30.rng"
+  },
+  "3.2": {
+    container: "ocf-container-30.rng",
+    opf: "package-30.rng",
+    nav: "epub-nav-30.rng",
+    xhtml: "epub-xhtml-30.rng",
+    svg: "epub-svg-30.rng"
+  },
+  "3.3": {
+    container: "ocf-container-30.rng",
+    opf: "package-30.rng",
+    nav: "epub-nav-30.rng",
+    xhtml: "epub-xhtml-30.rng",
+    svg: "epub-svg-30.rng"
+  }
+};
+var SchemaValidator = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Run all schema validations
+   */
+  async validate() {
+    const version = this.context.version;
+    const schemas = SCHEMA_MAPPINGS[version];
+    await this.validateContainer(schemas.container);
+    if (this.context.opfPath) {
+      await this.validateOPF(this.context.opfPath, schemas.opf);
+    }
+    if (this.context.packageDocument) {
+      await this.validateManifestItems(schemas);
+    }
+  }
+  /**
+   * Validate container.xml
+   */
+  async validateContainer(schemaPath) {
+    const containerPath = "META-INF/container.xml";
+    const data = this.context.files.get(containerPath);
+    if (!data) {
+      return;
+    }
+    const xml = new TextDecoder().decode(data);
+    const validator = new RelaxNGValidator();
+    const messages = await validator.validate(xml, schemaPath);
+    for (const msg of messages) {
+      this.addMessage({
+        ...msg,
+        location: { ...msg.location, path: containerPath }
+      });
+    }
+  }
+  /**
+   * Validate OPF package document
+   */
+  async validateOPF(opfPath, schemaPath) {
+    const data = this.context.files.get(opfPath);
+    if (!data) {
+      return;
+    }
+    const xml = new TextDecoder().decode(data);
+    const validator = new RelaxNGValidator();
+    const messages = await validator.validate(xml, schemaPath);
+    for (const msg of messages) {
+      this.addMessage({
+        ...msg,
+        location: { ...msg.location, path: opfPath }
+      });
+    }
+  }
+  /**
+   * Validate manifest items (XHTML, SVG, etc.)
+   */
+  async validateManifestItems(schemas) {
+    if (!this.context.packageDocument) {
+      return;
+    }
+    for (const item of this.context.packageDocument.manifest) {
+      if (item.href.startsWith("http") || !isXmlMediaType(item.mediaType)) {
+        continue;
+      }
+      const data = this.context.files.get(item.href);
+      if (!data) {
+        continue;
+      }
+      const xml = new TextDecoder().decode(data);
+      let schemaPath;
+      if (item.properties?.includes("nav") && schemas.nav) {
+        schemaPath = schemas.nav;
+      } else if (item.mediaType === "image/svg+xml" && schemas.svg) {
+        schemaPath = schemas.svg;
+      } else if (item.mediaType === "application/xhtml+xml" && schemas.xhtml) {
+        schemaPath = schemas.xhtml;
+      }
+      if (schemaPath) {
+        const validator = new RelaxNGValidator();
+        const messages = await validator.validate(xml, schemaPath);
+        for (const msg of messages) {
+          this.addMessage({
+            ...msg,
+            location: { ...msg.location, path: item.href }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Add a message to the context with proper filtering
+   */
+  addMessage(message) {
+    const messages = this.context.messages;
+    if (this.context.options.maxErrors > 0 && messages.filter((m) => m.severity === "error" || m.severity === "fatal").length >= this.context.options.maxErrors) {
+      return;
+    }
+    if (!this.context.options.includeUsage && message.severity === "usage") {
+      return;
+    }
+    if (!this.context.options.includeInfo && message.severity === "info") {
+      return;
+    }
+    messages.push(message);
+  }
+};
+function isXmlMediaType(mediaType) {
+  return mediaType === "application/xhtml+xml" || mediaType === "image/svg+xml" || mediaType === "application/oebps-package+xml" || mediaType === "application/x-dtbncx+xml" || mediaType === "application/xml" || mediaType === "text/xml";
+}
+
+// src/checker.ts
+var DEFAULT_OPTIONS = {
+  version: "3.3",
+  profile: "default",
+  includeUsage: false,
+  includeInfo: true,
+  maxErrors: 0,
+  locale: "en"
+};
+var EpubCheck = class _EpubCheck {
+  options;
+  /**
+   * Create a new EpubCheck instance with custom options
+   */
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Validate an EPUB file
+   *
+   * @param data - The EPUB file as a Uint8Array
+   * @returns Validation result
+   */
+  async check(data) {
+    const startTime = performance.now();
+    const context = {
+      data,
+      options: this.options,
+      version: this.options.version,
+      messages: [],
+      files: /* @__PURE__ */ new Map(),
+      rootfiles: []
+    };
+    try {
+      const ocfValidator = new OCFValidator();
+      ocfValidator.validate(context);
+      if (context.messages.some((m) => m.severity === "fatal")) {
+        const elapsedMs2 = performance.now() - startTime;
+        return buildReport(context.messages, context.version, elapsedMs2);
+      }
+      const opfValidator = new OPFValidator();
+      opfValidator.validate(context);
+      const contentValidator = new ContentValidator();
+      contentValidator.validate(context);
+      if (context.version === "2.0" && context.packageDocument) {
+        this.validateNCX(context);
+      }
+      const schemaValidator = new SchemaValidator(context);
+      await schemaValidator.validate();
+    } catch (error) {
+      context.messages.push({
+        id: "PKG-025",
+        severity: "fatal",
+        message: error instanceof Error ? error.message : "Unknown validation error"
+      });
+    }
+    const elapsedMs = performance.now() - startTime;
+    return buildReport(context.messages, context.version, elapsedMs);
+  }
+  /**
+   * Static method to validate an EPUB file with default options
+   *
+   * @param data - The EPUB file as a Uint8Array
+   * @param options - Optional validation options
+   * @returns Validation result
+   */
+  static async validate(data, options = {}) {
+    const checker = new _EpubCheck(options);
+    return checker.check(data);
+  }
+  /**
+   * Get the current EPUB version being validated against
+   */
+  get version() {
+    return this.options.version;
+  }
+  /**
+   * Validate NCX navigation document (EPUB 2.0)
+   */
+  validateNCX(context) {
+    if (!context.packageDocument) {
+      return;
+    }
+    const ncxId = context.packageDocument.spineToc;
+    if (!ncxId) {
+      return;
+    }
+    const ncxItem = context.packageDocument.manifest.find((item) => item.id === ncxId);
+    if (!ncxItem) {
+      return;
+    }
+    const opfPath = context.opfPath ?? "";
+    const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+    const ncxPath = opfDir ? `${opfDir}/${ncxItem.href}` : ncxItem.href;
+    const ncxData = context.files.get(ncxPath);
+    if (!ncxData) {
+      return;
+    }
+    const ncxContent = new TextDecoder().decode(ncxData);
+    const ncxValidator = new NCXValidator();
+    ncxValidator.validate(context, ncxContent, ncxPath);
+    if (context.ncxUid) {
+      const dcIdentifiers = context.packageDocument.dcElements.filter(
+        (dc) => dc.name === "identifier"
+      );
+      for (const dc of dcIdentifiers) {
+        const opfUid = dc.value.trim();
+        if (context.ncxUid !== opfUid) {
+          context.messages.push({
+            id: "NCX-001",
+            severity: "warning",
+            message: `NCX uid "${context.ncxUid}" does not match OPF unique identifier "${opfUid}"`,
+            location: { path: ncxPath }
+          });
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Add a validation message to the context
+   */
+  addMessage(messages, message) {
+    if (this.options.maxErrors > 0 && messages.filter((m) => m.severity === "error" || m.severity === "fatal").length >= this.options.maxErrors) {
+      return;
+    }
+    if (!this.options.includeUsage && message.severity === "usage") {
+      return;
+    }
+    if (!this.options.includeInfo && message.severity === "info") {
+      return;
+    }
+    messages.push(message);
+  }
+};
+
+// src/messages/message-id.ts
+var MessageId = /* @__PURE__ */ ((MessageId2) => {
+  MessageId2["PKG_001"] = "PKG-001";
+  MessageId2["PKG_002"] = "PKG-002";
+  MessageId2["PKG_003"] = "PKG-003";
+  MessageId2["PKG_004"] = "PKG-004";
+  MessageId2["PKG_005"] = "PKG-005";
+  MessageId2["PKG_006"] = "PKG-006";
+  MessageId2["PKG_007"] = "PKG-007";
+  MessageId2["PKG_008"] = "PKG-008";
+  MessageId2["PKG_009"] = "PKG-009";
+  MessageId2["PKG_010"] = "PKG-010";
+  MessageId2["PKG_011"] = "PKG-011";
+  MessageId2["PKG_012"] = "PKG-012";
+  MessageId2["PKG_020"] = "PKG-020";
+  MessageId2["PKG_021"] = "PKG-021";
+  MessageId2["PKG_022"] = "PKG-022";
+  MessageId2["PKG_023"] = "PKG-023";
+  MessageId2["PKG_024"] = "PKG-024";
+  MessageId2["PKG_025"] = "PKG-025";
+  MessageId2["OPF_001"] = "OPF-001";
+  MessageId2["OPF_002"] = "OPF-002";
+  MessageId2["OPF_003"] = "OPF-003";
+  MessageId2["OPF_004"] = "OPF-004";
+  MessageId2["OPF_005"] = "OPF-005";
+  MessageId2["OPF_006"] = "OPF-006";
+  MessageId2["OPF_007"] = "OPF-007";
+  MessageId2["OPF_008"] = "OPF-008";
+  MessageId2["OPF_009"] = "OPF-009";
+  MessageId2["OPF_010"] = "OPF-010";
+  MessageId2["OPF_011"] = "OPF-011";
+  MessageId2["OPF_012"] = "OPF-012";
+  MessageId2["OPF_013"] = "OPF-013";
+  MessageId2["OPF_014"] = "OPF-014";
+  MessageId2["OPF_097"] = "OPF-097";
+  MessageId2["OPF_015"] = "OPF-015";
+  MessageId2["RSC_001"] = "RSC-001";
+  MessageId2["RSC_002"] = "RSC-002";
+  MessageId2["RSC_003"] = "RSC-003";
+  MessageId2["RSC_004"] = "RSC-004";
+  MessageId2["RSC_005"] = "RSC-005";
+  MessageId2["RSC_006"] = "RSC-006";
+  MessageId2["RSC_007"] = "RSC-007";
+  MessageId2["RSC_007w"] = "RSC-007w";
+  MessageId2["RSC_008"] = "RSC-008";
+  MessageId2["RSC_009"] = "RSC-009";
+  MessageId2["RSC_010"] = "RSC-010";
+  MessageId2["RSC_011"] = "RSC-011";
+  MessageId2["RSC_012"] = "RSC-012";
+  MessageId2["RSC_013"] = "RSC-013";
+  MessageId2["RSC_014"] = "RSC-014";
+  MessageId2["RSC_015"] = "RSC-015";
+  MessageId2["RSC_016"] = "RSC-016";
+  MessageId2["RSC_017"] = "RSC-017";
+  MessageId2["RSC_018"] = "RSC-018";
+  MessageId2["RSC_019"] = "RSC-019";
+  MessageId2["RSC_020"] = "RSC-020";
+  MessageId2["RSC_026"] = "RSC-026";
+  MessageId2["RSC_027"] = "RSC-027";
+  MessageId2["RSC_028"] = "RSC-028";
+  MessageId2["RSC_029"] = "RSC-029";
+  MessageId2["RSC_031"] = "RSC-031";
+  MessageId2["HTM_001"] = "HTM-001";
+  MessageId2["HTM_002"] = "HTM-002";
+  MessageId2["HTM_003"] = "HTM-003";
+  MessageId2["HTM_004"] = "HTM-004";
+  MessageId2["HTM_005"] = "HTM-005";
+  MessageId2["HTM_006"] = "HTM-006";
+  MessageId2["HTM_007"] = "HTM-007";
+  MessageId2["HTM_008"] = "HTM-008";
+  MessageId2["HTM_009"] = "HTM-009";
+  MessageId2["HTM_010"] = "HTM-010";
+  MessageId2["HTM_011"] = "HTM-011";
+  MessageId2["HTM_012"] = "HTM-012";
+  MessageId2["HTM_013"] = "HTM-013";
+  MessageId2["HTM_014"] = "HTM-014";
+  MessageId2["HTM_015"] = "HTM-015";
+  MessageId2["HTM_016"] = "HTM-016";
+  MessageId2["HTM_017"] = "HTM-017";
+  MessageId2["HTM_018"] = "HTM-018";
+  MessageId2["HTM_019"] = "HTM-019";
+  MessageId2["HTM_020"] = "HTM-020";
+  MessageId2["HTM_021"] = "HTM-021";
+  MessageId2["HTM_022"] = "HTM-022";
+  MessageId2["HTM_023"] = "HTM-023";
+  MessageId2["HTM_024"] = "HTM-024";
+  MessageId2["HTM_025"] = "HTM-025";
+  MessageId2["HTM_026"] = "HTM-026";
+  MessageId2["HTM_027"] = "HTM-027";
+  MessageId2["HTM_028"] = "HTM-028";
+  MessageId2["HTM_029"] = "HTM-029";
+  MessageId2["HTM_030"] = "HTM-030";
+  MessageId2["HTM_031"] = "HTM-031";
+  MessageId2["HTM_032"] = "HTM-032";
+  MessageId2["HTM_033"] = "HTM-033";
+  MessageId2["CSS_001"] = "CSS-001";
+  MessageId2["CSS_002"] = "CSS-002";
+  MessageId2["CSS_003"] = "CSS-003";
+  MessageId2["CSS_004"] = "CSS-004";
+  MessageId2["CSS_005"] = "CSS-005";
+  MessageId2["CSS_006"] = "CSS-006";
+  MessageId2["CSS_007"] = "CSS-007";
+  MessageId2["CSS_008"] = "CSS-008";
+  MessageId2["CSS_009"] = "CSS-009";
+  MessageId2["CSS_010"] = "CSS-010";
+  MessageId2["CSS_011"] = "CSS-011";
+  MessageId2["CSS_012"] = "CSS-012";
+  MessageId2["CSS_015"] = "CSS-015";
+  MessageId2["CSS_016"] = "CSS-016";
+  MessageId2["CSS_017"] = "CSS-017";
+  MessageId2["CSS_019"] = "CSS-019";
+  MessageId2["CSS_020"] = "CSS-020";
+  MessageId2["CSS_021"] = "CSS-021";
+  MessageId2["CSS_022"] = "CSS-022";
+  MessageId2["CSS_023"] = "CSS-023";
+  MessageId2["NAV_001"] = "NAV-001";
+  MessageId2["NAV_002"] = "NAV-002";
+  MessageId2["NAV_003"] = "NAV-003";
+  MessageId2["NAV_004"] = "NAV-004";
+  MessageId2["NAV_005"] = "NAV-005";
+  MessageId2["NAV_006"] = "NAV-006";
+  MessageId2["NAV_007"] = "NAV-007";
+  MessageId2["NAV_008"] = "NAV-008";
+  MessageId2["NAV_009"] = "NAV-009";
+  MessageId2["NCX_001"] = "NCX-001";
+  MessageId2["NCX_002"] = "NCX-002";
+  MessageId2["NCX_003"] = "NCX-003";
+  MessageId2["NCX_004"] = "NCX-004";
+  MessageId2["NCX_005"] = "NCX-005";
+  MessageId2["ACC_001"] = "ACC-001";
+  MessageId2["ACC_002"] = "ACC-002";
+  MessageId2["ACC_003"] = "ACC-003";
+  MessageId2["ACC_004"] = "ACC-004";
+  MessageId2["ACC_005"] = "ACC-005";
+  MessageId2["ACC_006"] = "ACC-006";
+  MessageId2["ACC_007"] = "ACC-007";
+  MessageId2["ACC_008"] = "ACC-008";
+  MessageId2["ACC_009"] = "ACC-009";
+  MessageId2["ACC_010"] = "ACC-010";
+  MessageId2["ACC_011"] = "ACC-011";
+  MessageId2["ACC_012"] = "ACC-012";
+  MessageId2["ACC_013"] = "ACC-013";
+  MessageId2["ACC_014"] = "ACC-014";
+  MessageId2["ACC_015"] = "ACC-015";
+  MessageId2["ACC_016"] = "ACC-016";
+  MessageId2["ACC_017"] = "ACC-017";
+  MessageId2["MED_001"] = "MED-001";
+  MessageId2["MED_002"] = "MED-002";
+  MessageId2["MED_003"] = "MED-003";
+  MessageId2["MED_004"] = "MED-004";
+  MessageId2["MED_005"] = "MED-005";
+  MessageId2["MED_006"] = "MED-006";
+  MessageId2["MED_007"] = "MED-007";
+  MessageId2["MED_008"] = "MED-008";
+  MessageId2["MED_009"] = "MED-009";
+  MessageId2["MED_010"] = "MED-010";
+  MessageId2["MED_011"] = "MED-011";
+  MessageId2["MED_012"] = "MED-012";
+  MessageId2["MED_013"] = "MED-013";
+  MessageId2["MED_014"] = "MED-014";
+  MessageId2["MED_015"] = "MED-015";
+  MessageId2["SCP_001"] = "SCP-001";
+  MessageId2["SCP_002"] = "SCP-002";
+  MessageId2["SCP_003"] = "SCP-003";
+  MessageId2["SCP_004"] = "SCP-004";
+  MessageId2["SCP_005"] = "SCP-005";
+  MessageId2["SCP_006"] = "SCP-006";
+  MessageId2["SCP_007"] = "SCP-007";
+  MessageId2["SCP_008"] = "SCP-008";
+  MessageId2["SCP_009"] = "SCP-009";
+  MessageId2["SCP_010"] = "SCP-010";
+  MessageId2["CHK_001"] = "CHK-001";
+  MessageId2["CHK_002"] = "CHK-002";
+  MessageId2["CHK_003"] = "CHK-003";
+  MessageId2["CHK_004"] = "CHK-004";
+  MessageId2["CHK_005"] = "CHK-005";
+  MessageId2["CHK_006"] = "CHK-006";
+  MessageId2["CHK_007"] = "CHK-007";
+  return MessageId2;
+})(MessageId || {});
+
+exports.EpubCheck = EpubCheck;
+exports.MessageId = MessageId;
+exports.buildReport = buildReport;
+exports.countBySeverity = countBySeverity;
+exports.filterByPath = filterByPath;
+exports.filterBySeverity = filterBySeverity;
+exports.formatMessages = formatMessages;
+exports.toJSONReport = toJSONReport;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map