@internetarchive/radio-player 0.0.3 → 0.0.4-alpha.1

package/lib/src/search-handler/search-handler.js

@@ -1,178 +1,178 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { TranscriptConfig, TranscriptEntryConfig } from '@internetarchive/transcript-view';
-import { Range, SearchResult } from './search-models';
-import { SearchHelper } from './search-helper';
-/**
- * This is the main entrypoint into transcript searching. It has a single
- * public method as defined by `SearchHandlerInterface`: `search(term: string)`,
- * that returns a `Promise<TranscriptConfig>` with a search-modified transcript.
- * This means the original transcript entries get merged with search results since
- * search results can span across transcript entries.
- *
- * It offloads the searching work to a `SearchBackendInterface` object that
- * is responsible for returning the search result `Range` objects based on some
- * backend search like the `LocalSearchBackend` or `FullTextSearchBackend`.
- *
- * It also uses a `TranscriptIndexInterface` object that is responsible for indexing
- * the transcipt to make reassembly much more efficient.
- */
-export class SearchHandler {
-    constructor(searchBackend, transcriptIndex) {
-        this.searchBackend = searchBackend;
-        this.transcriptIndex = transcriptIndex;
-    }
-    /**
-     * This is the main method in here. It takes a search term and returns a TranscriptConfig
-     * that has been modified to insert the search results.
-     *
-     * @param {string} query
-     * @returns {TranscriptConfig}
-     * @memberof SearchHandler
-     */
-    search(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const searchSeparatedTranscript = yield this.getSearchSeparatedTranscript(query);
-            const newTranscriptEntries = [];
-            let searchResultIndex = 0;
-            let entryIdentifier = 1;
-            searchSeparatedTranscript.forEach((entry) => {
-                // If we encounter a match, just create a new transcript entry from it and append it.
-                // We don't care if it crosses over multiple transcript entries since we want one match,
-                // not multiple broken up by transcript entry.
-                if (entry.isSearchMatch) {
-                    // find the closest source transcript to this entry
-                    const startEntry = this.transcriptIndex.getTranscriptEntryAt(entry.range.startIndex);
-                    if (!startEntry) {
-                        return;
-                    }
-                    const { range } = entry;
-                    const { endIndex } = range;
-                    const endEntry = this.transcriptIndex.getTranscriptEntryAt(endIndex) || startEntry;
-                    const newTranscriptEntry = this.createBlankTranscriptEntryConfig(startEntry.entry);
-                    newTranscriptEntry.searchMatchIndex = searchResultIndex;
-                    searchResultIndex += 1;
-                    newTranscriptEntry.rawText = entry.text;
-                    newTranscriptEntry.id = entryIdentifier;
-                    entryIdentifier += 1;
-                    newTranscriptEntry.end = endEntry.entry.end;
-                    newTranscriptEntries.push(newTranscriptEntry);
-                    return;
-                }
-                // Next loop through all of the source transcript entries to find the ones that intersect
-                // with this search result. If it intersects, we take the intersected characters from the
-                // merged transcript and make a new entry from that.
-                this.transcriptIndex.transcriptEntryRanges.forEach((indexMap) => {
-                    const intersection = SearchHelper.getIntersection(entry.range, indexMap.range);
-                    if (!intersection || intersection.length === 0) {
-                        return;
-                    }
-                    const newTranscriptEntry = this.createBlankTranscriptEntryConfig(indexMap.entry);
-                    const text = this.transcriptIndex.mergedTranscript.substring(intersection.startIndex, intersection.endIndex);
-                    newTranscriptEntry.rawText = text.trim();
-                    newTranscriptEntry.id = entryIdentifier;
-                    entryIdentifier += 1;
-                    newTranscriptEntries.push(newTranscriptEntry);
-                });
-            });
-            const newTranscript = new TranscriptConfig(newTranscriptEntries);
-            return new Promise(resolve => resolve(newTranscript));
-        });
-    }
-    /**
-     * Copy a transcript entry but leave the text and search result index empty.
-     *
-     * @private
-     * @param {TranscriptEntryConfig} sourceTranscriptConfig
-     * @returns {TranscriptEntryConfig}
-     * @memberof SearchHandler
-     */
-    /* eslint-disable-next-line class-methods-use-this */
-    createBlankTranscriptEntryConfig(sourceTranscriptConfig) {
-        return new TranscriptEntryConfig(sourceTranscriptConfig.id, sourceTranscriptConfig.start, sourceTranscriptConfig.end, '', sourceTranscriptConfig.isMusic);
-    }
-    /**
-     * Search the full transcript and split up by search results and non-results. For instance,
-     * if the full transcript is `foo bar baz boop bump snap pop` and you search for `bump`,
-     * you'll get an array of 3 results back:
-     * 1. `foo bar baz boop `
-     * 2. `bump` <-- the match
-     * 3. ` snap pop`
-     *
-     * This is helpful when rebuilding the transcript later to be able to identify search results.
-     *
-     * @private
-     * @param {string} query
-     * @returns {SearchResult[]}
-     * @memberof SearchHandler
-     */
-    getSearchSeparatedTranscript(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const searchRanges = yield this.searchBackend.getSearchRanges(query);
-            const { mergedTranscript } = this.transcriptIndex;
-            // if there's no search results, just return a single SearchResult that is the full
-            // transcript marked as not a match.
-            if (searchRanges.length === 0) {
-                const range = new Range(0, mergedTranscript.length);
-                return new Promise(resolve => resolve([new SearchResult(range, mergedTranscript, false)]));
-            }
-            // Sort the search range results from start to end
-            // The search engine may return results in any order but while processing the results here,
-            // we are going from start to finish. If the search results are out of order, it rebuilds
-            // incorrect blocks of search results.
-            searchRanges.sort((a, b) => (a.startIndex - b.startIndex));
-            const transcriptEntries = [];
-            let startIndex = 0;
-            // Loop through all of the search result ranges and construct an array
-            // of SearchResult entries.
-            // For instance, if the full transcript is `foo bar baz boop bump snip snap`
-            // and you search for `baz`, we'll only have a single search range: Range(8, 11).
-            // We then take the text leading up to that range and store it as the "non result"
-            // so we now have Range(0, 7) and Range(8, 11).
-            // If there were more search results, we would continue from index 12 to build
-            // the next range to the next match.
-            // Finally once all the matches are finished, tack on the remaining text to the end.
-            searchRanges.forEach((searchRange) => {
-                // first find the "non-result" range, which is the current `startIndex` up to
-                // `range.startIndex` (the start of the search result)
-                const nonResultRange = new Range(startIndex, searchRange.startIndex);
-                const nonResultEntry = this.getSearchResult(nonResultRange, false);
-                transcriptEntries.push(nonResultEntry);
-                // get the search result match from the merged transcript
-                // using the current search range
-                const searchResultEntry = this.getSearchResult(searchRange, true);
-                transcriptEntries.push(searchResultEntry);
-                startIndex = searchRange.endIndex;
-            });
-            // add any remaining characters as the last final entry in the results
-            const finalResultRange = new Range(startIndex, mergedTranscript.length);
-            const finalResultEntry = this.getSearchResult(finalResultRange, false);
-            transcriptEntries.push(finalResultEntry);
-            return new Promise(resolve => resolve(transcriptEntries));
-        });
-    }
-    /**
-     * Generate a SearchResult entry from a given Range and annotate it
-     * with whether or not it is a search result match
-     *
-     * @private
-     * @param {Range} range
-     * @param {boolean} isSearchResult
-     * @returns {SearchResult}
-     * @memberof SearchHandler
-     */
-    getSearchResult(range, isSearchResult) {
-        const { mergedTranscript } = this.transcriptIndex;
-        const text = mergedTranscript.substring(range.startIndex, range.endIndex);
-        const searchResult = new SearchResult(range, text, isSearchResult);
-        return searchResult;
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { TranscriptConfig, TranscriptEntryConfig } from '@internetarchive/transcript-view';
+import { Range, SearchResult } from './search-models';
+import { SearchHelper } from './search-helper';
+/**
+ * This is the main entrypoint into transcript searching. It has a single
+ * public method as defined by `SearchHandlerInterface`: `search(term: string)`,
+ * that returns a `Promise<TranscriptConfig>` with a search-modified transcript.
+ * This means the original transcript entries get merged with search results since
+ * search results can span across transcript entries.
+ *
+ * It offloads the searching work to a `SearchBackendInterface` object that
+ * is responsible for returning the search result `Range` objects based on some
+ * backend search like the `LocalSearchBackend` or `FullTextSearchBackend`.
+ *
+ * It also uses a `TranscriptIndexInterface` object that is responsible for indexing
+ * the transcipt to make reassembly much more efficient.
+ */
+export class SearchHandler {
+    constructor(searchBackend, transcriptIndex) {
+        this.searchBackend = searchBackend;
+        this.transcriptIndex = transcriptIndex;
+    }
+    /**
+     * This is the main method in here. It takes a search term and returns a TranscriptConfig
+     * that has been modified to insert the search results.
+     *
+     * @param {string} query
+     * @returns {TranscriptConfig}
+     * @memberof SearchHandler
+     */
+    search(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchSeparatedTranscript = yield this.getSearchSeparatedTranscript(query);
+            const newTranscriptEntries = [];
+            let searchResultIndex = 0;
+            let entryIdentifier = 1;
+            searchSeparatedTranscript.forEach((entry) => {
+                // If we encounter a match, just create a new transcript entry from it and append it.
+                // We don't care if it crosses over multiple transcript entries since we want one match,
+                // not multiple broken up by transcript entry.
+                if (entry.isSearchMatch) {
+                    // find the closest source transcript to this entry
+                    const startEntry = this.transcriptIndex.getTranscriptEntryAt(entry.range.startIndex);
+                    if (!startEntry) {
+                        return;
+                    }
+                    const { range } = entry;
+                    const { endIndex } = range;
+                    const endEntry = this.transcriptIndex.getTranscriptEntryAt(endIndex) || startEntry;
+                    const newTranscriptEntry = this.createBlankTranscriptEntryConfig(startEntry.entry);
+                    newTranscriptEntry.searchMatchIndex = searchResultIndex;
+                    searchResultIndex += 1;
+                    newTranscriptEntry.rawText = entry.text;
+                    newTranscriptEntry.id = entryIdentifier;
+                    entryIdentifier += 1;
+                    newTranscriptEntry.end = endEntry.entry.end;
+                    newTranscriptEntries.push(newTranscriptEntry);
+                    return;
+                }
+                // Next loop through all of the source transcript entries to find the ones that intersect
+                // with this search result. If it intersects, we take the intersected characters from the
+                // merged transcript and make a new entry from that.
+                this.transcriptIndex.transcriptEntryRanges.forEach((indexMap) => {
+                    const intersection = SearchHelper.getIntersection(entry.range, indexMap.range);
+                    if (!intersection || intersection.length === 0) {
+                        return;
+                    }
+                    const newTranscriptEntry = this.createBlankTranscriptEntryConfig(indexMap.entry);
+                    const text = this.transcriptIndex.mergedTranscript.substring(intersection.startIndex, intersection.endIndex);
+                    newTranscriptEntry.rawText = text.trim();
+                    newTranscriptEntry.id = entryIdentifier;
+                    entryIdentifier += 1;
+                    newTranscriptEntries.push(newTranscriptEntry);
+                });
+            });
+            const newTranscript = new TranscriptConfig(newTranscriptEntries);
+            return new Promise(resolve => resolve(newTranscript));
+        });
+    }
+    /**
+     * Copy a transcript entry but leave the text and search result index empty.
+     *
+     * @private
+     * @param {TranscriptEntryConfig} sourceTranscriptConfig
+     * @returns {TranscriptEntryConfig}
+     * @memberof SearchHandler
+     */
+    /* eslint-disable-next-line class-methods-use-this */
+    createBlankTranscriptEntryConfig(sourceTranscriptConfig) {
+        return new TranscriptEntryConfig(sourceTranscriptConfig.id, sourceTranscriptConfig.start, sourceTranscriptConfig.end, '', sourceTranscriptConfig.isMusic);
+    }
+    /**
+     * Search the full transcript and split up by search results and non-results. For instance,
+     * if the full transcript is `foo bar baz boop bump snap pop` and you search for `bump`,
+     * you'll get an array of 3 results back:
+     * 1. `foo bar baz boop `
+     * 2. `bump` <-- the match
+     * 3. ` snap pop`
+     *
+     * This is helpful when rebuilding the transcript later to be able to identify search results.
+     *
+     * @private
+     * @param {string} query
+     * @returns {SearchResult[]}
+     * @memberof SearchHandler
+     */
+    getSearchSeparatedTranscript(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchRanges = yield this.searchBackend.getSearchRanges(query);
+            const { mergedTranscript } = this.transcriptIndex;
+            // if there's no search results, just return a single SearchResult that is the full
+            // transcript marked as not a match.
+            if (searchRanges.length === 0) {
+                const range = new Range(0, mergedTranscript.length);
+                return new Promise(resolve => resolve([new SearchResult(range, mergedTranscript, false)]));
+            }
+            // Sort the search range results from start to end
+            // The search engine may return results in any order but while processing the results here,
+            // we are going from start to finish. If the search results are out of order, it rebuilds
+            // incorrect blocks of search results.
+            searchRanges.sort((a, b) => (a.startIndex - b.startIndex));
+            const transcriptEntries = [];
+            let startIndex = 0;
+            // Loop through all of the search result ranges and construct an array
+            // of SearchResult entries.
+            // For instance, if the full transcript is `foo bar baz boop bump snip snap`
+            // and you search for `baz`, we'll only have a single search range: Range(8, 11).
+            // We then take the text leading up to that range and store it as the "non result"
+            // so we now have Range(0, 7) and Range(8, 11).
+            // If there were more search results, we would continue from index 12 to build
+            // the next range to the next match.
+            // Finally once all the matches are finished, tack on the remaining text to the end.
+            searchRanges.forEach((searchRange) => {
+                // first find the "non-result" range, which is the current `startIndex` up to
+                // `range.startIndex` (the start of the search result)
+                const nonResultRange = new Range(startIndex, searchRange.startIndex);
+                const nonResultEntry = this.getSearchResult(nonResultRange, false);
+                transcriptEntries.push(nonResultEntry);
+                // get the search result match from the merged transcript
+                // using the current search range
+                const searchResultEntry = this.getSearchResult(searchRange, true);
+                transcriptEntries.push(searchResultEntry);
+                startIndex = searchRange.endIndex;
+            });
+            // add any remaining characters as the last final entry in the results
+            const finalResultRange = new Range(startIndex, mergedTranscript.length);
+            const finalResultEntry = this.getSearchResult(finalResultRange, false);
+            transcriptEntries.push(finalResultEntry);
+            return new Promise(resolve => resolve(transcriptEntries));
+        });
+    }
+    /**
+     * Generate a SearchResult entry from a given Range and annotate it
+     * with whether or not it is a search result match
+     *
+     * @private
+     * @param {Range} range
+     * @param {boolean} isSearchResult
+     * @returns {SearchResult}
+     * @memberof SearchHandler
+     */
+    getSearchResult(range, isSearchResult) {
+        const { mergedTranscript } = this.transcriptIndex;
+        const text = mergedTranscript.substring(range.startIndex, range.endIndex);
+        const searchResult = new SearchResult(range, text, isSearchResult);
+        return searchResult;
+    }
+}
 //# sourceMappingURL=search-handler.js.map

