@atlaspack/core 2.14.0 → 2.14.1-canary.6

package/lib/Atlaspack.js

@@ -0,0 +1,677 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WORKER_PATH = exports.INTERNAL_TRANSFORM = exports.INTERNAL_RESOLVE = exports.BuildError = void 0;
+exports.createWorkerFarm = createWorkerFarm;
+exports.default = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _Asset = require("./public/Asset");
+var _Bundle = require("./public/Bundle");
+var _BundleGraph = _interopRequireDefault(require("./public/BundleGraph"));
+function _workers() {
+  const data = _interopRequireDefault(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _AtlaspackConfigRequest = require("./requests/AtlaspackConfigRequest");
+var _ReporterRunner = _interopRequireDefault(require("./ReporterRunner"));
+var _dumpGraphToGraphViz = _interopRequireDefault(require("./dumpGraphToGraphViz"));
+var _resolveOptions = _interopRequireDefault(require("./resolveOptions"));
+function _events() {
+  const data = require("@atlaspack/events");
+  _events = function () {
+    return data;
+  };
+  return data;
+}
+var _registerCoreWithSerializer = require("./registerCoreWithSerializer");
+function _utils2() {
+  const data = require("@atlaspack/utils");
+  _utils2 = function () {
+    return data;
+  };
+  return data;
+}
+var _AtlaspackConfig = require("./AtlaspackConfig");
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _RequestTracker = _interopRequireWildcard(require("./RequestTracker"));
+var _ValidationRequest = _interopRequireDefault(require("./requests/ValidationRequest"));
+var _AtlaspackBuildRequest = _interopRequireDefault(require("./requests/AtlaspackBuildRequest"));
+var _AssetRequest = _interopRequireDefault(require("./requests/AssetRequest"));
+var _PathRequest = _interopRequireDefault(require("./requests/PathRequest"));
+var _Environment = require("./Environment");
+var _Dependency = require("./Dependency");
+function _sourceMap() {
+  const data = require("@parcel/source-map");
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _cache() {
+  const data = require("@atlaspack/cache");
+  _cache = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _projectPath = require("./projectPath");
+function _profiler() {
+  const data = require("@atlaspack/profiler");
+  _profiler = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _atlaspackV = require("./atlaspack-v3");
+var _AssetGraphRequest = _interopRequireDefault(require("./requests/AssetGraphRequest"));
+var _AssetGraphRequestRust = require("./requests/AssetGraphRequestRust");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// eslint-disable-next-line no-unused-vars
+(0, _registerCoreWithSerializer.registerCoreWithSerializer)();
+const INTERNAL_TRANSFORM = exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
+const INTERNAL_RESOLVE = exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
+const WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+class Atlaspack {
+  #requestTracker /*: RequestTracker*/;
+  #config /*: AtlaspackConfig*/;
+  #farm /*: WorkerFarm*/;
+  #initialized /*: boolean*/ = false;
+  #disposable /*: Disposable */;
+  #initialOptions /*: InitialAtlaspackOptions */;
+  #reporterRunner /*: ReporterRunner*/;
+  #resolvedOptions /*: ?AtlaspackOptions*/ = null;
+  #optionsRef /*: SharedReference */;
+  #watchAbortController /*: AbortController*/;
+  #watchQueue /*: PromiseQueue<?BuildEvent>*/ = new (_utils2().PromiseQueue)({
+    maxConcurrent: 1
+  });
+  #watchEvents /*: ValueEmitter<
+               | {|
+               +error: Error,
+               +buildEvent?: void,
+               |}
+               | {|
+               +buildEvent: BuildEvent,
+               +error?: void,
+               |},
+               > */;
+  #watcherSubscription /*: ?AsyncSubscription*/;
+  #watcherCount /*: number*/ = 0;
+  #requestedAssetIds /*: Set<string>*/ = new Set();
+  constructor(options) {
+    this.#initialOptions = options;
+  }
+  async _init() {
+    if (this.#initialized) {
+      return;
+    }
+    const featureFlags = {
+      ..._featureFlags().DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags
+    };
+    (0, _featureFlags().setFeatureFlags)(featureFlags);
+    await _sourceMap().init;
+    await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
+    this.#disposable = new (_events().Disposable)();
+    try {
+      _rust().initializeMonitoring === null || _rust().initializeMonitoring === void 0 || (0, _rust().initializeMonitoring)();
+      const onExit = () => {
+        _rust().closeMonitoring === null || _rust().closeMonitoring === void 0 || (0, _rust().closeMonitoring)();
+      };
+      process.on('exit', onExit);
+      this.#disposable.add(() => {
+        process.off('exit', onExit);
+        onExit();
+      });
+    } catch (e) {
+      // Fallthrough
+      // eslint-disable-next-line no-console
+      console.warn(e);
+    }
+    let resolvedOptions = await (0, _resolveOptions.default)({
+      ...this.#initialOptions,
+      featureFlags
+    });
+    this.#resolvedOptions = resolvedOptions;
+    let rustAtlaspack;
+    if (resolvedOptions.featureFlags.atlaspackV3) {
+      // eslint-disable-next-line no-unused-vars
+      let {
+        entries,
+        inputFS,
+        outputFS,
+        ...options
+      } = this.#initialOptions;
+      if (!(resolvedOptions.cache instanceof _cache().LMDBLiteCache)) {
+        throw new Error('Atlaspack v3 must be run with lmdb lite cache');
+      }
+      const lmdb = resolvedOptions.cache.getNativeRef();
+
+      // $FlowFixMe
+      const version = require('../package.json').version;
+      await lmdb.put('current_session_version', Buffer.from(version));
+      rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
+        ...options,
+        corePath: _path().default.join(__dirname, '..'),
+        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
+        env: resolvedOptions.env,
+        fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
+        // $FlowFixMe ProjectPath is a string
+        defaultTargetOptions: resolvedOptions.defaultTargetOptions,
+        lmdb
+      });
+    }
+    this.rustAtlaspack = rustAtlaspack;
+    let {
+      config
+    } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);
+    this.#config = new _AtlaspackConfig.AtlaspackConfig(config, resolvedOptions);
+    if (this.#initialOptions.workerFarm) {
+      if (this.#initialOptions.workerFarm.ending) {
+        throw new Error('Supplied WorkerFarm is ending');
+      }
+      this.#farm = this.#initialOptions.workerFarm;
+    } else {
+      this.#farm = createWorkerFarm({
+        shouldPatchConsole: resolvedOptions.shouldPatchConsole,
+        shouldTrace: resolvedOptions.shouldTrace
+      });
+    }
+    await resolvedOptions.cache.ensure();
+    let {
+      dispose: disposeOptions,
+      ref: optionsRef
+    } = await this.#farm.createSharedReference(resolvedOptions, false);
+    this.#optionsRef = optionsRef;
+    if (this.#initialOptions.workerFarm) {
+      // If we don't own the farm, dispose of only these references when
+      // Atlaspack ends.
+      this.#disposable.add(disposeOptions);
+    } else {
+      // Otherwise, when shutting down, end the entire farm we created.
+      this.#disposable.add(() => this.#farm.end());
+    }
+    this.#watchEvents = new (_events().ValueEmitter)();
+    this.#disposable.add(() => this.#watchEvents.dispose());
+    this.#reporterRunner = new _ReporterRunner.default({
+      options: resolvedOptions,
+      reporters: await this.#config.getReporters(),
+      workerFarm: this.#farm
+    });
+    this.#disposable.add(this.#reporterRunner);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: 'Intializing request tracker...'
+    });
+    this.#requestTracker = await _RequestTracker.default.init({
+      farm: this.#farm,
+      options: resolvedOptions,
+      rustAtlaspack
+    });
+    this.#initialized = true;
+  }
+  async run() {
+    let startTime = Date.now();
+    if (!this.#initialized) {
+      await this._init();
+    }
+    let result = await this._build({
+      startTime
+    });
+    await this.#requestTracker.writeToCache();
+    await this._end();
+    if (result.type === 'buildFailure') {
+      throw new BuildError(result.diagnostics);
+    }
+    return result;
+  }
+  async _end() {
+    this.#initialized = false;
+    await this.#disposable.dispose();
+  }
+  async writeRequestTrackerToCache() {
+    if (this.#watchQueue.getNumWaiting() === 0) {
+      // If there's no queued events, we are safe to write the request graph to disk
+      const abortController = new AbortController();
+      const unsubscribe = this.#watchQueue.subscribeToAdd(() => {
+        abortController.abort();
+      });
+      try {
+        await this.#requestTracker.writeToCache(abortController.signal);
+      } catch (err) {
+        if (!abortController.signal.aborted) {
+          // We expect abort errors if we interrupt the cache write
+          throw err;
+        }
+      }
+      unsubscribe();
+    }
+  }
+  async _startNextBuild() {
+    this.#watchAbortController = new AbortController();
+    await this.clearBuildCaches();
+    try {
+      let buildEvent = await this._build({
+        signal: this.#watchAbortController.signal
+      });
+      this.#watchEvents.emit({
+        buildEvent
+      });
+      return buildEvent;
+    } catch (err) {
+      // Ignore BuildAbortErrors and only emit critical errors.
+      if (!(err instanceof _utils.BuildAbortError)) {
+        throw err;
+      }
+    } finally {
+      // If the build passes or fails, we want to cache the request graph
+      await this.writeRequestTrackerToCache();
+    }
+  }
+  async watch(cb) {
+    if (!this.#initialized) {
+      await this._init();
+    }
+    let watchEventsDisposable;
+    if (cb) {
+      watchEventsDisposable = this.#watchEvents.addListener(({
+        error,
+        buildEvent
+      }) => cb(error, buildEvent));
+    }
+    if (this.#watcherCount === 0) {
+      this.#watcherSubscription = await this._getWatcherSubscription();
+      await this.#reporterRunner.report({
+        type: 'watchStart'
+      });
+
+      // Kick off a first build, but don't await its results. Its results will
+      // be provided to the callback.
+      this.#watchQueue.add(() => this._startNextBuild());
+      this.#watchQueue.run();
+    }
+    this.#watcherCount++;
+    let unsubscribePromise;
+    const unsubscribe = async () => {
+      if (watchEventsDisposable) {
+        watchEventsDisposable.dispose();
+      }
+      this.#watcherCount--;
+      if (this.#watcherCount === 0) {
+        await (0, _nullthrows().default)(this.#watcherSubscription).unsubscribe();
+        this.#watcherSubscription = null;
+        await this.#reporterRunner.report({
+          type: 'watchEnd'
+        });
+        this.#watchAbortController.abort();
+        await this.#watchQueue.run();
+        await this._end();
+      }
+    };
+    return {
+      unsubscribe() {
+        if (unsubscribePromise == null) {
+          unsubscribePromise = unsubscribe();
+        }
+        return unsubscribePromise;
+      }
+    };
+  }
+  async _build({
+    signal,
+    startTime = Date.now()
+  } = {
+    /*::...null*/
+  }) {
+    this.#requestTracker.setSignal(signal);
+    let options = (0, _nullthrows().default)(this.#resolvedOptions);
+    try {
+      if (options.shouldProfile) {
+        await this.startProfiling();
+      }
+      if (options.shouldTrace) {
+        _profiler().tracer.enable();
+      }
+      await this.#reporterRunner.report({
+        type: 'buildStart'
+      });
+      this.#requestTracker.graph.invalidateOnBuildNodes();
+      let request = (0, _AtlaspackBuildRequest.default)({
+        optionsRef: this.#optionsRef,
+        requestedAssetIds: this.#requestedAssetIds,
+        signal
+      });
+      let {
+        bundleGraph,
+        bundleInfo,
+        changedAssets,
+        assetRequests
+      } = await this.#requestTracker.runRequest(request, {
+        force: true
+      });
+      this.#requestedAssetIds.clear();
+      await (0, _dumpGraphToGraphViz.default)(
+      // $FlowFixMe
+      this.#requestTracker.graph, 'RequestGraph', _RequestTracker.requestGraphEdgeTypes);
+      let event = {
+        type: 'buildSuccess',
+        changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)])),
+        bundleGraph: new _BundleGraph.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.PackagedBundle.getWithInfo(bundle, bundleGraph, options, bundleInfo.get(bundle.id)), options),
+        buildTime: Date.now() - startTime,
+        requestBundle: async bundle => {
+          let bundleNode = bundleGraph._graph.getNodeByContentKey(bundle.id);
+          (0, _assert().default)((bundleNode === null || bundleNode === void 0 ? void 0 : bundleNode.type) === 'bundle', 'Bundle does not exist');
+          if (!bundleNode.value.isPlaceholder) {
+            // Nothing to do.
+            return {
+              type: 'buildSuccess',
+              changedAssets: new Map(),
+              bundleGraph: event.bundleGraph,
+              buildTime: 0,
+              requestBundle: event.requestBundle,
+              unstable_requestStats: {}
+            };
+          }
+          for (let assetId of bundleNode.value.entryAssetIds) {
+            this.#requestedAssetIds.add(assetId);
+          }
+          if (this.#watchQueue.getNumWaiting() === 0) {
+            if (this.#watchAbortController) {
+              this.#watchAbortController.abort();
+            }
+            this.#watchQueue.add(() => this._startNextBuild());
+          }
+          let results = await this.#watchQueue.run();
+          let result = results.filter(Boolean).pop();
+          if (result.type === 'buildFailure') {
+            throw new BuildError(result.diagnostics);
+          }
+          return result;
+        },
+        unstable_requestStats: this.#requestTracker.flushStats()
+      };
+      await this.#reporterRunner.report(event);
+      await this.#requestTracker.runRequest((0, _ValidationRequest.default)({
+        optionsRef: this.#optionsRef,
+        assetRequests
+      }), {
+        force: assetRequests.length > 0
+      });
+      if (this.#reporterRunner.errors.length) {
+        throw this.#reporterRunner.errors;
+      }
+      return event;
+    } catch (e) {
+      if (e instanceof _utils.BuildAbortError) {
+        throw e;
+      }
+      let diagnostic = (0, _diagnostic().anyToDiagnostic)(e);
+      let event = {
+        type: 'buildFailure',
+        diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
+        unstable_requestStats: this.#requestTracker.flushStats()
+      };
+      await this.#reporterRunner.report(event);
+      return event;
+    } finally {
+      if (this.isProfiling) {
+        await this.stopProfiling();
+      }
+      await this.clearBuildCaches();
+    }
+  }
+  async _getWatcherSubscription() {
+    (0, _assert().default)(this.#watcherSubscription == null);
+    let resolvedOptions = (0, _nullthrows().default)(this.#resolvedOptions);
+    let opts = (0, _RequestTracker.getWatcherOptions)(resolvedOptions);
+    let sub = await resolvedOptions.inputFS.watch(resolvedOptions.watchDir, async (err, events) => {
+      var _events$, _events$2;
+      if (err) {
+        _logger().default.warn({
+          message: `File watch event error occured`,
+          meta: {
+            err,
+            trackableEvent: 'watcher_error'
+          }
+        });
+        this.#watchEvents.emit({
+          error: err
+        });
+        return;
+      }
+      _logger().default.verbose({
+        message: `File watch event emitted with ${events.length} events. Sample event: [${(_events$ = events[0]) === null || _events$ === void 0 ? void 0 : _events$.type}] ${(_events$2 = events[0]) === null || _events$2 === void 0 ? void 0 : _events$2.path}`
+      });
+      let nativeInvalid = false;
+      if (this.rustAtlaspack) {
+        nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
+      }
+      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
+        if (this.#watchAbortController) {
+          this.#watchAbortController.abort();
+        }
+        this.#watchQueue.add(() => this._startNextBuild());
+        this.#watchQueue.run();
+      }
+    }, opts);
+    return {
+      unsubscribe: () => sub.unsubscribe()
+    };
+  }
+
+  // This is mainly for integration tests and it not public api!
+  _getResolvedAtlaspackOptions() {
+    return (0, _nullthrows().default)(this.#resolvedOptions, 'Resolved options is null, please let atlaspack initialize before accessing this.');
+  }
+  async startProfiling() {
+    if (this.isProfiling) {
+      throw new Error('Atlaspack is already profiling');
+    }
+    _logger().default.info({
+      origin: '@atlaspack/core',
+      message: 'Starting profiling...'
+    });
+    this.isProfiling = true;
+    await this.#farm.startProfile();
+  }
+  stopProfiling() {
+    if (!this.isProfiling) {
+      throw new Error('Atlaspack is not profiling');
+    }
+    _logger().default.info({
+      origin: '@atlaspack/core',
+      message: 'Stopping profiling...'
+    });
+    this.isProfiling = false;
+    return this.#farm.endProfile();
+  }
+  takeHeapSnapshot() {
+    _logger().default.info({
+      origin: '@atlaspack/core',
+      message: 'Taking heap snapshot...'
+    });
+    return this.#farm.takeHeapSnapshot();
+  }
+
+  /**
+   * Must be called between builds otherwise there is global state that will
+   * break things unexpectedly.
+   */
+  async clearBuildCaches() {
+    var _this$farm;
+    await ((_this$farm = this.#farm) === null || _this$farm === void 0 ? void 0 : _this$farm.callAllWorkers('clearWorkerBuildCaches', []));
+  }
+  async unstable_invalidate() {
+    await this._init();
+  }
+
+  /**
+   * Build the asset graph
+   */
+  async unstable_buildAssetGraph(writeToCache = true) {
+    await this._init();
+    const origin = '@atlaspack/core';
+    const input = {
+      optionsRef: this.#optionsRef,
+      name: 'Main',
+      entries: this.#config.options.entries,
+      shouldBuildLazily: false,
+      lazyIncludes: [],
+      lazyExcludes: [],
+      requestedAssetIds: this.#requestedAssetIds
+    };
+    const start = Date.now();
+    const result = await this.#requestTracker.runRequest(this.rustAtlaspack != null ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) : (0, _AssetGraphRequest.default)(input), {
+      force: true
+    });
+    const duration = Date.now() - start;
+    _logger().default.info({
+      message: `Done building asset graph in ${duration / 1000}s!`,
+      origin
+    });
+    if (writeToCache) {
+      _logger().default.info({
+        message: 'Write request tracker to cache',
+        origin
+      });
+      await this.writeRequestTrackerToCache();
+      _logger().default.info({
+        message: 'Done writing request tracker to cache',
+        origin
+      });
+    }
+    return result;
+  }
+  async unstable_transform(options) {
+    var _options$env;
+    if (!this.#initialized) {
+      await this._init();
+    }
+    let projectRoot = (0, _nullthrows().default)(this.#resolvedOptions).projectRoot;
+    let request = (0, _AssetRequest.default)({
+      ...options,
+      filePath: (0, _projectPath.toProjectPath)(projectRoot, options.filePath),
+      optionsRef: this.#optionsRef,
+      env: (0, _Environment.createEnvironment)({
+        ...options.env,
+        loc: ((_options$env = options.env) === null || _options$env === void 0 ? void 0 : _options$env.loc) != null ? {
+          ...options.env.loc,
+          filePath: (0, _projectPath.toProjectPath)(projectRoot, options.env.loc.filePath)
+        } : undefined
+      })
+    });
+    let res = await this.#requestTracker.runRequest(request, {
+      force: true
+    });
+    return res.map(asset => (0, _Asset.assetFromValue)(asset, (0, _nullthrows().default)(this.#resolvedOptions)));
+  }
+  async unstable_resolve(request) {
+    var _request$env;
+    if (!this.#initialized) {
+      await this._init();
+    }
+    let projectRoot = (0, _nullthrows().default)(this.#resolvedOptions).projectRoot;
+    if (request.resolveFrom == null && _path().default.isAbsolute(request.specifier)) {
+      request.specifier = (0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPath)(projectRoot, request.specifier));
+    }
+    let dependency = (0, _Dependency.createDependency)(projectRoot, {
+      ...request,
+      env: (0, _Environment.createEnvironment)({
+        ...request.env,
+        loc: ((_request$env = request.env) === null || _request$env === void 0 ? void 0 : _request$env.loc) != null ? {
+          ...request.env.loc,
+          filePath: (0, _projectPath.toProjectPath)(projectRoot, request.env.loc.filePath)
+        } : undefined
+      })
+    });
+    let req = (0, _PathRequest.default)({
+      dependency,
+      name: request.specifier
+    });
+    let res = await this.#requestTracker.runRequest(req, {
+      force: true
+    });
+    if (!res) {
+      return null;
+    }
+    return {
+      filePath: (0, _projectPath.fromProjectPath)(projectRoot, res.filePath),
+      code: res.code,
+      query: res.query,
+      sideEffects: res.sideEffects
+    };
+  }
+}
+exports.default = Atlaspack;
+class BuildError extends _diagnostic().default {
+  constructor(diagnostic) {
+    super({
+      diagnostic
+    });
+    this.name = 'BuildError';
+  }
+}
+exports.BuildError = BuildError;
+function createWorkerFarm(options = {}) {
+  return new (_workers().default)({
+    ...options,
+    workerPath: WORKER_PATH
+  });
+}