isomorfeus-preact 10.5.1 → 10.5.2

data/node_modules/stacktrace-gps/node_modules/source-map/source-map.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;

data/node_modules/stacktrace-gps/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "stacktrace-gps",
+  "description": "Turns partial code location into precise code location",
+  "maintainers": [
+    "Eric Wendelin <me@eriwen.com> (https://www.eriwen.com)",
+    "Victor Homyakov <vkhomyackov@gmail.com> (https://github.com/victor-homyakov)",
+    "Oliver Salzburg (https://github.com/oliversalzburg)"
+  ],
+  "version": "3.0.4",
+  "license": "MIT",
+  "keywords": [
+    "stacktrace",
+    "error",
+    "debugger"
+  ],
+  "homepage": "https://www.stacktracejs.com",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stacktracejs/stacktrace-gps.git"
+  },
+  "dependencies": {
+    "source-map": "0.5.6",
+    "stackframe": "^1.1.1"
+  },
+  "devDependencies": {
+    "es6-promise": "^3.0.2",
+    "eslint": "^6.8.0",
+    "jasmine": "^2.7.0",
+    "jasmine-ajax": "^3.3.1",
+    "jasmine-core": "^2.7.0",
+    "karma": "^4.4.1",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-coverage": "^2.0.1",
+    "karma-coveralls": "^2.1.0",
+    "karma-firefox-launcher": "^1.2.0",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-jasmine": "^1.1.2",
+    "karma-jasmine-ajax": "^0.1.13",
+    "karma-opera-launcher": "^1.0.0",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-sauce-launcher": "^2.0.2",
+    "karma-spec-reporter": "^0.0.32",
+    "run-sequence": "^1.1.4",
+    "webpack": "^4.41.5",
+    "webpack-cli": "^3.3.10"
+  },
+  "bugs": {
+    "url": "https://github.com/stacktracejs/stacktrace-gps/issues"
+  },
+  "main": "./stacktrace-gps.js",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "stacktrace-gps.js",
+    "dist/",
+    "node_modules/source-map/"
+  ],
+  "scripts": {
+    "lint": "eslint --fix stacktrace-gps.js spec/",
+    "prepare": "cp stacktrace-gps.js polyfills.js dist/ && ./node_modules/.bin/webpack --mode production && uglifyjs node_modules/stackframe/stackframe.js ./build/bundle.js stacktrace-gps.js -o dist/stacktrace-gps.min.js --compress --mangle --source-map \"url=stacktrace-gps.min.js.map\" && uglifyjs node_modules/es6-promise/dist/es6-promise.js polyfills.js node_modules/stackframe/stackframe.js build/bundle.js stacktrace-gps.js -o dist/stacktrace-gps-with-polyfills.min.js --compress --mangle --source-map \"url=stacktrace-gps-polyfilled.min.js.map\"",
+    "test": "karma start karma.conf.js --single-run",
+    "test-pr": "karma start karma.conf.js --single-run --browsers Firefox,Chrome_Travis",
+    "test-ci": "karma start karma.conf.ci.js --single-run"
+  }
+}

data/node_modules/stacktrace-gps/stacktrace-gps.js

