flipbookengine 0.6.5 → 1.0.2

package/docs/getting-started.md

@@ -0,0 +1,128 @@
+# Getting Started
+
+Welcome to **FlipbookEngine**! This guide will help you set up and embed FlipbookEngine into your web applications.
+
+## Quick Installation
+
+You can install FlipbookEngine via npm:
+
+```bash
+npm install flipbookengine
+```
+
+Or reference it directly via CDN (such as unpkg) in your HTML:
+
+```html
+<link rel="stylesheet" href="https://unpkg.com/flipbookengine/dist/flipbook-engine.css" />
+<script src="https://unpkg.com/flipbookengine/dist/flipbook-engine.iife.js"></script>
+```
+
+## Setup Container
+
+Create an element in your HTML that will contain the flipbook viewer. Ensure the container has explicit dimensions:
+
+```html
+<div id="viewer" style="width: 100%; height: 600px;"></div>
+```
+
+## Initialize the Engine
+
+Import `FlipbookEngine` (if using ESM) and instantiate it:
+
+```javascript
+import { FlipbookEngine } from 'flipbookengine';
+import 'flipbookengine/dist/flipbook-engine.css';
+
+const engine = new FlipbookEngine('#viewer', {
+  allowDownload: true,
+  showThumbs: false,
+  primaryColor: '#7367f0'
+});
+
+// Load the PDF catalog file along with its rendered images
+await engine.init('/files/catalog.pdf', [
+  { kind: 'cover', pageNumber: 1, normal: '/img/1.jpg', low: '/img/1-low.jpg', thumb: '/img/1-thumb.jpg' },
+  { kind: 'spread', pageNumbers: [2, 3], normal: '/img/2-3.jpg', low: '/img/2-3-low.jpg', thumb: '/img/2-3-thumb.jpg' }
+]);
+```
+
+## Mixed Page Spreads
+
+FlipbookEngine supports loading single pages, spreads (double-pages), and covers mixed together. The engine will automatically normalize spreads (cutting them into left and right halves on portrait viewports) for responsive mobile viewing.
+
+
+## Iframe embedding
+
+For a viewer hosted in an iframe, connect the bridge from the iframe document and allow only the parent origin:
+
+```javascript
+const engine = new FlipbookEngine('#viewer', { showThumbs: false });
+engine.connectEmbed({
+  allowedOrigins: ['https://catalog.example.com']
+});
+await engine.init('/files/catalog.pdf');
+```
+
+From the parent page, use the controller exported by the package:
+
+```javascript
+import { createFlipbookEmbedController } from 'flipbookengine';
+
+const controller = createFlipbookEmbedController(
+  document.querySelector('#catalog-frame'),
+  { targetOrigin: 'https://viewer.example.com' }
+);
+await controller.goToPage(2);
+```
+
+Always configure explicit origins for cross-origin embeds. The bridge supports page navigation, zoom, single mode, option updates, fullscreen, TOC read/update, search, state queries, and event forwarding.
+
+
+## Deep links and sharing
+
+Enable opt-in URL synchronization with the `deepLink` option. The viewer reads an initial `?page=` value, updates it when the page changes, and responds to browser back/forward navigation. Page numbers in URLs are 1-based; engine API indexes remain 0-based.
+
+```ts
+const engine = new FlipbookEngine('#viewer', { deepLink: true });
+await engine.init('/files/catalog.pdf');
+
+const pageUrl = engine.getPageUrl(4);
+await engine.sharePage(4);
+// The viewer toolbar also exposes a localized Share button.
+// Bookmark state is host-managed and can be persisted from bookmarkChange.
+engine.on('bookmarkChange', ({ pageNumber, bookmarked }) => {
+  console.log(`Page ${pageNumber} bookmarked: ${bookmarked}`);
+});
+engine.on('noteChange', ({ pageNumber, note }) => {
+  console.log(`Page ${pageNumber} note changed`, note);
+});
+engine.on('deepLinkChange', ({ pageNumber, url }) => {
+  console.log(`Sharing page ${pageNumber}: ${url}`);
+});
+```
+
+
+## Client-side PDF search
+
+When initialized with a PDF URL, `search(query)` extracts text through PDF.js without rendering every page. It returns page-level matches and snippets, updates the search toolbar panel, and overlays precise normalized rectangles over matching text when PDF.js exposes text geometry. Search results use a zero-based `pageIndex` for API navigation and a one-based `pageNumber` for display.
+
+```ts
+const results = await engine.search('catalog', { caseSensitive: false, maxResults: 50 });
+engine.goToPage(results[0]?.pageIndex ?? 0);
+engine.clearSearch();
+```
+
+Search is unavailable for image-only page lists because those assets do not contain extractable PDF text or text geometry. For image mode, applications that need search/highlights should generate page text and normalized coordinates on the server and pass the resulting page metadata as a host-side feature; the open-source viewer does not OCR raster images. The iframe controller exposes the same operation with `search`, `clearSearch`, and `getSearchResults`.
+
+## Interactive hotspots
+
+Hosts can provide normalized (0..1) page coordinates for lightweight links and pop-ups:
+
+```ts
+const engine = new FlipbookEngine('#viewer', {
+  hotspots: [{ id: 'product-42', pageIndex: 3, x: 0.60, y: 0.25, width: 0.25, height: 0.18, label: 'Product details', content: 'Open the product details page.', href: '/products/42' }]
+});
+engine.on('hotspotActivate', ({ hotspot }) => console.log(hotspot.id));
+```
+
+Hotspots support `kind: 'info' | 'media' | 'gallery' | 'commerce'`. A hotspot can render a single image/video/audio preview through `media`, a selectable image gallery through `gallery`, and a safe external/product destination through `href`. Content remains plain text; applications should sanitize server-provided URLs before passing them to the viewer. Use `activateHotspot(id)` and `closeHotspot()` for programmatic control.

