@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/webpack/loaders/lightningcss-loader/src/minify.js

@@ -0,0 +1,94 @@
+// @ts-ignore
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LightningCssMinifyPlugin", {
+    enumerable: true,
+    get: function() {
+        return LightningCssMinifyPlugin;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _webpacksources3 = require("next/dist/compiled/webpack-sources3");
+const _interface = require("./interface");
+const _utils = require("./utils");
+const _buffer = require("buffer");
+const _swc = require("../../../../../build/swc");
+const PLUGIN_NAME = 'lightning-css-minify';
+const CSS_FILE_REG = /\.css(?:\?.*)?$/i;
+class LightningCssMinifyPlugin {
+    constructor(opts = {}){
+        const { implementation, ...otherOpts } = opts;
+        if (implementation && typeof implementation.transformCss !== 'function') {
+            throw Object.defineProperty(new TypeError(`[LightningCssMinifyPlugin]: implementation.transformCss must be an 'lightningcss' transform function. Received ${typeof implementation.transformCss}`), "__NEXT_ERROR_CODE", {
+                value: "E561",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        this.transform = implementation == null ? void 0 : implementation.transformCss;
+        this.options = otherOpts;
+    }
+    apply(compiler) {
+        const meta = JSON.stringify({
+            name: '@next/lightningcss-loader',
+            version: '0.0.0',
+            options: this.options
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (_, hash)=>hash.update(meta));
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                additionalAssets: true
+            }, async ()=>await this.transformAssets(compilation));
+            compilation.hooks.statsPrinter.tap(PLUGIN_NAME, (statsPrinter)=>{
+                statsPrinter.hooks.print.for('asset.info.minimized')// @ts-ignore
+                .tap(PLUGIN_NAME, (minimized, { green, formatFlag })=>{
+                    // @ts-ignore
+                    return minimized ? green(formatFlag('minimized')) : undefined;
+                });
+            });
+        });
+    }
+    async transformAssets(compilation) {
+        const { options: { devtool } } = compilation.compiler;
+        if (!this.transform) {
+            this.transform = (0, _swc.getBindingsSync)().css.lightning.transform;
+        }
+        const sourcemap = this.options.sourceMap === undefined ? devtool && devtool.includes('source-map') : this.options.sourceMap;
+        const { include, exclude, test: testRegExp, targets: userTargets, ...transformOptions } = this.options;
+        const assets = compilation.getAssets().filter((asset)=>// Filter out already minimized
+            !asset.info.minimized && // Filter out by file type
+            (testRegExp || CSS_FILE_REG).test(asset.name) && _webpack.ModuleFilenameHelpers.matchObject({
+                include,
+                exclude
+            }, asset.name));
+        await Promise.all(assets.map(async (asset)=>{
+            const { source, map } = asset.source.sourceAndMap();
+            const sourceAsString = source.toString();
+            const code = typeof source === 'string' ? _buffer.Buffer.from(source) : source;
+            const targets = (0, _utils.getTargets)({
+                targets: userTargets,
+                key: _interface.ECacheKey.minify
+            });
+            const result = await this.transform({
+                filename: asset.name,
+                code,
+                minify: true,
+                sourceMap: sourcemap,
+                targets,
+                ...transformOptions
+            });
+            const codeString = result.code.toString();
+            compilation.updateAsset(asset.name, // @ts-ignore
+            sourcemap ? new _webpacksources3.SourceMapSource(codeString, asset.name, JSON.parse(result.map.toString()), sourceAsString, map, true) : new _webpacksources3.RawSource(codeString), {
+                ...asset.info,
+                minimized: true
+            });
+        }));
+    }
+}
+
+//# sourceMappingURL=minify.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/lightningcss-loader/src/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTargets", {
+    enumerable: true,
+    get: function() {
+        return getTargets;
+    }
+});
+let targetsCache = {};
+/**
+ * Convert a version number to a single 24-bit number
+ *
+ * https://github.com/lumeland/lume/blob/4cc75599006df423a14befc06d3ed8493c645b09/plugins/lightningcss.ts#L160
+ */ function version(major, minor = 0, patch = 0) {
+    return major << 16 | minor << 8 | patch;
+}
+function parseVersion(v) {
+    return v.split('.').reduce((acc, val)=>{
+        if (!acc) {
+            return null;
+        }
+        const parsed = parseInt(val, 10);
+        if (isNaN(parsed)) {
+            return null;
+        }
+        acc.push(parsed);
+        return acc;
+    }, []);
+}
+function browserslistToTargets(targets) {
+    return targets.reduce((acc, value)=>{
+        const [name, v] = value.split(' ');
+        const parsedVersion = parseVersion(v);
+        if (!parsedVersion) {
+            return acc;
+        }
+        const versionDigit = version(parsedVersion[0], parsedVersion[1], parsedVersion[2]);
+        if (name === 'and_qq' || name === 'and_uc' || name === 'baidu' || name === 'bb' || name === 'kaios' || name === 'op_mini') {
+            return acc;
+        }
+        if (acc[name] == null || versionDigit < acc[name]) {
+            acc[name] = versionDigit;
+        }
+        return acc;
+    }, {});
+}
+const getTargets = (opts)=>{
+    const cache = targetsCache[opts.key];
+    if (cache) {
+        return cache;
+    }
+    const result = browserslistToTargets(opts.targets ?? []);
+    return targetsCache[opts.key] = result;
+};
+
+//# sourceMappingURL=utils.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/metadata/discover.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createMetadataExportsCode: null,
+    createStaticMetadataFromRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createMetadataExportsCode: function() {
+        return createMetadataExportsCode;
+    },
+    createStaticMetadataFromRoute: function() {
+        return createStaticMetadataFromRoute;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _querystring = require("querystring");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+const _constants = require("../../../../lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const METADATA_TYPE = 'metadata';
+const NUMERIC_SUFFIX_ARRAY = Array(10).fill(0);
+// Produce all compositions with filename (icon, apple-icon, etc.) with extensions (png, jpg, etc.)
+async function enumMetadataFiles(dir, filename, extensions, { metadataResolver, // When set to true, possible filename without extension could: icon, icon0, ..., icon9
+numericSuffix }) {
+    const collectedFiles = [];
+    // Collect <filename>.<ext>, <filename>[].<ext>
+    const possibleFileNames = [
+        filename
+    ].concat(numericSuffix ? NUMERIC_SUFFIX_ARRAY.map((_, index)=>filename + index) : []);
+    for (const name of possibleFileNames){
+        const resolved = await metadataResolver(dir, name, extensions);
+        if (resolved) {
+            collectedFiles.push(resolved);
+        }
+    }
+    return collectedFiles;
+}
+async function createStaticMetadataFromRoute(resolvedDir, { segment, metadataResolver, isRootLayoutOrRootPage, pageExtensions, basePath }) {
+    let hasStaticMetadataFiles = false;
+    const staticImagesMetadata = {
+        icon: [],
+        apple: [],
+        twitter: [],
+        openGraph: [],
+        manifest: undefined
+    };
+    async function collectIconModuleIfExists(type) {
+        if (type === 'manifest') {
+            const staticManifestExtension = [
+                'webmanifest',
+                'json'
+            ];
+            const manifestFile = await enumMetadataFiles(resolvedDir, 'manifest', staticManifestExtension.concat(pageExtensions), {
+                metadataResolver,
+                numericSuffix: false
+            });
+            if (manifestFile.length > 0) {
+                hasStaticMetadataFiles = true;
+                const { name, ext } = _path.default.parse(manifestFile[0]);
+                const extension = staticManifestExtension.includes(ext.slice(1)) ? ext.slice(1) : 'webmanifest';
+                staticImagesMetadata.manifest = JSON.stringify(`${basePath}/${name}.${extension}`);
+            }
+            return;
+        }
+        const isFavicon = type === 'favicon';
+        const resolvedMetadataFiles = await enumMetadataFiles(resolvedDir, _ismetadataroute.STATIC_METADATA_IMAGES[type].filename, [
+            ..._ismetadataroute.STATIC_METADATA_IMAGES[type].extensions,
+            ...isFavicon ? [] : pageExtensions
+        ], {
+            metadataResolver,
+            numericSuffix: !isFavicon
+        });
+        resolvedMetadataFiles.sort((a, b)=>a.localeCompare(b)).forEach((filepath)=>{
+            const imageModuleImportSource = `next-metadata-image-loader?${(0, _querystring.stringify)({
+                type,
+                segment,
+                basePath,
+                pageExtensions
+            })}!${filepath}?${_constants.WEBPACK_RESOURCE_QUERIES.metadata}`;
+            const imageModule = `(async (props) => (await import(/* webpackMode: "eager" */ ${JSON.stringify(imageModuleImportSource)})).default(props))`;
+            hasStaticMetadataFiles = true;
+            if (type === 'favicon') {
+                staticImagesMetadata.icon.unshift(imageModule);
+            } else {
+                staticImagesMetadata[type].push(imageModule);
+            }
+        });
+    }
+    // Intentionally make these serial to reuse directory access cache.
+    await collectIconModuleIfExists('icon');
+    await collectIconModuleIfExists('apple');
+    await collectIconModuleIfExists('openGraph');
+    await collectIconModuleIfExists('twitter');
+    if (isRootLayoutOrRootPage) {
+        await collectIconModuleIfExists('favicon');
+        await collectIconModuleIfExists('manifest');
+    }
+    return hasStaticMetadataFiles ? staticImagesMetadata : null;
+}
+function createMetadataExportsCode(metadata) {
+    return metadata ? `${METADATA_TYPE}: {
+    icon: [${metadata.icon.join(',')}],
+    apple: [${metadata.apple.join(',')}],
+    openGraph: [${metadata.openGraph.join(',')}],
+    twitter: [${metadata.twitter.join(',')}],
+    manifest: ${metadata.manifest ? metadata.manifest : 'undefined'}
+  }` : '';
+}
+
+//# sourceMappingURL=discover.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/metadata/resolve-route-data.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveManifest: null,
+    resolveRobots: null,
+    resolveRouteData: null,
+    resolveSitemap: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveManifest: function() {
+        return resolveManifest;
+    },
+    resolveRobots: function() {
+        return resolveRobots;
+    },
+    resolveRouteData: function() {
+        return resolveRouteData;
+    },
+    resolveSitemap: function() {
+        return resolveSitemap;
+    }
+});
+const _utils = require("../../../../lib/metadata/generate/utils");
+function resolveRobots(data) {
+    let content = '';
+    const rules = Array.isArray(data.rules) ? data.rules : [
+        data.rules
+    ];
+    for (const rule of rules){
+        const userAgent = (0, _utils.resolveArray)(rule.userAgent || [
+            '*'
+        ]);
+        for (const agent of userAgent){
+            content += `User-Agent: ${agent}\n`;
+        }
+        if (rule.allow) {
+            const allow = (0, _utils.resolveArray)(rule.allow);
+            for (const item of allow){
+                content += `Allow: ${item}\n`;
+            }
+        }
+        if (rule.disallow) {
+            const disallow = (0, _utils.resolveArray)(rule.disallow);
+            for (const item of disallow){
+                content += `Disallow: ${item}\n`;
+            }
+        }
+        if (rule.crawlDelay) {
+            content += `Crawl-delay: ${rule.crawlDelay}\n`;
+        }
+        content += '\n';
+    }
+    if (data.host) {
+        content += `Host: ${data.host}\n`;
+    }
+    if (data.sitemap) {
+        const sitemap = (0, _utils.resolveArray)(data.sitemap);
+        // TODO-METADATA: support injecting sitemap url into robots.txt
+        sitemap.forEach((item)=>{
+            content += `Sitemap: ${item}\n`;
+        });
+    }
+    return content;
+}
+function resolveSitemap(data) {
+    const hasAlternates = data.some((item)=>Object.keys(item.alternates ?? {}).length > 0);
+    const hasImages = data.some((item)=>{
+        var _item_images;
+        return Boolean((_item_images = item.images) == null ? void 0 : _item_images.length);
+    });
+    const hasVideos = data.some((item)=>{
+        var _item_videos;
+        return Boolean((_item_videos = item.videos) == null ? void 0 : _item_videos.length);
+    });
+    let content = '';
+    content += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
+    if (hasImages) {
+        content += ' xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"';
+    }
+    if (hasVideos) {
+        content += ' xmlns:video="http://www.google.com/schemas/sitemap-video/1.1"';
+    }
+    if (hasAlternates) {
+        content += ' xmlns:xhtml="http://www.w3.org/1999/xhtml">\n';
+    } else {
+        content += '>\n';
+    }
+    for (const item of data){
+        var _item_alternates, _item_images, _item_videos;
+        content += '<url>\n';
+        content += `<loc>${item.url}</loc>\n`;
+        const languages = (_item_alternates = item.alternates) == null ? void 0 : _item_alternates.languages;
+        if (languages && Object.keys(languages).length) {
+            // Since sitemap is separated from the page rendering, there's not metadataBase accessible yet.
+            // we give the default setting that won't effect the languages resolving.
+            for(const language in languages){
+                content += `<xhtml:link rel="alternate" hreflang="${language}" href="${languages[language]}" />\n`;
+            }
+        }
+        if ((_item_images = item.images) == null ? void 0 : _item_images.length) {
+            for (const image of item.images){
+                content += `<image:image>\n<image:loc>${image}</image:loc>\n</image:image>\n`;
+            }
+        }
+        if ((_item_videos = item.videos) == null ? void 0 : _item_videos.length) {
+            for (const video of item.videos){
+                let videoFields = [
+                    `<video:video>`,
+                    `<video:title>${video.title}</video:title>`,
+                    `<video:thumbnail_loc>${video.thumbnail_loc}</video:thumbnail_loc>`,
+                    `<video:description>${video.description}</video:description>`,
+                    video.content_loc && `<video:content_loc>${video.content_loc}</video:content_loc>`,
+                    video.player_loc && `<video:player_loc>${video.player_loc}</video:player_loc>`,
+                    video.duration && `<video:duration>${video.duration}</video:duration>`,
+                    video.view_count && `<video:view_count>${video.view_count}</video:view_count>`,
+                    video.tag && `<video:tag>${video.tag}</video:tag>`,
+                    video.rating && `<video:rating>${video.rating}</video:rating>`,
+                    video.expiration_date && `<video:expiration_date>${video.expiration_date}</video:expiration_date>`,
+                    video.publication_date && `<video:publication_date>${video.publication_date}</video:publication_date>`,
+                    video.family_friendly && `<video:family_friendly>${video.family_friendly}</video:family_friendly>`,
+                    video.requires_subscription && `<video:requires_subscription>${video.requires_subscription}</video:requires_subscription>`,
+                    video.live && `<video:live>${video.live}</video:live>`,
+                    video.restriction && `<video:restriction relationship="${video.restriction.relationship}">${video.restriction.content}</video:restriction>`,
+                    video.platform && `<video:platform relationship="${video.platform.relationship}">${video.platform.content}</video:platform>`,
+                    video.uploader && `<video:uploader${video.uploader.info && ` info="${video.uploader.info}"`}>${video.uploader.content}</video:uploader>`,
+                    `</video:video>\n`
+                ].filter(Boolean);
+                content += videoFields.join('\n');
+            }
+        }
+        if (item.lastModified) {
+            const serializedDate = item.lastModified instanceof Date ? item.lastModified.toISOString() : item.lastModified;
+            content += `<lastmod>${serializedDate}</lastmod>\n`;
+        }
+        if (item.changeFrequency) {
+            content += `<changefreq>${item.changeFrequency}</changefreq>\n`;
+        }
+        if (typeof item.priority === 'number') {
+            content += `<priority>${item.priority}</priority>\n`;
+        }
+        content += '</url>\n';
+    }
+    content += '</urlset>\n';
+    return content;
+}
+function resolveManifest(data) {
+    return JSON.stringify(data);
+}
+function resolveRouteData(data, fileType) {
+    if (fileType === 'robots') {
+        return resolveRobots(data);
+    }
+    if (fileType === 'sitemap') {
+        return resolveSitemap(data);
+    }
+    if (fileType === 'manifest') {
+        return resolveManifest(data);
+    }
+    return '';
+}
+
+//# sourceMappingURL=resolve-route-data.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/metadata/types.js

