@storyteller-platform/align 0.1.56 → 0.1.58

package/dist/emit/emit.cjs

@@ -0,0 +1,105 @@
+"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);
+var emit_exports = {};
+__export(emit_exports, {
+  emit: () => emit
+});
+module.exports = __toCommonJS(emit_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_itertools = require("itertools");
+var import_ghost_story = require("@storyteller-platform/ghost-story");
+var import_media_types = require("@storyteller-platform/media-types");
+var import_fs = require("./fs.cjs");
+async function emit(input, output, options) {
+  const controller = new AbortController();
+  const signal = AbortSignal.any([
+    ...options.signal ? [options.signal] : [],
+    controller.signal
+  ]);
+  await (0, import_promises.mkdir)(output, { recursive: true });
+  const allFiles = await (0, import_promises.readdir)(input, { recursive: true });
+  const filenames = allFiles.toSorted().filter((f) => import_media_types.MediaType.fromPath(f)?.kind === "audio");
+  if (!filenames.length) {
+    throw new Error(
+      `Failed to transcribe audio: found no audio files in ${input}`
+    );
+  }
+  const engine = "wav2vec2";
+  const model = options.model ?? "onnx-community/mms-300m-1130-forced-aligner-ONNX";
+  const emissions = [];
+  function aborted() {
+    return signal.aborted;
+  }
+  const timing = (0, import_ghost_story.createAggregator)();
+  timing.setMetadata("engine", engine);
+  timing.setMetadata("model", model);
+  for (const [i, filename] of (0, import_itertools.enumerate)(filenames)) {
+    let onFileProgress2 = function(progress) {
+      const updatedProgress = (i + progress) / filenames.length;
+      options.logger?.info(`Progress: ${Math.floor(updatedProgress * 100)}%`);
+      options.onProgress?.(updatedProgress);
+    };
+    var onFileProgress = onFileProgress2;
+    if (aborted()) throw new Error("Aborted");
+    const filepath = (0, import_node_path.join)(input, filename);
+    const emissionFilepath = (0, import_node_path.join)(
+      output,
+      `${(0, import_node_path.basename)(filename, (0, import_node_path.extname)(filename))}.json`
+    );
+    try {
+      await (0, import_promises.readFile)(emissionFilepath, {
+        encoding: "utf-8",
+        signal
+      });
+      options.logger?.info(`Found existing transcription for ${filepath}`);
+      emissions.push(emissionFilepath);
+      options.onProgress?.((emissions.length + 1) / filenames.length);
+      continue;
+    } catch {
+    }
+    if (aborted()) throw new Error("Aborted");
+    const result = await (0, import_ghost_story.emit)(filepath, {
+      ...options,
+      signal,
+      engine,
+      options: {
+        model,
+        ...options.device && { device: options.device },
+        ...options.dtype && { dtype: options.dtype },
+        onProgress: onFileProgress2
+      }
+    });
+    options.logger?.info(
+      (0, import_ghost_story.formatSingleReport)(
+        result.timing,
+        `Transcription Timing Report for ${filepath}`
+      )
+    );
+    timing.add(result.timing);
+    await (0, import_fs.writeEmissionsFile)(emissionFilepath, result, { signal });
+    emissions.push(emissionFilepath);
+    options.onProgress?.((i + 1) / filenames.length);
+  }
+  return timing;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emit
+});

package/dist/emit/emit.d.cts

@@ -0,0 +1,15 @@
+import { Logger } from 'pino';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { Wav2Vec2Model, Wav2Vec2Device, Wav2Vec2DataType } from '@storyteller-platform/ghost-story/constants';
+
+interface EmitOptions {
+    onProgress?: ((progress: number) => void) | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    model?: Wav2Vec2Model | null | undefined;
+    device?: Wav2Vec2Device | null | undefined;
+    dtype?: Wav2Vec2DataType | null | undefined;
+    logger?: Logger | null | undefined;
+}
+declare function emit(input: string, output: string, options: EmitOptions): Promise<TimingAggregator>;
+
+export { type EmitOptions, emit };

