@editframe/elements 0.6.0-beta.11 → 0.6.0-beta.9

package/dist/packages/elements/src/elements/EFCaptions.js

@@ -1,173 +0,0 @@
-import { EFAudio } from "./EFAudio.js";
-import { html, css, LitElement } from "lit";
-import { Task } from "@lit/task";
-import { property, customElement } from "lit/decorators.js";
-import { EFVideo } from "./EFVideo.js";
-import { EFTemporal } from "./EFTemporal.js";
-import { CrossUpdateController } from "./CrossUpdateController.js";
-import { FetchMixin } from "./FetchMixin.js";
-import { EFSourceMixin } from "./EFSourceMixin.js";
-import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-let EFCaptionsActiveWord = class extends EFTemporal(LitElement) {
-  constructor() {
-    super(...arguments);
-    this.wordStartMs = 0;
-    this.wordEndMs = 0;
-    this.wordText = "";
-  }
-  render() {
-    return html`${this.wordText}`;
-  }
-  get startTimeMs() {
-    return this.wordStartMs || 0;
-  }
-  get durationMs() {
-    return this.wordEndMs - this.wordStartMs;
-  }
-};
-EFCaptionsActiveWord.styles = [
-  css`
-      :host {
-        display: inline-block;
-      }
-    `
-];
-__decorateClass([
-  property({ type: Number, attribute: false })
-], EFCaptionsActiveWord.prototype, "wordStartMs", 2);
-__decorateClass([
-  property({ type: Number, attribute: false })
-], EFCaptionsActiveWord.prototype, "wordEndMs", 2);
-__decorateClass([
-  property({ type: String, attribute: false })
-], EFCaptionsActiveWord.prototype, "wordText", 2);
-EFCaptionsActiveWord = __decorateClass([
-  customElement("ef-captions-active-word")
-], EFCaptionsActiveWord);
-let EFCaptions = class extends EFSourceMixin(
-  EFTemporal(FetchMixin(LitElement)),
-  { assetType: "caption_files" }
-) {
-  constructor() {
-    super(...arguments);
-    this.target = null;
-    this.wordStyle = "";
-    this.activeWordContainers = this.getElementsByTagName("ef-captions-active-word");
-    this.md5SumLoader = new Task(this, {
-      autoRun: false,
-      args: () => [this.target],
-      task: async ([], { signal }) => {
-        const md5Path = `/@ef-asset/${this.targetElement.src ?? ""}`;
-        const response = await fetch(md5Path, { method: "HEAD", signal });
-        return response.headers.get("etag") ?? void 0;
-      }
-    });
-    this.captionsDataTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.captionsPath(), this.fetch],
-      task: async ([captionsPath, fetch2], { signal }) => {
-        const response = await fetch2(captionsPath, { signal });
-        return response.json();
-      }
-    });
-    this.frameTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.captionsDataTask.status],
-      task: async () => {
-        await this.captionsDataTask.taskComplete;
-      }
-    });
-  }
-  captionsPath() {
-    if (this.src.startsWith("editframe://") || this.src.startsWith("http")) {
-      return this.src.replace("isobmff", "caption");
-    }
-    return `/@ef-captions/${this.targetElement.src ?? ""}`;
-  }
-  productionSrc() {
-    if (!this.md5SumLoader.value) {
-      throw new Error(
-        `MD5 sum not available for ${this}. Cannot generate production URL`
-      );
-    }
-    return `http://localhost:3000/api/video2/caption_files/${this.md5SumLoader.value}`;
-  }
-  connectedCallback() {
-    super.connectedCallback();
-    if (this.targetElement) {
-      new CrossUpdateController(this.targetElement, this);
-    }
-  }
-  render() {
-    return this.captionsDataTask.render({
-      pending: () => html`<div>Generating captions data...</div>`,
-      error: () => html`<div>🚫 Error generating captions data</div>`,
-      complete: () => html`<slot></slot>`
-    });
-  }
-  updated(_changedProperties) {
-    this.updateActiveWord();
-  }
-  updateActiveWord() {
-    const caption = this.captionsDataTask.value;
-    if (!caption) {
-      return;
-    }
-    const words = [];
-    let startMs = 0;
-    let endMs = 0;
-    for (const segment of caption.segments) {
-      if (this.targetElement.ownCurrentTimeMs >= segment.start * 1e3 && this.targetElement.ownCurrentTimeMs <= segment.end * 1e3) {
-        return segment.words.map((word) => {
-          if (this.targetElement.ownCurrentTimeMs >= word.start * 1e3 && this.targetElement.ownCurrentTimeMs <= word.end * 1e3) {
-            words.push(word.text);
-            startMs = word.start * 1e3;
-            endMs = word.end * 1e3;
-          }
-        });
-      }
-    }
-    for (const container of Array.from(this.activeWordContainers)) {
-      container.wordText = words.join(" ");
-      container.wordStartMs = startMs;
-      container.wordEndMs = endMs;
-    }
-  }
-  get targetElement() {
-    const target = document.querySelector(this.getAttribute("target") ?? "");
-    if (target instanceof EFAudio || target instanceof EFVideo) {
-      return target;
-    }
-    throw new Error("Invalid target, must be an EFAudio  or EFVideo element");
-  }
-};
-EFCaptions.styles = [
-  css`
-      :host {
-        display: block;
-      }
-    `
-];
-__decorateClass([
-  property({ type: String, attribute: "target" })
-], EFCaptions.prototype, "target", 2);
-__decorateClass([
-  property({ attribute: "word-style" })
-], EFCaptions.prototype, "wordStyle", 2);
-EFCaptions = __decorateClass([
-  customElement("ef-captions")
-], EFCaptions);
-export {
-  EFCaptions,
-  EFCaptionsActiveWord
-};

