@caipira/vue-reader 0.0.1

package/dist/services/browser/url-rewrite.js

@@ -0,0 +1,183 @@
+import { getExt, resolveHref, parseSrcset, guessMediaType, } from '../../services/browser/url';
+const blobUrlCache = new Map();
+const getBlobUrl = (zip, path) => {
+    const existing = blobUrlCache.get(path);
+    if (existing) {
+        return existing;
+    }
+    const data = zip[path];
+    if (!data) {
+        return undefined;
+    }
+    const mime = guessMediaType(getExt(path));
+    // Ensure data is ArrayBuffer or valid BlobPart
+    let blobPart;
+    if (data instanceof Uint8Array) {
+        blobPart =
+            data.buffer instanceof ArrayBuffer
+                ? data.buffer
+                : new Uint8Array(data).buffer;
+    }
+    else {
+        blobPart = data;
+    }
+    const blob = new Blob([blobPart], { type: mime });
+    const url = URL.createObjectURL(blob);
+    blobUrlCache.set(path, url);
+    return url;
+};
+const clearBlobUrlCache = () => {
+    blobUrlCache.forEach((url) => {
+        URL.revokeObjectURL(url);
+    });
+    blobUrlCache.clear();
+};
+const rewriteXhtmlUrls = (doc, resourceHref, zip) => {
+    const ATTRIBUTE_TARGETS = [
+        ['img', 'src'],
+        ['source', 'src'],
+        ['source', 'srcset'],
+        ['video', 'src'],
+        ['video', 'poster'],
+        ['audio', 'src'],
+        ['script', 'src'],
+        ['link', 'href'],
+        ['object', 'data'],
+        ['embed', 'src'],
+        ['image', 'href'],
+        ['use', 'href'],
+    ];
+    // SVG xlink:href
+    try {
+        const useEls = doc.querySelectorAll('use');
+        for (const el of Array.from(useEls)) {
+            const val = el.getAttribute('xlink:href') ||
+                el.getAttributeNS('http://www.w3.org/1999/xlink', 'href');
+            if (!val) {
+                continue;
+            }
+            if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(val)) {
+                continue;
+            }
+            const resolved = resolveHref(resourceHref, val);
+            const blobUrl = getBlobUrl(zip, resolved);
+            if (blobUrl) {
+                el.setAttributeNS('http://www.w3.org/1999/xlink', 'href', blobUrl);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const imgEls = doc.querySelectorAll('image');
+        for (const el of Array.from(imgEls)) {
+            const val = el.getAttribute('xlink:href') ||
+                el.getAttributeNS('http://www.w3.org/1999/xlink', 'href');
+            if (!val) {
+                continue;
+            }
+            if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(val)) {
+                continue;
+            }
+            const resolved = resolveHref(resourceHref, val);
+            const blobUrl = getBlobUrl(zip, resolved);
+            if (blobUrl) {
+                el.setAttributeNS('http://www.w3.org/1999/xlink', 'href', blobUrl);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    for (const [tag, attr] of ATTRIBUTE_TARGETS) {
+        const selector = `${tag}[${attr}]`;
+        let elements;
+        try {
+            elements = Array.from(doc.querySelectorAll(selector));
+        }
+        catch {
+            continue;
+        }
+        for (const el of elements) {
+            const val = el.getAttribute(attr);
+            if (!val) {
+                continue;
+            }
+            if (attr === 'srcset') {
+                const urls = parseSrcset(val);
+                let changed = false;
+                const parts = val.split(',').map((part) => {
+                    const trimmed = part.trim();
+                    const firstSpace = trimmed.indexOf(' ');
+                    const src = firstSpace < 0
+                        ? trimmed
+                        : trimmed.substring(0, firstSpace).trim();
+                    const rest = firstSpace >= 0 ? trimmed.substring(firstSpace) : '';
+                    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(src)) {
+                        return part;
+                    }
+                    const resolved = resolveHref(resourceHref, src);
+                    const blobUrl = getBlobUrl(zip, resolved);
+                    if (blobUrl) {
+                        changed = true;
+                        return blobUrl + rest;
+                    }
+                    return part;
+                });
+                if (changed) {
+                    el.setAttribute(attr, parts.join(', '));
+                }
+            }
+            else {
+                if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(val)) {
+                    continue;
+                }
+                const resolved = resolveHref(resourceHref, val);
+                const blobUrl = getBlobUrl(zip, resolved);
+                if (blobUrl) {
+                    el.setAttribute(attr, blobUrl);
+                }
+            }
+        }
+    }
+    // Handle url() references in style attributes and <style> elements
+    styleUrlRewriteLoop(doc, resourceHref, zip);
+};
+const styleUrlRewriteLoop = (doc, resourceHref, zip) => {
+    const URL_RE = /url\(\s*["']?([^"')\\s]+)["']?\s*\)/g;
+    const rewriteFn = (_match, url) => {
+        if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url)) {
+            return _match;
+        }
+        const resolved = resolveHref(resourceHref, url);
+        const blobUrl = getBlobUrl(zip, resolved);
+        return blobUrl ? `url(${blobUrl})` : _match;
+    };
+    for (const el of Array.from(doc.querySelectorAll('[style]'))) {
+        const style = el.getAttribute('style');
+        if (style && URL_RE.test(style)) {
+            URL_RE.lastIndex = 0;
+            el.setAttribute('style', style.replace(URL_RE, rewriteFn));
+        }
+    }
+    for (const el of Array.from(doc.querySelectorAll('style'))) {
+        const content = el.textContent;
+        if (content && URL_RE.test(content)) {
+            URL_RE.lastIndex = 0;
+            el.textContent = content.replace(URL_RE, rewriteFn);
+        }
+    }
+};
+const rewriteCssUrls = (css, resourceHref, zip) => {
+    const URL_RE = /url\(\s*["']?([^"')\\s]+)["']?\s*\)/g;
+    return css.replace(URL_RE, (_match, url) => {
+        if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url)) {
+            return _match;
+        }
+        const resolved = resolveHref(resourceHref, url);
+        const blobUrl = getBlobUrl(zip, resolved);
+        return blobUrl ? `url(${blobUrl})` : _match;
+    });
+};
+export { clearBlobUrlCache, rewriteXhtmlUrls, rewriteCssUrls };

