@papyrus-sdk/engine-native 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,8 +1,270 @@
 // index.ts
-import { NativeModules, requireNativeComponent } from "react-native";
-import { BaseDocumentEngine } from "@papyrus-sdk/core";
+import { View } from "react-native";
+
+// ../../node_modules/expo-modules-core/src/ensureNativeModulesAreInstalled.ts
+import { NativeModules, Platform } from "react-native";
+
+// ../../node_modules/expo-modules-core/src/web/index.ts
+function registerWebGlobals() {
+}
+
+// ../../node_modules/expo-modules-core/src/ensureNativeModulesAreInstalled.ts
+function ensureNativeModulesAreInstalled() {
+  if (globalThis.expo) {
+    return;
+  }
+  try {
+    if (Platform.OS === "web") {
+      registerWebGlobals();
+    } else {
+      NativeModules.ExpoModulesCore?.installModules();
+    }
+  } catch (error) {
+    console.error(`Unable to install Expo modules: ${error}`);
+  }
+}
+
+// ../../node_modules/expo-modules-core/src/NativeModulesProxy.ts
+var NativeModulesProxy_default = {};
+
+// ../../node_modules/expo-modules-core/src/errors/CodedError.ts
+var CodedError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+
+// ../../node_modules/expo-modules-core/src/Platform.ts
+import { Platform as ReactNativePlatform } from "react-native";
+
+// ../../node_modules/expo-modules-core/src/environment/browser.ts
+var isDOMAvailable = false;
+var canUseEventListeners = false;
+var canUseViewport = false;
+var isAsyncDebugging = false;
+if (__DEV__) {
+  isAsyncDebugging = !global.nativeExtensions && !global.nativeCallSyncHook && !global.RN$Bridgeless;
+}
+
+// ../../node_modules/expo-modules-core/src/Platform.ts
+if (__DEV__ && typeof process.env.EXPO_OS === "undefined") {
+  console.warn(
+    `The global process.env.EXPO_OS is not defined. This should be inlined by babel-preset-expo during transformation.`
+  );
+}
+var nativeSelect = typeof window !== "undefined" ? ReactNativePlatform.select : (
+  // process.env.EXPO_OS is injected by `babel-preset-expo` and available in both client and `react-server` environments.
+  // Opt to use the env var when possible, and fallback to the React Native Platform module when it's not (arbitrary bundlers and transformers).
+  function select(specifics) {
+    if (!process.env.EXPO_OS) return void 0;
+    if (specifics.hasOwnProperty(process.env.EXPO_OS)) {
+      return specifics[process.env.EXPO_OS];
+    } else if (process.env.EXPO_OS !== "web" && specifics.hasOwnProperty("native")) {
+      return specifics.native;
+    } else if (specifics.hasOwnProperty("default")) {
+      return specifics.default;
+    }
+    return void 0;
+  }
+);
+var Platform2 = {
+  /**
+   * Denotes the currently running platform.
+   * Can be one of ios, android, web.
+   */
+  OS: process.env.EXPO_OS || ReactNativePlatform.OS,
+  /**
+   * Returns the value with the matching platform.
+   * Object keys can be any of ios, android, native, web, default.
+   *
+   * @ios ios, native, default
+   * @android android, native, default
+   * @web web, default
+   */
+  select: nativeSelect,
+  /**
+   * Denotes if the DOM API is available in the current environment.
+   * The DOM is not available in native React runtimes and Node.js.
+   */
+  isDOMAvailable,
+  /**
+   * Denotes if the current environment can attach event listeners
+   * to the window. This will return false in native React
+   * runtimes and Node.js.
+   */
+  canUseEventListeners,
+  /**
+   * Denotes if the current environment can inspect properties of the
+   * screen on which the current window is being rendered. This will
+   * return false in native React runtimes and Node.js.
+   */
+  canUseViewport,
+  /**
+   * If the JavaScript is being executed in a remote JavaScript environment.
+   * When `true`, synchronous native invocations cannot be executed.
+   */
+  isAsyncDebugging
+};
+var Platform_default = Platform2;
+
+// ../../node_modules/expo-modules-core/src/errors/UnavailabilityError.ts
+var UnavailabilityError = class extends CodedError {
+  constructor(moduleName, propertyName) {
+    super(
+      "ERR_UNAVAILABLE",
+      `The method or property ${moduleName}.${propertyName} is not available on ${Platform_default.OS}, are you sure you've linked all the native dependencies properly?`
+    );
+  }
+};
+
+// ../../node_modules/expo-modules-core/src/NativeViewManagerAdapter.tsx
+function requireNativeViewManager(viewName) {
+  throw new UnavailabilityError("expo-modules-core", "requireNativeViewManager");
+}
+
+// ../../node_modules/expo-modules-core/src/sweet/NativeErrorManager.ts
+var NativeErrorManager_default = NativeModulesProxy_default.ExpoModulesCoreErrorManager;
+
+// ../../node_modules/expo-modules-core/src/sweet/setUpErrorManager.fx.ts
+if (__DEV__ && Platform_default.OS === "android" && NativeErrorManager_default) {
+  const onNewException = "ExpoModulesCoreErrorManager.onNewException";
+  const onNewWarning = "ExpoModulesCoreErrorManager.onNewWarning";
+  NativeErrorManager_default.addListener(onNewException, ({ message }) => {
+    console.error(message);
+  });
+  NativeErrorManager_default.addListener(onNewWarning, ({ message }) => {
+    console.warn(message);
+  });
+}
+globalThis.ExpoModulesCore_CodedError = CodedError;
+
+// ../../node_modules/expo-modules-core/src/requireNativeModule.ts
+function requireOptionalNativeModule(moduleName) {
+  ensureNativeModulesAreInstalled();
+  return globalThis.expo?.modules?.[moduleName] ?? NativeModulesProxy_default[moduleName] ?? null;
+}
+
+// index.ts
+import { BaseDocumentEngine, papyrusEvents } from "@papyrus-sdk/core";
+import {
+  PapyrusEventType
+} from "@papyrus-sdk/types";
 var MODULE_NAME = "PapyrusNativeEngine";