package/dist/packages/elements/src/elements/EFImage.cjs

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const task = require("@lit/task");
-const lit = require("lit");
-const decorators_js = require("lit/decorators.js");
-const ref_js = require("lit/directives/ref.js");
-const FetchMixin = require("./FetchMixin.cjs");
-const EFSourceMixin = require("./EFSourceMixin.cjs");
-const EF_INTERACTIVE = require("../EF_INTERACTIVE.cjs");
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-exports.EFImage = class EFImage extends EFSourceMixin.EFSourceMixin(FetchMixin.FetchMixin(lit.LitElement), {
-  assetType: "image_files"
-}) {
-  constructor() {
-    super(...arguments);
-    this.imageRef = ref_js.createRef();
-    this.canvasRef = ref_js.createRef();
-    this.fetchImage = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [this.assetPath(), this.fetch],
-      task: async ([assetPath, fetch], { signal }) => {
-        const response = await fetch(assetPath, { signal });
-        const image = new Image();
-        image.src = URL.createObjectURL(await response.blob());
-        await new Promise((resolve) => {
-          image.onload = resolve;
-        });
-        if (!this.canvasRef.value) throw new Error("Canvas not ready");
-        const ctx = this.canvasRef.value.getContext("2d");
-        if (!ctx) throw new Error("Canvas 2d context not ready");
-        this.canvasRef.value.width = image.width;
-        this.canvasRef.value.height = image.height;
-        ctx.drawImage(image, 0, 0);
-      }
-    });
-    this.frameTask = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [this.fetchImage.status],
-      task: async () => {
-        await this.fetchImage.taskComplete;
-      }
-    });
-  }
-  render() {
-    return lit.html`<canvas ${ref_js.ref(this.canvasRef)}></canvas>`;
-  }
-  assetPath() {
-    if (this.src.startsWith("editframe://") || this.src.startsWith("http")) {
-      return this.src;
-    }
-    return `/@ef-image/${this.src}`;
-  }
-};
-exports.EFImage.styles = [
-  lit.css`
-      :host {
-        display: block;
-      }
-      canvas {
-        display: block;
-        width: 100%;
-        height: 100%;
-        object-fit: fill;
-        object-position: center;
-      }
-    `
-];
-exports.EFImage = __decorateClass([
-  decorators_js.customElement("ef-image")
-], exports.EFImage);

