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

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function getAugmentedNamespace(n) {
      if (n.__esModule) return n;
      var f = n.default;
     if (typeof f == "function") {
      var a = function a () {
       if (this instanceof a) {
        var args = [null];
        args.push.apply(args, arguments);
        var Ctor = Function.bind.apply(f, args);
        return new Ctor();
       }
       return f.apply(this, arguments);
      };
      a.prototype = f.prototype;
      } else a = {};
      Object.defineProperty(a, '__esModule', {value: true});
     Object.keys(n).forEach(function (k) {
      var d = Object.getOwnPropertyDescriptor(n, k);
      Object.defineProperty(a, k, d.get ? d : {
       enumerable: true,
       get: function () {
        return n[k];
       }
      });
     });
     return a;
    }

    var sourceMap$1 = {};

    var sourceMapGenerator = {};

    var base64Vlq = {};

    var base64 = {};

    var hasRequiredBase64;

    function requireBase64 () {
     if (hasRequiredBase64) return base64;
     hasRequiredBase64 = 1;
     /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

     const intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");

     /**
      * Encode an integer in the range of 0 to 63 to a single base 64 digit.
      */
     base64.encode = function(number) {
       if (0 <= number && number < intToCharMap.length) {
         return intToCharMap[number];
       }
       throw new TypeError("Must be between 0 and 63: " + number);
     };
     return base64;
    }

    var hasRequiredBase64Vlq;

    function requireBase64Vlq () {
     if (hasRequiredBase64Vlq) return base64Vlq;
     hasRequiredBase64Vlq = 1;
     /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      *
      * Based on the Base 64 VLQ implementation in Closure Compiler:
      * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
      *
      * Copyright 2011 The Closure Compiler Authors. All rights reserved.
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions are
      * met:
      *
      *  * Redistributions of source code must retain the above copyright
      *    notice, this list of conditions and the following disclaimer.
      *  * Redistributions in binary form must reproduce the above
      *    copyright notice, this list of conditions and the following
      *    disclaimer in the documentation and/or other materials provided
      *    with the distribution.
      *  * Neither the name of Google Inc. nor the names of its
      *    contributors may be used to endorse or promote products derived
      *    from this software without specific prior written permission.
      *
      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      */

     const base64 = requireBase64();

     // A single base 64 digit can contain 6 bits of data. For the base 64 variable
     // length quantities we use in the source map spec, the first bit is the sign,
     // the next four bits are the actual value, and the 6th bit is the
     // continuation bit. The continuation bit tells us whether there are more
     // digits in this value following this digit.
     //
     //   Continuation
     //   |    Sign
     //   |    |
     //   V    V
     //   101011

     const VLQ_BASE_SHIFT = 5;

     // binary: 100000
     const VLQ_BASE = 1 << VLQ_BASE_SHIFT;

     // binary: 011111
     const VLQ_BASE_MASK = VLQ_BASE - 1;

     // binary: 100000
     const VLQ_CONTINUATION_BIT = VLQ_BASE;

     /**
      * Converts from a two-complement value to a value where the sign bit is
      * placed in the least significant bit.  For example, as decimals:
      *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
      *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
      */
     function toVLQSigned(aValue) {
       return aValue < 0
         ? ((-aValue) << 1) + 1
         : (aValue << 1) + 0;
     }

     /**
      * Returns the base 64 VLQ encoded value.
      */
     base64Vlq.encode = function base64VLQ_encode(aValue) {
       let encoded = "";
       let digit;

       let vlq = toVLQSigned(aValue);

       do {
         digit = vlq & VLQ_BASE_MASK;
         vlq >>>= VLQ_BASE_SHIFT;
         if (vlq > 0) {
           // There are still more digits in this value, so we must make sure the
           // continuation bit is marked.
           digit |= VLQ_CONTINUATION_BIT;
         }
         encoded += base64.encode(digit);
       } while (vlq > 0);

       return encoded;
     };
     return base64Vlq;
    }

    var util = {};

    var hasRequiredUtil;

    function requireUtil () {
     if (hasRequiredUtil) return util;
     hasRequiredUtil = 1;
     (function (exports) {
      /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

      /**
      * This is a helper function for getting values from parameter/options
      * objects.
      *
      * @param args The object we are extracting values from
      * @param name The name of the property we are getting.
      * @param defaultValue An optional value to return if the property is missing
      * from the object. If this is not specified and the property is missing, an
      * error will be thrown.
      */
      function getArg(aArgs, aName, aDefaultValue) {
        if (aName in aArgs) {
          return aArgs[aName];
        } else if (arguments.length === 3) {
          return aDefaultValue;
        }
          throw new Error('"' + aName + '" is a required argument.');

      }
      exports.getArg = getArg;

      const urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
      const dataUrlRegexp = /^data:.+\,.+$/;

      function urlParse(aUrl) {
        const match = aUrl.match(urlRegexp);
        if (!match) {
          return null;
        }
        return {
          scheme: match[1],
          auth: match[2],
          host: match[3],
          port: match[4],
          path: match[5]
        };
      }
      exports.urlParse = urlParse;

      function urlGenerate(aParsedUrl) {
        let url = "";
        if (aParsedUrl.scheme) {
          url += aParsedUrl.scheme + ":";
        }
        url += "//";
        if (aParsedUrl.auth) {
          url += aParsedUrl.auth + "@";
        }
        if (aParsedUrl.host) {
          url += aParsedUrl.host;
        }
        if (aParsedUrl.port) {
          url += ":" + aParsedUrl.port;
        }
        if (aParsedUrl.path) {
          url += aParsedUrl.path;
        }
        return url;
      }
      exports.urlGenerate = urlGenerate;

      const MAX_CACHED_INPUTS = 32;

      /**
      * Takes some function `f(input) -> result` and returns a memoized version of
      * `f`.
      *
      * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
      * memoization is a dumb-simple, linear least-recently-used cache.
      */
      function lruMemoize(f) {
        const cache = [];

        return function(input) {
          for (let i = 0; i < cache.length; i++) {
            if (cache[i].input === input) {
              const temp = cache[0];
              cache[0] = cache[i];
              cache[i] = temp;
              return cache[0].result;
            }
          }

          const result = f(input);

          cache.unshift({
            input,
            result,
          });

          if (cache.length > MAX_CACHED_INPUTS) {
            cache.pop();
          }

          return result;
        };
      }

      /**
      * Normalizes a path, or the path portion of a URL:
      *
      * - Replaces consecutive slashes with one slash.
      * - Removes unnecessary '.' parts.
      * - Removes unnecessary '<dir>/..' parts.
      *
      * Based on code in the Node.js 'path' core module.
      *
      * @param aPath The path or url to normalize.
      */
      const normalize = lruMemoize(function normalize(aPath) {
        let path = aPath;
        const url = urlParse(aPath);
        if (url) {
          if (!url.path) {
            return aPath;
          }
          path = url.path;
        }
        const isAbsolute = exports.isAbsolute(path);

        // Split the path into parts between `/` characters. This is much faster than
        // using `.split(/\/+/g)`.
        const parts = [];
        let start = 0;
        let i = 0;
        while (true) {
          start = i;
          i = path.indexOf("/", start);
          if (i === -1) {
            parts.push(path.slice(start));
            break;
          } else {
            parts.push(path.slice(start, i));
            while (i < path.length && path[i] === "/") {
              i++;
            }
          }
        }

        let up = 0;
        for (i = parts.length - 1; i >= 0; i--) {
          const part = parts[i];
          if (part === ".") {
            parts.splice(i, 1);
          } else if (part === "..") {
            up++;
          } else if (up > 0) {
            if (part === "") {
              // The first part is blank if the path is absolute. Trying to go
              // above the root is a no-op. Therefore we can remove all '..' parts
              // directly after the root.
              parts.splice(i + 1, up);
              up = 0;
            } else {
              parts.splice(i, 2);
              up--;
            }
          }
        }
        path = parts.join("/");

        if (path === "") {
          path = isAbsolute ? "/" : ".";
        }

        if (url) {
          url.path = path;
          return urlGenerate(url);
        }
        return path;
      });
      exports.normalize = normalize;

      /**
      * Joins two paths/URLs.
      *
      * @param aRoot The root path or URL.
      * @param aPath The path or URL to be joined with the root.
      *
      * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
      *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
      *   first.
      * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
      *   is updated with the result and aRoot is returned. Otherwise the result
      *   is returned.
      *   - If aPath is absolute, the result is aPath.
      *   - Otherwise the two paths are joined with a slash.
      * - Joining for example 'http://' and 'www.example.com' is also supported.
      */
      function join(aRoot, aPath) {
        if (aRoot === "") {
          aRoot = ".";
        }
        if (aPath === "") {
          aPath = ".";
        }
        const aPathUrl = urlParse(aPath);
        const aRootUrl = urlParse(aRoot);
        if (aRootUrl) {
          aRoot = aRootUrl.path || "/";
        }

        // `join(foo, '//www.example.org')`
        if (aPathUrl && !aPathUrl.scheme) {
          if (aRootUrl) {
            aPathUrl.scheme = aRootUrl.scheme;
          }
          return urlGenerate(aPathUrl);
        }

        if (aPathUrl || aPath.match(dataUrlRegexp)) {
          return aPath;
        }

        // `join('http://', 'www.example.com')`
        if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
          aRootUrl.host = aPath;
          return urlGenerate(aRootUrl);
        }

        const joined = aPath.charAt(0) === "/"
          ? aPath
          : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);

        if (aRootUrl) {
          aRootUrl.path = joined;
          return urlGenerate(aRootUrl);
        }
        return joined;
      }
      exports.join = join;

      exports.isAbsolute = function(aPath) {
        return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
      };

      /**
      * Make a path relative to a URL or another path.
      *
      * @param aRoot The root path or URL.
      * @param aPath The path or URL to be made relative to aRoot.
      */
      function relative(aRoot, aPath) {
        if (aRoot === "") {
          aRoot = ".";
        }

        aRoot = aRoot.replace(/\/$/, "");

        // It is possible for the path to be above the root. In this case, simply
        // checking whether the root is a prefix of the path won't work. Instead, we
        // need to remove components from the root one by one, until either we find
        // a prefix that fits, or we run out of components to remove.
        let level = 0;
        while (aPath.indexOf(aRoot + "/") !== 0) {
          const index = aRoot.lastIndexOf("/");
          if (index < 0) {
            return aPath;
          }

          // If the only part of the root that is left is the scheme (i.e. http://,
          // file:///, etc.), one or more slashes (/), or simply nothing at all, we
          // have exhausted all components, so the path is not relative to the root.
          aRoot = aRoot.slice(0, index);
          if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
           return aPath;
         }

         ++level;
       }

       // Make sure we add a "../" for each component we removed from the root.
       return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
     }
     exports.relative = relative;

     const supportsNullProto = (function() {
       const obj = Object.create(null);
       return !("__proto__" in obj);
     }());

     function identity(s) {
       return s;
     }

     /**
      * Because behavior goes wacky when you set `__proto__` on objects, we
      * have to prefix all the strings in our set with an arbitrary character.
      *
      * See https://github.com/mozilla/source-map/pull/31 and
      * https://github.com/mozilla/source-map/issues/30
      *
      * @param String aStr
      */
      function toSetString(aStr) {
        if (isProtoString(aStr)) {
          return "$" + aStr;
        }

        return aStr;
      }
      exports.toSetString = supportsNullProto ? identity : toSetString;

      function fromSetString(aStr) {
        if (isProtoString(aStr)) {
          return aStr.slice(1);
        }

        return aStr;
      }
      exports.fromSetString = supportsNullProto ? identity : fromSetString;

      function isProtoString(s) {
        if (!s) {
          return false;
        }

        const length = s.length;

        if (length < 9 /* "__proto__".length */) {
          return false;
        }

        /* eslint-disable no-multi-spaces */
        if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
            s.charCodeAt(length - 2) !== 95  /* '_' */ ||
            s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
            s.charCodeAt(length - 4) !== 116 /* 't' */ ||
            s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
            s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
            s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
            s.charCodeAt(length - 8) !== 95  /* '_' */ ||
            s.charCodeAt(length - 9) !== 95  /* '_' */) {
          return false;
        }
        /* eslint-enable no-multi-spaces */

        for (let i = length - 10; i >= 0; i--) {
          if (s.charCodeAt(i) !== 36 /* '$' */) {
            return false;
          }
        }

        return true;
      }

      /**
      * Comparator between two mappings where the original positions are compared.
      *
      * Optionally pass in `true` as `onlyCompareGenerated` to consider two
      * mappings with the same original source/line/column, but different generated
      * line and column the same. Useful when searching for a mapping with a
      * stubbed out mapping.
      */
      function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
        let cmp = strcmp(mappingA.source, mappingB.source);
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalLine - mappingB.originalLine;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalColumn - mappingB.originalColumn;
        if (cmp !== 0 || onlyCompareOriginal) {
          return cmp;
        }

        cmp = mappingA.generatedColumn - mappingB.generatedColumn;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.generatedLine - mappingB.generatedLine;
        if (cmp !== 0) {
          return cmp;
        }

        return strcmp(mappingA.name, mappingB.name);
      }
      exports.compareByOriginalPositions = compareByOriginalPositions;

      /**
      * Comparator between two mappings with deflated source and name indices where
      * the generated positions are compared.
      *
      * Optionally pass in `true` as `onlyCompareGenerated` to consider two
      * mappings with the same generated line and column, but different
      * source/name/original line and column the same. Useful when searching for a
      * mapping with a stubbed out mapping.
      */
      function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
        let cmp = mappingA.generatedLine - mappingB.generatedLine;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.generatedColumn - mappingB.generatedColumn;
        if (cmp !== 0 || onlyCompareGenerated) {
          return cmp;
        }

        cmp = strcmp(mappingA.source, mappingB.source);
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalLine - mappingB.originalLine;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalColumn - mappingB.originalColumn;
        if (cmp !== 0) {
          return cmp;
        }

        return strcmp(mappingA.name, mappingB.name);
      }
      exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;

      function strcmp(aStr1, aStr2) {
        if (aStr1 === aStr2) {
          return 0;
        }

        if (aStr1 === null) {
          return 1; // aStr2 !== null
        }

        if (aStr2 === null) {
          return -1; // aStr1 !== null
        }

        if (aStr1 > aStr2) {
          return 1;
        }

        return -1;
      }

      /**
      * Comparator between two mappings with inflated source and name strings where
      * the generated positions are compared.
      */
      function compareByGeneratedPositionsInflated(mappingA, mappingB) {
        let cmp = mappingA.generatedLine - mappingB.generatedLine;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.generatedColumn - mappingB.generatedColumn;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = strcmp(mappingA.source, mappingB.source);
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalLine - mappingB.originalLine;
        if (cmp !== 0) {
          return cmp;
        }

        cmp = mappingA.originalColumn - mappingB.originalColumn;
        if (cmp !== 0) {
          return cmp;
        }

        return strcmp(mappingA.name, mappingB.name);
      }
      exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;

      /**
      * Strip any JSON XSSI avoidance prefix from the string (as documented
      * in the source maps specification), and then parse the string as
      * JSON.
      */
      function parseSourceMapInput(str) {
        return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
      }
      exports.parseSourceMapInput = parseSourceMapInput;

      /**
      * Compute the URL of a source given the the source root, the source's
      * URL, and the source map's URL.
      */
      function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
        sourceURL = sourceURL || "";

        if (sourceRoot) {
          // This follows what Chrome does.
          if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
            sourceRoot += "/";
          }
          // The spec says:
          //   Line 4: An optional source root, useful for relocating source
          //   files on a server or removing repeated values in the
          //   “sources” entry.  This value is prepended to the individual
          //   entries in the “source” field.
          sourceURL = sourceRoot + sourceURL;
        }

        // Historically, SourceMapConsumer did not take the sourceMapURL as
        // a parameter.  This mode is still somewhat supported, which is why
        // this code block is conditional.  However, it's preferable to pass
        // the source map URL to SourceMapConsumer, so that this function
        // can implement the source URL resolution algorithm as outlined in
        // the spec.  This block is basically the equivalent of:
        //    new URL(sourceURL, sourceMapURL).toString()
        // ... except it avoids using URL, which wasn't available in the
        // older releases of node still supported by this library.
        //
        // The spec says:
        //   If the sources are not absolute URLs after prepending of the
        //   “sourceRoot”, the sources are resolved relative to the
        //   SourceMap (like resolving script src in a html document).
        if (sourceMapURL) {
          const parsed = urlParse(sourceMapURL);
          if (!parsed) {
            throw new Error("sourceMapURL could not be parsed");
          }
          if (parsed.path) {
            // Strip the last path component, but keep the "/".
            const index = parsed.path.lastIndexOf("/");
            if (index >= 0) {
              parsed.path = parsed.path.substring(0, index + 1);
            }
          }
          sourceURL = join(urlGenerate(parsed), sourceURL);
        }

        return normalize(sourceURL);
      }
      exports.computeSourceURL = computeSourceURL; 
     } (util));
     return util;
    }

    var arraySet = {};

    var hasRequiredArraySet;

    function requireArraySet () {
     if (hasRequiredArraySet) return arraySet;
     hasRequiredArraySet = 1;
     /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

     /**
      * A data structure which is a combination of an array and a set. Adding a new
      * member is O(1), testing for membership is O(1), and finding the index of an
      * element is O(1). Removing elements from the set is not supported. Only
      * strings are supported for membership.
      */
     class ArraySet {
       constructor() {
         this._array = [];
         this._set = new Map();
       }

       /**
        * Static method for creating ArraySet instances from an existing array.
        */
       static fromArray(aArray, aAllowDuplicates) {
         const set = new ArraySet();
         for (let i = 0, len = aArray.length; i < len; i++) {
           set.add(aArray[i], aAllowDuplicates);
         }
         return set;
       }

       /**
        * Return how many unique items are in this ArraySet. If duplicates have been
        * added, than those do not count towards the size.
        *
        * @returns Number
        */
       size() {
         return this._set.size;
       }

       /**
        * Add the given string to this set.
        *
        * @param String aStr
        */
       add(aStr, aAllowDuplicates) {
         const isDuplicate = this.has(aStr);
         const idx = this._array.length;
         if (!isDuplicate || aAllowDuplicates) {
           this._array.push(aStr);
         }
         if (!isDuplicate) {
           this._set.set(aStr, idx);
         }
       }

       /**
        * Is the given string a member of this set?
        *
        * @param String aStr
        */
       has(aStr) {
           return this._set.has(aStr);
       }

       /**
        * What is the index of the given string in the array?
        *
        * @param String aStr
        */
       indexOf(aStr) {
         const idx = this._set.get(aStr);
         if (idx >= 0) {
             return idx;
         }
         throw new Error('"' + aStr + '" is not in the set.');
       }

       /**
        * What is the element at the given index?
        *
        * @param Number aIdx
        */
       at(aIdx) {
         if (aIdx >= 0 && aIdx < this._array.length) {
           return this._array[aIdx];
         }
         throw new Error("No element indexed by " + aIdx);
       }

       /**
        * Returns the array representation of this set (which has the proper indices
        * indicated by indexOf). Note that this is a copy of the internal array used
        * for storing the members so that no one can mess with internal state.
        */
       toArray() {
         return this._array.slice();
       }
     }
     arraySet.ArraySet = ArraySet;
     return arraySet;
    }

    var mappingList = {};

    var hasRequiredMappingList;

    function requireMappingList () {
     if (hasRequiredMappingList) return mappingList;
     hasRequiredMappingList = 1;
     /*
      * Copyright 2014 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

     const util = requireUtil();

     /**
      * Determine whether mappingB is after mappingA with respect to generated
      * position.
      */
     function generatedPositionAfter(mappingA, mappingB) {
       // Optimized for most common case
       const lineA = mappingA.generatedLine;
       const lineB = mappingB.generatedLine;
       const columnA = mappingA.generatedColumn;
       const columnB = mappingB.generatedColumn;
       return lineB > lineA || lineB == lineA && columnB >= columnA ||
              util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
     }

     /**
      * A data structure to provide a sorted view of accumulated mappings in a
      * performance conscious manner. It trades a negligible overhead in general
      * case for a large speedup in case of mappings being added in order.
      */
     class MappingList {
       constructor() {
         this._array = [];
         this._sorted = true;
         // Serves as infimum
         this._last = {generatedLine: -1, generatedColumn: 0};
       }

       /**
        * Iterate through internal items. This method takes the same arguments that
        * `Array.prototype.forEach` takes.
        *
        * NOTE: The order of the mappings is NOT guaranteed.
        */
       unsortedForEach(aCallback, aThisArg) {
         this._array.forEach(aCallback, aThisArg);
       }

       /**
        * Add the given source mapping.
        *
        * @param Object aMapping
        */
       add(aMapping) {
         if (generatedPositionAfter(this._last, aMapping)) {
           this._last = aMapping;
           this._array.push(aMapping);
         } else {
           this._sorted = false;
           this._array.push(aMapping);
         }
       }

       /**
        * Returns the flat, sorted array of mappings. The mappings are sorted by
        * generated position.
        *
        * WARNING: This method returns internal data without copying, for
        * performance. The return value must NOT be mutated, and should be treated as
        * an immutable borrow. If you want to take ownership, you must make your own
        * copy.
        */
       toArray() {
         if (!this._sorted) {
           this._array.sort(util.compareByGeneratedPositionsInflated);
           this._sorted = true;
         }
         return this._array;
       }
     }

     mappingList.MappingList = MappingList;
     return mappingList;
    }

    var hasRequiredSourceMapGenerator;

    function requireSourceMapGenerator () {
     if (hasRequiredSourceMapGenerator) return sourceMapGenerator;
     hasRequiredSourceMapGenerator = 1;
     /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

     const base64VLQ = requireBase64Vlq();
     const util = requireUtil();
     const ArraySet = requireArraySet().ArraySet;
     const MappingList = requireMappingList().MappingList;

     /**
      * An instance of the SourceMapGenerator represents a source map which is
      * being built incrementally. You may pass an object with the following
      * properties:
      *
      *   - file: The filename of the generated source.
      *   - sourceRoot: A root for all relative URLs in this source map.
      */
     class SourceMapGenerator {
       constructor(aArgs) {
         if (!aArgs) {
           aArgs = {};
         }
         this._file = util.getArg(aArgs, "file", null);
         this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
         this._skipValidation = util.getArg(aArgs, "skipValidation", false);
         this._sources = new ArraySet();
         this._names = new ArraySet();
         this._mappings = new MappingList();
         this._sourcesContents = null;
       }

       /**
        * Creates a new SourceMapGenerator based on a SourceMapConsumer
        *
        * @param aSourceMapConsumer The SourceMap.
        */
       static fromSourceMap(aSourceMapConsumer) {
         const sourceRoot = aSourceMapConsumer.sourceRoot;
         const generator = new SourceMapGenerator({
           file: aSourceMapConsumer.file,
           sourceRoot
         });
         aSourceMapConsumer.eachMapping(function(mapping) {
           const newMapping = {
             generated: {
               line: mapping.generatedLine,
               column: mapping.generatedColumn
             }
           };

           if (mapping.source != null) {
             newMapping.source = mapping.source;
             if (sourceRoot != null) {
               newMapping.source = util.relative(sourceRoot, newMapping.source);
             }

             newMapping.original = {
               line: mapping.originalLine,
               column: mapping.originalColumn
             };

             if (mapping.name != null) {
               newMapping.name = mapping.name;
             }
           }

           generator.addMapping(newMapping);
         });
         aSourceMapConsumer.sources.forEach(function(sourceFile) {
           let sourceRelative = sourceFile;
           if (sourceRoot !== null) {
             sourceRelative = util.relative(sourceRoot, sourceFile);
           }

           if (!generator._sources.has(sourceRelative)) {
             generator._sources.add(sourceRelative);
           }

           const content = aSourceMapConsumer.sourceContentFor(sourceFile);
           if (content != null) {
             generator.setSourceContent(sourceFile, content);
           }
         });
         return generator;
       }

       /**
        * Add a single mapping from original source line and column to the generated
        * source's line and column for this source map being created. The mapping
        * object should have the following properties:
        *
        *   - generated: An object with the generated line and column positions.
        *   - original: An object with the original line and column positions.
        *   - source: The original source file (relative to the sourceRoot).
        *   - name: An optional original token name for this mapping.
        */
       addMapping(aArgs) {
         const generated = util.getArg(aArgs, "generated");
         const original = util.getArg(aArgs, "original", null);
         let source = util.getArg(aArgs, "source", null);
         let name = util.getArg(aArgs, "name", null);

         if (!this._skipValidation) {
           this._validateMapping(generated, original, source, name);
         }

         if (source != null) {
           source = String(source);
           if (!this._sources.has(source)) {
             this._sources.add(source);
           }
         }

         if (name != null) {
           name = String(name);
           if (!this._names.has(name)) {
             this._names.add(name);
           }
         }

         this._mappings.add({
           generatedLine: generated.line,
           generatedColumn: generated.column,
           originalLine: original != null && original.line,
           originalColumn: original != null && original.column,
           source,
           name
         });
       }

       /**
        * Set the source content for a source file.
        */
       setSourceContent(aSourceFile, aSourceContent) {
         let source = aSourceFile;
         if (this._sourceRoot != null) {
           source = util.relative(this._sourceRoot, source);
         }

         if (aSourceContent != null) {
           // Add the source content to the _sourcesContents map.
           // Create a new _sourcesContents map if the property is null.
           if (!this._sourcesContents) {
             this._sourcesContents = Object.create(null);
           }
           this._sourcesContents[util.toSetString(source)] = aSourceContent;
         } else if (this._sourcesContents) {
           // Remove the source file from the _sourcesContents map.
           // If the _sourcesContents map is empty, set the property to null.
           delete this._sourcesContents[util.toSetString(source)];
           if (Object.keys(this._sourcesContents).length === 0) {
             this._sourcesContents = null;
           }
         }
       }

       /**
        * Applies the mappings of a sub-source-map for a specific source file to the
        * source map being generated. Each mapping to the supplied source file is
        * rewritten using the supplied source map. Note: The resolution for the
        * resulting mappings is the minimium of this map and the supplied map.
        *
        * @param aSourceMapConsumer The source map to be applied.
        * @param aSourceFile Optional. The filename of the source file.
        *        If omitted, SourceMapConsumer's file property will be used.
        * @param aSourceMapPath Optional. The dirname of the path to the source map
        *        to be applied. If relative, it is relative to the SourceMapConsumer.
        *        This parameter is needed when the two source maps aren't in the same
        *        directory, and the source map to be applied contains relative source
        *        paths. If so, those relative source paths need to be rewritten
        *        relative to the SourceMapGenerator.
        */
       applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
         let sourceFile = aSourceFile;
         // If aSourceFile is omitted, we will use the file property of the SourceMap
         if (aSourceFile == null) {
           if (aSourceMapConsumer.file == null) {
             throw new Error(
               "SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " +
               'or the source map\'s "file" property. Both were omitted.'
             );
           }
           sourceFile = aSourceMapConsumer.file;
         }
         const sourceRoot = this._sourceRoot;
         // Make "sourceFile" relative if an absolute Url is passed.
         if (sourceRoot != null) {
           sourceFile = util.relative(sourceRoot, sourceFile);
         }
         // Applying the SourceMap can add and remove items from the sources and
         // the names array.
         const newSources = this._mappings.toArray().length > 0
           ? new ArraySet()
           : this._sources;
         const newNames = new ArraySet();

         // Find mappings for the "sourceFile"
         this._mappings.unsortedForEach(function(mapping) {
           if (mapping.source === sourceFile && mapping.originalLine != null) {
             // Check if it can be mapped by the source map, then update the mapping.
             const original = aSourceMapConsumer.originalPositionFor({
               line: mapping.originalLine,
               column: mapping.originalColumn
             });
             if (original.source != null) {
               // Copy mapping
               mapping.source = original.source;
               if (aSourceMapPath != null) {
                 mapping.source = util.join(aSourceMapPath, mapping.source);
               }
               if (sourceRoot != null) {
                 mapping.source = util.relative(sourceRoot, mapping.source);
               }
               mapping.originalLine = original.line;
               mapping.originalColumn = original.column;
               if (original.name != null) {
                 mapping.name = original.name;
               }
             }
           }

           const source = mapping.source;
           if (source != null && !newSources.has(source)) {
             newSources.add(source);
           }

           const name = mapping.name;
           if (name != null && !newNames.has(name)) {
             newNames.add(name);
           }

         }, this);
         this._sources = newSources;
         this._names = newNames;

         // Copy sourcesContents of applied map.
         aSourceMapConsumer.sources.forEach(function(srcFile) {
           const content = aSourceMapConsumer.sourceContentFor(srcFile);
           if (content != null) {
             if (aSourceMapPath != null) {
               srcFile = util.join(aSourceMapPath, srcFile);
             }
             if (sourceRoot != null) {
               srcFile = util.relative(sourceRoot, srcFile);
             }
             this.setSourceContent(srcFile, content);
           }
         }, this);
       }

       /**
        * A mapping can have one of the three levels of data:
        *
        *   1. Just the generated position.
        *   2. The Generated position, original position, and original source.
        *   3. Generated and original position, original source, as well as a name
        *      token.
        *
        * To maintain consistency, we validate that any new mapping being added falls
        * in to one of these categories.
        */
       _validateMapping(aGenerated, aOriginal, aSource, aName) {
         // When aOriginal is truthy but has empty values for .line and .column,
         // it is most likely a programmer error. In this case we throw a very
         // specific error message to try to guide them the right way.
         // For example: https://github.com/Polymer/polymer-bundler/pull/519
         if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
             throw new Error(
                 "original.line and original.column are not numbers -- you probably meant to omit " +
                 "the original mapping entirely and only map the generated position. If so, pass " +
                 "null for the original mapping instead of an object with empty or null values."
             );
         }

         if (aGenerated && "line" in aGenerated && "column" in aGenerated
             && aGenerated.line > 0 && aGenerated.column >= 0
             && !aOriginal && !aSource && !aName) ; else if (aGenerated && "line" in aGenerated && "column" in aGenerated
                  && aOriginal && "line" in aOriginal && "column" in aOriginal
                  && aGenerated.line > 0 && aGenerated.column >= 0
                  && aOriginal.line > 0 && aOriginal.column >= 0
                  && aSource) ; else {
           throw new Error("Invalid mapping: " + JSON.stringify({
             generated: aGenerated,
             source: aSource,
             original: aOriginal,
             name: aName
           }));
         }
       }

       /**
        * Serialize the accumulated mappings in to the stream of base 64 VLQs
        * specified by the source map format.
        */
       _serializeMappings() {
         let previousGeneratedColumn = 0;
         let previousGeneratedLine = 1;
         let previousOriginalColumn = 0;
         let previousOriginalLine = 0;
         let previousName = 0;
         let previousSource = 0;
         let result = "";
         let next;
         let mapping;
         let nameIdx;
         let sourceIdx;

         const mappings = this._mappings.toArray();
         for (let i = 0, len = mappings.length; i < len; i++) {
           mapping = mappings[i];
           next = "";

           if (mapping.generatedLine !== previousGeneratedLine) {
             previousGeneratedColumn = 0;
             while (mapping.generatedLine !== previousGeneratedLine) {
               next += ";";
               previousGeneratedLine++;
             }
           } else if (i > 0) {
             if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
               continue;
             }
             next += ",";
           }

           next += base64VLQ.encode(mapping.generatedColumn
                                      - previousGeneratedColumn);
           previousGeneratedColumn = mapping.generatedColumn;

           if (mapping.source != null) {
             sourceIdx = this._sources.indexOf(mapping.source);
             next += base64VLQ.encode(sourceIdx - previousSource);
             previousSource = sourceIdx;

             // lines are stored 0-based in SourceMap spec version 3
             next += base64VLQ.encode(mapping.originalLine - 1
                                        - previousOriginalLine);
             previousOriginalLine = mapping.originalLine - 1;

             next += base64VLQ.encode(mapping.originalColumn
                                        - previousOriginalColumn);
             previousOriginalColumn = mapping.originalColumn;

             if (mapping.name != null) {
               nameIdx = this._names.indexOf(mapping.name);
               next += base64VLQ.encode(nameIdx - previousName);
               previousName = nameIdx;
             }
           }

           result += next;
         }

         return result;
       }

       _generateSourcesContent(aSources, aSourceRoot) {
         return aSources.map(function(source) {
           if (!this._sourcesContents) {
             return null;
           }
           if (aSourceRoot != null) {
             source = util.relative(aSourceRoot, source);
           }
           const key = util.toSetString(source);
           return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
             ? this._sourcesContents[key]
             : null;
         }, this);
       }

       /**
        * Externalize the source map.
        */
       toJSON() {
         const map = {
           version: this._version,
           sources: this._sources.toArray(),
           names: this._names.toArray(),
           mappings: this._serializeMappings()
         };
         if (this._file != null) {
           map.file = this._file;
         }
         if (this._sourceRoot != null) {
           map.sourceRoot = this._sourceRoot;
         }
         if (this._sourcesContents) {
           map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
         }

         return map;
       }

       /**
        * Render the source map being generated to a string.
        */
       toString() {
         return JSON.stringify(this.toJSON());
       }
     }

     SourceMapGenerator.prototype._version = 3;
     sourceMapGenerator.SourceMapGenerator = SourceMapGenerator;
     return sourceMapGenerator;
    }

    var sourceMapConsumer = {};

    var binarySearch = {};

    var hasRequiredBinarySearch;

    function requireBinarySearch () {
     if (hasRequiredBinarySearch) return binarySearch;
     hasRequiredBinarySearch = 1;
     (function (exports) {
      /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

      exports.GREATEST_LOWER_BOUND = 1;
      exports.LEAST_UPPER_BOUND = 2;

      /**
      * Recursive implementation of binary search.
      *
      * @param aLow Indices here and lower do not contain the needle.
      * @param aHigh Indices here and higher do not contain the needle.
      * @param aNeedle The element being searched for.
      * @param aHaystack The non-empty array being searched.
      * @param aCompare Function which takes two elements and returns -1, 0, or 1.
      * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
      *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
      *     closest element that is smaller than or greater than the one we are
      *     searching for, respectively, if the exact element cannot be found.
      */
      function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
        // This function terminates when one of the following is true:
        //
        //   1. We find the exact element we are looking for.
        //
        //   2. We did not find the exact element, but we can return the index of
        //      the next-closest element.
        //
        //   3. We did not find the exact element, and there is no next-closest
        //      element than the one we are searching for, so we return -1.
        const mid = Math.floor((aHigh - aLow) / 2) + aLow;
        const cmp = aCompare(aNeedle, aHaystack[mid], true);
        if (cmp === 0) {
          // Found the element we are looking for.
          return mid;
        } else if (cmp > 0) {
          // Our needle is greater than aHaystack[mid].
          if (aHigh - mid > 1) {
            // The element is in the upper half.
            return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
          }

          // The exact needle element was not found in this haystack. Determine if
          // we are in termination case (3) or (2) and return the appropriate thing.
          if (aBias == exports.LEAST_UPPER_BOUND) {
            return aHigh < aHaystack.length ? aHigh : -1;
          }
          return mid;
        }

        // Our needle is less than aHaystack[mid].
        if (mid - aLow > 1) {
          // The element is in the lower half.
          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
        }

        // we are in termination case (3) or (2) and return the appropriate thing.
        if (aBias == exports.LEAST_UPPER_BOUND) {
          return mid;
        }
        return aLow < 0 ? -1 : aLow;
      }

      /**
      * This is an implementation of binary search which will always try and return
      * the index of the closest element if there is no exact hit. This is because
      * mappings between original and generated line/col pairs are single points,
      * and there is an implicit region between each of them, so a miss just means
      * that you aren't on the very start of a region.
      *
      * @param aNeedle The element you are looking for.
      * @param aHaystack The array that is being searched.
      * @param aCompare A function which takes the needle and an element in the
      *     array and returns -1, 0, or 1 depending on whether the needle is less
      *     than, equal to, or greater than the element, respectively.
      * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
      *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
      *     closest element that is smaller than or greater than the one we are
      *     searching for, respectively, if the exact element cannot be found.
      *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
      */
      exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
        if (aHaystack.length === 0) {
          return -1;
        }

        let index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
                                    aCompare, aBias || exports.GREATEST_LOWER_BOUND);
        if (index < 0) {
          return -1;
        }

        // We have found either the exact element, or the next-closest element than
        // the one we are searching for. However, there may be more than one such
        // element. Make sure we always return the smallest of these.
        while (index - 1 >= 0) {
          if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
            break;
          }
          --index;
        }

        return index;
      }; 
     } (binarySearch));
     return binarySearch;
    }

    var readWasm = {exports: {}};

    var empty = {};

    var empty$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        default: empty
    });

    var require$$0 = /*@__PURE__*/getAugmentedNamespace(empty$1);

    // Copyright Joyent, Inc. and other Node contributors.
    //
    // Permission is hereby granted, free of charge, to any person obtaining a
    // copy of this software and associated documentation files (the
    // "Software"), to deal in the Software without restriction, including
    // without limitation the rights to use, copy, modify, merge, publish,
    // distribute, sublicense, and/or sell copies of the Software, and to permit
    // persons to whom the Software is furnished to do so, subject to the
    // following conditions:
    //
    // The above copyright notice and this permission notice shall be included
    // in all copies or substantial portions of the Software.
    //
    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
    // USE OR OTHER DEALINGS IN THE SOFTWARE.

    // resolves . and .. elements in a path array with directory names there
    // must be no slashes, empty elements, or device names (c:\) in the array
    // (so also no leading and trailing slashes - it does not distinguish
    // relative and absolute paths)
    function normalizeArray(parts, allowAboveRoot) {
      // if the path tries to go above the root, `up` ends up > 0
      var up = 0;
      for (var i = parts.length - 1; i >= 0; i--) {
        var last = parts[i];
        if (last === '.') {
          parts.splice(i, 1);
        } else if (last === '..') {
          parts.splice(i, 1);
          up++;
        } else if (up) {
          parts.splice(i, 1);
          up--;
        }
      }

      // if the path is allowed to go above the root, restore leading ..s
      if (allowAboveRoot) {
        for (; up--; up) {
          parts.unshift('..');
        }
      }

      return parts;
    }

    // Split a filename into [root, dir, basename, ext], unix version
    // 'root' is just a slash, or nothing.
    var splitPathRe =
        /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
    var splitPath = function(filename) {
      return splitPathRe.exec(filename).slice(1);
    };

    // path.resolve([from ...], to)
    // posix version
    function resolve() {
      var resolvedPath = '',
          resolvedAbsolute = false;

      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
        var path = (i >= 0) ? arguments[i] : '/';

        // Skip empty and invalid entries
        if (typeof path !== 'string') {
          throw new TypeError('Arguments to path.resolve must be strings');
        } else if (!path) {
          continue;
        }

        resolvedPath = path + '/' + resolvedPath;
        resolvedAbsolute = path.charAt(0) === '/';
      }

      // At this point the path should be resolved to a full absolute path, but
      // handle relative paths to be safe (might happen when process.cwd() fails)

      // Normalize the path
      resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
        return !!p;
      }), !resolvedAbsolute).join('/');

      return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
    }
    // path.normalize(path)
    // posix version
    function normalize(path) {
      var isPathAbsolute = isAbsolute(path),
          trailingSlash = substr(path, -1) === '/';

      // Normalize the path
      path = normalizeArray(filter(path.split('/'), function(p) {
        return !!p;
      }), !isPathAbsolute).join('/');

      if (!path && !isPathAbsolute) {
        path = '.';
      }
      if (path && trailingSlash) {
        path += '/';
      }

      return (isPathAbsolute ? '/' : '') + path;
    }
    // posix version
    function isAbsolute(path) {
      return path.charAt(0) === '/';
    }

    // posix version
    function join() {
      var paths = Array.prototype.slice.call(arguments, 0);
      return normalize(filter(paths, function(p, index) {
        if (typeof p !== 'string') {
          throw new TypeError('Arguments to path.join must be strings');
        }
        return p;
      }).join('/'));
    }


    // path.relative(from, to)
    // posix version
    function relative(from, to) {
      from = resolve(from).substr(1);
      to = resolve(to).substr(1);

      function trim(arr) {
        var start = 0;
        for (; start < arr.length; start++) {
          if (arr[start] !== '') break;
        }

        var end = arr.length - 1;
        for (; end >= 0; end--) {
          if (arr[end] !== '') break;
        }

        if (start > end) return [];
        return arr.slice(start, end - start + 1);
      }

      var fromParts = trim(from.split('/'));
      var toParts = trim(to.split('/'));

      var length = Math.min(fromParts.length, toParts.length);
      var samePartsLength = length;
      for (var i = 0; i < length; i++) {
        if (fromParts[i] !== toParts[i]) {
          samePartsLength = i;
          break;
        }
      }

      var outputParts = [];
      for (var i = samePartsLength; i < fromParts.length; i++) {
        outputParts.push('..');
      }

      outputParts = outputParts.concat(toParts.slice(samePartsLength));

      return outputParts.join('/');
    }

    var sep = '/';
    var delimiter = ':';

    function dirname(path) {
      var result = splitPath(path),
          root = result[0],
          dir = result[1];

      if (!root && !dir) {
        // No dirname whatsoever
        return '.';
      }

      if (dir) {
        // It has a dirname, strip trailing slash
        dir = dir.substr(0, dir.length - 1);
      }

      return root + dir;
    }

    function basename(path, ext) {
      var f = splitPath(path)[2];
      // TODO: make this comparison case-insensitive on windows?
      if (ext && f.substr(-1 * ext.length) === ext) {
        f = f.substr(0, f.length - ext.length);
      }
      return f;
    }


    function extname(path) {
      return splitPath(path)[3];
    }
    var path = {
      extname: extname,
      basename: basename,
      dirname: dirname,
      sep: sep,
      delimiter: delimiter,
      relative: relative,
      join: join,
      isAbsolute: isAbsolute,
      normalize: normalize,
      resolve: resolve
    };
    function filter (xs, f) {
        if (xs.filter) return xs.filter(f);
        var res = [];
        for (var i = 0; i < xs.length; i++) {
            if (f(xs[i], i, xs)) res.push(xs[i]);
        }
        return res;
    }

    // String.prototype.substr - negative index don't work in IE8
    var substr = 'ab'.substr(-1) === 'b' ?
        function (str, start, len) { return str.substr(start, len) } :
        function (str, start, len) {
            if (start < 0) start = str.length + start;
            return str.substr(start, len);
        }
    ;

    var path$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        basename: basename,
        default: path,
        delimiter: delimiter,
        dirname: dirname,
        extname: extname,
        isAbsolute: isAbsolute,
        join: join,
        normalize: normalize,
        relative: relative,
        resolve: resolve,
        sep: sep
    });

    var require$$1 = /*@__PURE__*/getAugmentedNamespace(path$1);

    var hasRequiredReadWasm;

    function requireReadWasm () {
     if (hasRequiredReadWasm) return readWasm.exports;
     hasRequiredReadWasm = 1;
     const isBrowserEnvironment = (function() {
         // eslint-disable-next-line no-undef
         return (typeof window !== "undefined") && (this === window);
     }).call();

     if (isBrowserEnvironment) {
       // Web version of reading a wasm file into an array buffer.

       let mappingsWasm = null;

       readWasm.exports = function readWasm() {
         if (typeof mappingsWasm === "string") {
           return fetch(mappingsWasm)
             .then(response => response.arrayBuffer());
         }
         if (mappingsWasm instanceof ArrayBuffer) {
           return Promise.resolve(mappingsWasm);
         }
         throw new Error("You must provide the string URL or ArrayBuffer contents " +
                         "of lib/mappings.wasm by calling " +
                         "SourceMapConsumer.initialize({ 'lib/mappings.wasm': ... }) " +
                         "before using SourceMapConsumer");
       };

       readWasm.exports.initialize = input => mappingsWasm = input;
     } else {
       // Node version of reading a wasm file into an array buffer.
       const fs = require$$0;
       const path = require$$1;

       readWasm.exports = function readWasm() {
         return new Promise((resolve, reject) => {
           const wasmPath = path.join(__dirname, "mappings.wasm");
           fs.readFile(wasmPath, null, (error, data) => {
             if (error) {
               reject(error);
               return;
             }

             resolve(data.buffer);
           });
         });
       };

       readWasm.exports.initialize = _ => {
         console.debug("SourceMapConsumer.initialize is a no-op when running in node.js");
       };
     }
     return readWasm.exports;
    }

    var wasm;
    var hasRequiredWasm;

    function requireWasm () {
     if (hasRequiredWasm) return wasm;
     hasRequiredWasm = 1;
     const readWasm = requireReadWasm();

     /**
      * Provide the JIT with a nice shape / hidden class.
      */
     function Mapping() {
       this.generatedLine = 0;
       this.generatedColumn = 0;
       this.lastGeneratedColumn = null;
       this.source = null;
       this.originalLine = null;
       this.originalColumn = null;
       this.name = null;
     }

     let cachedWasm = null;

     wasm = function wasm() {
       if (cachedWasm) {
         return cachedWasm;
       }

       const callbackStack = [];

       cachedWasm = readWasm().then(buffer => {
           return WebAssembly.instantiate(buffer, {
             env: {
               mapping_callback(
                 generatedLine,
                 generatedColumn,

                 hasLastGeneratedColumn,
                 lastGeneratedColumn,

                 hasOriginal,
                 source,
                 originalLine,
                 originalColumn,

                 hasName,
                 name
               ) {
                 const mapping = new Mapping();
                 // JS uses 1-based line numbers, wasm uses 0-based.
                 mapping.generatedLine = generatedLine + 1;
                 mapping.generatedColumn = generatedColumn;

                 if (hasLastGeneratedColumn) {
                   // JS uses inclusive last generated column, wasm uses exclusive.
                   mapping.lastGeneratedColumn = lastGeneratedColumn - 1;
                 }

                 if (hasOriginal) {
                   mapping.source = source;
                   // JS uses 1-based line numbers, wasm uses 0-based.
                   mapping.originalLine = originalLine + 1;
                   mapping.originalColumn = originalColumn;

                   if (hasName) {
                     mapping.name = name;
                   }
                 }

                 callbackStack[callbackStack.length - 1](mapping);
               },

               start_all_generated_locations_for() { console.time("all_generated_locations_for"); },
               end_all_generated_locations_for() { console.timeEnd("all_generated_locations_for"); },

               start_compute_column_spans() { console.time("compute_column_spans"); },
               end_compute_column_spans() { console.timeEnd("compute_column_spans"); },

               start_generated_location_for() { console.time("generated_location_for"); },
               end_generated_location_for() { console.timeEnd("generated_location_for"); },

               start_original_location_for() { console.time("original_location_for"); },
               end_original_location_for() { console.timeEnd("original_location_for"); },

               start_parse_mappings() { console.time("parse_mappings"); },
               end_parse_mappings() { console.timeEnd("parse_mappings"); },

               start_sort_by_generated_location() { console.time("sort_by_generated_location"); },
               end_sort_by_generated_location() { console.timeEnd("sort_by_generated_location"); },

               start_sort_by_original_location() { console.time("sort_by_original_location"); },
               end_sort_by_original_location() { console.timeEnd("sort_by_original_location"); },
             }
           });
       }).then(Wasm => {
         return {
           exports: Wasm.instance.exports,
           withMappingCallback: (mappingCallback, f) => {
             callbackStack.push(mappingCallback);
             try {
               f();
             } finally {
               callbackStack.pop();
             }
           }
         };
       }).then(null, e => {
         cachedWasm = null;
         throw e;
       });

       return cachedWasm;
     };
     return wasm;
    }

    var hasRequiredSourceMapConsumer;

    function requireSourceMapConsumer () {
     if (hasRequiredSourceMapConsumer) return sourceMapConsumer;
     hasRequiredSourceMapConsumer = 1;
     /*
      * Copyright 2011 Mozilla Foundation and contributors
      * Licensed under the New BSD license. See LICENSE or:
      * http://opensource.org/licenses/BSD-3-Clause
      */

     const util = requireUtil();
     const binarySearch = requireBinarySearch();
     const ArraySet = requireArraySet().ArraySet;
     requireBase64Vlq(); // eslint-disable-line no-unused-vars
     const readWasm = requireReadWasm();
     const wasm = requireWasm();

     const INTERNAL = Symbol("smcInternal");

     class SourceMapConsumer {
       constructor(aSourceMap, aSourceMapURL) {
         // If the constructor was called by super(), just return Promise<this>.
         // Yes, this is a hack to retain the pre-existing API of the base-class
         // constructor also being an async factory function.
         if (aSourceMap == INTERNAL) {
           return Promise.resolve(this);
         }

         return _factory(aSourceMap, aSourceMapURL);
       }

       static initialize(opts) {
         readWasm.initialize(opts["lib/mappings.wasm"]);
       }

       static fromSourceMap(aSourceMap, aSourceMapURL) {
         return _factoryBSM(aSourceMap, aSourceMapURL);
       }

       /**
        * Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
        * (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
        * function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
        * for `f` to complete, call `destroy` on the consumer, and return `f`'s return
        * value.
        *
--> --------------------

--> maximum size reached

--> --------------------