package/dist/emit/emit.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from 'pino';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { Wav2Vec2Model, Wav2Vec2Device, Wav2Vec2DataType } from '@storyteller-platform/ghost-story/constants';
+
+interface EmitOptions {
+    onProgress?: ((progress: number) => void) | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    model?: Wav2Vec2Model | null | undefined;
+    device?: Wav2Vec2Device | null | undefined;
+    dtype?: Wav2Vec2DataType | null | undefined;
+    logger?: Logger | null | undefined;
+}
+declare function emit(input: string, output: string, options: EmitOptions): Promise<TimingAggregator>;
+
+export { type EmitOptions, emit };

package/dist/emit/emit.js

@@ -0,0 +1,86 @@
+import "../chunk-BIEQXUOY.js";
+import { mkdir, readFile, readdir } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { enumerate } from "itertools";
+import {
+  createAggregator,
+  emit as emitFile,
+  formatSingleReport
+} from "@storyteller-platform/ghost-story";
+import { MediaType } from "@storyteller-platform/media-types";
+import { writeEmissionsFile } from "./fs.js";
+async function emit(input, output, options) {
+  const controller = new AbortController();
+  const signal = AbortSignal.any([
+    ...options.signal ? [options.signal] : [],
+    controller.signal
+  ]);
+  await mkdir(output, { recursive: true });
+  const allFiles = await readdir(input, { recursive: true });
+  const filenames = allFiles.toSorted().filter((f) => MediaType.fromPath(f)?.kind === "audio");
+  if (!filenames.length) {
+    throw new Error(
+      `Failed to transcribe audio: found no audio files in ${input}`
+    );
+  }
+  const engine = "wav2vec2";
+  const model = options.model ?? "onnx-community/mms-300m-1130-forced-aligner-ONNX";
+  const emissions = [];
+  function aborted() {
+    return signal.aborted;
+  }
+  const timing = createAggregator();
+  timing.setMetadata("engine", engine);
+  timing.setMetadata("model", model);
+  for (const [i, filename] of enumerate(filenames)) {
+    let onFileProgress2 = function(progress) {
+      const updatedProgress = (i + progress) / filenames.length;
+      options.logger?.info(`Progress: ${Math.floor(updatedProgress * 100)}%`);
+      options.onProgress?.(updatedProgress);
+    };
+    var onFileProgress = onFileProgress2;
+    if (aborted()) throw new Error("Aborted");
+    const filepath = join(input, filename);
+    const emissionFilepath = join(
+      output,
+      `${basename(filename, extname(filename))}.json`
+    );
+    try {
+      await readFile(emissionFilepath, {
+        encoding: "utf-8",
+        signal
+      });
+      options.logger?.info(`Found existing transcription for ${filepath}`);
+      emissions.push(emissionFilepath);
+      options.onProgress?.((emissions.length + 1) / filenames.length);
+      continue;
+    } catch {
+    }
+    if (aborted()) throw new Error("Aborted");
+    const result = await emitFile(filepath, {
+      ...options,
+      signal,
+      engine,
+      options: {
+        model,
+        ...options.device && { device: options.device },
+        ...options.dtype && { dtype: options.dtype },
+        onProgress: onFileProgress2
+      }
+    });
+    options.logger?.info(
+      formatSingleReport(
+        result.timing,
+        `Transcription Timing Report for ${filepath}`
+      )
+    );
+    timing.add(result.timing);
+    await writeEmissionsFile(emissionFilepath, result, { signal });
+    emissions.push(emissionFilepath);
+    options.onProgress?.((i + 1) / filenames.length);
+  }
+  return timing;
+}
+export {
+  emit
+};

package/dist/emit/fs.cjs