package/docs/i18n.md

@@ -0,0 +1,47 @@
+# Internationalization (i18n)
+
+FlipbookEngine features built-in support for multiple locales and customization of all user-facing copy.
+
+## Supported Locales
+
+- **`en`** (English - default)
+- **`tr`** (Turkish)
+
+## Set Active Locale
+
+Change the language on initialization or dynamically at runtime:
+
+```javascript
+// Initialization
+const engine = new FlipbookEngine('#viewer', {
+  locale: 'tr'
+});
+
+// Runtime change
+engine.setLocale('en');
+```
+
+## Overriding Messages
+
+Provide translation strings to override specific labels or define messages for a new locale:
+
+```javascript
+const engine = new FlipbookEngine('#viewer', {
+  locale: 'de',
+  messages: {
+    de: {
+      emptyStateTitle: 'Keine Seiten gefunden.',
+      thumbnails: 'Miniaturansichten',
+      singlePageMode: 'Einzelseiten-Modus',
+      pages: 'Seiten',
+      previous: 'Zurück',
+      next: 'Weiter',
+      zoomOut: 'Herauszoomen',
+      zoomIn: 'Herinzoomen',
+      fullscreen: 'Vollbild',
+      settings: 'Einstellungen',
+      downloadCatalog: 'PDF Herunterladen'
+    }
+  }
+});
+```

package/docs/migration-0.4.0.md

@@ -0,0 +1,24 @@
+# Migration Guide for 0.4.0
+
+## Scope
+
+FlipbookEngine 0.4.0 is the stabilization release described by the audit plan. It keeps the core public navigation methods while making lifecycle, state, wrapper, event, and viewer behavior deterministic across multiple instances.
+
+## Required consumer checks
+
+- Keep `pdfjs-dist` installed as the production dependency and provide `pdfWorkerSrc` from the host bundler or CDN. PDF.js is intentionally external to the FlipbookEngine bundle.
+- If host CSS or automation selected fixed viewer IDs, migrate to the instance-scoped classes such as `.bk-book-wrapper`, `.bk-book-sizer`, `.bk-book`, and `.bk-single-view` within the engine container.
+- Treat `pages` as optional when `pdfUrl` is provided. Framework wrappers may update `pdfUrl` and `pages` independently without triggering duplicate initialization.
+- Image-only viewers do not render a download button because no PDF URL is available.
+
+## Runtime behavior changes
+
+- Each `FlipbookEngine` instance owns its reactive state; internal singleton store imports must not be used by integrations.
+- A newer `init()` or `destroy()` cancels stale PDF loading, rendering, timers, and listeners.
+- `progress` and `error` events are available for PDF loading/rendering telemetry and failure handling.
+- High-quality page assets are promoted when pages become visible. PDF rendering uses bounded concurrency controlled by `pdfRenderConcurrency` (default `3`).
+- Toolbar and thumbnail controls expose accessible names, state, and keyboard interaction.
+
+## Verification
+
+Before shipping an integration, run `npm run typecheck`, `npm test`, and `npm run build` against the locked 0.4.0 dependency tree.

