@internetarchive/radio-player 0.0.4-alpha.1 → 0.1.1-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-index.d.ts

@@ -0,0 +1,53 @@
+import { TranscriptConfig } from '@internetarchive/transcript-view';
+import { Range, TranscriptEntryRange } from './search-models';
+export declare class SearchIndex {
+    /**
+     * Make these properties readonly. We don't want outside classes touching the private storage.
+     *
+     * @readonly
+     * @type {string}
+     * @memberof SearchIndex
+     */
+    get mergedTranscript(): string;
+    get transcriptEntryRanges(): TranscriptEntryRange[];
+    /**
+     * This gets populated as part of the search index build. It merges all of the transcript
+     * entries together so we can search it as a single document instead of a bunch of
+     * individual entries. This allows searches to cross over transcript entries.
+     *
+     * It also indexes the entries so we can quickly look them up later.
+     *
+     * @private
+     * @memberof SearchIndex
+     */
+    private searchIndexCache;
+    /**
+     * Find the closes TranscriptEntryRange to the given overallCharIndex
+     *
+     * @param overallCharIndex
+     * @returns {TranscriptEntryRange | undefined}
+     */
+    getTranscriptEntryAt(overallCharIndex: number): TranscriptEntryRange | undefined;
+    /**
+     * Finds all of the ranges of all the search results across the entire transcript.
+     *
+     * @private
+     * @param {string} term
+     * @returns {Range[]}
+     * @memberof SearchIndex
+     */
+    getSearchRanges(term: string): Range[];
+    constructor(transcriptConfig: TranscriptConfig);
+    /**
+     * Build the search index. This method does two things:
+     * 1. Builds the "merged transcript" with all of the text combined into one long transcript.
+     *    This allows us to search the entire thing at once instead of entry by entry.
+     * 2. For each entry, get the start and end index of that particular entry within the overall
+     *    transcript. This allows us to reconstruct the transcript later from the original transcript
+     *    and the search results.
+     *
+     * @private
+     * @memberof SearchHandler
+     */
+    private buildIndex;
+}

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

@@ -0,0 +1,118 @@
+import { Range, TranscriptEntryRange } from './search-models';
+class SearchIndexCache {
+    constructor(mergedTranscript = '', transcriptEntryRanges = []) {
+        /**
+         * This gets populated as part of the search index build. It merges all of the transcript
+         * entries together so we can search it as a single document instead of a bunch of
+         * individual entries. This allows searches to cross over transcript entries.
+         *
+         * NOTE: When the mergedTranscript gets created, spaces are put between each transcript
+         * entry, otherwise the words would run into each other. We account for this in the
+         * indices above.
+         *
+         * @type {string}
+         * @memberof SearchIndexCache
+         */
+        this.mergedTranscript = '';
+        this.mergedTranscriptLowercased = '';
+        /**
+         * This gets populated as part of the search index build. It maps the start and end indicies
+         * of all of the transcript entries so we can quickly look up where an entry is in the
+         * overall transcript.
+         *
+         * @type {TranscriptEntryRange[]}
+         * @memberof SearchIndexCache
+         */
+        this.transcriptEntryRanges = [];
+        this.mergedTranscript = mergedTranscript;
+        this.transcriptEntryRanges = transcriptEntryRanges;
+        this.mergedTranscriptLowercased = mergedTranscript.toLowerCase();
+    }
+}
+export class SearchIndex {
+    constructor(transcriptConfig) {
+        /**
+         * This gets populated as part of the search index build. It merges all of the transcript
+         * entries together so we can search it as a single document instead of a bunch of
+         * individual entries. This allows searches to cross over transcript entries.
+         *
+         * It also indexes the entries so we can quickly look them up later.
+         *
+         * @private
+         * @memberof SearchIndex
+         */
+        this.searchIndexCache = new SearchIndexCache();
+        this.buildIndex(transcriptConfig);
+    }
+    /**
+     * Make these properties readonly. We don't want outside classes touching the private storage.
+     *
+     * @readonly
+     * @type {string}
+     * @memberof SearchIndex
+     */
+    get mergedTranscript() {
+        return this.searchIndexCache.mergedTranscript;
+    }
+    get transcriptEntryRanges() {
+        return this.searchIndexCache.transcriptEntryRanges;
+    }
+    /**
+     * Find the closes TranscriptEntryRange to the given overallCharIndex
+     *
+     * @param overallCharIndex
+     * @returns {TranscriptEntryRange | undefined}
+     */
+    getTranscriptEntryAt(overallCharIndex) {
+        return this.searchIndexCache.transcriptEntryRanges.find(entry => {
+            const { range } = entry;
+            return range.endIndex > overallCharIndex && range.startIndex <= overallCharIndex;
+        });
+    }
+    /**
+     * Finds all of the ranges of all the search results across the entire transcript.
+     *
+     * @private
+     * @param {string} term
+     * @returns {Range[]}
+     * @memberof SearchIndex
+     */
+    getSearchRanges(term) {
+        const ranges = [];
+        const termLowerCased = term.toLowerCase();
+        let index = -1;
+        /* eslint-disable-next-line no-cond-assign */
+        while ((index = this.searchIndexCache.mergedTranscriptLowercased.indexOf(termLowerCased, index + 1)) !== -1) {
+            const newRange = new Range(index, index + termLowerCased.length);
+            ranges.push(newRange);
+        }
+        return ranges;
+    }
+    /**
+     * Build the search index. This method does two things:
+     * 1. Builds the "merged transcript" with all of the text combined into one long transcript.
+     *    This allows us to search the entire thing at once instead of entry by entry.
+     * 2. For each entry, get the start and end index of that particular entry within the overall
+     *    transcript. This allows us to reconstruct the transcript later from the original transcript
+     *    and the search results.
+     *
+     * @private
+     * @memberof SearchHandler
+     */
+    buildIndex(transcriptConfig) {
+        let startIndex = 0;
+        const transcriptEntryRanges = [];
+        let mergedTranscript = '';
+        transcriptConfig.entries.forEach((entry) => {
+            const { displayText } = entry;
+            const indexMapRange = new Range(startIndex, startIndex + displayText.length);
+            const indexMap = new TranscriptEntryRange(entry, indexMapRange);
+            transcriptEntryRanges.push(indexMap);
+            mergedTranscript += `${entry.displayText} `;
+            startIndex = mergedTranscript.length;
+        });
+        mergedTranscript = mergedTranscript.trim();
+        this.searchIndexCache = new SearchIndexCache(mergedTranscript, transcriptEntryRanges);
+    }
+}
+//# sourceMappingURL=search-index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search-index.js","sourceRoot":"","sources":["../../../src/search-handler/search-index.ts"],"names":[],"mappings":"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"}