-var PapyrusPageView = requireNativeComponent("PapyrusPageView");
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_LOOKUP = (() => {
+  const table = new Uint8Array(256);
+  table.fill(255);
+  for (let i = 0; i < BASE64_CHARS.length; i += 1) {
+    table[BASE64_CHARS.charCodeAt(i)] = i;
+  }
+  return table;
+})();
+var parseDataUri = (value) => {
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/.exec(value);
+  if (!match) return null;
+  return {
+    mime: match[1] ?? "",
+    isBase64: Boolean(match[2]),
+    data: match[3] ?? ""
+  };
+};
+var looksLikeUri = (value) => value.startsWith("http://") || value.startsWith("https://") || value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("file://");
+var isLikelyBase64 = (value) => {
+  if (looksLikeUri(value)) return false;
+  if (value.includes(".")) return false;
+  if (value.length < 16) return false;
+  return /^[A-Za-z0-9+/=]+$/.test(value);
+};
+var isHttpUri = (value) => value.startsWith("http://") || value.startsWith("https://");
+var decodeBase64 = (value) => {
+  const clean = value.replace(/[^A-Za-z0-9+/=]/g, "");
+  const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
+  const outputLength = Math.max(0, clean.length * 3 / 4 - padding);
+  const output = new Uint8Array(outputLength);
+  let buffer = 0;
+  let bits = 0;
+  let index = 0;
+  for (let i = 0; i < clean.length; i += 1) {
+    const charCode = clean.charCodeAt(i);
+    if (charCode === 61) break;
+    const valueIndex = BASE64_LOOKUP[charCode];
+    if (valueIndex === 255) continue;
+    buffer = buffer << 6 | valueIndex;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      output[index++] = buffer >> bits & 255;
+    }
+  }
+  return output;
+};
+var encodeBase64 = (bytes) => {
+  let output = "";
+  let buffer = 0;
+  let bits = 0;
+  for (let i = 0; i < bytes.length; i += 1) {
+    buffer = buffer << 8 | bytes[i];
+    bits += 8;
+    while (bits >= 6) {
+      bits -= 6;
+      output += BASE64_CHARS[buffer >> bits & 63];
+    }
+  }
+  if (bits > 0) {
+    output += BASE64_CHARS[buffer << 6 - bits & 63];
+  }
+  const remainder = bytes.length % 3;
+  if (remainder === 1) return `${output}==`;
+  if (remainder === 2) return `${output}=`;
+  return output;
+};
+var isLoadRequest = (input) => typeof input === "object" && input !== null && "source" in input && "type" in input;
+var normalizeLoadInput = (input) => isLoadRequest(input) ? { source: input.source, type: input.type } : { source: input };
+var inferDocumentType = (source) => {
+  if (typeof source === "string") {
+    const dataUri = parseDataUri(source);
+    if (dataUri?.mime) {
+      const mime = dataUri.mime.toLowerCase();
+      if (mime.includes("epub")) return "epub";
+      if (mime.includes("text")) return "text";
+      if (mime.includes("pdf")) return "pdf";
+    }
+    const clean = source.split("?")[0].split("#")[0];
+    const ext = clean.includes(".") ? clean.split(".").pop()?.toLowerCase() : void 0;
+    if (ext === "epub") return "epub";
+    if (ext === "txt") return "text";
+    if (ext === "pdf") return "pdf";
+    return "pdf";
+  }
+  if (typeof source === "object" && source !== null && "uri" in source) {
+    const uri = source.uri;
+    const clean = uri.split("?")[0].split("#")[0];
+    const ext = clean.includes(".") ? clean.split(".").pop()?.toLowerCase() : void 0;
+    if (ext === "epub") return "epub";
+    if (ext === "txt") return "text";
+    if (ext === "pdf") return "pdf";
+  }
+  return "pdf";
+};
+var normalizeNativeDestination = (dest) => {
+  if (!dest) return null;
+  if (typeof dest === "string") {
+    return { kind: "named", value: dest };
+  }
+  if (dest.kind === "pageIndex" || dest.kind === "pageNumber" || dest.kind === "named") {
+    return { kind: dest.kind, value: dest.value };
+  }
+  return null;
+};
+var resolvePapyrusPageView = () => {
+  try {
+    return requireNativeViewManager("PapyrusPageView");
+  } catch {
+    return View;
+  }
+};
+var PapyrusPageView = resolvePapyrusPageView();
 var NativeDocumentEngine = class extends BaseDocumentEngine {
   constructor() {
     super();
@@ -12,10 +274,14 @@ var NativeDocumentEngine = class extends BaseDocumentEngine {
     this.currentPage = 1;
     this.zoom = 1;
     this.rotation = 0;
-    this.nativeModule = NativeModules[MODULE_NAME] ?? null;
+    this.nativeModule = requireOptionalNativeModule(MODULE_NAME);
     this.engineId = this.nativeModule?.createEngine ? this.nativeModule.createEngine() : "default";
   }
-  async load(source) {
+  async load(input) {
+    const { source, type } = normalizeLoadInput(input);
+    if (type && type !== "pdf") {
+      throw new Error(`[NativeDocumentEngine] Tipo de documento n\xE3o suportado: ${type}`);
+    }
     const native = this.assertNativeModule();
     const normalized = await this.normalizeSource(source);
     const result = native.load ? await native.load(this.engineId, normalized) : void 0;
@@ -96,26 +362,50 @@ var NativeDocumentEngine = class extends BaseDocumentEngine {
     return native.searchText(this.engineId, query);
   }
   async getPageIndex(dest) {
+    if (!dest) return null;
+    if (typeof dest !== "string") {
+      if (dest.kind === "pageIndex") return dest.value;
+      if (dest.kind === "pageNumber") return Math.max(0, dest.value - 1);
+    }
     const native = this.assertNativeModule();
     if (!native.getPageIndex) return null;
-    return native.getPageIndex(this.engineId, dest);
+    const normalized = normalizeNativeDestination(dest);
+    if (!normalized || normalized.kind !== "named") return null;
+    return native.getPageIndex(this.engineId, normalized);
   }
   destroy() {
     this.nativeModule?.destroyEngine?.(this.engineId);
   }
   assertNativeModule() {
     if (!this.nativeModule) {
-      throw new Error(`[Papyrus] Native module "${MODULE_NAME}" not found. Did you run pod install / gradle sync?`);
+      throw new Error(
+        `[Papyrus] Native module "${MODULE_NAME}" not found. Use a dev client or a native build (Expo Go is not supported).`
+      );
     }
     return this.nativeModule;
   }
   async normalizeSource(source) {
-    if (typeof source === "string") return { uri: source };
+    if (typeof source === "string") {
+      const dataUri = parseDataUri(source);
+      if (dataUri?.isBase64) {
+        return { data: decodeBase64(dataUri.data) };
+      }
+      if (looksLikeUri(source)) return { uri: source };
+      if (isLikelyBase64(source)) return { data: decodeBase64(source) };
+      return { uri: source };
+    }
     if (this.isUriSource(source)) return { uri: source.uri };
-    if (this.isDataSource(source)) return { data: source.data };
-    if (this.isFileLike(source)) return { data: await source.arrayBuffer() };
-    if (source instanceof ArrayBuffer || source instanceof Uint8Array) return { data: source };
-    return { data: source };
+    if (this.isDataSource(source)) {
+      const data = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+      return { data };
+    }
+    if (this.isFileLike(source)) {
+      const buffer = await source.arrayBuffer();
+      return { data: new Uint8Array(buffer) };
+    }
+    if (source instanceof ArrayBuffer) return { data: new Uint8Array(source) };
+    if (source instanceof Uint8Array) return { data: source };
+    return { data: new Uint8Array(source) };
   }
   isUriSource(source) {
     return typeof source === "object" && source !== null && "uri" in source;
@@ -132,8 +422,389 @@ var NativeDocumentEngine = class extends BaseDocumentEngine {
     return null;
   }
 };
+var WebViewDocumentEngine = class extends BaseDocumentEngine {
+  constructor() {
+    super(...arguments);
+    this.bridge = null;
+    this.ready = false;
+    this.requestId = 0;
+    this.pending = /* @__PURE__ */ new Map();
+    this.bridgeResolvers = [];
+    this.readyResolvers = [];
+    this.pageCount = 0;
+    this.currentPage = 1;
+    this.zoom = 1;
+    this.rotation = 0;
+    this.outline = [];
+  }
+  getRenderTargetType() {
+    return "webview";
+  }
+  attachBridge(bridge) {
+    this.bridge = bridge;
+    this.bridgeResolvers.forEach((resolve) => resolve(bridge));
+    this.bridgeResolvers = [];
+  }
+  handleMessage(raw) {
+    let message = null;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!message) return;
+    if (message.type === "ready") {
+      this.ready = true;
+      this.readyResolvers.forEach((resolve) => resolve());
+      this.readyResolvers = [];
+      return;
+    }
+    if (message.type === "response") {
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      if (message.ok) {
+        pending.resolve(message.data);
+      } else {
+        pending.reject(new Error(message.error ?? "[Papyrus] WebView runtime error"));
+      }
+      return;
+    }
+    if (message.type === "state") {
+      if (typeof message.payload.pageCount === "number") this.pageCount = message.payload.pageCount;
+      if (typeof message.payload.currentPage === "number") this.currentPage = message.payload.currentPage;
+      if (typeof message.payload.zoom === "number") this.zoom = message.payload.zoom;
+      if (Array.isArray(message.payload.outline)) this.outline = message.payload.outline;
+      return;
+    }
+    if (message.type === "event") {
+      const payload = message.payload ?? {};
+      if (message.name === "RUNTIME_LOG") {
+        if (__DEV__) {
+          const text = typeof payload?.message === "string" ? payload.message : JSON.stringify(payload);
+          console.log("[Papyrus WebView runtime]", text);
+        }
+        return;
+      }
+      if (message.name === "RUNTIME_ERROR") {
+        const errorMessage = typeof payload?.message === "string" ? payload.message : "";
+        if (errorMessage.includes("ResizeObserver loop")) {
+          return;
+        }
+        if (__DEV__) {
+          console.warn("[Papyrus WebView runtime]", payload);
+        }
+        return;
+      }
+      if (message.name === PapyrusEventType.TEXT_SELECTED) {
+        papyrusEvents.emit(PapyrusEventType.TEXT_SELECTED, payload);
+      } else if (message.name === PapyrusEventType.SEARCH_TRIGGERED) {
+        papyrusEvents.emit(PapyrusEventType.SEARCH_TRIGGERED, payload);
+      } else if (message.name === PapyrusEventType.DOCUMENT_LOADED) {
+        if (typeof payload.pageCount === "number") {
+          this.pageCount = payload.pageCount;
+        }
+        papyrusEvents.emit(PapyrusEventType.DOCUMENT_LOADED, payload);
+      }
+      return;
+    }
+    if (__DEV__) {
+      console.warn("[Papyrus WebView] Unknown message", message);
+    }
+  }
+  async load(input) {
+    const { source, type } = normalizeLoadInput(input);
+    const resolvedType = type ?? inferDocumentType(source);
+    if (resolvedType === "pdf") {
+      throw new Error("[WebViewDocumentEngine] Use o NativeDocumentEngine para PDFs no mobile.");
+    }
+    const payloadSource = await this.normalizeRuntimeSource(resolvedType, source);
+    const response = await this.request("load", {
+      type: resolvedType,
+      source: payloadSource
+    });
+    if (typeof response?.pageCount === "number") this.pageCount = response.pageCount;
+    if (Array.isArray(response?.outline)) this.outline = response.outline;
+    this.currentPage = 1;
+  }
+  getPageCount() {
+    return this.pageCount;
+  }
+  getCurrentPage() {
+    return this.currentPage;
+  }
+  goToPage(page) {
+    if (page < 1) return;
+    this.currentPage = page;
+    void this.request("go-to-page", { page });
+  }
+  setZoom(zoom) {
+    this.zoom = Math.max(0.5, Math.min(4, zoom));
+    void this.request("set-zoom", { zoom: this.zoom });
+  }
+  getZoom() {
+    return this.zoom;
+  }
+  rotate(direction) {
+    if (direction === "clockwise") {
+      this.rotation = (this.rotation + 90) % 360;
+    } else {
+      this.rotation = (this.rotation - 90) % 360;
+      if (this.rotation < 0) this.rotation += 360;
+    }
+    void this.request("set-rotation", { rotation: this.rotation });
+  }
+  getRotation() {
+    return this.rotation;
+  }
+  async renderPage(pageIndex, target, scale) {
+    void pageIndex;
+    void target;
+    void scale;
+  }
+  async renderTextLayer(pageIndex, container, scale) {
+    void pageIndex;
+    void container;
+    void scale;
+  }
+  async getTextContent(pageIndex) {
+    return await this.request("get-text-content", { pageIndex });
+  }
+  async getPageDimensions(pageIndex) {
+    return await this.request("get-page-dimensions", { pageIndex });
+  }
+  async searchText(query) {
+    return await this.request("search-text", { query });
+  }
+  async selectText(pageIndex, rect) {
+    return await this.request("select-text", { pageIndex, rect });
+  }
+  async getOutline() {
+    if (this.outline.length > 0) return this.outline;
+    return await this.request("get-outline");
+  }
+  async getPageIndex(dest) {
+    if (!dest) return null;
+    if (typeof dest !== "string") {
+      if (dest.kind === "pageIndex") return dest.value;
+      if (dest.kind === "pageNumber") return Math.max(0, dest.value - 1);
+      if (dest.kind === "href") {
+        return await this.request("get-page-index", { dest: dest.value });
+      }
+      return null;
+    }
+    return await this.request("get-page-index", { dest });
+  }
+  destroy() {
+    this.pending.forEach(({ reject }) => reject(new Error("[Papyrus] WebView engine destroyed")));
+    this.pending.clear();
+    this.bridge = null;
+    this.ready = false;
+  }
+  async ensureBridge() {
+    if (this.bridge) return this.bridge;
+    return new Promise((resolve) => {
+      this.bridgeResolvers.push(resolve);
+    });
+  }
+  async ensureReady() {
+    if (this.ready) return;
+    return new Promise((resolve) => {
+      this.readyResolvers.push(resolve);
+    });
+  }
+  async request(kind, payload) {
+    const bridge = await this.ensureBridge();
+    await this.ensureReady();
+    const id = `${Date.now()}-${this.requestId++}`;
+    return new Promise((resolve, reject) => {
+      const timeoutMs = kind === "load" ? 3e4 : 8e3;
+      const timeoutId = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`[Papyrus] WebView response timeout: ${kind}`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (data) => {
+          clearTimeout(timeoutId);
+          resolve(data);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      });
+      bridge.postMessage(JSON.stringify({ id, kind, payload }));
+    });
+  }
+  async normalizeRuntimeSource(type, source) {
+    if (typeof source === "string") {
+      const dataUri = parseDataUri(source);
+      if (dataUri) {
+        if (dataUri.isBase64) {
+          return { kind: "base64", data: dataUri.data, mime: dataUri.mime || void 0 };
+        }
+        const text = decodeURIComponent(dataUri.data);
+        return { kind: "text", text };
+      }
+      if (looksLikeUri(source)) {
+        if (isHttpUri(source)) {
+          const fetched = await this.fetchRemoteSource(type, source);
+          if (fetched) return fetched;
+        }
+        return { kind: "uri", uri: source };
+      }
+      if (isLikelyBase64(source)) {
+        return { kind: "base64", data: source };
+      }
+      if (type === "text") {
+        return { kind: "text", text: source };
+      }
+      return { kind: "uri", uri: source };
+    }
+    if (this.isUriSource(source)) {
+      const uri = source.uri;
+      if (isHttpUri(uri)) {
+        const fetched = await this.fetchRemoteSource(type, uri);
+        if (fetched) return fetched;
+      }
+      return { kind: "uri", uri };
+    }
+    if (this.isDataSource(source)) {
+      const bytes = source.data instanceof Uint8Array ? source.data : new Uint8Array(source.data);
+      return { kind: "base64", data: encodeBase64(bytes) };
+    }
+    if (this.isFileLike(source)) {
+      const buffer = await source.arrayBuffer();
+      return { kind: "base64", data: encodeBase64(new Uint8Array(buffer)) };
+    }
+    if (source instanceof ArrayBuffer || source instanceof Uint8Array) {
+      const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
+      return { kind: "base64", data: encodeBase64(bytes) };
+    }
+    return { kind: "base64", data: encodeBase64(new Uint8Array(source)) };
+  }
+  async fetchRemoteSource(type, uri) {
+    try {
+      const response = await fetch(uri);
+      if (!response.ok) return null;
+      if (type === "text") {
+        const text = await response.text();
+        return { kind: "text", text };
+      }
+      if (type === "epub") {
+        const buffer = await this.readResponseBuffer(response);
+        return { kind: "base64", data: encodeBase64(new Uint8Array(buffer)) };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async readResponseBuffer(response) {
+    try {
+      return await response.arrayBuffer();
+    } catch {
+      const blob = await response.blob();
+      return await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => reject(new Error("[Papyrus] Failed to read response blob"));
+        reader.onload = () => resolve(reader.result);
+        reader.readAsArrayBuffer(blob);
+      });
+    }
+  }
+  isUriSource(source) {
+    return typeof source === "object" && source !== null && "uri" in source;
+  }
+  isDataSource(source) {
+    return typeof source === "object" && source !== null && "data" in source;
+  }
+  isFileLike(source) {
+    return typeof source === "object" && source !== null && typeof source.arrayBuffer === "function";
+  }
+};
+var MobileDocumentEngine = class extends BaseDocumentEngine {
+  constructor() {
+    super();
+    this.pdfEngine = new NativeDocumentEngine();
+    this.webEngine = new WebViewDocumentEngine();
+    this.activeEngine = this.pdfEngine;
+  }
+  getRenderTargetType() {
+    return this.activeEngine.getRenderTargetType?.() ?? "canvas";
+  }
+  attachWebView(bridge) {
+    this.webEngine.attachBridge(bridge);
+  }
+  handleWebViewMessage(data) {
+    this.webEngine.handleMessage(data);
+  }
+  async load(input) {
+    const { source, type } = normalizeLoadInput(input);
+    const resolvedType = type ?? inferDocumentType(source);
+    this.activeEngine = resolvedType === "pdf" ? this.pdfEngine : this.webEngine;
+    await this.activeEngine.load({ type: resolvedType, source });
+  }
+  getPageCount() {
+    return this.activeEngine.getPageCount();
+  }
+  getCurrentPage() {
+    return this.activeEngine.getCurrentPage();
+  }
+  goToPage(page) {
+    this.activeEngine.goToPage(page);
+  }
+  setZoom(zoom) {
+    this.activeEngine.setZoom(zoom);
+  }
+  getZoom() {
+    return this.activeEngine.getZoom();
+  }
+  rotate(direction) {
+    this.activeEngine.rotate(direction);
+  }
+  getRotation() {
+    return this.activeEngine.getRotation();
+  }
+  async renderPage(pageIndex, target, scale) {
+    await this.activeEngine.renderPage(pageIndex, target, scale);
+  }
+  async renderTextLayer(pageIndex, container, scale) {
+    await this.activeEngine.renderTextLayer(pageIndex, container, scale);
+  }
+  async getTextContent(pageIndex) {
+    return await this.activeEngine.getTextContent(pageIndex);
+  }
+  async getPageDimensions(pageIndex) {
+    return await this.activeEngine.getPageDimensions(pageIndex);
+  }
+  async searchText(query) {
+    if (typeof this.activeEngine.searchText === "function") {
+      return await this.activeEngine.searchText(query);
+    }
+    return [];
+  }
+  async selectText(pageIndex, rect) {
+    if (typeof this.activeEngine.selectText === "function") {
+      return await this.activeEngine.selectText(pageIndex, rect);
+    }
+    return null;
+  }
+  async getOutline() {
+    return await this.activeEngine.getOutline();
+  }
+  async getPageIndex(dest) {
+    return await this.activeEngine.getPageIndex(dest);
+  }
+  destroy() {
+    this.pdfEngine.destroy();
+    this.webEngine.destroy();
+  }
+};
 export {
+  MobileDocumentEngine,
   NativeDocumentEngine,
-  PapyrusPageView
+  PapyrusPageView,
+  WebViewDocumentEngine
 };
 //# sourceMappingURL=index.mjs.map