@@ -0,0 +1,342 @@
+(function(root, factory) {
+    'use strict';
+    // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.
+
+    /* istanbul ignore next */
+    if (typeof define === 'function' && define.amd) {
+        define('stacktrace-gps', ['source-map', 'stackframe'], factory);
+    } else if (typeof exports === 'object') {
+        module.exports = factory(require('source-map/lib/source-map-consumer'), require('stackframe'));
+    } else {
+        root.StackTraceGPS = factory(root.SourceMap || root.sourceMap, root.StackFrame);
+    }
+}(this, function(SourceMap, StackFrame) {
+    'use strict';
+
+    /**
+     * Make a X-Domain request to url and callback.
+     *
+     * @param {String} url
+     * @returns {Promise} with response text if fulfilled
+     */
+    function _xdr(url) {
+        return new Promise(function(resolve, reject) {
+            var req = new XMLHttpRequest();
+            req.open('get', url);
+            req.onerror = reject;
+            req.onreadystatechange = function onreadystatechange() {
+                if (req.readyState === 4) {
+                    if ((req.status >= 200 && req.status < 300) ||
+                        (url.substr(0, 7) === 'file://' && req.responseText)) {
+                        resolve(req.responseText);
+                    } else {
+                        reject(new Error('HTTP status: ' + req.status + ' retrieving ' + url));
+                    }
+                }
+            };
+            req.send();
+        });
+
+    }
+
+    /**
+     * Convert a Base64-encoded string into its original representation.
+     * Used for inline sourcemaps.
+     *
+     * @param {String} b64str Base-64 encoded string
+     * @returns {String} original representation of the base64-encoded string.
+     */
+    function _atob(b64str) {
+        if (typeof window !== 'undefined' && window.atob) {
+            return window.atob(b64str);
+        } else {
+            throw new Error('You must supply a polyfill for window.atob in this environment');
+        }
+    }
+
+    function _parseJson(string) {
+        if (typeof JSON !== 'undefined' && JSON.parse) {
+            return JSON.parse(string);
+        } else {
+            throw new Error('You must supply a polyfill for JSON.parse in this environment');
+        }
+    }
+
+    function _findFunctionName(source, lineNumber/*, columnNumber*/) {
+        var syntaxes = [
+            // {name} = function ({args}) TODO args capture
+            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*function\b/,
+            // function {name}({args}) m[1]=name m[2]=args
+            /function\s+([^('"`]*?)\s*\(([^)]*)\)/,
+            // {name} = eval()
+            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*(?:eval|new Function)\b/,
+            // fn_name() {
+            /\b(?!(?:if|for|switch|while|with|catch)\b)(?:(?:static)\s+)?(\S+)\s*\(.*?\)\s*\{/,
+            // {name} = () => {
+            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*\(.*?\)\s*=>/
+        ];
+        var lines = source.split('\n');
+
+        // Walk backwards in the source lines until we find the line which matches one of the patterns above
+        var code = '';
+        var maxLines = Math.min(lineNumber, 20);
+        for (var i = 0; i < maxLines; ++i) {
+            // lineNo is 1-based, source[] is 0-based
+            var line = lines[lineNumber - i - 1];
+            var commentPos = line.indexOf('//');
+            if (commentPos >= 0) {
+                line = line.substr(0, commentPos);
+            }
+
+            if (line) {
+                code = line + code;
+                var len = syntaxes.length;
+                for (var index = 0; index < len; index++) {
+                    var m = syntaxes[index].exec(code);
+                    if (m && m[1]) {
+                        return m[1];
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+
+    function _ensureSupportedEnvironment() {
+        if (typeof Object.defineProperty !== 'function' || typeof Object.create !== 'function') {
+            throw new Error('Unable to consume source maps in older browsers');
+        }
+    }
+
+    function _ensureStackFrameIsLegit(stackframe) {
+        if (typeof stackframe !== 'object') {
+            throw new TypeError('Given StackFrame is not an object');
+        } else if (typeof stackframe.fileName !== 'string') {
+            throw new TypeError('Given file name is not a String');
+        } else if (typeof stackframe.lineNumber !== 'number' ||
+            stackframe.lineNumber % 1 !== 0 ||
+            stackframe.lineNumber < 1) {
+            throw new TypeError('Given line number must be a positive integer');
+        } else if (typeof stackframe.columnNumber !== 'number' ||
+            stackframe.columnNumber % 1 !== 0 ||
+            stackframe.columnNumber < 0) {
+            throw new TypeError('Given column number must be a non-negative integer');
+        }
+        return true;
+    }
+
+    function _findSourceMappingURL(source) {
+        var sourceMappingUrlRegExp = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/mg;
+        var lastSourceMappingUrl;
+        var matchSourceMappingUrl;
+        // eslint-disable-next-line no-cond-assign
+        while (matchSourceMappingUrl = sourceMappingUrlRegExp.exec(source)) {
+            lastSourceMappingUrl = matchSourceMappingUrl[1];
+        }
+        if (lastSourceMappingUrl) {
+            return lastSourceMappingUrl;
+        } else {
+            throw new Error('sourceMappingURL not found');
+        }
+    }
+
+    function _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache) {
+        return new Promise(function(resolve, reject) {
+            var loc = sourceMapConsumer.originalPositionFor({
+                line: stackframe.lineNumber,
+                column: stackframe.columnNumber
+            });
+
+            if (loc.source) {
+                // cache mapped sources
+                var mappedSource = sourceMapConsumer.sourceContentFor(loc.source);
+                if (mappedSource) {
+                    sourceCache[loc.source] = mappedSource;
+                }
+
+                resolve(
+                    // given stackframe and source location, update stackframe
+                    new StackFrame({
+                        functionName: loc.name || stackframe.functionName,
+                        args: stackframe.args,
+                        fileName: loc.source,
+                        lineNumber: loc.line,
+                        columnNumber: loc.column
+                    }));
+            } else {
+                reject(new Error('Could not get original source for given stackframe and source map'));
+            }
+        });
+    }
+
+    /**
+     * @constructor
+     * @param {Object} opts
+     *      opts.sourceCache = {url: "Source String"} => preload source cache
+     *      opts.sourceMapConsumerCache = {/path/file.js.map: SourceMapConsumer}
+     *      opts.offline = True to prevent network requests.
+     *              Best effort without sources or source maps.
+     *      opts.ajax = Promise returning function to make X-Domain requests
+     */
+    return function StackTraceGPS(opts) {
+        if (!(this instanceof StackTraceGPS)) {
+            return new StackTraceGPS(opts);
+        }
+        opts = opts || {};
+
+        this.sourceCache = opts.sourceCache || {};
+        this.sourceMapConsumerCache = opts.sourceMapConsumerCache || {};
+
+        this.ajax = opts.ajax || _xdr;
+
+        this._atob = opts.atob || _atob;
+
+        this._get = function _get(location) {
+            return new Promise(function(resolve, reject) {
+                var isDataUrl = location.substr(0, 5) === 'data:';
+                if (this.sourceCache[location]) {
+                    resolve(this.sourceCache[location]);
+                } else if (opts.offline && !isDataUrl) {
+                    reject(new Error('Cannot make network requests in offline mode'));
+                } else {
+                    if (isDataUrl) {
+                        // data URLs can have parameters.
+                        // see http://tools.ietf.org/html/rfc2397
+                        var supportedEncodingRegexp =
+                            /^data:application\/json;([\w=:"-]+;)*base64,/;
+                        var match = location.match(supportedEncodingRegexp);
+                        if (match) {
+                            var sourceMapStart = match[0].length;
+                            var encodedSource = location.substr(sourceMapStart);
+                            var source = this._atob(encodedSource);
+                            this.sourceCache[location] = source;
+                            resolve(source);
+                        } else {
+                            reject(new Error('The encoding of the inline sourcemap is not supported'));
+                        }
+                    } else {
+                        var xhrPromise = this.ajax(location, {method: 'get'});
+                        // Cache the Promise to prevent duplicate in-flight requests
+                        this.sourceCache[location] = xhrPromise;
+                        xhrPromise.then(resolve, reject);
+                    }
+                }
+            }.bind(this));
+        };
+
+        /**
+         * Creating SourceMapConsumers is expensive, so this wraps the creation of a
+         * SourceMapConsumer in a per-instance cache.
+         *
+         * @param {String} sourceMappingURL = URL to fetch source map from
+         * @param {String} defaultSourceRoot = Default source root for source map if undefined
+         * @returns {Promise} that resolves a SourceMapConsumer
+         */
+        this._getSourceMapConsumer = function _getSourceMapConsumer(sourceMappingURL, defaultSourceRoot) {
+            return new Promise(function(resolve) {
+                if (this.sourceMapConsumerCache[sourceMappingURL]) {
+                    resolve(this.sourceMapConsumerCache[sourceMappingURL]);
+                } else {
+                    var sourceMapConsumerPromise = new Promise(function(resolve, reject) {
+                        return this._get(sourceMappingURL).then(function(sourceMapSource) {
+                            if (typeof sourceMapSource === 'string') {
+                                sourceMapSource = _parseJson(sourceMapSource.replace(/^\)\]\}'/, ''));
+                            }
+                            if (typeof sourceMapSource.sourceRoot === 'undefined') {
+                                sourceMapSource.sourceRoot = defaultSourceRoot;
+                            }
+
+                            resolve(new SourceMap.SourceMapConsumer(sourceMapSource));
+                        }, reject);
+                    }.bind(this));
+                    this.sourceMapConsumerCache[sourceMappingURL] = sourceMapConsumerPromise;
+                    resolve(sourceMapConsumerPromise);
+                }
+            }.bind(this));
+        };
+
+        /**
+         * Given a StackFrame, enhance function name and use source maps for a
+         * better StackFrame.
+         *
+         * @param {StackFrame} stackframe object
+         * @returns {Promise} that resolves with with source-mapped StackFrame
+         */
+        this.pinpoint = function StackTraceGPS$$pinpoint(stackframe) {
+            return new Promise(function(resolve, reject) {
+                this.getMappedLocation(stackframe).then(function(mappedStackFrame) {
+                    function resolveMappedStackFrame() {
+                        resolve(mappedStackFrame);
+                    }
+
+                    this.findFunctionName(mappedStackFrame)
+                        .then(resolve, resolveMappedStackFrame)
+                        // eslint-disable-next-line no-unexpected-multiline
+                        ['catch'](resolveMappedStackFrame);
+                }.bind(this), reject);
+            }.bind(this));
+        };
+
+        /**
+         * Given a StackFrame, guess function name from location information.
+         *
+         * @param {StackFrame} stackframe
+         * @returns {Promise} that resolves with enhanced StackFrame.
+         */
+        this.findFunctionName = function StackTraceGPS$$findFunctionName(stackframe) {
+            return new Promise(function(resolve, reject) {
+                _ensureStackFrameIsLegit(stackframe);
+                this._get(stackframe.fileName).then(function getSourceCallback(source) {
+                    var lineNumber = stackframe.lineNumber;
+                    var columnNumber = stackframe.columnNumber;
+                    var guessedFunctionName = _findFunctionName(source, lineNumber, columnNumber);
+                    // Only replace functionName if we found something
+                    if (guessedFunctionName) {
+                        resolve(new StackFrame({
+                            functionName: guessedFunctionName,
+                            args: stackframe.args,
+                            fileName: stackframe.fileName,
+                            lineNumber: lineNumber,
+                            columnNumber: columnNumber
+                        }));
+                    } else {
+                        resolve(stackframe);
+                    }
+                }, reject)['catch'](reject);
+            }.bind(this));
+        };
+
+        /**
+         * Given a StackFrame, seek source-mapped location and return new enhanced StackFrame.
+         *
+         * @param {StackFrame} stackframe
+         * @returns {Promise} that resolves with enhanced StackFrame.
+         */
+        this.getMappedLocation = function StackTraceGPS$$getMappedLocation(stackframe) {
+            return new Promise(function(resolve, reject) {
+                _ensureSupportedEnvironment();
+                _ensureStackFrameIsLegit(stackframe);
+
+                var sourceCache = this.sourceCache;
+                var fileName = stackframe.fileName;
+                this._get(fileName).then(function(source) {
+                    var sourceMappingURL = _findSourceMappingURL(source);
+                    var isDataUrl = sourceMappingURL.substr(0, 5) === 'data:';
+                    var defaultSourceRoot = fileName.substring(0, fileName.lastIndexOf('/') + 1);
+
+                    if (sourceMappingURL[0] !== '/' && !isDataUrl && !(/^https?:\/\/|^\/\//i).test(sourceMappingURL)) {
+                        sourceMappingURL = defaultSourceRoot + sourceMappingURL;
+                    }
+
+                    return this._getSourceMapConsumer(sourceMappingURL, defaultSourceRoot)
+                        .then(function(sourceMapConsumer) {
+                            return _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache)
+                                .then(resolve)['catch'](function() {
+                                    resolve(stackframe);
+                                });
+                        });
+                }.bind(this), reject)['catch'](reject);
+            }.bind(this));
+        };
+    };
+}));

data/node_modules/stacktrace-js/CHANGELOG.md

@@ -0,0 +1,97 @@
+## v2.0.0
+
+### ES6 Support
+
+ES6 code is now parsed and enhanced!
+
+### Extensible StackFrames
+
+StackFrames returned are now able to report on whether a function call was a `Constructor`, `native` code, or `eval` code. 
+
+### MIT License
+
+The community [has voted](https://github.com/stacktracejs/stacktrace.js/issues/187) to change the license of the project to the [MIT License](https://opensource.org/licenses/MIT)
+
+## v1.3.0
+* `Stacktrace.getSync()` gets a stack trace, synchronously. It does not attempt to map sources or guess function names, because those typically require network requests.
+
+## v1.2.0
+
+* `StackTrace.report` now accepts an error message argument, and will add a `message: "given thing"` to the JSON payload if it is provided.
+* Various bug fixes from v1.1.0
+
+## v1.1.0
+
+### Better parsing
+Updated [error-stack-parser](https://github.com/stacktracejs/error-stack-parser) to v1.3 which parses eval stack entries in a better way and fixes a bunch of bugs. 
+
+### Better resource handling
+Updated [stacktrace-gps](https://github.com/stacktracejs/stacktrace-gps). Now reuses the same instance to avoid duplicate requests for the same resource by default. 
+
+### Better dev experience
+JSCS and automated PR testing have been implemented to ensure consistent styles and quick feedback.
+
+> Possibly breaking changes: ErrorStackParser now provides it's own polyfill for `Array.map` and `Array.filter`. `eval` information is will display differently in stack traces.
+
+## v1.0.0
+
+### stacktrace.js is reborn
+
+stacktrace.js is now modularized into 5 projects:
+
+* [stacktrace-gps](https://github.com/stacktracejs/stacktrace-gps) - turn partial code location into precise code location
+* [error-stack-parser](https://github.com/stacktracejs/error-stack-parser) - extract meaning from JS Errors
+* [stack-generator](https://github.com/stacktracejs/stack-generator) - generate artificial backtrace in old browsers
+* [stackframe](https://github.com/stacktracejs/stackframe) - JS Object representation of a stack frame
+
+... and putting it all together: [stacktrace.js](stacktracejs/stacktrace.js) for instrumenting your code and generating stack traces!
+
+### Key Features
+
+* Fully asynchronous API, using [Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). Use your own polyfill or use [our distribution with polyfills included](https://github.com/stacktracejs/stacktrace.js/blob/master/dist/stacktrace-with-polyfills.min.js). See the [Migration Guide](http://www.stacktracejs.com/docs/v0-migration-guide)
+* [Source Maps](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/) support
+* Forward-compatible: stacktrace.js no longer assumes a given browser formats Error stacks in a given way. This prevents new browser versions from breaking error parsing
+* Stack entries are now fully parsed and returned as [StackFrame objects](https://github.com/stacktracejs/stackframe). Prefer the old format? - just call `.toString()`!
+* Use only what you need. All 5 projects work independently as well as together!
+* iOS 8+ Safari support
+
+### Available everywhere
+
+```
+npm install stacktrace-js
+bower install stacktrace-js
+component install stacktracejs/stacktrace.js
+https://cdnjs.cloudflare.com/ajax/libs/stacktrace.js/1.0.0/stacktrace.min.js
+```
+
+### Better for contributors
+
+* gulp build
+* TravisCI + Sauce for testing a bunch of browsers
+* EditorConfig for style adherence
+
+## v0.6.2
+
+* Ignore test/ dir in bower
+* Migrate references eriwen/javascript-stacktrace -> stacktracejs/stacktrace.js
+
+## v0.6.1
+
+* Fix printStackTrace throws exception with "use strict" code and PhantomJS
+
+## v0.6.0
+
+* Added AMD support using a UMD pattern (thanks @jeffrose)
+
+## v0.5.3
+
+* Fix Chrome 27 detection; Chrome no longer has Error#arguments
+
+## v0.5.1
+
+* Fix Bower integration; Added proper bower.json file
+
+## v0.5.0
+
+* Lots and lots of stuff
+