@readium/navigator 2.2.7 → 2.2.8

package/src/injection/epubInjectables.ts

@@ -0,0 +1,90 @@
+import { IInjectableRule, IInjectable } from "../injection/Injectable";
+import { stripJS, stripCSS } from "../helpers/minify";
+import { Metadata, Layout } from "@readium/shared";
+
+import readiumCSSAfter from "@readium/css/css/dist/ReadiumCSS-after.css?raw";
+import readiumCSSBefore from "@readium/css/css/dist/ReadiumCSS-before.css?raw";
+import readiumCSSDefault from "@readium/css/css/dist/ReadiumCSS-default.css?raw";
+
+import cssSelectorGeneratorContent from "../dom/_readium_cssSelectorGenerator.js?raw";
+import executionPreventionContent from "../dom/_readium_executionPrevention.js?raw";
+import onloadProxyContent from "../dom/_readium_executionCleanup.js?raw";
+
+/**
+ * Creates injectable rules for EPUB content documents
+ */
+export function createReadiumEpubRules(metadata: Metadata): IInjectableRule[] {
+    const isFixedLayout = metadata.effectiveLayout === Layout.fixed;
+    
+    // Core injectables that should be prepended
+    const prependInjectables: IInjectable[] = [
+        // CSS Selector Generator - always injected
+        {
+            id: "css-selector-generator",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(cssSelectorGeneratorContent)], { type: "text/javascript" })
+        },
+        // Execution Prevention - conditional (has executable scripts)
+        {
+            id: "execution-prevention",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(executionPreventionContent)], { type: "text/javascript" }),
+            condition: (doc: Document) => !!(doc.querySelector("script") || doc.querySelector("body[onload]:not(body[onload=''])"))
+        }
+    ];
+
+    // Core injectables that should be appended
+    const appendInjectables: IInjectable[] = [
+        // Onload Proxy - conditional (has executable scripts)
+        {
+            id: "onload-proxy",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(onloadProxyContent)], { type: "text/javascript" }),
+            condition: (doc: Document) => !!(doc.querySelector("script") || doc.querySelector("body[onload]:not(body[onload=''])"))
+        }
+    ];
+
+    // Only add Readium CSS for reflowable documents
+    if (!isFixedLayout) {
+        // Readium CSS Before - prepended for reflowable
+        prependInjectables.unshift({
+            id: "readium-css-before",
+            as: "link",
+            target: "head",
+            blob: new Blob([stripCSS(readiumCSSBefore)], { type: "text/css" }),
+            rel: "stylesheet"
+        });
+        
+        // Readium CSS Default and After - appended for reflowable
+        appendInjectables.unshift(
+            // Readium CSS Default - only for reflowable AND no existing styles
+            {
+                id: "readium-css-default",
+                as: "link",
+                target: "head",
+                blob: new Blob([stripCSS(readiumCSSDefault)], { type: "text/css" }),
+                rel: "stylesheet",
+                condition: (doc: Document) => !(doc.querySelector("link[rel='stylesheet']") || doc.querySelector("style") || doc.querySelector("[style]:not([style=''])"))
+            },
+            // Readium CSS After - only for reflowable
+            {
+                id: "readium-css-after",
+                as: "link",
+                target: "head",
+                blob: new Blob([stripCSS(readiumCSSAfter)], { type: "text/css" }),
+                rel: "stylesheet"
+            }
+        );
+    }
+
+    return [
+        {
+            resources: [/\.xhtml$/, /\.html$/],
+            prepend: prependInjectables,
+            append: appendInjectables
+        }
+    ];
+}

package/src/injection/index.ts

@@ -0,0 +1,2 @@
+export * from "./Injectable";
+export * from "./Injector";

package/src/injection/webpubInjectables.ts