package/dist/packages/elements/src/elements/EFImage.d.ts

@@ -1,14 +0,0 @@
-import { Task } from '@lit/task';
-import { LitElement } from 'lit';
-
-declare const EFImage_base: (new (...args: any[]) => import('./EFSourceMixin').EFSourceMixinInterface) & (new (...args: any[]) => import('./FetchMixin').FetchMixinInterface) & typeof LitElement;
-export declare class EFImage extends EFImage_base {
-    static styles: import('lit').CSSResult[];
-    imageRef: import('lit-html/directives/ref').Ref<HTMLImageElement>;
-    canvasRef: import('lit-html/directives/ref').Ref<HTMLCanvasElement>;
-    render(): import('lit-html').TemplateResult<1>;
-    assetPath(): string;
-    fetchImage: Task<readonly [string, typeof fetch], void>;
-    frameTask: Task<readonly [import('@lit/task').TaskStatus], void>;
-}
-export {};

package/dist/packages/elements/src/elements/EFImage.js

@@ -1,80 +0,0 @@
-import { Task } from "@lit/task";
-import { html, css, LitElement } from "lit";
-import { customElement } from "lit/decorators.js";
-import { createRef, ref } from "lit/directives/ref.js";
-import { FetchMixin } from "./FetchMixin.js";
-import { EFSourceMixin } from "./EFSourceMixin.js";
-import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-let EFImage = class extends EFSourceMixin(FetchMixin(LitElement), {
-  assetType: "image_files"
-}) {
-  constructor() {
-    super(...arguments);
-    this.imageRef = createRef();
-    this.canvasRef = createRef();
-    this.fetchImage = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.assetPath(), this.fetch],
-      task: async ([assetPath, fetch], { signal }) => {
-        const response = await fetch(assetPath, { signal });
-        const image = new Image();
-        image.src = URL.createObjectURL(await response.blob());
-        await new Promise((resolve) => {
-          image.onload = resolve;
-        });
-        if (!this.canvasRef.value) throw new Error("Canvas not ready");
-        const ctx = this.canvasRef.value.getContext("2d");
-        if (!ctx) throw new Error("Canvas 2d context not ready");
-        this.canvasRef.value.width = image.width;
-        this.canvasRef.value.height = image.height;
-        ctx.drawImage(image, 0, 0);
-      }
-    });
-    this.frameTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.fetchImage.status],
-      task: async () => {
-        await this.fetchImage.taskComplete;
-      }
-    });
-  }
-  render() {
-    return html`<canvas ${ref(this.canvasRef)}></canvas>`;
-  }
-  assetPath() {
-    if (this.src.startsWith("editframe://") || this.src.startsWith("http")) {
-      return this.src;
-    }
-    return `/@ef-image/${this.src}`;
-  }
-};
-EFImage.styles = [
-  css`
-      :host {
-        display: block;
-      }
-      canvas {
-        display: block;
-        width: 100%;
-        height: 100%;
-        object-fit: fill;
-        object-position: center;
-      }
-    `
-];
-EFImage = __decorateClass([
-  customElement("ef-image")
-], EFImage);
-export {
-  EFImage
-};

package/dist/packages/elements/src/elements/EFMedia.cjs