package/lib/src/search-handler/search-helper.d.ts

@@ -1,12 +1,12 @@
-import { Range } from './search-models';
-export declare class SearchHelper {
-    /**
-     * Get the intersection of two ranges and return a range or undefined if they do not intersect
-     *
-     * @param range1
-     * @param range2
-     *
-     * @returns Range|undefined
-     */
-    static getIntersection(range1: Range, range2: Range): Range | undefined;
-}
+import { Range } from './search-models';
+export declare class SearchHelper {
+    /**
+     * Get the intersection of two ranges and return a range or undefined if they do not intersect
+     *
+     * @param range1
+     * @param range2
+     *
+     * @returns Range|undefined
+     */
+    static getIntersection(range1: Range, range2: Range): Range | undefined;
+}

package/lib/src/search-handler/search-helper.js

@@ -1,23 +1,23 @@
-import { Range } from './search-models';
-export class SearchHelper {
-    /**
-     * Get the intersection of two ranges and return a range or undefined if they do not intersect
-     *
-     * @param range1
-     * @param range2
-     *
-     * @returns Range|undefined
-     */
-    static getIntersection(range1, range2) {
-        // get the range with the smaller starting point (min) and greater start (max)
-        const minRange = range1.startIndex < range2.startIndex ? range1 : range2;
-        const maxRange = minRange === range1 ? range2 : range1;
-        // min ends before max starts -> no intersection
-        if (minRange.endIndex < maxRange.startIndex) {
-            return undefined; // the ranges don't intersect
-        }
-        const endIndex = minRange.endIndex < maxRange.endIndex ? minRange.endIndex : maxRange.endIndex;
-        return new Range(maxRange.startIndex, endIndex);
-    }
-}
+import { Range } from './search-models';
+export class SearchHelper {
+    /**
+     * Get the intersection of two ranges and return a range or undefined if they do not intersect
+     *
+     * @param range1
+     * @param range2
+     *
+     * @returns Range|undefined
+     */
+    static getIntersection(range1, range2) {
+        // get the range with the smaller starting point (min) and greater start (max)
+        const minRange = range1.startIndex < range2.startIndex ? range1 : range2;
+        const maxRange = minRange === range1 ? range2 : range1;
+        // min ends before max starts -> no intersection
+        if (minRange.endIndex < maxRange.startIndex) {
+            return undefined; // the ranges don't intersect
+        }
+        const endIndex = minRange.endIndex < maxRange.endIndex ? minRange.endIndex : maxRange.endIndex;
+        return new Range(maxRange.startIndex, endIndex);
+    }
+}
 //# sourceMappingURL=search-helper.js.map