package/docs/migration-0.5.0.md

@@ -0,0 +1,25 @@
+# Migration Guide for 0.5.0
+
+## Scope
+
+FlipbookEngine 0.5.0 makes PDF-backed viewers responsive for large documents. Page markup is created from PDF metadata, while rendered page images are requested only for the current/nearby pages or when a page becomes visible.
+
+## Runtime behavior changes
+
+- `init()` resolves after the first PDF page has rendered. The next page is prefetched in the background.
+- PDF render requests are deduplicated and cancelled when a newer initialization starts or the engine is destroyed.
+- `pdfRenderConcurrency` continues to bound PDF.js work (default `3`).
+- `pdfRenderCacheSize` controls a per-instance least-recently-used cache (default `32`). Set it to `0` to disable retention of rendered page images.
+- `progress` reports loading and rendering phases; `error` reports `PDF_LOAD_FAILED` and `PDF_RENDER_FAILED` failures.
+- Browser, React, and Vue wrappers share the same lifecycle-safe on-demand behavior.
+- Keyboard controls and visible focus states remain available, and `prefers-reduced-motion: reduce` disables page-turn animation and shortens CSS transitions.
+
+## Consumer checks
+
+- Keep `pdfjs-dist` installed as the production dependency and provide `pdfWorkerSrc` from the host bundler or CDN.
+- If an application assumed that every PDF page image existed immediately after `init()`, listen for `progress` events or select the page before reading its image element.
+- Choose a cache size based on available memory and page dimensions. A value of `0` is appropriate for strictly bounded memory usage.
+
+## Verification
+
+Run `npm run typecheck`, `npm test`, `npm run build`, and `npm run test:e2e` (after installing Playwright browsers) before shipping an integration.

package/docs/migration-1.0.0.md

@@ -0,0 +1,59 @@
+# 1.0.0 migration guide
+
+FlipbookEngine 1.0.0 is the first stable open-source release. The 0.x line was
+alpha/beta and does not provide a compatibility guarantee. Test the viewer and
+wrapper integrations against the new package before deploying.
+
+## Plugin entry points
+
+The all-in-one import remains available:
+
+```ts
+import { FlipbookEngine } from 'flipbookengine';
+```
+
+Optional feature adapters can be loaded independently:
+
+```ts
+import { FlipbookEngine } from 'flipbookengine/core';
+import { notesPlugin } from 'flipbookengine/plugins/notes';
+
+const engine = new FlipbookEngine('#viewer', { plugins: [notesPlugin] });
+```
+
+Available adapters are documented in [plugin architecture](./plugin-architecture.md).
+The official OSS package does not include analytics, OCR, PDF outline extraction,
+protected downloads, or backend rendering.
+
+## TOC and iframe API
+
+TOC is supplied as a host-provided `FlipbookTocEntry[]` manifest. Use
+`engine.getToc()` and `engine.setToc(entries, show?)` for runtime updates. Iframe
+controllers additionally expose `getToc()` and `setToc()` through the validated
+postMessage bridge.
+
+## Wrapper validation
+
+React and Vue wrappers continue to accept the engine options object, including
+`plugins`. Validate wrapper lifecycle, CSS import, PDF worker configuration, and
+host-managed note/bookmark persistence during migration.
+
+## 0.8.0 to 1.0.0 differences
+
+The 1.0.0 release is the first compatibility boundary. The 0.x line was alpha/beta, so applications must validate the complete integration instead of assuming semver compatibility.
+
+| Area | 0.8.0 | 1.0.0 | Migration impact |
+| --- | --- | --- | --- |
+| Package surface | All-in-one public entry | All-in-one plus core, plugins, and feature subpaths | Imports from documented public paths are supported; imports from internal src/dist files are breaking and must be replaced. |
+| Optional features | Built-in reader surface only | Plugin contract with install/uninstall, typed events, toolbar/panel/API contributions | If an application wants an adapter API, register the adapter explicitly; omitted adapters are inactive. |
+| TOC | Host-provided TOC panel | Nested TOC plus getToc/setToc and iframe commands | Existing TOC data remains host-provided; update integrations that need runtime or embed control. |
+| Hotspots | Basic text/link overlays | info/media/gallery/commerce, image/video/audio previews, galleries, product links | Existing overlays remain valid; new media/gallery fields are additive. |
+| Image mode search | Disabled for raster page lists | Still disabled; PDF mode only | No change; raster search requires host/server text metadata. |
+| Commercial capabilities | Not part of OSS | Still not part of OSS | Backend rendering, OCR/indexing, protected downloads, persistence, identity, and analytics remain commercial/backend work. |
+
+### Breaking-change requirements
+
+- Do not depend on undocumented internal modules, generated chunk filenames, or 0.x implementation details.
+- Re-run wrapper and iframe smoke tests after upgrading; React and Vue wrappers must be rebuilt against the 1.0.0 declarations.
+- Treat plugin registration as explicit state. Calling uninstallPlugin removes APIs, UI contributions, event listeners, and cleanup callbacks; it does not merely hide a button.
+- Existing all-in-one initialization with documented options is retained, but the 0.x line has no compatibility guarantee and must not be used as a rollback contract.

