@netless/fastboard-core 0.3.4-canary.0 → 0.3.4

package/dist/index.js

@@ -0,0 +1,678 @@
+'use strict';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FastboardApp: () => FastboardApp,
+  FastboardPlayer: () => FastboardPlayer,
+  SlideApp: () => import_app_slide.default,
+  addSlideHooks: () => import_app_slide.addHooks,
+  convertedFileToScene: () => convertedFileToScene,
+  createFastboard: () => createFastboard,
+  genUID: () => genUID,
+  getImageSize: () => getImageSize,
+  makeSlideParams: () => makeSlideParams,
+  previewSlide: () => import_app_slide.previewSlide,
+  readable: () => readable,
+  register: () => register,
+  replayFastboard: () => replayFastboard,
+  slideApps: () => import_app_slide.apps,
+  version: () => version,
+  warn: () => warn,
+  writable: () => writable
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/store.ts
+function noop() {
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+function readable(value, start = noop) {
+  let stop;
+  const subscribers = /* @__PURE__ */ new Set();
+  function set(new_value) {
+    if (safe_not_equal(value, new_value)) {
+      value = new_value;
+      if (stop) {
+        for (const run of subscribers) {
+          run(value);
+        }
+      }
+    }
+  }
+  function subscribe(run) {
+    subscribers.add(run);
+    if (subscribers.size === 1) {
+      stop = start(set) || noop;
+    }
+    run(value);
+    return () => {
+      subscribers.delete(run);
+      if (subscribers.size === 0) {
+        stop && stop();
+        stop = void 0;
+      }
+    };
+  }
+  function reaction(run) {
+    subscribers.add(run);
+    if (subscribers.size === 1) {
+      stop = start(set) || noop;
+    }
+    return () => {
+      subscribers.delete(run);
+      if (subscribers.size === 0) {
+        stop && stop();
+        stop = void 0;
+      }
+    };
+  }
+  return {
+    get value() {
+      return value;
+    },
+    subscribe,
+    reaction
+  };
+}
+function writable(value, start = noop, set) {
+  const internal = readable(value, start);
+  return {
+    get value() {
+      return internal.value;
+    },
+    subscribe: internal.subscribe,
+    reaction: internal.reaction,
+    set,
+    update(fn) {
+      set(fn(value));
+    }
+  };
+}
+
+// src/utils/misc.ts
+function getImageSize(url, fallback) {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(fallback);
+    img.src = url;
+  });
+}
+function makeSlideParams(scenes) {
+  const emptyScenes = [];
+  let taskId = "";
+  let url = "";
+  const pptSrcRE = new RegExp("^pptx?(?<prefix>:\\/\\/\\S+?dynamicConvert)\\/(?<taskId>\\w+)\\/");
+  for (const { name, ppt } of scenes) {
+    emptyScenes.push({ name });
+    if (!ppt || !ppt.src.startsWith("ppt")) {
+      continue;
+    }
+    const match = pptSrcRE.exec(ppt.src);
+    if (!match || !match.groups) {
+      continue;
+    }
+    taskId = match.groups.taskId;
+    url = "https" + match.groups.prefix;
+    break;
+  }
+  return { scenes: emptyScenes, taskId, url };
+}
+function convertedFileToScene(f, i) {
+  return {
+    name: String(i + 1),
+    ppt: {
+      src: f.conversionFileUrl,
+      width: f.width,
+      height: f.height,
+      previewURL: f.preview
+    }
+  };
+}
+
+// src/utils/uid.ts
+var SOUP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var SOUP_LEN = 62;
+var ID_LEN = 20;
+var reusedIdCarrier = /* @__PURE__ */ Array(ID_LEN);
+function genUID() {
+  for (let i = 0; i < ID_LEN; i++) {
+    reusedIdCarrier[i] = SOUP.charAt(Math.random() * SOUP_LEN);
+  }
+  return reusedIdCarrier.join("");
+}
+
+// src/utils/warn.ts
+var warnings = {
+  "no-ppt-in-scenes": "You're probably inserting the slide app in a wrong way, there shouldn't exist `scenes[0].ppt`."
+};
+var warned = /* @__PURE__ */ new Set();
+function warn(id) {
+  if (warned.has(id))
+    return;
+  warned.add(id);
+  console.warn(warnings[id]);
+}
+
+// src/impl/FastboardApp.ts
+var import_white_web_sdk = require("white-web-sdk");
+var import_window_manager3 = require("@netless/window-manager");
+
+// src/internal.ts
+var import_window_manager = require("@netless/window-manager");
+function ensure_window_manager(joinRoom) {
+  if (!joinRoom.invisiblePlugins || !joinRoom.invisiblePlugins.includes(import_window_manager.WindowManager)) {
+    joinRoom.invisiblePlugins = [...joinRoom.invisiblePlugins || [], import_window_manager.WindowManager];
+  }
+  return joinRoom;
+}
+function transform_app_status(status) {
+  return status === "start" ? "loading" : status === "failed" ? "failed" : "idle";
+}
+
+// src/behaviors/index.ts
+var import_window_manager2 = require("@netless/window-manager");
+var import_app_slide = __toESM(require("@netless/app-slide"));
+var DefaultApps = {
+  Monaco: {
+    src: "https://netless-app.oss-cn-hangzhou.aliyuncs.com/@netless/app-monaco/0.1.12/dist/main.iife.js"
+  },
+  Countdown: {
+    src: "https://netless-app.oss-cn-hangzhou.aliyuncs.com/@netless/app-countdown/0.0.2/dist/main.iife.js"
+  },
+  GeoGebra: {
+    src: "https://netless-app.oss-cn-hangzhou.aliyuncs.com/@netless/app-geogebra/0.0.4/dist/main.iife.js",
+    appOptions: {
+      HTML5Codebase: "https://flat-storage-cn-hz.whiteboard.agora.io/GeoGebra/HTML5/5.0/web3d"
+    }
+  },
+  EmbeddedPage: {
+    src: "https://netless-app.oss-cn-hangzhou.aliyuncs.com/@netless/app-embedded-page/0.1.1/dist/main.iife.js"
+  },
+  Plyr: {
+    src: "https://netless-app.oss-cn-hangzhou.aliyuncs.com/@netless/app-plyr/0.1.3/dist/main.iife.js"
+  }
+};
+import_window_manager2.WindowManager.register({
+  kind: "Slide",
+  appOptions: { debug: false },
+  src: import_app_slide.default,
+  addHooks: import_app_slide.addHooks
+});
+for (const kind in DefaultApps) {
+  if (Object.prototype.hasOwnProperty.call(DefaultApps, kind)) {
+    const options = DefaultApps[kind];
+    import_window_manager2.WindowManager.register(__spreadValues({ kind }, options));
+  }
+}
+var register = import_window_manager2.WindowManager.register.bind(import_window_manager2.WindowManager);
+var version = "0.3.4";
+if (typeof window !== "undefined") {
+  let str = window.__netlessUA || "";
+  str += ` ${"@netless/fastboard"}@${version} `;
+  window.__netlessUA = str;
+}
+
+// src/impl/FastboardApp.ts
+var FastboardAppBase = class {
+  constructor(sdk, room, manager, hotKeys) {
+    this.sdk = sdk;
+    this.room = room;
+    this.manager = manager;
+    this.hotKeys = hotKeys;
+    this._destroyed = false;
+  }
+  _assertNotDestroyed() {
+    if (this._destroyed) {
+      throw new Error("FastboardApp has been destroyed");
+    }
+  }
+  _addRoomListener(name, listener) {
+    this._assertNotDestroyed();
+    this.room.callbacks.on(name, listener);
+    return () => this.room.callbacks.off(name, listener);
+  }
+  _addManagerListener(name, listener) {
+    this._assertNotDestroyed();
+    this.manager.emitter.on(name, listener);
+    return () => this.manager.emitter.off(name, listener);
+  }
+  _addMainViewListener(name, listener) {
+    this._assertNotDestroyed();
+    this.manager.mainView.callbacks.on(name, listener);
+    return () => this.manager.mainView.callbacks.off(name, listener);
+  }
+  destroy() {
+    this._destroyed = true;
+    this.manager.destroy();
+    return this.room.disconnect();
+  }
+};
+var FastboardApp = class extends FastboardAppBase {
+  constructor() {
+    super(...arguments);
+    this.writable = writable(this.room.isWritable, (set) => {
+      set(this.room.isWritable);
+      return this._addRoomListener("onEnableWriteNowChanged", () => set(this.room.isWritable));
+    }, this.room.setWritable.bind(this.room));
+    this.phase = readable(this.room.phase, (set) => {
+      set(this.room.phase);
+      return this._addRoomListener("onPhaseChanged", set);
+    });
+    this.boxState = readable(this.manager.boxState, (set) => {
+      set(this.manager.boxState);
+      return this._addManagerListener("boxStateChange", set);
+    });
+    this.focusedApp = readable(this.manager.focused, (set) => {
+      set(this.manager.focused);
+      return this._addManagerListener("focusedChange", set);
+    });
+    this.canRedoSteps = readable(this.manager.canRedoSteps, (set) => {
+      set(this.manager.canRedoSteps);
+      return this._addManagerListener("canRedoStepsChange", set);
+    });
+    this.canUndoSteps = readable(this.manager.canUndoSteps, (set) => {
+      set(this.manager.canUndoSteps);
+      return this._addManagerListener("canUndoStepsChange", set);
+    });
+    this.camera = readable(this.manager.camera, (set) => {
+      set(this.manager.camera);
+      return this._addMainViewListener("onCameraUpdated", set);
+    });
+    this.memberState = readable(this.room.state.memberState, (set) => {
+      set(this.room.state.memberState);
+      return this._addRoomListener("onRoomStateChanged", ({ memberState: m }) => m && set(m));
+    });
+    this.sceneIndex = writable(this.manager.mainViewSceneIndex, (set) => {
+      set(this.manager.mainViewSceneIndex);
+      return this._addManagerListener("mainViewSceneIndexChange", set);
+    }, this.manager.setMainViewSceneIndex.bind(this.manager));
+    this.sceneLength = readable(this.manager.mainViewScenesLength, (set) => {
+      set(this.manager.mainViewScenesLength);
+      return this._addManagerListener("mainViewScenesLengthChange", set);
+    });
+    this._appsStatus = {};
+    this.appsStatus = readable({}, (set) => this._addManagerListener("loadApp", ({ kind, status, reason }) => {
+      this._appsStatus[kind] = { status: transform_app_status(status), reason };
+      set(this._appsStatus);
+    }));
+  }
+  bindContainer(container) {
+    this._assertNotDestroyed();
+    this.manager.bindContainer(container);
+  }
+  bindCollector(container) {
+    this._assertNotDestroyed();
+    this.manager.bindCollectorContainer(container);
+  }
+  undo() {
+    this._assertNotDestroyed();
+    this.manager.undo();
+  }
+  redo() {
+    this._assertNotDestroyed();
+    this.manager.redo();
+  }
+  moveCamera(camera) {
+    this._assertNotDestroyed();
+    this.manager.moveCamera(camera);
+  }
+  moveCameraToContain(rectangle) {
+    this._assertNotDestroyed();
+    this.manager.moveCameraToContain(rectangle);
+  }
+  cleanCurrentScene() {
+    this._assertNotDestroyed();
+    this.manager.cleanCurrentScene();
+  }
+  setAppliance(appliance, shape) {
+    this._assertNotDestroyed();
+    this.manager.mainView.setMemberState({
+      currentApplianceName: appliance,
+      shapeType: shape
+    });
+  }
+  setStrokeWidth(strokeWidth) {
+    this._assertNotDestroyed();
+    this.manager.mainView.setMemberState({ strokeWidth });
+  }
+  setStrokeColor(strokeColor) {
+    this._assertNotDestroyed();
+    this.manager.mainView.setMemberState({ strokeColor });
+  }
+  setTextSize(textSize) {
+    this._assertNotDestroyed();
+    this.manager.mainView.setMemberState({ textSize });
+  }
+  setTextColor(textColor) {
+    this._assertNotDestroyed();
+    this.manager.mainView.setMemberState({ textColor });
+  }
+  prevPage() {
+    this._assertNotDestroyed();
+    return this.manager.prevPage();
+  }
+  nextPage() {
+    this._assertNotDestroyed();
+    return this.manager.nextPage();
+  }
+  addPage(params) {
+    this._assertNotDestroyed();
+    return this.manager.addPage(params);
+  }
+  removePage(index) {
+    this._assertNotDestroyed();
+    return this.manager.removePage(index);
+  }
+  async insertImage(url) {
+    this._assertNotDestroyed();
+    await this.manager.switchMainViewToWriter();
+    const { divElement } = this.manager.mainView;
+    const containerSize = {
+      width: (divElement == null ? void 0 : divElement.scrollWidth) || window.innerWidth,
+      height: (divElement == null ? void 0 : divElement.scrollHeight) || window.innerHeight
+    };
+    const maxWidth = containerSize.width * 0.8;
+    let { width, height } = await getImageSize(url, containerSize);
+    const scale = Math.min(maxWidth / width, 1);
+    const uuid = genUID();
+    const { centerX, centerY } = this.manager.camera;
+    width *= scale;
+    height *= scale;
+    this.manager.mainView.insertImage({ uuid, centerX, centerY, width, height, locked: false });
+    this.manager.mainView.completeImageUpload(uuid, url);
+    width /= 0.8;
+    height /= 0.8;
+    const originX = centerX - width / 2;
+    const originY = centerY - height / 2;
+    this.manager.moveCameraToContain({ originX, originY, width, height });
+  }
+  insertDocs(arg1, arg2) {
+    this._assertNotDestroyed();
+    if (typeof arg1 === "object" && "fileType" in arg1) {
+      return this._insertDocsImpl(arg1);
+    } else if (arg2 && arg2.status !== "Finished") {
+      throw new Error("FastboardApp cannot insert a converting doc.");
+    } else if (arg2 && arg2.progress) {
+      const title = arg1;
+      const scenePath = `/${arg2.uuid}/${genUID()}`;
+      const scenes1 = arg2.progress.convertedFileList.map(convertedFileToScene);
+      const { scenes, taskId, url } = makeSlideParams(scenes1);
+      if (taskId && url) {
+        return this._insertDocsImpl({ fileType: "pptx", scenePath, scenes, title, taskId, url });
+      } else {
+        return this._insertDocsImpl({ fileType: "pdf", scenePath, scenes: scenes1, title });
+      }
+    }
+  }
+  _insertDocsImpl(_a) {
+    var _b = _a, { fileType, scenePath, title, scenes } = _b, attributes = __objRest(_b, ["fileType", "scenePath", "title", "scenes"]);
+    this._assertNotDestroyed();
+    switch (fileType) {
+      case "pdf":
+        return this.manager.addApp({
+          kind: "DocsViewer",
+          options: { scenePath, title, scenes }
+        });
+      case "pptx":
+        if (scenes && scenes[0].ppt) {
+          warn("no-ppt-in-scenes");
+        }
+        return this.manager.addApp({
+          kind: "Slide",
+          options: { scenePath, title, scenes },
+          attributes
+        });
+    }
+  }
+  insertMedia(title, src) {
+    this._assertNotDestroyed();
+    return this.manager.addApp({
+      kind: import_window_manager3.BuiltinApps.MediaPlayer,
+      options: { title },
+      attributes: { src }
+    });
+  }
+  insertCodeEditor() {
+    this._assertNotDestroyed();
+    return this.manager.addApp({
+      kind: "Monaco",
+      options: { title: "Code Editor" }
+    });
+  }
+  insertCountdown() {
+    this._assertNotDestroyed();
+    return this.manager.addApp({
+      kind: "Countdown",
+      options: { title: "Countdown" }
+    });
+  }
+  insertGeoGebra() {
+    this._assertNotDestroyed();
+    return this.manager.addApp({
+      kind: "GeoGebra",
+      options: { title: "GeoGebra" }
+    });
+  }
+};
+async function createFastboard(_a) {
+  var _b = _a, {
+    sdkConfig,
+    joinRoom: _c
+  } = _b, _d = _c, { callbacks } = _d, joinRoomParams = __objRest(_d, ["callbacks"]), {
+    managerConfig,
+    netlessApps
+  } = _b;
+  const sdk = new import_white_web_sdk.WhiteWebSdk(__spreadProps(__spreadValues({}, sdkConfig), {
+    useMobXState: true
+  }));
+  const hotKeys = __spreadProps(__spreadValues({}, import_white_web_sdk.DefaultHotKeys), {
+    changeToSelector: "s",
+    changeToLaserPointer: "z",
+    changeToPencil: "p",
+    changeToRectangle: "r",
+    changeToEllipse: "c",
+    changeToEraser: "e",
+    changeToText: "t",
+    changeToStraight: "l",
+    changeToArrow: "a",
+    changeToHand: "h"
+  });
+  if (netlessApps) {
+    netlessApps.forEach((app) => {
+      register({ kind: app.kind, src: app });
+    });
+  }
+  const room = await sdk.joinRoom(__spreadProps(__spreadValues({
+    floatBar: true,
+    hotKeys
+  }, ensure_window_manager(joinRoomParams)), {
+    useMultiViews: true,
+    disableNewPencil: false,
+    disableMagixEventDispatchLimit: true
+  }), callbacks);
+  const manager = await import_window_manager3.WindowManager.mount(__spreadProps(__spreadValues({
+    cursor: true
+  }, managerConfig), {
+    room
+  }));
+  manager.mainView.setCameraBound({
+    minContentMode: (0, import_white_web_sdk.contentModeScale)(0.3),
+    maxContentMode: (0, import_white_web_sdk.contentModeScale)(3)
+  });
+  return new FastboardApp(sdk, room, manager, hotKeys);
+}
+
+// src/impl/FastboardPlayer.ts
+var import_white_web_sdk2 = require("white-web-sdk");
+var import_window_manager4 = require("@netless/window-manager");
+var FastboardPlayerBase = class {
+  constructor(sdk, player, manager) {
+    this.sdk = sdk;
+    this.player = player;
+    this.manager = manager;
+    this._destroyed = false;
+  }
+  _assertNotDestroyed() {
+    if (this._destroyed) {
+      throw new Error("FastboardApp has been destroyed");
+    }
+  }
+  _addPlayerListener(name, listener) {
+    this._assertNotDestroyed();
+    this.player.callbacks.on(name, listener);
+    return () => this.player.callbacks.off(name, listener);
+  }
+  _addManagerListener(name, listener) {
+    this._assertNotDestroyed();
+    this.manager.emitter.on(name, listener);
+    return () => this.manager.emitter.off(name, listener);
+  }
+  _addMainViewListener(name, listener) {
+    this._assertNotDestroyed();
+    this.manager.mainView.callbacks.on(name, listener);
+    return () => this.manager.mainView.callbacks.off(name, listener);
+  }
+  destroy() {
+    this._destroyed = true;
+    this.manager.destroy();
+    return this.player.callbacks.off();
+  }
+};
+var FastboardPlayer = class extends FastboardPlayerBase {
+  constructor() {
+    super(...arguments);
+    this.currentTime = writable(this.player.progressTime, (set) => {
+      set(this.player.progressTime);
+      return this._addPlayerListener("onProgressTimeChanged", set);
+    }, this.player.seekToProgressTime.bind(this.player));
+    this.phase = readable(this.player.phase, (set) => {
+      set(this.player.phase);
+      return this._addPlayerListener("onPhaseChanged", set);
+    });
+    this.canplay = readable(this.player.isPlayable, (set) => {
+      set(this.player.isPlayable);
+      return this._addPlayerListener("onIsPlayableChanged", set);
+    });
+    this.playbackRate = writable(this.player.playbackSpeed, (set) => {
+      this._setPlaybackRate = set;
+      set(this.player.playbackSpeed);
+    }, (value) => {
+      this.player.playbackSpeed = value;
+      this._setPlaybackRate(value);
+    });
+    this.duration = readable(this.player.timeDuration, (set) => {
+      set(this.player.timeDuration);
+    });
+    this.state = readable(this.player.state, (set) => {
+      set(this.player.state);
+      return this._addPlayerListener("onPlayerStateChanged", () => set(this.player.state));
+    });
+  }
+  bindContainer(container) {
+    this._assertNotDestroyed();
+    this.manager.bindContainer(container);
+  }
+  bindCollector(container) {
+    this._assertNotDestroyed();
+    this.manager.bindCollectorContainer(container);
+  }
+  seek(timestamp) {
+    this._assertNotDestroyed();
+    return this.player.seekToProgressTime(timestamp);
+  }
+  play() {
+    this._assertNotDestroyed();
+    this.player.play();
+  }
+  pause() {
+    this._assertNotDestroyed();
+    this.player.pause();
+  }
+  stop() {
+    this._assertNotDestroyed();
+    this.player.stop();
+  }
+  setPlaybackRate(value) {
+    this._assertNotDestroyed();
+    this.playbackRate.set(value);
+  }
+};
+async function replayFastboard(_a) {
+  var _b = _a, {
+    sdkConfig,
+    replayRoom: _c
+  } = _b, _d = _c, { callbacks } = _d, replayRoomParams = __objRest(_d, ["callbacks"]), {
+    managerConfig
+  } = _b;
+  const sdk = new import_white_web_sdk2.WhiteWebSdk(__spreadProps(__spreadValues({}, sdkConfig), {
+    useMobXState: true
+  }));
+  const player = await sdk.replayRoom(__spreadProps(__spreadValues({}, ensure_window_manager(replayRoomParams)), {
+    useMultiViews: true
+  }), callbacks);
+  const managerPromise = import_window_manager4.WindowManager.mount(__spreadProps(__spreadValues({
+    cursor: true
+  }, managerConfig), {
+    room: player
+  }));
+  player.play();
+  const manager = await managerPromise;
+  player.pause();
+  await player.seekToProgressTime(0);
+  return new FastboardPlayer(sdk, player, manager);
+}
+//# sourceMappingURL=index.js.map