package/lib/src/search-handler/search-models.d.ts

@@ -1,45 +1,45 @@
-import { TranscriptEntryConfig } from '@internetarchive/transcript-view';
-/**
- * A model to store the start and end indices for a given context.
- * This is used for augmenting the source transcript entries (`TranscriptEntryRange`)
- * as well as the search result entries (`SearchResult`) below.
- *
- * @class Range
- */
-declare class Range {
-    startIndex: number;
-    endIndex: number;
-    get length(): number;
-    constructor(startIndex: number, endIndex: number);
-}
-/**
- * This class augments the transcript entry with the range of the characters
- * in the merged transcript. This is useful for more rapidly splitting up and
- * restoring the transcript entries from the transforms that happen during the search.
- *
- * @class TranscriptIndexMap
- */
-declare class TranscriptEntryRange {
-    entry: TranscriptEntryConfig;
-    range: Range;
-    constructor(entry: TranscriptEntryConfig, range: Range);
-}
-/**
- * The first step in converting the search results back to a usable transcript
- * is to break up the overall merged transcript into search results and non-search-results
- * sections. This will allow us to more easily break it up into its original transcript
- * chunks in a subsequent process.
- *
- * This class is a container to hold those chunks. They each have a start and end index
- * from their spot in the merged transcript, the text from that chunk, and whether that
- * chunk was a search match or just regular text.
- *
- * @class SearchSeparatedTranscriptEntry
- */
-declare class SearchResult {
-    range: Range;
-    text: string;
-    isSearchMatch: boolean;
-    constructor(range: Range, text: string, isSearchMatch: boolean);
-}
-export { Range, TranscriptEntryRange, SearchResult };
+import { TranscriptEntryConfig } from '@internetarchive/transcript-view';
+/**
+ * A model to store the start and end indices for a given context.
+ * This is used for augmenting the source transcript entries (`TranscriptEntryRange`)
+ * as well as the search result entries (`SearchResult`) below.
+ *
+ * @class Range
+ */
+declare class Range {
+    startIndex: number;
+    endIndex: number;
+    get length(): number;
+    constructor(startIndex: number, endIndex: number);
+}
+/**
+ * This class augments the transcript entry with the range of the characters
+ * in the merged transcript. This is useful for more rapidly splitting up and
+ * restoring the transcript entries from the transforms that happen during the search.
+ *
+ * @class TranscriptIndexMap
+ */
+declare class TranscriptEntryRange {
+    entry: TranscriptEntryConfig;
+    range: Range;
+    constructor(entry: TranscriptEntryConfig, range: Range);
+}
+/**
+ * The first step in converting the search results back to a usable transcript
+ * is to break up the overall merged transcript into search results and non-search-results
+ * sections. This will allow us to more easily break it up into its original transcript
+ * chunks in a subsequent process.
+ *
+ * This class is a container to hold those chunks. They each have a start and end index
+ * from their spot in the merged transcript, the text from that chunk, and whether that
+ * chunk was a search match or just regular text.
+ *
+ * @class SearchSeparatedTranscriptEntry
+ */
+declare class SearchResult {
+    range: Range;
+    text: string;
+    isSearchMatch: boolean;
+    constructor(range: Range, text: string, isSearchMatch: boolean);
+}
+export { Range, TranscriptEntryRange, SearchResult };