package/docs/plugin-architecture.md

@@ -0,0 +1,103 @@
+# Plugin architecture
+
+FlipbookEngine v1 exposes a small plugin contract so optional reader features can
+be distributed independently from the rendering core. Plugins are installed
+before the first render through `plugins` or `engine.installPlugin(plugin)`.
+
+```ts
+import { FlipbookEngine } from 'flipbookengine/core';
+import type { FlipbookPlugin } from 'flipbookengine/plugins';
+
+const tocPlugin: FlipbookPlugin = {
+  name: 'toc',
+  install(engine, context) {
+    context.registerToolbarButton({
+      id: 'toc',
+      label: 'Contents',
+      icon: '☰',
+      onClick: () => context.openPanel('contents')
+    });
+
+    context.registerPanel({
+      id: 'contents',
+      title: 'Table of contents',
+      render: (container) => {
+        container.textContent = `Page ${engine.getCurrentPage() + 1}`;
+      }
+    });
+
+    context.registerApi('getCurrentSection', () => engine.getCurrentPage());
+    return () => context.closePanel('contents');
+  }
+};
+
+const engine = new FlipbookEngine('#viewer', { plugins: [tocPlugin] });
+```
+
+The context provides:
+
+- `registerToolbarButton()` for a framework-agnostic toolbar action.
+- `registerPanel()` for a panel mounted inside the viewer shell.
+- `registerApi()` and `engine.callPluginApi()` for namespaced plugin methods.
+- `on()` for typed engine event subscriptions with automatic cleanup.
+- `openPanel()` / `closePanel()` for panel state.
+
+Plugin names and contribution identifiers must be unique within an engine.
+Calling `engine.destroy()` removes all plugin registrations and runs cleanup
+callbacks. A plugin installed after initialization is available on the next
+viewer render; install initial plugins in the constructor options when their UI
+must be present on the first render.
+
+For example, a host that only needs note persistence can load the notes adapter
+without importing the other feature adapters:
+
+```ts
+import { FlipbookEngine } from 'flipbookengine/core';
+import { notesPlugin } from 'flipbookengine/plugins/notes';
+
+const engine = new FlipbookEngine('#viewer', { plugins: [notesPlugin] });
+await engine.callPluginApi('notes', 'set', 0, 'Review this page');
+```
+
+Official lightweight adapters are available as independent entry points:
+
+- `flipbookengine/plugins/notes`
+- `flipbookengine/plugins/bookmarks`
+- `flipbookengine/plugins/toc`
+- `flipbookengine/plugins/search`
+- `flipbookengine/plugins/annotations`
+- `flipbookengine/plugins/hotspots`
+- `flipbookengine/plugins/share`
+- `flipbookengine/plugins/deep-link`
+
+Each adapter registers namespaced APIs over the existing host-managed engine
+methods. The all-in-one entry remains unchanged, so applications can migrate
+incrementally without loading an adapter they do not use.
+
+The public `flipbookengine` entry remains the all-in-one build. `flipbookengine/core`
+contains the core engine exports, `flipbookengine/plugins` contains the plugin
+contract, and the feature subpaths above contain the optional adapters. Analytics is intentionally not an official
+open-source plugin; applications may consume events directly or use a private
+commercial adapter.
+
+
+## Activating and deactivating plugins
+
+Pass adapters in the constructor to activate them before the first render:
+
+```ts
+import { FlipbookEngine } from 'flipbookengine/core';
+import { hotspotsPlugin } from 'flipbookengine/plugins/hotspots';
+
+const engine = new FlipbookEngine('#viewer', { plugins: [hotspotsPlugin] });
+```
+
+A plugin can also be enabled or disabled after initialization. installPlugin returns the engine instance; uninstallPlugin returns true when a plugin was removed and clears all registered contributions.
+
+```ts
+engine.uninstallPlugin('hotspots');
+engine.installPlugin(hotspotsPlugin);
+await engine.callPluginApi('hotspots', 'activate', 'product-42');
+```
+
+Feature adapters are API-only contributions. The built-in all-in-one viewer continues to render its existing toolbar and panels from the corresponding options; custom plugins can add their own UI contributions with registerToolbarButton and registerPanel.