@@ -0,0 +1,59 @@
+import { IInjectableRule, IInjectable } from "../injection/Injectable";
+import { stripJS, stripCSS } from "../helpers/minify";
+
+import readiumCSSWebPub from "@readium/css/css/dist/webPub/ReadiumCSS-webPub.css?raw";
+
+import cssSelectorGeneratorContent from "../dom/_readium_cssSelectorGenerator.js?raw";
+import webpubExecutionContent from "../dom/_readium_webpubExecution.js?raw";
+import onloadProxyContent from "../dom/_readium_executionCleanup.js?raw";
+
+/**
+ * Creates injectable rules for WebPub content documents
+ */
+export function createReadiumWebPubRules(): IInjectableRule[] {
+    // Core injectables that should be prepended
+    const prependInjectables: IInjectable[] = [
+        // CSS Selector Generator - always injected
+        {
+            id: "css-selector-generator",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(cssSelectorGeneratorContent)], { type: "text/javascript" })
+        },
+        // WebPub Execution - always injected (sets up event blocking to false)
+        {
+            id: "webpub-execution",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(webpubExecutionContent)], { type: "text/javascript" })
+        }
+    ];
+
+    // Core injectables that should be appended
+    const appendInjectables: IInjectable[] = [
+        // Onload Proxy - conditional (has executable scripts)
+        {
+            id: "onload-proxy",
+            as: "script",
+            target: "head",
+            blob: new Blob([stripJS(onloadProxyContent)], { type: "text/javascript" }),
+            condition: (doc: Document) => !!(doc.querySelector("script") || doc.querySelector("body[onload]:not(body[onload=''])"))
+        },
+        // Readium CSS WebPub - always injected
+        {
+            id: "readium-css-webpub",
+            as: "link",
+            target: "head",
+            blob: new Blob([stripCSS(readiumCSSWebPub)], { type: "text/css" }),
+            rel: "stylesheet"
+        }
+    ];
+
+    return [
+        {
+            resources: [/\.xhtml$/, /\.html$/],
+            prepend: prependInjectables,
+            append: appendInjectables
+        }
+    ];
+}

package/src/webpub/WebPubBlobBuilder.ts

@@ -1,78 +1,27 @@
 import { Link, Publication } from "@readium/shared";
