@readium/navigator-html-injectables 1.2.0

package/dist/index.js

@@ -0,0 +1,3144 @@
+const Mt = Math.pow(2, 32), Ae = () => Math.round(Math.random() * Mt).toString(36), Nt = () => `${Math.round(performance.now())}-${Ae()}-${Ae()}`, X = 1;
+class Rt {
+  constructor(e) {
+    this.destination = null, this.registrar = /* @__PURE__ */ new Map(), this.origin = "", this.channelId = "", this.receiver = this.receive.bind(this), this.preLog = [], this.wnd = e, e.addEventListener("message", this.receiver);
+  }
+  receive(e) {
+    if (e.source === null)
+      throw Error("Event source is null");
+    if (typeof e.data != "object")
+      return;
+    const t = e.data;
+    if (!(!("_readium" in t) || !t._readium || t._readium <= 0)) {
+      if (t.key === "_ping") {
+        if (!this.destination) {
+          if (this.destination = e.source, this.origin = e.origin, this.channelId = t._channel, t._readium !== X) {
+            t._readium > X ? this.send("error", `received comms version ${t._readium} higher than ${X}`) : this.send("error", `received comms version ${t._readium} lower than ${X}`), this.destination = null, this.origin = "", this.channelId = "";
+            return;
+          }
+          this.send("_pong", void 0), this.preLog.forEach((r) => this.send("log", r)), this.preLog = [];
+        }
+        return;
+      } else if (this.channelId) {
+        if (t._channel !== this.channelId || e.origin !== this.origin)
+          return;
+      } else
+        return;
+      this.handle(t);
+    }
+  }
+  handle(e) {
+    const t = this.registrar.get(e.key);
+    if (!t || t.length === 0) {
+      e.strict && this.send("_unhandled", e);
+      return;
+    }
+    t.forEach((r) => r.cb(e.data, (s) => {
+      this.send("_ack", s, e.id);
+    }));
+  }
+  register(e, t, r) {
+    Array.isArray(e) || (e = [e]), e.forEach((s) => {
+      const n = this.registrar.get(s);
+      if (n && n.length >= 0) {
+        if (n.find((a) => a.module === t))
+          throw new Error(`Trying to register another callback for combination of event ${s} and module ${t}`);
+        n.push({
+          cb: r,
+          module: t
+        }), this.registrar.set(s, n);
+      } else
+        this.registrar.set(s, [{
+          cb: r,
+          module: t
+        }]);
+    });
+  }
+  unregister(e, t) {
+    Array.isArray(e) || (e = [e]), e.forEach((r) => {
+      const s = this.registrar.get(r);
+      !s || s.length === 0 || s.splice(s.findIndex((n) => n.module === t), 1);
+    });
+  }
+  unregisterAll(e) {
+    this.registrar.forEach((t, r) => this.registrar.set(r, t.filter((s) => s.module !== e)));
+  }
+  log(...e) {
+    this.destination ? this.send("log", e) : this.preLog.push(e);
+  }
+  get ready() {
+    return !!this.destination;
+  }
+  destroy() {
+    this.destination = null, this.channelId = "", this.preLog = [], this.registrar.clear(), this.wnd.removeEventListener("message", this.receiver);
+  }
+  send(e, t, r = void 0, s = []) {
+    if (!this.destination)
+      throw Error("Attempted to send comms message before destination has been initialized");
+    const n = {
+      _readium: X,
+      _channel: this.channelId,
+      id: r ?? Nt(),
+      // scrict,
+      key: e,
+      data: t
+    };
+    try {
+      this.destination.postMessage(n, {
+        targetOrigin: this.origin,
+        transfer: s
+      });
+    } catch (o) {
+      if (s.length > 0)
+        throw o;
+      this.destination.postMessage(n, this.origin, s);
+    }
+  }
+}
+class ce {
+}
+var F = [], Lt = function() {
+  return F.some(function(i) {
+    return i.activeTargets.length > 0;
+  });
+}, zt = function() {
+  return F.some(function(i) {
+    return i.skippedTargets.length > 0;
+  });
+}, Me = "ResizeObserver loop completed with undelivered notifications.", It = function() {
+  var i;
+  typeof ErrorEvent == "function" ? i = new ErrorEvent("error", {
+    message: Me
+  }) : (i = document.createEvent("Event"), i.initEvent("error", !1, !1), i.message = Me), window.dispatchEvent(i);
+}, G;
+(function(i) {
+  i.BORDER_BOX = "border-box", i.CONTENT_BOX = "content-box", i.DEVICE_PIXEL_CONTENT_BOX = "device-pixel-content-box";
+})(G || (G = {}));
+var k = function(i) {
+  return Object.freeze(i);
+}, Bt = function() {
+  function i(e, t) {
+    this.inlineSize = e, this.blockSize = t, k(this);
+  }
+  return i;
+}(), Qe = function() {
+  function i(e, t, r, s) {
+    return this.x = e, this.y = t, this.width = r, this.height = s, this.top = this.y, this.left = this.x, this.bottom = this.top + this.height, this.right = this.left + this.width, k(this);
+  }
+  return i.prototype.toJSON = function() {
+    var e = this, t = e.x, r = e.y, s = e.top, n = e.right, o = e.bottom, a = e.left, h = e.width, c = e.height;
+    return { x: t, y: r, top: s, right: n, bottom: o, left: a, width: h, height: c };
+  }, i.fromRect = function(e) {
+    return new i(e.x, e.y, e.width, e.height);
+  }, i;
+}(), Ee = function(i) {
+  return i instanceof SVGElement && "getBBox" in i;
+}, et = function(i) {
+  if (Ee(i)) {
+    var e = i.getBBox(), t = e.width, r = e.height;
+    return !t && !r;
+  }
+  var s = i, n = s.offsetWidth, o = s.offsetHeight;
+  return !(n || o || i.getClientRects().length);
+}, Ne = function(i) {
+  var e;
+  if (i instanceof Element)
+    return !0;
+  var t = (e = i == null ? void 0 : i.ownerDocument) === null || e === void 0 ? void 0 : e.defaultView;
+  return !!(t && i instanceof t.Element);
+}, Dt = function(i) {
+  switch (i.tagName) {
+    case "INPUT":
+      if (i.type !== "image")
+        break;
+    case "VIDEO":
+    case "AUDIO":
+    case "EMBED":
+    case "OBJECT":
+    case "CANVAS":
+    case "IFRAME":
+    case "IMG":
+      return !0;
+  }
+  return !1;
+}, _ = typeof window < "u" ? window : {}, Q = /* @__PURE__ */ new WeakMap(), Re = /auto|scroll/, Wt = /^tb|vertical/, Ft = /msie|trident/i.test(_.navigator && _.navigator.userAgent), N = function(i) {
+  return parseFloat(i || "0");
+}, $ = function(i, e, t) {
+  return i === void 0 && (i = 0), e === void 0 && (e = 0), t === void 0 && (t = !1), new Bt((t ? e : i) || 0, (t ? i : e) || 0);
+}, Le = k({
+  devicePixelContentBoxSize: $(),
+  borderBoxSize: $(),
+  contentBoxSize: $(),
+  contentRect: new Qe(0, 0, 0, 0)
+}), tt = function(i, e) {
+  if (e === void 0 && (e = !1), Q.has(i) && !e)
+    return Q.get(i);
+  if (et(i))
+    return Q.set(i, Le), Le;
+  var t = getComputedStyle(i), r = Ee(i) && i.ownerSVGElement && i.getBBox(), s = !Ft && t.boxSizing === "border-box", n = Wt.test(t.writingMode || ""), o = !r && Re.test(t.overflowY || ""), a = !r && Re.test(t.overflowX || ""), h = r ? 0 : N(t.paddingTop), c = r ? 0 : N(t.paddingRight), d = r ? 0 : N(t.paddingBottom), p = r ? 0 : N(t.paddingLeft), u = r ? 0 : N(t.borderTopWidth), f = r ? 0 : N(t.borderRightWidth), v = r ? 0 : N(t.borderBottomWidth), g = r ? 0 : N(t.borderLeftWidth), y = p + c, x = h + d, S = g + f, m = u + v, E = a ? i.offsetHeight - m - i.clientHeight : 0, O = o ? i.offsetWidth - S - i.clientWidth : 0, Y = s ? y + S : 0, Z = s ? x + m : 0, B = r ? r.width : N(t.width) - Y - O, D = r ? r.height : N(t.height) - Z - E, K = B + y + O + S, J = D + x + E + m, U = k({
+    devicePixelContentBoxSize: $(Math.round(B * devicePixelRatio), Math.round(D * devicePixelRatio), n),
+    borderBoxSize: $(K, J, n),
+    contentBoxSize: $(B, D, n),
+    contentRect: new Qe(p, h, B, D)
+  });
+  return Q.set(i, U), U;
+}, it = function(i, e, t) {
+  var r = tt(i, t), s = r.borderBoxSize, n = r.contentBoxSize, o = r.devicePixelContentBoxSize;
+  switch (e) {
+    case G.DEVICE_PIXEL_CONTENT_BOX:
+      return o;
+    case G.BORDER_BOX:
+      return s;
+    default:
+      return n;
+  }
+}, kt = function() {
+  function i(e) {
+    var t = tt(e);
+    this.target = e, this.contentRect = t.contentRect, this.borderBoxSize = k([t.borderBoxSize]), this.contentBoxSize = k([t.contentBoxSize]), this.devicePixelContentBoxSize = k([t.devicePixelContentBoxSize]);
+  }
+  return i;
+}(), rt = function(i) {
+  if (et(i))
+    return 1 / 0;
+  for (var e = 0, t = i.parentNode; t; )
+    e += 1, t = t.parentNode;
+  return e;
+}, Ut = function() {
+  var i = 1 / 0, e = [];
+  F.forEach(function(o) {
+    if (o.activeTargets.length !== 0) {
+      var a = [];
+      o.activeTargets.forEach(function(c) {
+        var d = new kt(c.target), p = rt(c.target);
+        a.push(d), c.lastReportedSize = it(c.target, c.observedBox), p < i && (i = p);
+      }), e.push(function() {
+        o.callback.call(o.observer, a, o.observer);
+      }), o.activeTargets.splice(0, o.activeTargets.length);
+    }
+  });
+  for (var t = 0, r = e; t < r.length; t++) {
+    var s = r[t];
+    s();
+  }
+  return i;
+}, ze = function(i) {
+  F.forEach(function(t) {
+    t.activeTargets.splice(0, t.activeTargets.length), t.skippedTargets.splice(0, t.skippedTargets.length), t.observationTargets.forEach(function(s) {
+      s.isActive() && (rt(s.target) > i ? t.activeTargets.push(s) : t.skippedTargets.push(s));
+    });
+  });
+}, $t = function() {
+  var i = 0;
+  for (ze(i); Lt(); )
+    i = Ut(), ze(i);
+  return zt() && It(), i > 0;
+}, de, st = [], Ht = function() {
+  return st.splice(0).forEach(function(i) {
+    return i();
+  });
+}, qt = function(i) {
+  if (!de) {
+    var e = 0, t = document.createTextNode(""), r = { characterData: !0 };
+    new MutationObserver(function() {
+      return Ht();
+    }).observe(t, r), de = function() {
+      t.textContent = "".concat(e ? e-- : e++);
+    };
+  }
+  st.push(i), de();
+}, Xt = function(i) {
+  qt(function() {
+    requestAnimationFrame(i);
+  });
+}, re = 0, Vt = function() {
+  return !!re;
+}, _t = 250, jt = { attributes: !0, characterData: !0, childList: !0, subtree: !0 }, Ie = [
+  "resize",
+  "load",
+  "transitionend",
+  "animationend",
+  "animationstart",
+  "animationiteration",
+  "keyup",
+  "keydown",
+  "mouseup",
+  "mousedown",
+  "mouseover",
+  "mouseout",
+  "blur",
+  "focus"
+], Be = function(i) {
+  return i === void 0 && (i = 0), Date.now() + i;
+}, ue = !1, Gt = function() {
+  function i() {
+    var e = this;
+    this.stopped = !0, this.listener = function() {
+      return e.schedule();
+    };
+  }
+  return i.prototype.run = function(e) {
+    var t = this;
+    if (e === void 0 && (e = _t), !ue) {
+      ue = !0;
+      var r = Be(e);
+      Xt(function() {
+        var s = !1;
+        try {
+          s = $t();
+        } finally {
+          if (ue = !1, e = r - Be(), !Vt())
+            return;
+          s ? t.run(1e3) : e > 0 ? t.run(e) : t.start();
+        }
+      });
+    }
+  }, i.prototype.schedule = function() {
+    this.stop(), this.run();
+  }, i.prototype.observe = function() {
+    var e = this, t = function() {
+      return e.observer && e.observer.observe(document.body, jt);
+    };
+    document.body ? t() : _.addEventListener("DOMContentLoaded", t);
+  }, i.prototype.start = function() {
+    var e = this;
+    this.stopped && (this.stopped = !1, this.observer = new MutationObserver(this.listener), this.observe(), Ie.forEach(function(t) {
+      return _.addEventListener(t, e.listener, !0);
+    }));
+  }, i.prototype.stop = function() {
+    var e = this;
+    this.stopped || (this.observer && this.observer.disconnect(), Ie.forEach(function(t) {
+      return _.removeEventListener(t, e.listener, !0);
+    }), this.stopped = !0);
+  }, i;
+}(), fe = new Gt(), De = function(i) {
+  !re && i > 0 && fe.start(), re += i, !re && fe.stop();
+}, Yt = function(i) {
+  return !Ee(i) && !Dt(i) && getComputedStyle(i).display === "inline";
+}, Zt = function() {
+  function i(e, t) {
+    this.target = e, this.observedBox = t || G.CONTENT_BOX, this.lastReportedSize = {
+      inlineSize: 0,
+      blockSize: 0
+    };
+  }
+  return i.prototype.isActive = function() {
+    var e = it(this.target, this.observedBox, !0);
+    return Yt(this.target) && (this.lastReportedSize = e), this.lastReportedSize.inlineSize !== e.inlineSize || this.lastReportedSize.blockSize !== e.blockSize;
+  }, i;
+}(), Kt = function() {
+  function i(e, t) {
+    this.activeTargets = [], this.skippedTargets = [], this.observationTargets = [], this.observer = e, this.callback = t;
+  }
+  return i;
+}(), ee = /* @__PURE__ */ new WeakMap(), We = function(i, e) {
+  for (var t = 0; t < i.length; t += 1)
+    if (i[t].target === e)
+      return t;
+  return -1;
+}, te = function() {
+  function i() {
+  }
+  return i.connect = function(e, t) {
+    var r = new Kt(e, t);
+    ee.set(e, r);
+  }, i.observe = function(e, t, r) {
+    var s = ee.get(e), n = s.observationTargets.length === 0;
+    We(s.observationTargets, t) < 0 && (n && F.push(s), s.observationTargets.push(new Zt(t, r && r.box)), De(1), fe.schedule());
+  }, i.unobserve = function(e, t) {
+    var r = ee.get(e), s = We(r.observationTargets, t), n = r.observationTargets.length === 1;
+    s >= 0 && (n && F.splice(F.indexOf(r), 1), r.observationTargets.splice(s, 1), De(-1));
+  }, i.disconnect = function(e) {
+    var t = this, r = ee.get(e);
+    r.observationTargets.slice().forEach(function(s) {
+      return t.unobserve(e, s.target);
+    }), r.activeTargets.splice(0, r.activeTargets.length);
+  }, i;
+}(), nt = function() {
+  function i(e) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (typeof e != "function")
+      throw new TypeError("Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function.");
+    te.connect(this, e);
+  }
+  return i.prototype.observe = function(e, t) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (!Ne(e))
+      throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element");
+    te.observe(this, e, t);
+  }, i.prototype.unobserve = function(e) {
+    if (arguments.length === 0)
+      throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present.");
+    if (!Ne(e))
+      throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element");
+    te.unobserve(this, e);
+  }, i.prototype.disconnect = function() {
+    te.disconnect(this);
+  }, i.toString = function() {
+    return "function ResizeObserver () { [polyfill code] }";
+  }, i;
+}();
+const Fe = "readium-snapper-style", ot = class me extends ce {
+  constructor() {
+    super(...arguments), this.protected = !1;
+  }
+  buildStyles() {
+    return `
+        html, body {
+            touch-action: manipulation;
+            user-select: ${this.protected ? "none" : "auto"};
+        }`;
+  }
+  mount(e, t) {
+    const r = e.document.createElement("style");
+    return r.dataset.readium = "true", r.id = Fe, r.textContent = this.buildStyles(), e.document.head.appendChild(r), t.register("protect", me.moduleName, (s, n) => {
+      this.protected = !0, r.textContent = this.buildStyles(), n(!0);
+    }), t.register("unprotect", me.moduleName, (s, n) => {
+      this.protected = !1, r.textContent = this.buildStyles(), n(!0);
+    }), t.log("Snapper Mounted"), !0;
+  }
+  unmount(e, t) {
+    var r;
+    return (r = e.document.getElementById(Fe)) == null || r.remove(), t.log("Snapper Unmounted"), !0;
+  }
+};
+ot.moduleName = "snapper";
+let at = ot;
+function W(i) {
+  return i.document.body.dir.toLowerCase() === "rtl";
+}
+function lt(i) {
+  return parseInt(
+    i.getComputedStyle(
+      i.document.documentElement
+    ).getPropertyValue("column-count")
+  );
+}
+function Jt(i) {
+  const e = "readium-virtual-page";
+  let t = i.document.getElementById(e);
+  if (lt(i) !== 2)
+    t && t.remove();
+  else {
+    const s = i.document.scrollingElement.scrollWidth / i.innerWidth;
+    Math.round(s * 2) / 2 % 1 > 0.1 && (t ? t.remove() : (t = i.document.createElement("div"), t.setAttribute("id", e), t.dataset.readium = "true", t.style.breakBefore = "column", t.innerHTML = "&#8203;", i.document.body.appendChild(t)));
+  }
+}
+function Qt(i) {
+  return i < 0.5 ? 2 * i * i : -1 + (4 - 2 * i) * i;
+}
+class xe {
+  /**
+   * Creates a [Encryption].
+   */
+  constructor(e) {
+    this.algorithm = e.algorithm, this.compression = e.compression, this.originalLength = e.originalLength, this.profile = e.profile, this.scheme = e.scheme;
+  }
+  /**
+   * Parses a [Encryption] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e.algorithm)
+      return new xe({
+        algorithm: e.algorithm,
+        compression: e.compression,
+        originalLength: e.originalLength,
+        profile: e.profile,
+        scheme: e.scheme
+      });
+  }
+  /**
+   * Serializes a [Encryption] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { algorithm: this.algorithm };
+    return this.compression !== void 0 && (e.compression = this.compression), this.originalLength !== void 0 && (e.originalLength = this.originalLength), this.profile !== void 0 && (e.profile = this.profile), this.scheme !== void 0 && (e.scheme = this.scheme), e;
+  }
+}
+class b {
+  constructor(e) {
+    this.otherProperties = e;
+  }
+  /**
+   * Creates a [Properties] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e)
+      return new b(e);
+  }
+  /**
+   * Serializes a [Properties] to its RWPM JSON representation.
+   */
+  serialize() {
+    return this.otherProperties;
+  }
+  /**
+   * Makes a copy of this [Properties] after merging in the given additional other [properties].
+   */
+  add(e) {
+    const t = Object.assign({}, this.otherProperties);
+    for (const r in e)
+      t[r] = e[r];
+    return new b(t);
+  }
+}
+Object.defineProperty(b.prototype, "encryption", {
+  get: function() {
+    return xe.deserialize(this.otherProperties.encrypted);
+  }
+});
+b.prototype.getContains = function() {
+  return new Set(this.otherProperties.contains || []);
+};
+b.prototype.getLayout = function() {
+  return this.otherProperties.layout;
+};
+class l {
+  /** Creates a MediaType object. */
+  constructor(e) {
+    let t, r, s = e.mediaType.replace(/\s/g, "").split(";");
+    const n = s[0].split("/");
+    if (n.length === 2) {
+      if (t = n[0].toLowerCase().trim(), r = n[1].toLowerCase().trim(), t.length === 0 || r.length === 0)
+        throw new Error("Invalid media type");
+    } else
+      throw new Error("Invalid media type");
+    const o = {};
+    for (let u = 1; u < s.length; u++) {
+      const f = s[u].split("=");
+      if (f.length === 2) {
+        const v = f[0].toLocaleLowerCase(), g = v === "charset" ? f[1].toUpperCase() : f[1];
+        o[v] = g;
+      }
+    }
+    const a = {}, h = Object.keys(o);
+    h.sort((u, f) => u.localeCompare(f)), h.forEach((u) => a[u] = o[u]);
+    let c = "";
+    for (const u in a) {
+      const f = a[u];
+      c += `;${u}=${f}`;
+    }
+    const d = `${t}/${r}${c}`, p = a.encoding;
+    this.string = d, this.type = t, this.subtype = r, this.parameters = a, this.encoding = p, this.name = e.name, this.fileExtension = e.fileExtension;
+  }
+  static parse(e) {
+    return new l(e);
+  }
+  /** Structured syntax suffix, e.g. `+zip` in `application/epub+zip`.
+   *  Gives a hint on the underlying structure of this media type.
+   *  See. https://tools.ietf.org/html/rfc6838#section-4.2.8
+   */
+  get structuredSyntaxSuffix() {
+    const e = this.subtype.split("+");
+    return e.length > 1 ? `+${e[e.length - 1]}` : void 0;
+  }
+  /** Parameter values might or might not be case-sensitive, depending on the semantics of
+   * the parameter name.
+   * https://tools.ietf.org/html/rfc2616#section-3.7
+   *
+   * The character set names may be up to 40 characters taken from the printable characters
+   * of US-ASCII.  However, no distinction is made between use of upper and lower case
+   * letters.
+   * https://www.iana.org/assignments/character-sets/character-sets.xhtml
+   */
+  get charset() {
+    return this.parameters.charset;
+  }
+  /** Returns whether the given `other` media type is included in this media type.
+   *  For example, `text/html` contains `text/html;charset=utf-8`.
+   *  - `other` must match the parameters in the `parameters` property, but extra parameters
+   *  are ignored.
+   *  - Order of parameters is ignored.
+   *  - Wildcards are supported, meaning that `image/*` contains `image/png`
+   */
+  contains(e) {
+    const t = typeof e == "string" ? l.parse({ mediaType: e }) : e;
+    if (!((this.type === "*" || this.type === t.type) && (this.subtype === "*" || this.subtype === t.subtype)))
+      return !1;
+    const r = new Set(
+      Object.entries(this.parameters).map(([n, o]) => `${n}=${o}`)
+    ), s = new Set(
+      Object.entries(t.parameters).map(([n, o]) => `${n}=${o}`)
+    );
+    for (const n of Array.from(r.values()))
+      if (!s.has(n))
+        return !1;
+    return !0;
+  }
+  /** Returns whether this media type and `other` are the same, ignoring parameters that
+   *  are not in both media types.
+   *  For example, `text/html` matches `text/html;charset=utf-8`, but `text/html;charset=ascii`
+   *  doesn't. This is basically like `contains`, but working in both direction.
+   */
+  matches(e) {
+    const t = typeof e == "string" ? l.parse({ mediaType: e }) : e;
+    return this.contains(t) || t.contains(this);
+  }
+  /**
+   * Returns whether this media type matches any of the [others] media types.
+   */
+  matchesAny(...e) {
+    for (const t of e)
+      if (this.matches(t))
+        return !0;
+    return !1;
+  }
+  /** Checks the MediaType equals another one (comparing their string) */
+  equals(e) {
+    return this.string === e.string;
+  }
+  /** Returns whether this media type is structured as a ZIP archive. */
+  get isZIP() {
+    return this.matchesAny(
+      l.ZIP,
+      l.LCP_PROTECTED_AUDIOBOOK,
+      l.LCP_PROTECTED_PDF
+    ) || this.structuredSyntaxSuffix === "+zip";
+  }
+  /** Returns whether this media type is structured as a JSON file. */
+  get isJSON() {
+    return this.matchesAny(l.JSON) || this.structuredSyntaxSuffix === "+json";
+  }
+  /** Returns whether this media type is of an OPDS feed. */
+  get isOPDS() {
+    return this.matchesAny(
+      l.OPDS1,
+      l.OPDS1_ENTRY,
+      l.OPDS2,
+      l.OPDS2_PUBLICATION,
+      l.OPDS_AUTHENTICATION
+    ) || this.structuredSyntaxSuffix === "+json";
+  }
+  /** Returns whether this media type is of an HTML document. */
+  get isHTML() {
+    return this.matchesAny(l.HTML, l.XHTML);
+  }
+  /** Returns whether this media type is of a bitmap image, so excluding vectorial formats. */
+  get isBitmap() {
+    return this.matchesAny(
+      l.BMP,
+      l.GIF,
+      l.JPEG,
+      l.PNG,
+      l.TIFF,
+      l.WEBP
+    );
+  }
+  /** Returns whether this media type is of an audio clip. */
+  get isAudio() {
+    return this.type === "audio";
+  }
+  /** Returns whether this media type is of a video clip. */
+  get isVideo() {
+    return this.type === "video";
+  }
+  /** Returns whether this media type is of a Readium Web Publication Manifest. */
+  get isRWPM() {
+    return this.matchesAny(
+      l.READIUM_AUDIOBOOK_MANIFEST,
+      l.DIVINA_MANIFEST,
+      l.READIUM_WEBPUB_MANIFEST
+    );
+  }
+  /** Returns whether this media type is of a publication file. */
+  get isPublication() {
+    return this.matchesAny(
+      l.READIUM_AUDIOBOOK,
+      l.READIUM_AUDIOBOOK_MANIFEST,
+      l.CBZ,
+      l.DIVINA,
+      l.DIVINA_MANIFEST,
+      l.EPUB,
+      l.LCP_PROTECTED_AUDIOBOOK,
+      l.LCP_PROTECTED_PDF,
+      l.LPF,
+      l.PDF,
+      l.W3C_WPUB_MANIFEST,
+      l.READIUM_WEBPUB,
+      l.READIUM_WEBPUB_MANIFEST,
+      l.ZAB
+    );
+  }
+  // Known Media Types
+  static get AAC() {
+    return l.parse({ mediaType: "audio/aac", fileExtension: "aac" });
+  }
+  static get ACSM() {
+    return l.parse({
+      mediaType: "application/vnd.adobe.adept+xml",
+      name: "Adobe Content Server Message",
+      fileExtension: "acsm"
+    });
+  }
+  static get AIFF() {
+    return l.parse({ mediaType: "audio/aiff", fileExtension: "aiff" });
+  }
+  static get AVI() {
+    return l.parse({
+      mediaType: "video/x-msvideo",
+      fileExtension: "avi"
+    });
+  }
+  static get BINARY() {
+    return l.parse({ mediaType: "application/octet-stream" });
+  }
+  static get BMP() {
+    return l.parse({ mediaType: "image/bmp", fileExtension: "bmp" });
+  }
+  static get CBZ() {
+    return l.parse({
+      mediaType: "application/vnd.comicbook+zip",
+      name: "Comic Book Archive",
+      fileExtension: "cbz"
+    });
+  }
+  static get CSS() {
+    return l.parse({ mediaType: "text/css", fileExtension: "css" });
+  }
+  static get DIVINA() {
+    return l.parse({
+      mediaType: "application/divina+zip",
+      name: "Digital Visual Narratives",
+      fileExtension: "divina"
+    });
+  }
+  static get DIVINA_MANIFEST() {
+    return l.parse({
+      mediaType: "application/divina+json",
+      name: "Digital Visual Narratives",
+      fileExtension: "json"
+    });
+  }
+  static get EPUB() {
+    return l.parse({
+      mediaType: "application/epub+zip",
+      name: "EPUB",
+      fileExtension: "epub"
+    });
+  }
+  static get GIF() {
+    return l.parse({ mediaType: "image/gif", fileExtension: "gif" });
+  }
+  static get GZ() {
+    return l.parse({
+      mediaType: "application/gzip",
+      fileExtension: "gz"
+    });
+  }
+  static get HTML() {
+    return l.parse({ mediaType: "text/html", fileExtension: "html" });
+  }
+  static get JAVASCRIPT() {
+    return l.parse({
+      mediaType: "text/javascript",
+      fileExtension: "js"
+    });
+  }
+  static get JPEG() {
+    return l.parse({ mediaType: "image/jpeg", fileExtension: "jpeg" });
+  }
+  static get JSON() {
+    return l.parse({ mediaType: "application/json" });
+  }
+  static get LCP_LICENSE_DOCUMENT() {
+    return l.parse({
+      mediaType: "application/vnd.readium.lcp.license.v1.0+json",
+      name: "LCP License",
+      fileExtension: "lcpl"
+    });
+  }
+  static get LCP_PROTECTED_AUDIOBOOK() {
+    return l.parse({
+      mediaType: "application/audiobook+lcp",
+      name: "LCP Protected Audiobook",
+      fileExtension: "lcpa"
+    });
+  }
+  static get LCP_PROTECTED_PDF() {
+    return l.parse({
+      mediaType: "application/pdf+lcp",
+      name: "LCP Protected PDF",
+      fileExtension: "lcpdf"
+    });
+  }
+  static get LCP_STATUS_DOCUMENT() {
+    return l.parse({
+      mediaType: "application/vnd.readium.license.status.v1.0+json"
+    });
+  }
+  static get LPF() {
+    return l.parse({
+      mediaType: "application/lpf+zip",
+      fileExtension: "lpf"
+    });
+  }
+  static get MP3() {
+    return l.parse({ mediaType: "audio/mpeg", fileExtension: "mp3" });
+  }
+  static get MPEG() {
+    return l.parse({ mediaType: "video/mpeg", fileExtension: "mpeg" });
+  }
+  static get NCX() {
+    return l.parse({
+      mediaType: "application/x-dtbncx+xml",
+      fileExtension: "ncx"
+    });
+  }
+  static get OGG() {
+    return l.parse({ mediaType: "audio/ogg", fileExtension: "oga" });
+  }
+  static get OGV() {
+    return l.parse({ mediaType: "video/ogg", fileExtension: "ogv" });
+  }
+  static get OPDS1() {
+    return l.parse({
+      mediaType: "application/atom+xml;profile=opds-catalog"
+    });
+  }
+  static get OPDS1_ENTRY() {
+    return l.parse({
+      mediaType: "application/atom+xml;type=entry;profile=opds-catalog"
+    });
+  }
+  static get OPDS2() {
+    return l.parse({ mediaType: "application/opds+json" });
+  }
+  static get OPDS2_PUBLICATION() {
+    return l.parse({ mediaType: "application/opds-publication+json" });
+  }
+  static get OPDS_AUTHENTICATION() {
+    return l.parse({
+      mediaType: "application/opds-authentication+json"
+    });
+  }
+  static get OPUS() {
+    return l.parse({ mediaType: "audio/opus", fileExtension: "opus" });
+  }
+  static get OTF() {
+    return l.parse({ mediaType: "font/otf", fileExtension: "otf" });
+  }
+  static get PDF() {
+    return l.parse({
+      mediaType: "application/pdf",
+      name: "PDF",
+      fileExtension: "pdf"
+    });
+  }
+  static get PNG() {
+    return l.parse({ mediaType: "image/png", fileExtension: "png" });
+  }
+  static get READIUM_AUDIOBOOK() {
+    return l.parse({
+      mediaType: "application/audiobook+zip",
+      name: "Readium Audiobook",
+      fileExtension: "audiobook"
+    });
+  }
+  static get READIUM_AUDIOBOOK_MANIFEST() {
+    return l.parse({
+      mediaType: "application/audiobook+json",
+      name: "Readium Audiobook",
+      fileExtension: "json"
+    });
+  }
+  static get READIUM_WEBPUB() {
+    return l.parse({
+      mediaType: "application/webpub+zip",
+      name: "Readium Web Publication",
+      fileExtension: "webpub"
+    });
+  }
+  static get READIUM_WEBPUB_MANIFEST() {
+    return l.parse({
+      mediaType: "application/webpub+json",
+      name: "Readium Web Publication",
+      fileExtension: "json"
+    });
+  }
+  static get SMIL() {
+    return l.parse({
+      mediaType: "application/smil+xml",
+      fileExtension: "smil"
+    });
+  }
+  static get SVG() {
+    return l.parse({
+      mediaType: "image/svg+xml",
+      fileExtension: "svg"
+    });
+  }
+  static get TEXT() {
+    return l.parse({ mediaType: "text/plain", fileExtension: "txt" });
+  }
+  static get TIFF() {
+    return l.parse({ mediaType: "image/tiff", fileExtension: "tiff" });
+  }
+  static get TTF() {
+    return l.parse({ mediaType: "font/ttf", fileExtension: "ttf" });
+  }
+  static get W3C_WPUB_MANIFEST() {
+    return l.parse({
+      mediaType: "application/x.readium.w3c.wpub+json",
+      name: "Web Publication",
+      fileExtension: "json"
+    });
+  }
+  static get WAV() {
+    return l.parse({ mediaType: "audio/wav", fileExtension: "wav" });
+  }
+  static get WEBM_AUDIO() {
+    return l.parse({ mediaType: "audio/webm", fileExtension: "webm" });
+  }
+  static get WEBM_VIDEO() {
+    return l.parse({ mediaType: "video/webm", fileExtension: "webm" });
+  }
+  static get WEBP() {
+    return l.parse({ mediaType: "image/webp", fileExtension: "webp" });
+  }
+  static get WOFF() {
+    return l.parse({ mediaType: "font/woff", fileExtension: "woff" });
+  }
+  static get WOFF2() {
+    return l.parse({ mediaType: "font/woff2", fileExtension: "woff2" });
+  }
+  static get XHTML() {
+    return l.parse({
+      mediaType: "application/xhtml+xml",
+      fileExtension: "xhtml"
+    });
+  }
+  static get XML() {
+    return l.parse({
+      mediaType: "application/xml",
+      fileExtension: "xml"
+    });
+  }
+  static get ZAB() {
+    return l.parse({
+      mediaType: "application/x.readium.zab+zip",
+      name: "Zipped Audio Book",
+      fileExtension: "zab"
+    });
+  }
+  static get ZIP() {
+    return l.parse({
+      mediaType: "application/zip",
+      fileExtension: "zip"
+    });
+  }
+}
+class ke {
+  constructor(e) {
+    this.uri = e, this.parameters = this.getParameters(e);
+  }
+  /**
+   * List of URI template parameter keys, if the [Link] is templated.
+   */
+  getParameters(e) {
+    const t = /\{\??([^}]+)\}/g, r = e.match(t);
+    return r ? new Set(
+      r.join(",").replace(t, "$1").split(",").map((s) => s.trim())
+    ) : /* @__PURE__ */ new Set();
+  }
+  /** Expands the URI by replacing the template variables by the given parameters.
+   *  Any extra parameter is appended as query parameters.
+   *  See RFC 6570 on URI template: https://tools.ietf.org/html/rfc6570
+   */
+  expand(e) {
+    const t = (s) => s.split(",").map((n) => {
+      const o = e[n];
+      return o ? encodeURIComponent(o) : "";
+    }).join(","), r = (s) => "?" + s.split(",").map((n) => {
+      const o = n.split("=")[0], a = e[o];
+      return a ? `${o}=${encodeURIComponent(a)}` : "";
+    }).join("&");
+    return this.uri.replace(/\{(\??)([^}]+)\}/g, (...s) => s[1] ? r(s[2]) : t(s[2]));
+  }
+}
+function ei(i) {
+  return i && i instanceof Array ? i : void 0;
+}
+function ht(i) {
+  return i && typeof i == "string" ? [i] : ei(i);
+}
+function Ue(i) {
+  return typeof i == "string" ? new Date(i) : void 0;
+}
+function se(i) {
+  return isNaN(i) ? void 0 : i;
+}
+function P(i) {
+  return se(i) !== void 0 && Math.sign(i) >= 0 ? i : void 0;
+}
+function ti(i) {
+  const e = new Array();
+  return i.forEach((t) => e.push(t)), e;
+}
+class w {
+  /**
+   * Creates a [Locations].
+   */
+  constructor(e) {
+    this.fragments = e.fragments ? e.fragments : new Array(), this.progression = e.progression, this.totalProgression = e.totalProgression, this.position = e.position, this.otherLocations = e.otherLocations;
+  }
+  /**
+   * Parses a [Locations] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (!e)
+      return;
+    const t = se(e.progression), r = se(e.totalProgression), s = se(e.position), n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set([
+      "fragment",
+      "fragments",
+      "progression",
+      "totalProgression",
+      "position"
+    ]);
+    return Object.entries(e).forEach(([a, h]) => {
+      o.has(a) || n.set(a, h);
+    }), new w({
+      fragments: ht(e.fragments || e.fragment),
+      progression: t !== void 0 && t >= 0 && t <= 1 ? t : void 0,
+      totalProgression: r !== void 0 && r >= 0 && r <= 1 ? r : void 0,
+      position: s !== void 0 && s > 0 ? s : void 0,
+      otherLocations: n.size === 0 ? void 0 : n
+    });
+  }
+  /**
+   * Serializes a [Locations] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = {};
+    return this.fragments && (e.fragments = this.fragments), this.progression !== void 0 && (e.progression = this.progression), this.totalProgression !== void 0 && (e.totalProgression = this.totalProgression), this.position !== void 0 && (e.position = this.position), this.otherLocations && this.otherLocations.forEach((t, r) => e[r] = t), e;
+  }
+}
+class q {
+  /**
+   * Creates a [Text].
+   */
+  constructor(e) {
+    this.after = e.after, this.before = e.before, this.highlight = e.highlight;
+  }
+  /**
+   * Parses a [Locations] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e)
+      return new q({
+        after: e.after,
+        before: e.before,
+        highlight: e.highlight
+      });
+  }
+  /**
+   * Serializes a [Locations] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = {};
+    return this.after !== void 0 && (e.after = this.after), this.before !== void 0 && (e.before = this.before), this.highlight !== void 0 && (e.highlight = this.highlight), e;
+  }
+}
+class I {
+  /**
+   * Creates a [Locator].
+   */
+  constructor(e) {
+    this.href = e.href, this.type = e.type, this.title = e.title, this.locations = e.locations ? e.locations : new w({}), this.text = e.text;
+  }
+  /**
+   * Parses a [Link] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e.href && e.type)
+      return new I({
+        href: e.href,
+        type: e.type,
+        title: e.title,
+        locations: w.deserialize(e.locations),
+        text: q.deserialize(e.text)
+      });
+  }
+  /**
+   * Serializes a [Link] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { href: this.href, type: this.type };
+    return this.title !== void 0 && (e.title = this.title), this.locations && (e.locations = this.locations.serialize()), this.text && (e.text = this.text.serialize()), e;
+  }
+  /**
+   * Shortcut to get a copy of the [Locator] with different [Locations] sub-properties.
+   */
+  copyWithLocations(e) {
+    return new I({
+      href: this.href,
+      type: this.type,
+      title: this.title,
+      text: this.text,
+      locations: new w({ ...this.locations, ...e })
+    });
+  }
+}
+class H {
+  /**
+   * Creates a [Link].
+   */
+  constructor(e) {
+    this.href = e.href, this.templated = e.templated, this.type = e.type, this.title = e.title, this.rels = e.rels, this.properties = e.properties, this.height = e.height, this.width = e.width, this.duration = e.duration, this.bitrate = e.bitrate, this.languages = e.languages, this.alternates = e.alternates, this.children = e.children;
+  }
+  /**
+   * Parses a [Link] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e.href && typeof e.href == "string")
+      return new H({
+        href: e.href,
+        templated: e.templated,
+        type: e.type,
+        title: e.title,
+        rels: e.rel ? e.rel instanceof Array ? new Set(e.rel) : /* @__PURE__ */ new Set([e.rel]) : void 0,
+        properties: b.deserialize(e.properties),
+        height: P(e.height),
+        width: P(e.width),
+        duration: P(e.duration),
+        bitrate: P(e.bitrate),
+        languages: ht(e.language),
+        alternates: ne.deserialize(e.alternate),
+        children: ne.deserialize(e.children)
+      });
+  }
+  /**
+   * Serializes a [Link] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { href: this.href };
+    return this.templated !== void 0 && (e.templated = this.templated), this.type !== void 0 && (e.type = this.type), this.title !== void 0 && (e.title = this.title), this.rels && (e.rel = ti(this.rels)), this.properties && (e.properties = this.properties.serialize()), this.height !== void 0 && (e.height = this.height), this.width !== void 0 && (e.width = this.width), this.duration !== void 0 && (e.duration = this.duration), this.bitrate !== void 0 && (e.bitrate = this.bitrate), this.languages && (e.language = this.languages), this.alternates && (e.alternate = this.alternates.serialize()), this.children && (e.children = this.children.serialize()), e;
+  }
+  /** MediaType of the linked resource. */
+  get mediaType() {
+    return this.type !== void 0 ? l.parse({ mediaType: this.type }) : l.BINARY;
+  }
+  /** Computes an absolute URL to the link, relative to the given `baseURL`.
+   *  If the link's `href` is already absolute, the `baseURL` is ignored.
+   */
+  toURL(e) {
+    const t = this.href.replace(/^(\/)/, "");
+    if (t.length === 0)
+      return;
+    let r = e || "/";
+    return r.startsWith("/") && (r = "file://" + r), new URL(t, r).href.replace(/^(file:\/\/)/, "");
+  }
+  /** List of URI template parameter keys, if the `Link` is templated. */
+  get templateParameters() {
+    return this.templated ? new ke(this.href).parameters : /* @__PURE__ */ new Set();
+  }
+  /** Expands the `Link`'s HREF by replacing URI template variables by the given parameters.
+   *  See RFC 6570 on URI template: https://tools.ietf.org/html/rfc6570
+   */
+  expandTemplate(e) {
+    return new H({
+      href: new ke(this.href).expand(e),
+      templated: !1
+    });
+  }
+  /**
+   * Makes a copy of this [Link] after merging in the given additional other [properties].
+   */
+  addProperties(e) {
+    var t;
+    const r = H.deserialize(this.serialize());
+    return r.properties = r.properties ? (t = r.properties) == null ? void 0 : t.add(e) : new b(e), r;
+  }
+  /**
+   * Creates a [Locator] from a reading order [Link].
+   */
+  get locator() {
+    let e = this.href.split("#");
+    return new I({
+      href: e.length > 0 && e[0] !== void 0 ? e[0] : this.href,
+      type: this.type ?? "",
+      title: this.title,
+      locations: new w({
+        fragments: e.length > 1 && e[1] !== void 0 ? [e[1]] : []
+      })
+    });
+  }
+}
+class ne {
+  /**
+   * Creates a [Links].
+   */
+  constructor(e) {
+    this.items = e;
+  }
+  /**
+   * Creates a list of [Link] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e instanceof Array)
+      return new ne(
+        e.map((t) => H.deserialize(t)).filter((t) => t !== void 0)
+      );
+  }
+  /**
+   * Serializes an array of [Link] to its RWPM JSON representation.
+   */
+  serialize() {
+    return this.items.map((e) => e.serialize());
+  }
+  /** Finds the first link with the given relation. */
+  findWithRel(e) {
+    const t = (r) => r.rels && r.rels.has(e);
+    return this.items.find(t);
+  }
+  /** Finds all the links with the given relation. */
+  filterByRel(e) {
+    const t = (r) => r.rels && r.rels.has(e);
+    return this.items.filter(t);
+  }
+  /** Finds the first link matching the given HREF. */
+  findWithHref(e) {
+    const t = (r) => r.href === e;
+    return this.items.find(t);
+  }
+  /** Finds the index of the first link matching the given HREF. */
+  findIndexWithHref(e) {
+    const t = (r) => r.href === e;
+    return this.items.findIndex(t);
+  }
+  /** Finds the first link matching the given media type. */
+  findWithMediaType(e) {
+    const t = (r) => r.mediaType.matches(e);
+    return this.items.find(t);
+  }
+  /** Finds all the links matching the given media type. */
+  filterByMediaType(e) {
+    const t = (r) => r.mediaType.matches(e);
+    return this.items.filter(t);
+  }
+  /** Finds all the links matching any of the given media types. */
+  filterByMediaTypes(e) {
+    const t = (r) => {
+      for (const s of e)
+        if (r.mediaType.matches(s))
+          return !0;
+      return !1;
+    };
+    return this.items.filter(t);
+  }
+  /** Returns whether all the resources in the collection are audio clips. */
+  everyIsAudio() {
+    const e = (t) => t.mediaType.isAudio;
+    return this.items.length > 0 && this.items.every(e);
+  }
+  /** Returns whether all the resources in the collection are bitmaps. */
+  everyIsBitmap() {
+    const e = (t) => t.mediaType.isBitmap;
+    return this.items.length > 0 && this.items.every(e);
+  }
+  /** Returns whether all the resources in the collection are HTML documents. */
+  everyIsHTML() {
+    const e = (t) => t.mediaType.isHTML;
+    return this.items.length > 0 && this.items.every(e);
+  }
+  /** Returns whether all the resources in the collection are video clips. */
+  everyIsVideo() {
+    const e = (t) => t.mediaType.isVideo;
+    return this.items.length > 0 && this.items.every(e);
+  }
+  /** Returns whether all the resources in the collection are matching any of the given media types. */
+  everyMatchesMediaType(e) {
+    return Array.isArray(e) ? this.items.length > 0 && this.items.every((t) => {
+      for (const r of e)
+        return t.mediaType.matches(r);
+      return !1;
+    }) : this.items.length > 0 && this.items.every((t) => t.mediaType.matches(e));
+  }
+  filterLinksHasType() {
+    return this.items.filter((e) => e.type);
+  }
+}
+class oe {
+  /**
+   * Creates a [DomRange].
+   */
+  constructor(e) {
+    this.cssSelector = e.cssSelector, this.textNodeIndex = e.textNodeIndex, this.charOffset = e.charOffset;
+  }
+  /**
+   * Parses a [DomRangePoint] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (!(e && e.cssSelector))
+      return;
+    let t = P(e.textNodeIndex);
+    if (t === void 0)
+      return;
+    let r = P(e.charOffset);
+    return r === void 0 && (r = P(e.offset)), new oe({
+      cssSelector: e.cssSelector,
+      textNodeIndex: t,
+      charOffset: r
+    });
+  }
+  /**
+   * Serializes a [DomRangePoint] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = {
+      cssSelector: this.cssSelector,
+      textNodeIndex: this.textNodeIndex
+    };
+    return this.charOffset !== void 0 && (e.charOffset = this.charOffset), e;
+  }
+}
+class we {
+  /**
+   * Creates a [DomRange].
+   */
+  constructor(e) {
+    this.start = e.start, this.end = e.end;
+  }
+  /**
+   * Parses a [DomRange] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (!e)
+      return;
+    let t = oe.deserialize(e.start);
+    if (t)
+      return new we({
+        start: t,
+        end: oe.deserialize(e.end)
+      });
+  }
+  /**
+   * Serializes a [DomRange] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { start: this.start.serialize() };
+    return this.end && (e.end = this.end.serialize()), e;
+  }
+}
+w.prototype.getCssSelector = function() {
+  var i;
+  return (i = this.otherLocations) == null ? void 0 : i.get("cssSelector");
+};
+w.prototype.getPartialCfi = function() {
+  var i;
+  return (i = this.otherLocations) == null ? void 0 : i.get("partialCfi");
+};
+w.prototype.getDomRange = function() {
+  var i;
+  return we.deserialize((i = this.otherLocations) == null ? void 0 : i.get("domRange"));
+};
+w.prototype.fragmentParameters = function() {
+  return new Map(
+    this.fragments.map((i) => i.startsWith("#") ? i.slice(1) : i).join("&").split("&").filter((i) => !i.startsWith("#")).map((i) => i.split("=")).filter((i) => i.length === 2).map((i) => [
+      i[0].trim().toLowerCase(),
+      i[1].trim()
+    ])
+  );
+};
+w.prototype.htmlId = function() {
+  if (!this.fragments.length)
+    return;
+  let i = this.fragments.find((e) => e.length && !e.includes("="));
+  if (!i) {
+    const e = this.fragmentParameters();
+    e.has("id") ? i = e.get("id") : e.has("name") && (i = e.get("name"));
+  }
+  return i != null && i.startsWith("#") ? i.slice(1) : i;
+};
+w.prototype.page = function() {
+  const i = parseInt(this.fragmentParameters().get("page"));
+  if (!isNaN(i) && i >= 0)
+    return i;
+};
+w.prototype.time = function() {
+  const i = parseInt(this.fragmentParameters().get("t"));
+  if (!isNaN(i))
+    return i;
+};
+w.prototype.space = function() {
+  const i = this.fragmentParameters();
+  if (!i.has("xywh"))
+    return;
+  const e = i.get("xywh").split(",").map((t) => parseInt(t));
+  if (e.length === 4 && !e.some(isNaN))
+    return e;
+};
+class Te {
+  /** Creates a [Price]. */
+  constructor(e) {
+    this.currency = e.currency, this.value = e.value;
+  }
+  /**
+   * Parses a [Price] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (!e)
+      return;
+    let t = e.currency;
+    if (!(t && typeof t == "string" && t.length > 0))
+      return;
+    let r = P(e.value);
+    if (r !== void 0)
+      return new Te({ currency: t, value: r });
+  }
+  /**
+   * Serializes a [Price] to its RWPM JSON representation.
+   */
+  serialize() {
+    return { currency: this.currency, value: this.value };
+  }
+}
+class j {
+  /** Creates a [Acquisition]. */
+  constructor(e) {
+    this.type = e.type, this.children = e.children;
+  }
+  /**
+   * Parses a [Acquisition] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e.type)
+      return new j({
+        type: e.type,
+        children: j.deserializeArray(e.children)
+      });
+  }
+  static deserializeArray(e) {
+    if (e instanceof Array)
+      return e.map((t) => j.deserialize(t)).filter((t) => t !== void 0);
+  }
+  /**
+   * Serializes a [Acquisition] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { type: this.type };
+    return this.children && (e.children = this.children.map((t) => t.serialize())), e;
+  }
+}
+class Se {
+  /** Creates a [Price]. */
+  constructor(e) {
+    this.total = e.total, this.position = e.position;
+  }
+  /**
+   * Parses a [Holds] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e)
+      return new Se({
+        total: P(e.total),
+        position: P(e.position)
+      });
+  }
+  /**
+   * Serializes a [Holds] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = {};
+    return this.total !== void 0 && (e.total = this.total), this.position !== void 0 && (e.position = this.position), e;
+  }
+}
+class Ce {
+  /** Creates a [Copies]. */
+  constructor(e) {
+    this.total = e.total, this.available = e.available;
+  }
+  /**
+   * Parses a [Copies] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e)
+      return new Ce({
+        total: P(e.total),
+        available: P(e.available)
+      });
+  }
+  /**
+   * Serializes a [Copies] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = {};
+    return this.total !== void 0 && (e.total = this.total), this.available !== void 0 && (e.available = this.available), e;
+  }
+}
+class Pe {
+  /** Creates a [Availability]. */
+  constructor(e) {
+    this.state = e.state, this.since = e.since, this.until = e.until;
+  }
+  /**
+   * Parses a [Availability] from its RWPM JSON representation.
+   */
+  static deserialize(e) {
+    if (e && e.state)
+      return new Pe({
+        state: e.state,
+        since: Ue(e.since),
+        until: Ue(e.until)
+      });
+  }
+  /**
+   * Serializes a [Availability] to its RWPM JSON representation.
+   */
+  serialize() {
+    const e = { state: this.state };
+    return this.since !== void 0 && (e.since = this.since.toISOString()), this.until !== void 0 && (e.until = this.until.toISOString()), e;
+  }
+}
+b.prototype.getNumberOfItems = function() {
+  return P(this.otherProperties.numberOfItems);
+};
+b.prototype.getPrice = function() {
+  return Te.deserialize(this.otherProperties.price);
+};
+b.prototype.getIndirectAcquisitions = function() {
+  const i = this.otherProperties.indirectAcquisition;
+  if (i && i instanceof Array)
+    return i.map((e) => j.deserialize(e)).filter((e) => e !== void 0);
+};
+b.prototype.getHolds = function() {
+  return Se.deserialize(this.otherProperties.holds);
+};
+b.prototype.getCopies = function() {
+  return Ce.deserialize(this.otherProperties.copies);
+};
+b.prototype.getAvailability = function() {
+  return Pe.deserialize(this.otherProperties.availability);
+};
+b.prototype.getAuthenticate = function() {
+  return H.deserialize(this.otherProperties.authenticate);
+};
+b.prototype.getClipped = function() {
+  return this.otherProperties.clipped;
+};
+b.prototype.getFit = function() {
+  return this.otherProperties.fit;
+};
+b.prototype.getOrientation = function() {
+  return this.otherProperties.orientation;
+};
+b.prototype.getOverflow = function() {
+  return this.otherProperties.overflow;
+};
+b.prototype.getPage = function() {
+  return this.otherProperties.page || void 0;
+};
+b.prototype.getSpread = function() {
+  return this.otherProperties.spread || void 0;
+};
+function $e(i) {
+  return i.split("").reverse().join("");
+}
+function ii(i, e, t) {
+  const r = $e(e);
+  return t.map((s) => {
+    const n = Math.max(0, s.end - e.length - s.errors), o = $e(i.slice(n, s.end));
+    return {
+      start: ct(o, r, s.errors).reduce((h, c) => s.end - c.end < h ? s.end - c.end : h, s.end),
+      end: s.end,
+      errors: s.errors
+    };
+  });
+}
+function pe(i) {
+  return (i | -i) >> 31 & 1;
+}
+function He(i, e, t, r) {
+  let s = i.P[t], n = i.M[t];
+  const o = r >>> 31, a = e[t] | o, h = a | n, c = (a & s) + s ^ s | a;
+  let d = n | ~(c | s), p = s & c;
+  const u = pe(d & i.lastRowMask[t]) - pe(p & i.lastRowMask[t]);
+  return d <<= 1, p <<= 1, p |= o, d |= pe(r) - o, s = p | ~(h | d), n = d & h, i.P[t] = s, i.M[t] = n, u;
+}
+function ct(i, e, t) {
+  if (e.length === 0)
+    return [];
+  t = Math.min(t, e.length);
+  const r = [], s = 32, n = Math.ceil(e.length / s) - 1, o = {
+    P: new Uint32Array(n + 1),
+    M: new Uint32Array(n + 1),
+    lastRowMask: new Uint32Array(n + 1)
+  };
+  o.lastRowMask.fill(1 << 31), o.lastRowMask[n] = 1 << (e.length - 1) % s;
+  const a = new Uint32Array(n + 1), h = /* @__PURE__ */ new Map(), c = [];
+  for (let u = 0; u < 256; u++)
+    c.push(a);
+  for (let u = 0; u < e.length; u += 1) {
+    const f = e.charCodeAt(u);
+    if (h.has(f))
+      continue;
+    const v = new Uint32Array(n + 1);
+    h.set(f, v), f < c.length && (c[f] = v);
+    for (let g = 0; g <= n; g += 1) {
+      v[g] = 0;
+      for (let y = 0; y < s; y += 1) {
+        const x = g * s + y;
+        if (x >= e.length)
+          continue;
+        e.charCodeAt(x) === f && (v[g] |= 1 << y);
+      }
+    }
+  }
+  let d = Math.max(0, Math.ceil(t / s) - 1);
+  const p = new Uint32Array(n + 1);
+  for (let u = 0; u <= d; u += 1)
+    p[u] = (u + 1) * s;
+  p[n] = e.length;
+  for (let u = 0; u <= d; u += 1)
+    o.P[u] = -1, o.M[u] = 0;
+  for (let u = 0; u < i.length; u += 1) {
+    const f = i.charCodeAt(u);
+    let v;
+    f < c.length ? v = c[f] : (v = h.get(f), typeof v > "u" && (v = a));
+    let g = 0;
+    for (let y = 0; y <= d; y += 1)
+      g = He(o, v, y, g), p[y] += g;
+    if (p[d] - g <= t && d < n && (v[d + 1] & 1 || g < 0)) {
+      d += 1, o.P[d] = -1, o.M[d] = 0;
+      let y;
+      if (d === n) {
+        const x = e.length % s;
+        y = x === 0 ? s : x;
+      } else
+        y = s;
+      p[d] = p[d - 1] + y - g + He(o, v, d, g);
+    } else
+      for (; d > 0 && p[d] >= t + s; )
+        d -= 1;
+    d === n && p[d] <= t && (p[d] < t && r.splice(0, r.length), r.push({
+      start: -1,
+      end: u + 1,
+      errors: p[d]
+    }), t = p[d]);
+  }
+  return r;
+}
+function ri(i, e, t) {
+  const r = ct(i, e, t);
+  return ii(i, e, r);
+}
+function dt(i, e, t) {
+  let r = 0;
+  const s = [];
+  for (; r !== -1; )
+    r = i.indexOf(e, r), r !== -1 && (s.push({
+      start: r,
+      end: r + e.length,
+      errors: 0
+    }), r += 1);
+  return s.length > 0 ? s : ri(i, e, t);
+}
+function qe(i, e) {
+  return e.length === 0 || i.length === 0 ? 0 : 1 - dt(i, e, e.length)[0].errors / e.length;
+}
+function si(i, e, t = {}) {
+  if (e.length === 0)
+    return null;
+  const r = Math.min(256, e.length / 2), s = dt(i, e, r);
+  if (s.length === 0)
+    return null;
+  const n = (a) => {
+    const u = 1 - a.errors / e.length, f = t.prefix ? qe(
+      i.slice(
+        Math.max(0, a.start - t.prefix.length),
+        a.start
+      ),
+      t.prefix
+    ) : 1, v = t.suffix ? qe(
+      i.slice(a.end, a.end + t.suffix.length),
+      t.suffix
+    ) : 1;
+    let g = 1;
+    typeof t.hint == "number" && (g = 1 - Math.abs(a.start - t.hint) / i.length);
+    const y = 50 * u + 20 * f + 20 * v + 2 * g, x = 50 + 20 + 20 + 2;
+    return y / x;
+  }, o = s.map((a) => ({
+    start: a.start,
+    end: a.end,
+    score: n(a)
+  }));
+  return o.sort((a, h) => h.score - a.score), o[0];
+}
+function ge(i, e, t) {
+  const r = t === 1 ? e : e - 1;
+  if (i.charAt(r).trim() !== "")
+    return e;
+  let s, n;
+  if (t === 2 ? (s = i.substring(0, e), n = s.trimEnd()) : (s = i.substring(e), n = s.trimStart()), !n.length)
+    return -1;
+  const o = s.length - n.length;
+  return t === 2 ? e - o : e + o;
+}
+function Xe(i, e) {
+  const t = i.commonAncestorContainer.ownerDocument.createNodeIterator(
+    i.commonAncestorContainer,
+    NodeFilter.SHOW_TEXT
+  ), r = e === 1 ? i.startContainer : i.endContainer, s = e === 1 ? i.endContainer : i.startContainer;
+  let n = t.nextNode();
+  for (; n && n !== r; )
+    n = t.nextNode();
+  e === 2 && (n = t.previousNode());
+  let o = -1;
+  const a = () => {
+    if (n = e === 1 ? t.nextNode() : t.previousNode(), n) {
+      const h = n.textContent, c = e === 1 ? 0 : h.length;
+      o = ge(h, c, e);
+    }
+  };
+  for (; n && o === -1 && n !== s; )
+    a();
+  if (n && o >= 0)
+    return { node: n, offset: o };
+  throw new RangeError("No text nodes with non-whitespace text found in range");
+}
+function ni(i) {
+  if (!i.toString().trim().length)
+    throw new RangeError("Range contains no non-whitespace text");
+  if (i.startContainer.nodeType !== Node.TEXT_NODE)
+    throw new RangeError("Range startContainer is not a text node");
+  if (i.endContainer.nodeType !== Node.TEXT_NODE)
+    throw new RangeError("Range endContainer is not a text node");
+  const e = i.cloneRange();
+  let t = !1, r = !1;
+  const s = {
+    start: ge(
+      i.startContainer.textContent,
+      i.startOffset,
+      1
+      /* Forwards */
+    ),
+    end: ge(
+      i.endContainer.textContent,
+      i.endOffset,
+      2
+      /* Backwards */
+    )
+  };
+  if (s.start >= 0 && (e.setStart(i.startContainer, s.start), t = !0), s.end > 0 && (e.setEnd(i.endContainer, s.end), r = !0), t && r)
+    return e;
+  if (!t) {
+    const { node: n, offset: o } = Xe(
+      e,
+      1
+      /* Forwards */
+    );
+    n && o >= 0 && e.setStart(n, o);
+  }
+  if (!r) {
+    const { node: n, offset: o } = Xe(
+      e,
+      2
+      /* Backwards */
+    );
+    n && o > 0 && e.setEnd(n, o);
+  }
+  return e;
+}
+function ut(i) {
+  var e;
+  switch (i.nodeType) {
+    case Node.ELEMENT_NODE:
+    case Node.TEXT_NODE:
+      return ((e = i.textContent) == null ? void 0 : e.length) ?? 0;
+    default:
+      return 0;
+  }
+}
+function Ve(i) {
+  let e = i.previousSibling, t = 0;
+  for (; e; )
+    t += ut(e), e = e.previousSibling;
+  return t;
+}
+function pt(i, ...e) {
+  let t = e.shift();
+  const r = i.ownerDocument.createNodeIterator(
+    i,
+    NodeFilter.SHOW_TEXT
+  ), s = [];
+  let n = r.nextNode(), o, a = 0;
+  for (; t !== void 0 && n; )
+    o = n, a + o.data.length > t ? (s.push({ node: o, offset: t - a }), t = e.shift()) : (n = r.nextNode(), a += o.data.length);
+  for (; t !== void 0 && o && a === t; )
+    s.push({ node: o, offset: o.data.length }), t = e.shift();
+  if (t !== void 0)
+    throw new RangeError("Offset exceeds text length");
+  return s;
+}
+class R {
+  constructor(e, t) {
+    if (t < 0)
+      throw new Error("Offset is invalid");
+    this.element = e, this.offset = t;
+  }
+  /**
+   * Return a copy of this position with offset relative to a given ancestor
+   * element.
+   *
+   * @param parent - Ancestor of `this.element`
+   */
+  relativeTo(e) {
+    if (!e.contains(this.element))
+      throw new Error("Parent is not an ancestor of current element");
+    let t = this.element, r = this.offset;
+    for (; t !== e; )
+      r += Ve(t), t = t.parentElement;
+    return new R(t, r);
+  }
+  /**
+   * Resolve the position to a specific text node and offset within that node.
+   *
+   * Throws if `this.offset` exceeds the length of the element's text. In the
+   * case where the element has no text and `this.offset` is 0, the `direction`
+   * option determines what happens.
+   *
+   * Offsets at the boundary between two nodes are resolved to the start of the
+   * node that begins at the boundary.
+   *
+   * @param options.direction - Specifies in which direction to search for the
+   *                            nearest text node if `this.offset` is `0` and
+   *                            `this.element` has no text. If not specified an
+   *                            error is thrown.
+   *
+   * @throws {RangeError}
+   */
+  resolve(e = {}) {
+    try {
+      return pt(this.element, this.offset)[0];
+    } catch (t) {
+      if (this.offset === 0 && e.direction !== void 0) {
+        const r = document.createTreeWalker(
+          this.element.getRootNode(),
+          NodeFilter.SHOW_TEXT
+        );
+        r.currentNode = this.element;
+        const s = e.direction === 1, n = s ? r.nextNode() : r.previousNode();
+        if (!n)
+          throw t;
+        return { node: n, offset: s ? 0 : n.data.length };
+      } else
+        throw t;
+    }
+  }
+  /**
+   * Construct a `TextPosition` that refers to the `offset`th character within
+   * `node`.
+   */
+  static fromCharOffset(e, t) {
+    switch (e.nodeType) {
+      case Node.TEXT_NODE:
+        return R.fromPoint(e, t);
+      case Node.ELEMENT_NODE:
+        return new R(e, t);
+      default:
+        throw new Error("Node is not an element or text node");
+    }
+  }
+  /**
+   * Construct a `TextPosition` representing the range start or end point (node, offset).
+   *
+   * @param node
+   * @param offset - Offset within the node
+   */
+  static fromPoint(e, t) {
+    switch (e.nodeType) {
+      case Node.TEXT_NODE: {
+        if (t < 0 || t > e.data.length)
+          throw new Error("Text node offset is out of range");
+        if (!e.parentElement)
+          throw new Error("Text node has no parent");
+        const r = Ve(e) + t;
+        return new R(e.parentElement, r);
+      }
+      case Node.ELEMENT_NODE: {
+        if (t < 0 || t > e.childNodes.length)
+          throw new Error("Child node offset is out of range");
+        let r = 0;
+        for (let s = 0; s < t; s++)
+          r += ut(e.childNodes[s]);
+        return new R(e, r);
+      }
+      default:
+        throw new Error("Point is not in an element or text node");
+    }
+  }
+}
+class z {
+  constructor(e, t) {
+    this.start = e, this.end = t;
+  }
+  /**
+   * Create a new TextRange whose `start` and `end` are computed relative to
+   * `element`. `element` must be an ancestor of both `start.element` and
+   * `end.element`.
+   */
+  relativeTo(e) {
+    return new z(
+      this.start.relativeTo(e),
+      this.end.relativeTo(e)
+    );
+  }
+  /**
+   * Resolve this TextRange to a (DOM) Range.
+   *
+   * The resulting DOM Range will always start and end in a `Text` node.
+   * Hence `TextRange.fromRange(range).toRange()` can be used to "shrink" a
+   * range to the text it contains.
+   *
+   * May throw if the `start` or `end` positions cannot be resolved to a range.
+   */
+  toRange() {
+    let e, t;
+    this.start.element === this.end.element && this.start.offset <= this.end.offset ? [e, t] = pt(
+      this.start.element,
+      this.start.offset,
+      this.end.offset
+    ) : (e = this.start.resolve({
+      direction: 1
+      /* FORWARDS */
+    }), t = this.end.resolve({
+      direction: 2
+      /* BACKWARDS */
+    }));
+    const r = new Range();
+    return r.setStart(e.node, e.offset), r.setEnd(t.node, t.offset), r;
+  }
+  /**
+   * Create a TextRange from a (DOM) Range
+   */
+  static fromRange(e) {
+    const t = R.fromPoint(
+      e.startContainer,
+      e.startOffset
+    ), r = R.fromPoint(e.endContainer, e.endOffset);
+    return new z(t, r);
+  }
+  /**
+   * Create a TextRange representing the `start`th to `end`th characters in
+   * `root`
+   */
+  static fromOffsets(e, t, r) {
+    return new z(
+      new R(e, t),
+      new R(e, r)
+    );
+  }
+  /**
+   * Return a new Range representing `range` trimmed of any leading or trailing
+   * whitespace
+   */
+  static trimmedRange(e) {
+    return ni(z.fromRange(e).toRange());
+  }
+}
+class ae {
+  constructor(e, t, r) {
+    this.root = e, this.start = t, this.end = r;
+  }
+  static fromRange(e, t) {
+    const r = z.fromRange(t).relativeTo(e);
+    return new ae(
+      e,
+      r.start.offset,
+      r.end.offset
+    );
+  }
+  static fromSelector(e, t) {
+    return new ae(e, t.start, t.end);
+  }
+  toSelector() {
+    return {
+      type: "TextPositionSelector",
+      start: this.start,
+      end: this.end
+    };
+  }
+  toRange() {
+    return z.fromOffsets(this.root, this.start, this.end).toRange();
+  }
+}
+class le {
+  /**
+   * @param root - A root element from which to anchor.
+   */
+  constructor(e, t, r = {}) {
+    this.root = e, this.exact = t, this.context = r;
+  }
+  /**
+   * Create a `TextQuoteAnchor` from a range.
+   *
+   * Will throw if `range` does not contain any text nodes.
+   */
+  static fromRange(e, t) {
+    const r = e.textContent, s = z.fromRange(t).relativeTo(e), n = s.start.offset, o = s.end.offset, a = 32;
+    return new le(e, r.slice(n, o), {
+      prefix: r.slice(Math.max(0, n - a), n),
+      suffix: r.slice(o, Math.min(r.length, o + a))
+    });
+  }
+  static fromSelector(e, t) {
+    const { prefix: r, suffix: s } = t;
+    return new le(e, t.exact, { prefix: r, suffix: s });
+  }
+  toSelector() {
+    return {
+      type: "TextQuoteSelector",
+      exact: this.exact,
+      prefix: this.context.prefix,
+      suffix: this.context.suffix
+    };
+  }
+  toRange(e = {}) {
+    return this.toPositionAnchor(e).toRange();
+  }
+  toPositionAnchor(e = {}) {
+    const t = this.root.textContent, r = si(t, this.exact, {
+      ...this.context,
+      hint: e.hint
+    });
+    if (!r)
+      throw new Error("Quote not found");
+    return new ae(this.root, r.start, r.end);
+  }
+}
+function Oe(i, e) {
+  try {
+    let r = e.locations, s = e.text;
+    if (s && s.highlight) {
+      let n;
+      r && r.getCssSelector() && (n = i.querySelector(r.getCssSelector())), n || (n = i.body);
+      let o = new le(n, s.highlight, {
+        prefix: s.before,
+        suffix: s.after
+      });
+      try {
+        return o.toRange();
+      } catch {
+        return console.warn("Quote not found:", o), null;
+      }
+    }
+    if (r) {
+      var t = null;
+      if (!t && r.getCssSelector() && (t = i.querySelector(r.getCssSelector())), !t && r.fragments) {
+        for (const n of r.fragments)
+          if (t = i.getElementById(n), t)
+            break;
+      }
+      if (t) {
+        let n = i.createRange();
+        return t.childNodes.length === 0 ? (n.selectNodeContents(t), n) : (n.setStartBefore(t), n.setEndAfter(t), n);
+      }
+    }
+  } catch (r) {
+    console.error(r);
+  }
+  return null;
+}
+function T(i) {
+  const e = i.getSelection();
+  e && e.removeAllRanges();
+}
+const oi = [
+  "a",
+  "audio",
+  "button",
+  "canvas",
+  "details",
+  "input",
+  "label",
+  "option",
+  "select",
+  "submit",
+  "textarea",
+  "video"
+];
+function ft(i) {
+  var e;
+  return oi.indexOf(i.nodeName.toLowerCase()) !== -1 || i.hasAttribute("contenteditable") && ((e = i.getAttribute("contenteditable")) == null ? void 0 : e.toLowerCase()) !== "false" ? i : i.parentElement ? ft(i.parentElement) : null;
+}
+function mt(i, e) {
+  const t = gt(i, i.document.body, e);
+  return new I({
+    href: "#",
+    type: "application/xhtml+xml",
+    locations: new w({
+      otherLocations: /* @__PURE__ */ new Map([
+        ["cssSelector", i._readium_cssSelectorGenerator.getCssSelector(t)]
+      ])
+    }),
+    text: new q({
+      highlight: t.textContent || void 0
+    })
+  });
+}
+function gt(i, e, t) {
+  for (var r = 0; r < e.children.length; r++) {
+    const s = e.children[r];
+    if (!li(s) && ai(i, s, t))
+      return gt(i, s, t);
+  }
+  return e;
+}
+function ai(i, e, t) {
+  if (e === document.body || e === document.documentElement)
+    return !0;
+  if (!document || !document.documentElement || !document.body)
+    return !1;
+  const r = e.getBoundingClientRect();
+  return t ? r.bottom > 0 && r.top < i.innerHeight : r.right > 0 && r.left < i.innerWidth;
+}
+function li(i) {
+  const e = getComputedStyle(i);
+  return !!(e && (e.getPropertyValue("display") != "block" || e.getPropertyValue("opacity") === "0"));
+}
+const _e = "readium-column-snapper-style", hi = 200, vt = class C extends at {
+  constructor() {
+    super(...arguments), this.shakeTimeout = 0, this.snappingCancelled = !1, this.alreadyScrollLeft = 0, this.overscroll = 0, this.cachedScrollWidth = 0, this.touchState = 0, this.startingX = void 0, this.endingX = void 0, this.onTouchStarter = this.onTouchStart.bind(this), this.onTouchEnder = this.onTouchEnd.bind(this), this.onWidthChanger = this.onWidthChange.bind(this), this.onTouchMover = this.onTouchMove.bind(this);
+  }
+  doc() {
+    return this.wnd.document.scrollingElement;
+  }
+  scrollOffset() {
+    return this.doc().scrollLeft > 0 ? this.doc().scrollLeft : this.alreadyScrollLeft;
+  }
+  snapOffset(e) {
+    const t = e + (W(this.wnd) ? -1 : 1);
+    return t - t % this.wnd.innerWidth;
+  }
+  reportProgress() {
+    this.comms.send("progress", this.wnd.scrollX / this.cachedScrollWidth);
+  }
+  shake() {
+    if (this.overscroll !== 0 || this.shakeTimeout !== 0)
+      return;
+    const e = this.doc();
+    e.classList.add(W(this.wnd) ? "readium-bounce-l" : "readium-bounce-r");
+    const t = this.scrollOffset();
+    this.shakeTimeout = this.wnd.setTimeout(() => {
+      e.classList.remove("readium-bounce-l"), e.classList.remove("readium-bounce-r"), this.shakeTimeout = 0, this.doc().scrollLeft = t;
+    }, 150);
+  }
+  // We have to cache this because during overscroll (transform, or left) the width is incorrect due to browser
+  takeOverSnap() {
+    var t;
+    this.snappingCancelled = !0, this.clearTouches();
+    const e = this.doc();
+    this.overscroll = ((t = e.style.transform) == null ? void 0 : t.length) > 12 ? parseFloat(e.style.transform.slice(12).split("px")[0]) : 0;
+  }
+  // Snaps the current offset to the page width.
+  snapCurrentOffset(e = !1, t = !1) {
+    const r = this.wnd.scrollX > 0 ? this.wnd.scrollX : this.alreadyScrollLeft, s = this.doc(), n = this.dragOffset(), o = lt(this.wnd), a = Math.min(Math.max(0, r), this.cachedScrollWidth), h = W(this.wnd) ? -1 : 1, c = (
+      // The hurdle to overcome in order to change pages
+      h * (this.wnd.innerWidth / 3) * (h * n > 0 ? 2 : 1)
+    ), d = this.snapOffset(a + c);
+    if (e && d !== this.scrollOffset()) {
+      this.snappingCancelled = !1;
+      const p = (g, y, x, S) => x > S ? y : g + (y - g) * Qt(x / S), u = (
+        /*Math.abs(startX - (this.useTransform ? currentOffset : 0)) < 10 ? 1 : */
+        hi * o
+      );
+      let f;
+      const v = (g) => {
+        if (this.snappingCancelled)
+          return;
+        f || (f = g);
+        const y = g - f, x = p(this.overscroll, 0, y, u), S = p(r, d, y, u);
+        s.scrollLeft = S, this.overscroll !== 0 && (s.style.transform = `translate3d(${-x}px, 0px, 0px)`), y < u ? this.wnd.requestAnimationFrame(v) : (this.clearTouches(), s.style.removeProperty("transform"), s.scrollLeft = d, t || this.reportProgress());
+      };
+      this.wnd.requestAnimationFrame(v);
+    } else
+      s.style.removeProperty("transform"), this.wnd.requestAnimationFrame(() => {
+        s.scrollLeft = d, this.clearTouches(), t || this.reportProgress();
+      });
+  }
+  dragOffset() {
+    return (this.startingX ?? 0) - (this.endingX ?? 0);
+  }
+  clearTouches() {
+    this.startingX = void 0, this.endingX = void 0, this.overscroll = 0;
+  }
+  onTouchStart(e) {
+    switch (e.stopPropagation(), this.takeOverSnap(), e.touches.length) {
+      case 1:
+        break;
+      case 2:
+        this.onTouchEnd(e);
+        return;
+      default: {
+        this.onTouchEnd(e), this.comms.send("tap_more", e.touches.length);
+        return;
+      }
+    }
+    this.startingX = e.touches[0].clientX, this.alreadyScrollLeft = this.doc().scrollLeft, this.touchState = 1;
+  }
+  onTouchEnd(e) {
+    if (this.touchState === 2) {
+      const t = this.dragOffset(), r = this.scrollOffset();
+      this.cachedScrollWidth <= this.wnd.innerWidth ? (this.reportProgress(), t > 5 && this.comms.send("no_more", void 0), t < -5 && this.comms.send("no_less", void 0)) : r < 5 && t < 5 ? (this.alreadyScrollLeft = 0, this.comms.send("no_less", void 0)) : this.cachedScrollWidth - r - this.wnd.innerWidth < 5 && t > 5 && (this.alreadyScrollLeft = this.cachedScrollWidth, this.comms.send("no_more", void 0)), this.snapCurrentOffset(!0), this.comms.send("swipe", t);
+    }
+    this.touchState = 0;
+  }
+  onWidthChange() {
+    this.cachedScrollWidth = this.doc().scrollWidth, this.comms.ready && this.snapCurrentOffset();
+  }
+  onTouchMove(e) {
+    if (this.touchState === 0)
+      return;
+    this.touchState === 1 && (this.touchState = 2, T(this.wnd)), this.endingX = e.touches[0].clientX;
+    const t = this.dragOffset(), r = this.alreadyScrollLeft + t;
+    r < 0 ? (this.overscroll = r, this.doc().style.transform = `translate3d(${-this.overscroll}px, 0px, 0px)`) : r + this.wnd.innerWidth > this.cachedScrollWidth ? (this.overscroll = r, this.doc().style.transform = `translate3d(${-r}px, 0px, 0px)`) : (this.overscroll = 0, this.doc().style.removeProperty("transform"), this.doc().scrollLeft = this.alreadyScrollLeft + t);
+  }
+  mount(e, t) {
+    if (this.wnd = e, this.comms = t, !super.mount(e, t))
+      return !1;
+    const r = e.document.createElement("style");
+    r.dataset.readium = "true", r.id = _e, r.textContent = `
+        @keyframes readium-bounce-l-animation {
+            0%, 100% {transform: translate3d(0, 0, 0);}
+            50% {transform: translate3d(-50px, 0, 0);}
+        }
+
+        @keyframes readium-bounce-r-animation {
+            0%, 100% {transform: translate3d(0, 0, 0);}
+            50% {transform: translate3d(50px, 0, 0);}
+        }
+
+        .readium-bounce-l {
+            animation: readium-bounce-l-animation 150ms ease-out 1;
+        }
+
+        .readium-bounce-r {
+            animation: readium-bounce-r-animation 150ms ease-out 1;
+        }
+
+        html {
+            overflow: hidden;
+        }
+
+        body {
+            -ms-overflow-style: none; /* for Internet Explorer, Edge */
+        }
+
+        * {
+            scrollbar-width: none; /* for Firefox */
+        }
+        
+        body::-webkit-scrollbar {
+            display: none; /* for Chrome, Safari, and Opera */
+        }
+        `, e.document.head.appendChild(r);
+    const s = e.ResizeObserver || nt;
+    this.resizeObserver = new s(() => e.requestAnimationFrame(() => {
+      e && Jt(e);
+    })), this.resizeObserver.observe(e.document.body), this.mutationObserver = new MutationObserver(() => {
+      this.wnd.requestAnimationFrame(() => this.cachedScrollWidth = this.doc().scrollWidth);
+    }), e.frameElement && this.mutationObserver.observe(e.frameElement, { attributes: !0, attributeFilter: ["style"] }), this.mutationObserver.observe(e.document, { attributes: !0, attributeFilter: ["style"] });
+    const n = (o) => {
+      const a = this.doc().scrollLeft;
+      return this.doc().scrollLeft = this.snapOffset(o), a !== this.doc().scrollLeft;
+    };
+    return e.addEventListener("orientationchange", this.onWidthChanger), e.addEventListener("resize", this.onWidthChanger), e.requestAnimationFrame(() => this.cachedScrollWidth = this.doc().scrollWidth), t.register("go_progression", C.moduleName, (o, a) => {
+      const h = o;
+      if (h < 0 || h > 1) {
+        t.send("error", {
+          message: "go_progression must be given a position from 0.0 to 1.0"
+        }), a(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.cachedScrollWidth = this.doc().scrollWidth;
+        const c = this.cachedScrollWidth, d = W(e) ? -1 : 1, p = c * h * d;
+        this.doc().scrollLeft = this.snapOffset(p), this.reportProgress(), T(this.wnd), a(!0);
+      });
+    }), t.register("go_id", C.moduleName, (o, a) => {
+      const h = e.document.getElementById(o);
+      if (!h) {
+        a(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.doc().scrollLeft = this.snapOffset(h.getBoundingClientRect().left + e.scrollX), this.reportProgress(), T(this.wnd), a(!0);
+      });
+    }), t.register("go_text", C.moduleName, (o, a) => {
+      let h;
+      Array.isArray(o) && (o.length > 1 && (h = o[1]), o = o[0]);
+      const c = q.deserialize(o), d = Oe(this.wnd.document, new I({
+        href: e.location.href,
+        type: "text/html",
+        text: c,
+        locations: h ? new w({
+          otherLocations: /* @__PURE__ */ new Map([
+            ["cssSelector", h]
+          ])
+        }) : void 0
+      }));
+      if (!d) {
+        a(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.doc().scrollLeft = this.snapOffset(d.getBoundingClientRect().left + e.scrollX), this.reportProgress(), T(this.wnd), a(!0);
+      });
+    }), t.register("go_end", C.moduleName, (o, a) => {
+      const h = W(e) ? -1 : 1;
+      this.wnd.requestAnimationFrame(() => {
+        this.cachedScrollWidth = this.doc().scrollWidth;
+        const c = this.cachedScrollWidth * h;
+        if (this.doc().scrollLeft === c)
+          return a(!1);
+        this.doc().scrollLeft = this.snapOffset(c), this.reportProgress(), T(this.wnd), a(!0);
+      });
+    }), t.register("go_start", C.moduleName, (o, a) => {
+      this.wnd.requestAnimationFrame(() => {
+        if (this.doc().scrollLeft === 0)
+          return a(!1);
+        this.doc().scrollLeft = 0, this.reportProgress(), T(this.wnd), a(!0);
+      });
+    }), t.register("go_prev", C.moduleName, (o, a) => {
+      this.wnd.requestAnimationFrame(() => {
+        const h = e.scrollX - e.innerWidth, c = W(e) ? -(this.cachedScrollWidth - e.innerWidth) : 0, d = n(Math.max(h, c));
+        d && (this.reportProgress(), T(this.wnd)), a(d);
+      });
+    }), t.register("go_next", C.moduleName, (o, a) => {
+      this.wnd.requestAnimationFrame(() => {
+        const h = e.scrollX + e.innerWidth, c = W(e) ? 0 : this.cachedScrollWidth - e.innerWidth, d = n(Math.min(h, c));
+        d && (this.reportProgress(), T(this.wnd)), a(d);
+      });
+    }), t.register("unfocus", C.moduleName, (o, a) => {
+      this.snappingCancelled = !0, T(this.wnd), a(!0);
+    }), t.register("shake", C.moduleName, (o, a) => {
+      this.shake(), a(!0);
+    }), t.register("focus", C.moduleName, (o, a) => {
+      this.wnd.requestAnimationFrame(() => {
+        this.cachedScrollWidth = this.doc().scrollWidth, this.snapCurrentOffset(!1, !0), this.reportProgress(), a(!0);
+      });
+    }), t.register("first_visible_locator", C.moduleName, (o, a) => {
+      const h = mt(e, !1);
+      this.comms.send("first_visible_locator", h.serialize()), a(!0);
+    }), e.addEventListener("touchstart", this.onTouchStarter, { passive: !0 }), e.addEventListener("touchend", this.onTouchEnder, { passive: !0 }), e.addEventListener("touchmove", this.onTouchMover, { passive: !0 }), e.document.addEventListener("touchstart", () => {
+    }), t.log("ColumnSnapper Mounted"), !0;
+  }
+  unmount(e, t) {
+    var r;
+    return this.snappingCancelled = !0, t.unregisterAll(C.moduleName), this.resizeObserver.disconnect(), this.mutationObserver.disconnect(), e.removeEventListener("touchstart", this.onTouchStarter), e.removeEventListener("touchend", this.onTouchEnder), e.removeEventListener("touchmove", this.onTouchMover), e.removeEventListener("orientationchange", this.onWidthChanger), e.removeEventListener("resize", this.onWidthChanger), (r = e.document.getElementById(_e)) == null || r.remove(), t.log("ColumnSnapper Unmounted"), super.unmount(e, t);
+  }
+};
+vt.moduleName = "column_snapper";
+let ci = vt;
+const he = {
+  top: "js-iframe-reader-top-anchor",
+  bottom: "js-iframe-reader-bottom-anchor"
+};
+class di extends HTMLElement {
+  connectedCallback() {
+    this.setAttribute("aria-hidden", "true"), this.style.setProperty("display", "block", "important"), this.style.setProperty("padding", "0", "important"), this.style.setProperty("margin", "0", "important"), this.style.setProperty("visibility", "hidden", "important");
+  }
+}
+function ui(i) {
+  const e = i.getElementsByTagName("body")[0], t = document.createElement("anchor-observer"), r = document.createElement("anchor-observer");
+  t.dataset.readium = "true", r.dataset.readium = "true", t == null || t.setAttribute("id", he.top), t == null || t.style.setProperty("height", "115px", "important"), r == null || r.setAttribute("id", he.bottom), r == null || r.style.setProperty("height", "80px", "important"), e == null || e.insertBefore(t, e.firstChild), e == null || e.appendChild(r);
+}
+function pi(i) {
+  var s, n;
+  const e = i.getElementsByTagName("body")[0], t = e == null ? void 0 : e.querySelector(`#${he.top}`), r = e == null ? void 0 : e.querySelector(`#${he.bottom}`);
+  t && ((s = t.parentElement) == null || s.removeChild(t)), r && ((n = r.parentElement) == null || n.removeChild(r));
+}
+const je = "readium-scroll-snapper-style", yt = class M extends at {
+  constructor() {
+    super(...arguments), this.createAnchorElements = () => {
+      ui(this.doc());
+    }, this.removeAnchorElements = () => {
+      pi(this.doc());
+    }, this.createCustomElement = () => {
+      customElements.get("anchor-observer") || customElements.define("anchor-observer", di);
+    };
+  }
+  doc() {
+    return this.wnd.document.scrollingElement;
+  }
+  reportProgress(e) {
+    this.comms.send("progress", e);
+  }
+  mount(e, t) {
+    this.wnd = e, this.comms = t;
+    const r = e.document.createElement("style");
+    return r.dataset.readium = "true", r.id = je, r.textContent = `
+        * {
+            scrollbar-width: none; /* for Firefox */
+        }
+        
+        body::-webkit-scrollbar {
+            display: none; /* for Chrome, Safari, and Opera */
+        }
+        `, e.document.head.appendChild(r), t.register("go_progression", M.moduleName, (s, n) => {
+      const o = s;
+      if (o < 0 || o > 1) {
+        t.send("error", {
+          message: "go_progression must be given a position from 0.0 to 1.0"
+        }), n(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.doc().scrollTop = this.doc().offsetHeight * o, this.reportProgress(o), T(this.wnd), n(!0);
+      });
+    }), t.register("go_id", M.moduleName, (s, n) => {
+      const o = e.document.getElementById(s);
+      if (!o) {
+        n(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.doc().scrollTop = o.getBoundingClientRect().top + e.scrollY - e.innerHeight / 2, this.reportProgress(this.doc().scrollTop / this.doc().offsetHeight), T(this.wnd), n(!0);
+      });
+    }), t.register("go_text", M.moduleName, (s, n) => {
+      let o;
+      Array.isArray(s) && (s.length > 1 && (o = s[1]), s = s[0]);
+      const a = q.deserialize(s), h = Oe(this.wnd.document, new I({
+        href: e.location.href,
+        type: "text/html",
+        text: a,
+        locations: o ? new w({
+          otherLocations: /* @__PURE__ */ new Map([
+            ["cssSelector", o]
+          ])
+        }) : void 0
+      }));
+      if (!h) {
+        n(!1);
+        return;
+      }
+      this.wnd.requestAnimationFrame(() => {
+        this.doc().scrollTop = h.getBoundingClientRect().top + e.scrollY - e.innerHeight / 2, this.reportProgress(this.doc().scrollTop / this.doc().offsetHeight), T(this.wnd), n(!0);
+      });
+    }), t.register("go_start", M.moduleName, (s, n) => {
+      if (this.doc().scrollTop === 0)
+        return n(!1);
+      this.doc().scrollTop = 0, this.reportProgress(0), n(!0);
+    }), t.register("go_end", M.moduleName, (s, n) => {
+      if (this.doc().scrollTop === 0)
+        return n(!1);
+      this.doc().scrollTop = 0, this.reportProgress(0), n(!0);
+    }), t.register("unfocus", M.moduleName, (s, n) => {
+      T(this.wnd), n(!0);
+    }), t.register([
+      "go_next",
+      "go_prev"
+    ], M.moduleName, (s, n) => n(!1)), t.register("focus", M.moduleName, (s, n) => {
+      this.reportProgress(this.doc().scrollTop / this.doc().offsetHeight), n(!0);
+    }), t.register("first_visible_locator", M.moduleName, (s, n) => {
+      const o = mt(e, !0);
+      this.comms.send("first_visible_locator", o.serialize()), n(!0);
+    }), t.log("ScrollSnapper Mounted"), this.createCustomElement(), this.createAnchorElements(), !0;
+  }
+  unmount(e, t) {
+    var r;
+    return t.unregisterAll(M.moduleName), this.removeAnchorElements(), (r = e.document.getElementById(je)) == null || r.remove(), t.log("ScrollSnapper Unmounted"), !0;
+  }
+};
+yt.moduleName = "scroll_snapper";
+let fi = yt;
+class bt extends ce {
+  constructor() {
+    super(...arguments), this.pointerMoved = !1, this.onPointerUp = this.onPointUp.bind(this), this.onPointerMove = this.onPointMove.bind(this), this.onPointerDown = this.onPointDown.bind(this), this.onContextMenu = this.onContext.bind(this), this.onClicker = this.onClick.bind(this);
+  }
+  onPointUp(e) {
+    var s, n, o, a, h;
+    const t = this.wnd.getSelection();
+    if (t && ((s = t.toString()) == null ? void 0 : s.length) > 0) {
+      const c = (n = t.getRangeAt(0)) == null ? void 0 : n.getClientRects();
+      if (!c || c.length === 0)
+        return;
+      const d = c[0], p = {
+        text: t.toString(),
+        x: d.x,
+        y: d.y,
+        width: d.width,
+        height: d.height,
+        targetFrameSrc: (a = (o = this.wnd) == null ? void 0 : o.location) == null ? void 0 : a.href
+      };
+      this.comms.send("text_selected", p);
+    }
+    if (this.pointerMoved) {
+      this.pointerMoved = !1;
+      return;
+    }
+    if (!(t != null && t.isCollapsed) || !e.isPrimary)
+      return;
+    const r = this.wnd.devicePixelRatio;
+    e.preventDefault(), this.comms.send(e.pointerType === "touch" ? "tap" : "click", {
+      defaultPrevented: e.defaultPrevented,
+      x: e.clientX * r,
+      y: e.clientY * r,
+      targetFrameSrc: this.wnd.location.href,
+      targetElement: e.target.outerHTML,
+      interactiveElement: (h = ft(e.target)) == null ? void 0 : h.outerHTML,
+      cssSelector: this.wnd._readium_cssSelectorGenerator.getCssSelector(e.target)
+    }), this.pointerMoved = !1;
+  }
+  onPointMove(e) {
+    if (e.movementY !== void 0 && e.movementX !== void 0) {
+      (Math.abs(e.movementX) > 1 || Math.abs(e.movementY) > 1) && (this.pointerMoved = !0);
+      return;
+    }
+    this.pointerMoved = !0;
+  }
+  onPointDown() {
+    this.pointerMoved = !1;
+  }
+  onContext(e) {
+    this.onPointUp(e), this.pointerMoved = !1;
+  }
+  onClick(e) {
+    if (e.preventDefault(), !e.isTrusted) {
+      const t = new PointerEvent("pointerup", {
+        isPrimary: !0,
+        pointerType: "mouse",
+        // Not really a better choice than this
+        clientX: e.clientX,
+        clientY: e.clientY
+      });
+      Object.defineProperty(t, "target", { writable: !1, value: e.target }), Object.defineProperty(t, "defaultPrevented", { writable: !1, value: e.defaultPrevented }), this.onPointUp(t);
+    }
+  }
+  mount(e, t) {
+    return this.wnd = e, this.comms = t, e.document.addEventListener("pointerdown", this.onPointerDown), e.document.addEventListener("pointerup", this.onPointerUp), e.document.addEventListener("contextmenu", this.onContextMenu), e.document.addEventListener("pointermove", this.onPointerMove), e.document.addEventListener("click", this.onClicker), t.log("Peripherals Mounted"), !0;
+  }
+  unmount(e, t) {
+    return e.document.removeEventListener("pointerdown", this.onPointerDown), e.document.removeEventListener("pointerup", this.onPointerUp), e.document.removeEventListener("contextmenu", this.onContextMenu), e.document.removeEventListener("pointermove", this.onPointerMove), e.document.removeEventListener("click", this.onClicker), t.log("Peripherals Unmounted"), !0;
+  }
+}
+bt.moduleName = "peripherals";
+const Et = class ve extends ce {
+  constructor() {
+    super(...arguments), this.mediaPlayingCount = 0, this.allAnimations = /* @__PURE__ */ new Set();
+  }
+  wndOnErr(e) {
+    var t;
+    (t = this.comms) == null || t.send("error", {
+      message: e.message,
+      filename: e.filename,
+      lineno: e.lineno,
+      colno: e.colno
+    });
+  }
+  unblock(e) {
+    var t;
+    for (e._readium_blockEvents = !1; ((t = e._readium_blockedEvents) == null ? void 0 : t.length) > 0; ) {
+      const r = e._readium_blockedEvents.shift();
+      switch (r[0]) {
+        case 0:
+          Reflect.apply(r[1], r[2], r[3]);
+          break;
+        case 1:
+          const s = r[1], n = r[2];
+          e.removeEventListener(s.type, e._readium_eventBlocker, !0);
+          const o = new Event(s.type, {
+            bubbles: s.bubbles,
+            cancelable: s.cancelable
+          });
+          n ? n.dispatchEvent(o) : e.dispatchEvent(o);
+          break;
+      }
+    }
+  }
+  onMediaPlayEvent() {
+    var e;
+    this.mediaPlayingCount++, (e = this.comms) == null || e.send("media_play", this.mediaPlayingCount);
+  }
+  onMediaPauseEvent() {
+    var e;
+    this.mediaPlayingCount > 0 && this.mediaPlayingCount--, (e = this.comms) == null || e.send("media_pause", this.mediaPlayingCount);
+  }
+  pauseAllMedia(e) {
+    const t = e.document.querySelectorAll("audio,video");
+    for (let r = 0; r < t.length; r++)
+      t[r].pause();
+  }
+  mount(e, t) {
+    this.comms = t, e.addEventListener(
+      "error",
+      this.wndOnErr,
+      !1
+    ), "getAnimations" in e.document && e.document.getAnimations().forEach((s) => {
+      s.cancel(), this.allAnimations.add(s);
+    }), t.register("activate", ve.moduleName, (s, n) => {
+      this.allAnimations.forEach((o) => {
+        o.cancel(), o.play();
+      }), n(!0);
+    }), t.register("unfocus", ve.moduleName, (s, n) => {
+      this.pauseAllMedia(e), this.allAnimations.forEach((o) => o.pause()), n(!0);
+    });
+    const r = e.document.querySelectorAll("audio,video");
+    for (let s = 0; s < r.length; s++) {
+      const n = r[s];
+      n.addEventListener("play", this.onMediaPlayEvent, {
+        passive: !0
+      }), n.addEventListener("pause", this.onMediaPauseEvent, {
+        passive: !0
+      });
+    }
+    return t.log("Setup Mounted"), !0;
+  }
+  unmount(e, t) {
+    return e.removeEventListener("error", this.wndOnErr), e.removeEventListener("play", this.onMediaPlayEvent), e.removeEventListener("pause", this.onMediaPauseEvent), this.allAnimations.forEach((r) => r.cancel()), this.allAnimations.clear(), t.log("Setup Unmounted"), !0;
+  }
+};
+Et.moduleName = "setup";
+let xt = Et;
+function mi(i, e) {
+  return i.document.documentElement.style.getPropertyValue(e);
+}
+function ye(i, e, t) {
+  i.document.documentElement.style.setProperty(e, t);
+}
+function wt(i, e) {
+  i.document.documentElement.style.removeProperty(e);
+}
+const Ge = "readium-viewport", Tt = class V extends xt {
+  onViewportWidthChanged(e) {
+    const t = e.target;
+    ye(t, "--RS__viewportWidth", `${t.innerWidth}px`);
+  }
+  mount(e, t) {
+    if (!super.mount(e, t))
+      return !1;
+    const r = e.document.createElement("meta");
+    return r.dataset.readium = "true", r.setAttribute("name", "viewport"), r.setAttribute("id", Ge), r.setAttribute(
+      "content",
+      "width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, shrink-to-fit=no"
+    ), e.document.head.appendChild(r), e.addEventListener("orientationchange", this.onViewportWidthChanged), e.addEventListener("resize", this.onViewportWidthChanged), this.onViewportWidthChanged({
+      target: e
+    }), t.register("set_property", V.moduleName, (s, n) => {
+      const o = s;
+      ye(e, o[0], o[1]), n(!0);
+    }), t.register("remove_property", V.moduleName, (s, n) => {
+      wt(e, s), n(!0);
+    }), t.register("activate", V.moduleName, (s, n) => {
+      this.unblock(e), n(!0);
+    }), t.log("ReflowableSetup Mounted"), !0;
+  }
+  unmount(e, t) {
+    var r;
+    return t.unregisterAll(V.moduleName), (r = e.document.head.querySelector(`#${Ge}`)) == null || r.remove(), e.removeEventListener("orientationchange", this.onViewportWidthChanged), t.log("ReflowableSetup Unmounted"), super.unmount(e, t);
+  }
+};
+Tt.moduleName = "reflowable_setup";
+let gi = Tt;
+const Ye = "readium-fixed-style", St = class L extends xt {
+  mount(e, t) {
+    if (!super.mount(e, t))
+      return !1;
+    const r = e.document.createElement("style");
+    return r.id = Ye, r.dataset.readium = "true", r.textContent = `
+        html, body {
+            text-size-adjust: none;
+            -ms-text-size-adjust: none;
+            -webkit-text-size-adjust: none;
+            -moz-text-size-adjust: none;
+
+            /* Fight Safari pinches */
+            touch-action: none !important;
+            min-height: 100%;
+
+            /*cursor: var() TODO*/
+        }`, e.document.head.appendChild(r), t.register("set_property", L.moduleName, (s, n) => {
+      const o = s;
+      ye(e, o[0], o[1]), n(!0);
+    }), t.register("remove_property", L.moduleName, (s, n) => {
+      wt(e, s), n(!0);
+    }), t.register("first_visible_locator", L.moduleName, (s, n) => n(!1)), t.register("unfocus", L.moduleName, (s, n) => {
+      T(e), n(!0);
+    }), t.register([
+      "focus",
+      "go_next",
+      "go_prev",
+      "go_id",
+      "go_end",
+      "go_start",
+      "go_text",
+      "go_progression"
+    ], L.moduleName, (s, n) => n(!0)), t.register("activate", L.moduleName, (s, n) => {
+      this.unblock(e), n(!0);
+    }), t.log("FixedSetup Mounted"), !0;
+  }
+  unmount(e, t) {
+    var r;
+    return t.unregisterAll(L.moduleName), (r = e.document.getElementById(Ye)) == null || r.remove(), t.log("FixedSetup Unmounted"), super.unmount(e, t);
+  }
+};
+St.moduleName = "fixed_setup";
+let vi = St;
+function yi(i, e) {
+  let t = i.getClientRects();
+  t.length || i.commonAncestorContainer.nodeType === Node.ELEMENT_NODE && (t = i.commonAncestorContainer.getClientRects());
+  const r = 1, s = [];
+  for (const c of t)
+    s.push({
+      bottom: c.bottom,
+      height: c.height,
+      left: c.left,
+      right: c.right,
+      top: c.top,
+      width: c.width
+    });
+  const n = Ct(
+    s,
+    r,
+    e
+  ), o = Ei(n, r), a = Pt(o), h = 2 * 2;
+  for (let c = a.length - 1; c >= 0; c--) {
+    const d = a[c];
+    if (!(d.width * d.height > h))
+      if (a.length > 1)
+        a.splice(c, 1);
+      else
+        break;
+  }
+  return a;
+}
+function Ct(i, e, t) {
+  for (let r = 0; r < i.length; r++)
+    for (let s = r + 1; s < i.length; s++) {
+      const n = i[r], o = i[s];
+      if (n === o)
+        continue;
+      const a = A(n.top, o.top, e) && A(n.bottom, o.bottom, e), h = A(n.left, o.left, e) && A(n.right, o.right, e);
+      if ((h && !t || a && !h) && Ot(n, o, e)) {
+        const u = i.filter((v) => v !== n && v !== o), f = bi(n, o);
+        return u.push(f), Ct(
+          u,
+          e,
+          t
+        );
+      }
+    }
+  return i;
+}
+function bi(i, e) {
+  const t = Math.min(i.left, e.left), r = Math.max(i.right, e.right), s = Math.min(i.top, e.top), n = Math.max(i.bottom, e.bottom);
+  return {
+    bottom: n,
+    height: n - s,
+    left: t,
+    right: r,
+    top: s,
+    width: r - t
+  };
+}
+function Ei(i, e) {
+  const t = new Set(i);
+  for (const r of i) {
+    if (!(r.width > 1 && r.height > 1)) {
+      t.delete(r);
+      continue;
+    }
+    for (const n of i)
+      if (r !== n && t.has(n) && xi(n, r, e)) {
+        t.delete(r);
+        break;
+      }
+  }
+  return Array.from(t);
+}
+function xi(i, e, t) {
+  return ie(i, e.left, e.top, t) && ie(i, e.right, e.top, t) && ie(i, e.left, e.bottom, t) && ie(i, e.right, e.bottom, t);
+}
+function ie(i, e, t, r) {
+  return (i.left < e || A(i.left, e, r)) && (i.right > e || A(i.right, e, r)) && (i.top < t || A(i.top, t, r)) && (i.bottom > t || A(i.bottom, t, r));
+}
+function Pt(i) {
+  for (let e = 0; e < i.length; e++)
+    for (let t = e + 1; t < i.length; t++) {
+      const r = i[e], s = i[t];
+      if (r !== s && Ot(r, s, -1)) {
+        let n = [], o;
+        const a = Ze(r, s);
+        if (a.length === 1)
+          n = a, o = r;
+        else {
+          const c = Ze(s, r);
+          a.length < c.length ? (n = a, o = r) : (n = c, o = s);
+        }
+        const h = i.filter((c) => c !== o);
+        return Array.prototype.push.apply(h, n), Pt(h);
+      }
+    }
+  return i;
+}
+function Ze(i, e) {
+  const t = wi(e, i);
+  if (t.height === 0 || t.width === 0)
+    return [i];
+  const r = [];
+  {
+    const s = {
+      bottom: i.bottom,
+      height: 0,
+      left: i.left,
+      right: t.left,
+      top: i.top,
+      width: 0
+    };
+    s.width = s.right - s.left, s.height = s.bottom - s.top, s.height !== 0 && s.width !== 0 && r.push(s);
+  }
+  {
+    const s = {
+      bottom: t.top,
+      height: 0,
+      left: t.left,
+      right: t.right,
+      top: i.top,
+      width: 0
+    };
+    s.width = s.right - s.left, s.height = s.bottom - s.top, s.height !== 0 && s.width !== 0 && r.push(s);
+  }
+  {
+    const s = {
+      bottom: i.bottom,
+      height: 0,
+      left: t.left,
+      right: t.right,
+      top: t.bottom,
+      width: 0
+    };
+    s.width = s.right - s.left, s.height = s.bottom - s.top, s.height !== 0 && s.width !== 0 && r.push(s);
+  }
+  {
+    const s = {
+      bottom: i.bottom,
+      height: 0,
+      left: t.right,
+      right: i.right,
+      top: i.top,
+      width: 0
+    };
+    s.width = s.right - s.left, s.height = s.bottom - s.top, s.height !== 0 && s.width !== 0 && r.push(s);
+  }
+  return r;
+}
+function wi(i, e) {
+  const t = Math.max(i.left, e.left), r = Math.min(i.right, e.right), s = Math.max(i.top, e.top), n = Math.min(i.bottom, e.bottom);
+  return {
+    bottom: n,
+    height: Math.max(0, n - s),
+    left: t,
+    right: r,
+    top: s,
+    width: Math.max(0, r - t)
+  };
+}
+function Ot(i, e, t) {
+  return (i.left < e.right || t >= 0 && A(i.left, e.right, t)) && (e.left < i.right || t >= 0 && A(e.left, i.right, t)) && (i.top < e.bottom || t >= 0 && A(i.top, e.bottom, t)) && (e.top < i.bottom || t >= 0 && A(e.top, i.bottom, t));
+}
+function A(i, e, t) {
+  return Math.abs(i - e) <= t;
+}
+const Ti = window.ResizeObserver || nt, Si = "Highlight" in window, Ke = ["IMG", "IMAGE", "AUDIO", "VIDEO", "SVG"];
+class Ci {
+  /**
+   * Creates a DecorationGroup object
+   * @param id Unique HTML ID-adhering name of the group
+   * @param name Human-readable name of the group
+   */
+  constructor(e, t, r, s) {
+    this.wnd = e, this.comms = t, this.id = r, this.name = s, this.items = [], this.lastItemId = 0, this.container = void 0, this.activateable = !1, this.experimentalHighlights = !1, this.currentRender = 0, Si && (this.experimentalHighlights = !0, this.notTextFlag = /* @__PURE__ */ new Map());
+  }
+  get activeable() {
+    return this.activateable;
+  }
+  set activeable(e) {
+    this.activateable = e;
+  }
+  /**
+   * Adds a new decoration to the group.
+   * @param decoration Decoration to add
+   */
+  add(e) {
+    var o, a, h, c;
+    const t = `${this.id}-${this.lastItemId++}`, r = Oe(this.wnd.document, e.locator);
+    if (!r) {
+      this.comms.log("Can't locate DOM range for decoration", e);
+      return;
+    }
+    const s = r.commonAncestorContainer;
+    s.nodeType !== Node.TEXT_NODE && this.experimentalHighlights && (Ke.includes(s.nodeName.toUpperCase()) && ((o = this.notTextFlag) == null || o.set(t, !0)), s.querySelector(Ke.join(", ").toLowerCase()) && ((a = this.notTextFlag) == null || a.set(t, !0)), (((h = s.textContent) == null ? void 0 : h.trim()) || "").length === 0 && ((c = this.notTextFlag) == null || c.set(t, !0)));
+    const n = {
+      decoration: e,
+      id: t,
+      range: r
+    };
+    this.items.push(n), this.layout(n), this.renderLayout([n]);
+  }
+  /**
+   * Removes the decoration with given ID from the group.
+   * @param identifier ID of item to remove
+   */
+  remove(e) {
+    var s, n;
+    const t = this.items.findIndex((o) => o.decoration.id === e);
+    if (t < 0)
+      return;
+    const r = this.items[t];
+    if (this.items.splice(t, 1), r.clickableElements = void 0, r.container && (r.container.remove(), r.container = void 0), this.experimentalHighlights && !((s = this.notTextFlag) != null && s.has(r.id))) {
+      const o = this.wnd.CSS.highlights.get(this.id);
+      o == null || o.delete(r.range);
+    }
+    (n = this.notTextFlag) == null || n.delete(r.id);
+  }
+  /**
+   * Notifies that the given decoration was modified and needs to be updated.
+   * @param decoration Decoration to update
+   */
+  update(e) {
+    this.remove(e.id), this.add(e);
+  }
+  /**
+   * Removes all decorations from this group.
+   */
+  clear() {
+    var e;
+    this.clearContainer(), this.items.length = 0, (e = this.notTextFlag) == null || e.clear();
+  }
+  /**
+   * Recreates the decoration elements.
+   * To be called after reflowing the resource, for example.
+   */
+  requestLayout() {
+    this.wnd.cancelAnimationFrame(this.currentRender), this.clearContainer(), this.items.forEach((e) => this.layout(e)), this.renderLayout(this.items);
+  }
+  experimentalLayout(e) {
+    var s, n;
+    const [t, r] = this.requireContainer(!0);
+    r.add(e.range), t.innerHTML = `
+        ::highlight(${this.id}) {
+            color: black;
+            background-color: ${((n = (s = e.decoration) == null ? void 0 : s.style) == null ? void 0 : n.tint) ?? "yellow"};
+        }`;
+  }
+  /**
+   * Layouts a single DecorationItem.
+   * @param item 
+   */
+  layout(e) {
+    var v, g, y, x, S;
+    if (this.experimentalHighlights && !((v = this.notTextFlag) != null && v.has(e.id)))
+      return this.experimentalLayout(e);
+    const t = this.wnd.document.createElement("div");
+    t.setAttribute("id", e.id), t.style.setProperty("pointer-events", "none");
+    const r = this.wnd.innerWidth, s = parseInt(
+      getComputedStyle(this.wnd.document.documentElement).getPropertyValue(
+        "column-count"
+      )
+    ), n = r / (s || 1), o = this.wnd.document.scrollingElement, a = o.scrollLeft, h = o.scrollTop, c = (m, E, O) => {
+      var Y, Z, B, D, K, J;
+      if (m.style.position = "absolute", ((Z = (Y = e.decoration) == null ? void 0 : Y.style) == null ? void 0 : Z.width) === "viewport") {
+        m.style.width = `${r}px`, m.style.height = `${E.height}px`;
+        let U = Math.floor(E.left / r) * r;
+        m.style.left = `${U + a}px`, m.style.top = `${E.top + h}px`;
+      } else if (((D = (B = e.decoration) == null ? void 0 : B.style) == null ? void 0 : D.width) === "bounds")
+        m.style.width = `${O.width}px`, m.style.height = `${E.height}px`, m.style.left = `${O.left + a}px`, m.style.top = `${E.top + h}px`;
+      else if (((J = (K = e.decoration) == null ? void 0 : K.style) == null ? void 0 : J.width) === "page") {
+        m.style.width = `${n}px`, m.style.height = `${E.height}px`;
+        let U = Math.floor(E.left / n) * n;
+        m.style.left = `${U + a}px`, m.style.top = `${E.top + h}px`;
+      } else
+        m.style.width = `${E.width}px`, m.style.height = `${E.height}px`, m.style.left = `${E.left + a}px`, m.style.top = `${E.top + h}px`;
+    }, d = e.range.getBoundingClientRect();
+    let p = this.wnd.document.createElement("template");
+    const u = mi(this.wnd, "--USER__appearance") === "readium-night-on";
+    p.innerHTML = `
+        <div
+            class="r2-highlight-0"
+            style="${[
+      `background-color: ${((y = (g = e.decoration) == null ? void 0 : g.style) == null ? void 0 : y.tint) ?? "yellow"} !important`,
+      //"opacity: 0.3 !important",
+      `mix-blend-mode: ${u ? "exclusion" : "multiply"} !important`,
+      "opacity: 1 !important",
+      "box-sizing: border-box !important"
+    ].join("; ")}"
+        >
+        </div>
+        `.trim();
+    const f = p.content.firstElementChild;
+    if (((S = (x = e.decoration) == null ? void 0 : x.style) == null ? void 0 : S.layout) === "bounds") {
+      const m = f.cloneNode(!0);
+      m.style.setProperty("pointer-events", "none"), c(m, d, d), t.append(m);
+    } else {
+      let m = yi(
+        e.range,
+        !0
+        // doNotMergeHorizontallyAlignedRects
+      );
+      m = m.sort((E, O) => E.top < O.top ? -1 : E.top > O.top ? 1 : 0);
+      for (let E of m) {
+        const O = f.cloneNode(!0);
+        O.style.setProperty("pointer-events", "none"), c(O, E, d), t.append(O);
+      }
+    }
+    e.container = t, e.clickableElements = Array.from(
+      t.querySelectorAll("[data-activable='1']")
+    ), e.clickableElements.length || (e.clickableElements = Array.from(t.children));
+  }
+  renderLayout(e) {
+    this.wnd.cancelAnimationFrame(this.currentRender), this.currentRender = this.wnd.requestAnimationFrame(() => {
+      if (e = e.filter((r) => {
+        var s;
+        return !this.experimentalHighlights || !!((s = this.notTextFlag) != null && s.has(r.id));
+      }), !e || e.length === 0)
+        return;
+      this.requireContainer().append(...e.map((r) => r.container).filter((r) => !!r));
+    });
+  }
+  /**
+   * Returns the group container element, after making sure it exists.
+   * @returns Group's container
+   */
+  requireContainer(e = !1) {
+    if (e) {
+      let t;
+      this.wnd.document.getElementById(`${this.id}-style`) ? t = this.wnd.document.getElementById(`${this.id}-style`) : (t = this.wnd.document.createElement("style"), t.dataset.readium = "true", t.id = `${this.id}-style`, this.wnd.document.head.appendChild(t));
+      let r;
+      return this.wnd.CSS.highlights.has(this.id) ? r = this.wnd.CSS.highlights.get(this.id) : (r = new this.wnd.Highlight(), this.wnd.CSS.highlights.set(this.id, r)), [t, r];
+    }
+    return this.container || (this.container = this.wnd.document.createElement("div"), this.container.setAttribute("id", this.id), this.container.dataset.group = this.name, this.container.dataset.readium = "true", this.container.style.setProperty("pointer-events", "none"), this.container.style.display = "contents", this.wnd.document.body.append(this.container)), this.container;
+  }
+  /**
+   * Removes the group container.
+   */
+  clearContainer() {
+    this.experimentalHighlights && this.wnd.CSS.highlights.delete(this.id), this.container && (this.container.remove(), this.container = void 0);
+  }
+}
+const At = class be extends ce {
+  constructor() {
+    super(...arguments), this.resizeFrame = 0, this.lastGroupId = 0, this.groups = /* @__PURE__ */ new Map(), this.handleResizer = this.handleResize.bind(this);
+  }
+  cleanup() {
+    this.groups.forEach((e) => e.clear()), this.groups.clear();
+  }
+  handleResize() {
+    this.wnd.clearTimeout(this.resizeFrame), this.resizeFrame = this.wnd.setTimeout(() => {
+      this.groups.forEach((e) => {
+        e.experimentalHighlights || e.requestLayout();
+      });
+    }, 50);
+  }
+  mount(e, t) {
+    return this.wnd = e, t.register("decorate", be.moduleName, (r, s) => {
+      const n = r;
+      n.decoration && n.decoration.locator && (n.decoration.locator = I.deserialize(n.decoration.locator)), this.groups.has(n.group) || this.groups.set(n.group, new Ci(
+        e,
+        t,
+        `readium-decoration-${this.lastGroupId++}`,
+        n.group
+      ));
+      const o = this.groups.get(n.group);
+      switch (n.action) {
+        case "add":
+          o == null || o.add(n.decoration);
+          break;
+        case "remove":
+          o == null || o.remove(n.decoration.id);
+          break;
+        case "clear":
+          o == null || o.clear();
+          break;
+        case "update":
+          o == null || o.update(n.decoration);
+          break;
+      }
+      s(!0);
+    }), this.resizeObserver = new Ti(() => e.requestAnimationFrame(() => this.handleResize())), this.resizeObserver.observe(e.document.body), e.addEventListener("orientationchange", this.handleResizer), e.addEventListener("resize", this.handleResizer), t.log("Decorator Mounted"), !0;
+  }
+  unmount(e, t) {
+    return e.removeEventListener("orientationchange", this.handleResizer), e.removeEventListener("resize", this.handleResizer), t.unregisterAll(be.moduleName), this.resizeObserver.disconnect(), this.cleanup(), t.log("Decorator Unmounted"), !0;
+  }
+};
+At.moduleName = "decorator";
+let Pi = At;
+const Oi = [
+  "fixed_setup",
+  "decorator",
+  "peripherals"
+], Ai = [
+  "reflowable_setup",
+  "decorator",
+  "peripherals",
+  "column_snapper",
+  "scroll_snapper"
+], Je = new Map([
+  // All modules go here
+  vi,
+  gi,
+  bt,
+  Pi,
+  ci,
+  fi
+].map((i) => [i.moduleName, i]));
+class Mi {
+  /**
+   * @param wnd Window instance to operate on
+   * @param initialModules List of initial modules to load
+   */
+  constructor(e = window, t = []) {
+    this.loadedModules = [], this.wnd = e, this.comms = new Rt(e);
+    const r = [...new Set(t)];
+    if (r.length) {
+      if (typeof e > "u")
+        throw Error("Loader is not in a web browser");
+      e.parent !== e && this.comms.log("Loader is probably in a frame"), this.loadedModules = r.map((s) => {
+        const n = this.loadModule(s);
+        if (n)
+          return n.mount(this.wnd, this.comms), n;
+      }).filter((s) => s !== void 0);
+    }
+  }
+  loadModule(e) {
+    const t = Je.get(e);
+    return t === void 0 ? (this.comms.log(`Module "${name}" does not exist in the library`), t) : new t();
+  }
+  /**
+   * Add a module by name
+   * @param moduleName Module name
+   * @returns Success
+   */
+  addModule(e) {
+    const t = this.loadModule(e);
+    return !t || !t.mount(this.wnd, this.comms) ? !1 : (this.loadedModules.push(t), !0);
+  }
+  /**
+   * Remove a module by name
+   * @param moduleName Module name
+   * @returns Success
+   */
+  removeModule(e) {
+    const t = Je.get(e);
+    if (t === void 0)
+      return this.comms.log(`Module "${e}" does not exist in the library`), !1;
+    const r = this.loadedModules.findIndex((s) => s instanceof t);
+    return r < 0 ? !1 : (this.loadedModules[r].unmount(this.wnd, this.comms), this.loadedModules.splice(r, 1), !0);
+  }
+  /**
+   * Unmount and remove all modules
+   */
+  destroy() {
+    this.comms.destroy(), this.loadedModules.forEach((e) => e.unmount(this.wnd, this.comms)), this.loadedModules = [];
+  }
+}
+export {
+  X as COMMS_VERSION,
+  Rt as Comms,
+  Oi as FXLModules,
+  Mi as Loader,
+  ce as Module,
+  Je as ModuleLibrary,
+  bt as Peripherals,
+  Ai as ReflowableModules,
+  Nt as mid
+};