package/docs/release-checklist.md

@@ -0,0 +1,37 @@
+# Release Checklist
+
+Use this checklist for every phase commit and every published release.
+
+## Before committing a phase
+
+- [ ] Confirm the change scope and choose the correct SemVer impact (patch, minor, or major).
+- [ ] Keep each coherent phase in a separate commit with an action-oriented message.
+- [ ] Add or update tests for every new feature, API, bug fix, and changed behavior.
+- [ ] Run the relevant focused tests and record results in the local `development-notes/` report.
+- [ ] Confirm no local audit reports, build output, credentials, or environment files are staged.
+- [ ] Review `git diff --check` and the staged diff.
+
+## Before a release
+
+- [ ] Update the version in `package.json` and `package-lock.json`.
+- [ ] Update every published version reference in README files, CHANGELOG, API documentation, migration guides, examples, and license/source headers.
+- [ ] Add a CHANGELOG entry describing features, fixes, API changes, and test coverage.
+- [ ] Document every new or changed API in the API reference and README examples.
+- [ ] Mark all breaking changes explicitly, explain the impact, and provide migration guidance.
+- [ ] Verify wrapper exports, generated declarations, package entry points, and framework integrations.
+- [ ] Run `npm run typecheck`, `npm test`, `npm run build`, and `npm run pack:check`.
+- [ ] Confirm `npm pkg get version` matches the intended release.
+- [ ] Inspect the `npm pack --dry-run` file list and package size.
+- [ ] Confirm both local repositories have clean working trees and the intended commits are on the correct branches.
+- [ ] Create and push the matching Git tag (for example, `v1.0.0`).
+- [ ] Create or update the GitHub Release from that tag and verify the Latest designation.
+- [ ] Push commits and tags before handing off the manual npm publish step.
+- [ ] Publish to npm manually with maintainer credentials; verify the registry version afterward.
+- [ ] Record all commands, results, release URLs, and follow-up items in local `development-notes/`.
+
+## After publishing
+
+- [ ] Verify the npm package page, tarball version, README, and package contents.
+- [ ] Verify GitHub tag/release and the default branch point to the same release commit.
+- [ ] Check that no deprecated or unreleased version is shown as Latest.
+- [ ] Note any known warnings (for example, network/DNS or jsdom media warnings) separately from failures.

package/docs/theming.md

