@embedpdf/engines 1.0.0

package/dist/worker.cjs

@@ -0,0 +1,1122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/webworker-engine.ts
+var webworker_engine_exports = {};
+__export(webworker_engine_exports, {
+  EngineRunner: () => EngineRunner,
+  WebWorkerEngine: () => WebWorkerEngine,
+  WorkerTask: () => WorkerTask
+});
+module.exports = __toCommonJS(webworker_engine_exports);
+
+// src/webworker/engine.ts
+var import_models = require("@embedpdf/models");
+var LOG_SOURCE = "WebWorkerEngine";
+var LOG_CATEGORY = "Engine";
+var WorkerTask = class extends import_models.Task {
+  /**
+   * Create a task that bind to web worker with specified message id
+   * @param worker - web worker instance
+   * @param messageId - id of message
+   *
+   * @public
+   */
+  constructor(worker, messageId) {
+    super();
+    this.worker = worker;
+    this.messageId = messageId;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!Task.abort}
+   *
+   * @override
+   */
+  abort(e) {
+    super.abort(e);
+    this.worker.postMessage({
+      type: "AbortRequest",
+      data: {
+        messageId: this.messageId
+      }
+    });
+  }
+};
+var _WebWorkerEngine = class _WebWorkerEngine {
+  /**
+   * Create an instance of WebWorkerEngine, it will create a worker with
+   * specified url.
+   * @param worker - webworker instance, this worker needs to contains the running instance of {@link EngineRunner}
+   * @param logger - logger instance
+   *
+   * @public
+   */
+  constructor(worker, logger = new import_models.NoopLogger()) {
+    this.worker = worker;
+    this.logger = logger;
+    /**
+     * All the tasks that is executing
+     */
+    this.tasks = /* @__PURE__ */ new Map();
+    /**
+     * Handle event from web worker. There are 2 kinds of event
+     * 1. ReadyResponse: web worker is ready
+     * 2. ExecuteResponse: result of execution
+     * @param evt - message event from web worker
+     * @returns
+     *
+     * @private
+     */
+    this.handle = (evt) => {
+      this.logger.debug(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        "webworker engine start handling message: ",
+        evt.data
+      );
+      try {
+        const response = evt.data;
+        const task = this.tasks.get(response.id);
+        if (!task) {
+          return;
+        }
+        switch (response.type) {
+          case "ReadyResponse":
+            this.readyTask.resolve(true);
+            break;
+          case "ExecuteResponse":
+            {
+              switch (response.data.type) {
+                case "result":
+                  task.resolve(response.data.value);
+                  break;
+                case "error":
+                  task.reject(response.data.value.reason);
+                  break;
+              }
+              this.tasks.delete(response.id);
+            }
+            break;
+        }
+      } catch (e) {
+        this.logger.error(LOG_SOURCE, LOG_CATEGORY, "webworker met error when handling message: ", e);
+      }
+    };
+    this.worker.addEventListener("message", this.handle);
+    this.readyTask = new WorkerTask(this.worker, _WebWorkerEngine.readyTaskId);
+    this.tasks.set(_WebWorkerEngine.readyTaskId, this.readyTask);
+  }
+  /**
+   * Generate a unique message id
+   * @returns message id
+   *
+   * @private
+   */
+  generateRequestId(id) {
+    return `${id}.${Date.now()}.${Math.random()}`;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.initialize}
+   *
+   * @public
+   */
+  initialize() {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "initialize");
+    const requestId = this.generateRequestId("General");
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "initialize",
+        args: []
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.destroy}
+   *
+   * @public
+   */
+  destroy() {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "destroy");
+    const requestId = this.generateRequestId("General");
+    const task = new WorkerTask(this.worker, requestId);
+    task.wait(
+      () => {
+        this.worker.removeEventListener("message", this.handle);
+      },
+      () => {
+        this.worker.removeEventListener("message", this.handle);
+      }
+    );
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "destroy",
+        args: []
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.openDocumentUrl}
+   *
+   * @public
+   */
+  openDocumentUrl(file, options) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "openDocumentUrl", file.url, options);
+    const requestId = this.generateRequestId(file.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "openDocumentUrl",
+        args: [file, options]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.openDocument}
+   *
+   * @public
+   */
+  openDocumentFromBuffer(file, password) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "openDocumentFromBuffer", file, password);
+    const requestId = this.generateRequestId(file.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "openDocumentFromBuffer",
+        args: [file, password]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.openDocumentFromLoader}
+   *
+   * @public
+   */
+  openDocumentFromLoader(file, password) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "openDocumentFromLoader", file, password);
+    const requestId = this.generateRequestId(file.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "openDocumentFromLoader",
+        args: [file, password]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getMetadata}
+   *
+   * @public
+   */
+  getMetadata(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getMetadata", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getMetadata",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getDocPermissions}
+   *
+   * @public
+   */
+  getDocPermissions(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getDocPermissions", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getDocPermissions",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getDocUserPermissions}
+   *
+   * @public
+   */
+  getDocUserPermissions(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getDocUserPermissions", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getDocUserPermissions",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getBookmarks}
+   *
+   * @public
+   */
+  getBookmarks(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getBookmarks", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getBookmarks",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getSignatures}
+   *
+   * @public
+   */
+  getSignatures(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getSignatures", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getSignatures",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.renderPage}
+   *
+   * @public
+   */
+  renderPage(doc, page, scaleFactor, rotation, dpr, options) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "renderPage",
+      doc,
+      page,
+      scaleFactor,
+      rotation,
+      dpr,
+      options
+    );
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "renderPage",
+        args: [doc, page, scaleFactor, rotation, dpr, options]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.renderPageRect}
+   *
+   * @public
+   */
+  renderPageRect(doc, page, scaleFactor, rotation, dpr, rect, options) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "renderPageRect",
+      doc,
+      page,
+      scaleFactor,
+      rotation,
+      dpr,
+      rect,
+      options
+    );
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "renderPageRect",
+        args: [doc, page, scaleFactor, rotation, dpr, rect, options]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getAllAnnotations}
+   *
+   * @public
+   */
+  getAllAnnotations(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getAllAnnotations", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getAllAnnotations",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getPageAnnotations}
+   *
+   * @public
+   */
+  getPageAnnotations(doc, page) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getPageAnnotations", doc, page);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getPageAnnotations",
+        args: [doc, page]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.createPageAnnotation}
+   *
+   * @public
+   */
+  createPageAnnotation(doc, page, annotation) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "createPageAnnotations", doc, page, annotation);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "createPageAnnotation",
+        args: [doc, page, annotation]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.transformPageAnnotation}
+   *
+   * @public
+   */
+  transformPageAnnotation(doc, page, annotation, transformation) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "transformPageAnnotation",
+      doc,
+      page,
+      annotation,
+      transformation
+    );
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "transformPageAnnotation",
+        args: [doc, page, annotation, transformation]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.removePageAnnotation}
+   *
+   * @public
+   */
+  removePageAnnotation(doc, page, annotation) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "removePageAnnotations", doc, page, annotation);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "removePageAnnotation",
+        args: [doc, page, annotation]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getPageTextRects}
+   *
+   * @public
+   */
+  getPageTextRects(doc, page, scaleFactor, rotation) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "getPageTextRects",
+      doc,
+      page,
+      scaleFactor,
+      rotation
+    );
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getPageTextRects",
+        args: [doc, page, scaleFactor, rotation]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.renderThumbnail}
+   *
+   * @public
+   */
+  renderThumbnail(doc, page, scaleFactor, rotation, dpr) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "renderThumbnail",
+      doc,
+      page,
+      scaleFactor,
+      rotation,
+      dpr
+    );
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "renderThumbnail",
+        args: [doc, page, scaleFactor, rotation, dpr]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.searchAllPages}
+   *
+   * @public
+   */
+  searchAllPages(doc, keyword, flags = []) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "searchAllPages 123", doc, keyword, flags);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "searchAllPages",
+        args: [doc, keyword, flags]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.saveAsCopy}
+   *
+   * @public
+   */
+  saveAsCopy(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "saveAsCopy", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "saveAsCopy",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getAttachments}
+   *
+   * @public
+   */
+  getAttachments(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getAttachments", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getAttachments",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.readAttachmentContent}
+   *
+   * @public
+   */
+  readAttachmentContent(doc, attachment) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "readAttachmentContent", doc, attachment);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "readAttachmentContent",
+        args: [doc, attachment]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.setFormFieldValue}
+   *
+   * @public
+   */
+  setFormFieldValue(doc, page, annotation, value) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "setFormFieldValue", doc, annotation, value);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "setFormFieldValue",
+        args: [doc, page, annotation, value]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.flattenPage}
+   *
+   * @public
+   */
+  flattenPage(doc, page, flag) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "flattenPage", doc, page, flag);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "flattenPage",
+        args: [doc, page, flag]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.extractPages}
+   *
+   * @public
+   */
+  extractPages(doc, pageIndexes) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "extractPages", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "extractPages",
+        args: [doc, pageIndexes]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.extractText}
+   *
+   * @public
+   */
+  extractText(doc, pageIndexes) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "extractText", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "extractText",
+        args: [doc, pageIndexes]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getPageGlyphs}
+   *
+   * @public
+   */
+  getPageGlyphs(doc, page) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getPageGlyphs", doc, page);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getPageGlyphs",
+        args: [doc, page]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.getPageGeometry}
+   *
+   * @public
+   */
+  getPageGeometry(doc, page) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getPageGeometry", doc, page);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "getPageGeometry",
+        args: [doc, page]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.merge}
+   *
+   * @public
+   */
+  merge(files) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "merge", files);
+    const fileIds = files.map((file) => file.id).join(".");
+    const requestId = this.generateRequestId(fileIds);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "merge",
+        args: [files]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.mergePages}
+   *
+   * @public
+   */
+  mergePages(mergeConfigs) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "mergePages", mergeConfigs);
+    const requestId = this.generateRequestId(mergeConfigs.map((config) => config.docId).join("."));
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "mergePages",
+        args: [mergeConfigs]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.closeDocument}
+   *
+   * @public
+   */
+  closeDocument(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "closeDocument", doc);
+    const requestId = this.generateRequestId(doc.id);
+    const task = new WorkerTask(this.worker, requestId);
+    const request = {
+      id: requestId,
+      type: "ExecuteRequest",
+      data: {
+        name: "closeDocument",
+        args: [doc]
+      }
+    };
+    this.proxy(task, request);
+    return task;
+  }
+  /**
+   * Send the request to webworker inside and register the task
+   * @param task - task that waiting for the response
+   * @param request - request that needs send to web worker
+   * @param transferables - transferables that need to transfer to webworker
+   * @returns
+   *
+   * @internal
+   */
+  proxy(task, request, transferables = []) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "send request to worker",
+      task,
+      request,
+      transferables
+    );
+    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `${request.data.name}`, "Begin", request.id);
+    this.readyTask.wait(
+      () => {
+        this.worker.postMessage(request, transferables);
+        task.wait(
+          () => {
+            this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `${request.data.name}`, "End", request.id);
+          },
+          () => {
+            this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `${request.data.name}`, "End", request.id);
+          }
+        );
+        this.tasks.set(request.id, task);
+      },
+      () => {
+        this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `${request.data.name}`, "End", request.id);
+        task.reject({
+          code: import_models.PdfErrorCode.Initialization,
+          message: "worker initialization failed"
+        });
+      }
+    );
+  }
+};
+_WebWorkerEngine.readyTaskId = "0";
+var WebWorkerEngine = _WebWorkerEngine;
+
+// src/webworker/runner.ts
+var import_models2 = require("@embedpdf/models");
+var LOG_SOURCE2 = "WebWorkerEngineRunner";
+var LOG_CATEGORY2 = "Engine";
+var EngineRunner = class {
+  /**
+   * Create instance of EngineRunnder
+   * @param logger - logger instance
+   */
+  constructor(logger = new import_models2.NoopLogger()) {
+    this.logger = logger;
+    /**
+     * Execute the request
+     * @param request - request that represent the pdf engine call
+     * @returns
+     *
+     * @protected
+     */
+    this.execute = (request) => {
+      this.logger.debug(LOG_SOURCE2, LOG_CATEGORY2, "runner start exeucte request");
+      if (!this.engine) {
+        const error = {
+          type: "reject",
+          reason: {
+            code: import_models2.PdfErrorCode.NotReady,
+            message: "engine has not started yet"
+          }
+        };
+        const response = {
+          id: request.id,
+          type: "ExecuteResponse",
+          data: {
+            type: "error",
+            value: error
+          }
+        };
+        this.respond(response);
+        return;
+      }
+      const engine = this.engine;
+      const { name, args } = request.data;
+      if (!engine[name]) {
+        const error = {
+          type: "reject",
+          reason: {
+            code: import_models2.PdfErrorCode.NotSupport,
+            message: "engine method has not supported yet"
+          }
+        };
+        const response = {
+          id: request.id,
+          type: "ExecuteResponse",
+          data: {
+            type: "error",
+            value: error
+          }
+        };
+        this.respond(response);
+        return;
+      }
+      let task;
+      switch (name) {
+        case "isSupport":
+          task = this.engine[name](...args);
+          break;
+        case "initialize":
+          task = this.engine[name](...args);
+          break;
+        case "destroy":
+          task = this.engine[name](...args);
+          break;
+        case "openDocumentUrl":
+          task = this.engine[name](...args);
+          break;
+        case "openDocumentFromBuffer":
+          task = this.engine[name](...args);
+          break;
+        case "openDocumentFromLoader":
+          task = this.engine[name](...args);
+          break;
+        case "getDocPermissions":
+          task = this.engine[name](...args);
+          break;
+        case "getDocUserPermissions":
+          task = this.engine[name](...args);
+          break;
+        case "getMetadata":
+          task = this.engine[name](...args);
+          break;
+        case "getBookmarks":
+          task = this.engine[name](...args);
+          break;
+        case "getSignatures":
+          task = this.engine[name](...args);
+          break;
+        case "renderPage":
+          task = this.engine[name](...args);
+          break;
+        case "renderPageRect":
+          task = this.engine[name](...args);
+          break;
+        case "renderThumbnail":
+          task = this.engine[name](...args);
+          break;
+        case "getAllAnnotations":
+          task = this.engine[name](...args);
+          break;
+        case "getPageAnnotations":
+          task = this.engine[name](...args);
+          break;
+        case "createPageAnnotation":
+          task = this.engine[name](...args);
+          break;
+        case "transformPageAnnotation":
+          task = this.engine[name](...args);
+          break;
+        case "removePageAnnotation":
+          task = this.engine[name](...args);
+          break;
+        case "getPageTextRects":
+          task = this.engine[name](...args);
+          break;
+        case "searchAllPages":
+          task = this.engine[name](...args);
+          break;
+        case "closeDocument":
+          task = this.engine[name](...args);
+          break;
+        case "saveAsCopy":
+          task = this.engine[name](...args);
+          break;
+        case "getAttachments":
+          task = this.engine[name](...args);
+          break;
+        case "readAttachmentContent":
+          task = this.engine[name](...args);
+          break;
+        case "setFormFieldValue":
+          task = this.engine[name](...args);
+          break;
+        case "flattenPage":
+          task = this.engine[name](...args);
+          break;
+        case "extractPages":
+          task = this.engine[name](...args);
+          break;
+        case "extractText":
+          task = this.engine[name](...args);
+          break;
+        case "getPageGlyphs":
+          task = this.engine[name](...args);
+          break;
+        case "getPageGeometry":
+          task = this.engine[name](...args);
+          break;
+        case "merge":
+          task = this.engine[name](...args);
+          break;
+        case "mergePages":
+          task = this.engine[name](...args);
+          break;
+      }
+      task.wait(
+        (result) => {
+          const response = {
+            id: request.id,
+            type: "ExecuteResponse",
+            data: {
+              type: "result",
+              value: result
+            }
+          };
+          this.respond(response);
+        },
+        (error) => {
+          const response = {
+            id: request.id,
+            type: "ExecuteResponse",
+            data: {
+              type: "error",
+              value: error
+            }
+          };
+          this.respond(response);
+        }
+      );
+    };
+  }
+  /**
+   * Listening on post message
+   */
+  listen() {
+    self.onmessage = (evt) => {
+      return this.handle(evt);
+    };
+  }
+  /**
+   * Handle post message
+   */
+  handle(evt) {
+    this.logger.debug(LOG_SOURCE2, LOG_CATEGORY2, "webworker receive message event: ", evt.data);
+    try {
+      const request = evt.data;
+      switch (request.type) {
+        case "ExecuteRequest":
+          this.execute(request);
+          break;
+      }
+    } catch (e) {
+      this.logger.info(
+        LOG_SOURCE2,
+        LOG_CATEGORY2,
+        "webworker met error when processing message event:",
+        e
+      );
+    }
+  }
+  /**
+   * Send the ready response when pdf engine is ready
+   * @returns
+   *
+   * @protected
+   */
+  ready() {
+    this.listen();
+    this.respond({
+      id: "0",
+      type: "ReadyResponse"
+    });
+    this.logger.debug(LOG_SOURCE2, LOG_CATEGORY2, "runner is ready");
+  }
+  /**
+   * Send back the response
+   * @param response - response that needs sent back
+   *
+   * @protected
+   */
+  respond(response) {
+    this.logger.debug(LOG_SOURCE2, LOG_CATEGORY2, "runner respond: ", response);
+    self.postMessage(response);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EngineRunner,
+  WebWorkerEngine,
+  WorkerTask
+});
+//# sourceMappingURL=worker.cjs.map