@@ -1,334 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const lit = require("lit");
-const EFTemporal = require("./EFTemporal.cjs");
-const decorators_js = require("lit/decorators.js");
-const deepEquals_js = require("@lit/task/deep-equals.js");
-const task = require("@lit/task");
-const MP4File = require("../../../../lib/av/MP4File.cjs");
-const util = require("./util.cjs");
-const EncodedAsset = require("../../../../lib/av/EncodedAsset.cjs");
-const FetchMixin = require("./FetchMixin.cjs");
-const EFWorkbench = require("../gui/EFWorkbench.cjs");
-const context = require("@lit/context");
-const EFSourceMixin = require("./EFSourceMixin.cjs");
-const EF_INTERACTIVE = require("../EF_INTERACTIVE.cjs");
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp(target, key, result);
-  return result;
-};
-const deepGetMediaElements = (element, medias = []) => {
-  for (const child of Array.from(element.children)) {
-    if (child instanceof EFMedia) {
-      medias.push(child);
-    } else {
-      deepGetMediaElements(child, medias);
-    }
-  }
-  return medias;
-};
-class EFMedia extends EFSourceMixin.EFSourceMixin(EFTemporal.EFTemporal(FetchMixin.FetchMixin(lit.LitElement)), {
-  assetType: "isobmff_files"
-}) {
-  constructor() {
-    super(...arguments);
-    this.currentTimeMs = 0;
-    this.trackFragmentIndexLoader = new task.Task(this, {
-      args: () => [this.fragmentIndexPath(), this.fetch],
-      task: async ([fragmentIndexPath, fetch], { signal }) => {
-        const response = await fetch(fragmentIndexPath, { signal });
-        return await response.json();
-      },
-      onComplete: () => {
-        this.requestUpdate("ownCurrentTimeMs");
-        this.parentTimegroup?.requestUpdate("ownCurrentTimeMs");
-      }
-    });
-    this.initSegmentsLoader = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [this.trackFragmentIndexLoader.value, this.src, this.fetch],
-      task: async ([fragmentIndex, _src, fetch], { signal }) => {
-        if (!fragmentIndex) {
-          return;
-        }
-        return await Promise.all(
-          Object.entries(fragmentIndex).map(async ([trackId, track]) => {
-            const start = track.initSegment.offset;
-            const end = track.initSegment.offset + track.initSegment.size - 1;
-            const response = await fetch(this.fragmentTrackPath(trackId), {
-              signal,
-              headers: { Range: `bytes=${start}-${end}` }
-            });
-            const buffer = await response.arrayBuffer();
-            buffer.fileStart = 0;
-            const mp4File = new MP4File.MP4File();
-            mp4File.appendBuffer(buffer, true);
-            mp4File.flush();
-            await mp4File.readyPromise;
-            return { trackId, buffer, mp4File };
-          })
-        );
-      }
-    });
-    this.seekTask = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [
-        this.desiredSeekTimeMs,
-        this.trackFragmentIndexLoader.value,
-        this.initSegmentsLoader.value
-      ],
-      task: async ([seekToMs, fragmentIndex, initSegments], { signal: _signal }) => {
-        if (fragmentIndex === void 0) {
-          return;
-        }
-        if (initSegments === void 0) {
-          return;
-        }
-        const result = {};
-        for (const index of Object.values(fragmentIndex)) {
-          const track = initSegments.find((segment2) => segment2.trackId === String(index.track))?.mp4File.getInfo().tracks[0];
-          if (!track) {
-            throw new Error("Could not finding matching track");
-          }
-          const segment = index.segments.toReversed().find((segment2) => {
-            return segment2.dts / track.timescale * 1e3 <= seekToMs;
-          });
-          if (!segment) {
-            return;
-          }
-          result[index.track] = { segment, track };
-        }
-        return result;
-      }
-    });
-    this.fetchSeekTask = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      argsEqual: deepEquals_js.deepArrayEquals,
-      args: () => [this.initSegmentsLoader.value, this.seekTask.value, this.fetch],
-      task: async ([initSegments, seekResult, fetch], { signal }) => {
-        if (!initSegments) {
-          return;
-        }
-        if (!seekResult) {
-          return;
-        }
-        const files = {};
-        for (const [trackId, { segment, track }] of Object.entries(seekResult)) {
-          const start = segment.offset;
-          const end = segment.offset + segment.size;
-          const response = await fetch(this.fragmentTrackPath(trackId), {
-            signal,
-            headers: { Range: `bytes=${start}-${end}` }
-          });
-          const initSegment = Object.values(initSegments).find(
-            (initSegment2) => initSegment2.trackId === String(track.id)
-          );
-          if (!initSegment) {
-            throw new Error("Could not find matching init segment");
-          }
-          const initBuffer = initSegment.buffer;
-          const mediaBuffer = await response.arrayBuffer();
-          files[trackId] = new File([initBuffer, mediaBuffer], "video.mp4", {
-            type: "video/mp4"
-          });
-        }
-        return files;
-      }
-    });
-    this.videoAssetTask = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [this.fetchSeekTask.value],
-      task: async ([files], { signal: _signal }) => {
-        if (!files) {
-          return;
-        }
-        if (!this.defaultVideoTrackId) {
-          return;
-        }
-        const videoFile = files[this.defaultVideoTrackId];
-        if (!videoFile) {
-          return;
-        }
-        for (const frame of this.videoAssetTask.value?.decodedFrames || []) {
-          frame.close();
-        }
-        this.videoAssetTask.value?.videoDecoder?.close();
-        return await EncodedAsset.VideoAsset.createFromReadableStream(
-          "video.mp4",
-          videoFile.stream(),
-          videoFile
-        );
-      }
-    });
-    this.desiredSeekTimeMs = 0;
-    this.#audioContext = new OfflineAudioContext(2, 48e3 / 30, 48e3);
-    this.audioBufferTask = new task.Task(this, {
-      autoRun: EF_INTERACTIVE.EF_INTERACTIVE,
-      args: () => [this.fetchSeekTask.value, this.seekTask.value],
-      task: async ([files, segments], { signal: _signal }) => {
-        if (!files) {
-          return;
-        }
-        if (!segments) {
-          return;
-        }
-        if (!this.defaultAudioTrackId) {
-          return;
-        }
-        const segment = segments[this.defaultAudioTrackId];
-        if (!segment) {
-          return;
-        }
-        const audioFile = files[this.defaultAudioTrackId];
-        if (!audioFile) {
-          return;
-        }
-        return {
-          buffer: await this.#audioContext.decodeAudioData(
-            await audioFile.arrayBuffer()
-          ),
-          startOffsetMs: segment.segment.cts / segment.track.timescale * 1e3
-        };
-      }
-    });
-  }
-  static {
-    this.styles = [
-      lit.css`
-      :host {
-        display: block;
-        position: relative;
-        overflow: hidden;
-      }
-    `
-    ];
-  }
-  fragmentIndexPath() {
-    if (this.src.startsWith("editframe://") || this.src.startsWith("http")) {
-      return `${this.src}/index`;
-    }
-    return `/@ef-track-fragment-index/${this.getAttribute("src") ?? ""}`;
-  }
-  fragmentTrackPath(trackId) {
-    if (this.src.startsWith("editframe://") || this.src.startsWith("http")) {
-      return `${this.src.replace("files", "tracks")}/${trackId}`;
-    }
-    return `/@ef-track/${this.src ?? ""}?trackId=${trackId}`;
-  }
-  get defaultVideoTrackId() {
-    return Object.values(this.trackFragmentIndexLoader.value ?? {}).find(
-      (track) => track.type === "video"
-    )?.track;
-  }
-  get defaultAudioTrackId() {
-    return Object.values(this.trackFragmentIndexLoader.value ?? {}).find(
-      (track) => track.type === "audio"
-    )?.track;
-  }
-  async executeSeek(seekToMs) {
-    this.desiredSeekTimeMs = seekToMs;
-  }
-  updated(changedProperties) {
-    if (changedProperties.has("ownCurrentTimeMs")) {
-      this.executeSeek(this.ownCurrentTimeMs);
-    }
-  }
-  get hasOwnDuration() {
-    return true;
-  }
-  get durationMs() {
-    if (!this.trackFragmentIndexLoader.value) {
-      return 0;
-    }
-    const durations = Object.values(this.trackFragmentIndexLoader.value).map(
-      (track) => {
-        return track.duration / track.timescale * 1e3;
-      }
-    );
-    if (durations.length === 0) {
-      return 0;
-    }
-    return Math.max(...durations);
-  }
-  get startTimeMs() {
-    return util.getStartTimeMs(this);
-  }
-  #audioContext;
-  async fetchAudioSpanningTime(fromMs, toMs) {
-    fromMs -= this.startTimeMs;
-    toMs -= this.startTimeMs;
-    await this.trackFragmentIndexLoader.taskComplete;
-    const audioTrackId = this.defaultAudioTrackId;
-    if (!audioTrackId) {
-      console.warn("No audio track found");
-      return;
-    }
-    const audioTrackIndex = this.trackFragmentIndexLoader.value?.[audioTrackId];
-    if (!audioTrackIndex) {
-      console.warn("No audio track found");
-      return;
-    }
-    const start = audioTrackIndex.initSegment.offset;
-    const end = audioTrackIndex.initSegment.offset + audioTrackIndex.initSegment.size - 1;
-    const audioInitFragmentRequest = this.fetch(
-      this.fragmentTrackPath(String(audioTrackId)),
-      {
-        headers: { Range: `bytes=${start}-${end}` }
-      }
-    );
-    const fragments = Object.values(audioTrackIndex.segments).filter(
-      (segment) => {
-        const segmentStartsBeforeEnd = segment.dts <= toMs * audioTrackIndex.timescale / 1e3;
-        const segmentEndsAfterStart = segment.dts + segment.duration >= fromMs * audioTrackIndex.timescale / 1e3;
-        return segmentStartsBeforeEnd && segmentEndsAfterStart;
-      }
-    );
-    const firstFragment = fragments[0];
-    if (!firstFragment) {
-      console.warn("No audio fragments found");
-      return;
-    }
-    const lastFragment = fragments[fragments.length - 1];
-    if (!lastFragment) {
-      console.warn("No audio fragments found");
-      return;
-    }
-    const fragmentStart = firstFragment.offset;
-    const fragmentEnd = lastFragment.offset + lastFragment.size - 1;
-    const audioFragmentRequest = this.fetch(
-      this.fragmentTrackPath(String(audioTrackId)),
-      {
-        headers: { Range: `bytes=${fragmentStart}-${fragmentEnd}` }
-      }
-    );
-    const initResponse = await audioInitFragmentRequest;
-    const dataResponse = await audioFragmentRequest;
-    const initBuffer = await initResponse.arrayBuffer();
-    const dataBuffer = await dataResponse.arrayBuffer();
-    const audioBlob = new Blob([initBuffer, dataBuffer], {
-      type: "audio/mp4"
-    });
-    return {
-      blob: audioBlob,
-      startMs: firstFragment.dts / audioTrackIndex.timescale * 1e3,
-      endMs: lastFragment.dts / audioTrackIndex.timescale * 1e3 + lastFragment.duration / audioTrackIndex.timescale * 1e3
-    };
-  }
-}
-__decorateClass([
-  decorators_js.property({ type: Number })
-], EFMedia.prototype, "currentTimeMs");
-__decorateClass([
-  context.consume({ context: EFWorkbench.apiHostContext, subscribe: true }),
-  decorators_js.state()
-], EFMedia.prototype, "efHost");
-__decorateClass([
-  decorators_js.state()
-], EFMedia.prototype, "desiredSeekTimeMs");
-exports.EFMedia = EFMedia;
-exports.deepGetMediaElements = deepGetMediaElements;