@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-route-loader/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    getRouteLoaderEntry: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    getRouteLoaderEntry: function() {
+        return getRouteLoaderEntry;
+    }
+});
+const _querystring = require("querystring");
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _routekind = require("../../../../server/route-kind");
+const _normalizepagepath = require("../../../../shared/lib/page-path/normalize-page-path");
+const _utils = require("../utils");
+const _utils1 = require("../../../utils");
+const _loadentrypoint = require("../../../load-entrypoint");
+function getRouteLoaderEntry(options) {
+    switch(options.kind){
+        case _routekind.RouteKind.PAGES:
+            {
+                const query = {
+                    kind: options.kind,
+                    page: options.page,
+                    preferredRegion: options.preferredRegion,
+                    absolutePagePath: options.absolutePagePath,
+                    // These are the path references to the internal components that may be
+                    // overridden by userland components.
+                    absoluteAppPath: options.pages['/_app'],
+                    absoluteDocumentPath: options.pages['/_document'],
+                    middlewareConfigBase64: (0, _utils.encodeToBase64)(options.middlewareConfig)
+                };
+                return `next-route-loader?${(0, _querystring.stringify)(query)}!`;
+            }
+        case _routekind.RouteKind.PAGES_API:
+            {
+                const query = {
+                    kind: options.kind,
+                    page: options.page,
+                    preferredRegion: options.preferredRegion,
+                    absolutePagePath: options.absolutePagePath,
+                    middlewareConfigBase64: (0, _utils.encodeToBase64)(options.middlewareConfig)
+                };
+                return `next-route-loader?${(0, _querystring.stringify)(query)}!`;
+            }
+        default:
+            {
+                throw Object.defineProperty(new Error('Invariant: Unexpected route kind'), "__NEXT_ERROR_CODE", {
+                    value: "E453",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+    }
+}
+const loadPages = async ({ page, absolutePagePath, absoluteDocumentPath, absoluteAppPath, preferredRegion, middlewareConfigBase64 }, buildInfo)=>{
+    const middlewareConfig = (0, _utils.decodeFromBase64)(middlewareConfigBase64);
+    // Attach build info to the module.
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    let file = await (0, _loadentrypoint.loadEntrypoint)('pages', {
+        VAR_USERLAND: absolutePagePath,
+        VAR_MODULE_DOCUMENT: absoluteDocumentPath,
+        VAR_MODULE_APP: absoluteAppPath,
+        VAR_DEFINITION_PAGE: (0, _normalizepagepath.normalizePagePath)(page),
+        VAR_DEFINITION_PATHNAME: page
+    });
+    if ((0, _utils1.isInstrumentationHookFile)(page)) {
+        // When we're building the instrumentation page (only when the
+        // instrumentation file conflicts with a page also labeled
+        // /instrumentation) hoist the `register` method.
+        file += '\nexport const register = hoist(userland, "register")';
+    }
+    return file;
+};
+const loadPagesAPI = async ({ page, absolutePagePath, preferredRegion, middlewareConfigBase64 }, buildInfo)=>{
+    const middlewareConfig = (0, _utils.decodeFromBase64)(middlewareConfigBase64);
+    // Attach build info to the module.
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    return await (0, _loadentrypoint.loadEntrypoint)('pages-api', {
+        VAR_USERLAND: absolutePagePath,
+        VAR_DEFINITION_PAGE: (0, _normalizepagepath.normalizePagePath)(page),
+        VAR_DEFINITION_PATHNAME: page
+    });
+};
+/**
+ * Handles the `next-route-loader` options.
+ * @returns the loader definition function
+ */ const loader = async function() {
+    if (!this._module) {
+        throw Object.defineProperty(new Error('Invariant: expected this to reference a module'), "__NEXT_ERROR_CODE", {
+            value: "E383",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    const opts = this.getOptions();
+    switch(opts.kind){
+        case _routekind.RouteKind.PAGES:
+            {
+                return await loadPages(opts, buildInfo);
+            }
+        case _routekind.RouteKind.PAGES_API:
+            {
+                return await loadPagesAPI(opts, buildInfo);
+            }
+        default:
+            {
+                throw Object.defineProperty(new Error('Invariant: Unexpected route kind'), "__NEXT_ERROR_CODE", {
+                    value: "E453",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+    }
+};
+const _default = loader;
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-style-loader/index.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _stringifyrequest = require("../../stringify-request");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const loaderApi = ()=>{};
+loaderApi.pitch = function loader(request) {
+    const loaderSpan = this.currentTraceSpan.traceChild('next-style-loader');
+    return loaderSpan.traceFn(()=>{
+        const options = this.getOptions();
+        const insert = typeof options.insert === 'undefined' ? '"head"' : typeof options.insert === 'string' ? JSON.stringify(options.insert) : options.insert.toString();
+        const injectType = options.injectType || 'styleTag';
+        const esModule = typeof options.esModule !== 'undefined' ? options.esModule : false;
+        delete options.esModule;
+        switch(injectType){
+            case 'linkTag':
+                {
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  module.hot.accept(
+    ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)},
+    function() {
+     ${esModule ? 'update(content);' : `content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+           content = content.__esModule ? content.default : content;
+
+           update(content);`}
+    }
+  );
+
+  module.hot.dispose(function() {
+    update();
+  });
+}` : '';
+                    return `${esModule ? `import api from ${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoLinkTag.js')}`)};
+            import content from ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)};` : `var api = require(${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoLinkTag.js')}`)});
+            var content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;`}
+
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+
+var update = api(content, options);
+
+${hmrCode}
+
+${esModule ? 'export default {}' : ''}`;
+                }
+            case 'lazyStyleTag':
+            case 'lazySingletonStyleTag':
+                {
+                    const isSingleton = injectType === 'lazySingletonStyleTag';
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  if (!content.locals || module.hot.invalidate) {
+    
+    var isEqualLocals = ${// eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+                    require('./runtime/isEqualLocals').toString()};
+    console.log({isEqualLocals})
+    var oldLocals = content.locals;
+
+    module.hot.accept(
+      ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)},
+      function () {
+        ${esModule ? `if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              if (update && refs > 0) {
+                update(content);
+              }` : `content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+              content = content.__esModule ? content.default : content;
+
+              if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              if (update && refs > 0) {
+                update(content);
+              }`}
+      }
+    )
+  }
+
+  module.hot.dispose(function() {
+    if (update) {
+      update();
+    }
+  });
+}` : '';
+                    return `${esModule ? `import api from ${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoStyleTag.js')}`)};
+            import content from ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)};` : `var api = require(${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoStyleTag.js')}`)});
+            var content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;
+
+            if (typeof content === 'string') {
+              content = [[module.id, content, '']];
+            }`}
+
+var refs = 0;
+var update;
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+options.singleton = ${isSingleton};
+
+var exported = {};
+
+exported.locals = content.locals || {};
+exported.use = function() {
+  if (!(refs++)) {
+    update = api(content, options);
+  }
+
+  return exported;
+};
+exported.unuse = function() {
+  if (refs > 0 && !--refs) {
+    update();
+    update = null;
+  }
+};
+
+${hmrCode}
+
+${esModule ? 'export default' : 'module.exports ='} exported;`;
+                }
+            case 'styleTag':
+            case 'singletonStyleTag':
+            default:
+                {
+                    const isSingleton = injectType === 'singletonStyleTag';
+                    const hmrCode = this.hot ? `
+if (module.hot) {
+  if (!content.locals || module.hot.invalidate) {
+    var isEqualLocals = ${// eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+                    require('./runtime/isEqualLocals').toString()};
+    var oldLocals = content.locals;
+
+    module.hot.accept(
+      ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)},
+      function () {
+        ${esModule ? `if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              update(content);` : `content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+              content = content.__esModule ? content.default : content;
+
+              if (typeof content === 'string') {
+                content = [[module.id, content, '']];
+              }
+
+              if (!isEqualLocals(oldLocals, content.locals)) {
+                module.hot.invalidate();
+
+                return;
+              }
+
+              oldLocals = content.locals;
+
+              update(content);`}
+      }
+    )
+  }
+
+  module.hot.dispose(function() {
+    update();
+  });
+}` : '';
+                    return `${esModule ? `import api from ${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoStyleTag.js')}`)};
+            import content from ${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)};` : `var api = require(${(0, _stringifyrequest.stringifyRequest)(this, `!${_path.default.join(__dirname, 'runtime/injectStylesIntoStyleTag.js')}`)});
+            var content = require(${(0, _stringifyrequest.stringifyRequest)(this, `!!${request}`)});
+
+            content = content.__esModule ? content.default : content;
+
+            if (typeof content === 'string') {
+              content = [[module.id, content, '']];
+            }`}
+
+var options = ${JSON.stringify(options)};
+
+options.insert = ${insert};
+options.singleton = ${isSingleton};
+
+var update = api(content, options);
+
+${hmrCode}
+
+${esModule ? 'export default' : 'module.exports ='} content.locals || {};`;
+                }
+        }
+    });
+};
+module.exports = loaderApi;
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoLinkTag.js

@@ -0,0 +1,61 @@
+/// <reference types="webpack/module.d.ts" />
+"use strict";
+const getTarget = (()=>{
+    const memo = {};
+    return function memorize(target) {
+        if (typeof memo[target] === 'undefined') {
+            let styleTarget = document.querySelector(target);
+            // Special case to return head of iframe instead of iframe itself
+            if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
+                try {
+                    // This will throw an exception if access to iframe is blocked
+                    // due to cross-origin restrictions
+                    styleTarget = styleTarget.contentDocument.head;
+                } catch (e) {
+                    // istanbul ignore next
+                    styleTarget = null;
+                }
+            }
+            memo[target] = styleTarget;
+        }
+        return memo[target];
+    };
+})();
+module.exports = (url, options)=>{
+    options = options || {};
+    options.attributes = typeof options.attributes === 'object' ? options.attributes : {};
+    if (typeof options.attributes.nonce === 'undefined') {
+        const nonce = typeof __webpack_nonce__ !== 'undefined' ? __webpack_nonce__ : null;
+        if (nonce) {
+            options.attributes.nonce = nonce;
+        }
+    }
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    Object.keys(options.attributes).forEach((key)=>{
+        link.setAttribute(key, options.attributes[key]);
+    });
+    if (typeof options.insert === 'function') {
+        options.insert(link);
+    } else {
+        const target = getTarget(options.insert || 'head');
+        if (!target) {
+            throw Object.defineProperty(new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."), "__NEXT_ERROR_CODE", {
+                value: "E245",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        target.appendChild(link);
+    }
+    return (newUrl)=>{
+        if (typeof newUrl === 'string') {
+            link.href = newUrl;
+        } else {
+            link.parentNode.removeChild(link);
+        }
+    };
+};
+
+//# sourceMappingURL=injectStylesIntoLinkTag.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-style-loader/runtime/injectStylesIntoStyleTag.js

@@ -0,0 +1,221 @@
+/// <reference types="webpack/module.d.ts" />
+"use strict";
+const isOldIE = function isOldIE() {
+    let memo;
+    return function memorize() {
+        if (typeof memo === 'undefined') {
+            // Test for IE <= 9 as proposed by Browserhacks
+            // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
+            // Tests for existence of standard globals is to allow style-loader
+            // to operate correctly into non-standard environments
+            // @see https://github.com/webpack-contrib/style-loader/issues/177
+            memo = Boolean(window && document && document.all && !window.atob);
+        }
+        return memo;
+    };
+}();
+const getTargetElement = function() {
+    const memo = {};
+    return function memorize(target) {
+        if (typeof memo[target] === 'undefined') {
+            let styleTarget = document.querySelector(target);
+            // Special case to return head of iframe instead of iframe itself
+            if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
+                try {
+                    // This will throw an exception if access to iframe is blocked
+                    // due to cross-origin restrictions
+                    styleTarget = styleTarget.contentDocument.head;
+                } catch (e) {
+                    // istanbul ignore next
+                    styleTarget = null;
+                }
+            }
+            memo[target] = styleTarget;
+        }
+        return memo[target];
+    };
+}();
+const stylesInDom = [];
+function getIndexByIdentifier(identifier) {
+    let result = -1;
+    for(let i = 0; i < stylesInDom.length; i++){
+        if (stylesInDom[i].identifier === identifier) {
+            result = i;
+            break;
+        }
+    }
+    return result;
+}
+function modulesToDom(list, options) {
+    const idCountMap = {};
+    const identifiers = [];
+    for(let i = 0; i < list.length; i++){
+        const item = list[i];
+        const id = options.base ? item[0] + options.base : item[0];
+        const count = idCountMap[id] || 0;
+        const identifier = id + ' ' + count.toString();
+        idCountMap[id] = count + 1;
+        const index = getIndexByIdentifier(identifier);
+        const obj = {
+            css: item[1],
+            media: item[2],
+            sourceMap: item[3]
+        };
+        if (index !== -1) {
+            stylesInDom[index].references++;
+            stylesInDom[index].updater(obj);
+        } else {
+            stylesInDom.push({
+                identifier: identifier,
+                updater: addStyle(obj, options),
+                references: 1
+            });
+        }
+        identifiers.push(identifier);
+    }
+    return identifiers;
+}
+function insertStyleElement(options) {
+    const style = document.createElement('style');
+    const attributes = options.attributes || {};
+    if (typeof attributes.nonce === 'undefined') {
+        const nonce = typeof __webpack_nonce__ !== 'undefined' ? __webpack_nonce__ : null;
+        if (nonce) {
+            attributes.nonce = nonce;
+        }
+    }
+    Object.keys(attributes).forEach(function(key) {
+        style.setAttribute(key, attributes[key]);
+    });
+    if (typeof options.insert === 'function') {
+        options.insert(style);
+    } else {
+        const target = getTargetElement(options.insert || 'head');
+        if (!target) {
+            throw Object.defineProperty(new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."), "__NEXT_ERROR_CODE", {
+                value: "E245",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        target.appendChild(style);
+    }
+    return style;
+}
+function removeStyleElement(style) {
+    // istanbul ignore if
+    if (style.parentNode === null) {
+        return false;
+    }
+    style.parentNode.removeChild(style);
+}
+/* istanbul ignore next  */ const replaceText = function replaceText() {
+    const textStore = [];
+    return function replace(index, replacement) {
+        textStore[index] = replacement;
+        return textStore.filter(Boolean).join('\n');
+    };
+}();
+function applyToSingletonTag(style, index, remove, obj) {
+    const css = remove ? '' : obj.media ? '@media ' + obj.media + ' {' + obj.css + '}' : obj.css;
+    // For old IE
+    /* istanbul ignore if  */ if (style.styleSheet) {
+        style.styleSheet.cssText = replaceText(index, css);
+    } else {
+        const cssNode = document.createTextNode(css);
+        const childNodes = style.childNodes;
+        if (childNodes[index]) {
+            style.removeChild(childNodes[index]);
+        }
+        if (childNodes.length) {
+            style.insertBefore(cssNode, childNodes[index]);
+        } else {
+            style.appendChild(cssNode);
+        }
+    }
+}
+function applyToTag(style, _options, obj) {
+    let css = obj.css;
+    const media = obj.media;
+    const sourceMap = obj.sourceMap;
+    if (media) {
+        style.setAttribute('media', media);
+    } else {
+        style.removeAttribute('media');
+    }
+    if (sourceMap && typeof btoa !== 'undefined') {
+        css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */';
+    }
+    // For old IE
+    /* istanbul ignore if  */ if (style.styleSheet) {
+        style.styleSheet.cssText = css;
+    } else {
+        while(style.firstChild){
+            style.removeChild(style.firstChild);
+        }
+        style.appendChild(document.createTextNode(css));
+    }
+}
+let singleton = null;
+let singletonCounter = 0;
+function addStyle(obj, options) {
+    let style;
+    let update;
+    let remove;
+    if (options.singleton) {
+        const styleIndex = singletonCounter++;
+        style = singleton || (singleton = insertStyleElement(options));
+        update = applyToSingletonTag.bind(null, style, styleIndex, false);
+        remove = applyToSingletonTag.bind(null, style, styleIndex, true);
+    } else {
+        style = insertStyleElement(options);
+        update = applyToTag.bind(null, style, options);
+        remove = function() {
+            removeStyleElement(style);
+        };
+    }
+    update(obj);
+    return function updateStyle(newObj) {
+        if (newObj) {
+            if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) {
+                return;
+            }
+            update(obj = newObj);
+        } else {
+            remove();
+        }
+    };
+}
+module.exports = function(list, options) {
+    options = options || {};
+    // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
+    // tags it will allow on a page
+    if (!options.singleton && typeof options.singleton !== 'boolean') {
+        options.singleton = isOldIE();
+    }
+    list = list || [];
+    let lastIdentifiers = modulesToDom(list, options);
+    return function update(newList) {
+        newList = newList || [];
+        if (Object.prototype.toString.call(newList) !== '[object Array]') {
+            return;
+        }
+        for(let i = 0; i < lastIdentifiers.length; i++){
+            const identifier = lastIdentifiers[i];
+            const index = getIndexByIdentifier(identifier);
+            stylesInDom[index].references--;
+        }
+        const newLastIdentifiers = modulesToDom(newList, options);
+        for(let i = 0; i < lastIdentifiers.length; i++){
+            const identifier = lastIdentifiers[i];
+            const index = getIndexByIdentifier(identifier);
+            if (stylesInDom[index].references === 0) {
+                stylesInDom[index].updater();
+                stylesInDom.splice(index, 1);
+            }
+        }
+        lastIdentifiers = newLastIdentifiers;
+    };
+};
+
+//# sourceMappingURL=injectStylesIntoStyleTag.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-style-loader/runtime/isEqualLocals.js

@@ -0,0 +1,27 @@
+"use strict";
+function isEqualLocals(a, b, isNamedExport) {
+    if (!a && b || a && !b) {
+        return false;
+    }
+    let p;
+    for(p in a){
+        if (isNamedExport && p === 'default') {
+            continue;
+        }
+        if (a[p] !== b[p]) {
+            return false;
+        }
+    }
+    for(p in b){
+        if (isNamedExport && p === 'default') {
+            continue;
+        }
+        if (!a[p]) {
+            return false;
+        }
+    }
+    return true;
+}
+module.exports = isEqualLocals;
+
+//# sourceMappingURL=isEqualLocals.js.map