-
-// Readium CSS imports
-// The "?inline" query is to prevent some bundlers from injecting these into the page (e.g. vite)
-// @ts-ignore
-import readiumCSSWebPub from "@readium/css/css/dist/webPub/ReadiumCSS-webPub.css?inline";
-
-// Import the pre-built CSS selector generator
-// This has to be injected because you need to be in the iframe's context for it to work properly
-import cssSelectorGeneratorContent from "../dom/_readium_cssSelectorGenerator.js?raw";
-
-// Utilities
-const blobify = (source: string, type: string) => URL.createObjectURL(new Blob([source], { type }));
-const stripJS = (source: string) => source.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\n/g, "").replace(/\s+/g, " ");
-const stripCSS = (source: string) => source.replace(/\/\*(?:(?!\*\/)[\s\S])*\*\/|[\r\n\t]+/g, '').replace(/ {2,}/g, ' ')
-    // Fully resolve absolute local URLs created by bundlers since it's going into a blob
-    .replace(/url\((?!(https?:)?\/\/)("?)\/([^\)]+)/g, `url($2${window.location.origin}/$3`);
-const scriptify = (doc: Document, source: string) => {
-    const s = doc.createElement("script");
-    s.dataset.readium = "true";
-    s.src = source.startsWith("blob:") ? source : blobify(source, "text/javascript");
-    return s;
-}
-const styleify = (doc: Document, source: string) => {
-    const s = doc.createElement("link");
-    s.dataset.readium = "true";
-    s.rel = "stylesheet";
-    s.type = "text/css";
-    s.href = source.startsWith("blob:") ? source : blobify(source, "text/css");
-    return s;
-}
-
-type CacheFunction = () => string;
-const resourceBlobCache = new Map<string, string>();
-const cached = (key: string, cacher: CacheFunction) => {
-    if(resourceBlobCache.has(key)) return resourceBlobCache.get(key)!;
-    const value = cacher();
-    resourceBlobCache.set(key, value);
-    return value;
-};
-
-const cssSelectorGenerator = (doc: Document) => scriptify(doc, cached("css-selector-generator", () => blobify(
-    cssSelectorGeneratorContent,
-    "text/javascript"
-)));
-
-const readiumPropertiesScript = `
-window._readium_blockedEvents = [];
-window._readium_blockEvents = false; // WebPub doesn't need event blocking
-window._readium_eventBlocker = null;
-`;
-
-const rBefore = (doc: Document) => scriptify(doc, cached("webpub-js-before", () => blobify(stripJS(readiumPropertiesScript), "text/javascript")));
-const rAfter = (doc: Document) => scriptify(doc, cached("webpub-js-after", () => blobify(stripJS(`
-if(window.onload) window.onload = new Proxy(window.onload, {
-    apply: function(target, receiver, args) {
-        if(!window._readium_blockEvents) {
-            Reflect.apply(target, receiver, args);
-            return;
-        }
-        _readium_blockedEvents.push([0, target, receiver, args]);
-    }
-});`), "text/javascript")));
+import { Injector } from "../injection/Injector";
 
 export class WebPubBlobBuilder {
     private readonly item: Link;
     private readonly burl: string;
     private readonly pub: Publication;
     private readonly cssProperties?: { [key: string]: string };
-
-    constructor(pub: Publication, baseURL: string, item: Link, cssProperties?: { [key: string]: string }) {
+    private readonly injector: Injector | null = null;
+
+    constructor(
+        pub: Publication,
+        baseURL: string,
+        item: Link,
+        options: {
+            cssProperties?: { [key: string]: string };
+            injector?: Injector | null;
+        }
+    ) {
         this.pub = pub;
         this.item = item;
         this.burl = item.toURL(baseURL) || "";
-        this.cssProperties = cssProperties;
+        this.cssProperties = options.cssProperties;
+        this.injector = options.injector ?? null;
     }
 
     public async build(): Promise<string> {
@@ -96,14 +45,12 @@ export class WebPubBlobBuilder {
             const details = perror.querySelector("div");
             throw new Error(`Failed parsing item ${this.item.href}: ${details?.textContent || perror.textContent}`);
         }
-        return this.finalizeDOM(doc, this.burl, this.item.mediaType, txt, this.cssProperties);
-    }
 
-    private hasExecutable(doc: Document): boolean {
-        return (
-            !!doc.querySelector("script") ||
-            !!doc.querySelector("body[onload]:not(body[onload=''])")
-        );
+        // Apply resource injections if injection service is provided
+        if (this.injector) {
+            await this.injector.injectForDocument(doc, this.item);
+        }
+        return this.finalizeDOM(doc, this.burl, this.item.mediaType, txt, this.cssProperties);
     }
 
     private setProperties(cssProperties: { [key: string]: string }, doc: Document) {
@@ -116,9 +63,6 @@ export class WebPubBlobBuilder {
     private finalizeDOM(doc: Document, base: string | undefined, mediaType: any, txt?: string, cssProperties?: { [key: string]: string }): string {
         if(!doc) return "";
 
-        // ReadiumCSS WebPub
-        doc.head.appendChild(styleify(doc, cached("ReadiumCSS-webpub", () => blobify(stripCSS(readiumCSSWebPub), "text/css"))));
-
         if (cssProperties) {
             this.setProperties(cssProperties, doc);
         }
@@ -134,11 +78,6 @@ export class WebPubBlobBuilder {
             doc.head.firstChild!.before(b);
         }
 
-        const hasExecutable = this.hasExecutable(doc);
-        if(hasExecutable) doc.head.firstChild!.before(rBefore(doc));
-        doc.head.firstChild!.before(cssSelectorGenerator(doc));
-        if(hasExecutable) doc.head.appendChild(rAfter(doc));
-
         // Serialize properly based on content type
         let serializedContent: string;
 

package/src/webpub/WebPubFramePoolManager.ts

@@ -2,6 +2,7 @@ import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
 import { WebPubBlobBuilder } from "./WebPubBlobBuilder";
 import { WebPubFrameManager } from "./WebPubFrameManager";
+import { Injector } from "../injection/Injector";
 
 export class WebPubFramePoolManager {
     private readonly container: HTMLElement;
@@ -12,10 +13,16 @@ export class WebPubFramePoolManager {
     private readonly inprogress: Map<string, Promise<void>> = new Map();
     private pendingUpdates: Map<string, { inPool: boolean }> = new Map();
     private currentBaseURL: string | undefined;
+    private readonly injector?: Injector | null = null;
 
-    constructor(container: HTMLElement, cssProperties?: { [key: string]: string }) {
+    constructor(
+        container: HTMLElement, 
+        cssProperties?: { [key: string]: string },
+        injector?: Injector | null
+    ) {
         this.container = container;
         this.currentCssProperties = cssProperties;
+        this.injector = injector;
     }
 
     async destroy() {
@@ -42,9 +49,15 @@ export class WebPubFramePoolManager {
         this.pool.clear();
 
         // Revoke all blobs
-        this.blobs.forEach(v => URL.revokeObjectURL(v));
+        this.blobs.forEach(v => {
+            this.injector?.releaseBlobUrl?.(v);
+            URL.revokeObjectURL(v);
+        });
         this.blobs.clear();
 
+        // Clean up injector if it exists
+        this.injector?.dispose();
+
         // Empty container of elements
         this.container.childNodes.forEach(v => {
             if(v.nodeType === Node.ELEMENT_NODE || v.nodeType === Node.TEXT_NODE) v.remove();
@@ -87,7 +100,10 @@ export class WebPubFramePoolManager {
             });
 
             if(this.currentBaseURL !== undefined && pub.baseURL !== this.currentBaseURL) {
-                this.blobs.forEach(v => URL.revokeObjectURL(v));
+                this.blobs.forEach(v => {
+                    this.injector?.releaseBlobUrl?.(v);
+                    URL.revokeObjectURL(v);
+                });
                 this.blobs.clear();
             }
             this.currentBaseURL = pub.baseURL;
@@ -97,6 +113,7 @@ export class WebPubFramePoolManager {
                 if(this.pendingUpdates.has(href) && this.pendingUpdates.get(href)?.inPool === false) {
                     const url = this.blobs.get(href);
                     if(url) {
+                        this.injector?.releaseBlobUrl?.(url);
                         URL.revokeObjectURL(url);
                         this.blobs.delete(href);
                         this.pendingUpdates.delete(href);
@@ -117,7 +134,15 @@ export class WebPubFramePoolManager {
                 const itm = pub.readingOrder.findWithHref(href);
                 if(!itm) return;
                 if(!this.blobs.has(href)) {
-                    const blobBuilder = new WebPubBlobBuilder(pub, this.currentBaseURL || "", itm, this.currentCssProperties);
+                    const blobBuilder = new WebPubBlobBuilder(
+                        pub, 
+                        this.currentBaseURL || "",
+                        itm,
+                        {
+                            cssProperties: this.currentCssProperties,
+                            injector: this.injector
+                        }
+                    );
                     const blobURL = await blobBuilder.build();
                     this.blobs.set(href, blobURL);
                 }

package/src/webpub/WebPubNavigator.ts

@@ -14,10 +14,14 @@ import { IWebPubDefaults, WebPubDefaults } from "./preferences/WebPubDefaults";
 import { WebPubSettings } from "./preferences/WebPubSettings";
 import { IPreferencesEditor } from "../preferences/PreferencesEditor";
 import { WebPubPreferencesEditor } from "./preferences/WebPubPreferencesEditor";
+import { Injector } from "../injection/Injector";
+import { createReadiumWebPubRules } from "../injection/webpubInjectables";
+import { IInjectablesConfig } from "../injection/Injectable";
 
 export interface WebPubNavigatorConfiguration {
     preferences: IWebPubPreferences;
     defaults: IWebPubDefaults;
+    injectables?: IInjectablesConfig;
 }
 
 export interface WebPubNavigatorListeners {
@@ -57,6 +61,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
     private _settings: WebPubSettings;
     private _css: WebPubCSS;
     private _preferencesEditor: WebPubPreferencesEditor | null = null;
+    private readonly _injector: Injector | null = null;
     
     private webViewport: VisualNavigatorViewport = {
         readingOrder: [],
@@ -79,6 +84,15 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
             userProperties: new WebUserProperties({ zoom: this._settings.zoom })
         });
 
+        // Combine WebPub rules with user-provided injectables
+        const webpubRules = createReadiumWebPubRules();
+        const userConfig = configuration.injectables || { rules: [], allowedDomains: [] };
+        
+        this._injector = new Injector({
+            rules: [...webpubRules, ...userConfig.rules],
+            allowedDomains: userConfig.allowedDomains
+        });
+
         // Initialize current location
         if (initialPosition && typeof initialPosition.copyWithLocations === 'function') {
             this.currentLocation = initialPosition;
@@ -95,7 +109,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
     public async load() {
         await this.updateCSS(false);
         const cssProperties = this.compileCSSProperties(this._css);
-        this.framePool = new WebPubFramePoolManager(this.container, cssProperties);
+        this.framePool = new WebPubFramePoolManager(this.container, cssProperties, this._injector);
 
         await this.apply();
     }

package/types/src/epub/EpubNavigator.d.ts

@@ -10,10 +10,12 @@ import { IEpubPreferences, EpubPreferences } from "./preferences/EpubPreferences
 import { IEpubDefaults } from "./preferences/EpubDefaults";
 import { EpubSettings } from "./preferences";
 import { EpubPreferencesEditor } from "./preferences/EpubPreferencesEditor";
+import { IInjectablesConfig } from "../injection/Injectable";
 export type ManagerEventKey = "zoom";
 export interface EpubNavigatorConfiguration {
     preferences: IEpubPreferences;
     defaults: IEpubDefaults;
+    injectables?: IInjectablesConfig;
 }
 export interface EpubNavigatorListeners {
     frameLoaded: (wnd: Window) => void;
@@ -42,6 +44,7 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     private _settings;
     private _css;
     private _preferencesEditor;
+    private readonly _injector;
     private resizeObserver;
     private reflowViewport;
     constructor(container: HTMLElement, pub: Publication, listeners: EpubNavigatorListeners, positions?: Locator[], initialPosition?: Locator | undefined, configuration?: EpubNavigatorConfiguration);

package/types/src/epub/frame/FrameBlobBuilder.d.ts

@@ -1,17 +1,20 @@
 import { Link, Publication } from "@readium/shared";
+import { Injector } from "../../injection/Injector";
 export default class FrameBlobBuider {
     private readonly item;
     private readonly burl;
     private readonly pub;
     private readonly cssProperties?;
-    constructor(pub: Publication, baseURL: string, item: Link, cssProperties?: {
-        [key: string]: string;
+    private readonly injector;
+    constructor(pub: Publication, baseURL: string, item: Link, options: {
+        cssProperties?: {
+            [key: string]: string;
+        };
+        injector?: Injector | null;
     });
     build(fxl?: boolean): Promise<string>;
     private buildHtmlFrame;
     private buildImageFrame;
-    private hasExecutable;
-    private hasStyle;
     private setProperties;
     private finalizeDOM;
 }

package/types/src/epub/frame/FramePoolManager.d.ts

@@ -1,6 +1,7 @@
 import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
 import { FrameManager } from "./FrameManager";
+import { Injector } from "../../injection/Injector";
 export declare class FramePoolManager {
     private readonly container;
     private readonly positions;
@@ -11,9 +12,10 @@ export declare class FramePoolManager {
     private readonly inprogress;
     private pendingUpdates;
     private currentBaseURL;
+    private readonly injector;
     constructor(container: HTMLElement, positions: Locator[], cssProperties?: {
         [key: string]: string;
-    });
+    }, injector?: Injector | null);
     destroy(): Promise<void>;
     update(pub: Publication, locator: Locator, modules: ModuleName[], force?: boolean): Promise<void>;
     setCSSProperties(properties: {

package/types/src/epub/fxl/FXLFramePoolManager.d.ts

@@ -4,6 +4,7 @@ import { FrameCommsListener } from "../frame";
 import { FXLFrameManager } from "./FXLFrameManager";
 import { FXLPeripherals } from "./FXLPeripherals";
 import { VisualNavigatorViewport } from "../../Navigator";
+import { Injector } from "../../injection/Injector";
 export declare class FXLFramePoolManager {
     private readonly container;
     private readonly positions;
@@ -14,6 +15,7 @@ export declare class FXLFramePoolManager {
     private readonly delayedTimeout;
     private currentBaseURL;
     private previousFrames;
+    private readonly injector;
     private readonly bookElement;
     readonly spineElement: HTMLDivElement;
     private readonly pub;
@@ -28,7 +30,7 @@ export declare class FXLFramePoolManager {
     private containerHeightCached;
     private resizeTimeout;
     readonly peripherals: FXLPeripherals;
-    constructor(container: HTMLElement, positions: Locator[], pub: Publication);
+    constructor(container: HTMLElement, positions: Locator[], pub: Publication, injector?: Injector | null);
     private _listener;
     set listener(listener: FrameCommsListener);
     get listener(): FrameCommsListener;

package/types/src/helpers/minify.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utilities for processing CSS and JavaScript content
+ */
+/**
+ * Minifies JavaScript by removing comments and normalizing whitespace
+ */
+export declare const stripJS: (source: string) => string;
+/**
+ * Minifies CSS by removing comments and normalizing whitespace
+ * Note: URL resolution should be handled by the caller with correct context
+ */
+export declare const stripCSS: (source: string) => string;

package/types/src/index.d.ts

@@ -5,3 +5,4 @@ export * from './audio';
 export * from './helpers';
 export * from './preferences';
 export * from './css';
+export * from './injection';

package/types/src/injection/Injectable.d.ts

@@ -0,0 +1,68 @@
+import { Link } from "@readium/shared";
+type ForbiddenAttributes = "type" | "rel" | "href" | "src";
+type AllowedAttributes = {
+    [K in string]: K extends ForbiddenAttributes ? never : (string | boolean | undefined);
+} & {
+    [K in ForbiddenAttributes]?: never;
+};
+export interface IBaseInjectable {
+    id?: string;
+    target?: "head" | "body";
+    type?: string;
+    condition?: (doc: Document) => boolean;
+    attributes?: AllowedAttributes;
+}
+export interface IScriptInjectable extends IBaseInjectable {
+    as: "script";
+    rel?: never;
+}
+export interface ILinkInjectable extends IBaseInjectable {
+    as: "link";
+    rel: string;
+}
+export interface IUrlInjectable {
+    url: string;
+}
+export interface IBlobInjectable {
+    blob: Blob;
+}
+export type IInjectable = (IScriptInjectable | ILinkInjectable) & (IUrlInjectable | IBlobInjectable);
+/**
+ * Defines a rule for resource injection, specifying which resources to inject into which documents.
+ */
+export interface IInjectableRule {
+    /**
+     * List of resource URLs or patterns that this rule applies to.
+     * Can be exact URLs or patterns with wildcards.
+     */
+    resources: Array<string | RegExp>;
+    /**
+     * Resources to inject at the beginning of the target (in array order)
+     */
+    prepend?: IInjectable[];
+    /**
+     * Resources to inject at the end of the target (in array order)
+     */
+    append?: IInjectable[];
+}
+export interface IInjectablesConfig {
+    rules: IInjectableRule[];
+    allowedDomains?: string[];
+}
+export interface IInjector {
+    /**
+     * Injects resources into a document based on matching rules
+     * @param doc The document to inject resources into
+     * @param link The link being loaded, used to match against injection rules
+     */
+    injectForDocument(doc: Document, link: Link): Promise<void>;
+    /**
+     * Cleans up any resources used by the injector
+     */
+    dispose(): void;
+    /**
+     * Get the list of allowed domains
+     */
+    getAllowedDomains(): string[];
+}
+export {};

package/types/src/injection/Injector.d.ts

@@ -0,0 +1,22 @@
+import { IInjector, IInjectablesConfig } from "./Injectable";
+import { Link } from "@readium/shared";
+export declare class Injector implements IInjector {
+    private readonly blobStore;
+    private readonly createdBlobUrls;
+    private readonly rules;
+    private readonly allowedDomains;
+    private injectableIdCounter;
+    constructor(config: IInjectablesConfig);
+    dispose(): void;
+    getAllowedDomains(): string[];
+    injectForDocument(doc: Document, link: Link): Promise<void>;
+    private matchesRule;
+    private getOrCreateBlobUrl;
+    releaseBlobUrl(url: string): Promise<void>;
+    private getResourceUrl;
+    private createPreloadLink;
+    private createElement;
+    private applyRule;
+    private processInjectable;
+    private isValidUrl;
+}

package/types/src/injection/epubInjectables.d.ts

@@ -0,0 +1,6 @@
+import { IInjectableRule } from "../injection/Injectable";
+import { Metadata } from "@readium/shared";
+/**
+ * Creates injectable rules for EPUB content documents
+ */
+export declare function createReadiumEpubRules(metadata: Metadata): IInjectableRule[];

package/types/src/injection/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Injectable";
+export * from "./Injector";

package/types/src/injection/webpubInjectables.d.ts

@@ -0,0 +1,5 @@
+import { IInjectableRule } from "../injection/Injectable";
+/**
+ * Creates injectable rules for WebPub content documents
+ */
+export declare function createReadiumWebPubRules(): IInjectableRule[];

package/types/src/webpub/WebPubBlobBuilder.d.ts

@@ -1,15 +1,19 @@
 import { Link, Publication } from "@readium/shared";
+import { Injector } from "../injection/Injector";
 export declare class WebPubBlobBuilder {
     private readonly item;
     private readonly burl;
     private readonly pub;
     private readonly cssProperties?;
-    constructor(pub: Publication, baseURL: string, item: Link, cssProperties?: {
-        [key: string]: string;
+    private readonly injector;
+    constructor(pub: Publication, baseURL: string, item: Link, options: {
+        cssProperties?: {
+            [key: string]: string;
+        };
+        injector?: Injector | null;
     });
     build(): Promise<string>;
     private buildHtmlFrame;
-    private hasExecutable;
     private setProperties;
     private finalizeDOM;
     private serializeAsHTML;