@@ -0,0 +1,61 @@
+# Theming & Customization
+
+FlipbookEngine provides deep customization support through compiled CSS custom properties (variables) and dark-mode compatibility.
+
+## CSS Custom Properties
+
+The styling system is driven by standard CSS variables. You can override these variables globally in your stylesheet or per-instance:
+
+```css
+:root {
+  --mainbgcolor: #f3f6fb;          /* Main canvas background */
+  --surfacebgcolor: #ffffff;       /* Overlay elements background */
+  --panelbgcolor: #172033;         /* Settings panel background */
+  --flipbook-accent: #7367f0;          /* Buttons and accent color */
+  --thumbrailbgcolor: #0f172a;     /* Thumbnails container background */
+  --bordercolor: #e2e8f0;          /* Border and separations color */
+  --textcolor: #1e293b;            /* General text color */
+}
+```
+
+## Dark Mode
+
+FlipbookEngine is compatible with Bootstrap 5 setups and automatically responds to light/dark themes in the hosting environment.
+
+- It queries `data-bs-theme="dark"` on the body/parent element to toggle styling.
+- You can force dark theme on initialization:
+  ```javascript
+  const engine = new FlipbookEngine('#viewer', {
+    theme: 'dark'
+  });
+  ```
+
+## Instance Overrides
+
+To style a single instance differently from the rest of your app, pass the `cssVariables` object to options:
+
+```javascript
+const engine = new FlipbookEngine('#viewer', {
+  cssVariables: {
+    mainbgcolor: '#0f172a',
+    flipbook-accent: '#10b981'
+  }
+});
+```
+
+
+## Optional Light/Dark Viewer Backgrounds
+
+A host can provide separate, optional backgrounds for the viewer surface. The default is null, so the built-in theme surfaces remain unchanged. Backgrounds are applied outside the PDF pages and automatically follow the selected light, dark, or auto theme.
+
+```ts
+const engine = new FlipbookEngine('#viewer', {
+  theme: 'auto',
+  background: {
+    light: { color: '#f8fafc', image: '/branding/catalog-light.webp', size: 'cover', position: 'center', repeat: 'no-repeat' },
+    dark: { color: '#0f172a', image: '/branding/catalog-dark.webp', size: 'cover' }
+  }
+});
+```
+
+The viewer reserves a bottom attribution area and uses equal responsive page gutters so the watermark does not overlap PDF content. Thumbnail rail scrolling is horizontal-only; thumbnail dimensions are reduced responsively to avoid vertical overflow.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flipbookengine",
-  "version": "0.6.5",
+  "version": "1.0.2",
   "description": "A modern, embeddable HTML flipbook engine for PDF-backed catalogs and digital publications.",
   "private": false,
   "scripts": {
@@ -43,6 +43,7 @@
   ],
   "files": [
     "dist",
+    "docs",
     "react",
     "vue",
     "README.md",
@@ -73,6 +74,56 @@
       "types": "./dist/vue/index.d.ts",
       "import": "./dist/flipbook-engine.vue.js",
       "default": "./dist/flipbook-engine.vue.js"
+    },
+    "./core": {
+      "types": "./dist/core-entry.d.ts",
+      "import": "./dist/flipbook-engine.core.js",
+      "default": "./dist/flipbook-engine.core.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/flipbook-engine.plugins.js",
+      "default": "./dist/flipbook-engine.plugins.js"
+    },
+    "./plugins/notes": {
+      "types": "./dist/plugins-notes.d.ts",
+      "import": "./dist/flipbook-engine.plugins-notes.js",
+      "default": "./dist/flipbook-engine.plugins-notes.js"
+    },
+    "./plugins/bookmarks": {
+      "types": "./dist/plugins-bookmarks.d.ts",
+      "import": "./dist/flipbook-engine.plugins-bookmarks.js",
+      "default": "./dist/flipbook-engine.plugins-bookmarks.js"
+    },
+    "./plugins/toc": {
+      "types": "./dist/plugins-toc.d.ts",
+      "import": "./dist/flipbook-engine.plugins-toc.js",
+      "default": "./dist/flipbook-engine.plugins-toc.js"
+    },
+    "./plugins/search": {
+      "types": "./dist/plugins-search.d.ts",
+      "import": "./dist/flipbook-engine.plugins-search.js",
+      "default": "./dist/flipbook-engine.plugins-search.js"
+    },
+    "./plugins/annotations": {
+      "types": "./dist/plugins-annotations.d.ts",
+      "import": "./dist/flipbook-engine.plugins-annotations.js",
+      "default": "./dist/flipbook-engine.plugins-annotations.js"
+    },
+    "./plugins/hotspots": {
+      "types": "./dist/plugins-hotspots.d.ts",
+      "import": "./dist/flipbook-engine.plugins-hotspots.js",
+      "default": "./dist/flipbook-engine.plugins-hotspots.js"
+    },
+    "./plugins/share": {
+      "types": "./dist/plugins-share.d.ts",
+      "import": "./dist/flipbook-engine.plugins-share.js",
+      "default": "./dist/flipbook-engine.plugins-share.js"
+    },
+    "./plugins/deep-link": {
+      "types": "./dist/plugins-deep-link.d.ts",
+      "import": "./dist/flipbook-engine.plugins-deep-link.js",
+      "default": "./dist/flipbook-engine.plugins-deep-link.js"
     }
   },
   "peerDependencies": {