package/dist/services/browser/url.d.ts

@@ -0,0 +1,11 @@
+declare const guessMediaType: (ext: string) => string;
+declare const getExt: (path: string) => string;
+/**
+ * Resolve a relative URL against a base resource path (absolute in the zip).
+ *
+ * e.g. resolveHref('OEBPS/Text/ch1.xhtml', '../Images/title.jpg')
+ *   → 'OEBPS/Images/title.jpg'
+ */
+declare const resolveHref: (base: string, relative: string) => string;
+declare const parseSrcset: (value: string) => string[];
+export { guessMediaType, getExt, resolveHref, parseSrcset };

package/dist/services/browser/url.js

@@ -0,0 +1,82 @@
+const guessMediaType = (ext) => {
+    const m = {
+        xhtml: 'application/xhtml+xml',
+        html: 'text/html',
+        htm: 'text/html',
+        css: 'text/css',
+        js: 'text/javascript',
+        ncx: 'application/x-dtbncx+xml',
+        xml: 'application/xml',
+        smil: 'application/smil+xml',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        webp: 'image/webp',
+        avif: 'image/avif',
+        otf: 'font/otf',
+        ttf: 'font/ttf',
+        woff: 'font/woff',
+        woff2: 'font/woff2',
+        mp3: 'audio/mpeg',
+        mp4: 'audio/mp4',
+        ogg: 'audio/ogg',
+        wav: 'audio/wav',
+        webm: 'video/webm',
+        opf: 'application/oebps-package+xml',
+        pls: 'application/pls+xml',
+    };
+    return m[ext] ?? 'application/octet-stream';
+};
+const getExt = (path) => {
+    const i = path.lastIndexOf('.');
+    return i >= 0 ? path.slice(i + 1).toLowerCase() : '';
+};
+/**
+ * Resolve a relative URL against a base resource path (absolute in the zip).
+ *
+ * e.g. resolveHref('OEBPS/Text/ch1.xhtml', '../Images/title.jpg')
+ *   → 'OEBPS/Images/title.jpg'
+ */
+const resolveHref = (base, relative) => {
+    const rel = relative.trim();
+    if (rel.startsWith('/')) {
+        return rel.slice(1);
+    }
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(rel)) {
+        return rel;
+    }
+    const dir = base.lastIndexOf('/') >= 0 ? base.substring(0, base.lastIndexOf('/') + 1) : '';
+    const stack = (dir + rel).split('/');
+    const result = [];
+    for (const seg of stack) {
+        if (seg === '.' || seg === '') {
+            continue;
+        }
+        if (seg === '..') {
+            if (result.length > 0) {
+                result.pop();
+            }
+        }
+        else {
+            result.push(seg);
+        }
+    }
+    return result.join('/');
+};
+const parseSrcset = (value) => {
+    const urls = [];
+    for (const part of value.split(',')) {
+        const trimmed = part.trim();
+        const firstSpace = trimmed.indexOf(' ');
+        if (firstSpace < 0) {
+            urls.push(trimmed);
+        }
+        else {
+            urls.push(trimmed.substring(0, firstSpace).trim());
+        }
+    }
+    return urls;
+};
+export { guessMediaType, getExt, resolveHref, parseSrcset };