@@ -0,0 +1,227 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var fs_exports = {};
+__export(fs_exports, {
+  EmissionsReader: () => EmissionsReader,
+  readEmissionsFile: () => readEmissionsFile,
+  readEmissionsFileHead: () => readEmissionsFileHead,
+  writeEmissionsFile: () => writeEmissionsFile
+});
+module.exports = __toCommonJS(fs_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_ghost_story = require("@storyteller-platform/ghost-story");
+async function writeEmissionsFile(path, data, options = {}) {
+  const encoded = (0, import_ghost_story.encodeEmissions)(data);
+  await (0, import_promises.writeFile)(path, encoded, options);
+}
+async function readEmissionsFile(path, framesFrom, framesTo) {
+  var _stack = [];
+  try {
+    const file = __using(_stack, await (0, import_promises.open)(path, "r"), true);
+    async function getBytes(bytesFrom, bytesTo) {
+      const length = bytesTo - bytesFrom;
+      const buffer = new Uint8Array(length);
+      let read = 0;
+      while (read < length) {
+        const { bytesRead } = await file.read(
+          buffer,
+          read,
+          length - read,
+          bytesFrom + read
+        );
+        if (bytesRead === 0) break;
+        read += bytesRead;
+      }
+      return buffer;
+    }
+    return await (0, import_ghost_story.decodeEmissions)(getBytes, framesFrom, framesTo);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
+  }
+}
+async function readEmissionsFileHead(path) {
+  return await readEmissionsFile(path, 0, 0);
+}
+async function packJsonEmissionsFile(path) {
+  const directory = (0, import_node_path.dirname)(path);
+  const filebase = (0, import_node_path.basename)(path, (0, import_node_path.extname)(path));
+  const emissionsName = (0, import_node_path.join)(directory, `${filebase}.emissions`);
+  const jsonData = await (0, import_promises.readFile)(path, { encoding: "utf-8" });
+  const parsed = JSON.parse(jsonData);
+  await writeEmissionsFile(emissionsName, {
+    ...parsed,
+    vocab: new Map(Object.entries(parsed.vocab)),
+    numFrames: parsed.emissions.length
+  });
+  await (0, import_promises.rm)(path);
+  return emissionsName;
+}
+class EmissionsReader {
+  constructor(numFrames = 0, frameMap, vocab, blankId, timings) {
+    this.numFrames = numFrames;
+    this.frameMap = frameMap;
+    this.vocab = vocab;
+    this.blankId = blankId;
+    this.timings = timings;
+  }
+  static async getFilepaths(fileOrDirectory) {
+    if ((0, import_node_path.extname)(fileOrDirectory) === ".emissions" || (0, import_node_path.extname)(fileOrDirectory) === ".json") {
+      return [fileOrDirectory];
+    }
+    const allFiles = await (0, import_promises.readdir)(fileOrDirectory, { recursive: true });
+    return allFiles.filter((f) => (0, import_node_path.extname)(f) === ".emissions" || (0, import_node_path.extname)(f) === ".json").toSorted().map((f) => (0, import_node_path.join)(fileOrDirectory, f));
+  }
+  static async from(fileOrDirectory) {
+    let vocab = null;
+    let blankId = null;
+    const timings = [];
+    const frameMap = [];
+    let numFrames = 0;
+    const emissionsFiles = await EmissionsReader.getFilepaths(fileOrDirectory);
+    let f = 0;
+    for (let path of emissionsFiles) {
+      if ((0, import_node_path.extname)(path) === ".json") {
+        path = await packJsonEmissionsFile(path);
+      }
+      const {
+        numFrames: numFrames2,
+        vocab: v,
+        blankIndex: b,
+        emissions: _,
+        ...emissionTimings
+      } = await readEmissionsFileHead(path);
+      vocab ??= v;
+      blankId ??= b;
+      timings.push(emissionTimings);
+      frameMap.push([path, f, f + numFrames2]);
+      f += numFrames2;
+    }
+    numFrames = f;
+    if (vocab === null || blankId === null) {
+      throw new Error("Failed to initialize EmissionsReader");
+    }
+    const reader = new EmissionsReader(
+      numFrames,
+      frameMap,
+      vocab,
+      blankId,
+      timings
+    );
+    return reader;
+  }
+  async *frames() {
+    let fileIndex = 0;
+    let chunkFrom = 0;
+    let frameIndex = 0;
+    while (frameIndex < this.numFrames) {
+      const [path, framesStart, framesEnd] = this.frameMap[fileIndex];
+      const chunkTo = Math.min(chunkFrom + 1e3, framesEnd - framesStart);
+      const { emissions: chunk } = await readEmissionsFile(
+        path,
+        chunkFrom,
+        chunkTo
+      );
+      for (const e of chunk) {
+        yield e;
+      }
+      frameIndex += chunkTo - chunkFrom;
+      if (chunkTo < chunkFrom + 1e3) {
+        fileIndex++;
+        chunkFrom = 0;
+      } else {
+        chunkFrom += 1e3;
+      }
+    }
+  }
+  async readFrames(framesFrom, framesTo) {
+    const startFile = this.frameMap.findIndex(([, , end]) => end > framesFrom);
+    if (startFile === -1) return [];
+    let endFile = this.frameMap.findLastIndex(([, start]) => start < framesTo);
+    if (endFile === -1) endFile = this.frameMap.length - 1;
+    const frames = [];
+    for (let i = startFile; i <= endFile; i++) {
+      const [path, from, to] = this.frameMap[i];
+      const { emissions } = await readEmissionsFile(
+        path,
+        Math.max(framesFrom, from) - from,
+        Math.min(to, framesTo) - from
+      );
+      for (const e of emissions) {
+        frames.push(e);
+      }
+    }
+    return frames;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmissionsReader,
+  readEmissionsFile,
+  readEmissionsFileHead,
+  writeEmissionsFile
+});

package/dist/emit/fs.d.cts

@@ -0,0 +1,22 @@
+import { EmissionData } from '@storyteller-platform/ghost-story';
+import { EmissionTimings } from '../align/ctc/emissions.cjs';
+
+declare function writeEmissionsFile(path: string, data: EmissionData, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+declare function readEmissionsFile(path: string, framesFrom?: number, framesTo?: number): Promise<EmissionData>;
+declare function readEmissionsFileHead(path: string): Promise<EmissionData>;
+declare class EmissionsReader {
+    numFrames: number;
+    frameMap: [string, number, number][];
+    vocab: Map<string, number>;
+    blankId: number;
+    timings: EmissionTimings[];
+    private constructor();
+    private static getFilepaths;
+    static from(fileOrDirectory: string): Promise<EmissionsReader>;
+    frames(): AsyncGenerator<number[], void, unknown>;
+    readFrames(framesFrom: number, framesTo: number): Promise<number[][]>;
+}
+
+export { EmissionsReader, readEmissionsFile, readEmissionsFileHead, writeEmissionsFile };

package/dist/emit/fs.d.ts

@@ -0,0 +1,22 @@
+import { EmissionData } from '@storyteller-platform/ghost-story';
+import { EmissionTimings } from '../align/ctc/emissions.js';
+
+declare function writeEmissionsFile(path: string, data: EmissionData, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+declare function readEmissionsFile(path: string, framesFrom?: number, framesTo?: number): Promise<EmissionData>;
+declare function readEmissionsFileHead(path: string): Promise<EmissionData>;
+declare class EmissionsReader {
+    numFrames: number;
+    frameMap: [string, number, number][];
+    vocab: Map<string, number>;
+    blankId: number;
+    timings: EmissionTimings[];
+    private constructor();
+    private static getFilepaths;
+    static from(fileOrDirectory: string): Promise<EmissionsReader>;
+    frames(): AsyncGenerator<number[], void, unknown>;
+    readFrames(framesFrom: number, framesTo: number): Promise<number[][]>;
+}
+
+export { EmissionsReader, readEmissionsFile, readEmissionsFileHead, writeEmissionsFile };

package/dist/emit/fs.js

@@ -0,0 +1,162 @@
+import {
+  __callDispose,
+  __using
+} from "../chunk-BIEQXUOY.js";
+import { open, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import {
+  decodeEmissions,
+  encodeEmissions
+} from "@storyteller-platform/ghost-story";
+async function writeEmissionsFile(path, data, options = {}) {
+  const encoded = encodeEmissions(data);
+  await writeFile(path, encoded, options);
+}
+async function readEmissionsFile(path, framesFrom, framesTo) {
+  var _stack = [];
+  try {
+    const file = __using(_stack, await open(path, "r"), true);
+    async function getBytes(bytesFrom, bytesTo) {
+      const length = bytesTo - bytesFrom;
+      const buffer = new Uint8Array(length);
+      let read = 0;
+      while (read < length) {
+        const { bytesRead } = await file.read(
+          buffer,
+          read,
+          length - read,
+          bytesFrom + read
+        );
+        if (bytesRead === 0) break;
+        read += bytesRead;
+      }
+      return buffer;
+    }
+    return await decodeEmissions(getBytes, framesFrom, framesTo);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
+  }
+}
+async function readEmissionsFileHead(path) {
+  return await readEmissionsFile(path, 0, 0);
+}
+async function packJsonEmissionsFile(path) {
+  const directory = dirname(path);
+  const filebase = basename(path, extname(path));
+  const emissionsName = join(directory, `${filebase}.emissions`);
+  const jsonData = await readFile(path, { encoding: "utf-8" });
+  const parsed = JSON.parse(jsonData);
+  await writeEmissionsFile(emissionsName, {
+    ...parsed,
+    vocab: new Map(Object.entries(parsed.vocab)),
+    numFrames: parsed.emissions.length
+  });
+  await rm(path);
+  return emissionsName;
+}
+class EmissionsReader {
+  constructor(numFrames = 0, frameMap, vocab, blankId, timings) {
+    this.numFrames = numFrames;
+    this.frameMap = frameMap;
+    this.vocab = vocab;
+    this.blankId = blankId;
+    this.timings = timings;
+  }
+  static async getFilepaths(fileOrDirectory) {
+    if (extname(fileOrDirectory) === ".emissions" || extname(fileOrDirectory) === ".json") {
+      return [fileOrDirectory];
+    }
+    const allFiles = await readdir(fileOrDirectory, { recursive: true });
+    return allFiles.filter((f) => extname(f) === ".emissions" || extname(f) === ".json").toSorted().map((f) => join(fileOrDirectory, f));
+  }
+  static async from(fileOrDirectory) {
+    let vocab = null;
+    let blankId = null;
+    const timings = [];
+    const frameMap = [];
+    let numFrames = 0;
+    const emissionsFiles = await EmissionsReader.getFilepaths(fileOrDirectory);
+    let f = 0;
+    for (let path of emissionsFiles) {
+      if (extname(path) === ".json") {
+        path = await packJsonEmissionsFile(path);
+      }
+      const {
+        numFrames: numFrames2,
+        vocab: v,
+        blankIndex: b,
+        emissions: _,
+        ...emissionTimings
+      } = await readEmissionsFileHead(path);
+      vocab ??= v;
+      blankId ??= b;
+      timings.push(emissionTimings);
+      frameMap.push([path, f, f + numFrames2]);
+      f += numFrames2;
+    }
+    numFrames = f;
+    if (vocab === null || blankId === null) {
+      throw new Error("Failed to initialize EmissionsReader");
+    }
+    const reader = new EmissionsReader(
+      numFrames,
+      frameMap,
+      vocab,
+      blankId,
+      timings
+    );
+    return reader;
+  }
+  async *frames() {
+    let fileIndex = 0;
+    let chunkFrom = 0;
+    let frameIndex = 0;
+    while (frameIndex < this.numFrames) {
+      const [path, framesStart, framesEnd] = this.frameMap[fileIndex];
+      const chunkTo = Math.min(chunkFrom + 1e3, framesEnd - framesStart);
+      const { emissions: chunk } = await readEmissionsFile(
+        path,
+        chunkFrom,
+        chunkTo
+      );
+      for (const e of chunk) {
+        yield e;
+      }
+      frameIndex += chunkTo - chunkFrom;
+      if (chunkTo < chunkFrom + 1e3) {
+        fileIndex++;
+        chunkFrom = 0;
+      } else {
+        chunkFrom += 1e3;
+      }
+    }
+  }
+  async readFrames(framesFrom, framesTo) {
+    const startFile = this.frameMap.findIndex(([, , end]) => end > framesFrom);
+    if (startFile === -1) return [];
+    let endFile = this.frameMap.findLastIndex(([, start]) => start < framesTo);
+    if (endFile === -1) endFile = this.frameMap.length - 1;
+    const frames = [];
+    for (let i = startFile; i <= endFile; i++) {
+      const [path, from, to] = this.frameMap[i];
+      const { emissions } = await readEmissionsFile(
+        path,
+        Math.max(framesFrom, from) - from,
+        Math.min(to, framesTo) - from
+      );
+      for (const e of emissions) {
+        frames.push(e);
+      }
+    }
+    return frames;
+  }
+}
+export {
+  EmissionsReader,
+  readEmissionsFile,
+  readEmissionsFileHead,
+  writeEmissionsFile
+};