dlxj commited on Feb 24

Commit

2d8be8f

1 Parent(s): 4e1096a

add sub mods

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

.gitattributes +6 -0
apps/readest-app/src/__tests__/utils/paragraph.test.ts +46 -0
apps/readest-app/src/utils/paragraph.ts +12 -9
apps/readest-app/src/utils/style.ts +6 -0
packages/foliate-js/.gitattributes +1 -0
packages/foliate-js/.github/FUNDING.yml +1 -0
packages/foliate-js/.github/workflows/eslint.yml +50 -0
packages/foliate-js/.gitignore +1 -0
packages/foliate-js/LICENSE +21 -0
packages/foliate-js/README.md +374 -0
packages/foliate-js/comic-book.js +64 -0
packages/foliate-js/dict.js +241 -0
packages/foliate-js/epub.js +1374 -0
packages/foliate-js/epubcfi.js +345 -0
packages/foliate-js/eslint.config.js +22 -0
packages/foliate-js/fb2.js +348 -0
packages/foliate-js/fixed-layout.js +618 -0
packages/foliate-js/footnotes.js +145 -0
packages/foliate-js/mobi.js +1236 -0
packages/foliate-js/opds.js +294 -0
packages/foliate-js/overlayer.js +409 -0
packages/foliate-js/package-lock.json +1584 -0
packages/foliate-js/package.json +50 -0
packages/foliate-js/paginator.js +1417 -0
packages/foliate-js/pdf.js +315 -0
packages/foliate-js/progress.js +113 -0
packages/foliate-js/quote-image.js +86 -0
packages/foliate-js/reader.html +304 -0
packages/foliate-js/reader.js +239 -0
packages/foliate-js/rollup.config.js +32 -0
packages/foliate-js/rollup/fflate.js +1 -0
packages/foliate-js/rollup/zip.js +1 -0
packages/foliate-js/search.js +130 -0
packages/foliate-js/tests/epubcfi-tests.js +236 -0
packages/foliate-js/tests/tests.html +5 -0
packages/foliate-js/tests/tests.js +1 -0
packages/foliate-js/text-walker.js +43 -0
packages/foliate-js/tts.js +377 -0
packages/foliate-js/ui/menu.js +42 -0
packages/foliate-js/ui/tree.js +169 -0
packages/foliate-js/uri-template.js +52 -0
packages/foliate-js/vendor/fflate.js +1 -0
packages/foliate-js/vendor/pdfjs/annotation_layer_builder.css +407 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-EUC-H.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-EUC-V.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-H.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-RKSJ-H.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-RKSJ-V.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78-V.bcmap +3 -0
packages/foliate-js/vendor/pdfjs/cmaps/78ms-RKSJ-H.bcmap +3 -0

.gitattributes CHANGED Viewed

@@ -1,4 +1,10 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.woff2 filter=lfs diff=lfs merge=lfs -text
 *.icns filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text

 *.7z filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.exe filter=lfs diff=lfs merge=lfs -text
+*.pfb filter=lfs diff=lfs merge=lfs -text
+*.bcmap filter=lfs diff=lfs merge=lfs -text
+*.bcmap filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
 *.woff2 filter=lfs diff=lfs merge=lfs -text
 *.icns filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text

apps/readest-app/src/__tests__/utils/paragraph.test.ts ADDED Viewed

	@@ -0,0 +1,46 @@

+import { describe, it, expect } from 'vitest';
+import { ParagraphIterator } from '@/utils/paragraph';
+const createDoc = (body: string): Document =>
+  new DOMParser().parseFromString(`<html><body>${body}</body></html>`, 'text/html');
+describe('ParagraphIterator', () => {
+  it('skips whitespace-only paragraphs', async () => {
+    const doc = createDoc(`
+      <p>First</p>
+      <p> </p>
+      <p>&nbsp;</p>
+      <p>\u200b</p>
+      <p><span>\u00a0</span></p>
+      <p><br /></p>
+      <p>Second</p>
+    `);
+    const iterator = await ParagraphIterator.createAsync(doc, 1000);
+    expect(iterator.length).toBe(2);
+    expect(iterator.first()?.toString()).toContain('First');
+    expect(iterator.next()?.toString()).toContain('Second');
+  });
+  it('keeps paragraphs with non-text content', async () => {
+    const doc = createDoc(`
+      <p>Intro</p>
+      <p><img src="cover.png" alt="" /></p>
+      <p>Outro</p>
+    `);
+    const iterator = await ParagraphIterator.createAsync(doc, 1000);
+    expect(iterator.length).toBe(3);
+    iterator.first();
+    expect(iterator.current()?.toString()).toContain('Intro');
+    const imageRange = iterator.next();
+    const fragment = imageRange?.cloneContents();
+    expect(fragment?.querySelector('img')).not.toBeNull();
+    expect(iterator.next()?.toString()).toContain('Outro');
+  });
+});

apps/readest-app/src/utils/paragraph.ts CHANGED Viewed

@@ -31,16 +31,19 @@ const blockTags = new Set([
 const MAX_BLOCKS = 5000;
 const rangeHasContent = (range: Range): boolean => {
   try {
-    const container = range.commonAncestorContainer;
-    if (container.nodeType === Node.TEXT_NODE) {
-      return (container.textContent?.trim().length ?? 0) > 0;
-    }
-    if (container.nodeType === Node.ELEMENT_NODE) {
-      return (container as Element).textContent?.trim().length !== 0;
-    }
-    return true;
   } catch {
     return false;
   }
@@ -48,7 +51,7 @@ const rangeHasContent = (range: Range): boolean => {
 const hasDirectText = (node: Element): boolean =>
   Array.from(node.childNodes).some(
-    (child) => child.nodeType === Node.TEXT_NODE && child.textContent?.trim(),
   );
 const hasBlockChild = (node: Element): boolean =>

 const MAX_BLOCKS = 5000;
+const INVISIBLE_TEXT_PATTERN =
+  /[\s\u00a0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\u200b-\u200d\u2060\ufeff]/g;
+const MEDIA_SELECTOR = 'img, svg, video, audio, canvas, math, iframe, object, embed, hr';
+const hasMeaningfulText = (text?: string | null): boolean =>
+  (text ?? '').replace(INVISIBLE_TEXT_PATTERN, '').length > 0;
 const rangeHasContent = (range: Range): boolean => {
   try {
+    const text = range.toString();
+    if (hasMeaningfulText(text)) return true;
+    const fragment = range.cloneContents();
+    return !!fragment.querySelector?.(MEDIA_SELECTOR);
   } catch {
     return false;
   }
 const hasDirectText = (node: Element): boolean =>
   Array.from(node.childNodes).some(
+    (child) => child.nodeType === Node.TEXT_NODE && hasMeaningfulText(child.textContent),
   );
 const hasBlockChild = (node: Element): boolean =>

apps/readest-app/src/utils/style.ts CHANGED Viewed

@@ -867,10 +867,16 @@ export const applyTableStyle = (document: Document) => {
         table.style.width = `calc(min(${computedWidth}, var(--available-width)))`;
       }
     }
     if (totalTableWidth > 0) {
       const scale = `calc(min(1, var(--available-width) / ${totalTableWidth}))`;
       table.style.transformOrigin = 'left top';
       table.style.transform = `scale(${scale})`;
     }
   });
 };

         table.style.width = `calc(min(${computedWidth}, var(--available-width)))`;
       }
     }
+    const parentWidth = window.getComputedStyle(parent as Element).width;
+    const parentContainerWidth = parseFloat(parentWidth) || 0;
     if (totalTableWidth > 0) {
       const scale = `calc(min(1, var(--available-width) / ${totalTableWidth}))`;
       table.style.transformOrigin = 'left top';
       table.style.transform = `scale(${scale})`;
+    } else if (parentContainerWidth > 0) {
+      const scale = `calc(min(1, var(--available-width) / ${parentContainerWidth}))`;
+      table.style.transformOrigin = 'center top';
+      table.style.transform = `scale(${scale})`;
     }
   });
 };

packages/foliate-js/.gitattributes ADDED Viewed

	@@ -0,0 +1 @@


1	+ vendor/** linguist-vendored=true

packages/foliate-js/.github/FUNDING.yml ADDED Viewed

	@@ -0,0 +1 @@


1	+ buy_me_a_coffee: johnfactotum

packages/foliate-js/.github/workflows/eslint.yml ADDED Viewed

	@@ -0,0 +1,50 @@

+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# ESLint is a tool for identifying and reporting on patterns
+# found in ECMAScript/JavaScript code.
+# More details at https://github.com/eslint/eslint
+# and https://eslint.org
+name: ESLint
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "main" ]
+  schedule:
+    - cron: '27 12 * * 1'
+jobs:
+  eslint:
+    name: Run eslint scanning
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+      actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Install ESLint
+        run: |
+          npm install eslint@9.28.0
+          npm install @microsoft/eslint-formatter-sarif@3.1.0
+      - name: Run ESLint
+        env:
+          SARIF_ESLINT_IGNORE_SUPPRESSED: "true"
+        run: npx eslint .
+          --format @microsoft/eslint-formatter-sarif
+          --output-file eslint-results.sarif
+        continue-on-error: true
+      - name: Upload analysis results to GitHub
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: eslint-results.sarif
+          wait-for-processing: true

packages/foliate-js/.gitignore ADDED Viewed

	@@ -0,0 +1 @@


1	+ node_modules/

packages/foliate-js/LICENSE ADDED Viewed

	@@ -0,0 +1,21 @@

+MIT License
+Copyright (c) 2022 John Factotum
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/foliate-js/README.md ADDED Viewed

	@@ -0,0 +1,374 @@

+# foliate-js
+Library for rendering e-books in the browser.
+Features:
+- Supports EPUB, MOBI, KF8 (AZW3), FB2, CBZ, PDF (experimental; requires PDF.js)
+- Add support for other formats yourself by implementing the book interface
+- Pure JavaScript
+- Small and modular
+- No hard dependencies
+- Does not require loading whole file into memory
+- Does not care about older browsers
+## Demo
+The repo includes a demo viewer that can be used to open local files. To use it, serve the files with a server, and navigate to `reader.html`. Or visit the [online demo](https://johnfactotum.github.io/foliate-js/reader.html) hosted on GitHub. Note that it is very incomplete at the moment, and lacks many basic features such as keyboard shortcuts.
+Also note that deobfuscating fonts with the IDPF algorithm requires a SHA-1 function. By default it uses Web Crypto, which is only available in secure contexts. Without HTTPS, you will need to modify `reader.js` and pass your own SHA-1 implementation.
+## Current Status
+It works reasonably well, and has been used in several stable releases of [Foliate](https://github.com/johnfactotum/foliate). This library itself is, however, *not* stable. Expect it to break and the API to change at any time. Use it at your own risk.
+If you do decide to use it, since there's no release yet, it is recommended that you include the library as a git submodule in your project so that you can easily update it.
+## Documentation
+### Overview
+This project uses native ES modules. There's no build step, and you can import them directly.
+There are mainly three kinds of modules:
+- Modules that parse and load books, implementing the "book" interface
+    - `comic-book.js`, for comic book archives (CBZ)
+    - `epub.js` and `epubcfi.js`, for EPUB
+    - `fb2.js`, for FictionBook 2
+    - `mobi.js`, for both Mobipocket files and KF8 (commonly known as AZW3) files
+- Modules that handle pagination, implementing the "renderer" interface
+    - `fixed-layout.js`, for fixed layout books
+    - `paginator.js`, for reflowable books
+- Auxiliary modules used to add additional functionalities
+    - `overlayer.js`, for rendering annotations
+    - `progress.js`, for getting reading progress
+    - `search.js`, for searching
+The modules are designed to be modular. In general, they don't directly depend on each other. Instead they depend on certain interfaces, detailed below. The exception is `view.js`. It is the higher level renderer that strings most of the things together, and you can think of it as the main entry point of the library. See "Basic Usage" below.
+The repo also includes a still higher level reader, though strictly speaking, `reader.html` (along with `reader.js` and its associated files in `ui/`) is not considered part of the library itself. It's akin to [Epub.js Reader](https://github.com/futurepress/epubjs-reader). You are expected to modify it or replace it with your own code.
+### Basic Usage
+To get started, clone the repo and import `view.js`:
+```js
+import './foliate-js/view.js'
+const view = document.createElement('foliate-view')
+document.body.append(view)
+view.addEventListener('relocate', e => {
+    console.log('location changed')
+    console.log(e.detail)
+})
+// can open a File/Blob object or a URL
+// or any object that implements the "book" interface
+await view.open('example.epub')
+await view.goTo(/* path, section index, or CFI */)
+```
+See the [online demo](https://johnfactotum.github.io/foliate-js/reader.html) for a more advanced example.
+### Security
+EPUB books can contain [scripted content](https://www.w3.org/TR/epub/#sec-scripted-content) (i.e. JavaScript in the e-book), which is potentially dangerous, and is not supported by this library because
+- It is currently impossible to do so securely due to the content being served from the same origin (using `blob:` URLs).
+- Due to [WebKit Bug 218086](https://bugs.webkit.org/show_bug.cgi?id=218086), the `allow-scripts` attribute is required on iframes, which renders iframe sandbox useless.
+It is therefore imperative that you use [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) to block all scripts except `'self'`. An EPUB file for testing can be found at https://github.com/johnfactotum/epub-test.
+> [!CAUTION]
+> Do NOT use this library (or any other e-book library, for that matter) without CSP unless you completely trust the content you're rendering or can block scripts by other means.
+### The Main Interface for Books
+Processors for each book format return an object that implements the following interface:
+- `.sections`: an array of sections in the book. Each item has the following properties:
+    - `.load()`: returns a string containing the URL that will be rendered. May be async.
+    - `.unload()`: returns nothing. If present, can be used to free the section.
+    - `.createDocument()`: returns a `Document` object of the section. Used for searching. May be async.
+    - `.size`: a number, the byte size of the section. Used for showing reading progress.
+    - `.linear`: a string. If it is `"no"`, the section is not part of the linear reading sequence (see the [`linear`](https://www.w3.org/publishing/epub32/epub-packages.html#attrdef-itemref-linear) attribute in EPUB).
+    - `.cfi`: base CFI string of the section. The part that goes before the `!` in CFIs.
+    - `.id`: an identifier for the section, used for getting TOC item (see below). Can be anything, as long as they can be used as keys in a `Map`.
+- `.dir`: a string representing the page progression direction of the book (`"rtl"` or `"ltr"`).
+- `.toc`: an array representing the table of contents of the book. Each item has
+    - `.label`: a string label for the item
+    - `.href`: a string representing the destination of the item. Does not have to be a valid URL.
+    - `.subitems`: a array that contains TOC items
+- `.pageList`: same as the TOC, but for the [page list](https://www.w3.org/publishing/epub32/epub-packages.html#sec-nav-pagelist).
+- `.metadata`: an object representing the metadata of the book. Currently, it follows more or less the metadata schema of [Readium's webpub manifest](https://github.com/readium/webpub-manifest). Note that titles and names can be a string or an object like `{ ja: "草枕", en: 'Kusamakura' }`, and authors, etc. can be a string, an object, or an array of strings or objects.
+- `.rendition`: an object that contains properties that correspond to the [rendition properties](https://www.w3.org/publishing/epub32/epub-packages.html#sec-package-metadata-rendering) in EPUB. If `.layout` is `"pre-paginated"`, the book is rendered with the fixed layout renderer.
+- `.resolveHref(href)`: given an href string, returns an object representing the destination referenced by the href, which has the following properties:
+    - `.index`: the index of the referenced section in the `.section` array
+    - `.anchor(doc)`: given a `Document` object, returns the document fragment referred to by the href (can either be an `Element` or a `Range`), or `null`
+- `.resolveCFI(cfi)`: same as above, but with a CFI string instead of href
+- `.isExternal(href)`: returns a boolean. If `true`, the link should be opened externally.
+The following methods are consumed by `progress.js`, for getting the correct TOC and page list item when navigating:
+- `.splitTOCHref(href)`: given an href string (from the TOC), returns an array, the first element of which is the `id` of the section (see above), and the second element is the fragment identifier (can be any type; see below). May be async.
+- `.getTOCFragment(doc, id)`: given a `Document` object and a fragment identifier (the one provided by `.splitTOCHref()`; see above), returns a `Node` representing the target linked by the TOC item
+In addition, the `.transformTarget`, if present, can be used to transform the contents of the book as it loads. It is an `EventTarget` with a custom event `"data"`, whose `.detail` is `{ data, type, name }`, where `.data` is either a string or `Blob`, or a `Promise` thereof, `.type` the content type string, and `.name` the identifier of the resource. Event handlers should mutate `.data` to transform the data.
+Almost all of the properties and methods are optional. At minimum it needs `.sections` and the `.load()` method for the sections, as otherwise there won't be anything to render.
+### Archived Files
+Reading Zip-based formats requires adapting an external library. Both `epub.js` and `comic-book.js` expect a `loader` object that implements the following interface:
+- `.entries`: (only used by `comic-book.js`) an array, each element of which has a `filename` property, which is a string containing the filename (the full path).
+- `.loadText(filename)`: given the path, returns the contents of the file as string.  May be async.
+- `.loadBlob(filename)`: given the path, returns the file as a `Blob` object. May be async.
+- `.getSize(filename)`: returns the file size in bytes. Used to set the `.size` property for `.sections` (see above).
+In `view.js`, this is implemented using [zip.js](https://github.com/gildas-lormeau/zip.js), which is highly recommended because it seems to be the only library that supports random access for `File` objects (as well as HTTP range requests).
+One advantage of having such an interface is that one can easily use it for reading unarchived files as well. For example, `view.js` has a loader that allows you to open unpacked EPUBs as directories.
+### Mobipocket and Kindle Files
+It can read both MOBI and KF8 (.azw3, and combo .mobi files) from a `File` (or `Blob`) object. For MOBI files, it decompresses all text at once and splits the raw markup into sections at every `<mbp:pagebreak>`, instead of outputting one long page for the whole book, which drastically improves rendering performance. For KF8 files, it tries to decompress as little text as possible when loading a section, but it can still be quite slow due to the slowness of the current HUFF/CDIC decompressor implementation. In all cases, images and other resources are not loaded until they are needed.
+Note that KF8 files can contain fonts that are zlib-compressed. They need to be decompressed with an external library. `view.js` uses [fflate](https://github.com/101arrowz/fflate) to decompress them.
+### PDF and Other Fixed-Layout Formats
+There is a proof-of-concept, highly experimental adapter for [PDF.js](https://mozilla.github.io/pdf.js/), with which you can show PDFs using the same fixed-layout renderer for EPUBs.
+CBZs are similarly handled like fixed-layout EPUBs.
+### The Renderers
+To simplify things, it has two separate renderers, one for reflowable books, and one for fixed layout books (as such there's no support for mixed layout books). These renderers are custom elements (web components).
+A renderer's interface is currently mainly:
+- `.open(book)`: open a book object.
+- `.goTo({ index, anchor })`: navigate to a destination. The argument has the same type as the one returned by `.resolveHref()` in the book object.
+- `.prev()`: go to previous page.
+- `.next()`: go to next page.
+It has the following custom events:
+- `load`, when a section is loaded. Its `event.detail` has two properties, `doc`, the `Document` object, and `index`, the index of the section.
+- `relocate`, when the location changes. Its `event.detail` has the properties `range`, `index`, and `fraction`, where `range` is a `Range` object containing the current visible area, and `fraction` is a number between 0 and 1, representing the reading progress within the section.
+- `create-overlayer`, which allows adding an overlay to the page. The `event.detail` has the properties `doc`, `index`, and a function `attach(overlay)`, which should be called with an overlayer object (see the description for `overlayer.js` below).
+Both renderers have the [`part`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/part) named `filter`, which you can apply CSS filters to, to e.g. invert colors or adjust brightness:
+```css
+foliate-view::part(filter) {
+    filter: invert(1) hue-rotate(180deg);
+}
+```
+The filter only applies to the book itself, leaving overlaid elements such as highlights unaffected.
+### The Paginator
+The paginator uses the same pagination strategy as [Epub.js](https://github.com/futurepress/epub.js): it uses CSS multi-column. As such it shares much of the same limitations (it's slow, some CSS styles do not work as expected, and other bugs). There are a few differences:
+- It is a totally standalone module. You can use it to paginate any content.
+- It is much simpler, but currently there's no support for continuous scrolling.
+- It has no concept of CFIs and operates on `Range` objects directly.
+- It uses bisecting to find the current visible range, which is more accurate than what Epub.js does.
+- It has an internal `#anchor` property, which can be a `Range`, `Element`, or a fraction that represents the current location. The view is *anchored* to it no matter how you resize the window.
+- It supports more than two columns.
+- It supports switching between scrolled and paginated mode without reloading (I can't figure out how to do this in Epub.js).
+The layout can be configured by setting the following attributes:
+- `animated`: a [boolean attribute](https://developer.mozilla.org/en-US/docs/Glossary/Boolean/HTML). If present, adds a sliding transition effect.
+- `flow`: either `paginated` or `scrolled`.
+- `margin`: a CSS `<length>`. The unit must be `px`. The height of the header and footer.
+- `gap`: a CSS `<percentage>`. The size of the space between columns, relative to page size.
+- `max-inline-size`: a CSS `<length>`. The unit must be `px`. The maximum inline size of the text (column width in paginated mode).
+- `max-block-size`: same as above, but for the size in the block direction.
+- `max-column-count`: integer. The maximum number of columns. Has no effect in scrolled mode, or when the orientation of the renderer element is `portrait` (or, for vertical writing, `landscape`).
+(Note: there's no JS property API. You must use `.setAttribute()`.)
+It has built-in header and footer regions accessible via the `.heads` and `.feet` properties of the paginator instance. These can be used to display running heads and reading progress. They are only available in paginated mode, and there will be one element for each column. They are styleable with `::part(head)` and `::part(foot)`. E.g., to add a border under the running heads,
+```css
+foliate-view::part(head) {
+    padding-bottom: 4px;
+    border-bottom: 1px solid graytext;
+}
+```
+### EPUB CFI
+Parsed CFIs are represented as a plain array or object. The basic type is called a "part", which is an object with the following structure: `{ index, id, offset, temporal, spatial, text, side }`, corresponding to a step + offset in the CFI.
+A collapsed, non-range CFI is represented as an array whose elements are arrays of parts, each corresponding to a full path. That is, `/6/4!/4` is turned into
+```json
+[
+    [
+        { "index": 6 },
+        { "index": 4 }
+    ],
+    [
+        { "index": 4 }
+    ]
+]
+```
+A range CFI is an object `{ parent, start, end }`, each property being the same type as a collapsed CFI. For example, `/6/4!/2,/2,/4` is represented as
+```json
+{
+    "parent": [
+        [
+            { "index": 6 },
+            { "index": 4 }
+        ],
+        [
+            { "index": 2 }
+        ]
+    ],
+    "start": [
+        [
+            { "index": 2 }
+        ]
+    ],
+    "end": [
+        [
+            { "index": 4 }
+        ]
+    ]
+}
+```
+The parser uses a state machine rather than regex, and should handle assertions that contain escaped characters correctly (see tests for examples of this).
+It has the ability ignore nodes, which is needed if you want to inject your own nodes into the document without affecting CFIs. To do this, you need to pass the optional filter function that works similarly to the filter function of [`TreeWalker`s](https://developer.mozilla.org/en-US/docs/Web/API/Document/createTreeWalker):
+```js
+const filter = node => node.nodeType !== 1 ? NodeFilter.FILTER_ACCEPT
+    : node.matches('.reject') ? NodeFilter.FILTER_REJECT
+    : node.matches('.skip') ? NodeFilter.FILTER_SKIP
+    : NodeFilter.FILTER_ACCEPT
+CFI.toRange(doc, 'epubcfi(...)', filter)
+CFI.fromRange(range, filter)
+```
+It can parse and stringify spatial and temporal offsets, as well as text location assertions and side bias, but there's no support for employing them when rendering yet.
+### Highlighting Text
+There is a generic module for overlaying arbitrary SVG elements, `overlayer.js`. It can be used to implement highlighting text for annotations. It's the same technique used by [marks-pane](https://github.com/fchasen/marks), used by Epub.js, but it's designed to be easily extensible. You can return any SVG element in the `draw` function, making it possible to add custom styles such as squiggly lines or even free hand drawings.
+The overlay has no event listeners by default. It only provides a `.hitTest(event)` method, that can be used to do hit tests. Currently it does this with the client rects of `Range`s, not the element returned by `draw()`.
+An overlayer object implements the following interface for the consumption of renderers:
+- `.element`: the DOM element of the overlayer. This element will be inserted, resized, and positioned automatically by the renderer on top of the page.
+- `.redraw()`: called by the renderer when the overlay needs to be redrawn.
+### The Text Walker
+Not a particularly descriptive name, but essentially, `text-walker.js` is a small DOM utility that allows you to
+1. Gather all text nodes in a `Range`, `Document` or `DocumentFragment` into an array of strings.
+2. Perform splitting or matching on the strings.
+3. Get back the results of these string operations as `Range`s.
+E.g. you can join all the text nodes together, use `Intl.Segmenter` to segment the string into words, and get the results in DOM Ranges, so you can mark up those words in the original document.
+In foliate-js, this is used for searching and TTS.
+### Searching
+It provides a search module, which can in fact be used as a standalone module for searching across any array of strings. There's no limit on the number of strings a match is allowed to span. It's based on `Intl.Collator` and `Intl.Segmenter`, to support ignoring diacritics and matching whole words only. It's extrenely slow, and you'd probably want to load results incrementally.
+### Text-to-Speech (TTS)
+The TTS module doesn't directly handle speech output. Rather, its methods return SSML documents (as strings), which you can then feed to your speech synthesizer.
+The SSML attributes `ssml:ph` and `ssml:alphabet` are supported. There's no support for PLS and CSS Speech.
+### Offline Dictionaries
+The `dict.js` module can be used to load dictd and StarDict dictionaries. Usage:
+```js
+import { StarDict } from './dict.js'
+import { inflate } from 'your inflate implementation'
+const { ifo, dz, idx, syn } = { /* `File` (or `Blob`) objects */ }
+const dict = new StarDict()
+await dict.loadIfo(ifo)
+await dict.loadDict(dz, inflate)
+await dict.loadIdx(idx)
+await dict.loadSyn(syn)
+// look up words
+const query = '...'
+await dictionary.lookup(query)
+await dictionary.synonyms(query)
+```
+Note that you must supply your own `inflate` function. Here is an example using [fflate](https://github.com/101arrowz/fflate):
+```js
+const inflate = data => new Promise(resolve => {
+    const inflate = new fflate.Inflate()
+    inflate.ondata = data => resolve(data)
+    inflate.push(data)
+})
+```
+### OPDS
+The `opds.js` module can be used to implement OPDS clients. It can convert OPDS 1.x documents to OPDS 2.0:
+- `getFeed(doc)`: converts an OPDS 1.x feed to OPDS 2.0. The argument must be a DOM Document object. You need to use a `DOMParser` to obtain a Document first if you have a string.
+- `getPublication(entry)`: converts a OPDS 1.x entry in acquisition feeds to an OPDS 2.0 publication. The argument must be a DOM Element object.
+It exports the following symbols for properties unsupported by OPDS 2.0:
+- `SYMBOL.SUMMARY`: used on navigation links to represent the summary/content (see https://github.com/opds-community/drafts/issues/51)
+- `SYMBOL.CONTENT`: used on publications to represent the content/description and its type. This is mainly for preserving the type info for XHTML. The value of this property is an object whose properties are:
+    - `.type`: either "text", "html", or "xhtml"
+    - `.value`: the value of the content
+There are also two functions that can be used to implement search forms:
+- `getOpenSearch(doc)`: for OpenSearch. The argument is a DOM Document object of an OpenSearch search document.
+- `getSearch(link)` for templated search in OPDS 2.0. The argument must be an OPDS 2.0 Link object. Note that this function will import `uri-template.js`.
+These two functions return an object that implements the following interface:
+- `.metadata`: an object with the string properties `title` and `description`
+- `.params`: an array, representing the search parameters, whose elements are objects whose properties are
+    - `ns`: a string; the namespace of the parameter
+    - `name`: a string; the name of the parameter
+    - `required`: a boolean, whether the parameter is required
+    - `value`: a string; the default value of the parameter
+- `.search(map)`: a function, whose argument is a `Map` whose values are `Map`s (i.e. a two-dimensional map). The first key is the namespace of the search parameter. For non-namespaced parameters, the first key must be `null`. The second key is the parameter's name. Returns a string representing the URL of the search results.
+### Generating Images for Quotes
+With `quote-image.js`, one can generate shareable images for quotes:
+```js
+document.querySelector('foliate-quoteimage').getBlob({
+    title: 'The Time Machine',
+    author: 'H. G. Wells',
+    text: 'Can an instantaneous cube exist?',
+})
+```
+### Supported Browsers
+It aims to support the latest version of WebKitGTK, Firefox, and Chromium. Older browsers like Firefox ESR are not supported.
+Although it's mainly indeded for rendering e-books in the browser, some features can be used in non-browser environments as well. In particular, `epubcfi.js` can be used as is in any environment if you only need to parse or sort CFIs. Most other features depend on having the global objects `Blob`, `TextDecoder`, `TextEncoder`, `DOMParser`, `XMLSerializer`, and `URL`, and should work if you polyfill them.
+## License
+MIT.
+Vendored libraries:
+- [zip.js](https://github.com/gildas-lormeau/zip.js) is licensed under the BSD-3-Clause license.
+- [fflate](https://github.com/101arrowz/fflate) is MIT licensed.
+- [PDF.js](https://mozilla.github.io/pdf.js/) is licensed under Apache.

packages/foliate-js/comic-book.js ADDED Viewed

	@@ -0,0 +1,64 @@

+export const makeComicBook = async ({ entries, loadBlob, getSize, getComment }, file) => {
+    const cache = new Map()
+    const urls = new Map()
+    const load = async name => {
+        if (cache.has(name)) return cache.get(name)
+        const src = URL.createObjectURL(await loadBlob(name))
+        const page = URL.createObjectURL(
+            new Blob([`<!DOCTYPE html><html><head><meta charset="utf-8"></head><body style="margin: 0"><img src="${src}"></body></html>`], { type: 'text/html' }))
+        urls.set(name, [src, page])
+        cache.set(name, page)
+        return page
+    }
+    const unload = name => {
+        urls.get(name)?.forEach?.(url => URL.revokeObjectURL(url))
+        urls.delete(name)
+        cache.delete(name)
+    }
+    const exts = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.jxl', '.avif']
+    const files = entries
+        .map(entry => entry.filename)
+        .filter(name => exts.some(ext => name.endsWith(ext)))
+        .sort()
+    if (!files.length) throw new Error('No supported image files in archive')
+    const book = {}
+    try {
+        const jsonComment = JSON.parse(await getComment() || '')
+        const info = jsonComment['ComicBookInfo/1.0']
+        if (info) {
+            const year = info.publicationYear
+            const month = info.publicationMonth
+            const mm = month && month >= 1 && month <= 12 ? String(month).padStart(2, '0') : null
+            book.metadata = {
+                title: info.title || file.name,
+                publisher: info.publisher,
+                language: info.language || info.lang,
+                author: info.credits ? info.credits.map(c => `${c.person} (${c.role})`).join(', ') : '',
+                published: year && month ? `${year}-${mm}` : undefined,
+            }
+        } else {
+            book.metadata = { title: file.name }
+        }
+    } catch {
+        book.metadata = { title: file.name }
+    }
+    book.getCover = () => loadBlob(files[0])
+    book.sections = files.map(name => ({
+        id: name,
+        load: () => load(name),
+        unload: () => unload(name),
+        size: getSize(name),
+    }))
+    book.toc = files.map(name => ({ label: name, href: name }))
+    book.rendition = { layout: 'pre-paginated' }
+    book.resolveHref = href => ({ index: book.sections.findIndex(s => s.id === href) })
+    book.splitTOCHref = href => [href, null]
+    book.getTOCFragment = doc => doc.documentElement
+    book.destroy = () => {
+        for (const arr of urls.values())
+            for (const url of arr) URL.revokeObjectURL(url)
+    }
+    return book
+}

packages/foliate-js/dict.js ADDED Viewed

	@@ -0,0 +1,241 @@

+const decoder = new TextDecoder()
+const decode = decoder.decode.bind(decoder)
+const concatTypedArray = (a, b) => {
+    const result = new a.constructor(a.length + b.length)
+    result.set(a)
+    result.set(b, a.length)
+    return result
+}
+const strcmp = (a, b) => {
+    a = a.toLowerCase(), b = b.toLowerCase()
+    return a < b ? -1 : a > b ? 1 : 0
+}
+class DictZip {
+    #chlen
+    #chunks
+    #compressed
+    inflate
+    async load(file) {
+        const header = new DataView(await file.slice(0, 12).arrayBuffer())
+        if (header.getUint8(0) !== 31 || header.getUint8(1) !== 139
+        || header.getUint8(2) !== 8) throw new Error('Not a DictZip file')
+        const flg = header.getUint8(3)
+        if (!flg & 0b100) throw new Error('Missing FEXTRA flag')
+        const xlen = header.getUint16(10, true)
+        const extra = new DataView(await file.slice(12, 12 + xlen).arrayBuffer())
+        if (extra.getUint8(0) !== 82 || extra.getUint8(1) !== 65)
+            throw new Error('Subfield ID should be RA')
+        if (extra.getUint16(4, true) !== 1) throw new Error('Unsupported version')
+        this.#chlen = extra.getUint16(6, true)
+        const chcnt = extra.getUint16(8, true)
+        this.#chunks = []
+        for (let i = 0, chunkOffset = 0; i < chcnt; i++) {
+            const chunkSize = extra.getUint16(10 + 2 * i, true)
+            this.#chunks.push([chunkOffset, chunkSize])
+            chunkOffset = chunkOffset + chunkSize
+        }
+        // skip to compressed data
+        let offset = 12 + xlen
+        const max = Math.min(offset + 512, file.size)
+        const strArr = new Uint8Array(await file.slice(0, max).arrayBuffer())
+        if (flg & 0b1000) { // fname
+            const i = strArr.indexOf(0, offset)
+            if (i < 0) throw new Error('Header too long')
+            offset = i + 1
+        }
+        if (flg & 0b10000) { // fcomment
+            const i = strArr.indexOf(0, offset)
+            if (i < 0) throw new Error('Header too long')
+            offset = i + 1
+        }
+        if (flg & 0b10) offset += 2 // fhcrc
+        this.#compressed = file.slice(offset)
+    }
+    async read(offset, size) {
+        const chunks = this.#chunks
+        const startIndex = Math.trunc(offset / this.#chlen)
+        const endIndex = Math.trunc((offset + size) / this.#chlen)
+        const buf = await this.#compressed.slice(chunks[startIndex][0],
+            chunks[endIndex][0] + chunks[endIndex][1]).arrayBuffer()
+        let arr = new Uint8Array()
+        for (let pos = 0, i = startIndex; i <= endIndex; i++) {
+            const data = new Uint8Array(buf, pos, chunks[i][1])
+            arr = concatTypedArray(arr, await this.inflate(data))
+            pos += chunks[i][1]
+        }
+        const startOffset = offset - startIndex * this.#chlen
+        return arr.subarray(startOffset, startOffset + size)
+    }
+}
+class Index {
+    strcmp = strcmp
+    // binary search
+    bisect(query, start = 0, end = this.words.length - 1) {
+        if (end - start === 1) {
+            if (!this.strcmp(query, this.getWord(start))) return start
+            if (!this.strcmp(query, this.getWord(end))) return end
+            return null
+        }
+        const mid = Math.floor(start + (end - start) / 2)
+        const cmp = this.strcmp(query, this.getWord(mid))
+        if (cmp < 0) return this.bisect(query, start, mid)
+        if (cmp > 0) return this.bisect(query, mid, end)
+        return mid
+    }
+    // check for multiple definitions
+    checkAdjacent(query, i) {
+        if (i == null) return []
+        let j = i
+        const equals = i => {
+            const word = this.getWord(i)
+            return word ? this.strcmp(query, word) === 0 : false
+        }
+        while (equals(j - 1)) j--
+        let k = i
+        while (equals(k + 1)) k++
+        return j === k ? [i] : Array.from({ length: k + 1 - j }, (_, i) => j + i)
+    }
+    lookup(query) {
+        return this.checkAdjacent(query, this.bisect(query))
+    }
+}
+const decodeBase64Number = str => {
+    const { length } = str
+    let n = 0
+    for (let i = 0; i < length; i++) {
+        const c = str.charCodeAt(i)
+        n += (c === 43 ? 62     // "+"
+            : c === 47 ? 63     // "/"
+            : c < 58 ? c + 4    // 0-9 -> 52-61
+            : c < 91 ? c - 65   // A-Z -> 0-25
+            : c - 71            // a-z -> 26-51
+        ) * 64 ** (length - 1 - i)
+    }
+    return n
+}
+class DictdIndex extends Index {
+    getWord(i) {
+        return this.words[i]
+    }
+    async load(file) {
+        const words = []
+        const offsets = []
+        const sizes = []
+        for (const line of decode(await file.arrayBuffer()).split('\n')) {
+            const a = line.split('\t')
+            words.push(a[0])
+            offsets.push(decodeBase64Number(a[1]))
+            sizes.push(decodeBase64Number(a[2]))
+        }
+        this.words = words
+        this.offsets = offsets
+        this.sizes = sizes
+    }
+}
+export class DictdDict {
+    #dict = new DictZip()
+    #idx = new DictdIndex()
+    loadDict(file, inflate) {
+        this.#dict.inflate = inflate
+        return this.#dict.load(file)
+    }
+    async #readWord(i) {
+        const word = this.#idx.getWord(i)
+        const offset = this.#idx.offsets[i]
+        const size = this.#idx.sizes[i]
+        return { word, data: ['m', this.#dict.read(offset, size)] }
+    }
+    #readWords(arr) {
+        return Promise.all(arr.map(this.#readWord.bind(this)))
+    }
+    lookup(query) {
+        return this.#readWords(this.#idx.lookup(query))
+    }
+}
+class StarDictIndex extends Index {
+    isSyn
+    #arr
+    getWord(i) {
+        const word = this.words[i]
+        if (!word) return
+        return decode(this.#arr.subarray(word[0], word[1]))
+    }
+    async load(file) {
+        const { isSyn } = this
+        const buf = await file.arrayBuffer()
+        const arr = new Uint8Array(buf)
+        this.#arr = arr
+        const view = new DataView(buf)
+        const words = []
+        const offsets = []
+        const sizes = []
+        for (let i = 0; i < arr.length;) {
+            const newI = arr.subarray(0, i + 256).indexOf(0, i)
+            if (newI < 0) throw new Error('Word too big')
+            words.push([i, newI])
+            offsets.push(view.getUint32(newI + 1))
+            if (isSyn) i = newI + 5
+            else {
+                sizes.push(view.getUint32(newI + 5))
+                i = newI + 9
+            }
+        }
+        this.words = words
+        this.offsets = offsets
+        this.sizes = sizes
+    }
+}
+export class StarDict {
+    #dict = new DictZip()
+    #idx = new StarDictIndex()
+    #syn = Object.assign(new StarDictIndex(), { isSyn: true })
+    async loadIfo(file) {
+        const str = decode(await file.arrayBuffer())
+        this.ifo = Object.fromEntries(str.split('\n').map(line => {
+            const sep = line.indexOf('=')
+            if (sep < 0) return
+            return [line.slice(0, sep), line.slice(sep + 1)]
+        }).filter(x => x))
+    }
+    loadDict(file, inflate) {
+        this.#dict.inflate = inflate
+        return this.#dict.load(file)
+    }
+    loadIdx(file) {
+        return this.#idx.load(file)
+    }
+    loadSyn(file) {
+        if (file) return this.#syn.load(file)
+    }
+    async #readWord(i) {
+        const word = this.#idx.getWord(i)
+        const offset = this.#idx.offsets[i]
+        const size = this.#idx.sizes[i]
+        const data = await this.#dict.read(offset, size)
+        const seq = this.ifo.sametypesequence
+        if (!seq) throw new Error('TODO')
+        if (seq.length === 1) return { word, data: [[seq[0], data]] }
+        throw new Error('TODO')
+    }
+    #readWords(arr) {
+        return Promise.all(arr.map(this.#readWord.bind(this)))
+    }
+    lookup(query) {
+        return this.#readWords(this.#idx.lookup(query))
+    }
+    synonyms(query) {
+        return this.#readWords(this.#syn.lookup(query).map(i => this.#syn.offsets[i]))
+    }
+}

packages/foliate-js/epub.js ADDED Viewed

	@@ -0,0 +1,1374 @@

+import * as CFI from './epubcfi.js'
+const NS = {
+    CONTAINER: 'urn:oasis:names:tc:opendocument:xmlns:container',
+    XHTML: 'http://www.w3.org/1999/xhtml',
+    OPF: 'http://www.idpf.org/2007/opf',
+    EPUB: 'http://www.idpf.org/2007/ops',
+    DC: 'http://purl.org/dc/elements/1.1/',
+    DCTERMS: 'http://purl.org/dc/terms/',
+    ENC: 'http://www.w3.org/2001/04/xmlenc#',
+    NCX: 'http://www.daisy.org/z3986/2005/ncx/',
+    XLINK: 'http://www.w3.org/1999/xlink',
+    SMIL: 'http://www.w3.org/ns/SMIL',
+}
+const MIME = {
+    XML: 'application/xml',
+    NCX: 'application/x-dtbncx+xml',
+    XHTML: 'application/xhtml+xml',
+    HTML: 'text/html',
+    CSS: 'text/css',
+    SVG: 'image/svg+xml',
+    JS: /\/(x-)?(javascript|ecmascript)/,
+}
+// https://www.w3.org/TR/epub-33/#sec-reserved-prefixes
+const PREFIX = {
+    a11y: 'http://www.idpf.org/epub/vocab/package/a11y/#',
+    dcterms: 'http://purl.org/dc/terms/',
+    marc: 'http://id.loc.gov/vocabulary/',
+    media: 'http://www.idpf.org/epub/vocab/overlays/#',
+    onix: 'http://www.editeur.org/ONIX/book/codelists/current.html#',
+    rendition: 'http://www.idpf.org/vocab/rendition/#',
+    schema: 'http://schema.org/',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+    msv: 'http://www.idpf.org/epub/vocab/structure/magazine/#',
+    prism: 'http://www.prismstandard.org/specifications/3.0/PRISM_CV_Spec_3.0.htm#',
+}
+const RELATORS = {
+    art: 'artist',
+    aut: 'author',
+    clr: 'colorist',
+    edt: 'editor',
+    ill: 'illustrator',
+    nrt: 'narrator',
+    trl: 'translator',
+    pbl: 'publisher',
+}
+const ONIX5 = {
+    '02': 'isbn',
+    '06': 'doi',
+    '15': 'isbn',
+    '26': 'doi',
+    '34': 'issn',
+}
+// convert to camel case
+const camel = x => x.toLowerCase().replace(/[-:](.)/g, (_, g) => g.toUpperCase())
+// strip and collapse ASCII whitespace
+// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+const normalizeWhitespace = str => str ? str
+    .replace(/[\t\n\f\r ]+/g, ' ')
+    .replace(/^[\t\n\f\r ]+/, '')
+    .replace(/[\t\n\f\r ]+$/, '') : ''
+const filterAttribute = (attr, value, isList) => isList
+    ? el => el.getAttribute(attr)?.split(/\s/)?.includes(value)
+    : typeof value === 'function'
+        ? el => value(el.getAttribute(attr))
+        : el => el.getAttribute(attr) === value
+const getAttributes = (...xs) => el =>
+    el ? Object.fromEntries(xs.map(x => [camel(x), el.getAttribute(x)])) : null
+const getElementText = el => normalizeWhitespace(el?.textContent)
+const childGetter = (doc, ns) => {
+    // ignore the namespace if it doesn't appear in document at all
+    const useNS = doc.lookupNamespaceURI(null) === ns || doc.lookupPrefix(ns)
+    const f = useNS
+        ? (el, name) => el => el.namespaceURI === ns && el.localName === name
+        : (el, name) => el => el.localName === name
+    return {
+        $: (el, name) => [...el.children].find(f(el, name)),
+        $$: (el, name) => [...el.children].filter(f(el, name)),
+        $$$: useNS
+            ? (el, name) => [...el.getElementsByTagNameNS(ns, name)]
+            : (el, name) => [...el.getElementsByTagName(name)],
+    }
+}
+const resolveURL = (url, relativeTo) => {
+    try {
+        // replace %2c in the url with a comma, this might be introduced by calibre
+        url = url.replace(/%2c/gi, ',').replace(/%3a/gi, ':')
+        if (relativeTo.includes(':') && !relativeTo.startsWith('OEBPS')) return new URL(url, relativeTo)
+        // the base needs to be a valid URL, so set a base URL and then remove it
+        const root = 'https://invalid.invalid/'
+        const obj = new URL(url, root + relativeTo)
+        obj.search = ''
+        return decodeURI(obj.href.replace(root, ''))
+    } catch(e) {
+        console.warn(e)
+        return url
+    }
+}
+const isExternal = uri => /^(?!blob)\w+:/i.test(uri)
+// like `path.relative()` in Node.js
+const pathRelative = (from, to) => {
+    if (!from) return to
+    const as = from.replace(/\/$/, '').split('/')
+    const bs = to.replace(/\/$/, '').split('/')
+    const i = (as.length > bs.length ? as : bs).findIndex((_, i) => as[i] !== bs[i])
+    return i < 0 ? '' : Array(as.length - i).fill('..').concat(bs.slice(i)).join('/')
+}
+const pathDirname = str => str.slice(0, str.lastIndexOf('/') + 1)
+// replace asynchronously and sequentially
+// same technique as https://stackoverflow.com/a/48032528
+const replaceSeries = async (str, regex, f) => {
+    const matches = []
+    str.replace(regex, (...args) => (matches.push(args), null))
+    const results = []
+    for (const args of matches) results.push(await f(...args))
+    return str.replace(regex, () => results.shift())
+}
+const regexEscape = str => str.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+const tidy = obj => {
+    for (const [key, val] of Object.entries(obj))
+        if (val == null) delete obj[key]
+        else if (Array.isArray(val)) {
+            obj[key] = val.filter(x => x).map(x =>
+                typeof x === 'object' && !Array.isArray(x) ? tidy(x) : x)
+            if (!obj[key].length) delete obj[key]
+            else if (obj[key].length === 1) obj[key] = obj[key][0]
+        }
+        else if (typeof val === 'object') {
+            obj[key] = tidy(val)
+            if (!Object.keys(val).length) delete obj[key]
+        }
+    const keys = Object.keys(obj)
+    if (keys.length === 1 && keys[0] === 'name') return obj[keys[0]]
+    return obj
+}
+// https://www.w3.org/TR/epub/#sec-prefix-attr
+const getPrefixes = doc => {
+    const map = new Map(Object.entries(PREFIX))
+    const value = doc.documentElement.getAttributeNS(NS.EPUB, 'prefix')
+        || doc.documentElement.getAttribute('prefix')
+    if (value) for (const [, prefix, url] of value
+        .matchAll(/(.+): +(.+)[ \t\r\n]*/g)) map.set(prefix, url)
+    return map
+}
+// https://www.w3.org/TR/epub-rs/#sec-property-values
+// but ignoring the case where the prefix is omitted
+const getPropertyURL = (value, prefixes) => {
+    if (!value) return null
+    const [a, b] = value.split(':')
+    const prefix = b ? a : null
+    const reference = b ? b : a
+    const baseURL = prefixes.get(prefix)
+    return baseURL ? baseURL + reference : null
+}
+const getMetadata = opf => {
+    const { $ } = childGetter(opf, NS.OPF)
+    const $metadata = $(opf.documentElement, 'metadata')
+    // first pass: convert to JS objects
+    const els = Object.groupBy($metadata.children, el =>
+        el.namespaceURI === NS.DC ? 'dc'
+        : el.namespaceURI === NS.OPF && el.localName === 'meta' ?
+            (el.hasAttribute('name') ? 'legacyMeta' : 'meta') : '')
+    const baseLang = $metadata.getAttribute('xml:lang')
+        ?? opf.documentElement.getAttribute('xml:lang') ?? 'und'
+    const prefixes = getPrefixes(opf)
+    const parse = el => {
+        const property = el.getAttribute('property')
+        const scheme = el.getAttribute('scheme')
+        return {
+            property: getPropertyURL(property, prefixes) ?? property,
+            scheme: getPropertyURL(scheme, prefixes) ?? scheme,
+            lang: el.getAttribute('xml:lang'),
+            value: getElementText(el),
+            props: getProperties(el),
+            // `opf:` attributes from EPUB 2 & EPUB 3.1 (removed in EPUB 3.2)
+            attrs: Object.fromEntries(Array.from(el.attributes)
+                .filter(attr => attr.namespaceURI === NS.OPF)
+                .map(attr => [attr.localName, attr.value])),
+        }
+    }
+    const refines = Map.groupBy(els.meta ?? [], el => el.getAttribute('refines'))
+    const getProperties = el => {
+        const els = refines.get(el ? '#' + el.getAttribute('id') : null)
+        if (!els) return null
+        return Object.groupBy(els.map(parse), x => x.property)
+    }
+    const dc = Object.fromEntries(Object.entries(Object.groupBy(els.dc || [], el => el.localName))
+        .map(([name, els]) => [name, els.map(parse)]))
+    const properties = getProperties() ?? {}
+    const legacyMeta = Object.fromEntries(els.legacyMeta?.map(el =>
+        [el.getAttribute('name'), el.getAttribute('content')]) ?? [])
+    // second pass: map to webpub
+    const one = x => x?.[0]?.value
+    const prop = (x, p) => one(x?.props?.[p])
+    const makeLanguageMap = x => {
+        if (!x) return null
+        const alts = x.props?.['alternate-script'] ?? []
+        const altRep = x.attrs['alt-rep']
+        if (!alts.length && (!x.lang || x.lang === baseLang) && !altRep) return x.value
+        const map = { [x.lang ?? baseLang]: x.value }
+        if (altRep) map[x.attrs['alt-rep-lang']] = altRep
+        for (const y of alts) map[y.lang] ??= y.value
+        return map
+    }
+    const makeContributor = x => x ? ({
+        name: makeLanguageMap(x),
+        sortAs: makeLanguageMap(x.props?.['file-as']?.[0]) ?? x.attrs['file-as'],
+        role: x.props?.role?.filter(x => x.scheme === PREFIX.marc + 'relators')
+            ?.map(x => x.value) ?? [x.attrs.role],
+        code: prop(x, 'term') ?? x.attrs.term,
+        scheme: prop(x, 'authority') ?? x.attrs.authority,
+    }) : null
+    const makeCollection = x => ({
+        name: makeLanguageMap(x),
+        // NOTE: webpub requires number but EPUB allows values like "2.2.1"
+        position: one(x.props?.['group-position']),
+    })
+    const makeSeries = x => ({
+        name: x.value,
+        position: one(x.props?.['group-position']),
+    })
+    const makeAltIdentifier = x => {
+        const { value } = x
+        if (/^urn:/i.test(value)) return value
+        if (/^doi:/i.test(value)) return `urn:${value}`
+        const type = x.props?.['identifier-type']
+        if (!type) {
+            const scheme = x.attrs.scheme
+            if (!scheme) return value
+            // https://idpf.github.io/epub-registries/identifiers/
+            // but no "jdcn", which isn't a registered URN namespace
+            if (/^(doi|isbn|uuid)$/i.test(scheme)) return `urn:${scheme}:${value}`
+            // NOTE: webpub requires scheme to be a URI; EPUB allows anything
+            return { scheme, value }
+        }
+        if (type.scheme === PREFIX.onix + 'codelist5') {
+            const nid = ONIX5[type.value]
+            if (nid) return `urn:${nid}:${value}`
+        }
+        return value
+    }
+    const belongsTo = Object.groupBy(properties['belongs-to-collection'] ?? [],
+        x => prop(x, 'collection-type') === 'series' ? 'series' : 'collection')
+    const mainTitle = dc.title?.find(x => prop(x, 'title-type') === 'main') ?? dc.title?.[0]
+    const metadata = {
+        identifier: getIdentifier(opf),
+        title: makeLanguageMap(mainTitle),
+        sortAs: makeLanguageMap(mainTitle?.props?.['file-as']?.[0])
+            ?? mainTitle?.attrs?.['file-as']
+            ?? legacyMeta?.['calibre:title_sort'],
+        subtitle: dc.title?.find(x => prop(x, 'title-type') === 'subtitle')?.value,
+        language: dc.language?.map(x => x.value),
+        description: one(dc.description),
+        publisher: makeContributor(dc.publisher?.[0]),
+        published: dc.date?.find(x => x.attrs.event === 'publication')?.value
+            ?? one(dc.date),
+        modified: one(properties[PREFIX.dcterms + 'modified'])
+            ?? dc.date?.find(x => x.attrs.event === 'modification')?.value,
+        subject: dc.subject?.map(makeContributor),
+        belongsTo: {
+            collection: belongsTo.collection?.map(makeCollection),
+            series: belongsTo.series?.map(makeSeries)
+            ?? (legacyMeta?.['calibre:series'] ? {
+                name: legacyMeta?.['calibre:series'],
+                position: parseFloat(legacyMeta?.['calibre:series_index']),
+            } : null),
+        },
+        altIdentifier: dc.identifier?.map(makeAltIdentifier),
+        source: dc.source?.map(makeAltIdentifier), // NOTE: not in webpub schema
+        rights: one(dc.rights), // NOTE: not in webpub schema
+    }
+    const remapContributor = defaultKey => x => {
+        const keys = new Set(x.role?.map(role => RELATORS[role] ?? defaultKey))
+        return [keys.size ? keys : [defaultKey], x]
+    }
+    for (const [keys, val] of [].concat(
+        dc.creator?.map(makeContributor)?.map(remapContributor('author')) ?? [],
+        dc.contributor?.map(makeContributor)?.map(remapContributor('contributor')) ?? []))
+        for (const key of keys) {
+            // if already parsed publisher don't remap it from author/contributor again
+            if (key === 'publisher' && metadata.publisher) continue
+            if (metadata[key]) metadata[key].push(val)
+            else metadata[key] = [val]
+        }
+    tidy(metadata)
+    if (metadata.altIdentifier === metadata.identifier)
+        delete metadata.altIdentifier
+    const rendition = {}
+    const media = {}
+    for (const [key, val] of Object.entries(properties)) {
+        if (key.startsWith(PREFIX.rendition))
+            rendition[camel(key.replace(PREFIX.rendition, ''))] = one(val)
+        else if (key.startsWith(PREFIX.media))
+            media[camel(key.replace(PREFIX.media, ''))] = one(val)
+    }
+    if (media.duration) media.duration = parseClock(media.duration)
+    return { metadata, rendition, media }
+}
+const parseNav = (doc, resolve = f => f) => {
+    const { $, $$, $$$ } = childGetter(doc, NS.XHTML)
+    const resolveHref = href => href ? decodeURI(resolve(href)) : null
+    const parseLI = getType => $li => {
+        const $a = $($li, 'a') ?? $($li, 'span')
+        const $ol = $($li, 'ol')
+        const href = resolveHref($a?.getAttribute('href'))
+        const label = getElementText($a) || $a?.getAttribute('title')
+        // TODO: get and concat alt/title texts in content
+        const result = { label, href, subitems: parseOL($ol) }
+        if (getType) result.type = $a?.getAttributeNS(NS.EPUB, 'type')?.split(/\s/)
+        return result
+    }
+    const parseOL = ($ol, getType) => $ol ? $$($ol, 'li').map(parseLI(getType)) : null
+    const parseNav = ($nav, getType) => parseOL($($nav, 'ol'), getType)
+    const $$nav = $$$(doc, 'nav')
+    let toc = null, pageList = null, landmarks = null, others = []
+    for (const $nav of $$nav) {
+        const type = $nav.getAttributeNS(NS.EPUB, 'type')?.split(/\s/) ?? []
+        if (type.includes('toc')) toc ??= parseNav($nav)
+        else if (type.includes('page-list')) pageList ??= parseNav($nav)
+        else if (type.includes('landmarks')) landmarks ??= parseNav($nav, true)
+        else others.push({
+            label: getElementText($nav.firstElementChild), type,
+            list: parseNav($nav),
+        })
+    }
+    return { toc, pageList, landmarks, others }
+}
+const parseNCX = (doc, resolve = f => f) => {
+    const { $, $$ } = childGetter(doc, NS.NCX)
+    const resolveHref = href => href ? decodeURI(resolve(href)) : null
+    const parseItem = el => {
+        const $label = $(el, 'navLabel')
+        const $content = $(el, 'content')
+        const label = getElementText($label)
+        const href = resolveHref($content.getAttribute('src'))
+        if (el.localName === 'navPoint') {
+            const els = $$(el, 'navPoint')
+            return { label, href, subitems: els.length ? els.map(parseItem) : null }
+        }
+        return { label, href }
+    }
+    const parseList = (el, itemName) => $$(el, itemName).map(parseItem)
+    const getSingle = (container, itemName) => {
+        const $container = $(doc.documentElement, container)
+        return $container ? parseList($container, itemName) : null
+    }
+    return {
+        toc: getSingle('navMap', 'navPoint'),
+        pageList: getSingle('pageList', 'pageTarget'),
+        others: $$(doc.documentElement, 'navList').map(el => ({
+            label: getElementText($(el, 'navLabel')),
+            list: parseList(el, 'navTarget'),
+        })),
+    }
+}
+const parseClock = str => {
+    if (!str) return
+    const parts = str.split(':').map(x => parseFloat(x))
+    if (parts.length === 3) {
+        const [h, m, s] = parts
+        return h * 60 * 60 + m * 60 + s
+    }
+    if (parts.length === 2) {
+        const [m, s] = parts
+        return m * 60 + s
+    }
+    const [x, unit] = str.split(/(?=[^\d.])/)
+    const n = parseFloat(x)
+    const f = unit === 'h' ? 60 * 60
+        : unit === 'min' ? 60
+        : unit === 'ms' ? .001
+        : 1
+    return n * f
+}
+const IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'gif', 'webp']
+const getImageMediaType = (path) => {
+    const extension = path.toLowerCase().split('.').pop()
+    const mediaTypeMap = {
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'gif': 'image/gif',
+        'webp': 'image/webp',
+    }
+    return mediaTypeMap[extension] || 'image/jpeg'
+}
+class MediaOverlay extends EventTarget {
+    #entries
+    #lastMediaOverlayItem
+    #sectionIndex
+    #audioIndex
+    #itemIndex
+    #audio
+    #volume = 1
+    #rate = 1
+    #state
+    constructor(book, loadXML) {
+        super()
+        this.book = book
+        this.loadXML = loadXML
+    }
+    async #loadSMIL(item) {
+        if (this.#lastMediaOverlayItem === item) return
+        const doc = await this.loadXML(item.href)
+        const resolve = href => href ? resolveURL(href, item.href) : null
+        const { $, $$$ } = childGetter(doc, NS.SMIL)
+        this.#audioIndex = -1
+        this.#itemIndex = -1
+        this.#entries = $$$(doc, 'par').reduce((arr, $par) => {
+            const text = resolve($($par, 'text')?.getAttribute('src'))
+            const $audio = $($par, 'audio')
+            if (!text || !$audio) return arr
+            const src = resolve($audio.getAttribute('src'))
+            const begin = parseClock($audio.getAttribute('clipBegin'))
+            const end = parseClock($audio.getAttribute('clipEnd'))
+            const last = arr.at(-1)
+            if (last?.src === src) last.items.push({ text, begin, end })
+            else arr.push({ src, items: [{ text, begin, end }] })
+            return arr
+        }, [])
+        this.#lastMediaOverlayItem = item
+    }
+    get #activeAudio() {
+        return this.#entries[this.#audioIndex]
+    }
+    get #activeItem() {
+        return this.#activeAudio?.items?.[this.#itemIndex]
+    }
+    #error(e) {
+        console.error(e)
+        this.dispatchEvent(new CustomEvent('error', { detail: e }))
+    }
+    #highlight() {
+        this.dispatchEvent(new CustomEvent('highlight', { detail: this.#activeItem }))
+    }
+    #unhighlight() {
+        this.dispatchEvent(new CustomEvent('unhighlight', { detail: this.#activeItem }))
+    }
+    async #play(audioIndex, itemIndex) {
+        this.#stop()
+        this.#audioIndex = audioIndex
+        this.#itemIndex = itemIndex
+        const src = this.#activeAudio?.src
+        if (!src || !this.#activeItem) return this.start(this.#sectionIndex + 1)
+        const url = URL.createObjectURL(await this.book.loadBlob(src))
+        const audio = new Audio(url)
+        this.#audio = audio
+        audio.volume = this.#volume
+        audio.playbackRate = this.#rate
+        audio.addEventListener('timeupdate', () => {
+            if (audio.paused) return
+            const t = audio.currentTime
+            const { items } = this.#activeAudio
+            if (t > this.#activeItem?.end) {
+                this.#unhighlight()
+                if (this.#itemIndex === items.length - 1) {
+                    this.#play(this.#audioIndex + 1, 0).catch(e => this.#error(e))
+                    return
+                }
+            }
+            const oldIndex = this.#itemIndex
+            while (items[this.#itemIndex + 1]?.begin <= t) this.#itemIndex++
+            if (this.#itemIndex !== oldIndex) this.#highlight()
+        })
+        audio.addEventListener('error', () =>
+            this.#error(new Error(`Failed to load ${src}`)))
+        audio.addEventListener('playing', () => this.#highlight())
+        audio.addEventListener('ended', () => {
+            this.#unhighlight()
+            URL.revokeObjectURL(url)
+            this.#audio = null
+            this.#play(audioIndex + 1, 0).catch(e => this.#error(e))
+        })
+        if (this.#state === 'paused') {
+            this.#highlight()
+            audio.currentTime = this.#activeItem.begin ?? 0
+        }
+        else audio.addEventListener('canplaythrough', () => {
+            // for some reason need to seek in `canplaythrough`
+            // or it won't play when skipping in WebKit
+            audio.currentTime = this.#activeItem.begin ?? 0
+            this.#state = 'playing'
+            audio.play().catch(e => this.#error(e))
+        }, { once: true })
+    }
+    async start(sectionIndex, filter = () => true) {
+        this.#audio?.pause()
+        const section = this.book.sections[sectionIndex]
+        const href = section?.id
+        if (!href) return
+        const { mediaOverlay } = section
+        if (!mediaOverlay) return this.start(sectionIndex + 1)
+        this.#sectionIndex = sectionIndex
+        await this.#loadSMIL(mediaOverlay)
+        for (let i = 0; i < this.#entries.length; i++) {
+            const { items } = this.#entries[i]
+            for (let j = 0; j < items.length; j++) {
+                if (items[j].text.split('#')[0] === href && filter(items[j], j, items))
+                    return this.#play(i, j).catch(e => this.#error(e))
+            }
+        }
+    }
+    pause() {
+        this.#state = 'paused'
+        this.#audio?.pause()
+    }
+    resume() {
+        this.#state = 'playing'
+        this.#audio?.play().catch(e => this.#error(e))
+    }
+    #stop() {
+        if (this.#audio) {
+            this.#audio.pause()
+            URL.revokeObjectURL(this.#audio.src)
+            this.#audio = null
+            this.#unhighlight()
+        }
+    }
+    stop() {
+        this.#state = 'stopped'
+        this.#stop()
+    }
+    prev() {
+        if (this.#itemIndex > 0) this.#play(this.#audioIndex, this.#itemIndex - 1)
+        else if (this.#audioIndex > 0) this.#play(this.#audioIndex - 1,
+            this.#entries[this.#audioIndex - 1].items.length - 1)
+        else if (this.#sectionIndex > 0)
+            this.start(this.#sectionIndex - 1, (_, i, items) => i === items.length - 1)
+    }
+    next() {
+        this.#play(this.#audioIndex, this.#itemIndex + 1)
+    }
+    setVolume(volume) {
+        this.#volume = volume
+        if (this.#audio) this.#audio.volume = volume
+    }
+    setRate(rate) {
+        this.#rate = rate
+        if (this.#audio) this.#audio.playbackRate = rate
+    }
+}
+const isUUID = /([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})/
+const getUUID = opf => {
+    for (const el of opf.getElementsByTagNameNS(NS.DC, 'identifier')) {
+        const [id] = getElementText(el).split(':').slice(-1)
+        if (isUUID.test(id)) return id
+    }
+    return ''
+}
+const getIdentifier = opf => getElementText(
+    opf.getElementById(opf.documentElement.getAttribute('unique-identifier'))
+    ?? opf.getElementsByTagNameNS(NS.DC, 'identifier')[0])
+// https://www.w3.org/publishing/epub32/epub-ocf.html#sec-resource-obfuscation
+const deobfuscate = async (key, length, blob) => {
+    const array = new Uint8Array(await blob.slice(0, length).arrayBuffer())
+    length = Math.min(length, array.length)
+    for (var i = 0; i < length; i++) array[i] = array[i] ^ key[i % key.length]
+    return new Blob([array, blob.slice(length)], { type: blob.type })
+}
+const WebCryptoSHA1 = async str => {
+    const data = new TextEncoder().encode(str)
+    const buffer = await globalThis.crypto.subtle.digest('SHA-1', data)
+    return new Uint8Array(buffer)
+}
+const deobfuscators = (sha1 = WebCryptoSHA1) => ({
+    'http://www.idpf.org/2008/embedding': {
+        key: opf => sha1(getIdentifier(opf)
+            // eslint-disable-next-line no-control-regex
+            .replaceAll(/[\u0020\u0009\u000d\u000a]/g, '')),
+        decode: (key, blob) => deobfuscate(key, 1040, blob),
+    },
+    'http://ns.adobe.com/pdf/enc#RC': {
+        key: opf => {
+            const uuid = getUUID(opf).replaceAll('-', '')
+            return Uint8Array.from({ length: 16 }, (_, i) =>
+                parseInt(uuid.slice(i * 2, i * 2 + 2), 16))
+        },
+        decode: (key, blob) => deobfuscate(key, 1024, blob),
+    },
+})
+class Encryption {
+    #uris = new Map()
+    #decoders = new Map()
+    #algorithms
+    constructor(algorithms) {
+        this.#algorithms = algorithms
+    }
+    async init(encryption, opf) {
+        if (!encryption) return
+        const data = Array.from(
+            encryption.getElementsByTagNameNS(NS.ENC, 'EncryptedData'), el => ({
+                algorithm: el.getElementsByTagNameNS(NS.ENC, 'EncryptionMethod')[0]
+                    ?.getAttribute('Algorithm'),
+                uri: el.getElementsByTagNameNS(NS.ENC, 'CipherReference')[0]
+                    ?.getAttribute('URI'),
+            }))
+        for (const { algorithm, uri } of data) {
+            if (!this.#decoders.has(algorithm)) {
+                const algo = this.#algorithms[algorithm]
+                if (!algo) {
+                    console.warn('Unknown encryption algorithm')
+                    continue
+                }
+                const key = await algo.key(opf)
+                this.#decoders.set(algorithm, blob => algo.decode(key, blob))
+            }
+            this.#uris.set(uri, algorithm)
+        }
+    }
+    getDecoder(uri) {
+        return this.#decoders.get(this.#uris.get(uri)) ?? (x => x)
+    }
+}
+class Resources {
+    constructor({ opf, resolveHref }) {
+        this.opf = opf
+        const { $, $$, $$$ } = childGetter(opf, NS.OPF)
+        const $manifest = $(opf.documentElement, 'manifest')
+        const $spine = $(opf.documentElement, 'spine')
+        const $$itemref = $$($spine, 'itemref')
+        this.manifest = $$($manifest, 'item')
+            .map(getAttributes('href', 'id', 'media-type', 'properties', 'media-overlay'))
+            .map(item => {
+                item.href = resolveHref(item.href)
+                item.properties = item.properties?.split(/\s/)
+                return item
+            })
+        this.manifestById = new Map(this.manifest.map(item => [item.id, item]))
+        this.spine = $$itemref
+            .map(getAttributes('idref', 'id', 'linear', 'properties'))
+            .map(item => (item.properties = item.properties?.split(/\s/), item))
+        this.pageProgressionDirection = $spine
+            .getAttribute('page-progression-direction')
+        this.navPath = this.getItemByProperty('nav')?.href
+        this.ncxPath = (this.getItemByID($spine.getAttribute('toc'))
+            ?? this.manifest.find(item => item.mediaType === MIME.NCX))?.href
+        const $guide = $(opf.documentElement, 'guide')
+        if ($guide) this.guide = $$($guide, 'reference')
+            .map(getAttributes('type', 'title', 'href'))
+            .map(({ type, title, href }) => ({
+                label: title,
+                type: type.split(/\s/),
+                href: resolveHref(href),
+            }))
+        this.cover = this.getItemByProperty('cover-image')
+            // EPUB 2 compat
+            ?? this.getItemByID($$$(opf, 'meta')
+                .find(filterAttribute('name', 'cover'))
+                ?.getAttribute('content'))
+            ?? this.manifest.find(item => item.id === 'cover'
+                && item.mediaType.startsWith('image'))
+            ?? this.manifest.find(item => item.href.includes('cover')
+                && item.mediaType.startsWith('image'))
+            ?? this.getItemByHref(this.guide
+                ?.find(ref => ref.type.includes('cover'))?.href)
+            // last resort: first image in manifest
+            ?? this.manifest.find(item => item.mediaType.startsWith('image'))
+        this.cfis = CFI.fromElements($$itemref)
+    }
+    getItemByID(id) {
+        return this.manifestById.get(id)
+    }
+    getItemByHref(href) {
+        return this.manifest.find(item => item.href === href)
+    }
+    getItemByProperty(prop) {
+        return this.manifest.find(item => item.properties?.includes(prop))
+    }
+    resolveCFI(cfi) {
+        const parts = CFI.parse(cfi)
+        const top = (parts.parent ?? parts).shift()
+        let $itemref = CFI.toElement(this.opf, top)
+        // make sure it's an idref; if not, try again without the ID assertion
+        // mainly because Epub.js used to generate wrong ID assertions
+        // https://github.com/futurepress/epub.js/issues/1236
+        if ($itemref && $itemref.nodeName !== 'idref') {
+            top.at(-1).id = null
+            $itemref = CFI.toElement(this.opf, top)
+        }
+        const idref = $itemref?.getAttribute('idref')
+        const index = this.spine.findIndex(item => item.idref === idref)
+        const anchor = doc => CFI.toRange(doc, parts)
+        return { index, anchor }
+    }
+}
+class Loader {
+    #cache = new Map()
+    #cacheXHTMLContent = new Map()
+    #children = new Map()
+    #refCount = new Map()
+    eventTarget = new EventTarget()
+    constructor({ loadText, loadBlob, resources, entries }) {
+        this.loadText = loadText
+        this.loadBlob = loadBlob
+        this.manifest = resources.manifest
+        this.assets = resources.manifest
+        this.entries = entries
+        // needed only when replacing in (X)HTML w/o parsing (see below)
+        //.filter(({ mediaType }) => ![MIME.XHTML, MIME.HTML].includes(mediaType))
+    }
+    async createURL(href, data, type, parent) {
+        if (!data) return ''
+        const detail = { data, type }
+        Object.defineProperty(detail, 'name', { value: href }) // readonly
+        const event = new CustomEvent('data', { detail })
+        this.eventTarget.dispatchEvent(event)
+        const newData = await event.detail.data
+        const newType = await event.detail.type
+        const url = URL.createObjectURL(new Blob([newData], { type: newType }))
+        this.#cache.set(href, url)
+        this.#refCount.set(href, 1)
+        if (newType === MIME.XHTML || newType === MIME.HTML) {
+            this.#cacheXHTMLContent.set(url, {href, type: newType, data: newData})
+        }
+        if (parent) {
+            const childList = this.#children.get(parent)
+            if (childList) childList.push(href)
+            else this.#children.set(parent, [href])
+        }
+        return url
+    }
+    ref(href, parent) {
+        const childList = this.#children.get(parent)
+        if (!childList?.includes(href)) {
+            this.#refCount.set(href, this.#refCount.get(href) + 1)
+            //console.log(`referencing ${href}, now ${this.#refCount.get(href)}`)
+            if (childList) childList.push(href)
+            else this.#children.set(parent, [href])
+        }
+        return this.#cache.get(href)
+    }
+    unref(href) {
+        if (!this.#refCount.has(href)) return
+        const count = this.#refCount.get(href) - 1
+        //console.log(`unreferencing ${href}, now ${count}`)
+        if (count < 1) {
+            //console.log(`unloading ${href}`)
+            const url = this.#cache.get(href)
+            URL.revokeObjectURL(url)
+            this.#cache.delete(href)
+            this.#cacheXHTMLContent.delete(url)
+            this.#refCount.delete(href)
+            // unref children
+            const childList = this.#children.get(href)
+            if (childList) while (childList.length) this.unref(childList.pop())
+            this.#children.delete(href)
+        } else this.#refCount.set(href, count)
+    }
+    // load manifest item, recursively loading all resources as needed
+    async loadItem(item, parents = []) {
+        if (!item) return null
+        const { href, mediaType } = item
+        const isScript = MIME.JS.test(item.mediaType)
+        const detail = { type: mediaType, isScript, allow: true}
+        const event = new CustomEvent('load', { detail })
+        this.eventTarget.dispatchEvent(event)
+        const allow = await event.detail.allow
+        if (!allow) return null
+        const parent = parents.at(-1)
+        if (this.#cache.has(href)) return this.ref(href, parent)
+        const shouldReplace =
+            (isScript || [MIME.XHTML, MIME.HTML, MIME.CSS, MIME.SVG].includes(mediaType))
+            // prevent circular references
+            && parents.every(p => p !== href)
+        if (shouldReplace) return this.loadReplaced(item, parents)
+        // NOTE: this can be replaced with `Promise.try()`
+        const tryLoadBlob = Promise.resolve().then(() => this.loadBlob(href))
+        return this.createURL(href, tryLoadBlob, mediaType, parent)
+    }
+    async loadItemXHTMLContent(item, parents = []) {
+        const url = await this.loadItem(item, parents)
+        if (url) return this.#cacheXHTMLContent.get(url)?.data
+    }
+    tryImageEntryItem(path) {
+        if (!IMAGE_EXTENSIONS.some(ext => path.toLowerCase().endsWith(`.${ext}`))) {
+            return null
+        }
+        if (!this.entries.get(path)) {
+            return null
+        }
+        return {
+            href: path,
+            mediaType: getImageMediaType(path),
+        }
+    }
+    async loadHref(href, base, parents = []) {
+        if (isExternal(href)) return href
+        const path = resolveURL(href, base)
+        let item = this.manifest.find(item => item.href === path)
+        if (!item) {
+            item = this.tryImageEntryItem(path)
+            if (!item) {
+                return href
+            }
+        }
+        return this.loadItem(item, parents.concat(base))
+    }
+    async loadReplaced(item, parents = []) {
+        const { href, mediaType } = item
+        const parent = parents.at(-1)
+        let str = ''
+        try {
+            str = await this.loadText(href)
+        } catch (e) {
+            return this.createURL(href, Promise.reject(e), mediaType, parent)
+        }
+        if (!str) return null
+        // note that one can also just use `replaceString` for everything:
+        // ```
+        // const replaced = await this.replaceString(str, href, parents)
+        // return this.createURL(href, replaced, mediaType, parent)
+        // ```
+        // which is basically what Epub.js does, which is simpler, but will
+        // break things like iframes (because you don't want to replace links)
+        // or text that just happen to be paths
+        // parse and replace in HTML
+        if ([MIME.XHTML, MIME.HTML, MIME.SVG].includes(mediaType)) {
+            let doc = new DOMParser().parseFromString(str, mediaType)
+            // change to HTML if it's not valid XHTML
+            if (mediaType === MIME.XHTML && (doc.querySelector('parsererror')
+            || !doc.documentElement?.namespaceURI)) {
+                console.warn(doc.querySelector('parsererror')?.innerText ?? 'Invalid XHTML')
+                item.mediaType = MIME.HTML
+                doc = new DOMParser().parseFromString(str, item.mediaType)
+            }
+            // replace hrefs in XML processing instructions
+            // this is mainly for SVGs that use xml-stylesheet
+            if ([MIME.XHTML, MIME.SVG].includes(item.mediaType)) {
+                let child = doc.firstChild
+                while (child instanceof ProcessingInstruction) {
+                    if (child.data) {
+                        const replacedData = await replaceSeries(child.data,
+                            /(?:^|\s*)(href\s*=\s*['"])([^'"]*)(['"])/i,
+                            (_, p1, p2, p3) => this.loadHref(p2, href, parents)
+                                .then(p2 => `${p1}${p2}${p3}`))
+                        child.replaceWith(doc.createProcessingInstruction(
+                            child.target, replacedData))
+                    }
+                    child = child.nextSibling
+                }
+            }
+            // replace hrefs (excluding anchors)
+            const replace = async (el, attr) => el.setAttribute(attr,
+                await this.loadHref(el.getAttribute(attr), href, parents))
+            for (const el of doc.querySelectorAll('link[href]')) await replace(el, 'href')
+            for (const el of doc.querySelectorAll('[src]')) await replace(el, 'src')
+            for (const el of doc.querySelectorAll('[poster]')) await replace(el, 'poster')
+            for (const el of doc.querySelectorAll('object[data]')) await replace(el, 'data')
+            for (const el of doc.querySelectorAll('[*|href]:not([href])'))
+                el.setAttributeNS(NS.XLINK, 'href', await this.loadHref(
+                    el.getAttributeNS(NS.XLINK, 'href'), href, parents))
+            for (const el of doc.querySelectorAll('[srcset]'))
+                el.setAttribute('srcset', await replaceSeries(el.getAttribute('srcset'),
+                    /(\s*)(.+?)\s*((?:\s[\d.]+[wx])+\s*(?:,|$)|,\s+|$)/g,
+                    (_, p1, p2, p3) => this.loadHref(p2, href, parents)
+                        .then(p2 => `${p1}${p2}${p3}`)))
+            // replace inline styles
+            for (const el of doc.querySelectorAll('style'))
+                if (el.textContent) el.textContent =
+                    await this.replaceCSS(el.textContent, href, parents)
+            for (const el of doc.querySelectorAll('[style]'))
+                el.setAttribute('style',
+                    await this.replaceCSS(el.getAttribute('style'), href, parents))
+            // TODO: replace inline scripts? probably not worth the trouble
+            const result = new XMLSerializer().serializeToString(doc)
+            return this.createURL(href, result, item.mediaType, parent)
+        }
+        const result = mediaType === MIME.CSS
+            ? await this.replaceCSS(str, href, parents)
+            : await this.replaceString(str, href, parents)
+        return this.createURL(href, result, mediaType, parent)
+    }
+    async replaceCSS(str, href, parents = []) {
+        const replacedUrls = await replaceSeries(str,
+            /url\(\s*["']?([^'"\n]*?)\s*["']?\s*\)/gi,
+            (_, url) => this.loadHref(url, href, parents)
+                .then(url => `url("${url}")`))
+        // apart from `url()`, strings can be used for `@import` (but why?!)
+        return replaceSeries(replacedUrls,
+            /@import\s*["']([^"'\n]*?)["']/gi,
+            (_, url) => this.loadHref(url, href, parents)
+                .then(url => `@import "${url}"`))
+    }
+    // find & replace all possible relative paths for all assets without parsing
+    replaceString(str, href, parents = []) {
+        const assetMap = new Map()
+        const urls = this.assets.map(asset => {
+            // do not replace references to the file itself
+            if (asset.href === href) return
+            // href was decoded and resolved when parsing the manifest
+            const relative = pathRelative(pathDirname(href), asset.href)
+            const relativeEnc = encodeURI(relative)
+            const rootRelative = '/' + asset.href
+            const rootRelativeEnc = encodeURI(rootRelative)
+            const set = new Set([relative, relativeEnc, rootRelative, rootRelativeEnc])
+            for (const url of set) assetMap.set(url, asset)
+            return Array.from(set)
+        }).flat().filter(x => x)
+        if (!urls.length) return str
+        const regex = new RegExp(urls.map(regexEscape).join('|'), 'g')
+        return replaceSeries(str, regex, async match =>
+            this.loadItem(assetMap.get(match.replace(/^\//, '')),
+                parents.concat(href)))
+    }
+    unloadItem(item) {
+        this.unref(item?.href)
+    }
+    destroy() {
+        for (const url of this.#cache.values()) URL.revokeObjectURL(url)
+    }
+}
+const getHTMLFragment = (doc, id) => doc.getElementById(id)
+    ?? doc.querySelector(`[name="${CSS.escape(id)}"]`)
+const getPageSpread = properties => {
+    for (const p of properties) {
+        if (p === 'page-spread-left' || p === 'rendition:page-spread-left')
+            return 'left'
+        if (p === 'page-spread-right' || p === 'rendition:page-spread-right')
+            return 'right'
+        if (p === 'rendition:page-spread-center') return 'center'
+    }
+}
+const getDisplayOptions = doc => {
+    if (!doc) return null
+    return {
+        fixedLayout: getElementText(doc.querySelector('option[name="fixed-layout"]')),
+        openToSpread: getElementText(doc.querySelector('option[name="open-to-spread"]')),
+    }
+}
+export class EPUB {
+    parser = new DOMParser()
+    #loader
+    #encryption
+    constructor({ entries, loadText, loadBlob, getSize, sha1 }) {
+        this.entries = entries.reduce((map, entry) => {
+            map.set(entry.filename, entry)
+            return map
+        }, new Map())
+        this.loadText = loadText
+        this.loadBlob = loadBlob
+        this.getSize = getSize
+        this.#encryption = new Encryption(deobfuscators(sha1))
+    }
+    #sanitizeXMLEntities(str) {
+        // Common HTML entities that aren't valid in XML
+        const entityMap = {
+            'nbsp': '&#160;',
+            'mdash': '&#8212;',
+            'ndash': '&#8211;',
+            'ldquo': '&#8220;',
+            'rdquo': '&#8221;',
+            'lsquo': '&#8216;',
+            'rsquo': '&#8217;',
+            'hellip': '&#8230;',
+            'copy': '&#169;',
+            'reg': '&#174;',
+            'trade': '&#8482;',
+            'bull': '&#8226;',
+            'middot': '&#183;',
+        }
+        return str.replace(/&([a-z]+);/gi, (match, entity) => {
+            return entityMap[entity.toLowerCase()] || match
+        })
+    }
+    async #loadXML(uri) {
+        const str = await this.loadText(uri)
+        if (!str) return null
+        const sanitized = this.#sanitizeXMLEntities(str)
+        const doc = this.parser.parseFromString(sanitized, MIME.XML)
+        if (doc.querySelector('parsererror'))
+            throw new Error(`XML parsing error: ${uri}
+${doc.querySelector('parsererror').innerText}`)
+        return doc
+    }
+    async init() {
+        const $container = await this.#loadXML('META-INF/container.xml')
+        if (!$container) throw new Error('Failed to load container file')
+        const opfs = Array.from(
+            $container.getElementsByTagNameNS(NS.CONTAINER, 'rootfile'),
+            getAttributes('full-path', 'media-type'))
+            .filter(file => file.mediaType === 'application/oebps-package+xml')
+        if (!opfs.length) throw new Error('No package document defined in container')
+        const opfPath = opfs[0].fullPath
+        const opf = await this.#loadXML(opfPath)
+        if (!opf) throw new Error('Failed to load package document')
+        const $encryption = await this.#loadXML('META-INF/encryption.xml')
+        await this.#encryption.init($encryption, opf)
+        this.resources = new Resources({
+            opf,
+            resolveHref: url => resolveURL(url, opfPath),
+        })
+        this.#loader = new Loader({
+            loadText: this.loadText,
+            loadBlob: uri => Promise.resolve(this.loadBlob(uri))
+                .then(this.#encryption.getDecoder(uri)),
+            resources: this.resources,
+            entries: this.entries,
+        })
+        this.transformTarget = this.#loader.eventTarget
+        this.sections = this.resources.spine.map((spineItem, index) => {
+            const { idref, linear, properties = [] } = spineItem
+            const item = this.resources.getItemByID(idref)
+            if (!item) {
+                console.warn(`Could not find item with ID "${idref}" in manifest`)
+                return null
+            }
+            return {
+                id: item.href,
+                load: () => this.#loader.loadItem(item),
+                unload: () => this.#loader.unloadItem(item),
+                loadText: () => this.#loader.loadText(item.href),
+                loadContent: () => this.#loader.loadItemXHTMLContent(item),
+                createDocument: () => this.loadDocument(item),
+                size: this.getSize(item.href),
+                cfi: this.resources.cfis[index],
+                linear,
+                pageSpread: getPageSpread(properties),
+                resolveHref: href => resolveURL(href, item.href),
+                mediaOverlay: item.mediaOverlay
+                    ? this.resources.getItemByID(item.mediaOverlay) : null,
+            }
+        }).filter(s => s)
+        const { navPath, ncxPath } = this.resources
+        if (navPath) try {
+            const resolve = url => resolveURL(url, navPath)
+            const nav = parseNav(await this.#loadXML(navPath), resolve)
+            this.toc = nav.toc
+            this.pageList = nav.pageList
+            this.landmarks = nav.landmarks
+        } catch(e) {
+            console.warn(e)
+        }
+        if (!this.toc && ncxPath) try {
+            const resolve = url => resolveURL(url, ncxPath)
+            const ncx = parseNCX(await this.#loadXML(ncxPath), resolve)
+            this.toc = ncx.toc
+            this.pageList = ncx.pageList
+        } catch(e) {
+            console.warn(e)
+        }
+        await this.#updateSubItems()
+        this.landmarks ??= this.resources.guide
+        const { metadata, rendition, media } = getMetadata(opf)
+        this.metadata = metadata
+        this.rendition = rendition
+        this.media = media
+        this.dir = this.resources.pageProgressionDirection
+        const displayOptions = getDisplayOptions(
+            await this.#loadXML('META-INF/com.apple.ibooks.display-options.xml')
+            ?? await this.#loadXML('META-INF/com.kobobooks.display-options.xml'))
+        if (displayOptions) {
+            if (displayOptions.fixedLayout === 'true')
+                this.rendition.layout ??= 'pre-paginated'
+            if (displayOptions.openToSpread === 'false') this.sections
+                .find(section => section.linear !== 'no').pageSpread ??=
+                    this.dir === 'rtl' ? 'left' : 'right'
+        }
+        return this
+    }
+    #groupTocSubitems(items) {
+        // Helper: Group subitems by section ID
+        const groupBySection = (subitems) => {
+            const grouped = new Map()
+            for (const subitem of subitems) {
+                const [sectionId] = this.splitTOCHref(subitem.href)
+                if (!grouped.has(sectionId)) grouped.set(sectionId, [])
+                grouped.get(sectionId).push(subitem)
+            }
+            return grouped
+        }
+        // Helper: Separate parent item from fragment items
+        const separateParentAndFragments = (sectionId, subitems) => {
+            let parent = null
+            const fragments = []
+            for (const subitem of subitems) {
+                const [, fragmentId] = this.splitTOCHref(subitem.href)
+                if (!fragmentId || subitem.href === sectionId) {
+                    parent = subitem
+                } else {
+                    fragments.push(subitem)
+                }
+            }
+            return { parent, fragments }
+        }
+        // Helper: Create grouped structure for multiple items in same section
+        const createGroupedItem = (sectionId, subitems) => {
+            const { parent, fragments } = separateParentAndFragments(sectionId, subitems)
+            // Use existing parent or create new one
+            const parentItem = parent ?? {
+                label: subitems[0].label || sectionId,
+                href: sectionId,
+            }
+            // Nest fragment items under parent
+            if (fragments.length > 0) {
+                parentItem.subitems = fragments
+            }
+            return parentItem
+        }
+        for (const item of items) {
+            if (!item.subitems?.length) continue
+            const groupedBySection = groupBySection(item.subitems)
+            const newSubitems = []
+            for (const [sectionId, subitems] of groupedBySection.entries()) {
+                const groupedItem = subitems.length === 1
+                    ? subitems[0]  // Single item, keep as-is
+                    : createGroupedItem(sectionId, subitems)  // Multiple items, group them
+                newSubitems.push(groupedItem)
+            }
+            item.subitems = newSubitems
+        }
+    }
+    // Helper: Find position of fragment ID in HTML string
+    #findFragmentPosition(html, fragmentId) {
+        if (!fragmentId) return html.length
+        const patterns = [
+            new RegExp(`\\sid=["']${CSS.escape(fragmentId)}["']`, 'i'),
+            new RegExp(`\\sname=["']${CSS.escape(fragmentId)}["']`, 'i'),
+        ]
+        for (const pattern of patterns) {
+            const match = html.match(pattern)
+            if (match) return match.index
+        }
+        return -1
+    }
+    // Helper: Flatten nested TOC structure into single array
+    #collectAllTocItems(tocItems) {
+        const allItems = []
+        const traverse = (items) => {
+            for (const item of items) {
+                allItems.push(item)
+                if (item.subitems?.length) traverse(item.subitems)
+            }
+        }
+        traverse(tocItems)
+        return allItems
+    }
+    // Helper: Group TOC items by section ID (base + fragments)
+    #groupItemsBySection(allItems) {
+        const sectionGroups = new Map()
+        for (const item of allItems) {
+            const [sectionId, fragmentId] = this.splitTOCHref(item.href)
+            if (!sectionGroups.has(sectionId)) {
+                sectionGroups.set(sectionId, { base: null, fragments: [] })
+            }
+            const group = sectionGroups.get(sectionId)
+            const isBase = !fragmentId || item.href === sectionId
+            if (isBase) group.base = item
+            else group.fragments.push(item)
+        }
+        return sectionGroups
+    }
+    // Helper: Calculate byte size of HTML between two fragments
+    #calculateFragmentSize(content, fragmentId, prevFragmentId) {
+        const endPos = this.#findFragmentPosition(content, fragmentId)
+        if (endPos < 0) return 0
+        const startPos = prevFragmentId
+            ? this.#findFragmentPosition(content, prevFragmentId)
+            : 0
+        const validStartPos = Math.max(0, startPos)
+        if (endPos < validStartPos) return 0
+        const htmlSubstring = content.substring(validStartPos, endPos)
+        return new Blob([htmlSubstring]).size
+    }
+    // Helper: Load and cache section HTML content
+    async #loadSectionContent(section, contentCache) {
+        const cached = contentCache.get(section.id)
+        if (cached) return cached
+        const content = await section.loadText()
+        if (content) contentCache.set(section.id, content)
+        return content
+    }
+    // Helper: Create section subitems from fragments
+    #createSectionSubitems(fragments, base, content, section) {
+        const subitems = []
+        for (let i = 0; i < fragments.length; i++) {
+            const fragment = fragments[i]
+            const [, fragmentId] = this.splitTOCHref(fragment.href)
+            const prevFragment = i > 0 ? fragments[i - 1] : base
+            const [, prevFragmentId] = prevFragment
+                ? this.splitTOCHref(prevFragment.href)
+                : [null, null]
+            const size = this.#calculateFragmentSize(content, fragmentId, prevFragmentId)
+            subitems.push({
+                id: fragment.href,
+                href: fragment.href,
+                cfi: fragment.cfi,
+                size,
+                linear: section.linear,
+            })
+        }
+        return subitems
+    }
+    // Update section subitems from TOC structure
+    async #updateSubItems() {
+        if (!this.toc || !this.sections) return
+        // Step 1: Group TOC items by section
+        this.#groupTocSubitems(this.toc)
+        // Step 2: Prepare section lookup and content cache
+        const sectionMap = new Map(this.sections.map(s => [s.id, s]))
+        const contentCache = new Map()
+        // Step 3: Flatten TOC and group by section ID
+        const allTocItems = this.#collectAllTocItems(this.toc)
+        const sectionGroups = this.#groupItemsBySection(allTocItems)
+        // Step 4: Process each section and create subitems
+        for (const [sectionId, { base, fragments }] of sectionGroups.entries()) {
+            const section = sectionMap.get(sectionId)
+            if (!section || fragments.length === 0) continue
+            // Load HTML content for this section
+            const content = await this.#loadSectionContent(section, contentCache)
+            if (!content) continue
+            // Create subitems from fragments
+            const subitems = this.#createSectionSubitems(fragments, base, content, section)
+            // Assign to section
+            if (subitems.length > 0) {
+                section.subitems = subitems
+            }
+        }
+    }
+    async loadDocument(item) {
+        const str = await this.loadText(item.href)
+        return this.parser.parseFromString(str, item.mediaType)
+    }
+    getMediaOverlay() {
+        return new MediaOverlay(this, this.#loadXML.bind(this))
+    }
+    resolveCFI(cfi) {
+        return this.resources.resolveCFI(cfi)
+    }
+    resolveHref(href) {
+        const [path, hash] = href.split('#')
+        const item = this.resources.getItemByHref(decodeURI(path))
+        if (!item) return null
+        const index = this.resources.spine.findIndex(({ idref }) => idref === item.id)
+        const anchor = hash ? doc => getHTMLFragment(doc, hash) : () => 0
+        return { index, anchor }
+    }
+    splitTOCHref(href) {
+        return href?.split('#') ?? []
+    }
+    getTOCFragment(doc, id) {
+        return doc.getElementById(id)
+            ?? doc.querySelector(`[name="${CSS.escape(id)}"]`)
+    }
+    isExternal(uri) {
+        return isExternal(uri)
+    }
+    async getCover() {
+        const cover = this.resources?.cover
+        return cover?.href
+            ? new Blob([await this.loadBlob(cover.href)], { type: cover.mediaType })
+            : null
+    }
+    async getCalibreBookmarks() {
+        const txt = await this.loadText('META-INF/calibre_bookmarks.txt')
+        const magic = 'encoding=json+base64:'
+        if (txt?.startsWith(magic)) {
+            const json = atob(txt.slice(magic.length))
+            return JSON.parse(json)
+        }
+    }
+    destroy() {
+        this.#loader?.destroy()
+    }
+}

packages/foliate-js/epubcfi.js ADDED Viewed

	@@ -0,0 +1,345 @@

+const findIndices = (arr, f) => arr
+    .map((x, i, a) => f(x, i, a) ? i : null).filter(x => x != null)
+const splitAt = (arr, is) => [-1, ...is, arr.length].reduce(({ xs, a }, b) =>
+    ({ xs: xs?.concat([arr.slice(a + 1, b)]) ?? [], a: b }), {}).xs
+const concatArrays = (a, b) =>
+    a.slice(0, -1).concat([a[a.length - 1].concat(b[0])]).concat(b.slice(1))
+const isNumber = /\d/
+export const isCFI = /^epubcfi\((.*)\)$/
+const escapeCFI = str => str.replace(/[\^[\](),;=]/g, '^$&')
+const wrap = x => isCFI.test(x) ? x : `epubcfi(${x})`
+const unwrap = x => x.match(isCFI)?.[1] ?? x
+const lift = f => (...xs) =>
+    `epubcfi(${f(...xs.map(x => x.match(isCFI)?.[1] ?? x))})`
+export const joinIndir = lift((...xs) => xs.join('!'))
+const tokenizer = str => {
+    const tokens = []
+    let state, escape, value = ''
+    const push = x => (tokens.push(x), state = null, value = '')
+    const cat = x => (value += x, escape = false)
+    for (const char of Array.from(str.trim()).concat('')) {
+        if (char === '^' && !escape) {
+            escape = true
+            continue
+        }
+        if (state === '!') push(['!'])
+        else if (state === ',') push([','])
+        else if (state === '/' || state === ':') {
+            if (isNumber.test(char)) {
+                cat(char)
+                continue
+            } else push([state, parseInt(value)])
+        } else if (state === '~') {
+            if (isNumber.test(char) || char === '.') {
+                cat(char)
+                continue
+            } else push(['~', parseFloat(value)])
+        } else if (state === '@') {
+            if (char === ':') {
+                push(['@', parseFloat(value)])
+                state = '@'
+                continue
+            }
+            if (isNumber.test(char) || char === '.') {
+                cat(char)
+                continue
+            } else push(['@', parseFloat(value)])
+        } else if (state === '[') {
+            if (char === ';' && !escape) {
+                push(['[', value])
+                state = ';'
+            } else if (char === ',' && !escape) {
+                push(['[', value])
+                state = '['
+            } else if (char === ']' && !escape) push(['[', value])
+            else cat(char)
+            continue
+        } else if (state?.startsWith(';')) {
+            if (char === '=' && !escape) {
+                state = `;${value}`
+                value = ''
+            } else if (char === ';' && !escape) {
+                push([state, value])
+                state = ';'
+            } else if (char === ']' && !escape) push([state, value])
+            else cat(char)
+            continue
+        }
+        if (char === '/' || char === ':' || char === '~' || char === '@'
+        || char === '[' || char === '!' || char === ',') state = char
+    }
+    return tokens
+}
+const findTokens = (tokens, x) => findIndices(tokens, ([t]) => t === x)
+const parser = tokens => {
+    const parts = []
+    let state
+    for (const [type, val] of tokens) {
+        if (type === '/') parts.push({ index: val })
+        else {
+            const last = parts[parts.length - 1]
+            if (type === ':') last.offset = val
+            else if (type === '~') last.temporal = val
+            else if (type === '@') last.spatial = (last.spatial ?? []).concat(val)
+            else if (type === ';s') last.side = val
+            else if (type === '[') {
+                if (state === '/' && val) last.id = val
+                else {
+                    last.text = (last.text ?? []).concat(val)
+                    continue
+                }
+            }
+        }
+        state = type
+    }
+    return parts
+}
+// split at step indirections, then parse each part
+const parserIndir = tokens =>
+    splitAt(tokens, findTokens(tokens, '!')).map(parser)
+export const parse = cfi => {
+    const tokens = tokenizer(unwrap(cfi))
+    const commas = findTokens(tokens, ',')
+    if (!commas.length) return parserIndir(tokens)
+    const [parent, start, end] = splitAt(tokens, commas).map(parserIndir)
+    return { parent, start, end }
+}
+const partToString = ({ index, id, offset, temporal, spatial, text, side }) => {
+    const param = side ? `;s=${side}` : ''
+    return `/${index}`
+        + (id ? `[${escapeCFI(id)}${param}]` : '')
+        // "CFI expressions [..] SHOULD include an explicit character offset"
+        + (offset != null && index % 2 ? `:${offset}` : '')
+        + (temporal ? `~${temporal}` : '')
+        + (spatial ? `@${spatial.join(':')}` : '')
+        + (text || (!id && side) ? '['
+            + (text?.map(escapeCFI)?.join(',') ?? '')
+            + param + ']' : '')
+}
+const toInnerString = parsed => parsed.parent
+    ? [parsed.parent, parsed.start, parsed.end].map(toInnerString).join(',')
+    : parsed.map(parts => parts.map(partToString).join('')).join('!')
+const toString = parsed => wrap(toInnerString(parsed))
+export const collapse = (x, toEnd) => typeof x === 'string'
+    ? toString(collapse(parse(x), toEnd))
+    : x.parent ? concatArrays(x.parent, x[toEnd ? 'end' : 'start']) : x
+// create range CFI from two CFIs
+const buildRange = (from, to) => {
+    if (typeof from === 'string') from = parse(from)
+    if (typeof to === 'string') to = parse(to)
+    from = collapse(from)
+    to = collapse(to, true)
+    // ranges across multiple documents are not allowed; handle local paths only
+    const localFrom = from[from.length - 1], localTo = to[to.length - 1]
+    const localParent = [], localStart = [], localEnd = []
+    let pushToParent = true
+    const len = Math.max(localFrom.length, localTo.length)
+    for (let i = 0; i < len; i++) {
+        const a = localFrom[i], b = localTo[i]
+        pushToParent &&= a?.index === b?.index && !a?.offset && !b?.offset
+        if (pushToParent) localParent.push(a)
+        else {
+            if (a) localStart.push(a)
+            if (b) localEnd.push(b)
+        }
+    }
+    // copy non-local paths from `from`
+    const parent = from.slice(0, -1).concat([localParent])
+    return toString({ parent, start: [localStart], end: [localEnd] })
+}
+export const compare = (a, b) => {
+    if (typeof a === 'string') a = parse(a)
+    if (typeof b === 'string') b = parse(b)
+    if (a.start || b.start) return compare(collapse(a), collapse(b))
+        || compare(collapse(a, true), collapse(b, true))
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const p = a[i] ?? [], q = b[i] ?? []
+        const maxIndex = Math.max(p.length, q.length) - 1
+        for (let i = 0; i <= maxIndex; i++) {
+            const x = p[i], y = q[i]
+            if (!x) return -1
+            if (!y) return 1
+            if (x.index > y.index) return 1
+            if (x.index < y.index) return -1
+            if (i === maxIndex) {
+                // TODO: compare temporal & spatial offsets
+                if (x.offset > y.offset) return 1
+                if (x.offset < y.offset) return -1
+            }
+        }
+    }
+    return 0
+}
+const isTextNode = ({ nodeType }) => nodeType === 3 || nodeType === 4
+const isElementNode = ({ nodeType }) => nodeType === 1
+const getChildNodes = (node, filter) => {
+    const nodes = Array.from(node.childNodes)
+        // "content other than element and character data is ignored"
+        .filter(node => isTextNode(node) || isElementNode(node))
+    return filter ? nodes.map(node => {
+        const accept = filter(node)
+        if (accept === NodeFilter.FILTER_REJECT) return null
+        else if (accept === NodeFilter.FILTER_SKIP) return getChildNodes(node, filter)
+        else return node
+    }).flat().filter(x => x) : nodes
+}
+// child nodes are organized such that the result is always
+//     [element, text, element, text, ..., element],
+// regardless of the actual structure in the document;
+// so multiple text nodes need to be combined, and nonexistent ones counted;
+// see "Step Reference to Child Element or Character Data (/)" in EPUB CFI spec
+const indexChildNodes = (node, filter) => {
+    const nodes = getChildNodes(node, filter)
+        .reduce((arr, node) => {
+            let last = arr[arr.length - 1]
+            if (!last) arr.push(node)
+            // "there is one chunk between each pair of child elements"
+            else if (isTextNode(node)) {
+                if (Array.isArray(last)) last.push(node)
+                else if (isTextNode(last)) arr[arr.length - 1] = [last, node]
+                else arr.push(node)
+            } else {
+                if (isElementNode(last)) arr.push(null, node)
+                else arr.push(node)
+            }
+            return arr
+        }, [])
+    // "the first chunk is located before the first child element"
+    if (isElementNode(nodes[0])) nodes.unshift('first')
+    // "the last chunk is located after the last child element"
+    if (isElementNode(nodes[nodes.length - 1])) nodes.push('last')
+    // "'virtual' elements"
+    nodes.unshift('before') // "0 is a valid index"
+    nodes.push('after') // "n+2 is a valid index"
+    return nodes
+}
+const partsToNode = (node, parts, filter) => {
+    const { id } = parts[parts.length - 1]
+    if (id) {
+        const el = node.ownerDocument.getElementById(id)
+        if (el) return { node: el, offset: 0 }
+    }
+    for (const { index } of parts) {
+        const newNode = node ? indexChildNodes(node, filter)[index] : null
+        // handle non-existent nodes
+        if (newNode === 'first') return { node: node.firstChild ?? node }
+        if (newNode === 'last') return { node: node.lastChild ?? node }
+        if (newNode === 'before') return { node, before: true }
+        if (newNode === 'after') return { node, after: true }
+        node = newNode
+    }
+    const { offset } = parts[parts.length - 1]
+    if (!Array.isArray(node)) return { node, offset }
+    // get underlying text node and offset from the chunk
+    let sum = 0
+    for (const n of node) {
+        const { length } = n.nodeValue
+        if (sum + length >= offset) return { node: n, offset: offset - sum }
+        sum += length
+    }
+}
+const nodeToParts = (node, offset, filter) => {
+    const { parentNode, id } = node
+    const indexed = indexChildNodes(parentNode, filter)
+    const index = indexed.findIndex(x =>
+        Array.isArray(x) ? x.some(x => x === node) : x === node)
+    // adjust offset as if merging the text nodes in the chunk
+    const chunk = indexed[index]
+    if (Array.isArray(chunk)) {
+        let sum = 0
+        for (const x of chunk) {
+            if (x === node) {
+                sum += offset
+                break
+            } else sum += x.nodeValue.length
+        }
+        offset = sum
+    }
+    const part = { id, index, offset }
+    return (parentNode !== node.ownerDocument.documentElement
+        ? nodeToParts(parentNode, null, filter).concat(part) : [part])
+        // remove ignored nodes
+        .filter(x => x.index !== -1)
+}
+export const fromRange = (range, filter) => {
+    const { startContainer, startOffset, endContainer, endOffset } = range
+    const start = nodeToParts(startContainer, startOffset, filter)
+    if (range.collapsed) return toString([start])
+    const end = nodeToParts(endContainer, endOffset, filter)
+    return buildRange([start], [end])
+}
+export const toRange = (doc, parts, filter) => {
+    const startParts = collapse(parts)
+    const endParts = collapse(parts, true)
+    const root = doc.documentElement
+    const start = partsToNode(root, startParts[0], filter)
+    const end = partsToNode(root, endParts[0], filter)
+    const range = doc.createRange()
+    if (start.before) range.setStartBefore(start.node)
+    else if (start.after) range.setStartAfter(start.node)
+    else range.setStart(start.node, start.offset)
+    if (end.before) range.setEndBefore(end.node)
+    else if (end.after) range.setEndAfter(end.node)
+    else range.setEnd(end.node, end.offset)
+    return range
+}
+// faster way of getting CFIs for sorted elements in a single parent
+export const fromElements = elements => {
+    const results = []
+    const { parentNode } = elements[0]
+    const parts = nodeToParts(parentNode)
+    for (const [index, node] of indexChildNodes(parentNode).entries()) {
+        const el = elements[results.length]
+        if (node === el)
+            results.push(toString([parts.concat({ id: el.id, index })]))
+    }
+    return results
+}
+export const toElement = (doc, parts) =>
+    partsToNode(doc.documentElement, collapse(parts)).node
+// turn indices into standard CFIs when you don't have an actual package document
+export const fake = {
+    fromIndex: index => wrap(`/6/${(index + 1) * 2}`),
+    toIndex: parts => parts?.at(-1).index / 2 - 1,
+}
+// get CFI from Calibre bookmarks
+// see https://github.com/johnfactotum/foliate/issues/849
+export const fromCalibrePos = pos => {
+    const [parts] = parse(pos)
+    const item = parts.shift()
+    parts.shift()
+    return toString([[{ index: 6 }, item], parts])
+}
+export const fromCalibreHighlight = ({ spine_index, start_cfi, end_cfi }) => {
+    const pre = fake.fromIndex(spine_index) + '!'
+    return buildRange(pre + start_cfi.slice(2), pre + end_cfi.slice(2))
+}

packages/foliate-js/eslint.config.js ADDED Viewed

	@@ -0,0 +1,22 @@

+import js from '@eslint/js'
+import globals from 'globals'
+export default [js.configs.recommended, { ignores: ['vendor'] }, {
+    languageOptions: {
+        globals: globals.browser,
+    },
+    linterOptions: {
+        reportUnusedDisableDirectives: true,
+    },
+    rules: {
+        semi: ['error', 'never'],
+        indent: ['warn', 4, { flatTernaryExpressions: true, SwitchCase: 1 }],
+        quotes: ['warn', 'single', { avoidEscape: true }],
+        'comma-dangle': ['warn', 'always-multiline'],
+        'no-trailing-spaces': 'warn',
+        'no-unused-vars': 'warn',
+        'no-console': ['warn', { allow: ['debug', 'warn', 'error', 'assert'] }],
+        'no-constant-condition': ['error', { checkLoops: false }],
+        'no-empty': ['error', { allowEmptyCatch: true }],
+    },
+}]

packages/foliate-js/fb2.js ADDED Viewed

	@@ -0,0 +1,348 @@

+const normalizeWhitespace = str => str ? str
+    .replace(/[\t\n\f\r ]+/g, ' ')
+    .replace(/^[\t\n\f\r ]+/, '')
+    .replace(/[\t\n\f\r ]+$/, '') : ''
+const getElementText = el => normalizeWhitespace(el?.textContent)
+const NS = {
+    XLINK: 'http://www.w3.org/1999/xlink',
+    EPUB: 'http://www.idpf.org/2007/ops',
+}
+const MIME = {
+    XML: 'application/xml',
+    XHTML: 'application/xhtml+xml',
+}
+const STYLE = {
+    'strong': ['strong', 'self'],
+    'emphasis': ['em', 'self'],
+    'style': ['span', 'self'],
+    'a': 'anchor',
+    'strikethrough': ['s', 'self'],
+    'sub': ['sub', 'self'],
+    'sup': ['sup', 'self'],
+    'code': ['code', 'self'],
+    'image': 'image',
+}
+const TABLE = {
+    'tr': ['tr', {
+        'th': ['th', STYLE, ['colspan', 'rowspan', 'align', 'valign']],
+        'td': ['td', STYLE, ['colspan', 'rowspan', 'align', 'valign']],
+    }, ['align']],
+}
+const POEM = {
+    'epigraph': ['blockquote'],
+    'subtitle': ['h2', STYLE],
+    'text-author': ['p', STYLE],
+    'date': ['p', STYLE],
+    'stanza': ['div', 'self'],
+    'v': ['div', STYLE],
+}
+const SECTION = {
+    'title': ['header', {
+        'p': ['h1', STYLE],
+        'empty-line': ['br'],
+    }],
+    'epigraph': ['blockquote', 'self'],
+    'image': 'image',
+    'annotation': ['aside'],
+    'section': ['section', 'self'],
+    'p': ['p', STYLE],
+    'poem': ['blockquote', POEM],
+    'subtitle': ['h2', STYLE],
+    'cite': ['blockquote', 'self'],
+    'empty-line': ['br'],
+    'table': ['table', TABLE],
+    'text-author': ['p', STYLE],
+}
+POEM['epigraph'].push(SECTION)
+const BODY = {
+    'image': 'image',
+    'title': ['section', {
+        'p': ['h1', STYLE],
+        'empty-line': ['br'],
+    }],
+    'epigraph': ['section', SECTION],
+    'section': ['section', SECTION],
+}
+class FB2Converter {
+    constructor(fb2) {
+        this.fb2 = fb2
+        this.doc = document.implementation.createDocument(NS.XHTML, 'html')
+        // use this instead of `getElementById` to allow images like
+        // `<image l:href="#img1.jpg" id="img1.jpg" />`
+        this.bins = new Map(Array.from(this.fb2.getElementsByTagName('binary'),
+            el => [el.id, el]))
+    }
+    getImageSrc(el) {
+        const href = el.getAttributeNS(NS.XLINK, 'href')
+        if (!href) return 'data:,'
+        const [, id] = href.split('#')
+        if (!id) return href
+        const bin = this.bins.get(id)
+        return bin
+            ? `data:${bin.getAttribute('content-type')};base64,${bin.textContent}`
+            : href
+    }
+    image(node) {
+        const el = this.doc.createElement('img')
+        el.alt = node.getAttribute('alt')
+        el.title = node.getAttribute('title')
+        el.setAttribute('src', this.getImageSrc(node))
+        return el
+    }
+    anchor(node) {
+        const el = this.convert(node, { 'a': ['a', STYLE] })
+        el.setAttribute('href', node.getAttributeNS(NS.XLINK, 'href'))
+        if (node.getAttribute('type') === 'note')
+            el.setAttributeNS(NS.EPUB, 'epub:type', 'noteref')
+        return el
+    }
+    convert(node, def) {
+        // not an element; return text content
+        if (node.nodeType === 3) return this.doc.createTextNode(node.textContent)
+        if (node.nodeType === 4) return this.doc.createCDATASection(node.textContent)
+        if (node.nodeType === 8) return this.doc.createComment(node.textContent)
+        const d = def?.[node.nodeName]
+        if (!d) return null
+        if (typeof d === 'string') return this[d](node)
+        const [name, opts, attrs] = d
+        const el = this.doc.createElement(name)
+        // copy the ID, and set class name from original element name
+        if (node.id) el.id = node.id
+        el.classList.add(node.nodeName)
+        // copy attributes
+        if (Array.isArray(attrs)) for (const attr of attrs) {
+            const value = node.getAttribute(attr)
+            if (value) el.setAttribute(attr, value)
+        }
+        // process child elements recursively
+        const childDef = opts === 'self' ? def : opts
+        let child = node.firstChild
+        while (child) {
+            const childEl = this.convert(child, childDef)
+            if (childEl) el.append(childEl)
+            child = child.nextSibling
+        }
+        return el
+    }
+}
+const parseXML = async blob => {
+    const buffer = await blob.arrayBuffer()
+    const str = new TextDecoder('utf-8').decode(buffer)
+    const parser = new DOMParser()
+    const doc = parser.parseFromString(str, MIME.XML)
+    const encoding = doc.xmlEncoding
+        // `Document.xmlEncoding` is deprecated, and already removed in Firefox
+        // so parse the XML declaration manually
+        || str.match(/^<\?xml\s+version\s*=\s*["']1.\d+"\s+encoding\s*=\s*["']([A-Za-z0-9._-]*)["']/)?.[1]
+    if (encoding && encoding.toLowerCase() !== 'utf-8') {
+        const str = new TextDecoder(encoding).decode(buffer)
+        return parser.parseFromString(str, MIME.XML)
+    }
+    return doc
+}
+const style = URL.createObjectURL(new Blob([`
+@namespace epub "http://www.idpf.org/2007/ops";
+body > img, section > img {
+    display: block;
+    margin: auto;
+}
+.title h1 {
+    text-align: center;
+}
+body > section > .title, body.notesBodyType > .title {
+    margin: 3em 0;
+}
+body.notesBodyType > section .title h1 {
+    text-align: start;
+}
+body.notesBodyType > section .title {
+    margin: 1em 0;
+}
+p {
+    text-indent: 1em;
+    margin: 0;
+}
+:not(p) + p, p:first-child {
+    text-indent: 0;
+}
+.stanza {
+    text-indent: 0;
+    margin: 1em 0;
+}
+.text-author, .date {
+    text-align: end;
+}
+.text-author:before {
+    content: "—";
+}
+table {
+    border-collapse: collapse;
+}
+td, th {
+    padding: .25em;
+}
+a[epub|type~="noteref"] {
+    font-size: .75em;
+    vertical-align: super;
+}
+body:not(.notesBodyType) > .title, body:not(.notesBodyType) > .epigraph {
+    margin: 3em 0;
+}
+`], { type: 'text/css' }))
+const template = html => `<?xml version="1.0" encoding="utf-8"?>
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head><link href="${style}" rel="stylesheet" type="text/css"/></head>
+    <body>${html}</body>
+</html>`
+// name of custom ID attribute for TOC items
+const dataID = 'data-foliate-id'
+export const makeFB2 = async blob => {
+    const book = {}
+    const doc = await parseXML(blob)
+    const converter = new FB2Converter(doc)
+    const $ = x => doc.querySelector(x)
+    const $$ = x => [...doc.querySelectorAll(x)]
+    const getPerson = el => {
+        const nick = getElementText(el.querySelector('nickname'))
+        if (nick) return nick
+        const first = getElementText(el.querySelector('first-name'))
+        const middle = getElementText(el.querySelector('middle-name'))
+        const last = getElementText(el.querySelector('last-name'))
+        const name = [first, middle, last].filter(x => x).join(' ')
+        const sortAs = last
+            ? [last, [first, middle].filter(x => x).join(' ')].join(', ')
+            : null
+        return { name, sortAs }
+    }
+    const getDate = el => el?.getAttribute('value') ?? getElementText(el)
+    const annotation = $('title-info annotation')
+    book.metadata = {
+        title: getElementText($('title-info book-title')),
+        identifier: getElementText($('document-info id')),
+        language: getElementText($('title-info lang')),
+        author: $$('title-info author').map(getPerson),
+        translator: $$('title-info translator').map(getPerson),
+        contributor: $$('document-info author').map(getPerson)
+            // techincially the program probably shouldn't get the `bkp` role
+            // but it has been so used by calibre, so ¯\_(ツ)_/¯
+            .concat($$('document-info program-used').map(getElementText))
+            .map(x => Object.assign(typeof x === 'string' ? { name: x } : x,
+                { role: 'bkp' })),
+        publisher: getElementText($('publish-info publisher')),
+        published: getDate($('title-info date')),
+        modified: getDate($('document-info date')),
+        description: annotation ? converter.convert(annotation,
+            { annotation: ['div', SECTION] }).innerHTML : null,
+        subject: $$('title-info genre').map(getElementText),
+    }
+    if ($('coverpage image')) {
+        const src = converter.getImageSrc($('coverpage image'))
+        book.getCover = () => fetch(src).then(res => res.blob())
+    } else book.getCover = () => null
+    // get convert each body
+    const bodyData = Array.from(doc.querySelectorAll('body'), body => {
+        const converted = converter.convert(body, { body: ['body', BODY] })
+        return [Array.from(converted.children, el => {
+            // get list of IDs in the section
+            const ids = [el, ...el.querySelectorAll('[id]')].map(el => el.id)
+            return { el, ids }
+        }), converted]
+    })
+    const urls = []
+    const sectionData = bodyData[0][0]
+        // make a separate section for each section in the first body
+        .map(({ el, ids }, id) => {
+            // set up titles for TOC
+            const titles = Array.from(
+                el.querySelectorAll(':scope > section > .title'),
+                (el, index) => {
+                    el.setAttribute(dataID, index)
+                    const section = el.closest('section')
+                    const size = new TextEncoder().encode(section.innerHTML).length
+                        - Array.from(section.querySelectorAll('[src]'))
+                            .reduce((sum, el) => sum + (el.getAttribute('src')?.length ?? 0), 0)
+                    return { title: getElementText(el), index, size, href: `${id}#${index}` }
+                })
+            return { ids, titles, el }
+        })
+        // for additional bodies, only make one section for each body
+        .concat(bodyData.slice(1).map(([sections, body]) => {
+            const ids = sections.map(s => s.ids).flat()
+            body.classList.add('notesBodyType')
+            return { ids, el: body, linear: 'no' }
+        }))
+        .map(({ ids, titles, el, linear }) => {
+            const str = template(el.outerHTML)
+            const blob = new Blob([str], { type: MIME.XHTML })
+            const url = URL.createObjectURL(blob)
+            urls.push(url)
+            const title = normalizeWhitespace(
+                el.querySelector('.title, .subtitle, p')?.textContent
+                ?? (el.classList.contains('title') ? el.textContent : ''))
+            return {
+                ids, title, titles, load: () => url,
+                createDocument: () => new DOMParser().parseFromString(str, MIME.XHTML),
+                // doo't count image data as it'd skew the size too much
+                size: blob.size - Array.from(el.querySelectorAll('[src]'),
+                    el => el.getAttribute('src')?.length ?? 0)
+                    .reduce((a, b) => a + b, 0),
+                linear,
+            }
+        })
+    const idMap = new Map()
+    book.sections = sectionData.map((section, index) => {
+        const { ids, load, createDocument, size, linear, titles } = section
+        for (const id of ids) if (id) idMap.set(id, index)
+        return { id: index, load, createDocument, size, linear, subitems: titles }
+    })
+    book.toc = sectionData.map(({ title, titles }, index) => {
+        const id = index.toString()
+        return {
+            label: title,
+            href: id,
+            subitems: titles?.length ? titles.map(({ title, index }) => ({
+                label: title,
+                href: `${id}#${index}`,
+            })) : null,
+        }
+    }).filter(item => item)
+    book.resolveHref = href => {
+        const [a, b] = href.split('#')
+        return a
+            // the link is from the TOC
+            ? { index: Number(a), anchor: doc => doc.querySelector(`[${dataID}="${b}"]`) }
+            // link from within the page
+            : { index: idMap.get(b), anchor: doc => doc.getElementById(b) }
+    }
+    book.splitTOCHref = href => href?.split('#')?.map(x => Number(x)) ?? []
+    book.getTOCFragment = (doc, id) => doc.querySelector(`[${dataID}="${id}"]`)
+    book.destroy = () => {
+        for (const url of urls) URL.revokeObjectURL(url)
+    }
+    return book
+}

packages/foliate-js/fixed-layout.js ADDED Viewed

	@@ -0,0 +1,618 @@

+import 'construct-style-sheets-polyfill'
+const parseViewport = str => str
+    ?.split(/[,;\s]/) // NOTE: technically, only the comma is valid
+    ?.filter(x => x)
+    ?.map(x => x.split('=').map(x => x.trim()))
+const getViewport = (doc, viewport) => {
+    // use `viewBox` for SVG
+    if (doc.documentElement.localName === 'svg') {
+        const [, , width, height] = doc.documentElement
+            .getAttribute('viewBox')?.split(/\s/) ?? []
+        return { width, height }
+    }
+    // get `viewport` `meta` element
+    const meta = parseViewport(doc.querySelector('meta[name="viewport"]')
+        ?.getAttribute('content'))
+    if (meta) return Object.fromEntries(meta)
+    // fallback to book's viewport
+    if (typeof viewport === 'string') return parseViewport(viewport)
+    if (viewport?.width && viewport.height) return viewport
+    // if no viewport (possibly with image directly in spine), get image size
+    const img = doc.querySelector('img')
+    if (img) return { width: img.naturalWidth, height: img.naturalHeight }
+    // just show *something*, i guess...
+    console.warn(new Error('Missing viewport properties'))
+    return { width: 1000, height: 2000 }
+}
+export class FixedLayout extends HTMLElement {
+    static observedAttributes = ['zoom', 'scale-factor', 'spread']
+    #root = this.attachShadow({ mode: 'open' })
+    #observer = new ResizeObserver(() => this.#render())
+    #spreads
+    #index = -1
+    defaultViewport
+    spread
+    #portrait = false
+    #left
+    #right
+    #center
+    #side
+    #zoom
+    #scaleFactor = 1.0
+    #totalScaleFactor = 1.0
+    #scrollLocked = false
+    #isOverflowX = false
+    #isOverflowY = false
+    #preloadCache = new Map()
+    #prerenderedSpreads = new Map()
+    #spreadAccessTime = new Map()
+    #maxConcurrentPreloads = 1
+    #numPrerenderedSpreads = 1
+    #maxCachedSpreads = 2
+    #preloadQueue = []
+    #activePreloads = 0
+    constructor() {
+        super()
+        const sheet = new CSSStyleSheet()
+        this.#root.adoptedStyleSheets = [sheet]
+        sheet.replaceSync(`:host {
+            width: 100%;
+            height: 100%;
+            display: flex;
+            justify-content: flex-start;
+            align-items: center;
+            overflow: auto;
+        }
+        @supports (justify-content: safe center) {
+          :host {
+            justify-content: safe center;
+          }
+        }`)
+        this.#observer.observe(this)
+    }
+    attributeChangedCallback(name, _, value) {
+        switch (name) {
+            case 'zoom':
+                this.#zoom = value !== 'fit-width' && value !== 'fit-page'
+                    ? parseFloat(value) : value
+                this.#render()
+                break
+            case 'scale-factor':
+                this.#scaleFactor = parseFloat(value) / 100
+                this.#render()
+                break
+            case 'spread':
+                this.#respread(value)
+                break
+        }
+    }
+    async #createFrame({ index, src: srcOption, detached = false }) {
+        const srcOptionIsString = typeof srcOption === 'string'
+        const src = srcOptionIsString ? srcOption : srcOption?.src
+        const data = srcOptionIsString ? null : srcOption?.data
+        const onZoom = srcOptionIsString ? null : srcOption?.onZoom
+        const element = document.createElement('div')
+        element.setAttribute('dir', 'ltr')
+        const iframe = document.createElement('iframe')
+        element.append(iframe)
+        Object.assign(iframe.style, {
+            border: '0',
+            display: 'none',
+            overflow: 'hidden',
+        })
+        // `allow-scripts` is needed for events because of WebKit bug
+        // https://bugs.webkit.org/show_bug.cgi?id=218086
+        iframe.setAttribute('sandbox', 'allow-same-origin allow-scripts')
+        iframe.setAttribute('scrolling', 'no')
+        iframe.setAttribute('part', 'filter')
+        this.#root.append(element)
+        if (detached) {
+            Object.assign(element.style, {
+                position: 'absolute',
+                visibility: 'hidden',
+                pointerEvents: 'none',
+            })
+        }
+        if (!src) return { blank: true, element, iframe }
+        return new Promise(resolve => {
+            iframe.addEventListener('load', () => {
+                const doc = iframe.contentDocument
+                this.dispatchEvent(new CustomEvent('load', { detail: { doc, index } }))
+                const { width, height } = getViewport(doc, this.defaultViewport)
+                resolve({
+                    element, iframe,
+                    width: parseFloat(width),
+                    height: parseFloat(height),
+                    onZoom,
+                    detached,
+                })
+            }, { once: true })
+            if (data) {
+                iframe.srcdoc = data
+            } else {
+                iframe.src = src
+            }
+        })
+    }
+    #render(side = this.#side) {
+        if (!side) return
+        const left = this.#left ?? {}
+        const right = this.#center ?? this.#right ?? {}
+        const target = side === 'left' ? left : right
+        const { width, height } = this.getBoundingClientRect()
+        // for unfolded devices with slightly taller height than width also use landscape layout
+        const portrait = this.spread !== 'both' && this.spread !== 'portrait'
+            && height > width * 1.2
+        this.#portrait = portrait
+        const blankWidth = left.width ?? right.width ?? 0
+        const blankHeight = left.height ?? right.height ?? 0
+        let scale = typeof this.#zoom === 'number' && !isNaN(this.#zoom)
+            ? this.#zoom
+            : (this.#zoom === 'fit-width'
+                ? (portrait || this.#center
+                    ? width / (target.width ?? blankWidth)
+                    : width / ((left.width ?? blankWidth) + (right.width ?? blankWidth)))
+                : (portrait || this.#center
+                    ? Math.min(
+                        width / (target.width ?? blankWidth),
+                        height / (target.height ?? blankHeight))
+                    : Math.min(
+                        width / ((left.width ?? blankWidth) + (right.width ?? blankWidth)),
+                        height / Math.max(
+                            left.height ?? blankHeight,
+                            right.height ?? blankHeight)))
+            ) || 1
+        scale *= this.#scaleFactor
+        this.#totalScaleFactor = scale
+        const transform = ({frame, styles}) => {
+            let { element, iframe, width, height, blank, onZoom } = frame
+            if (!iframe) return
+            if (onZoom) onZoom({ doc: frame.iframe.contentDocument, scale })
+            const iframeScale = onZoom ? scale : 1
+            const zoomedOut = this.#scaleFactor < 1.0
+            Object.assign(iframe.style, {
+                width: `${width * iframeScale}px`,
+                height: `${height * iframeScale}px`,
+                transform: onZoom ? 'none' : `scale(${scale})`,
+                transformOrigin: 'top left',
+                display: blank ? 'none' : 'block',
+            })
+            Object.assign(element.style, {
+                width: `${(width ?? blankWidth) * scale}px`,
+                height: `${(height ?? blankHeight) * scale}px`,
+                flexShrink: '0',
+                display: zoomedOut ? 'flex' : 'block',
+                marginBlock: zoomedOut ? undefined : 'auto',
+                alignItems: zoomedOut ? 'center' : undefined,
+                justifyContent: zoomedOut ? 'center' : undefined,
+                ...styles,
+            })
+            if (portrait && frame !== target) {
+                element.style.display = 'none'
+            }
+            const container= element.parentNode.host
+            const containerWidth = container.clientWidth
+            const containerHeight = container.clientHeight
+            container.scrollLeft = (element.clientWidth - containerWidth) / 2
+            return {
+                width: element.clientWidth,
+                height: element.clientHeight,
+                containerWidth,
+                containerHeight,
+            }
+        }
+        if (this.#center) {
+            const dimensions = transform({frame: this.#center, styles: { marginInline: 'auto' }})
+            const {width, height, containerWidth, containerHeight} = dimensions
+            this.#isOverflowX = width > containerWidth
+            this.#isOverflowY = height > containerHeight
+        } else {
+            const leftDimensions = transform({frame: left, styles: { marginInlineStart: 'auto' }})
+            const rightDimensions = transform({frame: right, styles: { marginInlineEnd: 'auto' }})
+            const {width: leftWidth, height: leftHeight, containerWidth, containerHeight} = leftDimensions
+            const {width: rightWidth, height: rightHeight} = rightDimensions
+            this.#isOverflowX = leftWidth + rightWidth > containerWidth
+            this.#isOverflowY = Math.max(leftHeight, rightHeight) > containerHeight
+        }
+    }
+    async #showSpread({ left, right, center, side, spreadIndex }) {
+        this.#left = null
+        this.#right = null
+        this.#center = null
+        const cacheKey = spreadIndex !== undefined ? `spread-${spreadIndex}` : null
+        const prerendered = cacheKey ? this.#prerenderedSpreads.get(cacheKey) : null
+        if (prerendered) {
+            this.#spreadAccessTime.set(cacheKey, Date.now())
+            if (prerendered.center) {
+                this.#center = prerendered.center
+            } else {
+                this.#left = prerendered.left
+                this.#right = prerendered.right
+            }
+        } else {
+            if (center) {
+                this.#center = await this.#createFrame(center)
+                if (cacheKey) {
+                    this.#prerenderedSpreads.set(cacheKey, { center: this.#center })
+                    this.#spreadAccessTime.set(cacheKey, Date.now())
+                }
+            } else {
+                this.#left = await this.#createFrame(left)
+                this.#right = await this.#createFrame(right)
+                if (cacheKey) {
+                    this.#prerenderedSpreads.set(cacheKey, { left: this.#left, right: this.#right })
+                    this.#spreadAccessTime.set(cacheKey, Date.now())
+                }
+            }
+        }
+        this.#side = center ? 'center' : this.#left.blank ? 'right'
+            : this.#right.blank ? 'left' : side
+        const visibleFrames = center
+            ? [this.#center?.element]
+            : [this.#left?.element, this.#right?.element]
+        Array.from(this.#root.children).forEach(child => {
+            const isVisible = visibleFrames.includes(child)
+            Object.assign(child.style, {
+                position: isVisible ? 'relative' : 'absolute',
+                visibility: isVisible ? 'visible' : 'hidden',
+                pointerEvents: isVisible ? 'auto' : 'none',
+            })
+        })
+        this.#render()
+    }
+    #goLeft() {
+        if (this.#center || this.#left?.blank) return
+        if (this.#portrait && this.#left?.element?.style?.display === 'none') {
+            this.#side = 'left'
+            this.#render()
+            this.#reportLocation('page')
+            return true
+        }
+    }
+    #goRight() {
+        if (this.#center || this.#right?.blank) return
+        if (this.#portrait && this.#right?.element?.style?.display === 'none') {
+            this.#side = 'right'
+            this.#render()
+            this.#reportLocation('page')
+            return true
+        }
+    }
+    open(book) {
+        this.book = book
+        this.defaultViewport = book.rendition?.viewport
+        this.rtl = book.dir === 'rtl'
+        this.#spread()
+    }
+    #spread(mode) {
+        const book = this.book
+        const { rendition } = book
+        const rtl = this.rtl
+        const ltr = !rtl
+        this.spread = mode || rendition?.spread
+        if (this.spread === 'none')
+            this.#spreads = book.sections.map(section => ({ center: section }))
+        else this.#spreads = book.sections.reduce((arr, section, i) => {
+            const last = arr[arr.length - 1]
+            const { pageSpread } = section
+            const newSpread = () => {
+                const spread = {}
+                arr.push(spread)
+                return spread
+            }
+            if (pageSpread === 'center') {
+                const spread = last.left || last.right ? newSpread() : last
+                spread.center = section
+            }
+            else if (pageSpread === 'left') {
+                const spread = last.center || last.left || ltr && i ? newSpread() : last
+                spread.left = section
+            }
+            else if (pageSpread === 'right') {
+                const spread = last.center || last.right || rtl && i ? newSpread() : last
+                spread.right = section
+            }
+            else if (ltr) {
+                if (last.center || last.right) newSpread().left = section
+                else if (last.left || !i) last.right = section
+                else last.left = section
+            }
+            else {
+                if (last.center || last.left) newSpread().right = section
+                else if (last.right || !i) last.left = section
+                else last.right = section
+            }
+            return arr
+        }, [{}])
+    }
+    #respread(spreadMode) {
+        if (this.#index === -1) return
+        const section = this.book.sections[this.index]
+        this.#spread(spreadMode)
+        const { index } = this.getSpreadOf(section)
+        this.#index = -1
+        this.#preloadCache.clear()
+        for (const frames of this.#prerenderedSpreads.values()) {
+            if (frames.center) {
+                frames.center.element?.remove()
+            } else {
+                frames.left?.element?.remove()
+                frames.right?.element?.remove()
+            }
+        }
+        this.#prerenderedSpreads.clear()
+        this.#spreadAccessTime.clear()
+        this.goToSpread(index, this.rtl ? 'right' : 'left', 'page')
+    }
+    get index() {
+        const spread = this.#spreads[this.#index]
+        const section = spread?.center ?? (this.#side === 'left'
+            ? spread.left ?? spread.right : spread.right ?? spread.left)
+        return this.book.sections.indexOf(section)
+    }
+    get scrollLocked() {
+        return this.#scrollLocked
+    }
+    set scrollLocked(value) {
+        this.#scrollLocked = value
+    }
+    get isOverflowX() {
+        return this.#isOverflowX
+    }
+    get isOverflowY() {
+        return this.#isOverflowY
+    }
+    #reportLocation(reason) {
+        this.dispatchEvent(new CustomEvent('relocate', { detail:
+            { reason, range: null, index: this.index, fraction: 0, size: 1 } }))
+    }
+    getSpreadOf(section) {
+        const spreads = this.#spreads
+        for (let index = 0; index < spreads.length; index++) {
+            const { left, right, center } = spreads[index]
+            if (left === section) return { index, side: 'left' }
+            if (right === section) return { index, side: 'right' }
+            if (center === section) return { index, side: 'center' }
+        }
+    }
+    async goToSpread(index, side, reason) {
+        if (index < 0 || index > this.#spreads.length - 1) return
+        if (index === this.#index) {
+            this.#render(side)
+            return
+        }
+        this.#index = index
+        const spread = this.#spreads[index]
+        const cacheKey = `spread-${index}`
+        const cached = this.#preloadCache.get(cacheKey)
+        if (cached && cached !== 'loading') {
+            if (cached.center) {
+                const sectionIndex = this.book.sections.indexOf(spread.center)
+                await this.#showSpread({ center: { index: sectionIndex, src: cached.center }, spreadIndex: index, side })
+            } else {
+                const indexL = this.book.sections.indexOf(spread.left)
+                const indexR = this.book.sections.indexOf(spread.right)
+                const left = { index: indexL, src: cached.left }
+                const right = { index: indexR, src: cached.right }
+                await this.#showSpread({ left, right, side, spreadIndex: index })
+            }
+        } else {
+            if (spread.center) {
+                const sectionIndex = this.book.sections.indexOf(spread.center)
+                const src = await spread.center?.load?.()
+                await this.#showSpread({ center: { index: sectionIndex, src }, spreadIndex: index, side })
+            } else {
+                const indexL = this.book.sections.indexOf(spread.left)
+                const indexR = this.book.sections.indexOf(spread.right)
+                const srcL = await spread.left?.load?.()
+                const srcR = await spread.right?.load?.()
+                const left = { index: indexL, src: srcL }
+                const right = { index: indexR, src: srcR }
+                await this.#showSpread({ left, right, side, spreadIndex: index })
+            }
+        }
+        this.#reportLocation(reason)
+        this.#preloadNextSpreads()
+    }
+    #preloadNextSpreads() {
+        this.#cleanupPreloadCache()
+        if (this.#numPrerenderedSpreads <= 0) return
+        const toPreload = []
+        const forwardPreloadCount = Math.max(1, this.#numPrerenderedSpreads - 1)
+        const backwardPreloadCount = Math.max(0, this.#numPrerenderedSpreads - forwardPreloadCount)
+        for (let distance = 1; distance <= forwardPreloadCount; distance++) {
+            const forwardIndex = this.#index + distance
+            if (forwardIndex >= 0 && forwardIndex < this.#spreads.length) {
+                toPreload.push({ index: forwardIndex, direction: 'forward', distance })
+            }
+        }
+        for (let distance = 1; distance <= backwardPreloadCount; distance++) {
+            const backwardIndex = this.#index - distance
+            if (backwardIndex >= 0 && backwardIndex < this.#spreads.length) {
+                toPreload.push({ index: backwardIndex, direction: 'backward', distance })
+            }
+        }
+        for (const { index: targetIndex, direction } of toPreload) {
+            const cacheKey = `spread-${targetIndex}`
+            if (this.#prerenderedSpreads.has(cacheKey)) continue
+            const spread = this.#spreads[targetIndex]
+            if (!spread) continue
+            this.#preloadQueue.push({ targetIndex, direction, spread, cacheKey })
+        }
+        this.#processPreloadQueue()
+    }
+    async #processPreloadQueue() {
+        while (this.#preloadQueue.length > 0 && this.#activePreloads < this.#maxConcurrentPreloads) {
+            const task = this.#preloadQueue.shift()
+            if (!task) break
+            const { spread, cacheKey } = task
+            this.#preloadCache.set(cacheKey, 'loading')
+            this.#activePreloads++
+            Promise.resolve().then(async () => {
+                try {
+                    if (spread.center) {
+                        const src = await spread.center?.load?.()
+                        this.#preloadCache.set(cacheKey, { center: src })
+                        const sectionIndex = this.book.sections.indexOf(spread.center)
+                        const frame = await this.#createFrame({ index: sectionIndex, src, detached: true })
+                        this.#prerenderedSpreads.set(cacheKey, { center: frame })
+                        this.#spreadAccessTime.set(cacheKey, Date.now())
+                        if (frame.onZoom) {
+                            const doc = frame.iframe.contentDocument
+                            frame.onZoom({ doc, scale: this.#totalScaleFactor })
+                        }
+                    } else {
+                        const srcL = await spread.left?.load?.()
+                        const srcR = await spread.right?.load?.()
+                        this.#preloadCache.set(cacheKey, { left: srcL, right: srcR })
+                        const indexL = this.book.sections.indexOf(spread.left)
+                        const indexR = this.book.sections.indexOf(spread.right)
+                        const leftFrame = await this.#createFrame({ index: indexL, src: srcL, detached: true })
+                        const rightFrame = await this.#createFrame({ index: indexR, src: srcR, detached: true })
+                        this.#prerenderedSpreads.set(cacheKey, { left: leftFrame, right: rightFrame })
+                        this.#spreadAccessTime.set(cacheKey, Date.now())
+                        if (leftFrame.onZoom) {
+                            const docL = leftFrame.iframe.contentDocument
+                            leftFrame.onZoom({ doc: docL, scale: this.#totalScaleFactor })
+                        }
+                        if (rightFrame.onZoom) {
+                            const docR = rightFrame.iframe.contentDocument
+                            rightFrame.onZoom({ doc: docR, scale: this.#totalScaleFactor })
+                        }
+                    }
+                } catch {
+                    this.#preloadCache.delete(cacheKey)
+                    this.#prerenderedSpreads.delete(cacheKey)
+                } finally {
+                    this.#activePreloads--
+                    this.#processPreloadQueue()
+                }
+            })
+        }
+    }
+    #cleanupPreloadCache() {
+        const maxSpreads = this.#maxCachedSpreads
+        if (this.#prerenderedSpreads.size <= maxSpreads) {
+            return
+        }
+        const framesByAge = Array.from(this.#prerenderedSpreads.keys())
+            .map(key => ({
+                key,
+                accessTime: this.#spreadAccessTime.get(key) || 0,
+            }))
+            .sort((a, b) => a.accessTime - b.accessTime)
+        const numToRemove = this.#prerenderedSpreads.size - maxSpreads
+        const framesToDelete = framesByAge.slice(0, numToRemove).map(item => item.key)
+        if (framesToDelete.length > 0) {
+            framesToDelete.forEach(key => {
+                const frames = this.#prerenderedSpreads.get(key)
+                if (frames) {
+                    if (frames.center) {
+                        frames.center.element?.remove()
+                    } else {
+                        frames.left?.element?.remove()
+                        frames.right?.element?.remove()
+                    }
+                }
+                this.#prerenderedSpreads.delete(key)
+                this.#spreadAccessTime.delete(key)
+                this.#preloadCache.delete(key)
+            })
+        }
+    }
+    async select(target) {
+        await this.goTo(target)
+        // TODO
+    }
+    async goTo(target) {
+        const { book } = this
+        const resolved = await target
+        const section = book.sections[resolved.index]
+        if (!section) return
+        const { index, side } = this.getSpreadOf(section)
+        await this.goToSpread(index, side)
+    }
+    async next() {
+        const s = this.rtl ? this.#goLeft() : this.#goRight()
+        if (!s) return this.goToSpread(this.#index + 1, this.rtl ? 'right' : 'left', 'page')
+    }
+    async prev() {
+        const s = this.rtl ? this.#goRight() : this.#goLeft()
+        if (!s) return this.goToSpread(this.#index - 1, this.rtl ? 'left' : 'right', 'page')
+    }
+    async pan(dx, dy) {
+        if (this.#scrollLocked) return
+        this.#scrollLocked = true
+        const transform = frame => {
+            let { element, iframe } = frame
+            if (!iframe || !element) return
+            const scrollableContainer = element.parentNode.host
+            scrollableContainer.scrollLeft += dx
+            scrollableContainer.scrollTop += dy
+        }
+        transform(this.#center ?? this.#right ?? {})
+        this.#scrollLocked = false
+    }
+    getContents() {
+        return Array.from(this.#root.querySelectorAll('iframe'), frame => ({
+            doc: frame.contentDocument,
+            // TODO: index, overlayer
+        }))
+    }
+    destroy() {
+        this.#observer.unobserve(this)
+        for (const frames of this.#prerenderedSpreads.values()) {
+            if (frames.center) {
+                frames.center.element?.remove()
+            } else {
+                frames.left?.element?.remove()
+                frames.right?.element?.remove()
+            }
+        }
+        this.#prerenderedSpreads.clear()
+        this.#preloadCache.clear()
+        this.#spreadAccessTime.clear()
+    }
+}
+customElements.define('foliate-fxl', FixedLayout)

packages/foliate-js/footnotes.js ADDED Viewed

	@@ -0,0 +1,145 @@

+const getTypes = el => new Set([
+    ...(el?.getAttributeNS?.('http://www.idpf.org/2007/ops', 'type')?.split(' ') ?? []),
+    ...(el?.attributes?.getNamedItem?.('epub:type')?.value?.split(' ') ?? []),
+])
+const getRoles = el => new Set(el?.getAttribute?.('role')?.split(' '))
+const isSuper = el => {
+    if (el.matches('sup')) return true
+    const { verticalAlign } = getComputedStyle(el)
+    return verticalAlign === 'super'
+        || verticalAlign === 'top'
+        || verticalAlign === 'text-top'
+        || /^\d/.test(verticalAlign)
+}
+const refTypes = ['biblioref', 'glossref', 'noteref']
+const refRoles = ['doc-biblioref', 'doc-glossref', 'doc-noteref']
+const isFootnoteReference = a => {
+    const types = getTypes(a)
+    const roles = getRoles(a)
+    return {
+        yes: refRoles.some(r => roles.has(r)) || refTypes.some(t => types.has(t)),
+        maybe: () => !types.has('backlink') && !roles.has('doc-backlink')
+            && (isSuper(a) || a.children.length === 1 && isSuper(a.children[0])
+            || isSuper(a.parentElement)),
+    }
+}
+const getReferencedType = el => {
+    const types = getTypes(el)
+    const roles = getRoles(el)
+    return roles.has('doc-biblioentry') || types.has('biblioentry') ? 'biblioentry'
+        : roles.has('definition') || types.has('glossdef') ? 'definition'
+        : roles.has('doc-endnote') || types.has('endnote') || types.has('rearnote') ? 'endnote'
+        : roles.has('doc-footnote') || types.has('footnote') ? 'footnote'
+        : roles.has('note') || types.has('note') ? 'note' : null
+}
+const isInline = 'a, span, sup, sub, em, strong, i, b, small, big'
+const extractFootnote = (doc, anchor) => {
+    let el = anchor(doc)
+    const target = el
+    while (el.matches(isInline)) {
+        const parent = el.parentElement
+        if (!parent) break
+        el = parent
+    }
+    if (el === doc.body) {
+        const sibling = target.nextElementSibling
+        if (sibling && !sibling.matches(isInline)) return sibling
+        throw new Error('Failed to extract footnote')
+    }
+    return el
+}
+export class FootnoteHandler extends EventTarget {
+    detectFootnotes = true
+    #showFragment(book, { index, anchor }, href) {
+        const view = document.createElement('foliate-view')
+        return new Promise((resolve, reject) => {
+            view.addEventListener('load', e => {
+                try {
+                    const { doc } = e.detail
+                    const el = anchor(doc)
+                    const type = getReferencedType(el)
+                    const hidden = el?.matches?.('aside') && type === 'footnote'
+                    if (el) {
+                        let range
+                        if (el.startContainer) {
+                            range = el
+                        } else if (el.matches('li, aside')) {
+                            range = doc.createRange()
+                            range.selectNodeContents(el)
+                        } else if (el.matches('dt')) {
+                            range = doc.createRange()
+                            range.setStartBefore(el)
+                            let sibling = el.nextElementSibling
+                            let lastDD = null
+                            while (sibling && sibling.matches('dd')) {
+                                lastDD = sibling
+                                sibling = sibling.nextElementSibling
+                            }
+                            range.setEndAfter(lastDD || el)
+                        } else if (el.closest('li')) {
+                            range = doc.createRange()
+                            range.selectNodeContents(el.closest('li'))
+                        } else if (el.closest('.note')) {
+                            range = doc.createRange()
+                            range.selectNodeContents(el.closest('.note'))
+                        } else if (el.querySelector('a')) {
+                            range = doc.createRange()
+                            range.setStartBefore(el)
+                            let next = el.nextElementSibling
+                            while (next) {
+                                if (next.querySelector('a')) break
+                                next = next.nextElementSibling
+                            }
+                            if (next) {
+                                range.setEndBefore(next)
+                            } else {
+                                range.setEndAfter(el.parentNode.lastChild)
+                            }
+                        } else {
+                            range = doc.createRange()
+                            const hasContent = el.textContent?.trim() || el.children.length > 0
+                            if (!hasContent && el.parentElement) {
+                                range.selectNodeContents(el.parentElement)
+                            } else {
+                                range.selectNode(el)
+                            }
+                        }
+                        const frag = range.extractContents()
+                        doc.body.replaceChildren()
+                        doc.body.appendChild(frag)
+                    }
+                    const detail = { view, href, type, hidden, target: el }
+                    this.dispatchEvent(new CustomEvent('render', { detail }))
+                    resolve()
+                } catch (e) {
+                    reject(e)
+                }
+            })
+            view.open(book)
+                .then(() => this.dispatchEvent(new CustomEvent('before-render', { detail: { view } })))
+                .then(() => view.goTo(index))
+                .catch(reject)
+        })
+    }
+    handle(book, e) {
+        const { a, href, follow } = e.detail
+        const { yes, maybe } = isFootnoteReference(a)
+        if (yes || follow) {
+            e.preventDefault()
+            return Promise.resolve(book.resolveHref(href)).then(target =>
+                this.#showFragment(book, target, href))
+        }
+        else if (this.detectFootnotes && maybe()) {
+            e.preventDefault()
+            return Promise.resolve(book.resolveHref(href)).then(({ index, anchor }) => {
+                const target = { index, anchor: doc => extractFootnote(doc, anchor) }
+                return this.#showFragment(book, target, href)
+            })
+        }
+    }
+}

packages/foliate-js/mobi.js ADDED Viewed

	@@ -0,0 +1,1236 @@

+const unescapeHTML = str => {
+    if (!str) return ''
+    const textarea = document.createElement('textarea')
+    textarea.innerHTML = str
+    return textarea.value
+}
+const MIME = {
+    XML: 'application/xml',
+    XHTML: 'application/xhtml+xml',
+    HTML: 'text/html',
+    CSS: 'text/css',
+    SVG: 'image/svg+xml',
+}
+const PDB_HEADER = {
+    name: [0, 32, 'string'],
+    type: [60, 4, 'string'],
+    creator: [64, 4, 'string'],
+    numRecords: [76, 2, 'uint'],
+}
+const PALMDOC_HEADER = {
+    compression: [0, 2, 'uint'],
+    numTextRecords: [8, 2, 'uint'],
+    recordSize: [10, 2, 'uint'],
+    encryption: [12, 2, 'uint'],
+}
+const MOBI_HEADER = {
+    magic: [16, 4, 'string'],
+    length: [20, 4, 'uint'],
+    type: [24, 4, 'uint'],
+    encoding: [28, 4, 'uint'],
+    uid: [32, 4, 'uint'],
+    version: [36, 4, 'uint'],
+    titleOffset: [84, 4, 'uint'],
+    titleLength: [88, 4, 'uint'],
+    localeRegion: [94, 1, 'uint'],
+    localeLanguage: [95, 1, 'uint'],
+    resourceStart: [108, 4, 'uint'],
+    huffcdic: [112, 4, 'uint'],
+    numHuffcdic: [116, 4, 'uint'],
+    exthFlag: [128, 4, 'uint'],
+    trailingFlags: [240, 4, 'uint'],
+    indx: [244, 4, 'uint'],
+}
+const KF8_HEADER = {
+    resourceStart: [108, 4, 'uint'],
+    fdst: [192, 4, 'uint'],
+    numFdst: [196, 4, 'uint'],
+    frag: [248, 4, 'uint'],
+    skel: [252, 4, 'uint'],
+    guide: [260, 4, 'uint'],
+}
+const EXTH_HEADER = {
+    magic: [0, 4, 'string'],
+    length: [4, 4, 'uint'],
+    count: [8, 4, 'uint'],
+}
+const INDX_HEADER = {
+    magic: [0, 4, 'string'],
+    length: [4, 4, 'uint'],
+    type: [8, 4, 'uint'],
+    idxt: [20, 4, 'uint'],
+    numRecords: [24, 4, 'uint'],
+    encoding: [28, 4, 'uint'],
+    language: [32, 4, 'uint'],
+    total: [36, 4, 'uint'],
+    ordt: [40, 4, 'uint'],
+    ligt: [44, 4, 'uint'],
+    numLigt: [48, 4, 'uint'],
+    numCncx: [52, 4, 'uint'],
+}
+const TAGX_HEADER = {
+    magic: [0, 4, 'string'],
+    length: [4, 4, 'uint'],
+    numControlBytes: [8, 4, 'uint'],
+}
+const HUFF_HEADER = {
+    magic: [0, 4, 'string'],
+    offset1: [8, 4, 'uint'],
+    offset2: [12, 4, 'uint'],
+}
+const CDIC_HEADER = {
+    magic: [0, 4, 'string'],
+    length: [4, 4, 'uint'],
+    numEntries: [8, 4, 'uint'],
+    codeLength: [12, 4, 'uint'],
+}
+const FDST_HEADER = {
+    magic: [0, 4, 'string'],
+    numEntries: [8, 4, 'uint'],
+}
+const FONT_HEADER = {
+    flags: [8, 4, 'uint'],
+    dataStart: [12, 4, 'uint'],
+    keyLength: [16, 4, 'uint'],
+    keyStart: [20, 4, 'uint'],
+}
+const MOBI_ENCODING = {
+    1252: 'windows-1252',
+    65001: 'utf-8',
+}
+const EXTH_RECORD_TYPE = {
+    100: ['creator', 'string', true],
+    101: ['publisher'],
+    103: ['description'],
+    104: ['isbn'],
+    105: ['subject', 'string', true],
+    106: ['date'],
+    108: ['contributor', 'string', true],
+    109: ['rights'],
+    110: ['subjectCode', 'string', true],
+    112: ['source', 'string', true],
+    113: ['asin'],
+    121: ['boundary', 'uint'],
+    122: ['fixedLayout'],
+    125: ['numResources', 'uint'],
+    126: ['originalResolution'],
+    127: ['zeroGutter'],
+    128: ['zeroMargin'],
+    129: ['coverURI'],
+    132: ['regionMagnification'],
+    201: ['coverOffset', 'uint'],
+    202: ['thumbnailOffset', 'uint'],
+    503: ['title'],
+    524: ['language', 'string', true],
+    527: ['pageProgressionDirection'],
+}
+const MOBI_LANG = {
+    1: ['ar', 'ar-SA', 'ar-IQ', 'ar-EG', 'ar-LY', 'ar-DZ', 'ar-MA', 'ar-TN', 'ar-OM',
+        'ar-YE', 'ar-SY', 'ar-JO', 'ar-LB', 'ar-KW', 'ar-AE', 'ar-BH', 'ar-QA'],
+    2: ['bg'], 3: ['ca'], 4: ['zh', 'zh-TW', 'zh-CN', 'zh-HK', 'zh-SG'], 5: ['cs'],
+    6: ['da'], 7: ['de', 'de-DE', 'de-CH', 'de-AT', 'de-LU', 'de-LI'], 8: ['el'],
+    9: ['en', 'en-US', 'en-GB', 'en-AU', 'en-CA', 'en-NZ', 'en-IE', 'en-ZA',
+        'en-JM', null, 'en-BZ', 'en-TT', 'en-ZW', 'en-PH'],
+    10: ['es', 'es-ES', 'es-MX', null, 'es-GT', 'es-CR', 'es-PA', 'es-DO',
+        'es-VE', 'es-CO', 'es-PE', 'es-AR', 'es-EC', 'es-CL', 'es-UY', 'es-PY',
+        'es-BO', 'es-SV', 'es-HN', 'es-NI', 'es-PR'],
+    11: ['fi'], 12: ['fr', 'fr-FR', 'fr-BE', 'fr-CA', 'fr-CH', 'fr-LU', 'fr-MC'],
+    13: ['he'], 14: ['hu'], 15: ['is'], 16: ['it', 'it-IT', 'it-CH'],
+    17: ['ja'], 18: ['ko'], 19: ['nl', 'nl-NL', 'nl-BE'], 20: ['no', 'nb', 'nn'],
+    21: ['pl'], 22: ['pt', 'pt-BR', 'pt-PT'], 23: ['rm'], 24: ['ro'], 25: ['ru'],
+    26: ['hr', null, 'sr'], 27: ['sk'], 28: ['sq'], 29: ['sv', 'sv-SE', 'sv-FI'],
+    30: ['th'], 31: ['tr'], 32: ['ur'], 33: ['id'], 34: ['uk'], 35: ['be'],
+    36: ['sl'], 37: ['et'], 38: ['lv'], 39: ['lt'], 41: ['fa'], 42: ['vi'],
+    43: ['hy'], 44: ['az'], 45: ['eu'], 46: ['hsb'], 47: ['mk'], 48: ['st'],
+    49: ['ts'], 50: ['tn'], 52: ['xh'], 53: ['zu'], 54: ['af'], 55: ['ka'],
+    56: ['fo'], 57: ['hi'], 58: ['mt'], 59: ['se'], 62: ['ms'], 63: ['kk'],
+    65: ['sw'], 67: ['uz', null, 'uz-UZ'], 68: ['tt'], 69: ['bn'], 70: ['pa'],
+    71: ['gu'], 72: ['or'], 73: ['ta'], 74: ['te'], 75: ['kn'], 76: ['ml'],
+    77: ['as'], 78: ['mr'], 79: ['sa'], 82: ['cy', 'cy-GB'], 83: ['gl', 'gl-ES'],
+    87: ['kok'], 97: ['ne'], 98: ['fy'],
+}
+const concatTypedArray = (a, b) => {
+    const result = new a.constructor(a.length + b.length)
+    result.set(a)
+    result.set(b, a.length)
+    return result
+}
+const concatTypedArray3 = (a, b, c) => {
+    const result = new a.constructor(a.length + b.length + c.length)
+    result.set(a)
+    result.set(b, a.length)
+    result.set(c, a.length + b.length)
+    return result
+}
+const decoder = new TextDecoder()
+const getString = buffer => decoder.decode(buffer)
+const getUint = buffer => {
+    if (!buffer) return
+    const l = buffer.byteLength
+    const func = l === 4 ? 'getUint32' : l === 2 ? 'getUint16' : 'getUint8'
+    return new DataView(buffer)[func](0)
+}
+const getStruct = (def, buffer) => Object.fromEntries(Array.from(Object.entries(def))
+    .map(([key, [start, len, type]]) => [key,
+        (type === 'string' ? getString : getUint)(buffer.slice(start, start + len))]))
+const getDecoder = x => new TextDecoder(MOBI_ENCODING[x])
+const getVarLen = (byteArray, i = 0) => {
+    let value = 0, length = 0
+    for (const byte of byteArray.subarray(i, i + 4)) {
+        value = (value << 7) | (byte & 0b111_1111) >>> 0
+        length++
+        if (byte & 0b1000_0000) break
+    }
+    return { value, length }
+}
+// variable-length quantity, but read from the end of data
+const getVarLenFromEnd = byteArray => {
+    let value = 0
+    for (const byte of byteArray.subarray(-4)) {
+        // `byte & 0b1000_0000` indicates the start of value
+        if (byte & 0b1000_0000) value = 0
+        value = (value << 7) | (byte & 0b111_1111)
+    }
+    return value
+}
+const countBitsSet = x => {
+    let count = 0
+    for (; x > 0; x = x >> 1) if ((x & 1) === 1) count++
+    return count
+}
+const countUnsetEnd = x => {
+    let count = 0
+    while ((x & 1) === 0) x = x >> 1, count++
+    return count
+}
+const decompressPalmDOC = array => {
+    let output = []
+    for (let i = 0; i < array.length; i++) {
+        const byte = array[i]
+        if (byte === 0) output.push(0) // uncompressed literal, just copy it
+        else if (byte <= 8) // copy next 1-8 bytes
+            for (const x of array.subarray(i + 1, (i += byte) + 1))
+                output.push(x)
+        else if (byte <= 0b0111_1111) output.push(byte) // uncompressed literal
+        else if (byte <= 0b1011_1111) {
+            // 1st and 2nd bits are 10, meaning this is a length-distance pair
+            // read next byte and combine it with current byte
+            const bytes = (byte << 8) | array[i++ + 1]
+            // the 3rd to 13th bits encode distance
+            const distance = (bytes & 0b0011_1111_1111_1111) >>> 3
+            // the last 3 bits, plus 3, is the length to copy
+            const length = (bytes & 0b111) + 3
+            for (let j = 0; j < length; j++)
+                output.push(output[output.length - distance])
+        }
+        // compressed from space plus char
+        else output.push(32, byte ^ 0b1000_0000)
+    }
+    return Uint8Array.from(output)
+}
+const read32Bits = (byteArray, from) => {
+    const startByte = from >> 3
+    const end = from + 32
+    const endByte = end >> 3
+    let bits = 0n
+    for (let i = startByte; i <= endByte; i++)
+        bits = bits << 8n | BigInt(byteArray[i] ?? 0)
+    return (bits >> (8n - BigInt(end & 7))) & 0xffffffffn
+}
+const huffcdic = async (mobi, loadRecord) => {
+    const huffRecord = await loadRecord(mobi.huffcdic)
+    const { magic, offset1, offset2 } = getStruct(HUFF_HEADER, huffRecord)
+    if (magic !== 'HUFF') throw new Error('Invalid HUFF record')
+    // table1 is indexed by byte value
+    const table1 = Array.from({ length: 256 }, (_, i) => offset1 + i * 4)
+        .map(offset => getUint(huffRecord.slice(offset, offset + 4)))
+        .map(x => [x & 0b1000_0000, x & 0b1_1111, x >>> 8])
+    // table2 is indexed by code length
+    const table2 = [null].concat(Array.from({ length: 32 }, (_, i) => offset2 + i * 8)
+        .map(offset => [
+            getUint(huffRecord.slice(offset, offset + 4)),
+            getUint(huffRecord.slice(offset + 4, offset + 8))]))
+    const dictionary = []
+    for (let i = 1; i < mobi.numHuffcdic; i++) {
+        const record = await loadRecord(mobi.huffcdic + i)
+        const cdic = getStruct(CDIC_HEADER, record)
+        if (cdic.magic !== 'CDIC') throw new Error('Invalid CDIC record')
+        // `numEntries` is the total number of dictionary data across CDIC records
+        // so `n` here is the number of entries in *this* record
+        const n = Math.min(1 << cdic.codeLength, cdic.numEntries - dictionary.length)
+        const buffer = record.slice(cdic.length)
+        for (let i = 0; i < n; i++) {
+            const offset = getUint(buffer.slice(i * 2, i * 2 + 2))
+            const x = getUint(buffer.slice(offset, offset + 2))
+            const length = x & 0x7fff
+            const decompressed = x & 0x8000
+            const value = new Uint8Array(
+                buffer.slice(offset + 2, offset + 2 + length))
+            dictionary.push([value, decompressed])
+        }
+    }
+    const decompress = byteArray => {
+        let output = new Uint8Array()
+        const bitLength = byteArray.byteLength * 8
+        for (let i = 0; i < bitLength;) {
+            const bits = Number(read32Bits(byteArray, i))
+            let [found, codeLength, value] = table1[bits >>> 24]
+            if (!found) {
+                while (bits >>> (32 - codeLength) < table2[codeLength][0])
+                    codeLength += 1
+                value = table2[codeLength][1]
+            }
+            if ((i += codeLength) > bitLength) break
+            const code = value - (bits >>> (32 - codeLength))
+            let [result, decompressed] = dictionary[code]
+            if (!decompressed) {
+                // the result is itself compressed
+                result = decompress(result)
+                // cache the result for next time
+                dictionary[code] = [result, true]
+            }
+            output = concatTypedArray(output, result)
+        }
+        return output
+    }
+    return decompress
+}
+const getIndexData = async (indxIndex, loadRecord) => {
+    const indxRecord = await loadRecord(indxIndex)
+    const indx = getStruct(INDX_HEADER, indxRecord)
+    if (indx.magic !== 'INDX') throw new Error('Invalid INDX record')
+    const decoder = getDecoder(indx.encoding)
+    const tagxBuffer = indxRecord.slice(indx.length)
+    const tagx = getStruct(TAGX_HEADER, tagxBuffer)
+    if (tagx.magic !== 'TAGX') throw new Error('Invalid TAGX section')
+    const numTags = (tagx.length - 12) / 4
+    const tagTable = Array.from({ length: numTags }, (_, i) =>
+        new Uint8Array(tagxBuffer.slice(12 + i * 4, 12 + i * 4 + 4)))
+    const cncx = {}
+    let cncxRecordOffset = 0
+    for (let i = 0; i < indx.numCncx; i++) {
+        const record = await loadRecord(indxIndex + indx.numRecords + i + 1)
+        const array = new Uint8Array(record)
+        for (let pos = 0; pos < array.byteLength;) {
+            const index = pos
+            const { value, length } = getVarLen(array, pos)
+            pos += length
+            const result = record.slice(pos, pos + value)
+            pos += value
+            cncx[cncxRecordOffset + index] = decoder.decode(result)
+        }
+        cncxRecordOffset += 0x10000
+    }
+    const table = []
+    for (let i = 0; i < indx.numRecords; i++) {
+        const record = await loadRecord(indxIndex + 1 + i)
+        const array = new Uint8Array(record)
+        const indx = getStruct(INDX_HEADER, record)
+        if (indx.magic !== 'INDX') throw new Error('Invalid INDX record')
+        for (let j = 0; j < indx.numRecords; j++) {
+            const offsetOffset = indx.idxt + 4 + 2 * j
+            const offset = getUint(record.slice(offsetOffset, offsetOffset + 2))
+            const length = getUint(record.slice(offset, offset + 1))
+            const name = getString(record.slice(offset + 1, offset + 1 + length))
+            const tags = []
+            const startPos = offset + 1 + length
+            let controlByteIndex = 0
+            let pos = startPos + tagx.numControlBytes
+            for (const [tag, numValues, mask, end] of tagTable) {
+                if (end & 1) {
+                    controlByteIndex++
+                    continue
+                }
+                const offset = startPos + controlByteIndex
+                const value = getUint(record.slice(offset, offset + 1)) & mask
+                if (value === mask) {
+                    if (countBitsSet(mask) > 1) {
+                        const { value, length } = getVarLen(array, pos)
+                        tags.push([tag, null, value, numValues])
+                        pos += length
+                    } else tags.push([tag, 1, null, numValues])
+                } else tags.push([tag, value >> countUnsetEnd(mask), null, numValues])
+            }
+            const tagMap = {}
+            for (const [tag, valueCount, valueBytes, numValues] of tags) {
+                const values = []
+                if (valueCount != null) {
+                    for (let i = 0; i < valueCount * numValues; i++) {
+                        const { value, length } = getVarLen(array, pos)
+                        values.push(value)
+                        pos += length
+                    }
+                } else {
+                    let count = 0
+                    while (count < valueBytes) {
+                        const { value, length } = getVarLen(array, pos)
+                        values.push(value)
+                        pos += length
+                        count += length
+                    }
+                }
+                tagMap[tag] = values
+            }
+            table.push({ name, tagMap })
+        }
+    }
+    return { table, cncx }
+}
+const getNCX = async (indxIndex, loadRecord) => {
+    const { table, cncx } = await getIndexData(indxIndex, loadRecord)
+    const items = table.map(({ tagMap }, index) => ({
+        index,
+        offset: tagMap[1]?.[0],
+        size: tagMap[2]?.[0],
+        label: cncx[tagMap[3]] ?? '',
+        headingLevel: tagMap[4]?.[0],
+        pos: tagMap[6],
+        parent: tagMap[21]?.[0],
+        firstChild: tagMap[22]?.[0],
+        lastChild: tagMap[23]?.[0],
+    }))
+    const getChildren = item => {
+        if (item.firstChild == null) return item
+        item.children = items.filter(x => x.parent === item.index).map(getChildren)
+        return item
+    }
+    return items.filter(item => item.headingLevel === 0).map(getChildren)
+}
+const getEXTH = (buf, encoding) => {
+    const { magic, count } = getStruct(EXTH_HEADER, buf)
+    if (magic !== 'EXTH') throw new Error('Invalid EXTH header')
+    const decoder = getDecoder(encoding)
+    const results = {}
+    let offset = 12
+    for (let i = 0; i < count; i++) {
+        const type = getUint(buf.slice(offset, offset + 4))
+        const length = getUint(buf.slice(offset + 4, offset + 8))
+        if (type in EXTH_RECORD_TYPE) {
+            const [name, typ, many] = EXTH_RECORD_TYPE[type]
+            const data = buf.slice(offset + 8, offset + length)
+            const value = typ === 'uint' ? getUint(data) : decoder.decode(data)
+            if (many) {
+                results[name] ??= []
+                results[name].push(value)
+            } else results[name] = value
+        }
+        offset += length
+    }
+    return results
+}
+const getFont = async (buf, unzlib) => {
+    const { flags, dataStart, keyLength, keyStart } = getStruct(FONT_HEADER, buf)
+    const array = new Uint8Array(buf.slice(dataStart))
+    // deobfuscate font
+    if (flags & 0b10) {
+        const bytes = keyLength === 16 ? 1024 : 1040
+        const key = new Uint8Array(buf.slice(keyStart, keyStart + keyLength))
+        const length = Math.min(bytes, array.length)
+        for (var i = 0; i < length; i++) array[i] = array[i] ^ key[i % key.length]
+    }
+    // decompress font
+    if (flags & 1) try {
+        return await unzlib(array)
+    } catch (e) {
+        console.warn(e)
+        console.warn('Failed to decompress font')
+    }
+    return array
+}
+export const isMOBI = async file => {
+    const magic = getString(await file.slice(60, 68).arrayBuffer())
+    return magic === 'BOOKMOBI'// || magic === 'TEXtREAd'
+}
+class PDB {
+    #file
+    #offsets
+    pdb
+    async open(file) {
+        this.#file = file
+        const pdb = getStruct(PDB_HEADER, await file.slice(0, 78).arrayBuffer())
+        this.pdb = pdb
+        const buffer = await file.slice(78, 78 + pdb.numRecords * 8).arrayBuffer()
+        // get start and end offsets for each record
+        this.#offsets = Array.from({ length: pdb.numRecords },
+            (_, i) => getUint(buffer.slice(i * 8, i * 8 + 4)))
+            .map((x, i, a) => [x, a[i + 1]])
+    }
+    loadRecord(index) {
+        const offsets = this.#offsets[index]
+        if (!offsets) throw new RangeError('Record index out of bounds')
+        return this.#file.slice(...offsets).arrayBuffer()
+    }
+    async loadMagic(index) {
+        const start = this.#offsets[index][0]
+        return getString(await this.#file.slice(start, start + 4).arrayBuffer())
+    }
+}
+export class MOBI extends PDB {
+    #start = 0
+    #resourceStart
+    #decoder
+    #encoder
+    #decompress
+    #removeTrailingEntries
+    constructor({ unzlib }) {
+        super()
+        this.unzlib = unzlib
+    }
+    async open(file) {
+        await super.open(file)
+        // TODO: if (this.pdb.type === 'TEXt')
+        this.headers = this.#getHeaders(await super.loadRecord(0))
+        this.#resourceStart = this.headers.mobi.resourceStart
+        let isKF8 = this.headers.mobi.version >= 8
+        if (!isKF8) {
+            const boundary = this.headers.exth?.boundary
+            if (boundary < 0xffffffff) try {
+                // it's a "combo" MOBI/KF8 file; try to open the KF8 part
+                this.headers = this.#getHeaders(await super.loadRecord(boundary))
+                this.#start = boundary
+                isKF8 = true
+            } catch (e) {
+                console.warn(e)
+                console.warn('Failed to open KF8; falling back to MOBI')
+            }
+        }
+        await this.#setup()
+        return isKF8 ? new KF8(this).init() : new MOBI6(this).init()
+    }
+    #getHeaders(buf) {
+        const palmdoc = getStruct(PALMDOC_HEADER, buf)
+        const mobi = getStruct(MOBI_HEADER, buf)
+        if (mobi.magic !== 'MOBI') throw new Error('Missing MOBI header')
+        const { titleOffset, titleLength, localeLanguage, localeRegion } = mobi
+        mobi.title = buf.slice(titleOffset, titleOffset + titleLength)
+        const lang = MOBI_LANG[localeLanguage]
+        mobi.language = lang?.[localeRegion >> 2] ?? lang?.[0]
+        const exth = mobi.exthFlag & 0b100_0000
+            ? getEXTH(buf.slice(mobi.length + 16), mobi.encoding) : null
+        const kf8 = mobi.version >= 8 ? getStruct(KF8_HEADER, buf) : null
+        return { palmdoc, mobi, exth, kf8 }
+    }
+    async #setup() {
+        const { palmdoc, mobi } = this.headers
+        this.#decoder = getDecoder(mobi.encoding)
+        // `TextEncoder` only supports UTF-8
+        // we are only encoding ASCII anyway, so I think it's fine
+        this.#encoder = new TextEncoder()
+        // set up decompressor
+        const { compression } = palmdoc
+        this.#decompress = compression === 1 ? f => f
+            : compression === 2 ? decompressPalmDOC
+            : compression === 17480 ? await huffcdic(mobi, this.loadRecord.bind(this))
+            : null
+        if (!this.#decompress) throw new Error('Unknown compression type')
+        // set up function for removing trailing bytes
+        const { trailingFlags } = mobi
+        const multibyte = trailingFlags & 1
+        const numTrailingEntries = countBitsSet(trailingFlags >>> 1)
+        this.#removeTrailingEntries = array => {
+            for (let i = 0; i < numTrailingEntries; i++) {
+                const length = getVarLenFromEnd(array)
+                array = array.subarray(0, -length)
+            }
+            if (multibyte) {
+                const length = (array[array.length - 1] & 0b11) + 1
+                array = array.subarray(0, -length)
+            }
+            return array
+        }
+    }
+    decode(...args) {
+        return this.#decoder.decode(...args)
+    }
+    encode(...args) {
+        return this.#encoder.encode(...args)
+    }
+    loadRecord(index) {
+        return super.loadRecord(this.#start + index)
+    }
+    loadMagic(index) {
+        return super.loadMagic(this.#start + index)
+    }
+    loadText(index) {
+        return this.loadRecord(index + 1)
+            .then(buf => new Uint8Array(buf))
+            .then(this.#removeTrailingEntries)
+            .then(this.#decompress)
+    }
+    async loadResource(index) {
+        const buf = await super.loadRecord(this.#resourceStart + index)
+        const magic = getString(buf.slice(0, 4))
+        if (magic === 'FONT') return getFont(buf, this.unzlib)
+        if (magic === 'VIDE' || magic === 'AUDI') return buf.slice(12)
+        return buf
+    }
+    getNCX() {
+        const index = this.headers.mobi.indx
+        if (index < 0xffffffff) return getNCX(index, this.loadRecord.bind(this))
+    }
+    getMetadata() {
+        const { mobi, exth } = this.headers
+        return {
+            identifier: mobi.uid.toString(),
+            title: unescapeHTML(exth?.title || this.decode(mobi.title)),
+            author: exth?.creator?.map(unescapeHTML),
+            publisher: unescapeHTML(exth?.publisher),
+            language: exth?.language ?? mobi.language,
+            published: exth?.date,
+            description: unescapeHTML(exth?.description),
+            subject: exth?.subject?.map(unescapeHTML),
+            rights: unescapeHTML(exth?.rights),
+            contributor: exth?.contributor,
+        }
+    }
+    async getCover() {
+        const { exth } = this.headers
+        const offset = exth?.coverOffset < 0xffffffff ? exth?.coverOffset
+            : exth?.thumbnailOffset < 0xffffffff ? exth?.thumbnailOffset : null
+        if (offset != null) {
+            const buf = await this.loadResource(offset)
+            return new Blob([buf])
+        }
+    }
+}
+const mbpPagebreakRegex = /<\s*(?:mbp:)?pagebreak[^>]*>/gi
+const fileposRegex = /<[^<>]+filepos=['"]{0,1}(\d+)[^<>]*>/gi
+const getIndent = el => {
+    let x = 0
+    while (el) {
+        const parent = el.parentElement
+        if (parent) {
+            const tag = parent.tagName.toLowerCase()
+            if (tag === 'p') x += 1.5
+            else if (tag === 'blockquote') x += 2
+        }
+        el = parent
+    }
+    return x
+}
+function rawBytesToString(uint8Array) {
+    const chunkSize = 0x8000
+    let result = ''
+    for (let i = 0; i < uint8Array.length; i += chunkSize) {
+        result += String.fromCharCode.apply(null, uint8Array.subarray(i, i + chunkSize))
+    }
+    return result
+}
+class MOBI6 {
+    parser = new DOMParser()
+    serializer = new XMLSerializer()
+    #resourceCache = new Map()
+    #textCache = new Map()
+    #cache = new Map()
+    #sections
+    #fileposList = []
+    #type = MIME.HTML
+    constructor(mobi) {
+        this.mobi = mobi
+    }
+    async init() {
+        const recordBuffers = []
+        for (let i = 0; i < this.mobi.headers.palmdoc.numTextRecords; i++) {
+            const buf = await this.mobi.loadText(i)
+            recordBuffers.push(buf)
+        }
+        const totalLength = recordBuffers.reduce((sum, buf) => sum + buf.byteLength, 0)
+        // load all text records in an array
+        const array = new Uint8Array(totalLength)
+        recordBuffers.reduce((offset, buf) => {
+            array.set(new Uint8Array(buf), offset)
+            return offset + buf.byteLength
+        }, 0)
+        // convert to string so we can use regex
+        // note that `filepos` are byte offsets
+        // so it needs to preserve each byte as a separate character
+        // (see https://stackoverflow.com/q/50198017)
+        const str = rawBytesToString(array)
+        // split content into sections at each `<mbp:pagebreak>`
+        this.#sections = [0]
+            .concat(Array.from(str.matchAll(mbpPagebreakRegex), m => m.index))
+            .map((start, i, a) => {
+                const end = a[i + 1] ?? array.length
+                return { book: this, raw: array.subarray(start, end) }
+            })
+            // get start and end filepos for each section
+            .map((section, i, arr) => {
+                section.start = arr[i - 1]?.end ?? 0
+                section.end = section.start + section.raw.byteLength
+                return section
+            })
+        this.sections = this.#sections.map((section, index) => ({
+            id: index,
+            load: () => this.loadSection(section),
+            createDocument: () => this.createDocument(section),
+            size: section.end - section.start,
+        }))
+        try {
+            this.landmarks = await this.getGuide()
+            const tocHref = this.landmarks
+                .find(({ type }) => type?.includes('toc'))?.href
+            if (tocHref) {
+                const { index } = this.resolveHref(tocHref)
+                const doc = await this.sections[index].createDocument()
+                let lastItem
+                let lastLevel = 0
+                let lastIndent = 0
+                const lastLevelOfIndent = new Map()
+                const lastParentOfLevel = new Map()
+                this.toc = Array.from(doc.querySelectorAll('a[filepos]'))
+                    .reduce((arr, a) => {
+                        const indent = getIndent(a)
+                        const item = {
+                            label: a.innerText?.trim() ?? '',
+                            href: `filepos:${a.getAttribute('filepos')}`,
+                        }
+                        const level = indent > lastIndent ? lastLevel + 1
+                            : indent === lastIndent ? lastLevel
+                            : lastLevelOfIndent.get(indent) ?? Math.max(0, lastLevel - 1)
+                        if (level > lastLevel) {
+                            if (lastItem) {
+                                lastItem.subitems ??= []
+                                lastItem.subitems.push(item)
+                                lastParentOfLevel.set(level, lastItem)
+                            }
+                            else arr.push(item)
+                        }
+                        else {
+                            const parent = lastParentOfLevel.get(level)
+                            if (parent) parent.subitems.push(item)
+                            else arr.push(item)
+                        }
+                        lastItem = item
+                        lastLevel = level
+                        lastIndent = indent
+                        lastLevelOfIndent.set(indent, level)
+                        return arr
+                    }, [])
+            }
+        } catch(e) {
+            console.warn(e)
+        }
+        // get list of all `filepos` references in the book,
+        // which will be used to insert anchor elements
+        // because only then can they be referenced in the DOM
+        this.#fileposList = [...new Set(
+            Array.from(str.matchAll(fileposRegex), m => m[1]))]
+            .map(filepos => ({ filepos, number: Number(filepos) }))
+            .sort((a, b) => a.number - b.number)
+        this.metadata = this.mobi.getMetadata()
+        this.getCover = this.mobi.getCover.bind(this.mobi)
+        return this
+    }
+    async getGuide() {
+        const doc = await this.createDocument(this.#sections[0])
+        return Array.from(doc.getElementsByTagName('reference'), ref => ({
+            label: ref.getAttribute('title'),
+            type: ref.getAttribute('type')?.split(/\s/),
+            href: `filepos:${ref.getAttribute('filepos')}`,
+        }))
+    }
+    async loadResource(index) {
+        if (this.#resourceCache.has(index)) return this.#resourceCache.get(index)
+        const raw = await this.mobi.loadResource(index)
+        const url = URL.createObjectURL(new Blob([raw]))
+        this.#resourceCache.set(index, url)
+        return url
+    }
+    async loadRecindex(recindex) {
+        return this.loadResource(Number(recindex) - 1)
+    }
+    async replaceResources(doc) {
+        for (const img of doc.querySelectorAll('img[recindex]')) {
+            const recindex = img.getAttribute('recindex')
+            try {
+                img.src = await this.loadRecindex(recindex)
+            } catch {
+                console.warn(`Failed to load image ${recindex}`)
+            }
+        }
+        for (const media of doc.querySelectorAll('[mediarecindex]')) {
+            const mediarecindex = media.getAttribute('mediarecindex')
+            const recindex = media.getAttribute('recindex')
+            try {
+                media.src = await this.loadRecindex(mediarecindex)
+                if (recindex) media.poster = await this.loadRecindex(recindex)
+            } catch {
+                console.warn(`Failed to load media ${mediarecindex}`)
+            }
+        }
+        for (const a of doc.querySelectorAll('[filepos]')) {
+            const filepos = a.getAttribute('filepos')
+            a.href = `filepos:${filepos}`
+        }
+    }
+    async loadText(section) {
+        if (this.#textCache.has(section)) return this.#textCache.get(section)
+        const { raw } = section
+        // insert anchor elements for each `filepos`
+        const fileposList = this.#fileposList
+            .filter(({ number }) => number >= section.start && number < section.end)
+            .map(obj => ({ ...obj, offset: obj.number - section.start }))
+        let arr = raw
+        if (fileposList.length) {
+            arr = raw.subarray(0, fileposList[0].offset)
+            fileposList.forEach(({ filepos, offset }, i) => {
+                const next = fileposList[i + 1]
+                const a = this.mobi.encode(`<a id="filepos${filepos}"></a>`)
+                arr = concatTypedArray3(arr, a, raw.subarray(offset, next?.offset))
+            })
+        }
+        const str = this.mobi.decode(arr).replaceAll(mbpPagebreakRegex, '')
+        this.#textCache.set(section, str)
+        return str
+    }
+    async createDocument(section) {
+        const str = await this.loadText(section)
+        return this.parser.parseFromString(str, this.#type)
+    }
+    async loadSection(section) {
+        if (this.#cache.has(section)) return this.#cache.get(section)
+        const doc = await this.createDocument(section)
+        // inject default stylesheet
+        const style = doc.createElement('style')
+        doc.head.append(style)
+        // blockquotes in MOBI seem to have only a small left margin by default
+        // many books seem to rely on this, as it's the only way to set margin
+        // (since there's no CSS)
+        style.append(doc.createTextNode(`blockquote {
+            margin-block-start: 0;
+            margin-block-end: 0;
+            margin-inline-start: 1em;
+            margin-inline-end: 0;
+        }`))
+        await this.replaceResources(doc)
+        const result = this.serializer.serializeToString(doc)
+        const url = URL.createObjectURL(new Blob([result], { type: this.#type }))
+        this.#cache.set(section, url)
+        return url
+    }
+    resolveHref(href) {
+        const filepos = href.match(/filepos:(.*)/)[1]
+        const number = Number(filepos)
+        const index = this.#sections.findIndex(section => section.end > number)
+        const anchor = doc => doc.getElementById(`filepos${filepos}`)
+        return { index, anchor }
+    }
+    splitTOCHref(href) {
+        const filepos = href.match(/filepos:(.*)/)[1]
+        const number = Number(filepos)
+        const index = this.#sections.findIndex(section => section.end > number)
+        return [index, `filepos${filepos}`]
+    }
+    getTOCFragment(doc, id) {
+        return doc.getElementById(id)
+    }
+    isExternal(uri) {
+        return /^(?!blob|filepos)\w+:/i.test(uri)
+    }
+    destroy() {
+        for (const url of this.#resourceCache.values()) URL.revokeObjectURL(url)
+        for (const url of this.#cache.values()) URL.revokeObjectURL(url)
+    }
+}
+// handlers for `kindle:` uris
+const kindleResourceRegex = /kindle:(flow|embed):(\w+)(?:\?mime=(\w+\/[-+.\w]+))?/
+const kindlePosRegex = /kindle:pos:fid:(\w+):off:(\w+)/
+const parseResourceURI = str => {
+    const [resourceType, id, type] = str.match(kindleResourceRegex).slice(1)
+    return { resourceType, id: parseInt(id, 32), type }
+}
+const parsePosURI = str => {
+    const [fid, off] = str.match(kindlePosRegex).slice(1)
+    return { fid: parseInt(fid, 32), off: parseInt(off, 32) }
+}
+const makePosURI = (fid = 0, off = 0) =>
+    `kindle:pos:fid:${fid.toString(32).toUpperCase().padStart(4, '0')
+    }:off:${off.toString(32).toUpperCase().padStart(10, '0')}`
+// `kindle:pos:` links are originally links that contain fragments identifiers
+// so there should exist an element with `id` or `name`
+// otherwise try to find one with an `aid` attribute
+const getFragmentSelector = str => {
+    const match = str.match(/\s(id|name|aid)\s*=\s*['"]([^'"]*)['"]/i)
+    if (!match) return
+    const [, attr, value] = match
+    return `[${attr}="${CSS.escape(value)}"]`
+}
+// replace asynchronously and sequentially
+const replaceSeries = async (str, regex, f) => {
+    const matches = []
+    str.replace(regex, (...args) => (matches.push(args), null))
+    const results = []
+    for (const args of matches) results.push(await f(...args))
+    return str.replace(regex, () => results.shift())
+}
+const getPageSpread = properties => {
+    for (const p of properties) {
+        if (p === 'page-spread-left' || p === 'rendition:page-spread-left')
+            return 'left'
+        if (p === 'page-spread-right' || p === 'rendition:page-spread-right')
+            return 'right'
+        if (p === 'rendition:page-spread-center') return 'center'
+    }
+}
+class KF8 {
+    parser = new DOMParser()
+    serializer = new XMLSerializer()
+    transformTarget = new EventTarget()
+    #cache = new Map()
+    #fragmentOffsets = new Map()
+    #fragmentSelectors = new Map()
+    #tables = {}
+    #sections
+    #fullRawLength
+    #rawHead = new Uint8Array()
+    #rawTail = new Uint8Array()
+    #lastLoadedHead = -1
+    #lastLoadedTail = -1
+    #type = MIME.XHTML
+    #inlineMap = new Map()
+    constructor(mobi) {
+        this.mobi = mobi
+    }
+    async init() {
+        const loadRecord = this.mobi.loadRecord.bind(this.mobi)
+        const { kf8 } = this.mobi.headers
+        try {
+            const fdstBuffer = await loadRecord(kf8.fdst)
+            const fdst = getStruct(FDST_HEADER, fdstBuffer)
+            if (fdst.magic !== 'FDST') throw new Error('Missing FDST record')
+            const fdstTable = Array.from({ length: fdst.numEntries },
+                (_, i) => 12 + i * 8)
+                .map(offset => [
+                    getUint(fdstBuffer.slice(offset, offset + 4)),
+                    getUint(fdstBuffer.slice(offset + 4, offset + 8))])
+            this.#tables.fdstTable = fdstTable
+            this.#fullRawLength = fdstTable[fdstTable.length - 1][1]
+        } catch {}
+        const skelTable = (await getIndexData(kf8.skel, loadRecord)).table
+            .map(({ name, tagMap }, index) => ({
+                index, name,
+                numFrag: tagMap[1][0],
+                offset: tagMap[6][0],
+                length: tagMap[6][1],
+            }))
+        const fragData = await getIndexData(kf8.frag, loadRecord)
+        const fragTable = fragData.table.map(({ name, tagMap }) => ({
+            insertOffset: parseInt(name),
+            selector: fragData.cncx[tagMap[2][0]],
+            index: tagMap[4][0],
+            offset: tagMap[6][0],
+            length: tagMap[6][1],
+        }))
+        this.#tables.skelTable = skelTable
+        this.#tables.fragTable = fragTable
+        this.#sections = skelTable.reduce((arr, skel) => {
+            const last = arr[arr.length - 1]
+            const fragStart = last?.fragEnd ?? 0, fragEnd = fragStart + skel.numFrag
+            const frags = fragTable.slice(fragStart, fragEnd)
+            const length = skel.length + frags.map(f => f.length).reduce((a, b) => a + b, 0)
+            const totalLength = (last?.totalLength ?? 0) + length
+            return arr.concat({ skel, frags, fragEnd, length, totalLength })
+        }, [])
+        const resources = await this.getResourcesByMagic(['RESC', 'PAGE'])
+        const pageSpreads = new Map()
+        if (resources.RESC) {
+            const buf = await this.mobi.loadRecord(resources.RESC)
+            const str = this.mobi.decode(buf.slice(16)).replace(/\0/g, '')
+            // the RESC record lacks the root `<package>` element
+            // but seem to be otherwise valid XML
+            const index = str.search(/\?>/)
+            const xmlStr = `<package>${str.slice(index)}</package>`
+            const opf = this.parser.parseFromString(xmlStr, MIME.XML)
+            for (const $itemref of opf.querySelectorAll('spine > itemref')) {
+                const i = parseInt($itemref.getAttribute('skelid'))
+                pageSpreads.set(i, getPageSpread(
+                    $itemref.getAttribute('properties')?.split(' ') ?? []))
+            }
+        }
+        this.sections = this.#sections.map((section, index) =>
+            section.frags.length ? ({
+                id: index,
+                load: () => this.loadSection(section),
+                createDocument: () => this.createDocument(section),
+                size: section.length,
+                pageSpread: pageSpreads.get(index),
+            }) : ({ linear: 'no' }))
+        try {
+            const ncx = await this.mobi.getNCX()
+            const map = ({ label, pos, children }) => {
+                const [fid, off] = pos
+                const href = makePosURI(fid, off)
+                const arr = this.#fragmentOffsets.get(fid)
+                if (arr) arr.push(off)
+                else this.#fragmentOffsets.set(fid, [off])
+                return { label: unescapeHTML(label), href, subitems: children?.map(map) }
+            }
+            this.toc = ncx?.map(map)
+            this.landmarks = await this.getGuide()
+        } catch(e) {
+            console.warn(e)
+        }
+        const { exth } = this.mobi.headers
+        this.dir = exth.pageProgressionDirection
+        this.rendition = {
+            layout: exth.fixedLayout === 'true' ? 'pre-paginated' : 'reflowable',
+            viewport: Object.fromEntries(exth.originalResolution
+                ?.split('x')?.slice(0, 2)
+                ?.map((x, i) => [i ? 'height' : 'width', x]) ?? []),
+        }
+        this.metadata = this.mobi.getMetadata()
+        this.getCover = this.mobi.getCover.bind(this.mobi)
+        return this
+    }
+    // is this really the only way of getting to RESC, PAGE, etc.?
+    async getResourcesByMagic(keys) {
+        const results = {}
+        const start = this.mobi.headers.kf8.resourceStart
+        const end = this.mobi.pdb.numRecords
+        for (let i = start; i < end; i++) {
+            try {
+                const magic = await this.mobi.loadMagic(i)
+                const match = keys.find(key => key === magic)
+                if (match) results[match] = i
+            } catch {}
+        }
+        return results
+    }
+    async getGuide() {
+        const index = this.mobi.headers.kf8.guide
+        if (index < 0xffffffff) {
+            const loadRecord = this.mobi.loadRecord.bind(this.mobi)
+            const { table, cncx } = await getIndexData(index, loadRecord)
+            return table.map(({ name, tagMap }) => ({
+                label: cncx[tagMap[1][0]] ?? '',
+                type: name?.split(/\s/),
+                href: makePosURI(tagMap[6]?.[0] ?? tagMap[3]?.[0]),
+            }))
+        }
+    }
+    async loadResourceBlob(str) {
+        const { resourceType, id, type } = parseResourceURI(str)
+        const raw = resourceType === 'flow' ? await this.loadFlow(id)
+            : await this.mobi.loadResource(id - 1)
+        const result = [MIME.XHTML, MIME.HTML, MIME.CSS, MIME.SVG].includes(type)
+            ? await this.replaceResources(this.mobi.decode(raw)) : raw
+        const detail = { data: result, type }
+        const event = new CustomEvent('data', { detail })
+        this.transformTarget.dispatchEvent(event)
+        const newData = await event.detail.data
+        const newType = await event.detail.type
+        const doc = newType === MIME.SVG ? this.parser.parseFromString(newData, newType) : null
+        return [new Blob([newData], { newType }),
+            // SVG wrappers need to be inlined
+            // as browsers don't allow external resources when loading SVG as an image
+            doc?.getElementsByTagNameNS('http://www.w3.org/2000/svg', 'image')?.length
+                ? doc.documentElement : null]
+    }
+    async loadResource(str) {
+        if (this.#cache.has(str)) return this.#cache.get(str)
+        const [blob, inline] = await this.loadResourceBlob(str)
+        const url = inline ? str : URL.createObjectURL(blob)
+        if (inline) this.#inlineMap.set(url, inline)
+        this.#cache.set(str, url)
+        return url
+    }
+    replaceResources(str) {
+        const regex = new RegExp(kindleResourceRegex, 'g')
+        return replaceSeries(str, regex, this.loadResource.bind(this))
+    }
+    // NOTE: there doesn't seem to be a way to access text randomly?
+    // how to know the decompressed size of the records without decompressing?
+    // 4096 is just the maximum size
+    async loadRaw(start, end) {
+        // here we load either from the front or back until we have reached the
+        // required offsets; at worst you'd have to load half the book at once
+        const distanceHead = end - this.#rawHead.length
+        const distanceEnd = this.#fullRawLength == null ? Infinity
+            : (this.#fullRawLength - this.#rawTail.length) - start
+        // load from the start
+        if (distanceHead < 0 || distanceHead < distanceEnd) {
+            while (this.#rawHead.length < end) {
+                const index = ++this.#lastLoadedHead
+                const data = await this.mobi.loadText(index)
+                this.#rawHead = concatTypedArray(this.#rawHead, data)
+            }
+            return this.#rawHead.slice(start, end)
+        }
+        // load from the end
+        while (this.#fullRawLength - this.#rawTail.length > start) {
+            const index = this.mobi.headers.palmdoc.numTextRecords - 1
+                - (++this.#lastLoadedTail)
+            const data = await this.mobi.loadText(index)
+            this.#rawTail = concatTypedArray(data, this.#rawTail)
+        }
+        const rawTailStart = this.#fullRawLength - this.#rawTail.length
+        return this.#rawTail.slice(start - rawTailStart, end - rawTailStart)
+    }
+    loadFlow(index) {
+        if (index < 0xffffffff)
+            return this.loadRaw(...this.#tables.fdstTable[index])
+    }
+    async loadText(section) {
+        const { skel, frags, length } = section
+        const raw = await this.loadRaw(skel.offset, skel.offset + length)
+        let skeleton = raw.slice(0, skel.length)
+        for (const frag of frags) {
+            const insertOffset = frag.insertOffset - skel.offset
+            const offset = skel.length + frag.offset
+            const fragRaw = raw.slice(offset, offset + frag.length)
+            skeleton = concatTypedArray3(
+                skeleton.slice(0, insertOffset), fragRaw,
+                skeleton.slice(insertOffset))
+            const offsets = this.#fragmentOffsets.get(frag.index)
+            if (offsets) for (const offset of offsets) {
+                const str = this.mobi.decode(fragRaw.slice(offset))
+                const selector = getFragmentSelector(str)
+                this.#setFragmentSelector(frag.index, offset, selector)
+            }
+        }
+        return this.mobi.decode(skeleton)
+    }
+    async createDocument(section) {
+        const str = await this.loadText(section)
+        return this.parser.parseFromString(str, this.#type)
+    }
+    async loadSection(section) {
+        if (this.#cache.has(section)) return this.#cache.get(section)
+        const str = await this.loadText(section)
+        const replaced = await this.replaceResources(str)
+        // by default, type is XHTML; change to HTML if it's not valid XHTML
+        let doc = this.parser.parseFromString(replaced, this.#type)
+        if (doc.querySelector('parsererror') || !doc.documentElement?.namespaceURI) {
+            this.#type = MIME.HTML
+            doc = this.parser.parseFromString(replaced, this.#type)
+        }
+        for (const [url, node] of this.#inlineMap) {
+            for (const el of doc.querySelectorAll(`img[src="${url}"]`))
+                el.replaceWith(node)
+        }
+        const url = URL.createObjectURL(
+            new Blob([this.serializer.serializeToString(doc)], { type: this.#type }))
+        this.#cache.set(section, url)
+        return url
+    }
+    getIndexByFID(fid) {
+        return this.#sections.findIndex(section =>
+            section.frags.some(frag => frag.index === fid))
+    }
+    #setFragmentSelector(id, offset, selector) {
+        const map = this.#fragmentSelectors.get(id)
+        if (map) map.set(offset, selector)
+        else {
+            const map = new Map()
+            this.#fragmentSelectors.set(id, map)
+            map.set(offset, selector)
+        }
+    }
+    async resolveHref(href) {
+        const { fid, off } = parsePosURI(href)
+        const index = this.getIndexByFID(fid)
+        if (index < 0) return
+        const saved = this.#fragmentSelectors.get(fid)?.get(off)
+        if (saved) return { index, anchor: doc => doc.querySelector(saved) }
+        const { skel, frags } = this.#sections[index]
+        const frag = frags.find(frag => frag.index === fid)
+        const offset = skel.offset + skel.length + frag.offset
+        const fragRaw = await this.loadRaw(offset, offset + frag.length)
+        const str = this.mobi.decode(fragRaw.slice(off))
+        const selector = getFragmentSelector(str)
+        this.#setFragmentSelector(fid, off, selector)
+        const anchor = doc => doc.querySelector(selector)
+        return { index, anchor }
+    }
+    splitTOCHref(href) {
+        const pos = parsePosURI(href)
+        const index = this.getIndexByFID(pos.fid)
+        return [index, pos]
+    }
+    getTOCFragment(doc, { fid, off }) {
+        const selector = this.#fragmentSelectors.get(fid)?.get(off)
+        return doc.querySelector(selector)
+    }
+    isExternal(uri) {
+        return /^(?!blob|kindle)\w+:/i.test(uri)
+    }
+    destroy() {
+        for (const url of this.#cache.values()) URL.revokeObjectURL(url)
+    }
+}

packages/foliate-js/opds.js ADDED Viewed

	@@ -0,0 +1,294 @@

+const NS = {
+    ATOM: 'http://www.w3.org/2005/Atom',
+    OPDS: 'http://opds-spec.org/2010/catalog',
+    THR: 'http://purl.org/syndication/thread/1.0',
+    DC: 'http://purl.org/dc/elements/1.1/',
+    DCTERMS: 'http://purl.org/dc/terms/',
+}
+const MIME = {
+    ATOM: 'application/atom+xml',
+    OPDS2: 'application/opds+json',
+}
+export const REL = {
+    ACQ: 'http://opds-spec.org/acquisition',
+    FACET: 'http://opds-spec.org/facet',
+    GROUP: 'http://opds-spec.org/group',
+    COVER: [
+        'http://opds-spec.org/image',
+        'http://opds-spec.org/cover',
+    ],
+    THUMBNAIL: [
+        'http://opds-spec.org/image/thumbnail',
+        'http://opds-spec.org/thumbnail',
+    ],
+}
+export const SYMBOL = {
+    SUMMARY: Symbol('summary'),
+    CONTENT: Symbol('content'),
+}
+const FACET_GROUP = Symbol('facetGroup')
+const groupByArray = (arr, f) => {
+    const map = new Map()
+    if (arr) for (const el of arr) {
+        const keys = f(el)
+        for (const key of [keys].flat()) {
+            const group = map.get(key)
+            if (group) group.push(el)
+            else map.set(key, [el])
+        }
+    }
+    return map
+}
+// https://www.rfc-editor.org/rfc/rfc7231#section-3.1.1
+const parseMediaType = str => {
+    if (!str) return null
+    const [mediaType, ...ps] = str.split(/ *; */)
+    return {
+        mediaType: mediaType.toLowerCase(),
+        parameters: Object.fromEntries(ps.map(p => {
+            const [name, val] = p.split('=')
+            return [name.toLowerCase(), val?.replace(/(^"|"$)/g, '')]
+        })),
+    }
+}
+export const isOPDSCatalog = str => {
+    const parsed = parseMediaType(str)
+    if (!parsed) return false
+    const { mediaType, parameters } = parsed
+    if (mediaType === MIME.OPDS2) return true
+    return mediaType === MIME.ATOM && parameters.profile?.toLowerCase() === 'opds-catalog'
+}
+export const isOPDSSearch = str => {
+    const parsed = parseMediaType(str)
+    if (!parsed) return false
+    const { mediaType } = parsed
+    return mediaType === MIME.ATOM
+}
+// ignore the namespace if it doesn't appear in document at all
+const useNS = (doc, ns) =>
+    doc.lookupNamespaceURI(null) === ns || doc.lookupPrefix(ns) ? ns : null
+const filterNS = ns => ns
+    ? name => el => el.namespaceURI === ns && el.localName === name
+    : name => el => el.localName === name
+const getContent = el => {
+    if (!el) return
+    const type = el.getAttribute('type') ?? 'text'
+    const value = type === 'xhtml' ? el.innerHTML
+        : type === 'html' ? el.textContent
+            .replaceAll('&lt;', '<')
+            .replaceAll('&gt;', '>')
+            .replaceAll('&amp;', '&')
+        : el.textContent
+    return { value, type }
+}
+const getTextContent = el => {
+    const content = getContent(el)
+    if (content?.type === 'text') return content?.value
+}
+const getSummary = (a, b) => getTextContent(a) ?? getTextContent(b)
+const getPrice = link => {
+    const price = link.getElementsByTagNameNS(NS.OPDS, 'price')[0]
+    return price ? {
+        currency: price.getAttribute('currencycode'),
+        value: price.textContent,
+    } : null
+}
+const getIndirectAcquisition = el => {
+    const ia = el.getElementsByTagNameNS(NS.OPDS, 'indirectAcquisition')[0]
+    if (!ia) return []
+    return [{ type: ia.getAttribute('type') }, ...getIndirectAcquisition(ia)]
+}
+const getLink = link => {
+    const obj = {
+        rel: link.getAttribute('rel')?.split(/ +/),
+        href: link.getAttribute('href'),
+        type: link.getAttribute('type'),
+        title: link.getAttribute('title'),
+        properties: {
+            price: getPrice(link),
+            indirectAcquisition: getIndirectAcquisition(link),
+            numberOfItems: link.getAttributeNS(NS.THR, 'count'),
+        },
+        [FACET_GROUP]: link.getAttributeNS(NS.OPDS, 'facetGroup'),
+    }
+    if (link.getAttributeNS(NS.OPDS, 'activeFacet') === 'true')
+        obj.rel = [obj.rel ?? []].flat().concat('self')
+    return obj
+}
+const getPerson = person => {
+    const NS = person.namespaceURI
+    const uri = person.getElementsByTagNameNS(NS, 'uri')[0]?.textContent
+    return {
+        name: person.getElementsByTagNameNS(NS, 'name')[0]?.textContent ?? '',
+        links: uri ? [{ href: uri }] : [],
+    }
+}
+export const getPublication = entry => {
+    const filter = filterNS(useNS(entry.ownerDocument, NS.ATOM))
+    const children = Array.from(entry.children)
+    const filterDCEL = filterNS(NS.DC)
+    const filterDCTERMS = filterNS(NS.DCTERMS)
+    const filterDC = x => {
+        const a = filterDCEL(x), b = filterDCTERMS(x)
+        return y => a(y) || b(y)
+    }
+    const links = children.filter(filter('link')).map(getLink)
+    const linksByRel = groupByArray(links, link => link.rel)
+    return {
+        metadata: {
+            title: children.find(filter('title'))?.textContent ?? '',
+            author: children.filter(filter('author')).map(getPerson),
+            contributor: children.filter(filter('contributor')).map(getPerson),
+            publisher: children.find(filterDC('publisher'))?.textContent,
+            published: (children.find(filterDCTERMS('issued'))
+                ?? children.find(filterDC('date')))?.textContent,
+            language: children.find(filterDC('language'))?.textContent,
+            identifier: children.find(filterDC('identifier'))?.textContent,
+            subject: children.filter(filter('category')).map(category => ({
+                name: category.getAttribute('label'),
+                code: category.getAttribute('term'),
+                scheme: category.getAttribute('scheme'),
+            })),
+            rights: children.find(filter('rights'))?.textContent ?? '',
+            [SYMBOL.CONTENT]: getContent(children.find(filter('content'))
+                ?? children.find(filter('summary'))),
+        },
+        links,
+        images: REL.COVER.concat(REL.THUMBNAIL)
+            .map(R => linksByRel.get(R)?.[0]).filter(x => x),
+    }
+}
+export const getFeed = doc => {
+    const ns = useNS(doc, NS.ATOM)
+    const filter = filterNS(ns)
+    const children = Array.from(doc.documentElement.children)
+    const entries = children.filter(filter('entry'))
+    const links = children.filter(filter('link')).map(getLink)
+    const linksByRel = groupByArray(links, link => link.rel)
+    const groupedItems = new Map([[null, []]])
+    const groupLinkMap = new Map()
+    for (const entry of entries) {
+        const children = Array.from(entry.children)
+        const links = children.filter(filter('link')).map(getLink)
+        const linksByRel = groupByArray(links, link => link.rel)
+        const isPub = [...linksByRel.keys()]
+            .some(rel => rel?.startsWith(REL.ACQ) || rel === 'preview')
+        const groupLinks = linksByRel.get(REL.GROUP) ?? linksByRel.get('collection')
+        const groupLink = groupLinks?.length
+            ? groupLinks.find(link => groupedItems.has(link.href)) ?? groupLinks[0] : null
+        if (groupLink && !groupLinkMap.has(groupLink.href))
+            groupLinkMap.set(groupLink.href, groupLink)
+        const item = isPub
+            ? getPublication(entry)
+            : Object.assign(links.find(link => isOPDSCatalog(link.type)) ?? links[0] ?? {}, {
+                title: children.find(filter('title'))?.textContent,
+                [SYMBOL.SUMMARY]: getSummary(children.find(filter('summary')),
+                    children.find(filter('content'))),
+            })
+        const arr = groupedItems.get(groupLink?.href ?? null)
+        if (arr) arr.push(item)
+        else groupedItems.set(groupLink.href, [item])
+    }
+    const [items, ...groups] = Array.from(groupedItems, ([key, items]) => {
+        const itemsKey = items[0]?.metadata ? 'publications' : 'navigation'
+        if (key == null) return { [itemsKey]: items }
+        const link = groupLinkMap.get(key)
+        return {
+            metadata: {
+                title: link.title,
+                numberOfItems: link.properties.numberOfItems,
+            },
+            links: [{ rel: 'self', href: link.href, type: link.type }],
+            [itemsKey]: items,
+        }
+    })
+    return {
+        metadata: {
+            title: children.find(filter('title'))?.textContent,
+            subtitle: children.find(filter('subtitle'))?.textContent,
+        },
+        links,
+        ...items,
+        groups,
+        facets: Array.from(
+            groupByArray(linksByRel.get(REL.FACET) ?? [], link => link[FACET_GROUP]),
+            ([facet, links]) => ({ metadata: { title: facet }, links })),
+    }
+}
+export const getSearch = async link => {
+    const { replace, getVariables } = await import('./uri-template.js')
+    return {
+        metadata: {
+            title: link.title,
+        },
+        search: map => replace(link.href, map.get(null)),
+        params: Array.from(getVariables(link.href), name => ({ name })),
+    }
+}
+export const getOpenSearch = doc => {
+    const defaultNS = doc.documentElement.namespaceURI
+    const filter = filterNS(defaultNS)
+    const children = Array.from(doc.documentElement.children)
+    const $$urls = children.filter(filter('Url'))
+    const $url = $$urls.find(url => isOPDSCatalog(url.getAttribute('type'))) ?? $$urls.find(url => isOPDSSearch(url.getAttribute('type'))) ?? $$urls[0]
+    if (!$url) throw new Error('document must contain at least one Url element')
+    const regex = /{(?:([^}]+?):)?(.+?)(\?)?}/g
+    const defaultMap = new Map([
+        ['count', '100'],
+        ['startIndex', $url.getAttribute('indexOffset') ?? '0'],
+        ['startPage', $url.getAttribute('pageOffset') ?? '0'],
+        ['language', '*'],
+        ['inputEncoding', 'UTF-8'],
+        ['outputEncoding', 'UTF-8'],
+    ])
+    const template = $url.getAttribute('template')
+    return {
+        metadata: {
+            title: (children.find(filter('LongName')) ?? children.find(filter('ShortName')))?.textContent,
+            description: children.find(filter('Description'))?.textContent,
+        },
+        search: map => template.replace(regex, (_, prefix, param) => {
+            const namespace = prefix ? $url.lookupNamespaceURI(prefix) : null
+            const ns = namespace === defaultNS ? null : namespace
+            const val = map.get(ns)?.get(param)
+            return encodeURIComponent(val ? val : (!ns ? defaultMap.get(param) ?? '' : ''))
+        }),
+        params: Array.from(template.matchAll(regex), ([, prefix, param, optional]) => {
+            const namespace = prefix ? $url.lookupNamespaceURI(prefix) : null
+            const ns = namespace === defaultNS ? null : namespace
+            return {
+                ns, name: param,
+                required: !optional,
+                value: ns && ns !== defaultNS ? '' : defaultMap.get(param) ?? '',
+            }
+        }),
+    }
+}

packages/foliate-js/overlayer.js ADDED Viewed

	@@ -0,0 +1,409 @@

+const createSVGElement = tag =>
+    document.createElementNS('http://www.w3.org/2000/svg', tag)
+export class Overlayer {
+    #svg = createSVGElement('svg')
+    #map = new Map()
+    #doc = null
+    #clipPath = null
+    #clipPathPath = null
+    constructor(doc) {
+        this.#doc = doc
+        Object.assign(this.#svg.style, {
+            position: 'absolute', top: '0', left: '0',
+            width: '100%', height: '100%',
+            pointerEvents: 'none',
+        })
+        // Create a clipPath to cut a hole for the loupe.
+        // We use clip-rule="evenodd" with a large outer rect and inner circle
+        // to create the hole effect efficiently without mask compositing.
+        const defs = createSVGElement('defs')
+        this.#clipPath = createSVGElement('clipPath')
+        this.#clipPath.setAttribute('id', 'foliate-loupe-clip')
+        this.#clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse')
+        this.#clipPathPath = createSVGElement('path')
+        this.#clipPathPath.setAttribute('clip-rule', 'evenodd')
+        this.#clipPathPath.setAttribute('fill-rule', 'evenodd') // for older renderers
+        this.#clipPath.append(this.#clipPathPath)
+        defs.append(this.#clipPath)
+        this.#svg.append(defs)
+    }
+    setHole(x, y, r) {
+        // Define a path with a large outer rect and a circular hole
+        // "Infinite" outer rect coverage is safe for userSpaceOnUse
+        // (20,000px limit was too small for long scrolls; use 2,000,000px)
+        const outer = 'M -2000000 -2000000 H 4000000 V 4000000 H -2000000 Z'
+        const inner = `M ${x} ${y} m -${r} 0 a ${r} ${r} 0 1 0 ${2*r} 0 a ${r} ${r} 0 1 0 -${2*r} 0`
+        this.#clipPathPath.setAttribute('d', `${outer} ${inner}`)
+        this.#svg.setAttribute('clip-path', 'url(#foliate-loupe-clip)')
+        this.#svg.style.webkitClipPath = 'url(#foliate-loupe-clip)'
+    }
+    clearHole() {
+        this.#svg.removeAttribute('clip-path')
+        this.#svg.style.webkitClipPath = ''
+        this.#clipPathPath.removeAttribute('d')
+    }
+    get element() {
+        return this.#svg
+    }
+    get #zoom() {
+        // Safari does not zoom the client rects, while Chrome, Edge and Firefox does
+        if (/^((?!chrome|android).)*AppleWebKit/i.test(navigator.userAgent) && !window.chrome) {
+            return window.getComputedStyle(this.#doc.body).zoom || 1.0
+        }
+        return 1.0
+    }
+    #splitRangeByParagraph(range) {
+        const ancestor = range.commonAncestorContainer
+        const paragraphs = Array.from(ancestor.querySelectorAll?.('p, h1, h2, h3, h4') || [])
+        const splitRanges = []
+        paragraphs.forEach((p) => {
+            const pRange = document.createRange()
+            if (range.intersectsNode(p)) {
+                pRange.selectNodeContents(p)
+                if (pRange.compareBoundaryPoints(Range.START_TO_START, range) < 0) {
+                    pRange.setStart(range.startContainer, range.startOffset)
+                }
+                if (pRange.compareBoundaryPoints(Range.END_TO_END, range) > 0) {
+                    pRange.setEnd(range.endContainer, range.endOffset)
+                }
+                splitRanges.push(pRange)
+            }
+        })
+        return splitRanges.length === 0 ? [range] : splitRanges
+    }
+    add(key, range, draw, options) {
+        if (this.#map.has(key)) this.remove(key)
+        if (typeof range === 'function') range = range(this.#svg.getRootNode())
+        const zoom = this.#zoom
+        let rects = []
+        this.#splitRangeByParagraph(range).forEach((pRange) => {
+            const pRects = Array.from(pRange.getClientRects()).map(rect => ({
+                left: rect.left * zoom,
+                top: rect.top * zoom,
+                right: rect.right * zoom,
+                bottom: rect.bottom * zoom,
+                width: rect.width * zoom,
+                height: rect.height * zoom,
+            }))
+            rects = rects.concat(pRects)
+        })
+        const element = draw(rects, options)
+        this.#svg.append(element)
+        this.#map.set(key, { range, draw, options, element, rects })
+    }
+    remove(key) {
+        if (!this.#map.has(key)) return
+        this.#svg.removeChild(this.#map.get(key).element)
+        this.#map.delete(key)
+    }
+    redraw() {
+        for (const obj of this.#map.values()) {
+            const { range, draw, options, element } = obj
+            this.#svg.removeChild(element)
+            const zoom = this.#zoom
+            let rects = []
+            this.#splitRangeByParagraph(range).forEach((pRange) => {
+                const pRects = Array.from(pRange.getClientRects()).map(rect => ({
+                    left: rect.left * zoom,
+                    top: rect.top * zoom,
+                    right: rect.right * zoom,
+                    bottom: rect.bottom * zoom,
+                    width: rect.width * zoom,
+                    height: rect.height * zoom,
+                }))
+                rects = rects.concat(pRects)
+            })
+            const el = draw(rects, options)
+            this.#svg.append(el)
+            obj.element = el
+            obj.rects = rects
+        }
+    }
+    hitTest({ x, y }) {
+        const arr = Array.from(this.#map.entries())
+        // loop in reverse to hit more recently added items first
+        for (let i = arr.length - 1; i >= 0; i--) {
+            const tolerance = 5
+            const [key, obj] = arr[i]
+            for (const { left, top, right, bottom } of obj.rects) {
+                if (
+                    top <= y + tolerance &&
+                    left <= x + tolerance &&
+                    bottom > y - tolerance &&
+                    right > x - tolerance
+                ) {
+                    return [key, obj.range, { left, top, right, bottom }]
+                }
+            }
+        }
+        return []
+    }
+    static underline(rects, options = {}) {
+        const { color = 'red', width: strokeWidth = 2, padding = 0, writingMode } = options
+        const g = createSVGElement('g')
+        g.setAttribute('fill', color)
+        if (writingMode === 'vertical-rl' || writingMode === 'vertical-lr')
+            for (const { right, top, height } of rects) {
+                const el = createSVGElement('rect')
+                el.setAttribute('x', right - strokeWidth / 2 + padding)
+                el.setAttribute('y', top)
+                el.setAttribute('height', height)
+                el.setAttribute('width', strokeWidth)
+                g.append(el)
+            }
+        else for (const { left, bottom, width } of rects) {
+            const el = createSVGElement('rect')
+            el.setAttribute('x', left)
+            el.setAttribute('y', bottom - strokeWidth / 2 + padding)
+            el.setAttribute('height', strokeWidth)
+            el.setAttribute('width', width)
+            g.append(el)
+        }
+        return g
+    }
+    static strikethrough(rects, options = {}) {
+        const { color = 'red', width: strokeWidth = 2, writingMode } = options
+        const g = createSVGElement('g')
+        g.setAttribute('fill', color)
+        if (writingMode === 'vertical-rl' || writingMode === 'vertical-lr')
+            for (const { right, left, top, height } of rects) {
+                const el = createSVGElement('rect')
+                el.setAttribute('x', (right + left) / 2)
+                el.setAttribute('y', top)
+                el.setAttribute('height', height)
+                el.setAttribute('width', strokeWidth)
+                g.append(el)
+            }
+        else for (const { left, top, bottom, width } of rects) {
+            const el = createSVGElement('rect')
+            el.setAttribute('x', left)
+            el.setAttribute('y', (top + bottom) / 2)
+            el.setAttribute('height', strokeWidth)
+            el.setAttribute('width', width)
+            g.append(el)
+        }
+        return g
+    }
+    static squiggly(rects, options = {}) {
+        const { color = 'red', width: strokeWidth = 2, padding = 0, writingMode } = options
+        const g = createSVGElement('g')
+        g.setAttribute('fill', 'none')
+        g.setAttribute('stroke', color)
+        g.setAttribute('stroke-width', strokeWidth)
+        const block = strokeWidth * 1.5
+        if (writingMode === 'vertical-rl' || writingMode === 'vertical-lr')
+            for (const { right, top, height } of rects) {
+                const el = createSVGElement('path')
+                const n = Math.round(height / block / 1.5)
+                const inline = height / n
+                const ls = Array.from({ length: n },
+                    (_, i) => `l${i % 2 ? -block : block} ${inline}`).join('')
+                el.setAttribute('d', `M${right - strokeWidth / 2 + padding} ${top}${ls}`)
+                g.append(el)
+            }
+        else for (const { left, bottom, width } of rects) {
+            const el = createSVGElement('path')
+            const n = Math.round(width / block / 1.5)
+            const inline = width / n
+            const ls = Array.from({ length: n },
+                (_, i) => `l${inline} ${i % 2 ? block : -block}`).join('')
+            el.setAttribute('d', `M${left} ${bottom + strokeWidth / 2 + padding}${ls}`)
+            g.append(el)
+        }
+        return g
+    }
+    static highlight(rects, options = {}) {
+        const {
+            color = 'red',
+            padding = 0,
+            radius = 4,
+            radiusPadding = 2,
+            vertical = false,
+        } = options
+        const g = createSVGElement('g')
+        g.setAttribute('fill', color)
+        g.style.opacity = 'var(--overlayer-highlight-opacity, .3)'
+        g.style.mixBlendMode = 'var(--overlayer-highlight-blend-mode, normal)'
+        for (const [index, { left, top, height, width }] of rects.entries()) {
+            const isFirst = index === 0
+            const isLast = index === rects.length - 1
+            let x, y, w, h
+            let radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft
+            if (vertical) {
+                x = left - padding
+                y = top - padding - (isFirst ? radiusPadding : 0)
+                w = width + padding * 2
+                h = height + padding * 2 + (isFirst ? radiusPadding : 0) + (isLast ? radiusPadding : 0)
+                radiusTopLeft = isFirst ? radius : 0
+                radiusTopRight = isFirst ? radius : 0
+                radiusBottomRight = isLast ? radius : 0
+                radiusBottomLeft = isLast ? radius : 0
+            } else {
+                x = left - padding - (isFirst ? radiusPadding : 0)
+                y = top - padding
+                w = width + padding * 2 + (isFirst ? radiusPadding : 0) + (isLast ? radiusPadding : 0)
+                h = height + padding * 2
+                radiusTopLeft = isFirst ? radius : 0
+                radiusTopRight = isLast ? radius : 0
+                radiusBottomRight = isLast ? radius : 0
+                radiusBottomLeft = isFirst ? radius : 0
+            }
+            const rtl = Math.min(radiusTopLeft, w / 2, h / 2)
+            const rtr = Math.min(radiusTopRight, w / 2, h / 2)
+            const rbr = Math.min(radiusBottomRight, w / 2, h / 2)
+            const rbl = Math.min(radiusBottomLeft, w / 2, h / 2)
+            if (rtl === 0 && rtr === 0 && rbr === 0 && rbl === 0) {
+                const el = createSVGElement('rect')
+                el.setAttribute('x', x)
+                el.setAttribute('y', y)
+                el.setAttribute('height', h)
+                el.setAttribute('width', w)
+                g.append(el)
+            } else {
+                const el = createSVGElement('path')
+                const d = `
+                M ${x + rtl} ${y}
+                L ${x + w - rtr} ${y}
+                ${rtr > 0 ? `Q ${x + w} ${y} ${x + w} ${y + rtr}` : `L ${x + w} ${y}`}
+                L ${x + w} ${y + h - rbr}
+                ${rbr > 0 ? `Q ${x + w} ${y + h} ${x + w - rbr} ${y + h}` : `L ${x + w} ${y + h}`}
+                L ${x + rbl} ${y + h}
+                ${rbl > 0 ? `Q ${x} ${y + h} ${x} ${y + h - rbl}` : `L ${x} ${y + h}`}
+                L ${x} ${y + rtl}
+                ${rtl > 0 ? `Q ${x} ${y} ${x + rtl} ${y}` : `L ${x} ${y}`}
+                Z
+            `.trim().replace(/\s+/g, ' ')
+                el.setAttribute('d', d)
+                g.append(el)
+            }
+        }
+        return g
+    }
+    static outline(rects, options = {}) {
+        const { color = 'red', width: strokeWidth = 3, padding = 0, radius = 3 } = options
+        const g = createSVGElement('g')
+        g.setAttribute('fill', 'none')
+        g.setAttribute('stroke', color)
+        g.setAttribute('stroke-width', strokeWidth)
+        for (const { left, top, height, width } of rects) {
+            const el = createSVGElement('rect')
+            el.setAttribute('x', left - padding)
+            el.setAttribute('y', top - padding)
+            el.setAttribute('height', height + padding * 2)
+            el.setAttribute('width', width + padding * 2)
+            el.setAttribute('rx', radius)
+            g.append(el)
+        }
+        return g
+    }
+    static bubble(rects, options = {}) {
+        const { color = '#fbbf24', writingMode, opacity = 0.85, size = 20, padding = 10 } = options
+        const isVertical = writingMode === 'vertical-rl' || writingMode === 'vertical-lr'
+        const g = createSVGElement('g')
+        g.style.opacity = opacity
+        if (rects.length === 0) return g
+        rects.splice(1)
+        const firstRect = rects[0]
+        const x = isVertical ? firstRect.right - size + padding : firstRect.right - size + padding
+        const y = isVertical ? firstRect.bottom - size + padding : firstRect.top - size + padding
+        firstRect.top = y - padding
+        firstRect.right = x + size + padding
+        firstRect.bottom = y + size + padding
+        firstRect.left = x - padding
+        const bubble = createSVGElement('path')
+        const s = size
+        const r = s * 0.15
+        // Speech bubble shape with a small tail
+        // Main rounded rectangle body
+        const d = `
+            M ${x + r} ${y}
+            h ${s - 2 * r}
+            a ${r} ${r} 0 0 1 ${r} ${r}
+            v ${s * 0.65 - 2 * r}
+            a ${r} ${r} 0 0 1 ${-r} ${r}
+            h ${-s * 0.3}
+            l ${-s * 0.15} ${s * 0.2}
+            l ${s * 0.05} ${-s * 0.2}
+            h ${-s * 0.6 + 2 * r}
+            a ${r} ${r} 0 0 1 ${-r} ${-r}
+            v ${-s * 0.65 + 2 * r}
+            a ${r} ${r} 0 0 1 ${r} ${-r}
+            z
+        `.replace(/\s+/g, ' ').trim()
+        bubble.setAttribute('d', d)
+        bubble.setAttribute('fill', color)
+        bubble.setAttribute('stroke', 'rgba(0, 0, 0, 0.2)')
+        bubble.setAttribute('stroke-width', '1')
+        // Add horizontal lines inside to represent text
+        const lineGroup = createSVGElement('g')
+        lineGroup.setAttribute('stroke', 'rgba(0, 0, 0, 0.3)')
+        lineGroup.setAttribute('stroke-width', '1.5')
+        lineGroup.setAttribute('stroke-linecap', 'round')
+        const lineY1 = y + s * 0.18
+        const lineY2 = y + s * 0.33
+        const lineY3 = y + s * 0.48
+        const lineX1 = x + s * 0.2
+        const lineX2 = x + s * 0.8
+        const line1 = createSVGElement('line')
+        line1.setAttribute('x1', lineX1)
+        line1.setAttribute('y1', lineY1)
+        line1.setAttribute('x2', lineX2)
+        line1.setAttribute('y2', lineY1)
+        const line2 = createSVGElement('line')
+        line2.setAttribute('x1', lineX1)
+        line2.setAttribute('y1', lineY2)
+        line2.setAttribute('x2', lineX2)
+        line2.setAttribute('y2', lineY2)
+        const line3 = createSVGElement('line')
+        line3.setAttribute('x1', lineX1)
+        line3.setAttribute('y1', lineY3)
+        line3.setAttribute('x2', x + s * 0.6)
+        line3.setAttribute('y2', lineY3)
+        lineGroup.append(line1, line2, line3)
+        if (isVertical) {
+            const centerX = x + s / 2
+            const centerY = y + s / 2
+            bubble.setAttribute('transform', `rotate(90 ${centerX} ${centerY})`)
+            lineGroup.setAttribute('transform', `rotate(90 ${centerX} ${centerY})`)
+        }
+        g.append(bubble)
+        g.append(lineGroup)
+        return g
+    }
+    // make an exact copy of an image in the overlay
+    // one can then apply filters to the entire element, without affecting them;
+    // it's a bit silly and probably better to just invert images twice
+    // (though the color will be off in that case if you do heu-rotate)
+    static copyImage([rect], options = {}) {
+        const { src } = options
+        const image = createSVGElement('image')
+        const { left, top, height, width } = rect
+        image.setAttribute('href', src)
+        image.setAttribute('x', left)
+        image.setAttribute('y', top)
+        image.setAttribute('height', height)
+        image.setAttribute('width', width)
+        return image
+    }
+}

packages/foliate-js/package-lock.json ADDED Viewed

	@@ -0,0 +1,1584 @@

+{
+  "name": "foliate-js",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "foliate-js",
+      "version": "0.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "construct-style-sheets-polyfill": "^3.1.0"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.9.1",
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@zip.js/zip.js": "^2.7.52",
+        "fflate": "^0.8.2",
+        "fs-extra": "^11.2.0",
+        "globals": "^15.9.0",
+        "pdfjs-dist": "^4.7.76",
+        "rollup": "^4.22.4"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.12.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.12.0.tgz",
+      "integrity": "sha512-eohesHH8WFRUprDNyEREgqP6beG6htMeUYeCpkEgBCieCMme5r9zFWjzAJp//9S+Kub4rqE+jXe9Cp1a7IYIIA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
+      "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.2.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
+      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.6",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
+      "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.25",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "node-pre-gyp": "bin/node-pre-gyp"
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "15.3.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.0.tgz",
+      "integrity": "sha512-9eO5McEICxMzJpDW9OnMYSv4Sta3hmt7VtBFz5zR9273suNOydOyq/FrGeGy+KsTRFm8w0SLVhzig2ILFT63Ag==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "@types/resolve": "1.20.2",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.78.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-terser": {
+      "version": "0.4.4",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-0.4.4.tgz",
+      "integrity": "sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "serialize-javascript": "^6.0.1",
+        "smob": "^1.0.0",
+        "terser": "^5.17.4"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.2.tgz",
+      "integrity": "sha512-/FIdS3PyZ39bjZlwqFnWqCOVnW7o963LtKMwQOD0NhQqw22gSr2YY1afu3FxRip4ZCZNsD5jq6Aaz6QV3D/Njw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.24.0.tgz",
+      "integrity": "sha512-Q6HJd7Y6xdB48x8ZNVDOqsbh2uByBhgK8PiQgPhwkIw/HC/YX5Ghq2mQY5sRMZWHb3VsFkWooUVOZHKr7DmDIA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.24.0.tgz",
+      "integrity": "sha512-ijLnS1qFId8xhKjT81uBHuuJp2lU4x2yxa4ctFPtG+MqEE6+C5f/+X/bStmxapgmwLwiL3ih122xv8kVARNAZA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.24.0.tgz",
+      "integrity": "sha512-bIv+X9xeSs1XCk6DVvkO+S/z8/2AMt/2lMqdQbMrmVpgFvXlmde9mLcbQpztXm1tajC3raFDqegsH18HQPMYtA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.24.0.tgz",
+      "integrity": "sha512-X6/nOwoFN7RT2svEQWUsW/5C/fYMBe4fnLK9DQk4SX4mgVBiTA9h64kjUYPvGQ0F/9xwJ5U5UfTbl6BEjaQdBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.24.0.tgz",
+      "integrity": "sha512-0KXvIJQMOImLCVCz9uvvdPgfyWo93aHHp8ui3FrtOP57svqrF/roSSR5pjqL2hcMp0ljeGlU4q9o/rQaAQ3AYA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.24.0.tgz",
+      "integrity": "sha512-it2BW6kKFVh8xk/BnHfakEeoLPv8STIISekpoF+nBgWM4d55CZKc7T4Dx1pEbTnYm/xEKMgy1MNtYuoA8RFIWw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.24.0.tgz",
+      "integrity": "sha512-i0xTLXjqap2eRfulFVlSnM5dEbTVque/3Pi4g2y7cxrs7+a9De42z4XxKLYJ7+OhE3IgxvfQM7vQc43bwTgPwA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.24.0.tgz",
+      "integrity": "sha512-9E6MKUJhDuDh604Qco5yP/3qn3y7SLXYuiC0Rpr89aMScS2UAmK1wHP2b7KAa1nSjWJc/f/Lc0Wl1L47qjiyQw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.24.0.tgz",
+      "integrity": "sha512-2XFFPJ2XMEiF5Zi2EBf4h73oR1V/lycirxZxHZNc93SqDN/IWhYYSYj8I9381ikUFXZrz2v7r2tOVk2NBwxrWw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.24.0.tgz",
+      "integrity": "sha512-M3Dg4hlwuntUCdzU7KjYqbbd+BLq3JMAOhCKdBE3TcMGMZbKkDdJ5ivNdehOssMCIokNHFOsv7DO4rlEOfyKpg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.24.0.tgz",
+      "integrity": "sha512-mjBaoo4ocxJppTorZVKWFpy1bfFj9FeCMJqzlMQGjpNPY9JwQi7OuS1axzNIk0nMX6jSgy6ZURDZ2w0QW6D56g==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.24.0.tgz",
+      "integrity": "sha512-ZXFk7M72R0YYFN5q13niV0B7G8/5dcQ9JDp8keJSfr3GoZeXEoMHP/HlvqROA3OMbMdfr19IjCeNAnPUG93b6A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.24.0.tgz",
+      "integrity": "sha512-w1i+L7kAXZNdYl+vFvzSZy8Y1arS7vMgIy8wusXJzRrPyof5LAb02KGr1PD2EkRcl73kHulIID0M501lN+vobQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.24.0.tgz",
+      "integrity": "sha512-VXBrnPWgBpVDCVY6XF3LEW0pOU51KbaHhccHw6AS6vBWIC60eqsH19DAeeObl+g8nKAz04QFdl/Cefta0xQtUQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.24.0.tgz",
+      "integrity": "sha512-xrNcGDU0OxVcPTH/8n/ShH4UevZxKIO6HJFK0e15XItZP2UcaiLFd5kiX7hJnqCbSztUF8Qot+JWBC/QXRPYWQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.24.0.tgz",
+      "integrity": "sha512-fbMkAF7fufku0N2dE5TBXcNlg0pt0cJue4xBRE2Qc5Vqikxr4VCgKj/ht6SMdFcOacVA9rqF70APJ8RN/4vMJw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
+      "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
+      "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@zip.js/zip.js": {
+      "version": "2.7.52",
+      "resolved": "https://registry.npmjs.org/@zip.js/zip.js/-/zip.js-2.7.52.tgz",
+      "integrity": "sha512-+5g7FQswvrCHwYKNMd/KFxZSObctLSsQOgqBSi0LzwHo3li9Eh1w5cF5ndjQw9Zbr3ajVnd2+XyiX85gAetx1Q==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "bun": ">=0.7.0",
+        "deno": ">=1.0.0",
+        "node": ">=16.5.0"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/acorn": {
+      "version": "8.12.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
+      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/aproba": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz",
+      "integrity": "sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "deprecated": "This package is no longer supported.",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/canvas": {
+      "version": "2.11.2",
+      "resolved": "https://registry.npmjs.org/canvas/-/canvas-2.11.2.tgz",
+      "integrity": "sha512-ItanGBMrmRV7Py2Z+Xhs7cT+FNt5K0vPL4p9EZ/UX/Mu7hFbkxSjKF2KVtPwX7UYWp7dRKnrTvReflgrItJbdw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@mapbox/node-pre-gyp": "^1.0.0",
+        "nan": "^2.17.0",
+        "simple-get": "^3.0.3"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "bin": {
+        "color-support": "bin.js"
+      }
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/construct-style-sheets-polyfill": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/construct-style-sheets-polyfill/-/construct-style-sheets-polyfill-3.1.0.tgz",
+      "integrity": "sha512-HBLKP0chz8BAY6rBdzda11c3wAZeCZ+kIG4weVC2NM3AXzxx09nhe8t0SQNdloAvg5GLuHwq/0SPOOSPvtCcKw==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decompress-response": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-4.2.1.tgz",
+      "integrity": "sha512-jOSne2qbyE+/r8G1VU+G/82LBs2Fs4LAsTiLSHOCOMZQl2OKZ6i8i4IyHemTe+/yIXOtTcRQMzPcgyhoFlqPkw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "mimic-response": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/detect-libc": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.3.tgz",
+      "integrity": "sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fflate": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz",
+      "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fs-extra": {
+      "version": "11.2.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
+      "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "deprecated": "This package is no longer supported.",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/globals": {
+      "version": "15.11.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-15.11.0.tgz",
+      "integrity": "sha512-yeyNSjdbyVaWurlwCpcA6XNBrHTMIeDdj0/hnvX/OLJ9ekOXYbLsLinH/MucQyGvNnXhidTdNhTtJaffL2sMfw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/is-core-module": {
+      "version": "2.15.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz",
+      "integrity": "sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jsonfile": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "semver": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/mimic-response": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-2.1.0.tgz",
+      "integrity": "sha512-wXqjST+SLt7R009ySCglWBCFpjUygmCIfD790/kVbiGmUgfYGuB14PiTd5DwVxSV4NcYHjzMkoj5LjQZwTQLEA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/nan": {
+      "version": "2.22.0",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.22.0.tgz",
+      "integrity": "sha512-nbajikzWTMwsW+eSsNm3QwlOs7het9gGJU5dDZzRTQGk03vyBOauxgI4VakDzE0PtsGTmXPsXTbbjVhRwR5mpw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "deprecated": "This package is no longer supported.",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/path2d": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/path2d/-/path2d-0.2.1.tgz",
+      "integrity": "sha512-Fl2z/BHvkTNvkuBzYTpTuirHZg6wW9z8+4SND/3mDTEcYbbNKWAy21dz9D3ePNNwrrK8pqZO5vLPZ1hLF6T7XA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/pdfjs-dist": {
+      "version": "4.7.76",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-4.7.76.tgz",
+      "integrity": "sha512-8y6wUgC/Em35IumlGjaJOCm3wV4aY/6sqnIT3fVW/67mXsOZ9HWBn8GDKmJUK0GSzpbmX3gQqwfoFayp78Mtqw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "canvas": "^2.11.2",
+        "path2d": "^0.2.1"
+      }
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.8",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz",
+      "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-core-module": "^2.13.0",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.24.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.24.0.tgz",
+      "integrity": "sha512-DOmrlGSXNk1DM0ljiQA+i+o0rSLhtii1je5wgk60j49d1jHT5YYttBv1iWOnYSTG+fZZESUOSNiAl89SIet+Cg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.6"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.24.0",
+        "@rollup/rollup-android-arm64": "4.24.0",
+        "@rollup/rollup-darwin-arm64": "4.24.0",
+        "@rollup/rollup-darwin-x64": "4.24.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.24.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.24.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.24.0",
+        "@rollup/rollup-linux-arm64-musl": "4.24.0",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.24.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.24.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.24.0",
+        "@rollup/rollup-linux-x64-gnu": "4.24.0",
+        "@rollup/rollup-linux-x64-musl": "4.24.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.24.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.24.0",
+        "@rollup/rollup-win32-x64-msvc": "4.24.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.6.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
+      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/serialize-javascript": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "randombytes": "^2.1.0"
+      }
+    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/simple-concat": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+      "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/simple-get": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.1.tgz",
+      "integrity": "sha512-CQ5LTKGfCpvE1K0n2us+kuMPbk/q0EKl82s4aheV9oXjFEz6W/Y7oQFVJuU6QG77hRT4Ghb5RURteF5vnWjupA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "decompress-response": "^4.2.0",
+        "once": "^1.3.1",
+        "simple-concat": "^1.0.0"
+      }
+    },
+    "node_modules/smob": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/smob/-/smob-1.5.0.tgz",
+      "integrity": "sha512-g6T+p7QO8npa+/hNx9ohv1E5pVCmWrVCUzUXJyLdMmftX6ER0oiWY/w9knEonLpnOp6b6FenKnMfR8gqwWdwig==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/terser": {
+      "version": "5.34.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.34.1.tgz",
+      "integrity": "sha512-FsJZ7iZLd/BXkz+4xrRTGJ26o/6VTjQytUk8b8OxkwcD2I+79VPJlz7qss1+zE7h8GNIScFqXcDyJ/KqBYZFVA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.8.2",
+        "commander": "^2.20.0",
+        "source-map-support": "~0.5.20"
+      },
+      "bin": {
+        "terser": "bin/terser"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "optional": true
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true
+    }
+  }
+}

packages/foliate-js/package.json ADDED Viewed

	@@ -0,0 +1,50 @@

+{
+  "name": "foliate-js",
+  "version": "0.0.0",
+  "description": "Render e-books in the browser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnfactotum/foliate-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/johnfactotum/foliate-js/issues"
+  },
+  "homepage": "https://github.com/johnfactotum/foliate-js#readme",
+  "author": "John Factotum",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./*.js": "./*.js"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.9.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@zip.js/zip.js": "^2.7.52",
+    "fflate": "^0.8.2",
+    "fs-extra": "^11.2.0",
+    "globals": "^15.9.0",
+    "pdfjs-dist": "^5.4.530",
+    "rollup": "^4.22.4"
+  },
+  "scripts": {
+    "build": "npx rollup -c"
+  },
+  "keywords": [
+    "ebook",
+    "reader",
+    "epub",
+    "cfi",
+    "mobi",
+    "azw",
+    "azw3",
+    "fb2",
+    "cbz",
+    "dictd",
+    "stardict",
+    "opds"
+  ],
+  "dependencies": {
+    "construct-style-sheets-polyfill": "^3.1.0"
+  }
+}

packages/foliate-js/paginator.js ADDED Viewed

	@@ -0,0 +1,1417 @@

+const wait = ms => new Promise(resolve => setTimeout(resolve, ms))
+const debounce = (f, wait, immediate) => {
+    let timeout
+    return (...args) => {
+        const later = () => {
+            timeout = null
+            if (!immediate) f(...args)
+        }
+        const callNow = immediate && !timeout
+        if (timeout) clearTimeout(timeout)
+        timeout = setTimeout(later, wait)
+        if (callNow) f(...args)
+    }
+}
+const lerp = (min, max, x) => x * (max - min) + min
+const easeOutQuad = x => 1 - (1 - x) * (1 - x)
+const animate = (a, b, duration, ease, render) => new Promise(resolve => {
+    let start
+    const step = now => {
+        if (document.hidden) {
+            render(lerp(a, b, 1))
+            return resolve()
+        }
+        start ??= now
+        const fraction = Math.min(1, (now - start) / duration)
+        render(lerp(a, b, ease(fraction)))
+        if (fraction < 1) requestAnimationFrame(step)
+        else resolve()
+    }
+    if (document.hidden) {
+        render(lerp(a, b, 1))
+        return resolve()
+    }
+    requestAnimationFrame(step)
+})
+// collapsed range doesn't return client rects sometimes (or always?)
+// try make get a non-collapsed range or element
+const uncollapse = range => {
+    if (!range?.collapsed) return range
+    const { endOffset, endContainer } = range
+    if (endContainer.nodeType === 1) {
+        const node = endContainer.childNodes[endOffset]
+        if (node?.nodeType === 1) return node
+        return endContainer
+    }
+    if (endOffset + 1 < endContainer.length) range.setEnd(endContainer, endOffset + 1)
+    else if (endOffset > 1) range.setStart(endContainer, endOffset - 1)
+    else return endContainer.parentNode
+    return range
+}
+const makeRange = (doc, node, start, end = start) => {
+    const range = doc.createRange()
+    range.setStart(node, start)
+    range.setEnd(node, end)
+    return range
+}
+// use binary search to find an offset value in a text node
+const bisectNode = (doc, node, cb, start = 0, end = node.nodeValue.length) => {
+    if (end - start === 1) {
+        const result = cb(makeRange(doc, node, start), makeRange(doc, node, end))
+        return result < 0 ? start : end
+    }
+    const mid = Math.floor(start + (end - start) / 2)
+    const result = cb(makeRange(doc, node, start, mid), makeRange(doc, node, mid, end))
+    return result < 0 ? bisectNode(doc, node, cb, start, mid)
+        : result > 0 ? bisectNode(doc, node, cb, mid, end) : mid
+}
+const { SHOW_ELEMENT, SHOW_TEXT, SHOW_CDATA_SECTION,
+    FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP } = NodeFilter
+const filter = SHOW_ELEMENT | SHOW_TEXT | SHOW_CDATA_SECTION
+// needed cause there seems to be a bug in `getBoundingClientRect()` in Firefox
+// where it fails to include rects that have zero width and non-zero height
+// (CSSOM spec says "rectangles [...] of which the height or width is not zero")
+// which makes the visible range include an extra space at column boundaries
+const getBoundingClientRect = target => {
+    let top = Infinity, right = -Infinity, left = Infinity, bottom = -Infinity
+    for (const rect of target.getClientRects()) {
+        left = Math.min(left, rect.left)
+        top = Math.min(top, rect.top)
+        right = Math.max(right, rect.right)
+        bottom = Math.max(bottom, rect.bottom)
+    }
+    return new DOMRect(left, top, right - left, bottom - top)
+}
+const getVisibleRange = (doc, start, end, mapRect) => {
+    // first get all visible nodes
+    const acceptNode = node => {
+        const name = node.localName?.toLowerCase()
+        // ignore all scripts, styles, and their children
+        if (name === 'script' || name === 'style') return FILTER_REJECT
+        if (node.nodeType === 1) {
+            const { left, right } = mapRect(node.getBoundingClientRect())
+            // no need to check child nodes if it's completely out of view
+            if (right < start || left > end) return FILTER_REJECT
+            // elements must be completely in view to be considered visible
+            // because you can't specify offsets for elements
+            if (left >= start && right <= end) return FILTER_ACCEPT
+            // TODO: it should probably allow elements that do not contain text
+            // because they can exceed the whole viewport in both directions
+            // especially in scrolled mode
+        } else {
+            // ignore empty text nodes
+            if (!node.nodeValue?.trim()) return FILTER_SKIP
+            // create range to get rect
+            const range = doc.createRange()
+            range.selectNodeContents(node)
+            const { left, right } = mapRect(range.getBoundingClientRect())
+            // it's visible if any part of it is in view
+            if (right >= start && left <= end) return FILTER_ACCEPT
+        }
+        return FILTER_SKIP
+    }
+    const walker = doc.createTreeWalker(doc.body, filter, { acceptNode })
+    const nodes = []
+    for (let node = walker.nextNode(); node; node = walker.nextNode())
+        nodes.push(node)
+    // we're only interested in the first and last visible nodes
+    const from = nodes[0] ?? doc.body
+    const to = nodes[nodes.length - 1] ?? from
+    // find the offset at which visibility changes
+    const startOffset = from.nodeType === 1 ? 0
+        : bisectNode(doc, from, (a, b) => {
+            const p = mapRect(getBoundingClientRect(a))
+            const q = mapRect(getBoundingClientRect(b))
+            if (p.right < start && q.left > start) return 0
+            return q.left > start ? -1 : 1
+        })
+    const endOffset = to.nodeType === 1 ? 0
+        : bisectNode(doc, to, (a, b) => {
+            const p = mapRect(getBoundingClientRect(a))
+            const q = mapRect(getBoundingClientRect(b))
+            if (p.right < end && q.left > end) return 0
+            return q.left > end ? -1 : 1
+        })
+    const range = doc.createRange()
+    range.setStart(from, startOffset)
+    range.setEnd(to, endOffset)
+    return range
+}
+const selectionIsBackward = sel => {
+    const range = document.createRange()
+    range.setStart(sel.anchorNode, sel.anchorOffset)
+    range.setEnd(sel.focusNode, sel.focusOffset)
+    return range.collapsed
+}
+const setSelectionTo = (target, collapse) => {
+    let range
+    if (target.startContainer) range = target.cloneRange()
+    else if (target.nodeType) {
+        range = document.createRange()
+        range.selectNode(target)
+    }
+    if (range) {
+        const sel = range.startContainer.ownerDocument?.defaultView.getSelection()
+        if (sel) {
+            sel.removeAllRanges()
+            if (collapse === -1) range.collapse(true)
+            else if (collapse === 1) range.collapse()
+            sel.addRange(range)
+        }
+    }
+}
+const getDirection = doc => {
+    const { defaultView } = doc
+    const { writingMode, direction } = defaultView.getComputedStyle(doc.body)
+    const vertical = writingMode === 'vertical-rl'
+        || writingMode === 'vertical-lr'
+    const rtl = doc.body.dir === 'rtl'
+        || direction === 'rtl'
+        || doc.documentElement.dir === 'rtl'
+    return { vertical, rtl }
+}
+const getBackground = doc => {
+    const bodyStyle = doc.defaultView.getComputedStyle(doc.body)
+    return bodyStyle.backgroundColor === 'rgba(0, 0, 0, 0)'
+        && bodyStyle.backgroundImage === 'none'
+        ? doc.defaultView.getComputedStyle(doc.documentElement).background
+        : bodyStyle.background
+}
+const makeMarginals = (length, part) => Array.from({ length }, () => {
+    const div = document.createElement('div')
+    const child = document.createElement('div')
+    div.append(child)
+    child.setAttribute('part', part)
+    return div
+})
+const setStyles = (el, styles) => {
+    const { style } = el
+    for (const [k, v] of Object.entries(styles)) style.setProperty(k, v)
+}
+const setStylesImportant = (el, styles) => {
+    const { style } = el
+    for (const [k, v] of Object.entries(styles)) style.setProperty(k, v, 'important')
+}
+class View {
+    #observer = new ResizeObserver(() => this.expand())
+    #element = document.createElement('div')
+    #iframe = document.createElement('iframe')
+    #contentRange = document.createRange()
+    #overlayer
+    #vertical = false
+    #rtl = false
+    #column = true
+    #size
+    #layout = {}
+    constructor({ container, onExpand }) {
+        this.container = container
+        this.onExpand = onExpand
+        this.#iframe.setAttribute('part', 'filter')
+        this.#element.append(this.#iframe)
+        Object.assign(this.#element.style, {
+            boxSizing: 'content-box',
+            position: 'relative',
+            overflow: 'hidden',
+            flex: '0 0 auto',
+            width: '100%', height: '100%',
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+        })
+        Object.assign(this.#iframe.style, {
+            overflow: 'hidden',
+            border: '0',
+            display: 'none',
+            width: '100%', height: '100%',
+        })
+        // `allow-scripts` is needed for events because of WebKit bug
+        // https://bugs.webkit.org/show_bug.cgi?id=218086
+        this.#iframe.setAttribute('sandbox', 'allow-same-origin allow-scripts')
+        this.#iframe.setAttribute('scrolling', 'no')
+    }
+    get element() {
+        return this.#element
+    }
+    get document() {
+        return this.#iframe.contentDocument
+    }
+    async load(src, data, afterLoad, beforeRender) {
+        if (typeof src !== 'string') throw new Error(`${src} is not string`)
+        return new Promise(resolve => {
+            this.#iframe.addEventListener('load', () => {
+                const doc = this.document
+                afterLoad?.(doc)
+                this.#iframe.setAttribute('aria-label', doc.title)
+                // it needs to be visible for Firefox to get computed style
+                this.#iframe.style.display = 'block'
+                const { vertical, rtl } = getDirection(doc)
+                this.docBackground = getBackground(doc)
+                doc.body.style.background = 'none'
+                const background = this.docBackground
+                this.#iframe.style.display = 'none'
+                this.#vertical = vertical
+                this.#rtl = rtl
+                this.#contentRange.selectNodeContents(doc.body)
+                const layout = beforeRender?.({ vertical, rtl, background })
+                this.#iframe.style.display = 'block'
+                this.render(layout)
+                this.#observer.observe(doc.body)
+                // the resize observer above doesn't work in Firefox
+                // (see https://bugzilla.mozilla.org/show_bug.cgi?id=1832939)
+                // until the bug is fixed we can at least account for font load
+                doc.fonts.ready.then(() => this.expand())
+                resolve()
+            }, { once: true })
+            if (data) {
+                this.#iframe.srcdoc = data
+            } else {
+                this.#iframe.src = src
+            }
+        })
+    }
+    render(layout) {
+        if (!layout || !this.document) return
+        this.#column = layout.flow !== 'scrolled'
+        this.#layout = layout
+        if (this.#column) this.columnize(layout)
+        else this.scrolled(layout)
+    }
+    scrolled({ marginTop, marginRight, marginBottom, marginLeft, gap, columnWidth }) {
+        const vertical = this.#vertical
+        const doc = this.document
+        setStylesImportant(doc.documentElement, {
+            'box-sizing': 'border-box',
+            'padding': vertical
+                ? `${marginTop * 1.5}px ${marginRight}px ${marginBottom * 1.5}px ${marginLeft}px`
+                : `${marginTop}px ${gap / 2 + marginRight / 2}px ${marginBottom}px ${gap / 2 + marginLeft / 2}px`,
+            'column-width': 'auto',
+            'height': 'auto',
+            'width': 'auto',
+        })
+        setStyles(doc.documentElement, {
+            '--page-margin-top': `${vertical ? marginTop * 1.5 : marginTop}px`,
+            '--page-margin-right': `${vertical ? marginRight : marginRight + gap /2}px`,
+            '--page-margin-bottom': `${vertical ? marginBottom * 1.5 : marginBottom}px`,
+            '--page-margin-left': `${vertical ? marginLeft : marginLeft + gap / 2}px`,
+            '--full-width': `${Math.trunc(window.innerWidth)}`,
+            '--full-height': `${Math.trunc(window.innerHeight)}`,
+            '--available-width': `${Math.trunc(Math.min(window.innerWidth, columnWidth) - marginLeft - marginRight - gap - 60)}`,
+            '--available-height': `${Math.trunc(window.innerHeight - marginTop - marginBottom)}`,
+        })
+        setStylesImportant(doc.body, {
+            [vertical ? 'max-height' : 'max-width']: `${columnWidth}px`,
+            'margin': 'auto',
+        })
+        this.setImageSize()
+        this.expand()
+    }
+    columnize({ width, height, marginTop, marginRight, marginBottom, marginLeft, gap, columnWidth }) {
+        const vertical = this.#vertical
+        this.#size = vertical ? height : width
+        const doc = this.document
+        setStylesImportant(doc.documentElement, {
+            'box-sizing': 'border-box',
+            'column-width': `${Math.trunc(columnWidth)}px`,
+            'column-gap': vertical ? `${(marginTop + marginBottom) * 1.5}px` : `${gap + marginRight / 2 + marginLeft / 2}px`,
+            'column-fill': 'auto',
+            ...(vertical
+                ? { 'width': `${width}px` }
+                : { 'height': `${height}px` }),
+            'padding': vertical
+                ? `${marginTop * 1.5}px ${marginRight}px ${marginBottom * 1.5}px ${marginLeft}px`
+                : `${marginTop}px ${gap / 2 + marginRight / 2}px ${marginBottom}px ${gap / 2 + marginLeft / 2}px`,
+            'overflow': 'hidden',
+            // force wrap long words
+            'overflow-wrap': 'break-word',
+            // reset some potentially problematic props
+            'position': 'static', 'border': '0', 'margin': '0',
+            'max-height': 'none', 'max-width': 'none',
+            'min-height': 'none', 'min-width': 'none',
+            // fix glyph clipping in WebKit
+            '-webkit-line-box-contain': 'block glyphs replaced',
+        })
+        setStyles(doc.documentElement, {
+            '--page-margin-top': `${vertical ? marginTop * 1.5 : marginTop}px`,
+            '--page-margin-right': `${vertical ? marginRight : marginRight / 2 + gap /2}px`,
+            '--page-margin-bottom': `${vertical ? marginBottom * 1.5 : marginBottom}px`,
+            '--page-margin-left': `${vertical ? marginLeft : marginLeft / 2 + gap / 2}px`,
+            '--full-width': `${Math.trunc(window.innerWidth)}`,
+            '--full-height': `${Math.trunc(window.innerHeight)}`,
+            '--available-width': `${Math.trunc(columnWidth - marginLeft - marginRight - gap)}`,
+            '--available-height': `${Math.trunc(height - marginTop - marginBottom)}`,
+        })
+        setStylesImportant(doc.body, {
+            'max-height': 'none',
+            'max-width': 'none',
+            'margin': '0',
+        })
+        this.setImageSize()
+        this.expand()
+    }
+    setImageSize() {
+        const { width, height, marginTop, marginRight, marginBottom, marginLeft } = this.#layout
+        const vertical = this.#vertical
+        const doc = this.document
+        for (const el of doc.body.querySelectorAll('img, svg, video')) {
+            // preserve max size if they are already set
+            const { maxHeight, maxWidth } = doc.defaultView.getComputedStyle(el)
+            setStylesImportant(el, {
+                'max-height': vertical
+                    ? (maxHeight !== 'none' && maxHeight !== '0px' ? maxHeight : '100%')
+                    : `${height - marginTop - marginBottom }px`,
+                'max-width': vertical
+                    ? `${width - marginLeft - marginRight }px`
+                    : (maxWidth !== 'none' && maxWidth !== '0px' ? maxWidth : '100%'),
+                'object-fit': 'contain',
+                'page-break-inside': 'avoid',
+                'break-inside': 'avoid',
+                'box-sizing': 'border-box',
+            })
+        }
+    }
+    get #zoom() {
+        // Safari does not zoom the client rects, while Chrome, Edge and Firefox does
+        if (/^((?!chrome|android).)*AppleWebKit/i.test(navigator.userAgent) && !window.chrome) {
+            return window.getComputedStyle(this.document.body).zoom || 1.0
+        }
+        return 1.0
+    }
+    expand() {
+        if (!this.document) return
+        const { documentElement } = this.document
+        if (this.#column) {
+            const side = this.#vertical ? 'height' : 'width'
+            const otherSide = this.#vertical ? 'width' : 'height'
+            const contentRect = this.#contentRange.getBoundingClientRect()
+            const rootRect = documentElement.getBoundingClientRect()
+            // offset caused by column break at the start of the page
+            // which seem to be supported only by WebKit and only for horizontal writing
+            const contentStart = this.#vertical ? 0
+                : this.#rtl ? rootRect.right - contentRect.right : contentRect.left - rootRect.left
+            const contentSize = (contentStart + contentRect[side]) * this.#zoom
+            const pageCount = Math.ceil(contentSize / this.#size)
+            const expandedSize = pageCount * this.#size
+            this.#element.style.padding = '0'
+            this.#iframe.style[side] = `${expandedSize}px`
+            this.#element.style[side] = `${expandedSize + this.#size * 2}px`
+            this.#iframe.style[otherSide] = '100%'
+            this.#element.style[otherSide] = '100%'
+            documentElement.style[side] = `${this.#size}px`
+            if (this.#overlayer) {
+                this.#overlayer.element.style.margin = '0'
+                this.#overlayer.element.style.left = this.#vertical ? '0' : `${this.#size}px`
+                this.#overlayer.element.style.top = this.#vertical ? `${this.#size}px` : '0'
+                this.#overlayer.element.style[side] = `${expandedSize}px`
+                this.#overlayer.redraw()
+            }
+        } else {
+            const side = this.#vertical ? 'width' : 'height'
+            const otherSide = this.#vertical ? 'height' : 'width'
+            const contentSize = documentElement.getBoundingClientRect()[side]
+            const expandedSize = contentSize
+            this.#element.style.padding = '0'
+            this.#iframe.style[side] = `${expandedSize}px`
+            this.#element.style[side] = `${expandedSize}px`
+            this.#iframe.style[otherSide] = '100%'
+            this.#element.style[otherSide] = '100%'
+            if (this.#overlayer) {
+                this.#overlayer.element.style.margin = '0'
+                this.#overlayer.element.style.left = '0'
+                this.#overlayer.element.style.top = '0'
+                this.#overlayer.element.style[side] = `${expandedSize}px`
+                this.#overlayer.redraw()
+            }
+        }
+        this.onExpand()
+    }
+    set overlayer(overlayer) {
+        this.#overlayer = overlayer
+        this.#element.append(overlayer.element)
+    }
+    get overlayer() {
+        return this.#overlayer
+    }
+    #loupeEl = null
+    #loupeScaler = null
+    #loupeCursor = null
+    // Show a magnifier loupe inside the iframe document.
+    // winX/winY are in main-window (screen) coordinates.
+    showLoupe(winX, winY, { isVertical, color, radius }) {
+        const doc = this.document
+        if (!doc) return
+        const frameRect = this.#iframe.getBoundingClientRect()
+        // Cursor in iframe-viewport coordinates.
+        const vpX = winX - frameRect.left
+        const vpY = winY - frameRect.top
+        // Cursor in document coordinates (accounts for scroll).
+        const scrollX = doc.scrollingElement?.scrollLeft ?? 0
+        const scrollY = doc.scrollingElement?.scrollTop ?? 0
+        const docX = vpX + scrollX
+        const docY = vpY + scrollY
+        const MAGNIFICATION = 1.2
+        const diameter = radius * 2
+        const MARGIN = 8
+        // Position loupe above the cursor (or to the left for vertical text).
+        const loupeOffset = radius + 16
+        let loupeLeft = isVertical ? vpX - loupeOffset - diameter : vpX - radius
+        let loupeTop  = isVertical ? vpY - radius : vpY - loupeOffset - diameter
+        loupeLeft = Math.max(MARGIN, Math.min(loupeLeft, frameRect.width  - diameter - MARGIN))
+        loupeTop  = Math.max(MARGIN, Math.min(loupeTop,  frameRect.height - diameter - MARGIN))
+        // CSS-transform math: map document point (docX, docY) to loupe centre (radius, radius).
+        //   visual_pos = offset + coord × MAGNIFICATION = radius
+        //   ⟹ offset = radius − coord × MAGNIFICATION
+        const offsetX = radius - docX * MAGNIFICATION
+        const offsetY = radius - docY * MAGNIFICATION
+        // Build loupe DOM structure once; subsequent calls only update positions.
+        if (!this.#loupeEl || !this.#loupeEl.isConnected) {
+            this.#loupeEl = doc.createElement('div')
+            // Clone the live body once — inside the iframe the epub's CSS
+            // variables, @font-face fonts, and styles apply automatically.
+            const bodyClone = doc.body.cloneNode(true)
+            // Wrap the clone in a div that replicates documentElement's inline
+            // styles (column-width, column-gap, padding, height, etc.) so text
+            // flows with the same column layout as the original document.
+            const htmlWrapper = doc.createElement('div')
+            htmlWrapper.style.cssText = doc.documentElement.style.cssText
+            // expand() constrains documentElement's page-axis dimension to one
+            // page size (width for horizontal, height for vertical).  Override
+            // with the full scroll dimension so all columns are rendered.
+            if (this.#vertical)
+                htmlWrapper.style.height = `${doc.documentElement.scrollHeight}px`
+            else
+                htmlWrapper.style.width = `${doc.documentElement.scrollWidth}px`
+            htmlWrapper.appendChild(bodyClone)
+            this.#loupeScaler = doc.createElement('div')
+            this.#loupeScaler.appendChild(htmlWrapper)
+            const cursorLen = Math.round(diameter * 0.24)
+            this.#loupeCursor = doc.createElement('div')
+            this.#loupeCursor.style.cssText = isVertical
+                ? `position:absolute;left:calc(50% - ${cursorLen / 2}px);top:50%;`
+                + `margin-top:-1px;width:${cursorLen}px;height:2px;background:${color};pointer-events:none;z-index:1;box-sizing:border-box;`
+                : `position:absolute;left:50%;top:calc(50% - ${cursorLen / 2}px);`
+                + `margin-left:-1px;width:2px;height:${cursorLen}px;background:${color};pointer-events:none;z-index:1;box-sizing:border-box;`
+            this.#loupeEl.appendChild(this.#loupeScaler)
+            this.#loupeEl.appendChild(this.#loupeCursor)
+            doc.documentElement.appendChild(this.#loupeEl)
+            // Static loupe shell styles (set once).
+            this.#loupeEl.style.cssText = `
+                position: absolute;
+                width: ${diameter}px;
+                height: ${diameter}px;
+                border-radius: 50%;
+                overflow: hidden;
+                border: 2.5px solid ${color};
+                box-shadow: 0 6px 24px rgba(0,0,0,0.28);
+                background-color: var(--theme-bg-color);
+                z-index: 9999;
+                pointer-events: none;
+                user-select: none;
+                box-sizing: border-box;
+            `
+        }
+        // Update only the dynamic position values (fast path on every move).
+        this.#loupeScaler.style.cssText = `
+            position: absolute;
+            left: ${offsetX}px;
+            top: ${offsetY}px;
+            width: ${doc.documentElement.scrollWidth}px;
+            height: ${doc.documentElement.scrollHeight}px;
+            transform: scale(${MAGNIFICATION});
+            transform-origin: 0 0;
+            pointer-events: none;
+        `
+        this.#loupeEl.style.left = `${loupeLeft + scrollX}px`
+        this.#loupeEl.style.top = `${loupeTop + scrollY}px`
+        // Cut a circular hole in the overlayer so highlights don't paint
+        // over the loupe.
+        if (this.#overlayer) {
+            const overlayerRect = this.#overlayer.element.getBoundingClientRect()
+            const dx = frameRect.left - overlayerRect.left
+            const dy = frameRect.top - overlayerRect.top
+            const cx = loupeLeft + radius + dx
+            const cy = loupeTop + radius + dy
+            const maskRadius = radius + 3
+            this.#overlayer.setHole(cx, cy, maskRadius)
+        }
+    }
+    hideLoupe() {
+        if (this.#loupeEl) {
+            this.#loupeEl.remove()
+            this.#loupeEl = null
+            this.#loupeScaler = null
+            this.#loupeCursor = null
+        }
+        if (this.#overlayer)
+            this.#overlayer.clearHole()
+    }
+    destroy() {
+        if (this.document) this.#observer.unobserve(this.document.body)
+    }
+}
+// NOTE: everything here assumes the so-called "negative scroll type" for RTL
+export class Paginator extends HTMLElement {
+    static observedAttributes = [
+        'flow', 'gap', 'margin-top', 'margin-bottom', 'margin-left', 'margin-right',
+        'max-inline-size', 'max-block-size', 'max-column-count',
+    ]
+    #root = this.attachShadow({ mode: 'open' })
+    #observer = new ResizeObserver(() => this.render())
+    #top
+    #background
+    #container
+    #header
+    #footer
+    #view
+    #vertical = false
+    #rtl = false
+    #marginTop = 0
+    #marginBottom = 0
+    #index = -1
+    #anchor = 0 // anchor view to a fraction (0-1), Range, or Element
+    #justAnchored = false
+    #locked = false // while true, prevent any further navigation
+    #styles
+    #styleMap = new WeakMap()
+    #mediaQuery = matchMedia('(prefers-color-scheme: dark)')
+    #mediaQueryListener
+    #scrollBounds
+    #touchState
+    #touchScrolled
+    #lastVisibleRange
+    #scrollLocked = false
+    constructor() {
+        super()
+        this.#root.innerHTML = `<style>
+        :host {
+            display: block;
+            container-type: size;
+        }
+        :host, #top {
+            box-sizing: border-box;
+            position: relative;
+            overflow: hidden;
+            width: 100%;
+            height: 100%;
+        }
+        #top {
+            --_gap: 7%;
+            --_margin-top: 48px;
+            --_margin-right: 48px;
+            --_margin-bottom: 48px;
+            --_margin-left: 48px;
+            --_max-inline-size: 720px;
+            --_max-block-size: 1440px;
+            --_max-column-count: 2;
+            --_max-column-count-portrait: var(--_max-column-count);
+            --_max-column-count-spread: var(--_max-column-count);
+            --_half-gap: calc(var(--_gap) / 2);
+            --_half-margin-left: calc(var(--_margin-left) / 2);
+            --_half-margin-right: calc(var(--_margin-right) / 2);
+            --_max-width: calc(var(--_max-inline-size) * var(--_max-column-count-spread));
+            --_max-height: var(--_max-block-size);
+            display: grid;
+            grid-template-columns:
+                minmax(0, 1fr)
+                var(--_margin-left)
+                minmax(0, calc(var(--_max-width) - var(--_gap)))
+                var(--_margin-right)
+                minmax(0, 1fr);
+            grid-template-rows:
+                minmax(var(--_margin-top), 1fr)
+                minmax(0, var(--_max-height))
+                minmax(var(--_margin-bottom), 1fr);
+            &.vertical {
+                --_max-column-count-spread: var(--_max-column-count-portrait);
+                --_max-width: var(--_max-block-size);
+                --_max-height: calc(var(--_max-inline-size) * var(--_max-column-count-spread));
+            }
+            @container (orientation: portrait) {
+                & {
+                    --_max-column-count-spread: var(--_max-column-count-portrait);
+                }
+                &.vertical {
+                    --_max-column-count-spread: var(--_max-column-count);
+                }
+            }
+        }
+        #background {
+            grid-column: 1 / -1;
+            grid-row: 1 / -1;
+        }
+        #container {
+            grid-column: 2 / 5;
+            grid-row: 1 / -1;
+            overflow: hidden;
+        }
+        :host([flow="scrolled"]) #container {
+            grid-column: 2 / 5;
+            grid-row: 1 / -1;
+            overflow: auto;
+        }
+        #header {
+            grid-column: 3 / 4;
+            grid-row: 1;
+        }
+        #footer {
+            grid-column: 3 / 4;
+            grid-row: 3;
+            align-self: end;
+        }
+        #header {
+            display: grid;
+            height: var(--_margin-top);
+        }
+        #footer {
+            display: grid;
+            height: var(--_margin-bottom);
+        }
+        :is(#header, #footer) > * {
+            display: flex;
+            align-items: center;
+            min-width: 0;
+        }
+        :is(#header, #footer) > * > * {
+            width: 100%;
+            overflow: hidden;
+            white-space: nowrap;
+            text-overflow: ellipsis;
+            text-align: center;
+            font-size: .75em;
+            opacity: .6;
+        }
+        </style>
+        <div id="top">
+            <div id="background" part="filter"></div>
+            <div id="header"></div>
+            <div id="container" part="container"></div>
+            <div id="footer"></div>
+        </div>
+        `
+        this.#top = this.#root.getElementById('top')
+        this.#background = this.#root.getElementById('background')
+        this.#container = this.#root.getElementById('container')
+        this.#header = this.#root.getElementById('header')
+        this.#footer = this.#root.getElementById('footer')
+        this.#observer.observe(this.#container)
+        this.#container.addEventListener('scroll', () => this.dispatchEvent(new Event('scroll')))
+        this.#container.addEventListener('scroll', debounce(() => {
+            if (this.scrolled) {
+                if (this.#justAnchored) this.#justAnchored = false
+                else this.#afterScroll('scroll')
+            }
+        }, 250))
+        const opts = { passive: false }
+        this.addEventListener('touchstart', this.#onTouchStart.bind(this), opts)
+        this.addEventListener('touchmove', this.#onTouchMove.bind(this), opts)
+        this.addEventListener('touchend', this.#onTouchEnd.bind(this))
+        this.addEventListener('load', ({ detail: { doc } }) => {
+            doc.addEventListener('touchstart', this.#onTouchStart.bind(this), opts)
+            doc.addEventListener('touchmove', this.#onTouchMove.bind(this), opts)
+            doc.addEventListener('touchend', this.#onTouchEnd.bind(this))
+        })
+        this.addEventListener('relocate', ({ detail }) => {
+            if (detail.reason === 'selection') setSelectionTo(this.#anchor, 0)
+            else if (detail.reason === 'navigation') {
+                if (this.#anchor === 1) setSelectionTo(detail.range, 1)
+                else if (typeof this.#anchor === 'number')
+                    setSelectionTo(detail.range, -1)
+                else setSelectionTo(this.#anchor, -1)
+            }
+        })
+        const checkPointerSelection = debounce((range, sel) => {
+            if (!sel.rangeCount) return
+            const selRange = sel.getRangeAt(0)
+            const backward = selectionIsBackward(sel)
+            if (backward && selRange.compareBoundaryPoints(Range.START_TO_START, range) < 0)
+                this.prev()
+            else if (!backward && selRange.compareBoundaryPoints(Range.END_TO_END, range) > 0)
+                this.next()
+        }, 700)
+        this.addEventListener('load', ({ detail: { doc } }) => {
+            let isPointerSelecting = false
+            doc.addEventListener('pointerdown', () => isPointerSelecting = true)
+            doc.addEventListener('pointerup', () => isPointerSelecting = false)
+            let isKeyboardSelecting = false
+            doc.addEventListener('keydown', () => isKeyboardSelecting = true)
+            doc.addEventListener('keyup', () => isKeyboardSelecting = false)
+            doc.addEventListener('selectionchange', () => {
+                if (this.scrolled) return
+                const range = this.#lastVisibleRange
+                if (!range) return
+                const sel = doc.getSelection()
+                if (!sel.rangeCount) return
+                // FIXME: this won't work on Android WebView, disable for now
+                if (!isPointerSelecting && isPointerSelecting && sel.type === 'Range')
+                    checkPointerSelection(range, sel)
+                else if (isKeyboardSelecting) {
+                    const selRange = sel.getRangeAt(0).cloneRange()
+                    const backward = selectionIsBackward(sel)
+                    if (!backward) selRange.collapse()
+                    this.#scrollToAnchor(selRange)
+                }
+            })
+            doc.addEventListener('focusin', e => {
+                if (this.scrolled) return null
+                if (this.#container && this.#container.contains(e.target)) {
+                    // NOTE: `requestAnimationFrame` is needed in WebKit
+                    requestAnimationFrame(() => this.#scrollToAnchor(e.target))
+                }
+            })
+        })
+        this.#mediaQueryListener = () => {
+            if (!this.#view) return
+            this.#replaceBackground(this.#view.docBackground, this.columnCount)
+        }
+        this.#mediaQuery.addEventListener('change', this.#mediaQueryListener)
+    }
+    attributeChangedCallback(name, _, value) {
+        switch (name) {
+            case 'flow':
+                this.render()
+                break
+            case 'gap':
+            case 'margin-top':
+            case 'margin-bottom':
+            case 'margin-left':
+            case 'margin-right':
+            case 'max-block-size':
+            case 'max-column-count':
+                this.#top.style.setProperty('--_' + name, value)
+                this.render()
+                break
+            case 'max-inline-size':
+                // needs explicit `render()` as it doesn't necessarily resize
+                this.#top.style.setProperty('--_' + name, value)
+                this.render()
+                break
+        }
+    }
+    open(book) {
+        this.bookDir = book.dir
+        this.sections = book.sections
+        book.transformTarget?.addEventListener('data', ({ detail }) => {
+            if (detail.type !== 'text/css') return
+            detail.data = Promise.resolve(detail.data).then(data => data
+                // unprefix as most of the props are (only) supported unprefixed
+                .replace(/([{\s;])-epub-/gi, '$1')
+                // `page-break-*` unsupported in columns; replace with `column-break-*`
+                .replace(/page-break-(after|before|inside)\s*:/gi, (_, x) =>
+                    `-webkit-column-break-${x}:`)
+                .replace(/break-(after|before|inside)\s*:\s*(avoid-)?page/gi, (_, x, y) =>
+                    `break-${x}: ${y ?? ''}column`))
+        })
+    }
+    #createView() {
+        if (this.#view) {
+            this.#view.destroy()
+            this.#container.removeChild(this.#view.element)
+        }
+        this.#view = new View({
+            container: this,
+            onExpand: () => this.#scrollToAnchor(this.#anchor),
+        })
+        this.#container.append(this.#view.element)
+        return this.#view
+    }
+    #replaceBackground(background, columnCount) {
+        const doc = this.#view?.document
+        if (!doc) return
+        const htmlStyle = doc.defaultView.getComputedStyle(doc.documentElement)
+        const themeBgColor = htmlStyle.getPropertyValue('--theme-bg-color')
+        const overrideColor = htmlStyle.getPropertyValue('--override-color') === 'true'
+        const bgTextureId = htmlStyle.getPropertyValue('--bg-texture-id')
+        const isDarkMode = htmlStyle.getPropertyValue('color-scheme') === 'dark'
+        if (background && themeBgColor) {
+            const parsedBackground = background.split(/\s(?=(?:url|rgb|hsl|#[0-9a-fA-F]{3,6}))/)
+            if ((isDarkMode || overrideColor) && (bgTextureId === 'none' || !bgTextureId)) {
+                parsedBackground[0] = themeBgColor
+            }
+            background = parsedBackground.join(' ')
+        }
+        this.#background.innerHTML = ''
+        this.#background.style.display = 'grid'
+        this.#background.style.gridTemplateColumns = `repeat(${columnCount}, 1fr)`
+        for (let i = 0; i < columnCount; i++) {
+            const column = document.createElement('div')
+            column.style.background = background
+            column.style.width = '100%'
+            column.style.height = '100%'
+            this.#background.appendChild(column)
+        }
+    }
+    #beforeRender({ vertical, rtl, background }) {
+        this.#vertical = vertical
+        this.#rtl = rtl
+        this.#top.classList.toggle('vertical', vertical)
+        const { width, height } = this.#container.getBoundingClientRect()
+        const size = vertical ? height : width
+        const style = getComputedStyle(this.#top)
+        const maxInlineSize = parseFloat(style.getPropertyValue('--_max-inline-size'))
+        const maxColumnCount = parseInt(style.getPropertyValue('--_max-column-count-spread'))
+        const marginTop = parseFloat(style.getPropertyValue('--_margin-top'))
+        const marginRight = parseFloat(style.getPropertyValue('--_margin-right'))
+        const marginBottom = parseFloat(style.getPropertyValue('--_margin-bottom'))
+        const marginLeft = parseFloat(style.getPropertyValue('--_margin-left'))
+        this.#marginTop = marginTop
+        this.#marginBottom = marginBottom
+        const g = parseFloat(style.getPropertyValue('--_gap')) / 100
+        // The gap will be a percentage of the #container, not the whole view.
+        // This means the outer padding will be bigger than the column gap. Let
+        // `a` be the gap percentage. The actual percentage for the column gap
+        // will be (1 - a) * a. Let us call this `b`.
+        //
+        // To make them the same, we start by shrinking the outer padding
+        // setting to `b`, but keep the column gap setting the same at `a`. Then
+        // the actual size for the column gap will be (1 - b) * a. Repeating the
+        // process again and again, we get the sequence
+        //     x₁ = (1 - b) * a
+        //     x₂ = (1 - x₁) * a
+        //     ...
+        // which converges to x = (1 - x) * a. Solving for x, x = a / (1 + a).
+        // So to make the spacing even, we must shrink the outer padding with
+        //     f(x) = x / (1 + x).
+        // But we want to keep the outer padding, and make the inner gap bigger.
+        // So we apply the inverse, f⁻¹ = -x / (x - 1) to the column gap.
+        const gap = -g / (g - 1) * size
+        const flow = this.getAttribute('flow')
+        if (flow === 'scrolled') {
+            // FIXME: vertical-rl only, not -lr
+            this.setAttribute('dir', vertical ? 'rtl' : 'ltr')
+            this.#top.style.padding = '0'
+            const columnWidth = maxInlineSize
+            this.heads = null
+            this.feet = null
+            this.#header.replaceChildren()
+            this.#footer.replaceChildren()
+            this.columnCount = 1
+            this.#replaceBackground(background, this.columnCount)
+            return { flow, marginTop, marginRight, marginBottom, marginLeft, gap, columnWidth }
+        }
+        const divisor = Math.min(maxColumnCount + (vertical ? 1 : 0), Math.ceil(Math.floor(size) / Math.floor(maxInlineSize)))
+        const columnWidth = vertical
+            ? (size / divisor - marginTop * 1.5 - marginBottom * 1.5)
+            : (size / divisor - gap - marginRight / 2 - marginLeft / 2)
+        this.setAttribute('dir', rtl ? 'rtl' : 'ltr')
+        // set background to `doc` background
+        // this is needed because the iframe does not fill the whole element
+        this.columnCount = divisor
+        this.#replaceBackground(background, this.columnCount)
+        const marginalDivisor = vertical
+            ? Math.min(2, Math.ceil(Math.floor(width) / Math.floor(maxInlineSize)))
+            : divisor
+        const marginalStyle = {
+            gridTemplateColumns: `repeat(${marginalDivisor}, 1fr)`,
+            gap: `${gap}px`,
+            direction: this.bookDir === 'rtl' ? 'rtl' : 'ltr',
+        }
+        Object.assign(this.#header.style, marginalStyle)
+        Object.assign(this.#footer.style, marginalStyle)
+        const heads = makeMarginals(marginalDivisor, 'head')
+        const feet = makeMarginals(marginalDivisor, 'foot')
+        this.heads = heads.map(el => el.children[0])
+        this.feet = feet.map(el => el.children[0])
+        this.#header.replaceChildren(...heads)
+        this.#footer.replaceChildren(...feet)
+        return { height, width, marginTop, marginRight, marginBottom, marginLeft, gap, columnWidth }
+    }
+    render() {
+        if (!this.#view) return
+        this.#view.render(this.#beforeRender({
+            vertical: this.#vertical,
+            rtl: this.#rtl,
+            background: this.#view.docBackground,
+        }))
+        this.#scrollToAnchor(this.#anchor)
+    }
+    get scrolled() {
+        return this.getAttribute('flow') === 'scrolled'
+    }
+    get scrollProp() {
+        const { scrolled } = this
+        return this.#vertical ? (scrolled ? 'scrollLeft' : 'scrollTop')
+            : scrolled ? 'scrollTop' : 'scrollLeft'
+    }
+    get sideProp() {
+        const { scrolled } = this
+        return this.#vertical ? (scrolled ? 'width' : 'height')
+            : scrolled ? 'height' : 'width'
+    }
+    get size() {
+        return this.#container.getBoundingClientRect()[this.sideProp]
+    }
+    get viewSize() {
+        if (!this.#view || !this.#view.element) return 0
+        return this.#view.element.getBoundingClientRect()[this.sideProp]
+    }
+    get start() {
+        return Math.abs(this.#container[this.scrollProp])
+    }
+    get end() {
+        return this.start + this.size
+    }
+    get page() {
+        return Math.floor(((this.start + this.end) / 2) / this.size)
+    }
+    get pages() {
+        return Math.round(this.viewSize / this.size)
+    }
+    get containerPosition() {
+        return this.#container[this.scrollProp]
+    }
+    get isOverflowX() {
+        return false
+    }
+    get isOverflowY() {
+        return false
+    }
+    set containerPosition(newVal) {
+        this.#container[this.scrollProp] = newVal
+    }
+    set scrollLocked(value) {
+        this.#scrollLocked = value
+    }
+    scrollBy(dx, dy) {
+        const delta = this.#vertical ? dy : dx
+        const [offset, a, b] = this.#scrollBounds
+        const rtl = this.#rtl
+        const min = rtl ? offset - b : offset - a
+        const max = rtl ? offset + a : offset + b
+        this.containerPosition = Math.max(min, Math.min(max,
+            this.containerPosition + delta))
+    }
+    snap(vx, vy) {
+        const velocity = this.#vertical ? vy : vx
+        const horizontal = Math.abs(vx) * 2 > Math.abs(vy)
+        const orthogonal = this.#vertical ? !horizontal : horizontal
+        const [offset, a, b] = this.#scrollBounds
+        const { start, end, pages, size } = this
+        const min = Math.abs(offset) - a
+        const max = Math.abs(offset) + b
+        const d = velocity * (this.#rtl ? -size : size) * (orthogonal ? 1 : 0)
+        const page = Math.floor(
+            Math.max(min, Math.min(max, (start + end) / 2
+                + (isNaN(d) ? 0 : d * 2))) / size)
+        this.#scrollToPage(page, 'snap').then(() => {
+            const dir = page <= 0 ? -1 : page >= pages - 1 ? 1 : null
+            if (dir) return this.#goTo({
+                index: this.#adjacentIndex(dir),
+                anchor: dir < 0 ? () => 1 : () => 0,
+            })
+        })
+    }
+    #onTouchStart(e) {
+        const touch = e.changedTouches[0]
+        this.#touchState = {
+            x: touch?.screenX, y: touch?.screenY,
+            t: e.timeStamp,
+            vx: 0, xy: 0,
+            dx: 0, dy: 0,
+        }
+    }
+    #onTouchMove(e) {
+        const state = this.#touchState
+        if (state.pinched) return
+        state.pinched = globalThis.visualViewport.scale > 1
+        if (this.scrolled || state.pinched) return
+        if (e.touches.length > 1) {
+            if (this.#touchScrolled) e.preventDefault()
+            return
+        }
+        const doc = this.#view?.document
+        const selection = doc?.getSelection()
+        if (selection && selection.rangeCount > 0 && !selection.isCollapsed) {
+            return
+        }
+        const touch = e.changedTouches[0]
+        const isStylus = touch.touchType === 'stylus'
+        if (!isStylus) e.preventDefault()
+        if (this.#scrollLocked) return
+        const x = touch.screenX, y = touch.screenY
+        const dx = state.x - x, dy = state.y - y
+        const dt = e.timeStamp - state.t
+        state.x = x
+        state.y = y
+        state.t = e.timeStamp
+        state.vx = dx / dt
+        state.vy = dy / dt
+        state.dx += dx
+        state.dy += dy
+        this.#touchScrolled = true
+        if (!this.hasAttribute('animated') || this.hasAttribute('eink')) return
+        if (!this.#vertical && Math.abs(state.dx) >= Math.abs(state.dy) && !this.hasAttribute('eink') && (!isStylus || Math.abs(dx) > 1)) {
+            this.scrollBy(dx, 0)
+        } else if (this.#vertical && Math.abs(state.dx) < Math.abs(state.dy) && !this.hasAttribute('eink') && (!isStylus || Math.abs(dy) > 1)) {
+            this.scrollBy(0, dy)
+        }
+    }
+    #onTouchEnd() {
+        if (!this.#touchScrolled) return
+        this.#touchScrolled = false
+        if (this.scrolled) return
+        // XXX: Firefox seems to report scale as 1... sometimes...?
+        // at this point I'm basically throwing `requestAnimationFrame` at
+        // anything that doesn't work
+        requestAnimationFrame(() => {
+            if (globalThis.visualViewport.scale === 1)
+                this.snap(this.#touchState.vx, this.#touchState.vy)
+        })
+    }
+    // allows one to process rects as if they were LTR and horizontal
+    #getRectMapper() {
+        if (this.scrolled) {
+            const size = this.viewSize
+            const marginTop = this.#marginTop
+            const marginBottom = this.#marginBottom
+            return this.#vertical
+                ? ({ left, right }) =>
+                    ({ left: size - right - marginTop, right: size - left - marginBottom })
+                : ({ top, bottom }) => ({ left: top - marginTop, right: bottom - marginBottom })
+        }
+        const pxSize = this.pages * this.size
+        return this.#rtl
+            ? ({ left, right }) =>
+                ({ left: pxSize - right, right: pxSize - left })
+            : this.#vertical
+                ? ({ top, bottom }) => ({ left: top, right: bottom })
+                : f => f
+    }
+    async #scrollToRect(rect, reason) {
+        if (this.scrolled) {
+            const offset = this.#getRectMapper()(rect).left - 4
+            return this.#scrollTo(offset, reason)
+        }
+        const offset = this.#getRectMapper()(rect).left
+        return this.#scrollToPage(Math.floor(offset / this.size) + (this.#rtl ? -1 : 1), reason)
+    }
+    async #scrollTo(offset, reason, smooth) {
+        const { size } = this
+        if (this.containerPosition === offset) {
+            this.#scrollBounds = [offset, this.atStart ? 0 : size, this.atEnd ? 0 : size]
+            this.#afterScroll(reason)
+            return
+        }
+        // FIXME: vertical-rl only, not -lr
+        if (this.scrolled && this.#vertical) offset = -offset
+        if ((reason === 'snap' || smooth) && this.hasAttribute('animated') && !this.hasAttribute('eink')) return animate(
+            this.containerPosition, offset, 300, easeOutQuad,
+            x => this.containerPosition = x,
+        ).then(() => {
+            this.#scrollBounds = [offset, this.atStart ? 0 : size, this.atEnd ? 0 : size]
+            this.#afterScroll(reason)
+        })
+        else {
+            this.containerPosition = offset
+            this.#scrollBounds = [offset, this.atStart ? 0 : size, this.atEnd ? 0 : size]
+            this.#afterScroll(reason)
+        }
+    }
+    async #scrollToPage(page, reason, smooth) {
+        const offset = this.size * (this.#rtl ? -page : page)
+        return this.#scrollTo(offset, reason, smooth)
+    }
+    async scrollToAnchor(anchor, select) {
+        return this.#scrollToAnchor(anchor, select ? 'selection' : 'navigation')
+    }
+    async #scrollToAnchor(anchor, reason = 'anchor') {
+        this.#anchor = anchor
+        const rects = uncollapse(anchor)?.getClientRects?.()
+        // if anchor is an element or a range
+        if (rects) {
+            // when the start of the range is immediately after a hyphen in the
+            // previous column, there is an extra zero width rect in that column
+            const rect = Array.from(rects)
+                .find(r => r.width > 0 && r.height > 0 && r.x >= 0 && r.y >= 0) || rects[0]
+            if (!rect) return
+            await this.#scrollToRect(rect, reason)
+            // focus the element when navigating with keyboard or screen reader
+            if (reason === 'navigation') {
+                let node = anchor.focus ? anchor : undefined
+                if (!node && anchor.startContainer) {
+                    node = anchor.startContainer
+                    if (node.nodeType === Node.TEXT_NODE) {
+                        node = node.parentElement
+                    }
+                }
+                if (node && node.focus) {
+                    node.tabIndex = -1
+                    node.style.outline = 'none'
+                    node.focus({ preventScroll: true })
+                }
+            }
+            return
+        }
+        // if anchor is a fraction
+        if (this.scrolled) {
+            await this.#scrollTo(anchor * this.viewSize, reason)
+            return
+        }
+        const { pages } = this
+        if (!pages) return
+        const textPages = pages - 2
+        const newPage = Math.round(anchor * (textPages - 1))
+        await this.#scrollToPage(newPage + 1, reason)
+    }
+    #getVisibleRange() {
+        if (this.scrolled) return getVisibleRange(this.#view.document,
+            this.start, this.end, this.#getRectMapper())
+        const size = this.#rtl ? -this.size : this.size
+        return getVisibleRange(this.#view.document,
+            this.start - size, this.end - size, this.#getRectMapper())
+    }
+    #afterScroll(reason) {
+        const range = this.#getVisibleRange()
+        this.#lastVisibleRange = range
+        // don't set new anchor if relocation was to scroll to anchor
+        if (reason !== 'selection' && reason !== 'navigation' && reason !== 'anchor')
+            this.#anchor = range
+        else this.#justAnchored = true
+        const index = this.#index
+        const detail = { reason, range, index }
+        if (this.scrolled) detail.fraction = this.start / this.viewSize
+        else if (this.pages > 0) {
+            const { page, pages } = this
+            this.#header.style.visibility = page > 1 ? 'visible' : 'hidden'
+            detail.fraction = (page - 1) / (pages - 2)
+            detail.size = 1 / (pages - 2)
+        }
+        this.dispatchEvent(new CustomEvent('relocate', { detail }))
+    }
+    async #display(promise) {
+        const { index, src, data, anchor, onLoad, select } = await promise
+        this.#index = index
+        const hasFocus = this.#view?.document?.hasFocus()
+        if (src) {
+            const view = this.#createView()
+            const afterLoad = doc => {
+                if (doc.head) {
+                    const $styleBefore = doc.createElement('style')
+                    doc.head.prepend($styleBefore)
+                    const $style = doc.createElement('style')
+                    doc.head.append($style)
+                    this.#styleMap.set(doc, [$styleBefore, $style])
+                }
+                onLoad?.({ doc, index })
+            }
+            const beforeRender = this.#beforeRender.bind(this)
+            await view.load(src, data, afterLoad, beforeRender)
+            this.dispatchEvent(new CustomEvent('create-overlayer', {
+                detail: {
+                    doc: view.document, index,
+                    attach: overlayer => view.overlayer = overlayer,
+                },
+            }))
+            this.#view = view
+        }
+        await this.scrollToAnchor((typeof anchor === 'function'
+            ? anchor(this.#view.document) : anchor) ?? 0, select)
+        if (hasFocus) this.focusView()
+    }
+    #canGoToIndex(index) {
+        return index >= 0 && index <= this.sections.length - 1
+    }
+    async #goTo({ index, anchor, select }) {
+        if (index === this.#index) await this.#display({ index, anchor, select })
+        else {
+            const oldIndex = this.#index
+            const onLoad = detail => {
+                this.sections[oldIndex]?.unload?.()
+                this.setStyles(this.#styles)
+                this.dispatchEvent(new CustomEvent('load', { detail }))
+            }
+            await this.#display(Promise.resolve(this.sections[index].load())
+                .then(async src => {
+                    const data = await this.sections[index].loadContent?.()
+                    return { index, src, data, anchor, onLoad, select }
+                }).catch(e => {
+                    console.warn(e)
+                    console.warn(new Error(`Failed to load section ${index}`))
+                    return {}
+                }))
+        }
+    }
+    async goTo(target) {
+        if (this.#locked) return
+        const resolved = await target
+        if (this.#canGoToIndex(resolved.index)) return this.#goTo(resolved)
+    }
+    #scrollPrev(distance) {
+        if (!this.#view) return true
+        if (this.scrolled) {
+            if (this.start > 0) return this.#scrollTo(
+                Math.max(0, this.start - (distance ?? this.size)), null, true)
+            return !this.atStart
+        }
+        if (this.atStart) return
+        const page = this.page - 1
+        return this.#scrollToPage(page, 'page', true).then(() => page <= 0)
+    }
+    #scrollNext(distance) {
+        if (!this.#view) return true
+        if (this.scrolled) {
+            if (this.viewSize - this.end > 2) return this.#scrollTo(
+                Math.min(this.viewSize, distance ? this.start + distance : this.end), null, true)
+            return !this.atEnd
+        }
+        if (this.atEnd) return
+        const page = this.page + 1
+        const pages = this.pages
+        return this.#scrollToPage(page, 'page', true).then(() => page >= pages - 1)
+    }
+    get atStart() {
+        return this.#adjacentIndex(-1) == null && this.page <= 1
+    }
+    get atEnd() {
+        return this.#adjacentIndex(1) == null && this.page >= this.pages - 2
+    }
+    #adjacentIndex(dir) {
+        for (let index = this.#index + dir; this.#canGoToIndex(index); index += dir)
+            if (this.sections[index]?.linear !== 'no') return index
+    }
+    async #turnPage(dir, distance) {
+        if (this.#locked) return
+        this.#locked = true
+        const prev = dir === -1
+        const shouldGo = await (prev ? this.#scrollPrev(distance) : this.#scrollNext(distance))
+        if (shouldGo) await this.#goTo({
+            index: this.#adjacentIndex(dir),
+            anchor: prev ? () => 1 : () => 0,
+        })
+        if (shouldGo || !this.hasAttribute('animated')) await wait(100)
+        this.#locked = false
+    }
+    async prev(distance) {
+        return await this.#turnPage(-1, distance)
+    }
+    async next(distance) {
+        return await this.#turnPage(1, distance)
+    }
+    async pan(dx, dy) {
+        if (this.#locked) return
+        this.#locked = true
+        this.scrollBy(dx, dy)
+        this.#locked = false
+    }
+    prevSection() {
+        return this.goTo({ index: this.#adjacentIndex(-1) })
+    }
+    nextSection() {
+        return this.goTo({ index: this.#adjacentIndex(1) })
+    }
+    firstSection() {
+        const index = this.sections.findIndex(section => section.linear !== 'no')
+        return this.goTo({ index })
+    }
+    lastSection() {
+        const index = this.sections.findLastIndex(section => section.linear !== 'no')
+        return this.goTo({ index })
+    }
+    getContents() {
+        if (this.#view) return [{
+            index: this.#index,
+            overlayer: this.#view.overlayer,
+            doc: this.#view.document,
+        }]
+        return []
+    }
+    setStyles(styles) {
+        this.#styles = styles
+        const $$styles = this.#styleMap.get(this.#view?.document)
+        if (!$$styles) return
+        const [$beforeStyle, $style] = $$styles
+        if (Array.isArray(styles)) {
+            const [beforeStyle, style] = styles
+            $beforeStyle.textContent = beforeStyle
+            $style.textContent = style
+        } else $style.textContent = styles
+        // NOTE: needs `requestAnimationFrame` in Chromium
+        requestAnimationFrame(() => {
+            this.#replaceBackground(this.#view.docBackground, this.columnCount)
+        })
+        // needed because the resize observer doesn't work in Firefox
+        this.#view?.document?.fonts?.ready?.then(() => this.#view.expand())
+    }
+    focusView() {
+        this.#view.document.defaultView.focus()
+    }
+    showLoupe(winX, winY, { isVertical, color, radius }) {
+        this.#view?.showLoupe(winX, winY, { isVertical, color, radius })
+    }
+    hideLoupe() {
+        this.#view?.hideLoupe()
+    }
+    destroy() {
+        this.#observer.unobserve(this)
+        this.#view.destroy()
+        this.#view = null
+        this.sections[this.#index]?.unload?.()
+        this.#mediaQuery.removeEventListener('change', this.#mediaQueryListener)
+    }
+}
+customElements.define('foliate-paginator', Paginator)

packages/foliate-js/pdf.js ADDED Viewed

	@@ -0,0 +1,315 @@

+const pdfjsPath = path => `/vendor/pdfjs/${path}`
+import '@pdfjs/pdf.min.mjs'
+const pdfjsLib = globalThis.pdfjsLib
+pdfjsLib.GlobalWorkerOptions.workerSrc = pdfjsPath('pdf.worker.min.mjs')
+const fetchText = async url => await (await fetch(url)).text()
+let textLayerBuilderCSS = null
+let annotationLayerBuilderCSS = null
+const render = async (page, doc, zoom) => {
+    if (!doc) return
+    const scale = zoom * devicePixelRatio
+    doc.documentElement.style.transform = `scale(${1 / devicePixelRatio})`
+    doc.documentElement.style.transformOrigin = 'top left'
+    doc.documentElement.style.setProperty('--total-scale-factor', scale)
+    doc.documentElement.style.setProperty('--user-unit', '1')
+    doc.documentElement.style.setProperty('--scale-round-x', '1px')
+    doc.documentElement.style.setProperty('--scale-round-y', '1px')
+    const viewport = page.getViewport({ scale })
+    // the canvas must be in the `PDFDocument`'s `ownerDocument`
+    // (`globalThis.document` by default); that's where the fonts are loaded
+    const canvas = document.createElement('canvas')
+    canvas.height = viewport.height
+    canvas.width = viewport.width
+    const canvasContext = canvas.getContext('2d')
+    await page.render({ canvasContext, viewport }).promise
+    const canvasElement = doc.querySelector('#canvas')
+    if (!canvasElement) return
+    canvasElement.replaceChildren(doc.adoptNode(canvas))
+    const container = doc.querySelector('.textLayer')
+    const textLayer = new pdfjsLib.TextLayer({
+        textContentSource: await page.streamTextContent(),
+        container, viewport,
+    })
+    await textLayer.render()
+    // hide "offscreen" canvases appended to document when rendering text layer
+    // https://github.com/mozilla/pdf.js/blob/642b9a5ae67ef642b9a8808fd9efd447e8c350e2/web/pdf_viewer.css#L51-L58
+    for (const canvas of document.querySelectorAll('.hiddenCanvasElement'))
+        Object.assign(canvas.style, {
+            position: 'absolute',
+            top: '0',
+            left: '0',
+            width: '0',
+            height: '0',
+            display: 'none',
+        })
+    // fix text selection
+    // https://github.com/mozilla/pdf.js/blob/642b9a5ae67ef642b9a8808fd9efd447e8c350e2/web/text_layer_builder.js#L105-L107
+    const endOfContent = document.createElement('div')
+    endOfContent.className = 'endOfContent'
+    container.append(endOfContent)
+    let isPanning = false
+    let startX = 0
+    let startY = 0
+    let scrollLeft = 0
+    let scrollTop = 0
+    let scrollParent = null
+    const findScrollableParent = (element) => {
+        let current = element
+        while (current) {
+            if (current !== document.body && current.nodeType === 1) {
+                const style = window.getComputedStyle(current)
+                const overflow = style.overflow + style.overflowY + style.overflowX
+                if (/(auto|scroll)/.test(overflow)) {
+                    if (current.scrollHeight > current.clientHeight ||
+                        current.scrollWidth > current.clientWidth) {
+                        return current
+                    }
+                }
+            }
+            if (current.parentElement) {
+                current = current.parentElement
+            } else if (current.parentNode && current.parentNode.host) {
+                current = current.parentNode.host
+            } else {
+                break
+            }
+        }
+        return window
+    }
+    container.onpointerdown = (e) => {
+        const selection = doc.getSelection()
+        const hasTextSelection = selection && selection.toString().length > 0
+        const elementUnderCursor = doc.elementFromPoint(e.clientX, e.clientY)
+        const hasTextUnderneath = elementUnderCursor &&
+                             (elementUnderCursor.tagName === 'SPAN' || elementUnderCursor.tagName === 'P') &&
+                             elementUnderCursor.textContent.trim().length > 0
+        if (!hasTextUnderneath && !hasTextSelection) {
+            isPanning = true
+            startX = e.screenX
+            startY = e.screenY
+            const iframe = doc.defaultView.frameElement
+            if (iframe) {
+                scrollParent = findScrollableParent(iframe)
+                if (scrollParent === window) {
+                    scrollLeft = window.scrollX || window.pageXOffset
+                    scrollTop = window.scrollY || window.pageYOffset
+                } else {
+                    scrollLeft = scrollParent.scrollLeft
+                    scrollTop = scrollParent.scrollTop
+                }
+                container.style.cursor = 'grabbing'
+            }
+        } else {
+            container.classList.add('selecting')
+        }
+    }
+    container.onpointermove = (e) => {
+        if (isPanning && scrollParent) {
+            e.preventDefault()
+            const dx = e.screenX - startX
+            const dy = e.screenY - startY
+            if (scrollParent === window) {
+                window.scrollTo(scrollLeft - dx, scrollTop - dy)
+            } else {
+                scrollParent.scrollLeft = scrollLeft - dx
+                scrollParent.scrollTop = scrollTop - dy
+            }
+        }
+    }
+    container.onpointerup = () => {
+        if (isPanning) {
+            isPanning = false
+            scrollParent = null
+            container.style.cursor = 'grab'
+        } else {
+            container.classList.remove('selecting')
+        }
+    }
+    container.onpointerleave = () => {
+        if (isPanning) {
+            isPanning = false
+            scrollParent = null
+            container.style.cursor = 'grab'
+        }
+    }
+    doc.addEventListener('selectionchange', () => {
+        const selection = doc.getSelection()
+        if (selection && selection.toString().length > 0) {
+            container.style.cursor = 'text'
+        } else if (!isPanning) {
+            container.style.cursor = 'grab'
+        }
+    })
+    container.style.cursor = 'grab'
+    const div = doc.querySelector('.annotationLayer')
+    const linkService = {
+        goToDestination: () => {},
+        getDestinationHash: dest => JSON.stringify(dest),
+        addLinkAttributes: (link, url) => link.href = url,
+    }
+    await new pdfjsLib.AnnotationLayer({ page, viewport, div, linkService }).render({
+        annotations: await page.getAnnotations(),
+    })
+}
+const renderPage = async (page, getImageBlob) => {
+    const viewport = page.getViewport({ scale: 1 })
+    if (getImageBlob) {
+        const canvas = document.createElement('canvas')
+        canvas.height = viewport.height
+        canvas.width = viewport.width
+        const canvasContext = canvas.getContext('2d')
+        await page.render({ canvasContext, viewport }).promise
+        return new Promise(resolve => canvas.toBlob(resolve))
+    }
+    // https://github.com/mozilla/pdf.js/blob/642b9a5ae67ef642b9a8808fd9efd447e8c350e2/web/text_layer_builder.css
+    if (textLayerBuilderCSS == null) {
+        textLayerBuilderCSS = await fetchText(pdfjsPath('text_layer_builder.css'))
+    }
+    // https://github.com/mozilla/pdf.js/blob/642b9a5ae67ef642b9a8808fd9efd447e8c350e2/web/annotation_layer_builder.css
+    if (annotationLayerBuilderCSS == null) {
+        annotationLayerBuilderCSS = await fetchText(pdfjsPath('annotation_layer_builder.css'))
+    }
+    const data = `
+        <!DOCTYPE html>
+        <html lang="en">
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=${viewport.width}, height=${viewport.height}">
+        <style>
+        html, body {
+            margin: 0;
+            padding: 0;
+        }
+        ${textLayerBuilderCSS}
+        ${annotationLayerBuilderCSS}
+        </style>
+        <div id="canvas"></div>
+        <div class="textLayer"></div>
+        <div class="annotationLayer"></div>
+    `
+    const src = URL.createObjectURL(new Blob([data], { type: 'text/html' }))
+    const onZoom = ({ doc, scale }) => render(page, doc, scale)
+    return { src, data, onZoom }
+}
+const makeTOCItem = async (item, pdf) => {
+    let pageIndex = undefined
+    if (item.dest) {
+        try {
+            const dest = typeof item.dest === 'string'
+                ? await pdf.getDestination(item.dest)
+                : item.dest
+            if (dest?.[0]) {
+                pageIndex = await pdf.getPageIndex(dest[0])
+            }
+        } catch (e) {
+            console.warn('Failed to get page index for TOC item:', item.title, e)
+        }
+    }
+    return {
+        label: item.title,
+        href: item.dest ? JSON.stringify(item.dest) : '',
+        index: pageIndex,
+        subitems: item.items?.length
+            ? await Promise.all(item.items.map(i => makeTOCItem(i, pdf)))
+            : null,
+    }
+}
+export const makePDF = async file => {
+    const transport = new pdfjsLib.PDFDataRangeTransport(file.size, [])
+    transport.requestDataRange = (begin, end) => {
+        file.slice(begin, end).arrayBuffer().then(chunk => {
+            transport.onDataRange(begin, chunk)
+        })
+    }
+    const pdf = await pdfjsLib.getDocument({
+        range: transport,
+        wasmUrl: pdfjsPath(''),
+        cMapUrl: pdfjsPath('cmaps/'),
+        standardFontDataUrl: pdfjsPath('standard_fonts/'),
+        isEvalSupported: false,
+    }).promise
+    const book = { rendition: { layout: 'pre-paginated' } }
+    const { metadata, info } = await pdf.getMetadata() ?? {}
+    // TODO: for better results, parse `metadata.getRaw()`
+    book.metadata = {
+        title: metadata?.get('dc:title') ?? info?.Title,
+        author: metadata?.get('dc:creator') ?? info?.Author,
+        contributor: metadata?.get('dc:contributor'),
+        description: metadata?.get('dc:description') ?? info?.Subject,
+        language: metadata?.get('dc:language'),
+        publisher: metadata?.get('dc:publisher'),
+        subject: metadata?.get('dc:subject'),
+        identifier: metadata?.get('dc:identifier'),
+        source: metadata?.get('dc:source'),
+        rights: metadata?.get('dc:rights'),
+    }
+    const outline = await pdf.getOutline()
+    book.toc = outline ? await Promise.all(outline.map(item => makeTOCItem(item, pdf))) : null
+    const cache = new Map()
+    book.sections = Array.from({ length: pdf.numPages }).map((_, i) => ({
+        id: i,
+        load: async () => {
+            const cached = cache.get(i)
+            if (cached) return cached
+            const url = await renderPage(await pdf.getPage(i + 1))
+            cache.set(i, url)
+            return url
+        },
+        size: 1000,
+    }))
+    book.isExternal = uri => /^\w+:/i.test(uri)
+    book.resolveHref = async href => {
+        const parsed = JSON.parse(href)
+        const dest = typeof parsed === 'string'
+            ? await pdf.getDestination(parsed) : parsed
+        const index = await pdf.getPageIndex(dest[0])
+        return { index }
+    }
+    book.splitTOCHref = async href => {
+        if (!href) return [null, null]
+        const parsed = JSON.parse(href)
+        const dest = typeof parsed === 'string'
+            ? await pdf.getDestination(parsed) : parsed
+        try {
+            const index = await pdf.getPageIndex(dest[0])
+            return [index, null]
+        } catch (e) {
+            console.warn('Error getting page index for href', href)
+            return [null, null]
+        }
+    }
+    book.getTOCFragment = doc => doc.documentElement
+    book.getCover = async () => renderPage(await pdf.getPage(1), true)
+    book.destroy = () => pdf.destroy()
+    return book
+}

packages/foliate-js/progress.js ADDED Viewed

	@@ -0,0 +1,113 @@

+// assign a unique ID for each TOC item
+const assignIDs = toc => {
+    let id = 0
+    const assignID = item => {
+        item.id = id++
+        if (item.subitems) for (const subitem of item.subitems) assignID(subitem)
+    }
+    for (const item of toc) assignID(item)
+    return toc
+}
+const flatten = items => items
+    .map(item => item.subitems?.length
+        ? [item, flatten(item.subitems)].flat()
+        : item)
+    .flat()
+export class TOCProgress {
+    async init({ toc, ids, splitHref, getFragment }) {
+        assignIDs(toc)
+        const items = flatten(toc)
+        const grouped = new Map()
+        for (const [i, item] of items.entries()) {
+            const [id, fragment] = await splitHref(item?.href) ?? []
+            const value = { fragment, item }
+            if (grouped.has(id)) grouped.get(id).items.push(value)
+            else grouped.set(id, { prev: items[i - 1], items: [value] })
+        }
+        const map = new Map()
+        for (const [i, id] of ids.entries()) {
+            if (grouped.has(id)) map.set(id, grouped.get(id))
+            else map.set(id, map.get(ids[i - 1]))
+        }
+        this.ids = ids
+        this.map = map
+        this.getFragment = getFragment
+    }
+    getProgress(index, range) {
+        if (!this.ids) return
+        const id = this.ids[index]
+        const obj = this.map.get(id)
+        if (!obj) return null
+        const { prev, items } = obj
+        if (!items) return prev
+        if (!range || items.length === 1 && !items[0].fragment) return items[0].item
+        const doc = range.startContainer.getRootNode()
+        for (const [i, { fragment }] of items.entries()) {
+            const el = this.getFragment(doc, fragment)
+            if (!el) continue
+            if (range.comparePoint(el, 0) > 0)
+                return (items[i - 1]?.item ?? prev)
+        }
+        return items[items.length - 1].item
+    }
+}
+export class SectionProgress {
+    constructor(sections, sizePerLoc, sizePerTimeUnit) {
+        this.sizes = sections.map(s => s.linear != 'no' && s.size > 0 ? s.size : 0)
+        this.sizePerLoc = sizePerLoc
+        this.sizePerTimeUnit = sizePerTimeUnit
+        this.sizeTotal = this.sizes.reduce((a, b) => a + b, 0)
+        this.sectionFractions = this.#getSectionFractions()
+    }
+    #getSectionFractions() {
+        const { sizeTotal } = this
+        const results = [0]
+        let sum = 0
+        for (const size of this.sizes) results.push((sum += size) / sizeTotal)
+        return results
+    }
+    // get progress given index of and fractions within a section
+    getProgress(index, fractionInSection, pageFraction = 0) {
+        const { sizes, sizePerLoc, sizePerTimeUnit, sizeTotal } = this
+        const sizeInSection = sizes[index] ?? 0
+        const sizeBefore = sizes.slice(0, index).reduce((a, b) => a + b, 0)
+        const size = sizeBefore + fractionInSection * sizeInSection
+        const nextSize = size + pageFraction * sizeInSection
+        const remainingTotal = sizeTotal - size
+        const remainingSection = (1 - fractionInSection) * sizeInSection
+        return {
+            fraction: nextSize / sizeTotal,
+            section: {
+                current: index,
+                total: sizes.length,
+            },
+            location: {
+                current: Math.floor(size / sizePerLoc),
+                next: Math.floor(nextSize / sizePerLoc),
+                total: Math.ceil(sizeTotal / sizePerLoc),
+            },
+            time: {
+                section: remainingSection / sizePerTimeUnit,
+                total: remainingTotal / sizePerTimeUnit,
+            },
+        }
+    }
+    // the inverse of `getProgress`
+    // get index of and fraction in section based on total fraction
+    getSection(fraction) {
+        if (fraction <= 0) return [0, 0]
+        if (fraction >= 1) return [this.sizes.length - 1, 1]
+        fraction = fraction + Number.EPSILON
+        const { sizeTotal } = this
+        let index = this.sectionFractions.findIndex(x => x > fraction) - 1
+        if (index < 0) return [0, 0]
+        while (!this.sizes[index]) index++
+        const fractionInSection = (fraction - this.sectionFractions[index])
+            / (this.sizes[index] / sizeTotal)
+        return [index, fractionInSection]
+    }
+}

packages/foliate-js/quote-image.js ADDED Viewed

	@@ -0,0 +1,86 @@

+const SVG_NS = 'http://www.w3.org/2000/svg'
+// bisect
+const fit = (el, a = 1, b = 50) => {
+    const c = Math.floor(a + (b - a) / 2)
+    el.style.fontSize = `${c}px`
+    if (b - a === 1) return
+    if (el.scrollHeight > el.clientHeight
+    || el.scrollWidth > el.clientWidth) fit(el, a, c)
+    else fit(el, c, b)
+}
+const width = 540
+const height = 540
+const pixelRatio = 2
+const html = `<style>
+:host {
+    position: absolute;
+    width: 0;
+    height: 0;
+    overflow: hidden;
+    visibility: hidden;
+}
+</style>
+<main style="width: ${width}px; height: ${height}px; overflow: hidden; display: flex; flex-direction: column; justify-content: center; text-align: center; background: #fff; color: #000; font: 16pt serif">
+    <style>
+    .ellipsis {
+        overflow: hidden;
+        display: -webkit-box;
+        -webkit-box-orient: vertical;
+        -webkit-line-clamp: 2;
+        text-overflow: ellipsis;
+    }
+    </style>
+    <div style="font-size: min(4em, 8rem); line-height: 1; margin-bottom: -.5em">“</div>
+    <div id="text" style="margin: 1em; text-wrap: balance"></div>
+    <div style="margin: 0 1em">
+        <div style="font-size: min(.8em, 1.25rem); font-family: sans-serif">
+            <div style="display: block; font-weight: bold; margin-bottom: .25em">
+                <span id="author" class="ellipsis"></span>
+            </div>
+            <div style="display: block; text-wrap: balance">
+                <cite id="title" class="ellipsis"></cite>
+            </div>
+        </div>
+    </div>
+    <div style="height: 1em">&nbsp;</div>
+</main>`
+// TODO: lang, vertical writing
+customElements.define('foliate-quoteimage', class extends HTMLElement {
+    #root = this.attachShadow({ mode: 'closed' })
+    constructor() {
+        super()
+        this.#root.innerHTML = html
+    }
+    async getBlob({ title, author, text }) {
+        this.#root.querySelector('#title').textContent = title
+        this.#root.querySelector('#author').textContent = author
+        this.#root.querySelector('#text').innerText = text
+        fit(this.#root.querySelector('main'))
+        const img = document.createElement('img')
+        return new Promise(resolve => {
+            img.onload = () => {
+                const canvas = document.createElement('canvas')
+                canvas.width = pixelRatio * width
+                canvas.height = pixelRatio * height
+                const ctx = canvas.getContext('2d')
+                ctx.drawImage(img, 0, 0, canvas.width, canvas.height)
+                canvas.toBlob(resolve)
+            }
+            const doc = document.implementation.createDocument(SVG_NS, 'svg')
+            doc.documentElement.setAttribute('viewBox', `0 0 ${width} ${height}`)
+            const obj = doc.createElementNS(SVG_NS, 'foreignObject')
+            obj.setAttribute('width', width)
+            obj.setAttribute('height', height)
+            obj.append(doc.importNode(this.#root.querySelector('main'), true))
+            doc.documentElement.append(obj)
+            img.src = 'data:image/svg+xml;charset=utf-8,'
+                + new XMLSerializer().serializeToString(doc)
+        })
+    }
+})

packages/foliate-js/reader.html ADDED Viewed

	@@ -0,0 +1,304 @@

+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name="color-scheme" content="light dark">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' blob:; script-src 'self'; style-src 'self' blob: 'unsafe-inline'; img-src 'self' blob: data:; connect-src 'self' blob: data: *; frame-src blob: data:; object-src blob: data:; form-action 'none';">
+<title>E-Book Reader</title>
+<style>
+:root {
+    --active-bg: rgba(0, 0, 0, .05);
+}
+@supports (color-scheme: light dark) {
+    @media (prefers-color-scheme: dark) {
+        :root {
+            --active-bg: rgba(255, 255, 255, .1);
+        }
+    }
+}
+html {
+    height: 100%;
+}
+body {
+    margin: 0 auto;
+    height: 100%;
+    font: menu;
+    font-family: system-ui, sans-serif;
+}
+#drop-target {
+    height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    visibility: hidden;
+}
+#drop-target h1 {
+    font-weight: 900;
+}
+#file-button {
+    font: inherit;
+    background: none;
+    border: 0;
+    padding: 0;
+    text-decoration: underline;
+    cursor: pointer;
+}
+.icon {
+    display: block;
+    fill: none;
+    stroke: currentcolor;
+    stroke-width: 2px;
+}
+.empty-state-icon {
+    margin: auto;
+}
+.toolbar {
+    box-sizing: border-box;
+    position: absolute;
+    z-index: 1;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    height: 48px;
+    padding: 6px;
+    transition: opacity 250ms ease;
+    visibility: hidden;
+}
+.toolbar button {
+    padding: 3px;
+    border-radius: 6px;
+    background: none;
+    border: 0;
+    color: GrayText;
+}
+.toolbar button:hover {
+    background: rgba(0, 0, 0, .1);
+    color: currentcolor;
+}
+#header-bar {
+    top: 0;
+}
+#nav-bar {
+    bottom: 0;
+}
+#progress-slider {
+    flex-grow: 1;
+    margin: 0 12px;
+    visibility: hidden;
+}
+#side-bar {
+    visibility: hidden;
+    box-sizing: border-box;
+    position: absolute;
+    z-index: 2;
+    top: 0;
+    left: 0;
+    height: 100%;
+    width: 320px;
+    transform: translateX(-320px);
+    display: flex;
+    flex-direction: column;
+    background: Canvas;
+    color: CanvasText;
+    box-shadow: 0 0 0 1px rgba(0, 0, 0, .2), 0 0 40px rgba(0, 0, 0, .2);
+    transition: visibility 0s linear 300ms, transform 300ms ease;
+}
+#side-bar.show {
+    visibility: visible;
+    transform: translateX(0);
+    transition-delay: 0s;
+}
+#dimming-overlay {
+    visibility: hidden;
+    position: fixed;
+    z-index: 2;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, .2);
+    opacity: 0;
+    transition: visibility 0s linear 300ms, opacity 300ms ease;
+}
+#dimming-overlay.show {
+    visibility: visible;
+    opacity: 1;
+    transition-delay: 0s;
+}
+#side-bar-header {
+    padding: 1rem;
+    display: flex;
+    border-bottom: 1px solid rgba(0, 0, 0, .1);
+    align-items: center;
+}
+#side-bar-cover {
+    height: 10vh;
+    min-height: 60px;
+    max-height: 180px;
+    border-radius: 3px;
+    border: 0;
+    background: lightgray;
+    box-shadow: 0 0 1px rgba(0, 0, 0, .1), 0 0 16px rgba(0, 0, 0, .1);
+    margin-inline-end: 1rem;
+}
+#side-bar-cover:not([src]) {
+    display: none;
+}
+#side-bar-title {
+    margin: .5rem 0;
+    font-size: inherit;
+}
+#side-bar-author {
+    margin: .5rem 0;
+    font-size: small;
+    color: GrayText;
+}
+#toc-view {
+    padding: .5rem;
+    overflow-y: scroll;
+}
+#toc-view li, #toc-view ol {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+}
+#toc-view a, #toc-view span {
+    display: block;
+    border-radius: 6px;
+    padding: 8px;
+    margin: 2px 0;
+}
+#toc-view a {
+    color: CanvasText;
+    text-decoration: none;
+}
+#toc-view a:hover {
+    background: var(--active-bg);
+}
+#toc-view span {
+    color: GrayText;
+}
+#toc-view svg {
+    margin-inline-start: -24px;
+    padding-inline-start: 5px;
+    padding-inline-end: 6px;
+    fill: CanvasText;
+    cursor: default;
+    transition: transform .2s ease;
+    opacity: .5;
+}
+#toc-view svg:hover {
+    opacity: 1;
+}
+#toc-view [aria-current] {
+    font-weight: bold;
+    background: var(--active-bg);
+}
+#toc-view [aria-expanded="false"] svg {
+    transform: rotate(-90deg);
+}
+#toc-view [aria-expanded="false"] + [role="group"] {
+    display: none;
+}
+.menu-container {
+    position: relative;
+}
+.menu, .menu ul {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+.menu {
+    visibility: hidden;
+    position: absolute;
+    right: 0;
+    background: Canvas;
+    color: CanvasText;
+    border-radius: 6px;
+    box-shadow: 0 0 0 1px rgba(0, 0, 0, .2), 0 0 16px rgba(0, 0, 0, .1);
+    padding: 6px;
+    cursor: default;
+}
+.menu.show {
+    visibility: visible;
+}
+.menu li {
+    padding: 6px 12px;
+    padding-left: 24px;
+    border-radius: 6px;
+}
+.menu li:hover {
+    background: var(--active-bg);
+}
+.menu li[aria-checked="true"] {
+    background-position: center left;
+    background-repeat: no-repeat;
+    background-image: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2224%22%20height%3D%2224%22%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%223%22%2F%3E%3C%2Fsvg%3E');
+}
+.popover {
+    background: Canvas;
+    color: CanvasText;
+    border-radius: 6px;
+    box-shadow: 0 0 0 1px rgba(0, 0, 0, .2), 0 0 16px rgba(0, 0, 0, .1), 0 0 32px rgba(0, 0, 0, .1);
+}
+.popover-arrow-down {
+    fill: Canvas;
+    filter: drop-shadow(0 -1px 0 rgba(0, 0, 0, .2));
+}
+.popover-arrow-up {
+    fill: Canvas;
+    filter: drop-shadow(0 1px 0 rgba(0, 0, 0, .2));
+}
+</style>
+<input type="file" id="file-input" hidden>
+<div id="drop-target" class="filter">
+    <div>
+        <svg class="icon empty-state-icon" width="72" height="72" aria-hidden="true">
+            <path d="M36 18s-6-6-12-6-15 6-15 6v42s9-6 15-6 12 6 12 6c4-4 8-6 12-6s12 2 15 6V18c-6-4-12-6-15-6-4 0-8 2-12 6m0 0v42"/>
+        </svg>
+        <h1>Drop a book here!</h1>
+        <p>Or <button id="file-button">choose a file</button> to open it.</p>
+    </div>
+</div>
+<div id="dimming-overlay" aria-hidden="true"></div>
+<div id="side-bar">
+    <div id="side-bar-header">
+        <img id="side-bar-cover">
+        <div>
+            <h1 id="side-bar-title"></h1>
+            <p id="side-bar-author"></p>
+        </div>
+    </div>
+    <div id="toc-view"></div>
+</div>
+<div id="header-bar" class="toolbar">
+    <button id="side-bar-button" aria-label="Show sidebar">
+        <svg class="icon" width="24" height="24" aria-hidden="true">
+            <path d="M 4 6 h 16 M 4 12 h 16 M 4 18 h 16"/>
+        </svg>
+    </button>
+    <div id="menu-button" class="menu-container">
+        <button aria-label="Show settings" aria-haspopup="true">
+            <svg class="icon" width="24" height="24" aria-hidden="true">
+                <path d="M5 12.7a7 7 0 0 1 0-1.4l-1.8-2 2-3.5 2.7.5a7 7 0 0 1 1.2-.7L10 3h4l.9 2.6 1.2.7 2.7-.5 2 3.4-1.8 2a7 7 0 0 1 0 1.5l1.8 2-2 3.5-2.7-.5a7 7 0 0 1-1.2.7L14 21h-4l-.9-2.6a7 7 0 0 1-1.2-.7l-2.7.5-2-3.4 1.8-2Z"/>
+                <circle cx="12" cy="12" r="3"/>
+            </svg>
+        </button>
+    </div>
+</div>
+<div id="nav-bar" class="toolbar">
+    <button id="left-button" aria-label="Go left">
+        <svg class="icon" width="24" height="24" aria-hidden="true">
+            <path d="M 15 6 L 9 12 L 15 18"/>
+        </svg>
+    </button>
+    <input id="progress-slider" type="range" min="0" max="1" step="any" list="tick-marks">
+    <datalist id="tick-marks"></datalist>
+    <button id="right-button" aria-label="Go right">
+        <svg class="icon" width="24" height="24" aria-hidden="true">
+            <path d="M 9 6 L 15 12 L 9 18"/>
+        </svg>
+    </button>
+</div>
+<script src="reader.js" type="module"></script>

packages/foliate-js/reader.js ADDED Viewed

	@@ -0,0 +1,239 @@

+import './view.js'
+import { createTOCView } from './ui/tree.js'
+import { createMenu } from './ui/menu.js'
+import { Overlayer } from './overlayer.js'
+const getCSS = ({ spacing, justify, hyphenate }) => `
+    @namespace epub "http://www.idpf.org/2007/ops";
+    html {
+        color-scheme: light dark;
+    }
+    /* https://github.com/whatwg/html/issues/5426 */
+    @media (prefers-color-scheme: dark) {
+        a:link {
+            color: lightblue;
+        }
+    }
+    p, li, blockquote, dd {
+        line-height: ${spacing};
+        text-align: ${justify ? 'justify' : 'start'};
+        -webkit-hyphens: ${hyphenate ? 'auto' : 'manual'};
+        hyphens: ${hyphenate ? 'auto' : 'manual'};
+        -webkit-hyphenate-limit-before: 3;
+        -webkit-hyphenate-limit-after: 2;
+        -webkit-hyphenate-limit-lines: 2;
+        hanging-punctuation: allow-end last;
+        widows: 2;
+    }
+    /* prevent the above from overriding the align attribute */
+    [align="left"] { text-align: left; }
+    [align="right"] { text-align: right; }
+    [align="center"] { text-align: center; }
+    [align="justify"] { text-align: justify; }
+    pre {
+        white-space: pre-wrap !important;
+    }
+    aside[epub|type~="endnote"],
+    aside[epub|type~="footnote"],
+    aside[epub|type~="note"],
+    aside[epub|type~="rearnote"] {
+        display: none;
+    }
+`
+const $ = document.querySelector.bind(document)
+const locales = 'en'
+const percentFormat = new Intl.NumberFormat(locales, { style: 'percent' })
+const listFormat = new Intl.ListFormat(locales, { style: 'short', type: 'conjunction' })
+const formatLanguageMap = x => {
+    if (!x) return ''
+    if (typeof x === 'string') return x
+    const keys = Object.keys(x)
+    return x[keys[0]]
+}
+const formatOneContributor = contributor => typeof contributor === 'string'
+    ? contributor : formatLanguageMap(contributor?.name)
+const formatContributor = contributor => Array.isArray(contributor)
+    ? listFormat.format(contributor.map(formatOneContributor))
+    : formatOneContributor(contributor)
+class Reader {
+    #tocView
+    style = {
+        spacing: 1.4,
+        justify: true,
+        hyphenate: true,
+    }
+    annotations = new Map()
+    annotationsByValue = new Map()
+    closeSideBar() {
+        $('#dimming-overlay').classList.remove('show')
+        $('#side-bar').classList.remove('show')
+    }
+    constructor() {
+        $('#side-bar-button').addEventListener('click', () => {
+            $('#dimming-overlay').classList.add('show')
+            $('#side-bar').classList.add('show')
+        })
+        $('#dimming-overlay').addEventListener('click', () => this.closeSideBar())
+        const menu = createMenu([
+            {
+                name: 'layout',
+                label: 'Layout',
+                type: 'radio',
+                items: [
+                    ['Paginated', 'paginated'],
+                    ['Scrolled', 'scrolled'],
+                ],
+                onclick: value => {
+                    this.view?.renderer.setAttribute('flow', value)
+                },
+            },
+        ])
+        menu.element.classList.add('menu')
+        $('#menu-button').append(menu.element)
+        $('#menu-button > button').addEventListener('click', () =>
+            menu.element.classList.toggle('show'))
+        menu.groups.layout.select('paginated')
+    }
+    async open(file) {
+        this.view = document.createElement('foliate-view')
+        document.body.append(this.view)
+        await this.view.open(file)
+        this.view.addEventListener('load', this.#onLoad.bind(this))
+        this.view.addEventListener('relocate', this.#onRelocate.bind(this))
+        const { book } = this.view
+        book.transformTarget?.addEventListener('data', ({ detail }) => {
+            detail.data = Promise.resolve(detail.data).catch(e => {
+                console.error(new Error(`Failed to load ${detail.name}`, { cause: e }))
+                return ''
+            })
+        })
+        this.view.renderer.setStyles?.(getCSS(this.style))
+        this.view.renderer.next()
+        $('#header-bar').style.visibility = 'visible'
+        $('#nav-bar').style.visibility = 'visible'
+        $('#left-button').addEventListener('click', () => this.view.goLeft())
+        $('#right-button').addEventListener('click', () => this.view.goRight())
+        const slider = $('#progress-slider')
+        slider.dir = book.dir
+        slider.addEventListener('input', e =>
+            this.view.goToFraction(parseFloat(e.target.value)))
+        for (const fraction of this.view.getSectionFractions()) {
+            const option = document.createElement('option')
+            option.value = fraction
+            $('#tick-marks').append(option)
+        }
+        document.addEventListener('keydown', this.#handleKeydown.bind(this))
+        const title = formatLanguageMap(book.metadata?.title) || 'Untitled Book'
+        document.title = title
+        $('#side-bar-title').innerText = title
+        $('#side-bar-author').innerText = formatContributor(book.metadata?.author)
+        Promise.resolve(book.getCover?.())?.then(blob =>
+            blob ? $('#side-bar-cover').src = URL.createObjectURL(blob) : null)
+        const toc = book.toc
+        if (toc) {
+            this.#tocView = createTOCView(toc, href => {
+                this.view.goTo(href).catch(e => console.error(e))
+                this.closeSideBar()
+            })
+            $('#toc-view').append(this.#tocView.element)
+        }
+        // load and show highlights embedded in the file by Calibre
+        const bookmarks = await book.getCalibreBookmarks?.()
+        if (bookmarks) {
+            const { fromCalibreHighlight } = await import('./epubcfi.js')
+            for (const obj of bookmarks) {
+                if (obj.type === 'highlight') {
+                    const value = fromCalibreHighlight(obj)
+                    const color = obj.style.which
+                    const note = obj.notes
+                    const annotation = { value, color, note }
+                    const list = this.annotations.get(obj.spine_index)
+                    if (list) list.push(annotation)
+                    else this.annotations.set(obj.spine_index, [annotation])
+                    this.annotationsByValue.set(value, annotation)
+                }
+            }
+            this.view.addEventListener('create-overlay', e => {
+                const { index } = e.detail
+                const list = this.annotations.get(index)
+                if (list) for (const annotation of list)
+                    this.view.addAnnotation(annotation)
+            })
+            this.view.addEventListener('draw-annotation', e => {
+                const { draw, annotation } = e.detail
+                const { color } = annotation
+                draw(Overlayer.highlight, { color })
+            })
+            this.view.addEventListener('show-annotation', e => {
+                const annotation = this.annotationsByValue.get(e.detail.value)
+                if (annotation.note) alert(annotation.note)
+            })
+        }
+    }
+    #handleKeydown(event) {
+        const k = event.key
+        if (k === 'ArrowLeft' || k === 'h') this.view.goLeft()
+        else if(k === 'ArrowRight' || k === 'l') this.view.goRight()
+    }
+    #onLoad({ detail: { doc } }) {
+        doc.addEventListener('keydown', this.#handleKeydown.bind(this))
+    }
+    #onRelocate({ detail }) {
+        const { fraction, location, tocItem, pageItem } = detail
+        const percent = percentFormat.format(fraction)
+        const loc = pageItem
+            ? `Page ${pageItem.label}`
+            : `Loc ${location.current}`
+        const slider = $('#progress-slider')
+        slider.style.visibility = 'visible'
+        slider.value = fraction
+        slider.title = `${percent} · ${loc}`
+        if (tocItem?.href) this.#tocView?.setCurrentHref?.(tocItem.href)
+    }
+}
+const open = async file => {
+    document.body.removeChild($('#drop-target'))
+    const reader = new Reader()
+    globalThis.reader = reader
+    await reader.open(file)
+}
+const dragOverHandler = e => e.preventDefault()
+const dropHandler = e => {
+    e.preventDefault()
+    const item = Array.from(e.dataTransfer.items)
+        .find(item => item.kind === 'file')
+    if (item) {
+        const entry = item.webkitGetAsEntry()
+        open(entry.isFile ? item.getAsFile() : entry).catch(e => console.error(e))
+    }
+}
+const dropTarget = $('#drop-target')
+dropTarget.addEventListener('drop', dropHandler)
+dropTarget.addEventListener('dragover', dragOverHandler)
+$('#file-input').addEventListener('change', e =>
+    open(e.target.files[0]).catch(e => console.error(e)))
+$('#file-button').addEventListener('click', () => $('#file-input').click())
+const params = new URLSearchParams(location.search)
+const url = params.get('url')
+if (url) open(url).catch(e => console.error(e))
+else dropTarget.style.visibility = 'visible'

packages/foliate-js/rollup.config.js ADDED Viewed

	@@ -0,0 +1,32 @@

+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import terser from '@rollup/plugin-terser'
+import { copy } from 'fs-extra'
+const copyPDFJS = () => ({
+    name: 'copy-pdfjs',
+    async writeBundle() {
+        await copy('node_modules/pdfjs-dist/build/pdf.mjs', 'vendor/pdfjs/pdf.mjs')
+        await copy('node_modules/pdfjs-dist/build/pdf.mjs.map', 'vendor/pdfjs/pdf.mjs.map')
+        await copy('node_modules/pdfjs-dist/build/pdf.worker.mjs', 'vendor/pdfjs/pdf.worker.mjs')
+        await copy('node_modules/pdfjs-dist/build/pdf.worker.mjs.map', 'vendor/pdfjs/pdf.worker.mjs.map')
+        await copy('node_modules/pdfjs-dist/cmaps', 'vendor/pdfjs/cmaps')
+        await copy('node_modules/pdfjs-dist/standard_fonts', 'vendor/pdfjs/standard_fonts')
+    },
+})
+export default [{
+    input: 'rollup/fflate.js',
+    output: {
+        dir: 'vendor/',
+        format: 'esm',
+    },
+    plugins: [nodeResolve(), terser()],
+},
+{
+    input: 'rollup/zip.js',
+    output: {
+        dir: 'vendor/',
+        format: 'esm',
+    },
+    plugins: [nodeResolve(), terser(), copyPDFJS()],
+}]

packages/foliate-js/rollup/fflate.js ADDED Viewed

	@@ -0,0 +1 @@


1	+ export { unzlibSync } from 'fflate'

packages/foliate-js/rollup/zip.js ADDED Viewed

	@@ -0,0 +1 @@


1	+ export { configure, ZipReader, BlobReader, TextWriter, BlobWriter } from '../node_modules/@zip.js/zip.js/lib/zip-no-worker-inflate.js'

packages/foliate-js/search.js ADDED Viewed

	@@ -0,0 +1,130 @@

+// length for context in excerpts
+const CONTEXT_LENGTH = 50
+const normalizeWhitespace = str => str.replace(/\s+/g, ' ')
+const makeExcerpt = (strs, { startIndex, startOffset, endIndex, endOffset }) => {
+    const start = strs[startIndex]
+    const end = strs[endIndex]
+    const match = start === end
+        ? start.slice(startOffset, endOffset)
+        : start.slice(startOffset)
+            + strs.slice(start + 1, end).join('')
+            + end.slice(0, endOffset)
+    const trimmedStart = normalizeWhitespace(start.slice(0, startOffset)).trimStart()
+    const trimmedEnd = normalizeWhitespace(end.slice(endOffset)).trimEnd()
+    const ellipsisPre = trimmedStart.length < CONTEXT_LENGTH ? '' : '…'
+    const ellipsisPost = trimmedEnd.length < CONTEXT_LENGTH ? '' : '…'
+    const pre = `${ellipsisPre}${trimmedStart.slice(-CONTEXT_LENGTH)}`
+    const post = `${trimmedEnd.slice(0, CONTEXT_LENGTH)}${ellipsisPost}`
+    return { pre, match, post }
+}
+const simpleSearch = function* (strs, query, options = {}) {
+    const { locales = 'en', sensitivity } = options
+    const matchCase = sensitivity === 'variant'
+    const haystack = strs.join('')
+    const lowerHaystack = matchCase ? haystack : haystack.toLocaleLowerCase(locales)
+    const needle = matchCase ? query : query.toLocaleLowerCase(locales)
+    const needleLength = needle.length
+    let index = -1
+    let strIndex = -1
+    let sum = 0
+    do {
+        index = lowerHaystack.indexOf(needle, index + 1)
+        if (index > -1) {
+            while (sum <= index) sum += strs[++strIndex].length
+            const startIndex = strIndex
+            const startOffset = index - (sum - strs[strIndex].length)
+            const end = index + needleLength
+            while (sum <= end) sum += strs[++strIndex].length
+            const endIndex = strIndex
+            const endOffset = end - (sum - strs[strIndex].length)
+            const range = { startIndex, startOffset, endIndex, endOffset }
+            yield { range, excerpt: makeExcerpt(strs, range) }
+        }
+    } while (index > -1)
+}
+const segmenterSearch = function* (strs, query, options = {}) {
+    const { locales = 'en', granularity = 'word', sensitivity = 'base' } = options
+    let segmenter, collator
+    try {
+        segmenter = new Intl.Segmenter(locales, { usage: 'search', granularity })
+        collator = new Intl.Collator(locales, { sensitivity })
+    } catch (e) {
+        console.warn(e)
+        segmenter = new Intl.Segmenter('en', { usage: 'search', granularity })
+        collator = new Intl.Collator('en', { sensitivity })
+    }
+    const queryLength = Array.from(segmenter.segment(query)).length
+    const substrArr = []
+    let strIndex = 0
+    let segments = segmenter.segment(strs[strIndex])[Symbol.iterator]()
+    main: while (strIndex < strs.length) {
+        while (substrArr.length < queryLength) {
+            const { done, value } = segments.next()
+            if (done) {
+                // the current string is exhausted
+                // move on to the next string
+                strIndex++
+                if (strIndex < strs.length) {
+                    segments = segmenter.segment(strs[strIndex])[Symbol.iterator]()
+                    continue
+                } else break main
+            }
+            const { index, segment } = value
+            // ignore formatting characters
+            if (!/[^\p{Format}]/u.test(segment)) continue
+            // normalize whitespace
+            if (/\s/u.test(segment)) {
+                if (!/\s/u.test(substrArr[substrArr.length - 1]?.segment))
+                    substrArr.push({ strIndex, index, segment: ' ' })
+                continue
+            }
+            value.strIndex = strIndex
+            substrArr.push(value)
+        }
+        const substr = substrArr.map(x => x.segment).join('')
+        if (collator.compare(query, substr) === 0) {
+            const endIndex = strIndex
+            const lastSeg = substrArr[substrArr.length - 1]
+            const endOffset = lastSeg.index + lastSeg.segment.length
+            const startIndex = substrArr[0].strIndex
+            const startOffset = substrArr[0].index
+            const range = { startIndex, startOffset, endIndex, endOffset }
+            yield { range, excerpt: makeExcerpt(strs, range) }
+        }
+        substrArr.shift()
+    }
+}
+export const search = (strs, query, options) => {
+    const { granularity = 'grapheme', sensitivity = 'base' } = options
+    if (!Intl?.Segmenter || granularity === 'grapheme'
+    && (sensitivity === 'variant' || sensitivity === 'accent'))
+        return simpleSearch(strs, query, options)
+    return segmenterSearch(strs, query, options)
+}
+export const searchMatcher = (textWalker, opts) => {
+    const { defaultLocale, matchCase, matchDiacritics, matchWholeWords, acceptNode } = opts
+    return function* (doc, query) {
+        const iter = textWalker(doc, function* (strs, makeRange) {
+            for (const result of search(strs, query, {
+                locales: doc.body.lang || doc.documentElement.lang || defaultLocale || 'en',
+                granularity: matchWholeWords ? 'word' : 'grapheme',
+                sensitivity: matchDiacritics && matchCase ? 'variant'
+                : matchDiacritics && !matchCase ? 'accent'
+                : !matchDiacritics && matchCase ? 'case'
+                : 'base',
+            })) {
+                const { startIndex, startOffset, endIndex, endOffset } = result.range
+                result.range = makeRange(startIndex, startOffset, endIndex, endOffset)
+                yield result
+            }
+        }, acceptNode)
+        for (const result of iter) yield result
+    }
+}

packages/foliate-js/tests/epubcfi-tests.js ADDED Viewed

	@@ -0,0 +1,236 @@

+import * as CFI from '../epubcfi.js'
+const parser = new DOMParser()
+const XML = str => parser.parseFromString(str, 'application/xml')
+const XHTML = str => parser.parseFromString(str, 'application/xhtml+xml')
+{
+    // example from EPUB CFI spec
+    const opf = XML(`<?xml version="1.0"?>
+<package version="2.0"
+         unique-identifier="bookid"
+         xmlns="http://www.idpf.org/2007/opf"
+         xmlns:dc="http://purl.org/dc/elements/1.1/"
+         xmlns:opf="http://www.idpf.org/2007/opf">
+    <metadata>
+    	<dc:title>…</dc:title>
+    	<dc:identifier id="bookid">…</dc:identifier>
+    	<dc:creator>…</dc:creator>
+        <dc:language>en</dc:language>
+    </metadata>
+    <manifest>
+        <item id="toc"
+              properties="nav"
+              href="toc.xhtml"
+              media-type="application/xhtml+xml"/>
+        <item id="titlepage"
+              href="titlepage.xhtml"
+              media-type="application/xhtml+xml"/>
+        <item id="chapter01"
+              href="chapter01.xhtml"
+              media-type="application/xhtml+xml"/>
+        <item id="chapter02"
+              href="chapter02.xhtml"
+              media-type="application/xhtml+xml"/>
+        <item id="chapter03"
+              href="chapter03.xhtml"
+              media-type="application/xhtml+xml"/>
+        <item id="chapter04"
+              href="chapter04.xhtml"
+              media-type="application/xhtml+xml"/>
+    </manifest>
+    <spine>
+        <itemref id="titleref"  idref="titlepage"/>
+        <itemref id="chap01ref" idref="chapter01"/>
+        <itemref id="chap02ref" idref="chapter02"/>
+        <itemref id="chap03ref" idref="chapter03"/>
+        <itemref id="chap04ref" idref="chapter04"/>
+    </spine>
+</package>`)
+    const a = opf.getElementById('chap01ref')
+    const b = CFI.toElement(opf, CFI.parse('/6/4[chap01ref]')[0])
+    const c = CFI.toElement(opf, CFI.parse('/6/4')[0])
+    console.assert(a === b)
+    console.assert(a === c)
+}
+{
+    // example from EPUB CFI spec
+    const page = XHTML(`<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+    	<title>…</title>
+    </head>
+    <body id="body01">
+    	<p>…</p>
+    	<p>…</p>
+    	<p>…</p>
+    	<p>…</p>
+        <p id="para05">xxx<em>yyy</em>0123456789</p>
+    	<p>…</p>
+    	<p>…</p>
+    	<img id="svgimg" src="foo.svg" alt="…"/>
+    	<p>…</p>
+    	<p>…</p>
+    </body>
+</html>`)
+    // the exact same page with some text nodes removed, CDATA & comment added,
+    // and characters changed to entities
+    const page2 = XHTML(`<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>…</title>
+    </head>
+    <body id="body01">
+        <p>…</p><p>…</p><p>…</p><p>…</p>
+        <p id="para05">xxx<em>yyy</em><![CDATA[]]><!--comment1--><![CDATA[0123]]>4<!--comment2-->5<![CDATA[67]]>&#56;&#57;</p>
+        <p>…</p>
+        <p>…</p>
+        <img id="svgimg" src="foo.svg" alt="…"/>
+        <p>…</p>
+        <p>…</p>
+    </body>
+</html>`)
+    // the exact same page with nodes are to be ignored
+    const page3 = XHTML(`<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title>…</title>
+    </head>
+    <body id="body01">
+        <h1 class="reject">This is ignored!</h1>
+        <section class="skip">
+            <p class="reject">Also ignored</p>
+            <p>…</p><p>…</p><p>…</p><p>…</p>
+            <p id="para05">xxx<em>yyy</em><span class="reject">Note: we put ignored text in this span but not the other ones because although the CFI library should ignore them, they won't be ignored by DOM Ranges, which will break the tests.</span><span class="skip">0<span class="skip"><span class="reject"><![CDATA[]]></span>123</span></span>45<span class="reject"><img src="icon.svg"/></span>6789</p>
+            <p>…</p>
+            <p>…</p>
+            <img id="svgimg" src="foo.svg" alt="…"/>
+            <p>…</p>
+            <p>…</p>
+        </section>
+    </body>
+</html>`)
+    const filter = node => node.nodeType !== 1 ? NodeFilter.FILTER_ACCEPT
+        : node.matches('.reject') ? NodeFilter.FILTER_REJECT
+        : node.matches('.skip') ? NodeFilter.FILTER_SKIP
+        : NodeFilter.FILTER_ACCEPT
+    const test = (page, filter) => {
+        for (const cfi of [
+            '/4[body01]/10[para05]/3:10',
+            '/4[body01]/16[svgimg]',
+            '/4[body01]/10[para05]/1:0',
+            '/4[body01]/10[para05]/2/1:0',
+            '/4[body01]/10[para05]/2/1:3',
+        ]) {
+            const range = CFI.toRange(page, CFI.parse(cfi), filter)
+            const a = CFI.fromRange(range, filter)
+            const b = `epubcfi(${cfi})`
+            console.assert(a === b, `expected ${b}, got ${a}`)
+        }
+        for (let i = 0; i < 10; i++) {
+            const cfi = `/4/10,/3:${i},/3:${i+1}`
+            const range = CFI.toRange(page, CFI.parse(cfi), filter)
+            const n = `${i}`
+            console.assert(range.toString() === n, `expected ${n}, got ${range}`)
+        }
+    }
+    test(page)
+    test(page2)
+    test(page, filter)
+    test(page2, filter)
+    test(page3, filter)
+}
+{
+    // special characters in ID assertions
+    const opf = XML(`<?xml version="1.0"?>
+<package version="2.0"
+         unique-identifier="bookid"
+         xmlns="http://www.idpf.org/2007/opf"
+         xmlns:dc="http://purl.org/dc/elements/1.1/"
+         xmlns:opf="http://www.idpf.org/2007/opf">
+    <metadata></metadata>
+    <manifest></manifest>
+    <spine>
+        <itemref id="titleref"  idref="titlepage"/>
+        <itemref id="chap0]!/1ref^" idref="chapter01"/>
+        <itemref id="chap02ref" idref="chapter02"/>
+        <itemref id="chap03ref" idref="chapter03"/>
+        <itemref id="chap04ref" idref="chapter04"/>
+    </spine>
+</package>`)
+    const a = opf.getElementById('chap0]!/1ref^')
+    const b = CFI.toElement(opf, CFI.parse('/6/4[chap0^]!/1ref^^]')[0])
+    console.assert(a === b)
+    const page = XHTML(`<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+    	<title>…</title>
+    </head>
+    <body id="body0]!/1^">
+    	<p>…</p>
+    	<p>…</p>
+    	<p>…</p>
+    	<p>…</p>
+        <p id="para]/0,/5">xxx<em>yyy</em>0123456789</p>
+    	<p>…</p>
+    	<p>…</p>
+    	<img id="s][vgimg" src="foo.svg" alt="…"/>
+    	<p>…</p>
+    	<p>…</p>
+    </body>
+</html>`)
+    for (const cfi of [
+        '/4[body0^]!/1^^]/10[para^]/0^,/5]/3:10',
+        '/4[body0^]!/1^^]/16[s^]^[vgimg]',
+        '/4[body0^]!/1^^]/10[para^]/0^,/5]/1:0',
+        '/4[body0^]!/1^^]/10[para^]/0^,/5]/2/1:0',
+        '/4[body0^]!/1^^]/10[para^]/0^,/5]/2/1:3',
+    ]) {
+        const range = CFI.toRange(page, CFI.parse(cfi))
+        const a = CFI.fromRange(range)
+        const b = `epubcfi(${cfi})`
+        console.assert(a === b, `expected ${b}, got ${a}`)
+    }
+    for (let i = 0; i < 10; i++) {
+        const cfi = `/4[body0^]!/1^^]/10[para^]/0^,^/5],/3:${i},/3:${i+1}`
+        const range = CFI.toRange(page, CFI.parse(cfi))
+        const n = `${i}`
+        console.assert(range.toString() === n, `expected ${n}, got ${range}`)
+    }
+}
+{
+    for (const [a, b, c] of [
+        ['/6/4!/10', '/6/4!/10', 0],
+        ['/6/4!/2/3:0', '/6/4!/2', 1],
+        ['/6/4!/2/4/6/8/10/3:0', '/6/4!/4', -1],
+        [
+            '/6/4[chap0^]!/1ref^^]!/4[body01^^]/10[para^]^,05^^]',
+            '/6/4!/4/10',
+            0,
+        ],
+        [
+            '/6/4[chap0^]!/1ref^^]!/4[body01^^],/10[para^]^,05^^],/15:10[foo^]]',
+            '/6/4!/4/12',
+            -1,
+        ],
+        ['/6/4', '/6/4!/2', -1],
+        ['/6/4!/2', '/6/4!/2!/2', -1],
+    ]) {
+        const x = CFI.compare(a, b)
+        console.assert(x === c, `compare ${a} and ${b}, expected ${c}, got ${x}`)
+    }
+}

packages/foliate-js/tests/tests.html ADDED Viewed

	@@ -0,0 +1,5 @@

+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name="color-scheme" content="light dark">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<script src="tests.js" type="module"></script>

packages/foliate-js/tests/tests.js ADDED Viewed

	@@ -0,0 +1 @@


1	+ import './epubcfi-tests.js'

packages/foliate-js/text-walker.js ADDED Viewed

	@@ -0,0 +1,43 @@

+const walkRange = (range, walker) => {
+    const nodes = []
+    for (let node = walker.currentNode; node; node = walker.nextNode()) {
+        const compare = range.comparePoint(node, 0)
+        if (compare === 0) nodes.push(node)
+        else if (compare > 0) break
+    }
+    return nodes
+}
+const walkDocument = (_, walker) => {
+    const nodes = []
+    for (let node = walker.nextNode(); node; node = walker.nextNode())
+        nodes.push(node)
+    return nodes
+}
+const filter = NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT
+    | NodeFilter.SHOW_CDATA_SECTION
+const acceptNode = node => {
+    if (node.nodeType === 1) {
+        const name = node.tagName.toLowerCase()
+        if (name === 'script' || name === 'style') return NodeFilter.FILTER_REJECT
+        return NodeFilter.FILTER_SKIP
+    }
+    return NodeFilter.FILTER_ACCEPT
+}
+export const textWalker = function* (x, func, filterFunc) {
+    const root = x.commonAncestorContainer ?? x.body ?? x
+    const walker = document.createTreeWalker(root, filter, { acceptNode: filterFunc || acceptNode })
+    const walk = x.commonAncestorContainer ? walkRange : walkDocument
+    const nodes = walk(x, walker)
+    const strs = nodes.map(node => node.nodeValue ?? '')
+    const makeRange = (startIndex, startOffset, endIndex, endOffset) => {
+        const range = document.createRange()
+        range.setStart(nodes[startIndex], startOffset)
+        range.setEnd(nodes[endIndex], endOffset)
+        return range
+    }
+    for (const match of func(strs, makeRange)) yield match
+}

packages/foliate-js/tts.js ADDED Viewed

	@@ -0,0 +1,377 @@

+const NS = {
+    XML: 'http://www.w3.org/XML/1998/namespace',
+    SSML: 'http://www.w3.org/2001/10/synthesis',
+}
+const blockTags = new Set([
+    'article', 'aside', 'audio', 'blockquote', 'caption',
+    'details', 'dialog', 'div', 'dl', 'dt', 'dd',
+    'figure', 'footer', 'form', 'figcaption',
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'li',
+    'main', 'math', 'nav', 'ol', 'p', 'pre', 'section', 'tr',
+])
+const getLang = el => {
+    const x = el.lang || el?.getAttributeNS?.(NS.XML, 'lang')
+    return x ? x : el.parentElement ? getLang(el.parentElement) : null
+}
+const getAlphabet = el => {
+    const x = el?.getAttributeNS?.(NS.XML, 'lang')
+    return x ? x : el.parentElement ? getAlphabet(el.parentElement) : null
+}
+const getSegmenter = (lang = 'en', granularity = 'word') => {
+    const segmenter = new Intl.Segmenter(lang, { granularity })
+    const granularityIsWord = granularity === 'word'
+    return function* (strs, makeRange) {
+        const str = strs.join('').replace(/\r\n/g, '  ').replace(/\r/g, ' ').replace(/\n/g, ' ')
+        let name = 0
+        let strIndex = -1
+        let sum = 0
+        const rawSegments = Array.from(segmenter.segment(str))
+        const mergedSegments = []
+        for (let i = 0; i < rawSegments.length; i++) {
+            const current = rawSegments[i]
+            const next = rawSegments[i + 1]
+            const segment = current.segment.trim()
+            const nextSegment = next?.segment?.trim()
+            const endsWithAbbr = /(?:^|\s)([A-Z][a-z]{1,5})\.$/.test(segment)
+            const nextStartsWithCapital = /^[A-Z]/.test(nextSegment || '')
+            if ((endsWithAbbr && nextStartsWithCapital) || segment.length <= 3) {
+                const mergedSegment = {
+                    index: current.index,
+                    segment: current.segment + (next?.segment || ''),
+                    isWordLike: true,
+                }
+                mergedSegments.push(mergedSegment)
+                i++
+            } else {
+                mergedSegments.push(current)
+            }
+        }
+        for (const { index, segment, isWordLike } of mergedSegments) {
+            if (granularityIsWord && !isWordLike) continue
+            while (sum <= index) sum += strs[++strIndex].length
+            const startIndex = strIndex
+            const startOffset = index - (sum - strs[strIndex].length)
+            const end = index + segment.length - 1
+            if (end < str.length) while (sum <= end) sum += strs[++strIndex].length
+            const endIndex = strIndex
+            const endOffset = end - (sum - strs[strIndex].length) + 1
+            yield [(name++).toString(),
+                makeRange(startIndex, startOffset, endIndex, endOffset)]
+        }
+    }
+}
+const fragmentToSSML = (fragment, nodeFilter, inherited) => {
+    const ssml = document.implementation.createDocument(NS.SSML, 'speak')
+    const { lang } = inherited
+    if (lang) ssml.documentElement.setAttributeNS(NS.XML, 'lang', lang)
+    const convert = (node, parent, inheritedAlphabet) => {
+        if (!node) return
+        if (node.nodeType === 3) return ssml.createTextNode(node.textContent)
+        if (node.nodeType === 4) return ssml.createCDATASection(node.textContent)
+        if (node.nodeType !== 1 && node.nodeType !== 11) return
+        if (nodeFilter && nodeFilter(node) === NodeFilter.FILTER_REJECT) return
+        let el
+        const nodeName = node.nodeName.toLowerCase()
+        if (nodeName === 'foliate-mark') {
+            el = ssml.createElementNS(NS.SSML, 'mark')
+            el.setAttribute('name', node.dataset.name)
+        }
+        else if (nodeName === 'br')
+            el = ssml.createElementNS(NS.SSML, 'break')
+        else if (nodeName === 'em' || nodeName === 'strong')
+            el = ssml.createElementNS(NS.SSML, 'emphasis')
+        const lang = node.lang || node.getAttributeNS?.(NS.XML, 'lang')
+        if (lang) {
+            if (!el) el = ssml.createElementNS(NS.SSML, 'lang')
+            el.setAttributeNS(NS.XML, 'lang', lang)
+        }
+        const alphabet = node.getAttributeNS?.(NS.SSML, 'alphabet') || inheritedAlphabet
+        if (!el) {
+            const ph = node.getAttributeNS?.(NS.SSML, 'ph')
+            if (ph) {
+                el = ssml.createElementNS(NS.SSML, 'phoneme')
+                if (alphabet) el.setAttribute('alphabet', alphabet)
+                el.setAttribute('ph', ph)
+            }
+        }
+        if (!el) el = parent
+        let child = node.firstChild
+        while (child) {
+            const childEl = convert(child, el, alphabet)
+            if (childEl && el !== childEl) el.append(childEl)
+            child = child.nextSibling
+        }
+        return el
+    }
+    convert(fragment, ssml.documentElement, inherited.alphabet)
+    return ssml
+}
+const getFragmentWithMarks = (range, textWalker, nodeFilter, granularity) => {
+    const lang = getLang(range.commonAncestorContainer)
+    const alphabet = getAlphabet(range.commonAncestorContainer)
+    const segmenter = getSegmenter(lang, granularity)
+    const fragment = range.cloneContents()
+    // we need ranges on both the original document (for highlighting)
+    // and the document fragment (for inserting marks)
+    // so unfortunately need to do it twice, as you can't copy the ranges
+    const entries = [...textWalker(range, segmenter, nodeFilter)]
+    const fragmentEntries = [...textWalker(fragment, segmenter, nodeFilter)]
+    for (const [name, range] of fragmentEntries) {
+        const mark = document.createElement('foliate-mark')
+        mark.dataset.name = name
+        range.insertNode(mark)
+    }
+    const ssml = fragmentToSSML(fragment, nodeFilter, { lang, alphabet })
+    return { entries, ssml }
+}
+const rangeIsEmpty = range => !range.toString().trim()
+function* getBlocks(doc) {
+    let last
+    const walker = doc.createTreeWalker(doc.body, NodeFilter.SHOW_ELEMENT)
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+        const name = node.tagName.toLowerCase()
+        if (blockTags.has(name)) {
+            if (last) {
+                last.setEndBefore(node)
+                if (!rangeIsEmpty(last)) yield last
+            }
+            last = doc.createRange()
+            last.setStart(node, 0)
+        }
+    }
+    if (!last) {
+        last = doc.createRange()
+        last.setStart(doc.body.firstChild ?? doc.body, 0)
+    }
+    last.setEndAfter(doc.body.lastChild ?? doc.body)
+    if (!rangeIsEmpty(last)) yield last
+}
+class ListIterator {
+    #arr = []
+    #iter
+    #index = -1
+    #f
+    constructor(iter, f = x => x) {
+        this.#iter = iter
+        this.#f = f
+    }
+    current() {
+        if (this.#arr[this.#index]) return this.#f(this.#arr[this.#index])
+    }
+    first() {
+        const newIndex = 0
+        if (this.#arr[newIndex]) {
+            this.#index = newIndex
+            return this.#f(this.#arr[newIndex])
+        }
+    }
+    prev() {
+        const newIndex = this.#index - 1
+        if (this.#arr[newIndex]) {
+            this.#index = newIndex
+            return this.#f(this.#arr[newIndex])
+        }
+    }
+    next() {
+        const newIndex = this.#index + 1
+        if (this.#arr[newIndex]) {
+            this.#index = newIndex
+            return this.#f(this.#arr[newIndex])
+        }
+        while (true) {
+            const { done, value } = this.#iter.next()
+            if (done) break
+            this.#arr.push(value)
+            if (this.#arr[newIndex]) {
+                this.#index = newIndex
+                return this.#f(this.#arr[newIndex])
+            }
+        }
+    }
+    find(f) {
+        const index = this.#arr.findIndex(x => f(x))
+        if (index > -1) {
+            this.#index = index
+            return this.#f(this.#arr[index])
+        }
+        while (true) {
+            const { done, value } = this.#iter.next()
+            if (done) break
+            this.#arr.push(value)
+            if (f(value)) {
+                this.#index = this.#arr.length - 1
+                return this.#f(value)
+            }
+        }
+    }
+}
+export class TTS {
+    #list
+    #ranges
+    #lastMark
+    #serializer = new XMLSerializer()
+    constructor(doc, textWalker, nodeFilter, highlight, granularity) {
+        this.doc = doc
+        this.highlight = highlight
+        this.#list = new ListIterator(getBlocks(doc), range => {
+            const { entries, ssml } = getFragmentWithMarks(range, textWalker, nodeFilter, granularity)
+            this.#ranges = new Map(entries)
+            return [ssml, range]
+        })
+    }
+    #getMarkElement(doc, mark) {
+        if (!mark) return null
+        return doc.querySelector(`mark[name="${CSS.escape(mark)}"`)
+    }
+    #speak(doc, getNode) {
+        if (!doc) return
+        if (!getNode) return this.#serializer.serializeToString(doc)
+        const ssml = document.implementation.createDocument(NS.SSML, 'speak')
+        ssml.documentElement.replaceWith(ssml.importNode(doc.documentElement, true))
+        let node = getNode(ssml)?.previousSibling
+        while (node) {
+            const next = node.previousSibling ?? node.parentNode?.previousSibling
+            node.parentNode.removeChild(node)
+            node = next
+        }
+        const ssmlStr = this.#serializer.serializeToString(ssml)
+        return ssmlStr
+    }
+    start() {
+        this.#lastMark = null
+        const [doc] = this.#list.first() ?? []
+        if (!doc) return this.next()
+        return this.#speak(doc, ssml => this.#getMarkElement(ssml, this.#lastMark))
+    }
+    resume() {
+        const [doc] = this.#list.current() ?? []
+        if (!doc) return this.next()
+        return this.#speak(doc, ssml => this.#getMarkElement(ssml, this.#lastMark))
+    }
+    prev(paused) {
+        this.#lastMark = null
+        const [doc, range] = this.#list.prev() ?? []
+        if (paused && range) this.highlight(range.cloneRange())
+        return this.#speak(doc)
+    }
+    next(paused) {
+        this.#lastMark = null
+        const [doc, range] = this.#list.next() ?? []
+        if (paused && range) this.highlight(range.cloneRange())
+        return this.#speak(doc)
+    }
+    prevMark(paused) {
+        const marks = Array.from(this.#ranges.keys())
+        if (marks.length === 0) return
+        const currentIndex = this.#lastMark ? marks.indexOf(this.#lastMark) : -1
+        if (currentIndex > 0) {
+            const prevMarkName = marks[currentIndex - 1]
+            const range = this.#ranges.get(prevMarkName)
+            if (range) {
+                this.#lastMark = prevMarkName
+                if (paused) this.highlight(range.cloneRange())
+                const [doc] = this.#list.current() ?? []
+                return this.#speak(doc, ssml => this.#getMarkElement(ssml, prevMarkName))
+            }
+        } else {
+            const [doc, range] = this.#list.prev() ?? []
+            if (doc && range) {
+                const prevMarks = Array.from(this.#ranges.keys())
+                if (prevMarks.length > 0) {
+                    const lastMarkName = prevMarks[prevMarks.length - 1]
+                    const lastMarkRange = this.#ranges.get(lastMarkName)
+                    if (lastMarkRange) {
+                        this.#lastMark = lastMarkName
+                        if (paused) this.highlight(lastMarkRange.cloneRange())
+                        return this.#speak(doc, ssml => this.#getMarkElement(ssml, lastMarkName))
+                    }
+                } else {
+                    this.#lastMark = null
+                    if (paused) this.highlight(range.cloneRange())
+                    return this.#speak(doc)
+                }
+            }
+        }
+    }
+    nextMark(paused) {
+        const marks = Array.from(this.#ranges.keys())
+        if (marks.length === 0) return
+        const currentIndex = this.#lastMark ? marks.indexOf(this.#lastMark) : -1
+        if (currentIndex >= 0 && currentIndex < marks.length - 1) {
+            const nextMarkName = marks[currentIndex + 1]
+            const range = this.#ranges.get(nextMarkName)
+            if (range) {
+                this.#lastMark = nextMarkName
+                if (paused) this.highlight(range.cloneRange())
+                const [doc] = this.#list.current() ?? []
+                return this.#speak(doc, ssml => this.#getMarkElement(ssml, nextMarkName))
+            }
+        } else {
+            const [doc, range] = this.#list.next() ?? []
+            if (doc && range) {
+                const nextMarks = Array.from(this.#ranges.keys())
+                if (nextMarks.length > 0) {
+                    const firstMarkName = nextMarks[0]
+                    const firstMarkRange = this.#ranges.get(firstMarkName)
+                    if (firstMarkRange) {
+                        this.#lastMark = firstMarkName
+                        if (paused) this.highlight(firstMarkRange.cloneRange())
+                        return this.#speak(doc, ssml => this.#getMarkElement(ssml, firstMarkName))
+                    }
+                } else {
+                    this.#lastMark = null
+                    if (paused) this.highlight(range.cloneRange())
+                    return this.#speak(doc)
+                }
+            }
+        }
+    }
+    from(range) {
+        this.#lastMark = null
+        const [doc] = this.#list.find(range_ =>
+            range.compareBoundaryPoints(Range.END_TO_START, range_) <= 0)
+        let mark
+        for (const [name, range_] of this.#ranges.entries())
+            if (range.compareBoundaryPoints(Range.START_TO_START, range_) <= 0) {
+                mark = name
+                break
+            }
+        return this.#speak(doc, ssml => this.#getMarkElement(ssml, mark))
+    }
+    getLastRange() {
+        if (this.#lastMark) {
+            const range = this.#ranges.get(this.#lastMark)
+            if (range) return range.cloneRange()
+        }
+    }
+    setMark(mark) {
+        const range = this.#ranges.get(mark)
+        if (range) {
+            this.#lastMark = mark
+            this.highlight(range.cloneRange())
+            return range
+        }
+    }
+}

packages/foliate-js/ui/menu.js ADDED Viewed

	@@ -0,0 +1,42 @@

+const createMenuItemRadioGroup = (label, arr, onclick) => {
+    const group = document.createElement('ul')
+    group.setAttribute('role', 'group')
+    group.setAttribute('aria-label', label)
+    const map = new Map()
+    const select = value => {
+        onclick(value)
+        const item = map.get(value)
+        for (const child of group.children)
+            child.setAttribute('aria-checked', child === item ? 'true' : 'false')
+    }
+    for (const [label, value] of arr) {
+        const item = document.createElement('li')
+        item.setAttribute('role', 'menuitemradio')
+        item.innerText = label
+        item.onclick = () => select(value)
+        map.set(value, item)
+        group.append(item)
+    }
+    return { element: group, select }
+}
+export const createMenu = arr => {
+    const groups = {}
+    const element = document.createElement('ul')
+    element.setAttribute('role', 'menu')
+    const hide = () => element.classList.remove('show')
+    const hideAnd = f => (...args) => (hide(), f(...args))
+    for (const { name, label, type, items, onclick } of arr) {
+        const widget = type === 'radio'
+            ? createMenuItemRadioGroup(label, items, hideAnd(onclick))
+            : null
+        if (name) groups[name] = widget
+        element.append(widget.element)
+    }
+    // TODO: keyboard events
+    window.addEventListener('blur', () => hide())
+    window.addEventListener('click', e => {
+        if (!element.parentNode.contains(e.target)) hide()
+    })
+    return { element, groups }
+}

packages/foliate-js/ui/tree.js ADDED Viewed

	@@ -0,0 +1,169 @@

+const createSVGElement = tag =>
+    document.createElementNS('http://www.w3.org/2000/svg', tag)
+const createExpanderIcon = () => {
+    const svg = createSVGElement('svg')
+    svg.setAttribute('viewBox', '0 0 13 10')
+    svg.setAttribute('width', '13')
+    svg.setAttribute('height', '13')
+    const polygon = createSVGElement('polygon')
+    polygon.setAttribute('points', '2 1, 12 1, 7 9')
+    svg.append(polygon)
+    return svg
+}
+const createTOCItemElement = (list, map, onclick) => {
+    let count = 0
+    const makeID = () => `toc-element-${count++}`
+    const createItem = ({ label, href, subitems }, depth = 0) => {
+        const a = document.createElement(href ? 'a' : 'span')
+        a.innerText = label
+        a.setAttribute('role', 'treeitem')
+        a.tabIndex = -1
+        a.style.paddingInlineStart = `${(depth + 1) * 24}px`
+        list.push(a)
+        if (href) {
+            if (!map.has(href)) map.set(href, a)
+            a.href = href
+            a.onclick = event => {
+                event.preventDefault()
+                onclick(href)
+            }
+        } else a.onclick = event => a.firstElementChild?.onclick(event)
+        const li = document.createElement('li')
+        li.setAttribute('role', 'none')
+        li.append(a)
+        if (subitems?.length) {
+            a.setAttribute('aria-expanded', 'false')
+            const expander = createExpanderIcon()
+            expander.onclick = event => {
+                event.preventDefault()
+                event.stopPropagation()
+                const expanded = a.getAttribute('aria-expanded')
+                a.setAttribute('aria-expanded', expanded === 'true' ? 'false' : 'true')
+            }
+            a.prepend(expander)
+            const ol = document.createElement('ol')
+            ol.id = makeID()
+            ol.setAttribute('role', 'group')
+            a.setAttribute('aria-owns', ol.id)
+            ol.replaceChildren(...subitems.map(item => createItem(item, depth + 1)))
+            li.append(ol)
+        }
+        return li
+    }
+    return createItem
+}
+// https://www.w3.org/TR/wai-aria-practices-1.2/examples/treeview/treeview-navigation.html
+export const createTOCView = (toc, onclick) => {
+    const $toc = document.createElement('ol')
+    $toc.setAttribute('role', 'tree')
+    const list = []
+    const map = new Map()
+    const createItem = createTOCItemElement(list, map, onclick)
+    $toc.replaceChildren(...toc.map(item => createItem(item)))
+    const isTreeItem = item => item?.getAttribute('role') === 'treeitem'
+    const getParents = function* (el) {
+        for (let parent = el.parentNode; parent !== $toc; parent = parent.parentNode) {
+            const item = parent.previousElementSibling
+            if (isTreeItem(item)) yield item
+        }
+    }
+    let currentItem, currentVisibleParent
+    $toc.addEventListener('focusout', () => {
+        if (!currentItem) return
+        // reset parent focus from last time
+        if (currentVisibleParent) currentVisibleParent.tabIndex = -1
+        // if current item is visible, let it have the focus
+        if (currentItem.offsetParent) {
+            currentItem.tabIndex = 0
+            return
+        }
+        // current item is hidden; give focus to the nearest visible parent
+        for (const item of getParents(currentItem)) {
+            if (item.offsetParent) {
+                item.tabIndex = 0
+                currentVisibleParent = item
+                break
+            }
+        }
+    })
+    const setCurrentHref = href => {
+        if (currentItem) {
+            currentItem.removeAttribute('aria-current')
+            currentItem.tabIndex = -1
+        }
+        const el = map.get(href)
+        if (!el) {
+            currentItem = list[0]
+            currentItem.tabIndex = 0
+            return
+        }
+        for (const item of getParents(el))
+            item.setAttribute('aria-expanded', 'true')
+        el.setAttribute('aria-current', 'page')
+        el.tabIndex = 0
+        el.scrollIntoView({ behavior: 'smooth', block: 'center' })
+        currentItem = el
+    }
+    const acceptNode = node => isTreeItem(node) && node.offsetParent
+        ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP
+    const iter = document.createTreeWalker($toc, 1, { acceptNode })
+    const getIter = current => (iter.currentNode = current, iter)
+    for (const el of list) el.addEventListener('keydown', event => {
+        let stop = false
+        const { currentTarget, key } = event
+        switch (key) {
+            case ' ':
+            case 'Enter':
+                currentTarget.click()
+                stop = true
+                break
+            case 'ArrowDown':
+                getIter(currentTarget).nextNode()?.focus()
+                stop = true
+                break
+            case 'ArrowUp':
+                getIter(currentTarget).previousNode()?.focus()
+                stop = true
+                break
+            case 'ArrowLeft':
+                if (currentTarget.getAttribute('aria-expanded') === 'true')
+                    currentTarget.setAttribute('aria-expanded', 'false')
+                else getParents(currentTarget).next()?.value?.focus()
+                stop = true
+                break
+            case 'ArrowRight':
+                if (currentTarget.getAttribute('aria-expanded') === 'true')
+                    getIter(currentTarget).nextNode()?.focus()
+                else if (currentTarget.getAttribute('aria-owns'))
+                    currentTarget.setAttribute('aria-expanded', 'true')
+                stop = true
+                break
+            case 'Home':
+                list[0].focus()
+                stop = true
+                break
+            case 'End': {
+                const last = list[list.length - 1]
+                if (last.offsetParent) last.focus()
+                else getIter(last).previousNode()?.focus()
+                stop = true
+                break
+            }
+        }
+        if (stop) {
+            event.preventDefault()
+            event.stopPropagation()
+        }
+    })
+    return { element: $toc, setCurrentHref }
+}

packages/foliate-js/uri-template.js ADDED Viewed

	@@ -0,0 +1,52 @@

+// URI Template: https://datatracker.ietf.org/doc/html/rfc6570
+const regex = /{([+#./;?&])?([^}]+?)}/g
+const varspecRegex = /(.+?)(\*|:[1-9]\d{0,3})?$/
+const table = {
+    undefined: { first: '', sep: ',' },
+    '+': { first: '', sep: ',', allowReserved: true },
+    '.': { first: '.', sep: '.' },
+    '/': { first: '/', sep: '/' },
+    ';': { first: ';', sep: ';', named: true, ifemp: '' },
+    '?': { first: '?', sep: '&', named: true, ifemp: '=' },
+    '&': { first: '&', sep: '&', named: true, ifemp: '=' },
+    '#': { first: '&', sep: '&', allowReserved: true },
+}
+// 2.4.1 Prefix Values, "Note that this numbering is in characters, not octets"
+const prefix = (maxLength, str) => {
+    let result = ''
+    for (const char of str) {
+        const newResult = char
+        if (newResult.length > maxLength) return result
+        else result = newResult
+    }
+    return result
+}
+export const replace = (str, map) => str.replace(regex, (_, operator, variableList) => {
+    const { first, sep, named, ifemp, allowReserved } = table[operator]
+    // TODO: this isn't spec compliant
+    const encode = allowReserved ? encodeURI : encodeURIComponent
+    const values = variableList.split(',').map(varspec => {
+        const match = varspec.match(varspecRegex)
+        if (!match) return
+        const [, name, modifier] = match
+        let value = map.get(name)
+        if (modifier?.startsWith(':')) {
+            const maxLength = parseInt(modifier.slice(1))
+            value = prefix(maxLength, value)
+        }
+        return [name, value ? encode(value) : null]
+    })
+    if (!values.filter(([, value]) => value).length) return ''
+    return first + values
+        .map(([name, value]) => value
+            ? (named ? name + (value ? '=' + value : ifemp) : value) : '')
+        .filter(x => x).join(sep)
+})
+export const getVariables = str => new Set(Array.from(str.matchAll(regex),
+    ([,, variableList]) => variableList.split(',')
+        .map(varspec => varspec.match(varspecRegex)?.[1])).flat())

packages/foliate-js/vendor/fflate.js ADDED Viewed

	@@ -0,0 +1 @@

+ var r=Uint8Array,a=Uint16Array,e=Int32Array,n=new r([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new r([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),t=new r([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),f=function(r,n){for(var i=new a(31),t=0;t<31;++t)i[t]=n+=1<<r[t-1];var f=new e(i[30]);for(t=1;t<30;++t)for(var o=i[t];o<i[t+1];++o)f[o]=o-i[t]<<5|t;return{b:i,r:f}},o=f(n,2),v=o.b,l=o.r;v[28]=258,l[258]=28;for(var u=f(i,0).b,c=new a(32768),d=0;d<32768;++d){var w=(43690&d)>>1|(21845&d)<<1;w=(61680&(w=(52428&w)>>2|(13107&w)<<2))>>4|(3855&w)<<4,c[d]=((65280&w)>>8|(255&w)<<8)>>1}var b=function(r,e,n){for(var i=r.length,t=0,f=new a(e);t<i;++t)r[t]&&++f[r[t]-1];var o,v=new a(e);for(t=1;t<e;++t)v[t]=v[t-1]+f[t-1]<<1;if(n){o=new a(1<<e);var l=15-e;for(t=0;t<i;++t)if(r[t])for(var u=t<<4|r[t],d=e-r[t],w=v[r[t]-1]++<<d,b=w|(1<<d)-1;w<=b;++w)o[c[w]>>l]=u}else for(o=new a(i),t=0;t<i;++t)r[t]&&(o[t]=c[v[r[t]-1]++]>>15-r[t]);return o},s=new r(288);for(d=0;d<144;++d)s[d]=8;for(d=144;d<256;++d)s[d]=9;for(d=256;d<280;++d)s[d]=7;for(d=280;d<288;++d)s[d]=8;var h=new r(32);for(d=0;d<32;++d)h[d]=5;var y=b(s,9,1),g=b(h,5,1),p=function(r){for(var a=r[0],e=1;e<r.length;++e)r[e]>a&&(a=r[e]);return a},k=function(r,a,e){var n=a/8|0;return(r[n]|r[n+1]<<8)>>(7&a)&e},m=function(r,a){var e=a/8|0;return(r[e]|r[e+1]<<8|r[e+2]<<16)>>(7&a)},x=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],T=function(r,a,e){var n=new Error(a||x[r]);if(n.code=r,Error.captureStackTrace&&Error.captureStackTrace(n,T),!e)throw n;return n},E=function(a,e,f,o){var l=a.length,c=o?o.length:0;if(!l||e.f&&!e.l)return f||new r(0);var d=!f,w=d||2!=e.i,s=e.i;d&&(f=new r(3*l));var h=function(a){var e=f.length;if(a>e){var n=new r(Math.max(2*e,a));n.set(f),f=n}},x=e.f||0,E=e.p||0,z=e.b||0,A=e.l,U=e.d,D=e.m,F=e.n,M=8*l;do{if(!A){x=k(a,E,1);var S=k(a,E+1,3);if(E+=3,!S){var I=a[(N=4+((E+7)/8|0))-4]|a[N-3]<<8,O=N+I;if(O>l){s&&T(0);break}w&&h(z+I),f.set(a.subarray(N,O),z),e.b=z+=I,e.p=E=8*O,e.f=x;continue}if(1==S)A=y,U=g,D=9,F=5;else if(2==S){var j=k(a,E,31)+257,q=k(a,E+10,15)+4,B=j+k(a,E+5,31)+1;E+=14;for(var C=new r(B),G=new r(19),H=0;H<q;++H)G[t[H]]=k(a,E+3*H,7);E+=3*q;var J=p(G),K=(1<<J)-1,L=b(G,J,1);for(H=0;H<B;){var N,P=L[k(a,E,K)];if(E+=15&P,(N=P>>4)<16)C[H++]=N;else{var Q=0,R=0;for(16==N?(R=3+k(a,E,3),E+=2,Q=C[H-1]):17==N?(R=3+k(a,E,7),E+=3):18==N&&(R=11+k(a,E,127),E+=7);R--;)C[H++]=Q}}var V=C.subarray(0,j),W=C.subarray(j);D=p(V),F=p(W),A=b(V,D,1),U=b(W,F,1)}else T(1);if(E>M){s&&T(0);break}}w&&h(z+131072);for(var X=(1<<D)-1,Y=(1<<F)-1,Z=E;;Z=E){var $=(Q=A[m(a,E)&X])>>4;if((E+=15&Q)>M){s&&T(0);break}if(Q||T(2),$<256)f[z++]=$;else{if(256==$){Z=E,A=null;break}var _=$-254;if($>264){var rr=n[H=$-257];_=k(a,E,(1<<rr)-1)+v[H],E+=rr}var ar=U[m(a,E)&Y],er=ar>>4;ar||T(3),E+=15&ar;W=u[er];if(er>3){rr=i[er];W+=m(a,E)&(1<<rr)-1,E+=rr}if(E>M){s&&T(0);break}w&&h(z+131072);var nr=z+_;if(z<W){var ir=c-W,tr=Math.min(W,nr);for(ir+z<0&&T(3);z<tr;++z)f[z]=o[ir+z]}for(;z<nr;++z)f[z]=f[z-W]}}e.l=A,e.p=Z,e.b=z,e.f=x,A&&(x=1,e.m=D,e.d=U,e.n=F)}while(!x);return z!=f.length&&d?function(a,e,n){return(null==n||n>a.length)&&(n=a.length),new r(a.subarray(e,n))}(f,0,z):f.subarray(0,z)},z=new r(0);function A(r,a){return E(r.subarray((e=r,n=a&&a.dictionary,(8!=(15&e[0])||e[0]>>4>7||(e[0]<<8|e[1])%31)&&T(6,"invalid zlib data"),(e[1]>>5&1)==+!n&&T(6,"invalid zlib data: "+(32&e[1]?"need":"unexpected")+" dictionary"),2+(e[1]>>3&4)),-4),{i:2},a&&a.out,a&&a.dictionary);var e,n}var U="undefined"!=typeof TextDecoder&&new TextDecoder;try{U.decode(z,{stream:!0})}catch(r){}export{A as unzlibSync};

packages/foliate-js/vendor/pdfjs/annotation_layer_builder.css ADDED Viewed

	@@ -0,0 +1,407 @@

+/* Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+.annotationLayer {
+  color-scheme: only light;
+  --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,<svg width='1px' height='1px' xmlns='http://www.w3.org/2000/svg'><rect width='100%' height='100%' style='fill:rgba(0, 54, 255, 0.13);'/></svg>");
+  --input-focus-border-color: Highlight;
+  --input-focus-outline: 1px solid Canvas;
+  --input-unfocused-border-color: transparent;
+  --input-disabled-border-color: transparent;
+  --input-hover-border-color: black;
+  --link-outline: none;
+  @media screen and (forced-colors: active) {
+    --input-focus-border-color: CanvasText;
+    --input-unfocused-border-color: ActiveText;
+    --input-disabled-border-color: GrayText;
+    --input-hover-border-color: Highlight;
+    --link-outline: 1.5px solid LinkText;
+    .textWidgetAnnotation :is(input, textarea):required,
+    .choiceWidgetAnnotation select:required,
+    .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+      outline: 1.5px solid selectedItem;
+    }
+    .linkAnnotation {
+      outline: var(--link-outline);
+      &:hover {
+        backdrop-filter: var(--hcm-highlight-filter);
+      }
+      & > a:hover {
+        opacity: 0 !important;
+        background: none !important;
+        box-shadow: none;
+      }
+    }
+    .popupAnnotation .popup {
+      outline: calc(1.5px * var(--total-scale-factor)) solid CanvasText !important;
+      background-color: ButtonFace !important;
+      color: ButtonText !important;
+    }
+    .highlightArea:hover::after {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      backdrop-filter: var(--hcm-highlight-filter);
+      content: "";
+      pointer-events: none;
+    }
+    .popupAnnotation.focused .popup {
+      outline: calc(3px * var(--total-scale-factor)) solid Highlight !important;
+    }
+  }
+  position: absolute;
+  top: 0;
+  left: 0;
+  pointer-events: none;
+  transform-origin: 0 0;
+  &[data-main-rotation="90"] .norotate {
+    transform: rotate(270deg) translateX(-100%);
+  }
+  &[data-main-rotation="180"] .norotate {
+    transform: rotate(180deg) translate(-100%, -100%);
+  }
+  &[data-main-rotation="270"] .norotate {
+    transform: rotate(90deg) translateY(-100%);
+  }
+  &.disabled {
+    section,
+    .popup {
+      pointer-events: none;
+    }
+  }
+  .annotationContent {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+    &.freetext {
+      background: transparent;
+      border: none;
+      inset: 0;
+      overflow: visible;
+      white-space: nowrap;
+      font: 10px sans-serif;
+      line-height: 1.35;
+    }
+  }
+  section {
+    position: absolute;
+    text-align: initial;
+    pointer-events: auto;
+    box-sizing: border-box;
+    transform-origin: 0 0;
+    user-select: none;
+    &:has(div.annotationContent) {
+      canvas.annotationContent {
+        display: none;
+      }
+    }
+    .overlaidText {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 0;
+      height: 0;
+      display: inline-block;
+      overflow: hidden;
+    }
+  }
+  .textLayer.selecting ~ & section {
+    pointer-events: none;
+  }
+  :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton) > a {
+    position: absolute;
+    font-size: 1em;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+  }
+  :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton):not(.hasBorder)
+    > a:hover {
+    opacity: 0.2;
+    background-color: rgb(255 255 0);
+  }
+  .linkAnnotation.hasBorder:hover {
+    background-color: rgb(255 255 0 / 0.2);
+  }
+  .hasBorder {
+    background-size: 100% 100%;
+  }
+  .textAnnotation img {
+    position: absolute;
+    cursor: pointer;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+  }
+  .textWidgetAnnotation :is(input, textarea),
+  .choiceWidgetAnnotation select,
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+    background-image: var(--annotation-unfocused-field-background);
+    border: 2px solid var(--input-unfocused-border-color);
+    box-sizing: border-box;
+    font: calc(9px * var(--total-scale-factor)) sans-serif;
+    height: 100%;
+    margin: 0;
+    vertical-align: top;
+    width: 100%;
+  }
+  .textWidgetAnnotation :is(input, textarea):required,
+  .choiceWidgetAnnotation select:required,
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+    outline: 1.5px solid red;
+  }
+  .choiceWidgetAnnotation select option {
+    padding: 0;
+  }
+  .buttonWidgetAnnotation.radioButton input {
+    border-radius: 50%;
+  }
+  .textWidgetAnnotation textarea {
+    resize: none;
+  }
+  .textWidgetAnnotation :is(input, textarea)[disabled],
+  .choiceWidgetAnnotation select[disabled],
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) input[disabled] {
+    background: none;
+    border: 2px solid var(--input-disabled-border-color);
+    cursor: not-allowed;
+  }
+  .textWidgetAnnotation :is(input, textarea):hover,
+  .choiceWidgetAnnotation select:hover,
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:hover {
+    border: 2px solid var(--input-hover-border-color);
+  }
+  .textWidgetAnnotation :is(input, textarea):hover,
+  .choiceWidgetAnnotation select:hover,
+  .buttonWidgetAnnotation.checkBox input:hover {
+    border-radius: 2px;
+  }
+  .textWidgetAnnotation :is(input, textarea):focus,
+  .choiceWidgetAnnotation select:focus {
+    background: none;
+    border: 2px solid var(--input-focus-border-color);
+    border-radius: 2px;
+    outline: var(--input-focus-outline);
+  }
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) :focus {
+    background-image: none;
+    background-color: transparent;
+  }
+  .buttonWidgetAnnotation.checkBox :focus {
+    border: 2px solid var(--input-focus-border-color);
+    border-radius: 2px;
+    outline: var(--input-focus-outline);
+  }
+  .buttonWidgetAnnotation.radioButton :focus {
+    border: 2px solid var(--input-focus-border-color);
+    outline: var(--input-focus-outline);
+  }
+  .buttonWidgetAnnotation.checkBox input:checked::before,
+  .buttonWidgetAnnotation.checkBox input:checked::after,
+  .buttonWidgetAnnotation.radioButton input:checked::before {
+    background-color: CanvasText;
+    content: "";
+    display: block;
+    position: absolute;
+  }
+  .buttonWidgetAnnotation.checkBox input:checked::before,
+  .buttonWidgetAnnotation.checkBox input:checked::after {
+    height: 80%;
+    left: 45%;
+    width: 1px;
+  }
+  .buttonWidgetAnnotation.checkBox input:checked::before {
+    transform: rotate(45deg);
+  }
+  .buttonWidgetAnnotation.checkBox input:checked::after {
+    transform: rotate(-45deg);
+  }
+  .buttonWidgetAnnotation.radioButton input:checked::before {
+    border-radius: 50%;
+    height: 50%;
+    left: 25%;
+    top: 25%;
+    width: 50%;
+  }
+  .textWidgetAnnotation input.comb {
+    font-family: monospace;
+    padding-left: 2px;
+    padding-right: 0;
+  }
+  .textWidgetAnnotation input.comb:focus {
+    /*
+     * Letter spacing is placed on the right side of each character. Hence, the
+     * letter spacing of the last character may be placed outside the visible
+     * area, causing horizontal scrolling. We avoid this by extending the width
+     * when the element has focus and revert this when it loses focus.
+     */
+    width: 103%;
+  }
+  .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+    appearance: none;
+  }
+  .fileAttachmentAnnotation .popupTriggerArea {
+    height: 100%;
+    width: 100%;
+  }
+  .popupAnnotation {
+    position: absolute;
+    font-size: calc(9px * var(--total-scale-factor));
+    pointer-events: none;
+    width: max-content;
+    max-width: 45%;
+    height: auto;
+  }
+  .popup {
+    background-color: rgb(255 255 153);
+    color: black;
+    box-shadow: 0 calc(2px * var(--total-scale-factor))
+      calc(5px * var(--total-scale-factor)) rgb(136 136 136);
+    border-radius: calc(2px * var(--total-scale-factor));
+    outline: 1.5px solid rgb(255 255 74);
+    padding: calc(6px * var(--total-scale-factor));
+    cursor: pointer;
+    font: message-box;
+    white-space: normal;
+    word-wrap: break-word;
+    pointer-events: auto;
+    user-select: text;
+  }
+  .popupAnnotation.focused .popup {
+    outline-width: 3px;
+  }
+  .popup * {
+    font-size: calc(9px * var(--total-scale-factor));
+  }
+  .popup > .header {
+    display: inline-block;
+  }
+  .popup > .header > .title {
+    display: inline;
+    font-weight: bold;
+  }
+  .popup > .header .popupDate {
+    display: inline-block;
+    margin-left: calc(5px * var(--total-scale-factor));
+    width: fit-content;
+  }
+  .popupContent {
+    border-top: 1px solid rgb(51 51 51);
+    margin-top: calc(2px * var(--total-scale-factor));
+    padding-top: calc(2px * var(--total-scale-factor));
+  }
+  .richText > * {
+    white-space: pre-wrap;
+    font-size: calc(9px * var(--total-scale-factor));
+  }
+  .popupTriggerArea {
+    cursor: pointer;
+    &:hover {
+      backdrop-filter: var(--hcm-highlight-filter);
+    }
+  }
+  section svg {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+  }
+  .annotationTextContent {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    color: transparent;
+    user-select: none;
+    pointer-events: none;
+    span {
+      width: 100%;
+      display: inline-block;
+    }
+  }
+  svg.quadrilateralsContainer {
+    contain: strict;
+    width: 0;
+    height: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: -1;
+  }
+}

packages/foliate-js/vendor/pdfjs/cmaps/78-EUC-H.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d92a261336dc18b8c03a46eb4d462382d33f4338fa195d303256b2031434c874
+size 2404

packages/foliate-js/vendor/pdfjs/cmaps/78-EUC-V.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:61670bebc4e4827b67230c054fd0d820d6e30c3584d02e386804e62bbedc032a
+size 173

packages/foliate-js/vendor/pdfjs/cmaps/78-H.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ece6415b853d61e1b2560165151407d35cf16e6556932b85a13ea75276b77402
+size 2379

packages/foliate-js/vendor/pdfjs/cmaps/78-RKSJ-H.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:696b1f973c97623496703809eaaa5f9b40696c77540057413f4b826a08edfa7b
+size 2398

packages/foliate-js/vendor/pdfjs/cmaps/78-RKSJ-V.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:53cb6d560ab377da48cf65d6dcacb0bdb31f13fab7066c580de38c12a73a7ff9
+size 173

packages/foliate-js/vendor/pdfjs/cmaps/78-V.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:289000f02fd34872b6975503217f33abae6bee676e7d28f640473a67c8db1712
+size 169

packages/foliate-js/vendor/pdfjs/cmaps/78ms-RKSJ-H.bcmap ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:a2442595218f5f8bd8e1b42188e368587d876cfe0cc4cd87196f077c878f72e2
+size 2651