tor-browser

search-worker.js (11372B)

---

(function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
   factory();
})((function () { 'use strict';

   (function() {
       const env = {"NODE_ENV":"production"};
       try {
           if (process) {
               process.env = Object.assign({}, process.env);
               Object.assign(process.env, env);
               return;
           }
       } catch (e) {} // avoid ReferenceError: process is not defined
       globalThis.process = { env:env };
   })();

   /* This Source Code Form is subject to the terms of the Mozilla Public
    * License, v. 2.0. If a copy of the MPL was not distributed with this
    * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */

   function isNode() {
     try {
       return process.release.name == "node";
     } catch (e) {
       return false;
     }
   }

   function isNodeTest() {
     return isNode() && process.env.NODE_ENV != "production";
   }

   let assert;
   // TODO: try to enable these assertions on mochitest by also enabling it on:
   //   import flags from "devtools/shared/flags";
   //   if (flags.testing)
   // Unfortunately it throws a lot on mochitests...

   if (isNodeTest()) {
     assert = function (condition, message) {
       if (!condition) {
         throw new Error(`Assertion failure: ${message}`);
       }
     };
   } else {
     assert = function () {};
   }
   var assert$1 = assert;

   /* This Source Code Form is subject to the terms of the Mozilla Public
    * License, v. 2.0. If a copy of the MPL was not distributed with this
    * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */

   function escapeRegExp(str) {
     const reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
     return str.replace(reRegExpChar, "\\$&");
   }

   /**
    * Ignore doing outline matches for less than 3 whitespaces
    *
    * @memberof utils/source-search
    * @static
    */
   function ignoreWhiteSpace(str) {
     return /^\s{0,2}$/.test(str) ? "(?!\\s*.*)" : str;
   }

   function wholeMatch(query, wholeWord) {
     if (query === "" || !wholeWord) {
       return query;
     }

     return `\\b${query}\\b`;
   }

   function buildFlags(caseSensitive, isGlobal) {
     if (caseSensitive && isGlobal) {
       return "g";
     }

     if (!caseSensitive && isGlobal) {
       return "gi";
     }

     if (!caseSensitive && !isGlobal) {
       return "i";
     }

     return null;
   }

   function buildQuery(
     originalQuery,
     modifiers,
     { isGlobal = false, ignoreSpaces = false }
   ) {
     const { caseSensitive, regexMatch, wholeWord } = modifiers;

     if (originalQuery === "") {
       return new RegExp(originalQuery);
     }

     // Remove the backslashes at the end of the query as it
     // breaks the RegExp
     let query = originalQuery.replace(/\\$/, "");

     // If we don't want to do a regexMatch, we need to escape all regex related characters
     // so they would actually match.
     if (!regexMatch) {
       query = escapeRegExp(query);
     }

     // ignoreWhiteSpace might return a negative lookbehind, and in such case, we want it
     // to be consumed as a RegExp part by the callsite, so this needs to be called after
     // the regexp is escaped.
     if (ignoreSpaces) {
       query = ignoreWhiteSpace(query);
     }

     query = wholeMatch(query, wholeWord);
     const flags = buildFlags(caseSensitive, isGlobal);

     if (flags) {
       return new RegExp(query, flags);
     }

     return new RegExp(query);
   }

   function getMatches(query, text, options) {
     if (!query || !text || !options) {
       return [];
     }
     const regexQuery = buildQuery(query, options, {
       isGlobal: true,
     });
     const matchedLocations = [];
     const lines = text.split("\n");
     for (let i = 0; i < lines.length; i++) {
       let singleMatch;
       const line = lines[i];
       while ((singleMatch = regexQuery.exec(line)) !== null) {
         // Flow doesn't understand the test above.
         if (!singleMatch) {
           throw new Error("no singleMatch");
         }

         matchedLocations.push({
           line: i,
           ch: singleMatch.index,
           match: singleMatch[0],
         });

         // When the match is an empty string the regexQuery.lastIndex will not
         // change resulting in an infinite loop so we need to check for this and
         // increment it manually in that case.  See issue #7023
         if (singleMatch[0] === "") {
           assert$1(
             !regexQuery.unicode,
             "lastIndex++ can cause issues in unicode mode"
           );
           regexQuery.lastIndex++;
         }
       }
     }
     return matchedLocations;
   }

   function findSourceMatches(content, queryText, options) {
     if (queryText == "") {
       return [];
     }

     const text = content.value;
     const lines = text.split("\n");

     return getMatches(queryText, text, options).map(({ line, ch, match }) => {
       const { value, matchIndex } = truncateLine(lines[line], ch);
       return {
         line: line + 1,
         column: ch,

         matchIndex,
         match,
         value,
       };
     });
   }

   // This is used to find start of a word, so that cropped string look nice
   const startRegex = /([ !@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?])/g;
   // Similarly, find
   const endRegex = new RegExp(
     [
       "([ !@#$%^&*()_+-=[]{};':\"\\|,.<>/?])",
       '[^ !@#$%^&*()_+-=[]{};\':"\\|,.<>/?]*$"/',
     ].join("")
   );
   // For texts over 100 characters this truncates the text (for display)
   // around the context of the matched text.
   function truncateLine(text, column) {
     if (text.length < 100) {
       return {
         matchIndex: column,
         value: text,
       };
     }

     // Initially take 40 chars left to the match
     const offset = Math.max(column - 40, 0);
     // 400 characters should be enough to figure out the context of the match
     const truncStr = text.slice(offset, column + 400);
     let start = truncStr.search(startRegex);
     let end = truncStr.search(endRegex);

     if (start > column) {
       // No word separator found before the match, so we take all characters
       // before the match
       start = -1;
     }
     if (end < column) {
       end = truncStr.length;
     }
     const value = truncStr.slice(start + 1, end);

     return {
       matchIndex: column - start - offset - 1,
       value,
     };
   }

   var workerUtils = {exports: {}};

   var hasRequiredWorkerUtils;

   function requireWorkerUtils () {
   	if (hasRequiredWorkerUtils) return workerUtils.exports;
   	hasRequiredWorkerUtils = 1;
   	(function (module) {

   		class WorkerDispatcher {
   		  #msgId = 1;
   		  #worker = null;
   		  // Map of message ids -> promise resolution functions, for dispatching worker responses
   		  #pendingCalls = new Map();
   		  #url = "";

   		  constructor(url) {
   		    this.#url = url;
   		  }

   		  start() {
   		    // When running in debugger jest test, we don't have access to ChromeWorker
   		    if (typeof ChromeWorker == "function") {
   		      this.#worker = new ChromeWorker(this.#url);
   		    } else {
   		      this.#worker = new Worker(this.#url);
   		    }
   		    this.#worker.onerror = err => {
   		      console.error(`Error in worker ${this.#url}`, err.message);
   		    };
   		    this.#worker.addEventListener("message", this.#onMessage);
   		  }

   		  stop() {
   		    if (!this.#worker) {
   		      return;
   		    }

   		    this.#worker.removeEventListener("message", this.#onMessage);
   		    this.#worker.terminate();
   		    this.#worker = null;
   		    this.#pendingCalls.clear();
   		  }

   		  task(method, { queue = false } = {}) {
   		    const calls = [];
   		    const push = args => {
   		      return new Promise((resolve, reject) => {
   		        if (queue && calls.length === 0) {
   		          Promise.resolve().then(flush);
   		        }

   		        calls.push({ args, resolve, reject });

   		        if (!queue) {
   		          flush();
   		        }
   		      });
   		    };

   		    const flush = () => {
   		      const items = calls.slice();
   		      calls.length = 0;

   		      if (!this.#worker) {
   		        this.start();
   		      }

   		      const id = this.#msgId++;
   		      this.#worker.postMessage({
   		        id,
   		        method,
   		        calls: items.map(item => item.args),
   		      });

   		      this.#pendingCalls.set(id, items);
   		    };

   		    return (...args) => push(args);
   		  }

   		  invoke(method, ...args) {
   		    return this.task(method)(...args);
   		  }

   		  #onMessage = ({ data: result }) => {
   		    const items = this.#pendingCalls.get(result.id);
   		    this.#pendingCalls.delete(result.id);
   		    if (!items) {
   		      return;
   		    }

   		    if (!this.#worker) {
   		      return;
   		    }

   		    result.results.forEach((resultData, i) => {
   		      const { resolve, reject } = items[i];

   		      if (resultData.error) {
   		        const err = new Error(resultData.message);
   		        err.metadata = resultData.metadata;
   		        reject(err);
   		      } else {
   		        resolve(resultData.response);
   		      }
   		    });
   		  };
   		}

   		function workerHandler(publicInterface) {
   		  return function (msg) {
   		    const { id, method, calls } = msg.data;

   		    Promise.all(
   		      calls.map(args => {
   		        try {
   		          const response = publicInterface[method].apply(undefined, args);
   		          if (response instanceof Promise) {
   		            return response.then(
   		              val => ({ response: val }),
   		              err => asErrorMessage(err)
   		            );
   		          }
   		          return { response };
   		        } catch (error) {
   		          return asErrorMessage(error);
   		        }
   		      })
   		    ).then(results => {
   		      globalThis.postMessage({ id, results });
   		    });
   		  };
   		}

   		function asErrorMessage(error) {
   		  if (typeof error === "object" && error && "message" in error) {
   		    // Error can't be sent via postMessage, so be sure to convert to
   		    // string.
   		    return {
   		      error: true,
   		      message:
   		        error.message +
   		        (error.stack ? "\nStack in the worker:" + error.stack : ""),
   		      metadata: error.metadata,
   		    };
   		  }

   		  return {
   		    error: true,
   		    message: error == null ? error : error.toString(),
   		    metadata: undefined,
   		  };
   		}

   		// Might be loaded within a worker thread where `module` isn't available.
   		{
   		  module.exports = {
   		    WorkerDispatcher,
   		    workerHandler,
   		  };
   		} 
   	} (workerUtils));
   	return workerUtils.exports;
   }

   var workerUtilsExports = requireWorkerUtils();

   self.onmessage = workerUtilsExports.workerHandler({ getMatches, findSourceMatches });

}));