package/dist/services/browser/zip-fetcher.d.ts

@@ -0,0 +1,12 @@
+import type { Fetcher } from '@readium/shared';
+import type { ZipData } from '../../types/browser';
+import { Link } from '@readium/shared';
+import { Resource } from '@readium/shared';
+declare class ZipFetcher implements Fetcher {
+    private zip;
+    constructor(zip: ZipData);
+    links(): Link[];
+    get(link: Link): Resource;
+    close(): void;
+}
+export default ZipFetcher;

package/dist/services/browser/zip-fetcher.js

@@ -0,0 +1,123 @@
+import { Link } from '@readium/shared';
+import { Resource } from '@readium/shared';
+import { guessMediaType, getExt } from '../../services/browser/url';
+import { rewriteCssUrls, rewriteXhtmlUrls, clearBlobUrlCache, } from '../../services/browser/url-rewrite';
+const isHtmlType = (path) => {
+    const ext = getExt(path);
+    return ext === 'xhtml' || ext === 'html' || ext === 'htm' || ext === 'svg';
+};
+class ZipResource extends Resource {
+    zip;
+    _link;
+    constructor(zip, link) {
+        super();
+        this.zip = zip;
+        this._link = link;
+    }
+    async link() {
+        return this._link;
+    }
+    async length() {
+        return this.zip[this._link.href]?.length;
+    }
+    async read(range) {
+        const data = this.zip[this._link.href];
+        if (!data) {
+            return undefined;
+        }
+        if (range) {
+            return data.slice(range.start, range.endInclusive + 1);
+        }
+        return data;
+    }
+    async readAsString() {
+        const data = this.zip[this._link.href];
+        if (!data) {
+            return undefined;
+        }
+        let str = new TextDecoder('utf-8').decode(data).replace(/^\uFEFF/, '');
+        // Replace HTML-only named entities invalid in XHTML
+        str = str.replace(/&(?!(?:amp|lt|gt|quot|apos);)([a-zA-Z][a-zA-Z0-9]*);/g, (match) => {
+            const el = document.createElement('span');
+            el.innerHTML = match;
+            return el.textContent ?? match;
+        });
+        // Rewrite relative resource URLs for HTML/XHTML/SVG and CSS
+        if (isHtmlType(this._link.href)) {
+            const mime = this._link.type &&
+                (this._link.type === 'application/xhtml+xml' ||
+                    this._link.type === 'text/html')
+                ? this._link.type
+                : guessMediaType(getExt(this._link.href));
+            try {
+                const doc = new DOMParser().parseFromString(str, mime);
+                const err = doc.querySelector('parsererror');
+                if (!err) {
+                    rewriteXhtmlUrls(doc, this._link.href, this.zip);
+                    // Readium's go_id handler uses document.getElementById(id),
+                    // which does not match name attributes.  Copy name→id so
+                    // anchor fragments resolve correctly.
+                    for (const el of Array.from(doc.querySelectorAll('[name]'))) {
+                        if (!el.id && el.getAttribute('name')) {
+                            el.id = el.getAttribute('name');
+                        }
+                    }
+                    if (this._link.type === 'application/xhtml+xml' ||
+                        mime === 'application/xhtml+xml' ||
+                        getExt(this._link.href) === 'xhtml' ||
+                        getExt(this._link.href) === 'svg') {
+                        str = new XMLSerializer().serializeToString(doc);
+                    }
+                    else {
+                        str = doc.documentElement.outerHTML;
+                    }
+                }
+            }
+            catch {
+                // If parsing fails, continue with the original string
+            }
+        }
+        else if (getExt(this._link.href) === 'css') {
+            try {
+                str = rewriteCssUrls(str, this._link.href, this.zip);
+            }
+            catch {
+                // If rewriting fails, continue with the original string
+            }
+        }
+        // Ensure <html> has the XHTML namespace
+        if (/<html[^>]*>/i.test(str) &&
+            !/xmlns\s*=\s*["']http:\/\/www\.w3\.org\/1999\/xhtml["']/i.test(str)) {
+            str = str.replace(/(<html)([^>]*>)/i, (_m, open, rest) => `${open} xmlns="http://www.w3.org/1999/xhtml"${rest}`);
+        }
+        return str;
+    }
+    async readAsJSON() {
+        const str = await this.readAsString();
+        return str ? JSON.parse(str) : undefined;
+    }
+    async readAsXML() {
+        const str = await this.readAsString();
+        if (!str) {
+            return undefined;
+        }
+        return new DOMParser().parseFromString(str, 'application/xml');
+    }
+    close() { }
+}
+class ZipFetcher {
+    zip;
+    constructor(zip) {
+        this.zip = zip;
+    }
+    links() {
+        return Object.keys(this.zip).map((path) => new Link({ href: path, type: guessMediaType(getExt(path)) }));
+    }
+    get(link) {
+        return new ZipResource(this.zip, link);
+    }
+    close() {
+        clearBlobUrlCache();
+    }
+}
+export default ZipFetcher;

package/dist/services/common/progression.d.ts

@@ -0,0 +1,32 @@
+import type { ZipData } from '../../types/browser';
+import type { ChapterBoundary } from '../../types/common';
+import { Link, Locator, Publication } from '@readium/shared';
+/**
+ * Scan the content files referenced by TOC entries and compute
+ * approximate progression boundaries for each chapter anchor.
+ *
+ * This is needed for books where all chapters live in a single spine
+ * file (e.g. EPUB 2 with fragment anchors) – the spine link always
+ * reports the same href, so we use progression within the file to
+ * determine which chapter the reader is on.
+ */
+declare const computeChapterProgressions: (toc: Link[], zip: ZipData) => Map<string, ChapterBoundary[]>;
+declare const generatePositions: (pub: Publication) => Locator[];
+declare const buildWeightsFromZip: (pub: Publication, zip: ZipData) => ((idx: number, rawProg?: number) => {
+    progress: number;
+    resourceProgression: number;
+});
+declare const buildWeightsFromResolver: (pub: Publication, resolveSize: (href: string) => number | undefined) => ((idx: number, rawProg?: number) => {
+    progress: number;
+    resourceProgression: number;
+});
+/**
+ * Save the current position (spine index and progression) for the given URL in sessionStorage.
+ */
+declare const savePosition: (url: string, persisted: Locator) => void;
+/**
+ * Restore the saved position for the given URL from sessionStorage.
+ */
+declare const restorePosition: (url: string, publication: Publication) => Locator | undefined;
+declare const computePublicationChaptersSize: (publication: Publication) => Promise<Map<string, number>>;
+export { savePosition, restorePosition, generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };

package/dist/services/common/progression.js

@@ -0,0 +1,169 @@
+import { Locator, LocatorLocations } from '@readium/shared';
+/**
+ * Scan the content files referenced by TOC entries and compute
+ * approximate progression boundaries for each chapter anchor.
+ *
+ * This is needed for books where all chapters live in a single spine
+ * file (e.g. EPUB 2 with fragment anchors) – the spine link always
+ * reports the same href, so we use progression within the file to
+ * determine which chapter the reader is on.
+ */
+const computeChapterProgressions = (toc, zip) => {
+    const result = new Map();
+    for (const tocLink of toc) {
+        if (!tocLink.title)
+            continue;
+        const parts = tocLink.href.split('#');
+        const baseHref = parts[0];
+        const fragment = parts[1];
+        if (!baseHref || !fragment)
+            continue;
+        // Read the raw text so we can find the anchor position by offset
+        const raw = zip[baseHref];
+        if (!raw)
+            continue;
+        let content;
+        try {
+            content = new TextDecoder('utf-8').decode(raw);
+        }
+        catch {
+            continue;
+        }
+        // Escape special regex chars in the fragment ID
+        const escaped = fragment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Look for id="fragment" or name="fragment"
+        const pattern = new RegExp(`(?:id|name)\\s*=\\s*["']${escaped}["']`);
+        const match = content.match(pattern);
+        if (!match || match.index === undefined) {
+            continue;
+        }
+        const offset = match.index;
+        const prog = content.length > 0 ? offset / content.length : 0;
+        let entries = result.get(baseHref);
+        if (!entries) {
+            entries = [];
+            result.set(baseHref, entries);
+        }
+        entries.push({ title: tocLink.title, startProg: prog });
+    }
+    // Sort each file's entries by progression ascending
+    for (const [, entries] of result) {
+        entries.sort((a, b) => a.startProg - b.startProg);
+    }
+    return result;
+};
+const generatePositions = (pub) => {
+    const items = pub.readingOrder.items;
+    if (items.length === 0) {
+        return [];
+    }
+    return items.map((link, index) => {
+        return new Locator({
+            href: link.href,
+            type: link.type || 'application/xhtml+xml',
+            title: link.title,
+            locations: new LocatorLocations({
+                position: index + 1,
+                progression: 0,
+            }),
+        });
+    });
+};
+/**
+ * Returns a function that computes overall publication progression based on
+ * the current spine index and progression within that spine item, using
+ * weights derived from the sizes of the spine items.
+ */
+const buildWeightedProgressCalculator = (resourceWeights) => {
+    const totalWeight = resourceWeights.reduce((sum, rw) => sum + rw.size, 0);
+    let cumulativeWeights = [];
+    let resourceProgression = 0;
+    let currentResourceIdx = 0;
+    let cum = 0;
+    cumulativeWeights = resourceWeights.map((rw) => {
+        const before = cum;
+        cum += rw.size;
+        return before;
+    });
+    return (idx, rawProg) => {
+        let progress = 0;
+        if (idx !== currentResourceIdx) {
+            currentResourceIdx = idx;
+            if (rawProg !== undefined && rawProg >= 0 && rawProg <= 1) {
+                resourceProgression = rawProg;
+            }
+            else {
+                resourceProgression = 0;
+            }
+        }
+        else if (rawProg !== undefined && rawProg >= 0 && rawProg <= 1) {
+            resourceProgression = rawProg;
+        }
+        if (totalWeight > 0 && idx < resourceWeights.length) {
+            const w = resourceWeights[idx].size;
+            const before = cumulativeWeights[idx];
+            progress = (before + resourceProgression * w) / totalWeight;
+        }
+        return { progress, resourceProgression };
+    };
+};
+const buildWeightsFromZip = (pub, zip) => {
+    const resourceWeights = pub.readingOrder.items.map((item) => ({
+        href: item.href,
+        size: zip[item.href]?.length ?? 1,
+    }));
+    return buildWeightedProgressCalculator(resourceWeights);
+};
+const buildWeightsFromResolver = (pub, resolveSize) => {
+    const resourceWeights = pub.readingOrder.items.map((item) => ({
+        href: item.href,
+        size: resolveSize(item.href) ?? 1,
+    }));
+    return buildWeightedProgressCalculator(resourceWeights);
+};
+/**
+ * Save the current position (spine index and progression) for the given URL in sessionStorage.
+ */
+const savePosition = (url, persisted) => {
+    sessionStorage.setItem(`epub-locator:${url}`, JSON.stringify(persisted.serialize()));
+};
+/**
+ * Restore the saved position for the given URL from sessionStorage.
+ */
+const restorePosition = (url, publication) => {
+    const saved = sessionStorage.getItem(`epub-locator:${url}`);
+    if (saved) {
+        const raw = JSON.parse(saved);
+        const parsed = Locator.deserialize(raw);
+        if (parsed) {
+            const href = parsed.href;
+            const idx = publication.readingOrder.findIndexWithHref(href) ?? -1;
+            if (idx >= 0) {
+                const prog = parsed.locations?.progression !== undefined &&
+                    parsed.locations.progression >= 0 &&
+                    parsed.locations.progression <= 1
+                    ? parsed.locations.progression
+                    : 0;
+                return parsed.copyWithLocations({
+                    position: idx + 1,
+                    progression: prog,
+                });
+            }
+        }
+    }
+};
+const computePublicationChaptersSize = async (publication) => {
+    const resourceSizes = new Map();
+    await Promise.all(publication.readingOrder.items.map(async (item) => {
+        const href = (item?.href ?? '').split('#')[0];
+        if (!href || resourceSizes.has(href)) {
+            return;
+        }
+        const length = await publication.get(item).length();
+        if (typeof length === 'number' && Number.isFinite(length) && length > 0) {
+            resourceSizes.set(href, length);
+        }
+    }));
+    return resourceSizes;
+};
+export { savePosition, restorePosition, generatePositions, buildWeightsFromZip, buildWeightsFromResolver, computeChapterProgressions, computePublicationChaptersSize, };

package/dist/services/common/title.d.ts

@@ -0,0 +1,11 @@
+import type { Locator } from '@readium/shared';
+import type { TocEntry, ChapterBoundary } from '../../types/common';
+/**
+ * Determine chapter title:
+ *     1. Progression-based lookup (single-file multi-chapter books)
+ *     2. Reading-order title (spine link fallback from TOC)
+ *     3. Fragment-aware TOC match
+ *     4. Base-href TOC fallback
+ */
+declare const getCurrentTitle: (locator: Locator, chapterProgressions: Map<string, ChapterBoundary[]>, tocLinks: TocEntry[]) => string;
+export { getCurrentTitle };

package/dist/services/common/title.js

@@ -0,0 +1,40 @@
+/**
+ * Determine chapter title:
+ *     1. Progression-based lookup (single-file multi-chapter books)
+ *     2. Reading-order title (spine link fallback from TOC)
+ *     3. Fragment-aware TOC match
+ *     4. Base-href TOC fallback
+ */
+const getCurrentTitle = (locator, chapterProgressions, tocLinks) => {
+    let chapterTitle = '';
+    const locBase = locator.href.split('#')[0];
+    const prog = locator.locations?.progression ?? 0;
+    const chapters = chapterProgressions.get(locBase);
+    if (chapters && chapters.length > 1) {
+        // Multi-chapter file → find the chapter whose startProg
+        // is the greatest that is ≤ current progression.
+        for (let i = chapters.length - 1; i >= 0; i--) {
+            if (prog >= chapters[i].startProg) {
+                chapterTitle = chapters[i].title;
+                break;
+            }
+        }
+    }
+    if (!chapterTitle && locator.title) {
+        chapterTitle = locator.title;
+    }
+    if (!chapterTitle && tocLinks.length > 0) {
+        const tocMatch = tocLinks.find((entry) => locator.href === entry.link.href);
+        if (tocMatch) {
+            chapterTitle = tocMatch.title;
+        }
+        else {
+            const baseMatch = tocLinks.find((entry) => entry.link.href.split('#')[0] === locBase);
+            if (baseMatch) {
+                chapterTitle = baseMatch.title;
+            }
+        }
+    }
+    return chapterTitle;
+};
+export { getCurrentTitle };

package/dist/services/common/word-decorations.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+import type { EpubNavigator } from '@readium/navigator';
+import type { ReadiumWordDecorationsController } from '../../types/common';
+export declare const createReadiumWordDecorationsController: (navigatorRef: Ref<EpubNavigator | null>, languageRef: () => string | undefined) => ReadiumWordDecorationsController;