@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/next/dist/build/webpack/loaders/css-loader/src/CssSyntaxError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return CssSyntaxError;
+    }
+});
+class CssSyntaxError extends Error {
+    constructor(error){
+        super(error);
+        const { reason, line, column } = error;
+        this.name = 'CssSyntaxError';
+        // Based on https://github.com/postcss/postcss/blob/master/lib/css-syntax-error.es6#L132
+        // We don't need `plugin` and `file` properties.
+        this.message = `${this.name}\n\n`;
+        if (typeof line !== 'undefined') {
+            this.message += `(${line}:${column}) `;
+        }
+        this.message += reason;
+        const code = error.showSourceCode();
+        if (code) {
+            this.message += `\n\n${code}\n`;
+        }
+        // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
+        this.stack = false;
+    }
+}
+
+//# sourceMappingURL=CssSyntaxError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/css-loader/src/camelcase.js

@@ -0,0 +1,93 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const preserveCamelCase = (string, locale)=>{
+    let isLastCharLower = false;
+    let isLastCharUpper = false;
+    let isLastLastCharUpper = false;
+    for(let i = 0; i < string.length; i++){
+        const character = string[i];
+        if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+            string = string.slice(0, i) + '-' + string.slice(i);
+            isLastCharLower = false;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = true;
+            i++;
+        } else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
+            string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = false;
+            isLastCharLower = true;
+        } else {
+            isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
+        }
+    }
+    return string;
+};
+const preserveConsecutiveUppercase = (input)=>{
+    return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, (m1)=>m1.toLowerCase());
+};
+const postProcess = (input, options)=>{
+    return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1)=>p1.toLocaleUpperCase(options.locale)).replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, (m)=>m.toLocaleUpperCase(options.locale));
+};
+const camelCase = (input, options)=>{
+    if (!(typeof input === 'string' || Array.isArray(input))) {
+        throw Object.defineProperty(new TypeError('Expected the input to be `string | string[]`'), "__NEXT_ERROR_CODE", {
+            value: "E613",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    options = {
+        pascalCase: false,
+        preserveConsecutiveUppercase: false,
+        ...options
+    };
+    if (Array.isArray(input)) {
+        input = input.map((x)=>x.trim()).filter((x)=>x.length).join('-');
+    } else {
+        input = input.trim();
+    }
+    if (input.length === 0) {
+        return '';
+    }
+    if (input.length === 1) {
+        return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
+    }
+    const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
+    if (hasUpperCase) {
+        input = preserveCamelCase(input, options.locale);
+    }
+    input = input.replace(/^[_.\- ]+/, '');
+    if (options.preserveConsecutiveUppercase) {
+        input = preserveConsecutiveUppercase(input);
+    } else {
+        input = input.toLocaleLowerCase();
+    }
+    if (options.pascalCase) {
+        input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
+    }
+    return postProcess(input, options);
+};
+const _default = camelCase;
+
+//# sourceMappingURL=camelcase.js.map

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

@@ -0,0 +1,287 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return loader;
+    }
+});
+const _CssSyntaxError = /*#__PURE__*/ _interop_require_default(require("./CssSyntaxError"));
+const _Warning = /*#__PURE__*/ _interop_require_default(require("../../postcss-loader/src/Warning"));
+const _stringifyrequest = require("../../../stringify-request");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const moduleRegExp = /\.module\.\w+$/i;
+function getModulesOptions(rawOptions, loaderContext) {
+    const { resourcePath } = loaderContext;
+    if (typeof rawOptions.modules === 'undefined') {
+        const isModules = moduleRegExp.test(resourcePath);
+        if (!isModules) {
+            return false;
+        }
+    } else if (typeof rawOptions.modules === 'boolean' && rawOptions.modules === false) {
+        return false;
+    }
+    let modulesOptions = {
+        compileType: rawOptions.icss ? 'icss' : 'module',
+        auto: true,
+        mode: 'local',
+        exportGlobals: false,
+        localIdentName: '[hash:base64]',
+        localIdentContext: loaderContext.rootContext,
+        localIdentHashPrefix: '',
+        localIdentRegExp: undefined,
+        namedExport: false,
+        exportLocalsConvention: 'asIs',
+        exportOnlyLocals: false
+    };
+    if (typeof rawOptions.modules === 'boolean' || typeof rawOptions.modules === 'string') {
+        modulesOptions.mode = typeof rawOptions.modules === 'string' ? rawOptions.modules : 'local';
+    } else {
+        if (rawOptions.modules) {
+            if (typeof rawOptions.modules.auto === 'boolean') {
+                const isModules = rawOptions.modules.auto && moduleRegExp.test(resourcePath);
+                if (!isModules) {
+                    return false;
+                }
+            } else if (rawOptions.modules.auto instanceof RegExp) {
+                const isModules = rawOptions.modules.auto.test(resourcePath);
+                if (!isModules) {
+                    return false;
+                }
+            } else if (typeof rawOptions.modules.auto === 'function') {
+                const isModule = rawOptions.modules.auto(resourcePath);
+                if (!isModule) {
+                    return false;
+                }
+            }
+            if (rawOptions.modules.namedExport === true && typeof rawOptions.modules.exportLocalsConvention === 'undefined') {
+                modulesOptions.exportLocalsConvention = 'camelCaseOnly';
+            }
+        }
+        modulesOptions = {
+            ...modulesOptions,
+            ...rawOptions.modules || {}
+        };
+    }
+    if (typeof modulesOptions.mode === 'function') {
+        modulesOptions.mode = modulesOptions.mode(loaderContext.resourcePath);
+    }
+    if (modulesOptions.namedExport === true) {
+        if (rawOptions.esModule === false) {
+            throw Object.defineProperty(new Error('The "modules.namedExport" option requires the "esModules" option to be enabled'), "__NEXT_ERROR_CODE", {
+                value: "E103",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (modulesOptions.exportLocalsConvention !== 'camelCaseOnly') {
+            throw Object.defineProperty(new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly"'), "__NEXT_ERROR_CODE", {
+                value: "E23",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    return modulesOptions;
+}
+function normalizeOptions(rawOptions, loaderContext) {
+    if (rawOptions.icss) {
+        loaderContext.emitWarning(Object.defineProperty(new Error('The "icss" option is deprecated, use "modules.compileType: "icss"" instead'), "__NEXT_ERROR_CODE", {
+            value: "E476",
+            enumerable: false,
+            configurable: true
+        }));
+    }
+    const modulesOptions = getModulesOptions(rawOptions, loaderContext);
+    return {
+        url: typeof rawOptions.url === 'undefined' ? true : rawOptions.url,
+        import: typeof rawOptions.import === 'undefined' ? true : rawOptions.import,
+        modules: modulesOptions,
+        // TODO remove in the next major release
+        icss: typeof rawOptions.icss === 'undefined' ? false : rawOptions.icss,
+        sourceMap: typeof rawOptions.sourceMap === 'boolean' ? rawOptions.sourceMap : loaderContext.sourceMap,
+        importLoaders: typeof rawOptions.importLoaders === 'string' ? parseInt(rawOptions.importLoaders, 10) : rawOptions.importLoaders,
+        esModule: typeof rawOptions.esModule === 'undefined' ? true : rawOptions.esModule,
+        fontLoader: rawOptions.fontLoader
+    };
+}
+async function loader(content, map, meta) {
+    const rawOptions = this.getOptions();
+    const plugins = [];
+    const callback = this.async();
+    const loaderSpan = this.currentTraceSpan.traceChild('css-loader');
+    loaderSpan.traceAsyncFn(async ()=>{
+        let options;
+        try {
+            options = normalizeOptions(rawOptions, this);
+        } catch (error) {
+            throw error;
+        }
+        const { postcss } = await rawOptions.postcss();
+        const { shouldUseModulesPlugins, shouldUseImportPlugin, shouldUseURLPlugin, shouldUseIcssPlugin, getPreRequester, getExportCode, getFilter, getImportCode, getModuleCode, getModulesPlugins, normalizeSourceMap, sort } = require('./utils');
+        const { icssParser, importParser, urlParser } = require('./plugins');
+        const replacements = [];
+        // if it's a font loader next-font-loader will have exports that should be exported as is
+        const exports1 = options.fontLoader ? meta.exports : [];
+        if (shouldUseModulesPlugins(options)) {
+            plugins.push(...getModulesPlugins(options, this, meta));
+        }
+        const importPluginImports = [];
+        const importPluginApi = [];
+        if (shouldUseImportPlugin(options)) {
+            const resolver = this.getResolve({
+                conditionNames: [
+                    'style'
+                ],
+                extensions: [
+                    '.css'
+                ],
+                mainFields: [
+                    'css',
+                    'style',
+                    'main',
+                    '...'
+                ],
+                mainFiles: [
+                    'index',
+                    '...'
+                ],
+                restrictions: [
+                    /\.css$/i
+                ]
+            });
+            plugins.push(importParser({
+                imports: importPluginImports,
+                api: importPluginApi,
+                context: this.context,
+                rootContext: this.rootContext,
+                filter: getFilter(options.import, this.resourcePath),
+                resolver,
+                urlHandler: (url)=>(0, _stringifyrequest.stringifyRequest)(this, getPreRequester(this)(options.importLoaders) + url)
+            }));
+        }
+        const urlPluginImports = [];
+        if (shouldUseURLPlugin(options)) {
+            const urlResolver = this.getResolve({
+                conditionNames: [
+                    'asset'
+                ],
+                mainFields: [
+                    'asset'
+                ],
+                mainFiles: [],
+                extensions: []
+            });
+            plugins.push(urlParser({
+                imports: urlPluginImports,
+                replacements,
+                context: this.context,
+                rootContext: this.rootContext,
+                filter: getFilter(options.url, this.resourcePath),
+                resolver: urlResolver,
+                urlHandler: (url)=>(0, _stringifyrequest.stringifyRequest)(this, url)
+            }));
+        }
+        const icssPluginImports = [];
+        const icssPluginApi = [];
+        if (shouldUseIcssPlugin(options)) {
+            const icssResolver = this.getResolve({
+                conditionNames: [
+                    'style'
+                ],
+                extensions: [],
+                mainFields: [
+                    'css',
+                    'style',
+                    'main',
+                    '...'
+                ],
+                mainFiles: [
+                    'index',
+                    '...'
+                ]
+            });
+            plugins.push(icssParser({
+                imports: icssPluginImports,
+                api: icssPluginApi,
+                replacements,
+                exports: exports1,
+                context: this.context,
+                rootContext: this.rootContext,
+                resolver: icssResolver,
+                urlHandler: (url)=>(0, _stringifyrequest.stringifyRequest)(this, getPreRequester(this)(options.importLoaders) + url)
+            }));
+        }
+        // Reuse CSS AST (PostCSS AST e.g 'postcss-loader') to avoid reparsing
+        if (meta) {
+            const { ast } = meta;
+            if (ast && ast.type === 'postcss') {
+                content = ast.root;
+                loaderSpan.setAttribute('astUsed', 'true');
+            }
+        }
+        const { resourcePath } = this;
+        let result;
+        try {
+            result = await postcss(plugins).process(content, {
+                from: resourcePath,
+                to: resourcePath,
+                map: options.sourceMap ? {
+                    prev: map ? normalizeSourceMap(map, resourcePath) : null,
+                    inline: false,
+                    annotation: false
+                } : false
+            });
+        } catch (error) {
+            if (error.file) {
+                this.addDependency(error.file);
+            }
+            throw error.name === 'CssSyntaxError' ? Object.defineProperty(new _CssSyntaxError.default(error), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            }) : error;
+        }
+        for (const warning of result.warnings()){
+            this.emitWarning(Object.defineProperty(new _Warning.default(warning), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            }));
+        }
+        const imports = [
+            ...icssPluginImports.sort(sort),
+            ...importPluginImports.sort(sort),
+            ...urlPluginImports.sort(sort)
+        ];
+        const api = [
+            ...importPluginApi.sort(sort),
+            ...icssPluginApi.sort(sort)
+        ];
+        if (options.modules.exportOnlyLocals !== true) {
+            imports.unshift({
+                importName: '___CSS_LOADER_API_IMPORT___',
+                url: (0, _stringifyrequest.stringifyRequest)(this, require.resolve('./runtime/api'))
+            });
+        }
+        const importCode = getImportCode(imports, options);
+        const moduleCode = getModuleCode(result, api, replacements, options, this);
+        const exportCode = getExportCode(exports1, replacements, options);
+        return `${importCode}${moduleCode}${exportCode}`;
+    }).then((code)=>{
+        callback(null, code);
+    }, (err)=>{
+        callback(err);
+    });
+}
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/css-loader/src/plugins/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    icssParser: null,
+    importParser: null,
+    urlParser: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    icssParser: function() {
+        return _postcssicssparser.default;
+    },
+    importParser: function() {
+        return _postcssimportparser.default;
+    },
+    urlParser: function() {
+        return _postcssurlparser.default;
+    }
+});
+const _postcssimportparser = /*#__PURE__*/ _interop_require_default(require("./postcss-import-parser"));
+const _postcssicssparser = /*#__PURE__*/ _interop_require_default(require("./postcss-icss-parser"));
+const _postcssurlparser = /*#__PURE__*/ _interop_require_default(require("./postcss-url-parser"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/css-loader/src/plugins/postcss-icss-parser.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _icssutils = require("next/dist/compiled/icss-utils");
+const _utils = require("../utils");
+const plugin = (options = {})=>{
+    return {
+        postcssPlugin: 'postcss-icss-parser',
+        async OnceExit (root) {
+            const importReplacements = Object.create(null);
+            const { icssImports, icssExports } = (0, _icssutils.extractICSS)(root);
+            const imports = new Map();
+            const tasks = [];
+            for(const url in icssImports){
+                const tokens = icssImports[url];
+                if (Object.keys(tokens).length === 0) {
+                    continue;
+                }
+                let normalizedUrl = url;
+                let prefix = '';
+                const queryParts = normalizedUrl.split('!');
+                if (queryParts.length > 1) {
+                    normalizedUrl = queryParts.pop();
+                    prefix = queryParts.join('!');
+                }
+                const request = (0, _utils.requestify)((0, _utils.normalizeUrl)(normalizedUrl, true), options.rootContext);
+                const doResolve = async ()=>{
+                    const { resolver, context } = options;
+                    const resolvedUrl = await (0, _utils.resolveRequests)(resolver, context, [
+                        ...new Set([
+                            normalizedUrl,
+                            request
+                        ])
+                    ]);
+                    if (!resolvedUrl) {
+                        return;
+                    }
+                    return {
+                        url: resolvedUrl,
+                        prefix,
+                        tokens
+                    };
+                };
+                tasks.push(doResolve());
+            }
+            const results = await Promise.all(tasks);
+            for(let index = 0; index <= results.length - 1; index++){
+                const item = results[index];
+                if (!item) {
+                    continue;
+                }
+                const newUrl = item.prefix ? `${item.prefix}!${item.url}` : item.url;
+                const importKey = newUrl;
+                let importName = imports.get(importKey);
+                if (!importName) {
+                    importName = `___CSS_LOADER_ICSS_IMPORT_${imports.size}___`;
+                    imports.set(importKey, importName);
+                    options.imports.push({
+                        type: 'icss_import',
+                        importName,
+                        url: options.urlHandler(newUrl),
+                        icss: true,
+                        index
+                    });
+                    options.api.push({
+                        importName,
+                        dedupe: true,
+                        index
+                    });
+                }
+                for (const [replacementIndex, token] of Object.keys(item.tokens).entries()){
+                    const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+                    const localName = item.tokens[token];
+                    importReplacements[token] = replacementName;
+                    options.replacements.push({
+                        replacementName,
+                        importName,
+                        localName
+                    });
+                }
+            }
+            if (Object.keys(importReplacements).length > 0) {
+                (0, _icssutils.replaceSymbols)(root, importReplacements);
+            }
+            for (const name of Object.keys(icssExports)){
+                const value = (0, _icssutils.replaceValueSymbols)(icssExports[name], importReplacements);
+                options.exports.push({
+                    name,
+                    value
+                });
+            }
+        }
+    };
+};
+plugin.postcss = true;
+const _default = plugin;
+
+//# sourceMappingURL=postcss-icss-parser.js.map