Quelle  search-worker.js   Sprache: JAVA

(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 });

}));