package/lib/src/search-handler/search-models.js

@@ -1,50 +1,50 @@
-/**
- * A model to store the start and end indices for a given context.
- * This is used for augmenting the source transcript entries (`TranscriptEntryRange`)
- * as well as the search result entries (`SearchResult`) below.
- *
- * @class Range
- */
-class Range {
-    constructor(startIndex, endIndex) {
-        this.startIndex = startIndex;
-        this.endIndex = endIndex;
-    }
-    get length() {
-        return Math.abs(this.endIndex - this.startIndex);
-    }
-}
-/**
- * This class augments the transcript entry with the range of the characters
- * in the merged transcript. This is useful for more rapidly splitting up and
- * restoring the transcript entries from the transforms that happen during the search.
- *
- * @class TranscriptIndexMap
- */
-class TranscriptEntryRange {
-    constructor(entry, range) {
-        this.entry = entry;
-        this.range = range;
-    }
-}
-/**
- * The first step in converting the search results back to a usable transcript
- * is to break up the overall merged transcript into search results and non-search-results
- * sections. This will allow us to more easily break it up into its original transcript
- * chunks in a subsequent process.
- *
- * This class is a container to hold those chunks. They each have a start and end index
- * from their spot in the merged transcript, the text from that chunk, and whether that
- * chunk was a search match or just regular text.
- *
- * @class SearchSeparatedTranscriptEntry
- */
-class SearchResult {
-    constructor(range, text, isSearchMatch) {
-        this.range = range;
-        this.text = text;
-        this.isSearchMatch = isSearchMatch;
-    }
-}
-export { Range, TranscriptEntryRange, SearchResult };
+/**
+ * A model to store the start and end indices for a given context.
+ * This is used for augmenting the source transcript entries (`TranscriptEntryRange`)
+ * as well as the search result entries (`SearchResult`) below.
+ *
+ * @class Range
+ */
+class Range {
+    constructor(startIndex, endIndex) {
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+    }
+    get length() {
+        return Math.abs(this.endIndex - this.startIndex);
+    }
+}
+/**
+ * This class augments the transcript entry with the range of the characters
+ * in the merged transcript. This is useful for more rapidly splitting up and
+ * restoring the transcript entries from the transforms that happen during the search.
+ *
+ * @class TranscriptIndexMap
+ */
+class TranscriptEntryRange {
+    constructor(entry, range) {
+        this.entry = entry;
+        this.range = range;
+    }
+}
+/**
+ * The first step in converting the search results back to a usable transcript
+ * is to break up the overall merged transcript into search results and non-search-results
+ * sections. This will allow us to more easily break it up into its original transcript
+ * chunks in a subsequent process.
+ *
+ * This class is a container to hold those chunks. They each have a start and end index
+ * from their spot in the merged transcript, the text from that chunk, and whether that
+ * chunk was a search match or just regular text.
+ *
+ * @class SearchSeparatedTranscriptEntry
+ */
+class SearchResult {
+    constructor(range, text, isSearchMatch) {
+        this.range = range;
+        this.text = text;
+        this.isSearchMatch = isSearchMatch;
+    }
+}
+export { Range, TranscriptEntryRange, SearchResult };
 //# sourceMappingURL=search-models.js.map