@@ -0,0 +1,7 @@
+// TODO-APP: check if this can be narrowed.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/modularize-import-loader.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * This loader is to create special re-exports from a specific file.
+ * For example, the following loader:
+ *
+ * modularize-import-loader?name=Arrow&from=Arrow&as=default&join=./icons/Arrow!lucide-react
+ *
+ * will be used to create a re-export of:
+ *
+ * export { Arrow as default } from "join(resolve_path('lucide-react'), '/icons/Arrow')"
+ *
+ * This works even if there's no export field in the package.json of the package.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return transformSource;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function transformSource() {
+    const { name, from, as, join } = this.getOptions();
+    const { resourcePath } = this;
+    const fullPath = join ? _path.default.join(_path.default.dirname(resourcePath), join) : resourcePath;
+    return `
+export {
+  ${from === 'default' ? 'default' : name} as ${as === 'default' ? 'default' : name}
+} from ${JSON.stringify(fullPath)}
+`;
+}
+
+//# sourceMappingURL=modularize-import-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-app-loader/create-app-route-code.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createAppRouteCode", {
+    enumerable: true,
+    get: function() {
+        return createAppRouteCode;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _querystring = require("querystring");
+const _constants = require("../../../../lib/constants");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+const _appbundlepathnormalizer = require("../../../../server/normalizers/built/app/app-bundle-path-normalizer");
+const _apppathnamenormalizer = require("../../../../server/normalizers/built/app/app-pathname-normalizer");
+const _loadentrypoint = require("../../../load-entrypoint");
+const _nextmetadatarouteloader = require("../next-metadata-route-loader");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function createAppRouteCode({ appDir, name, page, pagePath, resolveAppRoute, pageExtensions, nextConfigOutput }) {
+    // routePath is the path to the route handler file,
+    // but could be aliased e.g. private-next-app-dir/favicon.ico
+    const routePath = pagePath.replace(/[\\/]/, '/');
+    // This, when used with the resolver will give us the pathname to the built
+    // route handler file.
+    let resolvedPagePath = await resolveAppRoute(routePath);
+    if (!resolvedPagePath) {
+        throw Object.defineProperty(new Error(`Invariant: could not resolve page path for ${name} at ${routePath}`), "__NEXT_ERROR_CODE", {
+            value: "E281",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // If this is a metadata route file, then we need to use the metadata-loader
+    // for the route to ensure that the route is generated.
+    const fileBaseName = _path.default.parse(resolvedPagePath).name;
+    const appDirRelativePath = resolvedPagePath.slice(appDir.length);
+    const isMetadataEntryFile = (0, _ismetadataroute.isMetadataRouteFile)(appDirRelativePath, _ismetadataroute.DEFAULT_METADATA_ROUTE_EXTENSIONS, true);
+    if (isMetadataEntryFile) {
+        const { ext } = (0, _nextmetadatarouteloader.getFilenameAndExtension)(resolvedPagePath);
+        const isDynamicRouteExtension = pageExtensions.includes(ext);
+        resolvedPagePath = `next-metadata-route-loader?${(0, _querystring.stringify)({
+            filePath: resolvedPagePath,
+            isDynamicRouteExtension: isDynamicRouteExtension ? '1' : '0'
+        })}!?${_constants.WEBPACK_RESOURCE_QUERIES.metadataRoute}`;
+    }
+    const pathname = new _apppathnamenormalizer.AppPathnameNormalizer().normalize(page);
+    const bundlePath = new _appbundlepathnormalizer.AppBundlePathNormalizer().normalize(page);
+    return await (0, _loadentrypoint.loadEntrypoint)('app-route', {
+        VAR_USERLAND: resolvedPagePath,
+        VAR_DEFINITION_PAGE: page,
+        VAR_DEFINITION_PATHNAME: pathname,
+        VAR_DEFINITION_FILENAME: fileBaseName,
+        VAR_DEFINITION_BUNDLE_PATH: bundlePath,
+        VAR_RESOLVED_PAGE_PATH: resolvedPagePath
+    }, {
+        nextConfigOutput: JSON.stringify(nextConfigOutput)
+    });
+}
+
+//# sourceMappingURL=create-app-route-code.js.map